Problem Statement

Given a non-empty binary tree, find the maximum path sum. The path must contain at least one node and does not need to go through the root.

Example

Consider a binary tree:

Input:

root = [1,2,3]

Output:

6

Explanation: The optimal path is 2 -> 1 -> 3 with a path sum of 2 + 1 + 3 = 6.

Input:

root = [-10,9,20,null,null,15,7]

Output:

42

Explanation: The optimal path is 15 -> 20 -> 7 with a path sum of 15 + 20 + 7 = 42.

Solution Approach - Recursive Depth-First Search

class TreeNode {
  val: number;
  left: TreeNode | null;
  right: TreeNode | null;

  constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
    this.val = (val === undefined ? 0 : val);
    this.left = (left === undefined ? null : left);
    this.right = (right === undefined ? null : right);
  }
}

function maxPathSum(root: TreeNode | null): number {
  let maxSum = Number.MIN_SAFE_INTEGER;

  function maxGain(node: TreeNode | null): number {
    if (node === null) return 0;

    const leftGain = Math.max(maxGain(node.left), 0);
    const rightGain = Math.max(maxGain(node.right), 0);

    const priceNewPath = node.val + leftGain + rightGain;
    maxSum = Math.max(maxSum, priceNewPath);

    return node.val + Math.max(leftGain, rightGain);
  }

  maxGain(root);
  return maxSum;
}

Breaking Down the Solution

• Recursive Function: The maxGain function calculates the maximum sum starting from each node.

• Path Sum Calculation: At each node, calculate the maximum sum of any path that includes the node.

• Global Maximum: Track the maximum path sum found in the entire tree.

Conclusion

The Binary Tree Maximum Path Sum problem is a complex and intriguing challenge, showcasing the depth and flexibility of recursive algorithms in tree data structures.

Problem Statement

Given an array of k linked-lists lists, each linked-list is sorted in ascending order. Merge all the linked-lists into one sorted linked list and return it.

Example

Consider k sorted linked lists:

Example 1

• Input: lists = [[1,4,5],[1,3,4],[2,6]]
• Output: [1,1,2,3,4,4,5,6]
• Explanation: The linked-lists are:

[
1 -> 4 -> 5,
1 -> 3 -> 4,
2 -> 6
]

Merging them into one sorted list results in 1 -> 1 -> 2 -> 3 -> 4 -> 4 -> 5 -> 6.

Example 2

• Input: lists = []
• Output: []
• Explanation: No lists to merge, so the output is an empty list.

Example 3

• Input: lists = [[]]
• Output: []
• Explanation: A single empty list results in an empty merged list.

Solution Approach

A popular approach to solving this problem is using a Min Heap or a Priority Queue to efficiently find and merge the smallest elements of the lists.

Solution Approach - Min Heap

class ListNode {
  val: number;
  next: ListNode | null;
  constructor(val?: number, next?: ListNode | null) {
    this.val = val === undefined ? 0 : val;
    this.next = next === undefined ? null : next;
  }
}

class MinHeap {
  private heap: Array<ListNode | null>;

  constructor() {
    this.heap = [];
  }

  private getLeftChildIndex(parentIndex: number): number {
    return 2 * parentIndex + 1;
  }

  private getRightChildIndex(parentIndex: number): number {
    return 2 * parentIndex + 2;
  }

  private getParentIndex(childIndex: number): number {
    return Math.floor((childIndex - 1) / 2);
  }

  private hasLeftChild(index: number): boolean {
    return this.getLeftChildIndex(index) < this.heap.length;
  }

  private hasRightChild(index: number): boolean {
    return this.getRightChildIndex(index) < this.heap.length;
  }

  private hasParent(index: number): boolean {
    return this.getParentIndex(index) >= 0;
  }

  private leftChild(index: number): ListNode | null {
    return this.heap[this.getLeftChildIndex(index)];
  }

  private rightChild(index: number): ListNode | null {
    return this.heap[this.getRightChildIndex(index)];
  }

  private parent(index: number): ListNode | null {
    return this.heap[this.getParentIndex(index)];
  }

  private swap(indexOne: number, indexTwo: number): void {
    const temp = this.heap[indexOne];
    this.heap[indexOne] = this.heap[indexTwo];
    this.heap[indexTwo] = temp;
  }

  public isEmpty(): boolean {
    return this.heap.length === 0;
  }

  public insert(node: ListNode | null): void {
    this.heap.push(node);
    this.heapifyUp();
  }

  public extract(): ListNode | null {
    if (this.isEmpty()) {
      return null;
    }
    const node = this.heap[0];
    this.heap[0] = this.heap[this.heap.length - 1];
    this.heap.pop();
    this.heapifyDown();
    return node;
  }

  private heapifyUp(): void {
    let index = this.heap.length - 1;
    while (this.hasParent(index) && this.parent(index)!.val > this.heap[index]!.val) {
      this.swap(this.getParentIndex(index), index);
      index = this.getParentIndex(index);
    }
  }

  private heapifyDown(): void {
    let index = 0;
    while (this.hasLeftChild(index)) {
      let smallerChildIndex = this.getLeftChildIndex(index);
      if (this.hasRightChild(index) && this.rightChild(index)!.val < this.leftChild(index)!.val) {
        smallerChildIndex = this.getRightChildIndex(index);
      }

      if (this.heap[index]!.val < this.heap[smallerChildIndex]!.val) {
        break;
      } else {
        this.swap(index, smallerChildIndex);
      }
      index = smallerChildIndex;
    }
  }
}

function mergeKLists(lists: Array<ListNode | null>): ListNode | null {
  const minHeap = new MinHeap();
  lists.forEach(list => {
    if (list) minHeap.insert(list);
  });

  const dummy = new ListNode(0);
  let current = dummy;

  while (!minHeap.isEmpty()) {
    let node = minHeap.extract();
    current.next = node;
    if (current.next) {
      current = current.next;
    }
    if (node && node.next) {
      minHeap.insert(node.next);
    }
  }

  return dummy.next;
}

Breaking Down the Solution

The provided TypeScript solution for merging k sorted linked lists implements a custom Min Heap class and uses it to efficiently merge the lists. Here's a breakdown of how the solution works:

ListNode Class

• Represents a node in a linked list.
• Contains a value (val) and a reference to the next node (next).

MinHeap Class

• A min heap is a binary tree where the parent node is always less than or equal to its children.
• The class maintains a heap in an array (heap), where each element is a ListNode or null.

Key Methods and Properties:

• getLeftChildIndex, getRightChildIndex, getParentIndex: Calculate the indices of a node's left child, right child, and parent.
• hasLeftChild, hasRightChild, hasParent: Check if the node at the given index has a left child, right child, or parent.
• leftChild, rightChild, parent: Get the left child, right child, or parent of the node at the given index.
• swap: Swap two nodes in the heap.
• isEmpty: Check if the heap is empty.
• insert: Add a new node to the heap and reorganize the heap to maintain the min heap property (heapify up).
• extract: Remove and return the smallest node from the heap and reorganize the heap (heapify down).

mergeKLists Function

• Merges k sorted linked lists into one sorted linked list.
• Uses the Min Heap to efficiently find the smallest current node among all the lists.
• Iteratively extracts the smallest node from the heap and adds it to the merged list.
• If the extracted node has a next node, inserts the next node into the heap.

Process:

1. Initialize Min Heap: All head nodes of the k lists are inserted into the min heap.
2. Merging: Continuously extract the smallest node from the heap and attach it to the merged list.
3. Insert Next Nodes: If the extracted node has a next node, insert that next node into the heap to be considered in subsequent extractions.
4. Completion: The process continues until the heap is empty, meaning all nodes have been merged into the new list.

The result is a new linked list, pointed to by dummy.next, which is a sorted merge of all the input linked lists. This approach efficiently handles the merging process, making it suitable for a large number of lists or lists with a large number of nodes.

Conclusion

Merging k sorted lists is a classic problem that demonstrates the practical application of heap data structures in sorting and merging operations.

Problem Statement

Design a data structure that supports the following two operations:

• void addNum(int num): Add a number to the data structure.
• double findMedian(): Return the median of all elements so far.

Example

• Operations: addNum(1), addNum(2), findMedian(), addNum(3), findMedian()
• Outputs: [null, null, 1.5, null, 2.0]

Solution Approach - Two Heaps

The solution utilizes two heaps (a max heap and a min heap) to maintain the elements in sorted order and allow for efficient median calculation.

MedianFinder {
  private maxHeap: Heap<number>;
  private minHeap: Heap<number>;

  constructor() {
    this.maxHeap = new Heap<number>((a, b) => b - a);
    this.minHeap = new Heap<number>((a, b) => a - b);
  }

  addNum(num: number): void {
    // Add to maxHeap if it's empty or the number is less than or equal to its top element
    if (this.maxHeap.isEmpty() || num <= this.maxHeap.peek()!) {
      this.maxHeap.insert(num);
    } else {
      this.minHeap.insert(num);
    }

    // Balancing the heaps: ensure maxHeap has the same or one more element than minHeap
    if (this.maxHeap.size() > this.minHeap.size() + 1) {
      this.minHeap.insert(this.maxHeap.extract()!);
    } else if (this.minHeap.size() > this.maxHeap.size()) {
      this.maxHeap.insert(this.minHeap.extract()!);
    }
  }

  findMedian(): number {
    if (this.maxHeap.size() === this.minHeap.size()) {
      // If both heaps have the same size, the median is the average of their tops
      return (this.maxHeap.peek()! + this.minHeap.peek()!) / 2;
    } else {
      // If maxHeap has more elements, the median is its top element
      return this.maxHeap.peek()!;
    }
  }
}

Breaking Down the Solution

The MedianFinder class is an elegant solution to the "Find Median from Data Stream" problem, utilizing two heaps—a max heap and a min heap. Here's a breakdown of how this solution works:

Class: MedianFinder

• Manages two heaps to store the lower and upper halves of the data stream.

Properties:

• maxHeap: A max heap (Heap<number>) to store the smaller half of the numbers. The top of this heap will always be the largest number of the lower half.
• minHeap: A min heap (Heap<number>) to store the larger half of the numbers. The top of this heap will always be the smallest number of the upper half.

Constructor:

• Initializes the two heaps. The max heap uses a comparator that favors larger values (b - a), and the min heap uses a comparator that favors smaller values (a - b).

Method: addNum(num: number)

• Inserts a new number into one of the two heaps.
• If the number is less than or equal to the top of the max heap, or if the max heap is empty, it's added to the max heap. Otherwise, it's added to the min heap.
• After insertion, the method checks and rebalances the heaps to ensure that their sizes differ by no more than one element. This rebalancing is crucial for the median calculation.

Method: findMedian(): number

• Returns the median of the current set of numbers.
• If the heaps are of equal size, the median is the average of the tops of the two heaps.
• If the heaps are of unequal size, the median is the top of the larger heap (which, in this implementation, is always the max heap).

How It Works:

• The max heap and min heap effectively split the data stream into two halves.
• By maintaining the size property (the max heap is always equal or one more than the min heap), the class can quickly calculate the median.
• When a new number is added, it's placed in the correct half of the data. If this insertion unbalances the heaps, the class moves the top element of the larger heap to the smaller heap.
• For finding the median, if the sizes are equal, the median is the average of the two middle numbers. If not, it's just the middle number (from the max heap).

This implementation is efficient and dynamic, making it well-suited for a situation where data is continuously streaming, and the median needs to be recalculated frequently.

Conclusion

The Find Median from Data Stream problem showcases the utility of heap data structures in maintaining a running median in an efficient and scalable way.

Problem Statement

Given a non-empty array of integers, return the k most frequent elements.

Example

• Input:

nums = [1,1,1,2,2,3], k = 2

• Output:

[1,2]

• Explanation: The two most frequent elements are 1 and 2, which both appear three and two times respectively.

Solution Approach - Heap and Hash Map

The solution involves using a hash map to count the frequency of each element and then using a heap to efficiently extract the k most frequent elements.

function topKFrequent(nums: number[], k: number): number[] {
    const frequencyMap: { [key: number]: number } = {};
    for (const num of nums) {
        frequencyMap[num] = (frequencyMap[num] || 0) + 1;
    }

    const minHeap = new MinHeap<number>((a, b) => frequencyMap[a] - frequencyMap[b]);
    Object.keys(frequencyMap).forEach(num => {
        minHeap.insert(parseInt(num));
        if (minHeap.size() > k) {
            minHeap.extract();
        }
    });

    return minHeap.getItems();
}

Breaking Down the Solution

• Frequency Count: Use a hash map to count the occurrences of each number.
• Min Heap: A min heap is used to keep track of the top k frequent elements.
• Heap Operations: Insert each number into the heap. If the heap size exceeds k, remove the smallest element (based on frequency).
• Result: The contents of the heap represent the top k frequent elements.

Conclusion

The Top K Frequent Elements problem is a great example of combining data structures - hash maps for frequency counting and heaps for efficient element retrieval - to solve a common algorithmic challenge.

Problem Statement

Given an m x n board of characters and a list of strings words, return all words on the board. Each word must be constructed from letters of sequentially adjacent cells, where "adjacent" cells are horizontally or vertically neighboring. The same letter cell may not be used more than once in a word.

Example

Consider a board and a list of words:

Input:

board = [["o","a","a","n"],["e","t","a","e"],["i","h","k","r"],["i","f","l","v"]]
words = ["oath","pea","eat","rain"]

Output:

["eat","oath"]

Input:

board = [["a","b"],["c","d"]], words = ["abcb"]

Output:

[]

Solution Approach - Trie and Backtracking

class TrieNode {
  children: Map<string, TrieNode>;
  word: string | null;

  constructor() {
    this.children = new Map();
    this.word = null;
  }
}

class Trie {
  root: TrieNode;

  constructor() {
    this.root = new TrieNode();
  }

  insert(word: string): void {
    let node = this.root;
    for (const char of word) {
      if (!node.children.has(char)) {
        node.children.set(char, new TrieNode());
      }
      node = node.children.get(char)!;
    }
    node.word = word; // Store word at the leaf
  }
}

function findWords(board: string[][], words: string[]): string[] {
  const trie = new Trie();
  for (const word of words) {
    trie.insert(word);
  }

  const foundWords: string[] = [];
  for (let i = 0; i < board.length; i++) {
    for (let j = 0; j < board[i].length; j++) {
      dfs(board, i, j, trie.root, foundWords);
    }
  }

  function dfs(board: string[][], i: number, j: number, node: TrieNode, result: string[]) {
    const char = board[i][j];
    if (!node.children.has(char)) return;

    const nextNode = node.children.get(char);
    if (nextNode!.word) {
      // Found a word
      result.push(nextNode!.word);
      nextNode!.word = null; // Avoid duplicate entries
    }

    board[i][j] = '#'; // Mark as visited
    const directions = [
      [0, 1],
      [1, 0],
      [0, -1],
      [-1, 0],
    ]; // Right, Down, Left, Up
    for (const [dx, dy] of directions) {
      const x = i + dx,
        y = j + dy;
      if (x >= 0 && x < board.length && y >= 0 && y < board[0].length) {
        dfs(board, x, y, nextNode!, result);
      }
    }
    board[i][j] = char; // Reset
  }

  return foundWords;
}

Breaking Down the Solution

• Trie for Word Storage: Store the list of words in a Trie for efficient searching.

• Backtracking for Grid Traversal: Use depth-first search (DFS) with backtracking to explore the board.

• Finding Words: On each step of DFS, check if the current path corresponds to a word in the Trie.

Conclusion

Word Search II is a challenging problem that combines Trie data structures with backtracking techniques, demonstrating advanced concepts in algorithm design and optimization.

Problem Statement

Design a Trie data structure that supports insertion, search, and prefix search operations efficiently.

Example of Trie Functionality

• Insert: Adding words like "apple" and "app" into the Trie.
• Search: Checking if a word like "apple" is in the Trie.
• Starts With: Checking if there are any words that start with a prefix like "app".

Solution Approach - Trie Implementation

export class TrieNode {
  children: Map<string, TrieNode>;
  isEndOfWord: boolean;

  constructor() {
    this.children = new Map();
    this.isEndOfWord = false;
  }
}

export class Trie {
  root: TrieNode;

  constructor() {
    this.root = new TrieNode();
  }

  insert(word: string): void {
    let node = this.root;
    for (const char of word) {
      if (!node.children.has(char)) {
        node.children.set(char, new TrieNode());
      }
      node = node.children.get(char)!;
    }
    node.isEndOfWord = true;
  }

  search(word: string): boolean {
    let node = this.root;
    for (const char of word) {
      if (!node.children.has(char)) {
        return false;
      }
      node = node.children.get(char)!;
    }
    return node.isEndOfWord;
  }

  startsWith(prefix: string): boolean {
    let node = this.root;
    for (const char of prefix) {
      if (!node.children.has(char)) {
        return false;
      }
      node = node.children.get(char)!;
    }
    return true;
  }
}

Breaking Down the Solution

• TrieNode Class: Represents each node in the Trie, holding children and a flag to indicate end of a word.

• Trie Class: Implements the Trie with methods for insert, search, and startsWith.

• Efficient Operations: Leveraging the Trie structure for quick lookups and prefix searches.

Conclusion

Implementing a Trie is a crucial exercise in understanding tree-like data structures and their application in efficiently managing and searching strings.

Problem Statement

Design a data structure that supports adding new words and finding if a string matches any previously added string. The search method should be able to handle wildcard characters, where a . character can represent any letter.

Example of Functionality

• Add Word: Add words like "bad", "dad", and "mad" to the data structure.
• Search: Perform searches like ".ad" (matches "bad", "dad", "mad"), "b.." (matches "bad").

Solution Approach - Trie with Backtracking

class TrieNode {
  children: Map<string, TrieNode>;
  isEndOfWord: boolean;

  constructor() {
    this.children = new Map();
    this.isEndOfWord = false;
  }
}

class WordDictionary {
  root: TrieNode;

  constructor() {
    this.root = new TrieNode();
  }

  addWord(word: string): void {
    let node = this.root;
    for (const char of word) {
      if (!node.children.has(char)) {
        node.children.set(char, new TrieNode());
      }
      node = node.children.get(char)!;
    }
    node.isEndOfWord = true;
  }

  search(word: string): boolean {
    return this.searchInNode(word, this.root);
  }

  private searchInNode(word: string, node: TrieNode): boolean {
    for (let i = 0; i < word.length; i++) {
      const char = word.charAt(i);
      if (!node.children.has(char)) {
        if (char === '.') {
          for (const [_, childNode] of node.children) {
            if (this.searchInNode(word.substring(i + 1), childNode)) {
              return true;
            }
          }
        }
        return false;
      } else {
        node = node.children.get(char)!;
      }
    }
    return node.isEndOfWord;
  }
}

Breaking Down the Solution

• Trie Structure: The core of this data structure is a Trie to store the words efficiently.

• Wildcard Handling: The search method incorporates backtracking to handle wildcards ('.') by exploring all possible paths.

• Recursive Search: A helper function searchInNode is used for recursive searching with wildcard support.

Conclusion

Designing a word dictionary with add and search functionalities, especially handling wildcard searches, is an engaging exercise in Trie data structures and backtracking algorithms.

Problem Statement

Given a binary search tree (BST), find the lowest common ancestor (LCA) of two given nodes in the BST.

Example

Consider a binary search tree:

The lowest common ancestor of nodes 2 and 8 is 6.

Solution Approach - Iterative Traversal

class TreeNode {
    val: number;
    left: TreeNode | null;
    right: TreeNode | null;

    constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
        this.val = (val === undefined ? 0 : val);
        this.left = (left === undefined ? null : left);
        this.right = (right === undefined ? null : right);
    }
}

function lowestCommonAncestor(root: TreeNode | null, p: TreeNode, q: TreeNode): TreeNode | null {
    let currentNode = root;

    while (currentNode) {
        if (p.val < currentNode.val && q.val < currentNode.val) {
            currentNode = currentNode.left;
        } else if (p.val > currentNode.val && q.val > currentNode.val) {
            currentNode = currentNode.right;
        } else {
            return currentNode;
        }
    }

    return null;
}

Breaking Down the Solution

• Iterative Search: Iteratively traverse the tree starting from the root.

• Decision Making: If both nodes p and q are smaller than the current node, move to the left subtree. If both are larger, move to the right subtree.

• Finding LCA: The first node where p and q split into different directions is the LCA.

Conclusion

Finding the Lowest Common Ancestor in a BST is a fundamental problem in tree algorithms, demonstrating the efficiency of BST properties in solving search-related queries.

Problem Statement

Given two integer arrays preorder and inorder where preorder is the preorder traversal of a binary tree and inorder is the inorder traversal of the same tree, construct and return the binary tree.

Example

• Preorder: [3,9,20,15,7]
• Inorder: [9,3,15,20,7]

The constructed binary tree is:

Solution Approach - Recursive Construction

class TreeNode {
  val: number;
  left: TreeNode | null;
  right: TreeNode | null;

  constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
    this.val = val === undefined ? 0 : val;
    this.left = left === undefined ? null : left;
    this.right = right === undefined ? null : right;
  }
}

function buildTree(preorder: number[], inorder: number[]): TreeNode | null {
  let preIndex = 0;
  const inMap = new Map<number, number>();
  inorder.forEach((val, index) => inMap.set(val, index));

  function arrayToTree(left: number, right: number): TreeNode | null {
    if (left > right) return null;

    const rootVal = preorder[preIndex++];
    const rootValueIndex = inMap.get(rootVal);

    if (rootValueIndex === undefined) {
      throw new Error(`Key ${rootVal} not found in map.`);
    }

    const root = new TreeNode(rootVal);

    root.left = arrayToTree(left, rootValueIndex - 1);
    root.right = arrayToTree(rootValueIndex + 1, right);

    return root;
  }

  return arrayToTree(0, inorder.length - 1);
}

Breaking Down the Solution

• Map for Inorder Indices: Create a map to quickly find the index of each value in the inorder sequence.

• Recursive Construction: Recursively build the left and right subtrees using the indices in the map to find the dividing point.

• Preorder Traversal: The preorder array guides the creation of each node, starting from the root.

Conclusion

Constructing a binary tree from preorder and inorder traversals is an intriguing challenge that tests understanding of tree properties and traversal techniques.

Problem Statement

Given the root of a binary search tree and an integer k, return the kth smallest value (1-indexed) of all the values of the nodes in the tree.

Example

Consider a binary search tree:
Example 1:

Input: root = [3,1,4,null,2], k = 1
Output: 1

Example 2:

Input: root = [5,3,6,2,4,null,null,1], k = 3
Output: 3

Solution Approach - Inorder Traversal

class TreeNode {
    val: number;
    left: TreeNode | null;
    right: TreeNode | null;

    constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
        this.val = (val === undefined ? 0 : val);
        this.left = (left === undefined ? null : left);
        this.right = (right === undefined ? null : right);
    }
}

function kthSmallest(root: TreeNode | null, k: number): number {
  const stack: TreeNode[] = [];
  let current = root;
  let count = 0;

  while (current || stack.length > 0) {
    while (current) {
      stack.push(current);
      current = current.left;
    }

    let poppedValue = stack.pop();

    if (poppedValue !== undefined) {
      current = poppedValue;
      count++;
      if (count === k) return current.val;

      current = current.right;
    } else {
      current = null; // or however you want to handle the undefined case
    }
  }

  return -1;
}

Breaking Down the Solution

• Map for Inorder Indices: Create a map to quickly find the index of each value in the inorder sequence.

• Recursive Construction: Recursively build the left and right subtrees using the indices in the map to find the dividing point.

• Preorder Traversal: The preorder array guides the creation of each node, starting from the root.

Conclusion

Constructing a binary tree from preorder and inorder traversals is an intriguing challenge that tests understanding of tree properties and traversal techniques.

Problem Statement

Given the root of a binary tree, design an algorithm to serialize the tree into a string and deserialize the string back into the original tree structure.

Example

Consider a binary tree:

Serialized string might be: "1,2,null,null,3,4,null,null,5,null,null"

Solution Approach - Depth-First Traversal

class TreeNode {
  val: number;
  left: TreeNode | null;
  right: TreeNode | null;

  constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
    this.val = val === undefined ? 0 : val;
    this.left = left === undefined ? null : left;
    this.right = right === undefined ? null : right;
  }
}

function serialize(root: TreeNode | null): string {
  return serializeHelper(root, []).join();

  function serializeHelper(node: TreeNode | null, arr: string[]): string[] {
    if (node === null) {
      arr.push('null');
    } else {
      arr.push(node.val.toString());
      serializeHelper(node.left, arr);
      serializeHelper(node.right, arr);
    }
    return arr;
  }
}

function deserialize(data: string): TreeNode | null {
  const arr = data.split(',');
  return deserializeHelper(arr);

  function deserializeHelper(arr: string[]): TreeNode | null {
    if (arr[0] === 'null') {
      arr.shift();
      return null;
    }

    const value = arr.shift();
    if (typeof value === 'string') {
      const root = new TreeNode(parseInt(value));
      root.left = deserializeHelper(arr);
      root.right = deserializeHelper(arr);
      return root;
    } else {
      throw new Error('Array is empty, cannot shift any more elements.');
    }
    
  }
}

Breaking Down the Solution

• Serialize Function: Convert the tree into a string representation using pre-order traversal.

• Deserialize Function: Reconstruct the tree from the string representation, again using pre-order traversal logic.

• Handling Null Nodes: 'null' is used to represent the absence of a node.

Conclusion

Serializing and deserializing a binary tree is a critical problem in tree algorithms, demonstrating the importance of tree traversal techniques and data representation in computing.

Problem Statement

Given the root of a binary tree, determine if it is a valid binary search tree (BST).

Example

Consider a binary tree:

This tree is a valid BST.

Solution Approach - Recursive Traversal

class TreeNode {
    val: number;
    left: TreeNode | null;
    right: TreeNode | null;

    constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
        this.val = (val === undefined ? 0 : val);
        this.left = (left === undefined ? null : left);
        this.right = (right === undefined ? null : right);
    }
}

function isValidBST(root: TreeNode | null): boolean {
    return validate(root, null, null);

    function validate(node: TreeNode | null, low: number | null, high: number | null): boolean {
        if (node === null) return true;
        if ((low !== null && node.val <= low) || (high !== null && node.val >= high)) return false;
        return validate(node.left, low, node.val) && validate(node.right, node.val, high);
    }
}

Breaking Down the Solution

• Recursive Strategy: The function validate recursively checks each node.

• Boundary Conditions: Each node's value is compared against the allowed range (low and high) determined by its ancestors.

• Left and Right Subtree Checks: Ensures that left child values are less than the node's value and right child values are greater.

Conclusion

Validating a binary search tree is a fundamental problem in tree algorithms, highlighting the importance of recursion and boundary conditions in tree traversal.

Problem Statement

Given two non-empty binary trees s and t, check whether tree t has exactly the same structure and node values with a subtree of tree s.

Example

Consider two binary trees s and t:

Tree t is a subtree of tree s.

Solution Approach - Recursive Comparison

class TreeNode {
    val: number;
    left: TreeNode | null;
    right: TreeNode | null;

    constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
        this.val = (val === undefined ? 0 : val);
        this.left = (left === undefined ? null : left);
        this.right = (right === undefined ? null : right);
    }
}

function isSubtree(s: TreeNode | null, t: TreeNode | null): boolean {
    if (!s) return !t;
    return isSameTree(s, t) || isSubtree(s.left, t) || isSubtree(s.right, t);
}

function isSameTree(p: TreeNode | null, q: TreeNode | null): boolean {
    if (!p || !q) return p === q;
    if (p.val !== q.val) return false;
    return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
}

Breaking Down the Solution

• Recursive Tree Comparison: The function isSameTree checks if two trees are identical.

• Subtree Check: The function isSubtree checks if t is the same as s, or if t is a subtree of either the left or right subtree of s.

• Base Cases: Handle null trees appropriately in both functions.

Conclusion

The Subtree of Another Tree problem is an interesting application of binary tree algorithms, requiring a combination of tree traversal and recursive comparison to determine subtree relationships.

Problem Statement

Given the root of a binary tree, return the level order traversal of its nodes' values. (i.e., from left to right, level by level).

Example

Consider a binary tree:

Level order traversal of this tree is [[3], [9,20], [15,7]].

Solution Approach - Queue-Based Traversal

class TreeNode {
    val: number;
    left: TreeNode | null;
    right: TreeNode | null;

    constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
        this.val = (val === undefined ? 0 : val);
        this.left = (left === undefined ? null : left);
        this.right = (right === undefined ? null : right);
    }
}

function levelOrder(root: TreeNode | null): number[][] {
    if (!root) return [];
    
    const result: number[][] = [];
    const queue: TreeNode[] = [root];

    while (queue.length) {
        const levelSize = queue.length;
        const currentLevel: number[] = [];

        for (let i = 0; i < levelSize; i++) {
            const node = queue.shift();
            if (node) {
                currentLevel.push(node.val);
                if (node.left) queue.push(node.left);
                if (node.right) queue.push(node.right);
            }
        }

        result.push(currentLevel);
    }

    return result;
}

Breaking Down the Solution

• Queue Mechanism: Use a queue to keep track of nodes at each level.

• Iterative Traversal: Iteratively process nodes in the queue, adding their children to the queue for the next level.

• Collecting Levels: Collect the values of nodes at each level in separate lists.

Conclusion

Binary Tree Level Order Traversal is a fundamental problem in tree algorithms, emphasizing breadth-first traversal and demonstrating the practical use of queues in managing hierarchical data structures.

Problem Statement

Given the root of a binary tree, invert the tree, and return its root.

Example

Consider a binary tree:

The inverted tree is a mirror image of the original tree.

Solution Approach - Recursive Swap

class TreeNode {
    val: number;
    left: TreeNode | null;
    right: TreeNode | null;

    constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
        this.val = (val === undefined ? 0 : val);
        this.left = (left === undefined ? null : left);
        this.right = (right === undefined ? null : right);
    }
}

function invertTree(root: TreeNode | null): TreeNode | null {
    if (root === null) {
        return null;
    }
    [root.left, root.right] = [invertTree(root.right), invertTree(root.left)];
    return root;
}

Breaking Down the Solution

• Recursive Approach: The function invertTree is a recursive solution that inverts each node in the tree.

• Swapping Children: At each node, swap its left and right children.

• Base Case: If a node is null, return null.

Conclusion

Inverting a binary tree is an interesting problem that demonstrates the elegance and simplicity of recursive tree manipulation, showcasing fundamental concepts in binary tree algorithms.

Problem Statement

Given an array of strings, group the anagrams together. An Anagram is a word or phrase formed by rearranging the letters of a different word or phrase, typically using all the original letters exactly once.

Example

• Input: ["eat", "tea", "tan", "ate", "nat", "bat"]
• Output: [["ate","eat","tea"], ["nat","tan"], ["bat"]]

Solution Approach - Hashing and Sorting

function groupAnagrams(strs) {
    let map = {};

    for (let str of strs) {
        let sortedStr = str.split('').sort().join('');
        if (!map[sortedStr]) {
            map[sortedStr] = [];
        }
        map[sortedStr].push(str);
    }

    return Object.values(map);
}

Breaking Down the Solution

• Sort and Hash: For each string, sort its characters and use the sorted string as a key in a map.

• Group Anagrams: Group the original strings by their sorted key in the map.

• Result: Return the grouped anagrams as an array of arrays.

Solution in Typescript

function groupAnagrams(strs: string[]): string[][] {
    const map: Record<string, string[]> = {};

    for (const str of strs) {
        // Sort each string to form the key
        const sortedStr = str.split('').sort().join('');
        // Group strings by their sorted key
        if (!map[sortedStr]) {
            map[sortedStr] = [];
        }
        map[sortedStr].push(str);
    }

    // Return the grouped anagrams
    return Object.values(map);
}

In this TypeScript solution:

• The function groupAnagrams takes an array of strings.
• A map (Record<string, string[]>) is used to group strings by their sorted form.
• Each string in the input array is split into characters, sorted, and then joined back to form a key.
• The original strings are then grouped in the map based on this key.
• Finally, the function returns the values of the map, which are arrays of anagrams.

This implementation effectively groups anagrams together by using the sorted version of each string as a key, ensuring that all anagrams have the same key and are thus grouped together.

Conclusion

The Group Anagrams problem is an interesting exercise in string manipulation, sorting, and hashing. It demonstrates how to categorize data based on shared characteristics, in this case, the composition of characters.

Problem Statement

Given a string s, return the longest palindromic substring in s. A palindrome is a sequence of characters that reads the same forward and backward.

Example

• Input: "babad"
• Output: "bab" (Note: "aba" is also a valid answer)

Solution Approach - Expand Around Center

function longestPalindrome(s: string): string {
    if (!s || s.length < 2) return s;

    let start = 0, end = 0;
    for (let i = 0; i < s.length; i++) {
        let len1 = expandAroundCenter(s, i, i);       // Odd length palindrome
        let len2 = expandAroundCenter(s, i, i + 1);   // Even length palindrome
        let len = Math.max(len1, len2);
        if (len > end - start) {
            start = i - Math.floor((len - 1) / 2);
            end = i + Math.floor(len / 2);
        }
    }
    return s.substring(start, end + 1);
}

function expandAroundCenter(s: string, left: number, right: number): number {
    while (left >= 0 && right < s.length && s[left] === s[right]) {
        left--;
        right++;
    }
    return right - left - 1;
}

Breaking Down the Solution

• Center Expansion Technique: For each character in s, expand around it to find the longest palindrome.

• Handle Even and Odd Length: Check for palindromes of both odd and even lengths.

• Update Maximum Bounds: Update the start and end indices of the longest palindrome found.

Solution in typescript

function longestPalindrome(s: string): string {
  if (s.length < 2) return s;

  let start = 0,
    maxLength = 1;

  for (let i = 0; i < s.length; i++) {
    expandAroundCenter(s, i, i); // Odd length palindrome
    expandAroundCenter(s, i, i + 1); // Even length palindrome
  }

  function expandAroundCenter(str: string, left: number, right: number) {
    while (left >= 0 && right < str.length && str[left] === str[right]) {
      if (right - left + 1 > maxLength) {
        start = left;
        maxLength = right - left + 1;
      }
      left--;
      right++;
    }
  }

  return s.substring(start, start + maxLength);
}

In this TypeScript solution:

• The function longestPalindrome takes a string s as input.
• Two pointers (left and right) are used to expand around each character in the string to check for palindromes.
• The function expandAroundCenter expands around the center (the current character for odd length and between the current and next character for even length) and updates the start and maxLength if a longer palindrome is found.
• The substring method is used to extract and return the longest palindromic substring.

This approach effectively finds the longest palindromic substring by checking each character as the center of potential odd and even length palindromes.

The two-pointers approach for finding the longest palindromic substring is already quite efficient, particularly for its simplicity and directness in handling the problem. However, there are a couple of strategies that can be applied to optimize this solution further:

1. Early Termination: If the remaining substring is shorter than the current longest palindrome found, you can stop the search. This optimization helps reduce the number of unnecessary expansions.

2. Skip Identical Characters: When expanding around the center, if you encounter a group of identical characters, you can skip them in one step instead of expanding one character at a time. This can speed up the search in cases where there are long runs of the same character.

Here's how you could implement these optimizations:

function longestPalindrome(s: string): string {
    if (s.length < 2) return s;

    let start = 0, maxLength = 1;

    for (let i = 0; i < s.length; i++) {
        if (s.length - i <= maxLength / 2) break; // Early termination
        expandAroundCenter(s, i, i); // Odd length palindrome
        expandAroundCenter(s, i, i + 1); // Even length palindrome
    }

    function expandAroundCenter(str: string, left: number, right: number) {
        while (left >= 0 && right < str.length && str[left] === str[right]) {
            left--;
            right++;
        }
        // Adjust left and right to the last valid palindrome
        left++; right--;

        if (right - left + 1 > maxLength) {
            start = left;
            maxLength = right - left + 1;
        }
    }

    return s.substring(start, start + maxLength);
}

These optimizations can improve performance in specific scenarios, especially for longer strings or strings with many repeated characters. However, the fundamental time complexity of the algorithm remains O(n^2), as it still needs to consider each character as a potential center of a palindrome.

Conclusion

The Longest Palindromic Substring problem is a fascinating challenge in string processing, showcasing techniques like center expansion to find symmetrical patterns in text.

Problem Statement

Given a string s and an integer k, return the length of the longest substring containing the same letter you can get after performing at most k character replacements.

Example

• Input: s = "AABABBA", k = 1
• Output: 4 (Replace the one 'B' in "AABABBA" with 'A' to get "AAAA")

Solution Approach - Sliding Window Technique (typescript)

export function characterReplacement(s: string, k: number): number {
  let count: Record<string, number> = {};
  let maxCount = 0,
    maxLength = 0,
    start = 0;

  for (let end = 0; end < s.length; end++) {
    count[s[end]] = (count[s[end]] || 0) + 1;
    maxCount = Math.max(maxCount, count[s[end]]);

    while (end - start + 1 - maxCount > k) {
      count[s[start]]--;
      start++;
    }

    maxLength = Math.max(maxLength, end - start + 1);
  }

  return maxLength;
}

Breaking Down the Solution

• Sliding Window: Maintain a window of characters using two pointers (start and end).

• Track Character Counts: Use a map to count the occurrences of each character within the window.

• Adjust Window: If the window size minus the count of the most frequent character exceeds k, shrink the window from the start.

• Calculate Max Length: Update the maximum length of the substring as the window slides.

Imagine you have a long string of colorful beads, and each bead has a letter on it. Now, your task is to make the longest string of beads where all the beads have the same letter. But, there's a catch! You can only change a few beads (let's say k beads) to match the other beads.

Here's how you can do it:

1. Start Making a Necklace: Start stringing the beads together from one end. Keep adding beads as long as they have the same letter or until you have changed k beads to match.

2. Remember the Longest Necklace: As you string the beads, remember the longest necklace you've made so far where all beads looked the same.

3. Can't Change More Beads?: If you need to change more than k beads to keep adding to your necklace, then stop. Maybe start again from a different bead.

4. Try Different Starting Points: Keep trying to start your necklace from different beads in the string, using your k chances to change beads that don't match.

5. Find the Longest Necklace: After trying different starting points and using your k chances in the best way, the longest necklace you made is your answer!

In this game, changing a bead means replacing a character in the string, and making the longest necklace of the same letter is like finding the longest substring where you can replace at most k characters to make all characters in that substring the same.

Video Explanation

Longest Repeating Character Replacement

Conclusion

The Longest Repeating Character Replacement problem is an interesting challenge that tests the sliding window technique in strings. It's a valuable exercise in balancing the frequency of characters with the allowed number of replacements.

Problem Statement

Given the root of a binary tree, return its maximum depth.

Example

Consider a binary tree:

The maximum depth of this tree is 3.

Solution Approach - Depth-First Search

class TreeNode {
    val: number;
    left: TreeNode | null;
    right: TreeNode | null;

    constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
        this.val = (val === undefined ? 0 : val);
        this.left = (left === undefined ? null : left);
        this.right = (right === undefined ? null : right);
    }
}

function maxDepth(root: TreeNode | null): number {
    if (root === null) {
        return 0;
    } else {
        let leftDepth = maxDepth(root.left);
        let rightDepth = maxDepth(root.right);
        return Math.max(leftDepth, rightDepth) + 1;
    }
}

Breaking Down the Solution

• Recursive Approach: The solution uses a recursive depth-first search algorithm.

• Base Case: If the node is null, the depth is 0.

• Recursive Calculation: The depth of each subtree (left and right) is calculated, and the greater of the two depths is chosen, adding one to account for the current node.

Solution in Typescript one-liner

function maxDepth(root: TreeNode | null): number {
    if(!root) return 0;
    
    return 1 + Math.max(maxDepth(root.left), maxDepth(root.right));
};

Conclusion

Determining the maximum depth of a binary tree is a fundamental problem in tree algorithms, emphasizing the use of recursion and understanding of tree traversal techniques.

Problem Statement

Given two strings s and t, return the minimum window in s which will contain all the characters in t. If there is no such window in s that covers all characters in t, return the empty string "".

Example

• Input: s = "ADOBECODEBANC", t = "ABC"
• Output: "BANC"

Solution Approach - Sliding Window Technique (javascript)

function minWindow(s, t) {
    let map = {};
    t.split('').forEach(char => map[char] = (map[char] || 0) + 1);

    let counter = Object.keys(map).length;
    let begin = 0, end = 0, head = 0;
    let minLength = Infinity;

    while (end < s.length) {
        let endChar = s[end];
        if (map[endChar] !== undefined) map[endChar]--;
        if (map[endChar] === 0) counter--;

        while (counter === 0) {
            let tempLength = end - begin + 1;
            if (tempLength < minLength) {
                minLength = tempLength;
                head = begin;
            }

            let startChar = s[begin];
            if (map[startChar] !== undefined) map[startChar]++;
            if (map[startChar] > 0) counter++;

            begin++;
        }

        end++;
    }

    return minLength === Infinity ? "" : s.substr(head, minLength);
}

Breaking Down the Solution

• Character Count Map: Create a map to count the occurrences of each character in t.

• Sliding Window: Move a window over s, expanding and contracting it while tracking character frequencies.

• Find Minimum Window: When all characters from t are in the current window, try to minimize the window size while maintaining all characters from t.

Solution in typescript

function minWindow(s: string, t: string): string {
    let charMap: { [key: string]: number } = {};
    t.split('').forEach(char => {
        charMap[char] = (charMap[char] || 0) + 1;
    });

    let start = 0, end = 0, minLength = Infinity, head = 0;
    let required = Object.keys(charMap).length;

    while (end < s.length) {
        let endChar = s[end];
        if (charMap[endChar] !== undefined) charMap[endChar]--;
        if (charMap[endChar] === 0) required--;

        while (required === 0) {
            let tempLength = end - start + 1;
            if (tempLength < minLength) {
                minLength = tempLength;
                head = start;
            }

            let startChar = s[start];
            if (charMap[startChar] !== undefined) charMap[startChar]++;
            if (charMap[startChar] > 0) required++;

            start++;
        }

        end++;
    }

    return minLength === Infinity ? "" : s.substring(head, head + minLength);
}

In this TypeScript implementation:

• The minWindow function takes two strings s (the source string) and t (the target string).
• A map charMap is used to keep count of the required characters from t.
• The sliding window is defined by two pointers, start and end, which traverse the string s.
• When all required characters are within the current window, the window is contracted from the start to find the minimum length window that contains all characters of t.
• The minLength and head variables keep track of the size and starting position of the smallest valid window.
• The function returns the substring of s that represents the minimum window, or an empty string if no such window exists.

You can run this TypeScript code to find the smallest window in string s that contains all characters from string t.

Conclusion

The Minimum Window Substring problem is a key challenge in string manipulation, testing the ability to apply the sliding window technique effectively. It's commonly used in interview settings for its complexity and practical relevance in text processing.

Problem Statement

Given a string s, return the number of palindromic substrings in it. A substring is palindromic if it reads the same forward and backward.

Example

• Input: "abc"
• Output: 3 (The palindromic substrings are: "a", "b", "c")
• Input: "aaa"
• Output: 6 (The palindromic substrings are: "a", "a", "a", "aa", "aa", "aaa")

Solution Approach - Expand Around Center

function countSubstrings(s: string): number {
    let count = 0;

    for (let i = 0; i < s.length; i++) {
        count += expandAroundCenter(s, i, i);       // Odd length palindromes
        count += expandAroundCenter(s, i, i + 1);   // Even length palindromes
    }

    function expandAroundCenter(str: string, left: number, right: number): number {
        let tempCount = 0;
        while (left >= 0 && right < str.length && str[left] === str[right]) {
            tempCount++;
            left--;
            right++;
        }
        return tempCount;
    }

    return count;
}

Breaking Down the Solution

• Center Expansion Technique: For each character, consider it as the center of potential odd and even length palindromes.

• Counting Palindromes: Expand around each center and count valid palindromic substrings.

• Iterative Process: Accumulate the count of palindromic substrings for each expansion.

Optimised solution

function countSubstrings(s: string): number {
    let count = 0;

    for (let i = 0; i < s.length; i++) {
        // Check for odd length palindromes
        count += countPalindromesAroundCenter(s, i, i);
        // Check for even length palindromes
        count += countPalindromesAroundCenter(s, i, i + 1);
    }

    return count;
}

function countPalindromesAroundCenter(s: string, left: number, right: number): number {
    let count = 0;
    while (left >= 0 && right < s.length && s[left] === s[right]) {
        count++; // Increment count for each palindrome found
        left--;  // Expand to the left
        right++; // Expand to the right
    }
    return count;
}

Optimizations:

1. Focused Function: The countPalindromesAroundCenter function is dedicated solely to counting palindromic substrings, making the code more modular and easier to understand.

2. Single Responsibility: Each call to countPalindromesAroundCenter checks either odd or even length palindromes. This separation makes it clear what each function call is responsible for.

3. Efficient Expansion: The function expands around the center only as long as it finds palindromic substrings, minimizing unnecessary checks.

This approach retains the O(n^2) complexity, as in the worst case (like a string of identical characters), it must still expand around each character. However, it's more efficient in terms of operations performed for each expansion.

Conclusion

The Palindromic Substrings problem is a compelling challenge in string processing, demonstrating a methodical approach to identify and count symmetric patterns within a string.

Problem Statement

Given the roots of two binary trees p and q, write a function to check if they are the same or not. Two binary trees are considered the same if they are structurally identical, and the nodes have the same value.

Example

Consider two binary trees:

These two trees are the same.

Solution Approach - Recursive Comparison

class TreeNode {
    val: number;
    left: TreeNode | null;
    right: TreeNode | null;

    constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
        this.val = (val === undefined ? 0 : val);
        this.left = (left === undefined ? null : left);
        this.right = (right === undefined ? null : right);
    }
}

function isSameTree(p: TreeNode | null, q: TreeNode | null): boolean {
    if (p === null && q === null) {
        return true;
    }
    if (p === null || q === null) {
        return false;
    }
    if (p.val !== q.val) {
        return false;
    }
    return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
}

Breaking Down the Solution

• Recursive Strategy: The solution uses recursion to compare corresponding nodes of the two trees.

• Base Cases: Check for null nodes. If both are null, they are the same; if only one is null, they are not the same.

• Value Comparison: Compare the value of the current nodes. If they are different, the trees are not the same.

• Recursive Calls: Recursively compare left and right children of the current nodes.

Conclusion

The Same Tree problem is a fundamental exercise in understanding binary tree structure and recursion, highlighting the importance of simultaneous traversal in tree comparison.

Problem Statement

Given two strings s and t, write a function to determine if t is an anagram of s.

Example

• Input: s = "anagram", t = "nagaram"
• Output: true

Solution Approach - Character Counting (javascript)

function isAnagram(s, t) {
    if (s.length !== t.length) return false;

    let count = {};
    for (let char of s) {
        count[char] = (count[char] || 0) + 1;
    }
    
    for (let char of t) {
        if (!count[char]) return false;
        count[char]--;
    }

    return true;
}

Breaking Down the Solution

• Length Check: First, check if s and t are of the same length. If not, they can't be anagrams.

• Count Characters in s: Use a map to count the occurrences of each character in s.

• Verify Characters in t: Iterate over t and decrease the count for each character. If a character in t isn't in s or the count goes below zero, t is not an anagram of s.

Solution in TypeScript

function isAnagram(s: string, t: string): boolean {
    if (s.length !== t.length) {
        return false;
    }

    const count: Record<string, number> = {};
    for (const char of s) {
        count[char] = (count[char] || 0) + 1;
    }

    for (const char of t) {
        if (!count[char]) {
            return false;
        }
        count[char]--;
    }

    return true;
}

In this TypeScript solution:

• The function isAnagram takes two strings, s and t, and checks if they are anagrams.
• It first compares the lengths of s and t. If they are different, the function returns false immediately.
• A record count is used to count the occurrences of each character in s.
• Then, the function iterates through t, decrementing the count for each character. If a character in t is not in s or the count drops below zero, t is not an anagram of s.
• If all character counts are balanced, the function returns true.

This implementation effectively checks whether two strings are anagrams by comparing the frequency of each character in both strings.

Conclusion

The Valid Anagram problem is a fundamental exercise in string manipulation and character counting. It's a simple yet effective way to understand the importance of character frequency and order in strings.

Problem Statement

Given a string s, determine if it is a palindrome, considering only alphanumeric characters and ignoring cases.

Example

• Input: "A man, a plan, a canal: Panama"
• Output: true
• Input: "race a car"
• Output: false

Solution Approach - Two Pointers Technique (typescript)

function isPalindrome(s: string): boolean {
    s = s.replace(/[^A-Za-z0-9]/g, '').toLowerCase();
    let left = 0, right = s.length - 1;

    while (left < right) {
        if (s[left] !== s[right]) {
            return false;
        }
        left++;
        right--;
    }

    return true;
}

Breaking Down the Solution

• Preprocessing: Remove all non-alphanumeric characters and convert to lowercase to standardize the string.

• Two Pointers: Use two pointers, one at the start and one at the end, moving towards the center.

• Compare Characters: If characters at the start and end pointers don't match, it's not a palindrome.

• Iterate and Validate: Continue moving pointers inward and comparing until they meet or a mismatch is found.

Conclusion

The Valid Palindrome problem is a classic example of using the two pointers technique to check for symmetry in strings. It's a fundamental exercise in string manipulation and pattern recognition.

Problem Statement

Given a string containing characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid. The brackets must close in the correct order, meaning "()" and "()[]{}" are valid, but "(]" and "([)]" are not.

Example

• Input: "()[]{}"
• Output: true
• Input: "(]"
• Output: false

Solution Approach - Stack Utilization (typescript)

function isValid(s: string): boolean {
    let stack: string[] = [];
    const mappings = new Map([
        [')', '('],
        ['}', '{'],
        [']', '[']
    ]);

    for (let char of s) {
        if (mappings.has(char)) {
            const topElement = stack.length === 0 ? '#' : stack.pop();
            if (topElement !== mappings.get(char)) {
                return false;
            }
        } else {
            stack.push(char);
        }
    }

    return stack.length === 0;
}

Breaking Down the Solution

• Using a Stack: A stack is used to keep track of opening brackets.

• Map for Mappings: A map holds the pairs of corresponding opening and closing brackets.

• Validating Closure: For each closing bracket, check if the top of the stack is the corresponding opening bracket. If not, the string is invalid.

• Empty Stack: If the stack is empty at the end, the string is valid.

Conclusion

The Valid Parentheses problem is a classic example of using a stack to ensure proper closure and nesting of brackets in a string. It's a fundamental exercise in balancing and ordering in data structures.

Problem Statement

Given a string, find the length of the longest substring without repeating characters.

Example

• Input: "abcabcbb"
• Output: 3 (The answer is "abc", with the length of 3)

Solution Approach - Sliding Window Technique

function lengthOfLongestSubstring(s) {
    let map = new Map();
    let maxLen = 0, start = 0;

    for (let end = 0; end < s.length; end++) {
        if (map.has(s[end])) {
            start = Math.max(start, map.get(s[end]) + 1);
        }
        map.set(s[end], end);
        maxLen = Math.max(maxLen, end - start + 1);
    }

    return maxLen;
}

Breaking Down the Solution

• Sliding Window: Use two pointers (start and end) to create a sliding window that expands and contracts as it traverses the string.

• Track Characters: Use a map to track the last index of each character encountered.

• Adjust Window: When a repeated character is found, move the start pointer to avoid the repetition.

• Calculate Max Length: Continuously update the maximum length of the substring as the window slides.

Conclusion

The Longest Substring Without Repeating Characters problem is an excellent application of the sliding window technique in strings. It's commonly used in interview settings to assess understanding of string manipulation and efficient data storage.

Problem Statement

Given an n x n matrix representing an image, rotate the image by 90 degrees (clockwise). You have to rotate the image in place, which means you have to modify the input 2D matrix directly.

Example

• Input: Matrix

[
  [1, 2, 3], 
  [4, 5, 6],
  [7, 8, 9]
]

• Output (after rotation):

[
  [7, 4, 1],
  [8, 5, 2],
  [9, 6, 3]
]

Solution Approach (typescript)

function rotate(matrix: number[][]): void {
  const n = matrix.length;

  // Transpose the matrix
  for (let i = 0; i < n; i++) {
      for (let j = i; j < n; j++) {
          [matrix[i][j], matrix[j][i]] = [matrix[j][i], matrix[i][j]];
      }
  }

  // Reverse each row
  for (let i = 0; i < n; i++) {
      matrix[i].reverse();
  }
}

Breaking Down the Solution

• Transpose the Matrix: Swap elements across the diagonal to transpose the matrix, turning rows into columns.

• Reverse Each Row: Reverse the elements in each row to achieve the 90-degree clockwise rotation.

Solution Approach (go)

package main

import (
    "fmt"
)

func rotate(matrix [][]int) {
    n := len(matrix)
    // Transpose the matrix
    for i := 0; i < n; i++ {
        for j := i; j < n; j++ {
            matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]
        }
    }

    // Reverse each row
    for i := 0; i < n; i++ {
        for j := 0; j < n/2; j++ {
            matrix[i][j], matrix[i][n-1-j] = matrix[i][n-1-j], matrix[i][j]
        }
    }
}

func main() {
    matrix := [][]int{
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9},
    }

    rotate(matrix)
    fmt.Println("Rotated Matrix:")
    for _, row := range matrix {
        fmt.Println(row)
    }
}

In this Go program:

• The rotate function first transposes the matrix by swapping elements across its diagonal.
• Then, it reverses each row of the matrix. This combination of transposition and reversal results in a 90-degree clockwise rotation.
• The main function demonstrates the usage of the rotate function with a sample matrix.

Solution Approach (cpp)

#include <iostream>
#include <vector>

void rotate(std::vector<std::vector<int>>& matrix) {
    int n = matrix.size();

    // Transpose the matrix
    for (int i = 0; i < n; ++i) {
        for (int j = i; j < n; ++j) {
            std::swap(matrix[i][j], matrix[j][i]);
        }
    }

    // Reverse each row
    for (int i = 0; i < n; ++i) {
        std::reverse(matrix[i].begin(), matrix[i].end());
    }
}

int main() {
    std::vector<std::vector<int>> matrix = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };

    rotate(matrix);

    // Output the rotated matrix
    for (const auto& row : matrix) {
        for (int val : row) {
            std::cout << val << " ";
        }
        std::cout << std::endl;
    }

    return 0;
}

In this solution:

• The function rotate takes a reference to a 2D vector (representing the matrix) and modifies it in place.
• First, the matrix is transposed by swapping elements across the diagonal.
• Then, each row of the matrix is reversed. This combination of transposing and reversing the rows results in a 90-degree clockwise rotation.
• The main function demonstrates the usage of the rotate function with a sample matrix and prints the rotated matrix.

Conclusion

The Rotate Image problem is a classic exercise in matrix manipulation, demonstrating in-place transformations. It's a practical scenario in image processing and graphical applications, testing one's understanding of array operations and geometry.

Problem Statement

Given a m x n matrix, return all elements of the matrix in spiral order.

Example

• Input: Matrix

[
  [1, 2, 3],
  [4, 5, 6],
  [7, 8, 9]
]

• Output:

  [1, 2, 3, 6, 9, 8, 7, 4, 5]

Solution Approach (typescript)

function spiralOrder(matrix: number[][]): number[] {
  if (matrix.length === 0) return [];

  let result: number[] = [];
  let left = 0, right = matrix[0].length - 1;
  let top = 0, bottom = matrix.length - 1;

  while (left <= right && top <= bottom) {
      for (let i = left; i <= right; i++) result.push(matrix[top][i]);
      top++;

      for (let i = top; i <= bottom; i++) result.push(matrix[i][right]);
      right--;

      if (top <= bottom) {
          for (let i = right; i >= left; i--) result.push(matrix[bottom][i]);
          bottom--;
      }

      if (left <= right) {
          for (let i = bottom; i >= top; i--) result.push(matrix[i][left]);
          left++;
      }
  }

  return result;
}

Breaking Down the Solution

• Initialize Boundaries: Start with boundaries (left, right, top, bottom) for the matrix.

• Traverse in Spiral: Move right across the top row, down the rightmost column, left across the bottom row, and up the leftmost column, adjusting boundaries each time.

• Continue Inward: Repeat the process for each layer of the spiral until all elements are covered.

Solution Approach (go)

package main

import (
    "fmt"
)

func spiralOrder(matrix [][]int) []int {
    if len(matrix) == 0 {
        return []int{}
    }

    result := make([]int, 0)
    top, bottom := 0, len(matrix)-1
    left, right := 0, len(matrix[0])-1

    for left <= right && top <= bottom {
        // Move right
        for i := left; i <= right; i++ {
            result = append(result, matrix[top][i])
        }
        top++

        // Move down
        for i := top; i <= bottom; i++ {
            result = append(result, matrix[i][right])
        }
        right--

        if top <= bottom {
            // Move left
            for i := right; i >= left; i-- {
                result = append(result, matrix[bottom][i])
            }
            bottom--
        }

        if left <= right {
            // Move up
            for i := bottom; i >= top; i-- {
                result = append(result, matrix[i][left])
            }
            left++
        }
    }

    return result
}

func main() {
    matrix := [][]int{
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9},
    }
    fmt.Println(spiralOrder(matrix)) // Output: [1 2 3 6 9 8 7 4 5]
}

In this Go solution:

• The function spiralOrder takes a 2D integer slice (matrix) and returns a slice with the elements in spiral order.
• The variables top, bottom, left, and right define the boundaries of the current layer of the spiral.
• The spiral traversal is performed by moving right, down, left, and up, adjusting the boundaries after each direction change.
• The loop continues until all elements are traversed, shrinking the spiral layer by layer.

#include <iostream>
#include <vector>

std::vector<int> spiralOrder(std::vector<std::vector<int>>& matrix) {
    std::vector<int> result;
    if (matrix.empty()) return result;

    int top = 0, bottom = matrix.size() - 1;
    int left = 0, right = matrix[0].size() - 1;

    while (left <= right && top <= bottom) {
        // Move right
        for (int i = left; i <= right; i++) {
            result.push_back(matrix[top][i]);
        }
        top++;

        // Move down
        for (int i = top; i <= bottom; i++) {
            result.push_back(matrix[i][right]);
        }
        right--;

        if (top <= bottom) {
            // Move left
            for (int i = right; i >= left; i--) {
                result.push_back(matrix[bottom][i]);
            }
            bottom--;
        }

        if (left <= right) {
            // Move up
            for (int i = bottom; i >= top; i--) {
                result.push_back(matrix[i][left]);
            }
            left++;
        }
    }

    return result;
}

int main() {
    std::vector<std::vector<int>> matrix = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };

    std::vector<int> result = spiralOrder(matrix);
    for (int num : result) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

In this C++ solution:

• The function spiralOrder takes a reference to a 2D vector (matrix) and returns a vector with the elements in spiral order.
• The variables top, bottom, left, and right define the current spiral layer's boundaries.
• The spiral traversal includes moving right, down, left, and up, with each direction bounded by the current layer's limits.
• The loop continues until all layers are traversed, reducing the spiral layer by layer.

Solution Approach (rust)

fn spiral_order(matrix: Vec<Vec<i32>>) -> Vec<i32> {
    if matrix.is_empty() {
        return Vec::new();
    }

    let mut result = Vec::new();
    let (mut top, mut bottom) = (0, matrix.len() - 1);
    let (mut left, mut right) = (0, matrix[0].len() - 1);

    while left <= right && top <= bottom {
        // Move right
        for i in left..=right {
            result.push(matrix[top][i]);
        }
        top += 1;

        // Move down
        for i in top..=bottom {
            result.push(matrix[i][right]);
        }
        if right > 0 {
            right -= 1;
        }

        // Move left
        if top <= bottom {
            for i in (left..=right).rev() {
                result.push(matrix[bottom][i]);
            }
            bottom = bottom.saturating_sub(1);
        }

        // Move up
        if left <= right {
            for i in (top..=bottom).rev() {
                result.push(matrix[i][left]);
            }
            left += 1;
        }
    }

    result
}

fn main() {
    let matrix = vec![
        vec![1, 2, 3],
        vec![4, 5, 6],
        vec![7, 8, 9],
    ];

    let result = spiral_order(matrix);
    println!("{:?}", result); // Output: [1, 2, 3, 6, 9, 8, 7, 4, 5]
}

In this Rust solution:

• The spiral_order function takes a matrix (a Vec<Vec<i32>>) and returns a vector containing the elements in spiral order.
• The top, bottom, left, and right variables define the boundaries of the current spiral layer.
• The code performs spiral traversal, moving right, down, left, and up within the boundaries of the current layer. It decreases the layer size after each direction.
• The saturating_sub function is used to prevent underflow when decrementing bottom.
• Rust's range syntax (..=) and its ability to reverse ranges (rev()) are used to iterate over rows and columns.

Conclusion

The Spiral Matrix problem is a fascinating challenge that requires careful manipulation of array indices and boundaries. It is a popular question in technical interviews, testing understanding of 2D arrays and iterative traversals.

Problem Statement

Given a 2D board of letters and a word, check if the word exists in the grid. The word can be constructed from letters of sequentially adjacent cells, where "adjacent" cells are those horizontally or vertically neighboring.

Example

• Input:
  Board:

[
  ['A','B','C','E'],
  ['S','F','C','S'],
  ['A','D','E','E']
]

Word: "ABCCED"

• Output: true

Solution Approach (typescript)

function exist(board: string[][], word: string): boolean {
  function dfs(board: string[][], i: number, j: number, count: number, word: string): boolean {
    if (count === word.length) return true;
    if (
      i < 0 ||
      i >= board.length ||
      j < 0 ||
      j >= board[i].length ||
      board[i][j] !== word[count]
    ) {
      return false;
    }

    let temp = board[i][j];
    board[i][j] = ' ';
    let found =
      dfs(board, i + 1, j, count + 1, word) ||
      dfs(board, i - 1, j, count + 1, word) ||
      dfs(board, i, j + 1, count + 1, word) ||
      dfs(board, i, j - 1, count + 1, word);

    board[i][j] = temp;
    return found;
  }

  for (let i = 0; i < board.length; i++) {
    for (let j = 0; j < board[i].length; j++) {
      if (board[i][j] === word[0] && dfs(board, i, j, 0, word)) {
        return true;
      }
    }
  }
  return false;
}

Breaking Down the Solution

• Depth-First Search (DFS): Use DFS to traverse the board, exploring each possible path.

• Check Each Cell: Start from each cell that matches the first letter of the word, and recursively check its neighbors.

• Track Progress: Temporarily mark cells as visited during each DFS iteration to avoid revisiting them in the same path.

• Return Result: If the word is found, return true; if the board is fully explored without finding the word, return false.

Solution in Go

package main

import (
    "fmt"
)

func exist(board [][]byte, word string) bool {
    for i := 0; i < len(board); i++ {
        for j := 0; j < len(board[i]); j++ {
            if dfs(board, i, j, word, 0) {
                return true
            }
        }
    }
    return false
}

func dfs(board [][]byte, i, j int, word string, count int) bool {
    if count == len(word) {
        return true
    }
    if i < 0 || i >= len(board) || j < 0 || j >= len(board[0]) || board[i][j] != word[count] {
        return false
    }

    temp := board[i][j]
    board[i][j] = byte(' ')
    found := dfs(board, i+1, j, word, count+1) ||
        dfs(board, i-1, j, word, count+1) ||
        dfs(board, i, j+1, word, count+1) ||
        dfs(board, i, j-1, word, count+1)

    board[i][j] = temp
    return found
}

func main() {
    board := [][]byte{
        {'A', 'B', 'C', 'E'},
        {'S', 'F', 'C', 'S'},
        {'A', 'D', 'E', 'E'},
    }
    word := "ABCCED"
    fmt.Println(exist(board, word)) // Output: true
}

In this Go implementation:

• The exist function checks if a given word exists in the board. It iterates over each cell in the board and calls the dfs (Depth-First Search) function.
• The dfs function performs a depth-first search from the current cell to check if the remaining characters of the word can be formed. It marks the cell as visited by replacing the character with a space and then recursively checks adjacent cells.
• If dfs returns true at any point, exist will return true, indicating the word is found in the board.
• After the recursive call, the cell's original character is restored.

Solution in C++

#include <iostream>
#include <vector>

using namespace std;

bool dfs(vector<vector<char>>& board, int i, int j, string& word, int count) {
    if (count == word.length()) {
        return true;
    }
    if (i < 0 || i >= board.size() || j < 0 || j >= board[0].size() || board[i][j] != word[count]) {
        return false;
    }

    char temp = board[i][j];
    board[i][j] = ' ';
    bool found = dfs(board, i + 1, j, word, count + 1) 
              || dfs(board, i - 1, j, word, count + 1) 
              || dfs(board, i, j + 1, word, count + 1) 
              || dfs(board, i, j - 1, word, count + 1);
    
    board[i][j] = temp;
    return found;
}

bool exist(vector<vector<char>>& board, string word) {
    for (int i = 0; i < board.size(); i++) {
        for (int j = 0; j < board[i].size(); j++) {
            if (board[i][j] == word[0] && dfs(board, i, j, word, 0)) {
                return true;
            }
        }
    }
    return false;
}

int main() {
    vector<vector<char>> board = {
        {'A','B','C','E'},
        {'S','F','C','S'},
        {'A','D','E','E'}
    };
    string word = "ABCCED";

    cout << (exist(board, word) ? "true" : "false") << endl;

    return 0;
}

In this C++ solution:

• The dfs function performs a depth-first search from the current cell, recursively checking adjacent cells to form the word. It temporarily marks the cell as visited by setting it to a space character and restores it after the recursive calls.
• The exist function iterates over each cell in the board, starting a new DFS search whenever it finds the first character of the word.
• If dfs returns true for any starting cell, the entire function returns true, indicating the word is found.
• Compile and run this program to check if the given word exists in the board.

Solution in Python

def exist(board, word):
    def dfs(board, i, j, word, count):
        if count == len(word):
            return True
        if i < 0 or i >= len(board) or j < 0 or j >= len(board[0]) or board[i][j] != word[count]:
            return False

        temp = board[i][j]
        board[i][j] = ' '  # Mark as visited
        found = dfs(board, i + 1, j, word, count + 1) or \
                dfs(board, i - 1, j, word, count + 1) or \
                dfs(board, i, j + 1, word, count + 1) or \
                dfs(board, i, j - 1, word, count + 1)
        
        board[i][j] = temp  # Reset the state
        return found

    for i in range(len(board)):
        for j in range(len(board[0])):
            if board[i][j] == word[0] and dfs(board, i, j, word, 0):
                return True
    return False

# Example usage
board = [
    ['A', 'B', 'C', 'E'],
    ['S', 'F', 'C', 'S'],
    ['A', 'D', 'E', 'E']
]
word = "ABCCED"
print(exist(board, word))  # Output: True

In this Python solution:

• The dfs function is defined within exist to utilize the scope of board and word. It performs a depth-first search from the current cell.
• The cell is temporarily marked as visited by setting it to a space character, and then restored to its original value after the recursive calls.
• exist iterates over the board, calling dfs for each cell that matches the first letter of the word.
• If dfs returns True, the word exists in the board; otherwise, it does not.

Solution in Java

public class WordSearch {
    public boolean exist(char[][] board, String word) {
        for (int i = 0; i < board.length; i++) {
            for (int j = 0; j < board[i].length; j++) {
                if (board[i][j] == word.charAt(0) && dfs(board, i, j, 0, word)) {
                    return true;
                }
            }
        }
        return false;
    }

    private boolean dfs(char[][] board, int i, int j, int count, String word) {
        if (count == word.length()) return true;
        if (i < 0 || i >= board.length || j < 0 || j >= board[0].length || board[i][j] != word.charAt(count)) return false;

        char temp = board[i][j];
        board[i][j] = ' '; // Mark as visited
        boolean found = dfs(board, i + 1, j, count + 1, word) 
                     || dfs(board, i - 1, j, count + 1, word)
                     || dfs(board, i, j + 1, count + 1, word)
                     || dfs(board, i, j - 1, count + 1, word);

        board[i][j] = temp; // Reset state
        return found;
    }

    public static void main(String[] args) {
        WordSearch solution = new WordSearch();
        char[][] board = {
            {'A', 'B', 'C', 'E'},
            {'S', 'F', 'C', 'S'},
            {'A', 'D', 'E', 'E'}
        };
        String word = "ABCCED";
        System.out.println(solution.exist(board, word)); // Output: true
    }
}

In this Java solution:

• The exist method iterates over each cell in the board, starting a DFS search from cells that match the first character of the word.
• The dfs method performs a depth-first search to check if the word can be formed, starting from the current cell. It marks the cell as visited by setting it to a space character and resets it to its original value after exploring all possible paths from that cell.
• If dfs returns true at any point, exist will return true, indicating that the word is found in the board.
• The main method demonstrates how to use the WordSearch class with a sample board and word.

Solution in Kotlin

class WordSearch {
    fun exist(board: Array<CharArray>, word: String): Boolean {
        for (i in board.indices) {
            for (j in board[0].indices) {
                if (board[i][j] == word[0] && dfs(board, i, j, 0, word)) {
                    return true
                }
            }
        }
        return false
    }

    private fun dfs(board: Array<CharArray>, i: Int, j: Int, count: Int, word: String): Boolean {
        if (count == word.length) return true
        if (i < 0 || i >= board.size || j < 0 || j >= board[0].size || board[i][j] != word[count]) return false

        val temp = board[i][j]
        board[i][j] = ' '  // Mark as visited
        val found = dfs(board, i + 1, j, count + 1, word)
                  || dfs(board, i - 1, j, count + 1, word)
                  || dfs(board, i, j + 1, count + 1, word)
                  || dfs(board, i, j - 1, count + 1, word)

        board[i][j] = temp  // Reset state
        return found
    }
}

fun main() {
    val solution = WordSearch()
    val board = arrayOf(
        charArrayOf('A', 'B', 'C', 'E'),
        charArrayOf('S', 'F', 'C', 'S'),
        charArrayOf('A', 'D', 'E', 'E')
    )
    val word = "ABCCED"
    println(solution.exist(board, word)) // Output: true
}

In this Kotlin solution:

• The exist function iterates over each cell in the board, starting a DFS search from cells that match the first character of the word.
• The dfs function performs a depth-first search to check if the word can be formed, starting from the current cell. It marks the cell as visited by setting it to a space character and resets it to its original value after the recursive calls.
• If dfs returns true for any starting cell, exist will return true, indicating the word is found in the board.
• The main function demonstrates how to use the WordSearch class with a sample board and word.

Conclusion

The Word Search problem is a classic example of using DFS in a matrix-like structure. It tests one's ability to implement recursive search algorithms and handle edge cases in grid traversal.

Problem Statement

Given a list of non-overlapping intervals sorted by their start times, insert a new interval into the list so that the list remains sorted and any overlapping intervals are merged.

Example

• Input: Intervals [[1,3],[6,9]], New Interval [2,5]
  Output: [[1,5],[6,9]]
  Explanation: The new interval [2,5] overlaps with [1,3] and should be merged into [1,5].

Solution Approach

function insert(intervals, newInterval) {
    let result = [];
    let i = 0;

    // Add all intervals ending before newInterval starts
    while (i < intervals.length && intervals[i][1] < newInterval[0]) {
        result.push(intervals[i]);
        i++;
    }

    // Merge all overlapping intervals to one considering newInterval
    while (i < intervals.length && intervals[i][0] <= newInterval[1]) {
        newInterval = [
            Math.min(newInterval[0], intervals[i][0]),
            Math.max(newInterval[1], intervals[i][1])
        ];
        i++;
    }
    result.push(newInterval); // Add the merged interval

    // Add all the rest
    while (i < intervals.length) {
        result.push(intervals[i]);
        i++;
    }

    return result;
}

Breaking Down the Solution

• Initial Non-Overlapping Intervals: Add all intervals that end before the new interval starts to the result.

• Merging Overlapping Intervals: Iterate through all intervals that overlap with the new interval and merge them into a single interval.

• Add Remaining Intervals: Finally, add the remaining intervals that start after the new interval ends.

Conclusion

The Insert Interval problem is an excellent example of interval manipulation and requires a careful approach to handle overlapping and merging. It is a common scenario in calendar and scheduling applications, making it a practical problem in software development.

Binary Search Solution

function insert(intervals, newInterval) {
    let left = 0, right = intervals.length - 1;
    while (left <= right) {
        let mid = Math.floor((left + right) / 2);
        if (intervals[mid][1] < newInterval[0]) {
            left = mid + 1;
        } else if (intervals[mid][0] > newInterval[1]) {
            right = mid - 1;
        } else {
            newInterval = [
                Math.min(newInterval[0], intervals[mid][0]),
                Math.max(newInterval[1], intervals[mid][1])
            ];
            intervals.splice(mid, 1);
            left = mid; // Adjust left to recheck the same mid index
        }
    }

    intervals.splice(left, 0, newInterval); // Insert the new/merged interval

    // Merge overlapping intervals if necessary
    let i = left;
    while (i < intervals.length - 1) {
        if (intervals[i][1] >= intervals[i + 1][0]) {
            intervals[i] = [
                intervals[i][0],
                Math.max(intervals[i][1], intervals[i + 1][1])
            ];
            intervals.splice(i + 1, 1);
        } else {
            i++;
        }
    }

    return intervals;
}

Breaking Down the Solution

• Binary Search for Insertion Point: Use binary search to find the correct position or overlapping interval for the new interval.

• Insert and Merge: Insert the new interval at the found position. Then, iterate through the list to merge any overlapping intervals resulting from the insertion.

• Optimized Overlapping Check: Post-insertion, check only nearby intervals for any potential overlap, reducing the number of comparisons.

Conclusion

Using binary search in the Insert Interval problem significantly enhances the efficiency of finding the correct position for insertion, especially in cases with a large number of intervals. This approach exemplifies the power of combining binary search with interval merging for optimized solutions in array manipulation tasks.

Divide and Conquer solution

export function insertIntervalDivideAndConquer(
  intervals: [number, number][],
  newInterval: [number, number]
): [number, number][] {
  // Base case: if the intervals list is empty
  if (intervals.length === 0) {
    return [newInterval];
  }

  // Base case: if the intervals list contains only one interval
  if (intervals.length === 1) {
    return mergeIntervals(intervals[0], newInterval);
  }

  // Divide the intervals list into two halves
  const mid = Math.floor(intervals.length / 2);
  const leftPart = insertIntervalDivideAndConquer(intervals.slice(0, mid), newInterval);
  const rightPart = insertIntervalDivideAndConquer(intervals.slice(mid), newInterval);

  // Conquer: merge the two halves back together
  return mergeSortedIntervals(leftPart, rightPart);
}

// Helper function to merge two intervals if they overlap
function mergeIntervals(
  interval1: [number, number],
  interval2: [number, number]
): [number, number][] {
  if (interval1[1] < interval2[0] || interval2[1] < interval1[0]) {
    return [interval1, interval2].sort((a, b) => a[0] - b[0]);
  } else {
    return [[Math.min(interval1[0], interval2[0]), Math.max(interval1[1], interval2[1])]];
  }
}

// Helper function to merge two sorted lists of intervals
function mergeSortedIntervals(
  part1: [number, number][],
  part2: [number, number][]
): [number, number][] {
  let result = [],
    i = 0,
    j = 0;

  while (i < part1.length && j < part2.length) {
    let interval1 = part1[i],
      interval2 = part2[j];
    if (interval1[1] < interval2[0]) {
      result.push(interval1);
      i++;
    } else if (interval2[1] < interval1[0]) {
      result.push(interval2);
      j++;
    } else {
      const merged = mergeIntervals(interval1, interval2);
      result.push(...merged);
      i++;
      j++;
    }
  }

  while (i < part1.length) result.push(part1[i++]);
  while (j < part2.length) result.push(part2[j++]);

  return result;
}

In this solution:

1. The list of intervals is recursively split into two halves.
2. The mergeIntervals helper function is used to merge intervals if they overlap.
3. The mergeSortedIntervals function merges the two halves back together, ensuring that the result remains sorted and that all intervals are properly merged.

This approach is more complex than iterative solutions but showcases an alternative way of thinking about the problem.

Problem Statement

Given an array of intervals where each interval is represented as a pair [start, end], merge all overlapping intervals, and return an array of the non-overlapping intervals that cover all the intervals in the input.

Example

• Input: Intervals [[1,3],[2,6],[8,10],[15,18]]
  Output: [[1,6],[8,10],[15,18]]
  Explanation: Since intervals [1,3] and [2,6] overlap, they are merged into [1,6].

Solution Approach

function merge(intervals) {
    if (!intervals.length) return [];

    // Sort the intervals based on the start times
    intervals.sort((a, b) => a[0] - b[0]);

    const merged = [intervals[0]];

    for (let i = 1; i < intervals.length; i++) {
        const lastMerged = merged[merged.length - 1];
        const current = intervals[i];

        if (current[0] <= lastMerged[1]) {
            // Overlapping intervals, merge them
            lastMerged[1] = Math.max(lastMerged[1], current[1]);
        } else {
            // Non-overlapping interval, add to the result
            merged.push(current);
        }
    }

    return merged;
}

Breaking Down the Solution

• Sort Intervals: First, sort the intervals based on their starting points.

• Initialize Merged List: Start with the first interval in the merged list.

• Iterate and Merge: Go through each interval and merge it with the last interval in the merged list if they overlap. If they don't overlap, add the interval to the merged list.

• Return Merged Intervals: The merged list now contains the minimal set of non-overlapping intervals.

Conclusion

The Merge Intervals problem is a classic example of interval manipulation and is critical in many applications, such as calendar events, scheduling algorithms, and time-based data analysis. It emphasizes the importance of sorting and efficient merging in array processing.

Problem Statement

Merge two sorted linked lists and return it as a new sorted list. The new list should be made by splicing together the nodes of the first two lists.

Example

• Input: List1 1 -> 2 -> 4, List2 1 -> 3 -> 4
• Output: Merged List 1 -> 1 -> 2 -> 3 -> 4 -> 4

Iterative Solution

class ListNode {
    val: number;
    next: ListNode | null;

    constructor(val?: number, next?: ListNode | null) {
        this.val = (val === undefined ? 0 : val);
        this.next = (next === undefined ? null : next);
    }
}

function mergeTwoLists(l1: ListNode | null, l2: ListNode | null): ListNode | null {
    let dummyHead = new ListNode(0);
    let current = dummyHead;

    while (l1 !== null && l2 !== null) {
        if (l1.val < l2.val) {
            current.next = l1;
            l1 = l1.next;
        } else {
            current.next = l2;
            l2 = l2.next;
        }
        current = current.next;
    }

    // Attach the remaining part of l1 or l2
    current.next = l1 ? l1 : l2;

    return dummyHead.next;
}

Breaking Down the Solution

• Initialize a Dummy Head: Start with a dummy head to simplify edge cases and maintain a reference to the head of the merged list.

• Iterate Through Both Lists: Compare nodes from both lists, appending the smaller node to the merged list.

• Handle Remaining Nodes: Once one of the lists is exhausted, attach the remaining part of the other list to the merged list.

• Return Merged List: The next of the dummy head points to the start of the merged list.

Conclusion

Merging two sorted linked lists is a common problem that demonstrates the importance of pointer manipulation in data structures. It's a key skill for many algorithms and applications involving linked lists.

Problem Statement

Given an array of intervals, find the minimum number of intervals you need to remove to make the rest of the intervals non-overlapping.

Example

• Input: Intervals [[1,2],[2,3],[3,4],[1,3]]
  Output: 1
  Explanation: Removing the interval [1,3] leaves [1,2], [2,3], and [3,4], which are non-overlapping.

Greedy Solution Approach

function eraseOverlapIntervals(intervals) {
    if (!intervals.length) return 0;

    // Sort intervals based on their end times
    intervals.sort((a, b) => a[1] - b[1]);

    let end = intervals[0][1];
    let count = 0;

    for (let i = 1; i < intervals.length; i++) {
        if (intervals[i][0] < end) {
            // Overlapping interval, increment count
            count++;
        } else {
            // Update end time for the next comparison
            end = intervals[i][1];
        }
    }

    return count;
}

Breaking Down the Solution

• Sort by End Time: Sort the intervals by their end times to ensure a minimal number of removals.

• Count Removals: Iterate through the intervals, counting each time an interval overlaps with the previous one.

• Update End Time: After a non-overlapping interval is found, update the end time for the next comparison.

Conclusion

The Non-overlapping Intervals problem is an excellent application of greedy algorithms in optimizing interval arrangements. It highlights the importance of strategic sorting and interval selection in minimizing removals and is a common scenario in resource allocation and scheduling systems.

Problem Statement

Given the head of a linked list, remove the nth node from the end of the list and return its head.

Example

• Input: Linked List 1 -> 2 -> 3 -> 4 -> 5, n = 2
• Output: Modified List 1 -> 2 -> 3 -> 5

Solution Approach - Two Pointer Technique

class ListNode {
    val: number;
    next: ListNode | null;

    constructor(val?: number, next?: ListNode | null) {
        this.val = (val === undefined ? 0 : val);
        this.next = (next === undefined ? null : next);
    }
}

function removeNthFromEnd(head: ListNode | null, n: number): ListNode | null {
    let dummy = new ListNode(0);
    dummy.next = head;
    let first: ListNode | null = dummy;
    let second: ListNode | null = dummy;

    // Advance first pointer by n+1 steps
    for (let i = 0; i <= n; i++) {
        if (first) {
            first = first.next;
        }
    }

    // Move first to the end, maintaining the gap
    while (first !== null) {
        first = first.next;
        if (second) {
            second = second.next;
        }
    }

    // Skip the desired node
    if (second && second.next) {
        second.next = second.next.next;
    }

    return dummy.next;
}

Breaking Down the Solution

• Initialize Two Pointers: Use two pointers, first and second, both starting from a dummy node before the head.

• Advance the First Pointer: Move first n+1 steps ahead, creating a gap of n nodes between first and second.

• Move Both Pointers: Traverse the list with both pointers until first reaches the end. At this point, second is just before the nth node from the end.

• Remove the Nth Node: Adjust the next pointer of the second node to skip the nth node.

Conclusion

The Remove Nth Node From End of List problem is an excellent exercise in pointer manipulation and demonstrates the two-pointer technique's usefulness in linked list problems. It highlights a common scenario in data structure manipulation and algorithm design.

Problem Statement

Given a singly linked list, reorder it such that the list follows the pattern: first node, last node, second node, second last node, and so on.

Example

• Input: Linked List 1 -> 2 -> 3 -> 4
• Output: Reordered List 1 -> 4 -> 2 -> 3

Solution Approach

class ListNode {
    val: number;
    next: ListNode | null;

    constructor(val?: number, next?: ListNode | null) {
        this.val = (val === undefined ? 0 : val);
        this.next = (next === undefined ? null : next);
    }
}

function reorderList(head: ListNode | null): void {
    if (!head || !head.next) return;

    // Step 1: Find the middle of the list
    let slow: ListNode | null = head, fast: ListNode | null = head;
    while (fast && fast.next) {
        slow = slow!.next;
        fast = fast.next.next;
    }

    // Step 2: Reverse the second half of the list
    let prev: ListNode | null = null;
    let curr: ListNode | null = slow;
    let temp: ListNode | null;
    while (curr) {
        temp = curr.next;
        curr.next = prev;
        prev = curr;
        curr = temp;
    }

    // Step 3: Merge the two halves
    let first: ListNode | null = head, second: ListNode | null = prev;
    while (second && second.next) {
        temp = first!.next;
        first!.next = second;
        first = temp;

        temp = second.next;
        second.next = first;
        second = temp;
    }
}

Breaking Down the Solution

• Find Middle: Use the fast and slow pointer technique to find the middle of the list.

• Reverse Second Half: Reverse the second half of the list starting from the middle.

• Merge Halves: Alternately merge nodes from the first half and the reversed second half.

Conclusion

The Reorder List problem is an excellent exercise in linked list operations, combining techniques like finding the middle of a list, reversing a list, and merging lists. It showcases complex manipulation of data structures and is a useful skill for many algorithmic challenges.

Problem Statement

Given the head of a singly linked list, reverse the list and return the reversed list.

Example

Consider a linked list: 1 -> 2 -> 3 -> 4 -> 5
After reversing, the list becomes: 5 -> 4 -> 3 -> 2 -> 1

Iterative Solution

function reverseList(head) {
    let prev = null;
    let current = head;

    while (current !== null) {
        let nextTemp = current.next;
        current.next = prev;
        prev = current;
        current = nextTemp;
    }

    return prev; // New head of the reversed list
}

Breaking Down the Solution

• Initialize Pointers: Start with prev set to null and current set to the head of the list.

• Iterate Through List: Traverse the list, reversing the pointers at each node.

• Update Pointers: For each node, point it to the prev node, then update prev to be the current node and move current to the next node in the original list.

• Return New Head: At the end of the iteration, prev will be the new head of the reversed list.

Conclusion

The Reverse Linked List problem is a fundamental exercise in linked list manipulation, demonstrating the importance of pointer manipulation in data structures. It is a valuable skill for understanding more complex linked list operations and problems.

Problem Statement

Given a 2D grid map of '1's (land) and '0's (water), determine the number of islands. An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically.

Example

Consider a grid map:
11110
11010
11000
00000

The number of islands in this grid is 1.

Depth-First Search Solution

function numIslands(grid) {
    if (!grid || !grid.length) return 0;

    let numIslands = 0;

    function dfs(row, col) {
        if (row < 0 || row >= grid.length || col < 0 || col >= grid[0].length || grid[row][col] === '0') {
            return;
        }
        grid[row][col] = '0'; // Mark as visited
        dfs(row + 1, col); // Down
        dfs(row - 1, col); // Up
        dfs(row, col + 1); // Right
        dfs(row, col - 1); // Left
    }

    for (let i = 0; i < grid.length; i++) {
        for (let j = 0; j < grid[i].length; j++) {
            if (grid[i][j] === '1') {
                numIslands++;
                dfs(i, j);
            }
        }
    }

    return numIslands;
}

Breaking Down the Solution

• DFS Traversal: Use depth-first search to explore each land cell and mark it as visited by setting it to '0'.

• Count Islands: Iterate over each cell in the grid. When a land cell ('1') is found, increment the island count and use DFS to mark the entire island.

• Handle Edge Cases: Check for invalid indices and water cells ('0') in the DFS function to prevent out-of-bounds errors and unnecessary exploration.

Time Complexity

The time complexity is O(M x N), where M is the number of rows and N is the number of columns in the grid. This is because, in the worst case, the algorithm needs to visit every cell in the grid once. The DFS traversal ensures that each cell is visited only once, so the total number of operations is proportional to the total number of cells.

Space Complexity

The space complexity is also O(M x N) in the worst case. This is due to the recursive nature of DFS, which could potentially have a call stack with a depth equal to the number of cells in the grid in the worst case (e.g., a grid that is entirely land).

Can It Be Improved?

• Space Complexity: One way to improve the space complexity is to use an iterative DFS approach with an explicit stack instead of recursion. This can help in scenarios where the grid is large, and recursion might lead to a stack overflow.
• Alternative Approach - BFS: Another way to traverse the grid is by using breadth-first search (BFS). While BFS does not improve the worst-case time complexity, it can be more practical in terms of space complexity, especially if the grid forms one large island, as BFS will keep the queue size minimal relative to the size of the island being explored.
• Union-Find (Disjoint Set): An alternative approach is to use the Union-Find algorithm. This can be particularly efficient if there are many queries on the grid after some modifications (e.g., adding or removing land). However, the implementation complexity is higher compared to DFS or BFS.

In practice, the choice of algorithm might depend on the specific characteristics of the input data and the constraints of the problem (e.g., grid size, number of islands, likelihood of stack overflow, etc.).

Conclusion

The Number of Islands problem is an essential application of depth-first search in a grid-based context. It highlights how grid traversal can be used to solve complex problems in areas such as mapping, geographical information systems, and computer graphics.

Problem Statement

Given the total number of courses numbered from 0 to n - 1 and a list of prerequisite pairs, determine if it's possible for a student to finish all courses. A prerequisite pair [a, b] indicates that course a must be taken before course b.

Example

• Input: numCourses = 2, prerequisites = [[1, 0]]
  Output: true
  Explanation: There are a total of 2 courses to take. To take course 1, you must first take course 0. So it is possible.

• Input: numCourses = 2, prerequisites = [[1, 0], [0, 1]]
  Output: false
  Explanation: There are a total of 2 courses to take. To take course 1, you must first take course 0, and to take course 0, you must first take course 1. Thus, it is impossible to finish all courses.

Graph theory and topological sorting

• Graph theory is a branch of mathematics that studies the properties of graphs, which are mathematical structures used to model pairwise relations between objects. A graph in this context is made up of vertices (also called nodes or points) and edges (also called links or lines) that connect them.
• Graphs document for reading and understanding graphs.

Graph Theory Solution

function canFinish(numCourses, prerequisites) {
    const graph = new Array(numCourses).fill(0).map(() => []);
    const indegree = new Array(numCourses).fill(0);

    for (let [crs, pre] of prerequisites) {
        graph[pre].push(crs);
        indegree[crs]++;
    }

    const queue = [];
    for (let i = 0; i < numCourses; i++) {
        if (indegree[i] === 0) queue.push(i);
    }

    while (queue.length) {
        const curr = queue.shift();
        numCourses--;
        for (let next of graph[curr]) {
            if (--indegree[next] === 0) queue.push(next);
        }
    }

    return numCourses === 0;
}

Breaking Down the Solution

• Create Graph and Indegree Array: Build a graph to represent prerequisites and an array to track the number of prerequisites (indegree) for each course.

"Indegree" in the context of graph theory refers to the number of edges coming into a vertex (or node) in a directed graph. In simpler terms, it's the count of how many arrows are pointing to a node in a graph.

Let's break this down with an example, especially in the context of a problem like the Course Schedule:

Imagine each course is a point or a node in a graph, and a prerequisite is an arrow that points from one course to another. For instance, if Course A is a prerequisite for Course B, there would be an arrow pointing from A to B.

In this scenario:

• The indegree of Course B is the number of prerequisites it has. So if Course B has two prerequisites, Course A and Course C, its indegree is 2 (because there are two arrows pointing to it).
• A course with an indegree of 0 means it has no prerequisites and can be taken immediately.
  Understanding indegree helps determine the order in which courses should be taken and is crucial in solving problems that involve scheduling and dependency resolution, like the Course Schedule problem.

• Queue for Courses with No Prerequisites: Initialize a queue with courses that don't have any prerequisites.

• Process Courses: Remove courses from the queue one by one and decrease the indegree of their dependent courses. If a dependent course's indegree becomes 0, add it to the queue.

• Check Course Completion: If all courses are processed (numCourses reaches 0), then it is possible to finish all courses.

Conclusion

The Course Schedule problem demonstrates the practical application of graph theory and topological sorting in real-world scenarios, such as planning and scheduling. It emphasizes the importance of understanding dependencies and order in complex systems.

Problem Statement

Given an m x n matrix of non-negative integers representing the height of each unit cell in a continent, determine the list of grid coordinates where water can flow to both the Pacific and Atlantic oceans. Water can only flow in four directions (up, down, left, or right) from a cell to another one with height equal or lower.

Example

Consider a matrix:
Pacific ~ ~ ~ ~ ~
~ 1 2 2 3 (5) *
~ 3 2 3 (4) (4) *
~ 2 4 (5) 3 1 *
~ (6) (7) 1 4 5 *
~ (5) 1 1 2 4 *

• • • • Atlantic

The cells marked with * are the ones where water can flow to both oceans.

Depth-First Search Solution

function pacificAtlantic(heights) {
    if (!heights || !heights.length) return [];
    
    const m = heights.length, n = heights[0].length;
    const pacific = Array.from({ length: m }, () => new Array(n).fill(false));
    const atlantic = Array.from({ length: m }, () => new Array(n).fill(false));

    function dfs(row, col, ocean) {
        if (ocean[row][col]) return;
        ocean[row][col] = true;

        [[-1, 0], [1, 0], [0, -1], [0, 1]].forEach(([dr, dc]) => {
            const newRow = row + dr, newCol = col + dc;
            if (newRow >= 0 && newRow < m && newCol >= 0 && newCol < n && heights[newRow][newCol] >= heights[row][col]) {
                dfs(newRow, newCol, ocean);
            }
        });
    }

    for (let i = 0; i < m; i++) {
        dfs(i, 0, pacific);
        dfs(i, n - 1, atlantic);
    }
    for (let i = 0; i < n; i++) {
        dfs(0, i, pacific);
        dfs(m - 1, i, atlantic);
    }

    const result = [];
    for (let i = 0; i < m; i++) {
        for (let j = 0; j < n; j++) {
            if (pacific[i][j] && atlantic[i][j]) {
                result.push([i, j]);
            }
        }
    }
    return result;
}

Breaking Down the Solution

• Initialize Oceans: Create two matrices, pacific and atlantic, to track the cells reachable from each ocean.

• Depth-First Search: Perform DFS from the edges of the matrix towards the interior. Mark cells reachable from each ocean in their respective matrices.

• Collect Results: Iterate over the entire matrix, and for each cell reachable from both oceans, add its coordinates to the result list.

Conclusion

The Pacific Atlantic Water Flow problem showcases the application of DFS in matrix traversal and is an excellent example of how to handle complex flow and reachability problems in a grid. It emphasizes depth-first search's versatility in exploring paths and conditions in a matrix.

Problem Statement

Given a reference to a node in a connected undirected graph, return a deep copy (clone) of the graph. Each node in the graph contains a value (val) and a list (neighbors) of its neighbors.

Example

Consider a graph with nodes labeled 1, 2, 3, and 4, connected in the following structure:

• Node 1 is connected to nodes 2 and 4.
• Node 2 is connected to nodes 1 and 3.
• Node 3 is connected to nodes 2 and 4.
• Node 4 is connected to nodes 1 and 3.

A deep copy of this graph would be a new graph with the same structure but with different node instances.

Depth-First Search Solution

function cloneGraph(node: GraphNode) {
  if (!node) return null;
  const map = new Map();

  function dfs(node: GraphNode) {
    if (map.has(node)) return map.get(node);

    const clone = new GraphNode(node.val);
    map.set(node, clone);

    for (let neighbor of node.neighbors) {
      clone.neighbors.push(dfs(neighbor));
    }
    return clone;
  }

  return dfs(node);
}

Breaking Down the Solution

• Handle Empty Graph: Return null if the input graph is empty.

• Map for Cloned Nodes: Use a map to track cloned nodes to avoid duplications and handle cycles in the graph.

• Depth-First Search (DFS): Implement a DFS function to traverse the graph. For each node, create a clone and recursively clone its neighbors.

• Return Cloned Graph: Start DFS from the given node and return the cloned graph.

Conclusion

The Clone Graph problem exemplifies the application of depth-first search in graph theory and the intricacies of creating deep copies of complex structures. It's a valuable exercise for understanding graph traversal and the nuances of object references in programming.

Problem Statement

Given an array of distinct integers nums and a target integer target, return the number of possible combinations that add up to target.

Example

• Input: nums = [1, 2, 3], target = 4
  Output: 7
  Explanation: The possible combination ways are:
  • (1, 1, 1, 1)
  • (1, 1, 2)
  • (1, 2, 1)
  • (1, 3)
  • (2, 1, 1)
  • (2, 2)
  • (3, 1)

Dynamic Programming Solution

function combinationSum4(nums, target) {
    let dp = new Array(target + 1).fill(0);
    dp[0] = 1;

    for (let i = 1; i <= target; i++) {
        for (let num of nums) {
            if (i >= num) {
                dp[i] += dp[i - num];
            }
        }
    }

    return dp[target];
}

Breaking Down the Solution

• Initialize dp Array: Create a dp array of length target + 1 and initialize it with zeros. Set dp[0] to 1, representing the base case.

• Dynamic Programming Iteration: Iterate through each possible sum from 1 to target. For each sum, iterate through the numbers in nums and add to dp[i] the number of ways to reach i - num.

• Calculate Total Combinations: By the end of the iterations, dp[target] contains the total number of ways to reach the target sum using numbers from nums.

Conclusion

The Combination Sum IV problem is a valuable exercise in dynamic programming, demonstrating how to efficiently solve problems related to counting and combinations. It illustrates the importance of building up solutions for smaller subproblems and combining them to form the solution to the overall problem.

Problem Statement

Given a string s containing only digits, return the number of ways to decode it into letters using the mapping: '1' -> 'A', '2' -> 'B', ..., '26' -> 'Z'.

Example

• Input: s = "12"
  Output: 2
  Explanation: It could be decoded as "AB" (1 2) or "L" (12).

• Input: s = "226"
  Output: 3
  Explanation: It could be decoded as "BZ" (2 26), "VF" (22 6), or "BBF" (2 2 6).

Dynamic Programming Solution

function numDecodings(s) {
    if (s[0] === '0') return 0;
    let dp = new Array(s.length + 1).fill(0);
    dp[0] = 1;
    dp[1] = 1;

    for (let i = 2; i <= s.length; i++) {
        let oneDigit = parseInt(s.slice(i - 1, i));
        let twoDigits = parseInt(s.slice(i - 2, i));

        if (oneDigit >= 1) {
            dp[i] += dp[i - 1];
        }
        if (twoDigits >= 10 && twoDigits <= 26) {
            dp[i] += dp[i - 2];
        }
    }

    return dp[s.length];
}

Breaking Down the Solution

• Handle Leading Zero: If the string starts with '0', return 0, as it can't be decoded.

• Initialize dp Array: Create a dp array to store the number of ways to decode up to each character in the string.

• Iterate and Update dp: For each character, check if it forms a valid one-digit or two-digit number and update dp accordingly.

• Return Decoding Count: The last element in the dp array gives the total number of ways to decode the entire string.

Conclusion

The Decode Ways problem is an interesting application of dynamic programming in string processing. It showcases how to approach problems where solutions depend on the number of ways previous subproblems have been solved, illustrating the flexibility and utility of dynamic programming in a wide range of scenarios.

Problem Statement

Given a list of non-negative integers representing the amount of money in each house, find the maximum amount of money you can rob tonight without alerting the police. In this version, the first and last houses are adjacent; if you rob one, you cannot rob the other.

Example

• Input: nums = [2, 3, 2]
  Output: 3
  Explanation: Rob the second house (3) because robbing the first and the last house is not allowed due to their adjacency.

• Input: nums = [1, 2, 3, 1]
  Output: 4
  Explanation: Rob the first house (1) and the third house (3), totaling 4.

Dynamic Programming Solution

function rob(nums) {
    if (nums.length === 0) return 0;
    if (nums.length === 1) return nums[0];
    
    function robLinear(houses) {
        let prev = 0, curr = 0;
        for (let amount of houses) {
            let temp = curr;
            curr = Math.max(prev + amount, curr);
            prev = temp;
        }
        return curr;
    }

    return Math.max(
        robLinear(nums.slice(1)),
        robLinear(nums.slice(0, -1))
    );
}

Breaking Down the Solution

• Base Cases: Handle scenarios with no houses or only one house.

• Rob Houses Linearly: Define a function robLinear that solves the problem for a linear arrangement of houses, using a dynamic programming approach.

• Two Scenarios: Since the houses are in a circle, consider two scenarios - one excluding the first house and the other excluding the last house.

• Maximize the Robbery: Use the robLinear function for both scenarios and return the maximum of the two.

Conclusion

House Robber II introduces an interesting twist to the standard dynamic programming problem by arranging the houses in a circle. This problem requires careful consideration of edge cases and illustrates the adaptability of dynamic programming techniques in solving complex variations of standard problems.

Problem Statement

Given an array of integers representing the amount of money in each house, determine the maximum amount of money you can rob without robbing two adjacent houses.

Example

• Input: nums = [1, 2, 3, 1]
  Output: 4
  Explanation: Rob the first house (1) and the third house (3), totaling 4.

• Input: nums = [2, 7, 9, 3, 1]
  Output: 12
  Explanation: Rob the first house (2), the third house (9), and the fifth house (1), totaling 12.

Dynamic Programming Solution

function rob(nums) {
    if (nums.length === 0) return 0;
    if (nums.length === 1) return nums[0];

    let dp = [nums[0], Math.max(nums[0], nums[1])];

    for (let i = 2; i < nums.length; i++) {
        dp[i] = Math.max(nums[i] + dp[i - 2], dp[i - 1]);
    }

    return dp[nums.length - 1];
}

Breaking Down the Solution

• Base Cases: Handle the cases where there are no houses or only one house.

• Initialize dp Array: Create a dp array to store the maximum amount of money that can be robbed up to each house.

• Dynamic Programming Iteration: Iterate through the array. For each house, calculate the maximum money by either robbing this house and the best house before the previous one, or by not robbing this house and taking the best total from the previous house.

• Return the Maximum Robbery Amount: The last element in the dp array represents the maximum amount of money that can be robbed.

Conclusion

The House Robber problem demonstrates the effectiveness of dynamic programming in solving optimization problems. It shows how to make decisions at each step to maximize the overall outcome while adhering to certain constraints.

Problem Statement

Given an array of non-negative integers nums, where each element represents the maximum number of steps that can be jumped forward from that position, determine if it's possible to reach the last index starting from the first index.

Example

• Input: nums = [2, 3, 1, 1, 4]
  Output: true
  Explanation: Jump 1 step from index 0 to 1, then 3 steps to the last index.

• Input: nums = [3, 2, 1, 0, 4]
  Output: false
  Explanation: You will always arrive at index 3 no matter what. It's impossible to jump to the last index from there.

Dynamic Programming Solution

function canJump(nums) {
    let goal = nums.length - 1;

    for (let i = nums.length - 2; i >= 0; i--) {
        if (i + nums[i] >= goal) {
            goal = i;
        }
    }

    return goal === 0;
}

Breaking Down the Solution

• Set the Goal: Initialize the goal variable to the last index of the array.

• Backward Iteration: Iterate through the array backward. For each position, check if it's possible to reach the goal from that position.

• Update the Goal: If a position can reach the goal, update the goal to be this new position.

• Check Reachability: If the start of the array (index 0) becomes the new goal, it means the end is reachable. Return true if the goal is 0, indicating reachability.

Conclusion

The Jump Game problem is a fascinating exercise in dynamic programming and pathfinding within arrays. It emphasizes the importance of strategy in solving complex problems and showcases how dynamic programming can be applied in various situations, including games and simulations.

Problem Statement

Given two strings text1 and text2, find the length of their longest common subsequence. A subsequence is a sequence that appears in the same relative order in both strings but isn't necessarily contiguous.

Examples

• Input: text1 = "abcde", text2 = "ace"
  Output: 3
  Explanation: The longest common subsequence is "ace" and its length is 3.

• Input: text1 = "abc", text2 = "abc"
  Output: 3
  Explanation: The longest common subsequence is "abc" and its length is 3.

Dynamic Programming Solution

function longestCommonSubsequence(text1, text2) {
    let m = text1.length, n = text2.length;
    let dp = Array.from({length: m + 1}, () => new Array(n + 1).fill(0));

    for (let i = 1; i <= m; i++) {
        for (let j = 1; j <= n; j++) {
            if (text1[i - 1] === text2[j - 1]) {
                dp[i][j] = dp[i - 1][j - 1] + 1;
            } else {
                dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
            }
        }
    }

    return dp[m][n];
}

Breaking Down the Solution

• Initialization: Create a 2D array dp with dimensions (len(text1) + 1) x (len(text2) + 1) and initialize all elements to 0.

• Dynamic Programming Iteration: Iterate over each character in text1 and text2. Update dp[i][j] with the length of the LCS up to that point.

• Character Match: If characters match (text1[i - 1] === text2[j - 1]), increment the length of the LCS by 1 from the previous characters' LCS length.

• Character Mismatch: If characters don't match, carry forward the maximum LCS length found so far.

• Return the LCS Length: The value in dp[m][n] gives the length of the LCS.

Conclusion

The LCS problem is a fundamental dynamic programming challenge, demonstrating how to break down a complex problem into smaller sub-problems. It's widely used in text comparison, DNA sequencing, and understanding the principles of building up solutions incrementally.

Problem Statement

Given a m x n grid, find the number of unique paths that the robot can take to reach the bottom-right corner from the top-left corner. The robot can only move either down or right at any point in time.

Example

• Input: m = 3, n = 2
  Output: 3
  Explanation: From the top-left corner, there are a total of 3 ways to reach the bottom-right corner:
  1. Right -> Right -> Down
  2. Right -> Down -> Right
  3. Down -> Right -> Right

Dynamic Programming Solution

function uniquePaths(m, n) {
    const dp = Array.from(Array(m), () => new Array(n).fill(1));

    for (let i = 1; i < m; i++) {
        for (let j = 1; j < n; j++) {
            dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
        }
    }

    return dp[m - 1][n - 1];
}

Breaking Down the Solution

• Initialize dp Array: Create a m x n dp array and initialize all elements to 1. Each cell represents the number of paths to reach that cell.

• Dynamic Programming Iteration: Iterate through the grid, and for each cell, calculate the number of paths by adding the paths from the top and left cells.

• Return Total Unique Paths: The value in dp[m - 1][n - 1] gives the total number of unique paths to reach the bottom-right corner.

Conclusion

The Unique Paths problem is an excellent example of dynamic programming applied to grid-based problems. It demonstrates how to incrementally build up solutions and is essential for understanding pathfinding and navigation within grids in various applications.

Problem Statement

Given a non-empty string s and a dictionary wordDict containing a list of non-empty words, determine if s can be segmented into a space-separated sequence of one or more dictionary words.

Example

• Input: s = "leetcode", wordDict = ["leet", "code"]
  Output: true
  Explanation: The string "leetcode" can be segmented as "leet code".

• Input: s = "applepenapple", wordDict = ["apple", "pen"]
  Output: true
  Explanation: The string can be segmented as "apple pen apple".

Dynamic Programming Solution

function wordBreak(s, wordDict) {
    let wordSet = new Set(wordDict);
    let dp = new Array(s.length + 1).fill(false);
    dp[0] = true;

    for (let i = 1; i <= s.length; i++) {
        for (let j = 0; j < i; j++) {
            if (dp[j] && wordSet.has(s.substring(j, i))) {
                dp[i] = true;
                break;
            }
        }
    }

    return dp[s.length];
}

Breaking Down the Solution

• Initialize dp Array: Create an array dp of length s.length + 1 and initialize all elements to false, except dp[0], which is true.

• Dynamic Programming Iteration: Iterate through the string s. For each position i, check all substrings ending at i. If any substring is found in wordDict and the remaining part of the string up to the start of the substring is also breakable (as indicated by dp), mark dp[i] as true.

• Check for Word Break: Return the value of dp[s.length]. If it's true, it means the string s can be segmented into words from the dictionary.

Conclusion

The Word Break problem is an excellent application of dynamic programming to solve string manipulation challenges. It shows how problems can be solved by breaking them down into smaller, more manageable subproblems, and then combining these solutions to solve the larger problem.

Problem Statement

Given an integer array nums, the task is to find the length of the longest strictly increasing subsequence.

Examples

• Input: nums = [10,9,2,5,3,7,101,18]
  Output: 4
  Explanation: The longest increasing subsequence is [2,3,7,101].

• Input: nums = [0,1,0,3,2,3]
  Output: 4
  Explanation: One example of the longest increasing subsequence is [0,1,2,3].

JavaScript Solution (Dynamic Programming)

function lengthOfLIS(nums) {
    if (nums.length === 0) return 0;
    let dp = new Array(nums.length).fill(1);
    let maxAns = 1;

    for (let i = 1; i < nums.length; i++) {
        for (let j = 0; j < i; j++) {
            if (nums[i] > nums[j]) {
                dp[i] = Math.max(dp[i], dp[j] + 1);
            }
        }
        maxAns = Math.max(maxAns, dp[i]);
    }
    return maxAns;
}

Breaking Down the Solution

• Initialize dp Array:
  A dynamic programming (dp) array is created and initially filled with 1s. This is because the minimum length of the Longest Increasing Subsequence (LIS) for each element is 1, considering each element as a subsequence by itself.

• Iterate and Update dp:
  For each element in the array nums, the algorithm iterates and compares it with all previous elements. If nums[i] is greater than a previous element nums[j], the algorithm updates dp[i]. It sets dp[i] to be the maximum of its current value and dp[j] + 1. This update reflects the addition of the current element to the increasing subsequence ending at nums[j].

• Track the Maximum Length:
  Throughout the iterations, the algorithm continually updates the maximum length of the LIS found so far. This is done by maintaining the maximum value in the dp array.

• Return the LIS Length:
  The final result, which is the length of the longest increasing subsequence, is obtained from the maximum value in the dp array. This value represents the overall LIS in the entire array.

Conclusion

The Longest Increasing Subsequence problem is a key challenge in dynamic programming. It demonstrates the power and efficiency of this technique in solving complex computational problems. This problem is exemplary in illustrating the concepts of subsequences and showcases how dynamic programming can be used to build up solutions incrementally and efficiently, making it a staple in algorithmic problem-solving.

Problem Statement

Given a staircase with n steps, where each time you can either climb 1 or 2 steps, the task is to determine the total number of distinct ways to reach the top of the staircase.

Examples

• Input: n = 2
  Output: 2
  Explanation: There are two ways to climb to the top:

  1. 1 step + 1 step
  2. 2 steps

• Input: n = 3
  Output: 3
  Explanation: There are three ways to climb to the top:

  1. 1 step + 1 step + 1 step
  2. 1 step + 2 steps
  3. 2 steps + 1 step

Dynamic Programming Solution

Here's how you can solve this problem using dynamic programming in JavaScript:

function climbStairs(n) {
    if (n === 1) return 1;
    let dp = [1, 2];
    for (let i = 2; i < n; i++) {
        dp[i] = dp[i - 1] + dp[i - 2];
    }
    return dp[n - 1];
}

Breaking Down the Solution

• Base Cases:
  If n is 1, the answer is straightforwardly 1. The dynamic programming array dp is initialized with its base cases: dp[0] = 1 and dp[1] = 2. These represent the number of ways to climb a staircase with one step and two steps, respectively.

• Filling the dp Array:
  For each step from 2 to n - 1, the function calculates the number of ways to reach that step. The value of dp[i] is determined as the sum of dp[i - 1] and dp[i - 2]. This represents the total ways to climb to the current step, either by taking one step from the previous step or two steps from the step before that.

• Returning the Result:
  The final result is stored in dp[n - 1], which gives the total number of distinct ways to reach the top of the staircase. This value is returned as the solution to the problem.

Conclusion

The "Climbing Stairs" problem is a classic example that showcases the efficacy of dynamic programming in solving computational problems related to combinations and counting. It emphasizes the importance of breaking down the problem into smaller, overlapping subproblems and building up the solution by storing and reusing intermediate results. This approach not only makes the solution more efficient but also simplifies the process of solving complex problems.

Problem Statement

Given an array coins representing different coin denominations and an integer amount, the goal is to find the fewest number of coins needed to make up the given amount. If it's not possible to make up the amount with the given coins, return -1.

Examples

• Input: coins = [1, 2, 5], amount = 11
  Output: 3
  Explanation: The amount 11 can be composed by 5 + 5 + 1, hence 3 coins.

• Input: coins = [2], amount = 3
  Output: -1

JavaScript Solution

function coinChange(coins, amount) {
    const max = amount + 1;
    const dp = new Array(max).fill(max);
    dp[0] = 0;

    for (let i = 1; i <= amount; i++) {
        for (let j = 0; j < coins.length; j++) {
            if (coins[j] <= i) {
                dp[i] = Math.min(dp[i], dp[i - coins[j]] + 1);
            }
        }
    }

    return dp[amount] > amount ? -1 : dp[amount];
}

Breaking Down the Solution

• Initialize dp Array:
  Create an array dp of size amount + 1, initializing all elements to amount + 1, except for dp[0], which is set to 0. This initialization prepares the array to store the minimum number of coins required for each amount up to the given amount.

• Dynamic Programming Iteration:
  Iterate through each amount from 1 to amount. In each iteration, also iterate through the available coin denominations. The goal is to find the minimum number of coins needed for each specific amount.

• Updating the dp Array:
  For each coin denomination that is less than or equal to the current amount being considered, update dp[i]. Set it to the minimum of its current value and the value calculated for i - coins[j] (the current amount minus the coin denomination) plus one. This step involves comparing and selecting the best option among the previously computed values.

• Return Result:
  After completing the iterations, check the value of dp[amount]. If it is greater than amount, it implies that it's not possible to make up the amount with the given coins, and the function should return -1. If it's not greater than amount, return dp[amount], which represents the minimum number of coins needed.

Let's explain the "Coin Change" problem in a way that's easy for a 10-year-old to understand.

Imagine you have a piggy bank full of coins of different values - like 1 cent, 5 cents, or 10 cents - and you want to buy a toy that costs a certain amount of money, say 11 cents. Now, the challenge is to find the smallest number of coins you can use to make exactly 11 cents.

It's like a puzzle! You try different combinations of coins to see which one gives you 11 cents using the least number of coins.

Here’s how you might solve it:

Start With No Coins: Think of starting with no coins and then adding one coin at a time to see how many ways you can reach the total amount you need.

Add Coins One by One:

First, see if you can make 1 cent, then 2 cents, and so on, all the way up to 11 cents.
For each amount, check all the different coins you could use. For example, to make 4 cents, you could use four 1-cent coins or two 2-cent coins.
Keep Track of the Best Way:

For each amount, you keep track of the smallest number of coins needed.
You write down the best way to make each amount, like a cheat sheet. So, when you want to make 6 cents, you look back at your cheat sheet to see the best ways to make smaller amounts like 5 cents, 4 cents, etc., and then add one more coin.
Find the Smallest Number of Coins for Your Toy:

Once you reach the amount that the toy costs, look at your cheat sheet.
The number you wrote down for the toy's cost is the smallest number of coins you can use to buy it.
Think of it like a game where you try to score exactly 11 points, and each coin is worth different points. You want to score exactly, and you want to use the fewest turns (or coins) possible to win!

This is what computers do in the "Coin Change" problem – they try all combinations in a smart way to find the answer using the fewest coins.

Conclusion

The "Coin Change" problem effectively demonstrates the power of dynamic programming in solving problems involving the search for optimal combinations. By incrementally building up the solution for increasing amounts and efficiently utilizing previously computed results, this approach provides an elegant and efficient solution to the problem, emphasizing the importance of identifying and optimizing overlapping subproblems.

Problem Statement

Given a non-negative integer num, the objective is to return an array count such that count[i] represents the number of 1s in the binary representation of i, for all 0 <= i <= num.

Dynamic Programming Solution

Here's a JavaScript function that employs dynamic programming to solve this problem:

function countBits(num) {
    const count = new Array(num + 1).fill(0);
    
    for (let i = 1; i <= num; i++) {
        count[i] = count[Math.floor(i / 2)] + (i % 2);
    }

    return count;
}

Breaking Down the Solution

• Initialize Array:
  An array count of size num + 1 is initialized with zeros. This array is crucial for storing the number of set bits (1s) for each number from 0 to num.

• Iterative Computation:
  A loop is executed, iterating through numbers from 1 to num. In each iteration, the number of set bits for the current number i is calculated. This is done by leveraging the results computed in previous iterations.

• Using Previous Results:
  The expression count[Math.floor(i / 2)] + (i % 2) effectively calculates the number of set bits in i. The idea is that the number of set bits in i is equal to the number of set bits in i / 2 (which is the same number right-shifted by one bit) plus an additional bit if i is odd. The extra bit comes from the fact that odd numbers have their least significant bit set to 1.

• Return the Result:
  After completing the iterations, the array count contains the number of set bits for each number in the range from 0 to num. This array is then returned as the final result.

Conclusion

The "Counting Bits" problem showcases the elegance of dynamic programming when applied to bit manipulation. It demonstrates how complex problems can be simplified into smaller subproblems. By iteratively building up the solution and utilizing previously computed results, the algorithm efficiently counts set bits across a range of numbers, highlighting the synergistic power of dynamic programming and bitwise operations in algorithmic problem-solving.

Problem Statement

Given an array containing n distinct numbers taken from 0 to n, find the one number that is missing from the sequence.

Examples

• Input: nums = [3,0,1]
  Output: 2
  Explanation: Numbers 0, 1, and 3 are present. The missing number is 2.

• Input: nums = [0,1]
  Output: 2
  Explanation: Numbers 0 and 1 are present. The missing number is 2.

Solutions

Mathematical Solution:

function missingNumber(nums) {
    let expectedSum = nums.length * (nums.length + 1) / 2;
    let actualSum = nums.reduce((a, b) => a + b, 0);
    return expectedSum - actualSum;
}

Bit Manipulation Solution:

function missingNumber(nums) {
    let xor = 0;
    for (let i = 0; i < nums.length; i++) {
        xor ^= i ^ nums[i];
    }
    return xor ^ nums.length;
}

Breaking Down the Solutions

• Mathematical Approach:
  • The sum of the first n numbers is n * (n + 1) / 2. We can use this formula to find the expected sum of the numbers in the array.
  • We can then find the actual sum of the numbers in the array by using the reduce method.
  • The difference between the expected sum and the actual sum is the missing number.
• Bit Manipulation Approach:
  • We can use the XOR operator to find the missing number.
  • The XOR operator is a bitwise operator that returns a 1 if the bits are different and a 0 if the bits are the same.
  • We can use the XOR operator to find the missing number by XORing the index of each number in the array with the number itself.
  • The XOR operator is associative and commutative, so we can XOR the numbers in any order.
  • We can XOR the index of each number in the array with the number itself to find the missing number.

Conclusion

The "Missing Number" problem is a classic example of array and bit manipulation in computer science. It involves finding a missing number in a sequence. We can solve this problem using mathematical and bit manipulation techniques.

Problem Statement

Given a 32-bit unsigned integer n, the goal is to reverse its bits and return the result.

Example

• Input: n = 43261596 (binary representation: 00000010100101000001111010011100)
• Output: 964176192 (binary representation: 00111001011110000010100101000000)

JavaScript Solution

Here's an efficient way to solve this problem in JavaScript:

function reverseBits(n) {
    let result = 0;
    for (let i = 0; i < 32; i++) {
        result = (result << 1) | (n & 1);
        n >>>= 1;
    }
    return result >>> 0; // Ensure unsigned 32-bit integer
}

Breaking Down the Solution

• Initialization:
  Start with result set to 0. This variable will hold the reversed bits.

• Iterative Bitwise Operations: For 32 iterations (each iteration represents a bit in the 32-bit integer):

  • Left-shift result:
    Shift result left by one bit (result << 1). This operation makes space for adding the new bit at the least significant position.

  • Add Bit to result:
    Use bitwise OR (|) to add the rightmost bit of n to result. The expression n & 1 isolates the least significant bit of n, which is then added to result.

  • Right-shift n:
    Shift n right by one bit (n >>>= 1). This operation moves all bits of n to the right by one position, bringing the next bit in line to be processed.

• Return Unsigned Integer:
  The expression result >>> 0 converts result to an unsigned 32-bit integer. This step ensures that the final returned value is in the correct format, respecting the constraints of the problem.

Conclusion

Reversing the bits of an integer is a valuable exercise in bit manipulation. It demonstrates how bitwise operations can be used to precisely control and manipulate individual bits within integers. This problem is not only frequently asked in technical interviews but also plays a crucial role in areas like low-level computing and digital signal processing, where bit-level manipulation is common.

Problem Statement

Given a non-negative integer n, count and return the number of '1' bits (also known as set bits) in its binary representation.

JavaScript Solution

Here's a simple JavaScript function to solve this problem:

function hammingWeight(n) {
    let count = 0;
    while (n !== 0) {
        count += n & 1;
        n >>>= 1;
    }
    return count;
}

Breaking Down the Solution

• Initialize a Count Variable: let count = 0; initializes a variable to keep track of the number of 1 bits.

• Loop Until n is Zero: The loop while (n !== 0) {} continues until all bits of n have been checked.

• Count 1 Bits: count += n & 1; adds 1 to count if the least significant bit of n is 1.

• Right Shift n: n >>>= 1; performs a logical right shift on n, moving all bits to the right by one place. This step is crucial for checking the next bit in the next iteration.

• Return the Count: After all bits have been checked, the function returns the count of 1 bits.

Conclusion

Calculating the Hamming weight of a number is a fundamental operation in bit manipulation. This problem not only tests basic understanding of bitwise operations but also serves as a foundation for more complex bit manipulation challenges.

Problem Statement

Given two integers a and b, the challenge is to compute their sum using only bitwise operators and without the conventional arithmetic operators.

JavaScript Solution

Here's a JavaScript function that demonstrates the solution:

function getSum(a, b) {
    while (b !== 0) {
        let carry = (a & b) << 1;
        a = a ^ b;
        b = carry;
    }
    return a;
}

Breaking Down the Solution

• Carry Calculation:
  Using let carry = (a & b) << 1, the carry from each bit is computed. The bitwise AND (&) identifies the bits that are 1 in both a and b. The left shift (<< 1) then moves these bits to a higher order, representing the carry effect in binary addition.

• Sum Without Carry:
  The expression a = a ^ b calculates the sum of a and b without considering the carry. The XOR operation (^) effectively adds the bits where there is at least one 1, aligning with how addition works in binary.

• Iterative Process:
  A while loop continues this process of updating a with the sum and b with the new carry. This loop iterates until there is no carry left, indicated by b becoming 0.

• Result:
  Once b is 0, it signifies that no further carry is being generated, and a contains the final computed sum. This sum is then returned as the solution.

Conclusion

This problem elegantly demonstrates how bit manipulation can effectively replicate basic arithmetic operations, such as addition, without using standard arithmetic operators. It offers a unique perspective on understanding and applying bitwise operators to solve computational problems, showcasing the versatility and power of bit-level operations in programming.

The Problem

Given an array nums of integers, the task is to find all unique triplets in the array that sum up to zero.

The Solution

Here's a JavaScript function that effectively solves the 3Sum problem:

function threeSum(nums) {
    nums.sort((a, b) => a - b);
    const triplets = [];

    for (let i = 0; i < nums.length - 2; i++) {
        if (i > 0 && nums[i] === nums[i - 1]) continue;

        let left = i + 1, right = nums.length - 1;
        while (left < right) {
            const sum = nums[i] + nums[left] + nums[right];

            if (sum === 0) {
                triplets.push([nums[i], nums[left], nums[right]]);
                while (nums[left] === nums[left + 1]) left++;
                while (nums[right] === nums[right - 1]) right--;
                left++;
                right--;
            } else if (sum < 0) {
                left++;
            } else {
                right--;
            }
        }
    }
    return triplets;
}

The Explanation

• Sort the Array: The array is sorted to use the two-pointer technique effectively.
• Iterate and Find Triplets: Loop through the array, for each element, use a left and right pointer to find triplets.
• Skip Duplicates: Skip over duplicate elements to avoid repeating triplets.
• Two-Pointer Technique: Adjust the left and right pointers to find different combinations that sum up to zero.

Conclusion

This problem is a perfect example of the application of sorting and two-pointer techniques in solving complex array problems. It's often used in coding interviews to assess a candidate's problem-solving and array manipulation skills.

The Problem

You are given an array height, representing the height of vertical lines on a chart. The task is to find the two lines that, together with the x-axis, form a container that can hold the maximum amount of water.

The Solution

Here's a straightforward JavaScript implementation:

function maxArea(height) {
    let maxArea = 0, left = 0, right = height.length - 1;

    while (left < right) {
        const width = right - left;
        const currentArea = Math.min(height[left], height[right]) * width;
        maxArea = Math.max(maxArea, currentArea);

        if (height[left] < height[right]) {
            left++;
        } else {
            right--;
        }
    }

    return maxArea;
}

The solution uses two pointers, left and right, to traverse the array from both ends. The maxArea variable keeps track of the maximum area found so far. The while loop continues until the two pointers meet.
The width variable represents the width of the container. The currentArea variable represents the area of the container formed by the two pointers. The Math.min function is used to find the minimum height of the two pointers. The Math.max function is used to update the maxArea variable.
The if statement checks if the height of the left pointer is less than the height of the right pointer. If so, the left pointer is moved one step to the right. Otherwise, the right pointer is moved one step to the left.

Breaking Down the Solution

• Two-Pointer Technique: Start with two pointers, one at the beginning (left) and one at the end (right) of the array. These pointers represent potential boundaries of the water container.

• Calculate Area: At each step, calculate the area formed by the lines at the left and right pointers. The area is determined by the distance between the pointers (width) and the height of the shorter line.

• Update Max Area: Keep track of the maximum area encountered so far. If the current area is larger than the maxArea, update maxArea.

• Move Pointers: Move the pointer pointing to the shorter line towards the other pointer. This is because moving the shorter line could potentially find a taller line and thus increase the area.

• Repeat: Continue the process until the left and right pointers meet, meaning all potential pairs have been evaluated.

• Return Result: The maxArea at the end of the iteration process will be the maximum amount of water the container can store.

Conclusion

This problem is an excellent demonstration of the two-pointer technique's effectiveness in solving array-based challenges. It particularly highlights how optimal solutions often involve comparing pairs of elements and adjusting strategies based on their comparison. The "Container With Most Water" problem is not just about understanding arrays, but also about grasping the significance of element positions and how they relate to an optimal solution.

Problem Statement

Given a rotated sorted array, the goal is to find the minimum element. The original array is sorted in ascending order but then rotated at some pivot.

Examples

1. Input: nums = [3,4,5,1,2]
   Output: 1
   Explanation: The original array was [1,2,3,4,5] rotated 3 times.

2. Input: nums = [4,5,6,7,0,1,2]
   Output: 0
   Explanation: The original array was [0,1,2,4,5,6,7] and it was rotated 4 times.

Constraints

• 1 <= nums.length <= 5000
• -5000 <= nums[i] <= 5000
• The array is sorted and rotated at some pivot.

Binary Search Solution

The solution leverages a modified binary search due to the sorted nature of the array:

function findMin(nums: number[]): number {
    let left = 0;
    let right = nums.length - 1;

    while (left < right) {
        let mid = Math.floor((left + right) / 2);

        if (nums[mid] > nums[right]) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }

    return nums[left];
}

Explanation

• The algorithm initiates a binary search. However, instead of searching for a specific value, it looks for the inflection point.
• The inflection point is where we find the smallest element.
• The logic in the binary search is modified to find this point by comparing the middle element with the rightmost element to decide which half of the array to continue the search.

This problem is a classic example used in interviews to assess a candidate's proficiency in modifying and applying binary search in different scenarios.

Problem Statement

Given an integer array nums, the task is to find the contiguous subarray within nums that has the largest product and return this product.

Unique Challenge

The presence of negative numbers in the array adds a layer of complexity. The product of negative numbers can turn a seemingly small product into a large one, which is a key difference from sum-based problems.

Dynamic Programming Solution

function maxProduct(nums: number[]): number {
    if (nums.length === 0) return 0;

    let maxSoFar = nums[0];
    let minSoFar = nums[0];
    let result = maxSoFar;

    for (let i = 1; i < nums.length; i++) {
        let curr = nums[i];
        let tempMax = Math.max(curr, Math.max(maxSoFar * curr, minSoFar * curr));
        minSoFar = Math.min(curr, Math.min(maxSoFar * curr, minSoFar * curr));

        maxSoFar = tempMax;
        result = Math.max(maxSoFar, result);
    }

    return result;
}

Explanation

• Dynamic Programming Approach:
  • The algorithm keeps track of the maximum and minimum product up to each index, considering the impact of negative numbers.
  • At each step, it updates the maximum and minimum products based on the current number and the previous maximum and minimum products.
  • The result is continuously updated with the largest product found.

Conclusion

This problem is an excellent example of dynamic programming's utility in handling complex array manipulation tasks, especially when dealing with both positive and negative elements.

Dynamic Programming Solution

The dynamic programming approach, also known as Kadane's algorithm, iteratively computes the maximum subarray sum ending at each position.

function maxSubArray(nums: number[]): number {
    let maxSub = nums[0];
    let curSum = 0;
    
    for (let num of nums) {
        if (curSum < 0) {
            curSum = 0;
        }
        curSum += num;
        maxSub = Math.max(maxSub, curSum);
    }
    
    return maxSub;
}

Divide and Conquer Solution

The divide and conquer approach splits the array into two halves and recursively finds the maximum subarray sum in each half. It also considers the possibility of the maximum subarray crossing the midpoint.

function crossSum(nums: number[], left: number, right: number, mid: number): number {
    if (left === right) return nums[left];

    let leftSubsum = Number.NEGATIVE_INFINITY;
    let currSum = 0;
    for (let i = mid; i > left - 1; --i) {
        currSum += nums[i];
        leftSubsum = Math.max(leftSubsum, currSum);
    }

    let rightSubsum = Number.NEGATIVE_INFINITY;
    currSum = 0;
    for (let i = mid + 1; i < right + 1; ++i) {
        currSum += nums[i];
        rightSubsum = Math.max(rightSubsum, currSum);
    }

    return leftSubsum + rightSubsum;
}

function helper(nums: number[], left: number, right: number): number {
    if (left === right) return nums[left];

    const mid = Math.floor((left + right) / 2);

    const leftSum = helper(nums, left, mid);
    const rightSum = helper(nums, mid + 1, right);
    const crossSum = crossSum(nums, left, right, mid);

    return Math.max(Math.max(leftSum, rightSum), crossSum);
}

function maxSubArrayDivideAndConquer(nums: number[]): number {
    return helper(nums, 0, nums.length - 1);
}

Explanation

• Dynamic Programming: This approach iteratively updates a running sum and maximum sum, resetting the running sum if it becomes negative.
• Divide and Conquer: This method recursively solves the problem in subarrays and finds the maximum sum that crosses the middle of the array.
  Both methods offer a way to understand different algorithmic strategies and their applications in solving complex problems.

The Function

function productExceptSelf(nums: number[]): number[] {
    let res = new Array(nums.length).fill(nums[0]);
    
    let prefix = 1;
    for (let i = 0; i < nums.length; i++) {
        res[i] = prefix;
        prefix *= nums[i];
    }
    
    let postfix = 1;
    for (let i = nums.length - 1; i >= 0; i--) {
        res[i] *= postfix;
        postfix *= nums[i];
    }
    
    return res;
}

The "Product of Array Except Self" problem is a classic challenge often encountered in coding interviews. It tests a candidate's ability to manipulate arrays and optimize algorithms.

Problem Statement

Given an array nums of n integers where n > 1, the task is to return an array output such that output[i] is equal to the product of all the elements of nums except nums[i].

Constraints and Challenges

• No division operation is allowed in the solution.
• The goal is to achieve a linear runtime complexity, O(n).
• A straightforward nested loop approach leads to O(n²) time complexity, which is inefficient.

Techniques for Solution

1. Prefix and Postfix Products:
   This efficient approach involves two passes through the array:

   • Prefix Product: Traverse the array from left to right, calculating the cumulative product up to the current element. Store these products in a new array.
   • Postfix Product: Traverse the array from right to left, calculating the cumulative product from the end to the current element. Multiply these with the prefix products in the new array.

2. Left and Right Product Lists:
   Use two additional arrays to store products of all elements to the left and right of each element, and then multiply corresponding elements from these arrays for the final result. This method uses extra space.

3. Optimized Space Approach:
   Optimize the space complexity by using the output array for storing one of the lists (like left products) and a variable to track the right product during the second traversal.

Example

Consider nums = [1, 2, 3, 4]. The expected output is [24, 12, 8, 6].

• After the first pass (prefix): [1, 1, 2, 6].
• After the second pass (postfix): [24, 12, 8, 6].

This problem demonstrates the importance of array manipulation and optimizing solutions for better time and space efficiency.

References

https://www.enjoyalgorithms.com/blog/product-of-array-except-self

Understanding the Problem

The "Search in Rotated Sorted Array" problem involves finding the index of a target number in a sorted array that has been rotated. It's a twist on the binary search algorithm, where the array is no longer strictly sorted in the conventional sense, but is instead rotated at an unknown pivot point.

The Challenge

Given an array nums that has been rotated and a target value, the task is to find the index of this target in nums, or return -1 if it does not exist.

The Solution

Here's a JavaScript function to effectively solve this problem:

function search(nums, target) {
    let left = 0, right = nums.length - 1;
    
    while (left <= right) {
        const mid = Math.floor((left + right) / 2);
        
        if (nums[mid] === target) return mid;
        
        // Check if the left half is sorted
        if (nums[left] <= nums[mid]) {
            if (target >= nums[left] && target < nums[mid]) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        // Right half is sorted
        else {
            if (target > nums[mid] && target <= nums[right]) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
    }
    
    return -1;
}

How It Works

• Check Middle Element: At each step, check if the middle element is the target.
• Identify Sorted Half: Determine which half of the array is sorted.
• Refine Search: Based on the target’s value and the sorted half, adjust the search range.
• Iterate Until Found: Continue the process until the target is found or the range is empty.

Conclusion

This problem serves as an excellent example of how binary search can be adapted to less straightforward scenarios. It tests your ability to think critically about sorted arrays and how to navigate them when a typical sorted order is disrupted.

The Problem

The challenge is framed as follows: Given an array where each element represents the price of a stock on that day, find the maximum profit you can achieve. You are allowed to buy and sell only once. In other words, find the maximum difference between a later selling price and an earlier buying price.

Why It Matters

This problem is not just about finding the maximum difference in an array; it's about understanding the nuances of timing in buying and selling—akin to real-world stock trading. It tests your grasp of array traversal and optimization.

The JavaScript Solution

Here's a concise and efficient way to solve this problem in JavaScript:

/**
 * @param {number[]} prices
 * @return {number}
 */
var maxProfit = function(prices) {
    let [buy, sell] = [0, 1];
    let maxProfit = 0;

    while (sell < prices.length) {
        if (prices[buy] < prices[sell]) {
            let profit = prices[sell] - prices[buy];
            maxProfit = Math.max(maxProfit, profit);
        } else {
            buy = sell;
        }

        sell++;
    }

    return maxProfit;
};

Breaking Down the Solution

• Initial Setup: We start with two pointers, buy and sell, representing the days to buy and sell the stock.
• Loop Through Prices: As we iterate through the array, we continuously calculate the profit (difference between selling and buying prices) and update the maximum profit.
• Optimize Buy Day: If we find a day with a lower price than our current buying day, we shift our buying day to this lower price day.
• Return Maximum Profit: After traversing the array, the maximum profit we've calculated is returned.

Key Takeaways

• Efficiency Matters: The solution uses a single pass over the array, ensuring an optimal time complexity.
• Pointer Technique: Using two pointers helps in comparing elements without nested loops, a handy technique in many coding problems.

By understanding this approach, you're not just solving a problem; you're gaining insights into efficient data traversal and optimization—skills crucial for many coding challenges and real-world applications.

The Problem Statement

Given an array of integers, nums, the task is to check if the array contains any duplicate elements. In other words, we need to see if any value appears at least twice in the array.

Why It's Important

This problem tests your ability to handle arrays and use JavaScript's built-in data structures, like Set, effectively. It's a common task that mirrors real-world scenarios where data uniqueness is crucial.

JavaScript Solution: Using Set

Here's a simple and efficient JavaScript function to solve this problem:

/**
 * @param {number[]} nums
 * @return {boolean}
 */
var containsDuplicate = function(nums) {
    return new Set(nums).size !== nums.length;
};

Breaking Down the Solution

• Leverage Set: JavaScript's Set object is a collection of unique values. By converting the array to a set, we automatically remove any duplicates.
• Compare Sizes: If the size of the set is different from the original array's length, it implies that duplicates were present and removed in the conversion process.

Key Takeaways

• Simplicity and Efficiency: This solution is both simple and efficient, utilizing the powerful features of JavaScript's standard objects.
• Understanding Data Structures: Knowing the properties of different data structures, like a Set, is key in crafting optimized solutions.

By grasping this approach, you not only solve the problem at hand but also enhance your understanding of JavaScript's data structures, a vital skill in many programming tasks and interviews.

Problem Statement

Determine if a given singly linked list has a cycle in it. In a linked list with a cycle, a node's next pointer points to an earlier node, creating a loop.

Example

Consider a linked list where the next pointer of a node points back to a previous node, forming a loop. The challenge is to detect this loop.

Solution Approach - Floyd's Tortoise and Hare Algorithm

class ListNode {
  val: number;
  next: ListNode | null;

  constructor(val?: number, next?: ListNode | null) {
      this.val = (val === undefined ? 0 : val);
      this.next = (next === undefined ? null : next);
  }
}

function hasCycle(head: ListNode | null): boolean {
  let slow: ListNode | null = head;
  let fast: ListNode | null = head;

  while (fast && fast.next) {
      slow = slow ? slow.next : null;
      fast = fast.next ? fast.next.next : null;

      if (slow === fast) {
          return true; // Cycle detected
      }
  }

  return false; // No cycle found
}

Breaking Down the Solution

• Two Pointers: Initialize two pointers, slow and fast. slow moves one step at a time, while fast moves two steps.

• Iterate Through List: Move through the list, with slow and fast progressing at their respective speeds.

• Detecting the Cycle: If there is a cycle, slow and fast will eventually meet at some node. If they do, return true.

• Termination Condition: If fast or fast.next becomes null, it means the list has no cycle, and we return false.

Conclusion

The Linked List Cycle problem is a fundamental concept in data structures, particularly in understanding linked lists. Floyd's Tortoise and Hare algorithm provides an efficient way to detect cycles, demonstrating the importance of pointer manipulation and two-pointer techniques in algorithm design.

Problem Statement

Given an m x n matrix, if an element is 0, set its entire row and column to 0. Do it in-place.

Example

• Input: Matrix
  [
  [1,1,1],
  [1,0,1],
  [1,1,1]
  ]

• Output:
  [
  [1,0,1],
  [0,0,0],
  [1,0,1]
  ]

Solution Approach - Space Optimized

function setZeroes(matrix: number[][]): void {
  if (matrix.length === 0 || matrix[0].length === 0) return;
  
  let isCol = false;
  const R = matrix.length;
  const C = matrix[0].length;

  for (let i = 0; i < R; i++) {
      if (matrix[i][0] === 0) isCol = true;
      for (let j = 1; j < C; j++) {
          if (matrix[i][j] === 0) {
              matrix[i][0] = 0;
              matrix[0][j] = 0;
          }
      }
  }

  for (let i = 1; i < R; i++) {
      for (let j = 1; j < C; j++) {
          if (matrix[i][0] === 0 || matrix[0][j] === 0) matrix[i][j] = 0;
      }
  }

  if (matrix[0][0] === 0) {
      for (let j = 0; j < C; j++) matrix[0][j] = 0;
  }

  if (isCol) {
      for (let i = 0; i < R; i++) matrix[i][0] = 0;
  }
}

Breaking Down the Solution

• Mark Zeroes: Iterate through the matrix, marking the first cell of each row and column that contains a zero.

• Set Rows and Columns: Use the marks to set entire rows and columns to zero.

• Handle First Row and Column: Special handling for the first row and column to avoid overriding the marks.

Conclusion

The Set Matrix Zeroes problem is a valuable exercise in in-place array manipulation. It requires careful consideration to avoid unintended side effects while modifying the matrix.

The algorithm achieves constant space complexity (O(1)) by using the first row and the first column of the matrix itself to store information about which rows and columns should be zeroed.

Here’s a breakdown of how this is achieved:

First Pass: Iterate through the matrix and use the first cell of each row and column to mark whether that row or column should be set to zero. This requires two special checks:

Determine if the first row should be set to zero based on the cells in the first row.
Determine if the first column should be set to zero based on the cells in the first column.
Second Pass: Use the marks in the first row and first column to set the appropriate rows and columns to zero. Skip the first row and first column in this pass.

Final Step: Based on the checks from the first step, set the first row and/or first column to zero if needed.

This approach only uses a constant amount of additional space (for variables like isCol and loop counters) and modifies the matrix in place.

The Two Sum problem is simple in its statement: Given an array of integers nums and an integer target,
return indices of the two numbers such that they add up to target. This problem tests your understanding of array manipulation and hashing concepts.
It's a fundamental question in algorithm design, often used to gauge a candidate's ability to work with data structures.

Understanding the Problem

The key to solving the Two Sum problem lies in understanding how to efficiently find two numbers in the array that sum up to the target value. A brute force approach would involve checking each pair of numbers, but this is inefficient, especially for large arrays. A more efficient approach involves using a hash table to store and quickly look up the complement of each number.

The Solution

Here's a TypeScript function that solves the Two Sum problem:

export function twoSum(nums: number[], target: number): number[] {
  const hash: { [key: number]: number } = {};
  for (let i = 0; i < nums.length; i++) {
    const diff = target - nums[i];
    if (diff in hash) {
      return [hash[diff], i];
    }
    hash[nums[i]] = i;
  }

  return [];
}

Here's a JavaScript function that solves the Two Sum problem:

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
var twoSum = function(nums, target) {
    const map = new Map();

    for (let i = 0; i < nums.length; i++) {
        const diff = map.get(target - nums[i]);

        if (diff !== undefined) {
            return [diff, i]
        }

        map.set(nums[i], i);
    }
};

Breaking Down the Solution

Initialize a Hash Table: We create a hash table (or object in JavaScript) to store each number's index as we iterate through the array.

Iterate Through the Array: We loop through each element in the array.

Calculate the Difference: For each element, we calculate the difference between the target and the current element. This difference is the value we need to find in the array to get a pair that sums to the target.

Check the Hash Table: We check if this difference already exists in our hash table. If it does, it means we have found a pair that adds up to the target. We return the indices of these two elements.

Store in the Hash Table: If the difference is not in the hash table, we add the current element and its index to the hash table and continue the loop.

Return Empty if No Solution: If no pair adds up to the target, we return an empty array.

This collection is divided into several categories, such as arrays, strings, linked lists, trees, dynamic programming, and more. Each category contains a mix of easy, medium, and hard problems, allowing you to gradually build your skills.

Array

• Two Sum <span style={{color: 'green'}}>(Easy) HashMap Solution
• Best Time to Buy and Sell Stock <span style={{color: 'green'}}>(Easy) Two Pointer Solution
• Contains Duplicate <span style={{color: 'green'}}>(Easy) HashSet Solution
• Product of Array Except Self <span style={{color: 'orange'}}>(Medium) Prefix and Suffix product array Solution
• Maximum Subarray <span style={{color: 'orange'}}>(Medium) Kadane's algorithm (Dynamic Programming) Solution
• Maximum Product Subarray <span style={{color: 'orange'}}>(Medium) Kadane's algorithm (Dynamic Programming) Solution
• Find Minimum in Rotated Sorted Array <span style={{color: 'orange'}}>(Medium) Binary Search Solution
• Search in Rotated Sorted Array <span style={{color: 'orange'}}>(Medium) Binary Search Solution
• 3Sum <span style={{color: 'orange'}}>(Medium) Two Pointer Solution
• Container With Most Water <span style={{color: 'orange'}}>(Medium) Two Pointer Solution

Binary

• Sum of Two Integers <span style={{color: 'orange'}}>(Medium) Bit Manipulation Solution
• Number of 1 Bits <span style={{color: 'green'}}>(Easy) Bit Manipulation Solution
• Counting Bits <span style={{color: 'green'}}>(Easy) Bit Manipulation (Dynamic Programming) Solution
• Missing Number <span style={{color: 'green'}}>(Easy) Bit Manipulation Solution
• Reverse Bits <span style={{color: 'green'}}>(Easy) Bit Manipulation Solution

Dynamic Programming

• Climbing Stairs <span style={{color: 'green'}}>(Easy) Dynamic Programming Solution
• Coin Change <span style={{color: 'orange'}}>(Medium) Dynamic Programming Solution
• Longest Increasing Subsequence <span style={{color: 'orange'}}>(Medium) Dynamic Programming Solution
• Longest Common Subsequence <span style={{color: 'orange'}}>(Medium) Dynamic Programming Solution
• Word Break Problem <span style={{color: 'orange'}}>(Medium) Dynamic Programming Solution
• Combination Sum <span style={{color: 'orange'}}>(Medium) Dynamic Programming Solution
• House Robber <span style={{color: 'orange'}}>(Medium) Dynamic Programming Solution
• House Robber II <span style={{color: 'orange'}}>(Medium) Dynamic Programming Solution
• Decode Ways <span style={{color: 'orange'}}>(Medium) Dynamic Programming Solution
• Unique Paths <span style={{color: 'orange'}}>(Medium) Dynamic Programming Solution
• Jump Game <span style={{color: 'orange'}}>(Medium) Dynamic Programming Solution

Graph

• Clone Graph <span style={{color: 'orange'}}>(Medium) Graph Traversal Solution
• Course Schedule <span style={{color: 'orange'}}>(Medium) Topological Sort Solution
• Pacific Atlantic Water Flow <span style={{color: 'orange'}}>(Medium) Graph Traversal Solution
• Number of Islands <span style={{color: 'orange'}}>(Medium) Graph Traversal Solution
• Longest Consecutive Sequence <span style={{color: 'orange'}}>(Medium) Graph Traversal Solution
• Alien Dictionary (Leetcode Premium) <span style={{color: 'orange'}}>(Medium) Topological Sort Solution
• Graph Valid Tree (Leetcode Premium) <span style={{color: 'orange'}}>(Medium) Graph Traversal Solution
• Number of Connected Components in an Undirected Graph (Leetcode Premium) <span style={{color: 'orange'}}>(Medium) Graph Traversal Solution

Interval

• Insert Interval <span style={{color: 'orange'}}>(Medium) Interval Solution
• Merge Intervals <span style={{color: 'orange'}}>(Medium) Interval Solution
• Non-overlapping Intervals <span style={{color: 'orange'}}>(Medium) Interval Solution
• Meeting Rooms (Leetcode Premium) <span style={{color: 'orange'}}>(Medium) Interval Solution
• Meeting Rooms II (Leetcode Premium) <span style={{color: 'orange'}}>(Medium) Interval Solution

Linked List

• Reverse a Linked List <span style={{color: 'green'}}>(Easy) Linked List Solution
• Detect Cycle in a Linked List <span style={{color: 'green'}}>(Easy) Linked List Two Pointers Solution
• Merge Two Sorted Lists <span style={{color: 'green'}}>(Easy) Linked List Solution
• Merge K Sorted Lists <span style={{color: 'red'}}>(Hard) Linked List Divide and Conquer Solution
• Remove Nth Node From End Of List <span style={{color: 'orange'}}>(Medium) Linked List Solution
• Reorder List <span style={{color: 'orange'}}>(Medium) Linked List Solution

Matrix

• Set Matrix Zeroes <span style={{color: 'green'}}>(Easy) Matrix Solution
• Spiral Matrix <span style={{color: 'orange'}}>(Medium) Matrix right,left,top,bottom Solution
• Rotate Image <span style={{color: 'orange'}}>(Medium) Matrix change rows with columns then rotate each row Solution
• Word Search <span style={{color: 'orange'}}>(Medium) Matrix DFS Solution

String

• Longest Substring Without Repeating Characters <span style={{color: 'orange'}}>(Medium) Sliding Window Solution
• Longest Repeating Character Replacement <span style={{color: 'orange'}}>(Medium) Sliding Window Solution
• Minimum Window Substring <span style={{color: 'red'}}>(Hard) Sliding Window Solution
• Valid Anagram <span style={{color: 'green'}}>(Easy) HashMap Solution
• Group Anagrams <span style={{color: 'orange'}}>(Medium) HashMap Solution
• Valid Parentheses <span style={{color: 'green'}}>(Easy) Stack Solution
• Valid Palindrome <span style={{color: 'green'}}>(Easy) Two Pointer Solution
• Longest Palindromic Substring <span style={{color: 'orange'}}>(Medium) Two Pointer expand around center Solution
• Palindromic Substrings <span style={{color: 'orange'}}>(Medium) Two Pointer Solution
• Encode and Decode Strings (Leetcode Premium) <span style={{color: 'orange'}}>(Medium) String Solution

Tree

• Maximum Depth of Binary Tree <span style={{color: 'green'}}>(Easy) Tree Traversal Solution
• Same Tree <span style={{color: 'green'}}>(Easy) Tree Traversal Solution
• Invert/Flip Binary Tree <span style={{color: 'green'}}>(Easy) Tree Traversal Solution
• Binary Tree Maximum Path Sum <span style={{color: 'red'}}>(Hard) Tree Traversal Solution
• Binary Tree Level Order Traversal <span style={{color: 'orange'}}>(Medium) Tree Traversal Solution
• Serialize and Deserialize Binary Tree <span style={{color: 'red'}}>(Hard) Tree Traversal Solution
• Subtree of Another Tree <span style={{color: 'green'}}>(Easy) Tree Traversal Solution
• Construct Binary Tree from Preorder and Inorder Traversal <span style={{color: 'orange'}}>(Medium) Tree Traversal Solution
• Validate Binary Search Tree <span style={{color: 'orange'}}>(Medium) Tree Traversal Solution
• Kth Smallest Element in a BST <span style={{color: 'orange'}}>(Medium) Tree Traversal Solution
• Lowest Common Ancestor of BST <span style={{color: 'oragne'}}>(Medium) Tree Traversal Solution
• Implement Trie (Prefix Tree) <span style={{color: 'orange'}}>(Medium) Tree Traversal Solution
• Add and Search Word <span style={{color: 'orange'}}>(Medium) Tree Traversal Solution
• Word Search II <span style={{color: 'red'}}>(Hard) Tree Traversal Solution

Heap

• Merge K Sorted Lists <span style={{color: 'red'}}>(Hard) Heap Solution
• Top K Frequent Elements <span style={{color: 'orange'}}>(Medium) Heap Solution
• Find Median from Data Stream <span style={{color: 'red'}}>(Hard) Heap Solution

Important Link:

14 Patterns to Ace Any Coding Interview Question

How to Use This List

• Start with Basics: Begin with easier problems to build your confidence.
• Focus on Patterns: Identify common patterns and algorithms.
• Practice Regularly: Consistency is key in problem-solving.
• Review Solutions: Understand not just the how, but also the why behind each solution.
• Mock Interviews: Use these problems to simulate real interview scenarios.

Resources

• LeetCode
• Blind 75 Discussion Forum
• Coding Interview Resources
• LeetCode Patterns
• LeetCode Explore
• Blind 75 spreadsheet
• Coding Patterns

Remember, the goal is not just to solve all 75 problems, but to understand the underlying principles and patterns that will enable you to tackle any new problem with confidence.

This post has been updated for Next.js 14.

To address the React-sized elephant in the room:
you do not need this fancy setup to build a blog.
HTML and CSS may be a better choice for you, but I'd find little fun in that, and I'm a strong believer in having a website to experiment with.

To set a few expectations, here's what this post won't do:

• Act as documentation for Next.js or React
• Be a 100% code-complete tutorial. You'll need to fill in some gaps yourself.
  • You can always reference this website's source code.
  • There are file trees included with links to the source code.

And here's what it will do:

• Show you real-world examples involving React Server Components and the App Router.
• Guide you in spinning up your own blog with Next.js 13 and React Server Components with great SEO and performance.
  • I say static first because while you can opt into dynamic rendering everything presented here can result in a fully static no-JavaScript site.
• Demonstrate how to enable writing in markdown with MDX and next-mdx-remote/rsc
  • We'll use Bright for server-side syntax highlighting.
• Act as a launching point for your own experimentation and exploration.

Now that that's out of the way:

Table of Contents

Set up the project

First, we'll need to create a new Next.js project. You can launch the setup wizard with npx create-next-app:

npx create-next-app --experimental-app

Hit y (or n, I'm not your boss) a few times to complete the wizard.

File structure

The easiest way I've found to thinking about structuring App Router applications is from a top-down approach.
Think of your general path structure, then start with your highest level 'scope' (layout) and work your way down.

In our case, we'll have a home page. Let's also add a projects page and an about page.
We'll cover the blog in the next section.

In general, a page will look like this:

// page.tsx
export default function Page() {
  return <>Your content here</>
}

In my case, the three pages we're making all look the same minus their content, so they seem like a strong candidate for sharing a layout.

A Layout will look something like this:

// layout.tsx
export default function Layout({ children }: PropsWithChildren) {
  return (
    <>
      // Your layout content here
      {children}
      // Or here
    </>
  )
}

Knowing all of this, I chose to create four files: app/layout.tsx, app/page.tsx, app/projects/page.tsx, and app/about/page.tsx.
The layout will apply to all pages, and each page file will contain it's own content.

I ran into one small issue with this approach: the home page doesn't need a <span style={{ position: 'relative', top: 4 }}> icon, but the other pages do.
It doesn't make much sense to include that in the home page, but all the other pages should have it,
so we'll keep it out of the root layout and create a Route Group with it's own nested layout layout to only apply to the other pages.

First, lets create our app/(subpages)/components directory and create a quick header only for the subpages:

// app/(subpages)components/header.tsx
import Link from 'next/link'
import { HomeIcon } from 'react-feather'

export default function Header() {
  return (
    <header>
      <Link href="/">
        <HomeIcon />
      </Link>
      // If you want to add a Client Component here like a theme switcher, mark that
      // component with "use client" and leave the majority of the header as an RSC
    </header>
  )
}

And use it in our app/(subpages)/layout.tsx:

// app/(subpages)/layout.tsx
import Header from './components/header'

export default function SubLayout({ children }) {
  return (
    <>
      <Header />
      {children}
    </>
  )
}

With the header in place, you now have a nested layout for subpages and blog posts.

Let's go ahead and create our files and directories:

A blog needs posts

Routing with dynamic segments

For our blog posts like this one, we'll want /blog/[slug] to be a page that displays a single blog post, and we want it to have it's own footer to link to other posts.
It sure seems like the footer should live inside the /blog/[slug] layout. The [slug] in the URL is referred to as a Dynamic Segment.

But how do we render markdown files in our blog posts?

Fetching and rendering markdown

The official Next.js documentation has a great guide for using MDX with all your pages.
Sometimes you want to render content from a remote source though, like a CMS.
In my case, for niche specific reasons, I want to keep my markdown separate from the Next.js project, so I'll be using next-mdx-remote and it's experimental React Server Components support.

A lot of the code is the same if you want to apply it to your own project, so just follow along with the code snippets.

Fetching your posts

You need to fetch your posts from somewhere before you can render them.
There's a lot of ways to do this. Here's a simplified but functional version of mine loading them from the file system:

import matter from 'gray-matter'
import path from 'path'
import type { Post } from './types'
import fs from 'fs/promises'
import { cache } from 'react'

// `cache` is a React 18 feature that allows you to cache a function for the lifetime of a request.
// this means getPosts() will only be called once per page build, even though we may call it multiple times
// when rendering the page.
export const getPosts = cache(async () => {
  const posts = await fs.readdir('./posts/')

  return Promise.all(
    posts
      .filter((file) => path.extname(file) === '.mdx')
      .map(async (file) => {
        const filePath = `./posts/${file}`
        const postContent = await fs.readFile(filePath, 'utf8')
        const { data, content } = matter(postContent)

        if (data.published === false) {
          return null
        }

        return { ...data, body: content } as Post
      })
  )
})

export async function getPost(slug: string) {
  const posts = await getPosts()
  return posts.find((post) => post.slug === slug)
}

export default getPosts

// Usage:
const posts = await getPosts()
const post = await getPost('my-post')

Because getPosts is cached, you can call getPost multiple times in your layout tree without worrying about a network waterfall.

Rendering your posts

Now that we have our posts, we can render them.

First, we need to setup MDX with any remark and rehype plugins. All the plugins are optional, but I've included the ones I use.

// app/(subpages)/blog/[slug]/components/post-body.tsx
import { MDXRemote } from 'next-mdx-remote/rsc'

import remarkGfm from 'remark-gfm'
import rehypeSlug from 'rehype-slug'
import rehypeAutolinkHeadings from 'rehype-autolink-headings'
import remarkA11yEmoji from '@fec/remark-a11y-emoji'
import remarkToc from 'remark-toc'
import { mdxComponents } from './markdown-components'

export function PostBody({ children }: { children: string }) {
  return (
    <MDXRemote
      source={children}
      options={{
        mdxOptions: {
          remarkPlugins: [
            // Adds support for GitHub Flavored Markdown
            remarkGfm,
            // Makes emojis more accessible
            remarkA11yEmoji,
            // generates a table of contents based on headings
            remarkToc,
          ],
          // These work together to add IDs and linkify headings
          rehypePlugins: [rehypeSlug, rehypeAutolinkHeadings],
        },
      }}
      components={mdxComponents}
    />
  )
}

You may notice the components={mdxComponents} prop. This is where we pass in our custom components that we want to use in our markdown files.
For using with Next.js, we probably want to use the official next/link and next/image components to opt into client side routing and image optimization.
This is also where I've defined the components like the file trees in this post.

// app/(subpages)/blog/[slug]/components/markdown-components.tsx
import Link from 'next/link'
import Image from 'next/image'

export const mdxComponents: MDXComponents = {
  a: ({ children, ...props }) => {
    return (
      <Link {...props} href={props.href || ''}>
        {children}
      </Link>
    )
  },
  img: ({ children, props }) => {
    // You need to do some work here to get the width and height of the image.
    // See the details below for my solution.
    return <Image {...props} />
  },
  // any other components you want to use in your markdown
}

// app/(subpages)/blog/[slug]/components/mdx-image.tsx
import NextImage from 'next/image'

export function MDXImage({
  src,
  alt,
}: React.DetailedHTMLProps<
  React.ImgHTMLAttributes<HTMLImageElement>,
  HTMLImageElement
> & {
  src: string
  alt: string
}) {
  let widthFromSrc, heightFromSrc
  const url = new URL(src, 'https://albert-kovalevskij.com')
  const widthParam = url.searchParams.get('w') || url.searchParams.get('width')
  const heightParam =
    url.searchParams.get('h') || url.searchParams.get('height')
  if (widthParam) {
    widthFromSrc = parseInt(widthParam)
  }
  if (heightParam) {
    heightFromSrc = parseInt(heightParam)
  }

  const imageProps = {
    src,
    alt,
    // tweak these to your liking
    height: heightFromSrc || 450,
    width: widthFromSrc || 550,
  }

  return <NextImage {...imageProps} />
}

// In a Markdown file
![alt text](/image.png?width=500&height=400)

Syntax highlighting with Bright

Bright is a new RSC-first syntax highlighter by code-hike.
It performs the highlighting on the server, so only the necessary styles and markup are sent to the client.
It also has first-class support for extensions like line numbers, highlighting, or whatever you decide to build.

Install the bright package and use it in your MDX components like so:

import { Code } from 'bright'
export const mdxComponents: MDXComponents = {
  // the `a` and `img` tags from before should remain
  pre: Code,
}

And that's all you need for great syntax highlighting.

Now that we have MDX setup and equipped with our components, we can render a post.

First, let's import the getPost function and the PostBody component we created earlier.

// app/(subpages)/blog/[slug]/page.tsx
import getPosts from '@lib/get-posts'
import { PostBody } from '@mdx/post-body'

Now we just... render the component.

import getPosts, { getPost } from '@lib/get-posts'
import { PostBody } from '@mdx/post-body'
import { notFound } from 'next/navigation'

export default async function PostPage({
  params,
}: {
  params: {
    slug: string
  }
}) {
  const post = await getPost(params.slug)
  // notFound is a Next.js utility
  if (!post) return notFound()
  // Pass the post contents to MDX
  return <PostBody>{post?.body}</PostBody>
}

We can now render a post; that's pretty cool.

We can optionally choose to build all of our posts at build time,
by adding generateStaticParams to the page:

export async function generateStaticParams() {
  const posts = await getPosts()
  // The params to pre-render the page with.
  // Without this, the page will be rendered at runtime
  return posts.map((post) => ({ slug: post.slug }))
}

SEO

The new Metadata API is fantastic, but it's also a major work in progress. Be sure to check the docs for the latest updates.

Metadata API

The new Metadata API has great documentation, so I won't go into too much detail here.
I define the majority of my layout in the root layout and override it as necessary in the leaf pages.

Here's what my root layout's metadata looks like:

// app/layout.tsx
export const metadata = {
  title: {
    template: '%s | Albert Kovalevskij',
    default: 'Albert Kovalevskij',
  },
  description: 'Full-stack developer.',
  openGraph: {
    title: 'Albert Kovalevskij',
    description: 'Full-stack developer.',
    url: 'https://albert-kovalevskij.com',
    siteName: "Albert Kovalevskij's site",
    locale: 'en_US',
    type: 'website',
    // To use your own endpoint, refer to https://vercel.com/docs/concepts/functions/edge-functions/og-image-generation
    // Note that an official `app/` solution is coming soon.
    images: [
      {
        url: `https://www.albert-kovalevskij.com//api/og?title=${encodeURIComponent(
          "Albert Kovalevskij's site"
        )}`,
        width: 1200,
        height: 630,
        alt: '',
      },
    ],
  },
  icons: {
    shortcut: 'https://www.albert-kovalevskij.com//favicons/favicon.ico',
  },
  alternates: {
    types: {
      // See the RSS Feed section for more details
      'application/rss+xml': 'https://www.albert-kovalevskij.com//feed.xml',
    },
  },
}

export const viewport = {
  themeColor: [
    { media: '(prefers-color-scheme: light)', color: '#f5f5f5' },
    { media: '(prefers-color-scheme: dark)', color: '#000' },
  ],
}

And a pages metadata may look like this:

// app/(subpages)/about/page.tsx
export const metadata = {
  title: 'About',
  alternates: {
    canonical: 'https://www.albert-kovalevskij.com//about',
  },
}

Sitemap support (sitemap.js)

See @leeerob's announcement tweet for more details.

// app/sitemap.ts
import { getPosts } from './lib/get-posts'

export default async function sitemap() {
  const posts = await getPosts()
  const blogs = posts.map((post) => ({
    url: `https://www.albert-kovalevskij.com/blog/${post.slug}`,
    lastModified: new Date(post.lastModified).toISOString().split('T')[0],
  }))

  const routes = ['', '/about', '/blog', '/projects'].map((route) => ({
    url: `https://www.albert-kovalevskij.com${route}`,
    lastModified: new Date().toISOString().split('T')[0],
  }))

  return [...routes, ...blogs]
}

Generating an RSS Feed

While waiting for of an official solution for RSS feeds, I've created a custom solution that works well for me.
I use the marked library to parse the markdown files and then use the rss library to generate the RSS feed.
This means the JSX components for MDX are passed through to the RSS feed,
so I just try and ensure the components are legible even when not renderd.

// scripts/rss.ts
import fs from 'fs'
import RSS from 'rss'
import path from 'path'
import { marked } from 'marked'
import matter from 'gray-matter'

const posts = fs
  .readdirSync(path.resolve(__dirname, '../posts/'))
  .filter(
    (file) => path.extname(file) === '.md' || path.extname(file) === '.mdx'
  )
  .map((file) => {
    const postContent = fs.readFileSync(`./posts/${file}`, 'utf8')
    const { data, content }: { data: any; content: string } =
      matter(postContent)
    return { ...data, body: content }
  })
  .sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime())

const renderer = new marked.Renderer()

renderer.link = (href, _, text) =>
  `<a href="${href}" target="_blank" rel="noopener noreferrer">${text}</a>`

marked.setOptions({
  gfm: true,
  breaks: true,
  renderer,
})

const renderPost = (md: string) => marked.parse(md)

const main = () => {
  const feed = new RSS({
    title: 'Albert Kovalevskij',
    site_url: 'https://www.albert-kovalevskij.com',
    feed_url: 'https://www.albert-kovalevskij.com/feed.xml',
    // image_url: 'https://www.albert-kovalevskij.com/og.png',
    language: 'en',
    description: "Albert Kovalevskij's blog",
  })

  posts.forEach((post) => {
    const url = `https://www.albert-kovalevskij.com/blog/${post.slug}`

    feed.item({
      title: post.title,
      description: renderPost(post.body),
      date: new Date(post?.date),
      author: 'Albert Kovalevskij',
      url,
      guid: url,
    })
  })

  const rss = feed.xml({ indent: true })
  fs.writeFileSync(path.join(__dirname, '../public/feed.xml'), rss)
}

main()

Deployment

I use Vercel for deployments (I may be bias), but you can use any static site provider you want with a setup
like this because it supports static export.

Wrapping up

I hope this post was helpful to you.
As a reminder, you can find the source code for this site here.
Please try to not think negatively of me for anything you find (but feel free to offer praise for anything you like).

Problem Statement

Given an unsorted array of integers nums, return the length of the longest consecutive elements sequence. The sequence must be strictly consecutive, and the numbers in the sequence can appear in any order in the array.

Example

• Input: nums = [100, 4, 200, 1, 3, 2]
  Output: 4
  Explanation: The longest consecutive elements sequence is [1, 2, 3, 4]. Therefore, its length is 4.

Set-Based Solution

function longestConsecutive(nums) {
    const numSet = new Set(nums);
    let longestStreak = 0;

    for (const num of numSet) {
        if (!numSet.has(num - 1)) {
            let currentNum = num;
            let currentStreak = 1;

            while (numSet.has(currentNum + 1)) {
                currentNum += 1;
                currentStreak += 1;
            }

            longestStreak = Math.max(longestStreak, currentStreak);
        }
    }

    return longestStreak;
}

Breaking Down the Solution

• Create a Set: Convert the array into a set to allow for O(1) lookups and to eliminate duplicates.

• Iterate Through the Set: For each number, check if it's the start of a sequence (i.e., num - 1 is not in the set).

• Expand the Sequence: If it's the start, count the length of the consecutive sequence by continuously checking the presence of the next numbers in the set.

• Track the Longest Sequence: Update the longest sequence length found so far.

Time Complexity

1. Creating the Set: Converting the array into a set has a time complexity of O(N), where N is the number of elements in the array. This is because each element is added to the set once.

2. Iterating Through the Set: The main loop iterates through each element of the set. For each element, it checks whether it is the start of a new sequence (i.e., whether num - 1 is not in the set).

3. Finding Consecutive Numbers: For each starting element of a sequence, the algorithm potentially iterates through the consecutive numbers following it. In the worst case, if there is a long consecutive sequence, this could seem like an additional nested loop. However, each element in the array is visited at most twice in these operations: once when it's checked as a potential start of a sequence, and once when it's counted as part of an existing sequence.

   The key insight is that, although there's a nested loop, each element from the original array contributes to the longest streak only once. This means the total number of operations is still proportional to N.

Putting it all together, the worst-case time complexity is O(N).

Space Complexity

The space complexity is primarily determined by the set used to store the elements of the array. Since the set contains every distinct element from the original array, the space complexity is O(N).

Summary

The set-based approach for the "Longest Consecutive Sequence" problem is efficient with a linear time complexity of O(N) and a linear space complexity of O(N), making it a suitable solution for large arrays.

Conclusion

The Longest Consecutive Sequence problem is an excellent application of sets in algorithms, demonstrating their utility in efficiently solving problems that involve uniqueness and ordering. It emphasizes the importance of choosing the right data structure for optimal performance in solving complex problems.

First off, it's a good idea! Contributing to projects is a fantastic way to build experience, connections, and improve a piece of software you use or rely on. I've grown immensely through maintaining my few projects and contributing to a hand full of others. I've gained experience in community management, team communication, code review, dependency management, and the list goes on. This post is focused on programming, but don't forget that issue management, documentation, user support, and bug reporting are all valuable ways you can contribute.

That point about using open-source software is important. The first thing I tell my friends is they should first ensure they're using some before they attempt to contribute. There are few things that are more satisfying than fixing a bug that's been bugging you in a program written by someone else, and the motivation that provides is not inconsequential[^1]. As a maintainer, contributor, and extensive procrastinator I've seen and felt lack of motivation and burn-out from multiple perspectives, and know how daunting making a contribution can be. So to give you some ideas, here are some applications I use that you may want to try using (or may already use!), and a checklist for how to get started contributing to them:

• Firefox (really, it's (in some cases) as fast as Chrome now! Plus it helps you escape the Alphabet.)
• GIMP (GNU Image Manipulator Program, a free version of Photoshop.)
• VS Code (note that most of it is open-souce, but parts are not.)
  • See VSCodium if you want a VS Code fork without Microsoft telemetry and licensing

And loads more. I didn't even mention the vast number of open-source software libraries and frameworks you likely already use. Maybe Next.js, Vue, or Flask are of interest to you, just to provide a few examples. And below is my framework for getting started.

The steps

1. Find a project and feature or bug to work on: find one from experience or on their issue tracker/mailing list. Targeting a bug that bothers you or a feature you personally want is ideal due to the motivation aspect mentioned above. If the project is on GitHub these may be in the Milestone or Discussion pages. GitHub Explore filtered to languages you know or are interested in learning is a great place to start.
2. Search for prior work or discussions: it's important your changes align with the maintainers vision, and you should double check that no one else is working on it. If they are or previously have, you can offer to team-up or ask for their advice.
3. Familiarize yourself with the code base: depending on the size, it may not be feasible or sensible for you to grok the entire code base. Instead, try to learn just the parts you need. Feel free to ask the maintainers after searching the documentation and using the below tips if you need help:
   • Read the README and CONTRIBUTING files, if they both exist[^2]
   • Use a package explorer or the Unix find utility to find directories and files of interest
   • Use git grep to find identifiable or interesting messages/logs/strings in the code (an error alert's text, for example)
   • Use git log to explore commits
   • Use git blame to find out who to email or contact with questions
     • You can also check the README or look for a COMMUNITY file to find where to ask
4. Get crackin': Work on the task, reaching out to the maintainers and/or community for help if necessary. Always be courteous, patient, and as clear as possible. Code samples and reproducible cases are king.
5. Submit your work: Most likely, submitting your completed work will be done via a mailing list or over a code forge like GitHub and BitBucket. Refer to their documentation and the project's documentation to determine how to submit your changes.
6. Wait, Fix, Repeat: It's likely you'll need to address some comments and make some changes to your initial work. That's okay! Address their comments and send it back to them. Few things feel worse than wasting a reviewers time (especially a volunteer like in many open-source projects), so be sure you self-review your code like you (hopefully) would an English paper.[^3]

A quick example:

...which you can read more about in my dedicated post.

1. I wanted ambient light support on my Surface Pro 3 running Linux
2. I searched Google for information and luckily found this issue and repo:
   
3. I searched the LKML for previous examples of minor driver adjustments and joined the #linux-surface IRC channel to talk with the other contributors to hear their ideas.
4. After a few hours and with some help from IRC I determined how to have the device registered using the existing driver and pushed my code to GitHub.
5. Once the code was reviewed by a few members of linux-surface I submit my patch set to LKML.
6. It was released in Linux 5.11 🎉

In short

• Read the documentation
• Find an interesting problem to tackle that motivates you
• Discover and grow comfortable with your tools for grepping and exploring unfamiliar code bases
• Don't be afraid to reach out to the maintainers and community; develop communication skills

[^1]: One of the few better feelings is fixing a bug in software you made that someone else reported.
[^2]: If the README does not exist, consider that a red flag. If the CONTRIBUTING file does not exist, consider asking the maintainers if you could help draft one.
[^3]: If you haven't worked professionally in CS yet, this is likely your first code review, and they're highly prevalent in the industry, so try extra hard to learn from your mistakes and take note of what you like and dislike about the review left for you.

To get started, you'll need to generate a Developer Token on the control panel. Navigate to the Sub-accounts page and generate a new API key at the bottom of the page:

Also, install axios (or change the below code to your favorite request library, I don't care):

    yarn add axios

Then, incorporate these two files:

import axios, { AxiosRequestConfig } from "axios";
import { InitializationOptions, MetricResponse, RestartResponse } from "./types";

export default class Client {
    private instance: string;
    constructor({ apiKey, apiSecret, apiUrl = 'https://api.creeper.host', instanceId}: InitializationOptions) {
        axios.defaults.baseURL = apiUrl;

        axios.defaults.headers.common['key'] = apiKey;
        axios.defaults.headers.common['secret'] = apiSecret;
        axios.defaults.headers.common['Content-Type'] = 'application/json';

        this.instance = instanceId;
    }

    private async request<T = any>({ method = "GET", apiRoute, body }: { method: "GET" | "POST", apiRoute: string, body?: any}) {
        const config: AxiosRequestConfig = {
            method,
            url: apiRoute,
            data: body
        }

        console.log(`[${method}] ${apiRoute}`, body ? `\t ${JSON.stringify(body)}` : '');

        const request = await axios.request<T>(config);
        return request.data;
    }

    public os = {
            getram: async () => {
                return this.request<MetricResponse>({ method: "GET", apiRoute: "os/getram" });
            },
            getssd: async () => {
                return this.request<MetricResponse>({ method: "GET", apiRoute: "os/getssd" });
            },
    }

    public minecraft = {
        restartserver: async () => {
            return this.request<RestartResponse>({ method: "POST", apiRoute: "minecraft/restartserver", body: { instance: this.instance} });
        },
    }
}

export type MetricResponse = {
    status: 'success';
    free: number;
    used: number;
} | {
    status: 'error',
    message: string
}

export type RestartResponse = {
    status: 'success';
    message: string;
} | {
    status: 'error',
    message: string
}

Finally, create an instance via new Client({ apiKey, apiSecret, instanceId });
You can use it by finding what you want to call on the Creeper Host docs and accessing that on the client; I purposefully used the same naming scheme. For example,

Client.os.getram(): Promise<MetricResponse>

corresponds to the https://api.creeper.host/os/getram endpoint.

I removed some methods from the above to avoid cluttering this page, but it's straight forward to add your own. If you really want to use this, contact me and I can set up a repo for us to collaborate. Also, if you have suggestions on how I can improve this, let me know via email or on Twitter.