Numbers With Same Consecutive Differences

Numbers With Same Consecutive Differences - Problem

Given two integers n and k, return an array of all the integers of length n where the difference between every two consecutive digits is k.

You may return the answer in any order.

Note: The integers should not have leading zeros. Integers as 02 and 043 are not allowed.

Input & Output

Example 1 — Basic Case

$ Input: n = 3, k = 7

› Output: [181,292,707,818,929]

💡 Note: For 3-digit numbers with consecutive difference 7: 181 (|8-1|=7, |1-8|=7), 292 (|9-2|=7, |2-9|=7), etc.

Example 2 — Single Digit

$ Input: n = 1, k = 3

› Output: [0,1,2,3,4,5,6,7,8,9]

💡 Note: For single digits, all digits 0-9 are valid since there are no consecutive pairs to check.

Example 3 — Small Difference

$ Input: n = 2, k = 1

› Output: [10,12,21,23,32,34,43,45,54,56,65,67,76,78,87,89,98]

💡 Note: 2-digit numbers where consecutive digits differ by 1: 10 (|1-0|=1), 12 (|1-2|=1), etc.

Constraints

1 ≤ n ≤ 8
0 ≤ k ≤ 9

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8 M Microsoft 6

The key insight is that each digit constrains the next digit to at most two possibilities: current digit ± k. We can use backtracking or BFS to build valid numbers digit by digit, avoiding the need to check all possible n-digit numbers. Best approach is BFS with Time: O(2^n), Space: O(2^n).

Common Approaches

✓ BFS - Level by Level Construction

⏱️ Time: O(2^n) Space: O(2^n)

Use breadth-first search to construct valid numbers level by level. Start with digits 1-9, then for each level, extend each number by adding valid next digits. This naturally builds all n-digit numbers without recursion.

Backtracking - Build Valid Numbers

⏱️ Time: O(2^n) Space: O(n)

Use recursive backtracking to build valid numbers digit by digit. For each position, try digits that maintain the difference k with the previous digit. Backtrack when we can't place a valid digit.

Brute Force - Generate All Numbers

⏱️ Time: O(10^n) Space: O(1)

Generate every possible n-digit number (from 10^(n-1) to 10^n - 1) and check if consecutive digits have difference k. This approach is straightforward but extremely inefficient for larger inputs.

BFS - Level by Level Construction — Algorithm Steps

Initialize queue with digits 1-9
For each level, extend current numbers with valid digits
Add numbers with difference k to next level
Continue until n digits reached

Visualization

Tap to expand

Step-by-Step Walkthrough

Level 0

Start with single digits 1-9

Level 1

Extend each digit with ±k

Level n-1

Complete n-digit numbers

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int* solution(int n, int k, int* returnSize) {
    if (n == 1) {
        int* result = (int*)malloc(10 * sizeof(int));
        for (int i = 0; i < 10; i++) {
            result[i] = i;
        }
        *returnSize = 10;
        return result;
    }
    
    static int finalResult[10000];
    int finalSize = 0;
    
    // Start BFS from each digit 1-9 (no leading zeros)
    for (int startDigit = 1; startDigit <= 9; startDigit++) {
        static int queue[10000];
        int queueSize = 1;
        queue[0] = startDigit;
        
        // Build numbers level by level
        for (int level = 1; level < n; level++) {
            static int nextQueue[10000];
            int nextQueueSize = 0;
            
            for (int i = 0; i < queueSize; i++) {
                int currentNum = queue[i];
                int lastDigit = currentNum % 10;
                
                // Try adding digit = lastDigit + k
                if (lastDigit + k <= 9) {
                    nextQueue[nextQueueSize++] = currentNum * 10 + (lastDigit + k);
                }
                
                // Try adding digit = lastDigit - k (avoid duplicates when k=0)
                if (k != 0 && lastDigit - k >= 0) {
                    nextQueue[nextQueueSize++] = currentNum * 10 + (lastDigit - k);
                }
            }
            
            // Copy nextQueue to queue
            for (int i = 0; i < nextQueueSize; i++) {
                queue[i] = nextQueue[i];
            }
            queueSize = nextQueueSize;
        }
        
        // Add all numbers from this starting digit to final result
        for (int i = 0; i < queueSize; i++) {
            finalResult[finalSize++] = queue[i];
        }
    }
    
    // Sort the result
    qsort(finalResult, finalSize, sizeof(int), compare);
    
    int* result = (int*)malloc(finalSize * sizeof(int));
    for (int i = 0; i < finalSize; i++) {
        result[i] = finalResult[i];
    }
    
    *returnSize = finalSize;
    return result;
}

int main() {
    int n, k;
    scanf("%d", &n);
    scanf("%d", &k);
    
    int returnSize;
    int* result = solution(n, k, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Each number can generate at most 2 children (±k), leading to 2^n total numbers

⚠ Quadratic Growth

Space Complexity

O(2^n)

Queue stores all numbers at current level, which can be up to 2^n

⚡ Linearithmic Space

35.4K Views

Medium Frequency

~15 min Avg. Time

892 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

BFS - Level by Level Construction — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler