Added C solutions

Author: javadev

README.md

@@ -0,0 +1,66 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 1\. Two Sum
+
+Easy
+
+Given an array of integers `nums` and an integer `target`, return _indices of the two numbers such that they add up to `target`_.
+
+You may assume that each input would have **_exactly_ one solution**, and you may not use the _same_ element twice.
+
+You can return the answer in any order.
+
+**Example 1:**
+
+**Input:** nums = [2,7,11,15], target = 9
+
+**Output:** [0,1]
+
+**Output:** Because nums[0] + nums[1] == 9, we return [0, 1]. 
+
+**Example 2:**
+
+**Input:** nums = [3,2,4], target = 6
+
+**Output:** [1,2] 
+
+**Example 3:**
+
+**Input:** nums = [3,3], target = 6
+
+**Output:** [0,1] 
+
+**Constraints:**
+
+*   <code>2 <= nums.length <= 10<sup>4</sup></code>
+*   <code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code>
+*   <code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code>
+*   **Only one valid answer exists.**
+
+**Follow-up:** Can you come up with an algorithm that is less than <code>O(n<sup>2</sup>) </code>time complexity?
+
+## Solution
+
+```c
+/**
+ * Note: The returned array must be malloced, assume caller calls free().
+ */
+int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
+    returnSize[0] = 2;
+    int* output = (int*)malloc(sizeof(int) * 2);
+
+    for (int offset = 1; offset < numsSize; offset++) {
+        int i = 0;
+        while (i + offset < numsSize) {
+            if (nums[i] + nums[i + offset] == target) {
+                output[0] = i;
+                output[1] = i + offset;
+                return output;
+            }
+            i++;
+        }
+    }
+    return (void*)0;
+}
+```

src/main/c/g0001_0100/s0001_two_sum/readme.md

@@ -0,0 +1,91 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 2\. Add Two Numbers
+
+Medium
+
+You are given two **non-empty** linked lists representing two non-negative integers. The digits are stored in **reverse order**, and each of their nodes contains a single digit. Add the two numbers and return the sum as a linked list.
+
+You may assume the two numbers do not contain any leading zero, except the number 0 itself.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/10/02/addtwonumber1.jpg)
+
+**Input:** l1 = [2,4,3], l2 = [5,6,4]
+
+**Output:** [7,0,8]
+
+**Explanation:** 342 + 465 = 807. 
+
+**Example 2:**
+
+**Input:** l1 = [0], l2 = [0]
+
+**Output:** [0] 
+
+**Example 3:**
+
+**Input:** l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
+
+**Output:** [8,9,9,9,0,0,0,1] 
+
+**Constraints:**
+
+*   The number of nodes in each linked list is in the range `[1, 100]`.
+*   `0 <= Node.val <= 9`
+*   It is guaranteed that the list represents a number that does not have leading zeros.
+
+## Solution
+
+```c
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     struct ListNode *next;
+ * };
+ */
+// Function to create a new ListNode
+struct ListNode* createNode(int val) {
+    struct ListNode* newNode = (struct ListNode*)malloc(sizeof(struct ListNode));
+    newNode->val = val;
+    newNode->next = NULL;
+    return newNode;
+}
+
+struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2) {
+    struct ListNode dummyHead;
+    dummyHead.val = 0;
+    dummyHead.next = NULL;
+    
+    struct ListNode* p = l1;
+    struct ListNode* q = l2;
+    struct ListNode* curr = &dummyHead;
+    int carry = 0;
+
+    while (p != NULL || q != NULL) {
+        int x = (p != NULL) ? p->val : 0;
+        int y = (q != NULL) ? q->val : 0;
+        int sum = carry + x + y;
+        carry = sum / 10;
+
+        curr->next = createNode(sum % 10);
+        curr = curr->next;
+
+        if (p != NULL) {
+            p = p->next;
+        }
+        if (q != NULL) {
+            q = q->next;
+        }
+    }
+
+    if (carry > 0) {
+        curr->next = createNode(carry);
+    }
+
+    return dummyHead.next;
+}
+```

src/main/c/g0001_0100/s0002_add_two_numbers/readme.md

@@ -0,0 +1,80 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 3\. Longest Substring Without Repeating Characters
+
+Medium
+
+Given a string `s`, find the length of the **longest substring** without repeating characters.
+
+**Example 1:**
+
+**Input:** s = "abcabcbb"
+
+**Output:** 3
+
+**Explanation:** The answer is "abc", with the length of 3. 
+
+**Example 2:**
+
+**Input:** s = "bbbbb"
+
+**Output:** 1
+
+**Explanation:** The answer is "b", with the length of 1. 
+
+**Example 3:**
+
+**Input:** s = "pwwkew"
+
+**Output:** 3
+
+**Explanation:** The answer is "wke", with the length of 3. Notice that the answer must be a substring, "pwke" is a subsequence and not a substring. 
+
+**Example 4:**
+
+**Input:** s = ""
+
+**Output:** 0 
+
+**Constraints:**
+
+*   <code>0 <= s.length <= 5 * 10<sup>4</sup></code>
+*   `s` consists of English letters, digits, symbols and spaces.
+
+## Solution
+
+```c
+#include <stdio.h>
+#include <string.h>
+
+int lengthOfLongestSubstring(const char* s) {
+    int lastIndices[256];
+    for (int i = 0; i < 256; i++) {
+        lastIndices[i] = -1;
+    }
+
+    int maxLen = 0;
+    int curLen = 0;
+    int start = 0;
+
+    for (int i = 0; i < strlen(s); i++) {
+        char cur = s[i];
+        if (lastIndices[(unsigned char)cur] < start) {
+            lastIndices[(unsigned char)cur] = i;
+            curLen++;
+        } else {
+            int lastIndex = lastIndices[(unsigned char)cur];
+            start = lastIndex + 1;
+            curLen = i - start + 1;
+            lastIndices[(unsigned char)cur] = i;
+        }
+
+        if (curLen > maxLen) {
+            maxLen = curLen;
+        }
+    }
+
+    return maxLen;
+}
+```

src/main/c/g0001_0100/s0003_longest_substring_without_repeating_characters/readme.md

@@ -0,0 +1,91 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 4\. Median of Two Sorted Arrays
+
+Hard
+
+Given two sorted arrays `nums1` and `nums2` of size `m` and `n` respectively, return **the median** of the two sorted arrays.
+
+The overall run time complexity should be `O(log (m+n))`.
+
+**Example 1:**
+
+**Input:** nums1 = [1,3], nums2 = [2]
+
+**Output:** 2.00000
+
+**Explanation:** merged array = [1,2,3] and median is 2. 
+
+**Example 2:**
+
+**Input:** nums1 = [1,2], nums2 = [3,4]
+
+**Output:** 2.50000
+
+**Explanation:** merged array = [1,2,3,4] and median is (2 + 3) / 2 = 2.5. 
+
+**Example 3:**
+
+**Input:** nums1 = [0,0], nums2 = [0,0]
+
+**Output:** 0.00000 
+
+**Example 4:**
+
+**Input:** nums1 = [], nums2 = [1]
+
+**Output:** 1.00000 
+
+**Example 5:**
+
+**Input:** nums1 = [2], nums2 = []
+
+**Output:** 2.00000 
+
+**Constraints:**
+
+*   `nums1.length == m`
+*   `nums2.length == n`
+*   `0 <= m <= 1000`
+*   `0 <= n <= 1000`
+*   `1 <= m + n <= 2000`
+*   <code>-10<sup>6</sup> <= nums1[i], nums2[i] <= 10<sup>6</sup></code>
+
+## Solution
+
+```c
+#include <stdio.h>
+#include <limits.h>
+
+double findMedianSortedArrays(int* nums1, int n1, int* nums2, int n2) {
+    if (n1 > n2) {
+        return findMedianSortedArrays(nums2, n2, nums1, n1);
+    }
+
+    int low = 0, high = n1;
+    while (low <= high) {
+        int cut1 = (low + high) / 2;
+        int cut2 = (n1 + n2 + 1) / 2 - cut1;
+
+        int l1 = (cut1 == 0) ? INT_MIN : nums1[cut1 - 1];
+        int l2 = (cut2 == 0) ? INT_MIN : nums2[cut2 - 1];
+        int r1 = (cut1 == n1) ? INT_MAX : nums1[cut1];
+        int r2 = (cut2 == n2) ? INT_MAX : nums2[cut2];
+
+        if (l1 <= r2 && l2 <= r1) {
+            if ((n1 + n2) % 2 == 0) {
+                return (double)(fmax(l1, l2) + fmin(r1, r2)) / 2.0;
+            } else {
+                return (double)fmax(l1, l2);
+            }
+        } else if (l1 > r2) {
+            high = cut1 - 1;
+        } else {
+            low = cut1 + 1;
+        }
+    }
+
+    return 0.0;
+}
+```