2025년 16주차 문제 풀이 (#42)

## 문제 풀이 목록

- [LeetCode 1534. Count Good
Triplets](https://leetcode.com/problems/count-good-triplets)
- [LeetCode 2179. Count Good Triplets in an
Array](https://leetcode.com/problems/count-good-triplets-in-an-array) ✨
- [LeetCode 2537. Count the Number of Good
Subarrays](https://leetcode.com/problems/count-the-number-of-good-subarrays)
✨
- [LeetCode 2176. Count Equal and Divisible Pairs in an
Array](https://leetcode.com/problems/count-equal-and-divisible-pairs-in-an-array)
- [LeetCode 38. Count and
Say](https://leetcode.com/problems/count-and-say)
- [LeetCode 2563. Count the Number of Fair
Pairs](https://leetcode.com/problems/count-the-number-of-fair-pairs)
- [LeetCode 781. Rabbits in
Forest](https://leetcode.com/problems/rabbits-in-forest) ✨

Author: sangrimlee

solution/README.md

@@ -2,12 +2,9 @@ import { countAndSay } from './0038';
 
 describe('LeetCode 0038', () => {
   test('Example 1', () => {
-    expect(countAndSay(1)).toBe('1');
-  });
-  test('Example 2', () => {
     expect(countAndSay(4)).toBe('1211');
   });
-  test('Example 3', () => {
-    expect(countAndSay(5)).toBe('111221');
+  test('Example 2', () => {
+    expect(countAndSay(1)).toBe('1');
   });
 });

solution/src/leetcode/0038/0038.test.ts

@@ -3,29 +3,24 @@
  * https://leetcode.com/problems/count-and-say
  */
 export function countAndSay(n: number): string {
-  const count = (s: string) => {
-    let result = '';
+  let current = '1';
+  for (let i = 0; i < n - 1; i++) {
+    current = runLengthEncoding(current);
+  }
+  return current;
+}
 
-    let num = '';
-    let count = 0;
-    for (const char of s) {
-      if (num === char) {
-        count += 1;
-        continue;
-      }
-      if (0 < count) {
-        result += `${count.toString()}${num.toString()}`;
-      }
-      num = char;
+function runLengthEncoding(s: string): string {
+  let result = '';
+  let count = 1;
+  for (let i = 1; i < s.length; i++) {
+    if (s[i - 1] === s[i]) {
+      count += 1;
+    } else {
+      result += `${count.toString()}${s[i - 1]}`;
       count = 1;
     }
-    result += `${count.toString()}${num.toString()}`;
-    return result;
-  };
-
-  let answer = '1';
-  for (let i = 2; i <= n; i++) {
-    answer = count(answer);
   }
-  return answer;
+  result += `${count.toString()}${s[s.length - 1]}`;
+  return result;
 }

solution/src/leetcode/0038/0038.ts

@@ -0,0 +1,10 @@
+import { numRabbits } from './0781';
+
+describe('LeetCode 0781', () => {
+  test('Example 1', () => {
+    expect(numRabbits([1, 1, 2])).toBe(5);
+  });
+  test('Example 2', () => {
+    expect(numRabbits([10, 10, 10])).toBe(11);
+  });
+});

solution/src/leetcode/0781/0781.test.ts

@@ -0,0 +1,17 @@
+/**
+ * 781. Rabbits in Forest
+ * https://leetcode.com/problems/rabbits-in-forest
+ */
+export function numRabbits(answers: number[]): number {
+  const counter = new Map<number, number>();
+  for (const answer of answers) {
+    counter.set(answer, (counter.get(answer) ?? 0) + 1);
+  }
+
+  let result = 0;
+  for (const [answer, count] of counter) {
+    const groupCount = Math.ceil(count / (answer + 1));
+    result += groupCount * (answer + 1);
+  }
+  return result;
+}

solution/src/leetcode/0781/0781.ts

@@ -0,0 +1,8 @@
+{
+  "id": "781",
+  "url": "https://leetcode.com/problems/rabbits-in-forest",
+  "title": "Rabbits in Forest",
+  "category": "Algorithms",
+  "difficulty": "Medium",
+  "tags": ["Array", "Hash Table", "Math", "Greedy"]
+}

solution/src/leetcode/0781/meta.json

@@ -3,22 +3,21 @@
  * https://leetcode.com/problems/count-good-triplets
  */
 export function countGoodTriplets(arr: number[], a: number, b: number, c: number): number {
-  const diff = (i: number, j: number) => Math.abs(arr[i] - arr[j]);
   const n = arr.length;
 
   let answer = 0;
   for (let i = 0; i < n; i++) {
     for (let j = i + 1; j < n; j++) {
-      if (diff(i, j) > a) {
+      if (Math.abs(arr[i] - arr[j]) > a) {
         continue;
       }
+
       for (let k = j + 1; k < n; k++) {
-        if (diff(j, k) <= b && diff(i, k) <= c) {
+        if (Math.abs(arr[j] - arr[k]) <= b && Math.abs(arr[i] - arr[k]) <= c) {
           answer += 1;
         }
       }
     }
   }
-
   return answer;
 }

solution/src/leetcode/1534/1534.ts

@@ -3,23 +3,29 @@
  * https://leetcode.com/problems/count-equal-and-divisible-pairs-in-an-array
  */
 export function countPairs(nums: number[], k: number): number {
-  const indicesByValue = new Map<number, number[]>();
-
-  let answer = 0;
+  const indicesByNum = new Map<number, number[]>();
   nums.forEach((num, i) => {
-    const indices = indicesByValue.get(num) ?? [];
-    if (indices.length === 0) {
-      indicesByValue.set(num, [i]);
-      return;
-    }
-
-    for (const j of indices) {
-      if ((i * j) % k === 0) {
-        answer += 1;
-      }
-    }
+    const indices = indicesByNum.get(num) ?? [];
     indices.push(i);
+    indicesByNum.set(num, indices);
   });
 
+  let answer = 0;
+  for (const indices of indicesByNum.values()) {
+    const gcdCount = new Map<number, number>();
+    for (const i of indices) {
+      const gcdI = gcd(i, k);
+      for (const [gcdJ, count] of gcdCount) {
+        if ((gcdI * gcdJ) % k === 0) {
+          answer += count;
+        }
+      }
+      gcdCount.set(gcdI, (gcdCount.get(gcdI) ?? 0) + 1);
+    }
+  }
   return answer;
 }
+
+function gcd(a: number, b: number): number {
+  return b === 0 ? a : gcd(b, a % b);
+}

solution/src/leetcode/2176/2176.ts

@@ -0,0 +1,10 @@
+import { goodTriplets } from './2179';
+
+describe('LeetCode 2179', () => {
+  test('Example 1', () => {
+    expect(goodTriplets([2, 0, 1, 3], [0, 1, 2, 3])).toBe(1);
+  });
+  test('Example 2', () => {
+    expect(goodTriplets([4, 0, 1, 3, 2], [4, 1, 0, 2, 3])).toBe(4);
+  });
+});

solution/src/leetcode/2179/2179.test.ts

@@ -0,0 +1,55 @@
+/**
+ * 2179. Count Good Triplets in an Array
+ * https://leetcode.com/problems/count-good-triplets-in-an-array
+ */
+export function goodTriplets(nums1: number[], nums2: number[]): number {
+  const n = nums1.length;
+  const pos2 = new Array<number>(n).fill(-1);
+  const indexMapping = new Array<number>(n).fill(-1);
+  nums2.forEach((num2, i) => {
+    pos2[num2] = i;
+  });
+  nums1.forEach((num1, i) => {
+    indexMapping[pos2[num1]] = i;
+  });
+
+  const tree = new BinaryIndexedTree(n);
+  let answer = 0;
+  for (let value = 0; value < n; value++) {
+    const pos = indexMapping[value];
+
+    const left = tree.query(pos);
+    tree.update(pos, 1);
+    const right = n - 1 - pos - (value - left);
+    answer += left * right;
+  }
+  return answer;
+}
+
+class BinaryIndexedTree {
+  readonly size: number;
+  private readonly tree: number[];
+
+  constructor(size: number) {
+    this.size = size;
+    this.tree = new Array<number>(this.size + 1).fill(0);
+  }
+
+  update(index: number, delta: number): void {
+    let currentIndex = index + 1;
+    while (currentIndex <= this.size) {
+      this.tree[currentIndex] += delta;
+      currentIndex += currentIndex & -currentIndex;
+    }
+  }
+
+  query(index: number): number {
+    let result = 0;
+    let currentIndex = index + 1;
+    while (currentIndex > 0) {
+      result += this.tree[currentIndex];
+      currentIndex -= currentIndex & -currentIndex;
+    }
+    return result;
+  }
+}