2025년 15주차 문제 풀이 (#40)

## 문제 풀이 목록

- [LeetCode 416. Partition Equal Subset
Sum](https://leetcode.com/problems/partition-equal-subset-sum) ✨
- [LeetCode 3396. Minimum Number of Operations to Make Elements in Array
Distinct](https://leetcode.com/problems/minimum-number-of-operations-to-make-elements-in-array-distinct)
- [LeetCode 3375. Minimum Operations to Make Array Values Equal to
K](https://leetcode.com/problems/minimum-operations-to-make-array-values-equal-to-k)
- [LeetCode 2999. Count the Number of Powerful
Integers](https://leetcode.com/problems/count-the-number-of-powerful-integers)
✨
- [LeetCode 2843. Count Symmetric
Integers](https://leetcode.com/problems/count-symmetric-integers)
- [LeetCode 3272. Find the Count of Good
Integers](https://leetcode.com/problems/find-the-count-of-good-integers)
:sparkles:
- [LeetCode 1922. Count Good
Numbers](https://leetcode.com/problems/count-good-numbers) ✨

Author: sangrimlee

solution/README.md

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

solution/src/leetcode/0416/0416.test.ts

@@ -0,0 +1,23 @@
+/**
+ * 416. Partition Equal Subset Sum
+ * https://leetcode.com/problems/partition-equal-subset-sum
+ */
+export function canPartition(nums: number[]): boolean {
+  const totalSum = nums.reduce((acc, num) => acc + num, 0);
+  if (totalSum % 2 !== 0) {
+    return false;
+  }
+
+  const targetSum = totalSum / 2;
+  const dp = new Array<boolean>(targetSum + 1).fill(false);
+  dp[0] = true;
+  for (const num of nums) {
+    for (let sum = targetSum; sum >= num; sum--) {
+      dp[sum] = dp[sum] || dp[sum - num];
+      if (dp[targetSum]) {
+        return true;
+      }
+    }
+  }
+  return dp[targetSum];
+}

solution/src/leetcode/0416/0416.ts

@@ -0,0 +1,8 @@
+{
+  "id": "416",
+  "url": "https://leetcode.com/problems/partition-equal-subset-sum",
+  "title": "Partition Equal Subset Sum",
+  "category": "Algorithms",
+  "difficulty": "Medium",
+  "tags": ["Array", "Dynamic Programming"]
+}

solution/src/leetcode/0416/meta.json

@@ -0,0 +1,13 @@
+import { countGoodNumbers } from './1922';
+
+describe('LeetCode 1922', () => {
+  test('Example 1', () => {
+    expect(countGoodNumbers(1)).toBe(5);
+  });
+  test('Example 2', () => {
+    expect(countGoodNumbers(4)).toBe(400);
+  });
+  test('Example 3', () => {
+    expect(countGoodNumbers(50)).toBe(564908303);
+  });
+});

solution/src/leetcode/1922/1922.test.ts

@@ -0,0 +1,24 @@
+/**
+ * 1922. Count Good Numbers
+ * https://leetcode.com/problems/count-good-numbers
+ */
+export function countGoodNumbers(n: number): number {
+  const MOD = BigInt(10 ** 9 + 7);
+
+  function pow(x: bigint, y: bigint): bigint {
+    let result = 1n;
+    let [base, exponent] = [x, y];
+    while (exponent > 0) {
+      if (exponent % 2n === 1n) {
+        result = (result * base) % MOD;
+      }
+      base = (base * base) % MOD;
+      exponent = exponent / 2n;
+    }
+    return result;
+  }
+
+  const even = BigInt(Math.floor((n + 1) / 2));
+  const odd = BigInt(Math.floor(n / 2));
+  return Number((pow(5n, even) * pow(4n, odd)) % MOD);
+}

solution/src/leetcode/1922/1922.ts

@@ -0,0 +1,8 @@
+{
+  "id": "1922",
+  "url": "https://leetcode.com/problems/count-good-numbers",
+  "title": "Count Good Numbers",
+  "category": "Algorithms",
+  "difficulty": "Medium",
+  "tags": ["Math", "Recursion"]
+}

solution/src/leetcode/1922/meta.json

@@ -3,25 +3,26 @@
  * https://leetcode.com/problems/count-symmetric-integers
  */
 export function countSymmetricIntegers(low: number, high: number): number {
-  function isSymmetric(num: number) {
-    const str = num.toString();
-    const n = str.length;
-    if (n % 2 !== 0) {
-      return false;
-    }
-    let [leftSum, rightSum] = [0, 0];
-    for (let i = 0; i < Math.floor(n / 2); i++) {
-      leftSum += parseInt(str[i]);
-      rightSum += parseInt(str[n - i - 1]);
-    }
-    return leftSum === rightSum;
-  }
-
   let answer = 0;
   for (let num = low; num <= high; num++) {
-    if (isSymmetric(num)) {
+    if (isSymmetricInteger(num)) {
       answer += 1;
     }
   }
   return answer;
 }
+
+function isSymmetricInteger(num: number): boolean {
+  const s = num.toString();
+  if (s.length % 2 !== 0) {
+    return false;
+  }
+
+  const n = s.length / 2;
+  let [left, right] = [0, 0];
+  for (let i = 0; i < n; i++) {
+    left += parseInt(s[i]);
+    right += parseInt(s[s.length - i - 1]);
+  }
+  return left === right;
+}

solution/src/leetcode/2843/2843.ts

@@ -1,7 +1,7 @@
 {
   "id": "2843",
   "url": "https://leetcode.com/problems/count-symmetric-integers",
-  "title": "  Count Symmetric Integers",
+  "title": "Count Symmetric Integers",
   "category": "Algorithms",
   "difficulty": "Easy",
   "tags": ["Math", "Enumeration"]

solution/src/leetcode/2843/meta.json

@@ -0,0 +1,13 @@
+import { numberOfPowerfulInt } from './2999';
+
+describe('LeetCode 2999', () => {
+  test('Example 1', () => {
+    expect(numberOfPowerfulInt(1, 6000, 4, '124')).toBe(5);
+  });
+  test('Example 2', () => {
+    expect(numberOfPowerfulInt(15, 215, 6, '10')).toBe(2);
+  });
+  test('Example 3', () => {
+    expect(numberOfPowerfulInt(1000, 2000, 4, '3000')).toBe(0);
+  });
+});