Improve

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

Author: begeekmyfriend

053_maximum_subarray/max_subarray.c

@@ -2,15 +2,15 @@
 #include <stdlib.h>
 #include <limits.h>
 
-static int recursive(int *nums, int lo, int hi)
+static int partition(int *nums, int lo, int hi)
 {
     if (lo == hi) {
         return nums[lo];
     }
 
     int ce = (hi - lo) / 2;
-    int left_max = recursive(nums, lo, lo + ce);
-    int right_max = recursive(nums, hi - ce, hi);
+    int left_max = partition(nums, lo, lo + ce);
+    int right_max = partition(nums, hi - ce, hi);
 
     int i;
     int left_border = 0, left_border_max = INT_MIN;
@@ -48,7 +48,7 @@ static int maxSubArray(int* nums, int numsSize)
     }
     return max;
 #else
-    return recursive(nums, 0, numsSize - 1);
+    return partition(nums, 0, numsSize - 1);
 #endif
 }
 

054_spiral_matrix/spiral_matrix.c

@@ -60,9 +60,9 @@ int main(int argc, char **argv)
         mat[i] = malloc(col * sizeof(int));
         for (j = 0; j < col; j++) {
             mat[i][j] = ++count;
-printf("%d ", mat[i][j]);
+            printf("%d ", mat[i][j]);
         }
-printf("\n");
+        printf("\n");
     }
     int *nums = spiralOrder(mat, row, col);
     for (i = 0; i < row * col; i++) {

055_jump_game/jump_game.c

@@ -2,24 +2,22 @@
 #include <stdlib.h>
 #include <stdbool.h>
 
-static bool canJump(int* nums, int numsSize) {
-    if (numsSize == 0) return false;
+static inline int max(int a, int b)
+{
+    return a > b ? a : b;
+}
 
-    int i = numsSize - 1, j;
-    while (i > 0) {
-        if (nums[--i] == 0) {
-            for (j = i - 1; j >= 0; j--) {
-                if (nums[j] > i - j) {
-                    break;
-                }
-            }
-            if (j == -1) {
-                return false;
-            }
+static bool canJump(int* nums, int numsSize)
+{
+    int i, pos = 0;
+    for (i = 0; i < numsSize - 1; i++) {
+        if (pos < i || pos >= numsSize - 1) {
+            break;
         }
+        pos = max(i + nums[i], pos);
     }
 
-    return true;
+    return pos >= numsSize - 1;
 }
 
 int main(int argc, char **argv)

060_permutation_sequence/permutation_sequence.c

@@ -2,59 +2,34 @@
 #include <stdlib.h>
 #include <string.h>
 
-static void reverse(int *a, int size)
+static int factorial(int n)
 {
-    int left = 0;
-    int right = size - 1;
-    while (left < right) {
-        int tmp = a[left];
-        a[left] = a[right];
-        a[right] = tmp;
-        left++;
-        right--;
+    if (n == 0) {
+        return 0;
+    } else if (n == 1) {
+        return 1;
+    } else {
+        return n * factorial(n - 1);
     }
 }
 
-void nextPermutation(int* nums, int numsSize) {
-    if (numsSize <= 1) {
-        return;
-    }
-
-    int *p = nums + numsSize - 1;    
-    int *q = nums + numsSize - 1;
-
-    while (p != nums && *(p - 1) >= *p) {
-        p--;
-    }
-
-    if (p != nums) {
-        int n = *(p - 1);
-        while (*q <= n) {
-            q--;
-        }
-
-        int tmp = *q;
-        *q = *(p - 1);
-        *(p - 1) = tmp;
-    }
-    reverse(p, numsSize - (p - nums));
-}
-
-static char* getPermutation(int n, int k) {
+static char* getPermutation(int n, int k)
+{
     int i;
     int *permutation = malloc(n * sizeof(int));
     for (i = 0; i < n; i++) {
         permutation[i] = i + 1;
     }
-    while (--k > 0) {
-        nextPermutation(permutation, n);
-    }
+
     char *result = malloc(n + 1);
     for (i = 0; i < n; i++) {
-        result[i] = permutation[i] + '0';
+        int fac = factorial(n - i - 1);
+        int j = k > 1 ? (k - 1) / fac : 0;
+        result[i] = permutation[j] + '0';
+        k -= j * fac;
+        memmove(permutation + j, permutation + j + 1, (n - j) * sizeof(int));
     }
     result[n] = '\0';
-    free(permutation);
     return result;
 }
 

062_unique_path/unique_path.c

@@ -1,33 +1,8 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-static void valid_path_recursive(int col, int m, int row, int n, int *count)
+static int uniquePaths(int m, int n)
 {
-    if (col == m - 1 && row == n - 1) {
-        (*count)++;
-    } else {
-        if (m > n) {
-            if (col < m - 1) {
-                valid_path(col + 1, m, row, n, count);
-            }
-            if (row < n - 1) {
-                valid_path(col, m, row + 1, n, count);
-            }
-        } else {
-            if (col < m - 1) {
-                valid_path(col + 1, m, row, n, count);
-            }
-            if (row < n - 1) {
-                valid_path(col, m, row + 1, n, count);
-            }
-        }
-    }
-}
-
-static int uniquePaths(int m, int n) {
-    //int count = 0;
-    //valid_path(0, m, 0, n, &count);
-    //return count;
     int row, col;
     int *grids = malloc(m * n * sizeof(int));
     for (col = 0; col < m; col++) {
@@ -41,9 +16,7 @@ static int uniquePaths(int m, int n) {
             grids[row * m + col] = grids[row * m + col - 1] + grids[(row - 1) * m + col];
         }
     }
-    int result = grids[m * n - 1];
-    free(grids);
-    return result;
+    return grids[m * n - 1];
 }
 
 int main(int argc, char **argv)

064_minumum_path_sum/minimum_path_sum.c

@@ -1,9 +1,14 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <limits.h>
 
-int minPathSum(int** grid, int gridRowSize, int gridColSize) {
+static inline int min(int a, int b)
+{
+    return a < b ? a : b;
+}
+
+int minPathSum(int** grid, int gridRowSize, int gridColSize)
+{
     int i, j;
     int **dp = malloc(gridRowSize * sizeof(int *));
     for (i = 0; i < gridRowSize; i++) {
@@ -23,11 +28,9 @@ int minPathSum(int** grid, int gridRowSize, int gridColSize) {
         dp[0][i] = sum;
     }
 
-    int min = INT_MAX;
     for (i = 1; i < gridRowSize; i++) {
         for (j = 1; j < gridColSize; j++) {
-            int n = dp[i - 1][j] < dp[i][j - 1] ? dp[i - 1][j] : dp[i][j - 1];
-            dp[i][j] = n + grid[i][j];
+            dp[i][j] = grid[i][j] + min(dp[i - 1][j], dp[i][j - 1]);
         }
     }
 

065_valid_number/valid_number.c

@@ -1,57 +1,38 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdbool.h>
+#include <ctype.h>
 
-static bool isNumber(const char *s) {
-    bool point = false;
-    bool hasE = false;
-    
-    //trim the space
-    while(isspace(*s)) s++;
-    //check empty 
-    if (*s == '\0' ) return false;
-    //check sign
-    if (*s=='+' || *s=='-') s++;
-
-    const char *head  = s;
-    for(; *s!='\0'; s++){
-        // if meet point
-        if ( *s == '.' ){
-            if ( hasE == true || point == true){
-                return false;
-            }
-            if ( s == head && !isdigit(*(s+1))  ){
-                return false;
-            }
-            point = true; 
-            continue; 
-        }
-        //if meet "e"
-        if ( *s == 'e' ){
-            if ( hasE == true || s == head) {
-                return false;
-            }
-            s++;
-            if ( *s=='+' || *s=='-' )  s++;
-            if ( !isdigit(*s) ) return false;
-      
-            hasE = true; 
-            continue; 
-        }
-        //if meet space, check the rest chars are space or not
-        if (isspace(*s)){
-            for (; *s != '\0'; s++){
-                if (!isspace(*s)) return false;
-            }
-            return true;
-        }
-        if ( !isdigit(*s) ) {
-            return false;
+static bool isNumber(const char *s)
+{
+    while (*s == ' ')
+        ++s;
+    bool if_find_num = false;
+    if (*s == '-' || *s == '+')
+        ++s;
+    while (isdigit(*s)) {
+        if_find_num = true;
+        ++s;
+    }
+    if (*s == '.')
+        ++s;
+    while (isdigit(*s)) {
+        if_find_num = true;
+        ++s;
+    }
+    if (if_find_num == true && *s == 'e') {
+        ++s;
+        if (*s == '+' || *s == '-')
+            ++s;
+        if_find_num = false;
+        while (isdigit(*s)) {
+            if_find_num = true;
+            ++s;
         }
-       
     }
-    
-    return true; 
+    while (*s == ' ')
+        ++s;
+    return *s == '\0' && if_find_num == true;
 }
 
 int main(int argc, char** argv)

071_simplify_path/simplify_path.c

@@ -2,7 +2,8 @@
 #include <stdlib.h>
 #include <string.h>
 
-static char* simplifyPath(char* path) {
+static char* simplifyPath(char* path)
+{
     int len = strlen(path);
     if (len == 0) {
         return path;

072_edit_distance/edit_distance.c

@@ -4,41 +4,6 @@
 #include <string.h>
 
 /*
- *  Dynamic Programming
- *
- *    Definitaion
- *
- *        m[i][j] is minimal distance from word1[0..i] to word2[0..j]
- *
- *    So, 
- *
- *        1) if word1[i] == word2[j], then m[i][j] == m[i-1][j-1].
- *
- *        2) if word1[i] != word2[j], then we need to find which one below is minimal:
- *
- *             min( m[i-1][j-1], m[i-1][j],  m[i][j-1] )
- *            
- *             and +1 - current char need be changed.
- *
- *        Let's take a look  m[1][2] :  "a" => "ab" 
- *
- *               +---+  +---+                                         
- *        ''=> a | 1 |  | 2 | '' => ab                                
- *               +---+  +---+                                         
- *                                                                    
- *               +---+  +---+                                         
- *        a => a | 0 |  | 1 | a => ab                                 
- *               +---+  +---+                                         
- *                                                            
- *        To know the minimal distance `a => ab`, we can get it from one of the following cases:
- *
- *            1) delete the last char in word1,  minDistance( '' => ab ) + 1                                                             
- *            2) delete the last char in word2,  minDistance(  a => a ) + 1                                                             
- *            3) change the last char,           minDistance( '' => a ) + 1                                                             
- *                                                            
- *  
- *    For Example:
- *
  *        word1="abb", word2="abccb"
  *
  *        1) Initialize the DP matrix as below:
@@ -56,9 +21,13 @@
  *            a   1 0 1 2 3 4 
  *            b   2 1 0 1 2 3
  *            b   3 2 1 1 2 2
- *
  */ 
 
+static inline int min(int a, int b)
+{
+    return a < b ? a : b;
+}
+
 static int minDistance(char* word1, char* word2)
 {
     int i, j;
@@ -82,9 +51,7 @@ static int minDistance(char* word1, char* word2)
             if (word1[i - 1] == word2[j - 1]) {
                 dp[i][j] = dp[i - 1][j - 1];
             } else {
-                int min = dp[i - 1][j] > dp[i][j - 1] ? dp[i][j - 1] : dp[i - 1][j];
-                dp[i][j] = min > dp[i - 1][j - 1] ? dp[i - 1][j - 1] : min;
-                dp[i][j] += 1;
+                dp[i][j] = 1 + min(dp[i - 1][j - 1], min(dp[i - 1][j], dp[i][j - 1]));
             }
         }
     }