Merge branch 'main' into main

Author: ajay-dhangar

dsa-problems/leetcode-problems/0900-0999.md

@@ -99,7 +99,7 @@ export const problems = [
         problemName: "914. X of a Kind in a Deck of Cards",
         difficulty: "Easy",
         leetCodeLink: "https://leetcode.com/problems/x-of-a-kind-in-a-deck-of-cards",
-        solutionLink: "#"
+        solutionLink: "/dsa-solutions/lc-solutions/0900-0999/x-of-a-kind-in-a-deck-of-cards"
     },
     {
         problemName: "915. Partition Array into Disjoint Intervals",

dsa-solutions/lc-solutions/0000-0099/0060-permutation-sequence.md

@@ -0,0 +1,119 @@
+---
+id: permutation-sequence
+title: Permutation Sequence(LeetCode)
+sidebar_label: 0060-Permutation Sequence
+tags:
+  - Math
+  - Recursion
+description: The set [1, 2, 3, ..., n] contains a total of n! unique permutations. Given n and k, return the kth permutation sequence.
+---
+
+## Problem Statement
+
+The set `[1, 2, 3, ..., n]` contains a total of `n!` unique permutations.
+
+By listing and labeling all of the permutations in order, we get the following sequence for `n = 3`:
+
+1. `"123"`
+2. `"132"`
+3. `"213"`
+4. `"231"`
+5. `"312"`
+6. `"321"`
+Given `n` and `k`, return the `kth` permutation sequence.
+
+### Examples
+
+**Example 1:**
+
+```plaintext
+Input: n = 3, k = 3
+Output: "213"
+```
+
+**Example 2:**
+
+```plaintext
+Input: n = 4, k = 9
+Output: "2314"
+```
+
+**Example 3:**
+
+```plaintext
+Input: n = 3, k = 1
+Output: "123"
+```
+
+### Constraints
+
+- `1 <= n <= 9`
+- `1 <= k <= n!`
+
+## Solution
+
+### Approach
+
+#### Algorithm
+
+1. Initialize Factorial Values:
+* Precompute and store the factorial values of integers from 0 to 9 in a vector `factVal` to get factorials in O(1) time.
+2. Initialize Array:
+* Create a vector `v` containing elements from 1 to `n`.
+3. Recursive Function `setPerm`:
+* Base Case: If `n == 1`, append the last remaining element in `v` to `ans` and return.
+* Calculate the required index using `k / factVal[n-1]`.
+* Handle the corner case where if `k` is a multiple of `(n-1)!`, decrement the index by 1.
+* Append the element at the calculated index from `v` to `ans`.
+* Remove the selected element from `v`.
+* Adjust the value of `k` to be the remainder after dividing by `factVal[n-1]`.
+* Make a recursive call with updated values of `n`, `k`, `v`, and `ans`.
+4. Construct Result:
+* Initialize an empty string `ans`.
+* Call the recursive function setPerm with initial values of `v`, `ans`, `n`, `k`, and `factVal`.
+* Return the result `ans`.
+
+#### Implementation
+
+```C++
+class Solution {
+public:
+    void setPerm(vector<int>& v, string& ans, int n, int k, vector<int>& factVal) {
+        if (n == 1) {
+            ans += to_string(v.back());
+            return;
+        }
+        
+        int index = (k / factVal[n-1]);
+        if (k % factVal[n-1] == 0) {
+            index--;
+        }
+        
+        ans += to_string(v[index]);
+        v.erase(v.begin() + index);
+        k -= factVal[n-1] * index;
+        setPerm(v, ans, n-1, k, factVal);
+    }
+    
+    string getPermutation(int n, int k) {
+        if (n == 1) return "1";
+        
+        vector<int> factVal = {1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880};
+        string ans = "";
+        vector<int> v;
+        for (int i = 1; i <= n; i++) v.emplace_back(i);
+        
+        setPerm(v, ans, n, k, factVal);
+        return ans;
+    }
+};
+```
+
+### Complexity Analysis
+
+- **Time complexity**: $O(N^2)$
+- **Space complexity**: $O(N)$
+
+### Conclusion
+
+This algorithm efficiently finds the k-th permutation of a set of n elements by using a combination of precomputed factorials and recursive selection. The approach ensures that the computation is done in a systematic manner without generating all permutations.

dsa-solutions/lc-solutions/0000-0099/0076-minimum-window-substring.md

@@ -0,0 +1,168 @@
+---
+id: minimum-window-substring
+title: Minimum Window Substring(LeetCode)
+sidebar_label: 0076-Minimum Window Substring
+tags:
+  - String
+  - Hash Table
+  - Sliding Window
+description: Given two strings s and t of lengths m and n respectively, return the minimum window substring of s such that every character in t (including duplicates) is included in the window. If there is no such substring, return the empty string "".
+---
+
+## Problem Statement
+
+Given two strings `s` and `t` of lengths `m` and `n` respectively, return the minimum window substring of `s` such that every character in `t` (including duplicates) is included in the window. If there is no such substring, return the empty string `""`.
+
+The testcases will be generated such that the answer is unique.
+
+### Examples
+
+**Example 1:**
+
+```plaintext
+Input: s = "ADOBECODEBANC", t = "ABC"
+Output: "BANC"
+Explanation: The minimum window substring "BANC" includes 'A', 'B', and 'C' from string t.
+```
+
+**Example 2:**
+
+```plaintext
+Input: s = "a", t = "a"
+Output: "a"
+Explanation: The entire string s is the minimum window.
+```
+
+**Example 3:**
+
+```plaintext
+Input: s = "a", t = "aa"
+Output: ""
+Explanation: Both 'a's from t must be included in the window.
+Since the largest window of s only has one 'a', return empty string.
+```
+
+### Constraints
+
+- `m == s.length`
+- `n == t.length`
+- `1 <= m, n <= 105`
+- `s` and `t` consist of uppercase and lowercase English letters.
+
+## Solution
+
+### Approach 1: C++
+
+#### Algorithm
+
+1. Initialization:
+* Create a `map` to count characters in `t`.
+* Initialize `counter` to the length of `t`, begin and end pointers to 0, `d` (length of the minimum window) to `INT_MAX`, and `head` to 0.
+2. Expand the Window:
+* Move the `end` pointer to expand the window.
+* Decrease the count in `map` for the current character in `s`.
+* If the count in `map` is greater than 0, decrement `counter`.
+3. Shrink the Window:
+* When `counter` is 0, try to shrink the window by moving the `begin` pointer.
+* If the new window size is smaller, update `head` and `d`.
+* Increase the count in `map` for the character at `begin`.
+* If the count in `map` becomes positive, increment `counter`.
+4. Return Result:
+* If `d` is still `INT_MAX`, return an empty string.
+* Otherwise, return the substring starting from `head` with length `d`.
+
+#### Implementation
+
+```C++
+class Solution {
+public:
+    string minWindow(string s, string t) {
+        vector<int> map(128, 0);
+        for (char c : t) {
+            map[c]++;
+        }
+
+        int counter = t.size(), begin = 0, end = 0, d = INT_MAX, head = 0;
+        while (end < s.size()) {
+            if (map[s[end++]]-- > 0) {
+                counter--;
+            }
+            while (counter == 0) {
+                if (end - begin < d) {
+                    head = begin;
+                    d = end - head;
+                }
+                if (map[s[begin++]]++ == 0) {
+                    counter++;
+                }
+            }
+        }
+        return d == INT_MAX ? "" : s.substr(head, d);
+    }
+};
+```
+
+### Complexity Analysis
+
+- **Time complexity**: $O(M+N)$
+- **Space complexity**: $O(1)$
+
+### Approach 2: Python
+
+#### Algorithm
+
+1. Initialization:
+* Create a `needstr` dictionary to count characters in `t`.
+* Initialize `needcnt` to the length of `t`, `res` to store the result window, and `start` to 0.
+2. Expand the Window:
+* Move the `end` pointer to expand the window.
+* Decrease the count in `needstr` for the current character in `s`.
+* If the count in `needstr` is greater than 0, decrement `needcnt`.
+3. Shrink the Window:
+* When `needcnt` is 0, try to shrink the window by moving the `start` pointer.
+* Adjust the count in `needstr` for the character at `start`.
+* If the count in `needstr` becomes positive, increment `needcnt`.
+4. Return Result:
+* If the result window is valid, return the substring.
+* Otherwise, return an empty string.
+  
+#### Implementation 
+
+```Python
+class Solution:
+    def minWindow(self, s: str, t: str) -> str:
+        if len(s) < len(t):
+            return ""
+        needstr = collections.defaultdict(int)
+        for ch in t:
+            needstr[ch] += 1
+        needcnt = len(t)
+        res = (0, float('inf'))
+        start = 0
+        for end, ch in enumerate(s):
+            if needstr[ch] > 0:
+                needcnt -= 1
+            needstr[ch] -= 1
+            if needcnt == 0:
+                while True:
+                    tmp = s[start]
+                    if needstr[tmp] == 0:
+                        break
+                    needstr[tmp] += 1
+                    start += 1
+                if end - start < res[1] - res[0]:
+                    res = (start, end)
+                needstr[s[start]] += 1
+                needcnt += 1
+                start += 1
+        return '' if res[1] > len(s) else s[res[0]:res[1]+1]
+```
+
+### Complexity Analysis
+
+- **Time complexity**: $O(M+N)$
+- **Space complexity**: $O(N)$
+
+### Conclusion
+
+The C++ and Python approaches for finding the minimum window substring are quite similar in their methodology. Both utilize the two-pointer technique, also known as the sliding window approach, to efficiently traverse the string s and dynamically adjust the window to find the smallest valid substring containing all characters of the string t. They maintain a character count map to keep track of the required characters from t and adjust the counts as the window expands and contracts. Additionally, both solutions use a counter variable to monitor the number of characters still needed to form a valid window.