NeetCode Altered Quiz

What is the correct method to remove a specific item from a Set? // Removing an item from a set const guests = new Set(['Alice', 'Bob', 'Charlie']); // ____ ('Alice');

.delete()

When updating the value for an existing key in a Map, which method is used? // Updating the value for a key in a map const prices = new Map(); prices.?('Milk', 1.99); // ____ ('Milk', 2.99);

.set()

To compare characters without case sensitivity in a palindrome, which method should be called on both characters? // Ignoring cases in a palindrome check function isCaseInsensitivePalindrome(s) { let front = 0; let back = s.length - 1; // while (front < back) { // if (s[front].____() !== s[back].____()) { // ... // } // } }

.toLowerCase()

Which operator should be used to skip over a duplicate element in a sorted array? // Skipping over duplicate elements for (let i = 1; i < nums.length; i++) { // if (nums[i] ____ nums[i - 1]) { // ... // } }

===

When employing a recursive Depth-First Search to determine the maximum depth of a binary tree, which of the following would be an appropriate stopping condition? var calculateDepthDFS = function(root) { // DFS implementation with base case... };

A suitable base case would be reaching a null node, suggesting that a leaf node was encountered in the prior step.

Which method is used to add an element to a Set? const items = new Set(); items._____('🍎'); items._____('🍌');

.add()

When swapping the children of nodes in a binary tree to achieve its inversion, which traversal strategy can guarantee the correct result?

Both DFS and BFS are valid strategies.

After applying the function invertTree which uses Depth-First Search (DFS) on the given binary tree, how does the structure of each node in the tree change? class TreeNode { constructor(val) { this.val = val; this.left = null; this.right = null; } } var invertTreeDFS = (root) => { if (!root) return null; const left = invertTreeDFS(root.left); const right = invertTreeDFS(root.right); root.left = right; root.right = left; return root; }

Each node's left and right children are swapped.

When aiming to invert a binary tree, which traversal method can be used to ensure each node's children are correctly swapped? class TreeNode { constructor(val) { this.val = val; this.left = null; this.right = null; } } const invertDFS = (node) => { if (!node) return null; const leftSubtree = invertDFS(node.left); const rightSubtree = invertDFS(node.right); node.left = rightSubtree; node.right = leftSubtree; return node; } const invertBFS =

Either DFS or BFS can be used effectively.

How can the size of a HashSet be used to identify if duplicates exist in the original array?

If the size of the HashSet is smaller than the array's length, duplicates are present.

In JavaScript, what data structure can be used to store key-value pairs where the key is unique?

Map

To identify the optimal days for buying and selling stocks, what strategy is represented by nested loops where the outer loop represents the buying day and the inner loop indicates the selling day? let maximumProfit = 0; for (let buy = 0; buy < prices.length; buy++) { for (let sell = buy + 1; sell < prices.length; sell++) { maximumProfit = Math.max(maximumProfit, prices[sell] - prices[buy]); } }

The code is implementing a brute-force approach by calculating the potential profit of every valid pair of buying and selling days.

Given the following code to compute the maximum profit from stock prices, how is the space complexity characterized? let minPrice = Infinity; let maxProfit = 0; for (let price of prices) { if (price < minPrice) { minPrice = price; } else { maxProfit = Math.max(maxProfit, price - minPrice); } }

The code operates with a constant space complexity, O(1), as it only uses a fixed number of variables regardless of input size.

In a hashmap-based approach for finding duplicates, what does the key-value pair represent? numMap.set(num, true);

The number from the array as the key and a boolean indicating its presence as the value.

Given an array of stock prices, if you are examining the profit potential for each possible day pair (buying and selling), which methodology best describes this approach? let profit = 0; for (let i = 0; i < prices.length; i++) { for (let j = i + 1; j < prices.length; j++) { profit = Math.max(profit, prices[j] - prices[i]); } }

This is a brute-force methodology where each day's profit is computed against every future day to ascertain the highest possible profit.

What is the purpose of the complement variable within the twoSum function? const complement = (target - num);

To calculate the difference between the target and the current number, indicating the needed value for the sum.

To store the index of a previously visited number in the hashmap, which method should be employed? let number = nums[i]; map.?(number, i);

set

Which property is used to find out the number of elements in a Set? const mySet = new Set([1, 2, 3, 2, 1]);

size

If the sum of two numbers pointed to by the start and end pointers is less than zero, what is the correct way to move the start pointer? // Using two pointers to find a specific sum let start = 0; let end = sortedArray.length - 1; // while (start < end) { // const sum = sortedArray[start] + sortedArray[end]; // if (sum ____ 0) { // ... // } // }

start++

In the context of the house robber problem, when planning the robbery using a dynamic programming approach, what's the key decision at each house? var calculateMaxLoot = function(nums) { // DP strategy for robbing... };

At each house, the robber decides between robbing the current house and skipping the next one, or skipping the current house and moving on.

Given a situation where you want to rob a sequence of houses without triggering any adjacent security systems, which approach should be used to decide the optimal set of houses to rob? function maxRobbery(nums) { // Optimal robbery logic... };

At each step, decide between robbing the current house and moving two positions ahead or skipping the current house and moving to the next position.

Given the problem of determining the maximum depth of a binary tree, which of the following traversal methods is applicable? var findMaxDepth = function(root) { // Implementation here... };

Both Depth-First Search (DFS) and Breadth-First Search (BFS) are suitable as they both can explore the full depth of the tree.

In order to avoid detection from adjacent security systems while robbing a series of houses, what should be the logic in our dynamic programming approach? function stealthyRob(nums) { // Stealthy robbery dynamic programming logic... };

Build a dynamic table where each entry represents the maximum value robbed up to that house, ensuring that we either take the current house and skip one or move to the next one.

In the one-pass algorithm for determining maximum stock profit, what action is taken every time we see a new price? let minPrice = Infinity; let maxProfit = 0; for (let price of prices) { if (price < minPrice) { minPrice = price; } else { maxProfit = Math.max(maxProfit, price - minPrice); } }

Check if it's a new minimum and update it if necessary, then evaluate the profit by subtracting this minimum from the current price and adjust maximum profit accordingly.

What approach can be taken to verify the palindrome nature of a string after it has been processed (converted to lowercase and non-alphanumeric characters removed)? const reversed = reverse(alphaNumeric); return alphaNumeric === reversed;

Compare the processed string to its reversed version.

To verify if a string is a palindrome without forming its reversed copy, which efficient method can be considered? let start = 0; let end = s.length - 1; while (start < end) { if (s[start] !== s[end]) { return false; } start++; end--; }

Employ a two-pointer approach where one starts at the beginning and the other at the end, and they move towards each other.

What is the time complexity of detecting duplicates in an array when using a hashmap? const numMap = new Map(); for (const num of nums) { if (numMap.has(num)) { return true; } numMap.set(num, true); }

O(n)

What data structure in JavaScript is primarily used to represent a collection of unique values?

Set

Regarding the two-pointer method to ascertain if a string qualifies as a palindrome, what can be deduced about the time it takes relative to the string's length? let leftPointer = 0; let rightPointer = s.length - 1; while (leftPointer < rightPointer) { if (s[leftPointer] !== s[rightPointer]) { return false; } leftPointer++; rightPointer--; }

The algorithm runs in linear time, O(n), where 'n' is the length of the string.

When employing the two-pointer strategy for palindrome verification, how is the time complexity characterized when evaluated against the length of the string? let i = 0; let j = s.length - 1; while (i < j) { if (s[i] !== s[j]) { return false; } i++; j--; }

The approach exhibits a linear time complexity, O(n), with 'n' being the string's length.

For the strategy where a new string is constructed as the reversed version of the input to verify its palindrome property, what is the space cost? const cleanedString = s.replace(/[^a-z0-9]/gi, '').toLowerCase(); const reversedString = cleanedString.split('').reverse().join('');

The approach requires O(n) space complexity since a new string is created which can be of the same length as the input.

Given the following logic for reversing a singly linked list, what happens when the list contains a single element, say [3]? function reverseLinkedList(node) { if (!node || !node.next) { return node; } // ... (code to reverse the list) }

The list remains the same as there are no other nodes to rearrange with [3].

In using the two-pointer technique for palindrome validation, how does the amount of additional space used correlate with the input string's size? let start = 0; let end = s.length - 1; while (start < end) { if (s[start] !== s[end]) { return false; } start++; end--; }

The method uses constant space, O(1), since no extra space dependent on the string's length is used.

When using recursive DFS to invert a binary tree, what should the function consider to halt its recursion?

The recursion should halt and return when a null node is encountered, as it has no children to swap.

In the provided palindrome functions, which operation is applied to the string to remove characters that are not considered letters or numbers? const nonAlphaNumeric = new RegExp('[^a-z0-9]','gi'); s.replace(nonAlphaNumeric, '');

The string is processed using a regular expression that matches non-alphanumeric characters and replaces them with an empty string.

In a DFS recursive approach to invert a binary tree, which node condition ensures we don't need further recursive calls?

When we encounter a node that is null or a leaf node, as it won't have children to swap.

When you want to calculate the number of distinct pairs in an array of size n, which formula would you typically use?

(n - 1) / 2

When using two pointers in a loop, how are the left and right variables typically modified? // Moving pointers in a loop let left = 0; let right = array.length - 1; // while (left < right) { // ... // left____; // right____; // }

++ and --

To ignore case when comparing characters in a string for a palindrome check, which transformation should be applied? // Comparing characters from both ends in a string function isPalindrome(str) { let start = 0; let end = str.length - 1; // while (start < end) { // if (str[start].____ !== str[end].____) { // ... // } // } }

.toLowerCase()

In the context of validating nested and ordered sequences, such as those found in XML or HTML documents, which data structure is most appropriate to ensure each opening tag has a corresponding closing tag? function validateSequence(sequence) { const stack = []; const openTags = ['<div>', '<p>', '<span>']; const closeTags = ['</div>', '</p>', '</span>']; for (const tag of sequence) { if (openTags.includes(tag)) { stack.push(tag); } else if (closeTags.i

A Stack, as it can effectively match each opening tag with its corresponding closing tag in a LIFO (Last In First Out) manner.

Given a scenario where we are navigating through web pages and want to implement a 'back' feature to return to the previous page, which data structure is best suited for this? function navigate(pages) { const stack = []; for (const page of pages) { if (page === 'back') { stack.pop(); } else { stack.push(page); } } return stack; }

A Stack, since it allows us to move back and forth in a LIFO manner, perfectly capturing the essence of the back navigation feature.

To validate a palindrome string without extra space costs from a reversed version, what technique can be harnessed? let i = 0; let j = s.length - 1; while (i < j) { if (s[i] !== s[j]) { return false; } i++; j--; }

Adopt a two-pointer technique, comparing characters from the start and end while moving towards the middle of the string.

When parsing an HTML document to ensure all tags are correctly closed, if we're using a stack to keep track of opened tags, how can we ascertain that all tags were closed properly at the end of the document? function validateHtml(htmlString) { const tagsStack = []; //... (code to process tags and update the stack) return tagsStack.length === 0; }

All tags in the document are closed properly if the stack is empty at the end.

Given a node structure for a singly linked list as shown below, which aspect should we adjust to reverse the linked list? function SingleNode(value) { this.value = value; this.nextNode = null; }

Alter the 'nextNode' property of every node to reference the preceding node.

In a function that checks for balanced parenthesis in an expression, what does an empty stack signify after iterating over the entire string? function isBalanced(expression) { const parenthesisStack = []; // ... (code to push/pop based on opening/closing parenthesis) return parenthesisStack.length === 0; }

An empty stack suggests that the expression has balanced parenthesis.

How do you initialize a Map with multiple key-value pairs? // Creating a map with initial key-value pairs // const currencies = ____([ // ['USD', 'Dollar'], // ['EUR', 'Euro'] // ]);

By passing an array of key-value pairs to the Map constructor

When iterating through the array of stock prices, what method do we use to assess if a new potential profit is greater than our current maximum profit? let profitPotential = price - minPrice; if (profitPotential > maxProfit) { maxProfit = profitPotential; }

Compute the difference between the current price and the current minimum, then compare it with the current maximum profit.

When solving the house robbing problem with a brute-force recursion strategy, how should we approach the decision-making at each house? var bruteForceRob = function(nums) { // Recursive strategy... };

For each house, we have two choices: either rob the current house and skip the next one, or skip the current house to rob the next one.

In the recursive solution designed to find a tree's maximum depth, what logic is implemented for non-terminal nodes? var findMaxDepth = function(root) { // Recursive depth determination logic... };

For each non-terminal node, its depth is the larger of the depths of its left or right subtree, incremented by one.

Given an algorithm that uses a stack to validate the brackets in a string, what should the final state of the stack indicate about the validity of the bracket sequence? function areBracketsValid(string) { const stack = []; // ... (code that processes the string and updates the stack) return stack.length === 0; }

If the stack is empty after processing the entire string, it indicates the string has a valid sequence of brackets.

Considering the recursive nature of the binary tree inversion algorithm, what inference can you make about its space efficiency? function invertTree(root) { if (root === null) return null; [root.left, root.right] = [root.right, root.left]; invertTree(root.left); invertTree(root.right); return root; }

In a balanced binary tree, the space complexity averages O(log n) due to recursive call stack depth, but it could be O(n) in the worst case scenario of an unbalanced tree.

In the context of checking for palindromes, what is the significance of converting the entire string to lowercase? const alphaNumeric = filterAlphaNumeric(s);

It ensures that the comparison between characters is case-insensitive, making the palindrome check consistent regardless of letter casing.

How does a Set behave when you try to add a duplicate item?

It ignores the duplicate.

What is the primary benefit of the two-pointer technique in algorithm problems?

It is efficient and can reduce complexity.

For improving the efficiency of finding two numbers that add up to a target, which data structure is used to store and retrieve values in constant time? let map = new ?();

Map

Which function correctly finds the maximum of two values to update the max variable? // Calculating the maximum area in an array function maxArea(heights) { let left = 0; let right = heights.length - 1; let max = 0; // while (left < right) { // const area = (right - left) * Math.min(heights[left], heights[right]); // max = Math.____(max, area); // ... // } return max; }

Math.max

For a hashmap solution that detects duplicates in an integer array, what is the worst-case space complexity?

O(n)

Considering an efficient method to reverse a singly linked list without allocating extra space, which technique stands out? function Node(value) { this.value = value; this.nextNode = null; }

Progressively traverse the list and redirect the 'nextNode' of every node to the one before it.

Suppose you are traversing a string that contains mixed types of brackets: (, ), {, }, [, and ]. What should be the first action when encountering an opening bracket while ensuring the string's brackets are balanced? function isBalanced(s) { const stack = []; for (const char of s) { if (['(', '{', '['].includes(char)) { stack.push(char); } // ... (rest of the function) } return stack.length === 0; }

Push the opening bracket onto the stack to keep track of it until a matching closing bracket is found.

In the context of reversing a singly linked list, which property of the nodes becomes pivotal? function Node(data) { this.data = data; this.link = null; }

The 'link' property as it has to be updated to refer to the node before it.

When we aim to reverse the direction of a singly linked list, which component of each node must be modified? function ListNode(val) { this.val = val; this.next = null; }

The 'next' reference of each node to make it point to the previous node.

Given the implementation of reversing a singly linked list without using additional space, how would you categorize its time efficiency? class ListNode { constructor(val = 0, next = null) { this.val = val; this.next = next; } } class ReverseLinkedList { reverse(head) { let previous = null, current = head; while (current) { let nextNode = current.next; current.next = previous; previous = current; current

The algorithm exhibits a linear time complexity, O(n), where 'n' represents the number of nodes in the list.

When employing the given method for calculating maximum stock profit, what space complexity does the algorithm demonstrate? let minPrice = Infinity; let maxProfit = 0; for (let price of prices) { if (price < minPrice) { minPrice = price; } else { maxProfit = Math.max(maxProfit, price - minPrice); } }

The algorithm maintains a constant space complexity, O(1), as it manages only two variables independent of the input size.

Provided the following algorithm to validate if parentheses in a string are balanced, how does it determine the string's validity? var isValid = (s, stack = []) => { const map = { '}': '{', ']': '[', ')': '(', }; for (const char of s) {/* Time O(N) */ const isBracket = (char in map) if (!isBracket) { stack.push(char); continue; }/* Space O(N) */ const isEqual = (stack[stack.length - 1] === map[char]) if (isEqual) { stack.p

The algorithm pushes every opening bracket onto a stack and pops the stack when it encounters a matching closing bracket. If the stack is empty at the end, the string is valid.

For the following method employed to calculate the maximum depth of a binary tree using recursion, how is the depth for a non-leaf node determined? var determineTreeDepth = function(root) { // Recursive depth calculation... };

The depth of a non-leaf node is one more than the maximum of the depths of its left and right subtrees.

If the complement value exists within the map, what does the twoSum function return? const isTarget = map.has(complement) if (isTarget) return [ index, sumIndex ];

The indices of the two numbers from the array that sum up to the target.

When inverting a binary tree using Breadth-First Search (BFS), which of the following best describes the process applied to each node? class TreeNode { constructor(val) { this.val = val; this.left = null; this.right = null; } } var invertTreeBFS = (root) => { if (!root) return null; const queue = [root]; while (queue.length) { const current = queue.shift(); const temp = current.left; current.left = current.right; curren

The left and right children of the current node are swapped at each step.

In the context of the reverse operation on linked lists, if a linked list is represented as [7], what will be the outcome post-reversal? function reverseLL(node) { let previous = null; while (node) { const nextNode = node.next; node.next = previous; previous = node; node = nextNode; } return previous; }

The linked list remains unchanged as [7] since there's only one node.

In the provided iterative DFS method for finding the maximum depth, which of the following accurately describes its working mechanism? var maxDepth = function(root) { const isBaseCase = root === null; if (isBaseCase) return 0; return iterativeDfs([[root, 1]]); }; const iterativeDfs = (stack, height = 0) => { while (stack.length) { const [root, depth] = stack.pop(); height = Math.max(height, depth); if (root.right) stack.push([root.right, depth + 1]);

The method uses a stack to traverse nodes in a depth-first manner, adjusting the height as deeper nodes are encountered.

When using a hashmap to solve the two-sum problem, what does the key-value pair in the hashmap represent? numMap.set(nums[i], i);

The number from the array as the key and its index as the value.

When reversing a string to check for its palindromic nature, what is the computational overhead in terms of time? const reversedStr = s.toLowerCase().replace(/[^a-z0-9]/gi, '').split('').reverse().join('');

The operation runs in linear time, O(n), with 'n' being the length of the string.

When aiming to find the maximum profit from the stock prices array using the optimal algorithm, how is the time complexity determined based on the number of days in the array? let minPrice = Infinity; let maxProfit = 0; for (let price of prices) { if (price < minPrice) { minPrice = price; } else { maxProfit = Math.max(maxProfit, price - minPrice); } }

The optimal solution iterates through the prices array once, yielding a time complexity of O(n) where n represents the number of days.

While parsing a programming code for syntax errors, when the parser encounters a closing curly brace }, what operation regarding the stack of brackets should the parser perform? function syntaxChecker(code) { const bracketStack = []; for (const token of code) { if (token === '}') { const correspondingBracket = bracketStack.pop(); // ... (rest of the function) } } return bracketStack.length === 0; }

The parser should pop the stack and verify if the retrieved token is the matching opening curly brace {.

Given the following problem, where a robber is planning to rob houses on a street, which constraint needs to be followed when deciding on the houses to rob? var theftPlan = function(nums) { // Robbery strategy... };

The robber cannot rob two adjacent houses on the same night as they have interconnected security systems.

When examining the space requirements for an algorithm that utilizes a stack to ensure all tags in an XML document are closed, what would be the worst-case space complexity given a string of length n? function validateXmlTags(xmlString) { const stack = []; //... (code to process tags and update the stack) return stack.length === 0; }

The space complexity is O(n) as in the worst case every tag in the string could be an opening tag, which would be pushed onto the stack.

Analyzing the method to reverse a singly linked list in the below code, what can you infer about its space requirements? class ListNode { constructor(val = 0, next = null) { this.val = val; this.next = next; } } class LinkedListReversal { reverse(head) { let prevNode = null, currNode = head; while (currNode) { let tempNode = currNode.next; currNode.next = prevNode; prevNode = currNode; currNode = tempNod

The space complexity of the method is constant, O(1), because it only uses a fixed amount of space irrespective of the list size.

Considering a singly linked list reversing function, what is the memory overhead when only altering the 'next' pointers of nodes? class ListNode { constructor(value = 0, next = null) { this.value = value; this.next = next; } } class Reverse { process(head) { let former = null, latter = head; while (latter) { let followingNode = latter.next; latter.next = former; former = latter; latter = followingNode;

The space overhead remains constant, O(1), because the method doesn't employ any additional memory that scales with input size.

Given an algorithm that uses a stack to validate the parentheses in a string, how would the time complexity of this algorithm be characterized in terms of the length of the input string, n? function validateParens(s) { const stack = []; for (let char of s) { if (['(', '{', '['].includes(char)) { stack.push(char); } else { // ... (code to check and pop from the stack) } } return stack.length === 0; }

The time complexity of the algorithm is O(n) because it processes each character in the string once.

Given the recursive algorithm to invert a binary tree, what can we conclude about its time complexity? function invertTree(root) { if (root === null) return null; [root.left, root.right] = [root.right, root.left]; invertTree(root.left); invertTree(root.right); return root; }

The time complexity of the algorithm is O(n), where n represents the number of nodes in the tree since each node is visited once.

What is the role of converting all uppercase letters into lowercase when checking if a string is a palindrome? const alphaNumeric = filterAlphaNumeric(s);

To ensure a case-insensitive comparison of characters in the palindrome checking process.

In the twoSum function, what is the role of the map data structure?

To keep track of each number's index within the array, allowing for constant-time lookups.

When checking for palindromes using two pointers, how do the pointers move?

Towards the center from both ends.

When tasked with reversing a singly linked list without utilizing additional memory, which method should we apply? function ListNode(val) { this.val = val; this.next = null; }

Traverse the list and update the 'next' reference of each node to point to the preceding node.

During the single iteration through the stock prices array to maximize profit, what is the approach taken when encountering a price lower than the current minimum? let minPrice = Infinity; let maxProfit = 0; for (let price of prices) { if (price < minPrice) { minPrice = price; } else { maxProfit = Math.max(maxProfit, price - minPrice); } }

Update the current minimum price to this newly encountered lower price.

When searching for the two numbers that add up to the target, what technique can be employed to optimize the search time?

Using a hashmap to store previously visited numbers.

For determining a palindrome nature of a string, what approach can be applied to avoid extra space overhead from a reversed string? let left = 0; let right = s.length - 1; while (left < right) { if (s[left] !== s[right]) { return false; } left++; right--; } return true;

Utilize two pointers, one starting from the beginning and the other from the end, comparing the characters at both positions as they converge towards the center.

Given the string sequence s = "{[]}", is the sequence considered valid when processed through the bracket-balancing validation algorithm? var isValid = (s, stack = []) => { const map = { '}': '{', ']': '[', ')': '(', }; for (const char of s) { const isBracket = (char in map) if (!isBracket) { stack.push(char); continue; } const isEqual = (stack[stack.length - 1] === map[char]) if (isEqual) { stack.pop(); continue; }

Yes, every opening bracket in the sequence has a matching closing bracket of the same type, and they are closed in the correct order, making the sequence valid.

Within the iteration of houses, which code segment preserves the current mid value before potential updates? var rob = (nums) => { if (!nums.length) return 0; let [ left, mid ] = [ 0, 0 ]; for (const right of nums) { /* Your code here */ // ... mid = Math.max(mid, house); left = temp; } return mid; };

const temp = mid;

To check if the complement of an element exists in a hashmap (which contains previously visited numbers), which of the following methods should be employed? const numMap = new Map(); if (numMap.?(y)) { // ... }

has

Using a hashmap, which operation helps to determine if the complement of a number (i.e., target - current number) exists in the array? const numMap = new Map(); for (let i = 0; i < nums.length; i++) { let complement = target - nums[i]; if (numMap.?(complement) !== undefined) { return [numMap.get(complement), i]; } numMap.set(nums[i], i); }

has

Assessing the DFS recursive approach in the below algorithm, what is the base condition to determine the depth of the tree? var maxDepth = function(root) { const isBaseCase = root === null; if (isBaseCase) return 0; return dfs(root); }; const dfs = (root) => { const left = maxDepth(root.left); const right = maxDepth(root.right); const height = Math.max(left, right); return height + 1; };

he base condition is when the node is null, representing the end of a branch, in which case it returns 0.

When utilizing a HashSet to identify duplicates in an integer array, what happens if you attempt to insert an already existing element? const numbersSet = new Set(); nums.forEach(num => { numbersSet.add(num); });

he element is not added, and the size of the HashSet remains unchanged.

Given the initial check in our rob function, what should we do if the nums array is empty? var rob = (nums) => { // ... /* Your code here */ // ... for (const right of nums) { // ... } return mid; };

if (!nums.length) return 0;

When using a recursive strategy to invert a binary tree, which code snippet represents the primary steps taken at each node?

if (root === null) return null; let temp = root.left; root.left = root.right; root.right = temp; invertTree(root.left); invertTree(root.right);

Which set of variables should we initialize at the beginning of our algorithm to track the maximum amount that can be robbed? var rob = (nums) => { if (!nums.length) return 0; // ... /* Your code here */ // ... for (const right of nums) { // ... } return mid; };

let [ left, mid ] = [ 0, 0 ];

If given a function to determine the maximum profit, which set of variables best describes the optimal strategy for a single pass solution? function findMaxProfit(prices) { let minPrice = Infinity; let maxProfit = 0; for (let price of prices) { if (price < minPrice) { minPrice = price; } else { maxProfit = Math.max(maxProfit, price - minPrice); } } return maxProfit; }

minPrice stores the lowest stock price encountered, and maxProfit retains the greatest profit seen to date.

To determine the complement of an element x from the array that satisfies the equation target = x + y, what mathematical operation needs to be performed? for (let i = 0; i < nums.length; i++) { let y = target - ?; }

nums[i]

Given an element x from the array, to find its pair that sums up to the target, what should be the value we look for in the hashmap? let y = target - nums[i]; if (map.has(?)) { // Pair found }

y