renew

Author: lemon8888

0001-two-sum.c renamed to 0001-two-sum/0001-two-sum.c

@@ -0,0 +1,11 @@
+#利用哈希表，空间换时间
+class Solution:
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        n=len(nums)
+        mapper={}
+        for i in range(n):
+            if (target-nums[i] in mapper):
+                return [mapper[target-nums[i]],i]
+            else:
+                mapper[nums[i]]=i
+        return []

0001-two-sum/0001-two-sum.py

@@ -0,0 +1,12 @@
+int findMaxConsecutiveOnes(int* nums, int numsSize) {
+    int count = 0, max = 0;
+    for(int i = 0; i < numsSize; i++) {
+        if(nums[i] == 1) {
+            count++;
+        } else {
+            count = 0;
+        }
+        max = fmax(max, count);
+    }
+    return max;
+}

0485-max-consecutive-ones.c

@@ -0,0 +1,20 @@
+int** matrixReshape(int** nums, int numsSize, int* numsColSize, int r, int c, int* returnSize, int** returnColumnSizes) {
+    if(r * c != numsSize * numsColSize[0]) {
+        *returnSize = numsSize;
+        *returnColumnSizes = numsColSize;
+        return nums;
+    }
+    *returnSize = r;
+    *returnColumnSizes = (int*)malloc(sizeof(int) * r);
+    int **ret = (int**)malloc(sizeof(int*)*r);
+    for(int i = 0; i < r; i++) {
+        (*returnColumnSizes)[i] = c;
+        ret[i] = (int*)malloc(sizeof(int) * c);
+    }
+    for(int i = 0; i < r; i++) {
+        for(int j = 0; j < c; j++) {
+            ret[i][j] = nums[(i * c + j) / numsColSize[0]][(i * c + j) % numsColSize[0]];
+        }
+    }
+    return ret;
+}

0566-reshape-the-matrix.c

@@ -0,0 +1,39 @@
+//uthash散列表
+typedef struct {
+    int num;
+    int count;
+    int start;
+    int end;
+    UT_hash_handle hh;
+} numhash;
+
+numhash *numh = NULL;
+
+int findShortestSubArray(int* nums, int numsSize) {
+    numhash *s = NULL;
+    numhash *tmp = NULL;
+    int max = 1;
+    int size = numsSize;
+    numh = NULL;
+    for(int i = 0; i < numsSize; i++) {
+        HASH_FIND_INT(numh, &nums[i], s);
+        if(s == NULL) {
+            s = (numhash*)malloc(sizeof(numhash));
+            s->num = nums[i];
+            s->count = 1;
+            s->start = i;
+            s->end = i;
+            HASH_ADD_INT(numh, num, s);
+        } else {
+            s->count++;
+            s->end = i;
+            max = fmax(max, s->count);
+        }
+    }
+    HASH_ITER(hh, numh, s, tmp) {
+        if(s->count == max) {
+            size = fmin(size, s->end - s->start + 1);
+        }
+    }
+    return size;
+}

0697-degree-of-an-array.c

@@ -0,0 +1,16 @@
+int dominantIndex(int* nums, int numsSize) {
+    int nummax = 0, numsec = 0, numindex = 0;
+    for(int i = 0; i < numsSize; i++) {
+        if(nums[i] >= nummax) {
+            numsec = nummax;
+            nummax = nums[i];
+            numindex = i;
+        } else if(nums[i] >= numsec) {
+            numsec = nums[i];
+        }
+    }
+    if(nummax >= numsec * 2) {
+        return numindex;
+    }
+    return -1;
+}

0747-largest-number-at-least-twice-of-others.c

@@ -0,0 +1,10 @@
+bool isToeplitzMatrix(int** matrix, int matrixSize, int* matrixColSize) {
+    for(int i = 0; i < matrixSize - 1; i++) {
+        for(int j = 0; j < matrixColSize[0] - 1; j++) {
+            if(matrix[i][j] != matrix[i + 1][j + 1]) {
+                return false;
+            }
+        }
+    }
+    return true;
+}

0766-toeplitz-matrix.c

@@ -0,0 +1,19 @@
+int** transpose(int** matrix, int matrixSize, int* matrixColSize, int* returnSize, int** returnColumnSizes)
+{
+    int m=matrixSize;
+    int n=matrixColSize[0];
+    int **ret=(int**)malloc(sizeof(int*)*n);
+    *returnColumnSizes=(int*)malloc(sizeof(int)*n);
+
+    for(int i=0; i<n; i++)
+    {
+        ret[i]=(int*)malloc(sizeof(int*)*m);
+        (*returnColumnSizes)[i]=m;
+        for(int j=0; j<m; j++)
+        {
+            ret[i][j]=matrix[j][i];
+        }
+    }
+    *returnSize=n;
+    return ret;
+}

0867-transpose-matrix.c

@@ -0,0 +1,18 @@
+//滑动窗口
+int longestOnes(int* A, int ASize, int K) {
+    int l = 0, r = 0;
+    int count = 0, zero = 0;
+    while(r < ASize) {
+        if(A[r++] == 0) {
+            zero++;
+        }
+        while(zero > K) {
+            if(A[l] == 0) {
+                zero--;
+            }
+            l++;
+        }
+        count = fmax(count, r - l);
+    }
+    return count;
+}

1004-max-consecutive-ones-iii.c

@@ -0,0 +1,15 @@
+int* smallerNumbersThanCurrent(int* nums, int numsSize, int* returnSize) {
+    int *ret = (int*)malloc(sizeof(int) * numsSize);
+    int count[101] = {0};
+    for(int i = 0; i < numsSize; i++) {
+        count[nums[i]]++;
+    }
+    for(int i = 1; i < 101; i++) {
+        count[i] += count[i - 1];
+    }
+    for(int i = 0; i < numsSize; i++) {
+        ret[i] = nums[i] == 0 ? 0 : count[nums[i] - 1];
+    }
+    *returnSize = numsSize;
+    return ret;
+}

1365-how-many-numbers-are-smaller-than-the-current-number.c

@@ -0,0 +1,10 @@
+int* runningSum(int* nums, int numsSize, int* returnSize) {
+    int *num = (int*)malloc(sizeof(int) * numsSize);
+    int sum = 0;
+    *returnSize = numsSize;
+    for(int i = 0; i < numsSize; i++) {
+        num[i] = sum + nums[i];
+        sum = num[i];
+    }
+    return num;
+}

1480-running-sum-of-1d-array.c

@@ -0,0 +1,11 @@
+int diagonalSum(int** mat, int matSize, int* matColSize) {
+    if(mat == NULL) {
+        return 0;
+    }
+    int sum = 0;
+    for(int i = 0; i < matSize; i++) {
+        sum += mat[i][i];
+        sum += mat[i][matSize - i - 1];
+    }
+    return matSize % 2 == 0 ? sum : sum - mat[matSize / 2][matSize / 2];
+}

1572-matrix-diagonal-sum.c

@@ -0,0 +1,8 @@
+int largestAltitude(int* gain, int gainSize) {
+    int ret = 0, sum = 0;;
+    for(int i = 0; i < gainSize; i++) {
+        sum += gain[i];
+        ret = fmax(ret, sum);
+    }
+    return ret;
+}

1732-find-the-highest-altitude.c

@@ -0,0 +1,13 @@
+int sumOfUnique(int* nums, int numsSize) {
+    int count[101] = {0};
+    int sum = 0;
+    for(int i = 0; i < numsSize; i++) {
+        count[nums[i]]++;
+    }
+    for(int i = 0; i < 101; i++) {
+        if(count[i] == 1) {
+            sum += i;
+        }
+    }
+    return sum;
+}