Merge branch 'main' of https://github.com/chetannada/leetcode into ltc-2485-js

Author: chetannada

README.md

@@ -0,0 +1,26 @@
+bool isMatch(char *s, char *p) {
+    int m = strlen(s);
+    int n = strlen(p);
+    
+    bool dp[m + 1][n + 1];
+    memset(dp, false, sizeof(dp));
+    dp[0][0] = true;
+    
+    for (int j = 1; j <= n; j++) {
+        if (p[j - 1] == '*') {
+            dp[0][j] = dp[0][j - 2];
+        }
+    }
+    
+    for (int i = 1; i <= m; i++) {
+        for (int j = 1; j <= n; j++) {
+            if (p[j - 1] == s[i - 1] || p[j - 1] == '.') {
+                dp[i][j] = dp[i - 1][j - 1];
+            } else if (p[j - 1] == '*') {
+                dp[i][j] = dp[i][j - 2] || ((s[i - 1] == p[j - 2] || p[j - 2] == '.') && dp[i - 1][j]);
+            }
+        }
+    }
+    
+    return dp[m][n];
+}

c/0010-regular-expression-matching.c

@@ -0,0 +1,30 @@
+int max(int a, int b) {
+    return (a > b) ? a : b;
+}
+
+int maxCoins(int* nums, int numsSize) {
+    // Add padding of 1 to both ends of the array
+    int n = numsSize + 2;
+    int paddedNums[n];
+    paddedNums[0] = paddedNums[n - 1] = 1;
+    for (int i = 1; i < n - 1; i++) {
+        paddedNums[i] = nums[i - 1];
+    }
+    
+    // Create a 2D DP array to store the results
+    int dp[n][n];
+    memset(dp, 0, sizeof(dp));
+    
+    // Start dynamic programming process
+    for (int len = 2; len < n; len++) {
+        for (int left = 0; left < n - len; left++) {
+            int right = left + len;
+            for (int k = left + 1; k < right; k++) {
+                dp[left][right] = max(dp[left][right], 
+                                      paddedNums[left] * paddedNums[k] * paddedNums[right] + dp[left][k] + dp[k][right]);
+            }
+        }
+    }
+    
+    return dp[0][n - 1];
+}

c/0312-burst-balloons.c

@@ -31,16 +31,8 @@ class Solution {
             return list1;
         }
 
-        ListNode* head = NULL;
-        if (list1->val <= list2->val) {
-            head = list1;
-            list1 = list1->next;
-        } else {
-            head = list2;
-            list2 = list2->next;
-        }
-        ListNode* curr = head;
-        
+        ListNode* dummy = new ListNode();
+        ListNode *curr = dummy;
         while (list1 != NULL && list2 != NULL) {
             if (list1->val <= list2->val) {
                 curr->next = list1;
@@ -58,6 +50,6 @@ class Solution {
             curr->next = list1;
         }
 
-        return head;
+        return dummy->next;
     }
 };

cpp/0021-merge-two-sorted-lists.cpp

@@ -0,0 +1,21 @@
+class Solution {
+public:
+    int maxPoints(vector<vector<int>>& points) {
+        int res = 1;
+        for (int i=0; i<points.size(); ++i) {
+            unordered_map<float, int> count;
+            for (int j=i+1; j<points.size(); ++j) {
+                float s = slope(points[i], points[j]);
+                count[s] ++; 
+                res = max(res, count[s] + 1);
+            }
+        }
+        return res;
+    }
+private:
+    float slope(vector<int>& p1, vector<int>& p2) {
+        if ((p2[0] - p1[0]) == 0) 
+            return INT_MAX; // aka edge case to handle a slope of infinity
+        return (float) (p2[1] - p1[1]) / (float) (p2[0] - p1[0]);
+    }
+};

cpp/0149-max-points-on-a-line.cpp

@@ -0,0 +1,27 @@
+/**
+ * Definition for singly-linked list.
+ * type ListNode struct {
+ *     Val int
+ *     Next *ListNode
+ * }
+ */
+func swapNodes(head *ListNode, k int) *ListNode {
+	curr := head
+	for i := 0; i < k-1; i++ {
+		curr = curr.Next
+	}
+
+	left := curr
+	right := head
+
+	for curr.Next != nil {
+		curr = curr.Next
+		right = right.Next
+	}
+
+	left.Val, right.Val = right.Val, left.Val
+
+	return head
+}
+//Time: O(n)
+//Space: O(1)

go/1721-swapping-nodes-in-a-linked-list.go

@@ -0,0 +1,34 @@
+class Solution {
+    public boolean canShip(int cap, int days, int[] weights){
+        int ships=1, currCap=cap;
+        for(int w: weights){
+            if(currCap - w < 0){
+                ships += 1;
+                currCap = cap;
+            }
+            currCap -= w;
+        }
+        return ships <= days;
+    }
+    public int shipWithinDays(int[] weights, int days) {
+        int l=0, r=0;
+
+        for(int w: weights){
+            l = Math.max(l, w);
+            r += w;
+        }
+
+        int res = r;
+
+        while(l <= r){
+            int cap = (l+r)/2;
+            if(canShip(cap, days, weights)){
+                res = Math.min(res, cap);
+                r = cap-1;
+            }else{
+                l = cap+1;
+            }
+        }
+        return res;
+    }
+}

java/1011-capacity-to-ship-packages-within-d-days.java

@@ -3,7 +3,7 @@ def longestConsecutive(self, nums: List[int]) -> int:
         numSet = set(nums)
         longest = 0
 
-        for n in nums:
+        for n in numSet:
             # check if its the start of a sequence
             if (n - 1) not in numSet:
                 length = 1