Added python

Author: javadev

README.md

@@ -0,0 +1,57 @@
+[![](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]
+
+**Explanation:** 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
+
+```python
+class Solution:
+    def twoSum(self, numbers: List[int], target: int) -> List[int]:
+        index_map = {}
+        for i, num in enumerate(numbers):
+            required_num = target - num
+            if required_num in index_map:
+                return [index_map[required_num], i]
+            index_map[num] = i
+        return [-1, -1]
+```

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

@@ -0,0 +1,72 @@
+[![](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
+
+```python
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
+        dummy_head = ListNode(0)
+        p, q, curr = l1, l2, dummy_head
+        carry = 0
+        
+        while p is not None or q is not None:
+            x = p.val if p is not None else 0
+            y = q.val if q is not None else 0
+            sum = carry + x + y
+            carry = sum // 10
+            curr.next = ListNode(sum % 10)
+            curr = curr.next
+            if p is not None:
+                p = p.next
+            if q is not None:
+                q = q.next
+        
+        if carry > 0:
+            curr.next = ListNode(carry)
+        
+        return dummy_head.next
+```

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

@@ -0,0 +1,71 @@
+[![](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
+
+```python
+class Solution:
+    def lengthOfLongestSubstring(self, s: str) -> int:
+        last_indices = [-1] * 256
+        max_len = 0
+        cur_len = 0
+        start = 0
+
+        for i, char in enumerate(s):
+            if last_indices[ord(char)] < start:
+                last_indices[ord(char)] = i
+                cur_len += 1
+            else:
+                last_index = last_indices[ord(char)]
+                start = last_index + 1
+                cur_len = i - start + 1
+                last_indices[ord(char)] = i
+
+            if cur_len > max_len:
+                max_len = cur_len
+
+        return max_len
+```

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

@@ -0,0 +1,87 @@
+[![](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
+
+```python
+class Solution:
+    def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
+        if len(nums2) < len(nums1):
+            return self.findMedianSortedArrays(nums2, nums1)
+
+        n1, n2 = len(nums1), len(nums2)
+        low, high = 0, n1
+
+        while low <= high:
+            cut1 = (low + high) // 2
+            cut2 = (n1 + n2 + 1) // 2 - cut1
+
+            l1 = float('-inf') if cut1 == 0 else nums1[cut1 - 1]
+            l2 = float('-inf') if cut2 == 0 else nums2[cut2 - 1]
+            r1 = float('inf') if cut1 == n1 else nums1[cut1]
+            r2 = float('inf') if cut2 == n2 else nums2[cut2]
+
+            if l1 <= r2 and l2 <= r1:
+                if (n1 + n2) % 2 == 0:
+                    return (max(l1, l2) + min(r1, r2)) / 2.0
+                return max(l1, l2)
+            elif l1 > r2:
+                high = cut1 - 1
+            else:
+                low = cut1 + 1
+
+        return 0.0
+```

src/main/python/g0001_0100/s0004_median_of_two_sorted_arrays/readme.md

@@ -0,0 +1,77 @@
+[![](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)
+
+## 5\. Longest Palindromic Substring
+
+Medium
+
+Given a string `s`, return _the longest palindromic substring_ in `s`.
+
+**Example 1:**
+
+**Input:** s = "babad"
+
+**Output:** "bab" **Note:** "aba" is also a valid answer. 
+
+**Example 2:**
+
+**Input:** s = "cbbd"
+
+**Output:** "bb" 
+
+**Example 3:**
+
+**Input:** s = "a"
+
+**Output:** "a" 
+
+**Example 4:**
+
+**Input:** s = "ac"
+
+**Output:** "a" 
+
+**Constraints:**
+
+*   `1 <= s.length <= 1000`
+*   `s` consist of only digits and English letters.
+
+
+
+## Solution
+
+```python
+class Solution:
+    def longestPalindrome(self, s: str) -> str:
+        # Create a new string with separators
+        new_str = ['#'] * (2 * len(s) + 1)
+        for i in range(len(s)):
+            new_str[2 * i + 1] = s[i]
+
+        dp = [0] * len(new_str)
+        friend_center = 0
+        friend_radius = 0
+        lps_center = 0
+        lps_radius = 0
+
+        for i in range(len(new_str)):
+            if friend_center + friend_radius > i:
+                dp[i] = min(dp[2 * friend_center - i], (friend_center + friend_radius) - i)
+            else:
+                dp[i] = 1
+
+            while i + dp[i] < len(new_str) and i - dp[i] >= 0 and new_str[i + dp[i]] == new_str[i - dp[i]]:
+                dp[i] += 1
+
+            if friend_center + friend_radius < i + dp[i]:
+                friend_center = i
+                friend_radius = dp[i]
+
+            if lps_radius < dp[i]:
+                lps_center = i
+                lps_radius = dp[i]
+
+        start = (lps_center - lps_radius + 1) // 2
+        end = (lps_center + lps_radius - 1) // 2
+        return s[start:end]
+```