将一个数分解为两个数的和

Question

I have a problem with a such a task:

Write a program that finds such a pair of numbers x and y that their sum is equal to n. In addition, the pair of numbers should meet the following conditions:

• the number x has at least 2 digits,
• the number y is one digit less than the number x.

N is from the range <10 ; 10^5>

for number 80, the output should look like this:

79 + 1 = 80
78 + 2 = 80
77 + 3 = 80
76 + 4 = 80
75 + 5 = 80
74 + 6 = 80
73 + 7 = 80
72 + 8 = 80
71 + 9 = 80

I wrote a code that works in most cases but the system rejects the solution when testing the number 100000, because the program does not find such pairs - the test requires 9000 such pairs. I can't understand what's wrong because I think the program is okay. I'd like to ask for some advice.

My code:

#include <stdio.h>
#include <math.h>

int digit_count(int n)
{
    int i = 0;
    while (n > 0)
    {
        n /= 10;
        i++;
    }
    return i;
}

int breakdown(int n)
{
    long n_digits = digit_count(n), check = 0, count = 1;
    long double y_max = pow(10, (n_digits - 1)) - 1, y_min = (pow(10, (n_digits - 2)));

    for (int i = (int)y_min; i <= (int)y_max; i++)
    {
        if (digit_count(n - i) >= 2 && digit_count(i)+1 == digit_count(n - 1))
        {
            printf("%d + %d = %d          %d\n", n - i, i, n, count);
            check = 1;
            count++;
        }
    }

    if (check == 0)
    {
        printf("Nothing to show.");
    }
    return 0;
}

int main(void)
{
    unsigned int n = 0;
    printf("Podaj N: ");
    if (1 != scanf("%u", &n))
    {
        printf("Incorrect input");
        return 1;
    }
    if (n > 1000000 || n < 10)
    {
        printf("Incorrect input");
        return 1;
    }

    breakdown(n);
    return 0;
}

PS: I forgot to mention that the count variable is here only for debugging

Answer 1

I solved the problem in this way. Now it works for all numbers in the range according to the task.

#include <stdio.h>
#include <math.h>

int digit_count(int n)
{
    int i = 0;
    while (n > 0)
    {
        n /= 10;
        i++;
    }
    return i;
}

int breakdown(int n)
{
    int n_digits = digit_count(n), check = 0;
    double y_max = pow(10, n_digits - 1) - 1; 
    //int i = 0 instead of i = y_min = (pow(10, (n_digits - 2))
    for (int i = 0; i <= (int)y_max; i++)
    {
        //instead of if (digit_count(n - i) >= 2 && digit_count(i)+1 == digit_count(n - i))
        if (digit_count(n - i) >= 2 && digit_count(n - i) == digit_count(i) + 1) 
        {
            printf("%d + %d = %d\n", n - i, i, n);
            check = 1;
        }
    }

    if (check == 0)
    {
        printf("Nothing to show.");
    }
    return 0;
}

int main(void)
{
    unsigned int n = 0;
    printf("Podaj N: ");
    if (1 != scanf("%u", &n))
    {
        printf("Incorrect input");
        return 1;
    }
    if (n > 1000000 || n < 10)
    {
        printf("Incorrect input");
        return 1;
    }

    breakdown(n);
    return 0;
}

Answer 2

The posted code checks all the numbers in [10 ^{k - 2} , 10 ^{k - 1} - 1], k beeing the number of digits of n , using the expansive (and wrong) condition

if (digit_count(n - i) >= 2 && digit_count(i)+1 == digit_count(n - 1)) { /* ... */ }
//                                                                 ^

You can solve the problem avoiding all (or at least most of) those digits counts, by carefully calculating the valid extents of the ranges of the x and y values.

The following is a possible implementation

#include <assert.h>
#include <stdbool.h>
#include <stdio.h>

static inline long min_(long a, long b)
{
    return b < a ? b : a;   
}

static inline long max_(long a, long b)
{
    return b < a ? a : b;   
}

int digit_count(long n);

// Specilization for integer exponent. 
long pow_10_(int exponent);

// A little helper struct
typedef struct range_s
{
    long begin, end;
} range_t;

// Shrinks the range of the y values so that all the x = z - y are valid
// (the right nummber of digits and less than z).
range_t find_range(long z, long x_0)
{
    range_t y = {max_(1, x_0 / 10), x_0};
    range_t x = {x_0, min_(z, x_0 * 10)};

    long x_1 = z - y.begin;
    if (x_1 < x.begin)
        y.end = y.begin;
    else if (x_1 >= x.end)
        y.begin = min_(z - x.end + 1, y.end);

    long x_2 = z - y.end;
    if (x_2 > x.end)
        y.begin = y.end;
    else if (x_2 <= x.begin)
        y.end = max_(z - x.begin + 1, y.begin);

    return y;
}

long print_sums(long z, range_t y);

long breakdown(long z)
{
    int n_digits = digit_count(z); // <- Only once.

    long x_0 = pow_10_(n_digits - 1);

    // Depending on z, the x values may have the same number of digits of z or
    // one less. 
    long count = 0;
    if (n_digits > 2)
    {
        count += print_sums(z, find_range(z, x_0 / 10));
    }
    count += print_sums(z, find_range(z, x_0));
    return count;
}

int main(void)
{
    long n = 0;
    if (1 != scanf("%lu", &n))
    {
        printf("Incorrect input");
        return 1;
    }
    if (n > 1000000 || n < 10)
    {
        printf("Incorrect input");
        return 1;
    }

    printf("\nCount: %ld\n", breakdown(n));
    return 0;
}

int digit_count(long n)
{
    int i = 0;
    while (n > 0)
    {
        n /= 10;
        i++;
    }
    return i ? i : 1;  // I consider 0 a 1-digit number.
}

long pow_10_(int exponent)
{
    if (exponent < 0)
        return 0;
    long result = 1;
    while (exponent-- > 0)
        result *= 10;
    return result;
}

#define SAMPLES 5

long print_sums(long z, range_t y)
{
    for (long i = y.begin; i < y.end; ++i)
#ifndef SHOW_ONLY_SAMPLES
        printf("%ld + %ld = %ld\n", z - i, i, z);
#else
        if ( i < y.begin + SAMPLES - 1 || i > y.end - SAMPLES )
            printf("%ld + %ld = %ld\n", z - i, i, z);
        else if ( i == y.begin + SAMPLES )
            puts("...");
#endif
    return  y.end - y.begin;  
}

Testable here .