void set(int key, int value) { auto iter = mm.find(key); if(iter != mm.end()){ iter->second->second = value; ll.splice(ll.begin(), ll, iter->second); // move the record } else { if(mm.size() == cap){ auto back = ll.back(); // NOTICE: back() returns a reference mm.erase(back.first); ll.pop_back(); } ll.emplace_front(key, value); mm[key] = ll.begin(); } }
static void get_chrom(const bool VERBOSE, const GenomicRegion &r, const unordered_map<string, string>& chrom_files, GenomicRegion &chrom_region, string &chrom) { const unordered_map<string, string>::const_iterator fn(chrom_files.find(r.get_chrom())); if (fn == chrom_files.end()) throw SMITHLABException("could not find chrom: " + r.get_chrom()); chrom.clear(); read_fasta_file(fn->second, r.get_chrom(), chrom); if (chrom.empty()) throw SMITHLABException("could not find chrom: " + r.get_chrom()); else { chrom_region.set_chrom(r.get_chrom()); } }
void createIndices(vector<int>& nums, int which) { for (int i = 0; i < (int)nums.size(); i++) { unordered_map<int, IndexNode*>::iterator it = mIndices.find(nums[i]); if (it != mIndices.end()) { it->second->append(which, i); } else { mIndices.insert(pair<int, IndexNode *>(nums[i], new IndexNode(nums[i], which, i))); } } }
list<int> search (string &str) { if (str.length() == 0) return indexes; else { char first = str[0]; if (children.find (first) != children.end()) { string remainder = str.substr (1); return (children[first].search(remainder)); } } return list<int>(); }
void put(int key, int value) { auto it = data.find(key); if (it != data.end()) { access_order.splice(access_order.begin(), access_order, it->second.second); data[key] = {value, access_order.begin()}; } else { if (current_capacity == _capacity) { data.erase(*access_order.rbegin()); access_order.pop_back(); } else { current_capacity++; } access_order.push_front(key); data[key] = {value, access_order.begin()}; } }
int helper(long n, unordered_map<long, int> &numStepsMap) { if (n <= 1) return 0; if (numStepsMap.find(n) != numStepsMap.end()) return numStepsMap[n]; int res; if (n % 2 == 0) { res = 1 + helper(n / 2, numStepsMap); } else { res = 1 + min( helper(n - 1, numStepsMap), helper(n + 1, numStepsMap) ); } numStepsMap[n] = res; return res; }
int findRoot(unordered_map<int, int> &dj, int x) { if (dj.find(x) == dj.end()) { return x; } int r = x; while (r != dj[r]) { r = dj[r]; } int k = x; while (x != r) { x = dj[x]; dj[k] = r; k = x; } return r; }
int32_t operator()(df::coord p1, df::coord p2) { if ( p1 == p2 ) return 0; auto i1 = pointCost->find(p1); auto i2 = pointCost->find(p2); if ( i1 == pointCost->end() && i2 == pointCost->end() ) return p1 < p2; if ( i1 == pointCost->end() ) return true; if ( i2 == pointCost->end() ) return false; cost_t c1 = (*i1).second; cost_t c2 = (*i2).second; if ( c1 != c2 ) return c1 < c2; return p1 < p2; }
void backTrace(string s) { if (bt.find(s) == bt.end()) { // End of back trac vector<string> r(res); r.push_back(s); reverse(r.begin(), r.end()); ans.push_back(r); return; } unordered_set<string> &v = bt[s]; res.push_back(s); for (auto it = v.begin(); it != v.end(); ++it) { backTrace(*it); } res.pop_back(); }
vector<int> findSubstring(string S, vector<string> &L) { vector<int> result; if(L.size() == 0) return result; size_t wordLen = L[0].size(); size_t wordNum = L.size(); size_t wordsLen = wordLen * wordNum; if(S.size() < wordsLen) return result; //cout << "wordLen \t" << wordLen << endl; //cout << "wordNum \t" << wordNum<< endl; //cout << "wordsLen\t" << wordsLen << endl; initMap(L); //printMap(); for(size_t i = 0; i <= S.size() - wordsLen; i++) { size_t j = i; for( /**/; j < (i + wordsLen); j += wordLen) { //cout << "j\t" << j << endl; //printMap(); string tmp = S.substr(j, wordLen); if(m_map.find(tmp) != m_map.end() && m_map[tmp] > 0) { m_map[tmp]--; } else { break; } } //cout << "==j\t" << j << endl; if(j >= (i+wordsLen)) { result.push_back(i); } initMap(L); } return result; }
df::building *Buildings::findAtTile(df::coord pos) { auto occ = Maps::getTileOccupancy(pos); if (!occ || !occ->bits.building) return NULL; // Try cache lookup in case it works: auto cached = locationToBuilding.find(pos); if (cached != locationToBuilding.end()) { auto building = df::building::find(cached->second); if (building && building->z == pos.z && building->isSettingOccupancy() && containsTile(building, pos, false)) { return building; } } // The authentic method, i.e. how the game generally does this: auto &vec = df::building::get_vector(); for (size_t i = 0; i < vec.size(); i++) { auto bld = vec[i]; if (pos.z != bld->z || pos.x < bld->x1 || pos.x > bld->x2 || pos.y < bld->y1 || pos.y > bld->y2) continue; if (!bld->isSettingOccupancy()) continue; if (bld->room.extents && bld->isExtentShaped()) { auto etile = getExtentTile(bld->room, pos); if (!etile || !*etile) continue; } return bld; } return NULL; }
static void get_chrom(const MappedRead &mr, const vector<string> &all_chroms, const unordered_map<string, size_t> &chrom_lookup, GenomicRegion &chrom_region, string &chrom) { const unordered_map<string, size_t>::const_iterator the_chrom(chrom_lookup.find(mr.r.get_chrom())); if (the_chrom == chrom_lookup.end()) throw runtime_error("could not find chrom: " + mr.r.get_chrom()); chrom = all_chroms[the_chrom->second]; if (chrom.empty()) throw runtime_error("could not find chrom: " + mr.r.get_chrom()); chrom_region.set_chrom(mr.r.get_chrom()); }
// Reduce an event name to a short string. string LocalState::short_event_name (string longname) { string shortname; auto siter = short_evname.find(longname); if (siter == short_evname.end()) { // Unknown name: Make up something for now, but we really ought to fix the // code to match the run-time library. static size_t id = 1; char sname[25]; sprintf(sname, "E%lu", id++); shortname = string(sname); short_evname[longname] = shortname; } else shortname = siter->second; return shortname; }
void set(int key, int value) { if (dict.find(key) != dict.end()) { data.splice(data.begin(), data, dict[key]); dict[key]->val = value; } else { if (data.size() == capacity) { dict.erase(data.back().key); data.pop_back(); } data.push_front(Node(key, value)); } dict[key] = data.begin(); }
bool extract(const string &str, vector<pair<string, double> > &keywords, size_t topN) const { vector<string> words; if (!_segment.cut(str, words)) { LogError("segment cut(%s) failed.", str.c_str()); return false; } map<string, double> wordmap; for (vector<string>::iterator iter = words.begin(); iter != words.end(); iter++) { if (_isSingleWord(*iter)) { continue; } wordmap[*iter] += 1.0; } for (map<string, double>::iterator itr = wordmap.begin(); itr != wordmap.end(); ) { if (_stopWords.end() != _stopWords.find(itr->first)) { wordmap.erase(itr++); continue; } unordered_map<string, double>::const_iterator cit = _idfMap.find(itr->first); if (cit != _idfMap.end()) { itr->second *= cit->second; } else { itr->second *= _idfAverage; } itr ++; } keywords.clear(); std::copy(wordmap.begin(), wordmap.end(), std::inserter(keywords, keywords.begin())); topN = min(topN, keywords.size()); partial_sort(keywords.begin(), keywords.begin() + topN, keywords.end(), _cmp); keywords.resize(topN); return true; }
int romanToInt(string s) { int res = 0; if (a2i.size() == 0) build_tlb(); while (!s.empty()) { int len = s.length(); for (int i=min(4, len); i>0; i--) { unordered_map<string, int>::iterator iter = a2i.find(s.substr(len-i)); if (iter == a2i.end()) continue; res += iter->second; s.resize(len - i); break; } } return res; }
vector<string> findRepeatedDnaSequences(string s) { std::hash<std::string> strHash; if (s.length() < 10) return vector<string>(); for (int ind=0; ind <= s.length() - 10; ind++) { string cand = s.substr(ind, 10); auto it = seqCount.find(strHash(cand)); if (it == seqCount.end()) { seqCount[strHash(cand)] = 1; } else { seqCount[strHash(cand)] += 1; if (seqCount[strHash(cand)] == 2) { strMap.push_back(cand); } } } return strMap; }
i64 get_mem_value(int xc, int yc, int aindex, int peri) { xc += peri; yc += peri; i64 result = xc; result <<= 8; result += yc; result <<=8; result += aindex; result <<= 8; result += peri; auto iter =pmap.find(result); if(iter != pmap.end()) return iter->second; else return -1; }
int RouteTableImpl::update_service_map(const ServiceItem& item, unordered_map<INSTANCE_ID_TYPE, ServiceItem>& new_map) { unordered_map<INSTANCE_ID_TYPE, ServiceItem>::iterator it; it = new_map.find(item.instance_id); if (it != new_map.end()) { LOG_FATAL("Duplicated service item, instance_name:" << item.instance_name << ", instance_id:" << item.instance_id); return -1; } new_map[item.instance_id] = item; return 0; }
//1 if stan 0 if ollie bool winner(unsigned long n, unsigned long p, bool current) { for(int i = 9; i >= 2; i--) { //if current play has multiplication greater than n, then he wins if(p * i >= n) return current; //if not, search map see if can wins or not based on current state if(win.find(p * i) != win.end()) { if(win[p * i]) return current; continue; } win[p * i] = winner(n, p * i, (current + 1) % 2) == current; if(win[p * i]) return current; } return (current + 1) % 2; }
bool isMatched_(vector<string> s, unordered_map<string,int> LL) { for(int i=0; i<s.size(); ++i) { if(LL.find(s[i])!=LL.end()) { if(--LL[s[i]]<0) { return false; } } else { return false; } } for(unordered_map<string,int>::iterator its=LL.begin(); its!=LL.end(); its++) { if(its->second!=0) return false; } return true; }
void ExchangeAnalyzer::populateTraderFills( unordered_map<uint64_t, string>& traders, unordered_map<uint32_t, uint64_t>& clients, unordered_map<string, size_t>& traderFills ) { for (auto msg : _ds->getOrderFills()) { shared_ptr<OrderFillMessage> fill_msg = static_pointer_cast<OrderFillMessage>(msg); // downcast for accessing message specific info uint64_t t = clients[fill_msg->order_id]; string trader_name = traders[t]; // lookup in clients and traders to get tradername. size_t total_qty = getFillQty(fill_msg); if (traderFills.find(trader_name) == traderFills.end()) traderFills[trader_name] = total_qty; else traderFills[trader_name] += total_qty; } }
long long int MaxValue(long long int n) { unordered_map<long long int,long long int>::const_iterator it = hashtable.find(n); if(it==hashtable.end()) { long long int t = MaxValue(n/2)+MaxValue(n/3)+MaxValue(n/4); long long int val = maximum(n,t); hashtable[n] = val; return val; } else { return it->second; } }
int get(int key) { if (to_index.find(key) == to_index.end()) { return -1; } int index = to_index[key]; ++std::get<2>(huan_cun[index]); int result = std::get<1>(huan_cun[index]); if (index>0 && std::get<2>(huan_cun[index - 1]) <= std::get<2>(huan_cun[index])) { swap(huan_cun[index], huan_cun[index - 1]); to_index[std::get<0>(huan_cun[index])] = index; to_index[std::get<0>(huan_cun[index - 1])] = index - 1; } return result; }
vector<T*> findAll(const Str& name) const { auto it = data.find(name); Binding* binding = (it != data.end()) ? it->second : nullptr; vector<T*> result; while (binding) { result.push_back(binding->value); binding = binding->shadow; } return result; }
void calNeighbor(vector<unordered_set<int> > & neighbor, int node, const vector<string> & vs, const unordered_map<string, int> & m) { string str = vs[node]; for(size_t i=0; i < vs[node].length(); ++i) { char t = str[i]; for(char ch='a'; ch <= 'z'; ++ch) { if ( ch != t) { str[i] = ch; auto iter = m.find(str); if ( iter != m.end()) { neighbor[node].insert(iter->second); neighbor[iter->second].insert(node); } } } str[i] = t; } }
void set(int key, int value) { if(hash.find(key) != hash.end()){ iterator it = hash[key]; q.erase(it); q.push_front(make_pair(key,value)); hash[key] = q.begin(); } else{ if(q.size() == mCapacity){ pii last = q.back(); q.pop_back(); hash.erase(last.first); } q.push_front(make_pair(key,value)); hash[key] = q.begin(); } }
void set(int key, int value) { if (m_map.find(key) == m_map.end()) { CacheEntry newItem(key, value); if (m_LRU_cache.size() >= m_capacity) { m_map.erase(m_LRU_cache.back().key); m_LRU_cache.pop_back(); } m_LRU_cache.push_front(newItem); m_map[key] = m_LRU_cache.begin(); return; } m_map[key]->value = value; MoveToHead(key); }
vector<vector<int>> getFactors(int n) { if(record.find(n)!=record.end()) return record[n]; vector<vector<int>> result; for(int i=2; i*i<=n; i++) { if(n%i!=0) continue; result.push_back({i, n/i}); vector<vector<int>> remnants = getFactors(n/i); for(auto r:remnants) { if(r[0]<i) continue; vector<int> sol(r); sol.insert(sol.begin(), i); result.push_back(sol); } } record[n] = result; return result; }
bool isScr(string s1, int start1, int end1, string s2, int start2, int end2) { bool result = false; string s = s1.substr(start1, end1 - start1 + 1) + "#" + s2.substr(start2, end2 - start2 + 1); if (m.find(str_hash(s)) != m.end()) return m[str_hash(s)]; if ((end1 - start1) != (end2 - start2)) result = false; if ((end1 < start1) || (end2 < start2)) result = false; if (s1.substr(start1, (end1 - start1 + 1)) == s2.substr(start2, (end2 - start2 + 1))) result = true; if (start1 == end1) result = (s1[start1]==s2[start2]); for (int i = 0; i < (end1 - start1); ++i) { if (isScr(s1, start1, start1 + i, s2, start2, start2 + i) && isScr(s1, start1 + i + 1, end1, s2, start2 + i + 1, end2)) result = true; if (isScr(s1, start1, start1 + i, s2, end2 - i, end2) && isScr(s1, start1 + i + 1, end1, s2, start2, end2 - i - 1)) result = true; } m[str_hash(s)] = result; return result; }