int getAndRemoveFirstDigit(intmax_t *input) { int tmp = *input; if (tmp < 10) { *input = NULL; return tmp; } else { tmp = (int) (tmp / (intmax_t) pow(10,(countDigits(tmp) - 1))); *input = *input - tmp * pow(10,(countDigits(*input) - 1)); return tmp; } }
int isSatisfyingCondition(long long int n) { int *arr,len,start,end,counter; long long int n1,n2,i; len=countDigits(n); arr=(int*)malloc(sizeof(int)*len); arr=formArray(n); bubbleSortDescending(arr,len); n2=formNumber(arr,len); bubbleSortAscending(arr,len); n1=formNumber(arr,len); free(arr); start=(int)pow(n1,1/3.0); start--; end=(int)pow(n2,1/3.0); end++; counter=0; for(i=start;i<=end;i++) { if(containsSameDigits(i*i*i,n) && isPerfectCube(i*i*i)) { printf("%lld\n",(i*i*i)); counter++; } } if(counter==5) return 1; return 0; }
int main() { int num = 3748; printf("Ingresa un numero: "); scanf("%d", &num); printf("El numero: %d tiene %d digitos.\n", num, countDigits(num)); printf("El numero: %d sus numeros suman: %d\n", num, sumDigits(num)); return 0; }
bool DateComponents::parseTime(const String& src, unsigned start, unsigned& end) { int hour; if (!toInt(src, start, 2, hour) || hour < 0 || hour > 23) return false; unsigned index = start + 2; if (index >= src.length()) return false; if (src[index] != ':') return false; ++index; int minute; if (!toInt(src, index, 2, minute) || minute < 0 || minute > 59) return false; index += 2; int second = 0; int millisecond = 0; // Optional second part. // Do not return with false because the part is optional. if (index + 2 < src.length() && src[index] == ':') { if (toInt(src, index + 1, 2, second) && second >= 0 && second <= 59) { index += 3; // Optional fractional second part. if (index < src.length() && src[index] == '.') { unsigned digitsLength = countDigits(src, index + 1); if (digitsLength > 0) { ++index; bool ok; if (digitsLength == 1) { ok = toInt(src, index, 1, millisecond); millisecond *= 100; } else if (digitsLength == 2) { ok = toInt(src, index, 2, millisecond); millisecond *= 10; } else { // digitsLength >= 3 ok = toInt(src, index, 3, millisecond); } DCHECK(ok); index += digitsLength; } } } } m_hour = hour; m_minute = minute; m_second = second; m_millisecond = millisecond; end = index; m_type = Time; return true; }
char* intToCharTable(intmax_t input){ int iter = countDigits(input); char result[iter]; for(int i = 0; i < iter; i++) { result[iter-i-1] = input % 10; input /= 10; } return result; }
int *formArray(long long int n) { int len,*arr,i; len=countDigits(n); arr=(int*)malloc(sizeof(int)*len); for(i=len-1;i>=0;i--) { arr[i]=n%10; n/=10; } return arr; }
bool validLastTwoNumbers(int initNumber, int lastLength, int nextToLastLength) { int number = initNumber; int last = cutLastDigits(number, lastLength), nextToLast = cutLastDigits(number, nextToLastLength); while (number != 0) { int expectedNext = last - nextToLast; if (countDigits(number) < countDigits(expectedNext)) { return false; } else { int actualNext = cutLastDigits(number, countDigits(expectedNext)); if (expectedNext != actualNext) { return false; } } last = nextToLast; nextToLast = expectedNext; } return true; }
bool DateComponents::parseYear(const String& src, unsigned start, unsigned& end) { unsigned digitsLength = countDigits(src, start); // Needs at least 4 digits according to the standard. if (digitsLength < 4) return false; int year; if (!toInt(src, start, digitsLength, year)) return false; if (year < minimumYear() || year > maximumYear()) return false; m_year = year; end = start + digitsLength; return true; }
bool isAggregated(int number) { if (number <= 0) { return false; } int nDigits = countDigits(number); for (int i = 1 ; i <= nDigits / 2 ; ++i) { for (int j = 1 ; (i + j) <= nDigits - 1 ; ++j) { if (validLastTwoNumbers(number, i, j)) { return true; } } } return false; }
// processing lines with mismatches int extractMismatches(string reads, string baseQuals, int cov, string transcriptID, string mispos, string refbase, int qualThreshold, int &seqCount) { string correctedReads; string skip; int start = 0, end = 0, i = 0; char readPos; int current = 0; while (i < reads.length()) { readPos = reads.at(i); if (reads[i] == '+' || reads[i] == '-') { i ++ ; current = 0; while (isdigit(reads.at(i))) { current += current * 10 + (reads[i]-'0'); i++; } i += current - countDigits(current) ; } else if (readPos == '^') { i ++; start = 1; } else if (readPos == '$') { end = 1; } else { correctedReads.push_back(reads[i]); } i++; } assert (correctedReads.size() == cov); seqCount ++; if (seqCount > 1 && seqCount % 10000 == 0) { cerr << "Processed " << seqCount << " alignments" <<endl; } printingTable(transcriptID, mispos, refbase, correctedReads, cov, baseQuals,start,end, qualThreshold); return 0; }
/* Format a command according to the Redis protocol using an sds string and * sdscatfmt for the processing of arguments. This function takes the * number of arguments, an array with arguments and an array with their * lengths. If the latter is set to NULL, strlen will be used to compute the * argument lengths. */ int redisFormatSdsCommandArgv(sds *target, int argc, const char **argv, const size_t *argvlen) { sds cmd; unsigned long long totlen; int j; size_t len; /* Abort on a NULL target */ if (target == NULL) return -1; /* Calculate our total size */ totlen = 1+countDigits(argc)+2; for (j = 0; j < argc; j++) { len = argvlen ? argvlen[j] : strlen(argv[j]); totlen += bulklen(len); } /* Use an SDS string for command construction */ cmd = sdsempty(); if (cmd == NULL) return -1; /* We already know how much storage we need */ cmd = sdsMakeRoomFor(cmd, totlen); if (cmd == NULL) return -1; /* Construct command */ cmd = sdscatfmt(cmd, "*%i\r\n", argc); for (j=0; j < argc; j++) { len = argvlen ? argvlen[j] : strlen(argv[j]); cmd = sdscatfmt(cmd, "$%T\r\n", len); cmd = sdscatlen(cmd, argv[j], len); cmd = sdscatlen(cmd, "\r\n", sizeof("\r\n")-1); } assert(sdslen(cmd)==totlen); *target = cmd; return totlen; }
int main() { int max=0, max_palindrome=0; for (int i=999;i;--i) { for (int j=999;j;--j) { int candidate = i*j; int len = countDigits(candidate); if ((isPalindrome(candidate,len)) && (len >= max) && (candidate > max_palindrome)) { max = len; max_palindrome = candidate; } } } std::cout << max_palindrome << std::endl; }
int count(int n) { int ndigits = countDigits(n), n2s = 0, pow10 = 1; for (int i = 0 ; i < ndigits ; ++i) { n2s += pow10 * (n / (pow10 * 10)); int remainder = n % (pow10 * 10); if (remainder / pow10 > 2) { n2s += pow10; } else if (remainder / pow10 == 2) { n2s += (remainder % pow10 + 1); } pow10 *= 10; } return n2s; }
char *getDivide(long dividend, long divisor, unsigned long decimalPlace) { long a,b,c,d; bool h=false; bool r=false; long f=1; char *s = malloc(decimalPlace+countDigits(dividend/divisor)+2); while (dividend < divisor) { if (!r) { sprintf(s,"0."); h = r = true; } else { sprintf(s,"0"); dividend = dividend * 10; f++; } } a = dividend / divisor; if (!h) sprintf(s,"%ld.",a); else { sprintf(s,"%ld",a); f++; } b = dividend % divisor; while (f <= decimalPlace) { c = b * 10; while((c < divisor) && (f < decimalPlace)) { c = c * 10; sprintf(s,"0"); f++; } d = c / divisor; sprintf(s,"%ld",d); b = c % divisor; f++; } return s; }
/* Format a command according to the Redis protocol. This function takes the * number of arguments, an array with arguments and an array with their * lengths. If the latter is set to NULL, strlen will be used to compute the * argument lengths. */ int redisFormatCommandArgv(char **target, int argc, const char **argv, const size_t *argvlen) { char *cmd = NULL; /* final command */ int pos; /* position in final command */ size_t len; int totlen, j; /* Abort on a NULL target */ if (target == NULL) return -1; /* Calculate number of bytes needed for the command */ totlen = 1+countDigits(argc)+2; for (j = 0; j < argc; j++) { len = argvlen ? argvlen[j] : strlen(argv[j]); totlen += bulklen(len); } /* Build the command at protocol level */ cmd = malloc(totlen+1); if (cmd == NULL) return -1; pos = sprintf(cmd,"*%d\r\n",argc); for (j = 0; j < argc; j++) { len = argvlen ? argvlen[j] : strlen(argv[j]); pos += sprintf(cmd+pos,"$%zu\r\n",len); memcpy(cmd+pos,argv[j],len); pos += len; cmd[pos++] = '\r'; cmd[pos++] = '\n'; } assert(pos == totlen); cmd[pos] = '\0'; *target = cmd; return totlen; }
_Bool writePid(intmax_t inputPid, int desc){ intmax_t buffSize = 32768, fileLength = 0; int descriptor = desc; if (descriptor < 0) { printf("Open Err\n"); return false; } char *buf = malloc(buffSize); int tmp = 0; buffSize =countDigits(inputPid) + 1; buf = realloc(buf, buffSize * sizeof(char)); char *pidTmp = intToCharTable(inputPid); int pidTmpSize = sizeof(pidTmp) / sizeof(pidTmp[0]); for (int i = 0; i < pidTmpSize; i ++) buf[i] = (char) pidTmp[i] + '0'; buf[buffSize - 1] = (char) '\n'; if(write(descriptor, buf, buffSize) == -1) { printf("Write Err\n"); return false; } if(close(descriptor)) { printf("Close Err\n"); return false; } return true; }
int concat(int a,int b){ int digits=countDigits(b); a*=pow(10,digits); a+=b; return a; }
Grid<double> createRandomMaze(int size) { Grid<double> maze(size, size, kMazeFloor); BasicGraph* graph = gridToGraph(maze, mazeCost); // assign random weights to the edges // give each edge a 'random' weight; // put all edges into a priority queue, sorted by weight Set<Edge*> edgeSet = graph->getEdgeSet(); int edgeCount = edgeSet.size(); for (Edge* edge : edgeSet) { int weight = randomInteger(1, edgeCount * 1000); edge->cost = weight; } // run the student's Kruskal algorithm to get a minimum spanning tree (MST) Set<Edge*> mst = kruskal(*graph); // convert the MST/graph back into a maze grid // (insert a 'wall' between any neighbors that do not have a connecting edge) graph->clearEdges(); for (Edge* edge : mst) { graph->addEdge(edge->start, edge->finish); graph->addEdge(edge->finish, edge->start); } // physical <-> logical size; a maze of size MxN has 2M-1 x 2N-1 grid cells. // cells in row/col 0, 2, 4, ... are open squares (floors), and cells in // row/col 1, 3, 5, ... are blocked (walls). int digits = countDigits(size); int worldSize = size * 2 - 1; Grid<double> world(worldSize, worldSize, kMazeWall); for (int row = 0; row < worldSize; row++) { for (int col = 0; col < worldSize; col++) { if (row % 2 == 0 && col % 2 == 0) { world[row][col] = kMazeFloor; } } } for (int row = 0; row < size; row++) { int gridRow = row * 2; for (int col = 0; col < size; col++) { int gridCol = col * 2; string name = vertexName(row, col, digits); // decide whether to put open floor between neighbors // (if there is an edge between them) for (int dr = -1; dr <= 1; dr++) { int nr = row + dr; int gridNr = gridRow + dr; for (int dc = -1; dc <= 1; dc++) { int nc = col + dc; int gridNc = gridCol + dc; if ((nr != row && nc != col) || (nr == row && nc == col) || !world.inBounds(gridNr, gridNc)) { continue; } string neighborName = vertexName(nr, nc, digits); if (graph->containsEdge(name, neighborName)) { world[gridNr][gridNc] = kMazeFloor; } } } } } delete graph; return world; }
int main(void) { long long cardNum; int currProduct; int currTotal = 0; int digits; //prompt user to enter a credit card printf("Please Enter Your Card Number\n"); cardNum = GetLongLong(); //lets count the number of digits digits = countDigits(cardNum); //printf("%d count \n", digits); if(digits == 13 || digits == 15 || digits == 16) { //lets check validity int last = 1; char* card_string = calloc(digits, sizeof(char)); //use this to loop through above array int pos = digits; //multiply every other number by two while (cardNum > 0) { int currDigit = cardNum % 10; card_string[pos] = (char)currDigit; pos --; //this means we are at the last and we can use this as an interval for the next iteration if(last == 0) { currProduct = currDigit * 2; //run this loop again to get the digits of the result while(currProduct > 0 ) { int currInnerDigit = currProduct % 10; currTotal += currInnerDigit; //get the next inner digit currProduct /= 10; } //switch indicator for next iteration last = 1; } else { //add to the total since we didnt multiply it by e currTotal += currDigit; //switch the indicator of positions last = 0; } //get the next digit cardNum /= 10; } int validity = currTotal % 10; // convert card num to string //sprintf(card_string, "%llu", cardNum); //ltoa(cardNum,card_string,10); printf("Card String %s\n", card_string); if(validity != 0) { printf("INVALID\n"); } else { //check the number of digits to show you card type check valid cart prefixes if ( digits == 15 ) { if(startsWith("34", card_string) || startsWith("37", card_string)) { printf("AMEX\n"); } else { printf("INVALID\n"); } } else if ( digits == 16 ) { if (startsWith("51", card_string) || startsWith("52", card_string) || startsWith("53", card_string) || startsWith("54", card_string) || startsWith("55", card_string)) { printf("MASTERCARD\n"); } else if (startsWith("4", card_string)) { printf("VISA\n"); } else { printf("INVALID\n"); } } else if (startsWith("4", card_string) ) { printf("VISA\n"); } else { printf("INVALID\n"); } } } else { printf("INVALID\n"); } return 0; }
string vertexName(int r, int c, const Grid<double>& world) { // zero-pad the number of rows/cols for better alphabetic sorting int rowCols = max(world.numRows(), world.numCols()); return vertexName(r, c, countDigits(rowCols)); }
static void onlineClusterKNN_cluster(t_onlineClusterKNN *x, t_symbol *s, int argc, t_atom *argv) { int i, j, k, instanceIdx, listLength; float min_dist,dist; instanceIdx = x->numInstances; listLength = argc; //s=s; // to get rid of 'unused variable' warning //post("list length: %i", listLength); if((x->featureLength>0) && (x->featureLength != listLength)) { post("received list of length %i and expected %i", listLength, x->featureLength); return; } x->instances = (t_instance *)t_resizebytes_(x->instances, x->numInstances * sizeof(t_instance), (x->numInstances+1) * sizeof(t_instance)); x->instanceFeatureLengths = (int *)t_resizebytes_(x->instanceFeatureLengths, x->numInstances * sizeof(int), (x->numInstances+1) * sizeof(int)); x->instanceFeatureLengths[instanceIdx] = listLength; x->instances[instanceIdx].instance = (float *)t_getbytes_(listLength * sizeof(float)); x->numInstances++; //post("no. of instances: %i", x->numInstances); //get the data for(i=0; i<listLength; i++) x->instances[instanceIdx].instance[i] = atom_getfloat(argv+i); //test if received element is zeros vector if (test_zero(x->instances[instanceIdx].instance,listLength) == 0) { //post("instance cannot be zeros vector"); //rollback t_freebytes_(x->instances[instanceIdx].instance, x->instanceFeatureLengths[instanceIdx]*sizeof(float)); x->instances = (t_instance *)t_resizebytes_(x->instances, x->numInstances * sizeof(t_instance), (x->numInstances-1) * sizeof(t_instance)); x->instanceFeatureLengths = (int *)t_resizebytes_(x->instanceFeatureLengths, x->numInstances * sizeof(int), (x->numInstances-1) * sizeof(int)); x->numInstances--; } else { if(instanceIdx == 0) { x->featureInput = (float *)t_resizebytes_(x->featureInput, x->featureLength * sizeof(float), listLength * sizeof(float)); x->featureLength = listLength; x->num = (int *)t_resizebytes_(x->num, 0 * sizeof(int), x->numClusters * sizeof(int)); // initialize means randomly for each cluster for(i=0; i<x->numClusters; i++) { x->means = (t_instance *)t_resizebytes_(x->means, i * sizeof(t_instance), (i+1) * sizeof(t_instance)); x->means[i].instance = (float *)t_getbytes_(listLength * sizeof(float)); if (x->randomFlag == 1) { for(j=0; j<listLength; j++) { srand(i*j+i+j+1); x->means[i].instance[j] = (float)rand()/(float)RAND_MAX; } } } // initialize number of instances for each cluster for(i=0; i<x->numClusters; i++) x->num[i] = 0; }; //normalize the data to be 0-1 for(i=0; i<listLength; i++) if (x->instances[instanceIdx].instance[i]>1) { x->instances[instanceIdx].instance[i] = x->instances[instanceIdx].instance[i] * pow(10,-countDigits((int)(x->instances[instanceIdx].instance[i]))); } //////////////ONLINE CLUSTERING //initialize means with the first instances if random==0 if ((x->randomFlag == 0) && (instanceIdx < x->numClusters)) { for(j=0; j<listLength; j++) { x->means[instanceIdx].instance[j] = x->instances[instanceIdx].instance[j]; } x->instances[instanceIdx].cluster = instanceIdx; x->num[instanceIdx] = 1; } else { //compute distances to the means and determine the closest cluster min_dist = 99999999; k = -1; for(i=0; i<x->numClusters; i++) { dist = squared_euclid(x->means[i].instance,x->instances[instanceIdx].instance,listLength); //post("%6.20f", dist); if (dist < min_dist) { min_dist = dist; k = i; } } //add the new instance to the found cluster //post("cluster %i", k); if (k != -1) { x->num[k] = x->num[k] + 1; compute_mean(x, k, x->instances[instanceIdx]); x->instances[instanceIdx].cluster = k; } } outlet_int(x->id, x->instances[instanceIdx].cluster); } }
void WorldMaze::createRandomMaze(WorldSize size) { clearSelection(/* redraw */ false); int rowsCols = getRowsCols(size) / 2 + 1; worldGrid.resize(rowsCols, rowsCols); worldGrid.fill(MAZE_FLOOR); graph = gridToGraph(worldGrid); // assign random weights to the edges // give each edge a 'random' weight; // put all edges into a priority queue, sorted by weight Set<Edge*> edgeSet = graph->getEdgeSet(); int edgeCount = edgeSet.size(); for (Edge* edge : edgeSet) { int weight = randomInteger(1, edgeCount * 1000); edge->cost = weight; } // run the student's Kruskal algorithm to get a minimum spanning tree (MST) Set<Edge*> mst = kruskal(*graph); // convert the MST/graph back into a maze grid // (insert a 'wall' between any neighbors that do not have a connecting edge) graph->clearEdges(); for (Edge* edge : mst) { graph->addEdge(edge->start, edge->finish); graph->addEdge(edge->finish, edge->start); } // physical <-> logical size; a maze of size MxN has 2M-1 x 2N-1 grid cells. // cells in row/col 0, 2, 4, ... are open squares (floors), and cells in // row/col 1, 3, 5, ... are blocked (walls). int digits = countDigits(rowsCols); int worldSize = rowsCols * 2 - 1; worldGrid.resize(worldSize, worldSize); worldGrid.fill(MAZE_WALL); pxPerWidth = (double) windowWidth / worldSize; pxPerHeight = (double) windowHeight / worldSize; for (int row = 0; row < worldSize; row++) { for (int col = 0; col < worldSize; col++) { if (row % 2 == 0 && col % 2 == 0) { worldGrid.set(row, col, MAZE_FLOOR); } } } for (int row = 0; row < rowsCols; row++) { int gridRow = row * 2; for (int col = 0; col < rowsCols; col++) { int gridCol = col * 2; std::string name = vertexName(row, col, digits); // decide whether to put open floor between neighbors // (if there is an edge between them) for (int dr = -1; dr <= 1; dr++) { int nr = row + dr; int gridNr = gridRow + dr; for (int dc = -1; dc <= 1; dc++) { int nc = col + dc; int gridNc = gridCol + dc; if ((nr != row && nc != col) || (nr == row && nc == col) || !worldGrid.inBounds(gridNr, gridNc)) { continue; } std::string neighborName = vertexName(nr, nc, digits); if (graph->containsEdge(name, neighborName)) { worldGrid.set(gridNr, gridNc, MAZE_FLOOR); } } } } } delete graph; graph = gridToGraph(worldGrid); }
int redisvFormatCommand(char **target, const char *format, va_list ap) { const char *c = format; char *cmd = NULL; /* final command */ int pos; /* position in final command */ sds curarg, newarg; /* current argument */ int touched = 0; /* was the current argument touched? */ char **curargv = NULL, **newargv = NULL; int argc = 0; int totlen = 0; int error_type = 0; /* 0 = no error; -1 = memory error; -2 = format error */ int j; /* Abort if there is not target to set */ if (target == NULL) return -1; /* Build the command string accordingly to protocol */ curarg = sdsempty(); if (curarg == NULL) return -1; while(*c != '\0') { if (*c != '%' || c[1] == '\0') { if (*c == ' ') { if (touched) { newargv = realloc(curargv,sizeof(char*)*(argc+1)); if (newargv == NULL) goto memory_err; curargv = newargv; curargv[argc++] = curarg; totlen += bulklen(sdslen(curarg)); /* curarg is put in argv so it can be overwritten. */ curarg = sdsempty(); if (curarg == NULL) goto memory_err; touched = 0; } } else { newarg = sdscatlen(curarg,c,1); if (newarg == NULL) goto memory_err; curarg = newarg; touched = 1; } } else { char *arg; size_t size; /* Set newarg so it can be checked even if it is not touched. */ newarg = curarg; switch(c[1]) { case 's': arg = va_arg(ap,char*); size = strlen(arg); if (size > 0) newarg = sdscatlen(curarg,arg,size); break; case 'b': arg = va_arg(ap,char*); size = va_arg(ap,size_t); if (size > 0) newarg = sdscatlen(curarg,arg,size); break; case '%': newarg = sdscat(curarg,"%"); break; default: /* Try to detect printf format */ { static const char intfmts[] = "diouxX"; static const char flags[] = "#0-+ "; char _format[16]; const char *_p = c+1; size_t _l = 0; va_list _cpy; /* Flags */ while (*_p != '\0' && strchr(flags,*_p) != NULL) _p++; /* Field width */ while (*_p != '\0' && isdigit(*_p)) _p++; /* Precision */ if (*_p == '.') { _p++; while (*_p != '\0' && isdigit(*_p)) _p++; } /* Copy va_list before consuming with va_arg */ va_copy(_cpy,ap); /* Integer conversion (without modifiers) */ if (strchr(intfmts,*_p) != NULL) { va_arg(ap,int); goto fmt_valid; } /* Double conversion (without modifiers) */ if (strchr("eEfFgGaA",*_p) != NULL) { va_arg(ap,double); goto fmt_valid; } /* Size: char */ if (_p[0] == 'h' && _p[1] == 'h') { _p += 2; if (*_p != '\0' && strchr(intfmts,*_p) != NULL) { va_arg(ap,int); /* char gets promoted to int */ goto fmt_valid; } goto fmt_invalid; } /* Size: short */ if (_p[0] == 'h') { _p += 1; if (*_p != '\0' && strchr(intfmts,*_p) != NULL) { va_arg(ap,int); /* short gets promoted to int */ goto fmt_valid; } goto fmt_invalid; } /* Size: long long */ if (_p[0] == 'l' && _p[1] == 'l') { _p += 2; if (*_p != '\0' && strchr(intfmts,*_p) != NULL) { va_arg(ap,long long); goto fmt_valid; } goto fmt_invalid; } /* Size: long */ if (_p[0] == 'l') { _p += 1; if (*_p != '\0' && strchr(intfmts,*_p) != NULL) { va_arg(ap,long); goto fmt_valid; } goto fmt_invalid; } fmt_invalid: va_end(_cpy); goto format_err; fmt_valid: _l = (_p+1)-c; if (_l < sizeof(_format)-2) { memcpy(_format,c,_l); _format[_l] = '\0'; newarg = sdscatvprintf(curarg,_format,_cpy); /* Update current position (note: outer blocks * increment c twice so compensate here) */ c = _p-1; } va_end(_cpy); break; } } if (newarg == NULL) goto memory_err; curarg = newarg; touched = 1; c++; } c++; } /* Add the last argument if needed */ if (touched) { newargv = realloc(curargv,sizeof(char*)*(argc+1)); if (newargv == NULL) goto memory_err; curargv = newargv; curargv[argc++] = curarg; totlen += bulklen(sdslen(curarg)); } else { sdsfree(curarg); } /* Clear curarg because it was put in curargv or was free'd. */ curarg = NULL; /* Add bytes needed to hold multi bulk count */ totlen += 1+countDigits(argc)+2; /* Build the command at protocol level */ cmd = malloc(totlen+1); if (cmd == NULL) goto memory_err; pos = sprintf(cmd,"*%d\r\n",argc); for (j = 0; j < argc; j++) { pos += sprintf(cmd+pos,"$%zu\r\n",sdslen(curargv[j])); memcpy(cmd+pos,curargv[j],sdslen(curargv[j])); pos += sdslen(curargv[j]); sdsfree(curargv[j]); cmd[pos++] = '\r'; cmd[pos++] = '\n'; } assert(pos == totlen); cmd[pos] = '\0'; free(curargv); *target = cmd; return totlen; format_err: error_type = -2; goto cleanup; memory_err: error_type = -1; goto cleanup; cleanup: if (curargv) { while(argc--) sdsfree(curargv[argc]); free(curargv); } sdsfree(curarg); /* No need to check cmd since it is the last statement that can fail, * but do it anyway to be as defensive as possible. */ if (cmd != NULL) free(cmd); return error_type; }
/* Helper that calculates the bulk length given a certain string length. */ static size_t bulklen(size_t len) { return 1+countDigits(len)+2+len+2; }
/** @fn int countColWidth ( double num, int decimals ) @brief calculates the width in characters the number will occupy @param num [in] number to count column width for @param decimals [in] number of decimals @return width of space the number will take */ int countColWidth(double num, int decimals) { int digitsCount = countDigits(num); if (!decimals) --decimals; // remove extra space for a period if no decimals return digitsCount + (digitsCount / 3) + decimals + 2; //digits, commas, decimals, period, possible minus sign }
int cmpDigits(uint32_t a, uint32_t b){ countDigits(a, digitsa); countDigits(b, digitsb); return memcmp(digitsa, digitsb, 10*sizeof(uint8_t)); }