#2704

Easy

auto_awesomeTo Be Or Not To Be core interview pattern

LeetCode Problem Workspace

To Be Or Not To Be

Implement a function 'expect' to help developers test values using 'toBe' and 'notToBe' methods.

Problem Statement

In this problem, you need to write a function called 'expect' that helps developers test values in their code. The function should accept any value, 'val', and return an object with two methods, 'toBe' and 'notToBe'. The 'toBe' method should check for equality and return true or an error message if the values match or not. Similarly, the 'notToBe' method should check for inequality and return true or an error if the values are equal when they should not be.

For example, calling 'expect(5).toBe(5)' should return an object with {"value": true}. If 'expect(5).toBe(null)' is called, it should return {"error": "Not Equal"}. The challenge requires you to correctly implement these two methods to perform the expected operations.

Examples

Example 1

Input: func = () => expect(5).toBe(5)

Output: {"value": true}

5 === 5 so this expression returns true.

Example 2

Input: func = () => expect(5).toBe(null)

Output: {"error": "Not Equal"}

5 !== null so this expression throw the error "Not Equal".

Example 3

Input: func = () => expect(5).notToBe(null)

Output: {"value": true}

5 !== null so this expression returns true.

Constraints

Solution Approach

Understand equality and inequality checks

You need to implement methods that evaluate the equality and inequality of two values. The 'toBe' method will check for exact equality, while 'notToBe' checks that the values are not equal. Consider edge cases like null, undefined, and different data types while implementing.

Return the appropriate result

The 'toBe' method should return an object with {"value": true} if the values match, and {"error": "Not Equal"} if they do not. For the 'notToBe' method, return {"value": true} if the values are not equal and {"error": "Equal"} if they are.

Test thoroughly with various inputs

Once the methods are implemented, test the function with a variety of values such as numbers, strings, null, and undefined. Ensure the outputs are consistent with the expected behavior for both 'toBe' and 'notToBe'.

Complexity Analysis

Metric	Value
Time	Depends on the final approach
Space	Depends on the final approach

The time and space complexity depend on how the comparison is performed. For simple equality checks, both the time and space complexity are O(1). However, if there are additional computations or type checks involved, the complexity may vary based on the implementation approach.

What Interviewers Usually Probe

Evaluates the candidate's understanding of equality and inequality checks.
Tests the candidate’s ability to implement method chaining.
Checks the candidate's approach to handling edge cases like null and undefined.

Common Pitfalls or Variants

Common pitfalls

Confusing 'toBe' with '===' in JavaScript which only checks strict equality.
Incorrectly implementing the 'notToBe' method to return true for equal values instead of false.
Not handling edge cases such as null or undefined in the comparisons.

Follow-up variants

Adding more methods for greater flexibility, like 'toBeGreaterThan' or 'toBeLessThan'.
Handling deep equality comparisons (e.g., arrays or objects).
Improving the solution by adding customizable error messages.

FAQ

How do I implement 'toBe' and 'notToBe' methods?

To implement these methods, focus on comparing the values passed into 'expect' using strict equality for 'toBe' and inequality for 'notToBe'.

What are the expected outputs for 'toBe' and 'notToBe'?

'toBe' returns {"value": true} for matching values and {"error": "Not Equal"} for non-matching values. 'notToBe' returns {"value": true} for non-equal values and {"error": "Equal"} for equal values.

Why should I test with null or undefined?

These values may behave differently in equality checks, so it's important to ensure they are handled correctly in both methods.

What happens if the types of the compared values differ?

The types of the values should be considered during comparison. Strict equality checks ('===') will return false if the types differ.

How can I improve the performance of the function?

Since equality checks are O(1), the main performance concern would be managing type checks and handling edge cases efficiently.

terminal

Solution

Solution 1

#### TypeScript

/**
 * @param {string} val
 * @return {Object}
 */
var expect = function (val) {
    return {
        toBe: function (expected) {
            if (val !== expected) {
                throw new Error('Not Equal');
            }
            return true;
        },
        notToBe: function (expected) {
            if (val === expected) {
                throw new Error('Equal');
            }
            return true;
        },
    };
};

/**
 * expect(5).toBe(5); // true
 * expect(5).notToBe(5); // throws "Equal"
 */

Explore more problems →

auto_awesome

Continue Pattern

To Be Or Not To Be core interview pattern

Expand the same solving frame across more problems.

arrow_forward signal_cellular_alt

Same Difficulty Track

Easy

Stay on this level to stabilize interview delivery.

arrow_forward