initial publish

leetcode solutions in c.

Author: Victor

1. Two Sum.c

@@ -0,0 +1,97 @@
+/*
+1. Two Sum
+
+Given an array of integers, return indices of the two numbers such that they add up to a specific target.
+
+You may assume that each input would have exactly one solution, and you may not use the same element twice.
+
+
+Example:
+Given nums = [2, 7, 11, 15], target = 9,
+
+Because nums[0] + nums[1] = 2 + 7 = 9,
+return [0, 1].
+*/
+
+/**
+ * Note: The returned array must be malloced, assume caller calls free().
+ */
+typedef struct data_s {
+    int val;
+    int idx;
+} data_t;
+int cmp(const void *a, const void *b) {
+    return ((data_t *)a)->val - ((data_t *)b)->val;
+}
+int* twoSum(int* nums, int numsSize, int target) {
+    int *indices;
+    int i, j, k;
+    
+#if 0
+    for (i = 0; i < numsSize - 1; i ++) {
+        for (j = i + 1; j < numsSize; j ++) {
+            if (nums[i] + nums[j] == target) {
+                indices = malloc(2 * sizeof(int));
+                //assert(indices);
+                indices[0] = i;
+                indices[1] = j;
+                return indices;
+            }
+        }
+    }
+#else
+    data_t *array;
+    array = malloc((numsSize + 1) * sizeof(data_t));
+    //assert(array);
+    for (i = 0; i < numsSize; i ++) {
+        array[i].val = nums[i];
+        array[i].idx = i;
+    }
+    qsort(array, numsSize, sizeof(data_t), cmp);
+    i = 0;
+    j = numsSize - 1;
+    while (i < j) {
+        k = array[i].val + array[j].val;
+        if (k == target) {
+            indices = malloc(2 * sizeof(int));
+            //assert(indices);
+            indices[0] = array[i].idx;
+            indices[1] = array[j].idx;
+            free(array);
+            return indices;
+        } else if (k < target) {
+            i ++;
+        } else {
+            j --;
+        }
+    }
+    free(array);
+#endif
+    
+    return NULL;
+}
+
+
+/*
+Difficulty:Easy
+Total Accepted:586.7K
+Total Submissions:1.7M
+
+
+Companies LinkedIn Uber Airbnb Facebook Amazon Microsoft Apple Yahoo Dropbox Bloomberg Yelp Adobe
+Related Topics Array Hash Table
+Similar Questions 
+                
+                  
+                    3Sum
+                  
+                    4Sum
+                  
+                    Two Sum II - Input array is sorted
+                  
+                    Two Sum III - Data structure design
+                  
+                    Subarray Sum Equals K
+                  
+                    Two Sum IV - Input is a BST
+*/

10. Regular Expression Matching.c

@@ -0,0 +1,102 @@
+/*
+10. Regular Expression Matching
+
+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
+*/
+
+#define NOT_MATCH(A, B) (((B) == '.' && (A) == 0) || ((B) != '.' && (A) != (B)))
+#define MATCH(A, B)     ((A) == (B) || (B) == '.')
+#define IDX(I, J)       (((I) + 1) * (plen + 1) + (J) + 1)
+​
+bool match_recursive(char *s, char *p, int *retry) {
+    if (*p == 0) return *s == 0;
+    if (*(p + 1) == '*') {
+        while (*retry) {
+            if (match_recursive(s, p + 2, retry)) {
+                return true;
+            }
+            if (NOT_MATCH(*s, *p)) {
+                return false;
+            }
+            s ++;
+        }
+        *retry = 0;
+        return false;
+    }
+    if (NOT_MATCH(*s, *p)) {
+        return false;
+    }
+    return match_recursive(s + 1, p + 1, retry);
+}
+bool isMatch(char* s, char* p) {
+#if 0  // 22ms
+    int retry = 1;
+    return match_recursive(s, p, &retry);
+#else  // 9ms
+    int *dp;
+    int i, j;
+    int slen, plen;
+    
+    slen = strlen(s);
+    plen = strlen(p);
+    
+    dp = calloc((slen + 1) * (plen + 1), sizeof(int));
+    //assert(dp);
+​
+    dp[0] = 1;
+    for (j = 0; j < plen; j ++) {
+        if (p[j] == '*') {
+            dp[IDX(-1, j)] = dp[IDX(-1, j - 2)];
+        }
+    }
+    for (i = 0; i < slen; i++) {
+        for (j = 0; j < plen; j++) {
+            if (p[j] != '*') {
+                dp[IDX(i, j)] = dp[IDX(i - 1, j - 1)] && MATCH(s[i], p[j]);
+            } else {
+                dp[IDX(i, j)] = dp[IDX(i, j - 2)] ||                                 // no s
+                                dp[IDX(i, j - 1)] ||                                 // one s
+                                (MATCH(s[i], p[j - 1]) && dp[IDX(i - 1, j)]);        // more s
+            }
+        }
+    }
+    
+    i = dp[IDX(slen - 1, plen - 1)];
+    
+    free(dp);
+    
+    return i;
+#endif
+}
+
+
+/*
+Difficulty:Hard
+Total Accepted:147.1K
+Total Submissions:610.5K
+
+
+Companies Google Uber Airbnb Facebook Twitter
+Related Topics Dynamic Programming Backtracking String
+Similar Questions 
+                
+                  
+                    Wildcard Matching
+*/

101. Symmetric Tree.c

@@ -0,0 +1,85 @@
+/*
+101. Symmetric Tree
+
+Given a binary tree, check whether it is a mirror of itself (ie, symmetric around its center).
+
+
+For example, this binary tree [1,2,2,3,4,4,3] is symmetric:
+    1
+   / \
+  2   2
+ / \ / \
+3  4 4  3
+
+
+
+But the following [1,2,2,null,3,null,3]  is not:
+    1
+   / \
+  2   2
+   \   \
+   3    3
+
+
+
+
+Note:
+Bonus points if you could solve it both recursively and iteratively.
+*/
+
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     struct TreeNode *left;
+ *     struct TreeNode *right;
+ * };
+ */
+#define PUSH(N) do { p[n ++] = N; } while (0)
+​
+bool isSymmetric(struct TreeNode* root) {
+    struct TreeNode **p, **tmp;
+    int dep, n, i, j, k;
+    
+    if (!root) return true;
+    
+    dep = 0; n = 0;
+    p = malloc((1 << dep) * sizeof(struct TreeNode *));
+    //assert(p);
+    PUSH(root);
+    while (n) {
+        for (i = 0, j = n - 1; i < j; i ++, j --) {
+            if ((!p[i] && p[j]) ||
+                (!p[j] && p[i]) ||
+                ( p[i] && p[i]->val != p[j]->val)) {
+                free(p);
+                return false;
+            }
+        }
+        tmp = p; k = n;
+        dep ++; n = 0;
+        p = malloc((1 << dep) * sizeof(struct TreeNode *));
+        //assert(p);
+        for (i = 0; i < k; i ++) {
+            if (tmp[i]) {
+                PUSH(tmp[i]->left);
+                PUSH(tmp[i]->right);
+            }
+        }
+        free(tmp);
+    }
+    free(p);
+    return true;
+}
+
+
+/*
+Difficulty:Easy
+Total Accepted:187.9K
+Total Submissions:484.8K
+
+
+Companies LinkedIn Bloomberg Microsoft
+Related Topics Tree Depth-first Search Breadth-first Search
+
+*/