Convert Integer to the Sum of Two No-Zero Integers

Convert Integer to the Sum of Two No-Zero Integers - Problem

Math Easy

No-Zero Integer Challenge

A No-Zero integer is a positive integer that doesn't contain any 0 digits in its decimal representation. For example, 123 and 789 are No-Zero integers, but 102 and 300 are not.

Given an integer n, your task is to find two No-Zero integers a and b such that:

Both a and b are positive No-Zero integers
a + b = n

Return any valid pair [a, b] as an array. The problem guarantees that at least one valid solution exists.

Examples:
• n = 11 → [1, 10] is invalid (10 contains 0), but [2, 9] is valid
• n = 1000 → [1, 999] works perfectly

Input & Output

example_1.py — Python

$ Input: n = 2

› Output: [1, 1]

💡 Note: Both 1 and 1 are No-Zero integers, and 1 + 1 = 2

example_2.py — Python

$ Input: n = 11

› Output: [2, 9]

💡 Note: We can't use [1, 10] because 10 contains a zero. [2, 9] works since both numbers have no zeros and 2 + 9 = 11

example_3.py — Python

$ Input: n = 1000

› Output: [1, 999]

💡 Note: 1 and 999 are both No-Zero integers that sum to 1000. Note that 999 has no zeros despite being close to 1000

Constraints

2 ≤ n ≤ 10⁴
The answer is guaranteed to exist
Both returned integers must be positive

Visualization

Tap to expand

Understanding the Visualization

Start Simple

Begin with the smallest possible first number (1)

Calculate Complement

Find what the second number must be: b = n - a

Validate Both

Check that neither number contains the digit 0

Success or Continue

Return the pair if valid, otherwise try the next number

Key Takeaway

🎯 Key Insight: Since a solution is guaranteed to exist and most small numbers don't contain zeros, a simple linear search from a=1 upward will quickly find a valid pair, making this an efficient O(n) solution in practice.

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 Apple 6

The optimal approach uses a simple linear search starting from a = 1 and incrementing until we find a valid pair where both a and n - a contain no zeros. This works efficiently because the problem guarantees a solution exists, and we typically find one quickly since most small numbers don't contain zeros.

Common Approaches

Approach	Time	Space	Notes
✓ Linear Search (Brute Force)	O(n)	O(1)	Try every possible first number and check if complement is zero-free

Linear Search (Brute Force) — Algorithm Steps

Start with a = 1
Calculate b = n - a
Check if both a and b contain no zeros
If valid, return [a, b]; otherwise increment a and repeat

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Search

Begin with a=1, calculate b=n-1

Check Validity

Test if both numbers contain no zeros

Found or Continue

Return pair if valid, otherwise increment a

Code -

solution.c — C

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

int hasNoZero(int num) {
    char str[20];
    sprintf(str, "%d", num);
    return strchr(str, '0') == NULL;
}

int* getNoZeroIntegers(int n) {
    int* result = (int*)malloc(2 * sizeof(int));
    
    for (int a = 1; a < n; a++) {
        int b = n - a;
        if (hasNoZero(a) && hasNoZero(b)) {
            result[0] = a;
            result[1] = b;
            return result;
        }
    }
    return result; // Should never reach here
}

int main() {
    int n;
    scanf("%d", &n);
    int* result = getNoZeroIntegers(n);
    printf("[%d, %d]\n", result[0], result[1]);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

In worst case, we might need to check up to n/2 values for a

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

67.0K Views

Medium Frequency

~12 min Avg. Time

1.9K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Linear Search (Brute Force) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler