int main(int argc,char *argv[]){ node *tree = NULL; node *tree2 = NULL; tree = getNumbers(tree); tree2 = getNumbers(tree2); if(isSubset(tree,tree2) == 1) printf("Tree 2 is a subset of Tree 1."); else printf("Tree 2 is not a subset of Tree 1."); freeTree(tree); freeTree(tree2); return 0; }
int main (void){ int number1, number2, gcf; // Collect 2 numbers number1 = getNumbers(); number2 = getNumbers(); // Store the greatest common factor of 2 numbers gcf = greatestFactor(number1, number2); // return gcf printf("The GCF of %i and %i is %i\n", number1, number2, gcf); }
// Main Function, controls program flow int main() { NodeT *pRoot; int i; int k = 0; int iAnswer = 0; int iSize; pRoot = NULL; pRoot = getNumbers(pRoot); // Call function to get user input iSize = treeSize(pRoot); for (i = 0; i < 1000; i++) { srand(i*17); k = rand()%iSize+1; updateKthNum(pRoot, k); // Call function to update picked number } printf("\nProbabilities after 1000 random selections are:\n"); printTree(pRoot); freeTreeMem(pRoot); // Alwys free that allocated memory!! printf("\n\n"); return 0; }
int main(int argc, char **argv) { int i,a,b,c; FILE * output=stdout; int verbose=0; for(i=1; i < argc; i++) { if(strcmp(argv[i],"-o")==0) output=fopen(argv[++i],"w"); else if(strcmp(argv[i],"-v")==0) verbose=1; else { printf("invalid parameter - %s\n",argv[i]); return 1; } } getNumbers(&a, &b); c = _sum(a,b); if(verbose) fprintf(output, "Welcome to task0, the input numbers are %i and %i\nThe sum is %i\n",a,b,c); fprintf(output,"sum of %i and %i is: %i\n",a,b,c); if(output!=stdout) fclose(output); return 0; }
int main(void) { int arrSize; printf("Enter number of integer elements in array: "); scanf("%d", &arrSize); // store number of integers printf("\n"); int *arr = malloc(arrSize * sizeof(int)); // allocate memory for number of integers printf("Enter %d integers to sort using quicksort algorithm: ", arrSize); getNumbers(arr, arrSize); // store user's input printf("Before QuickSort: \n"); displayArray(arr, arrSize); quicksort(arr, 0, arrSize - 1); // use the QuickSort algo to sort user's input integers printf("After QuickSort: \n"); displayArray(arr, arrSize); printf("\n"); free(arr); return 0; }
int main (int argc, char *argv[]){ //declaring main variables node *tree = NULL; int treeSz; tree = getNumbers(tree); treeSz = treeSize(tree); findKthInt(tree, treeSz); freeTree(tree); }
void initializeIds() { if( _space.isValid() && _space->getRootObject() == NULL && _rootObject.isValid() ) { _space->initialize( _rootObject.get() ); } if( _space.isValid() && _rootObject.isValid() && _space->getRootObject() == _rootObject.get() ) { _graphIds = co::newInstance( "flow.ServiceIdMap" )->getService<flow::IServiceIdMap>(); _graphIds->initWithIds( _space.get(), getNumbers(_ids.substr(1, _ids.npos-1) ) ); ready = true; } }
Loader::Loader() { QFile file(Lotto::sampleFile.c_str()); file.open(QFile::ReadOnly); if (file.exists() && file.isReadable()) { QByteArray allFile = file.readAll(); std::string data = allFile.data(); for (unsigned int i = 0; i < data.length(); i++) { if (data[i] == '#' || data[i] == '\n' || data[i] == ' ' || data[i] == '\r') { while (data[i] != '\n') { i++; } continue; } try { int id = getNumber(i, data); std::string date = getData(i, data); int *numbers = getNumbers(i, data); Sample* s = new Sample(id, date, numbers); i--; list.push_front(s); if (debug) { std::cout << *s; } } catch (NumberException &e) { std::cout << "NumberExceptionError\nLine: " << __LINE__ << "\nFile: " << __FILE__ << std::endl; throw; } } } else { throw FileError(); } }
void applyRefChange( co::IService* service, const std::string& name, const std::string& idList ) { if( idList == "nil" ) { co::IService* serviceNil = nullptr; co::AnyValue value(serviceNil); // null setField( service, name, value ); } if( idList.at( 0 ) == '#' ) { if( idList.at( 1 ) == '{' ) { std::string numbersStr = idList.substr( 2, idList.npos - 2 ); std::vector<int> numbers = getNumbers( numbersStr ); co::IField* refVecField = co::cast<co::IField>( service->getInterface()->getMember( name ) ); co::IType* fieldType = refVecField->getType(); co::AnyValue returnValue; returnValue.create( fieldType ); co::IReflector* serviceReflector = service->getInterface()->getReflector(); serviceReflector->getField( service, refVecField, returnValue ); returnValue.getAny().resize( numbers.size() ); for( int i = 0; i < numbers.size(); i++ ) { co::IService* serviceRef = _graphIds->getService( numbers[i] ); if( !serviceRef ) CORAL_THROW( co::Exception, "service id " << numbers[i] << " not found" ); returnValue.getAny()[i].put( serviceRef ); } refVecField->getOwner()->getReflector()->setField( service, refVecField, returnValue ); } else { int id = atoi( idList.substr( 1 ).c_str() ); co::IService* serviceValue = _graphIds->getService( id ); setField( service, name, serviceValue ); } } }
//O(n*k) with the radixSort function as the longest operation int main(int argc, char * argv[]){ DEQUE *radixarray[RADIXSIZE], *maindeque; int i, number, max, mainitems; maindeque = createDeque(); for(i = 0; i < RADIXSIZE; i++) radixarray[i] = createDeque(); getNumbers(maindeque, &max); radixSort(maindeque, radixarray, max); mainitems = numItems(maindeque); system("clear"); for(i = 0; i < mainitems; i++){ number = removeLast(maindeque); printf("%d\n", number); } destroyDeque(maindeque); for(i = 0; i < RADIXSIZE; i++){ destroyDeque(radixarray[i]); } return 0; }
// Main Function, controls program flow int main() { CNode *pHeadC; // For the Doubly linked list CNode *pRoot; // For the binary tree // Initializing doubly linked list pHeadC = (CNode*)malloc(sizeof(CNode)); pHeadC->pNext = NULL; pHeadC->pPrevious = NULL; // Let the user know what we are doing printf("\n\nPlease enter a series of integers.\n"); printf("These will first be stored in a doubly linked list,\n"); printf("then converted into a binary tree.\n"); pHeadC = getNumbers(pHeadC); printf("\nGreat! Before we begin, let's print the doubly linked list: \n"); printDLL(pHeadC); pRoot = convDLLtoBT(pHeadC); printf("\n\nLooks good! Now, let's convert that doubly linked list into a binary tree.\n"); printf("\nFirst, let's print our binary tree in order:\n"); printTree(pRoot); printf("\n\nNow, let's print our binary tree in preorder walk traversal:\n"); printTreePreOrder(pRoot); printf("\n\nNow, let's print our binary tree in postorder walk traversal:\n"); printTreePostOrder(pRoot); freeTreeMem(pRoot); printf("\n\n"); return 0; }
int main() { MSS * myResult; /* initialize random seed: */ srand (time(NULL)); unsigned int sizeOfNum = 512; std::vector<int> num; createVector(num, sizeOfNum); printf("Max Sum Sub-Array Algorithms\n\n"); printf("size = %d\n\n", sizeOfNum); std::clock_t start; printf("\n\nBrute Force Max Sum Sub-Array\n\n"); start = std::clock(); bruteMaxSumSub(num, result, sizeOfNum); std::cout << "Brute Force Time: " << (std::clock() - start) / (double)(CLOCKS_PER_SEC / 1000) << " ms\n"; printf("Result of bruteMaxSumSub, max sum = %d\nSubArray*************\n", result.sum); for(int i = result.start; i <= result.end; ++i) { printf("%d\t", num[i]); } printf("\n\nImproved Brute Force Max Sum Sub-Array\n\n"); start = std::clock(); betterBruteMaxSum(num, result, sizeOfNum); std::cout << "Better Brute Force Time: " << (std::clock() - start) / (double)(CLOCKS_PER_SEC / 1000) << " ms\n"; printf("Result of betterBruteMaxSumSub, max sum = %d\nSubArray*************\n", result.sum); for(int i = result.start; i <= result.end; ++i) { printf("%d\t", num[i]); } printf("\n\nDivide and Conquer Max Sum Sub-Array\n\n"); start = std::clock(); myResult = divideAndConquerMaxSub(num, 0, sizeOfNum - 1); std::cout << "Divide and Conquer Max Sum Time: " << (std::clock() - start) / (double)(CLOCKS_PER_SEC / 1000) << " ms\n"; printf("Result of divideAndConquerMaxSub, max sum = %d\nSubArray*************\n", myResult->sum); for(int i = myResult->start; i <= myResult->end; ++i) { printf("%d\t", num[i]); } //clean up delete myResult; myResult = NULL; printf("\n\nLinear Max Sum Sub-Array\n\n"); start = std::clock(); linearMaxSub(num, sizeOfNum, result); std::cout << "Linear Max Sum Time: " << (std::clock() - start) / (double)(CLOCKS_PER_SEC / 1000) << " ms\n"; printf("Result of linearMaxSub, max sum = %d\nSubArray*************\n", result.sum); for(int i = result.start; i <= result.end; ++i) { printf("%d\t", num[i]); } std::cout << std::endl << std::endl; /********************************************************************************************************************************* **TESTING FILES **********************************************************************************************************************************/ /* Stream class provided by C++ to read from files Credit: http://www.cplusplus.com/doc/tutorial/files/*/ std::ifstream textfile; /* In order to open a file with a stream object we use its member function open */ textfile.open( "MSS_Problems.txt" ); /* To check if a file stream was successful opening a file, you can do it by calling to member is_open Credit: http://www.cplusplus.com/doc/tutorial/files/*/ if( !textfile.is_open() ) { textfile.close(); std::cout << "Please add MSS_Problems.txt and try again." << std::endl; exit(1); } /* Stream class to write on files Credit: http://www.cplusplus.com/doc/tutorial/files/*/ std::ofstream textfile2; textfile2.open("MSS_Results.txt"); /* vector of vectors to store number set */ std::vector<std::vector<int>> setOfNumbers = getNumbers(textfile); textfile.close(); /* Label the results file */ textfile2 << " Algorithm 1: Enumeration \n"; std::cout << " Algorithm 1: Enumeration \n" << std::endl; /* Run enumeration algorithm on input numbers */ for( unsigned int i = 0; i < setOfNumbers.size(); i++ ) { bruteMaxSumSub(setOfNumbers.at(i), result, setOfNumbers.at(i).size()); int total = result.sum; int start = result.start; int end = result.end; /* Call function to output is to be written to MSS_Results.txt */ std::cout << total << std::endl; writeResults( textfile2, setOfNumbers.at(i), start, end, total ); } /* Label the results file */ textfile2 << " Algorithm 2: Better Enumeration \n"; std::cout << " Algorithm 2: Better Enumeration \n" << std::endl; /* Run better enumeration algorithm on input numbers */ for( unsigned int i = 0; i < setOfNumbers.size(); i++ ) { betterBruteMaxSum(setOfNumbers.at(i), result, setOfNumbers.at(i).size()); int total = result.sum; int start = result.start; int end = result.end; /* Call function to output is to be written to MSS_Results.txt */ std::cout << total << std::endl; writeResults( textfile2, setOfNumbers.at(i), start, end, total ); } /* Label the results file */ textfile2 << " Algorithm 3: Divide and Conquer \n"; std::cout << " Algorithm 3: Divide and Conquer \n" << std::endl; /* Run divide and conquer algorithm on input numbers */ for( unsigned int i = 0; i < setOfNumbers.size(); i++ ) { myResult = divideAndConquerMaxSub(setOfNumbers.at(i), 0, setOfNumbers.at(i).size()-1); int total = myResult->sum; int start = myResult->start; int end = myResult->end; /* Call function to output is to be written to MSS_Results.txt */ std::cout << total << std::endl; writeResults( textfile2, setOfNumbers.at(i), start, end, total ); //clean up delete myResult; myResult = NULL; } /* Label the results file */ textfile2 << " Algorithm 4: Linear-time \n"; std::cout << " Algorithm 4: Linear-time \n" << std::endl; for( unsigned int i = 0; i < setOfNumbers.size(); i++ ) { linearMaxSub(setOfNumbers.at(i), setOfNumbers.at(i).size(), result); int total = result.sum; int start = result.start; int end = result.end; /* Call function to output is to be written to MSS_Results.txt */ std::cout << total << std::endl; writeResults( textfile2, setOfNumbers.at(i), start, end, total ); } textfile2.close(); //clean up delete myResult; myResult = NULL; return 0; }