Square every digit of a number and concatenate them as a number using C (Program isn't dealing with 0 properly)

Question

So i was asked to square every digit of the number and concatenate them and return as a number using C. But for some reason I am having problems dealing with 0 as digit and implement it in my algorithm. For example: when n = 3210987654, expected 9410816449362516, but got 941816449362516.

#include<math.h>
unsigned long long square_digits(unsigned n) {
    unsigned long long result = 0;
    int k = 0;
    int digits = (int)log10(n) + 1;
    for (int d = 0; d < digits; d++) {
        int digit = n % 10;
        int squared = digit * digit;
        n /= 10;
        if (d == 0) {
            result += squared * pow(10, k);
        }
        else {
            if (digit == 0) {
                k++;
            } 
            else if (digit < 4) {
                k++;
                result += squared * pow(10, k);
            } 
            else {
                k += 2;
                result += squared * pow(10, k);
            }
        }
    }
    return result;
}

So what i tried to do i use a variable k which will work as the power over 10 and function according to amount of digits needed to concatinate a squared digit. for the very first digit i kept it simple as i didn't change the value of k. and for others i checked first if the digits square takes 2 digits or not. if it takes then each time i have to increase power twice and once for single digit square. And as for digit 0, i can't multiply or concatinate accordingly instead i just move one step left by increasing the power. according to my hypothesis this should work perfectly but this isn't working right as it's having problem dealing with 0's in middle of the number.

For example: for n = 3210987654, expected 9410816449362516, but got 941816449362516

Answer 1

To address the manipulation of large numbers like this is often best done by evaluating the number as a string as is often done with large numbers such as credit card numbers. Once the number is converted to a string, each digit can be individually processed as necessary for the problem scenario. With that, following is a refactored version of the digit squaring function along with a test harness in the "main" function.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

unsigned long long square_digits(long long n)
{
    char work[32];
    long long x = 1;
    long long result = 0;

    sprintf(work, "%lld", n);                               /* Store value in a string          */

    for (int i = (strlen(work) - 1); i >= 0; i--)           /* Evaluate each digit character    */
    {
        result += (work[i] - '0') * (work[i] - '0') * x;    /* Square the digit value and multiply by a succesive power of 10   */

        x *= 10;

        if (work[i] > '3')                                  /* Increase multiplier by 10 again for a two digit square           */
            x *= 10;
    }

    return result;
}

int main()
{
    long long i;

    printf("Enter a value: ");
    scanf("%lld", &i);

    printf("Result for %lld is %lld\n", i, square_digits(i));
    return 0;
}

Following are the key points.

• The integer value to be evaluated is converted into a string value.
• Starting with the first digit, each character is squared and then multiplied by a work variable which is successively increased in value by either "10" or "100" depending upon the size of the squared digit which will accommodate encountering a "0".
• Once all digits have been evaluated the result is returned

Testing out this refactored code with your example, the following terminal output was created.

craig@Vera:~/C_Programs/Console/SquareInt/bin/Release$ ./SquareInt 
Enter a value: 3210987654
Result for 3210987654 is 9410816449362516

Go ahead and evaluate this possible route.

Answer 2

The use of pow and log10 makes things too complicated (and may even end being incorrect due to floating point calculations). When doing integer calculations do it all using integers.

Keep a factor variable so that you know what to multiply the squared digit with before adding to the result. Start with factor being 1 and then for each squared digit multiply it by 10 or 100 depending on the value of the squared digit.

Something like:

unsigned long long square_digits(unsigned n) 
{
    unsigned long long result = 0;
    unsigned long long factor = 1;
    while (n) 
    {
        unsigned digit = n % 10;
        unsigned squared = digit * digit;
        result += factor * squared;
        factor = (squared >= 10) ? factor * 100 : factor * 10;
        n /= 10;
    }
    return result;
}

Answer 3

Your code is very complicated and unclear. And usually such a code contains bugs.

Consider for example n equal to 104.

For the first iteration of the loop k is equal to 0:

int k = 0;

So result after the first iteration will be 16.

The next digit is 0. In this case k is incremented:

if (digit == 0) {
    k++;
} 

and becomes equal to 1.

Then for the last digit equal to 1 you have

else if (digit < 4) {
    k++;
    result += squared * pow(10, k);
} 

That is k becomes equal to 2 ans consequenly result becomes equal to 116. However result shall be equal to 1016.

I can suggest in my opinion a more clear and simple solution without using the auxiliary standard functions pow and log10 that deal with double values..

Here you are.

#include <stdio.h>

unsigned int max_divisor( unsigned int n )
{
    const unsigned int Base = 10;

    unsigned int divisor = 1;

    while (!( n / divisor < Base ))
    {
        divisor *= Base;
    }

    return divisor;
}

unsigned long long square_digits( unsigned n )
{
    const unsigned int Base = 10;

    unsigned long long result = 0;

    unsigned int divisor = max_divisor( n );

    do
    {
        unsigned long long digit = n / divisor;

        digit *= digit;

        result = ( digit < 10 ? Base : Base * Base ) * result + digit;

        n %= divisor;
    } while (divisor /= Base);

    return result;
}

int main( void )
{
    for (unsigned int n = 0; n <= 10; ++n)
    {
        printf( "%u -> %llu\n", n, square_digits( n ) );
    }

    unsigned int n = 3210987654;
    printf( "%u -> %llu\n", n, square_digits( n ) );
}

The program output is

0 -> 0
1 -> 1
2 -> 4
3 -> 9
4 -> 16
5 -> 25
6 -> 36
7 -> 49
8 -> 64
9 -> 81
10 -> 10
3210987654 -> 9410816449362516