// coding-test/04-hash-map-set/01-two-sum/solution.js
// 시간복잡도: O(n) — 배열을 한 번 순회하며 Map에서 조회한다
// 공간복잡도: O(n) — 지금까지 본 값을 Map에 저장한다
export function solution(nums, target) {
  const indexByValue = new Map();
  for (let i = 0; i < nums.length; i++) {
    const complement = target - nums[i];
    if (indexByValue.has(complement)) {
      return [indexByValue.get(complement), i];
    }
    indexByValue.set(nums[i], i);
  }
  return [];
}

// coding-test/04-hash-map-set/01-two-sum/solution.test.js
import { test } from 'node:test';
import assert from 'node:assert/strict';
import { solution } from './solution.js';
 
test('합이 target인 두 인덱스를 찾는다', () => {
  assert.deepStrictEqual(solution([2, 7, 11, 15], 9), [0, 1]);
});
 
test('음수가 섞여 있어도 정확하다', () => {
  assert.deepStrictEqual(solution([-3, 4, 3, 90], 0), [0, 2]);
});

// coding-test/04-hash-map-set/02-group-anagrams/solution.js
// 시간복잡도: O(n * k log k) — 문자열 n개를 각각 정렬(O(k log k))해 키로 쓴다
// 공간복잡도: O(n * k) — 그룹별 문자열을 모두 저장한다
export function solution(words) {
  const groups = new Map();
  for (const word of words) {
    const key = word.split('').sort().join('');
    if (!groups.has(key)) {
      groups.set(key, []);
    }
    groups.get(key).push(word);
  }
  return [...groups.values()];
}

// coding-test/04-hash-map-set/02-group-anagrams/solution.test.js
import { test } from 'node:test';
import assert from 'node:assert/strict';
import { solution } from './solution.js';
 
test('애너그램끼리 묶는다', () => {
  const result = solution(['eat', 'tea', 'tan', 'ate', 'nat', 'bat']);
  assert.deepStrictEqual(result, [
    ['eat', 'tea', 'ate'],
    ['tan', 'nat'],
    ['bat'],
  ]);
});
 
test('애너그램이 없으면 각자 자기 그룹이 된다', () => {
  assert.deepStrictEqual(solution(['abc', 'def']), [['abc'], ['def']]);
});

// coding-test/04-hash-map-set/03-dedupe-preserve-order/solution.js
// 시간복잡도: O(n) — 배열 원소를 한 번씩만 Set에 넣는다
// 공간복잡도: O(n) — 중복 없는 값을 저장하는 Set을 쓴다
export function solution(nums) {
  return [...new Set(nums)];
}

// coding-test/04-hash-map-set/03-dedupe-preserve-order/solution.test.js
import { test } from 'node:test';
import assert from 'node:assert/strict';
import { solution } from './solution.js';
 
test('중복을 제거하되 처음 등장 순서를 유지한다', () => {
  assert.deepStrictEqual(solution([1, 2, 2, 3, 1, 4]), [1, 2, 3, 4]);
});
 
test('모두 같은 값이면 하나만 남는다', () => {
  assert.deepStrictEqual(solution([5, 5, 5]), [5]);
});

// coding-test/04-hash-map-set/04-array-intersection/solution.js
// 시간복잡도: O(n + m) — 두 배열 길이의 합에 비례한다
// 공간복잡도: O(n + m) — Set 두 개를 사용한다
export function solution(nums1, nums2) {
  const firstSet = new Set(nums1);
  const resultSet = new Set();
  for (const num of nums2) {
    if (firstSet.has(num)) {
      resultSet.add(num);
    }
  }
  return [...resultSet].sort((a, b) => a - b);
}

// coding-test/04-hash-map-set/04-array-intersection/solution.test.js
import { test } from 'node:test';
import assert from 'node:assert/strict';
import { solution } from './solution.js';
 
test('공통으로 들어있는 값만 중복 없이 반환한다', () => {
  assert.deepStrictEqual(solution([1, 2, 2, 1], [2, 2]), [2]);
});
 
test('결과를 오름차순으로 정렬해 반환한다', () => {
  assert.deepStrictEqual(solution([4, 9, 5], [9, 4, 9, 8, 4]), [4, 9]);
});