Displaying individual number with spacing on printf - c

Question

im writing a code which will show the result is to display the individual digits and the decimal equivalent.
For e.g., if n is 6 and the number entered is 110011, the printout will be
1 1 0 0 1 1
The decimal equivalent is 51
I have already sourced and edited a code, however it shows
"110011 110011 110011 110011 110011 110011" instead of
"1 1 0 0 1 1".
#include <math.h>
void main()
{
int num, binary, decimal = 0, base = 1, remainder, n, digits;
printf("Please enter the number of digits:\n");
scanf("%d", &n);
printf("Please enter the %d digits:\n",n);
scanf("%d", &num);
binary = num;
while (n > 0)
{
remainder = num % 10;
decimal = decimal + remainder * base;
num = num / 10 ;
base = base * 2;
printf("%d ", binary);
n--;
}
printf("\nIts decimal equivalent is = %d \n", decimal);
}

Answer 1

The value in the variable binary becomes a copy of the value in the variable num in the following line.
binary = num;
Since it is never changed afterwards, it will always remain the same value, a copy of the value in num at the time when it was copied (see the code line above).
Your loop is executed n times (in your example six times).
Each time through the loop, the same copied value is printed in the following code line.
So the original value will be printed six times in your example.
printf("%d ", binary);
You did not actually ask a question (which is really recommended here at StackOverflow).
So I answered the question "Why is the same value printed six times?"
You probably want to now ask the next question, "How do get the desired result?"
That question is much harder to answer, because your code is quite far away from achieving that.
You would have to determine the binary digits one by one and in the right order.
You do determine the digits one by one, around the following line in your code.
remainder = num % 10;
But that is the wrong order, it gives you the digits from least signifying to most signifying. Try with an input of "100011" to see what I mean.
To be more precise I have to say that I guess that you want the digits from most to least, but maybe not, in that case it is easier: print remainder instead of binary.
If I am right and you do want most to least, then you have to make some way of reversing the digits. You could use a stack, an array, recursion or different (more complicated ) math involving to determine the number of digits first.

Answer 2

The reason you're getting this output is because each call for printf("%d ", binary); prints the entirety of the 'binary' variable onto the screen, and that variable contains the number as opposed to individual digits of that number.
The easiest way of accessing specific digits of a number is by first dividing it by some power of 10, then getting mod10 of that number, e.g.:
int number = 6543;
int lastDigit = number % 10;
int secondLastDigit = (number / 10) % 10;
int thirdLastDigit = (number / 100) % 10;
This works because dividing integers in C causes any fraction parts to be ommitted, thus if you divide 6543/10 (as in the example), you will not get 654.3, but 654.
You could create a function which will return a number's digit from any position like so:
int digitAt(int num, int pos)
{
// Divide num by 10^(pos - 1) to "shift" the number to the right
num /= pow(10, pos - 1);
// Return the last digit after the divisions
return num % 10;
}
The above function returns digits starting from the right (pos 1 = last digit, pos 2 = second last digit)!
To make this function more intuitive you could for example flip the number horizontally before dividing (123 becomes 321).
I went on a little tangent, back to the original topic. To achieve the functionality you want, you could write your code like this (just the while loop):
while (n > 0)
{
remainder = num % 10;
decimal = decimal + remainder * base;
num = num / 10 ;
base = base * 2;
int binaryDigit = (binary / pow(10, n - 1)) % 10;
printf("%d ", binaryDigit);
n--;
}
Now, the reason you don't have to worry about your digits being read backwards (like in the previous function example) is because conveniently, your iterator, n, is already going in reverse direction ('from n to 0' as opposed to 'from 0 to n'), so you're reading the leftmost digits before the rightmost ones.
Hope that helped.
[EDIT] As pointed out in the replies, using pow() in integer operations may lead to undesired results. My bad. There are plenty of ways to achieve an integer power of 10 though, a function like
int powerOf10(int exp)
{
int num = 1;
while (exp > 0) {
num *= 10;
exp--;
}
return num;
}
should do the job.

Answer 3

The problem is that you do:
printf("%d ", binary);
but binary is the same value all the time, i.e. it's never changing so you get the original value printed again and again.
If you changed it to:
printf("%d ", remainder);
things would be "a bit better" as the binary pattern would be printed but in reversed order. So that's not the solution.
So instead you can collect the values in the loop and store them in a string to be printed after the loop. Like:
int main()
{
int num, decimal = 0, base = 1, remainder, n;
printf("Please enter the number of digits:\n");
scanf("%d", &n);
int idx = 2*n-1;
char *str = malloc(2*n); // Allocate memory for the string
str[idx--] = 0; // and zero-terminate it
printf("Please enter the %d digits:\n",n);
scanf("%d", &num);
while (n > 0)
{
remainder = num % 10;
decimal = decimal + remainder * base;
num = num / 10 ;
base = base * 2;
str[idx--] = '0' + remainder; // Put the "binary" (i.e. '0' or '1') char in the string
if (idx>0) str[idx--] = ' '; // Put a space in the string
n--;
}
printf("%s", str); // Print the string
printf("\nIts decimal equivalent is = %d \n", decimal);
free(str); // Free the string
return 0;
}