Hash Maps والـ Sets

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

  const countMap = {};

  for (const char of s) {
    countMap[char] = (countMap[char] || 0) + 1;
  }

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

  return true;
}

function intersection(nums1, nums2) {
  const set1 = new Set(nums1);
  const result = [];

  for (const num of nums2) {
    if (set1.has(num)) {
      result.push(num);
      set1.delete(num);
    }
  }

  return result;
}

function isHappy(n) {
  const seen = new Set();

  while (n !== 1 && !seen.has(n)) {
    seen.add(n);
    let sum = 0;
    while (n > 0) {
      const digit = n % 10;
      sum += digit * digit;
      n = Math.floor(n / 10);
    }
    n = sum;
  }

  return n === 1;
}

function singleNumber(nums) {
  const countMap = {};

  for (const num of nums) {
    countMap[num] = (countMap[num] || 0) + 1;
  }

  for (const num in countMap) {
    if (countMap[num] === 1) return Number(num);
  }
}

function twoSum(nums, target) {
  const map = new Map();

  for (let i = 0; i < nums.length; i++) {
    const complement = target - nums[i];
    if (map.has(complement)) {
      return [map.get(complement), i];
    }
    map.set(nums[i], i);
  }

  return [];
}

function groupAnagrams(strs) {
  const map = new Map();

  for (const str of strs) {
    const sorted = str.split('').sort().join('');
    if (!map.has(sorted)) {
      map.set(sorted, []);
    }
    map.get(sorted).push(str);
  }

  return Array.from(map.values());
}

function topKFrequent(nums, k) {
  const freqMap = {};

  for (const num of nums) {
    freqMap[num] = (freqMap[num] || 0) + 1;
  }

  return Object.entries(freqMap)
    .sort((a, b) => b[1] - a[1])
    .slice(0, k)
    .map(([num]) => Number(num));
}

function fractionToDecimal(numerator, denominator) {
  if (numerator === 0) return "0";

  const result = [];
  const map = new Map();

  if ((numerator < 0) !== (denominator < 0)) {
    result.push("-");
  }

  let num = Math.abs(numerator);
  const den = Math.abs(denominator);

  result.push(Math.floor(num / den));
  num %= den;

  if (num === 0) return result.join("");

  result.push(".");

  while (num !== 0) {
    if (map.has(num)) {
      const index = map.get(num);
      result.splice(index, 0, "(");
      result.push(")");
      break;
    }

    map.set(num, result.length);
    num *= 10;
    result.push(Math.floor(num / den));
    num %= den;
  }

  return result.join("");
}

function longestConsecutive(nums) {
  const numSet = new Set(nums);
  let longest = 0;

  for (const num of numSet) {
    if (!numSet.has(num - 1)) {
      let currentNum = num;
      let currentStreak = 1;

      while (numSet.has(currentNum + 1)) {
        currentNum++;
        currentStreak++;
      }

      longest = Math.max(longest, currentStreak);
    }
  }

  return longest;
}

function subarraySum(nums, k) {
  const map = new Map();
  map.set(0, 1);
  let prefixSum = 0;
  let count = 0;

  for (const num of nums) {
    prefixSum += num;
    if (map.has(prefixSum - k)) {
      count += map.get(prefixSum - k);
    }
    map.set(prefixSum, (map.get(prefixSum) || 0) + 1);
  }

  return count;
}

function minimumIndex(nums) {
  const freqMap = {};
  for (const num of nums) {
    freqMap[num] = (freqMap[num] || 0) + 1;
  }

  let dominant = null;
  let maxFreq = 0;
  for (const num in freqMap) {
    if (freqMap[num] > maxFreq) {
      maxFreq = freqMap[num];
      dominant = Number(num);
    }
  }

  let leftCount = 0;
  for (let i = 0; i < nums.length; i++) {
    if (nums[i] === dominant) {
      leftCount++;
    }
    const rightCount = maxFreq - leftCount;
    const leftLen = i + 1;
    const rightLen = nums.length - leftLen;

    if (leftCount * 2 > leftLen && rightCount * 2 > rightLen) {
      return i;
    }
  }

  return -1;
}

function findAnagrams(s, p) {
  const result = [];

  if (s.length < p.length) return result;

  const pCount = new Array(26).fill(0);
  const sCount = new Array(26).fill(0);

  for (let i = 0; i < p.length; i++) {
    pCount[p.charCodeAt(i) - 97]++;
    sCount[s.charCodeAt(i) - 97]++;
  }

  if (arraysEqual(pCount, sCount)) {
    result.push(0);
  }

  for (let i = p.length; i < s.length; i++) {
    sCount[s.charCodeAt(i) - 97]++;
    sCount[s.charCodeAt(i - p.length) - 97]--;

    if (arraysEqual(pCount, sCount)) {
      result.push(i - p.length + 1);
    }
  }

  return result;
}

function arraysEqual(a, b) {
  for (let i = 0; i < 26; i++) {
    if (a[i] !== b[i]) return false;
  }
  return true;
}