Refine

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

Author: begeekmyfriend

044_wildcard_matching/wildcard_matching.c

@@ -3,36 +3,40 @@
 #include <stdbool.h>
 #include <string.h>
 
+
 static bool isMatch(char* s, char* p)
 {
     char *last_s = NULL;
     char *last_p = NULL;
-    while(*s != '\0') {
-        if (*p=='*'){
-            //skip the "*", and mark a flag
-            p++;
-            //edge case
-            if (*p=='\0') return true;
-            //use last_s and last_p to store where the "*" match starts.
+    while (*s != '\0') {
+        if (*p == '*') {
+            /* skip the '*', and mark a flag */
+            if (*++p == '\0') {
+                return true;
+            }
+            /* use last_s and last_p to store where the "*" match starts. */
             last_s = s;
             last_p = p;
-        } else if (*p=='?' || *s == *p) {
+        } else if (*p == '?' || *s == *p) {
             s++;
             p++;
         } else if (last_s != NULL) {
-            // check "last_s" to know whether meet "*" before
-            // if meet "*" previously, and the *s != *p
-            // reset the p, using '*' to match this situation
+            /* check "last_s" to know whether meet "*" before
+             * if meet "*" previously, and the *s != *p
+             * reset the p, using '*' to match this situation
+             */
             p = last_p;
             s = ++last_s;
         } else {
-            // *p is not wildcard char, 
-            // doesn't match *s, 
-            // there are no '*' wildcard matched before
+            /* *p is not wildcard char, 
+             * doesn't match *s, 
+             * there are no '*' wildcard matched before
+             */
             return false;
         }
     }
-    //edge case: "s" is done, but "p" still have chars.
+
+    /* s is done, but "p" still have chars. */
     while (*p == '*') {
         p++;
     }

045_jump_game_ii/jump_game.c

@@ -12,11 +12,11 @@ static int jump(int* nums, int numsSize)
     int steps = 0;
     while (hi < numsSize - 1) {
         int right = 0;
-        /* [lo, hi] is the next location range, find the farest jump */
         for (i = lo; i <= hi; i++) {
             /* Assume right > hi for the purpose of the problem */
             right = max(i + nums[i], right);
         }
+        /* [lo, hi] is the next location range */
         lo = hi + 1;
         hi = right;
         steps++;

048_rotate_image/rotate.c

@@ -1,47 +1,45 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-static void rotate(int** matrix, int matrixRowSize, int matrixColSize)
+static void rotate(int** matrix, int matrixSize, int *matrixColSize)
 {
     int i, j;
-    if (matrixRowSize != matrixColSize) {
-        return;
-    }
-
-    for (i = 0; i < matrixRowSize / 2; i++) {
-        int low = i, high = matrixColSize - i - 1;
+    for (i = 0; i < matrixSize / 2; i++) {
+        int col_size = matrixColSize[i];
+        int low = i, high = col_size - i - 1;
         for (j = low; j < high; j++) {
             int tmp = matrix[i][j];
-            matrix[i][j] = matrix[matrixColSize - 1 - j][i];
-            matrix[matrixColSize - 1 - j][i] = matrix[matrixRowSize - 1 - i][matrixColSize - 1 - j];
-            matrix[matrixRowSize - 1 - i][matrixColSize - 1 - j] = matrix[j][matrixRowSize - 1 - i];
-            matrix[j][matrixRowSize - 1 - i] = tmp;
+            matrix[i][j] = matrix[col_size - 1 - j][i];
+            matrix[col_size - 1 - j][i] = matrix[matrixSize - 1 - i][col_size - 1 - j];
+            matrix[matrixSize - 1 - i][col_size - 1 - j] = matrix[j][matrixSize - 1 - i];
+            matrix[j][matrixSize - 1 - i] = tmp;
         }
     }
 }
 
 int main(int argc, char **argv)
 {
-    if (argc != 3) {
-        fprintf(stderr, "Usage: ./test 3 3\n");
+    if (argc != 2) {
+        fprintf(stderr, "Usage: ./test 3\n");
     }
 
     int i, j, count = 0;
     int row_size = atoi(argv[1]);
-    int col_size = atoi(argv[2]);
+    int *col_sizes = malloc(row_size * sizeof(int));
     int **matrix = malloc(row_size * sizeof(int *));
     for (i = 0; i < row_size; i++) {
-        matrix[i] = malloc(col_size * sizeof(int));
-        for (j = 0; j < col_size; j++) {
+        col_sizes[i] = row_size;
+        matrix[i] = malloc(col_sizes[i] * sizeof(int));
+        for (j = 0; j < col_sizes[i]; j++) {
             matrix[i][j] = ++count;
             printf("%d ", matrix[i][j]);
         }
         printf("\n");
     }
 
-    rotate(matrix, row_size, col_size);
-    for (i = 0; i < col_size; i++) {
-        for (j = 0; j < row_size; j++) {
+    rotate(matrix, row_size, col_sizes);
+    for (i = 0; i < row_size; i++) {
+        for (j = 0; j < col_sizes[i]; j++) {
             printf("%02d ", matrix[i][j]);
         }
         putchar('\n');

049_group_anagrams/anagrams.c

@@ -2,6 +2,7 @@
 #include <stdlib.h>
 #include <string.h>
 
+
 struct word_hash {
     char *word;
     int num;
@@ -25,10 +26,10 @@ static inline int BKDRHash(char *s, size_t size)
 
 /**
  ** Return an array of arrays of size *returnSize.
- ** The sizes of the arrays are returned as *columnSizes array.
- ** Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
+ ** The sizes of the arrays are returned as *returnColumnSizes array.
+ ** Note: Both returned array and *returnColumnSizes array must be malloced, assume caller calls free().
  **/
-static char*** groupAnagrams(char** strs, int strsSize, int** columnSizes, int* returnSize)
+static char*** groupAnagrams(char** strs, int strsSize, int* returnSize, int** returnColumnSizes)
 {
     int i, j, count = 0;
     int hash_size = strsSize;
@@ -53,10 +54,10 @@ static char*** groupAnagrams(char** strs, int strsSize, int** columnSizes, int*
     int k = 0;
     struct hlist_node *p;
     char ***lists = malloc(count * sizeof(char **));
-    *columnSizes = malloc(count * sizeof(int));
+    *returnColumnSizes = malloc(count * sizeof(int));
     for (i = 0; i < hash_size; i++) {
         if (ht[i].num > 0) {
-            (*columnSizes)[k] = ht[i].num;
+            (*returnColumnSizes)[k] = ht[i].num;
             lists[k] = malloc(ht[i].num * sizeof(char *));
             for (j = 0; j < ht[i].num; j++) {
                 int index = ht[i].indexes[j];

239_sliding_window_maximum/slide_window.c

@@ -7,27 +7,30 @@
  */
 int* maxSlidingWindow(int* nums, int numsSize, int k, int* returnSize)
 {
-    int i, head = 0, tail = 0;
+    int i, left = 0, right = 0;
     int count = 0;
     int *indexes = malloc(numsSize * sizeof(int));
     int *results = malloc((numsSize - k + 1) * sizeof(int));
 
     for (i = 0; i < numsSize; i++) {
         /* keep the elements in slide window monotonous decreasing */
-        while (tail > head && nums[i] >= nums[indexes[tail - 1]]) {
+        while (right > left && nums[i] >= nums[indexes[right - 1]]) {
             /* squeeze out the previous smaller ones */
-            tail--;
+            right--;
         }
 
-        /* Pipe: first in last out */
-        indexes[tail++] = i;
-        if (indexes[head] <= i - k) {
-            head++;
-        }
+        /* In order to measure the moving size of the sliding window, we
+         * need to store the index instead of element into the window.
+         */
+        indexes[right++] = i;
 
-        /* k - 1 is the end of the first sliding window */
+        /* let k = 1 to verify the corner case */
         if (i >= k - 1) {
-            results[count++] = nums[indexes[head]];
+            results[count++] = nums[indexes[left]];
+        }
+
+        if (i - indexes[left] + 1 >= k) {
+            left++;
         }
     }