add some codes

Author: supercoderhawk

C/1-50/10-Regular-Expression-Matching.c

@@ -0,0 +1,31 @@
+/*
+ * Implement regular expression matching with support for '.' and '*'.
+
+ * '.' Matches any single character.
+ * '*' Matches zero or more of the preceding element.
+
+ * The matching should cover the entire input string (not partial).
+
+ * The function prototype should be:
+ * bool isMatch(const char *s, const char *p)
+
+ * Some examples:
+ * isMatch("aa","a") ? false
+ * isMatch("aa","aa") ? true
+ * isMatch("aaa","aa") ? false
+ * isMatch("aa", "a*") ? true
+ * isMatch("aa", ".*") ? true
+ * isMatch("ab", ".*") ? true
+ * isMatch("aab", "c*a*b") ? true
+ * Created by supercoderx on 2017/8/11.
+ */
+
+#include "../main.h"
+#include 
+
+bool isMatch(char* s, char* p) {
+    if(p == NULL || *p){
+        return *s;
+    }
+
+}

C/1-50/46-Permutations.c

@@ -0,0 +1,52 @@
+/*
+ * Given a collection of distinct numbers, return all possible permutations.
+
+ * For example,
+ * [1,2,3] have the following permutations:
+ * [
+ *   [1,2,3],
+ *   [1,3,2],
+ *   [2,1,3],
+ *   [2,3,1],
+ *   [3,1,2],
+ *   [3,2,1]
+ * ]
+ * Created by supercoderx on 2017/8/14.
+ */
+#include 
+#include 
+int** permute(int* nums, int numsSize, int* returnSize) {
+    *returnSize = 0;
+    if(numsSize == 0)
+        return NULL;
+    *returnSize = 1;
+    
+    for(int i = 1; i <=numsSize;i++)
+        *returnSize *= i;
+
+    int ** result = malloc(sizeof(int*)**returnSize);
+    for(int i = 0;i < *returnSize;i++)
+        result[i] = malloc(sizeof(int)*numsSize);
+    int start = 0,index = start,cur=*returnSize;
+    for(int i = 0; i <numsSize;i++){
+            index = start-1;
+        cur/=numsSize;
+        for(int j =0; j<*returnSize;j++){
+            result[j][i] = nums[++index%numsSize];
+        }
+        start++;
+    }
+
+    return result;
+}
+
+void testPermute(){
+    int a[] = {1,2,3},count = 0;
+    int** result = permute(a,3,&count);
+    for(int i = 0; i <count;i++){
+        for(int j =0 ;j<3;j++){
+            printf("%d,",result[i][j]);
+        }
+        printf("\n");
+    }
+}

C/1-50/49-Group Anagrams.c

@@ -0,0 +1,87 @@
+/*
+ * Given an array of strings, group anagrams together.
+
+ * For example, given: ["eat", "tea", "tan", "ate", "nat", "bat"],
+ * Return:
+ *
+ * [
+ *   ["ate", "eat","tea"],
+ *   ["nat","tan"],
+ *   ["bat"]
+ * ]
+ * Created by supercoderx on 2017/8/15.
+ */
+
+#include 
+#include 
+#include 
+char*** groupAnagrams(char** strs, int strsSize, int** columnSizes, int* returnSize) {
+    *returnSize = 0;
+    if(strsSize == 0)
+        return NULL;
+    int strSize[strsSize],len=0,**hash = NULL,*hashLen =NULL,*rowLen=NULL,*word,id,*col;
+    char *s,***result=NULL,**row=NULL,*w;
+    columnSizes = NULL;
+
+    for (int i = 0; i <strsSize ; ++i) {
+        strSize[i] = 0;
+        s = strs[i];
+        while(*s!='\0'){
+            strSize[i]++;
+            s++;
+        }
+    }
+    for (int j = 0; j < strsSize; ++j) {
+            if(hash == NULL){
+                word = malloc(sizeof(int)*26);
+                for (int i = 0; i < 26; ++i) {
+                    word[i] = 0;
+                }
+                for (int k = 0; k < strSize[j]; ++k) {
+                    word[strs[j][k]-'a']++;
+                }
+                hash = malloc(sizeof(int*));
+                hash[len] = word;
+                hashLen = malloc(sizeof(int));
+                hashLen[len++] = strSize[j];
+                row = malloc(sizeof(char*));
+                row[0] = strs[j];
+                result = malloc(sizeof(char**));
+                result[0] = row;
+                columnSizes = malloc(sizeof(int*));
+                col= malloc(sizeof(int));
+                col[0] = strSize[j];
+                columnSizes[0] = col;
+                rowLen = malloc(sizeof(int));
+                rowLen[0] = 1;
+            } else{
+                int i;
+                for (i = 0; i <len ; ++i) {
+                    if(strSize[j]!=hashLen[i])
+                        continue;
+                    word = malloc(sizeof(int)*26);
+                    for (int p = 0; p < 26; ++p) {
+                        word[p] = 0;
+                    }
+                    for (int k = 0; k < strSize[j]; ++k) {
+                        word[strs[j][k]-'a']++;
+                    }
+                    int l;
+                    for (l = 0; l <26 ; ++l) {
+                        if(word[l]!=hash[i][l])
+                            break;
+                    }
+                    free(word);
+                    if(l != 26 )
+                        continue;
+                    id = 0;
+                    for (int m = 0; m < rowLen[i]-1; ++m) {
+                        if(strcmp(strs[j],result[i][m])>=0 &&strcmp(strs[j],result[i][m])<=0){
+
+                        }
+                    }
+                }
+            }
+    }
+
+}

C/51-100/53-Maximum-Subarray.c

@@ -0,0 +1,28 @@
+/*
+ * Find the contiguous subarray within an array (containing at least one number) which has the largest sum.
+
+ * For example, given the array [-2,1,-3,4,-1,2,1,-5,4],
+ * the contiguous subarray [4,-1,2,1] has the largest sum = 6.
+ * Created by supercoderx on 2017/8/15.
+ */
+#include 
+#include 
+int maxSubArray(int* nums, int numsSize) {
+    if(numsSize == 1)
+        return nums[0];
+    int sum=0,maxSum = 0;
+    for (int i = 0; i < numsSize; ++i) {
+        sum+=nums[i];
+        if(sum>maxSum)
+            maxSum = sum;
+        else if(sum<0)
+            sum = 0;
+    }
+    return maxSum;
+}
+
+void testMaxSubArray(){
+    // int a[] = {-2,1,-3,4,-1,2,1,-5,4};
+    int a[] = {-2,-1};
+    printf("%d",maxSubArray(a,sizeof(a)/sizeof(int)));
+}

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)
+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)
 add_executable(C ${SOURCE_FILES})

C/headers/problem_1_50.h

@@ -19,6 +19,10 @@ void testAddTwoNumbers();
 int lengthOfLongestSubstring(char* s);
 void testLengthOfLongestSubstring();
 
+// problem 4
+double findMedianSortedArrays(int* nums1, int nums1Size, int* nums2, int nums2Size);
+void testFindMedianSortedArrays();
+
 // problem 5
 char* longestPalindrome(char* s);
 void testLongestPalindrome();
@@ -42,4 +46,96 @@ void testIsPalindrome();
 // problem 11
 int maxArea(int* height, int heightSize);
 void testMaxArea();
+
+// problem 13
+int romanToInt(char* s);
+void testRomanToInt();
+
+// problem 14
+char *longestCommonPrefix(char **strs, int strsSize);
+void testLongestCommonPrefix();
+
+// problem 15
+int** threeSum(int* nums, int numsSize, int* returnSize);
+void testThreeSum();
+
+// problem 17
+char **letterCombinations(char *digits, int *returnSize);
+void testLetterCombinations();
+
+// problem 18
+int **fourSum(int *nums, int numsSize, int target, int *returnSize);
+void testFourSum();
+
+// problem 20
+bool isValid(char* s);
+void testIsValid();
+
+// problem 21
+struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2);
+void testMergeTwoLists();
+
+// problem 22
+char** generateParenthesis(int n, int* returnSize);
+void testGenerateParenthesis();
+
+// problem 23
+struct ListNode* mergeKLists(struct ListNode** lists, int listsSize);
+void testMergeKLists();
+
+// problem 26
+int removeDuplicates(int* nums, int numsSize);
+void testRemoveDuplicates();
+
+// problem 28
+int strStr(char* haystack, char* needle);
+void testStrStr();
+
+// problem 29
+int divide(int dividend, int divisor);
+void testDivide();
+
+// problem 32
+int longestValidParentheses(char* s);
+void testLongestValidParentheses();
+
+// problem 33
+int search(int* nums, int numsSize, int target);
+void testSearch();
+
+// problem 34
+int *searchRange(int *nums, int numsSize, int target, int *returnSize);
+void testSearchRange();
+
+// problem 36
+bool isValidSudoku(char **board, int boardRowSize, int boardColSize);
+void testIsValidSudoku();
+
+// problem
+char* countAndSay(int n);
+void testCountAndSay();
+
+// problem 41
+int firstMissingPositive(int* nums, int numsSize);
+void testFirstMissingPositive();
+
+// problem 42
+int trap(int* height, int heightSize);
+void testTrap();
+
+// problem 44
+bool isWildcardMatch(char* s, char* p);
+void testIsWildcardMatch();
+
+// problem 46
+int** permute(int* nums, int numsSize, int* returnSize);
+void testPermute();
+
+// problem 48
+void rotate(int** matrix, int matrixRowSize, int matrixColSize);
+void testRotate();
+
+// problem 50
+double myPow(double x, int n);
+void testMyPow();
 #endif //C_PROBLEM_1_50_H

C/headers/problem_51_100.h

@@ -0,0 +1,11 @@
+/*
+ * Created by supercoderx on 2017/8/15.
+ */
+
+#ifndef C_PROBLEM_51_100_H
+#define C_PROBLEM_51_100_H
+
+// problem 53
+int maxSubArray(int* nums, int numsSize);
+void testMaxSubArray();
+#endif //C_PROBLEM_51_100_H

C/main.c

@@ -5,6 +5,7 @@
 #include 
 #include "main.h"
 #include "headers/problem_1_50.h"
+#include "headers/problem_51_100.h"
 #include "headers/problem_151_200.h"
 #include "headers/problem_201_250.h"
 #include "headers/problem_301_350.h"
@@ -41,13 +42,42 @@ void test_1_50() {
     // testTwoSum();
     // testAddTwoNumbers();
     // testLengthOfLongestSubstring();
+    // testFindMedianSortedArrays();
     // testLongestPalindrome();
     // testConvert();
     // testReverse();
     // testMyAtoi();
     // testIsPalindrome();
-    /// testConvert();
-    testMaxArea();
+    // testConvert();
+    // testMaxArea();
+    // testLongestCommonPrefix();
+    // testThreeSum();
+    // testLetterCombinations();
+    // testFourSum();
+    // testIsValid();
+    // testMergeTwoLists();
+    // testGenerateParenthesis();
+    // testMergeKLists();
+    // testRemoveDuplicates();
+    // testStrStr();
+    // testDivide();
+    // testRomanToInt();
+    // testLongestValidParentheses();
+    // testSearch();
+    // testSearchRange();
+    // testIsValidSudoku();
+    // testFirstMissingPositive();
+    // testTrap();
+    // testIsMatch();
+    // testIsWildcardMatch();
+    // testPermute();
+    // testRotate();
+    // testCountAndSay();
+    testMyPow();
+}
+
+void test_51_100() {
+    testMaxSubArray();
 }
 
 void test_151_200() {
@@ -64,6 +94,7 @@ void test_301_350() {
 
 //
 int main(int argc, char *argv[]) {
-    test_1_50();
+    // test_1_50();
+    test_51_100();
     // test_151_200();
 }