Check If Digits Are Equal in String After Operations I

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

Math String Simulation Combinatorics Number Theory Easy

You are given a string s consisting of digits. Your task is to simulate a digit reduction process that repeatedly combines adjacent digits until only two digits remain.

The Process:

For each pair of consecutive digits in s, starting from the first digit, calculate a new digit as (digit1 + digit2) % 10
Replace the entire string with these newly calculated digits
Repeat until exactly two digits remain

Goal: Return true if the final two digits are identical, false otherwise.

Example: "123" → "15" (1+2=3, 2+3=5) → Since 1 ≠ 5, return false

Input & Output

example_1.py — Basic Case

$ Input: s = "1234"

› Output: false

💡 Note: Step 1: "1234" → "357" (1+2=3, 2+3=5, 3+4=7). Step 2: "357" → "82" (3+5=8, 5+7=12→2). Final digits 8 and 2 are different, so return false.

example_2.py — Equal Result

$ Input: s = "12"

› Output: true

💡 Note: String already has exactly 2 digits. Since we need exactly 2 digits to stop, and 1 ≠ 2, this would be false. Wait, let me recalculate: if we have "12", we stop immediately and check 1 == 2, which is false.

example_3.py — Single Reduction

$ Input: s = "999"

› Output: true

💡 Note: Step 1: "999" → "88" (9+9=18→8, 9+9=18→8). Final digits are both 8, so return true.

Visualization

Tap to expand

Understanding the Visualization

Parse Input

Convert string digits to integer array for easier manipulation

Iterative Reduction

While more than 2 digits exist, combine adjacent pairs using modulo 10

Create New Sequence

Each iteration produces a sequence one element shorter

Final Comparison

Compare the last two remaining digits for equality

Key Takeaway

🎯 Key Insight: This problem requires faithful simulation - there are no mathematical shortcuts to skip the iterative reduction process.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, we process n + (n-1) + (n-2) + ... + 2 = O(n²) digit operations

⚠ Quadratic Growth

Space Complexity

O(n)

We store intermediate results in arrays/strings of decreasing size

⚡ Linearithmic Space

Constraints

2 ≤ s.length ≤ 1000
s consists of digits only
s contains at least 2 digits initially

Asked in

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

This problem requires direct simulation of the digit reduction process. We repeatedly combine adjacent digits using (a + b) % 10 until exactly two digits remain, then check if they're equal. The time complexity is O(n²) where n is the initial string length.

Common Approaches

Approach	Time	Space	Notes
✓ Direct Simulation (Optimal)	O(n²)	O(n)	Simulate the digit combination process step by step until two digits remain

Direct Simulation (Optimal) — Algorithm Steps

Convert string to list of integers for easier manipulation
While length > 2, create new list by combining adjacent pairs
For each consecutive pair (i, i+1), compute (digit[i] + digit[i+1]) % 10
Replace current list with the new combined results
Return true if final two digits are equal

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial String

Start with the input string of digits

First Reduction

Combine each adjacent pair using modulo 10

Continue Process

Repeat until exactly two digits remain

Final Check

Compare the final two digits for equality

Code -

solution.c — C

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

bool areDigitsEqual(char* s) {
    int len = strlen(s);
    int digits[1000];
    
    // Convert string to int array
    for (int i = 0; i < len; i++) {
        digits[i] = s[i] - '0';
    }
    
    while (len > 2) {
        int newDigits[1000];
        for (int i = 0; i < len - 1; i++) {
            newDigits[i] = (digits[i] + digits[i + 1]) % 10;
        }
        len--;
        for (int i = 0; i < len; i++) {
            digits[i] = newDigits[i];
        }
    }
    
    return digits[0] == digits[1];
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, we process n + (n-1) + (n-2) + ... + 2 = O(n²) digit operations

⚠ Quadratic Growth

Space Complexity

O(n)

We store intermediate results in arrays/strings of decreasing size

⚡ Linearithmic Space

Constraints

2 ≤ s.length ≤ 1000
s consists of digits only
s contains at least 2 digits initially

23.3K Views

Medium Frequency

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

Direct Simulation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler