Added tasks 240-1143

Author: javadev

Diff for: README.md

@@ -0,0 +1,60 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-C/LeetCode-in-C?label=Stars&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C)
+[![](https://img.shields.io/github/forks/LeetCode-in-C/LeetCode-in-C?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C/fork)
+
+## 240\. Search a 2D Matrix II
+
+Medium
+
+Write an efficient algorithm that searches for a value `target` in an `m x n` integer matrix `matrix`. This matrix has the following properties:
+
+*   Integers in each row are sorted in ascending from left to right.
+*   Integers in each column are sorted in ascending from top to bottom.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/11/24/searchgrid2.jpg)
+
+**Input:** matrix = \[\[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]], target = 5
+
+**Output:** true
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/11/24/searchgrid.jpg)
+
+**Input:** matrix = \[\[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]], target = 20
+
+**Output:** false
+
+**Constraints:**
+
+*   `m == matrix.length`
+*   `n == matrix[i].length`
+*   `1 <= n, m <= 300`
+*   <code>-10<sup>9</sup> <= matrix[i][j] <= 10<sup>9</sup></code>
+*   All the integers in each row are **sorted** in ascending order.
+*   All the integers in each column are **sorted** in ascending order.
+*   <code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code>
+
+## Solution
+
+```c
+#include <stdbool.h>
+#include <stdio.h>
+
+bool searchMatrix(int** matrix, int matrixSize, int* matrixColSize, int target) {
+    int r = 0;
+    int c = matrixColSize[0] - 1; // Start from the top-right corner
+
+    while (r < matrixSize && c >= 0) {
+        if (matrix[r][c] == target) {
+            return true;
+        } else if (matrix[r][c] > target) {
+            c--; // Move left
+        } else {
+            r++; // Move down
+        }
+    }
+    return false;
+}
+```

Diff for: src/main/c/g0201_0300/s0240_search_a_2d_matrix_ii/readme.md

@@ -0,0 +1,51 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-C/LeetCode-in-C?label=Stars&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C)
+[![](https://img.shields.io/github/forks/LeetCode-in-C/LeetCode-in-C?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C/fork)
+
+## 283\. Move Zeroes
+
+Easy
+
+Given an integer array `nums`, move all `0`'s to the end of it while maintaining the relative order of the non-zero elements.
+
+**Note** that you must do this in-place without making a copy of the array.
+
+**Example 1:**
+
+**Input:** nums = [0,1,0,3,12]
+
+**Output:** [1,3,12,0,0]
+
+**Example 2:**
+
+**Input:** nums = [0]
+
+**Output:** [0]
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>4</sup></code>
+*   <code>-2<sup>31</sup> <= nums[i] <= 2<sup>31</sup> - 1</code>
+
+**Follow up:** Could you minimize the total number of operations done?
+
+## Solution
+
+```c
+#include <stdio.h>
+
+void swap(int* a, int* b) {
+    int temp = *a;
+    *a = *b;
+    *b = temp;
+}
+
+void moveZeroes(int* nums, int numsSize) {
+    int firstZero = 0;
+    for (int i = 0; i < numsSize; i++) {
+        if (nums[i] != 0) {
+            swap(&nums[firstZero], &nums[i]);
+            firstZero++;
+        }
+    }
+}
+```

Diff for: src/main/c/g0201_0300/s0283_move_zeroes/readme.md

@@ -0,0 +1,60 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-C/LeetCode-in-C?label=Stars&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C)
+[![](https://img.shields.io/github/forks/LeetCode-in-C/LeetCode-in-C?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C/fork)
+
+## 287\. Find the Duplicate Number
+
+Medium
+
+Given an array of integers `nums` containing `n + 1` integers where each integer is in the range `[1, n]` inclusive.
+
+There is only **one repeated number** in `nums`, return _this repeated number_.
+
+You must solve the problem **without** modifying the array `nums` and uses only constant extra space.
+
+**Example 1:**
+
+**Input:** nums = [1,3,4,2,2]
+
+**Output:** 2
+
+**Example 2:**
+
+**Input:** nums = [3,1,3,4,2]
+
+**Output:** 3
+
+**Constraints:**
+
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   `nums.length == n + 1`
+*   `1 <= nums[i] <= n`
+*   All the integers in `nums` appear only **once** except for **precisely one integer** which appears **two or more** times.
+
+**Follow up:**
+
+*   How can we prove that at least one duplicate number must exist in `nums`?
+*   Can you solve the problem in linear runtime complexity?
+
+## Solution
+
+```c
+#include <stdio.h>
+
+int findDuplicate(int* nums, int numsSize) {
+    // Create an array of size numsSize + 1, initialized to 0
+    int arr[numsSize + 1];
+    for (int i = 0; i <= numsSize; i++) {
+        arr[i] = 0;
+    }
+
+    // Iterate over the nums array and update the arr counts
+    for (int i = 0; i < numsSize; i++) {
+        arr[nums[i]] += 1;
+        if (arr[nums[i]] == 2) {
+            return nums[i];  // Return the duplicate element
+        }
+    }
+
+    return 0;  // In case no duplicate is found, though the problem assumes there is always a duplicate
+}
+```

Diff for: src/main/c/g0201_0300/s0287_find_the_duplicate_number/readme.md

@@ -0,0 +1,202 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-C/LeetCode-in-C?label=Stars&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C)
+[![](https://img.shields.io/github/forks/LeetCode-in-C/LeetCode-in-C?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C/fork)
+
+## 295\. Find Median from Data Stream
+
+Hard
+
+The **median** is the middle value in an ordered integer list. If the size of the list is even, there is no middle value and the median is the mean of the two middle values.
+
+*   For example, for `arr = [2,3,4]`, the median is `3`.
+*   For example, for `arr = [2,3]`, the median is `(2 + 3) / 2 = 2.5`.
+
+Implement the MedianFinder class:
+
+*   `MedianFinder()` initializes the `MedianFinder` object.
+*   `void addNum(int num)` adds the integer `num` from the data stream to the data structure.
+*   `double findMedian()` returns the median of all elements so far. Answers within <code>10<sup>-5</sup></code> of the actual answer will be accepted.
+
+**Example 1:**
+
+**Input**
+
+    ["MedianFinder", "addNum", "addNum", "findMedian", "addNum", "findMedian"]
+    [[], [1], [2], [], [3], []]
+
+**Output:** [null, null, null, 1.5, null, 2.0]
+
+**Explanation:**
+
+    MedianFinder medianFinder = new MedianFinder();
+    medianFinder.addNum(1); // arr = [1]
+    medianFinder.addNum(2); // arr = [1, 2]
+    medianFinder.findMedian(); // return 1.5 (i.e., (1 + 2) / 2)
+    medianFinder.addNum(3); // arr[1, 2, 3]
+    medianFinder.findMedian(); // return 2.0 
+
+**Constraints:**
+
+*   <code>-10<sup>5</sup> <= num <= 10<sup>5</sup></code>
+*   There will be at least one element in the data structure before calling `findMedian`.
+*   At most <code>5 * 10<sup>4</sup></code> calls will be made to `addNum` and `findMedian`.
+
+**Follow up:**
+
+*   If all integer numbers from the stream are in the range `[0, 100]`, how would you optimize your solution?
+*   If `99%` of all integer numbers from the stream are in the range `[0, 100]`, how would you optimize your solution?
+
+## Solution
+
+```c
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct {
+    int* maxHeap;
+    int maxHeapSize;
+    int maxHeapCapacity;
+
+    int* minHeap;
+    int minHeapSize;
+    int minHeapCapacity;
+} MedianFinder;
+
+MedianFinder* medianFinderCreate() {
+    MedianFinder* obj = (MedianFinder*)malloc(sizeof(MedianFinder));
+
+    obj->maxHeapCapacity = 10;  // Initial capacity for maxHeap
+    obj->maxHeapSize = 0;
+    obj->maxHeap = (int*)malloc(obj->maxHeapCapacity * sizeof(int));
+
+    obj->minHeapCapacity = 10;  // Initial capacity for minHeap
+    obj->minHeapSize = 0;
+    obj->minHeap = (int*)malloc(obj->minHeapCapacity * sizeof(int));
+
+    return obj;
+}
+
+// Helper functions for max-heap and min-heap
+void swap(int* a, int* b) {
+    int temp = *a;
+    *a = *b;
+    *b = temp;
+}
+
+// Max-Heap functions
+void maxHeapPush(MedianFinder* obj, int value) {
+    if (obj->maxHeapSize == obj->maxHeapCapacity) {
+        obj->maxHeapCapacity *= 2;
+        obj->maxHeap = (int*)realloc(obj->maxHeap, obj->maxHeapCapacity * sizeof(int));
+    }
+    obj->maxHeap[obj->maxHeapSize++] = value;
+
+    // Sift-up
+    int i = obj->maxHeapSize - 1;
+    while (i > 0 && obj->maxHeap[(i - 1) / 2] < obj->maxHeap[i]) {
+        swap(&obj->maxHeap[(i - 1) / 2], &obj->maxHeap[i]);
+        i = (i - 1) / 2;
+    }
+}
+
+int maxHeapPop(MedianFinder* obj) {
+    int result = obj->maxHeap[0];
+    obj->maxHeap[0] = obj->maxHeap[--obj->maxHeapSize];
+
+    // Sift-down
+    int i = 0;
+    while (2 * i + 1 < obj->maxHeapSize) {
+        int j = 2 * i + 1;
+        if (j + 1 < obj->maxHeapSize && obj->maxHeap[j + 1] > obj->maxHeap[j]) {
+            j++;
+        }
+        if (obj->maxHeap[i] >= obj->maxHeap[j]) break;
+        swap(&obj->maxHeap[i], &obj->maxHeap[j]);
+        i = j;
+    }
+    return result;
+}
+
+int maxHeapTop(MedianFinder* obj) {
+    return obj->maxHeap[0];
+}
+
+// Min-Heap functions
+void minHeapPush(MedianFinder* obj, int value) {
+    if (obj->minHeapSize == obj->minHeapCapacity) {
+        obj->minHeapCapacity *= 2;
+        obj->minHeap = (int*)realloc(obj->minHeap, obj->minHeapCapacity * sizeof(int));
+    }
+    obj->minHeap[obj->minHeapSize++] = value;
+
+    // Sift-up
+    int i = obj->minHeapSize - 1;
+    while (i > 0 && obj->minHeap[(i - 1) / 2] > obj->minHeap[i]) {
+        swap(&obj->minHeap[(i - 1) / 2], &obj->minHeap[i]);
+        i = (i - 1) / 2;
+    }
+}
+
+int minHeapPop(MedianFinder* obj) {
+    int result = obj->minHeap[0];
+    obj->minHeap[0] = obj->minHeap[--obj->minHeapSize];
+
+    // Sift-down
+    int i = 0;
+    while (2 * i + 1 < obj->minHeapSize) {
+        int j = 2 * i + 1;
+        if (j + 1 < obj->minHeapSize && obj->minHeap[j + 1] < obj->minHeap[j]) {
+            j++;
+        }
+        if (obj->minHeap[i] <= obj->minHeap[j]) break;
+        swap(&obj->minHeap[i], &obj->minHeap[j]);
+        i = j;
+    }
+    return result;
+}
+
+int minHeapTop(MedianFinder* obj) {
+    return obj->minHeap[0];
+}
+
+// Balancing the heaps
+void balanceHeaps(MedianFinder* obj) {
+    if (obj->maxHeapSize > obj->minHeapSize + 1) {
+        minHeapPush(obj, maxHeapPop(obj));
+    } else if (obj->minHeapSize > obj->maxHeapSize) {
+        maxHeapPush(obj, minHeapPop(obj));
+    }
+}
+
+void medianFinderAddNum(MedianFinder* obj, int num) {
+    if (obj->maxHeapSize == 0 || num <= maxHeapTop(obj)) {
+        maxHeapPush(obj, num);
+    } else {
+        minHeapPush(obj, num);
+    }
+    balanceHeaps(obj);
+}
+
+double medianFinderFindMedian(MedianFinder* obj) {
+    if (obj->maxHeapSize > obj->minHeapSize) {
+        return maxHeapTop(obj);
+    } else {
+        return (maxHeapTop(obj) + minHeapTop(obj)) / 2.0;
+    }
+}
+
+void medianFinderFree(MedianFinder* obj) {
+    free(obj->maxHeap);
+    free(obj->minHeap);
+    free(obj);
+}
+
+/**
+ * Your MedianFinder struct will be instantiated and called as such:
+ * MedianFinder* obj = medianFinderCreate();
+ * medianFinderAddNum(obj, num);
+ 
+ * double param_2 = medianFinderFindMedian(obj);
+ 
+ * medianFinderFree(obj);
+*/
+```