Numbers With Same Consecutive Differences

Numbers With Same Consecutive Differences - Problem

Find All Numbers with Equal Consecutive Digit Differences

Given two integers n and k, your task is to generate all possible integers of exactly n digits where the absolute difference between every two consecutive digits equals k.

For example, if n = 3 and k = 2, then 121 is valid because |1-2| = 1 and |2-1| = 1... wait, that's not right! We need |1-2| = 2, so 131 would be valid instead.

Important constraints:

No leading zeros allowed (except for single digit numbers when n=1)
The result can be returned in any order
Each consecutive pair of digits must have an absolute difference of exactly k

Examples: If n=2, k=1, valid numbers include: 10, 12, 21, 23, 32, 34, 43, 45, 54, 56, 65, 67, 76, 78, 87, 89, 98

Input & Output

example_1.py — Basic Case

$ Input: n = 3, k = 7

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

💡 Note: For n=3 digits with k=7 difference: 181 (|1-8|=7, |8-1|=7), 292 (|2-9|=7, |9-2|=7), etc. Each consecutive pair has exactly difference 7.

example_2.py — 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: All 2-digit numbers where consecutive digits differ by 1. Like 10 (|1-0|=1), 12 (|1-2|=1), etc.

example_3.py — Single Digit Edge Case

$ Input: n = 1, k = 0

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

💡 Note: When n=1, we return all single digits 0-9 regardless of k value, since there are no consecutive digits to compare.

Constraints

2 ≤ n ≤ 9
0 ≤ k ≤ 9
No leading zeros allowed except for single digits when n = 1

Visualization

Tap to expand

Understanding the Visualization

Choose Starting Floor

Pick any starting digit from 1-9 (no leading zeros allowed)

Calculate Next Steps

From current digit d, you can only go to d+k or d-k (if they're valid digits 0-9)

Build Complete Staircase

Continue until you have exactly n steps (digits), then save the complete number

Key Takeaway

🎯 Key Insight: At each digit position, we have at most 2 valid choices (current ± k), making backtracking much more efficient than brute force enumeration.

Asked in

f Meta 42 G Google 35 a Amazon 28 ⊞ Microsoft 21

The optimal approach uses backtracking (DFS) to generate valid numbers digit by digit. Starting with digits 1-9 (no leading zeros), we recursively build numbers by only trying digits that maintain the required difference k from the previous digit. This avoids generating invalid numbers and achieves O(2^n) time complexity, much better than brute force O(9×10^n).

Common Approaches

Approach	Time	Space	Notes
✓ Backtracking (DFS Approach)	O(2^n)	O(n)	Build valid numbers digit by digit using recursive backtracking

Backtracking (DFS Approach) — Algorithm Steps

Start with each digit 1-9 as the first digit (no leading zeros)
For each position, calculate valid next digits: current ± k
Recursively build the rest of the number
When we reach n digits, add the complete number to results

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with 1-9

Begin with each valid first digit (no leading zeros)

Branch on Valid Digits

For each digit, try current ± k if they're valid (0-9)

Build Complete Numbers

Continue until we have n digits, then save the result

Code -

solution.c — C

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

void backtrack(int num, int remainingDigits, int k, int* result, int* returnSize) {
    // Base case: if no more digits needed
    if (remainingDigits == 0) {
        result[(*returnSize)++] = num;
        return;
    }
    
    // Get the last digit of current number
    int lastDigit = num % 10;
    
    // Try adding lastDigit + k
    if (lastDigit + k <= 9) {
        backtrack(num * 10 + lastDigit + k, remainingDigits - 1, k, result, returnSize);
    }
    
    // Try adding lastDigit - k (avoid duplicates when k = 0)
    if (k != 0 && lastDigit - k >= 0) {
        backtrack(num * 10 + lastDigit - k, remainingDigits - 1, k, result, returnSize);
    }
}

int* numsSameConsecDiff(int n, int k, int* returnSize) {
    int* result = (int*)malloc(10000 * sizeof(int));
    *returnSize = 0;
    
    if (n == 1) {
        for (int i = 0; i <= 9; i++) {
            result[(*returnSize)++] = i;
        }
        return result;
    }
    
    // Start with each digit 1-9 (no leading zeros)
    for (int firstDigit = 1; firstDigit <= 9; firstDigit++) {
        backtrack(firstDigit, n - 1, k, result, returnSize);
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

In worst case, each digit has 2 choices (current + k and current - k), leading to 2^n possibilities

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth is n, plus space for storing results

⚡ Linearithmic Space

67.4K Views

Medium-High Frequency

~15 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

Backtracking (DFS Approach) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler