Number of Different Integers in a String - Practice Coding Problems

Number of Different Integers in a String - Problem

You're given a string word that contains a mix of digits and lowercase English letters. Your task is to extract all the integers from this string and count how many unique integers there are.

Here's how it works:

Replace every non-digit character with a space
This creates a sequence of integers separated by spaces
Count the number of different integers (ignoring leading zeros)

Example: "a123bc34d8ef34" becomes " 123 34 8 34"

The extracted integers are: 123, 34, 8, and 34. Since 34 appears twice, we have 3 unique integers.

Note: Leading zeros are ignored when comparing integers. For example, "01" and "1" represent the same integer.

Input & Output

example_1.py — Basic Mixed String

$ Input: word = "a123bc34d8ef34"

› Output: 3

💡 Note: After replacing non-digits with spaces, we get " 123 34 8 34". The unique integers are 123, 34, and 8. Note that 34 appears twice but is counted only once.

example_2.py — Leading Zeros

$ Input: word = "leet1234code234"

› Output: 2

💡 Note: After processing, we get " 1234 234". The unique integers are 1234 and 234, so the answer is 2.

example_3.py — Leading Zeros Edge Case

$ Input: word = "a1b01c001"

› Output: 1

💡 Note: After processing, we get " 1 01 001". When we remove leading zeros, all three become "1", so there's only 1 unique integer.

Visualization

Tap to expand

Understanding the Visualization

Scan Characters

Read each character, building integers when we see digits

Normalize Numbers

Remove leading zeros by converting to integer and back to string

Add to Set

Hash set automatically prevents duplicates

Count Result

Set size equals number of unique integers

Key Takeaway

🎯 Key Insight: Hash sets provide automatic deduplication - just normalize integers (remove leading zeros) and let the set handle uniqueness checking for you!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string of length n, hash set operations are O(1) average

✓ Linear Growth

Space Complexity

O(k)

Space for storing k unique integers in the hash set

✓ Linear Space

Constraints

1 ≤ word.length ≤ 1000
word consists of digits and lowercase English letters
Leading zeros are ignored when comparing integers

Asked in

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

The optimal approach uses a hash set to automatically handle uniqueness while parsing the string in a single pass. Extract integers by scanning character by character, normalize them by removing leading zeros (convert to int then back to string), and add to the set. The hash set size gives us the count of unique integers in O(n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Manual Parsing + List)	O(n²)	O(k)	Extract all integers into a list, then manually check for duplicates
One-Pass Hash Set (Optimal)	O(n)	O(k)	Extract integers and store in hash set for automatic deduplication in one pass

Brute Force (Manual Parsing + List) — Algorithm Steps

Iterate through the string and extract all integers
Store each integer (without leading zeros) in a list
For each integer in the list, check if it appears earlier
Count integers that haven't appeared before

Visualization

Tap to expand

Step-by-Step Walkthrough

Parse String

Scan each character and build integers

Store in List

Add each integer to a list (removing leading zeros)

Check Duplicates

For each integer, compare with all previous integers

Count Unique

Count integers that haven't appeared before

Code -

solution.c — C

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

int numDifferentIntegers(char* word) {
    char integers[1000][200];
    int count = 0;
    char current[200] = "";
    int currentLen = 0;
    
    for (int i = 0; word[i]; i++) {
        if (isdigit(word[i])) {
            current[currentLen++] = word[i];
        } else {
            if (currentLen > 0) {
                current[currentLen] = '\0';
                // Remove leading zeros
                int start = 0;
                while (start < currentLen - 1 && current[start] == '0') {
                    start++;
                }
                strcpy(integers[count++], &current[start]);
                currentLen = 0;
            }
        }
    }
    
    if (currentLen > 0) {
        current[currentLen] = '\0';
        int start = 0;
        while (start < currentLen - 1 && current[start] == '0') {
            start++;
        }
        strcpy(integers[count++], &current[start]);
    }
    
    int uniqueCount = 0;
    for (int i = 0; i < count; i++) {
        int isUnique = 1;
        for (int j = 0; j < i; j++) {
            if (strcmp(integers[j], integers[i]) == 0) {
                isUnique = 0;
                break;
            }
        }
        if (isUnique) {
            uniqueCount++;
        }
    }
    
    return uniqueCount;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n) to parse string + O(k²) to check duplicates where k is number of integers found

⚠ Quadratic Growth

Space Complexity

O(k)

Space for storing k integers in a list

✓ Linear Space

Constraints

1 ≤ word.length ≤ 1000
word consists of digits and lowercase English letters
Leading zeros are ignored when comparing integers

28.5K Views

Medium Frequency

~15 min Avg. Time

890 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

Brute Force (Manual Parsing + List) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler