Merge branch 'neetcode-gh:main' into main

Author: BraxMassengale

README.md

@@ -0,0 +1,46 @@
+int** insert(int** intervals, int intervalsSize, int* intervalsColSize, int* newInterval, int newIntervalSize, int* returnSize, int** returnColumnSizes) {
+    // Create a result array to store the merged intervals
+    int** result = (int**)malloc(sizeof(int*) * (intervalsSize + 1));
+    *returnColumnSizes = (int*)malloc(sizeof(int) * (intervalsSize + 1));
+    
+    int i = 0, j = 0;
+    
+    // Add intervals that end before the new interval starts
+    while (i < intervalsSize && intervals[i][1] < newInterval[0]) {
+        result[j] = (int*)malloc(sizeof(int) * 2);
+        result[j][0] = intervals[i][0];
+        result[j][1] = intervals[i][1];
+        (*returnColumnSizes)[j] = 2;
+        j++;
+        i++;
+    }
+    
+    // Merge overlapping intervals
+    while (i < intervalsSize && intervals[i][0] <= newInterval[1]) {
+        newInterval[0] = (newInterval[0] < intervals[i][0]) ? newInterval[0] : intervals[i][0];
+        newInterval[1] = (newInterval[1] > intervals[i][1]) ? newInterval[1] : intervals[i][1];
+        i++;
+    }
+    
+    // Add the merged interval
+    result[j] = (int*)malloc(sizeof(int) * 2);
+    result[j][0] = newInterval[0];
+    result[j][1] = newInterval[1];
+    (*returnColumnSizes)[j] = 2;
+    j++;
+    
+    // Add remaining intervals
+    while (i < intervalsSize) {
+        result[j] = (int*)malloc(sizeof(int) * 2);
+        result[j][0] = intervals[i][0];
+        result[j][1] = intervals[i][1];
+        (*returnColumnSizes)[j] = 2;
+        j++;
+        i++;
+    }
+    
+    // Update the return size
+    *returnSize = j;
+    
+    return result;
+}

c/0057-insert-interval.c

@@ -0,0 +1,26 @@
+int* partitionLabels(char* s, int* returnSize) {
+    int* result = NULL;
+    int* lastOccurrence = (int*)calloc(26, sizeof(int)); // Store the last occurrence index of each character
+
+    // Find the last occurrence index of each character
+    for (int i = 0; s[i] != '\0'; i++) {
+        lastOccurrence[s[i] - 'a'] = i;
+    }
+
+    int start = 0, end = 0; // Pointers to track the current partition
+    *returnSize = 0;
+
+    for (int i = 0; s[i] != '\0'; i++) {
+        end = (end > lastOccurrence[s[i] - 'a']) ? end : lastOccurrence[s[i] - 'a'];
+
+        if (i == end) {
+            (*returnSize)++;
+            result = (int*)realloc(result, sizeof(int) * (*returnSize));
+            result[(*returnSize) - 1] = end - start + 1;
+            start = end + 1;
+        }
+    }
+
+    free(lastOccurrence);
+    return result;
+}

c/0763-partition-labels.c

@@ -0,0 +1,21 @@
+int cmpfunc(const void* a, const void* b) {
+    return (*(int*)a - *(int*)b);
+}
+
+bool isNStraightHand(int* hand, int handSize, int groupSize) {
+    if (handSize % groupSize != 0) return false;
+
+    qsort(hand, handSize, sizeof(int), cmpfunc);
+
+    for (int i = 0; i < handSize; i++) {
+        if (hand[i] == -1) continue;
+        int k = i;
+        for (int j = 1; j < groupSize; j++) {
+            while (k < handSize && hand[i] + j != hand[k]) k++;
+            if (k == handSize) return false;
+            hand[k] = -1;
+        }
+    }
+
+    return true;
+}

c/0846-hand-of-straights.c

@@ -0,0 +1,13 @@
+bool mergeTriplets(int** triplets, int tripletsSize, int* tripletsColSize, int* target, int targetSize) {
+    int x = 0, y = 0, z = 0;
+
+    for (int i = 0; i < tripletsSize; i++) {
+        if (triplets[i][0] <= target[0] && triplets[i][1] <= target[1] && triplets[i][2] <= target[2]) {
+            x = (x > triplets[i][0]) ? x : triplets[i][0];
+            y = (y > triplets[i][1]) ? y : triplets[i][1];
+            z = (z > triplets[i][2]) ? z : triplets[i][2];
+        }
+    }
+
+    return (x == target[0] && y == target[1] && z == target[2]);
+}

c/1899-merge-triplets-to-form-target-triplet.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

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