clean up

Author: shreymehul

66.PlusOne.cs

@@ -1,7 +1,44 @@
 // 66. Plus One    
-// 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.
+// 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 = [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].
+
+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[] result = new int[digits.Length + 1];
+        result[0] = 1;
+        return result;
+    }
+}
+
+
 public class Solution {
     public int[] PlusOne(int[] digits) {
         for (int i= digits.Length-1;i>=0;i--){

73.SetZeroes.cs

@@ -1,15 +1,12 @@
 // 73. Set Matrix Zeroes
 
 // Given an m x n integer matrix matrix, if an element is 0, set its entire row and column to 0's.
-
 // You must do it in place.
 
 // Example 1:
-
 // Input: matrix = [[1,1,1],[1,0,1],[1,1,1]]
 // Output: [[1,0,1],[0,0,0],[1,0,1]]
 // Example 2:
-
 // Input: matrix = [[0,1,2,0],[3,4,5,2],[1,3,1,5]]
 // Output: [[0,0,0,0],[0,4,5,0],[0,3,1,0]]
 

74.SearchMatrix.cs

@@ -1,5 +1,6 @@
 // 74. Search a 2D Matrix
-// Write an efficient algorithm that searches for a value target in an m x n integer matrix matrix. This matrix has the following properties:
+// Write an efficient algorithm that searches for a value target in an m x n integer matrix matrix. 
+//This matrix has the following properties:
 
 // Integers in each row are sorted from left to right.
 // The first integer of each row is greater than the last integer of the previous row.

78.Subsets.cs

@@ -1,22 +1,15 @@
 // 78. Subsets
 
 // Given an integer array nums of unique elements, return all possible subsets (the power set).
-
 // The solution set must not contain duplicate subsets. Return the solution in any order.
 
- 
-
 // Example 1:
-
 // Input: nums = [1,2,3]
 // Output: [[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]
 // Example 2:
-
 // Input: nums = [0]
 // Output: [[],[0]]
 
-
-
 public class Solution {
     public IList<IList<int>> Subsets(int[] nums) {
         int pow = (int)Math.Pow(2, nums.Length);

79.Exist.cs

@@ -2,18 +2,13 @@
 
 // Given an m x n grid of characters board and a string word, return true if word exists in the grid.
 
-// The word can be constructed from letters of sequentially adjacent cells, where adjacent cells are horizontally or vertically neighboring. The same letter cell may not be used more than once.
-
- 
+// The word can be constructed from letters of sequentially adjacent cells, where adjacent cells are horizontally or
+// vertically neighboring. The same letter cell may not be used more than once.
 
 // Example 1:
-
-
 // Input: board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCCED"
 // Output: true
 // Example 2:
-
-
 // Input: board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "SEE"
 // Output: true
 

84.LargestRectangleArea.cs

@@ -1,5 +1,6 @@
 // 84. Largest Rectangle in Histogram
-// Given an array of integers heights representing the histogram's bar height where the width of each bar is 1, return the area of the largest rectangle in the histogram.
+// Given an array of integers heights representing the histogram's bar height where the width of each bar is 1, 
+// return the area of the largest rectangle in the histogram.
 // Example 1:
 // Input: heights = [2,1,5,6,2,3]
 // Output: 10

88.Merge.cs

@@ -1,8 +1,10 @@
 // 88. Merge Sorted Array
-// You are given two integer arrays nums1 and nums2, sorted in non-decreasing order, and two integers m and n, representing the number of elements in nums1 and nums2 respectively.
+// You are given two integer arrays nums1 and nums2, sorted in non-decreasing order, and two integers m and n, 
+// representing the number of elements in nums1 and nums2 respectively.
 // Merge nums1 and nums2 into a single array sorted in non-decreasing order.
 // The final sorted array should not be returned by the function, but instead be stored inside the array nums1. To accommodate this, nums1 has a length of m + n, where the first m elements denote the elements that should be merged, and the last n elements are set to 0 and should be ignored. nums2 has a length of n.
 
+//Time O(nlogn)
 public class Solution
 {
     public void Merge(int[] nums1, int m, int[] nums2, int n)
@@ -13,4 +15,43 @@ public void Merge(int[] nums1, int m, int[] nums2, int n)
         }
         Array.Sort(nums1);
     }
-}
+}
+
+//Space O(n+m) Time O(n+m)
+public class Solution {
+    public void Merge(int[] nums1, int m, int[] nums2, int n) {
+        int[] res = new int[m+n];
+        int i = 0, j = 0, k = 0;
+        while( i < m && j < n){
+            if(nums1[i] <= nums2[j])
+                res[k++] = nums1[i++];
+            else
+                res[k++] = nums2[j++]; 
+        }
+        while( i < m){
+            res[k++] = nums1[i++];
+        }
+        while(j < n){
+            res[k++] = nums2[j++]; 
+        }
+        res.CopyTo(nums1,0);
+    }
+}
+//Time O(n,m) Space O(1)
+public void Merge(int[] nums1, int m, int[] nums2, int n) {
+    int i = m - 1;
+    int j = n - 1;
+    int k = m + n - 1;
+    
+    while(i >= 0 && j >= 0) {
+        if(nums1[i] > nums2[j]) {
+            nums1[k--] = nums1[i--];
+        } else {
+            nums1[k--] = nums2[j--];
+        }
+    }
+    
+    while(j >= 0) {
+        nums1[k--] = nums2[j--];
+    }
+}