Find the Punishment Number of an Integer - Practice Coding Problems

Find the Punishment Number of an Integer - Problem

Math Backtracking Medium

Given a positive integer n, return the punishment number of n.

The punishment number is a fascinating mathematical concept that challenges us to find special integers with unique digit properties. For an integer i to contribute to the punishment number, its square must have a remarkable property: its digits can be split into contiguous groups that sum back to the original number!

Definition: The punishment number of n is the sum of squares of all integers i where:

1 ≤ i ≤ n
The decimal representation of i² can be partitioned into contiguous substrings such that the sum of these substring values equals i

Example: For i = 10, we have i² = 100. We can partition "100" as "1" + "00" = 1 + 0 = 1 ≠ 10, or "10" + "0" = 10 + 0 = 10 ✓. Since the sum equals the original number, 10 contributes 10² = 100 to the punishment number.

Input & Output

example_1.py — Basic Case

$ Input: n = 10

› Output: 182

💡 Note: Numbers 1, 9, and 10 are punishment numbers. 1² = 1 ("1" = 1), 9² = 81 ("81" = 81 ≠ 9, "8"+"1" = 9 ✓), 10² = 100 ("10"+"0" = 10 ✓). Sum = 1 + 81 + 100 = 182.

example_2.py — Smaller Case

$ Input: n = 37

› Output: 1478

💡 Note: Punishment numbers ≤ 37 are: 1, 9, 10, 36. Their squares are 1, 81, 100, 1296. For 36: 36² = 1296, and "1"+"2"+"9"+"6" = 18 ≠ 36, but "12"+"9"+"6" = 27 ≠ 36, "1"+"29"+"6" = 36 ✓. Sum = 1 + 81 + 100 + 1296 = 1478.

example_3.py — Edge Case

$ Input: n = 1

› Output: 1

💡 Note: Only number 1 exists. 1² = 1, and "1" = 1, so it's a punishment number. Result = 1.

Constraints

1 ≤ n ≤ 1000
The answer is guaranteed to fit in a 32-bit integer

Visualization

Tap to expand

Understanding the Visualization

Square Investigation

Take each number i and create its square 'fingerprint' i²

Digit Splitting

Try all possible ways to split the square's digits into contiguous groups

Sum Verification

Check if any splitting arrangement sums back to the original number i

Evidence Collection

If verified, add i² to the punishment number total

Key Takeaway

🎯 Key Insight: Use backtracking to systematically explore all possible digit partitions, with memoization to cache subproblem results and avoid redundant computations.

Asked in

G Google 12 a Amazon 8 ⊞ Microsoft 6 f Meta 4

The optimal approach uses backtracking with memoization to efficiently check if each number's square can be partitioned. For each number i from 1 to n, we compute i² and use recursive partitioning to find if its digits can be split into contiguous substrings that sum to i. Memoization prevents redundant computations, reducing time complexity from O(n × 2^d) to O(n × d × target).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force with Recursive Partitioning	O(n * 2^d)	O(d)	Check each number by trying all possible digit partitions of its square
Optimized with Memoization	O(n * d * target)	O(d * target)	Use memoization to cache results of partition checks for better performance

Brute Force with Recursive Partitioning — Algorithm Steps

Iterate through all numbers i from 1 to n
For each i, compute i² and convert to string
Use backtracking to generate all possible partitions of the digit string
For each partition, sum the substring values and check if equals i
If any partition sums to i, add i² to the result

Visualization

Tap to expand

Step-by-Step Walkthrough

Square the number

Convert i² to string of digits

Try all partitions

Use backtracking to explore all possible ways to split digits

Check sum

For each partition, sum the parts and compare to original number

Code -

solution.c — C

bool canPartition(char* s, int target, int index, int len) {
    if (index == len) {
        return target == 0;
    }
    
    for (int i = index + 1; i <= len; i++) {
        char temp = s[i];
        s[i] = '\0';
        int num = atoi(s + index);
        s[i] = temp;
        
        if (num <= target && canPartition(s, target - num, i, len)) {
            return true;
        }
    }
    return false;
}

int punishmentNumber(int n) {
    int result = 0;
    for (int i = 1; i <= n; i++) {
        int square = i * i;
        char squareStr[20];
        sprintf(squareStr, "%d", square);
        int len = strlen(squareStr);
        
        if (canPartition(squareStr, i, 0, len)) {
            result += square;
        }
    }
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * 2^d)

For each of n numbers, we explore 2^d possible partitions where d is the number of digits in i²

✓ Linear Growth

Space Complexity

O(d)

Recursion stack depth is at most d digits

✓ Linear Space

24.5K Views

Medium Frequency

~25 min Avg. Time

890 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

Brute Force with Recursive Partitioning — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler