Datasets:

kreimben

/

leetcode_user_submissions_only_python

like 1

Two Sum

two-sum

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.

Array,Hash Table

Easy

A really brute force way would be to search for all possible pairs of numbers but that would be too slow. Again, it's best to try out brute force solutions for just for completeness. It is from these brute force solutions that you can come up with optimizations. So, if we fix one of the numbers, say x, we have to scan the entire array to find the next number y which is value - x where value is the input parameter. Can we change our array somehow so that this search becomes faster? The second train of thought is, without changing the array, can we use additional space somehow? Like maybe a hash map to speed up the search?

# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nThe Two Sum problem asks us to find two numbers in an array that sum up to a given target value. We need to return the indices of these two numbers.\n# Approach\n<!-- Describe your approach to solving the problem. -->\n1. One brute force approach is to consider every pair of elements and check if their sum equals the target. This can be done using nested loops, where the outer loop iterates from the first element to the second-to-last element, and the inner loop iterates from the next element to the last element. However, this approach has a time complexity of O(n^2).\n2. A more efficient approach is to use a hash table (unordered_map in C++). We can iterate through the array once, and for each element, check if the target minus the current element exists in the hash table. If it does, we have found a valid pair of numbers. If not, we add the current element to the hash table.\n\n**Approach using a hash table:**\n1. Create an empty hash table to store elements and their indices.\n2. Iterate through the array from left to right.\n3. For each element nums[i], calculate the complement by subtracting it from the target: complement = target - nums[i].\n4. Check if the complement exists in the hash table. If it does, we have found a solution.\n5. If the complement does not exist in the hash table, add the current element nums[i] to the hash table with its index as the value.\n6. Repeat steps 3-5 until we find a solution or reach the end of the array.\n7. If no solution is found, return an empty array or an appropriate indicator.\n\nThis approach has a time complexity of O(n) since hash table lookups take constant time on average. It allows us to solve the Two Sum problem efficiently by making just one pass through the array.\n\n# Code\n# Solution 1: (Brute Force)\n```C++ []\nclass Solution {\npublic:\n vector<int> twoSum(vector<int>& nums, int target) {\n int n = nums.size();\n for (int i = 0; i < n - 1; i++) {\n for (int j = i + 1; j < n; j++) {\n if (nums[i] + nums[j] == target) {\n return {i, j};\n }\n }\n }\n return {}; // No solution found\n }\n};\n\n```\n```Java []\nclass Solution {\n public int[] twoSum(int[] nums, int target) {\n int n = nums.length;\n for (int i = 0; i < n - 1; i++) {\n for (int j = i + 1; j < n; j++) {\n if (nums[i] + nums[j] == target) {\n return new int[]{i, j};\n }\n }\n }\n return new int[]{}; // No solution found\n }\n}\n\n```\n```Python3 []\nclass Solution:\n def twoSum(self, nums: List[int], target: int) -> List[int]:\n n = len(nums)\n for i in range(n - 1):\n for j in range(i + 1, n):\n if nums[i] + nums[j] == target:\n return [i, j]\n return [] # No solution found\n\n```\n\n# Solution 2: (Two-pass Hash Table)\n```C++ []\nclass Solution {\npublic:\n vector<int> twoSum(vector<int>& nums, int target) {\n unordered_map<int, int> numMap;\n int n = nums.size();\n\n // Build the hash table\n for (int i = 0; i < n; i++) {\n numMap[nums[i]] = i;\n }\n\n // Find the complement\n for (int i = 0; i < n; i++) {\n int complement = target - nums[i];\n if (numMap.count(complement) && numMap[complement] != i) {\n return {i, numMap[complement]};\n }\n }\n\n return {}; // No solution found\n }\n};\n\n```\n```Java []\nclass Solution {\n public int[] twoSum(int[] nums, int target) {\n Map<Integer, Integer> numMap = new HashMap<>();\n int n = nums.length;\n\n // Build the hash table\n for (int i = 0; i < n; i++) {\n numMap.put(nums[i], i);\n }\n\n // Find the complement\n for (int i = 0; i < n; i++) {\n int complement = target - nums[i];\n if (numMap.containsKey(complement) && numMap.get(complement) != i) {\n return new int[]{i, numMap.get(complement)};\n }\n }\n\n return new int[]{}; // No solution found\n }\n}\n\n```\n```Python3 []\nclass Solution:\n def twoSum(self, nums: List[int], target: int) -> List[int]:\n numMap = {}\n n = len(nums)\n\n # Build the hash table\n for i in range(n):\n numMap[nums[i]] = i\n\n # Find the complement\n for i in range(n):\n complement = target - nums[i]\n if complement in numMap and numMap[complement] != i:\n return [i, numMap[complement]]\n\n return [] # No solution found\n\n```\n# Solution 3: (One-pass Hash Table)\n```C++ []\nclass Solution {\npublic:\n vector<int> twoSum(vector<int>& nums, int target) {\n unordered_map<int, int> numMap;\n int n = nums.size();\n\n for (int i = 0; i < n; i++) {\n int complement = target - nums[i];\n if (numMap.count(complement)) {\n return {numMap[complement], i};\n }\n numMap[nums[i]] = i;\n }\n\n return {}; // No solution found\n }\n};\n\n```\n```Java []\nclass Solution {\n public int[] twoSum(int[] nums, int target) {\n Map<Integer, Integer> numMap = new HashMap<>();\n int n = nums.length;\n\n for (int i = 0; i < n; i++) {\n int complement = target - nums[i];\n if (numMap.containsKey(complement)) {\n return new int[]{numMap.get(complement), i};\n }\n numMap.put(nums[i], i);\n }\n\n return new int[]{}; // No solution found\n }\n}\n\n```\n```Python3 []\nclass Solution:\n def twoSum(self, nums: List[int], target: int) -> List[int]:\n numMap = {}\n n = len(nums)\n\n for i in range(n):\n complement = target - nums[i]\n if complement in numMap:\n return [numMap[complement], i]\n numMap[nums[i]] = i\n\n return [] # No solution found\n\n```\n![CUTE_CAT.png]()\n\n**If you are a beginner solve these problems which makes concepts clear for future coding:**\n1. [Two Sum]()\n2. [Roman to Integer]()\n3. [Palindrome Number]()\n4. [Maximum Subarray]()\n5. [Remove Element]()\n6. [Contains Duplicate]()\n7. [Add Two Numbers]()\n8. [Majority Element]()\n9. [Remove Duplicates from Sorted Array]()\n10. **Practice them in a row for better understanding and please Upvote for more questions.**\n\n**If you found my solution helpful, I would greatly appreciate your upvote, as it would motivate me to continue sharing more solutions.**\n

Two Sum

two-sum

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.

Array,Hash Table

Easy

A really brute force way would be to search for all possible pairs of numbers but that would be too slow. Again, it's best to try out brute force solutions for just for completeness. It is from these brute force solutions that you can come up with optimizations. So, if we fix one of the numbers, say x, we have to scan the entire array to find the next number y which is value - x where value is the input parameter. Can we change our array somehow so that this search becomes faster? The second train of thought is, without changing the array, can we use additional space somehow? Like maybe a hash map to speed up the search?

# Beginner doubt - Where is main function?\n- Answer is very simple. LeetCode uses Class and Member method. In future I came with detailed answer of this question.\n- Lets Connect on LinkedIn (Leave a note) - \n\n# Problem Constraints\n- Test cases written like more than one solution cannot exist. Either solution exist or not.\n# Brute Force Approach\n- Run two nested loops to check every possible pair of numbers in the given array to see if they add up to the target sum.\n- If they add up to the target sum return the indexes.\n\n# Brute Force Code\n\n```C++ []\nclass Solution {\npublic:\n vector<int> twoSum(vector<int>& nums, int target) {\n for (int i = 0; i < nums.size(); i++) {\n for (int j = i + 1; j < nums.size(); j++) {\n if (nums[i] + nums[j] == target) {\n return {i, j};\n }\n }\n }\n return {};\n }\n};\n\n```\n```Java []\nclass Solution {\n public int[] twoSum(int[] nums, int target) {\n for (int i = 0; i < nums.length; i++) {\n for (int j = i + 1; j < nums.length; j++) {\n if (nums[i] + nums[j] == target) {\n return new int[] {i, j};\n }\n }\n }\n return new int[] {};\n }\n}\n\n```\n```Python []\nclass Solution:\n def twoSum(self, nums: List[int], target: int) -> List[int]:\n for i in range(len(nums)):\n for j in range(i + 1, len(nums)):\n if (i != j and nums[i] + nums[j] == target):\n return [i, j]\n return []\n\n```\n# Complexity\n- Time complexity: O(N^2);\n- Space Complexity: O(1);\n\n---\n\n# Optimized Code\n\n```C++ []\n#include <unordered_map>\n \nclass Solution {\npublic:\n vector<int> twoSum(vector<int>& nums, int target) {\n unordered_map<int, int> mp;\n \n for(int i = 0; i < nums.size(); i++){\n if(mp.find(target - nums[i]) == mp.end())\n mp[nums[i]] = i;\n else\n return {mp[target - nums[i]], i};\n }\n \n return {-1, -1};\n }\n};\n\n```\n```Java []\nimport java.util.HashMap;\nimport java.util.Map;\n \nclass Solution {\n public int[] twoSum(int[] nums, int target) {\n Map<Integer, Integer> numToIndex = new HashMap<>();\n for (int i = 0; i < nums.length; i++) {\n if (numToIndex.containsKey(target - nums[i])) {\n return new int[] {numToIndex.get(target - nums[i]), i};\n }\n numToIndex.put(nums[i], i);\n }\n return new int[] {};\n }\n}\n\n\n```\n```Python []\nclass Solution:\n def twoSum(self, nums: List[int], target: int) -> List[int]:\n numToIndex = {}\n for i in range(len(nums)):\n if target - nums[i] in numToIndex:\n return [numToIndex[target - nums[i]], i]\n numToIndex[nums[i]] = i\n return []\n\n```\n# Complexity\n- Time complexity: O(N);\n- Space Complexity: O(N);\n\n# DRY Run\nSuppose we have an array nums = [2, 7, 11, 15] and a target of target = 9. We want to find two numbers in nums that add up to target.\n\nInitially, the unordered_map mp is empty. We start iterating through the array from left to right.\n\nFor the first element nums[0] = 2, we check if its complement target - nums[0] = 7 exists in the map by using the find() method. Since it does not exist in the map, we add the key-value pair (2, 0) to the map. The map now looks like this: {2: 0}.\n\nFor the second element nums[1] = 7, we check if its complement target - nums[1] = 2 exists in the map. Since it does exist in the map, we return the indices mp[2] = 0 and i = 1 as a vector {0, 1}.\n\nTherefore, the code returns the expected output of [0, 1], indicating that the indices of the two elements that add up to the target are 0 and 1.\n\n---\n\n# Upvote Me If You Like It \n\n![supermeme_12h13_27.png]()\n

Two Sum

two-sum

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.

Array,Hash Table

Easy

A really brute force way would be to search for all possible pairs of numbers but that would be too slow. Again, it's best to try out brute force solutions for just for completeness. It is from these brute force solutions that you can come up with optimizations. So, if we fix one of the numbers, say x, we have to scan the entire array to find the next number y which is value - x where value is the input parameter. Can we change our array somehow so that this search becomes faster? The second train of thought is, without changing the array, can we use additional space somehow? Like maybe a hash map to speed up the search?

# **Read article Explaination and codes : \n\nThe LeetCode Two Sum 1 problem is a popular coding challenge that requires finding the indices of two numbers in an array that add up to a specific target. The problem statement provides an array of integers and a target value, and the task is to return the indices of the two numbers that sum up to the target.\n\nOne approach to solve this problem efficiently is by using a hash map or dictionary. We can iterate through the given array, checking if the complement of each element (target minus current element) exists in our hash map. If it does, we have found our solution and can return the indices. Otherwise, we add the current element and its index to our hash map for future reference.\n\nAnother possible solution is by using two pointers. We can sort the array first and then initialize two pointers at the beginning and end of the array. By comparing their sum with the target value, we can move either pointer closer to each other until we find a match or exhaust all possibilities.\n\nBoth approaches have a time complexity of O(n), where n is the length of the input array. However, using a hash map might be more efficient when dealing with large arrays or when multiple solutions are expected.\n\n\n\n[![image]()]()\n\nExplanation Eg.\nTime Complexity:\n\nBruteforce: O(n^2)\n\nHashMap: O(n)\n\nTwo pass Hashmap: O(n)\n\nTwo Pointer: O(n log n)\n\n![image]()\n\n![image]()\n\nPython :\nJava:\nc++:\nJavaScript:\n\n\nRead Whole article :\n![image]()\n\n

Two Sum

two-sum

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.

Array,Hash Table

Easy

A really brute force way would be to search for all possible pairs of numbers but that would be too slow. Again, it's best to try out brute force solutions for just for completeness. It is from these brute force solutions that you can come up with optimizations. So, if we fix one of the numbers, say x, we have to scan the entire array to find the next number y which is value - x where value is the input parameter. Can we change our array somehow so that this search becomes faster? The second train of thought is, without changing the array, can we use additional space somehow? Like maybe a hash map to speed up the search?

# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\nclass Solution:\n def twoSum(self, nums: List[int], target: int) -> List[int]:\n dict={}\n for i,n in enumerate(nums):\n if n in dict:\n return dict[n],i\n else:\n dict[target-n]=i\n #please upvote me it would encourage me alot\n\n```

Two Sum

two-sum

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.

Array,Hash Table

Easy

A really brute force way would be to search for all possible pairs of numbers but that would be too slow. Again, it's best to try out brute force solutions for just for completeness. It is from these brute force solutions that you can come up with optimizations. So, if we fix one of the numbers, say x, we have to scan the entire array to find the next number y which is value - x where value is the input parameter. Can we change our array somehow so that this search becomes faster? The second train of thought is, without changing the array, can we use additional space somehow? Like maybe a hash map to speed up the search?

If you\'re a newbie and sometimes have a hard time understanding the logic. Don\'t worry, you\'ll catch up after a month of doing Leetcode on a daily basis. Try to do it, even one example per day. It\'d help. I\'ve compiled a bunch on `sum` problems here, go ahead and check it out. Also, I think focusing on a subject and do 3-4 problems would help to get the idea behind solution since they mostly follow the same logic. Of course there are other ways to solve each problems but I try to be as uniform as possible. Good luck. \n\nIn general, `sum` problems can be categorized into two categories: 1) there is any array and you add some numbers to get to (or close to) a `target`, or 2) you need to return indices of numbers that sum up to a (or close to) a `target` value. Note that when the problem is looking for a indices, `sort`ing the array is probably NOT a good idea. \n\n\n **[Two Sum:]()** \n \n This is the second type of the problems where we\'re looking for indices, so sorting is not necessary. What you\'d want to do is to go over the array, and try to find two integers that sum up to a `target` value. Most of the times, in such a problem, using dictionary (hastable) helps. You try to keep track of you\'ve observations in a dictionary and use it once you get to the results. \n\nNote: try to be comfortable to use `enumerate` as it\'s sometime out of comfort zone for newbies. `enumerate` comes handy in a lot of problems (I mean if you want to have a cleaner code of course). If I had to choose three built in functions/methods that I wasn\'t comfortable with at the start and have found them super helpful, I\'d probably say `enumerate`, `zip` and `set`. \n \nSolution: In this problem, you initialize a dictionary (`seen`). This dictionary will keep track of numbers (as `key`) and indices (as `value`). So, you go over your array (line `#1`) using `enumerate` that gives you both index and value of elements in array. As an example, let\'s do `nums = [2,3,1]` and `target = 3`. Let\'s say you\'re at index `i = 0` and `value = 2`, ok? you need to find `value = 1` to finish the problem, meaning, `target - 2 = 1`. 1 here is the `remaining`. Since `remaining + value = target`, you\'re done once you found it, right? So when going through the array, you calculate the `remaining` and check to see whether `remaining` is in the `seen` dictionary (line `#3`). If it is, you\'re done! you\'re current number and the remaining from `seen` would give you the output (line `#4`). Otherwise, you add your current number to the dictionary (line `#5`) since it\'s going to be a `remaining` for (probably) a number you\'ll see in the future assuming that there is at least one instance of answer. \n \n \n ```\n class Solution:\n def twoSum(self, nums: List[int], target: int) -> List[int]:\n seen = {}\n for i, value in enumerate(nums): #1\n remaining = target - nums[i] #2\n \n if remaining in seen: #3\n return [i, seen[remaining]] #4\n else:\n seen[value] = i #5\n```\n \n \n\n **[Two Sum II:]()** \n\nFor this, you can do exactly as the previous. The only change I made below was to change the order of line `#4`. In the previous example, the order didn\'t matter. But, here the problem asks for asending order and since the values/indicess in `seen` has always lower indices than your current number, it should come first. Also, note that the problem says it\'s not zero based, meaning that indices don\'t start from zero, that\'s why I added 1 to both of them. \n\n```\nclass Solution:\n def twoSum(self, numbers: List[int], target: int) -> List[int]:\n \n seen = {}\n for i, value in enumerate(numbers): \n remaining = target - numbers[i] \n \n if remaining in seen: \n return [seen[remaining]+1, i+1] #4\n else:\n seen[value] = i \n```\n\nAnother approach to solve this problem (probably what Leetcode is looking for) is to treat it as first category of problems. Since the array is already sorted, this works. You see the following approach in a lot of problems. What you want to do is to have two pointer (if it was 3sum, you\'d need three pointers as you\'ll see in the future examples). One pointer move from `left` and one from `right`. Let\'s say you `numbers = [1,3,6,9]` and your `target = 10`. Now, `left` points to 1 at first, and `right` points to 9. There are three possibilities. If you sum numbers that `left` and `right` are pointing at, you get `temp_sum` (line `#1`). If `temp_sum` is your target, you\'r done! You\'re return it (line `#9`). If it\'s more than your `target`, it means that `right` is poiting to a very large value (line `#5`) and you need to bring it a little bit to the left to a smaller (r maybe equal) value (line `#6`) by adding one to the index . If the `temp_sum` is less than `target` (line `#7`), then you need to move your `left` to a little bit larger value by adding one to the index (line `#9`). This way, you try to narrow down the range in which you\'re looking at and will eventually find a couple of number that sum to `target`, then, you\'ll return this in line `#9`. In this problem, since it says there is only one solution, nothing extra is necessary. However, when a problem asks to return all combinations that sum to `target`, you can\'t simply return the first instace and you need to collect all the possibilities and return the list altogether (you\'ll see something like this in the next example). \n\n```\nclass Solution:\n def twoSum(self, numbers: List[int], target: int) -> List[int]:\n \n for left in range(len(numbers) -1): #1\n right = len(numbers) - 1 #2\n while left < right: #3\n temp_sum = numbers[left] + numbers[right] #4\n if temp_sum > target: #5\n right -= 1 #6\n elif temp_sum < target: #7\n left +=1 #8\n else:\n return [left+1, right+1] #9\n```\n\n\n\n\n[**3Sum**]()\n\nThis is similar to the previous example except that it\'s looking for three numbers. There are some minor differences in the problem statement. It\'s looking for all combinations (not just one) of solutions returned as a list. And second, it\'s looking for unique combination, repeatation is not allowed. \n\nHere, instead of looping (line `#1`) to `len(nums) -1`, we loop to `len(nums) -2` since we\'re looking for three numbers. Since we\'re returning values, `sort` would be a good idea. Otherwise, if the `nums` is not sorted, you cannot reducing `right` pointer or increasing `left` pointer easily, makes sense? \n\nSo, first you `sort` the array and define `res = []` to collect your outputs. In line `#2`, we check wether two consecutive elements are equal or not because if they are, we don\'t want them (solutions need to be unique) and will skip to the next set of numbers. Also, there is an additional constrain in this line that `i > 0`. This is added to take care of cases like `nums = [1,1,1]` and `target = 3`. If we didn\'t have `i > 0`, then we\'d skip the only correct solution and would return `[]` as our answer which is wrong (correct answer is `[[1,1,1]]`. \n\nWe define two additional pointers this time, `left = i + 1` and `right = len(nums) - 1`. For example, if `nums = [-2,-1,0,1,2]`, all the points in the case of `i=1` are looking at: `i` at `-1`, `left` at `0` and `right` at `2`. We then check `temp` variable similar to the previous example. There is only one change with respect to the previous example here between lines `#5` and `#10`. If we have the `temp = target`, we obviously add this set to the `res` in line `#5`, right? However, we\'re not done yet. For a fixed `i`, we still need to check and see whether there are other combinations by just changing `left` and `right` pointers. That\'s what we are doing in lines `#6, 7, 8`. If we still have the condition of `left < right` and `nums[left]` and the number to the right of it are not the same, we move `left` one index to right (line `#6`). Similarly, if `nums[right]` and the value to left of it is not the same, we move `right` one index to left. This way for a fixed `i`, we get rid of repeative cases. For example, if `nums = [-3, 1,1, 3,5]` and `target = 3`, one we get the first `[-3,1,5]`, `left = 1`, but, `nums[2]` is also 1 which we don\'t want the `left` variable to look at it simply because it\'d again return `[-3,1,5]`, right? So, we move `left` one index. Finally, if the repeating elements don\'t exists, lines `#6` to `#8` won\'t get activated. In this case we still need to move forward by adding 1 to `left` and extracting 1 from `right` (lines `#9, 10`). \n\n```\nclass Solution:\n def threeSum(self, nums: List[int]) -> List[List[int]]:\n \n nums.sort()\n res = []\n\n for i in range(len(nums) -2): #1\n if i > 0 and nums[i] == nums[i-1]: #2\n continue\n left = i + 1 #3\n right = len(nums) - 1 #4\n \n while left < right: \n temp = nums[i] + nums[left] + nums[right]\n \n if temp > 0:\n right -= 1\n \n elif temp < 0:\n left += 1\n \n else:\n res.append([nums[i], nums[left], nums[right]]) #5\n while left < right and nums[left] == nums[left + 1]: #6\n left += 1\n while left < right and nums[right] == nums[right-1]:#7\n right -= 1 #8\n \n right -= 1 #9 \n left += 1 #10\n \n```\n\nAnother way to solve this problem is to change it into a two sum problem. Instead of finding `a+b+c = 0`, you can find `a+b = -c` where we want to find two numbers `a` and `b` that are equal to `-c`, right? This is similar to the first problem. Remember if you wanted to use the exact same as the first code, it\'d return indices and not numbers. Also, we need to re-arrage this problem in a way that we have `nums` and `target`. This code is not a good code and can be optimipized but you got the idea. For a better version of this, check [this](). \n\n```\nclass Solution:\n def threeSum(self, nums: List[int]) -> List[List[int]]:\n res = []\n nums.sort()\n \n for i in range(len(nums)-2):\n if i > 0 and nums[i] == nums[i-1]:\n continue\n output_2sum = self.twoSum(nums[i+1:], -nums[i])\n if output_2sum ==[]:\n continue\n else:\n for idx in output_2sum:\n instance = idx+[nums[i]]\n res.append(instance)\n \n output = []\n for idx in res:\n if idx not in output:\n output.append(idx)\n \n \n return output\n \n \n def twoSum(self, nums, target):\n seen = {}\n res = []\n for i, value in enumerate(nums): #1\n remaining = target - nums[i] #2\n \n if remaining in seen: #3\n res.append([value, remaining]) #4\n else:\n seen[value] = i #5\n \n return res\n```\n\n[**4Sum**]()\n\nYou should have gotten the idea, and what you\'ve seen so far can be generalized to `nSum`. Here, I write the generic code using the same ideas as before. What I\'ll do is to break down each case to a `2Sum II` problem, and solve them recursively using the approach in `2Sum II` example above. \n\nFirst sort `nums`, then I\'m using two extra functions, `helper` and `twoSum`. The `twoSum` is similar to the `2sum II` example with some modifications. It doesn\'t return the first instance of results, it check every possible combinations and return all of them now. Basically, now it\'s more similar to the `3Sum` solution. Understanding this function shouldn\'t be difficult as it\'s very similar to `3Sum`. As for `helper` function, it first tries to check for cases that don\'t work (line `#1`). And later, if the `N` we need to sum to get to a `target` is 2 (line `#2`), then runs the `twoSum` function. For the more than two numbers, it recursively breaks them down to two sum (line `#3`). There are some cases like line `#4` that we don\'t need to proceed with the algorithm anymore and we can `break`. These cases include if multiplying the lowest number in the list by `N` is more than `target`. Since its sorted array, if this happens, we can\'t find any result. Also, if the largest array (`nums[-1]`) multiplied by `N` would be less than `target`, we can\'t find any solution. So, `break`. \n\n\nFor other cases, we run the `helper` function again with new inputs, and we keep doing it until we get to `N=2` in which we use `twoSum` function, and add the results to get the final output. \n\n```\nclass Solution:\n def fourSum(self, nums: List[int], target: int) -> List[List[int]]:\n nums.sort()\n results = []\n self.helper(nums, target, 4, [], results)\n return results\n \n def helper(self, nums, target, N, res, results):\n \n if len(nums) < N or N < 2: #1\n return\n if N == 2: #2\n output_2sum = self.twoSum(nums, target)\n if output_2sum != []:\n for idx in output_2sum:\n results.append(res + idx)\n \n else: \n for i in range(len(nums) -N +1): #3\n if nums[i]*N > target or nums[-1]*N < target: #4\n break\n if i == 0 or i > 0 and nums[i-1] != nums[i]: #5\n self.helper(nums[i+1:], target-nums[i], N-1, res + [nums[i]], results)\n \n \n def twoSum(self, nums: List[int], target: int) -> List[int]:\n res = []\n left = 0\n right = len(nums) - 1 \n while left < right: \n temp_sum = nums[left] + nums[right] \n\n if temp_sum == target:\n res.append([nums[left], nums[right]])\n right -= 1\n left += 1\n while left < right and nums[left] == nums[left - 1]:\n left += 1\n while right > left and nums[right] == nums[right + 1]:\n right -= 1\n \n elif temp_sum < target: \n left +=1 \n else: \n right -= 1\n \n return res\n```\n[**Combination Sum II**]()\nI don\'t post combination sum here since it\'s basically this problem a little bit easier. \nCombination questions can be solved with `dfs` most of the time. if you want to fully understand this concept and [backtracking](.***.org/backtracking-introduction/), try to finish [this]() post and do all the examples. \n\nRead my older post first [here](). This should give you a better idea of what\'s going on. The solution here also follow the exact same format except for some minor changes. I first made a minor change in the `dfs` function where it doesn\'t need the `index` parameter anymore. This is taken care of by `candidates[i+1:]` in line `#3`. Note that we had `candidates` here in the previous post. \n\n```\nclass Solution(object):\n def combinationSum2(self, candidates, target):\n """\n :type candidates: List[int]\n :type target: int\n :rtype: List[List[int]]\n """\n res = []\n candidates.sort()\n self.dfs(candidates, target, [], res)\n return res\n \n \n def dfs(self, candidates, target, path, res):\n if target < 0:\n return\n \n if target == 0:\n res.append(path)\n return res\n \n for i in range(len(candidates)):\n if i > 0 and candidates[i] == candidates[i-1]: #1\n continue #2\n self.dfs(candidates[i+1:], target - candidates[i], path+[candidates[i]], res) #3\n```\n\n\nThe only differences are lines `#1, 2, 3`. The difference in problem statement in this one and `combinations` problem of my previous post is >>>candidates must be used once<<< and lines `#1` and `2` are here to take care of this. Line `#1` has two components where first `i > 0` and second `candidates[i] == candidates[i-1]`. The second component `candidates[i] == candidates[i-1]` is to take care of duplicates in the `candidates` variable as was instructed in the problem statement. Basically, if the next number in `candidates` is the same as the previous one, it means that it has already been taken care of, so `continue`. The first component takes care of cases like an input `candidates = [1]` with `target = 1` (try to remove this component and submit your solution. You\'ll see what I mean). The rest is similar to the previous [post]()\n\n================================================================\nFinal note: Please let me know if you found any typo/error/ect. I\'ll try to fix them.

Two Sum

two-sum

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.

Array,Hash Table

Easy

A really brute force way would be to search for all possible pairs of numbers but that would be too slow. Again, it's best to try out brute force solutions for just for completeness. It is from these brute force solutions that you can come up with optimizations. So, if we fix one of the numbers, say x, we have to scan the entire array to find the next number y which is value - x where value is the input parameter. Can we change our array somehow so that this search becomes faster? The second train of thought is, without changing the array, can we use additional space somehow? Like maybe a hash map to speed up the search?

# Problem\n#### The problem statement describes a classic coding interview question. You are given an array of integers (nums) and an integer (target). Your task is to find two distinct numbers in the array that add up to the target. You need to return the indices of these two numbers.\n\n---\n# Solution\n\n##### 1. The twoSum function takes two arguments: nums, which is the list of integers, and target, which is the desired sum.\n\n##### 2. The solution uses a nested loop. The outer loop iterates through the elements of the nums list using enumerate. The outer loop variable i represents the index, and x represents the element at that index.\n\n##### 3.The inner loop also uses enumerate but starts from the i+1 index. This ensures that you don\'t use the same element twice (as the problem specifies). The inner loop variable j represents the index, and y represents the element at that index.\n\n##### 4.The condition if x + y == target checks whether the sum of the current elements x and y is equal to the target.\n\n##### 5.If a pair of elements is found that satisfies the condition, the next function returns a tuple (i, j) representing the indices of the two elements that add up to the target.\n---\n\n# Code\n```Python3 []\nclass Solution:\n def twoSum(self, nums: List[int], target: int) -> List[int]:\n return next((i, j) for i, x in enumerate(nums) for j, y in enumerate(nums[i+1:], i+1) if x + y == target)\n\n```\n```python []\nclass Solution:\n def twoSum(self, nums: List[int], target: int) -> List[int]:\n return next((i, j) for i, x in enumerate(nums) for j, y in enumerate(nums[i+1:], i+1) if x + y == target)\n\n```\n```C# []\npublic class Solution\n{\n public int[] TwoSum(int[] nums, int target)\n {\n for (int i = 0; i < nums.Length; i++)\n {\n for (int j = i + 1; j < nums.Length; j++)\n {\n if (nums[i] + nums[j] == target)\n {\n return new int[] { i, j };\n }\n }\n }\n throw new ArgumentException("No solution found");\n }\n}\n\n```\n```javascript []\nvar twoSum = function(nums, target) {\n const numToIndex = new Map(); // Create a Map to store numbers and their indices\n\n for (let i = 0; i < nums.length; i++) {\n const complement = target - nums[i];\n\n // Check if the complement exists in the Map\n if (numToIndex.has(complement)) {\n return [numToIndex.get(complement), i];\n }\n\n // Store the current number and its index in the Map\n numToIndex.set(nums[i], i);\n }\n\n throw new Error("No solution found");\n};\n```\n```C []\nint* twoSum(int* nums, int numsSize, int target, int* returnSize) {\n int* result = (int*)malloc(2 * sizeof(int)); // Allocate memory for the result array\n if (result == NULL) {\n *returnSize = 0;\n return NULL; // Return NULL if memory allocation fails\n }\n\n for (int i = 0; i < numsSize; i++) {\n for (int j = i + 1; j < numsSize; j++) {\n if (nums[i] + nums[j] == target) {\n result[0] = i;\n result[1] = j;\n *returnSize = 2; // Set the return size to 2\n return result; // Return the result array\n }\n }\n }\n\n *returnSize = 0; // If no solution found, set return size to 0\n free(result); // Free the allocated memory before returning NULL\n return NULL; // Return NULL if no solution is found\n}\n```\n```Java []\npublic class Solution {\n public int[] twoSum(int[] nums, int target) {\n Map<Integer, Integer> numToIndex = new HashMap<>();\n for (int i = 0; i < nums.length; i++) {\n int complement = target - nums[i];\n if (numToIndex.containsKey(complement)) {\n return new int[]{numToIndex.get(complement), i};\n }\n numToIndex.put(nums[i], i);\n }\n throw new IllegalArgumentException("No solution found");\n }\n}\n\n```\n```C++ []\nclass Solution {\npublic:\n std::vector<int> twoSum(std::vector<int>& nums, int target) {\n std::unordered_map<int, int> numToIndex;\n for (int i = 0; i < nums.size(); i++) {\n int complement = target - nums[i];\n if (numToIndex.find(complement) != numToIndex.end()) {\n return {numToIndex[complement], i};\n }\n numToIndex[nums[i]] = i;\n }\n throw std::invalid_argument("No solution found");\n }\n};\n\n```\n\n

Two Sum

two-sum

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.

Array,Hash Table

Easy

A really brute force way would be to search for all possible pairs of numbers but that would be too slow. Again, it's best to try out brute force solutions for just for completeness. It is from these brute force solutions that you can come up with optimizations. So, if we fix one of the numbers, say x, we have to scan the entire array to find the next number y which is value - x where value is the input parameter. Can we change our array somehow so that this search becomes faster? The second train of thought is, without changing the array, can we use additional space somehow? Like maybe a hash map to speed up the search?

# Intuition\nMethod 1: A brute-force solution to find two numbers in the nums list that add up to the target value.\n\nMethod 2: By list concept\n\nMethod 3: By Dictionary (more efficient solution)\n# Approach\nMethod 1: \nThe code uses nested loops to iterate over each pair of numbers in the nums list. The outer loop runs from 0 to len(nums)-1, and the inner loop runs from i+1 to len(nums)-1, where i is the current index of the outer loop. Within the nested loops, constant time operations are performed, such as checking if the sum of two numbers equals the target, appending indices to the a list, and using break and continue statements.\nTherefore, the overall time complexity of the code is O(n^2) due to the nested loops.\n\nMethod 2: \nThe code uses one loop to iterate over the number and subtract from target and if that subtracted number is present in list then return the index of both number. \n(here if condition of a==i means that possibly the target is 10 and present number in list might be [5,5] but it will return the same index so we need to skip)\n\nMethod 3: \nThe dictionary will help us to find the complement of each number more efficiently. In Method 2, Change the loop variable from i to num using the enumerate() function. This allows us to directly access the numbers from the nums list instead of using indexing.\nReplaced the variable p with complement to improve code readability.\nReplaced if p in nums with if complement in num_dict. This change allows us to check if the complement exists in the num_dict dictionary, which provides a more efficient lookup compared to the in operator on a list.\nModified the return statement to return [num_dict[complement], i] instead of i, a. This returns the indices of the two numbers that add up to the target, as required.\n\n\n# Complexity\n- Time complexity:\n\nMethod 1: \nO(n^2) due to nested loops\n\nMethod 2: \nO(n^2) because the the code uses a single loop that iterates over each element in the nums list which takes O(n) and index() method is called within the loop which takes O(n) time in the worst case to call the index of element.\n\nMethod 3: \n**O(n)** The use of the dictionary (num_dict) allows for efficient lookup of complements in constant time, improving the overall time complexity to O(n) compared to the previous methods with a time complexity of O(n^2) when using the brute force and index() method.\n\n\n- Space complexity:\nthe space complexity of the code is O(1) in all 3 methods.\n\n$$KINDLY$$ $$UPVOTE$$\n# Code\n\nMethod 1: \n```\nclass Solution:\n def twoSum(self, nums: List[int], target: int) -> List[int]:\n a=[]\n for i in range(len(nums)):\n for j in range(i+1,len(nums)):\n if (nums[i]+nums[j]==target):\n a.append(i)\n a.append(j)\n break \n return a\n```\nMethod 2:\n```\nclass Solution:\n def twoSum(self, nums: List[int], target: int) -> List[int]:\n a=0\n for i in range(len(nums)):\n p = target-nums[i]\n if p in nums:\n a=nums.index(p)\n if a==i:\n continue\n break\n return i,a\n```\nMethod 3:\n```\nclass Solution:\n def twoSum(self, nums: List[int], target: int) -> List[int]:\n num_dict = {}\n for i, num in enumerate(nums):\n complement = target - num\n if complement in num_dict:\n return [num_dict[complement], i]\n num_dict[num] = i\n return []\n```

Two Sum

two-sum

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.

Array,Hash Table

Easy

A really brute force way would be to search for all possible pairs of numbers but that would be too slow. Again, it's best to try out brute force solutions for just for completeness. It is from these brute force solutions that you can come up with optimizations. So, if we fix one of the numbers, say x, we have to scan the entire array to find the next number y which is value - x where value is the input parameter. Can we change our array somehow so that this search becomes faster? The second train of thought is, without changing the array, can we use additional space somehow? Like maybe a hash map to speed up the search?

Two Sum

two-sum

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.

Array,Hash Table

Easy

A really brute force way would be to search for all possible pairs of numbers but that would be too slow. Again, it's best to try out brute force solutions for just for completeness. It is from these brute force solutions that you can come up with optimizations. So, if we fix one of the numbers, say x, we have to scan the entire array to find the next number y which is value - x where value is the input parameter. Can we change our array somehow so that this search becomes faster? The second train of thought is, without changing the array, can we use additional space somehow? Like maybe a hash map to speed up the search?

# Approach\nThis code defines a Python class called `Solution` with a method named `twoSum`. The purpose of this method is to find two numbers in a list (`nums`) that add up to a specific target number (`target`). Here\'s a simple explanation of how it works:\n\n1. Create an empty dictionary called `numsList` to store numbers from the list `nums` and their corresponding indices.\n \n2. Loop through each element (`n`) in the `nums` list along with its index (`i`).\n\n3. Calculate the difference (`diff`) between the `target` and the current number `n`. This difference represents the value we need to find in the list in order to reach the target.\n\n4. Check if the `diff` is already in the `numsList` dictionary. If it is, it means we have found a pair of numbers whose sum equals the target. In this case, return a list containing the indices of those two numbers: `[numsList[diff], i]`. This pair of indices will identify the two numbers in the original list that add up to the target.\n\n5. If the `diff` is not in the `numsList` dictionary, it means we haven\'t seen this number before. So, we add the current number `n` to the `numsList` dictionary, with its index `i` as the associated value. This allows us to look up this number later if we encounter its complement in the list.\n\n6. Repeat steps 3 to 5 for each number in the `nums` list until a pair of numbers that adds up to the `target` is found, at which point the function returns the indices of those numbers.\n\nIn summary, this code efficiently finds a pair of numbers in the `nums` list that add up to the given `target`, using a dictionary to keep track of the numbers seen so far and their indices.\n\n# Code\n```\nclass Solution:\n def twoSum(self, nums: List[int], target: int) -> List[int]:\n numsList = {}\n for i,n in enumerate(nums):\n diff = target-n\n if diff in numsList:\n return [numsList[diff], i]\n else:\n numsList[n] = i\n```\n\n**Please upvote if you like the solution.\nHappy Coding! \uD83D\uDE0A**

Two Sum

two-sum

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.

Array,Hash Table

Easy

A really brute force way would be to search for all possible pairs of numbers but that would be too slow. Again, it's best to try out brute force solutions for just for completeness. It is from these brute force solutions that you can come up with optimizations. So, if we fix one of the numbers, say x, we have to scan the entire array to find the next number y which is value - x where value is the input parameter. Can we change our array somehow so that this search becomes faster? The second train of thought is, without changing the array, can we use additional space somehow? Like maybe a hash map to speed up the search?

```\nclass Solution:\n def twoSum(self, nums: List[int], target: int) -> List[int]:\n dict={}\n for index, ele in enumerate(nums):\n if target- ele in dict:\n return dict[target- ele], index\n dict[ele]= index\n```

Two Sum

two-sum

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.

Array,Hash Table

Easy

A really brute force way would be to search for all possible pairs of numbers but that would be too slow. Again, it's best to try out brute force solutions for just for completeness. It is from these brute force solutions that you can come up with optimizations. So, if we fix one of the numbers, say x, we have to scan the entire array to find the next number y which is value - x where value is the input parameter. Can we change our array somehow so that this search becomes faster? The second train of thought is, without changing the array, can we use additional space somehow? Like maybe a hash map to speed up the search?

\n\nInstead of checking every single combination of pairs, the key realization is that for each number in the array, there is only **one** number that can be added to it to reach the target.\n\nWe combine this with a hash table, which can look up values in constant time, to keep track of array elements and its indices as we traverse it. For each array element **x**, we calculate **target - x** and check if we\'ve encountered it in the array before.\n\nIn the worst case, the array will only have to be traversed once, resulting in an O(n) solution.\n\n# Code\n```\nclass Solution(object):\n def twoSum(self, nums, target):\n seen = {}\n for i in range(len(nums)):\n diff = target - nums[i]\n if diff in seen:\n return [seen[diff], i]\n else:\n seen[nums[i]] = i\n```

Add Two Numbers

add-two-numbers

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.

Linked List,Math,Recursion

Medium

# Intuition:\nThe Intuition is to iterate through two linked lists representing non-negative integers in reverse order, starting from the least significant digit. It performs digit-wise addition along with a carry value and constructs a new linked list to represent the sum. The process continues until both input lists and the carry value are exhausted. The resulting linked list represents the sum of the input numbers in the correct order.\n\n# Explanation: \n1. Create a placeholder node called `dummyHead` with a value of 0. This node will hold the resulting linked list.\n2. Initialize a pointer called `tail` and set it to `dummyHead`. This pointer will keep track of the last node in the result list.\n3. Initialize a variable called `carry` to 0. This variable will store the carry value during addition.\n4. Start a loop that continues until there are no more digits in both input lists (`l1` and `l2`) and there is no remaining carry value.\n5. Inside the loop:\n - Check if there is a digit in the current node of `l1`. If it exists, assign its value to a variable called `digit1`. Otherwise, set `digit1` to 0.\n - Check if there is a digit in the current node of `l2`. If it exists, assign its value to a variable called `digit2`. Otherwise, set `digit2` to 0.\n - Add the current digits from `l1` and `l2`, along with the carry value from the previous iteration, and store the sum in a variable called `sum`.\n - Calculate the unit digit of `sum` by taking the modulus (`%`) of `sum` by 10. This digit will be placed in a new node for the result.\n - Update the `carry` variable by dividing `sum` by 10 and taking the integer division (`/`) part. This gives us the carry value for the next iteration.\n - Create a new node with the calculated digit as its value.\n - Attach the new node to the `tail` node of the result list.\n - Move the `tail` pointer to the newly added node.\n - Move to the next nodes in both `l1` and `l2`, if they exist. If either list is exhausted, set the corresponding pointer to `nullptr`.\n6. After the loop, obtain the actual result list by skipping the `dummyHead` node.\n7. Delete the `dummyHead` node.\n8. Return the resulting list.\n\n# Code\n```C++ []\nclass Solution {\npublic:\n ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {\n ListNode* dummyHead = new ListNode(0);\n ListNode* tail = dummyHead;\n int carry = 0;\n\n while (l1 != nullptr || l2 != nullptr || carry != 0) {\n int digit1 = (l1 != nullptr) ? l1->val : 0;\n int digit2 = (l2 != nullptr) ? l2->val : 0;\n\n int sum = digit1 + digit2 + carry;\n int digit = sum % 10;\n carry = sum / 10;\n\n ListNode* newNode = new ListNode(digit);\n tail->next = newNode;\n tail = tail->next;\n\n l1 = (l1 != nullptr) ? l1->next : nullptr;\n l2 = (l2 != nullptr) ? l2->next : nullptr;\n }\n\n ListNode* result = dummyHead->next;\n delete dummyHead;\n return result;\n }\n};\n```\n```Java []\nclass Solution {\n public ListNode addTwoNumbers(ListNode l1, ListNode l2) {\n ListNode dummyHead = new ListNode(0);\n ListNode tail = dummyHead;\n int carry = 0;\n\n while (l1 != null || l2 != null || carry != 0) {\n int digit1 = (l1 != null) ? l1.val : 0;\n int digit2 = (l2 != null) ? l2.val : 0;\n\n int sum = digit1 + digit2 + carry;\n int digit = sum % 10;\n carry = sum / 10;\n\n ListNode newNode = new ListNode(digit);\n tail.next = newNode;\n tail = tail.next;\n\n l1 = (l1 != null) ? l1.next : null;\n l2 = (l2 != null) ? l2.next : null;\n }\n\n ListNode result = dummyHead.next;\n dummyHead.next = null;\n return result;\n }\n}\n```\n```Python3 []\nclass Solution:\n def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:\n dummyHead = ListNode(0)\n tail = dummyHead\n carry = 0\n\n while l1 is not None or l2 is not None or carry != 0:\n digit1 = l1.val if l1 is not None else 0\n digit2 = l2.val if l2 is not None else 0\n\n sum = digit1 + digit2 + carry\n digit = sum % 10\n carry = sum // 10\n\n newNode = ListNode(digit)\n tail.next = newNode\n tail = tail.next\n\n l1 = l1.next if l1 is not None else None\n l2 = l2.next if l2 is not None else None\n\n result = dummyHead.next\n dummyHead.next = None\n return result\n```\n\n![CUTE_CAT.png]()\n\n**If you are a beginner solve these problems which makes concepts clear for future coding:**\n1. [Two Sum]()\n2. [Roman to Integer]()\n3. [Palindrome Number]()\n4. [Maximum Subarray]()\n5. [Remove Element]()\n6. [Contains Duplicate]()\n7. [Add Two Numbers]()\n8. [Majority Element]()\n9. [Remove Duplicates from Sorted Array]()\n10. **Practice them in a row for better understanding and please Upvote the post for more questions.**\n\n\n**If you found my solution helpful, I would greatly appreciate your upvote, as it would motivate me to continue sharing more solutions.**

Add Two Numbers

add-two-numbers

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.

Linked List,Math,Recursion

Medium

\n\nFirst we create a new ListNode, `head`, which will hold our answer. We then traverse the two lists, and at every node, we add the values together, create a new node with the sum, and link it to `head`. However, the problem is complicated by the need to keep track of <i>carries</i>. Here\'s how we deal with it. After adding two digits together:\n\n- The <i>non-carry</i> part is obtained by doing `total % 10`. By taking the remainder of a number after dividing by 10, we only get what\'s left in the ones place. For example, if the total is 15, then 15 % 10 = 5, so we create a new ListNode with value 5 and link it to `head`\n- The <i>carry</i> is obtained by doing `total // 10` (floor division by 10). By dividing by 10 and rounding down, we get the carry value. So 15 // 10 = 1 (1.5 rounded down is 1) so that corresponds to a carry of 1.\n\nWe then keep repeating this until all lists have reached the end AND there are no more carry values. At the end, `head.next`holds the very first node of our answer, so we return `head.next`.\n\n# Code\n```\n# Definition for singly-linked list.\n# class ListNode(object):\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution(object):\n def addTwoNumbers(self, l1, l2):\n head = ListNode()\n current = head\n carry = 0\n while (l1 != None or l2 != None or carry != 0):\n l1_value = l1.val if l1 else 0\n l2_value = l2.val if l2 else 0\n total = l1_value + l2_value + carry\n current.next = ListNode(total % 10)\n carry = total // 10\n # Move list pointers forward\n l1 = l1.next if l1 else None\n l2 = l2.next if l2 else None\n current = current.next\n return head.next\n```

Add Two Numbers

add-two-numbers

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.

Linked List,Math,Recursion

Medium

# Your upvote is my motivation!\n\n\n# Code\n```\n# Definition for singly-linked list.\n# Definition for singly-linked list.\nclass ListNode:\n def __init__(self, val=0, next=None):\n self.val = val\n self.next = next\nclass Solution:\n def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:\n dummyHead = ListNode(0)\n curr = dummyHead\n carry = 0\n while l1 != None or l2 != None or carry != 0:\n l1Val = l1.val if l1 else 0\n l2Val = l2.val if l2 else 0\n columnSum = l1Val + l2Val + carry\n carry = columnSum // 10\n newNode = ListNode(columnSum % 10)\n curr.next = newNode\n curr = newNode\n l1 = l1.next if l1 else None\n l2 = l2.next if l2 else None\n return dummyHead.next\n\n\n<!-- ========================================================= -->\n# Long Approach to understand\n<!-- Same Approach but diff way -- 99.9% beats in Memory -->\n\n newhead = ListNode(-1)\n temphead = newhead\n c = 0\n\n while l1 and l2:\n cur_digit = l1.val + l2.val + c # 25\n\n if cur_digit >= 10:\n c = cur_digit // 10 #2\n cur_digit = cur_digit % 10 #5\n else:\n c = 0\n \n new_node = ListNode(cur_digit)\n temphead.next = new_node\n temphead = new_node\n \n l1 = l1.next\n l2 = l2.next\n \n while l1:\n cur_digit = l1.val + c\n if cur_digit >= 10:\n c = cur_digit // 10 #2\n cur_digit = cur_digit % 10 #5\n else:\n c = 0\n new_node = ListNode(cur_digit)\n temphead.next = new_node\n temphead = new_node\n l1 = l1.next\n \n while l2:\n cur_digit = l2.val + c\n if cur_digit >= 10:\n c = cur_digit // 10 #2\n cur_digit = cur_digit % 10 #5\n else:\n c = 0\n new_node = ListNode(cur_digit)\n temphead.next = new_node\n temphead = new_node\n l2 = l2.next\n \n if c == 0:\n return newhead.next\n else:\n new_node = ListNode(c)\n temphead.next = new_node\n return newhead.next\n\n```

Add Two Numbers

add-two-numbers

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.

Linked List,Math,Recursion

Medium

# Code\n```\n# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:\n d = n = ListNode(0)\n num1 = num2 = ""\n while l1:\n num1 += str(l1.val)\n l1 = l1.next\n while l2:\n num2 += str(l2.val)\n l2 = l2.next\n res = str(int(num1[::-1]) + int(num2[::-1]))[::-1]\n for i in res:\n d.next = ListNode(i)\n d = d.next\n return n.next \n```\nDo upvote if you like the Solution :)

Add Two Numbers

add-two-numbers

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.

Linked List,Math,Recursion

Medium

\n### steps\n1. Initialize a dummy node and a current node to keep track of the result linked list.\n2. Initialize carry to 0.\n3. Traverse both input linked lists simultaneously.\n4. At each step, calculate the sum of the current nodes\' values along with the carry.\n5. Calculate the carry for the next iteration as sum / 10.\n6. Create a new node with the value sum % 10 and append it to the result list.\n7. Move to the next nodes in both input lists.\n8. Repeat steps 4-7 until you have processed all digits in both input lists.\n9. If there is still a carry left after the loop, create an additional node with the carry as its value and append it to the result list.\n10. Return the next node of the dummy node, which represents the head of the result linked list.\n\n\n``` java []\nclass Solution {\n public ListNode addTwoNumbers(ListNode l1, ListNode l2) {\n ListNode dummy = new ListNode(0); // Dummy node to simplify result list handling\n ListNode current = dummy; // Current node to build the result list\n int carry = 0; // Initialize carry to 0\n\n while (l1 != null || l2 != null) {\n int x = (l1 != null) ? l1.val : 0; // Get the current digit from l1 or set to 0 if null\n int y = (l2 != null) ? l2.val : 0; // Get the current digit from l2 or set to 0 if null\n\n int sum = x + y + carry; // Calculate the sum of digits and carry\n carry = sum / 10; // Calculate the carry for the next iteration\n\n // Create a new node with the value sum % 10 and append it to the result list\n current.next = new ListNode(sum % 10);\n current = current.next; // Move to the next node in the result list\n\n // Move to the next nodes in both input lists if they are not null\n if (l1 != null) l1 = l1.next;\n if (l2 != null) l2 = l2.next;\n }\n\n // If there is still a carry left after the loop, create an additional node for it\n if (carry > 0) {\n current.next = new ListNode(carry);\n }\n\n return dummy.next; // Return the next node of the dummy node, which is the head of the result list\n }\n}\n```\n``` C++ []\nclass Solution {\npublic:\n ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {\n ListNode* dummy_head = new ListNode(0); // Dummy head to simplify the code\n ListNode* current = dummy_head;\n int carry = 0;\n\n while (l1 || l2) {\n int x = (l1) ? l1->val : 0;\n int y = (l2) ? l2->val : 0;\n int sum = x + y + carry;\n\n carry = sum / 10;\n current->next = new ListNode(sum % 10);\n current = current->next;\n\n if (l1) l1 = l1->next;\n if (l2) l2 = l2->next;\n }\n\n if (carry > 0) {\n current->next = new ListNode(carry);\n }\n\n return dummy_head->next; // Return the actual result, not the dummy head.\n\n }\n};\n```\n``` Python []\n\ndef addTwoNumbers(l1, l2):\n dummy = ListNode()\n current = dummy\n p, q = l1, l2\n carry = 0\n \n while p or q:\n x = p.val if p else 0\n y = q.val if q else 0\n val = carry + x + y\n carry = val // 10\n current.next = ListNode(val % 10)\n current = current.next\n \n if p:\n p = p.next\n if q:\n q = q.next\n \n if carry > 0:\n current.next = ListNode(carry)\n \n return dummy.next\n\n```\n``` javascript []\nvar addTwoNumbers = function(l1, l2) {\n let dummyHead = new ListNode(0); // Create a dummy node to simplify the code.\n let current = dummyHead; // Initialize a current pointer to the dummy node.\n let carry = 0; // Initialize a variable to store the carry value.\n\n while (l1 || l2) {\n const x = l1 ? l1.val : 0;\n const y = l2 ? l2.val : 0;\n const sum = x + y + carry;\n\n carry = Math.floor(sum / 10); // Calculate the carry for the next iteration.\n current.next = new ListNode(sum % 10); // Create a new node with the current digit.\n\n current = current.next; // Move the current pointer to the next node.\n\n if (l1) l1 = l1.next;\n if (l2) l2 = l2.next;\n }\n\n // If there is a carry after processing all digits, add it as a new node.\n if (carry > 0) {\n current.next = new ListNode(carry);\n }\n\n return dummyHead.next; // Return the result, skipping the dummy node.\n}\n```\n\n``` C# []\npublic class Solution {\n public ListNode AddTwoNumbers(ListNode l1, ListNode l2) {\n ListNode dummyHead = new ListNode();\n ListNode current = dummyHead;\n int carry = 0;\n\n while (l1 != null || l2 != null)\n {\n int x = (l1 != null) ? l1.val : 0;\n int y = (l2 != null) ? l2.val : 0;\n\n int sum = x + y + carry;\n carry = sum / 10;\n\n current.next = new ListNode(sum % 10);\n current = current.next;\n\n if (l1 != null) l1 = l1.next;\n if (l2 != null) l2 = l2.next;\n }\n\n if (carry > 0)\n {\n current.next = new ListNode(carry);\n }\n\n return dummyHead.next; \n }\n}\n```\n\n``` PHP []\n\nfunction addTwoNumbers($l1, $l2) {\n $dummy = new ListNode(0);\n $current = $dummy;\n $carry = 0;\n \n while ($l1 !== null || $l2 !== null) {\n $x = ($l1 !== null) ? $l1->val : 0;\n $y = ($l2 !== null) ? $l2->val : 0;\n \n $sum = $x + $y + $carry;\n $carry = (int)($sum / 10);\n \n $current->next = new ListNode($sum % 10);\n $current = $current->next;\n \n if ($l1 !== null) $l1 = $l1->next;\n if ($l2 !== null) $l2 = $l2->next;\n }\n \n if ($carry > 0) {\n $current->next = new ListNode($carry);\n }\n \n return $dummy->next;\n}\n```

Add Two Numbers

add-two-numbers

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.

Linked List,Math,Recursion

Medium

class Solution:\n # @return a ListNode\n def addTwoNumbers(self, l1, l2):\n carry = 0\n root = n = ListNode(0)\n while l1 or l2 or carry:\n v1 = v2 = 0\n if l1:\n v1 = l1.val\n l1 = l1.next\n if l2:\n v2 = l2.val\n l2 = l2.next\n carry, val = divmod(v1+v2+carry, 10)\n n.next = ListNode(val)\n n = n.next\n return root.next

Longest Substring Without Repeating Characters

longest-substring-without-repeating-characters

Given a string s, find the length of the longest substring without repeating characters.

Hash Table,String,Sliding Window

Medium

# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nThe intuition behind the 3 solutions is to iteratively find the longest substring without repeating characters by maintaining a sliding window approach. We use two pointers (`left` and `right`) to represent the boundaries of the current substring. As we iterate through the string, we update the pointers and adjust the window to accommodate new unique characters and eliminate repeating characters.\n\n# Approach 1 - Set\n<!-- Describe your approach to solving the problem. -->\n\n1. We use a set (`charSet`) to keep track of unique characters in the current substring.\n2. We maintain two pointers, `left` and `right`, to represent the boundaries of the current substring.\n3. The `maxLength` variable keeps track of the length of the longest substring encountered so far.\n4. We iterate through the string using the `right` pointer.\n5. If the current character is not in the set (`charSet`), it means we have a new unique character.\n6. We insert the character into the set and update the `maxLength` if necessary.\n7. If the character is already present in the set, it indicates a repeating character within the current substring.\n8. In this case, we move the `left` pointer forward, removing characters from the set until the repeating character is no longer present.\n9. We insert the current character into the set and continue the iteration.\n10. Finally, we return the `maxLength` as the length of the longest substring without repeating characters.\n\n# Code\n```C++ []\nclass Solution {\npublic:\n int lengthOfLongestSubstring(string s) {\n int n = s.length();\n int maxLength = 0;\n unordered_set<char> charSet;\n int left = 0;\n \n for (int right = 0; right < n; right++) {\n if (charSet.count(s[right]) == 0) {\n charSet.insert(s[right]);\n maxLength = max(maxLength, right - left + 1);\n } else {\n while (charSet.count(s[right])) {\n charSet.erase(s[left]);\n left++;\n }\n charSet.insert(s[right]);\n }\n }\n \n return maxLength;\n }\n};\n```\n```Java []\nclass Solution {\n public int lengthOfLongestSubstring(String s) {\n int n = s.length();\n int maxLength = 0;\n Set<Character> charSet = new HashSet<>();\n int left = 0;\n \n for (int right = 0; right < n; right++) {\n if (!charSet.contains(s.charAt(right))) {\n charSet.add(s.charAt(right));\n maxLength = Math.max(maxLength, right - left + 1);\n } else {\n while (charSet.contains(s.charAt(right))) {\n charSet.remove(s.charAt(left));\n left++;\n }\n charSet.add(s.charAt(right));\n }\n }\n \n return maxLength;\n }\n}\n\n```\n```Python3 []\nclass Solution:\n def lengthOfLongestSubstring(self, s: str) -> int:\n n = len(s)\n maxLength = 0\n charSet = set()\n left = 0\n \n for right in range(n):\n if s[right] not in charSet:\n charSet.add(s[right])\n maxLength = max(maxLength, right - left + 1)\n else:\n while s[right] in charSet:\n charSet.remove(s[left])\n left += 1\n charSet.add(s[right])\n \n return maxLength\n\n```\n\n# Approach 2 - Unordered Map\n1. We improve upon the first solution by using an unordered map (`charMap`) instead of a set.\n2. The map stores characters as keys and their indices as values.\n3. We still maintain the `left` and `right` pointers and the `maxLength` variable.\n4. We iterate through the string using the `right` pointer.\n5. If the current character is not in the map or its index is less than `left`, it means it is a new unique character.\n6 We update the `charMap` with the character\'s index and update the `maxLength` if necessary.\n7. If the character is repeating within the current substring, we move the `left` pointer to the next position after the last occurrence of the character.\n8. We update the index of the current character in the `charMap` and continue the iteration.\n9. At the end, we return the `maxLength` as the length of the longest substring without repeating characters.\n\n# Code\n```C++ []\nclass Solution {\npublic:\n int lengthOfLongestSubstring(string s) {\n int n = s.length();\n int maxLength = 0;\n unordered_map<char, int> charMap;\n int left = 0;\n \n for (int right = 0; right < n; right++) {\n if (charMap.count(s[right]) == 0 || charMap[s[right]] < left) {\n charMap[s[right]] = right;\n maxLength = max(maxLength, right - left + 1);\n } else {\n left = charMap[s[right]] + 1;\n charMap[s[right]] = right;\n }\n }\n \n return maxLength;\n }\n};\n```\n```Java []\nclass Solution {\n public int lengthOfLongestSubstring(String s) {\n int n = s.length();\n int maxLength = 0;\n Map<Character, Integer> charMap = new HashMap<>();\n int left = 0;\n \n for (int right = 0; right < n; right++) {\n if (!charMap.containsKey(s.charAt(right)) || charMap.get(s.charAt(right)) < left) {\n charMap.put(s.charAt(right), right);\n maxLength = Math.max(maxLength, right - left + 1);\n } else {\n left = charMap.get(s.charAt(right)) + 1;\n charMap.put(s.charAt(right), right);\n }\n }\n \n return maxLength;\n }\n}\n\n```\n```Python3 []\nclass Solution:\n def lengthOfLongestSubstring(self, s: str) -> int:\n n = len(s)\n maxLength = 0\n charMap = {}\n left = 0\n \n for right in range(n):\n if s[right] not in charMap or charMap[s[right]] < left:\n charMap[s[right]] = right\n maxLength = max(maxLength, right - left + 1)\n else:\n left = charMap[s[right]] + 1\n charMap[s[right]] = right\n \n return maxLength\n\n```\n\n# Approach 3 - Integer Array\n1. This solution uses an integer array `charIndex` to store the indices of characters.\n2. We eliminate the need for an unordered map by utilizing the array.\n3. The `maxLength`, `left`, and `right` pointers are still present.\n4. We iterate through the string using the `right` pointer.\n5. We check if the current character has occurred within the current substring by comparing its index in `charIndex` with `left`.\n6. If the character has occurred, we move the `left` pointer to the next position after the last occurrence of the character.\n7. We update the index of the current character in `charIndex`.\n8. At each step, we update the `maxLength` by calculating the length of the current substring.\n9. We continue the iteration until reaching the end of the string.\n10. Finally, we return the `maxLength` as the length of the longest substring without repeating characters.\n\n# Code\n```C++ []\nclass Solution {\npublic:\n int lengthOfLongestSubstring(string s) {\n int n = s.length();\n int maxLength = 0;\n vector<int> charIndex(128, -1);\n int left = 0;\n \n for (int right = 0; right < n; right++) {\n if (charIndex[s[right]] >= left) {\n left = charIndex[s[right]] + 1;\n }\n charIndex[s[right]] = right;\n maxLength = max(maxLength, right - left + 1);\n }\n \n return maxLength;\n }\n};\n```\n```Java []\nclass Solution {\n public int lengthOfLongestSubstring(String s) {\n int n = s.length();\n int maxLength = 0;\n int[] charIndex = new int[128];\n Arrays.fill(charIndex, -1);\n int left = 0;\n \n for (int right = 0; right < n; right++) {\n if (charIndex[s.charAt(right)] >= left) {\n left = charIndex[s.charAt(right)] + 1;\n }\n charIndex[s.charAt(right)] = right;\n maxLength = Math.max(maxLength, right - left + 1);\n }\n \n return maxLength;\n }\n}\n\n```\n```Python3 []\nclass Solution:\n def lengthOfLongestSubstring(self, s: str) -> int:\n n = len(s)\n maxLength = 0\n charIndex = [-1] * 128\n left = 0\n \n for right in range(n):\n if charIndex[ord(s[right])] >= left:\n left = charIndex[ord(s[right])] + 1\n charIndex[ord(s[right])] = right\n maxLength = max(maxLength, right - left + 1)\n \n return maxLength\n\n```\n\n![CUTE_CAT.png]()\n**If you found my solution helpful, I would greatly appreciate your upvote, as it would motivate me to continue sharing more solutions.**\n\n\n

Longest Substring Without Repeating Characters

longest-substring-without-repeating-characters

Given a string s, find the length of the longest substring without repeating characters.

Hash Table,String,Sliding Window

Medium

# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nif you know sliding window...then it can be intuitive. But if you don\'t know ...no worry i will teach you...\nRefer below approach points.....\n# Approach\n<!-- Describe your approach to solving the problem. -->\n1. Use sliding window with hashset, use left and right pointers to move the window . \n2. If the set doesn\'t contains character then first add into the set and calculate the maxLength hand-in-hand... \n3. if character already present in the set that means you have to move your sliding window by 1 , before that you have to remove all the characters that are infront of the character that is present already in window before.\n4. Now you have to remove that character also and move the left pointer and also add the new character into the set.\n5. THAT\'S ALL........EASY APPROACH USING SIMPLE HASHSET+SLIDING WINDOW\n\n# Complexity\n- Time complexity: O(n)\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity: O(k), where k is the number of distinctive characters prsent in the hashset.\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\nclass Solution {\n public int lengthOfLongestSubstring(String s) {\n Set<Character>set=new HashSet<>();\n int maxLength=0;\n int left=0;\n for(int right=0;right<s.length();right++){\n \n if(!set.contains(s.charAt(right))){\n set.add(s.charAt(right));\n maxLength=Math.max(maxLength,right-left+1);\n \n }else{\n while(s.charAt(left)!=s.charAt(right)){\n set.remove(s.charAt(left));\n left++;\n }\n set.remove(s.charAt(left));left++;\n set.add(s.charAt(right));\n }\n \n }\n return maxLength;\n }\n}\n```\n\n![upvote.jpg]()\n\n\n**PLEASE UPVOTE** .....if you find this solution useful , and if any suggestions to improve then please comment.

Longest Substring Without Repeating Characters

longest-substring-without-repeating-characters

Given a string s, find the length of the longest substring without repeating characters.

Hash Table,String,Sliding Window

Medium

\n\nA brute force solution would first require finding every possible substring, which would run in O(n²) time. We\'re not done yet though, because we now have to check every substring for duplicate characters by iterating through every substring. Each check for duplicate characters runs in O(n) time, and we need to do that for every substring generated (which ran in O(n²) time), so the brute force approach ends up running in O(n³) time.\n\nInstead, we can reduce this to O(n) time by using a sliding window approach and eliminating unnecessary computations. We use two pointers, `l` and `r`, to denote where the substring starts and ends, and a dictionary called `seen` to keep track of the index of each character encountered. Then, we move the right pointer one character at a time to the right to expand our substring.\n\nAt each iteration, we check for two things.\n1. Have we seen the newly added character (at index `r`) before? If we haven\'t, then this is a brand new character and we can just add it to the substring and extend the length\n2. If we have seen it before, is its last known position greater than or equal to the left index? If it is, then that means it\'s repeated somewhere in the substring. If not, then that means it\'s <i>outside</i> of the substring, so we can just add it to the substring and extend the length\n\nSo if both conditions are true, the new character is repeated and we have a problem. We can get rid of the repeated character by moving up the left pointer to be one index past the last recorded index in `seen`. Then, we just keep moving up the right pointer until it reaches the end of the string. Since we only have to loop through the string once, and since hash table lookups run in constant time, this algorithm ends up running in O(n) time.\n\nFor an intuitive proof of why this works and why we don\'t need to check all the other substrings while moving up the left pointer, please see the video - it\'s a bit difficult to explain without a visualization and a concrete example. But basically, all the other substrings will either still contain a repeated character or will be shorter than the last valid substring encountered, so they can be safely ignored.\n\n\n# Code\n```\nclass Solution(object):\n def lengthOfLongestSubstring(self, s):\n seen = {}\n l = 0\n length = 0\n for r in range(len(s)):\n char = s[r]\n if char in seen and seen[char] >= l:\n l = seen[char] + 1\n else:\n length = max(length, r - l + 1)\n seen[char] = r\n\n return length\n```

Longest Substring Without Repeating Characters

longest-substring-without-repeating-characters

Given a string s, find the length of the longest substring without repeating characters.

Hash Table,String,Sliding Window

Medium

**Sliding window**\nWe use a dictionary to store the character as the key, the last appear index has been seen so far as value.\nseen[charactor] = index\n\n move the pointer when you met a repeated character in your window.\n\n\t \n```\nindext 0 1 2 3 4 5 6 7\nstring a c b d b a c d\n ^ ^\n | |\n\t\tleft right\n\t\tseen = {a : 0, c : 1, b : 2, d: 3} \n\t\t# case 1: seen[b] = 2, current window is s[0:4] , \n\t\t# b is inside current window, seen[b] = 2 > left = 0. Move left pointer to seen[b] + 1 = 3\n\t\tseen = {a : 0, c : 1, b : 4, d: 3} \nindext 0 1 2 3 4 5 6 7\nstring a c b d b a c d\n\t\t\t\t\t\t ^ ^\n\t\t\t\t\t | |\n\t\t\t\t left right\t\t\nindext 0 1 2 3 4 5 6 7\nstring a c b d b a c d\n\t\t\t\t\t ^ ^\n\t\t\t\t\t | |\n\t\t\t\t left right\t\t\n\t\t# case 2: seen[a] = 0,which means a not in current window s[3:5] , since seen[a] = 0 < left = 3 \n\t\t# we can keep moving right pointer.\n```\n\n```\nclass Solution:\n def lengthOfLongestSubstring(self, s: str) -> int:\n seen = {}\n l = 0\n output = 0\n for r in range(len(s)):\n """\n If s[r] not in seen, we can keep increasing the window size by moving right pointer\n """\n if s[r] not in seen:\n output = max(output,r-l+1)\n """\n There are two cases if s[r] in seen:\n case1: s[r] is inside the current window, we need to change the window by moving left pointer to seen[s[r]] + 1.\n case2: s[r] is not inside the current window, we can keep increase the window\n """\n else:\n if seen[s[r]] < l:\n output = max(output,r-l+1)\n else:\n l = seen[s[r]] + 1\n seen[s[r]] = r\n return output\n```\n* Time complexity :O(n). \n\tn is the length of the input string.\n\tIt will iterate n times to get the result.\n\n* Space complexity: O(m)\n\tm is the number of unique characters of the input. \n\tWe need a dictionary to store unique characters.\n\n

Longest Substring Without Repeating Characters

longest-substring-without-repeating-characters

Given a string s, find the length of the longest substring without repeating characters.

Hash Table,String,Sliding Window

Medium

# First Approach\n- Using set stl.\n- Time complexity: O(2*n)~O(n)\n- Space complexity: O(n) \n# Code\n```\nlass Solution {\npublic:\n int lengthOfLongestSubstring(string s) {\n unordered_set<char> t;\n int m=0;\n int l=0,r=0;\n while(r<s.size())\n {\n //To eliminate the below loop for finding the index of \n //repeated character use the below approach by storing the\n //indicies using a vector or hasmap.\n while(t.find(s[r])!=t.end())\n {\n t.erase(s[l]);\n l++;\n }\n t.insert(s[r]);\n m=max(m,r-l+1);\n r++;\n \n }\n return m;\n \n }\n};\n```\n\n# Approach for optimization\n- Using index array\n\n# Complexity\n- Time complexity: O(n) \n- Space complexity: O(1) \n\n\n# Code\n```\nclass Solution {\npublic:\n int lengthOfLongestSubstring(string s) {\n vector<int> m(256,-1); //index array \n int len=0;\n\n int r=0,l=0;\n while(r<s.size())\n {\n if(m[s[r]]!=-1 and l<m[s[r]]+1)\n {\n l=m[s[r]]+1; \n }\n m[s[r]]=r;\n len=max(len,r-l+1);\n r++;\n }\n return len;\n \n }\n};\n```\n

Longest Substring Without Repeating Characters

longest-substring-without-repeating-characters

Given a string s, find the length of the longest substring without repeating characters.

Hash Table,String,Sliding Window

Medium

See Code and Explanation : **\u2B50[]()\u2B50**\n\n**Examples : C# - HashSet**\n```\npublic class Solution {\n public int LengthOfLongestSubstring(string s) {\n \n if(string.IsNullOrEmpty(s))\n {\n return 0;\n }\n\n HashSet<char> hSet = new HashSet<char>();\n int max = 0;\n int i = 0;\n int j = 0;\n \n while(i<s.Length)\n {\n if(!hSet.Contains(s[i]))\n {\n hSet.Add(s[i]);\n i++;\n \n }\n else\n {\n max = Math.Max(max,hSet.Count);\n hSet.Remove(s[j]);\n j++;\n }\n }\n max = Math.Max(max,hSet.Count);\n return max;\n \n }\n}\n```\n\n**Examples : C# - Dictionary**\n```\npublic class Solution {\n public int LengthOfLongestSubstring(string s) {\n Dictionary<char,int> dict = new Dictionary<char,int>();\n int max = 0;\n \n for (int i = 0;i < s.Length;i++)\n {\n char c = s[i];\n if (!dict.ContainsKey(c))\n {\n dict.Add(c, i);\n max = Math.Max(dict.Count, max);\n }\n else\n {\n i = dict[c] ;\n dict.Clear();\n }\n }\n return max; \n }\n}\n```\n\n\nIf you got any problem about the explanation or you need other programming language solution, please feel free to leave your comment.\n\n\uD83E\uDDE1See more problems solutions - **[Zyrastory - LeetCode Solution]()**\n\nThanks!

Longest Substring Without Repeating Characters

longest-substring-without-repeating-characters

Given a string s, find the length of the longest substring without repeating characters.

Hash Table,String,Sliding Window

Medium

\n\n# Code\n```\nclass Solution:\n def lengthOfLongestSubstring(self, s: str) -> int:\n l=len(s)\n if l==0:\n return 0\n dicts={}\n max_len=0\n start=0\n for i in range(l):\n if s[i] in dicts and start<=dicts[s[i]]:\n start = dicts[s[i]]+1\n else:\n max_len=max(max_len,i-start+1)\n dicts[s[i]]=i\n return max_len\n \n```\n![7abc56.jpg]()\n

Longest Substring Without Repeating Characters

longest-substring-without-repeating-characters

Given a string s, find the length of the longest substring without repeating characters.

Hash Table,String,Sliding Window

Medium

Lets start with the following example: \n\n**Assume you had no repeating characters** (In below example, just look at *first three* characters)\n\nWe take two pointers, `l` and `r`, both starting at `0`. At every iteration, we update the longest string with non-repeating characters found = `r-l+1` and just keep a note of which character we see at which index\n\n\n<img src="" width=400/>\n\n\n```python\n def lengthOfLongestSubstringSimpler(self, s):\n seen = {}\n left, right = 0, 0\n longest = 1\n while right < len(s):\n longest = max(longest, right - left + 1)\n seen[s[right]] = right\n right += 1\n return longest\n```\n\nAfter 3 iterations, if you were keeping a map of when you last saw the character, you\'d have something like this:\n\n<img src="" width=300/>\n\nat this point, `longest = r-l+1 = 2 - 0 + 1 = 3`\n\nNow, lets face it - our string _does_ have repeating characters. We look at index 3, we\'re realizing we\'ve seen `a` before. So we now, we can\'t just calculate the value of `longest` like we were doing before. We need to make sure our left pointer, or `l`, is at least past the index where we last saw `a` , thus - we move `l ` to ` seen[right]+1`. We also update our map with last seen of `a` to `3`\n\n<img src="" width=300/>\n\nAnd this interplay goes on\n\n<img src="" width=300/>\n\n\n```python\n def lengthOfLongestSubstring(self, s):\n """\n :type s: str\n :rtype: int \n """\n if len(s) == 0:\n return 0\n seen = {}\n left, right = 0, 0\n longest = 1\n while right < len(s):\n if s[right] in seen:\n left = seen[s[right]]+1\n longest = max(longest, right - left + 1)\n seen[s[right]] = right\n right += 1\n return longest\n```\n\nLife was good, until this test case came into our lives:\n`abba`\n\n<img src="" width=200/>\n\nAnd we realised, after 4 iterations, our left pointer was to be moved `seen[s[right]]+1 = seen[a] + 1 = 1` - wait what, left was to move back ? That doesn\'t sound correct - that\'d give us longest to be 3 (bba) which is NOT CORRECT\n\nThus, we need to ensure that `l` always goes to the right of it, or just stays at its position\n\nIn other words;\n\n```python\nclass Solution(object):\n def lengthOfLongestSubstring(self, s):\n """\n :type s: str\n :rtype: int abcabcbb\n """\n if len(s) == 0:\n return 0\n seen = {}\n left, right = 0, 0\n longest = 1\n while right < len(s):\n if s[right] in seen:\n left = max(left,seen[s[right]]+1)\n longest = max(longest, right - left + 1)\n seen[s[right]] = right\n right += 1\n print(left, right, longest)\n return longest\n```\n\nThanks, and don\'t forget to upvote if it helped you !\n\n\n\n**BONUS** Trying to be a strong Java Developer ? Checkout this [awesome hands-on series]() with illustrations! \n

Longest Substring Without Repeating Characters

longest-substring-without-repeating-characters

Given a string s, find the length of the longest substring without repeating characters.

Hash Table,String,Sliding Window

Medium

# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\nclass Solution:\n def lengthOfLongestSubstring(self, s: str) -> int:\n start=0\n count=0\n for end in range(1,len(s)+1):\n if len(set(s[start:end]))==len(s[start:end]):\n if (end-start+1)>count:\n count=len(s[start:end])\n else:\n start+=1\n return(count)\n\n```

Longest Substring Without Repeating Characters

longest-substring-without-repeating-characters

Given a string s, find the length of the longest substring without repeating characters.

Hash Table,String,Sliding Window

Medium

# Intuition\nwe use a **starting point** while iterating over the given string and every time we find a repeated character we calculate the length of the substring between the starting point and the current point - 1.\nevery time we find a repetition we set the starting point to the character next to the last occurrence.\n\n**Ex :** consider the string **`abcdae`**\n\nthe starting point will be $$0$$ initially, we keep iterating until we find the second **`a`**. we calculate then the length of the substring **`abcd`** and then set the starting point to the character next to the first **`a`**, which is **`b`**.\nthen, we will keep iterating until the end since there are no more repetitions and the answer will be $$5$$ (the length of **`bcdae`**).\n\n# Approach\nwe will need $$2$$ variables: \n1. $$`longest`$$ to **save the length of the longest substring found**\n2. $$`offset`$$ for **the starting point**.\n\nwe will also need to save the encountered characters to check repetition, a dictionary will be ideal for this case as it doesn\'t allow repetition. for that we will use an extra variable \n- $$`indexes`$$: to save characters and their indexes, **characters** will be **keys** and **indexes** will be **values**.\n\nwe start then: for every character: \n1. we get its index from indexes dictionary.\n2. if the index wasn\'t null `(meaning that it was encountered before)`, we check if its index is **greater or equal to the offset** `(meaning that its in the current substring)`.\nif so :\n - we calculate the length of the substring : $$i\\,(current\\: position) - offset$$\n - we set the offset to the next character of the last occurrence : $$index\\,(last\\:occurrence) + 1$$\n - if the length of this substring is greater than the length of the current longest substring, we update it\n3. we update the index of the last occurrence of the current character (or add it if this is its first occurrence).\n\nFinally, we return the **maximum** between $$`longest`$$ and **the length of the last substring** `(which is equal to the difference between the length of the string and offset)`as it contains **no repeated characters** and its length is **never compared** to $$`longest`$$ because **we get out of the loop**.\n\n# Complexity\n- Time complexity:\n$$O(n)$$\n\n# Code\n```\nclass Solution:\n def lengthOfLongestSubstring(self, s: str) -> int:\n longest = 0\n indexes = {}\n offset = 0\n for i in range(len(s)):\n char = s[i]\n index = indexes.get(char)\n if index is not None and index >= offset:\n length = i - offset\n offset = index + 1\n if length > longest:\n longest = length\n indexes[char] = i\n return max(longest, (len(s) - offset))\n```

Longest Substring Without Repeating Characters

longest-substring-without-repeating-characters

Given a string s, find the length of the longest substring without repeating characters.

Hash Table,String,Sliding Window

Medium

class Solution:\n # @return an integer\n def lengthOfLongestSubstring(self, s):\n start = maxLength = 0\n usedChar = {}\n \n for i in range(len(s)):\n if s[i] in usedChar and start <= usedChar[s[i]]:\n start = usedChar[s[i]] + 1\n else:\n maxLength = max(maxLength, i - start + 1)\n \n usedChar[s[i]] = i\n \n return maxLength

Longest Substring Without Repeating Characters

longest-substring-without-repeating-characters

Given a string s, find the length of the longest substring without repeating characters.

Hash Table,String,Sliding Window

Medium

**\u2705 IF YOU LIKE THIS SOLUTION, PLEASE UPVOTE.**\n****\nThis solution employs storage of positions and calculation of their differences for repeated characters. Time complexity is linear: **O(N)**. Space complexity is constant: **O(1)**. \n\n| Language | [**Python**]() | [**C++**]() | [**Java**]() | [**Rust**]() | \n|---|---|---|---|---|\n| Runtime | **62 ms (95.17%)** | **0 ms (100.00%)** | **2 ms (100.00%)** | **0 ms (100.00%)** |\n| Memory | **14.0 MB (93.06%)** | **7.6 MB (87.55%)** | **42.1 MB (98.23%)** | **7.6 MB (87.55%)** |\n\n<iframe src="" frameBorder="0" width="800" height="600"></iframe>

Median of Two Sorted Arrays

median-of-two-sorted-arrays

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)).

Array,Binary Search,Divide and Conquer

Hard

I made a super detailed video walkthrough, since this is a really tough question \uD83D\uDE42 \nPlease upvote if you find this helpful!\n\n\n\nCode:\n```\nclass Solution:\n def findMedianSortedArrays(self, nums1, nums2):\n if len(nums1) > len(nums2):\n nums1, nums2 = nums2, nums1\n \n m, n = len(nums1), len(nums2)\n left, right = 0, m\n N = m + n\n\n while left <= right:\n A = (left + right) // 2\n B = ((N + 1) // 2) - A\n\n x1 = -float("inf") if A - 1 < 0 else nums1[A - 1]\n y1 = float("inf") if A == m else nums1[A]\n x2 = -float("inf") if B - 1 < 0 else nums2[B - 1]\n y2 = float("inf") if B == n else nums2[B]\n\n if x1 <= y2 and x2 <= y1:\n if N % 2 == 0:\n return (max(x1, x2) + min(y1, y2)) / 2\n else:\n return max(x1, x2)\n elif x1 > y2:\n right = A - 1\n else:\n left = A + 1\n```

Median of Two Sorted Arrays

median-of-two-sorted-arrays

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)).

Array,Binary Search,Divide and Conquer

Hard

# Problem Understanding:\nIn simpler terms, you need to **find the middle value of the combined**, sorted array formed by merging nums1 and nums2. If the combined **array has an even number** of elements, you should return the average of the two middle values. **If it has an odd number of elements, you should return the middle value itself.**\n<!-- Describe your first thoughts on how to solve this problem. -->\n# Hint:\n```Hint1 []\nThink of a brute force approach.\n```\n```Hint2 []\nDo you think how two pointer will help us?\n```\n```Hint3 []\nCan you observe the fact that the given arrays are sorted?\n```\n**I would recommend you, don\'t jump directly on solution.**\n# Approach 1: Merge and Sort\n- **Create a new array** with a size equal to the total number of elements in both input arrays.\n- **Insert elements** from both input arrays into the new array.\n- **Sort the new array.**\n- **Find and return the median of the sorted array.**\n\n**Time Complexity**\n- In the worst case TC is **O((n + m) * log(n + m))**.\n\n**Space Complexity**\n - **O(n + m)**, where \u2018n\u2019 and \u2018m\u2019 are the sizes of the arrays.\n# Approach 2: Two-Pointer Method\n\n- **Initialize two pointers**, i and j, both initially set to 0.\n- **Move the pointer** that corresponds to the **smaller value forward at each step.**\n- Continue moving the pointers **until you have processed half of the total number of elements.**\n- Calculate and **return the median** based on the values pointed to by i and j.\n\n\n**Time Complexity**\n- **O(n + m)**, where \u2018n\u2019 & \u2018m\u2019 are the sizes of the two arrays.\n\n**Space Complexity**\n - **O(1)**.\n\n# Approach 3: Binary Search\n\n- **Use binary search to partition the smaller of the two input arrays into two parts.**\n- Find the partition of the **larger array such that the sum of elements on the left side of the partition in both arrays is half of the total elements.**\n- Check if this partition **is valid by verifying** if the largest number on the left side is smaller than the smallest number on the right side.\n- **If the partition is valid,** calculate and return the median.\n\n**Time Complexity**\n- **O(logm/logn)**\n\n**Space Complexity**\n - **O(1)**\n\n---\n\n# SMALL REQUEST : If you found this post even remotely helpful, be kind enough to smash a upvote. I will be grateful.I will be motivated\uD83D\uDE0A\uD83D\uDE0A\n\n---\n\n\n<!-- Describe your approach to solving the problem. -->\n# Code Brute Force- Merge and Sort\n```C++ []\nclass Solution {\npublic:\n double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {\n // Get the sizes of both input arrays.\n int n = nums1.size();\n int m = nums2.size();\n\n // Merge the arrays into a single sorted array.\n vector<int> merged;\n for (int i = 0; i < n; i++) {\n merged.push_back(nums1[i]);\n }\n for (int i = 0; i < m; i++) {\n merged.push_back(nums2[i]);\n }\n\n // Sort the merged array.\n sort(merged.begin(), merged.end());\n\n // Calculate the total number of elements in the merged array.\n int total = merged.size();\n\n if (total % 2 == 1) {\n // If the total number of elements is odd, return the middle element as the median.\n return static_cast<double>(merged[total / 2]);\n } else {\n // If the total number of elements is even, calculate the average of the two middle elements as the median.\n int middle1 = merged[total / 2 - 1];\n int middle2 = merged[total / 2];\n return (static_cast<double>(middle1) + static_cast<double>(middle2)) / 2.0;\n }\n }\n};\n\n```\n```Java []\nimport java.util.Arrays;\n\nclass Solution {\n public double findMedianSortedArrays(int[] nums1, int[] nums2) {\n // Get the sizes of both input arrays.\n int n = nums1.length;\n int m = nums2.length;\n\n // Merge the arrays into a single sorted array.\n int[] merged = new int[n + m];\n int k = 0;\n for (int i = 0; i < n; i++) {\n merged[k++] = nums1[i];\n }\n for (int i = 0; i < m; i++) {\n merged[k++] = nums2[i];\n }\n\n // Sort the merged array.\n Arrays.sort(merged);\n\n // Calculate the total number of elements in the merged array.\n int total = merged.length;\n\n if (total % 2 == 1) {\n // If the total number of elements is odd, return the middle element as the median.\n return (double) merged[total / 2];\n } else {\n // If the total number of elements is even, calculate the average of the two middle elements as the median.\n int middle1 = merged[total / 2 - 1];\n int middle2 = merged[total / 2];\n return ((double) middle1 + (double) middle2) / 2.0;\n }\n }\n}\n\n```\n```python3 []\nclass Solution:\n def findMedianSortedArrays(self, nums1, nums2):\n # Merge the arrays into a single sorted array.\n merged = nums1 + nums2\n\n # Sort the merged array.\n merged.sort()\n\n # Calculate the total number of elements in the merged array.\n total = len(merged)\n\n if total % 2 == 1:\n # If the total number of elements is odd, return the middle element as the median.\n return float(merged[total // 2])\n else:\n # If the total number of elements is even, calculate the average of the two middle elements as the median.\n middle1 = merged[total // 2 - 1]\n middle2 = merged[total // 2]\n return (float(middle1) + float(middle2)) / 2.0\n\n```\n\n\n# Code for Two-Pointer Method\n```C++ []\nclass Solution {\npublic:\n double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {\n int n = nums1.size();\n int m = nums2.size();\n int i = 0, j = 0, m1 = 0, m2 = 0;\n\n // Find median.\n for (int count = 0; count <= (n + m) / 2; count++) {\n m2 = m1;\n if (i != n && j != m) {\n if (nums1[i] > nums2[j]) {\n m1 = nums2[j++];\n } else {\n m1 = nums1[i++];\n }\n } else if (i < n) {\n m1 = nums1[i++];\n } else {\n m1 = nums2[j++];\n }\n }\n\n // Check if the sum of n and m is odd.\n if ((n + m) % 2 == 1) {\n return static_cast<double>(m1);\n } else {\n double ans = static_cast<double>(m1) + static_cast<double>(m2);\n return ans / 2.0;\n }\n }\n};\n\n```\n```Java []\nclass Solution {\n public double findMedianSortedArrays(int[] nums1, int[] nums2) {\n int n = nums1.length;\n int m = nums2.length;\n int i = 0, j = 0, m1 = 0, m2 = 0;\n\n // Find median.\n for (int count = 0; count <= (n + m) / 2; count++) {\n m2 = m1;\n if (i != n && j != m) {\n if (nums1[i] > nums2[j]) {\n m1 = nums2[j++];\n } else {\n m1 = nums1[i++];\n }\n } else if (i < n) {\n m1 = nums1[i++];\n } else {\n m1 = nums2[j++];\n }\n }\n\n // Check if the sum of n and m is odd.\n if ((n + m) % 2 == 1) {\n return (double) m1;\n } else {\n double ans = (double) m1 + (double) m2;\n return ans / 2.0;\n }\n }\n}\n\n```\n```python []\nclass Solution:\n def findMedianSortedArrays(self, nums1, nums2):\n n = len(nums1)\n m = len(nums2)\n i = 0\n j = 0\n m1 = 0\n m2 = 0\n\n # Find median.\n for count in range(0, (n + m) // 2 + 1):\n m2 = m1\n if i < n and j < m:\n if nums1[i] > nums2[j]:\n m1 = nums2[j]\n j += 1\n else:\n m1 = nums1[i]\n i += 1\n elif i < n:\n m1 = nums1[i]\n i += 1\n else:\n m1 = nums2[j]\n j += 1\n\n # Check if the sum of n and m is odd.\n if (n + m) % 2 == 1:\n return float(m1)\n else:\n ans = float(m1) + float(m2)\n return ans / 2.0\n\n```\n\n\n# Code for Binary Search\n```C++ []\nclass Solution {\npublic:\n double findMedianSortedArrays(vector<int> &nums1, vector<int> &nums2) {\n int n1 = nums1.size(), n2 = nums2.size();\n \n // Ensure nums1 is the smaller array for simplicity\n if (n1 > n2)\n return findMedianSortedArrays(nums2, nums1);\n \n int n = n1 + n2;\n int left = (n1 + n2 + 1) / 2; // Calculate the left partition size\n int low = 0, high = n1;\n \n while (low <= high) {\n int mid1 = (low + high) >> 1; // Calculate mid index for nums1\n int mid2 = left - mid1; // Calculate mid index for nums2\n \n int l1 = INT_MIN, l2 = INT_MIN, r1 = INT_MAX, r2 = INT_MAX;\n \n // Determine values of l1, l2, r1, and r2\n if (mid1 < n1)\n r1 = nums1[mid1];\n if (mid2 < n2)\n r2 = nums2[mid2];\n if (mid1 - 1 >= 0)\n l1 = nums1[mid1 - 1];\n if (mid2 - 1 >= 0)\n l2 = nums2[mid2 - 1];\n \n if (l1 <= r2 && l2 <= r1) {\n // The partition is correct, we found the median\n if (n % 2 == 1)\n return max(l1, l2);\n else\n return ((double)(max(l1, l2) + min(r1, r2))) / 2.0;\n }\n else if (l1 > r2) {\n // Move towards the left side of nums1\n high = mid1 - 1;\n }\n else {\n // Move towards the right side of nums1\n low = mid1 + 1;\n }\n }\n \n return 0; // If the code reaches here, the input arrays were not sorted.\n }\n};\n\n\n```\n```Java []\nclass Solution {\n public double findMedianSortedArrays(int[] nums1, int[] nums2) {\n int n1 = nums1.length, n2 = nums2.length;\n \n // Ensure nums1 is the smaller array for simplicity\n if (n1 > n2)\n return findMedianSortedArrays(nums2, nums1);\n \n int n = n1 + n2;\n int left = (n1 + n2 + 1) / 2; // Calculate the left partition size\n int low = 0, high = n1;\n \n while (low <= high) {\n int mid1 = (low + high) >> 1; // Calculate mid index for nums1\n int mid2 = left - mid1; // Calculate mid index for nums2\n \n int l1 = Integer.MIN_VALUE, l2 = Integer.MIN_VALUE, r1 = Integer.MAX_VALUE, r2 = Integer.MAX_VALUE;\n \n // Determine values of l1, l2, r1, and r2\n if (mid1 < n1)\n r1 = nums1[mid1];\n if (mid2 < n2)\n r2 = nums2[mid2];\n if (mid1 - 1 >= 0)\n l1 = nums1[mid1 - 1];\n if (mid2 - 1 >= 0)\n l2 = nums2[mid2 - 1];\n \n if (l1 <= r2 && l2 <= r1) {\n // The partition is correct, we found the median\n if (n % 2 == 1)\n return Math.max(l1, l2);\n else\n return ((double)(Math.max(l1, l2) + Math.min(r1, r2))) / 2.0;\n }\n else if (l1 > r2) {\n // Move towards the left side of nums1\n high = mid1 - 1;\n }\n else {\n // Move towards the right side of nums1\n low = mid1 + 1;\n }\n }\n \n return 0; // If the code reaches here, the input arrays were not sorted.\n }\n}\n\n```\n```python []\nclass Solution:\n def findMedianSortedArrays(self, nums1, nums2):\n n1 = len(nums1)\n n2 = len(nums2)\n \n # Ensure nums1 is the smaller array for simplicity\n if n1 > n2:\n return self.findMedianSortedArrays(nums2, nums1)\n \n n = n1 + n2\n left = (n1 + n2 + 1) // 2 # Calculate the left partition size\n low = 0\n high = n1\n \n while low <= high:\n mid1 = (low + high) // 2 # Calculate mid index for nums1\n mid2 = left - mid1 # Calculate mid index for nums2\n \n l1 = float(\'-inf\')\n l2 = float(\'-inf\')\n r1 = float(\'inf\')\n r2 = float(\'inf\')\n \n # Determine values of l1, l2, r1, and r2\n if mid1 < n1:\n r1 = nums1[mid1]\n if mid2 < n2:\n r2 = nums2[mid2]\n if mid1 - 1 >= 0:\n l1 = nums1[mid1 - 1]\n if mid2 - 1 >= 0:\n l2 = nums2[mid2 - 1]\n \n if l1 <= r2 and l2 <= r1:\n # The partition is correct, we found the median\n if n % 2 == 1:\n return max(l1, l2)\n else:\n return (max(l1, l2) + min(r1, r2)) / 2.0\n elif l1 > r2:\n # Move towards the left side of nums1\n high = mid1 - 1\n else:\n # Move towards the right side of nums1\n low = mid1 + 1\n \n return 0 # If the code reaches here, the input arrays were not sorted.\n\n```\n# SMALL REQUEST : If you found this post even remotely helpful, be kind enough to smash a upvote. I will be grateful.I will be motivated\uD83D\uDE0A\uD83D\uDE0A\n![upvotememe.png]()\n\n\n

Median of Two Sorted Arrays

median-of-two-sorted-arrays

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)).

Array,Binary Search,Divide and Conquer

Hard

# Comprehensive Guide to Solving "Median of Two Sorted Arrays"\n\n## Introduction & Problem Statement\n\n"Median of Two Sorted Arrays" is a classic problem that tests one\'s algorithmic depth and understanding of binary search and two-pointer techniques. The challenge is to find the median of two sorted arrays, `nums1` and `nums2`, with potentially different sizes. The objective is to solve it in logarithmic time complexity in terms of the minimum size of the two arrays.\n\n## Key Concepts and Constraints\n\n### What Makes This Problem Unique?\n\n1. **Array Constraints**: \n - The length of `nums1` (denoted as $$ m $$) can range from 0 to 1000.\n - The length of `nums2` (denoted as $$ n $$) can also vary between 0 and 1000.\n - The combined size (i.e., $$ m + n $$) of both arrays can go up to 2000.\n \n2. **Element Constraints**:\n - Each element in both `nums1` and `nums2` can be any integer from -$$ 10^6 $$ to $$ 10^6 $$.\n\n3. **Runtime Complexity**: \n The primary challenge is to achieve a runtime of $$ O(\\log(\\min(m, n))) $$. This constraint rules out naive solutions that might merge and then find the median.\n\n### Solution Strategies:\n\n1. **Two Pointers Approach**: \n This technique involves iterating through both arrays using two pointers. By comparing the elements at the current pointers, we can merge the two arrays. Once merged, finding the median is straightforward.\n\n2. **Binary Search Approach**: \n Leveraging the properties of sorted arrays, we can apply a binary search on the smaller array, effectively partitioning both arrays. This method ensures we find the median without explicitly merging the arrays, adhering to the desired logarithmic time complexity.\n\n---\n\n## Live Coding Binary Search & Explain \n\n\n## Strategy to Solve the Problem:\n\n## Two Pointers Merging Technique\n\nThe core idea here is to merge the two sorted arrays, nums1 and nums2, using a two-pointer approach. After merging, the median of the combined array can be found directly based on its length.\n\n## Key Data Structures:\n\n- `merged`: An array to store the merged result of `nums1` and `nums2`.\n- `i` and `j`: Two pointers to traverse `nums1` and `nums2` respectively.\n\n## Enhanced Breakdown:\n\n1. **Initialize Pointers**:\n - Set `i` and `j` to 0. These pointers will help traverse `nums1` and `nums2`.\n\n2. **Merging using Two Pointers**:\n - Merge elements of `nums1` and `nums2` in sorted order using two pointers. If an element in `nums1` is smaller, append it to `merged` and move the `i` pointer. Otherwise, append the element from `nums2` and move the `j` pointer.\n\n3. **Handle Remaining Elements**:\n - If there are any remaining elements in `nums1` or `nums2`, append them directly to `merged`.\n\n4. **Calculate Median**:\n - Based on the length of `merged`, compute the median. If the length is even, the median is the average of the two middle elements. Otherwise, it\'s the middle element.\n\n## Complexity Analysis:\n\n**Time Complexity**: \n- The merging process traverses both arrays once, resulting in a time complexity of $$ O(m + n) $$, where $$ m $$ and $$ n $$ are the lengths of `nums1` and `nums2` respectively.\n\n**Space Complexity**: \n- The algorithm creates a merged array of length $$ m + n $$, leading to a space complexity of $$ O(m + n) $$.\n\n\n## Code Two Pointers\n``` Python []\nclass Solution:\n def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:\n merged = []\n i, j = 0, 0\n \n while i < len(nums1) and j < len(nums2):\n if nums1[i] < nums2[j]:\n merged.append(nums1[i])\n i += 1\n else:\n merged.append(nums2[j])\n j += 1\n \n while i < len(nums1):\n merged.append(nums1[i])\n i += 1\n \n while j < len(nums2):\n merged.append(nums2[j])\n j += 1\n \n mid = len(merged) // 2\n if len(merged) % 2 == 0:\n return (merged[mid-1] + merged[mid]) / 2\n else:\n return merged[mid]\n\n```\n``` Go []\nfunc findMedianSortedArrays(nums1 []int, nums2 []int) float64 {\n merged := make([]int, 0, len(nums1)+len(nums2))\n i, j := 0, 0\n\n for i < len(nums1) && j < len(nums2) {\n if nums1[i] < nums2[j] {\n merged = append(merged, nums1[i])\n i++\n } else {\n merged = append(merged, nums2[j])\n j++\n }\n }\n\n for i < len(nums1) {\n merged = append(merged, nums1[i])\n i++\n }\n for j < len(nums2) {\n merged = append(merged, nums2[j])\n j++\n }\n\n mid := len(merged) / 2\n if len(merged)%2 == 0 {\n return (float64(merged[mid-1]) + float64(merged[mid])) / 2.0\n } else {\n return float64(merged[mid])\n }\n}\n```\n``` Rust []\nimpl Solution {\n pub fn find_median_sorted_arrays(nums1: Vec<i32>, nums2: Vec<i32>) -> f64 {\n let mut merged: Vec<i32> = Vec::new();\n let (mut i, mut j) = (0, 0);\n \n while i < nums1.len() && j < nums2.len() {\n if nums1[i] < nums2[j] {\n merged.push(nums1[i]);\n i += 1;\n } else {\n merged.push(nums2[j]);\n j += 1;\n }\n }\n \n while i < nums1.len() {\n merged.push(nums1[i]);\n i += 1;\n }\n while j < nums2.len() {\n merged.push(nums2[j]);\n j += 1;\n }\n \n let mid = merged.len() / 2;\n if merged.len() % 2 == 0 {\n return (merged[mid-1] + merged[mid]) as f64 / 2.0;\n } else {\n return merged[mid] as f64;\n }\n }\n}\n```\n``` C++ []\nclass Solution {\npublic:\n double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {\n vector<int> merged;\n int i = 0, j = 0;\n \n while (i < nums1.size() && j < nums2.size()) {\n if (nums1[i] < nums2[j]) {\n merged.push_back(nums1[i++]);\n } else {\n merged.push_back(nums2[j++]);\n }\n }\n \n while (i < nums1.size()) merged.push_back(nums1[i++]);\n while (j < nums2.size()) merged.push_back(nums2[j++]);\n \n int mid = merged.size() / 2;\n if (merged.size() % 2 == 0) {\n return (merged[mid-1] + merged[mid]) / 2.0;\n } else {\n return merged[mid];\n }\n }\n};\n```\n``` Java []\npublic class Solution {\n public double findMedianSortedArrays(int[] nums1, int[] nums2) {\n List<Integer> merged = new ArrayList<>();\n int i = 0, j = 0;\n \n while (i < nums1.length && j < nums2.length) {\n if (nums1[i] < nums2[j]) {\n merged.add(nums1[i++]);\n } else {\n merged.add(nums2[j++]);\n }\n }\n \n while (i < nums1.length) merged.add(nums1[i++]);\n while (j < nums2.length) merged.add(nums2[j++]);\n \n int mid = merged.size() / 2;\n if (merged.size() % 2 == 0) {\n return (merged.get(mid-1) + merged.get(mid)) / 2.0;\n } else {\n return merged.get(mid);\n }\n }\n}\n```\n``` C# []\npublic class Solution {\n public double FindMedianSortedArrays(int[] nums1, int[] nums2) {\n List<int> merged = new List<int>();\n int i = 0, j = 0;\n \n while (i < nums1.Length && j < nums2.Length) {\n if (nums1[i] < nums2[j]) {\n merged.Add(nums1[i++]);\n } else {\n merged.Add(nums2[j++]);\n }\n }\n \n while (i < nums1.Length) merged.Add(nums1[i++]);\n while (j < nums2.Length) merged.Add(nums2[j++]);\n \n int mid = merged.Count / 2;\n if (merged.Count % 2 == 0) {\n return (merged[mid-1] + merged[mid]) / 2.0;\n } else {\n return merged[mid];\n }\n }\n}\n```\n``` JavaScript []\n/**\n * @param {number[]} nums1\n * @param {number[]} nums2\n * @return {number}\n */\nvar findMedianSortedArrays = function(nums1, nums2) {\n let merged = [];\n let i = 0, j = 0;\n\n while (i < nums1.length && j < nums2.length) {\n if (nums1[i] < nums2[j]) {\n merged.push(nums1[i++]);\n } else {\n merged.push(nums2[j++]);\n }\n }\n\n while (i < nums1.length) merged.push(nums1[i++]);\n while (j < nums2.length) merged.push(nums2[j++]);\n\n let mid = Math.floor(merged.length / 2);\n if (merged.length % 2 === 0) {\n return (merged[mid-1] + merged[mid]) / 2;\n } else {\n return merged[mid];\n }\n};\n```\n``` PHP []\nclass Solution {\n\n function findMedianSortedArrays($nums1, $nums2) {\n $merged = array();\n $i = $j = 0;\n\n while ($i < count($nums1) && $j < count($nums2)) {\n if ($nums1[$i] < $nums2[$j]) {\n array_push($merged, $nums1[$i++]);\n } else {\n array_push($merged, $nums2[$j++]);\n }\n }\n\n while ($i < count($nums1)) array_push($merged, $nums1[$i++]);\n while ($j < count($nums2)) array_push($merged, $nums2[$j++]);\n\n $mid = intdiv(count($merged), 2);\n if (count($merged) % 2 == 0) {\n return ($merged[$mid-1] + $merged[$mid]) / 2;\n } else {\n return $merged[$mid];\n }\n }\n}\n```\n\n---\n\n## Binary Search with Partitioning\n\nThe problem can be elegantly solved using binary search by partitioning the two arrays such that elements on the left are smaller or equal to elements on the right.\n\n## Key Data Structures:\n\n- `partitionX` and `partitionY`: To store the partition indices for `nums1` and `nums2` respectively.\n- `maxX`, `minX`, `maxY`, `minY`: To store the values around the partition in both arrays.\n\n## Enhanced Breakdown:\n\n1. **Initialize and Swap Arrays if Needed**:\n - Swap `nums1` and `nums2` if `nums1` is larger. This ensures we always binary search the smaller array, optimizing the time complexity.\n\n2. **Binary Search Setup**:\n - Initialize `low` to 0 and `high` to the size of the smaller array.\n \n3. **Start Binary Search Loop**:\n - The loop continues until `low` is not greater than `high`.\n - Calculate `partitionX` and `partitionY` based on `low` and `high`.\n\n4. **Calculate Partition Values**:\n - Compute `maxX`, `minX`, `maxY`, `minY` based on the partitions.\n \n5. **Check for Correct Partition**:\n - If `maxX <= minY` and `maxY <= minX`, we have found the correct partition.\n - Calculate and return the median based on the values around the partition.\n\n6. **Adjust Binary Search Bounds**:\n - If `maxX > minY`, adjust `high` to `partitionX - 1`.\n - Otherwise, adjust `low` to `partitionX + 1`.\n\n## Complexity Analysis:\n\n**Time Complexity**: \n- The algorithm performs a binary search on the smaller array, leading to a time complexity of $$ O(\\log(\\min(m, n))) $$.\n\n**Space Complexity**: \n- The algorithm uses only a constant amount of extra space, thus having a space complexity of $$ O(1) $$.\n\n# Code Binary Search\n``` Python []\nclass Solution:\n def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:\n if len(nums1) > len(nums2):\n nums1, nums2 = nums2, nums1\n \n m, n = len(nums1), len(nums2)\n low, high = 0, m\n \n while low <= high:\n partitionX = (low + high) // 2\n partitionY = (m + n + 1) // 2 - partitionX\n \n maxX = float(\'-inf\') if partitionX == 0 else nums1[partitionX - 1]\n maxY = float(\'-inf\') if partitionY == 0 else nums2[partitionY - 1]\n minX = float(\'inf\') if partitionX == m else nums1[partitionX]\n minY = float(\'inf\') if partitionY == n else nums2[partitionY]\n \n if maxX <= minY and maxY <= minX:\n if (m + n) % 2 == 0:\n return (max(maxX, maxY) + min(minX, minY)) / 2\n else:\n return max(maxX, maxY)\n elif maxX > minY:\n high = partitionX - 1\n else:\n low = partitionX + 1\n```\n``` Go []\nfunc findMedianSortedArrays(nums1 []int, nums2 []int) float64 {\n\tif len(nums1) > len(nums2) {\n\t\tnums1, nums2 = nums2, nums1\n\t}\n\n\tm, n := len(nums1), len(nums2)\n\tlow, high := 0, m\n\n\tfor low <= high {\n\t\tpartitionX := (low + high) / 2\n\t\tpartitionY := (m + n + 1) / 2 - partitionX\n\n\t\tmaxX := math.MinInt64\n\t\tif partitionX > 0 {\n\t\t\tmaxX = nums1[partitionX-1]\n\t\t}\n\n\t\tminX := math.MaxInt64\n\t\tif partitionX < m {\n\t\t\tminX = nums1[partitionX]\n\t\t}\n\n\t\tmaxY := math.MinInt64\n\t\tif partitionY > 0 {\n\t\t\tmaxY = nums2[partitionY-1]\n\t\t}\n\n\t\tminY := math.MaxInt64\n\t\tif partitionY < n {\n\t\t\tminY = nums2[partitionY]\n\t\t}\n\n\t\tif maxX <= minY && maxY <= minX {\n\t\t\tif (m+n)%2 == 0 {\n\t\t\t\treturn (float64(max(maxX, maxY)) + float64(min(minX, minY))) / 2.0\n\t\t\t}\n\t\t\treturn float64(max(maxX, maxY))\n\t\t} else if maxX > minY {\n\t\t\thigh = partitionX - 1\n\t\t} else {\n\t\t\tlow = partitionX + 1\n\t\t}\n\t}\n\n\treturn 0.0\n}\n\nfunc max(a, b int) int {\n\tif a > b {\n\t\treturn a\n\t}\n\treturn b\n}\n\nfunc min(a, b int) int {\n\tif a < b {\n\t\treturn a\n\t}\n\treturn b\n}\n```\n``` Rust []\nimpl Solution {\n pub fn find_median_sorted_arrays(nums1: Vec<i32>, nums2: Vec<i32>) -> f64 {\n let (mut nums1, mut nums2) = if nums1.len() > nums2.len() {\n (nums2, nums1)\n } else {\n (nums1, nums2)\n };\n \n let (m, n) = (nums1.len(), nums2.len());\n let (mut low, mut high) = (0, m);\n \n while low <= high {\n let partition_x = (low + high) / 2;\n let partition_y = (m + n + 1) / 2 - partition_x;\n \n let max_x = if partition_x == 0 { i32::MIN } else { nums1[partition_x - 1] };\n let min_x = if partition_x == m { i32::MAX } else { nums1[partition_x] };\n \n let max_y = if partition_y == 0 { i32::MIN } else { nums2[partition_y - 1] };\n let min_y = if partition_y == n { i32::MAX } else { nums2[partition_y] };\n \n if max_x <= min_y && max_y <= min_x {\n if (m + n) % 2 == 0 {\n return (max_x.max(max_y) + min_x.min(min_y)) as f64 / 2.0;\n } else {\n return max_x.max(max_y) as f64;\n }\n } else if max_x > min_y {\n high = partition_x - 1;\n } else {\n low = partition_x + 1;\n }\n }\n \n 0.0\n }\n}\n```\n``` C++ []\nclass Solution {\npublic:\n double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {\n if (nums1.size() > nums2.size()) {\n swap(nums1, nums2);\n }\n \n int m = nums1.size();\n int n = nums2.size();\n int low = 0, high = m;\n \n while (low <= high) {\n int partitionX = (low + high) / 2;\n int partitionY = (m + n + 1) / 2 - partitionX;\n \n int maxX = (partitionX == 0) ? INT_MIN : nums1[partitionX - 1];\n int maxY = (partitionY == 0) ? INT_MIN : nums2[partitionY - 1];\n \n int minX = (partitionX == m) ? INT_MAX : nums1[partitionX];\n int minY = (partitionY == n) ? INT_MAX : nums2[partitionY];\n \n if (maxX <= minY && maxY <= minX) {\n if ((m + n) % 2 == 0) {\n return (max(maxX, maxY) + min(minX, minY)) / 2.0;\n } else {\n return max(maxX, maxY);\n }\n } else if (maxX > minY) {\n high = partitionX - 1;\n } else {\n low = partitionX + 1;\n }\n }\n \n throw invalid_argument("Input arrays are not sorted.");\n }\n};\n```\n``` Java []\npublic class Solution {\n public double findMedianSortedArrays(int[] nums1, int[] nums2) {\n if (nums1.length > nums2.length) {\n int[] temp = nums1;\n nums1 = nums2;\n nums2 = temp;\n }\n \n int m = nums1.length;\n int n = nums2.length;\n int low = 0, high = m;\n \n while (low <= high) {\n int partitionX = (low + high) / 2;\n int partitionY = (m + n + 1) / 2 - partitionX;\n \n int maxX = (partitionX == 0) ? Integer.MIN_VALUE : nums1[partitionX - 1];\n int maxY = (partitionY == 0) ? Integer.MIN_VALUE : nums2[partitionY - 1];\n \n int minX = (partitionX == m) ? Integer.MAX_VALUE : nums1[partitionX];\n int minY = (partitionY == n) ? Integer.MAX_VALUE : nums2[partitionY];\n \n if (maxX <= minY && maxY <= minX) {\n if ((m + n) % 2 == 0) {\n return (Math.max(maxX, maxY) + Math.min(minX, minY)) / 2.0;\n } else {\n return Math.max(maxX, maxY);\n }\n } else if (maxX > minY) {\n high = partitionX - 1;\n } else {\n low = partitionX + 1;\n }\n }\n \n throw new IllegalArgumentException("Input arrays are not sorted.");\n }\n}\n```\n``` C# []\npublic class Solution {\n public double FindMedianSortedArrays(int[] nums1, int[] nums2) {\n if (nums1.Length > nums2.Length) {\n int[] temp = nums1;\n nums1 = nums2;\n nums2 = temp;\n }\n \n int m = nums1.Length;\n int n = nums2.Length;\n int low = 0, high = m;\n \n while (low <= high) {\n int partitionX = (low + high) / 2;\n int partitionY = (m + n + 1) / 2 - partitionX;\n \n int maxX = (partitionX == 0) ? int.MinValue : nums1[partitionX - 1];\n int maxY = (partitionY == 0) ? int.MinValue : nums2[partitionY - 1];\n \n int minX = (partitionX == m) ? int.MaxValue : nums1[partitionX];\n int minY = (partitionY == n) ? int.MaxValue : nums2[partitionY];\n \n if (maxX <= minY && maxY <= minX) {\n if ((m + n) % 2 == 0) {\n return (Math.Max(maxX, maxY) + Math.Min(minX, minY)) / 2.0;\n } else {\n return Math.Max(maxX, maxY);\n }\n } else if (maxX > minY) {\n high = partitionX - 1;\n } else {\n low = partitionX + 1;\n }\n }\n \n throw new ArgumentException("Input arrays are not sorted.");\n }\n}\n```\n``` JavaScript []\nvar findMedianSortedArrays = function(nums1, nums2) {\n if (nums1.length > nums2.length) {\n [nums1, nums2] = [nums2, nums1];\n }\n \n const m = nums1.length;\n const n = nums2.length;\n let low = 0, high = m;\n \n while (low <= high) {\n const partitionX = Math.floor((low + high) / 2);\n const partitionY = Math.floor((m + n + 1) / 2) - partitionX;\n \n const maxX = (partitionX === 0) ? Number.MIN_SAFE_INTEGER : nums1[partitionX - 1];\n const maxY = (partitionY === 0) ? Number.MIN_SAFE_INTEGER : nums2[partitionY - 1];\n \n const minX = (partitionX === m) ? Number.MAX_SAFE_INTEGER : nums1[partitionX];\n const minY = (partitionY === n) ? Number.MAX_SAFE_INTEGER : nums2[partitionY];\n \n if (maxX <= minY && maxY <= minX) {\n if ((m + n) % 2 === 0) {\n return (Math.max(maxX, maxY) + Math.min(minX, minY)) / 2;\n } else {\n return Math.max(maxX, maxY);\n }\n } else if (maxX > minY) {\n high = partitionX - 1;\n } else {\n low = partitionX + 1;\n }\n }\n \n throw new Error("Input arrays are not sorted.");\n};\n```\n``` PHP []\nclass Solution {\n function findMedianSortedArrays($nums1, $nums2) {\n if (count($nums1) > count($nums2)) {\n list($nums1, $nums2) = [$nums2, $nums1];\n }\n \n $m = count($nums1);\n $n = count($nums2);\n $low = 0; $high = $m;\n \n while ($low <= $high) {\n $partitionX = intdiv($low + $high, 2);\n $partitionY = intdiv($m + $n + 1, 2) - $partitionX;\n \n $maxX = ($partitionX == 0) ? PHP_INT_MIN : $nums1[$partitionX - 1];\n $maxY = ($partitionY == 0) ? PHP_INT_MIN : $nums2[$partitionY - 1];\n \n $minX = ($partitionX == $m) ? PHP_INT_MAX : $nums1[$partitionX];\n $minY = ($partitionY == $n) ? PHP_INT_MAX : $nums2[$partitionY];\n \n if ($maxX <= $minY && $maxY <= $minX) {\n if (($m + $n) % 2 == 0) {\n return (max($maxX, $maxY) + min($minX, $minY)) / 2.0;\n } else {\n return max($maxX, $maxY);\n }\n } elseif ($maxX > $minY) {\n $high = $partitionX - 1;\n } else {\n $low = $partitionX + 1;\n }\n }\n \n throw new Exception("Input arrays are not sorted.");\n }\n}\n```\n\n## Performance\n\n| Language | Execution Time (ms) | Memory Usage (MB) |\n|-----------|---------------------|--------------------|\n| Rust | 0 | 2 |\n| Java | 1 | 44.5 |\n| Go | 9 | 5.1 |\n| C++ | 16 | 89.6 |\n| PHP | 28 | 18.9 |\n| Python3 | 80 | 16.5 |\n| JavaScript| 85 | 46.6 |\n| Python3 (Two Pointers) | 93 | 16.5 |\n| C# | 98 | 52.1 |\n\n![v45.png]()\n\n\n## Live Coding in Rust - 0 ms \n\n\n## Conclusion\n\nBoth strategies have their own unique benefits. While the two-pointers approach offers simplicity and clarity, the binary search approach showcases efficiency and mastery over the properties of sorted arrays. Choosing between them depends on the specific constraints and requirements of a given scenario.

Median of Two Sorted Arrays

median-of-two-sorted-arrays

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)).

Array,Binary Search,Divide and Conquer

Hard

# Intuition\nWelcome to my article! This starts with `What is median?`. Understanding `median` is a key to solve this quesiton.\n\n---\n\n# Solution Video\n\nToday, I\'m going on business trip. This article is written in a train. lol\nIf I have a time tonight, I will create a solution video for this question.\n\nInstead of the video, I added more comments to the codes.\n\n### \u2B50\uFE0F\u2B50\uFE0F Don\'t forget to subscribe to my channel! \u2B50\uFE0F\u2B50\uFE0F\n\n**\u25A0 Subscribe URL**\n\n\nSubscribers: 2,423\nMy initial goal is 10,000\nThank you for your support!\n\n---\n\n# Approach\n\n## My thought process - How I think about a solution\n\n### What is `median`?\n\nFirst and foremost, we must understand what `median` is. Without this understanding, we cannot write a program.\n\n`The median is one of the measures of central tendency for data or a set, representing the value that is at the middle position.`\n\n- In the case of an even-sized data set\n\nHowever, in the case of an even-sized data set, the arithmetic mean of the two middle values is taken.\n\nFor example, in a data set consisting of the ages of 6 individuals: `1, 2, 3, 5, 9, 11`, the median is `4 years old` (taking two middle values `3 + 5` and divide by `2`)\n\n- In the case of an odd-sized data set\n\nIn the case of an odd-sized data set, for example, in a data set consisting of the ages of 5 individuals: `10, 32, 96, 100, 105` years old, the median is `96 years old`, which is the value at the 3rd position from both the top and the bottom. If there are 2 more children aged `0`, making a total of 7 individuals `0, 0, 10, 32, 96, 100, 105`, the median becomes `32 years old`.\n\n### My first thought\nNow, I hope you understand what `median` is. Simply, when we convert `median` to program, we can write it like this.\n\nThis is Python code.\n```\nclass Solution:\n def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:\n # Merge the two sorted arrays\n merged = sorted(nums1 + nums2)\n length = len(merged)\n \n # Check if the total length is even or odd\n if length % 2 == 0:\n # If even, return the average of the two middle elements\n return (merged[length // 2 - 1] + merged[length // 2]) / 2\n else:\n # If odd, return the middle element\n return merged[length // 2]\n```\nIt\'s very simple right? In fact, this program passed all cases and execution time is not bad. Beats 68% when I ran the code. If we can use this code for this question. this is acutually easy problem.\n\nThat is my first thought.\n\n### We have a constraint\n\nBut we have a constrant about time complexity. Description says "The overall run time complexity should be `O(log(m+n))`", so we can\'t use my simple solution for this question, even if the simple solution passed all cases.\n\nWe need to find another solution.\n\nLet\'s focus on time complexity of the constraint. Time complexity of `O(log(m+n))` is a constraint, on the other hand, it should be a hint to solve the question. If you know time complexity well, you can guess a solution from `O(log(something))`.\n\nThat is time complexity of `binary search`. That\'s why I stated to focus on a binary search-based solution to find the median of two arrays.\n\nThat is my thoguht process to reach `binary search-based solution`.\n\n---\n\n# Solution\n\n### Algorithm overview:\n1. Ensure that nums1 is the smaller array.\n2. Calculate the lengths of the input arrays nums1 and nums2.\n3. Set the initial range for binary search on nums1 using the variables left and right.\n\n### Detailed Explanation:\n1. Check and swap nums1 and nums2 if nums1 is longer than nums2 to ensure nums1 is the smaller array.\n2. Calculate the lengths of nums1 and nums2 and store them in len1 and len2.\n3. Initialize the binary search range using left (0) and right (length of nums1).\n4. Enter a while loop that continues as long as the left pointer is less than or equal to the right pointer.\n5. Inside the loop:\n a. Calculate the partition points for nums1 and nums2 based on the binary search.\n b. Determine the maximum elements on the left side (max_left) and minimum elements on the right side (min_right) for both arrays.\n c. Check if the current partition is correct by comparing max_left and min_right.\n d. If the partition is correct:\n - If the total length is even, return the average of max_left and min_right.\n - If the total length is odd, return max_left.\n e. If the partition is not correct, adjust the binary search range based on the comparison of max_left1 and min_right2.\n\nThis algorithm efficiently finds the median of two sorted arrays using a binary search approach to adjust the partition points and determine the correct position for the median.\n\n\n---\n\n\n# Complexity\n- Time complexity: O(log(min(N, M)))\nThe while loop performs binary search, and each iteration divides the search range in half. Thus, the time complexity is O(log(min(N, M))), where `N` is the length of nums1 and `M` is the length of nums2.\n\n- Space complexity: O(1)\nThe algorithm uses a constant amount of extra space for variables like `left`, `right`, `partition1`, `partition2`, `max_left1`, `max_left2`, `max_left`, `min_right1`, `min_right2`, and `min_right`. Therefore, the space complexity is O(1), indicating constant space usage irrespective of the input size.\n\n\n```python []\nclass Solution:\n def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:\n # Ensure nums1 is the smaller array\n if len(nums1) > len(nums2):\n nums1, nums2 = nums2, nums1\n \n # Get the lengths of the two arrays\n len1, len2 = len(nums1), len(nums2)\n \n # Set the range for binary search on nums1\n left, right = 0, len1\n \n while left <= right:\n # Partition nums1 and nums2\n partition1 = (left + right) // 2\n partition2 = (len1 + len2 + 1) // 2 - partition1\n \n # Find the maximum elements on the left of the partition\n max_left1 = nums1[partition1-1] if partition1 > 0 else float(\'-inf\')\n max_left2 = nums2[partition2-1] if partition2 > 0 else float(\'-inf\')\n max_left = max(max_left1, max_left2)\n \n # Find the minimum elements on the right of the partition\n min_right1 = nums1[partition1] if partition1 < len1 else float(\'inf\')\n min_right2 = nums2[partition2] if partition2 < len2 else float(\'inf\')\n min_right = min(min_right1, min_right2)\n \n # Check if the partition is correct\n if max_left <= min_right:\n # If the total length is even, return the average of the two middle elements\n if (len1 + len2) % 2 == 0:\n return (max_left + min_right) / 2\n # If the total length is odd, return the middle element\n else:\n return max_left\n elif max_left1 > min_right2:\n right = partition1 - 1\n else:\n left = partition1 + 1\n```\n```javascript []\n/**\n * @param {number[]} nums1\n * @param {number[]} nums2\n * @return {number}\n */\nvar findMedianSortedArrays = function(nums1, nums2) {\n // Ensure nums1 is the smaller array\n if (nums1.length > nums2.length) {\n [nums1, nums2] = [nums2, nums1];\n }\n\n // Get the lengths of the two arrays\n const len1 = nums1.length;\n const len2 = nums2.length;\n\n // Set the range for binary search on nums1\n let left = 0;\n let right = len1;\n\n while (left <= right) {\n // Partition nums1 and nums2\n const partition1 = Math.floor((left + right) / 2);\n const partition2 = Math.floor((len1 + len2 + 1) / 2) - partition1;\n\n // Find the maximum elements on the left of the partition\n const maxLeft1 = partition1 > 0 ? nums1[partition1 - 1] : Number.NEGATIVE_INFINITY;\n const maxLeft2 = partition2 > 0 ? nums2[partition2 - 1] : Number.NEGATIVE_INFINITY;\n const maxLeft = Math.max(maxLeft1, maxLeft2);\n\n // Find the minimum elements on the right of the partition\n const minRight1 = partition1 < len1 ? nums1[partition1] : Number.POSITIVE_INFINITY;\n const minRight2 = partition2 < len2 ? nums2[partition2] : Number.POSITIVE_INFINITY;\n const minRight = Math.min(minRight1, minRight2);\n\n // Check if the partition is correct\n if (maxLeft <= minRight) {\n // If the total length is even, return the average of the two middle elements\n if ((len1 + len2) % 2 === 0) {\n return (maxLeft + minRight) / 2;\n }\n // If the total length is odd, return the middle element\n else {\n return maxLeft;\n }\n } else if (maxLeft1 > minRight2) {\n right = partition1 - 1;\n } else {\n left = partition1 + 1;\n }\n } \n};\n```\n```java []\nclass Solution {\n public double findMedianSortedArrays(int[] nums1, int[] nums2) {\n // Ensure nums1 is the smaller array\n if (nums1.length > nums2.length) {\n int[] temp = nums1;\n nums1 = nums2;\n nums2 = temp;\n }\n\n // Get the lengths of the two arrays\n int len1 = nums1.length;\n int len2 = nums2.length;\n\n // Set the range for binary search on nums1\n int left = 0;\n int right = len1;\n\n while (left <= right) {\n // Partition nums1 and nums2\n int partition1 = (left + right) / 2;\n int partition2 = (len1 + len2 + 1) / 2 - partition1;\n\n // Find the maximum elements on the left of the partition\n int maxLeft1 = partition1 > 0 ? nums1[partition1 - 1] : Integer.MIN_VALUE;\n int maxLeft2 = partition2 > 0 ? nums2[partition2 - 1] : Integer.MIN_VALUE;\n int maxLeft = Math.max(maxLeft1, maxLeft2);\n\n // Find the minimum elements on the right of the partition\n int minRight1 = partition1 < len1 ? nums1[partition1] : Integer.MAX_VALUE;\n int minRight2 = partition2 < len2 ? nums2[partition2] : Integer.MAX_VALUE;\n int minRight = Math.min(minRight1, minRight2);\n\n // Check if the partition is correct\n if (maxLeft <= minRight) {\n // If the total length is even, return the average of the two middle elements\n if ((len1 + len2) % 2 == 0) {\n return (maxLeft + minRight) / 2.0;\n }\n // If the total length is odd, return the middle element\n else {\n return maxLeft;\n }\n } else if (maxLeft1 > minRight2) {\n right = partition1 - 1;\n } else {\n left = partition1 + 1;\n }\n }\n\n return 0.0; // This should not be reached, just to satisfy Java\'s return requirements\n }\n}\n```\n```C++ []\nclass Solution {\npublic:\n double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {\n // Ensure nums1 is the smaller array\n if (nums1.size() > nums2.size()) {\n nums1.swap(nums2);\n }\n\n // Get the lengths of the two arrays\n int len1 = nums1.size();\n int len2 = nums2.size();\n\n // Set the range for binary search on nums1\n int left = 0;\n int right = len1;\n\n while (left <= right) {\n // Partition nums1 and nums2\n int partition1 = (left + right) / 2;\n int partition2 = (len1 + len2 + 1) / 2 - partition1;\n\n // Find the maximum elements on the left of the partition\n int maxLeft1 = partition1 > 0 ? nums1[partition1 - 1] : INT_MIN;\n int maxLeft2 = partition2 > 0 ? nums2[partition2 - 1] : INT_MIN;\n int maxLeft = max(maxLeft1, maxLeft2);\n\n // Find the minimum elements on the right of the partition\n int minRight1 = partition1 < len1 ? nums1[partition1] : INT_MAX;\n int minRight2 = partition2 < len2 ? nums2[partition2] : INT_MAX;\n int minRight = min(minRight1, minRight2);\n\n // Check if the partition is correct\n if (maxLeft <= minRight) {\n // If the total length is even, return the average of the two middle elements\n if ((len1 + len2) % 2 == 0) {\n return (maxLeft + minRight) / 2.0;\n }\n // If the total length is odd, return the middle element\n else {\n return maxLeft;\n }\n } else if (maxLeft1 > minRight2) {\n right = partition1 - 1;\n } else {\n left = partition1 + 1;\n }\n }\n\n return 0.0; // This should not be reached, just to satisfy C++\'s return requirements \n }\n};\n```\n\n---\n\n\nThank you for reading such a long article.\n\n\u2B50\uFE0F If you learn something from the article, please upvote it and don\'t forget to subscribe to my channel!\n\nMy next post for daily coding challenge on Sep 22, 2023\n\n

Median of Two Sorted Arrays

median-of-two-sorted-arrays

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)).

Array,Binary Search,Divide and Conquer

Hard

# Problem Description\nGiven two sorted arrays, `nums1` and `nums2`, each of sizes `M` and `N` respectively. The **goal** is to find the **median** of the **combined** array formed by merging `nums1` and `nums2`.\n\nThe **task** is to design an algorithm with an overall run time complexity of `O(log(min(m, n)))` to calculate the median of the combined sorted array.\n\n**The median** of an array is the **middle** element when the array is **sorted**. If the combined array has an even number of elements, the median is the **average** of the two middle elements.\n\n![image.png]()\n\n\n\n---\n\n\n# Intuition\nHello There\uD83D\uDE00\nLet\'s take a look on our today\'s interesting problem\uD83D\uDE80\n\nIn our today\'s problem we have, two **sorted** arrays and a **median** to find but the **median** is for the array that **results** from **merging** both of the arrays.\nSounds like a **neat** problem.\uD83E\uDD29\n\n## Two Pointers\nThe **first** solution that would pop in mind is Why don\'t we **merge** the two arrays.\uD83E\uDD14\nWe can do this in **linear** time since the two arrays are **sorted** then we will have `2` pointer each of them on a **different** array from the other and put the **smaller** number in the **available** position in our **new** array.\n![image.png]()\n\nThe **tricky** part here that this solution has **complexity** of `O(m + n)` and still get **accepted** although the problem said it wants an algorithm with `O(log(min(m, n)))`\uD83E\uDD2F\nBut I had `100%` solution in **Java** with **Two Pointers** solution exactly like the next solution that I will discuss.\n\n\n\n## Divide And Conquer\n\n**Divide and Conquer** in a great technique in the world of computer science.\uD83D\uDE80\nIt **shares** something important with **dynamic programming** that both of them **break** the problem into smaller **subproblems**.\nThe **diffrenece** between the two approaches that the subproblems are **independent** in divide and conquer but in dynamic programming there is some **overlapping** between the subproblems.\uD83E\uDD2F\n\n- The **essence** of this solution that two things :\n - **drop** the part of the two arrays that we are sure that our median **won\'t be in it**.\n - **choose** the median when one array has **no elements** in it.\n\nlet\'s look at the **base case**, when we have one array is **empty**\nif you have two arrays `a` , `b` and I told you to get the median of their merge like that:\n```\n-> a = [1, 4, 10]\n-> b = []\n\n-> index median of a + b = 1\n-> median of a + b = 4\n``` \nWe can note here that since `b` is empty then the median is in a with the same **index** we are searching for.\uD83E\uDD2F\n\nLet\'s look at another example:\n```\n-> a = [1, 4, 10]\n-> b = [2, 4, 7, 15]\n-> index median of a + b = 3\n-> mid of a = 1\n-> mid of b = 2\n```\n```\nnew a and b to search in:\n-> a = [1, 4, 10]\n-> b = [2, 4]\n-> index median of a + b = 3\n-> mid of a = 1\n-> mid of b = 1\n```\n```\nnew a and b to search in\n-> a = [10]\n-> b = [2, 4]\n-> index median of a + b = 1\n-> mid of a = 0\n-> mid of b = 1\n```\n```\nnew a and b to search in\n-> a = []\n-> b = [2, 4]\n-> index median of a + b = 1\n```\nWow, we can see now we reached our **base** case that a is **empty** then the solution is the `1` **index** of our new array of b which is `4`.\n\nWe can see in the last example that we applied divide and conquer by **dropping** the **half** of the array that we are sure that our median won\'t be inside it then recursively search in our new arrays until we reach our base case.\uD83D\uDE80\n\nAnd this is the solution for our today problem I hope that you understood it\uD83D\uDE80\uD83D\uDE80\n\n\n---\n# Approach\n## 1. Two Pointers\n1. **Create** a new array `mergedArray` with a size equal to the **sum** of the sizes of `nums1` and `nums2`.\n2. **Initialize** two pointers `idxNums1` and `idxNums2` to `0`, representing the indices for `nums1` and `nums2`.\n3. **Iterate** through mergedArray from `0` to its `size`.\n - **Compare** the elements pointed by `idxNums1` in `nums1` and `idxNums2` in `nums2`.\n - Place the **smaller** element in `mergedArray` and **increment** the respective pointer (`idxNums1` or `idxNums2`).\n4. Check if the **size** of `mergedArray` is **odd** or **even**.\n - If **odd**, return the **middle** element of `mergedArray`.\n - If **even**, return the **average** of the two middle elements in `mergedArray`.\n\n## Complexity\n- **Time complexity:** $$O(N + M)$$ \nSince we are iterating over the big array which has size of `N + M`.\n- **Space complexity:** $$O(N + M)$$\nSince we are storing the new merged array with size of `N + M`.\n\n\n---\n\n## 2. Divide And Conquer\n1. **findKthElement** Function.\n - Handle **base cases** where one of the arrays is **exhausted**.\n - Return the kth element from the remaining array accordingly.\n - **Calculate** mid indices for both arrays to divide and conquer.\n - Based on mid elements, decide which **portion** of the arrays to **discard** and recurse accordingly.\n2. **findMedianSortedArrays** Function.\n - Calculate the **total size** of the merged arrays. \n - If the total size is **odd**, return the kth element where `k = total_size // 2`.\n - If the total size is **even**, find the `kth and (kth - 1)` elements and return their **average**.\n\n## Complexity\n- **Time complexity:** $$O(log(min(M, N)))$$ \nThe **logarithmic** term is because we are using **Divide And Conquer** then each call we divide the size of the two arrays into half.\nThe **minimum** term since the base case is when the size of one of the arrays is `0` and the array which will be faster to reach `0` is the smaller array which is `min(M, N)`\nSo total complexity is `O(log(min(M, N)))` .\n- **Space complexity:** $$O(1)$$\nSince we are only store constant number of variables then complexity is `O(1)`.\n\n\n\n---\n\n\n\n# Code\n## 1. Two Pointers\n```C++ []\nclass Solution {\npublic:\n double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {\n // Merge the sorted arrays into a single array\n vector<int> mergedArray(nums1.size() + nums2.size());\n \n int idxNums1 = 0; // Index for nums1\n int idxNums2 = 0; // Index for nums2\n \n // Merge the arrays while maintaining the sorted order\n for(int i = 0; i < mergedArray.size(); i++) {\n if (idxNums2 != nums2.size() && (idxNums1 == nums1.size() || nums2[idxNums2] < nums1[idxNums1])) {\n mergedArray[i] = nums2[idxNums2++];\n } else {\n mergedArray[i] = nums1[idxNums1++];\n }\n }\n \n // Calculate the median of the merged array\n if (mergedArray.size() % 2 == 1) {\n return mergedArray[mergedArray.size() / 2];\n } else {\n return ((mergedArray[mergedArray.size() / 2]) + (mergedArray[mergedArray.size() / 2 - 1])) / 2.0;\n }\n }\n};\n```\n```Java []\nclass Solution {\n public double findMedianSortedArrays(int[] nums1, int[] nums2) {\n // Merge the sorted arrays into a single array\n int[] mergedArray = new int[nums1.length + nums2.length];\n\n int idxNums1 = 0; // Index for nums1\n int idxNums2 = 0; // Index for nums2\n\n // Merge the arrays while maintaining the sorted order\n for (int i = 0; i < mergedArray.length; i++) {\n if (idxNums2 < nums2.length && (idxNums1 == nums1.length || nums2[idxNums2] < nums1[idxNums1])) {\n mergedArray[i] = nums2[idxNums2++];\n } else {\n mergedArray[i] = nums1[idxNums1++];\n }\n }\n\n // Calculate the median of the merged array\n if (mergedArray.length % 2 == 1) {\n return mergedArray[mergedArray.length / 2];\n } else {\n return (mergedArray[mergedArray.length / 2] + mergedArray[mergedArray.length / 2 - 1]) / 2.0;\n }\n }\n}\n```\n```Python []\nclass Solution:\n def findMedianSortedArrays(self, nums1, nums2) -> float:\n merged_array = [0] * (len(nums1) + len(nums2))\n idx_nums1 = 0 # Index for nums1\n idx_nums2 = 0 # Index for nums2\n\n # Merge the arrays while maintaining the sorted order\n for i in range(len(merged_array)):\n if idx_nums2 < len(nums2) and (idx_nums1 == len(nums1) or nums2[idx_nums2] < nums1[idx_nums1]):\n merged_array[i] = nums2[idx_nums2]\n idx_nums2 += 1\n else:\n merged_array[i] = nums1[idx_nums1]\n idx_nums1 += 1\n\n # Calculate the median of the merged array\n if len(merged_array) % 2 == 1:\n return merged_array[len(merged_array) // 2]\n else:\n return (merged_array[len(merged_array) // 2] + merged_array[len(merged_array) // 2 - 1]) / 2.0\n```\n\n## 2. Divide And Conquer\n```C++ []\nclass Solution {\npublic:\n // Helper function to find the kth element in merged sorted arrays\n double findKthElement(int k, vector<int>& nums1, vector<int>& nums2, int start1, int end1, int start2, int end2) {\n // Base cases when one array is exhausted\n if (start1 >= end1)\n return nums2[start2 + k];\n if (start2 >= end2)\n return nums1[start1 + k];\n\n // Calculate mid indices\n int mid1 = (end1 - start1) / 2;\n int mid2 = (end2 - start2) / 2;\n\n // Compare mid elements and recurse accordingly\n if (mid1 + mid2 < k) {\n if (nums1[start1 + mid1] > nums2[start2 + mid2])\n // Discard elements before mid2 and search in the remaining array\n return findKthElement(k - mid2 - 1, nums1, nums2, start1, end1, start2 + mid2 + 1, end2);\n else\n // Discard elements before mid1 and search in the remaining array\n return findKthElement(k - mid1 - 1, nums1, nums2, start1 + mid1 + 1, end1, start2, end2);\n } else {\n if (nums1[start1 + mid1] > nums2[start2 + mid2])\n // Discard elements after mid1 and search in the remaining array\n return findKthElement(k, nums1, nums2, start1, start1 + mid1, start2, end2);\n else\n // Discard elements after mid2 and search in the remaining array\n return findKthElement(k, nums1, nums2, start1, end1, start2, start2 + mid2);\n }\n }\n\n // Function to find the median of merged sorted arrays\n double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {\n int size1 = nums1.size();\n int size2 = nums2.size();\n int totalSize = size1 + size2;\n\n // Check if the total size is odd or even and find the median accordingly\n if (totalSize % 2 == 1)\n // For odd total size, median is the kth element where k = total_size // 2\n return findKthElement(totalSize / 2, nums1, nums2, 0, size1, 0, size2);\n else {\n // For even total size, median is the average of kth and (kth - 1) elements\n int num1 = findKthElement(totalSize / 2, nums1, nums2, 0, size1, 0, size2);\n int num2 = findKthElement(totalSize / 2 - 1, nums1, nums2, 0, size1, 0, size2);\n\n return (num1 + num2) / 2.0;\n }\n }\n};\n```\n```Java []\nclass Solution {\n // Helper function to find the kth element in merged sorted arrays\n private double findKthElement(int k, int[] nums1, int[] nums2, int start1, int end1, int start2, int end2) {\n // Base cases when one array is exhausted\n if (start1 >= end1)\n return nums2[start2 + k];\n if (start2 >= end2)\n return nums1[start1 + k];\n\n // Calculate mid indices\n int mid1 = (end1 - start1) / 2;\n int mid2 = (end2 - start2) / 2;\n\n // Compare mid elements and recurse accordingly\n if (mid1 + mid2 < k) {\n if (nums1[start1 + mid1] > nums2[start2 + mid2])\n // Discard elements before mid2 and search in the remaining array\n return findKthElement(k - mid2 - 1, nums1, nums2, start1, end1, start2 + mid2 + 1, end2);\n else\n // Discard elements before mid1 and search in the remaining array\n return findKthElement(k - mid1 - 1, nums1, nums2, start1 + mid1 + 1, end1, start2, end2);\n } else {\n if (nums1[start1 + mid1] > nums2[start2 + mid2])\n // Discard elements after mid1 and search in the remaining array\n return findKthElement(k, nums1, nums2, start1, start1 + mid1, start2, end2);\n else\n // Discard elements after mid2 and search in the remaining array\n return findKthElement(k, nums1, nums2, start1, end1, start2, start2 + mid2);\n }\n }\n\n // Function to find the median of merged sorted arrays\n public double findMedianSortedArrays(int[] nums1, int[] nums2) {\n int size1 = nums1.length;\n int size2 = nums2.length;\n int totalSize = size1 + size2;\n\n // Check if the total size is odd or even and find the median accordingly\n if (totalSize % 2 == 1)\n // For odd total size, median is the kth element where k = total_size // 2\n return findKthElement(totalSize / 2, nums1, nums2, 0, size1, 0, size2);\n else {\n // For even total size, median is the average of kth and (kth - 1) elements\n double num1 = findKthElement(totalSize / 2, nums1, nums2, 0, size1, 0, size2);\n double num2 = findKthElement(totalSize / 2 - 1, nums1, nums2, 0, size1, 0, size2);\n\n return (num1 + num2) / 2.0;\n }\n }\n}\n```\n```Python []\nclass Solution:\n def find_kth_element(self, k, nums1, nums2):\n # Base cases when one array is exhausted\n if not nums1:\n return nums2[k]\n if not nums2:\n return nums1[k]\n\n mid1 = len(nums1) // 2 # Midpoint of nums1\n mid2 = len(nums2) // 2 # Midpoint of nums2\n\n if mid1 + mid2 < k:\n if nums1[mid1] > nums2[mid2]:\n # Discard elements before mid2 and search in the remaining array\n return self.find_kth_element(k - mid2 - 1, nums1, nums2[mid2 + 1:])\n else:\n # Discard elements before mid1 and search in the remaining array\n return self.find_kth_element(k - mid1 - 1, nums1[mid1 + 1:], nums2)\n else:\n if nums1[mid1] > nums2[mid2]:\n # Discard elements after mid1 and search in the remaining array\n return self.find_kth_element(k, nums1[:mid1], nums2)\n else:\n # Discard elements after mid2 and search in the remaining array\n return self.find_kth_element(k, nums1, nums2[:mid2])\n\n def findMedianSortedArrays(self, nums1, nums2):\n total_size = len(nums1) + len(nums2)\n\n if total_size % 2 == 1:\n # For odd total size, median is the kth element where k = total_size // 2\n return self.find_kth_element(total_size // 2, nums1, nums2)\n else:\n # For even total size, median is the average of kth and (kth - 1) elements\n k1 = total_size // 2\n k2 = total_size // 2 - 1\n num1 = self.find_kth_element(k1, nums1, nums2)\n num2 = self.find_kth_element(k2, nums1, nums2)\n return (num1 + num2) / 2.0\n```\n\n \n![leet_sol.jpg]()\n\n

Median of Two Sorted Arrays

median-of-two-sorted-arrays

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)).

Array,Binary Search,Divide and Conquer

Hard

\n# Intuition:\nGiven two sorted arrays nums1 and nums2 of size n1 and n2 respectively, the median of the combined sorted array can be found by dividing the elements of the combined sorted array into two halves of equal length such that one half is always greater than the other. The median is then the average of the maximum element of the left half and the minimum element of the right half if the total number of elements is even, or the maximum element of the left half if the total number of elements is odd.\n\n# Approach:\nWe can use binary search to find the partition of both arrays such that the number of elements on the left side of the combined array is equal to the number of elements on the right side of the combined array. The partition of nums1 and nums2 is represented by mid1 and mid2 respectively, such that mid1 + mid2 = (n1 + n2 + 1) / 2. We divide the combined sorted array into two halves such that the left half contains all elements before the partition and the right half contains all elements after the partition.\n\nWe then check if the maximum element of the left half of nums1 is less than or equal to the minimum element of the right half of nums2 and the maximum element of the left half of nums2 is less than or equal to the minimum element of the right half of nums1. If this condition is true, we have found the partition such that the number of elements on the left side of the combined array is equal to the number of elements on the right side of the combined array. We can then calculate the median using the approach mentioned in the intuition section.\n\nIf the condition is false, we adjust the partition of nums1 by changing l to mid1 + 1 if the maximum element of the left half of nums1 is greater than the minimum element of the right half of nums2, or by changing r to mid1 - 1 otherwise. We continue the binary search until we find the partition such that the condition is true or until the search space is exhausted.\n\n# Complexity:\n- The time complexity of the solution is O(log(min(n1, n2))), where n1 and n2 are the sizes of nums1 and nums2 respectively, since we are performing binary search on the smaller array. \n- The space complexity of the solution is O(1) since we are not using any extra space apart from a few variables to keep track of the search space and the partition of both arrays.\n\n---\n# C++\n```\nclass Solution {\npublic:\n double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {\n int n1 = nums1.size();\n int n2 = nums2.size();\n \n // If nums1 is larger than nums2, swap them to ensure n1 is smaller than n2.\n if (n1 > n2) {\n return findMedianSortedArrays(nums2, nums1);\n }\n \n int l = 0;\n int r = n1;\n while (l <= r) {\n int mid1 = (l + r) / 2;\n int mid2 = (n1 + n2 + 1) / 2 - mid1;\n \n int maxLeft1 = (mid1 == 0) ? INT_MIN : nums1[mid1-1];\n int minRight1 = (mid1 == n1) ? INT_MAX : nums1[mid1];\n \n int maxLeft2 = (mid2 == 0) ? INT_MIN : nums2[mid2-1];\n int minRight2 = (mid2 == n2) ? INT_MAX : nums2[mid2];\n \n if (maxLeft1 <= minRight2 && maxLeft2 <= minRight1) {\n if ((n1 + n2) % 2 == 0) {\n return (double)(max(maxLeft1, maxLeft2) + min(minRight1, minRight2)) / 2;\n } else {\n return (double)max(maxLeft1, maxLeft2);\n }\n } else if (maxLeft1 > minRight2) {\n r = mid1 - 1;\n } else {\n l = mid1 + 1;\n }\n }\n \n return -1;\n }\n};\n\n```\n---\n# JavaScript\n```\nvar findMedianSortedArrays = function(nums1, nums2) {\n let n1 = nums1.length;\n let n2 = nums2.length;\n \n // If nums1 is larger than nums2, swap them to ensure n1 is smaller than n2.\n if (n1 > n2) {\n return findMedianSortedArrays(nums2, nums1);\n }\n \n let l = 0;\n let r = n1;\n while (l <= r) {\n let mid1 = Math.floor((l + r) / 2);\n let mid2 = Math.floor((n1 + n2 + 1) / 2 - mid1);\n \n let maxLeft1 = (mid1 == 0) ? Number.MIN_SAFE_INTEGER : nums1[mid1-1];\n let minRight1 = (mid1 == n1) ? Number.MAX_SAFE_INTEGER : nums1[mid1];\n \n let maxLeft2 = (mid2 == 0) ? Number.MIN_SAFE_INTEGER : nums2[mid2-1];\n let minRight2 = (mid2 == n2) ? Number.MAX_SAFE_INTEGER : nums2[mid2];\n \n if (maxLeft1 <= minRight2 && maxLeft2 <= minRight1) {\n if ((n1 + n2) % 2 == 0) {\n return (Math.max(maxLeft1, maxLeft2) + Math.min(minRight1, minRight2)) / 2;\n } else {\n return Math.max(maxLeft1, maxLeft2);\n }\n } else if (maxLeft1 > minRight2) {\n r = mid1 - 1;\n } else {\n l = mid1 + 1;\n }\n }\n \n return -1;\n};\n\n```\n\n---\n# JAVA\n```\nclass Solution {\n public double findMedianSortedArrays(int[] nums1, int[] nums2) {\n int n1 = nums1.length;\n int n2 = nums2.length;\n\n // If nums1 is larger than nums2, swap them to ensure n1 is smaller than n2.\n if (n1 > n2) {\n return findMedianSortedArrays(nums2, nums1);\n }\n\n int l = 0;\n int r = n1;\n while (l <= r) {\n int mid1 = (l + r) / 2;\n int mid2 = (n1 + n2 + 1) / 2 - mid1;\n\n int maxLeft1 = (mid1 == 0) ? Integer.MIN_VALUE : nums1[mid1 - 1];\n int minRight1 = (mid1 == n1) ? Integer.MAX_VALUE : nums1[mid1];\n\n int maxLeft2 = (mid2 == 0) ? Integer.MIN_VALUE : nums2[mid2 - 1];\n int minRight2 = (mid2 == n2) ? Integer.MAX_VALUE : nums2[mid2];\n\n if (maxLeft1 <= minRight2 && maxLeft2 <= minRight1) {\n if ((n1 + n2) % 2 == 0) {\n return (double) (Math.max(maxLeft1, maxLeft2) + Math.min(minRight1, minRight2)) / 2;\n } else {\n return (double) Math.max(maxLeft1, maxLeft2);\n }\n } else if (maxLeft1 > minRight2) {\n r = mid1 - 1;\n } else {\n l = mid1 + 1;\n }\n }\n\n return -1;\n }\n}\n\n```\n\n---\n# Python\n```\nclass Solution(object):\n def findMedianSortedArrays(self, nums1, nums2):\n n1 = len(nums1)\n n2 = len(nums2)\n\n # If nums1 is larger than nums2, swap them to ensure n1 is smaller than n2.\n if n1 > n2:\n return self.findMedianSortedArrays(nums2, nums1)\n\n l = 0\n r = n1\n while l <= r:\n mid1 = (l + r) / 2\n mid2 = (n1 + n2 + 1) / 2 - mid1\n\n maxLeft1 = nums1[mid1-1] if mid1 != 0 else float(\'-inf\')\n minRight1 = nums1[mid1] if mid1 != n1 else float(\'inf\')\n\n maxLeft2 = nums2[mid2-1] if mid2 != 0 else float(\'-inf\')\n minRight2 = nums2[mid2] if mid2 != n2 else float(\'inf\')\n\n if maxLeft1 <= minRight2 and maxLeft2 <= minRight1:\n if (n1 + n2) % 2 == 0:\n return float(max(maxLeft1, maxLeft2) + min(minRight1, minRight2)) / 2\n else:\n return float(max(maxLeft1, maxLeft2))\n elif maxLeft1 > minRight2:\n r = mid1 - 1\n else:\n l = mid1 + 1\n\n return -1\n\n```

Median of Two Sorted Arrays

median-of-two-sorted-arrays

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)).

Array,Binary Search,Divide and Conquer

Hard

\uD83D\uDCA1The problem \'Median of two sorted arrays\' is a classic computer science problem that involves finding the median value in a set of numbers, where the numbers are split between two sorted arrays. The median is the middle value in a set of numbers, or if there are an even numbers of values, the average of the two middle values.\n\nThe purpose of finding the median of two sorted arrays is to effciently locate the middle value(s) in a combined set of numbers without having to first merge the arrays. This is useful when working with large arrays,as mergin two large arrays can be time-consuming. By using the sorting information of the arrays, it is possible to find the median in O(log(min(m,n))) time, where m and n are the lengths of the two arryas.\n\n---\n\n# Approach\n1. Determine the length of both arrays \'nums1\' and \'nums2\'. Let \'m\' be the length of \'nums1\' and \'n\' be the length of \'nums2\'.\n2. Choose The array with the smaller length to be the first array. This is because binary search requires that we divide the array into two parts and compare values on both sides. If we start with the larger array, it would take longer to find the partion points because there would be more values to search through. By starting with the smaller array,we reduce the search space and make the process more efficent.\n3. Initialize two variables, \'imin\' and \'imax\', to keep track of the range of possible values for \'i\', the partition point in \'nums1\'. Set \'imin\' to 0 and \'imax\' to \'m\'/\n4. Calculate the desired length of elements on both sides on the partition points. let \'half_len\' be equal to \'(m+n+1)//2\n5. Use a while loop to perform binary search. while \'imin\' is less than or equal to \'imax\',do the following:\na. Calculate the partition point in \'nums1\' by finding the average of \'imin\' and \'imax\' and rounding down. Let \'i =(imin +imax) //2\'\nb. Calculate the corresponding partion point in \'nums2\' by substracting \'i\' from \'half_len\' . Let \'j =half_len -i\'\nc. Compare the values on both sides of the partition points. If \'i<m\' abd \'nums2[j-1] > nums1[i], it means that \'i\' is too small, so we need to increase it. Update \'imin\' to \'i+1\'. If \'i>0\' and \'nums1[i-1] > nums2[j]\', It means that \'i\' is too large, so we need to decrease it. Update \'imax\' to \'i-1\'.\nd. If \'i\' is such that the number of elements on both sides of the partion points is roughly equal, we have found the partion points. Go to step 6\n6. Calculate the median based on the values on both sides of the partion points. If the total number of elements \'(m+n)\' is odd, the median is simply the maximun value on the left side of the partition points.If the total number of element is even, the median is the average of the maximun value on the left side and the mimimun value on the right side of the partition points.\n7. Return the median as the result.\n\n# Code\n```\nclass Solution(object):\n def findMedianSortedArrays(self,nums1, nums2):\n m, n = len(nums1), len(nums2)\n if m > n:\n nums1, nums2, m, n = nums2, nums1, n, m\n\n imin, imax, half_len = 0, m, (m + n + 1) // 2\n while imin <= imax:\n i = (imin + imax) // 2\n j = half_len - i\n if i < m and nums2[j-1] > nums1[i]:\n imin = i + 1\n elif i > 0 and nums1[i-1] > nums2[j]:\n imax = i - 1\n else:\n if i == 0: max_of_left = nums2[j-1]\n elif j == 0: max_of_left = nums1[i-1]\n else: max_of_left = max(nums1[i-1], nums2[j-1])\n\n if (m + n) % 2 == 1:\n return max_of_left\n\n if i == m: min_of_right = nums2[j]\n elif j == n: min_of_right = nums1[i]\n else: min_of_right = min(nums1[i], nums2[j])\n\n return (max_of_left + min_of_right) / 2.0\n```