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. An integer is good if it meets the following conditions:

It is a substring of num with length 3.
It consists of only one unique digit.

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

Note:

A substring is a contiguous sequence of characters within a string.
There may be leading zeroes in num or a good integer.

Input & Output

Example 1 — Multiple Good Integers

$ Input: num = "6777133"

› Output: "777"

💡 Note: The good integers are "777" and "333". Since "777" > "333", we return "777".

Example 2 — No Good Integer

$ Input: num = "2300019"

› Output: "000"

💡 Note: The only good integer is "000" (three consecutive zeros).

Example 3 — No Valid Triplets

$ Input: num = "42352338"

› Output: ""

💡 Note: No substring of length 3 consists of only one unique digit.

Constraints

3 ≤ num.length ≤ 1000
num only consists of digits.

Visualization

Tap to expand

Understanding the Visualization

Input

String containing digits: "6777133"

Process

Find all 3-character substrings with identical digits

Output

Return the lexicographically largest: "777"

Key Takeaway

🎯 Key Insight: Scan for consecutive identical triplets and track the lexicographically largest one

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to scan through the string and identify 3 consecutive identical digits, then keep track of the lexicographically largest such substring. Best approach is the optimized single pass with direct character comparison. Time: O(n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Single Pass	O(n)	O(1)	Scan once and immediately identify valid 3-digit sequences when found
Brute Force - Check All Substrings	O(n)	O(1)	Check every possible 3-character substring and find the maximum valid one

Optimized Single Pass — Algorithm Steps

Step 1: Initialize result as empty string
Step 2: Scan string, when we find 3 consecutive identical chars, we have a candidate
Step 3: Compare candidate with current result and keep the larger one

Visualization

Tap to expand

Step-by-Step Walkthrough

Compare Characters

Check if num[i] == num[i+1] == num[i+2] directly

Found Match

When found, extract the 3-character substring

Update Maximum

Compare with current best and update if needed

Code -

solution.c — C

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

char* solution(char* num) {
    int len = strlen(num);
    char* maxGood = malloc(4 * sizeof(char));
    strcpy(maxGood, "");
    
    for (int i = 0; i <= len - 3; i++) {
        if (num[i] == num[i+1] && num[i+1] == num[i+2]) {
            char candidate[4];
            strncpy(candidate, num + i, 3);
            candidate[3] = '\0';
            
            if (strcmp(candidate, maxGood) > 0) {
                strcpy(maxGood, candidate);
            }
        }
    }
    
    return maxGood;
}

int main() {
    char num[1001];
    fgets(num, sizeof(num), stdin);
    num[strcspn(num, "\n")] = 0;
    
    char* result = solution(num);
    printf("%s\n", result);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, constant work per character

✓ Linear Growth

Space Complexity

O(1)

Only storing the result string, no extra data structures

✓ Linear Space

23.4K 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

Optimized Single Pass — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler