// A recursive function to find the smallest distance. The array P contains // all points sorted according to x coordinate float closestUtil(Point P[], int n) { // If there are 2 or 3 points, then use brute force if (n <= 3) return bruteForce(P, n); // Find the middle point int mid = n/2; Point midPoint = P[mid]; // Consider the vertical line passing through the middle point // calculate the smallest distance dl on left of middle point and // dr on right side float dl = closestUtil(P, mid); float dr = closestUtil(P + mid, n-mid); // Find the smaller of two distances float d = min(dl, dr); // Build an array strip[] that contains points close (closer than d) // to the line passing through the middle point Point strip[n]; int j = 0; for (int i = 0; i < n; i++) if (abs(P[i].x - midPoint.x) < d) strip[j] = P[i], j++; // Find the closest points in strip. Return the minimum of d and closest // distance is strip[] return min(d, stripClosest(strip, j, d) ); }
float ClosestPair(Point* pX, int n){ if(n <= 3) return bruteForce(pX, n); //Chia mang thanh hai phan bang nhau int mid = n/2; Point midPoint = pX[mid]; float dL = ClosestPair(pX, mid); printf("ClosestPairL %f\n", dL); float dR = ClosestPair(pX + mid,n-mid); printf("ClosestPairR %f\n", dR); float d = min(dL, dR); printf("ClosestPair %f\n", d); Point* pLR = (Point*) malloc (n * sizeof(Point)); int k = 0; for (int i = 0; i < n; ++i){ if (abs(pX[i].x - midPoint.x) <= d){ pLR[k] = pX[i]; k++; } } if (dmin > min(stripClosest(pLR, k, d), d)){ dmin = min(stripClosest(pLR, k, d), d); } return min(stripClosest(pLR, k, d), d);; }
void cal(const char *a, const char *b) { int maxLen, maxstart; maxstart = bruteForce(a, b, &maxLen); for(int i = 0; i < maxLen; i++) printf("%c", a[maxstart + i]); printf("\n"); }
std::string execute(int variation) { switch (variation) { case 0: return to_string(bruteForce()); case 1: case -1: return to_string(optimized()); default: return std::string("unavailable"); } return NULL; }
float closest(point *A,long long N,point *u,point *v) { if(N<3) { return bruteForce(A,N,u,v); } long long mid=N/2; point midPoint = A[mid]; point a,b,r,s; long long i,j; double dl = closest(A, mid,&a,&b); double dr = closest(A + mid, N-mid,&r,&s); double d = min(dl, dr); if(dl<dr) { u[0].x=a.x;u[0].y=a.y; v[0].x=b.x;v[0].y=b.y; } else { u[0].x=r.x;u[0].y=r.y; v[0].x=s.x;v[0].y=s.y; } point strip[N]; j=0; for (i = 0; i < N; i++) if (abs(A[i].x - midPoint.x) < d) { strip[j] = A[i]; j++; } // return min(d, stripClosest(strip, j, d) ); double minStrip = stripClosest(strip,j,d,&a,&b); if(d<minStrip) { return d; } else { u[0].x=a.x;u[0].y=a.y; v[0].x=b.x;v[0].y=b.y; return minStrip; } }
float closestUtil(Point P[], int n) { if (n <= 3) return bruteForce(P, n); int mid = n/2; Point midPoint = P[mid]; float dl = closestUtil(P, mid); float dr = closestUtil(P + mid, n-mid); float d = min(dl, dr); Point strip[n]; int j = 0; for (int i = 0; i < n; i++) if (abs(P[i].x - midPoint.x) < d) strip[j] = P[i], j++; return min(d, stripClosest(strip, j, d) ); }
void SudokubeSolver::solve(Sudokube& sudokube) { if(sudokube.isSolved()) { return; } if(simpleConstraintPropagation(sudokube)) { solve(sudokube); return; }else if(lastRemainingCellInARegion(sudokube)) { solve(sudokube); return; }else if(nakedPairs(sudokube)) { solve(sudokube); return; }else if(hiddenPairs(sudokube)) { solve(sudokube); return; }else if(hiddenTriples(sudokube)) { solve(sudokube); return; }else if(pointingPairs(sudokube)) { solve(sudokube); return; }else if(pointingTriples(sudokube)) { solve(sudokube); return; }else if(boxLineReductionPair(sudokube)) { solve(sudokube); return; }else if(boxLineReductionTriple(sudokube)) { solve(sudokube); return; }else { bruteForce(sudokube); return; } return; }
void testStringMatch(char * textbuffer, char * newtext, ordGrowthT horspool, ordGrowthT bruteforce, int index){ int i, hFive, hTen, hTwenty, lFive, lTen, lTwenty; string pattern; resultT result; result = (resultT)GetBlock(sizeof * result); /****EXPERIMENT************/ /**********HIGH************/ /* printf("**********************************************************\n"); printf("HORSPOOL\n\n"); printf("Patterns consisting of the 5, 10 and 20 most common letters\nin the text will be generated\neach will be shuffled and retried 50 times.\n"); */ pattern = generatePattern(5, textbuffer); for (i = 0; i < 50; i++){ result->fivepat[i] = horSpool(newtext, randomPattern(pattern)); } pattern = generatePattern(10, textbuffer); for (i = 0; i < 50; i++){ result->tenpat[i] = horSpool(newtext, randomPattern(pattern)); } pattern = generatePattern(20, textbuffer); for (i = 0; i < 50; i++){ result->twentypat[i] = horSpool(newtext, randomPattern(pattern)); } /********LOW*********/ //printf("Patterns consisting of the 5, 10 and 20 LEAST common letters\nin the text will be generated\neach will be shuffled and retried 50 times.\n"); pattern = generateLowPattern(5, textbuffer); for (i = 0; i < 50; i++){ result->lowfivepat[i] = horSpool(newtext, randomPattern(pattern)); } pattern = generateLowPattern(10, textbuffer); for (i = 0; i < 50; i++){ result->lowtenpat[i] = horSpool(newtext, randomPattern(pattern)); } pattern = generateLowPattern(20, textbuffer); for (i = 0; i < 50; i++){ result->lowtwentypat[i] = horSpool(newtext, randomPattern(pattern)); } //printf("MOST COMMON LETTERS\n"); hFive = (sumArr(result->fivepat, 50) / 50); hTen = (sumArr(result->tenpat, 50) / 50); hTwenty = (sumArr(result->twentypat, 50) / 50); /* printf("5 letters: %d\n", hFive); printf("10 letters: %d\n", hTen); printf("20 letters: %d\n", hTwenty); */ horspool->five->nComps[index] = hFive; horspool->ten->nComps[index] = hTen; horspool->twenty->nComps[index] = hTwenty; //printf("LEAST COMMON LETTERS\n"); lFive = (sumArr(result->lowfivepat, 50) / 50); lTen = (sumArr(result->lowtenpat, 50) / 50); lTwenty = (sumArr(result->lowtwentypat, 50) / 50); /* printf("5 letters: %d\n", lFive); printf("10 letters: %d\n", lTen); printf("20 letters: %d\n", lTwenty); */ horspool->lowfive->nComps[index] = lFive; horspool->lowten->nComps[index] = lTen; horspool->lowtwenty->nComps[index] = lTwenty; //printf("**********************************************************\n\n"); /****EXPERIMENT************/ /**********HIGH************/ /* printf("**********************************************************\n"); printf("BRUTEFORCE\n"); printf("Patterns consisting of the 5, 10 and 20 most common letters\nin the text will be generated\neach will be shuffled and retried 50 times.\n"); */ pattern = generatePattern(5, textbuffer); for (i = 0; i < 50; i++){ result->fivepat[i] = bruteForce(newtext, randomPattern(pattern)); } pattern = generatePattern(10, textbuffer); for (i = 0; i < 50; i++){ result->tenpat[i] = bruteForce(newtext, randomPattern(pattern)); } pattern = generatePattern(20, textbuffer); for (i = 0; i < 50; i++){ result->twentypat[i] = bruteForce(newtext, randomPattern(pattern)); } /********LOW*********/ //printf("Patterns consisting of the 5, 10 and 20 LEAST common letters\nin the text will be generated\neach will be shuffled and retried 50 times.\n"); pattern = generateLowPattern(5, textbuffer); for (i = 0; i < 50; i++){ result->lowfivepat[i] = bruteForce(newtext, randomPattern(pattern)); } pattern = generateLowPattern(10, textbuffer); for (i = 0; i < 50; i++){ result->lowtenpat[i] = bruteForce(newtext, randomPattern(pattern)); } pattern = generateLowPattern(20, textbuffer); for (i = 0; i < 50; i++){ result->lowtwentypat[i] = bruteForce(newtext, randomPattern(pattern)); } //printf("MOST COMMON LETTERS\n"); hFive = (sumArr(result->fivepat, 50) / 50); hTen = (sumArr(result->tenpat, 50) / 50); hTwenty = (sumArr(result->twentypat, 50) / 50); /* printf("5 letters: %d\n", hFive); printf("10 letters: %d\n", hTen); printf("20 letters: %d\n", hTwenty); */ bruteforce->five->nComps[index] = hFive; bruteforce->ten->nComps[index] = hTen; bruteforce->twenty->nComps[index] = hTwenty; //printf("LEAST COMMON LETTERS\n"); lFive = (sumArr(result->lowfivepat, 50) / 50); lTen = (sumArr(result->lowtenpat, 50) / 50); lTwenty = (sumArr(result->lowtwentypat, 50) / 50); /* printf("5 letters: %d\n", lFive); printf("10 letters: %d\n", lTen); printf("20 letters: %d\n", lTwenty); */ bruteforce->lowfive->nComps[index] = lFive; bruteforce->lowten->nComps[index] = lTen; bruteforce->lowtwenty->nComps[index] = lTwenty; }
int main(int argc, char* argv[]) { if (argc < 3)//cmd line arguments { std::cout << "Error! Error!" << std::endl; std::cout << "Argument 1 is the program name" << std::endl; std::cout << "Argument 2 is input file for greedy and dynamic programming algorithms." << std::endl; std::cout << "Argument 3 is input file for brute force algorithm" << std::endl; return 1; } //Hold input and output file names std::string input_filename;//Holds filename of first input file. std::string output_filename;//Holds filename of first output file. std::string input_filename2;//Holds filename of second input file. std::string output_filename2;//Holds filename of second output file. //Modify first output file name input_filename = argv[1];//Getting the first input filename via command line output_filename = input_filename;//Getting name for first output file output_filename.erase(output_filename.end() - 4, output_filename.end() - 0);//remove .txt from filename output_filename.append("change.txt");//appending change.txt to output_filename //Modify second output file name input_filename2 = argv[2];//Getting the second input filename via command line output_filename2 = input_filename2;//Getting name for second output file output_filename2.erase(output_filename2.end() - 4, output_filename2.end() - 0);//remove .txt from filename output_filename2.append("change.txt");//appending change.txt to output_filename std::cout << "1st INPUT FILE " << input_filename << std::endl; std::cout << "1st OUTPUT FILE " << output_filename << std::endl; std::cout << std::endl; std::cout << "2nd INPUT FILE " << input_filename2 << std::endl; std::cout << "2nd OUTPUT FILE " << output_filename2 << std::endl; std::cout << std::endl; std::string inputFile = input_filename;//first Input file name. std::ifstream if_inputStream;//input stream for first input file. std::string inputFile2 = input_filename2;//second Input file name. std::ifstream if_inputStream2;//input stream for second input file. //For first input file std::string tempFile = "temp.txt";//temp file name. std::fstream f_tempStream;//temp stream for temp file. //For second input file std::string tempFile2 = "temp2.txt";//temp2 file name. std::fstream f_tempStream2;//temp2 stream for temp file. std::string outputFile = output_filename;//first output file name. std::ofstream outputStream;//first output stream for output file. std::string outputFile2 = output_filename2;//second output file name. std::ofstream outputStream2;//second output stream for output file. output_file_check(outputStream, output_filename);//Checks if first output file is opened. output_file_check(outputStream2, output_filename2);//Checks if second output file is opened. if_file_check(if_inputStream, inputFile);//Checks to see if first input file is opened. if_file_check(if_inputStream2, inputFile2);//Checks to see if second input file is opened. f_file_check(f_tempStream, tempFile);//Check if temp file is opened f_file_check(f_tempStream2, tempFile2);//Check if temp2 file is opened std::vector<int> relay;// Holds values from array in first input file. std::vector<int> relay2;// Holds values from array in second input file. std::vector<int> coins;// Coins to calculate value from first input file. std::vector<int> coins2;// Coins to calculate value from second input file. int value;// Value to find with coins from first input file. int value2;// Value to find with coins from second input file. int arrayCount = 0;//Number of arrays in first input file. int arrayCount2 = 0;//Number of arrays in second input file. double time = 0; //Holds time for each array to be processed, used for greedy and DP algorithm run time double greedyTotalTime = 0;//Total run time for greedy algorithm double dpTotalTime = 0;//Total run time for DP algorithm //Variables used for brute force algorithm coinChange answer;//Keeps track of number of each coin used answer.num = 0; int minCoin;//Keeps track of total coins used. std::vector<int> storeCoin;//Vector to hold amount of each coin used. double bruteForceTotalTime = 0;//Total run time for brute force algorithm clock_t start, stop;//Used for calculating run time for brute force algorithm. //Strip first input file strip_file(if_inputStream, f_tempStream); //stripping first input file of [] and , arrayCount = numofArrays(f_tempStream, tempFile);//Get count of number of arrays in first file. //Strip second input file strip_file(if_inputStream2, f_tempStream2); //stripping second input file of [] and , arrayCount2 = numofArrays(f_tempStream2, tempFile2);//Get count of number of arrays in second file. //Iterate through the first input file for each array. Runs Greedy and DP algorithms for (int i = 1; i <= arrayCount + 1; i++) { //First input file relay = lineToVector(f_tempStream, tempFile, relay, i);//Populates relay vector with values. if (i % 2 != 0) { coins = relay;//Set coins vector equal to relay. relay.clear();//Clears the relay vector of all values. } else { value = relay[0];//Set value to the only index with a value in relay /***************************GREEDY ALGORITHM**********************************/ //time = name_for_greedy_algorithm_function(outputStream, coins, value); //greedyTotalTime += time; //time = 03 /***************************DP ALGORITHM**************************************/ //time = name_for_dp_algorithm_function(outputStream, coins, value); //dpTotalTime += time; //time = 0; relay.clear();//Clears the relay vector of all values. coins.clear();//Reset coins vector value = 0;//Reset value } } //Iterate through the second input file for each array. Runs brute force algorithm for (int i = 1; i <= arrayCount2 + 1; i++) { //Reset timers; start = 0; stop = 0; //Second input file relay2 = lineToVector(f_tempStream2, tempFile2, relay2, i);//Populates relay vector with values. if (i % 2 != 0) { coins2 = relay2;//Set coins vector equal to relay. relay2.clear();//Clears the relay vector of all values. } else { value2 = relay2[0];//Set value to the only index with a value in relay int arraySize2 = coins2.size(); start = clock();//Start timer answer = bruteForce(coins2, value2, arraySize2); stop = clock();//stop timer bruteForceTotalTime += (stop - start) / double(CLOCKS_PER_SEC); storeCoin.resize(arraySize2);//Sets the size of the amount of coins vector for (int i = 0; i < arraySize2; i++) { storeCoin[i] = answer.coinCount[i]; } minCoin = arraySum(answer.coinCount, arraySize2); outputStream2 << "Brute Force Algorithm" << std::endl; outputStream2 << "["; for (int i = 0; i < arraySize2; i++) { if (i < (arraySize2 - 1)) { outputStream2 << storeCoin[i] << ", "; } else { outputStream2 << storeCoin[i]; } } outputStream2 << "]"; outputStream2 << '\r' << '\n'; outputStream2 << minCoin << std::endl; outputStream2 << '\r' << '\n'; outputStream2 << '\r' << '\n'; relay2.clear();//Clears the relay vector of all values. coins2.clear();//Reset coins vector value2 = 0;//Reset value } } std::cout << "Alg1: Brute Force Run-time is: " << bruteForceTotalTime << std::endl; std::cout << "Alg2: Greedy Run-time is: " << greedyTotalTime << std::endl; std::cout << "Alg3: Dynamic Programming Run-time is: " << dpTotalTime << std::endl; //Closing file streams if_inputStream.close(); if_inputStream2.close(); f_tempStream.close(); f_tempStream2.close(); outputStream.close(); outputStream2.close(); return 0; };//end main
static void testQuadAngles(skiatest::Reporter* reporter, const SkDQuad& quad1, const SkDQuad& quad2, int testNo, SkChunkAlloc* allocator) { SkPoint shortQuads[2][3]; SkOpContour contour; SkOpGlobalState state(NULL PATH_OPS_DEBUG_PARAMS(&contour)); contour.init(&state, false, false); makeSegment(&contour, quad1, shortQuads[0], allocator); makeSegment(&contour, quad1, shortQuads[1], allocator); SkOpSegment* seg1 = contour.first(); seg1->debugAddAngle(0, 1, allocator); SkOpSegment* seg2 = seg1->next(); seg2->debugAddAngle(0, 1, allocator); int realOverlap = PathOpsAngleTester::ConvexHullOverlaps(*seg1->debugLastAngle(), *seg2->debugLastAngle()); const SkDPoint& origin = quad1[0]; REPORTER_ASSERT(reporter, origin == quad2[0]); double a1s = atan2(origin.fY - quad1[1].fY, quad1[1].fX - origin.fX); double a1e = atan2(origin.fY - quad1[2].fY, quad1[2].fX - origin.fX); double a2s = atan2(origin.fY - quad2[1].fY, quad2[1].fX - origin.fX); double a2e = atan2(origin.fY - quad2[2].fY, quad2[2].fX - origin.fX); bool oldSchoolOverlap = radianBetween(a1s, a2s, a1e) || radianBetween(a1s, a2e, a1e) || radianBetween(a2s, a1s, a2e) || radianBetween(a2s, a1e, a2e); int overlap = quadHullsOverlap(reporter, quad1, quad2); bool realMatchesOverlap = realOverlap == overlap || SK_ScalarPI - fabs(a2s - a1s) < 0.002; if (realOverlap != overlap) { SkDebugf("\nSK_ScalarPI - fabs(a2s - a1s) = %1.9g\n", SK_ScalarPI - fabs(a2s - a1s)); } if (!realMatchesOverlap) { DumpQ(quad1, quad2, testNo); } REPORTER_ASSERT(reporter, realMatchesOverlap); if (oldSchoolOverlap != (overlap < 0)) { overlap = quadHullsOverlap(reporter, quad1, quad2); // set a breakpoint and debug if assert fires REPORTER_ASSERT(reporter, oldSchoolOverlap == (overlap < 0)); } SkDVector v1s = quad1[1] - quad1[0]; SkDVector v1e = quad1[2] - quad1[0]; SkDVector v2s = quad2[1] - quad2[0]; SkDVector v2e = quad2[2] - quad2[0]; double vDir[2] = { v1s.cross(v1e), v2s.cross(v2e) }; bool ray1In2 = v1s.cross(v2s) * vDir[1] <= 0 && v1s.cross(v2e) * vDir[1] >= 0; bool ray2In1 = v2s.cross(v1s) * vDir[0] <= 0 && v2s.cross(v1e) * vDir[0] >= 0; if (overlap >= 0) { // verify that hulls really don't overlap REPORTER_ASSERT(reporter, !ray1In2); REPORTER_ASSERT(reporter, !ray2In1); bool ctrl1In2 = v1e.cross(v2s) * vDir[1] <= 0 && v1e.cross(v2e) * vDir[1] >= 0; REPORTER_ASSERT(reporter, !ctrl1In2); bool ctrl2In1 = v2e.cross(v1s) * vDir[0] <= 0 && v2e.cross(v1e) * vDir[0] >= 0; REPORTER_ASSERT(reporter, !ctrl2In1); // check answer against reference bruteForce(reporter, quad1, quad2, overlap > 0); } // continue end point rays and see if they intersect the opposite curve SkDLine rays[] = {{{origin, quad2[2]}}, {{origin, quad1[2]}}}; const SkDQuad* quads[] = {&quad1, &quad2}; SkDVector midSpokes[2]; SkIntersections intersect[2]; double minX, minY, maxX, maxY; minX = minY = SK_ScalarInfinity; maxX = maxY = -SK_ScalarInfinity; double maxWidth = 0; bool useIntersect = false; double smallestTs[] = {1, 1}; for (unsigned index = 0; index < SK_ARRAY_COUNT(quads); ++index) { const SkDQuad& q = *quads[index]; midSpokes[index] = q.ptAtT(0.5) - origin; minX = SkTMin(SkTMin(SkTMin(minX, origin.fX), q[1].fX), q[2].fX); minY = SkTMin(SkTMin(SkTMin(minY, origin.fY), q[1].fY), q[2].fY); maxX = SkTMax(SkTMax(SkTMax(maxX, origin.fX), q[1].fX), q[2].fX); maxY = SkTMax(SkTMax(SkTMax(maxY, origin.fY), q[1].fY), q[2].fY); maxWidth = SkTMax(maxWidth, SkTMax(maxX - minX, maxY - minY)); intersect[index].intersectRay(q, rays[index]); const SkIntersections& i = intersect[index]; REPORTER_ASSERT(reporter, i.used() >= 1); bool foundZero = false; double smallT = 1; for (int idx2 = 0; idx2 < i.used(); ++idx2) { double t = i[0][idx2]; if (t == 0) { foundZero = true; continue; } if (smallT > t) { smallT = t; } } REPORTER_ASSERT(reporter, foundZero == true); if (smallT == 1) { continue; } SkDVector ray = q.ptAtT(smallT) - origin; SkDVector end = rays[index][1] - origin; if (ray.fX * end.fX < 0 || ray.fY * end.fY < 0) { continue; } double rayDist = ray.length(); double endDist = end.length(); double delta = fabs(rayDist - endDist) / maxWidth; if (delta > 1e-4) { useIntersect ^= true; } smallestTs[index] = smallT; } bool firstInside; if (useIntersect) { int sIndex = (int) (smallestTs[1] < 1); REPORTER_ASSERT(reporter, smallestTs[sIndex ^ 1] == 1); double t = smallestTs[sIndex]; const SkDQuad& q = *quads[sIndex]; SkDVector ray = q.ptAtT(t) - origin; SkDVector end = rays[sIndex][1] - origin; double rayDist = ray.length(); double endDist = end.length(); SkDVector mid = q.ptAtT(t / 2) - origin; double midXray = mid.crossCheck(ray); if (gPathOpsAngleIdeasVerbose) { SkDebugf("rayDist>endDist:%d sIndex==0:%d vDir[sIndex]<0:%d midXray<0:%d\n", rayDist > endDist, sIndex == 0, vDir[sIndex] < 0, midXray < 0); } SkASSERT(SkScalarSignAsInt(SkDoubleToScalar(midXray)) == SkScalarSignAsInt(SkDoubleToScalar(vDir[sIndex]))); firstInside = (rayDist > endDist) ^ (sIndex == 0) ^ (vDir[sIndex] < 0); } else if (overlap >= 0) { return; // answer has already been determined } else { firstInside = checkParallel(reporter, quad1, quad2); } if (overlap < 0) { SkDEBUGCODE(int realEnds =) PathOpsAngleTester::EndsIntersect(*seg1->debugLastAngle(), *seg2->debugLastAngle()); SkASSERT(realEnds == (firstInside ? 1 : 0)); }
void* workerX(void *arg) { int output56BitKey[56]; int result = 0; struct worker_inputs *input=arg; printf("\n Worker : %d\n",input->workerid); //printf("\n start : %d\n",input->start); //printf("\n end : %d\n",input->end); result = bruteForce(plainText64Bit,cipher64Bit, input->start,input->end,output56BitKey,input->workerid); if(result == 1) { printf("\n---------- Worker %d found the key--------------->\n",input->workerid); printArray(output56BitKey,56,"KEY FOUND"); if(isMaster == 1) { //MASTER - IFOUNDIT char ipAddress[16]; char* message="MASTER - IFOUNDIT"; memset(ipAddress,'\0',sizeof(ipAddress)); strcpy(ipAddress, clientIPAddress[1]); messageSender(ipAddress, message); memset(ipAddress,'\0',sizeof(ipAddress)); strcpy(ipAddress, clientIPAddress[2]); messageSender(ipAddress, message); memset(ipAddress,'\0',sizeof(ipAddress)); strcpy(ipAddress, clientIPAddress[3]); messageSender(ipAddress, message); memset(ipAddress,'\0',sizeof(ipAddress)); strcpy(ipAddress, clientIPAddress[4]); messageSender(ipAddress, message); memset(ipAddress,'\0',sizeof(ipAddress)); strcpy(ipAddress, clientIPAddress[5]); messageSender(ipAddress, message); memset(ipAddress,'\0',sizeof(ipAddress)); strcpy(ipAddress, clientIPAddress[6]); messageSender(ipAddress, message); //MASTER - STOP message="MASTER - STOP"; memset(ipAddress,'\0',sizeof(ipAddress)); strcpy(ipAddress, clientIPAddress[1]); messageSender(ipAddress, message); memset(ipAddress,'\0',sizeof(ipAddress)); strcpy(ipAddress, clientIPAddress[2]); messageSender(ipAddress, message); memset(ipAddress,'\0',sizeof(ipAddress)); strcpy(ipAddress, clientIPAddress[3]); messageSender(ipAddress, message); memset(ipAddress,'\0',sizeof(ipAddress)); strcpy(ipAddress, clientIPAddress[4]); messageSender(ipAddress, message); memset(ipAddress,'\0',sizeof(ipAddress)); strcpy(ipAddress, clientIPAddress[5]); messageSender(ipAddress, message); memset(ipAddress,'\0',sizeof(ipAddress)); strcpy(ipAddress, clientIPAddress[6]); messageSender(ipAddress, message); exit(0); } else { char message[1024]; char array[57]; char workerName[56]; //int g=0,h=0; memset(message,0x0,(sizeof(char)*1024)); memset(workerName,0x0,(sizeof(char)*56)); memset(array,0x0,(sizeof(char)*57)); strcpy(message,"CLIENT - IFOUNDIT Key : "); // //24 char filled. // for(g=24,h=0;h<56;g++,h++) // { // message[g] = output56BitKey[h]; // } sprintf(array,"%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d" ,output56BitKey[0],output56BitKey[1],output56BitKey[2],output56BitKey[3],output56BitKey[4], output56BitKey[5],output56BitKey[6],output56BitKey[7],output56BitKey[8],output56BitKey[9], output56BitKey[10],output56BitKey[11],output56BitKey[12],output56BitKey[13],output56BitKey[14], output56BitKey[15],output56BitKey[16],output56BitKey[17],output56BitKey[18],output56BitKey[19], output56BitKey[20],output56BitKey[21],output56BitKey[22],output56BitKey[23],output56BitKey[24], output56BitKey[25],output56BitKey[26],output56BitKey[27],output56BitKey[28],output56BitKey[29], output56BitKey[30],output56BitKey[31],output56BitKey[32],output56BitKey[33],output56BitKey[34], output56BitKey[35],output56BitKey[36],output56BitKey[37],output56BitKey[38],output56BitKey[39], output56BitKey[40],output56BitKey[41],output56BitKey[42],output56BitKey[43],output56BitKey[44], output56BitKey[45],output56BitKey[46],output56BitKey[47],output56BitKey[48],output56BitKey[49], output56BitKey[50],output56BitKey[51],output56BitKey[52],output56BitKey[53],output56BitKey[54], output56BitKey[55]); sprintf(workerName, " by Worker %d", input->workerid); strcat(message,array); strcat(message,workerName); printf("\n Send message to the Master that I found the key.\n"); printf("\n Send the message to Master IP : %s \n",masterIPAddress); printf("\n Send the message : %s \n",message); messageSender(masterIPAddress, message); printf("\n Returned from messageSender\n"); } } while(1) { //printf("\nWorker %d done brute forcing. Idling.\n",input->workerid); sleep(1); } return (0); }