- Input: N = {N} -
-- Output: {result} -
-- Input: n = {n}, k = {k}, a = [{a.join(", ")}] - - -
-- Output: {result} -
-- Input: n = {n}, k = {k}, a = [{a.join(", ")}] -
-- Output: {result} -
-- Input: L = {L}, R = {R}, X = {X} -
-- Output: {result} -
-- Input: L = {L}, R = {R}, X = {X} -
-- Output: {result} -
-- Input: N = {N} -
-- Output: {JSON.stringify(result)} -
-- Input: N = {N} -
-- Output: {JSON.stringify(result)} -
-- Input: n = {n}, arr = [{arr.join(", ")}] -
-- Output: [{result.join(", ")}] -
-- Input: n = {n}, arr = [{arr.join(", ")}] -
-- Output: [{result.join(", ")}] -
-- Input: n = {n}, arr = [{arr.join(", ")}] -
-- Output: [{result.join(", ")}] -
-- Input: n = {decimalInput} -
-- Output: {result} -
-- Input: n = {decimalInput} -
-- Output: {result} -
-- Input: n = {decimalInput} -
-- Output: {result} -
-$2 \leq \text{nums.length} \leq 10^4$
-- $-10^9 \leq \text{nums[i]} \leq 10^9$
-- $-10^9 \leq \text{target} \leq 10^9$
-- Only one valid answer exists.
-
-**Follow up:** Can you come up with an algorithm that is less than $O(n^2)$ time complexity?
-
----
-
-## Solution for Two Sum Problem
-
-### Intuition and Approach
-
-The problem can be solved using a brute force approach, a hash table, or the two-pointer technique. The brute force approach has a time complexity of $O(n^2)$, while the hash table and two-pointer techniques have a time complexity of $O(n)$. The hash table approach is the most efficient and is recommended for large inputs.
-
-- Input: nums = {"[" + nums.join(", ") + "]"}, target = {target} -
-- Output: {"[" + result.join(", ") + "]"} -
-- Input: nums = {"[" + nums.join(", ") + "]"}, target = {target} -
-- Output: {"[" + result.join(", ") + "]"} -
-- Input: nums = {"[" + nums.join(", ") + "]"}, target = {target} -
-- Output: {"[" + result.join(", ") + "]"} -
-$0 \leq \text{Node.val} \leq 9$
-- It is guaranteed that the list represents a number that does not have leading zeros.
-
----
-
-## Solution for Add Two Numbers Problem
-
-### Intuition and Approach
-
-We iterate through both linked lists, adding corresponding node values along with a carry from the previous addition. If the sum of the current node values and carry is 10 or more, we keep the carry for the next addition. We continue this process until we traverse both linked lists.
-
-### Flowchart
-
-```mermaid
-flowchart TD
- A[Start] --> B{l1 or l2 or carry}
- B --> |Yes| C[Add values of l1, l2, and carry]
- C --> D[Calculate new carry and current node value]
- D --> E[Add node with value to result list]
- E --> F{Move to next node in l1 and l2 if exist}
- F --> |Next nodes exist| B
- F --> |Next nodes do not exist| G[Return result list]
- B --> |No| G
-```
-
-### Pseudocode
-
-```plaintext
-1. Initialize a dummy node and a current node to keep track of the current node.
-2. Initialize a carry variable to 0.
-3. Iterate through both linked lists until both are empty.
- 1. Calculate the sum of the current node values and carry.
- 2. Update the carry and current node value.
- 3. Add the new node to the result list.
- 4. Move to the next nodes in l1 and l2 if they exist.
-4. Return the next node of the dummy node.
-```
-
-### Implementation and Code
-
-Here is a live code editor for you to play around with the solution:
-
-```jsx live
-function addTwoNumbersProblem() {
- class ListNode {
- constructor(val = 0, next = null) {
- this.val = val;
- this.next = next;
- }
- }
-
- const l1 = new ListNode(2, new ListNode(4, new ListNode(3)));
- const l2 = new ListNode(5, new ListNode(6, new ListNode(4)));
-
- const addTwoNumbers = function (l1, l2) {
- let dummyHead = new ListNode(0);
- let p = l1,
- q = l2,
- curr = dummyHead;
- let carry = 0;
-
- while (p !== null || q !== null) {
- let x = p !== null ? p.val : 0;
- let y = q !== null ? q.val : 0;
- let sum = carry + x + y;
- carry = Math.floor(sum / 10);
- curr.next = new ListNode(sum % 10);
- curr = curr.next;
- if (p !== null) p = p.next;
- if (q !== null) q = q.next;
- }
-
- if (carry > 0) {
- curr.next = new ListNode(carry);
- }
-
- return dummyHead.next;
- };
-
- const result = addTwoNumbers(l1, l2);
- const listToArray = (node) => {
- const arr = [];
- while (node) {
- arr.push(node.val);
- node = node.next;
- }
- return arr;
- };
-
- const resultArray = listToArray(result);
- return (
- - Input: l1 = {"[" + listToArray(l1).join(", ") + "]"}, l2 ={" "} - {"[" + listToArray(l2).join(", ") + "]"} -
-- Output: {"[" + resultArray.join(", ") + "]"} -
-- Input: {testCase.input} -
-- Output: {findLongestSubstring(testCase.input)} -
-- Expected: {testCase.expected} -
-$O(log (m+n))$.
-
-### Example 1
-
-```plaintext
-Input: nums1 = [1,3], nums2 = [2]
-Output: 2.00000
-Explanation: merged array = [1,2,3] and median is 2.
-```
-
-### Example 2
-
-```plaintext
-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.
-```
-
-### Constraints:
-
-- $nums1.length == m$
-- $nums2.length == n$
-- $0 <= m <= 1000$
-- $0 <= n <= 1000$
-- $1 <= m + n <= 2000$
-- $-10^6 <= nums1[i], nums2[i] <= 10^6$
-
----
-
-## Solution for Median of Two Sorted Arrays
-
-The **Median of Two Sorted Arrays** is a classic algorithm problem on LeetCode ([Problem 4](https://leetcode.com/problems/median-of-two-sorted-arrays/description/)). It requires finding the median of two sorted arrays. Given two sorted arrays `nums1` and `nums2`, the task is to find the median of the two arrays combined.
-
-Here is an explanation of the intuition and approaches to solve this problem:
-
-### intuition
-
-The median is the middle value of a dataset. For an even number of elements, it is the average of the two middle values. If we have two sorted arrays, the naive approach would involve merging both arrays and then finding the median, but this approach does not take full advantage of the fact that the arrays are already sorted and is not efficient for large arrays.
-
-Instead, we can use a more advanced approach to find the median in $O(log(min(n, m)))$ time, where `n` and `m` are the lengths of the two arrays. This involves using a binary search method. The idea is to partition both arrays into two halves such that the combined left half and right half are both sorted and of equal length (or differing by one).
-
-- Input: nums1 = {"[" + nums1.join(", ") + "]"}, nums2 = {"[" + nums2.join(", ") + "]"} -
-- Output: {result} -
-$O(log(min(n, m)))$, where `n` and `m` are the lengths of the two arrays. The binary search approach helps in reducing the search space and finding the median efficiently.
-- **Space Complexity**: The space complexity of this approach is $O(1)$ as we are using constant extra space.
-
-### Test Cases
-
-Let's test the solution with the sample test cases:
-
-- Input: nums1 = {"[" + nums1.join(", ") + "]"}, nums2 = {"[" + nums2.join(", ") + "]"} -
-- Output: {result} -
-$O(log(min(n, m)))$, where `n` and `m` are the lengths of the two arrays. Each recursive call divides the problem into half.
-- **Space Complexity**: The space complexity of this approach is $O(1)$ as we are using constant extra space.
-
-### Test Cases
-
-Let's test the solution with the sample test cases:
-
-$O(log(min(n, m)))$ compared to the divide and conquer approach. However, both approaches provide a solution to the problem of finding the median of two sorted arrays.
-
-**Which approach is best for you?**
-
-The binary search approach is more efficient and recommended for solving the problem of finding the median of two sorted arrays. However, the divide and conquer approach is also a valid solution and can be used if needed.
-
-:::
-
-:::tip
-When asked to find the median of two sorted arrays, a direct approach that merges the two arrays and then finds the median will work but isn't optimal. Given the problem's constraints, we can leverage the fact that the arrays are already sorted and use binary search to find the median in $$ O(\log(\min(n, m))) $$ time complexity.
-
-The key idea is to use binary search to partition the smaller array in such a way that we can easily find the median by comparing elements around the partition.
-
-#### Detailed Explanation
-
-1. **Ensure the Smaller Array is First**:
- - This step is to make sure we always perform the binary search on the smaller array, which helps us manage the partition logic more easily. Let $$ \text{nums1} $$ be the smaller array and $$ \text{nums2} $$ be the larger array.
-
-2. **Set Up Binary Search**:
- - Initialize $$ \text{low} $$ and $$ \text{high} $$ pointers for the binary search on $$ \text{nums1} $$.
- - We aim to partition $$ \text{nums1} $$ and $$ \text{nums2} $$ such that the left side of the combined arrays contains half of the elements, and the right side contains the other half.
-
-3. **Partitioning the Arrays**:
- - Calculate $$ \text{partitionX} $$ as the midpoint of $$ \text{nums1} $$.
- - Calculate $$ \text{partitionY} $$ such that the left side of the combined arrays has the same number of elements as the right side. This can be achieved by:
- $$
- \text{partitionY} = \frac{(x + y + 1)}{2} - \text{partitionX}
- $$
-
- where $$ x $$ and $$ y $$ are the lengths of $$ \text{nums1} $$ and $$ \text{nums2} $$ respectively.
-
-4. **Boundary Conditions**:
- - Handle cases where partitions might go out of bounds. If $$ \text{partitionX} $$ is 0, it means there are no elements on the left side of $$ \text{nums1} $$. If $$ \text{partitionX} $$ is $$ x $$, it means there are no elements on the right side of $$ \text{nums1} $$.
-
-5. **Check Valid Partition**:
- - A valid partition is one where the maximum element on the left side of both partitions is less than or equal to the minimum element on the right side of both partitions:
- $$
- \text{maxX} \leq \text{minY} \quad \text{and} \quad \text{maxY} \leq \text{minX}
- $$
- Here, $$ \text{maxX} $$ is the largest element on the left side of $$ \text{nums1} $$, $$ \text{minX} $$ is the smallest element on the right side of $$ \text{nums1} $$, and similarly for $$ \text{nums2} $$.
-
-6. **Calculate the Median**:
- - If the total number of elements $$ (x + y) $$ is even, the median is the average of the two middle values:
- $$
- \text{median} = \frac{\text{max(maxX, maxY)} + \text{min(minX, minY)}}{2}
- $$
- - If the total number of elements is odd, the median is the maximum element of the left partition:
- $$
- \text{median} = \text{max(maxX, maxY)}
- $$
-
-7. **Adjust Binary Search**:
- - If $$ \text{maxX} > \text{minY} $$, it means we need to move the partition in $$ \text{nums1} $$ to the left, so adjust $$ \text{high} $$.
- - If $$ \text{maxY} > \text{minX} $$, it means we need to move the partition in $$ \text{nums1} $$ to the right, so adjust $$ \text{low} $$.
-
-:::
-
----
-
-