Add solution #2030

Author: JoshCrozier

README.md

@@ -1,4 +1,4 @@
-# 1,697 LeetCode solutions in JavaScript
+# 1,698 LeetCode solutions in JavaScript
 
 [https://leetcodejavascript.com](https://leetcodejavascript.com)
 
@@ -1557,6 +1557,7 @@
 2027|[Minimum Moves to Convert String](./solutions/2027-minimum-moves-to-convert-string.js)|Easy|
 2028|[Find Missing Observations](./solutions/2028-find-missing-observations.js)|Medium|
 2029|[Stone Game IX](./solutions/2029-stone-game-ix.js)|Medium|
+2030|[Smallest K-Length Subsequence With Occurrences of a Letter](./solutions/2030-smallest-k-length-subsequence-with-occurrences-of-a-letter.js)|Hard|
 2033|[Minimum Operations to Make a Uni-Value Grid](./solutions/2033-minimum-operations-to-make-a-uni-value-grid.js)|Medium|
 2037|[Minimum Number of Moves to Seat Everyone](./solutions/2037-minimum-number-of-moves-to-seat-everyone.js)|Easy|
 2047|[Number of Valid Words in a Sentence](./solutions/2047-number-of-valid-words-in-a-sentence.js)|Easy|

solutions/2030-smallest-k-length-subsequence-with-occurrences-of-a-letter.js

@@ -0,0 +1,83 @@
+/**
+ * 2030. Smallest K-Length Subsequence With Occurrences of a Letter
+ * https://leetcode.com/problems/smallest-k-length-subsequence-with-occurrences-of-a-letter/
+ * Difficulty: Hard
+ *
+ * You are given a string s, an integer k, a letter letter, and an integer repetition.
+ *
+ * Return the lexicographically smallest subsequence of s of length k that has the letter
+ * letter appear at least repetition times. The test cases are generated so that the letter
+ * appears in s at least repetition times.
+ *
+ * A subsequence is a string that can be derived from another string by deleting some or no
+ * characters without changing the order of the remaining characters.
+ *
+ * A string a is lexicographically smaller than a string b if in the first position where a
+ * and b differ, string a has a letter that appears earlier in the alphabet than the
+ * corresponding letter in b.
+ */
+
+/**
+ * @param {string} s
+ * @param {number} k
+ * @param {character} letter
+ * @param {number} repetition
+ * @return {string}
+ */
+var smallestSubsequence = function(s, k, letter, repetition) {
+  const n = s.length;
+  let letterTotal = 0;
+  for (let i = 0; i < n; i++) {
+    if (s[i] === letter) letterTotal++;
+  }
+
+  const stack = [];
+  let stackLetterCount = 0;
+  let remainingCount = letterTotal;
+
+  for (let i = 0; i < n; i++) {
+    const char = s[i];
+
+    if (char === letter) {
+      remainingCount--;
+    }
+
+    while (
+      stack.length > 0 && stack[stack.length - 1] > char && stack.length - 1 + (n - i) >= k
+      && (stack[stack.length - 1] !== letter || stackLetterCount + remainingCount > repetition)
+    ) {
+      if (stack[stack.length - 1] === letter) {
+        stackLetterCount--;
+      }
+      stack.pop();
+    }
+
+    if (stack.length < k) {
+      if (char === letter) {
+        stackLetterCount++;
+      }
+
+      const neededLetters = repetition - stackLetterCount;
+      const remainingPositions = k - stack.length - 1;
+      if (char === letter || remainingPositions >= neededLetters) {
+        stack.push(char);
+      }
+    }
+  }
+
+  if (stackLetterCount < repetition) {
+    let missingLetters = repetition - stackLetterCount;
+    const result = [...stack];
+
+    for (let i = k - 1; i >= 0 && missingLetters > 0; i--) {
+      if (result[i] !== letter) {
+        result[i] = letter;
+        missingLetters--;
+      }
+    }
+
+    return result.join('');
+  }
+
+  return stack.join('');
+};