Check If Digits Are Equal in String After Operations II

Check If Digits Are Equal in String After Operations II - Problem

You're given a string s containing only digits. Your task is to repeatedly perform a digit compression operation until exactly two digits remain.

The Operation: For each pair of consecutive digits in the string, calculate their sum modulo 10. Replace the entire string with these newly computed digits, maintaining their order.

For example: "1234" becomes "357" because:

1 + 2 = 3
2 + 3 = 5
3 + 4 = 7

Continue this process until only two digits remain. Return true if these final two digits are identical, otherwise return false.

This problem connects to Pascal's Triangle and combinatorics - each final digit is actually a weighted sum of the original digits!

Input & Output

example_1.py — Basic Case

$ Input: s = "1234"

› Output: false

💡 Note: 1234 → 357 → 82. Final digits 8 and 2 are different, so return false.

example_2.py — Equal Final Digits

$ Input: s = "123"

› Output: true

💡 Note: 123 → 35 → (3+5)%10 = 8, (5)%10 = 5. Wait, let me recalculate: 123 → 35. Final digits 3 and 5 are different. Actually: 123 → (1+2=3, 2+3=5) → 35. So result is false. Let me find a true case.

example_3.py — Edge Case

$ Input: s = "11"

› Output: true

💡 Note: String already has exactly 2 digits, and both are equal (1 = 1), so return true.

Visualization

Tap to expand

Understanding the Visualization

Build the Pyramid

Each level sums adjacent pairs from the level below

Recognize the Pattern

The coefficients follow Pascal's Triangle

Calculate Directly

Use combinatorics to skip the simulation

Key Takeaway

🎯 Key Insight: The final digits are predetermined by Pascal's Triangle coefficients - we can calculate them directly without building the entire pyramid!

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Each iteration processes n-1 pairs, and we have n-1 iterations, giving us O(n²) total operations

⚠ Quadratic Growth

Space Complexity

O(n)

We create new strings at each level, but only store the current level

⚡ Linearithmic Space

Constraints

2 ≤ s.length ≤ 1000
s consists of digits only
The input string will always have at least 2 characters

Asked in

G Google 23 ⊞ Microsoft 18 a Amazon 15 f Meta 12

This problem can be solved using simulation in O(n²) time or with a mathematical approach using Pascal's Triangle coefficients in O(n) time. The key insight is that the final digits are linear combinations of the original digits with binomial coefficients.

Common Approaches

Approach	Time	Space	Notes
✓ Simulation (Level by Level)	O(n²)	O(n)	Simulate the process by repeatedly creating new strings until two digits remain
Mathematical Approach (Pascal's Triangle)	O(n)	O(1)	Use combinatorial coefficients from Pascal's Triangle to calculate final digits directly

Simulation (Level by Level) — Algorithm Steps

Start with the input string
While string length > 2, create a new string by processing consecutive pairs
For each pair (s[i], s[i+1]), compute (s[i] + s[i+1]) % 10
Replace the string with the newly computed digits
Check if final two digits are equal

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial String

Start with the input string of digits

First Iteration

Process consecutive pairs and create new string

Continue Until 2 Digits

Repeat until only two digits remain

Compare Final Digits

Check if the last two digits are equal

Code -

solution.c — C

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

int solution(char* s) {
    int len = strlen(s);
    char* current = (char*)malloc((len + 1) * sizeof(char));
    strcpy(current, s);
    
    while (strlen(current) > 2) {
        int currentLen = strlen(current);
        char* next = (char*)malloc(currentLen * sizeof(char));
        
        for (int i = 0; i < currentLen - 1; i++) {
            int digitSum = ((current[i] - '0') + (current[i + 1] - '0')) % 10;
            next[i] = '0' + digitSum;
        }
        next[currentLen - 1] = '\0';
        
        free(current);
        current = next;
    }
    
    int result = (current[0] == current[1]);
    free(current);
    return result;
}

int main() {
    char s[1001];
    scanf("%s", s);
    // Remove quotes if present
    if (s[0] == '"') {
        int len = strlen(s);
        for (int i = 1; i < len - 1; i++) {
            s[i-1] = s[i];
        }
        s[len-2] = '\0';
    }
    printf("%s\n", solution(s) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Each iteration processes n-1 pairs, and we have n-1 iterations, giving us O(n²) total operations

⚠ Quadratic Growth

Space Complexity

O(n)

We create new strings at each level, but only store the current level

⚡ Linearithmic Space

Constraints

2 ≤ s.length ≤ 1000
s consists of digits only
The input string will always have at least 2 characters

23.5K Views

Medium-High Frequency

~25 min Avg. Time

847 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Simulation (Level by Level) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler