Welcome to Subscribe On Youtube

Formatted question description: https://leetcode.ca/all/1805.html

1805. Number of Different Integers in a String

Level

Easy

Description

You are given a string word that consists of digits and lowercase English letters.

You will replace every non-digit character with a space. For example, "a123bc34d8ef34" will become " 123 34 8 34". Notice that you are left with some integers that are separated by at least one space: "123", "34", "8", and "34".

Return the number of different integers after performing the replacement operations on word.

Two integers are considered different if their decimal representations without any leading zeros are different.

Example 1:

Input: word = “a123bc34d8ef34”

Output: 3

Explanation: The three different integers are “123”, “34”, and “8”. Notice that “34” is only counted once.

Example 2:

Input: word = “leet1234code234”

Output: 2

Example 3:

Input: word = “a1b01c001”

Output: 1

Explanation: The three integers “1”, “01”, and “001” all represent the same integer because the leading zeros are ignored when comparing their decimal values.

Constraints:

  • 1 <= word.length <= 1000
  • word consists of digits and lowercase English letters.

Solution

Use a set to store the integers in the form of strings. Loop over string word. If a complete integer is found, remove the leading zeros and added the integer into the set. Finally, return the set’s size.

  • class Solution {
    public int numDifferentIntegers(String word) {
        Set<String> set = new HashSet<String>();
        StringBuffer sb = new StringBuffer();
        int length = word.length();
        for (int i = 0; i < length; i++) {
            char c = word.charAt(i);
            if (Character.isDigit(c))
                sb.append(c);
            else {
                if (sb.length() > 0) {
                    String num = removeLeadingZeroes(sb.toString());
                    set.add(num);
                    sb.setLength(0);
                }
            }
        }
        if (sb.length() > 0) {
            String num = removeLeadingZeroes(sb.toString());
            set.add(num);
        }
        return set.size();
    }

    public String removeLeadingZeroes(String str) {
        int length = str.length();
        if (length == 1)
            return str;
        int start = 0;
        while (start < length - 1) {
            if (str.charAt(start) != '0')
                break;
            start++;
        }
        return str.substring(start);
    }
}

############

class Solution {
    public int numDifferentIntegers(String word) {
        Set<String> s = new HashSet<>();
        int n = word.length();
        for (int i = 0; i < n; ++i) {
            if (Character.isDigit(word.charAt(i))) {
                while (i < n && word.charAt(i) == '0') {
                    ++i;
                }
                int j = i;
                while (j < n && Character.isDigit(word.charAt(j))) {
                    ++j;
                }
                s.add(word.substring(i, j));
                i = j;
            }
        }
        return s.size();
    }
}

  • class Solution:
    def numDifferentIntegers(self, word: str) -> int:
        s = set()
        i, n = 0, len(word)
        while i < n:
            if word[i].isdigit():
                while i < n and word[i] == '0':
                    i += 1
                j = i
                while j < n and word[j].isdigit():
                    j += 1
                s.add(word[i:j])
                i = j
            i += 1
        return len(s)

############

# 1805. Number of Different Integers in a String
# https://leetcode.com/problems/number-of-different-integers-in-a-string/

class Solution:
    def numDifferentIntegers(self, word: str) -> int:
        s = set()
        
        tmp = ""
        for w in word+"a":
            if w in "12345667890":
                tmp += w
            else:
                if tmp != "":
                    while tmp and tmp[0] == "0":
                        tmp = tmp[1:]
                    s.add(tmp)
                tmp = ""

        return len(s)


  • class Solution {
public:
    int numDifferentIntegers(string word) {
        unordered_set<string> s;
        int n = word.size();
        for (int i = 0; i < n; ++i) {
            if (isdigit(word[i])) {
                while (i < n && word[i] == '0') ++i;
                int j = i;
                while (j < n && isdigit(word[j])) ++j;
                s.insert(word.substr(i, j - i));
                i = j;
            }
        }
        return s.size();
    }
};

  • func numDifferentIntegers(word string) int {
	s := map[string]struct{}{}
	n := len(word)
	for i := 0; i < n; i++ {
		if word[i] >= '0' && word[i] <= '9' {
			for i < n && word[i] == '0' {
				i++
			}
			j := i
			for j < n && word[j] >= '0' && word[j] <= '9' {
				j++
			}
			s[word[i:j]] = struct{}{}
			i = j
		}
	}
	return len(s)
}

  • function numDifferentIntegers(word: string): number {
    return new Set(
        word
            .replace(/\D+/g, ' ')
            .trim()
            .split(' ')
            .filter(v => v !== '')
            .map(v => v.replace(/^0+/g, '')),
    ).size;
}


  • use std::collections::HashSet;
impl Solution {
    pub fn num_different_integers(word: String) -> i32 {
        let s = word.as_bytes();
        let n = s.len();
        let mut set = HashSet::new();
        let mut i = 0;
        while i < n {
            if s[i] >= b'0' && s[i] <= b'9' {
                let mut j = i;
                while j < n && s[j] >= b'0' && s[j] <= b'9' {
                    j += 1;
                }
                while i < j - 1 && s[i] == b'0' {
                    i += 1;
                }
                set.insert(String::from_utf8(s[i..j].to_vec()).unwrap());
                i = j;
            } else {
                i += 1;
            }
        }
        set.len() as i32
    }
}

All Problems

All Solutions