Added tasks 61-100

Author: javadev

LeetCodeNet/G0001_0100/S0061_rotate_list/readme.md

@@ -0,0 +1,76 @@
+[![](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)
+
+## 61\. Rotate List
+
+Medium
+
+Given the `head` of a linked list, rotate the list to the right by `k` places.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/11/13/rotate1.jpg)
+
+**Input:** head = [1,2,3,4,5], k = 2
+
+**Output:** [4,5,1,2,3] 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/11/13/roate2.jpg)
+
+**Input:** head = [0,1,2], k = 4
+
+**Output:** [2,0,1] 
+
+**Constraints:**
+
+*   The number of nodes in the list is in the range `[0, 500]`.
+*   `-100 <= Node.val <= 100`
+*   <code>0 <= k <= 2 * 10<sup>9</sup></code>
+
+## Solution
+
+```csharp
+using LeetCodeNet.Com_github_leetcode;
+
+/**
+    * Definition for singly-linked list.
+    * public class ListNode {
+    *     public int val;
+    *     public ListNode next;
+    *     public ListNode(int val=0, ListNode next=null) {
+    *         this.val = val;
+    *         this.next = next;
+    *     }
+    * }
+    */
+public class Solution {
+    public ListNode RotateRight(ListNode head, int k) {
+        if (head == null || head.next == null || k == 0) {
+            return head;
+        }
+        // Compute the length
+        int len = 1;
+        ListNode tail = head;
+        while (tail.next != null) {
+            tail = tail.next;
+            len++;
+        }
+        k = k % len;
+        if (k == 0) {
+            return head;
+        }
+        // Make it a circle
+        tail.next = head;
+        // Find new tail: (len - k - 1)th node
+        ListNode newTail = head;
+        for (int i = 0; i < len - k - 1; i++) {
+            newTail = newTail.next;
+        }
+        ListNode newHead = newTail.next;
+        newTail.next = null;
+        return newHead;
+    }
+}
+```

LeetCodeNet/G0001_0100/S0063_unique_paths_ii/readme.md

@@ -0,0 +1,63 @@
+[![](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)
+
+## 63\. Unique Paths II
+
+Medium
+
+A robot is located at the top-left corner of a `m x n` grid (marked 'Start' in the diagram below).
+
+The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked 'Finish' in the diagram below).
+
+Now consider if some obstacles are added to the grids. How many unique paths would there be?
+
+An obstacle and space is marked as `1` and `0` respectively in the grid.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/11/04/robot1.jpg)
+
+**Input:** obstacleGrid = \[\[0,0,0],[0,1,0],[0,0,0]]
+
+**Output:** 2
+
+**Explanation:** There is one obstacle in the middle of the 3x3 grid above. There are two ways to reach the bottom-right corner: 1. Right -> Right -> Down -> Down 2. Down -> Down -> Right -> Right 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/11/04/robot2.jpg)
+
+**Input:** obstacleGrid = \[\[0,1],[0,0]]
+
+**Output:** 1 
+
+**Constraints:**
+
+*   `m == obstacleGrid.length`
+*   `n == obstacleGrid[i].length`
+*   `1 <= m, n <= 100`
+*   `obstacleGrid[i][j]` is `0` or `1`.
+
+## Solution
+
+```csharp
+public class Solution {
+    public int UniquePathsWithObstacles(int[][] obstacleGrid) {
+        int m = obstacleGrid.Length;
+        int  n = obstacleGrid[0].Length;
+        int[,] dp = new int[m, n];
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                if (obstacleGrid[i][j] == 1) {
+                    dp[i, j] = 0;
+                } else if (i == 0 && j == 0) {
+                    dp[i, j] = 1;
+                } else {
+                    dp[i, j] = (i > 0 ? dp[i - 1, j] : 0) + (j > 0 ? dp[i, j - 1] : 0);
+                }
+            }
+        }
+        return dp[m - 1, n - 1];
+    }
+}
+```

LeetCodeNet/G0001_0100/S0066_plus_one/readme.md

@@ -0,0 +1,67 @@
+[![](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)
+
+## 66\. Plus One
+
+Easy
+
+You are given a **large integer** represented as an integer array `digits`, where each `digits[i]` is the `ith` digit of the integer. The digits are ordered from most significant to least significant in left-to-right order. The large integer does not contain any leading `0`'s.
+
+Increment the large integer by one and return _the resulting array of digits_.
+
+**Example 1:**
+
+**Input:** digits = [1,2,3]
+
+**Output:** [1,2,4]
+
+**Explanation:** The array represents the integer 123. Incrementing by one gives 123 + 1 = 124. Thus, the result should be [1,2,4]. 
+
+**Example 2:**
+
+**Input:** digits = [4,3,2,1]
+
+**Output:** [4,3,2,2]
+
+**Explanation:** The array represents the integer 4321. Incrementing by one gives 4321 + 1 = 4322. Thus, the result should be [4,3,2,2]. 
+
+**Example 3:**
+
+**Input:** digits = [0]
+
+**Output:** [1]
+
+**Explanation:** The array represents the integer 0. Incrementing by one gives 0 + 1 = 1. Thus, the result should be [1]. 
+
+**Example 4:**
+
+**Input:** digits = [9]
+
+**Output:** [1,0]
+
+**Explanation:** The array represents the integer 9. Incrementing by one gives 9 + 1 = 10. Thus, the result should be [1,0]. 
+
+**Constraints:**
+
+*   `1 <= digits.length <= 100`
+*   `0 <= digits[i] <= 9`
+*   `digits` does not contain any leading `0`'s.
+
+## Solution
+
+```csharp
+public class Solution {
+    public int[] PlusOne(int[] digits) {
+        for (int i = digits.Length - 1; i >= 0; i--) {
+            if (digits[i] < 9) {
+                digits[i]++;
+                return digits;
+            }
+            digits[i] = 0;
+        }
+        int[] res = new int[digits.Length + 1];
+        res[0] = 1;
+        return res;
+    }
+}
+```

LeetCodeNet/G0001_0100/S0067_add_binary/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)
+
+## 67\. Add Binary
+
+Easy
+
+Given two binary strings `a` and `b`, return _their sum as a binary string_.
+
+**Example 1:**
+
+**Input:** a = "11", b = "1"
+
+**Output:** "100" 
+
+**Example 2:**
+
+**Input:** a = "1010", b = "1011"
+
+**Output:** "10101" 
+
+**Constraints:**
+
+*   <code>1 <= a.length, b.length <= 10<sup>4</sup></code>
+*   `a` and `b` consist only of `'0'` or `'1'` characters.
+*   Each string does not contain leading zeros except for the zero itself.
+
+## Solution
+
+```csharp
+public class Solution {
+    public string AddBinary(string a, string b) {
+        var sb = new System.Text.StringBuilder();
+        int i = a.Length - 1; 
+        int j = b.Length - 1; 
+        int carry = 0;
+        while (i >= 0 || j >= 0 || carry > 0) {
+            int sum = carry;
+            if (i >= 0) {
+                sum += a[i--] - '0';
+            }
+            if (j >= 0) {
+                sum += b[j--] - '0';
+            }
+            sb.Insert(0, (char)('0' + (sum % 2)));
+            carry = sum / 2;
+        }
+        return sb.ToString();
+    }
+}
+```

LeetCodeNet/G0001_0100/S0068_text_justification/readme.md

@@ -0,0 +1,91 @@
+[![](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)
+
+## 68\. Text Justification
+
+Hard
+
+Given an array of strings `words` and a width `maxWidth`, format the text such that each line has exactly `maxWidth` characters and is fully (left and right) justified.
+
+You should pack your words in a greedy approach; that is, pack as many words as you can in each line. Pad extra spaces `' '` when necessary so that each line has exactly `maxWidth` characters.
+
+Extra spaces between words should be distributed as evenly as possible. If the number of spaces on a line does not divide evenly between words, the empty slots on the left will be assigned more spaces than the slots on the right.
+
+For the last line of text, it should be left-justified and no extra space is inserted between words.
+
+**Note:**
+
+*   A word is defined as a character sequence consisting of non-space characters only.
+*   Each word's length is guaranteed to be greater than 0 and not exceed maxWidth.
+*   The input array `words` contains at least one word.
+
+**Example 1:**
+
+**Input:** words = ["This", "is", "an", "example", "of", "text", "justification."], maxWidth = 16
+
+**Output:** [ "This is an", "example of text", "justification. " ]
+
+**Example 2:**
+
+**Input:** words = ["What","must","be","acknowledgment","shall","be"], maxWidth = 16
+
+**Output:** [ "What must be", "acknowledgment ", "shall be " ]
+
+**Explanation:** Note that the last line is "shall be " instead of "shall be", because the last line must be left-justified instead of fully-justified. Note that the second line is also left-justified becase it contains only one word.
+
+**Example 3:**
+
+**Input:** words = ["Science","is","what","we","understand","well","enough","to","explain","to","a","computer.","Art","is","everything","else","we","do"], maxWidth = 20
+
+**Output:** [ "Science is what we", "understand well", "enough to explain to", "a computer. Art is", "everything else we", "do " ]
+
+**Constraints:**
+
+*   `1 <= words.length <= 300`
+*   `1 <= words[i].length <= 20`
+*   `words[i]` consists of only English letters and symbols.
+*   `1 <= maxWidth <= 100`
+*   `words[i].length <= maxWidth`
+
+## Solution
+
+```csharp
+public class Solution {
+    public IList<string> FullJustify(string[] words, int maxWidth) {
+        var res = new List<string>();
+        int i = 0;
+        int n = words.Length;
+        while (i < n) {
+            int j = i, lineLen = 0;
+            while (j < n && lineLen + words[j].Length + (j - i) <= maxWidth) {
+                lineLen += words[j].Length;
+                j++;
+            }
+            int spaces = maxWidth - lineLen;
+            int gaps = j - i - 1;
+            var line = new System.Text.StringBuilder();
+            if (j == n || gaps == 0) {
+                for (int k = i; k < j; k++) {
+                    line.Append(words[k]);
+                    if (k < j - 1) {
+                        line.Append(' ');
+                    }
+                }
+                line.Append(' ', maxWidth - line.Length);
+            } else {
+                int spaceEach = spaces / gaps;
+                int extra = spaces % gaps;
+                for (int k = i; k < j; k++) {
+                    line.Append(words[k]);
+                    if (k < j - 1) {
+                        line.Append(' ', spaceEach + (k - i < extra ? 1 : 0));
+                    }
+                }
+            }
+            res.Add(line.ToString());
+            i = j;
+        }
+        return res;
+    }
+}
+```