A1 — Two Sum

// JavaScript
function twoSum(nums, target) {
  const seen = new Map();
  for (let i = 0; i < nums.length; i++) {
    const complement = target - nums[i];
    if (seen.has(complement)) {
      return [seen.get(complement), i];
    }
    seen.set(nums[i], i);
  }
  throw new Error("No solution found");
}

// TypeScript
function twoSum(nums: number[], target: number): number[] {
  const seen = new Map<number, number>();
  for (let i = 0; i < nums.length; i++) {
    const complement = target - nums[i];
    if (seen.has(complement)) {
      return [seen.get(complement)!, i];
    }
    seen.set(nums[i], i);
  }
  throw new Error("No solution found");
}

A2 — Valid Palindrome

// JavaScript
function isPalindrome(s) {
  let left = 0, right = s.length - 1;
  const isAlnum = (c) => /[a-z0-9]/i.test(c);
  while (left < right) {
    while (left < right && !isAlnum(s[left])) left++;
    while (left < right && !isAlnum(s[right])) right--;
    if (s[left].toLowerCase() !== s[right].toLowerCase()) return false;
    left++;
    right--;
  }
  return true;
}

// TypeScript
function isPalindrome(s: string): boolean {
  let left = 0, right = s.length - 1;
  const isAlnum = (c: string): boolean => /[a-z0-9]/i.test(c);
  while (left < right) {
    while (left < right && !isAlnum(s[left])) left++;
    while (left < right && !isAlnum(s[right])) right--;
    if (s[left].toLowerCase() !== s[right].toLowerCase()) return false;
    left++;
    right--;
  }
  return true;
}

A3 — Valid Parentheses

// JavaScript
function isValid(s) {
  const stack = [];
  const pairs = { ')': '(', ']': '[', '}': '{' };
  for (const c of s) {
    if (c in pairs) {
      if (stack.pop() !== pairs[c]) return false;
    } else {
      stack.push(c);
    }
  }
  return stack.length === 0;
}

// TypeScript
function isValid(s: string): boolean {
  const stack: string[] = [];
  const pairs: Record<string, string> = { ')': '(', ']': '[', '}': '{' };
  for (const c of s) {
    if (c in pairs) {
      if (stack.pop() !== pairs[c]) return false;
    } else {
      stack.push(c);
    }
  }
  return stack.length === 0;
}

A4 — Longest Subarray Without Repeats

// JavaScript
function longestUniqueSubarray(nums) {
  const lastSeen = new Map();
  let maxLen = 0, left = 0;
  for (let right = 0; right < nums.length; right++) {
    if (lastSeen.has(nums[right]) && lastSeen.get(nums[right]) >= left) {
      left = lastSeen.get(nums[right]) + 1;
    }
    lastSeen.set(nums[right], right);
    maxLen = Math.max(maxLen, right - left + 1);
  }
  return maxLen;
}

// TypeScript
function longestUniqueSubarray(nums: number[]): number {
  const lastSeen = new Map<number, number>();
  let maxLen = 0, left = 0;
  for (let right = 0; right < nums.length; right++) {
    if (lastSeen.has(nums[right]) && lastSeen.get(nums[right])! >= left) {
      left = lastSeen.get(nums[right])! + 1;
    }
    lastSeen.set(nums[right], right);
    maxLen = Math.max(maxLen, right - left + 1);
  }
  return maxLen;
}

A5 — Max Depth of Binary Tree

// JavaScript
function maxDepth(root) {
  if (root === null) return 0;
  return 1 + Math.max(maxDepth(root.left), maxDepth(root.right));
}

// TypeScript
interface TreeNode {
  val: number;
  left: TreeNode | null;
  right: TreeNode | null;
}

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