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

## 문제 풀이 목록
- [LeetCode 2145. Count the Hidden
Sequences](https://leetcode.com/problems/count-the-hidden-sequences)
:sparkles:
- [LeetCode 2338. Count the Number of Ideal
Arrays](https://leetcode.com/problems/count-the-number-of-ideal-arrays)
✨
- [LeetCode 1399. Count Largest
Group](https://leetcode.com/problems/count-largest-group)
- [LeetCode 2799. Count Complete Subarrays in an
Array](https://leetcode.com/problems/count-complete-subarrays-in-an-array)
✨
- [LeetCode 2845. Count of Interesting
Subarrays](https://leetcode.com/problems/count-of-interesting-subarrays)
✨
- [LeetCode 2444. Count Subarrays With Fixed
Bounds](https://leetcode.com/problems/count-subarrays-with-fixed-bounds)
- [LeetCode 3392. Count Subarrays of Length Three With a
Condition](https://leetcode.com/problems/count-subarrays-of-length-three-with-a-condition)

Author: sangrimlee

solution/README.md

@@ -3,20 +3,30 @@
  * https://leetcode.com/problems/count-largest-group
  */
 export function countLargestGroup(n: number): number {
-  const sumOfDigits = (n: number) => {
-    return n
-      .toString()
-      .split('')
-      .reduce((sum, digit) => sum + +digit, 0);
-  };
-  const groups = new Map<number, number>();
+  let groupCount = 0;
   let largestGroupSize = 0;
-  for (let i = 1; i <= n; i++) {
-    const group = sumOfDigits(i);
-    const groupSize = (groups.get(group) ?? 0) + 1;
-    groups.set(group, groupSize);
-    largestGroupSize = Math.max(groupSize, largestGroupSize);
+  const group = new Map<number, number>();
+  for (let num = 1; num <= n; num++) {
+    const sum = sumOfDigits(num);
+    const groupSize = (group.get(sum) ?? 0) + 1;
+    group.set(sum, groupSize);
+
+    if (groupSize > largestGroupSize) {
+      largestGroupSize = groupSize;
+      groupCount = 1;
+    } else if (groupSize === largestGroupSize) {
+      groupCount += 1;
+    }
   }
+  return groupCount;
+}
 
-  return [...groups.values()].filter((groupSize) => groupSize === largestGroupSize).length;
+function sumOfDigits(num: number): number {
+  let result = 0;
+  let curr = num;
+  while (curr > 0) {
+    result += curr % 10;
+    curr = Math.floor(curr / 10);
+  }
+  return result;
 }

solution/src/leetcode/1399/1399.ts

@@ -0,0 +1,13 @@
+import { numberOfArrays } from './2145';
+
+describe('LeetCode 2145', () => {
+  test('Example 1', () => {
+    expect(numberOfArrays([1, -3, 4], 1, 6)).toBe(2);
+  });
+  test('Example 2', () => {
+    expect(numberOfArrays([3, -4, 5, 1, -2], -4, 5)).toBe(4);
+  });
+  test('Example 3', () => {
+    expect(numberOfArrays([4, -7, 2], 3, 6)).toBe(0);
+  });
+});

solution/src/leetcode/2145/2145.test.ts

@@ -0,0 +1,23 @@
+/**
+ * 2145. Count the Hidden Sequences
+ * https://leetcode.com/problems/count-the-hidden-sequences
+ */
+export function numberOfArrays(differences: number[], lower: number, upper: number): number {
+  const rangeSize = upper - lower;
+
+  let minValue = 0;
+  let maxValue = 0;
+  let currentValue = 0;
+  for (const difference of differences) {
+    currentValue += difference;
+    minValue = Math.min(minValue, currentValue);
+    maxValue = Math.max(maxValue, currentValue);
+    // 최대값과 최소값의 차이가 기존의 범위 크기 보다 크다면 `hidden`은 존재할 수 없다.
+    if (maxValue - minValue > rangeSize) {
+      return 0;
+    }
+  }
+
+  // 기존의 범위 내에서 시작점을 이동시킬 수 있는 범위의 크기
+  return rangeSize - (maxValue - minValue) + 1;
+}

solution/src/leetcode/2145/2145.ts

@@ -0,0 +1,8 @@
+{
+  "id": "2145",
+  "url": "https://leetcode.com/problems/count-the-hidden-sequences",
+  "title": "Count the Hidden Sequences",
+  "category": "Algorithms",
+  "difficulty": "Medium",
+  "tags": ["Array", "Prefix Sum"]
+}

solution/src/leetcode/2145/meta.json

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

solution/src/leetcode/2338/2338.test.ts

@@ -0,0 +1,79 @@
+/**
+ * 2338. Count the Number of Ideal Arrays
+ * https://leetcode.com/problems/count-the-number-of-ideal-arrays
+ */
+export function idealArrays(n: number, maxValue: number): number {
+  const MOD = 10 ** 9 + 7;
+
+  /**
+   * 점점 증가하는 이상적인 배열의 최대 길이는 14입니다.
+   * 2^14 > 10,000 가능한 가장 긴 점점 증가하는 이상적 배열은 [1, 2, 4, 8, ..., 8192]입니다.
+   */
+  const MAX_LEN = Math.min(n, 14);
+
+  // dp[i][j]는 길이 i의 j로 끝나는 이상적인 배열의 개수
+  const dp = Array.from({ length: MAX_LEN + 1 }, () => new Array<number>(maxValue + 1).fill(0));
+
+  // `maxValue`까지 모든 수에 대한 약수
+  const divisors = getDivisors(maxValue);
+
+  // 길이가 1인 이상적인 배열의 개수는 1로 초기화합니다.
+  for (let i = 1; i <= maxValue; i++) {
+    dp[1][i] = 1;
+  }
+
+  /**
+   * dp[i][j] = sum(dp[i-1][k])
+   * 단, j는 k로 나누어 떨어져야 함 (즉, k는 j의 약수)
+   */
+  for (let i = 2; i <= MAX_LEN; i++) {
+    for (let j = 1; j <= maxValue; j++) {
+      for (const k of divisors.get(j) ?? []) {
+        dp[i][j] = (dp[i][j] + dp[i - 1][k]) % MOD;
+      }
+    }
+  }
+
+  // dp[i][0] = 길이가 i인 점점 증가하는 이상적인 배열의 개수
+  for (let i = 1; i <= MAX_LEN; i++) {
+    for (let j = 1; j <= maxValue; j++) {
+      dp[i][0] = (dp[i][0] + dp[i][j]) % MOD;
+    }
+  }
+
+  /**
+   * 조합론을 사용한, 길이가 i인 점점 증가하는 이상적인 배열의 개수로부터
+   * 길이가 n인 증가하는 이상적인 배열의 총 개수를 도출
+   */
+  let answer = 0n;
+  for (let i = 1; i <= MAX_LEN; i++) {
+    answer += nCk(n - 1, i - 1) * BigInt(dp[i][0]);
+    answer %= BigInt(MOD);
+  }
+  return Number(answer);
+}
+
+// "n Choose k"를 계산
+function nCk(n: number, k: number): bigint {
+  let result = 1n;
+  for (let i = 1; i <= k; i++) {
+    result = (result * BigInt(n - (i - 1))) / BigInt(i);
+  }
+  return result;
+}
+
+// `maxValue`까지의 모든 수에 대한 약수들을 계산
+function getDivisors(maxValue: number): Map<number, number[]> {
+  const divisors = new Map<number, number[]>();
+  for (let value = 1; value <= maxValue; value++) {
+    divisors.set(value, []);
+  }
+  for (let value = 1; value <= maxValue; value++) {
+    let multiply = 2;
+    while (value * multiply <= maxValue) {
+      divisors.get(value * multiply)?.push(value);
+      multiply += 1;
+    }
+  }
+  return divisors;
+}

solution/src/leetcode/2338/2338.ts

@@ -0,0 +1,8 @@
+{
+  "id": "2338",
+  "url": "https://leetcode.com/problems/count-the-number-of-ideal-arrays",
+  "title": "Count the Number of Ideal Arrays",
+  "category": "Algorithms",
+  "difficulty": "Hard",
+  "tags": ["Math", "Dynamic Programming", "Combinatorics", "Number Theory"]
+}

solution/src/leetcode/2338/meta.json

@@ -3,23 +3,26 @@
  * https://leetcode.com/problems/count-subarrays-with-fixed-bounds
  */
 export function countSubarrays(nums: number[], minK: number, maxK: number): number {
-  let answer = 0;
+  const n = nums.length;
 
-  let minIndex = -1;
-  let maxIndex = -1;
-  let outIndex = -1;
-  nums.forEach((num, i) => {
-    if (num < minK || maxK < num) {
-      outIndex = i;
+  let answer = 0;
+  let start = 0;
+  let lastMinIndex = -1;
+  let lastMaxIndex = -1;
+  for (let i = 0; i < n; i++) {
+    const num = nums[i];
+    if (num < minK || num > maxK) {
+      start = i + 1;
+    }
+    if (num === maxK) {
+      lastMaxIndex = i;
     }
     if (num === minK) {
-      minIndex = i;
+      lastMinIndex = i;
     }
-    if (num === maxK) {
-      maxIndex = i;
+    if (start <= lastMinIndex && start <= lastMaxIndex) {
+      answer += Math.min(lastMinIndex, lastMaxIndex) - start + 1;
     }
-    answer += Math.max(0, Math.min(minIndex, maxIndex) - outIndex);
-  });
-
+  }
   return answer;
 }

solution/src/leetcode/2444/2444.ts

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