add some algorithms

Author: supercoderhawk

C/51-100/55-Jump-Game.c

@@ -0,0 +1,34 @@
+/*
+ * Given an array of non-negative integers, you are initially positioned at the first index of the array.
+
+ * Each element in the array represents your maximum jump length at that position.
+
+ * Determine if you are able to reach the last index.
+
+ * For example:
+ * A = [2,3,1,1,4], return true.
+
+ * A = [3,2,1,0,4], return false.
+ * Created by supercoderhawk on 2017/8/17.
+ */
+
+#include "../main.h"
+#include 
+
+bool canJump(int *nums, int numsSize) {
+    if (numsSize == 0)
+        return false;
+
+    int i = 0, maxJump;
+    for (int reach = 0; i < numsSize && i <= reach; ++i) {
+        maxJump = nums[i] + i;
+        reach = reach > maxJump ? reach : maxJump;
+    }
+    return i == numsSize;
+}
+
+void testCanJump() {
+    int nums[] = {2, 3, 1, 1, 4};
+    int nums1[] = {3, 2, 1, 0, 4};
+    printf("%d", canJump(nums, sizeof(nums) / sizeof(int)));
+}

C/51-100/56-Merge-Intervals.c

@@ -0,0 +1,20 @@
+/*
+ * Given a collection of intervals, merge all overlapping intervals.
+
+ * For example,
+ * Given [1,3],[2,6],[8,10],[15,18],
+ * return [1,6],[8,10],[15,18].
+ * Created by supercoderhawk on 2017/8/18.
+ */
+
+#include 
+#include 
+#include "../main.h"
+
+struct Interval* merge(struct Interval* intervals, int intervalsSize, int* returnSize) {
+
+}
+
+void testMerge(){
+
+}

C/51-100/62-Unique-Paths.c

@@ -0,0 +1,40 @@
+/*
+ * A robot is located at the top-left corner of a m x n grid (marked 'Start' in the diagram below).
+
+ * The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked 'Finish' in the diagram below).
+
+ * How many possible unique paths are there?
+ * Note: m and n will be at most 100.
+ * Created by supercoderhawk on 2017/8/18.
+ */
+#include 
+void trace(int x, int y,int m,int n, int *count){
+    if(x == m && y == n){
+        (*count)++;
+        return;
+    }
+    if(x<m)
+        trace(++x,y,m,n,count);
+    if(y<n)
+        trace(x,++y,m,n,count);
+}
+
+int uniquePaths(int m, int n) {
+    /*int count = 0;
+    trace(1,1,m,n,&count);
+    return count;*/
+    int grid[m][n];
+    for (int i = 0; i < m; ++i) {
+        for (int j = 0; j <n ; ++j) {
+            if(i == 0 || j == 0)
+                grid[i][j] = 1;
+            else
+                grid[i][j] = grid[i-1][j]+grid[i][j-1];
+        }
+    }
+    return grid[m-1][n-1];
+}
+
+void testUniquePaths(){
+    printf("%d",uniquePaths(3,3));
+}

C/51-100/66-Plus-One.c

@@ -0,0 +1,43 @@
+/*
+ * Given a non-negative integer represented as a non-empty array of digits, plus one to the integer.
+
+ * You may assume the integer do not contain any leading zero, except the number 0 itself.
+
+ * The digits are stored such that the most significant digit is at the head of the list.
+ * Created by supercoderhawk on 2017/8/18.
+ */
+#include 
+#include 
+
+int* plusOne(int* digits, int digitsSize, int* returnSize) {
+    *returnSize = digitsSize;
+    int *result = malloc(sizeof(int)*digitsSize), plus;
+    result[digitsSize-1] = (digits[digitsSize-1]+1)%10;
+    plus = (digits[digitsSize-1]+1)/10;
+    for (int i = digitsSize-2; i >=0 ; --i) {
+        if(plus!=0){
+            result[i] = (digits[i]+1)%10;
+            plus = (digits[i]+1)/10;
+        }else{
+            result[i] = digits[i];
+        }
+    }
+    if(plus!=0){
+        result = realloc(result, sizeof(int)*(digitsSize+1));
+        for (int i = digitsSize-1; i >=0 ; --i) {
+            result[i+1] = result[i];
+        }
+        result[0] = plus;
+        (*returnSize)++;
+    }
+
+    return result;
+}
+
+void testPlusOne(){
+    int a[] = {1,1,9},count=0;
+    int* res = plusOne(a,sizeof(a)/ sizeof(int),&count);
+    for (int i = 0; i <count ; ++i) {
+        printf("%d,",res[i]);
+    }
+}

C/51-100/69-Sqrt(x).c

@@ -0,0 +1,27 @@
+/*
+ * Implement int sqrt(int x).
+
+ * Compute and return the square root of x.
+ * Created by supercoderhawk on 2017/8/18.
+ */
+#include 
+#include 
+int mySqrt(int x) {
+    if(x == 0)
+        return 0;
+    int left = 0,right = INT_MAX,mid;
+    while (1){
+        mid = (left+right)/2;
+        if(mid>x/mid){
+            right = mid -1;
+        }else{
+            if(mid+1>x/(mid+1))
+                return mid;
+            left =  mid+1;
+        }
+    }
+}
+
+void testMySqrt(){
+    printf("%d",mySqrt(0));
+}

C/51-100/70-Climbing-Stairs.c

@@ -0,0 +1,22 @@
+/*
+ * You are climbing a stair case. It takes n steps to reach to the top.
+
+ * Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?
+
+ * Note: Given n will be a positive integer.
+ * Created by supercoderhawk on 2017/8/18.
+ */
+#include 
+int climbStairs(int n) {
+    if (n <= 1)
+        return n;
+    int curr_ways = 1, next_ways = 1;
+    for (int i = 1; i <= n; ++i) {
+        curr_ways = (next_ways += curr_ways) - curr_ways;
+    }
+    return curr_ways;
+}
+
+void testClimbStairs(){
+printf("%d",climbStairs(2));
+}

C/51-100/73-Set-Matrix-Zeroes.c

@@ -0,0 +1,64 @@
+/*
+ * Given a m x n matrix, if an element is 0, set its entire row and column to 0. Do it in place.
+ * Created by supercoderhawk on 2017/8/21.
+ */
+#include 
+#include 
+
+void setZeroes(int **matrix, int matrixRowSize, int matrixColSize) {
+    int isRow = 0;
+    for (int i = 0; i < matrixRowSize; ++i) {
+        for (int j = 0; j < matrixColSize; ++j) {
+            if (matrix[i][j] == 0) {
+                if (i == 0) {
+                    isRow = 1;
+                    matrix[0][j] = 0;
+                } else {
+                    matrix[i][0] = matrix[0][j] = 0;
+                }
+            }
+        }
+    }
+
+    for (int k = 1; k < matrixRowSize; ++k) {
+        if (matrix[k][0] == 0)
+            for (int i = 0; i < matrixColSize; ++i) {
+                matrix[k][i] = 0;
+            }
+    }
+
+    for (int l = 1; l < matrixColSize; ++l) {
+        if (matrix[0][l] == 0) {
+            for (int i = 1; i < matrixRowSize; ++i) {
+                matrix[i][l] = 0;
+            }
+        }
+    }
+    if (matrix[0][0] == 0)
+        for (int m = 0; m < matrixRowSize; ++m) {
+            matrix[m][0] = 0;
+        }
+    if (isRow)
+        for (int n = 0; n < matrixColSize; ++n) {
+            matrix[0][n] = 0;
+        }
+}
+
+void testSetZeroes() {
+    int **m = malloc(sizeof(int *) * 2);
+    m[0] = malloc(sizeof(int) * 3);
+    m[1] = malloc(sizeof(int) * 3);
+    m[0][0] = 1;
+    m[0][1] = 1;
+    m[0][2] = 1;
+    m[1][0] = 0;
+    m[1][1] = 1;
+    m[1][2] = 2;
+
+    setZeroes(m, 2, 3);
+    for (int i = 0; i < 2; ++i) {
+        for (int j = 0; j < 3; ++j) {
+            printf("%d,", m[i][j]);
+        }
+    }
+}

C/51-100/75-Sort-Colors.c

@@ -0,0 +1,13 @@
+/*
+ * Given an array with n objects colored red, white or blue, sort them so that objects of the same color are adjacent, with the colors in the order red, white and blue.
+
+ * Here, we will use the integers 0, 1, and 2 to represent the color red, white, and blue respectively.
+
+ * Note:
+ * You are not suppose to use the library's sort function for this problem.
+ * Created by supercoderhawk on 2017/8/21.
+ */
+
+void sortColors(int* nums, int numsSize) {
+
+}

C/CMakeLists.txt

@@ -3,5 +3,5 @@ project(C)
 
 set(CMAKE_C_STANDARD 99)
 
-set(SOURCE_FILES main.c 301-350/328-Odd-Even-Linked-List.c 201-250/233-Number-of-Digit-One.c 1-50/1-Two-Sum.c 1-50/2-Add-Two_Numbers.c 1-50/3-Longest-Substring-Without-Repeating-Characters.c 1-50/5.-Longest-Palindromic-Substring.c 1-50/7-Reverse-Integer.c 1-50/8-String-to-Integer-atoi.c 1-50/6-ZigZag-Conversion.c 1-50/9-Palindrome-Number.c headers/problem_301_350.h headers/problem_201_250.h 151-200/172.-Factorial-Trailing-Zeroes.c "201-250/224-Basic-Calculator .c" headers/problem_151_200.h 1-50/11.-Container-With-Most-Water.c 1-50/4-Median-of-Two-Sorted-Arrays.c 1-50/14-Longest-Common-Prefix.c 1-50/15-3Sum.c 1-50/17-Letter-Combinations-of-a-Phone-Number.c 1-50/18-4Sum.c 1-50/20-Valid-Parentheses.c 1-50/19-Remove-Nth-Node-From-End-of-List.c 1-50/21-Merge-Two-Sorted-Lists.c 1-50/22-Generate-Parentheses.c 1-50/23-Merge-k-Sorted-Lists.c 1-50/26-Remove-Duplicates-from-Sorted-Array.c "1-50/28-Implement-strStr().c" 1-50/29-Divide-Two-Integers.c 1-50/13-Roman-to-Integer.c 1-50/10-Regular-Expression-Matching.c 1-50/33-Search-in-Rotated-Sorted-Array.c 1-50/32-Longest-Valid-Parentheses.c 1-50/34-Search-for-a-Range.c 1-50/36-Valid-Sudoku.c 1-50/38-Count-and-Say.c 1-50/41-First-Missing-Positive.c 1-50/42-Trapping-Rain-Water.c 1-50/44-Wildcard-Matching.c 1-50/46-Permutations.c 1-50/48-Rotate-Image.c "1-50/49-Group Anagrams.c" "1-50/50-Pow(x, n).c" 51-100/53-Maximum-Subarray.c headers/problem_51_100.h)
+set(SOURCE_FILES main.c 301-350/328-Odd-Even-Linked-List.c 201-250/233-Number-of-Digit-One.c 1-50/1-Two-Sum.c 1-50/2-Add-Two_Numbers.c 1-50/3-Longest-Substring-Without-Repeating-Characters.c 1-50/5.-Longest-Palindromic-Substring.c 1-50/7-Reverse-Integer.c 1-50/8-String-to-Integer-atoi.c 1-50/6-ZigZag-Conversion.c 1-50/9-Palindrome-Number.c headers/problem_301_350.h headers/problem_201_250.h 151-200/172.-Factorial-Trailing-Zeroes.c "201-250/224-Basic-Calculator .c" headers/problem_151_200.h 1-50/11.-Container-With-Most-Water.c 1-50/4-Median-of-Two-Sorted-Arrays.c 1-50/14-Longest-Common-Prefix.c 1-50/15-3Sum.c 1-50/17-Letter-Combinations-of-a-Phone-Number.c 1-50/18-4Sum.c 1-50/20-Valid-Parentheses.c 1-50/19-Remove-Nth-Node-From-End-of-List.c 1-50/21-Merge-Two-Sorted-Lists.c 1-50/22-Generate-Parentheses.c 1-50/23-Merge-k-Sorted-Lists.c 1-50/26-Remove-Duplicates-from-Sorted-Array.c "1-50/28-Implement-strStr().c" 1-50/29-Divide-Two-Integers.c 1-50/13-Roman-to-Integer.c 1-50/10-Regular-Expression-Matching.c 1-50/33-Search-in-Rotated-Sorted-Array.c 1-50/32-Longest-Valid-Parentheses.c 1-50/34-Search-for-a-Range.c 1-50/36-Valid-Sudoku.c 1-50/38-Count-and-Say.c 1-50/41-First-Missing-Positive.c 1-50/42-Trapping-Rain-Water.c 1-50/44-Wildcard-Matching.c 1-50/46-Permutations.c 1-50/48-Rotate-Image.c "1-50/49-Group Anagrams.c" "1-50/50-Pow(x, n).c" 51-100/53-Maximum-Subarray.c headers/problem_51_100.h 51-100/54-Spiral-Matrix.c 51-100/55-Jump-Game.c 51-100/56-Merge-Intervals.c 51-100/62-Unique-Paths.c 51-100/66-Plus-One.c "51-100/69-Sqrt(x).c" 51-100/70-Climbing-Stairs.c 51-100/73-Set-Matrix-Zeroes.c 51-100/75-Sort-Colors.c)
 add_executable(C ${SOURCE_FILES})

C/headers/problem_1_50.h

@@ -43,6 +43,10 @@ void testMyAtoi();
 bool isPalindrome(int x);
 void testIsPalindrome();
 
+// problem 11
+bool isMatch(char* s, char* p);
+void testIsMatch();
+
 // problem 11
 int maxArea(int* height, int heightSize);
 void testMaxArea();
@@ -111,7 +115,7 @@ void testSearchRange();
 bool isValidSudoku(char **board, int boardRowSize, int boardColSize);
 void testIsValidSudoku();
 
-// problem
+// problem 38
 char* countAndSay(int n);
 void testCountAndSay();
 

C/headers/problem_51_100.h

@@ -8,4 +8,32 @@
 // problem 53
 int maxSubArray(int* nums, int numsSize);
 void testMaxSubArray();
+
+// problem 54
+int* spiralOrder(int** matrix, int matrixRowSize, int matrixColSize);
+void testSpiralOrder();
+
+// problem 55
+bool canJump(int* nums, int numsSize);
+void testCanJump();
+
+// problem 62
+int uniquePaths(int m, int n);
+void testUniquePaths();
+
+// problem 66
+int* plusOne(int* digits, int digitsSize, int* returnSize);
+void testPlusOne();
+
+// problem 69
+int mySqrt(int x);
+void testMySqrt();
+
+// problem 70
+int climbStairs(int n);
+void testClimbStairs();
+
+// problem 73
+void setZeroes(int **matrix, int matrixRowSize, int matrixColSize);
+void testSetZeroes();
 #endif //C_PROBLEM_51_100_H

C/main.c

@@ -73,11 +73,19 @@ void test_1_50() {
     // testPermute();
     // testRotate();
     // testCountAndSay();
-    testMyPow();
+    // testMyPow();
+    testIsMatch();
 }
 
 void test_51_100() {
-    testMaxSubArray();
+    // testMaxSubArray();
+    // testSpiralOrder();
+    // testCanJump();
+    // testUniquePaths();
+    // testPlusOne();
+    // testMySqrt();
+    // testClimbStairs();
+    testSetZeroes();
 }
 
 void test_151_200() {

C/main.h

@@ -17,4 +17,9 @@ struct ListNode *createList(const int *vals, int count);
 
 void printList(struct ListNode *l);
 
+struct Interval {
+    int start;
+    int end;
+};
+
 #endif //C_MAIN_H