Merge branch 'CodeHarborHub:main' into main

Aditi22Bansal · web-flow · commit f8ee4f1e7fc4 · 2024-06-21T15:43:06.000+05:30
diff --git a/dsa-problems/leetcode-problems/0000-0099.md b/dsa-problems/leetcode-problems/0000-0099.md
@@ -109,13 +109,13 @@ export const problems = [
 "problemName": "17. Letter Combinations of a Phone Number",
 "difficulty": "Medium",
 "leetCodeLink": "https://leetcode.com/problems/letter-combinations-of-a-phone-number/",
-"solutionLink": "/dsa-solutions/lc-solutions/0000-0099/four-sum"
+"solutionLink": "/dsa-solutions/lc-solutions/0000-0099/letter-combination"
 },
 {
 "problemName": "18. 4Sum",
 "difficulty": "Medium",
 "leetCodeLink": "https://leetcode.com/problems/4sum/",
-"solutionLink": "/dsa-solutions/lc-solutions/0000-0099/"
+"solutionLink": "/dsa-solutions/lc-solutions/0000-0099/four-sum"
 },
 {
 "problemName": "19. Remove Nth Node From End of List",
diff --git a/dsa-solutions/lc-solutions/0000-0099/0017-letter-combination.md b/dsa-solutions/lc-solutions/0000-0099/0017-letter-combination.md
@@ -0,0 +1,217 @@
+---
+id: letter-combination
+title: Letter Combinations of a Phone Number (LeetCode)
+sidebar_label: 0017 - letter-combination
+tags:
+  - Array
+  - Backtracking
+  - String
+description: "Given a string containing digits from 2-9 inclusive, return all possible letter combinations that the number could represent."
+---
+
+## Problem Description
+
+Given a string containing digits from 2-9 inclusive, return all possible letter combinations that the number could represent. Return the answer in any order.
+
+A mapping of digits to letters (just like on the telephone buttons) is given below. Note that 1 does not map to any letters.
+
+
+### Examples
+
+**Example 1:**
+
+```
+Input
+digits = "
+Output
+["ad","ae","af","bd","be","bf","cd","ce","cf"]
+
+```
+**Example 2:**
+
+```
+Input: digits = ""
+Output: []
+```
+**Example 3:**
+
+```
+Input: digits = "2"
+Output: ["a","b","c"]
+```
+### Constraints
+
+- `0 <= digits.length <= 4`
+- `digits[i] is a digit in the range ['2', '9']`
+
+
+## Solution for Letter combination of phone number
+
+### Intuition
+Using backtracking to create all possible combinations
+
+
+
+
+### Complexity Analysis
+
+#### Time Complexity: $O(3^n)$
+
+#### Space Complexity: $O(N)$
+
+
+## Approach
+
+- This is based on a Python solution. Other implementations might differ a bit.
+
+- Initialize an empty list `res` to store the generated combinations.
+
+- Check if the `digits` string is empty. If it is, return an empty list since there are no digits to process.
+
+- Create a dictionary `digit_to_letters` that maps each digit from '2' to '9' to the corresponding letters on a phone keypad.
+
+- Define a recursive function `backtrack(idx, comb)` that takes two parameters:
+  - `idx`: The current index of the digit being processed in the `digits` string.
+  - `comb`: The current combination being formed by appending letters.
+
+- Inside the `backtrack` function:
+  - Check if `idx` is equal to the length of the `digits` string. If it is, it means a valid combination has been formed, so append the current `comb` to the `res` list.
+  - If not, iterate through each letter corresponding to the digit at `digits[idx]` using the `digit_to_letters` dictionary.
+  - For each letter, recursively call `backtrack` with `idx + 1` to process the next digit and `comb + letter` to add the current letter to the combination.
+
+- Initialize the `res` list.
+
+- Start the initial call to `backtrack` with `idx` set to 0 and an empty string as `comb`. This will start the process of generating combinations.
+
+- After the recursive calls have been made, return the `res` list containing all the generated combinations.
+
+- The algorithm works by iteratively exploring all possible combinations of letters that can be formed from the given input digits. It uses a recursive approach to generate combinations, building them one letter at a time. The base case for the recursion is when all digits have been processed, at which point a combination is complete and added to the `res` list. The backtracking nature of the algorithm ensures that all possible combinations are explored.
+
+
+### Code in Different Languages
+
+<Tabs>
+<TabItem value="cpp" label="C++">
+  <SolutionAuthor name="@Shreyash3087"/>
+
+```cpp
+#include <vector>
+#include <algorithm>
+#include <climits>
+
+class Solution {
+public:
+    int cherryPickup(std::vector<std::vector<int>>& grid) {
+        int N = grid.size();
+        std::vector<std::vector<int>> dp(N, std::vector<int>(N, INT_MIN));
+        dp[0][0] = grid[0][0];
+
+        for (int t = 1; t <= 2 * N - 2; ++t) {
+            std::vector<std::vector<int>> dp2(N, std::vector<int>(N, INT_MIN));
+
+            for (int i = std::max(0, t - (N - 1)); i <= std::min(N - 1, t); ++i) {
+                for (int j = std::max(0, t - (N - 1)); j <= std::min(N - 1, t); ++j) {
+                    if (grid[i][t - i] == -1 || grid[j][t - j] == -1) {
+                        continue;
+                    }
+                    int val = grid[i][t - i];
+                    if (i != j) {
+                        val += grid[j][t - j];
+                    }
+                    for (int pi = i - 1; pi <= i; ++pi) {
+                        for (int pj = j - 1; pj <= j; ++pj) {
+                            if (pi >= 0 && pj >= 0) {
+                                dp2[i][j] = std::max(dp2[i][j], dp[pi][pj] + val);
+                            }
+                        }
+                    }
+                }
+            }
+            dp = std::move(dp2);
+        }
+        return std::max(0, dp[N - 1][N - 1]);
+    }
+};
+
+
+```
+</TabItem>
+<TabItem value="java" label="Java">
+  <SolutionAuthor name="@Shreyash3087"/>
+
+```java
+class Solution {
+    public int cherryPickup(int[][] grid) {
+        int N = grid.length;
+        int[][] dp = new int[N][N];
+        for (int[] row: dp) {
+            Arrays.fill(row, Integer.MIN_VALUE);
+        }
+        dp[0][0] = grid[0][0];
+
+        for (int t = 1; t <= 2*N - 2; ++t) {
+            int[][] dp2 = new int[N][N];
+            for (int[] row: dp2) {
+                Arrays.fill(row, Integer.MIN_VALUE);
+            }
+
+            for (int i = Math.max(0, t - (N - 1)); i <= Math.min(N - 1, t); ++i) {
+                for (int j = Math.max(0, t - (N - 1)); j <= Math.min(N - 1, t); ++j) {
+                    if (grid[i][t - i] == -1 || grid[j][t - j] == -1) {
+                        continue;
+                    }                    
+                    int val = grid[i][t-i];
+                    if (i != j) {
+                        val += grid[j][t - j];
+                    }
+                    for (int pi = i - 1; pi <= i; ++pi) {
+                        for (int pj = j - 1; pj <= j; ++pj) {
+                            if (pi >= 0 && pj >= 0) {
+                                dp2[i][j] = Math.max(dp2[i][j], dp[pi][pj] + val);
+                            }
+                        }
+                    }
+                }
+            }
+            dp = dp2;
+        }
+        return Math.max(0, dp[N - 1][N - 1]);
+    }
+}
+```
+
+</TabItem>
+<TabItem value="python" label="Python">
+  <SolutionAuthor name="@Shreyash3087"/>
+
+```python
+class Solution(object):
+    def cherryPickup(self, grid):
+        N = len(grid)
+        dp = [[float('-inf')] * N for _ in xrange(N)]
+        dp[0][0] = grid[0][0]
+        for t in xrange(1, 2 * N - 1):
+            dp2 = [[float('-inf')] * N for _ in xrange(N)]
+            for i in xrange(max(0, t - (N - 1)), min(N - 1, t) + 1):
+                for j in xrange(max(0, t - (N - 1)), min(N - 1, t) + 1):
+                    if grid[i][t - i] == -1 or grid[j][t - j] == -1:
+                        continue
+                    val = grid[i][t - i]
+                    if i != j:
+                        val += grid[j][t - j]
+                    dp2[i][j] = max(dp[pi][pj] + val
+                                    for pi in (i - 1, i) for pj in (j - 1, j)
+                                    if pi >= 0 and pj >= 0)
+            dp = dp2
+        return max(0, dp[N - 1][N - 1])
+```
+</TabItem>
+</Tabs>
+
+
+
+## References
+
+- **LeetCode Problem**: [Letter combinatino of Phone number](https://leetcode.com/problems/cherry-pickup/description/)
+
+- **Solution Link**: [letter combination of phone number](https://leetcode.com/problems/letter-combinations-of-a-phone-number/solutions/5125020/video-simple-solution/)
diff --git a/dsa-solutions/lc-solutions/0200-0299/0202-Happy-Numbers.md b/dsa-solutions/lc-solutions/0200-0299/0202-Happy-Numbers.md
@@ -0,0 +1,160 @@
+---
+id: Happy-Number
+title: Happy Number
+sidebar_label: Happy Number
+tags: 
+    - Math
+    - Hash Table
+    - Two Pointers
+---
+
+## Problem Description
+
+| Problem Statement                                       | Solution Link                                                              | LeetCode Profile                                        |
+| :------------------------------------------------------ | :------------------------------------------------------------------------- | :------------------------------------------------------ |
+| [Happy-Number](https://leetcode.com/problems/Happy-Number/description/) | [Happy-Number Solution on LeetCode](https://leetcode.com/problems/Happy-Number/solutions/) | [Nikita Saini](https://leetcode.com/u/Saini_Nikita/) |
+
+## Problem Description
+
+A happy number is a number defined by the following process:
+Starting with any positive integer, replace the number by the sum of the squares of its digits.
+Repeat the process until the number equals 1 (where it will stay), or it loops endlessly in a cycle which does not include 1.
+Those numbers for which this process ends in 1 are happy.
+
+Given a positive integer `n`, determine if it is a happy number.
+
+### Example 1:
+
+Input: `n = 19`
+Output: `true`
+Explanation:
+1^2 + 9^2 = 82
+8^2 + 2^2 = 68
+6^2 + 8^2 = 100
+1^2 + 0^2 + 0^2 = 1
+
+### Example 2:
+
+Input: `n = 2`
+Output: `false`
+Explanation:
+$2^2 = 4$
+$4^2 = 16$
+$1^2 + 6^2 = 37$
+$3^2 + 7^2 = 58$
+$5^2 + 8^2 = 89$
+$8^2 + 9^2 = 145$
+$1^2 + 4^2 + 5^2 = 42$
+$4^2 + 2^2 = 20$
+$2^2 + 0^2 = 4$ (cycle repeats endlessly)
+
+## Constraints
+
+- `1 <= n <= 2^31 - 1`
+
+## Approach
+
+To determine if a number `n` is a happy number:
+1. Use a set to keep track of numbers seen during the process to detect cycles.
+2. Repeat the process of replacing `n` by the sum of the squares of its digits until `n` becomes 1 or a cycle is detected (a number repeats).
+3. If `n` becomes 1, return true; otherwise, return false.
+
+## Solution in Python
+
+```python
+def isHappy(n: int) -> bool:
+    seen = set()
+    while n != 1 and n not in seen:
+        seen.add(n)
+        n = sum(int(digit)**2 for digit in str(n))
+    return n == 1
+```
+
+## Solution in Java
+```java
+import java.util.HashSet;
+import java.util.Set;
+
+class Solution {
+    public boolean isHappy(int n) {
+        Set<Integer> seen = new HashSet<>();
+        while (n != 1 && !seen.contains(n)) {
+            seen.add(n);
+            int sum = 0;
+            while (n > 0) {
+                int digit = n % 10;
+                sum += digit * digit;
+                n /= 10;
+            }
+            n = sum;
+        }
+        return n == 1;
+    }
+}
+```
+
+## Solution in C++
+```cpp
+class Solution {
+public:
+    bool isHappy(int n) {
+        unordered_set<int> seen;
+        while (n != 1 && seen.find(n) == seen.end()) {
+            seen.insert(n);
+            int sum = 0;
+            while (n > 0) {
+                int digit = n % 10;
+                sum += digit * digit;
+                n /= 10;
+            }
+            n = sum;
+        }
+        return n == 1;
+    }
+};
+```
+
+## Solution in C
+```c
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+bool isHappy(int n) {
+    int seen[1000] = {0};
+    while (n != 1 && !seen[n]) {
+        seen[n] = 1;
+        int sum = 0;
+        while (n > 0) {
+            int digit = n % 10;
+            sum += digit * digit;
+            n /= 10;
+        }
+        n = sum;
+    }
+    return n == 1;
+}
+```
+
+## Solution in JavaScript
+```js
+var isHappy = function(n) {
+    let seen = new Set();
+    while (n !== 1 && !seen.has(n)) {
+        seen.add(n);
+        n = String(n).split('').reduce((sum, digit) => sum + digit * digit, 0);
+    }
+    return n === 1;
+};
+```
+
+## Step-By_Step Algorithm
+1. Initialize an empty set `seen` to keep track of numbers encountered.
+2. While `n` is not 1 and `n` is not in `seen`:
+    - Add `n` to `seen`.
+    - Compute the sum of the squares of its digits for `n`.
+    - Update `n` to this computed sum.
+3. Check if `n` equals 1. If yes, return true (it is a happy number). If no, return false (it is not a happy number).
+
+## Conclusion
+The provided solutions use a similar approach to solve the happy number problem across different programming languages. They efficiently detect cycles and determine if a number eventually leads to 1 or loops endlessly. The use of a set ensures that the algorithm runs in linear time relative to the number of digits in `n`, making it suitable for the given constraints.
