# Solving Leetcode Interviews in Seconds with AI: Maximum Number of Words You Can Type


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "1935" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> 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 <= 104 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.  

	# Explanation
	Here's an efficient solution to the problem, along with explanations:

*   **High-level Approach:**
    *   Split the input text into individual words.
    *   Iterate through each word and check if any of the broken letters are present in the word.
    *   Count the words that can be typed (i.e., do not contain any broken letters).

*   **Complexity:**
    *   Runtime Complexity: O(N * M), where N is the number of words in the text and M is the average length of a word.
    *   Storage Complexity: O(1) (excluding the space used to store the input strings and the split words array, which are inherent to the problem). We are using only a few integer variables.

	
	# Code
	```python
	def can_be_typed_words(text: str, brokenLetters: str) -> int:
    """
    Counts the number of words in text that can be fully typed using a malfunctioning keyboard.

    Args:
        text: A string of words separated by a single space.
        brokenLetters: A string of distinct broken letter keys.

    Returns:
        The number of words in text that can be fully typed.
    """

    words = text.split()
    count = 0
    for word in words:
        can_type = True
        for char in brokenLetters:
            if char in word:
                can_type = False
                break
        if can_type:
            count += 1
    return count
	```