Add solution #1223

Author: JoshCrozier

README.md

@@ -1,4 +1,4 @@
-# 1,185 LeetCode solutions in JavaScript
+# 1,186 LeetCode solutions in JavaScript
 
 [https://leetcodejavascript.com](https://leetcodejavascript.com)
 
@@ -939,6 +939,7 @@
 1219|[Path with Maximum Gold](./solutions/1219-path-with-maximum-gold.js)|Medium|
 1220|[Count Vowels Permutation](./solutions/1220-count-vowels-permutation.js)|Hard|
 1222|[Queens That Can Attack the King](./solutions/1222-queens-that-can-attack-the-king.js)|Medium|
+1223|[Dice Roll Simulation](./solutions/1223-dice-roll-simulation.js)|Hard|
 1232|[Check If It Is a Straight Line](./solutions/1232-check-if-it-is-a-straight-line.js)|Easy|
 1233|[Remove Sub-Folders from the Filesystem](./solutions/1233-remove-sub-folders-from-the-filesystem.js)|Medium|
 1249|[Minimum Remove to Make Valid Parentheses](./solutions/1249-minimum-remove-to-make-valid-parentheses.js)|Medium|

solutions/1223-dice-roll-simulation.js

@@ -0,0 +1,59 @@
+/**
+ * 1223. Dice Roll Simulation
+ * https://leetcode.com/problems/dice-roll-simulation/
+ * Difficulty: Hard
+ *
+ * A die simulator generates a random number from 1 to 6 for each roll. You introduced a constraint
+ * to the generator such that it cannot roll the number i more than rollMax[i] (1-indexed)
+ * consecutive times.
+ *
+ * Given an array of integers rollMax and an integer n, return the number of distinct sequences
+ * that can be obtained with exact n rolls. Since the answer may be too large, return it modulo
+ * 1e9 + 7.
+ *
+ * Two sequences are considered different if at least one element differs from each other.
+ */
+
+/**
+ * @param {number} n
+ * @param {number[]} rollMax
+ * @return {number}
+ */
+var dieSimulator = function(n, rollMax) {
+  const MOD = 1e9 + 7;
+  const faces = 6;
+
+  const dp = new Array(n + 1).fill().map(() => new Array(faces).fill(0));
+  for (let face = 0; face < faces; face++) {
+    dp[1][face] = 1;
+  }
+
+  for (let rolls = 2; rolls <= n; rolls++) {
+    for (let face = 0; face < faces; face++) {
+      const maxConsecutive = Math.min(rolls, rollMax[face]);
+      let sequences = 0;
+
+      for (let streak = 1; streak <= maxConsecutive; streak++) {
+        if (streak === rolls) {
+          sequences = (sequences + 1) % MOD;
+        } else {
+          let prevCombinations = 0;
+          for (let prevFace = 0; prevFace < faces; prevFace++) {
+            if (prevFace !== face) {
+              prevCombinations = (prevCombinations + dp[rolls - streak][prevFace]) % MOD;
+            }
+          }
+          sequences = (sequences + prevCombinations) % MOD;
+        }
+      }
+      dp[rolls][face] = sequences;
+    }
+  }
+
+  let result = 0;
+  for (let face = 0; face < faces; face++) {
+    result = (result + dp[n][face]) % MOD;
+  }
+
+  return result;
+};