 # Leetcode 1805. Number of Different Integers in a String Solution

## Problem Description

In this problem, you are given a string `word` that consists of digits and lowercase English letters. The goal is to replace every non-digit character with a space and then find the number of different integers in the modified string. Two integers are considered different if their decimal representations without any leading zeros are different.

Let's walk through an example:

Example:

``````1Input: word = "a123bc34d8ef34"
2Output: 3``````

In this example, after replacing non-digit characters with spaces, we have the following string:

``1" 123  34 8  34"``

Now, we can extract the integers present in this string, which are "123", "34", "8", and "34". Notice that "34" appears twice, but we only count it once since we're interested in the number of different integers. Hence, the answer is 3 because there are three unique integers: "123", "34", and "8".

## Approach

This problem can be solved by following these steps:

1. Replace all non-digit characters with spaces and split the string using spaces.
2. Iterate through the resulting list, get rid of any leading zeros, and track unique integers using a set.
3. Return the size of the set.

Let's see how this approach works on our example:

``1word = "a123bc34d8ef34"``
1. Replace non-digit characters and split:

``1" 123  34 8  34".split() => ["123", "34", "8", "34"]``
2. Iterate through the list and add unique integers to a set:

``1{123, 34, 8}``
3. Return the size of the set:

``13``

Now let's implement this approach in different programming languages.

## Python Solution

``````1class Solution:
2    def numDifferentIntegers(self, word: str) -> int:
3        # Replace non-digit characters with spaces and split the string
4        nums = word.translate(str.maketrans('abcdefghijklmnopqrstuvwxyz', ' ' * 26)).split()
5
6        # Use a set to store unique integers (ignoring leading zeros)
7        unique_ints = set(int(num) for num in nums)
8
9        return len(unique_ints)``````

## Java Solution

``````1import java.util.HashSet;
2import java.util.Set;
3
4class Solution {
5    public int numDifferentIntegers(String word) {
6        String noLetters = word.replaceAll("[a-z]", " ");
7        String[] nums = noLetters.split("\\s+");
8        Set<Integer> uniqueInts = new HashSet<>();
9
10        for (String num : nums) {
11            if (!num.isEmpty()) {
13            }
14        }
15
16        return uniqueInts.size();
17    }
18}``````

## JavaScript Solution

``````1class Solution {
2    numDifferentIntegers(word) {
3        const nums = word.split(/[a-z]/).filter(e => e !== '');
4        const uniqueInts = new Set(nums.map(num => parseInt(num, 10)));
5
6        return uniqueInts.size;
7    }
8}``````

## C++ Solution

``````1#include <set>
2#include <sstream>
3#include <algorithm>
4
5class Solution {
6public:
7    int numDifferentIntegers(std::string word) {
8        std::set<int> uniqueInts;
9        std::for_each(word.begin(), word.end(), [](char& c) {
10            if ('a' <= c && c <= 'z') c = ' ';
11        });
12
13        std::istringstream iss(word);
14        int num;
15        while (iss >> num) {
16            uniqueInts.insert(num);
17        }
18
19        return uniqueInts.size();
20    }
21};``````

## C# Solution

``````1using System.Collections.Generic;
2using System.Text.RegularExpressions;
3
4public class Solution {
5    public int NumDifferentIntegers(string word) {
6        string[] nums = Regex.Split(word, "[a-z]+");
7        HashSet<int> uniqueInts = new HashSet<int>();
8
9        foreach (string num in nums) {
10            if (num != "") {