Merge branch 'neetcode-gh:main' into main

Author: drxlx

README.md

@@ -0,0 +1,11 @@
+int removeDuplicates(int* nums, int numsSize){
+    int indx = 1;
+    
+    for(int i = 1; i < numsSize; i++){
+        if(nums[i] != nums[i-1]){
+            nums[indx] = nums[i];
+            indx++;
+        }
+    }
+    return indx;
+}

c/0026-remove-duplicates-from-sorted-array.c

@@ -0,0 +1,26 @@
+int firstMissingPositive(int* nums, int numsSize){
+    
+    int i = 0;
+
+    while(i < numsSize){
+        int val = nums[i];
+        if(val > 0) val = val - 1;
+        
+        if(nums[i] > 0 && nums[i] < numsSize && nums[i] != nums[val]){
+            int temp = nums[i];
+            nums[i] = nums[val];
+            nums[val] = temp;
+        }
+        else i++;
+    }
+
+    int ans = numsSize + 1;
+    for(int i = 0 ; i < numsSize ; i++){
+        if(nums[i] != i+1){
+            ans = i+1;
+            break;
+        }
+    }
+
+    return ans;
+}

c/0041-first-missing-positive.c

@@ -0,0 +1,32 @@
+char* multiply(char* num1, char* num2) {
+    int len1 = strlen(num1);
+    int len2 = strlen(num2);
+    int len = len1 + len2;
+    int* result = (int*)calloc(len, sizeof(int));
+
+    for (int i = len1 - 1; i >= 0; i--) {
+        for (int j = len2 - 1; j >= 0; j--) {
+            int product = (num1[i] - '0') * (num2[j] - '0');
+            int sum = product + result[i + j + 1];
+            result[i + j + 1] = sum % 10;
+            result[i + j] += sum / 10;
+        }
+    }
+
+    char* res = (char*)malloc((len + 1) * sizeof(char));
+    int idx = 0;
+    for (int i = 0; i < len; i++) {
+        if (idx == 0 && result[i] == 0) {
+            continue;
+        }
+        res[idx++] = result[i] + '0';
+    }
+    res[idx] = '\0';
+
+    if (idx == 0) {
+        return "0";
+    }
+
+    free(result);
+    return res;
+}

c/0043-multiply-strings.c

@@ -0,0 +1,57 @@
+/**
+ * Note: The returned array must be malloced, assume caller calls free().
+ */
+int* spiralOrder(int** matrix, int matrixSize, int* matrixColSize, int* returnSize) {
+    // Allocate the result array and set its size
+    int *result = (int*)malloc(sizeof(int) * matrixSize * matrixColSize[0]);
+    *returnSize = 0;
+    
+    // Handle the empty matrix case
+    if (matrixSize == 0 || matrixColSize[0] == 0) {
+        return result;
+    }
+    
+    // Initialize the boundaries of the matrix
+    int top = 0, bottom = matrixSize - 1, left = 0, right = matrixColSize[0] - 1;
+    
+    // Traverse the matrix in a clockwise spiral order
+    while (top <= bottom && left <= right) {
+        // Traverse the top row
+        for (int col = left; col <= right; col++) {
+            *result = matrix[top][col];
+            (*returnSize)++;
+            result++;
+        }
+        top++;
+        
+        // Traverse the right column
+        for (int row = top; row <= bottom; row++) {
+            *result = matrix[row][right];
+            (*returnSize)++;
+            result++;
+        }
+        right--;
+        
+        // Traverse the bottom row
+        if (top <= bottom) {
+            for (int col = right; col >= left; col--) {
+                *result = matrix[bottom][col];
+                (*returnSize)++;
+                result++;
+            }
+            bottom--;
+        }
+        
+        // Traverse the left column
+        if (left <= right) {
+            for (int row = bottom; row >= top; row--) {
+                *result = matrix[row][left];
+                (*returnSize)++;
+                result++;
+            }
+            left++;
+        }
+    }
+    
+    return result - (*returnSize); // Adjust the pointer back before returning
+}

c/0054-spiral-matrix.c

@@ -0,0 +1,61 @@
+// Interval structure
+struct Interval {
+    int start;
+    int end;
+};
+
+// Function to compare intervals for sorting
+int compareIntervals(const void* a, const void* b) {
+    return ((struct Interval*)a)->start - ((struct Interval*)b)->start;
+}
+
+// Function to merge intervals
+int** merge(int** intervals, int intervalsSize, int* intervalsColSize, int* returnSize, int** returnColumnSizes) {
+    if (intervalsSize <= 1) {
+        *returnSize = intervalsSize;
+        *returnColumnSizes = intervalsColSize;
+        return intervals;
+    }
+
+    // Create an array of Interval structures
+    struct Interval* sortedIntervals = (struct Interval*)malloc(sizeof(struct Interval) * intervalsSize);
+    for (int i = 0; i < intervalsSize; i++) {
+        sortedIntervals[i].start = intervals[i][0];
+        sortedIntervals[i].end = intervals[i][1];
+    }
+
+    // Sort intervals based on start times
+    qsort(sortedIntervals, intervalsSize, sizeof(struct Interval), compareIntervals);
+
+    // Merge intervals
+    struct Interval* mergedIntervals = (struct Interval*)malloc(sizeof(struct Interval) * intervalsSize);
+    int mergedCount = 0;
+
+    for (int i = 0; i < intervalsSize; i++) {
+        if (mergedCount == 0 || mergedIntervals[mergedCount - 1].end < sortedIntervals[i].start) {
+            mergedIntervals[mergedCount++] = sortedIntervals[i];
+        } else {
+            mergedIntervals[mergedCount - 1].end = mergedIntervals[mergedCount - 1].end > sortedIntervals[i].end
+                                                      ? mergedIntervals[mergedCount - 1].end
+                                                      : sortedIntervals[i].end;
+        }
+    }
+
+    // Allocate memory for return arrays
+    int** result = (int**)malloc(sizeof(int*) * mergedCount);
+    *returnColumnSizes = (int*)malloc(sizeof(int) * mergedCount);
+
+    for (int i = 0; i < mergedCount; i++) {
+        result[i] = (int*)malloc(sizeof(int) * 2);
+        result[i][0] = mergedIntervals[i].start;
+        result[i][1] = mergedIntervals[i].end;
+        (*returnColumnSizes)[i] = 2;
+    }
+
+    *returnSize = mergedCount;
+
+    free(sortedIntervals);
+    free(mergedIntervals);
+
+    return result;
+}

c/0056-merge-intervals.c

@@ -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,18 @@
+int mySqrt(int x){
+    int l = 0;
+    int r = x;
+
+    while(l <= r){
+        long int m = (l + r) / 2;
+        if(m * m == x){
+            return m;
+        }
+        else if(m * m > x){
+            r = m - 1;
+        }
+        else{
+            l = m + 1;
+        }
+    }
+    return r;
+}

c/0069-sqrtx.c

@@ -0,0 +1,13 @@
+int min(int a, int b) {
+    return a < b ? a : b;
+}
+
+int minimumTotal(int** triangle, int triangleSize, int* triangleColSize) {
+    // We'll use bottom-up dynamic programming approach
+    for (int i = triangleSize - 2; i >= 0; i--) {
+        for (int j = 0; j <= i; j++) {
+            triangle[i][j] += min(triangle[i + 1][j], triangle[i + 1][j + 1]);
+        }
+    }
+    return triangle[0][0];
+}