Add solution #2818

Author: JoshCrozier

README.md

@@ -1,4 +1,4 @@
-# 1,050 LeetCode solutions in JavaScript
+# 1,051 LeetCode solutions in JavaScript
 
 [https://leetcode.com/](https://leetcode.com/)
 
@@ -1031,6 +1031,7 @@
 2726|[Calculator with Method Chaining](./solutions/2726-calculator-with-method-chaining.js)|Easy|
 2727|[Is Object Empty](./solutions/2727-is-object-empty.js)|Easy|
 2780|[Minimum Index of a Valid Split](./solutions/2780-minimum-index-of-a-valid-split.js)|Medium|
+2818|[Apply Operations to Maximize Score](./solutions/2818-apply-operations-to-maximize-score.js)|Hard|
 2948|[Make Lexicographically Smallest Array by Swapping Elements](./solutions/2948-make-lexicographically-smallest-array-by-swapping-elements.js)|Medium|
 2965|[Find Missing and Repeated Values](./solutions/2965-find-missing-and-repeated-values.js)|Easy|
 3042|[Count Prefix and Suffix Pairs I](./solutions/3042-count-prefix-and-suffix-pairs-i.js)|Easy|

solutions/2818-apply-operations-to-maximize-score.js

@@ -0,0 +1,94 @@
+/**
+ * 2818. Apply Operations to Maximize Score
+ * https://leetcode.com/problems/apply-operations-to-maximize-score/
+ * Difficulty: Hard
+ *
+ * You are given an array nums of n positive integers and an integer k.
+ *
+ * Initially, you start with a score of 1. You have to maximize your score by applying the following
+ * operation at most k times:
+ * - Choose any non-empty subarray nums[l, ..., r] that you haven't chosen previously.
+ * - Choose an element x of nums[l, ..., r] with the highest prime score. If multiple such elements
+ *   exist, choose the one with the smallest index.
+ * - Multiply your score by x.
+ *
+ * Here, nums[l, ..., r] denotes the subarray of nums starting at index l and ending at the index
+ * r, both ends being inclusive.
+ *
+ * The prime score of an integer x is equal to the number of distinct prime factors of x. For
+ * example, the prime score of 300 is 3 since 300 = 2 * 2 * 3 * 5 * 5.
+ *
+ * Return the maximum possible score after applying at most k operations.
+ *
+ * Since the answer may be large, return it modulo 109 + 7.
+ */
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var maximumScore = function(nums, k) {
+  const MOD = 1000000007n;
+  const MAX = 100000;
+  const powerCache = {};
+
+  const primeScores = new Array(MAX + 1).fill(0);
+  for (let prime = 2; prime <= MAX; prime++) {
+    if (primeScores[prime] > 0) continue;
+    for (let multiple = prime; multiple <= MAX; multiple += prime) {
+      primeScores[multiple]++;
+    }
+  }
+
+  const elements = nums.map(num => [num, primeScores[num], 1]);
+
+  const stack = [-1];
+  const n = elements.length;
+
+  for (let i = 0; i <= n; i++) {
+    while (
+      stack.length > 1 && (i === n || elements[stack[stack.length - 1]][1] < elements[i][1])
+    ) {
+      const current = stack.pop();
+      elements[current][2] = (i - current) * (current - stack[stack.length - 1]);
+    }
+
+    stack.push(i);
+  }
+
+  elements.sort((a, b) => b[0] - a[0]);
+
+  let result = 1n;
+  let remainingOps = k;
+
+  for (let i = 0; remainingOps > 0; i++) {
+    const usedOps = Math.min(remainingOps, elements[i][2]);
+    remainingOps -= usedOps;
+
+    const cacheKey = `${elements[i][0]},${usedOps}`;
+    let power;
+
+    if (cacheKey in powerCache) {
+      power = powerCache[cacheKey];
+    } else {
+      let base = BigInt(elements[i][0]);
+      let exp = usedOps;
+      power = 1n;
+
+      while (exp > 0) {
+        if (exp & 1) {
+          power = (power * base) % MOD;
+        }
+        exp >>= 1;
+        base = (base * base) % MOD;
+      }
+
+      powerCache[cacheKey] = power;
+    }
+
+    result = (result * power) % MOD;
+  }
+
+  return Number(result);
+};