Jobs

Interviews

Discussions

To Be Or Not To Be

Easy

Asked by:

More companies

71 views

Write a function expect that helps developers test their code. It should take in any value val and return an object with the following two functions.

toBe(val) accepts another value and returns true if the two values === each other. If they are not equal, it should throw an error "Not Equal".
notToBe(val) accepts another value and returns true if the two values !== each other. If they are equal, it should throw an error "Equal".

Example 1:

Input: func = () => expect(5).toBe(5)
Output: {"value": true}
Explanation: 5 === 5 so this expression returns true.

Example 2:

Input: func = () => expect(5).toBe(null)
Output: {"error": "Not Equal"}
Explanation: 5 !== null so this expression throw the error "Not Equal".

Example 3:

Input: func = () => expect(5).notToBe(null)
Output: {"value": true}
Explanation: 5 !== null so this expression returns true.

Try coding it in LeetCode

To Be Or Not To Be

Easy

Asked by:

71 views

Write a function expect that helps developers test their code. It should take in any value val and return an object with the following two functions.

toBe(val) accepts another value and returns true if the two values === each other. If they are not equal, it should throw an error "Not Equal".
notToBe(val) accepts another value and returns true if the two values !== each other. If they are equal, it should throw an error "Equal".

Example 1:

Input: func = () => expect(5).toBe(5)
Output: {"value": true}
Explanation: 5 === 5 so this expression returns true.

Example 2:

Input: func = () => expect(5).toBe(null)
Output: {"error": "Not Equal"}
Explanation: 5 !== null so this expression throw the error "Not Equal".

Example 3:

Input: func = () => expect(5).notToBe(null)
Output: {"value": true}
Explanation: 5 !== null so this expression returns true.

Try coding it in LeetCode

Solution

Clarifying Questions

When you get asked this question in a real-life environment, it will often be ambiguous (especially at FAANG). Make sure to ask these questions in that case:

Is the input `boolValue` strictly a boolean value (true or false), or can it be any other type that might be interpreted as truthy or falsy?
Should the returned string be capitalized exactly as 'True' and 'False', or is case-insensitivity acceptable (e.g., 'true', 'FALSE')?
Are there any memory constraints I should be aware of for this seemingly simple operation?
Should I handle potential null or undefined input values, and if so, how should they be represented as a string?
Although this seems straightforward, are there any hidden or unexpected edge cases I should consider beyond the basic true/false inputs?

Brute Force Solution

Approach

The brute force method for this problem is like trying every single possible outcome to see if it meets the conditions. We go through each possibility step-by-step until we either find the right one or exhaust all the options. It's thorough but can be slow.

Here's how the algorithm would work step-by-step:

Consider the first item and see if it satisfies the condition by itself.
Next, check the first two items together to see if they satisfy the condition.
Continue this process by adding one more item at a time and checking if the current combination satisfies the condition.
Repeat this process, starting now with the second item as the first entry of a potential solution, then with the third, fourth and so on. This way, we are sure we cover all possible sub-groupings of the total items.
Once you've checked every possible combination of items, compare all of the combinations that satisfied the conditions.
Finally, return the best combination found, according to what 'best' means in the context of the problem.

Code Implementation

def find_best_combination_brute_force(items, condition_function, quality_function):
    best_combination = None
    best_quality = float('-inf')

    for start_index in range(len(items)):
        for end_index in range(start_index, len(items)):
            # Create a combination from start_index to end_index
            current_combination = items[start_index:end_index + 1]

            # Check if the current combination meets the specified condition
            if condition_function(current_combination):

                # Calculate the quality of the current combination
                current_quality = quality_function(current_combination)

                # Determine if the current combination improves upon the best found so far
                if current_quality > best_quality:
                    best_quality = current_quality
                    best_combination = current_combination

    return best_combination

Big(O) Analysis

Time Complexity

O(n^2) – The provided brute force approach considers all possible sub-groupings (subarrays or subsequences) within the input of size n. For each starting element, the algorithm iterates through the remaining elements to form combinations, resulting in nested loops. Specifically, for the first element, we potentially check n-1 elements, for the second n-2, and so on. The total number of operations is proportional to the sum 1 + 2 + ... + (n-1), which approximates n * (n-1) / 2. Therefore, the time complexity simplifies to O(n^2).

Space Complexity

O(N) – The brute force method, as described, considers subgroups of items. In the worst-case scenario, it might need to store a combination of items that includes almost all N items to check if it satisfies the condition. This implies the need for a temporary data structure (e.g., a list) to hold these items. Additionally, the algorithm needs to store the 'best' combination found so far, which, in the worst case, could also contain close to N items. Therefore, the auxiliary space used grows linearly with the input size N, leading to a space complexity of O(N).

Optimal Solution

Approach

The goal is to efficiently determine if we can transform one word into another by only changing one letter at a time, using a dictionary of valid words. We'll use a method that explores possible word transformations in a focused way, avoiding redundant paths.

Here's how the algorithm would work step-by-step:

Start by putting the beginning word onto a list of words to explore.
While there are still words to explore, take the first word from the list.
Figure out all possible words you can create from that word by changing just one letter, and check if those new words are valid (in the dictionary) and haven't been explored yet.
If you find a valid new word that is the same as the ending word, you are done!
If you find a valid new word that is *not* the ending word, add it to the list of words to explore, so you can check *its* one-letter-different neighbors later.
If you run out of words to explore without finding the ending word, it means there's no way to get from the start to the end.

Code Implementation

def can_transform(begin_word, end_word, word_list):
    word_set = set(word_list)
    if end_word not in word_set:
        return False

    words_to_explore = [begin_word]
    visited_words = {begin_word}

    while words_to_explore:
        current_word = words_to_explore.pop(0)

        for i in range(len(current_word)):
            for char_code in range(ord('a'), ord('z') + 1):
                new_char = chr(char_code)
                new_word = current_word[:i] + new_char + current_word[i+1:]

                if new_word == end_word:
                    return True

                # Only explore valid, unvisited words
                if new_word in word_set and new_word not in visited_words:

                    words_to_explore.append(new_word)

                    #Mark as visited to avoid infinite loops
                    visited_words.add(new_word)

    # If we exhaust all possibilities, there's no transformation
    return False

Big(O) Analysis

Time Complexity

O(N * M^2 * L) – Let N be the number of words in the dictionary, M be the average length of a word, and L be the length of the word being transformed. The breadth-first search explores words. In the worst case, we might visit all N words. For each word visited, we generate all possible one-letter variations. Changing one letter at a time takes M steps, and for each of the M positions, we have approximately 26 possible letters to try (ignoring the original letter), giving us M * 26, so roughly M possible new words. The dictionary lookup to validate each new word takes O(L) where L is the length of the word. Therefore, the total time complexity is approximately O(N * M * L). However, M can be seen as a constant factor dependent on the size of the dictionary. Also, generating possible neighbor words is at most the word length M times the number of possible characters for each position which is a constant which we can express as M. Thus, the number of neighbors checked will be at most M. Hence, the total time complexity can be approximated to O(N * M^2 * L), where M is the average length of the words checked and L is the length of the words in the dictionary. This accounts for word generation and validation across all possible words in the dictionary during our breadth-first search. In simplified terms, the algorithm checks all N words in the dictionary, for each word generating up to M possible neighboring words, and checking their validity which takes O(L) time

Space Complexity

O(N) – The algorithm uses a list to explore words and a mechanism to track visited words. In the worst-case scenario, the list of words to explore could contain all N words from the dictionary if each word is a valid transformation from the start word and the end word is unreachable. Similarly, the set of visited words could also store up to N words to prevent redundant exploration. Therefore, the auxiliary space is proportional to the number of words in the dictionary.

Edge Cases

Case	How to Handle
Input is a valid boolean True	The function correctly returns the string 'True'.
Input is a valid boolean False	The function correctly returns the string 'False'.
Input is None (Python) or null (Java/C++)	The function should raise a TypeError or NullPointerException, as the input is not a boolean.
Input is an integer 0	The function should raise a TypeError, as the input is not a boolean (Python's truthiness rules do not apply here).
Input is an integer 1	The function should raise a TypeError, as the input is not a boolean.
Input is a string 'True' or 'False'	The function should raise a TypeError, as the input is not a boolean.
Input is a different type that could be implicitly converted (e.g., in JavaScript)	The function should ensure strict type checking to only accept boolean values, preventing unexpected behavior due to implicit conversions.
Input is a boolean object (e.g., Boolean(true) in JavaScript)	The function correctly returns the string 'True' after automatic unboxing to primitive boolean true.

Input is a valid boolean True

How to Handle:

The function correctly returns the string 'True'.

Input is a valid boolean False

How to Handle:

The function correctly returns the string 'False'.

Input is None (Python) or null (Java/C++)

How to Handle:

The function should raise a TypeError or NullPointerException, as the input is not a boolean.

Input is an integer 0

How to Handle:

The function should raise a TypeError, as the input is not a boolean (Python's truthiness rules do not apply here).

Input is an integer 1

How to Handle:

The function should raise a TypeError, as the input is not a boolean.

Input is a string 'True' or 'False'

How to Handle:

The function should raise a TypeError, as the input is not a boolean.

Input is a different type that could be implicitly converted (e.g., in JavaScript)

How to Handle:

The function should ensure strict type checking to only accept boolean values, preventing unexpected behavior due to implicit conversions.

Input is a boolean object (e.g., Boolean(true) in JavaScript)

How to Handle:

The function correctly returns the string 'True' after automatic unboxing to primitive boolean true.

Solution

Clarifying Questions

When you get asked this question in a real-life environment, it will often be ambiguous (especially at FAANG). Make sure to ask these questions in that case:

Is the input `boolValue` strictly a boolean value (true or false), or can it be any other type that might be interpreted as truthy or falsy?
Should the returned string be capitalized exactly as 'True' and 'False', or is case-insensitivity acceptable (e.g., 'true', 'FALSE')?
Are there any memory constraints I should be aware of for this seemingly simple operation?
Should I handle potential null or undefined input values, and if so, how should they be represented as a string?
Although this seems straightforward, are there any hidden or unexpected edge cases I should consider beyond the basic true/false inputs?

Brute Force Solution

Approach

Here's how the algorithm would work step-by-step:

Consider the first item and see if it satisfies the condition by itself.
Next, check the first two items together to see if they satisfy the condition.
Continue this process by adding one more item at a time and checking if the current combination satisfies the condition.
Repeat this process, starting now with the second item as the first entry of a potential solution, then with the third, fourth and so on. This way, we are sure we cover all possible sub-groupings of the total items.
Once you've checked every possible combination of items, compare all of the combinations that satisfied the conditions.
Finally, return the best combination found, according to what 'best' means in the context of the problem.

Code Implementation

def find_best_combination_brute_force(items, condition_function, quality_function):
    best_combination = None
    best_quality = float('-inf')

    for start_index in range(len(items)):
        for end_index in range(start_index, len(items)):
            # Create a combination from start_index to end_index
            current_combination = items[start_index:end_index + 1]

            # Check if the current combination meets the specified condition
            if condition_function(current_combination):

                # Calculate the quality of the current combination
                current_quality = quality_function(current_combination)

                # Determine if the current combination improves upon the best found so far
                if current_quality > best_quality:
                    best_quality = current_quality
                    best_combination = current_combination

    return best_combination

Big(O) Analysis

Time Complexity

Space Complexity

Optimal Solution

Approach

Here's how the algorithm would work step-by-step:

Start by putting the beginning word onto a list of words to explore.
While there are still words to explore, take the first word from the list.
Figure out all possible words you can create from that word by changing just one letter, and check if those new words are valid (in the dictionary) and haven't been explored yet.
If you find a valid new word that is the same as the ending word, you are done!
If you find a valid new word that is *not* the ending word, add it to the list of words to explore, so you can check *its* one-letter-different neighbors later.
If you run out of words to explore without finding the ending word, it means there's no way to get from the start to the end.

Code Implementation

def can_transform(begin_word, end_word, word_list):
    word_set = set(word_list)
    if end_word not in word_set:
        return False

    words_to_explore = [begin_word]
    visited_words = {begin_word}

    while words_to_explore:
        current_word = words_to_explore.pop(0)

        for i in range(len(current_word)):
            for char_code in range(ord('a'), ord('z') + 1):
                new_char = chr(char_code)
                new_word = current_word[:i] + new_char + current_word[i+1:]

                if new_word == end_word:
                    return True

                # Only explore valid, unvisited words
                if new_word in word_set and new_word not in visited_words:

                    words_to_explore.append(new_word)

                    #Mark as visited to avoid infinite loops
                    visited_words.add(new_word)

    # If we exhaust all possibilities, there's no transformation
    return False

Big(O) Analysis

Time Complexity

Space Complexity

Edge Cases

Case	How to Handle
Input is a valid boolean True	The function correctly returns the string 'True'.
Input is a valid boolean False	The function correctly returns the string 'False'.
Input is None (Python) or null (Java/C++)	The function should raise a TypeError or NullPointerException, as the input is not a boolean.
Input is an integer 0	The function should raise a TypeError, as the input is not a boolean (Python's truthiness rules do not apply here).
Input is an integer 1	The function should raise a TypeError, as the input is not a boolean.
Input is a string 'True' or 'False'	The function should raise a TypeError, as the input is not a boolean.
Input is a different type that could be implicitly converted (e.g., in JavaScript)	The function should ensure strict type checking to only accept boolean values, preventing unexpected behavior due to implicit conversions.
Input is a boolean object (e.g., Boolean(true) in JavaScript)	The function correctly returns the string 'True' after automatic unboxing to primitive boolean true.

Input is a valid boolean True

How to Handle:

The function correctly returns the string 'True'.

Input is a valid boolean False

How to Handle:

The function correctly returns the string 'False'.

Input is None (Python) or null (Java/C++)

How to Handle:

The function should raise a TypeError or NullPointerException, as the input is not a boolean.

Input is an integer 0

How to Handle:

The function should raise a TypeError, as the input is not a boolean (Python's truthiness rules do not apply here).

Input is an integer 1

How to Handle:

The function should raise a TypeError, as the input is not a boolean.

Input is a string 'True' or 'False'

How to Handle:

The function should raise a TypeError, as the input is not a boolean.

Input is a different type that could be implicitly converted (e.g., in JavaScript)

How to Handle:

The function should ensure strict type checking to only accept boolean values, preventing unexpected behavior due to implicit conversions.

Input is a boolean object (e.g., Boolean(true) in JavaScript)

How to Handle:

The function correctly returns the string 'True' after automatic unboxing to primitive boolean true.