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. Perform the following operation repeatedly until the string has exactly two digits:

For each pair of consecutive digits in s, starting from the first digit, calculate a new digit as the sum of the two digits modulo 10.
Replace s with the sequence of newly calculated digits, maintaining the order in which they are computed.

Return true if the final two digits in s are the same; otherwise, return false.

Input & Output

Example 1 — Basic Case

$ Input: s = "1234"

› Output: false

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

Example 2 — Equal Result

$ Input: s = "999"

› Output: true

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

Example 3 — Two Digits

$ Input: s = "12"

› Output: false

💡 Note: String already has two digits. 1 ≠ 2, so return false.

Constraints

2 ≤ s.length ≤ 1000
s consists of digits only

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 8

The key insight is to simulate the digit combination process round by round until only two digits remain. Each round reduces the string length by 1, so we need exactly n-2 rounds. Best approach uses direct simulation with efficient string building. Time: O(n²), Space: O(n)

Common Approaches

✓ Direct Simulation

⏱️ Time: O(n²) Space: O(n)

Create new string each round by combining adjacent digits. Continue until string length is 2, then check if both digits are equal.

Optimized String Building

⏱️ Time: O(n²) Space: O(n)

Same simulation approach but uses efficient string building techniques to reduce memory allocations and improve performance.

Direct Simulation — Algorithm Steps

Start with input string
For each round, combine adjacent digit pairs
Replace string with new combined digits
Repeat until length is 2
Check if final digits are equal

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial String

Start with input string

Combine Adjacent

Sum adjacent pairs mod 10

Check Result

Compare final two digits

Code -

solution.c — C

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

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

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    int result = solution(s);
    printf(result ? "true\n" : "false\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Each round takes O(n) time and we need n-2 rounds, so total is O(n²)

⚠ Quadratic Growth

Space Complexity

O(n)

Store intermediate strings during the simulation process

⚡ Linearithmic Space

12.5K Views

Medium Frequency

~15 min Avg. Time

235 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

Direct Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler