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

go/20-Valid-Parentheses.go

@@ -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
+}

go/21-Merge-Two-Sorted-Lists.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
+}

kotlin/853-Car-Fleet.kt

@@ -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
+ }
+}

python/18-4Sum.py

@@ -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

ruby/0053-Maximum-Subarray.rb

@@ -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

ruby/78-Subsets.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