Split numbers into place values in C - c

Question

I want to print a breakdown of an integer, only outputting non-zero numbers. For example: ./printint 23401 will print: 20000 + 3000 + 400 + 1 Note: the tens value of 0 is omitted.
That is my code so far:
#include <stdio.h>
int main(int argc, const char * argv[]) {
int n = 23401;
int g,s,b,q,w;
g=n%10;
s=(n/10)%10*10;
b=(n/100)%10*100;
q= (n/1000)%10*1000;
w= n/10000*10000;
printf("%d" ,"+","%d","+","%d","+","%d","+","%d\n",w,q,b,s,g);
return 0;
}
I am new at coding and new at C. I am also trying to get input but it is hard to think it thoroughly, so I am just using the example in the question. Also, I have a problem with the connect style in the printf().

Answer 1

As with any problem, you simply need to break the complex problem down into smaller problems that you can solve, code a solution for each of the parts and then consolidate all of the individual coded solutions into your final code. In this case that can be thought of as:
prompt user for input,
read and VALIDATE the user input,
handle the corner-case of the user entering 0 which has no additive component,
determine if the number entered was negative, make positive and save flag indicating original was negative,
determine the number of digits in the number entered by the user,
generate a power of 10 for that many digits,
loop over the number dividing by the power of 10, output the resulting power of 10 formed by digit * power of 10 (if non-zero), and reduce the number by that amount and divide your power of 10 by 10 and repeat until your power of 10 is zero.
Now just go write the code for the pieces. Let's decide on a few variable names that we will need before coding up each step (to server as a guide-post as we work through the steps). On a 64-bit computer with a 8-byte long, choosing long as the type to hold your number entered by the user makes sense for handling negative values. We will add a few more to help with the rest of the code. Five variables should do it, e.g.
#include <stdio.h>
int main (void) {
int ndigits, sign = 0; /* number of digits, sign (1 if negative) */
long num /* the number to get from user */
unsigned long limit = 1, n; /* divisor limit, working var for num */
Let's start with Step 1. - prompting for input. There is no conversion required, and if we want the input to be at the end of the line instead of below it, fputs is a good choice for the prompt (use puts if you want to output a newline forcing the user input to the next line), e.g.
fputs ("enter number in range of long int: ", stdout);
Step 2. - read and VALIDATE the user-input (every user input) and handle the error if invalid input is provided (we simply return 1; from main() exiting if an invalid integer is entered):
if (scanf ("%ld", &num) != 1) { /* validate input */
fputs ("error: invalid integer input.\n", stderr);
return 1;
}
Step 3. - handle the case if the user enters 0 where there will be nothing to add to obtain your final number:
if (!num) { /* handle 0 corner-case */
printf ("%ld : ()\n", num);
return 0;
}
(we will also output the number entered by the user at this point and output the remainder in the loop and following the loop. call this Step 3a.)
printf ("%ld : ", num); /* output orignal number */
Step 4. determine if the number is negative, and if so, make it positive and save a flag indicating the original input was negative. (you could just output the '-' in this case and do away with the flag, but you won't always have that opportunity -- so get used to saving the state with a simple flag if required)
if (num < 0) { /* if negative set sign=1, make positive */
sign = 1;
num = -num;
}
n = num; /* set working variable for num */
(note: we also set our working variable n = num; at this point. If you don't want to preserve the original, you can dispense with using a working variable and just modify the original as needed -- as we could here since we have already output the original)
Step 5. - determine the number of digits in the number entered by the user:
ndigits = snprintf (NULL, 0, "%ld", num); /* get number of digits in num */
(yes: snprintf with a destination of NULL and length of 0 provides a very convenient way to calculate the number of characters that would be required to hold the number converted to a string)
Step 6. - generate a power of 10 for the number of digits entered:
for (int i = 1; i < ndigits; i++) /* set power of 10 limit */
limit *= 10;
(before entering our loop we check if the original number was negative an output the '-' at this point -- a step 6a.):
if (sign) /* if negative, output '-' */
putchar ('-');
Step 7. loop over the number dividing by the limit power of 10 and outputting the resulting component power of 10 (if non-zero) that you would add to arrive at the final number. We then reduce our working variable by that amount and divide the power of 10 (by 10) and repeat until the power of 10 is zero, you can do:
while (limit) { /* loop over each power of 10 */
int digit = n / limit; /* is there a digit at that power of 10? */
if (digit) { /* if so, output digit * power of 10 */
printf (n != (unsigned long)num ? " + %lu" : "(%lu", digit * limit);
}
n -= digit * limit; /* subtract digit * power of 10 */
limit /= 10; /* reduce limit by power of 10 */
}
All that remains is tidying up the output any way you like. We'll add a closing parenthesis just to make it look nice. And this is also were you would figure out where you wanted to put the remainder of your output during the program (what led to all the 3a. and 6a. steps, etc..)
puts (")"); /* output closing paren */
}
If you collect all the pieces and put them together you would have:
#include <stdio.h>
int main (void) {
int ndigits, sign = 0; /* number of digits, sign (1 if negative) */
long num /* the number to get from user */
unsigned long limit = 1, n; /* divisor limit, working var for num */
fputs ("enter number in range of long int: ", stdout);
if (scanf ("%ld", &num) != 1) { /* validate input */
fputs ("error: invalid integer input.\n", stderr);
return 1;
}
if (!num) { /* handle 0 corner-case */
printf ("%ld : ()\n", num);
return 0;
}
printf ("%ld : ", num); /* output orignal number */
if (num < 0) { /* if negative set sign=1, make positive */
sign = 1;
num = -num;
}
n = num; /* set working variable for num */
ndigits = snprintf (NULL, 0, "%ld", num); /* get number of digits in num */
for (int i = 1; i < ndigits; i++) /* set power of 10 limit */
limit *= 10;
if (sign) /* if negative, output '-' */
putchar ('-');
while (limit) { /* loop over each power of 10 */
int digit = n / limit; /* is there a digit at that power of 10? */
if (digit) { /* if so, output digit * power of 10 */
printf (n != (unsigned long)num ? " + %lu" : "(%lu", digit * limit);
}
n -= digit * limit; /* subtract digit * power of 10 */
limit /= 10; /* reduce limit by power of 10 */
}
puts (")"); /* output closing paren */
}
Example Use/Output
Now run it and make sure it does what you intend, and if not -- go fix it.
$ ./bin/pwrsof10sum_scanf
enter number in range of long int: 23401
23401 : (20000 + 3000 + 400 + 1)
$ ./bin/pwrsof10sum_scanf
enter number in range of long int: 20431
20431 : (20000 + 400 + 30 + 1)
$ ./bin/pwrsof10sum_scanf
enter number in range of long int: 1
1 : (1)
Handle zero:
$ ./bin/pwrsof10sum_scanf
enter number in range of long int: 0
0 : ()
Handle negative values:
$ ./bin/pwrsof10sum_scanf
enter number in range of long int: -1
-1 : -(1)
$ ./bin/pwrsof10sum_scanf
enter number in range of long int: -29031
-29031 : -(20000 + 9000 + 30 + 1)
Note. instead of prompting the user for input with scanf, you can simply set a default value for num in your code and then provide any number you want to test as the first argument to your program. That avoids all the prompting and input during the testing phase. If you want to give it a try, just replace your scanf entry with a check to see if an argument was provided on the command line, and if so, convert and assign to num using sscanf instead, e.g.
#include <stdio.h>
int main (int argc, char **argv) {
int ndigits, sign = 0; /* number of digits, sign (1 if negative) */
long num = 23401; /* the number */
unsigned long limit = 1, n; /* divisor limit, working var for num */
/* check if new mumber provided on command line, convert to long */
if (argc > 1 && sscanf (argv[1], "%ld", &num) != 1) {
fputs ("error: invalid non-integer argument.\n", stderr);
return 1;
}
(the only change is the default value for num and then the check of argc and conversion and VALIDATION with sscanf.
Look things over and let me know if you have further questions.