int main(int argc, char **argv) { max_x=max_y=min_x=min_y=MID; readDictionary(*argv +1); ws_maker(); setlastFour(); getMaxAndMin_X_Y(); if(debug) for(int i=0; i<MAXMATRIX; i++){ for(int j=0; j<MAXMATRIX; j++) printf("%C",Word[i][j]); printf("\n"); } FILE *h; h = fopen("answer.txt", "w+"); for(int i=0; i<max_x - min_x +1 ; i++){ for(int j=0; j<max_y - min_y +1; j++){ answer[i][j] = Word[min_x+i][min_y+j]; if(answer[i][j] == 0) answer[i][j] = 'Z'; printf("%c ", answer[i][j]); fputc(answer[i][j],h); } printf("\n"); fputc('\n',h); } printf("%d %d %d %d\n",max_x ,min_x, max_y ,min_y); }
/** Funkcja otwierajaca plik z rozszerzeniem dt @param name nazwa otwieranego pliku @param name_save nazwa pliku wynikowego */ void Reader::open(string name,string name_save){ size_t found = name.find(".dt"); if(found==-1) { name = name + ".dt"; } char *nazwa= new char[name.length()+1]; strcpy( nazwa, name.c_str() ); plik.open( nazwa, ios::in|ios::binary); if( plik.good() == true ) { // wczytanie width plik.seekg( 0,ios::beg ); int length =24; char * buffer = new char [length]; plik.read(buffer,length); string helpReader; helpReader =charToString(buffer,length); width=bin2dec(helpReader); // end of width //wczytanie height plik.read(buffer,length); helpReader =charToString(buffer,length); height=bin2dec(helpReader); //end of height //wczytanie pixelWidth plik.read(buffer,length); helpReader =charToString(buffer,length); pixelWidth=bin2dec(helpReader); //end of pixelWidth //wczytaniey length =16; buffer = new char [length]; plik.read(buffer,length); helpReader =charToString(buffer,length); dictionaryStart=bin2dec(helpReader); // endo of dictionaryStart //wczytanie pictureStart plik.read(buffer,length); helpReader =charToString(buffer,length); pictureStart=bin2dec(helpReader); ///end of pictureStart screen = SDL_SetVideoMode(width, height,32,SDL_RESIZABLE|SDL_DOUBLEBUF); readDictionary(name_save); } plik.close(); }
void jccTest(char *dictionary, char *phoneBook, char *output) /* jccTest - Test program.. */ { int maxSize; struct hash *hash = readDictionary(dictionary, &maxSize); processPhoneBook(hash, maxSize, phoneBook, output); }
int main(int argc, char *argv[]) { readDictionary(); size_t tam; std::ifstream fileStream(argv[1]); if (!fileStream) { std::cerr << "ERROR"; exit(-1); } while (fileStream >> tam >> letters) { std::sort(letters.begin(), letters.end()); char previous = letters[0]; static std::string uniqueLetters; uniqueLetters.push_back(previous); for (char c : letters) { if (c != previous) { uniqueLetters.push_back(c); previous = c; } } std::vector<std::string> candidates = getWords(uniqueLetters, tam); std::vector<std::string> wordSquare = findWordSquare(candidates, tam); for (std::string s : wordSquare) { std::cout << s << std::endl; } std::cout << std::endl; } return 0; }
int main (void) { int row, col, i, max; char *str = malloc(sizeof(char) * (MAX_WORD_LENGTH + 1)); char temp[2]; Dictionary *dict = malloc(sizeof(Dictionary)); WordSearchPuzzle *puzzle = malloc(sizeof(WordSearchPuzzle)); readDictionary(dict); readPuzzle(puzzle); //set bigger dimension of puzzle, use for determining //length of diagonal for() loops if (puzzle->height > puzzle->width) { max = puzzle->height; } else { max = puzzle->width; } temp[1] = '\0'; for (row = 0; row < puzzle->height; row++) { for (col = 0; col < puzzle->width; col++) { //clear array, except for char at index 0 for (i = 1; i < MAX_WORD_LENGTH + 1; i++) { str[i] = '\0'; } //single char strings *str = puzzle->grid[row][col]; checkString(dict, str); //build strings horizontally-right for (i = 1; i < puzzle->width; i++) { //make sure not to go too far! if (col + i < puzzle->width) { temp[0] = puzzle->grid[row][col + i]; str = strcat(str, temp); checkString(dict, str); } } //clear array, except for char at index 0 for (i = 1; i < MAX_WORD_LENGTH + 1; i++) { str[i] = '\0'; } //build strings horizontally-left for (i = 1; i < puzzle->width; i++) { //make sure not to go too far! if (col - i > 0) { temp[0] = puzzle->grid[row][col - i]; str = strcat(str, temp); checkString(dict, str); } } //clear array, except for char at index 0 for (i = 1; i < MAX_WORD_LENGTH + 1; i++) { str[i] = '\0'; } //build strings vertically-down for (i = 1; i < puzzle->height; i++) { if (row + i < puzzle->height) { temp[0] = puzzle->grid[row + i][col]; str = strcat(str, temp); checkString(dict, str); } } //clear array, except for char at index 0 for (i = 1; i < MAX_WORD_LENGTH + 1; i++) { str[i] = '\0'; } //build strings vertically-up for (i = 1; i < puzzle->height; i++) { //why is this >=? top row of puzzle (height/width ints) hindering correct reading? if (row - i >= 0) { temp[0] = puzzle->grid[row - i][col]; str = strcat(str, temp); checkString(dict, str); } } //clear array, except for char at index 0 for (i = 1; i < MAX_WORD_LENGTH + 1; i++) { str[i] = '\0'; } //build string diagonally up-left for (i = 1; i <= max; i++) { if (row - i >= 0 && col - i >= 0) { temp[0] = puzzle->grid[row - i][col - i]; str = strcat(str, temp); checkString(dict, str); } } //clear array, except for char at index 0 for (i = 1; i < MAX_WORD_LENGTH + 1; i++) { str[i] = '\0'; } //build string diagonally up-right for (i = 1; i < max; i++) { if (row - i >= 0 && col + i < puzzle->width) { temp[0] = puzzle->grid[row - i][col + i]; str = strcat(str, temp); checkString(dict, str); } } //clear array, except for char at index 0 for (i = 1; i < MAX_WORD_LENGTH + 1; i++) { str[i] = '\0'; } //build string diagonally down-left for (i = 1; i < max; i++) { if (row + i < puzzle->height && col - i >= 0) { temp[0] = puzzle->grid[row + i][col - i]; str = strcat(str, temp); checkString(dict, str); } } //clear array, except for char at index 0 for (i = 1; i < MAX_WORD_LENGTH + 1; i++) { str[i] = '\0'; } //build string diagonally down-right for (i = 1; i < max; i++) { if (row + i < puzzle->height && col + i < puzzle->width) { temp[0] = puzzle->grid[row + i][col + i]; str = strcat(str, temp); checkString(dict, str); } } }//end [col] for loop }//end [row] for loop for (i = 0; i < dict->size; i++) { if (dict->counts[i] > 0) { printf("%s (%d)\n", dict->words[i], dict->counts[i]); } } destroyDictionary(dict); destroyPuzzle(puzzle); free(str); str = NULL; return 0; }
bool ClParserParser:: parse() { ClParserOperatorType op = CL_PARSER_OP_NONE; error_code_ = 0; bool expression = false; parse_.skipSpace(); while (! parse_.eof()) { /* <expression> := <inline_operator> <expression> <expression> := <expression> <inline_operator> */ if (parse_.isString("++") || parse_.isString("--")) { if (parse_.isChar('+')) ClParserStackMgrInst->push(CL_PARSER_OP_INCREMENT); else ClParserStackMgrInst->push(CL_PARSER_OP_DECREMENT); ClParserStackMgrInst->toNext(); parse_.skipChars(2); if (! expression) { ClParserParser parser(this); if (! parser.parse()) { error_code_ = parser.getErrorCode(); goto fail; } if (parser.isAssign()) { error_code_ = int(ClErr::INVALID_LVALUE_FOR_ASSIGNMENT); goto fail; } } expression = true; } /* <expression> := <unary_operator> <expression> */ else if (! expression && parse_.isOneOf(parser_unary_operator_chars)) { if (! readUnaryOperator(&op)) { error_code_ = int(ClErr::INVALID_CHARACTER); goto fail; } ClParserStackMgrInst->push(op); ClParserStackMgrInst->toNext(); ClParserParser parser(this); if (! parser.parse()) { error_code_ = parser.getErrorCode(); goto fail; } if (parser.isAssign()) { error_code_ = int(ClErr::INVALID_LVALUE_FOR_ASSIGNMENT); goto fail; } expression = true; } /* <expression> := '(' <expression> ')' */ else if (! expression && parse_.isChar('(')) { ClParserStackMgrInst->push(CL_PARSER_OP_OPEN_R_BRACKET); ClParserStackMgrInst->toNext(); parse_.skipChar(); ClParserParser parser(this); /* TODO: set end char */ if (! parser.parse() && parser.getErrorCode() != int(ClErr::INVALID_CHARACTER)) { error_code_ = parser.getErrorCode(); goto fail; } parse_.skipSpace(); if (! parse_.isChar(')')) { error_code_ = int(ClErr::MISSING_CLOSE_ROUND_BRACKET); goto fail; } ClParserStackMgrInst->push(CL_PARSER_OP_CLOSE_R_BRACKET); ClParserStackMgrInst->toNext(); parse_.skipChar(); expression = true; } /* <expression> := <numeric_value> */ else if (! expression && (parse_.isDigit() || parse_.isChar('.'))) { ClParserValuePtr value; if (! readNumericValue(value)) goto fail; ClParserStackMgrInst->push(value); ClParserStackMgrInst->toNext(); expression = true; } /* <expression> := <string_value> */ else if (! expression && parse_.isOneOf(parser_string_chars)) { ClParserValuePtr value; if (! readStringValue(value)) goto fail; ClParserStackMgrInst->push(value); ClParserStackMgrInst->toNext(); expression = true; } /* <expression> := <array_value> */ else if (! expression && parse_.isChar('[')) { ClParserStackMgrInst->push(CL_PARSER_OP_OPEN_S_BRACKET); ClParserStackMgrInst->toNext(); parse_.skipChar(); if (! readArray()) goto fail; expression = true; } /* <expression> := <dict_value> */ else if (! expression && parse_.isString("{{")) { ClParserStackMgrInst->push(CL_PARSER_OP_OPEN_DICT); ClParserStackMgrInst->toNext(); parse_.skipChars(2); if (! readDictionary()) goto fail; expression = true; } /* <expression> := <list_value> */ else if (! expression && parse_.isChar('{')) { ClParserStackMgrInst->push(CL_PARSER_OP_OPEN_BRACE); ClParserStackMgrInst->toNext(); parse_.skipChar(); if (! readList()) goto fail; expression = true; } /* <expression> := <expression> <binary_operator> <expression> */ else if (expression && parse_.isOneOf(parser_binary_operator_chars)) { if (! readBinaryOperator(&op)) goto fail; ClParserStackMgrInst->push(op); ClParserStackMgrInst->toNext(); ClParserParser parser(this); if (! parser.parse()) { error_code_ = parser.getErrorCode(); goto fail; } ClParserOperatorPtr op1 = ClParserOperatorMgrInst->getOperator(op); if (! op1->isAssignment() && parser.isAssign()) { error_code_ = int(ClErr::INVALID_LVALUE_FOR_ASSIGNMENT); goto fail; } if (op1->isAssignment()) assign_ = true; expression = true; } /* <expression> := <expression> '?' <expression> ':' <expression> */ else if (expression && parse_.isChar('?')) { ClParserStackMgrInst->push(CL_PARSER_OP_QUESTION_MARK); ClParserStackMgrInst->toNext(); parse_.skipChar(); ClParserParser parser1(this); if (! parser1.parse() && parser1.getErrorCode() != int(ClErr::INVALID_CHARACTER)) { error_code_ = parser1.getErrorCode(); goto fail; } parse_.skipSpace(); if (! parse_.isChar(':')) { error_code_ = int(ClErr::MISSING_COLON_OPERATOR); goto fail; } ClParserStackMgrInst->push(CL_PARSER_OP_COLON); ClParserStackMgrInst->toNext(); parse_.skipChar(); ClParserParser parser2(this); if (! parser2.parse() && parser2.getErrorCode() != int(ClErr::INVALID_CHARACTER)) { error_code_ = parser2.getErrorCode(); goto fail; } assign_ = parser1.isAssign() | parser2.isAssign(); expression = true; } /* <expression> := <expression> '[' <expression> ',' .... ']' */ else if (expression && parse_.isChar('[')) { ClParserStackMgrInst->push(CL_PARSER_OP_OPEN_S_BRACKET); ClParserStackMgrInst->toNext(); parse_.skipChar(); if (! readArray()) goto fail; expression = true; } /* <expression> := <expression> ',' <expression> */ else if (expression && parse_.isChar(',')) { ClParserStackMgrInst->push(CL_PARSER_OP_COMMA); ClParserStackMgrInst->toNext(); parse_.skipChar(); ClParserParser parser(this); if (! parser.parse()) { error_code_ = parser.getErrorCode(); goto fail; } expression = true; } /* <expression> := <variable> */ /* <expression> := <variable> '.' <variable> '.' <...> */ /* <expression> := <variable> '[' <expression> ',' .... ']' */ /* <expression> := <function> '(' <expression> ',' .... ')' */ /* <expression> := <type> '(' <expression> ',' .... ')' */ else if (! expression && ((! ClParserInst->getDollarPrefix() && parse_.isIdentifier()) || ( ClParserInst->getDollarPrefix() && parse_.isChar('$') && parse_.isIdentifier(1)))) { if (ClParserInst->getDollarPrefix() && parse_.isChar('$')) parse_.skipChar(); ClParserIdentifierPtr identifier; if (! readIdentifier(identifier)) goto fail; const std::string &name = identifier->getName(); ClParserScopePtr scope = identifier->getScope(); parse_.skipSpace(); if (parse_.isChar('(')) { ClParserInternFnPtr internfn; if (scope.isValid()) internfn = scope->getInternFn(name); else internfn = ClParserInst->getInternFn(name); if (internfn.isValid()) { ClParserStackMgrInst->push(internfn); ClParserStackMgrInst->toNext(); } else { ClParserUserFnPtr userfn; if (scope.isValid()) userfn = scope->getUserFn(name); else userfn = ClParserInst->getUserFn(name); if (userfn.isValid()) { ClParserStackMgrInst->push(userfn); ClParserStackMgrInst->toNext(); } else { ClParserTypePtr type = ClParserInst->getType(name); if (type.isValid()) { ClParserStackMgrInst->push(type); ClParserStackMgrInst->toNext(); } else { identifier->setFunction(); ClParserStackMgrInst->push(identifier); ClParserStackMgrInst->toNext(); } } } ClParserStackMgrInst->push(CL_PARSER_OP_OPEN_R_BRACKET); ClParserStackMgrInst->toNext(); parse_.skipChar(); if (! readArgList()) goto fail; expression = true; } else { identifier->setVariable(); ClParserStackMgrInst->push(identifier); ClParserStackMgrInst->toNext(); if (parse_.isChar('[')) { ClParserStackMgrInst->push(CL_PARSER_OP_OPEN_S_BRACKET); ClParserStackMgrInst->toNext(); parse_.skipChar(); if (! readArray()) goto fail; parse_.skipSpace(); } while (parse_.isChar('.')) { identifier->setStructPart(); ClParserStackMgrInst->push(CL_PARSER_OP_DOT); ClParserStackMgrInst->toNext(); parse_.skipChar(); parse_.skipSpace(); if (! readIdentifier(identifier)) { error_code_ = int(ClErr::INVALID_CHARACTER); goto fail; } identifier->setVariable(); ClParserStackMgrInst->push(identifier); ClParserStackMgrInst->toNext(); if (parse_.isChar('[')) { ClParserStackMgrInst->push(CL_PARSER_OP_OPEN_S_BRACKET); ClParserStackMgrInst->toNext(); parse_.skipChar(); if (! readArray()) goto fail; parse_.skipSpace(); } } expression = true; } } /* <expression> := <string_value> */ else if (! expression && ClParserInst->getDollarPrefix()) { std::string str; parse_.readNonSpace(str); ClParserValuePtr value = ClParserValueMgrInst->createValue(str); ClParserStackMgrInst->push(value); ClParserStackMgrInst->toNext(); parse_.skipSpace(); expression = true; } else { error_code_ = int(ClErr::INVALID_CHARACTER); goto fail; } parse_.skipSpace(); } if (error_code_ == 0 && ! expression) { error_code_ = int(ClErr::NULL_EXPRESSION); goto fail; } if (parent_) parent_->parse_.setPos(parent_->parse_.getPos() + parse_.getPos()); return true; fail: if (parent_) parent_->parse_.setPos(parent_->parse_.getPos() + parse_.getPos()); return false; }
int main(int argc, char* argv[]) { std::ifstream wordFile, inFile; std::queue<std::string> matchingCase; std::vector<std::string> dictionary, input; // cmake build version(as specified in cmake header std::cout << "VERSION " << MAJOR << "." << MINOR << std::endl; // if the user enters no args if(argc == 1) { std::cout << "Usage: ./auto <wordList> <inputFile>" << std::endl; return 1; // testing for retarded user } else if(argc == 2) { std::cout << "Error, must provide inputFile" << std::endl; return 1; } // open dictionary text file if(!openGood(wordFile, argv[1])) { std::cout << "Error, dictionary file could not be opened\n"; return 1; } // now open input file with the words we need to complete if(!openGood(inFile, argv[2])) { std::cout << "Error, input file could not be opened\n"; return 1; } #ifdef USE_INPUT readDictionary(wordFile, dictionary, argv[1]); readInput(inFile, input, argv[2]); #else //-------------------------------------------------------------------- input.push_back("par"); dictionary.push_back("apple"); dictionary.push_back("and"); dictionary.push_back("batman"); dictionary.push_back("gone"); dictionary.push_back("imaginary"); dictionary.push_back("parachute"); dictionary.push_back("paraglide"); dictionary.push_back("testing"); dictionary.push_back("zoo"); //-------------------------------------------------------------------- #endif //check to make sure list is sorted! //--check, ok done if(!search(dictionary, input, matchingCase)) { std::cout << "no words have been found matching...." << std::endl; return 1; } // print contents of queue while(!matchingCase.empty()) { //make sure to display our queue in the order we found them std::cout << matchingCase.front() << std::endl; //pop off the front of the queue matchingCase.pop(); } return 0; }