Merge branch 'main' of https://github.com/ThBlitz/NeetCode-Fork

Author: th-blitz

Diff for: README.md

@@ -0,0 +1,29 @@
+func isValid(s string) bool {
+	pairs := map[byte]byte{
+		'}': '{',
+		']': '[',
+		')': '(',
+	}
+
+	stack := make([]byte, 0)
+
+	for _, char := range []byte(s) {
+		pair, ok := pairs[char]
+		if !ok {
+			stack = append(stack, char)
+			continue
+		}
+
+		if len(stack) == 0 {
+			return false
+		}
+
+		if stack[len(stack) - 1] != pair {
+			return false
+		}
+
+		stack = stack[:len(stack) - 1]
+	}
+
+	return len(stack) == 0
+}

Diff for: go/20-Valid-Parentheses.go

@@ -0,0 +1,49 @@
+/**
+ * Definition for singly-linked list.
+ * type ListNode struct {
+ *     Val int
+ *     Next *ListNode
+ * }
+ */
+func mergeTwoLists(l1 *ListNode, l2 *ListNode) *ListNode {
+	if l1 == nil {
+		return l2
+	}
+
+	if l2 == nil {
+		return l1
+	}
+
+	ptr1, ptr2 := l1, l2
+
+	result := new(ListNode)
+
+	temp := result
+
+	for ptr1 != nil && ptr2 != nil {
+		if ptr1.Val < ptr2.Val {
+			temp.Next = ptr1
+			temp = temp.Next
+			ptr1 = ptr1.Next
+		} else {
+			temp.Next = ptr2
+			temp = temp.Next
+			ptr2 = ptr2.Next
+		}
+	}
+
+	for ptr1 != nil{
+		temp.Next = ptr1
+		temp = temp.Next
+		ptr1 = ptr1.Next
+	}
+
+	for ptr2 != nil{
+		temp.Next = ptr2
+		temp = temp.Next
+		ptr2 = ptr2.Next
+	}
+
+	result = result.Next
+	return result
+}

Diff for: go/21-Merge-Two-Sorted-Lists.go

@@ -0,0 +1,21 @@
+class Solution {
+    fun carFleet(target: Int, position: IntArray, speed: IntArray): Int {
+        val sortedPairs = position
+            .zip(speed)
+            .sortedBy { (position, _) -> position }
+        var numberOfFleets = 1
+        var timeRequiredForCarInFrontToReachInTarget =
+            (target - sortedPairs[sortedPairs.lastIndex].first) / sortedPairs[sortedPairs.lastIndex].second.toFloat()
+        var timeRequiredForCurrentCarToReachTarget: Float
+        for (i in (sortedPairs.lastIndex - 1) downTo 0) {
+            timeRequiredForCurrentCarToReachTarget = (target - sortedPairs[i].first) / sortedPairs[i].second.toFloat()
+            if (timeRequiredForCurrentCarToReachTarget > timeRequiredForCarInFrontToReachInTarget) {
+                // the current car requires more time to reach the destination
+                // than the car in front of it.
+                numberOfFleets++
+                timeRequiredForCarInFrontToReachInTarget = timeRequiredForCurrentCarToReachTarget
+            }
+        }
+        return numberOfFleets
+    }
+}

Diff for: kotlin/853-Car-Fleet.kt

@@ -0,0 +1,26 @@
+class Solution:
+    def fourSum(self, nums, target):
+        def findNsum(l, r, target, N, result, results):
+            if r-l+1 < N or N < 2 or target < nums[l]*N or target > nums[r]*N:  
+                return
+            if N == 2: 
+                while l < r:
+                    s = nums[l] + nums[r]
+                    if s == target:
+                        results.append(result + [nums[l], nums[r]])
+                        l += 1
+                        while l < r and nums[l] == nums[l-1]:
+                            l += 1
+                    elif s < target:
+                        l += 1
+                    else:
+                        r -= 1
+            else:
+                for i in range(l, r+1):
+                    if i == l or (i > l and nums[i-1] != nums[i]):
+                        findNsum(i+1, r, target-nums[i], N-1, result+[nums[i]], results)
+
+        nums.sort()
+        results = []
+        findNsum(0, len(nums)-1, target, 4, [], results)
+        return results

Diff for: python/18-4Sum.py

@@ -0,0 +1,13 @@
+def max_sub_array(nums)
+    sum = 0
+    max = -10 * 10 * 10 * 10 - 1
+
+    nums.each do |num|
+        sum += num
+        max = sum > max ? sum : max
+
+        sum = 0 if  sum < 0
+    end 
+
+    max
+end

Diff for: ruby/0053-Maximum-Subarray.rb

@@ -0,0 +1,24 @@
+# @param {Integer[]} nums
+# @return {Integer[][]}
+def subsets(nums)
+    ans = []
+    
+    recurse(nums, ans, [], 0)
+    
+    ans
+end
+
+
+def recurse(nums, ans, curr, i)
+    if i == nums.length
+        ans << curr.clone
+        return
+    end
+    
+
+    curr << nums[i]
+    recurse(nums, ans, curr, i + 1)
+
+    curr.pop
+    recurse(nums, ans, curr, i + 1)
+end