Largest 3-Same-Digit Number in String - Practice Coding Problems

Largest 3-Same-Digit Number in String - Problem

String Easy

You are given a string num representing a large integer. Your task is to find the largest "good" integer within this string.

A good integer is defined as:

A substring of exactly 3 consecutive characters
All 3 characters must be the same digit

Return the maximum good integer as a string, or an empty string "" if no such integer exists.

Note: Leading zeros are allowed in both the input and output. For example, "000" is a valid good integer and is smaller than "111".

Examples:

"6777133339" → "777" (largest among "777" and "333")
"2300019" → "000"
"42352338" → "" (no consecutive identical digits)

Input & Output

example_1.py — Basic case with multiple good integers

$ Input: "6777133339"

› Output: "777"

💡 Note: The string contains two good integers: "777" and "333". Since "777" > "333" lexicographically, we return "777".

example_2.py — Good integer with zeros

$ Input: "2300019"

› Output: "000"

💡 Note: The string contains one good integer: "000". Even though it contains zeros, it's still a valid good integer.

example_3.py — No good integers

$ Input: "42352338"

› Output: ""

💡 Note: There are no three consecutive identical digits in this string, so we return an empty string.

Constraints

3 ≤ num.length ≤ 1000
num only consists of digits
Leading zeros are allowed in the result

Visualization

Tap to expand

Understanding the Visualization

Start scanning

Begin at the first position and examine groups of 3 consecutive characters

Check for matches

At each position, verify if the current character matches the next two

Update maximum

When a good integer is found, compare it with the current best and update if larger

Continue to end

Keep scanning until all possible positions are checked

Key Takeaway

🎯 Key Insight: A single pass through the string checking consecutive characters is sufficient to find the maximum good integer in O(n) time.

Asked in

a Amazon 35 G Google 28 ⊞ Microsoft 22 f Meta 15

This problem is optimally solved with a single pass approach in O(n) time. Simply iterate through the string and check each position for three consecutive identical characters. Keep track of the lexicographically largest good integer found. The key insight is that we can check all potential good integers in one pass without needing extra space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Substrings)	O(n)	O(1)	Check every possible 3-character substring and find the maximum good integer
One-Pass Optimal Solution	O(n)	O(1)	Single pass through string, checking consecutive identical characters

Brute Force (Check All Substrings) — Algorithm Steps

Iterate through each possible starting position (0 to n-3)
For each position, extract the 3-character substring
Check if all 3 characters are identical
If they are, compare with the current maximum and update if larger
Return the maximum good integer found, or empty string if none

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at position 0

Check if characters at positions 0, 1, 2 are identical

Move to position 1

Check if characters at positions 1, 2, 3 are identical

Continue sliding window

Keep checking until we reach the end of the string

Track maximum

Remember the lexicographically largest good integer found

Code -

solution.c — C

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

char* largestGoodInteger(char* num) {
    char* maxGood = (char*)malloc(4 * sizeof(char));
    strcpy(maxGood, "");
    
    int len = strlen(num);
    
    // Check all possible 3-character substrings
    for (int i = 0; i <= len - 3; i++) {
        // Check if all characters are the same
        if (num[i] == num[i+1] && num[i+1] == num[i+2]) {
            char substring[4];
            strncpy(substring, &num[i], 3);
            substring[3] = '\0';
            
            // Update max if this is larger
            if (strcmp(substring, maxGood) > 0) {
                strcpy(maxGood, substring);
            }
        }
    }
    
    return maxGood;
}

int main() {
    char num[1001];
    scanf("%s", num);
    
    // Remove quotes if present
    if (num[0] == '"') {
        int len = strlen(num);
        memmove(num, num + 1, len - 2);
        num[len - 2] = '\0';
    }
    
    char* result = largestGoodInteger(num);
    printf("\"%s\"\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We iterate through the string once, and each substring check is O(1)

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track the maximum

✓ Linear Space

26.8K Views

Medium Frequency

~12 min Avg. Time

892 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 (Check All Substrings) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler