Refine

Signed-off-by: begeekmyfriend <[email protected]>

Author: begeekmyfriend

001_two_sum/two_sum.c

@@ -11,7 +11,7 @@ static int compare(const void *a, const void *b)
     return ((struct object *) a)->val - ((struct object *) b)->val;
 }
 
-static int * twosum(int *nums, int numsSize, int target)
+static int * twosum(int *nums, int numsSize, int target, int *returnSize)
 {
     int i, j;
     struct object *objs = malloc(numsSize * sizeof(*objs));
@@ -21,19 +21,19 @@ static int * twosum(int *nums, int numsSize, int target)
     }
     qsort(objs, numsSize, sizeof(*objs), compare);
 
-    int count = 0;
     int *results = malloc(2 * sizeof(int));
     i = 0;
     j = numsSize - 1;
     while (i < j) {
-        int diff = target - objs[i].val;
-        if (diff > objs[j].val) {
-            while (++i < j && objs[i].val == objs[i - 1].val) {}
-        } else if (diff < objs[j].val) {
-            while (--j > i && objs[j].val == objs[j + 1].val) {}
+        int sum = objs[i].val + objs[j].val;
+        if (sum < target) {
+            i++;
+        } else if (sum > target) {
+            j--;
         } else {
             results[0] = objs[i].index;
             results[1] = objs[j].index;
+            *returnSize = 2;
             return results;
         }
     }

015_three_sum/three_sum.c

@@ -9,11 +9,11 @@ static int compare(const void *a, const void *b)
 static void two_sum(int *nums, int low, int high, int target, int **results, int *count)
 {
     while (low < high) {
-        int diff = target - nums[low];
-        if (diff > nums[high]) {
-            while (++low < high && nums[low] == nums[low - 1]) {}
-        } else if (diff < nums[high]) {
-            while (--high > low && nums[high] == nums[high + 1]) {}
+        int sum = nums[low] + nums[high];
+        if (sum < target) {
+            low++;
+        } else if (sum > target) {
+            high--;
         } else {
             results[*count] = malloc(3 * sizeof(int));
             results[*count][0] = -target;

018_four_sum/four_sum.c

@@ -7,22 +7,23 @@ static int compare(const void *a, const void *b)
     return *(int *) a - *(int *) b;
 }
 
-static void k_sum(int *nums, int low, int high, int target, int total,
-                  int k, int *stack, int len, int **results, int *count)
+static void k_sum(int *nums, int low, int high, int target, int total, int k, 
+                  int *stack, int len, int **results, int *count, int *columnSizes)
 {
     int i;
     if (k == 2) {
         while (low < high) {
-            int diff = target - nums[low];
-            if (diff > nums[high]) {
-                while (++low < high && nums[low] == nums[low - 1]) {}
-            } else if (diff < nums[high]) {
-                while (--high > low && nums[high] == nums[high + 1]) {}
+            int sum = nums[low] + nums[high];
+            if (sum < target) {
+                low++;
+            } else if (sum > target) {
+                high--;
             } else {
                 stack[len++] = nums[low];
                 stack[len++] = nums[high];
                 results[*count] = malloc(total * sizeof(int));
                 memcpy(results[*count], stack, total * sizeof(int));
+                columnSizes[*count] = total;
                 (*count)++;
                 len -= 2;
                 while (++low < high && nums[low] == nums[low - 1]) {}
@@ -34,29 +35,28 @@ static void k_sum(int *nums, int low, int high, int target, int total,
         for (i = low; i <= high - k + 1; i++) {
             if (i > low && nums[i] == nums[i - 1]) continue;
             stack[len++] = nums[i];
-            k_sum(nums, i + 1, high, target - nums[i], 4, k - 1, stack, len,  results, count);
+            k_sum(nums, i + 1, high, target - nums[i], 4, k - 1, stack, len,  results, count, columnSizes);
             len--;
         }
     }
 }
 
 /**
- ** Return an array of arrays of size *returnSize.
- ** Note: The returned array must be malloced, assume caller calls free().
- **/
-static int** fourSum(int* nums, int numsSize, int target, int* returnSize)
-{
-    if (numsSize < 4) {
-        return NULL;
-    }
-
-    qsort(nums, numsSize, sizeof(*nums), compare);
-
+ * Return an array of arrays of size *returnSize.
+ * The sizes of the arrays are returned as *returnColumnSizes array.
+ * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
+ */
+int** fourSum(int* nums, int numsSize, int target, int* returnSize, int** returnColumnSizes) {
     *returnSize = 0;
     int i, j, capacity = 50000;
     int **results = malloc(capacity * sizeof(int *));
-    int *stack = malloc(4 * sizeof(int));
-    k_sum(nums, 0, numsSize - 1, target, 4, 4, stack, 0, results, returnSize);
+    *returnColumnSizes = malloc(capacity * sizeof(int));
+
+    if (numsSize >= 4) {
+        qsort(nums, numsSize, sizeof(*nums), compare);
+        int *stack = malloc(4 * sizeof(int));
+        k_sum(nums, 0, numsSize - 1, target, 4, 4, stack, 0, results, returnSize, *returnColumnSizes);
+    }
     return results;
 }
 

030_substring_with_concatenation_of_all_words/concatenation.c

@@ -128,6 +128,7 @@ static int *findSubstring(char *s, char **words, int wordsSize, int *returnSize)
     for (i = 0; s[i + length] != '\0'; i++) {
         memset(fqs, 0, wordsSize * sizeof(int));
         for (j = 0; j < wordsSize; j++) {
+            /* concatenation */
             int index = indexes[i + j * len];
             if (index < 0 || ++fqs[index] > freqs[index]) {
                 break;