Fix

begeekmyfriend · begeekmyfriend · commit 3c3d4863940a · 2020-07-23T21:23:53.000+08:00
Signed-off-by: begeekmyfriend &lt;begeekmyfriend@gmail.com&gt;
diff --git a/034_search_for_a_range/range_search.c b/034_search_for_a_range/range_search.c
@@ -1,43 +1,43 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-static int binary_search_start(int *a, int size, int target)
+static int binary_search_begin(int *a, int size, int target)
 {
-    int low = -1;
-    int high = size;
-    while (low + 1 < high) {
-        int mid = low + (high - low) / 2;
+    int lo = -1;
+    int hi = size;
+    while (lo + 1 < hi) {
+        int mid = lo + (hi - lo) / 2;
         if (target > a[mid]) {
-            low = mid;
+            lo = mid;
         } else {
-            high = mid;
+            hi = mid;
         }
     }
 
-    if (high == size || a[high] != target) {
+    if (hi == size || a[hi] != target) {
         return -1;
     } else {
-        return high;
+        return hi;
     }
 }
 
 static int binary_search_end(int *a, int size, int target)
 {
-    int low = -1;
-    int high = size;
-    while (low + 1 < high) {
-        int mid = low + (high - low) / 2;
+    int lo = -1;
+    int hi = size;
+    while (lo + 1 < hi) {
+        int mid = lo + (hi - lo) / 2;
         if (target < a[mid]) {
-            high = mid;
+            hi = mid;
         } else {
-            low = mid;
+            lo = mid;
         }
     }
 
-    if (low == -1 || a[low] != target) {
+    if (lo == -1 || a[lo] != target) {
         return -1;
     } else {
-        return low;
+        return lo;
     }
 }
 
@@ -49,13 +49,7 @@ static int* searchRange(int* nums, int numsSize, int target, int* returnSize)
 {
     int *range = malloc(2 * sizeof(int));
     *returnSize = 2;    
-
-    if (numsSize == 0) {
-        range[0] = range[1] = -1;
-        return range;
-    }
-
-    range[0] = binary_search_start(nums, numsSize, target);
+    range[0] = binary_search_begin(nums, numsSize, target);
     range[1] = binary_search_end(nums, numsSize, target);
     return range;
 }
diff --git a/036_valid_sudoku/valid_sudoku.c b/036_valid_sudoku/valid_sudoku.c
@@ -3,138 +3,83 @@
 #include <stdbool.h>
 #include <string.h>
 
-struct stack {
-    int row;
-    int col;
-    int value;
-};
 
-static bool valid(char **board, int row, int col)
+static bool valid(char **board, char *mark, int i, int j) {
+    if (board[i][j] != '.') {
+        int index = board[i][j] - '0';
+        if (mark[index]) {
+            return false;
+        } else {
+            mark[index] = 1;
+        }
+    }
+    return true;
+}
+
+bool isValidSudoku(char** board, int boardSize, int* boardColSize)
 {
     int i, j, k;
-    char mark[10];
 
-    for (i = 0; i <= row; i++) {
-        memset(mark, 0, 10);
-        /* check row validity */
-        for (j = 0; j < 9; j++) {
-            if (board[i][j] != '.') {
-                int index = board[i][j] - '0';
-                if (mark[index]) {
-                    return false;
-                } else {
-                    mark[index] = 1;
-                }
+    /* check row validity */
+    for (i = 0; i < boardSize; i++) {
+        char mark[10] = { '\0' };
+        for (j = 0; j < boardColSize[i]; j++) {
+            if (!valid(board, mark, i, j)) {
+                return false;
             }
         }
     }
 
     /* check column validity */
-    for (i = 0; i <= col; i++) {
-        memset(mark, 0, 10);
-        for (j = 0; j < 9; j++) {
-            if (board[j][i] != '.') {
-                int index = board[j][i] - '0';
-                if (mark[index]) {
-                    return false;
-                } else {
-                    mark[index] = 1;
-                }
+    for (j = 0; j < boardColSize[0]; j++) {
+        char mark[10] = { '\0' };
+        for (i = 0; i < boardSize; i++) {
+            if (!valid(board, mark, i, j)) {
+                return false;
             }
         }
     }
 
     /* check sub-box validity */
-    int count = row / 3 * 3 + col / 3 + 1;
-    for (k = 0; k < count; k++) {
+    for (k = 0; k < boardSize; k++) {
         int sr = k / 3 * 3;
         int sc = (k % 3) * 3;
-        memset(mark, 0, 10);
+        char mark[10] = { '\0' };
         for (i = sr; i < sr + 3; i++) {
             for (j = sc; j < sc + 3; j++) {
-                if (board[i][j] != '.') {
-                    int index = board[i][j] - '0';
-                    if (mark[index]) {
-                        return false;
-                    } else {
-                        mark[index] = 1;
-                    }
-                }
-            }
-        }
-    }
-
-    return true;
-}
-
-static bool isValidSudoku(char** board, int boardRowSize, int boardColSize)
-{
-    if (boardRowSize != 9 || boardColSize != 9) {
-        return false;
-    }
-
-    int i = 0, j = 0, k = 1, num = 0;
-    struct stack stack[81];
-
-    while (i < boardRowSize) {
-        if (board[i][j] == '.') {
-            while (k <= 9) {
-                board[i][j] = k + '0';
-                if (valid(board, i, j)) {
-                    stack[num].row = i;
-                    stack[num].col = j;
-                    stack[num].value = k;
-                    num++;
-                    k = 1;
-                    break;
-                }
-                k++;
-            }
-            if (k == 10) {
-                if (num == 0) {
+                if (!valid(board, mark, i, j)) {
                     return false;
                 }
-                board[i][j] = '.';
-                --num;
-                i = stack[num].row;
-                j = stack[num].col;
-                k = stack[num].value + 1;
-                board[i][j] = '.';
-                continue;
             }
         }
-        /* next row */
-        if (++j == boardColSize) {
-            j = 0;
-            i++;
-        }
     }
-
+    
     return true;
 }
 
 int main(int argc, char **argv)
 {
     int i, j;
     char *str = argv[1];
+    int *col_sizes = malloc(9 * sizeof(int));
     char **board = malloc(9 * sizeof(char *));
     for (i = 0; i < 9; i++) {
         board[i] = malloc(10);
-        memcpy(board[i], str + i * 9, 9);
-        board[9] = '\0';
-        char *row = board[i];
+        strcpy(board[i], str + i * 9);
         for (j = 0; j < 9; j++) {
-            printf("%c ", row[j]);
+            printf("%c ", board[i][j]);
         }
+        col_sizes[i] = 9;
         printf("\n");
     }
-    printf("%s\n", isValidSudoku(board, 9, 9) ? "true" : "false");
+
+    printf("%s\n", isValidSudoku(board, 9, col_sizes) ? "true" : "false");
     for (i = 0; i < 9; i++) {
-        char *row = board[i];
         for (j = 0; j < 9; j++) {
-            printf("%c ", row[j]);
+            printf("%c ", board[i][j]);
         }
         printf("\n");
     }
-    return;
+
+    return 0;
 }
diff --git a/037_sudoku_solver/sudoku_solver.c b/037_sudoku_solver/sudoku_solver.c
