Added tasks 48-1143

Author: javadev

LeetCodeNet/G0001_0100/S0048_rotate_image/readme.md

@@ -0,0 +1,66 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Net/LeetCode-in-Net?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net)
+[![](https://img.shields.io/github/forks/LeetCode-in-Net/LeetCode-in-Net?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net/fork)
+
+## 48\. Rotate Image
+
+Medium
+
+You are given an `n x n` 2D `matrix` representing an image, rotate the image by **90** degrees (clockwise).
+
+You have to rotate the image [**in-place**](https://en.wikipedia.org/wiki/In-place_algorithm), which means you have to modify the input 2D matrix directly. **DO NOT** allocate another 2D matrix and do the rotation.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/08/28/mat1.jpg)
+
+**Input:** matrix = \[\[1,2,3],[4,5,6],[7,8,9]]
+
+**Output:** [[7,4,1],[8,5,2],[9,6,3]] 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/08/28/mat2.jpg)
+
+**Input:** matrix = \[\[5,1,9,11],[2,4,8,10],[13,3,6,7],[15,14,12,16]]
+
+**Output:** [[15,13,2,5],[14,3,4,1],[12,6,8,9],[16,7,10,11]] 
+
+**Example 3:**
+
+**Input:** matrix = \[\[1]]
+
+**Output:** [[1]] 
+
+**Example 4:**
+
+**Input:** matrix = \[\[1,2],[3,4]]
+
+**Output:** [[3,1],[4,2]] 
+
+**Constraints:**
+
+*   `matrix.length == n`
+*   `matrix[i].length == n`
+*   `1 <= n <= 20`
+*   `-1000 <= matrix[i][j] <= 1000`
+
+## Solution
+
+```csharp
+public class Solution {
+    public void Rotate(int[][] matrix) {
+        (int height, int width) = (matrix.Length, matrix[0].Length);
+        for (int row = 0; row < height - 1; row++) {
+            for (int col = row + 1; col < width; col++) {
+                (matrix[col][row], matrix[row][col]) = (matrix[row][col], matrix[col][row]);
+            }
+        }
+        for (int col = 0; col < width / 2; col++) {
+            int oppositeCol = width - 1 - col;
+            for (int row = 0; row < height; row++) {
+                (matrix[row][col], matrix[row][oppositeCol]) = (matrix[row][oppositeCol], matrix[row][col]);
+            }
+        }
+    }
+}
+```

LeetCodeNet/G0001_0100/S0049_group_anagrams/readme.md

@@ -0,0 +1,57 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Net/LeetCode-in-Net?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net)
+[![](https://img.shields.io/github/forks/LeetCode-in-Net/LeetCode-in-Net?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net/fork)
+
+## 49\. Group Anagrams
+
+Medium
+
+Given an array of strings `strs`, group **the anagrams** together. You can return the answer in **any order**.
+
+An **Anagram** is a word or phrase formed by rearranging the letters of a different word or phrase, typically using all the original letters exactly once.
+
+**Example 1:**
+
+**Input:** strs = ["eat","tea","tan","ate","nat","bat"]
+
+**Output:** [["bat"],["nat","tan"],["ate","eat","tea"]] 
+
+**Example 2:**
+
+**Input:** strs = [""]
+
+**Output:** [[""]] 
+
+**Example 3:**
+
+**Input:** strs = ["a"]
+
+**Output:** [["a"]] 
+
+**Constraints:**
+
+*   <code>1 <= strs.length <= 10<sup>4</sup></code>
+*   `0 <= strs[i].length <= 100`
+*   `strs[i]` consists of lowercase English letters.
+
+## Solution
+
+```csharp
+public class Solution {
+    public IList<IList<string>> GroupAnagrams(string[] strs) {
+        var map = new Dictionary<string, IList<string>>();
+        // allocate memory only once and reuse it to sort the chars of each s in strs.
+        var buffer = new char[10000];
+        var bufferSpan = new Span<char>(buffer);
+        foreach (var s in strs) {
+            s.CopyTo(bufferSpan);
+            Array.Sort(buffer, 0, s.Length);
+            var key = new string(buffer, 0, s.Length);
+            if (!map.TryGetValue(key, out var value)) {
+                map[key] = value = new List<string>();
+            }
+            value.Add(s);
+        }
+        return map.Values.Cast<IList<string>>().ToList();
+    }
+}
+```

LeetCodeNet/G0001_0100/S0051_n_queens/readme.md

@@ -0,0 +1,65 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Net/LeetCode-in-Net?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net)
+[![](https://img.shields.io/github/forks/LeetCode-in-Net/LeetCode-in-Net?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net/fork)
+
+## 51\. N-Queens
+
+Hard
+
+The **n-queens** puzzle is the problem of placing `n` queens on an `n x n` chessboard such that no two queens attack each other.
+
+Given an integer `n`, return _all distinct solutions to the **n-queens puzzle**_. You may return the answer in **any order**.
+
+Each solution contains a distinct board configuration of the n-queens' placement, where `'Q'` and `'.'` both indicate a queen and an empty space, respectively.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/11/13/queens.jpg)
+
+**Input:** n = 4
+
+**Output:** [[".Q..","...Q","Q...","..Q."],["..Q.","Q...","...Q",".Q.."]]
+
+**Explanation:** There exist two distinct solutions to the 4-queens puzzle as shown above 
+
+**Example 2:**
+
+**Input:** n = 1
+
+**Output:** [["Q"]] 
+
+**Constraints:**
+
+*   `1 <= n <= 9`
+
+## Solution
+
+```csharp
+public class Solution {
+    public IList<IList<string>> SolveNQueens(int n) {
+        return this.Backtrack(n, 0, (x, y) => false).ToList();
+    }
+
+    private IEnumerable<IList<string>> Backtrack(int boardSize, int y, Func<int, int, bool> check) {
+        for (int x = 0; x < boardSize; x++) {
+            if (check(x, y)) {
+                continue;
+            }
+            string currentLine = $"{new string('.', x)}Q{new string('.', boardSize - x - 1)}";
+            if (y == boardSize - 1) {
+                yield return new List<string> { currentLine };
+                continue;
+            }
+            var results = this.Backtrack(boardSize, y + 1, (xx, yy) =>
+                check(xx, yy) ||
+                (xx == x) ||
+                (yy == (y - x) + xx) ||
+                (yy == (x + y) - xx)
+            );
+            foreach (var result in results) {
+                result.Add(currentLine);
+                yield return result;
+            }
+        }
+    }
+}
+```

LeetCodeNet/G0001_0100/S0053_maximum_subarray/readme.md

@@ -0,0 +1,56 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Net/LeetCode-in-Net?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net)
+[![](https://img.shields.io/github/forks/LeetCode-in-Net/LeetCode-in-Net?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net/fork)
+
+## 53\. Maximum Subarray
+
+Easy
+
+Given an integer array `nums`, find the contiguous subarray (containing at least one number) which has the largest sum and return _its sum_.
+
+A **subarray** is a **contiguous** part of an array.
+
+**Example 1:**
+
+**Input:** nums = [-2,1,-3,4,-1,2,1,-5,4]
+
+**Output:** 6
+
+**Explanation:** [4,-1,2,1] has the largest sum = 6. 
+
+**Example 2:**
+
+**Input:** nums = [1]
+
+**Output:** 1 
+
+**Example 3:**
+
+**Input:** nums = [5,4,-1,7,8]
+
+**Output:** 23 
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>-10<sup>4</sup> <= nums[i] <= 10<sup>4</sup></code>
+
+**Follow up:** If you have figured out the `O(n)` solution, try coding another solution using the **divide and conquer** approach, which is more subtle.
+
+## Solution
+
+```csharp
+public class Solution {
+    public int MaxSubArray(int[] nums) {
+        int maxSum = nums[0];
+        int curSum = 0;
+        for (int i = 0; i < nums.Length; i++) {
+            curSum += nums[i];
+            maxSum = Math.Max(curSum, maxSum);
+            if (curSum < 0) {
+                curSum = 0;
+            }
+        }
+        return maxSum;
+    }
+}
+```

LeetCodeNet/G0001_0100/S0055_jump_game/readme.md

@@ -0,0 +1,51 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Net/LeetCode-in-Net?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net)
+[![](https://img.shields.io/github/forks/LeetCode-in-Net/LeetCode-in-Net?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net/fork)
+
+## 55\. Jump Game
+
+Medium
+
+You are given an integer array `nums`. You are initially positioned at the array's **first index**, and each element in the array represents your maximum jump length at that position.
+
+Return `true` _if you can reach the last index, or_ `false` _otherwise_.
+
+**Example 1:**
+
+**Input:** nums = [2,3,1,1,4]
+
+**Output:** true
+
+**Explanation:** Jump 1 step from index 0 to 1, then 3 steps to the last index. 
+
+**Example 2:**
+
+**Input:** nums = [3,2,1,0,4]
+
+**Output:** false
+
+**Explanation:** You will always arrive at index 3 no matter what. Its maximum jump length is 0, which makes it impossible to reach the last index. 
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>4</sup></code>
+*   <code>0 <= nums[i] <= 10<sup>5</sup></code>
+
+## Solution
+
+```csharp
+public class Solution {
+    public bool CanJump(int[] nums) {
+        var accumulatedJumps = 0;
+        for (var i = 0; i < nums.Length; i++) {
+            if (i > accumulatedJumps) {
+                return false;
+            }
+            if (accumulatedJumps >= nums.Length - 1) {
+                return true;
+            }
+            accumulatedJumps = Math.Max(accumulatedJumps, i + nums[i]);
+        }
+        return false;
+    }
+}
+```

LeetCodeNet/G0001_0100/S0056_merge_intervals/readme.md

@@ -0,0 +1,48 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Net/LeetCode-in-Net?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net)
+[![](https://img.shields.io/github/forks/LeetCode-in-Net/LeetCode-in-Net?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net/fork)
+
+## 56\. Merge Intervals
+
+Medium
+
+Given an array of `intervals` where <code>intervals[i] = [start<sub>i</sub>, end<sub>i</sub>]</code>, merge all overlapping intervals, and return _an array of the non-overlapping intervals that cover all the intervals in the input_.
+
+**Example 1:**
+
+**Input:** intervals = \[\[1,3],[2,6],[8,10],[15,18]]
+
+**Output:** [[1,6],[8,10],[15,18]]
+
+**Explanation:** Since intervals [1,3] and [2,6] overlaps, merge them into [1,6]. 
+
+**Example 2:**
+
+**Input:** intervals = \[\[1,4],[4,5]]
+
+**Output:** [[1,5]]
+
+**Explanation:** Intervals [1,4] and [4,5] are considered overlapping. 
+
+**Constraints:**
+
+*   <code>1 <= intervals.length <= 10<sup>4</sup></code>
+*   `intervals[i].length == 2`
+*   <code>0 <= start<sub>i</sub> <= end<sub>i</sub> <= 10<sup>4</sup></code>
+
+## Solution
+
+```csharp
+public class Solution {
+    public int[][] Merge(int[][] intervals) {
+        Array.Sort(intervals, (a, b) => a[0] - b[0]);
+        for (int i = 1; i < intervals.Length; i++) {
+            if (intervals[i][0] <= intervals[i - 1][1]) {
+                intervals[i][0] = intervals[i - 1][0];
+                intervals[i][1] = Math.Max(intervals[i - 1][1], intervals[i][1]);
+                intervals[i - 1][0] = -1;
+            }
+        }
+        return intervals.Where(obj => obj[0] != -1).ToArray();
+    }
+}
+```