Second Largest Digit in a String - Practice Coding Problems

Second Largest Digit in a String - Problem

Given an alphanumeric string s, you need to find the second largest numerical digit that appears in the string. If no second largest digit exists, return -1.

An alphanumeric string consists of lowercase English letters and digits (0-9). Your task is to ignore all letters and focus only on the numerical digits present in the string.

Key Points:

Only consider digits (0-9), ignore all letters
Find the second largest unique digit
If there are fewer than 2 unique digits, return -1
Duplicate digits are treated as the same value

Example: In string "dfa12321afd", the digits are [1,2,3,2,1]. Unique digits in descending order: [3,2,1]. The second largest is 2.

Input & Output

example_1.py — Basic Case

$ Input: s = "dfa12321afd"

› Output: 2

💡 Note: The digits in the string are [1,2,3,2,1]. The unique digits in descending order are [3,2,1]. The second largest unique digit is 2.

example_2.py — Single Digit

$ Input: s = "abc1111"

› Output: -1

💡 Note: The only digit present is 1. Since there's only one unique digit, there is no second largest digit, so we return -1.

example_3.py — No Digits

$ Input: s = "abcdef"

› Output: -1

💡 Note: There are no digits in the string, only letters. Since we need at least 2 unique digits to find a second largest, we return -1.

Constraints

1 ≤ s.length ≤ 500
s consists of only lowercase English letters and digits
Return -1 if no second largest digit exists

Visualization

Tap to expand

Understanding the Visualization

Setup Podium

Initialize gold and silver positions as empty (-1)

Contestants Arrive

Each digit in the string steps forward to compete

Medal Assignment

If a digit beats the current gold medalist, gold moves to silver and new digit takes gold

Award Ceremony

Return the silver medalist (second largest) or -1 if no silver exists

Key Takeaway

🎯 Key Insight: We only need to track the top 2 performers (digits) as we scan through the contestants (string), making this an optimal O(n) solution!

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 12 Apple 8

The optimal solution uses a one-pass tracking approach with O(n) time and O(1) space complexity. We maintain two variables to track the largest and second largest unique digits while scanning through the string once. This avoids the overhead of sorting or using additional data structures, making it the most efficient approach for this problem.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Extract and Sort)	O(n log n)	O(n)	Extract all digits, remove duplicates, sort, and find second largest
One-Pass Tracking (Optimal)	O(n)	O(1)	Track first and second largest digits in a single pass through the string

Brute Force (Extract and Sort) — Algorithm Steps

Iterate through the string and collect all digit characters
Convert the list to a set to remove duplicates
Sort the unique digits in descending order
Return the second element if it exists, otherwise return -1

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Digits

Scan string and collect all digit characters

Remove Duplicates

Convert to set to keep only unique digits

Sort Descending

Sort unique digits from largest to smallest

Pick Second

Return the element at index 1 if exists

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)b - *(int*)a);
}

int secondHighest(char* s) {
    int digits[1000], count = 0;
    int len = strlen(s);
    
    for (int i = 0; i < len; i++) {
        if (s[i] >= '0' && s[i] <= '9') {
            digits[count++] = s[i] - '0';
        }
    }
    
    int unique[10], uniqueCount = 0;
    for (int i = 0; i < count; i++) {
        int found = 0;
        for (int j = 0; j < uniqueCount; j++) {
            if (unique[j] == digits[i]) {
                found = 1;
                break;
            }
        }
        if (!found) {
            unique[uniqueCount++] = digits[i];
        }
    }
    
    qsort(unique, uniqueCount, sizeof(int), compare);
    
    if (uniqueCount < 2) {
        return -1;
    }
    return unique[1];
}

int main() {
    char s[1001];
    scanf("%s", s);
    printf("%d\n", secondHighest(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n) to scan string + O(k log k) to sort unique digits where k ≤ 10, dominated by sorting

⚡ Linearithmic

Space Complexity

O(n)

O(n) space to store extracted digits, though at most 10 unique digits

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~15 min Avg. Time

850 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 (Extract and Sort) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler