Maximum Number of Words You Can Type solution and explanation

def can_be_typed_words(text, broken_letters):
    broken = set(broken_letters)
    words = text.split()
    count = 0
    for word in words:
        if not set(word) & broken:
            count += 1
    return count

print(can_be_typed_words("hello world", "ad"))  # Output: 1

import java.util.*;

public class Solution {
    public int canBeTypedWords(String text, String brokenLetters) {
        Set<Character> broken = new HashSet<>();
        for (char c : brokenLetters.toCharArray()) {
            broken.add(c);
        }
        String[] words = text.split(" ");
        int count = 0;
        for (String word : words) {
            boolean isBroken = false;
            for (char c : word.toCharArray()) {
                if (broken.contains(c)) {
                    isBroken = true;
                    break;
                }
            }
            if (!isBroken) {
                count++;
            }
        }
        return count;
    }

    public static void main(String[] args) {
        Solution solution = new Solution();
        System.out.println(solution.canBeTypedWords("hello world", "ad")); // Output: 1
    }
}

#include <iostream>
#include <unordered_set>
#include <sstream>
using namespace std;

int canBeTypedWords(string text, string brokenLetters) {
    unordered_set<char> broken(brokenLetters.begin(), brokenLetters.end());
    stringstream ss(text);
    string word;
    int count = 0;
    while (ss >> word) {
        bool isBroken = false;
        for (char ch : word) {
            if (broken.count(ch)) {
                isBroken = true;
                break;
            }
        }
        if (!isBroken) {
            count++;
        }
    }
    return count;
}

int main() {
    cout << canBeTypedWords("hello world", "ad") << endl; // Output: 1
    return 0;
}

function canBeTypedWords(text, brokenLetters) {
    const broken = new Set(brokenLetters);
    const words = text.split(' ');
    let count = 0;
    for (const word of words) {
        if (![...word].some(ch => broken.has(ch))) {
            count++;
        }
    }
    return count;
}

console.log(canBeTypedWords("hello world", "ad")); // Output: 1

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

int canBeTypedWords(char * text, char * brokenLetters) {
    int count = 0;
    bool isBroken;
    char *word = strtok(text, " ");
    
    while (word != NULL) {
        isBroken = false;
        for (int i = 0; i < strlen(word); i++) {
            if (strchr(brokenLetters, word[i]) != NULL) {
                isBroken = true;
                break;
            }
        }
        if (!isBroken) {
            count++;
        }
        word = strtok(NULL, " ");
    }
    return count;
}

int main() {
    char text[] = "hello world";
    char brokenLetters[] = "ad";
    printf("%d\n", canBeTypedWords(text, brokenLetters)); // Output: 1
    return 0;
}

using System;
using System.Collections.Generic;

public class Solution {
    public int CanBeTypedWords(string text, string brokenLetters) {
        HashSet<char> broken = new HashSet<char>(brokenLetters);
        string[] words = text.Split(' ');
        int count = 0;
        foreach (string word in words) {
            bool isBroken = false;
            foreach (char ch in word) {
                if (broken.Contains(ch)) {
                    isBroken = true;
                    break;
                }
            }
            if (!isBroken) count++;
        }
        return count;
    }

    public static void Main(string[] args) {
        Solution solution = new Solution();
        Console.WriteLine(solution.CanBeTypedWords("hello world", "ad")); // Output: 1
    }
}

def can_be_typed_words(text, broken_letters):
    broken = set(broken_letters)
    words = text.split()
    return sum(1 for word in words if not set(word) & broken)

print(can_be_typed_words("hello world", "ad"))  # Output: 1

function canBeTypedWords(text, brokenLetters) {
    const broken = new Set(brokenLetters);
    const words = text.split(' ');
    let count = 0;
    words.forEach(word => {
        const wordSet = new Set(word);
        if (![...broken].some(brokenChar => wordSet.has(brokenChar))) {
            count += 1;
        }
    });
    return count;
}

console.log(canBeTypedWords("hello world", "ad")); // Output: 1

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;
}

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
}

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
    }
}