Merge branch 'neetcode-gh:main' into 9

Author: tahsintunan

README.md

@@ -1,59 +1,28 @@
 class Solution {
 public:
-  vector<vector<int>> res;
-  
-  vector<vector<int>> fourSum(vector<int>& nums, int target) {
-    
-      if(nums.size() < 4) return res;
-    
-      vector<int>quad;
-      sort(nums.begin() , nums.end());
-      kSum(0,4,target,nums,quad);
-      return res;
-    }
-  
-  
-  void kSum (int index , int k , long long target, vector<int> nums , vector<int>&q)
-  {
-    
-    if(k == 2)
-    {
-      twoSum(index , target, q , nums);
-      return;
-    }
- 
-    for(int i = index ; i < nums.size() - k + 1; i++)
-    {
-      if(i > index && nums[i] == nums[i-1]) continue;
-      q.push_back(nums[i]);
-      kSum(i+1 , k-1 , target-nums[i] , nums , q);
-      q.pop_back();
-    }      
-
-  }
-  
-  void twoSum (int start,long long target,vector<int>&ans,vector<int>& nums)
-  {
-    int lo = start;
-    int hi = nums.size()-1;
-    
-    while(lo < hi)
-    {
-      int sum = nums[lo]+nums[hi];
-      if(sum > target) hi--;
-      else if (sum < target) lo++;
-      
-      else 
-      {
-        ans.insert(ans.end() , {nums[lo] , nums[hi]});
-        res.push_back(ans);
+    string longestCommonPrefix(vector<string>& strs) {
+        string result = strs[0];
+        int charIndex = 0;
 
-        ans.pop_back();
-        ans.pop_back();
-        
-        lo++;
-        while (lo < hi && nums[lo] == nums[lo - 1]) lo++;
-      }
-    }    
-  }
+        //finding minimum string length  - that could be max common prefix
+        long maxCharIndex = strs[0].length();
+        for (int i = 1; i < strs.size(); ++i) {
+            if (strs[i].length() < maxCharIndex) {
+                maxCharIndex = strs[i].length();
+            }
+        }
+
+        while (charIndex < maxCharIndex) {
+            char prevChar = strs[0][charIndex];
+            for (int i = 1; i < strs.size(); ++i) {
+                if (prevChar == strs[i][charIndex]) {
+                    continue;
+                }
+                return result.substr(0, charIndex);
+            }
+            ++charIndex;
+            result += prevChar;
+        }
+        return result.substr(0, charIndex);
+    }
 };

cpp/0014-longest-common-prefix.cpp

@@ -0,0 +1,15 @@
+class Solution {
+public:
+    int removeDuplicates(vector<int>& nums) {
+        int left = 1;
+
+        for(int right = 1; right < nums.size(); right++){
+            if(nums[right] != nums[right - 1]){
+                nums[left] = nums[right];
+                left++;
+            }
+        }
+
+        return left;
+    }
+};

cpp/0026-Remove-Duplicates-from-Sorted-Array.cpp

@@ -0,0 +1,17 @@
+class Solution {
+public:
+    int removeElement(vector<int>& nums, int val) {
+        int n=nums.size();
+        int count=0;
+        for(int i=0;i<n;i++)
+        {
+            if(nums[i]!=val)
+            {
+                swap(nums[i],nums[count]);
+                count++;
+            }
+        }
+        
+        return count;
+    }
+};

cpp/0027-Remove-element.cpp

@@ -0,0 +1,32 @@
+class Solution {
+public:
+    bool wordPattern(string pattern, string s) {
+        stringstream ss(s);
+        vector<string> sWords;
+        string word;
+        while(ss >> word){
+            sWords.push_back(word);
+        }
+
+        if(pattern.size() != sWords.size()){
+            return false;
+        }
+
+        unordered_map<char, string> patternMap;
+        unordered_map<string, char> sMap;
+
+        for(int i = 0; i < pattern.size(); i++){
+            if(patternMap.count(pattern[i]) && patternMap[pattern[i]] != sWords[i]){
+                return false;
+            }
+            if(sMap.count(sWords[i]) && sMap[sWords[i]] != pattern[i]){
+                return false;
+            }
+          
+            patternMap[pattern[i]] = sWords[i];
+            sMap[sWords[i]] = pattern[i];
+        }
+
+        return true;
+    }
+};

cpp/0290-Word-Pattern.cpp

@@ -0,0 +1,13 @@
+class Solution {
+public:
+    void reverseString(vector<char>& s) {
+        int left = 0, right = s.size() - 1;
+        
+        while (left < right){
+            swap(s[left], s[right]);
+            
+            left++;
+            right--;
+        }
+    }
+};

cpp/0344-Reverse-String.cpp

@@ -0,0 +1,48 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public int val;
+ *     public TreeNode left;
+ *     public TreeNode right;
+ *     public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+public class Solution {
+    public IList<int> InorderTraversal(TreeNode root) {
+        // return InorderTraversalRecursive(root).ToList();
+        return InorderTraversalIterative(root).ToList();
+    }
+
+    // Time: O(n)
+    // Space: O(n)
+    private IEnumerable<int> InorderTraversalRecursive(TreeNode node) {
+        if (node == null) {
+            return Enumerable.Empty<int>();
+        }
+
+        return InorderTraversalRecursive(node.left)
+            .Append(node.val)
+            .Concat(InorderTraversalRecursive(node.right));
+    }
+
+    // Time: O(n)
+    // Space: O(n)
+    private IEnumerable<int> InorderTraversalIterative(TreeNode node) {
+        List<int> result = new();
+        Stack<TreeNode> stack = new();
+        while (node != null || stack.Any()) {
+            while (node != null) {
+                stack.Push(node);
+                node = node.left;
+            }
+            node = stack.Pop();
+            result.Add(node.val);
+            node = node.right;
+        }
+        return result;
+    }
+}

csharp/0094-binary-tree-inorder-traversal.cs

@@ -0,0 +1,34 @@
+func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
+    var dummy = new(ListNode)
+    var l3 **ListNode = &dummy
+    var carry int
+    list1 := l1
+    list2 := l2
+    
+    for  (list1 != nil) || (list2 != nil) {
+        l3 = &((*l3).Next)
+        *l3 = new(ListNode)
+        var sum int
+        
+        if list1 != nil {
+            sum += list1.Val;            
+            list1 = list1.Next
+        }
+        
+        if list2 != nil{
+            sum += list2.Val
+            list2 = list2.Next
+        }
+        
+        (*l3).Val = (sum + carry)%10
+        carry = (sum + carry)/10
+    }
+    
+    if(carry > 0){
+         l3 = &((*l3).Next)
+        *l3 = new(ListNode)
+        (*l3).Val = carry
+    }
+    
+    return dummy.Next
+}

go/0002-add-two-numbers.go.txt

@@ -0,0 +1,16 @@
+var visited = 200 // -100 <= matrix[i][j] <= 100
+
+func spiralOrder(matrix [][]int) []int {
+	n, m := len(matrix[0]), len(matrix)
+	x, y, dx, dy := 0, 0, 1, 0
+	ans := make([]int, 0)
+	for i := 0; i < m*n; i++ {
+		if !(0 <= x+dx && x+dx < n) || !(0 <= y+dy && y+dy < m) || matrix[y+dy][x+dx] == visited {
+			dx, dy = -dy, dx
+		}
+		ans = append(ans, matrix[y][x])
+		matrix[y][x] = visited
+		x, y = x+dx, y+dy
+	}
+	return ans
+}

go/0054-spiral-matrix.go

@@ -0,0 +1,19 @@
+func backtrack(n, k, start int, arr []int, ans *[][]int) {
+	if len(arr) == k {
+		comb := make([]int, k)
+		copy(comb, arr)
+		*ans = append(*ans, comb)
+		return
+	}
+	for i := start; i <= n-k+(len(arr)+1); i++ {
+		arr = append(arr, i)
+		backtrack(n, k, i+1, arr, ans)
+		arr = arr[:len(arr)-1]
+	}
+}
+
+func combine(n int, k int) [][]int {
+	ans := [][]int{}
+	backtrack(n, k, 1, []int{}, &ans)
+	return ans
+}

go/0077-combinations.go

@@ -0,0 +1,19 @@
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func sortedArrayToBST(nums []int) *TreeNode {
+	if nums == nil || len(nums) == 0 {
+		return nil
+	}
+	mid := len(nums) / 2
+	return &TreeNode{
+		Val:   nums[mid],
+		Left:  sortedArrayToBST(nums[:mid]),
+		Right: sortedArrayToBST(nums[mid+1:]),
+	}
+}

go/0108-convert-sorted-array-to-binary-search-tree.go

@@ -0,0 +1,30 @@
+/**
+ * Definition for a Node.
+ * type Node struct {
+ *     Val int
+ *     Left *Node
+ *     Right *Node
+ *     Next *Node
+ * }
+ */
+
+func connect(root *Node) *Node {
+	populate(root)
+	return root
+}
+
+func populate(node *Node) {
+	if node == nil {
+		return
+	}
+	if node.Left == nil {
+		return
+	}
+
+	node.Left.Next = node.Right
+	if node.Next != nil {
+		node.Right.Next = node.Next.Left
+	}
+	populate(node.Left)
+	populate(node.Right)
+}

go/0116-populating-next-right-pointers-in-each-node.go

@@ -0,0 +1,23 @@
+/**
+ * Definition for singly-linked list.
+ * type ListNode struct {
+ *     Val int
+ *     Next *ListNode
+ * }
+ */
+func getIntersectionNode(headA, headB *ListNode) *ListNode {
+	a, b := headA, headB
+	for a != b {
+		if a == nil {
+			a = headB
+		} else {
+			a = a.Next
+		}
+		if b == nil {
+			b = headA
+		} else {
+			b = b.Next
+		}
+	}
+	return a
+}

go/0160-intersection-of-two-linked-lists.go

@@ -0,0 +1,4 @@
+func findKthLargest(nums []int, k int) int {
+	sort.Ints(nums)
+	return nums[len(nums)-k]
+}

go/0215-kth-largest-element-in-an-array.go

@@ -0,0 +1,13 @@
+func isUgly(n int) bool {
+	if n <= 0 {
+		return false
+	}
+
+	primes := []int{2, 3, 5}
+	for _, p := range primes {
+		for n%p == 0 {
+			n /= p
+		}
+	}
+	return n == 1
+}