int main() { srand(1337); //Set<int> *s = new ArrayIntSet(60000000); //Set<int> *s = new BsVectorSet<int>(); //Set<double> *s = new ListSet<double>(); Set<double> *s = new OrderedVectorSet<double>(); for(int i = 0; i != 20; i++) { s->insert(rand() % 30); } for(int i = 0; i != 30; i++) { cout << i << ": " << (s->contains(i) ? "Yes" : "No") << endl; if (i % 2 == 0) { s->remove(i); } } cout << endl; for(int i = 0; i != 30; i++) { cout << i << ": " << (s->contains(i) ? "Yes" : "No") << endl; } for(int i = 0; i != 100000; i++) { s->insert(rand() % 55789127); } cout << "Done inserting" << endl; for(int i = 0; i != 1000000; i++) { s->contains(i); } }
public List<String> wordBreak(String s, Set<String> dict) { List<String> result = new ArrayList<String>(); for(int j = s.length() - 1; j >= 0; j--){ if(dict.contains(s.substring(j))) break; else{ if(j == 0) return result; } } for(int i = 0; i < s.length()-1; i++) { if(dict.contains(s.substring(0,i+1))) { List<String> strs = wordBreak(s.substring(i+1,s.length()),dict); if(strs.size() != 0) for(Iterator<String> it = strs.iterator();it.hasNext();) { result.add(s.substring(0,i+1)+" "+it.next()); } } } if(dict.contains(s)) result.add(s); return result; }
static void generateAllPossibleWords(const Grid<char> & boggleBoard, Set<string> & wordsSpottedSoFar, const Lexicon & english, int rowIndex, int colIndex, string buildingWord, Set<coord> wordPath){ buildingWord += boggleBoard[rowIndex][colIndex]; if (buildingWord.size() >= kMinGuessLength && english.contains(buildingWord) && !wordsSpottedSoFar.contains(buildingWord)) { wordsSpottedSoFar.add(buildingWord); recordWordForPlayer(buildingWord, COMPUTER); } if (!english.containsPrefix(buildingWord)) return; for (int i = -1; i <= 1; i++) { for (int j = -1; j <=1; j++){ if(isShiftValid(boggleBoard, rowIndex, colIndex, i, j)){ coord nextPos; nextPos.row = rowIndex + i; nextPos.col = colIndex + j; if (!wordPath.contains(nextPos)){ wordPath.add(nextPos); generateAllPossibleWords(boggleBoard, wordsSpottedSoFar, english, rowIndex + i, colIndex + j, buildingWord, wordPath); wordPath.remove(nextPos); } } } } }
/* * Recursive Computer Search * * Recursively searches the Boggle board to find all the * words that can be made on the board and haven't * been guessed correctly by the human player */ void recursiveComputer(int row, int col, string word, Grid<string>& board, Lexicon& dictionary, Set<string>& results, Grid<bool>& visitedCubes, int& computerScore, Set<string>& usedWords){ if(!board.inBounds(row, col)) return; if(dictionary.contains(word) && word.length() >= 4) { if (!results.contains(word) && !usedWords.contains(word)) { computerScore += word.length() - 3; results.add(word); } } if(!dictionary.containsPrefix(word)){ return; } word = word + board[row][col]; visitedCubes[row][col] = true; for(int i = -1; i <= 1; i++){ for(int j = -1; j <= 1; j++){ if(visitedCubes.inBounds(row + i, col + j) && !visitedCubes[row + i][col + j]){ recursiveComputer(row + i, col + j, word, board, dictionary, results, visitedCubes, computerScore, usedWords); } if(visitedCubes.inBounds(row + i, col + j) && dictionary.contains(word) && !results.contains(word) && word.length() >=4) { computerScore += word.length() - 3; results.add(word); } } } visitedCubes[row][col] = false; }
int main() { int numbers[10] = {1,2,3,4,5,6,7,8,9,0}; Set<int> a; Set<int> b(a); Set<int> c(numbers, 10); b = a; assert(b==a); a = b & c; assert(a.empty()); a = b & 3; assert(a.empty()); a = 3 & b; assert(a.empty()); b &= a; assert(b.empty()); b &= 3; assert(b.empty()); b = a | c; assert(b == c); b = a | 3; assert(b.size() == 1); b = 3 | a; assert(b.size() == 1); a |= b; assert(a.size() == 1); a |= 3; assert(a.size() == 1 && a.contains(3)); assert(!(a != b)); assert(a< c); assert(3 < c); c > a; c > 3; a <= c; c >= a; a.contains(3); a.empty(); a.size(); a.insert(99); cout << a << endl << c; a.remove(99); }
static void testExtractionOperator() { declare(istringstream ss("{one, two, three}")); reportMessage("Set<string> set;"); Set<string> set; trace(ss >> set); test(set.size(), 3); test(set.contains("one"), true); test(set.contains("two"), true); test(set.contains("three"), true); }
bool MultipleDeriv ::isInRequiredSet(const Set<MultiSet<int> >& funcCombinations, const Set<MultiIndex>& multiIndices) const { if (spatialOrder() == 0) { return funcCombinations.contains(dofIDs()); } else { return multiIndices.contains(spatialDeriv()); } }
int main() { Set ss; ss.insert("focaccia"); assert(!ss.contains("")); ss.insert("tortilla"); ss.insert(""); ss.insert("lavash"); assert(ss.contains("")); ss.erase("focaccia"); assert(ss.size() == 3); assert(ss.contains("lavash")); assert(ss.contains("tortilla")); assert(ss.contains("")); }
int main() { Set<string> round; // Round things Set<string> green; // Green things round.add("peas"); // Sample data for both sets round.add("ball"); round.add("pie"); round.add("grapes"); green.add("peas"); green.add("grapes"); green.add("garden hose"); green.add("grass"); cout << "Contents of set round: "; round.output(); cout << "Contents of set green: "; green.output(); cout << "ball in set round? " << round.contains("ball") << endl; cout << "ball in set green? " << green.contains("ball") << endl; cout << "ball and peas in same set? "; if ((round.contains("ball") && round.contains("peas")) || (green.contains("ball") && green.contains("peas"))) cout << " true" << endl; else cout << " false" << endl; cout << "pie and grass in same set? "; if ((round.contains("pie") && round.contains("grass")) || (green.contains("pie") && green.contains("grass"))) cout << " true" << endl; else cout << " false" << endl; cout << "Union of green and round: " << endl; Set<string> *unionset = round.setUnion(green); unionset->output(); delete unionset; cout << "Intersection of green and round: " << endl; Set<string> *interset = round.setIntersection(green); interset->output(); delete interset; return 0; }
int GoNext(int start,Vector<int> squares){ // it is better not to return value for this kind of function int value; //cout << "start : " << start << endl; path.add(start); if (squares.getAt(start)==0) { answer=1; return 1; }else if (curnum > 1000) { answer=2; return 2; }else { curnum++; value=squares.getAt(start); //cout << "value: " << value << endl; if ((start+value) >= squares.size()) { //cout << "1" << endl; GoNext((start-value),squares); }else if ((start-value) < 0) { //cout << "2" << endl; GoNext((start+value),squares); }else { /*cout << "3" << endl; // This would go into infinite loop if (switchon) { GoNext((start+value),squares); GoNext((start-value),squares); switchon=false; }else { GoNext((start-value),squares); GoNext((start+value),squares); switchon=true; }*/ if (!path.contains(start+value)) { GoNext((start+value),squares); }else if (!path.contains(start-value)) { GoNext((start-value),squares); }else { GoNext((start-value),squares); GoNext((start+value),squares); } } } }
bool WordIsValid(string word, Grid<string> & board, Lexicon & lex, Set<string> & wordsSeen) { if (word.length() < 4) { return false; } else if (wordsSeen.contains(word)) { //already seen the word return false; } else if (!lex.containsWord(word)) { //not a word according to the dictionary return false; } else { Vector<locationT> empty; Vector<Vector<locationT> > results; Findable(board, word, -1, -1, empty, results); if (results.size() == 0) { //no paths were found for the word, so word can't be found return false; } else { Vector<locationT> answer = results[0]; //at least one path was found, so return true and highlight the cubes for (int i = 0; i < answer.size(); i++) { HighlightCube(answer[i].numRow, answer[i].numCol, true); } Pause(.5); for (int i = 0; i < answer.size(); i++) { //then un-highlight the cubes HighlightCube(answer[i].numRow, answer[i].numCol, false); } return true; } } }
static std::string addAutograderButton(GWindow& gui, const std::string& text, const std::string& icon) { static Set<char> usedMnemonics; std::string html = "<html><center>" + stringReplace(text, "\n", "<br>") + "</center></html>"; GButton* button = new GButton(html); STATIC_VARIABLE(AUTOGRADER_BUTTONS).add(button); // set mnemonic shortcut char mnemonic = '\0'; for (int i = 0; i < (int) text.length(); i++) { if (isalpha(text[i]) && !usedMnemonics.contains(text[i])) { mnemonic = text[i]; break; } } if (mnemonic) { usedMnemonics.add(mnemonic); button->setMnemonic(mnemonic); button->setAccelerator("ctrl " + charToString(mnemonic)); } if (!icon.empty()) { button->setIcon(icon); button->setTextPosition(SwingConstants::SWING_CENTER, SwingConstants::SWING_BOTTOM); } gui.addToRegion(button, "SOUTH"); return html; }
bool solvePuzzle(Grid<MarbleType>& board, int marblesLeft, Set<uint32_t>& exploredBoards, Vector<Move>& moveHistory){ /* TODO: COMPLETE THIS */ if (exploredBoards.size()%10000 == 0){ cout << "Boards evaluated: " << exploredBoards.size() << "\tDepth: " << moveHistory.size() << endl; cout.flush(); } if(marblesLeft == 1) return true; if(exploredBoards.contains(compressMarbleBoard(board))) return false; exploredBoards.add(compressMarbleBoard(board)); Vector<Move> moves = findPossibleMoves(board); for(int i=0; i<moves.size(); ++i){ Move move = moves[i]; makeMove(move, board); moveHistory.add(move); if(solvePuzzle(board, marblesLeft-1,exploredBoards, moveHistory)) { return true; } else{ undoMove(move, board); moveHistory.remove(moveHistory.size()-1); } } return false; }
int AToCPointLocator::findEnclosingCell(int initialGuessLID, const double* x, double* xLocal) const { std::queue<int> Q; Set<int> repeats; int d = mesh_.spatialDim(); Array<int> facets(mesh_.numFacets(d, 0, 0)); Array<int> facetOr(facets.size()); Q.push(initialGuessLID); while (!Q.empty()) { int next = Q.front(); Q.pop(); if (repeats.contains(next)) continue; // const int* facets = mesh_.elemZeroFacetView(next); mesh_.getFacetArray(d, next, 0, facets, facetOr); if (cellContainsPoint(next, x, &(facets[0]), xLocal)) return next; repeats.put(next); fillMaximalNeighbors(next, &(facets[0])); for (Set<int>::const_iterator i=neighborSet_[next]->begin(); i!=neighborSet_[next]->end(); i++) { Q.push(*i); } } return -1; // no containing cell found }
static void tryPlayerGuess(const Grid<char> & boggleBoard, Set<string> & playerAnswers, string playerGuess, const Lexicon & english) { if (playerGuess.size() < kMinGuessLength){ cout << endl << "Words need to be at least " + integerToString(kMinGuessLength) + " characters long" << endl; return; } if (!english.contains(playerGuess)){ cout << endl << "That word is not in the english language" << endl; return; } playerGuess = toUpperCase(playerGuess); if (playerAnswers.contains(playerGuess)){ cout << endl << "You have already guessed that word" << endl; return; } for(int i = 0; i < boggleBoard.numRows(); i++){ for(int j = 0; j < boggleBoard.numCols(); j++){ Set <coord> wordPath; coord pos; pos.row = i; pos.col = j; wordPath.add(pos); if(tryPlayerGuess(boggleBoard, playerAnswers, playerGuess, english, "", i, j, wordPath)){ pause(highlightPause); clearBoard(wordPath); recordWordForPlayer(playerGuess, HUMAN); return; } } } cout << endl << "That word is not on the board." << endl; }
int findEnclosingCell(const Mesh& mesh, int cellDim, int initialGuessLID, const double* x) { std::queue<int> Q; Set<int> repeats; static Array<int> facets; Q.push(initialGuessLID); while (!Q.empty()) { int next = Q.front(); Q.pop(); if (repeats.contains(next)) continue; if (cellContainsPoint(mesh, cellDim, next, x, facets)) return next; repeats.put(next); std::list<int> neighbors; maximalNeighbors(mesh, cellDim, next, facets, neighbors); for (std::list<int>::const_iterator i=neighbors.begin(); i!=neighbors.end(); i++) { Q.push(*i); } } return -1; // no containing cell found }
bool recSolvable(int start, Vector<int> & squares, Set<int> &indexVisited) { if (start < 0 || start >= squares.size() || indexVisited.contains(start)) return false; if (start == (squares.size() - 1)) return true; indexVisited.add(start); return (recSolvable(start + squares[start], squares, indexVisited) ||recSolvable(start - squares[start], squares, indexVisited)); }
bool Store::retrieveValue(const BinaryString &key, Set<BinaryString> &values) { // Note: values is not cleared ! const Identifier localNode = Network::Instance->overlay()->localNode(); Database::Statement statement = mDatabase->prepare("SELECT value FROM map WHERE key = ?1"); statement.bind(1, key); while(statement.step()) { BinaryString v; statement.value(0, v); values.insert(v); } statement.finalize(); if(!values.contains(localNode)) { // Also look for digest in blocks in case map is not up-to-date statement = mDatabase->prepare("SELECT 1 FROM blocks WHERE digest = ?1 LIMIT 1"); statement.bind(1, key); if(statement.step()) values.insert(localNode); statement.finalize(); } return !values.empty(); }
void ArticulatedModel::Part::transformGeometry(shared_ptr<ArticulatedModel> am, const Matrix4& xform) { // TODO: this is a linear search through the mesh array for every part, could be sped up // TODO: this transforms any geometry that is touch by a mesh in this part. This will have // unintended side effects when multiple parts have meshes that share geometry Set<ArticulatedModel::Geometry*> touchedGeometry; for (int i = 0; i < am->m_meshArray.size(); ++i) { Mesh* mesh = am->m_meshArray[i]; alwaysAssertM(notNull(mesh->geometry), "Found a NULL mesh in transformGeometry"); if ( mesh->logicalPart == this && ! touchedGeometry.contains(mesh->geometry)) { touchedGeometry.insert(mesh->geometry); CPUVertexArray::Vertex* vertex = mesh->geometry->cpuVertexArray.vertex.getCArray(); const int N = mesh->geometry->cpuVertexArray.size(); for (int i = 0; i < N; ++i) { vertex->position = xform.homoMul(vertex->position, 1.0f); vertex->tangent = Vector4::nan(); vertex->normal = Vector3::nan(); ++vertex; } } } for (int c = 0; c < m_children.size(); ++c) { m_children[c]->cframe.translation = xform.homoMul(m_children[c]->cframe.translation, 1.0f); } }
int AToCPointLocator::findEnclosingCell(int initialGuessLID, const double* x, double* xLocal) const { std::queue<int> Q; Set<int> repeats; Q.push(initialGuessLID); while (!Q.empty()) { int next = Q.front(); Q.pop(); if (repeats.contains(next)) continue; const int* facets = mesh_.elemZeroFacetView(next); if (cellContainsPoint(next, x, facets, xLocal)) return next; repeats.put(next); fillMaximalNeighbors(next, facets); for (Set<int>::const_iterator i=neighborSet_[next]->begin(); i!=neighborSet_[next]->end(); i++) { Q.push(*i); } } return -1; // no containing cell found }
void subtract(const Set& s1, const Set& s2, Set& result) { Set A = s1; Set B = s2; Set C; result = C; //clear the contents of result by setting it equal to empty Set C for (int a = 0; a < B.size(); a++) { ItemType value; B.get(a, value); if (A.contains(value)) { A.erase(value); //if A contains a value that is also in B, delete it from A } } for (int d = 0; d < A.size(); d++) { ItemType value; A.get(d, value); result.insert(value); //insert these into result, which now only contains values from A and not B } }
void WatcherData::watch(const Path& path) { std::lock_guard<std::mutex> lock(mutex); assert(!paths.contains(path)); paths.insert(path); CFRunLoopSourceSignal(source); CFRunLoopWakeUp(loop); }
void test() { Set uls; assert(uls.insert(10)); assert(uls.insert(20)); assert(uls.size() == 2); assert(uls.contains(20)); ItemType x = 30; assert(uls.get(0, x) && (x == 10 || x == 20)); }
bool Set<ElemType>::isSubsetOf(Set & otherSet) { if (cmpFn != otherSet.cmpFn) { Error("isSubsetOf: sets have different comparison functions"); } Iterator iter = iterator(); while (iter.hasNext()) { if (!otherSet.contains(iter.next())) return false; } return true; }
Set<std::string> WebPage::allWords () const { std::stringstream ss; ss.str(data); Set<std::string>* words = new Set<std::string>(); while(!ss.fail()) { std::string word = ""; ss >> word; bool insideWord = false; bool skipForBracket = false; Set<std::string> innerWords = Set<std::string>(); int startIndex = 0; int endIndex = 0; for(unsigned int j = 0; j < word.length(); j++) { if(word[j] == '[') { skipForBracket = true; } if(word[j] == ']') { skipForBracket = false; } //Check to see if the char at line[j] is within the ASCII bounds of upper/lower case alphabet letters if(isalnum(word[j]) && !skipForBracket) { if(insideWord == false) { startIndex = j; } insideWord = true; //If yes, then it is inside a word } else { if(insideWord == true) { //else the word has ended insideWord = false; endIndex = j; int length = endIndex - startIndex; innerWords.insert(innerWords.end(),word.substr(startIndex,length)); } } } if(insideWord) { endIndex = word.length(); } int length = endIndex - startIndex; if(length > 0) { innerWords.insert(innerWords.end(),word.substr(startIndex,length)); } set<std::string>::iterator innerWordsIter = innerWords.begin(); for(unsigned int i = 0; i < innerWords.size(); i++) { if(innerWordsIter != innerWords.end()) { std::string addition = *innerWordsIter; innerWordsIter++; if (!words->contains(addition)) { words->insert(words->end(),addition); } } } } return *words; }
void dirtySymbols(SymbolMap &map, const Set<uint32_t> &dirty) { SymbolMap::iterator it = map.begin(); while (it != map.end()) { if (dirty.contains(it->first.fileId())) { map.erase(it++); } else { it->second->dirty(dirty); ++it; } } }
/* Determines any covered cities in hospital location and removes them from the cities set. * Returns the removed/covered cities. */ Set<string> getCoveredCities(Set<string>& cities, Set<string> location) { Set<string> coveredCities; foreach(string city in cities) { if (location.contains(city)) { coveredCities.add(city); cities.remove(city); } } return coveredCities; }
TIMED_TEST(MapTests, forEachTest_Map, TEST_TIMEOUT_DEFAULT) { Map<std::string, int> map; map.put("zz", 26); map.put("a", 1); map.put("ss", 97); map.put("bbbb", 2); map.put("E", 4); map.put("yZ44", 33); Set<std::string> expected {"zz", "a", "ss", "bbbb", "E", "yZ44"}; for (const std::string& key : map) { assertTrue("foreach Map contains " + key, expected.contains(key)); } map.remove("ss"); map.remove("zz"); map.remove("yZ44"); map.remove("notfound"); expected = {"a", "bbbb", "E"}; for (const std::string& key : map) { assertTrue("foreach Map contains " + key, expected.contains(key)); } }
void TestTools::set_initializerList() { Set<int> set = {1, 1, 2, 3, 4, 5}; QCOMPARE(set.count(), 5); QVERIFY(set.contains(1)); QVERIFY(set.contains(2)); QVERIFY(set.contains(3)); QVERIFY(set.contains(4)); QVERIFY(set.contains(5)); // check _which_ of the equal elements gets inserted (in the QHash/QMap case, it's the last): const Set<IdentityTracker> set2 = {{1, 0}, {1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}}; QCOMPARE(set2.count(), 5); const int dummy = -1; const IdentityTracker searchKey = {1, dummy}; QCOMPARE(set2.find(searchKey)->id, 0); Set<int> emptySet{}; QVERIFY(emptySet.isEmpty()); Set<int> set3{{}, {}, {}}; QVERIFY(!set3.isEmpty()); }
bool WatcherThread::isWatching(const Path& p) const { Path path = p, parent; if (!path.endsWith('/')) path += '/'; for (;;) { if (paths.contains(path)) return true; parent = path.parentDir(); if (parent == path || parent.isEmpty()) break; path = parent; } return false; }