string getHappyLetters(string letters) {
IntVec chars(26);
for (char c : letters) {
chars[c - 'a'] += 1;
}
string ans;
for (int i = 0; i < 26; ++i) {
IntVec cnt = chars;
int p = cnt[i];
cnt[i] = 0;
while (true) {
sort(cnt.begin(), cnt.end());
if (cnt[24] > 0 && cnt[25] > 0) {
cnt[24]--, cnt[25]--;
} else {
break;
}
}
int q = accumulate(cnt.begin(), cnt.end(), 0);
if (p > q) {
ans += ('a' + i);
}
}
return ans;
}
void test_empty()
{
IntVec v;
CYBOZU_TEST_EQUAL((int)v.size(), 0);
CYBOZU_TEST_ASSERT(v.empty());
for (typename IntVec::const_iterator i = v.begin(); i != v.end(); ++i) {
printf("%d\n", i->val());
}
v.push_back(3, 1);
CYBOZU_TEST_EQUAL((int)v.size(), 1);
CYBOZU_TEST_ASSERT(!v.empty());
for (typename IntVec::const_iterator i = v.begin(); i != v.end(); ++i) {
CYBOZU_TEST_EQUAL(i->pos(), (size_t)3);
CYBOZU_TEST_EQUAL(i->val(), 1);
}
v.push_back(4, 2);
CYBOZU_TEST_EQUAL((int)v.size(), 2);
int j = 0;
for (typename IntVec::const_iterator i = v.begin(); i != v.end(); ++i) {
CYBOZU_TEST_EQUAL(i->pos(), size_t(j + 3));
CYBOZU_TEST_EQUAL(i->val(), j + 1);
j++;
}
v.clear();
CYBOZU_TEST_EQUAL((int)v.size(), 0);
CYBOZU_TEST_ASSERT(v.empty());
IntVec v1, v2;
for (int i = 0; i < 3; i++) {
v1.push_back(i, i);
v2.push_back(i, i);
}
CYBOZU_TEST_ASSERT(v1 == v2);
v2.push_back(10, 10);
CYBOZU_TEST_ASSERT(v1 != v2);
}
//
// Initialise with domain data
//
bool DataVar::initFromMeshData(const_DomainChunk_ptr dom, const IntVec& data,
int fsCode, Centering c, NodeData_ptr nodes, const IntVec& id)
{
cleanup();
domain = dom;
rank = 0;
ptsPerSample = 1;
centering = c;
sampleID = id;
meshName = nodes->getName();
siloMeshName = nodes->getFullSiloName();
numSamples = data.size();
if (numSamples > 0) {
float* c = new float[numSamples];
dataArray.push_back(c);
IntVec::const_iterator it;
for (it=data.begin(); it != data.end(); it++)
*c++ = static_cast<float>(*it);
}
initialized = true;
return initialized;
}
long long minCost(vector <string> road, vector <int> altitude) {
int sz = (int)road.size();
// generate alt table
IntVec alt = altitude;
sort(alt.begin(), alt.end());
unique(alt.begin(), alt.end());
LL mincost[64][64];
memset(mincost, 0x3f, sizeof(mincost));
LIIQueue q;
int i, j;
for (i = 0; i < (int)alt.size(); ++i) {
LL cost = abs(alt[i] - altitude[0]);
mincost[0][i] = cost;
q.push(LII(-cost, II(0, alt[i])));
}
// dijkstra
while (q.size() > 0) {
LII current = q.top();
q.pop();
int from = current.second.first;
if (from == (sz-1)) {
return -current.first;
}
for (i = 0; i < (int)alt.size(); ++i) {
if (alt[i] > current.second.second) {
break;
}
for (j = 0; j < sz; ++j) {
if (road[from][j] == 'Y') {
LL cost = -current.first + abs(alt[i] - altitude[j]);
if (cost < mincost[j][i]) {
mincost[j][i] = cost;
q.push(LII(-cost, II(j, alt[i])));
}
}
}
}
}
return -1;
}
int main ()
{
typedef vector <int> IntVec;
IntVec v (10);
for (int i = 0; i < v.size (); i++)
v[i] = (i + 1) * (i + 1);
IntVec::iterator iter;
iter = find_if (v.begin (), v.end (), div_3);
if (iter != v.end ())
cout
<< "Value "
<< *iter
<< " at offset "
<< (iter - v.begin ())
<< " is divisible by 3"
<< endl;
return 0;
}
void SpeckleyElements::reorderArray(IntVec& v, const IntVec& idx,
int elementsPerIndex)
{
IntVec newArray(v.size());
IntVec::iterator arrIt = newArray.begin();
IntVec::const_iterator idxIt;
if (elementsPerIndex == 1) {
for (idxIt=idx.begin(); idxIt!=idx.end(); idxIt++) {
*arrIt++ = v[*idxIt];
}
} else {
for (idxIt=idx.begin(); idxIt!=idx.end(); idxIt++) {
int i = *idxIt;
copy(&v[i*elementsPerIndex], &v[(i+1)*elementsPerIndex], arrIt);
arrIt += elementsPerIndex;
}
}
v.swap(newArray);
}
int minMoves(vector <int> w) {
IntVec v = w;
sort(v.begin(), v.end());
int ans = 0;
if (v != w) {
if (v[0] == w[0] || v.back() == w.back()) {
ans = 1;
} else {
ans = 2 + (v[0] == w.back() && v.back() == w[0]);
}
}
return ans;
}
mpz_class PrimeSwing::Swing( int _number, PrimeSieve& _sieve )
{
// Small precalculated values
if (_number < 33)
return smallOddSwing[_number];
// Fetch multiplies
IntVec multiplies = GetMultiplies(_number, _sieve);
// Return multiplies of primorials
return _sieve.Primorial(_number / 2, _number) *
UtilityFunctions::SequenceProduct( multiplies.begin(), multiplies.end() );
}
void test(size_t n, bool doPut, F pred)
{
IntVec iv;
PtrVec pv;
init(iv, pv, n);
if (doPut) put(pv);
Xbyak::util::Clock clk;
clk.begin();
std::sort(pv.begin(), pv.end(), pred);
clk.end();
int sum = std::accumulate(iv.begin(), iv.end(), 0);
printf("clk=%.2fclk, sum=%d\n", clk.getClock() / double(n), sum);
if (doPut) put(pv);
}
long long minimalFatigue(vector <int> magicalGirlStrength, vector <int> enemyStrength, vector<long long> enemyCount) {
g = magicalGirlStrength;
sort(g.begin(), g.end());
e.clear();
for (int i = 0; i < (int)enemyStrength.size(); ++i) {
e[enemyStrength[i]] += enemyCount[i];
}
LL low = -1, high = 1LL<<62;
while (low < high) {
LL mid = (low + high) / 2;
if (can(mid)) {
high = mid;
} else {
low = mid + 1;
}
}
return low < (1LL<<62) ? low : -1;
}
SpeckleyNodes::SpeckleyNodes(SpeckleyNodes_ptr fullNodes, IntVec& requiredNodes,
const string& meshName) :
name(meshName)
{
numDims = fullNodes->numDims;
nodeDist = fullNodes->nodeDist;
globalNumNodes = fullNodes->globalNumNodes;
// first: find the unique set of required nodes and their IDs while
// updating the contents of requiredNodes at the same time
// requiredNodes contains node indices (not IDs!)
IntVec::iterator it;
IndexMap indexMap; // maps old index to new index
size_t newIndex = 0;
for (it = requiredNodes.begin(); it != requiredNodes.end(); it++) {
IndexMap::iterator res = indexMap.find(*it);
if (res == indexMap.end()) {
nodeID.push_back(fullNodes->nodeID[*it]);
nodeTag.push_back(fullNodes->nodeTag[*it]);
indexMap[*it] = newIndex;
*it = newIndex++;
} else {
*it = res->second;
}
}
// second: now that we know how many nodes we need use the map to fill
// the coordinates
numNodes = newIndex;
for (int dim=0; dim<numDims; dim++) {
const float* origC = fullNodes->coords[dim];
float* c = new float[numNodes];
coords.push_back(c);
IndexMap::const_iterator mIt;
for (mIt = indexMap.begin(); mIt != indexMap.end(); mIt++) {
c[mIt->second] = origC[mIt->first];
}
}
}
bool contains(IntVec& vec, uint32 value)
{
return std::find(vec.begin(), vec.end(), value) != vec.end();
}
void test_intersect()
{
DoubleVec dv;
IntVec iv;
const struct {
unsigned int pos;
double val;
} dTbl[] = {
{ 5, 3.14 }, { 10, 2 }, { 12, 1.4 }, { 100, 2.3 }, { 1000, 4 },
};
const struct {
unsigned int pos;
int val;
} iTbl[] = {
{ 2, 4 }, { 5, 2 }, { 100, 4 }, { 101, 3}, { 999, 4 }, { 1000, 1 }, { 2000, 3 },
};
const struct {
unsigned int pos;
double d;
int i;
} interTbl[] = {
{ 5, 3.14, 2 }, { 100, 2.3, 4 }, { 1000, 4, 1 }
};
for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(dTbl); i++) {
dv.push_back(dTbl[i].pos, dTbl[i].val);
}
for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(iTbl); i++) {
iv.push_back(iTbl[i].pos, iTbl[i].val);
}
int j = 0;
for (typename DoubleVec::const_iterator i = dv.begin(), ie = dv.end(); i != ie; ++i) {
CYBOZU_TEST_EQUAL(i->pos(), dTbl[j].pos);
CYBOZU_TEST_EQUAL(i->val(), dTbl[j].val);
j++;
}
j = 0;
for (typename IntVec::const_iterator i = iv.begin(), ie = iv.end(); i != ie; ++i) {
CYBOZU_TEST_EQUAL(i->pos(), iTbl[j].pos);
CYBOZU_TEST_EQUAL(i->val(), iTbl[j].val);
j++;
}
int sum = 0;
for (typename IntVec::const_iterator i = iv.begin(), ie = iv.end(); i != ie; ++i) {
sum += i->val() * i->val();
}
CYBOZU_TEST_EQUAL(sum, 71);
typedef cybozu::nlp::Intersection<DoubleVec, IntVec> InterSection;
InterSection inter(dv, iv);
j = 0;
for (typename InterSection::const_iterator i = inter.begin(), ie = inter.end(); i != ie; ++i) {
CYBOZU_TEST_EQUAL(i->pos(), interTbl[j].pos);
CYBOZU_TEST_EQUAL(i->val1(), interTbl[j].d);
CYBOZU_TEST_EQUAL(i->val2(), interTbl[j].i);
j++;
}
}
// makes a new paving from a vtk file
// expects 3d, structured point data in file
SPMinimalnode* SPMinimalnode::vtkPaving(const std::string filename)
{
SPMinimalnode* newTree = NULL;
try {
size_t expectedDims = 3;
IntVec Xs;
IntVec Ys;
IntVec Zs;
// get the spacing and fill in the coordinates vectors using
// getCoordinatesFromVtk.
// getCoordinatesFromVtk expects 10 header lines with spacings on 4th
IntVec spacing = getCoordinatesFromVtk(Xs, Ys, Zs, filename);
bool success = ((spacing.size() == expectedDims) && (spacing[0] > 0)
&& (spacing[0] == spacing[1])
&& (spacing[0] == spacing[2]));
if (success) {
ivector rootbox(expectedDims);
double maxXYZ = spacing[0] * 1.0;
ImageList boxes;
double totalListVol = 0;
IntVecItr xIt = Xs.begin();
IntVecItr yIt = Ys.begin();
IntVecItr zIt = Zs.begin();
for (xIt = Xs.begin(); xIt < Xs.end(); xIt++, yIt++, zIt++) {
ivector box(expectedDims);
// make the box so that its boundaries are on the inner edges
// of the voxel
interval xdim(Sup(_interval(*xIt/maxXYZ)),
Inf(_interval(*xIt + 1.0)/maxXYZ));
interval ydim(Sup(_interval(*yIt/maxXYZ)),
Inf(_interval(*yIt + 1.0)/maxXYZ));
interval zdim(Sup(_interval(*zIt/maxXYZ)),
Inf(_interval(*zIt + 1.0)/maxXYZ));
box[1] = xdim;
box[2] = ydim;
box[3] = zdim;
boxes.push_back(box);
totalListVol += Volume(box);
}
rootbox[1] = interval(0.0, 1.0);
rootbox[2] = interval(0.0, 1.0);
rootbox[3] = interval(0.0, 1.0);
newTree = makeTreeFromVoxels(rootbox, boxes,
maxXYZ, expectedDims);
}
if (newTree != NULL) {
newTree->setNodeName("X");
newTree->recursiveRename();
}
return newTree;
}
catch(std::exception const& e) {
delete newTree;
newTree = NULL;
throw;
}
}
