# GeetCode Hub

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`
• `-106 <= nums1[i], nums2[i] <= 106`

class Solution: def findMedianSortedArrays(self, nums1, nums2): """ :type nums1: List[int] :type nums2: List[int] :rtype: float """ list_ = [] i = j = 0 len_ = len(nums1)+len(nums2) while i<len(nums1) and j<len(nums2): if nums1[i] <= nums2[j]: list_.append(nums1[i]) i +=1 else: list_.append(nums2[j]) j +=1 if i<len(nums1): list_ += nums1[i:len(nums1)] if j<len(nums2): list_ += nums2[j:len(nums2)] if len_ % 2 == 0: return (list_[len_//2 - 1] + list_[len_//2]) / 2 else: return list_[(len_-1)//2]

The main gist of this solution is to use Binary search on the shorter size of Array and create partitioning in which both partitions will be having the same number of elements where all elements in the left partition is smaller than all the elements on the right side of the partition.

Time Complexity: O(log(min(m,n)) //Where m and n are the sizes of both the arrays.

Space Complexity: O(1) // We are not using any extra space.