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;
}
