add leetcode solutions ⚡

Author: MuhtasimTanmoy

leetcode/0384-shuffle-an-array/0384-shuffle-an-array.cpp

@@ -0,0 +1,22 @@
+class Solution {
+	vector<int> original;
+	int n;
+public:
+	Solution(vector<int>& nums) {
+		original = nums;
+		n = original.size();
+	}
+	
+	vector<int> reset() {
+		return original;
+	}
+	
+	vector<int> shuffle() {
+        vector<int> shuffled = original;
+        for (int i = n - 1, leftSize = n; i >= 0; i--, leftSize--) {
+            int j = rand() % leftSize;
+            swap(shuffled[i], shuffled[j]);
+        }
+        return shuffled;
+	}
+};

leetcode/0384-shuffle-an-array/NOTES.md

@@ -0,0 +1 @@
+​

leetcode/0384-shuffle-an-array/README.md

@@ -0,0 +1,39 @@
+<h2><a href="https://leetcode.com/problems/shuffle-an-array/">384. Shuffle an Array</a></h2><h3>Medium</h3><hr><div><p>Given an integer array <code>nums</code>, design an algorithm to randomly shuffle the array. All permutations of the array should be <strong>equally likely</strong> as a result of the shuffling.</p>
+
+<p>Implement the <code>Solution</code> class:</p>
+
+<ul>
+	<li><code>Solution(int[] nums)</code> Initializes the object with the integer array <code>nums</code>.</li>
+	<li><code>int[] reset()</code> Resets the array to its original configuration and returns it.</li>
+	<li><code>int[] shuffle()</code> Returns a random shuffling of the array.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input</strong>
+["Solution", "shuffle", "reset", "shuffle"]
+[[[1, 2, 3]], [], [], []]
+<strong>Output</strong>
+[null, [3, 1, 2], [1, 2, 3], [1, 3, 2]]
+
+<strong>Explanation</strong>
+Solution solution = new Solution([1, 2, 3]);
+solution.shuffle();    // Shuffle the array [1,2,3] and return its result.
+                       // Any permutation of [1,2,3] must be equally likely to be returned.
+                       // Example: return [3, 1, 2]
+solution.reset();      // Resets the array back to its original configuration [1,2,3]. Return [1, 2, 3]
+solution.shuffle();    // Returns the random shuffling of array [1,2,3]. Example: return [1, 3, 2]
+
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 50</code></li>
+	<li><code>-10<sup>6</sup> &lt;= nums[i] &lt;= 10<sup>6</sup></code></li>
+	<li>All the elements of <code>nums</code> are <strong>unique</strong>.</li>
+	<li>At most <code>10<sup>4</sup></code> calls <strong>in total</strong> will be made to <code>reset</code> and <code>shuffle</code>.</li>
+</ul>
+</div>

leetcode/0403-frog-jump/0403-frog-jump.cpp

@@ -0,0 +1,28 @@
+class Solution {
+public:
+    bool canCross(vector<int>& s) {
+        if (s[0] + 1 != s[1]) return false;
+        
+        int n = s.size() - 1;
+        unordered_map<string, bool> bag;
+        auto gen_key = [](auto l, auto ...r) {
+            return (to_string(l) + ... + ("-" + to_string(r)));
+        };
+        
+        function<bool(int, int, int)> go = [&](auto i, auto val, auto offset) {
+            if (val < s[i]) return false;
+            if ( i == n ) return val == s[i];
+            
+            auto key = gen_key(i, val, offset);
+            if (bag.count(key)) return bag[key];
+            
+            if (val > s[i]) return bag[key] = go(i + 1, val, offset);
+            auto paths = go(i + 1, val + offset, offset) 
+                      || go(i + 1, val + offset + 1, offset + 1)
+                      || go(i + 1, val + offset - 1, offset - 1);
+            return bag[key] = paths;
+        };
+        
+        return go(1, 1, 1);
+    }
+};

leetcode/0403-frog-jump/NOTES.md

@@ -0,0 +1 @@
+​

leetcode/0403-frog-jump/README.md

@@ -0,0 +1,31 @@
+<h2><a href="https://leetcode.com/problems/frog-jump/">403. Frog Jump</a></h2><h3>Hard</h3><hr><div><p>A frog is crossing a river. The river is divided into some number of units, and at each unit, there may or may not exist a stone. The frog can jump on a stone, but it must not jump into the water.</p>
+
+<p>Given a list of <code>stones</code>' positions (in units) in sorted <strong>ascending order</strong>, determine if the frog can cross the river by landing on the last stone. Initially, the frog is on the first stone and assumes the first jump must be <code>1</code> unit.</p>
+
+<p>If the frog's last jump was <code>k</code> units, its next jump must be either <code>k - 1</code>, <code>k</code>, or <code>k + 1</code> units. The frog can only jump in the forward direction.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> stones = [0,1,3,5,6,8,12,17]
+<strong>Output:</strong> true
+<strong>Explanation:</strong> The frog can jump to the last stone by jumping 1 unit to the 2nd stone, then 2 units to the 3rd stone, then 2 units to the 4th stone, then 3 units to the 6th stone, 4 units to the 7th stone, and 5 units to the 8th stone.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> stones = [0,1,2,3,4,8,9,11]
+<strong>Output:</strong> false
+<strong>Explanation:</strong> There is no way to jump to the last stone as the gap between the 5th and 6th stone is too large.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= stones.length &lt;= 2000</code></li>
+	<li><code>0 &lt;= stones[i] &lt;= 2<sup>31</sup> - 1</code></li>
+	<li><code>stones[0] == 0</code></li>
+	<li><code>stones</code>&nbsp;is sorted in a strictly increasing order.</li>
+</ul>
+</div>

leetcode/0423-reconstruct-original-digits-from-english/0423-reconstruct-original-digits-from-english.cpp

@@ -0,0 +1,21 @@
+class Solution {
+public:
+    string originalDigits(string s) {
+        vector<string> words = {"zero", "two", "four", "six", "eight", 
+                                "one", "three", "five", "seven", "nine"};
+        vector<int> nums = {0, 2, 4, 6, 8, 1, 3, 5, 7, 9};
+        vector<int> distinct_char = {'z', 'w', 'u', 'x', 'g', 'o', 'r', 'f', 'v', 'i'};
+        vector<int> counts(26, 0);
+        string result;
+        for (auto ch : s) counts[ch-'a']++;
+        for (int i = 0; i < 10; i++) {
+            int count = counts[distinct_char[i]-'a'];
+            for (int j = 0; j < words[i].size(); j++)
+                counts[words[i][j]-'a'] -= count;
+            while (count--)
+                result += to_string(nums[i]);
+        }
+        sort(result.begin(), result.end());
+        return result;
+    }
+};

leetcode/0423-reconstruct-original-digits-from-english/NOTES.md

@@ -0,0 +1 @@
+​

leetcode/0423-reconstruct-original-digits-from-english/README.md

@@ -0,0 +1,19 @@
+<h2><a href="https://leetcode.com/problems/reconstruct-original-digits-from-english/">423. Reconstruct Original Digits from English</a></h2><h3>Medium</h3><hr><div><p>Given a string <code>s</code> containing an out-of-order English representation of digits <code>0-9</code>, return <em>the digits in <strong>ascending</strong> order</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<pre><strong>Input:</strong> s = "owoztneoer"
+<strong>Output:</strong> "012"
+</pre><p><strong class="example">Example 2:</strong></p>
+<pre><strong>Input:</strong> s = "fviefuro"
+<strong>Output:</strong> "45"
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>s[i]</code> is one of the characters <code>["e","g","f","i","h","o","n","s","r","u","t","w","v","x","z"]</code>.</li>
+	<li><code>s</code> is <strong>guaranteed</strong> to be valid.</li>
+</ul>
+</div>

leetcode/0454-4sum-ii/0454-4sum-ii.cpp

@@ -0,0 +1,34 @@
+// Gets TLE
+/*
+class Solution {
+public:
+    int fourSumCount(vector<int>& one, 
+                     vector<int>& two, 
+                     vector<int>& three, 
+                     vector<int>& four, int res = 0) {
+        for (auto a: one)
+            for (auto b: two)
+                for (auto c: three)
+                    for (auto d: four)
+                        res += (a + b + c + d == 0);
+        return res;                    
+    }
+};
+*/
+
+class Solution {
+public:
+    int fourSumCount(vector<int>& one, 
+                     vector<int>& two, 
+                     vector<int>& three, 
+                     vector<int>& four, int res = 0) {
+        unordered_map<int,int> mp;
+        for (auto a: one)
+            for (auto b: two)
+                mp[a + b]++;
+        for (auto c: three)
+            for (auto d: four)
+               if (mp.count(0 - c - d)) res += mp[0 - c - d];
+        return res;               
+    }
+};