##### Welcome to Subscribe On Youtube

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

# 1935. Maximum Number of Words You Can Type

Easy

## Description

There is a malfunctioning keyboard where some letter keys do not work. All other keys on the keyboard work properly.

Given a string text of words separated by a single space (no leading or trailing spaces) and a string brokenLetters of all distinct letter keys that are broken, return* the number of words in text you can fully type using this keyboard*.

Example 1:

Input: text = “hello world”, brokenLetters = “ad”

Output: 1

Explanation: We cannot type “world” because the ‘d’ key is broken.

Example 2:

Input: text = “leet code”, brokenLetters = “lt”

Output: 1

Explanation: We cannot type “leet” because the ‘l’ and ‘t’ keys are broken.

Example 3:

Input: text = “leet code”, brokenLetters = “e”

Output: 0

Explanation: We cannot type either word because the ‘e’ key is broken.

Constraints:

• 1 <= text.length <= 10^4
• 0 <= brokenLetters.length <= 26
• text consists of words separated by a single space without any leading or trailing spaces.
• Each word only consists of lowercase English letters.
• brokenLetters consists of distinct lowercase English letters.

## Solution

Use a hash set to store the letters in brokenLetters. Split text into an array of words. For each word, check whether there exists at least one letter in the word that is in the set. If so, the word cannot be typed. Finally, return the number of words that can be typed.

• class Solution {
public int canBeTypedWords(String text, String brokenLetters) {
Set<Character> set = new HashSet<Character>();
int brokenCount = brokenLetters.length();
for (int i = 0; i < brokenCount; i++)
int canType = 0;
String[] array = text.split(" ");
for (String word : array) {
boolean flag = true;
int length = word.length();
for (int i = 0; i < length; i++) {
char c = word.charAt(i);
if (set.contains(c)) {
flag = false;
break;
}
}
if (flag)
canType++;
}
return canType;
}
}

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

class Solution {
public int canBeTypedWords(String text, String brokenLetters) {
Set<Character> letters = new HashSet<>();
for (char c : brokenLetters.toCharArray()) {
}
int res = 0;
for (String word : text.split(" ")) {
boolean find = false;
for (char c : letters) {
if (word.indexOf(c) > -1) {
find = true;
break;
}
}
if (!find) {
++res;
}
}
return res;
}
}

• // OJ: https://leetcode.com/problems/maximum-number-of-words-you-can-type/
// Time: O(N)
// Space: O(1)
class Solution {
public:
int canBeTypedWords(string s, string broken) {
string word;
istringstream ss(s);
unordered_set<char> st(begin(broken), end(broken));
int ans = 0;
while (ss >> word) {
int i = 0;
for (; i < word.size() && st.count(word[i]) == 0; ++i);
ans += i == word.size();
}
return ans;
}
};

• class Solution:
def canBeTypedWords(self, text: str, brokenLetters: str) -> int:
letters = set(brokenLetters)
res = 0
for word in text.split():
find = False
for letter in letters:
if letter in word:
find = True
break
if not find:
res += 1
return res

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

# 1935. Maximum Number of Words You Can Type
# https://leetcode.com/problems/maximum-number-of-words-you-can-type

class Solution:
def canBeTypedWords(self, text: str, brokenLetters: str) -> int:
ss = set(brokenLetters)
text = text.split(" ")
res = len(text)

for t in text:
if set(t) & ss: res -= 1

return res


• func canBeTypedWords(text string, brokenLetters string) (ans int) {
s := [26]bool{}
for _, c := range brokenLetters {
s[c-'a'] = true
}
for _, w := range strings.Split(text, " ") {
for _, c := range w {
if s[c-'a'] {
ans--
break
}
}
ans++
}
return
}

• function canBeTypedWords(text: string, brokenLetters: string): number {
const s: boolean[] = Array(26).fill(false);
for (const c of brokenLetters) {
s[c.charCodeAt(0) - 'a'.charCodeAt(0)] = true;
}
let ans = 0;
for (const w of text.split(' ')) {
for (const c of w) {
if (s[c.charCodeAt(0) - 'a'.charCodeAt(0)]) {
--ans;
break;
}
}
++ans;
}
return ans;
}


• impl Solution {
pub fn can_be_typed_words(text: String, broken_letters: String) -> i32 {
let mut s = vec![false; 26];
for c in broken_letters.chars() {
s[c as usize - 'a' as usize] = true;
}
let mut ans = 0;
let words = text.split_whitespace();
for w in words {
for c in w.chars() {
if s[c as usize - 'a' as usize] {
ans -= 1;
break;
}
}
ans += 1;
}
ans
}
}