new soln

Author: shreymehul

1047.RemoveDuplicates.cs

@@ -0,0 +1,38 @@
+// 1047. Remove All Adjacent Duplicates In String
+// You are given a string s consisting of lowercase English letters. 
+// A duplicate removal consists of choosing two adjacent and equal letters and removing them.
+// We repeatedly make duplicate removals on s until we no longer can.
+// Return the final string after all such duplicate removals have been made. 
+// It can be proven that the answer is unique.
+
+// Example 1:
+// Input: s = "abbaca"
+// Output: "ca"
+// Explanation: 
+// For example, in "abbaca" we could remove "bb" since the letters are adjacent and equal, and this is the only possible move.  The result of this move is that the string is "aaca", of which only "aa" is possible, so the final string is "ca".
+// Example 2:
+// Input: s = "azxxzy"
+// Output: "ay"
+ 
+
+// Constraints:
+// 1 <= s.length <= 105
+// s consists of lowercase English letters.
+
+public class Solution {
+    //Intuition: Use stack to keep track of the characters. 
+    //If the current character is same as the top of the stack, pop the top of the stack. 
+    //Else, push the current character to the stack.
+    public string RemoveDuplicates(string s) {
+        Stack<char> st = new();
+        for(int i = 0; i < s.Length; i++){
+            if(st.Count() > 0 && st.Peek() == s[i]){
+                st.Pop();
+            }
+            else{
+                st.Push(s[i]);
+            }
+        }
+        return new string(st.ToArray().Reverse().ToArray());
+    }
+}

11.MaxArea.cs

@@ -1,6 +1,7 @@
 // 11. Container With Most Water
 
-// You are given an integer array height of length n. There are n vertical lines drawn such that the two endpoints of the ith line are (i, 0) and (i, height[i]).
+// You are given an integer array height of length n. 
+// There are n vertical lines drawn such that the two endpoints of the ith line are (i, 0) and (i, height[i]).
 
 // Find two lines that together with the x-axis form a container, such that the container contains the most water.
 
@@ -18,6 +19,13 @@
 // Output: 1
 
 public class Solution {
+    //intution: We can solve this problem by using two pointers.
+    //We can use two pointers to iterate through the array and find the maximum area.
+    //We can use the two pointers to find the maximum area by finding the minimum of the two heights
+    //and the distance between the two pointers.
+    //We can return the maximum area.
+    //Time complexity: O(n)
+    //Space complexity: O(1)
     public int MaxArea(int[] height) {
         int left = 0,
             right = height.Length -1;

14.LongestCommonPrefix.cs

@@ -11,7 +11,9 @@ public string LongestCommonPrefix(string[] strs)
             return "";
         if (size == 1)
             return strs[0];
-
+        //Sort the array of strings
+        //The first and last strings will be the smallest and largest strings
+        //We can compare the first and last strings to find the longest common prefix
         Array.Sort(strs);
         int end = Math.Min(strs[0].Length, strs[size - 1].Length);
         int i = 0;

15.ThreeSum.cs

@@ -1,11 +1,11 @@
 // 15. 3Sum
 
-// Given an integer array nums, return all the triplets [nums[i], nums[j], nums[k]] such that i != j, i != k, and j != k, and nums[i] + nums[j] + nums[k] == 0.
+// Given an integer array nums, return all the triplets [nums[i], nums[j], nums[k]] 
+// such that i != j, i != k, and j != k, and nums[i] + nums[j] + nums[k] == 0.
 
 // Notice that the solution set must not contain duplicate triplets.
 
 // Example 1:
-
 // Input: nums = [-1,0,1,2,-1,-4]
 // Output: [[-1,-1,2],[-1,0,1]]
 // Explanation: 
@@ -15,17 +15,21 @@
 // The distinct triplets are [-1,0,1] and [-1,-1,2].
 // Notice that the order of the output and the order of the triplets does not matter.
 // Example 2:
-
 // Input: nums = [0,1,1]
 // Output: []
 // Explanation: The only possible triplet does not sum up to 0.
 // Example 3:
-
 // Input: nums = [0,0,0]
 // Output: [[0,0,0]]
 // Explanation: The only possible triplet sums up to 0.
 
 public class Solution {
+    //intuition: We can solve this problem by using two pointers.
+    //We can sort the array and then iterate through the array.
+    //For each element, we can use two pointers to find the other two elements that sum up to 0.
+    //We can skip duplicate elements to avoid duplicate triplets.
+    //Time complexity: O(n^2)
+    //Space complexity: O(1)
     public IList<IList<int>> ThreeSum(int[] nums) {
         Array.Sort(nums);
 

1669.MergeInBetween.cs

@@ -0,0 +1,60 @@
+// 1669. Merge In Between Linked Lists
+// You are given two linked lists: list1 and list2 of sizes n and m respectively.
+// Remove list1's nodes from the ath node to the bth node, and put list2 in their place.
+// The blue edges and nodes in the following figure indicate the result:
+// Build the result list and return its head.
+// Example 1:
+// Input: list1 = [10,1,13,6,9,5], a = 3, b = 4, list2 = [1000000,1000001,1000002]
+// Output: [10,1,13,1000000,1000001,1000002,5]
+// Explanation: We remove the nodes 3 and 4 and put the entire list2 in their place. The blue edges and nodes in the above figure indicate the result.
+// Example 2:
+// Input: list1 = [0,1,2,3,4,5,6], a = 2, b = 5, list2 = [1000000,1000001,1000002,1000003,1000004]
+// Output: [0,1,1000000,1000001,1000002,1000003,1000004,6]
+// Explanation: The blue edges and nodes in the above figure indicate the result.
+
+// Constraints:
+// 3 <= list1.length <= 104
+// 1 <= a <= b < list1.length - 1
+// 1 <= list2.length <= 104
+
+/**
+ * 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 MergeInBetween(ListNode list1, int a, int b, ListNode list2) {
+        int i = 0;
+        ListNode Start, Curr, End;
+        Start = Curr = list1;
+        //iterate to the ath node
+        while(i < a-1){
+            Curr = Curr.next; 
+            i++;
+        }
+        //save the ath node as Start of the list to be removed
+        Start = Curr;
+        //iterate to the bth node to save it as End of the list to be removed
+        while(i <= b){
+            Curr = Curr.next;
+            i++;
+        }
+        //save the bth node as End of the list to be removed
+        End = Curr;
+        //connect the list1 to list2
+        Start.next = list2;
+        //iterate to the end of list2
+        while(Start.next != null){
+            Start = Start.next;
+        }
+        //connect the end of list2 to the list1
+        Start.next = End;
+        return list1;
+    }
+}

17.LetterCombinations.cs

@@ -1,6 +1,8 @@
 // 17. Letter Combinations of a Phone Number
-// 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.
+// 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.
 // Example 1:
 // Input: digits = "23"
 // Output: ["ad","ae","af","bd","be","bf","cd","ce","cf"]
@@ -12,6 +14,8 @@
 // Output: ["a","b","c"]
 
 public class Solution {
+    //Time complexity: O(3^n * 4^m) where n is the number of digits that have 3 letters and m is the number of digits that have 4 letters.
+    //Space complexity: O(3^n * 4^m) where n is the number of digits that have 3 letters and m is the number of digits that have 4 letters.
     string[] dialPad = new string[]
         {"","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
     public IList<string> LetterCombinations(string digits) {
@@ -22,11 +26,14 @@ public IList<string> LetterCombinations(string digits) {
         return result;  
     }
     public void AllCombination(IList<string> result,string digits,string s, int idx)    {
+        //if last index is checked, add the string to the result list.
         if(idx == digits.Length){
             result.Add(new string(s));
             return;
         }
+        //Get the number from the string by converting string to int.
         int num = digits[idx] - '0';
+        //Add current character to string s and then call the function recursively for the next digit.
         foreach(char c in dialPad[num]){
             AllCombination(result,digits,s + c, idx+1);
         }

2.AddTwoNumbers.cs

@@ -15,8 +15,18 @@
  */
 public class Solution
 {
+    //Intuition: We can solve this problem using two pointers.
+    //We can iterate through both the lists and add the values of the nodes.
+    //We can keep track of the carry and add it to the next node.
+    //If the sum is greater than 9, we can take the remainder and set the carry to 1.
+    //If the sum is less than 9, we can set the carry to 0.
+    //If we reach the end of the list and there is still a carry, we can add a new node with the value 1.
+    //Finally, we can return the head of the list.
+    //Time complexity: O(n)
+    //Space complexity: O(1)
     public ListNode AddTwoNumbers(ListNode list1, ListNode list2)
     {
+        
         ListNode head, curr, prev;
         if (list1 == null && list2 == null)
             return null;

20.IsValid.cs

@@ -3,9 +3,27 @@
 //An input string is valid if:
 //Open brackets must be closed by the same type of brackets.
 //Open brackets must be closed in the correct order.
+// Every close bracket has a corresponding open bracket of the same type.
+// Example 1:
+// Input: s = "()"
+// Output: true
+// Example 2:
+// Input: s = "()[]{}"
+// Output: true
+// Example 3:
+// Input: s = "(]"
+// Output: false
+
+// Constraints:
+// 1 <= s.length <= 104
+// s consists of parentheses only '()[]{}'.
 
 public class Solution
 {
+    //intution: Use stack to store the opening brackets and pop the stack when a closing bracket is found.
+    //If the stack is empty and a closing bracket is found, return false.
+    //Time complexity: O(n) where n is the length of the string.
+    //Space complexity: O(n) where n is the length of the string.
     public bool IsValid(string s)
     {
         Stack<char> stack = new Stack<char>();
@@ -17,10 +35,11 @@ public bool IsValid(string s)
             if ((s[i] == '{') || (s[i] == '[') || (s[i] == '('))
             {
                 stack.Push(s[i]);
+                continue;
             }
-            else if (stack.Count == 0)
+            if (stack.Count == 0)
                 return false;
-            else if ((s[i] == '}') && (stack.Peek() == '{'))
+            if ((s[i] == '}') && (stack.Peek() == '{'))
             {
                 stack.Pop();
             }

23.MergeKLists.cs

@@ -1,13 +1,9 @@
 // 23. Merge k Sorted Lists
 
 // You are given an array of k linked-lists lists, each linked-list is sorted in ascending order.
-
 // Merge all the linked-lists into one sorted linked-list and return it.
 
- 
-
 // Example 1:
-
 // Input: lists = [[1,4,5],[1,3,4],[2,6]]
 // Output: [1,1,2,3,4,4,5,6]
 // Explanation: The linked-lists are:
@@ -19,16 +15,16 @@
 // merging them into one sorted list:
 // 1->1->2->3->4->4->5->6
 // Example 2:
-
 // Input: lists = []
 // Output: []
 // Example 3:
-
 // Input: lists = [[]]
 // Output: []
-
 //Approch Divide & Conqure -> Merge Sort
 public class Solution {
+    //intution: Use Merge Sort to merge the lists.
+    //Time complexity: O(NLogK) where N is the total number of elements in all the lists and K is the number of lists.
+    //Space complexity: O(1)
     public ListNode MergeKLists(ListNode[] lists) {
         if(lists == null || lists.Length == 0)
             return null;

24.SwapPairs.cs

@@ -14,6 +14,7 @@
  */
 public class Solution
 {
+    //intuio
     public ListNode SwapPairs(ListNode head)
     {
         ListNode prev, curr;
@@ -25,6 +26,7 @@ public ListNode SwapPairs(ListNode head)
         head = head.next;
         while (curr != null && curr.next != null)
         {
+            //swap
             prev.next = curr.next;
             prev = curr;
             curr = curr.next;

26.RemoveDuplicates.cs

@@ -1,8 +1,44 @@
-//26. Remove Duplicates from Sorted Array
-//Given an integer array nums sorted in non-decreasing order, remove the duplicates in-place such that each unique element appears only once. The relative order of the elements should be kept the same.
-// Since it is impossible to change the length of the array in some languages, you must instead have the result be placed in the first part of the array nums. More formally, if there are k elements after removing the duplicates, then the first k elements of nums should hold the final result. It does not matter what you leave beyond the first k elements.
-// Return k after placing the final result in the first k slots of nums.
-// Do not allocate extra space for another array. You must do this by modifying the input array in-place with O(1) extra memory.
+// 26. Remove Duplicates from Sorted Array
+
+// Given an integer array nums sorted in non-decreasing order, remove the duplicates in-place such that each unique element appears only once. 
+// The relative order of the elements should be kept the same. Then return the number of unique elements in nums.
+
+// Consider the number of unique elements of nums to be k, to get accepted, you need to do the following things:
+
+// Change the array nums such that the first k elements of nums contain the unique elements in the order they were present in nums initially. 
+// The remaining elements of nums are not important as well as the size of nums.
+// Return k.
+// Custom Judge:
+
+// The judge will test your solution with the following code:
+
+// int[] nums = [...]; // Input array
+// int[] expectedNums = [...]; // The expected answer with correct length
+
+// int k = removeDuplicates(nums); // Calls your implementation
+
+// assert k == expectedNums.length;
+// for (int i = 0; i < k; i++) {
+//     assert nums[i] == expectedNums[i];
+// }
+// If all assertions pass, then your solution will be accepted.
+
+// Example 1:
+// Input: nums = [1,1,2]
+// Output: 2, nums = [1,2,_]
+// Explanation: Your function should return k = 2, with the first two elements of nums being 1 and 2 respectively.
+// It does not matter what you leave beyond the returned k (hence they are underscores).
+// Example 2:
+// Input: nums = [0,0,1,1,1,2,2,3,3,4]
+// Output: 5, nums = [0,1,2,3,4,_,_,_,_,_]
+// Explanation: Your function should return k = 5, with the first five elements of nums being 0, 1, 2, 3, and 4 respectively.
+// It does not matter what you leave beyond the returned k (hence they are underscores).
+ 
+// Constraints:
+// 1 <= nums.length <= 3 * 104
+// -100 <= nums[i] <= 100
+// nums is sorted in non-decreasing order.
+
 public class Solution {
     public int RemoveDuplicates(int[] nums) {
         int j=0;