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```

Longest Palindromic Substring

longest-palindromic-substring

Given a string s, return the longest palindromic substring in s.

String,Dynamic Programming

Medium

How can we reuse a previously computed palindrome to compute a larger palindrome? If “aba” is a palindrome, is “xabax” a palindrome? Similarly is “xabay” a palindrome? Complexity based hint: If we use brute-force and check whether for every start and end position a substring is a palindrome we have O(n^2) start - end pairs and O(n) palindromic checks. Can we reduce the time for palindromic checks to O(1) by reusing some previous computation.

### It takes a lot of efforts to write such long explanatinon, so please UpVote \u2B06\uFE0F if this helps you.\n\n# Approach 1: Brute Force\n\n![image.png]()\n\n# Intuition :\n\n**The obvious brute force solution is to pick all possible starting and ending positions for a substring, and verify if it is a palindrome. There are a total of n^2 such substrings (excluding the trivial solution where a character itself is a palindrome). Since verifying each substring takes O(n) time, the run time complexity is O(n^3).**\n\n# Algorithm :\n1. Pick a starting index for the current substring which is every index from 0 to n-2.\n2. Now, pick the ending index for the current substring which is every index from i+1 to n-1.\n3. Check if the substring from ith index to jth index is a palindrome.\n4. If step 3 is true and length of substring is greater than maximum length so far, update maximum length and maximum substring. \n5. Print the maximum substring.\n\n# Complexity Analysis\n- Time complexity : ***O(n^3)***. Assume that n is the length of the input string, there are a total of C(n, 2) = n(n-1)/2 substrings (excluding the trivial solution where a character itself is a palindrome). Since verifying each substring takes O(n) time, the run time complexity is O(n^3).\n\n- Space complexity : ***O(1)***.\n\n# Code\n``` Python []\nclass Solution:\n def longestPalindrome(self, s: str) -> str:\n if len(s) <= 1:\n return s\n \n Max_Len=1\n Max_Str=s[0]\n for i in range(len(s)-1):\n for j in range(i+1,len(s)):\n if j-i+1 > Max_Len and s[i:j+1] == s[i:j+1][::-1]:\n Max_Len = j-i+1\n Max_Str = s[i:j+1]\n\n return Max_Str\n```\n``` C++ []\nclass Solution {\npublic:\n std::string longestPalindrome(std::string s) {\n if (s.length() <= 1) {\n return s;\n }\n \n int max_len = 1;\n std::string max_str = s.substr(0, 1);\n \n for (int i = 0; i < s.length(); ++i) {\n for (int j = i + max_len; j <= s.length(); ++j) {\n if (j - i > max_len && isPalindrome(s.substr(i, j - i))) {\n max_len = j - i;\n max_str = s.substr(i, j - i);\n }\n }\n }\n\n return max_str;\n }\n\nprivate:\n bool isPalindrome(const std::string& str) {\n int left = 0;\n int right = str.length() - 1;\n \n while (left < right) {\n if (str[left] != str[right]) {\n return false;\n }\n ++left;\n --right;\n }\n \n return true;\n }\n};\n```\n``` Java []\npublic class Solution {\n public String longestPalindrome(String s) {\n if (s.length() <= 1) {\n return s;\n }\n\n int maxLen = 1;\n String maxStr = s.substring(0, 1);\n\n for (int i = 0; i < s.length(); i++) {\n for (int j = i + maxLen; j <= s.length(); j++) {\n if (j - i > maxLen && isPalindrome(s.substring(i, j))) {\n maxLen = j - i;\n maxStr = s.substring(i, j);\n }\n }\n }\n\n return maxStr;\n }\n\n private boolean isPalindrome(String str) {\n int left = 0;\n int right = str.length() - 1;\n\n while (left < right) {\n if (str.charAt(left) != str.charAt(right)) {\n return false;\n }\n left++;\n right--;\n }\n\n return true;\n }\n}\n```\n# Approach 2: Expand Around Center\n![Screenshot 2023-10-27 at 8.15.36\u202FAM.png]()\n\n# Intuition :\n\n**To enumerate all palindromic substrings of a given string, we first expand a given string at each possible starting position of a palindrome and also at each possible ending position of a palindrome and keep track of the length of the longest palindrome we found so far.**\n\n# Approach :\n1. We observe that a palindrome mirrors around its center. Therefore, a palindrome can be expanded from its center, and there are only 2n - 1 such centers.\n2. You might be asking why there are 2n - 1 but not n centers? The reason is the center of a palindrome can be in between two letters. Such palindromes have even number of letters (such as "abba") and its center are between the two \'b\'s.\'\n3. Since expanding a palindrome around its center could take O(n) time, the overall complexity is O(n^2).\n\n# Algorithm :\n1. At starting we have maz_str = s[0] and max_len = 1 as every single character is a palindrome.\n2. Now, we will iterate over the string and for every character we will expand around its center.\n3. For odd length palindrome, we will consider the current character as the center and expand around it.\n4. For even length palindrome, we will consider the current character and the next character as the center and expand around it.\n5. We will keep track of the maximum length and the maximum substring.\n6. Print the maximum substring.\n\n# Complexity Analysis\n- Time complexity : ***O(n^2)***. Since expanding a palindrome around its center could take O(n) time, the overall complexity is O(n^2).\n\n- Space complexity : ***O(1)***.\n\n# Code\n\n``` Python []\nclass Solution:\n def longestPalindrome(self, s: str) -> str:\n if len(s) <= 1:\n return s\n\n def expand_from_center(left, right):\n while left >= 0 and right < len(s) and s[left] == s[right]:\n left -= 1\n right += 1\n return s[left + 1:right]\n\n max_str = s[0]\n\n for i in range(len(s) - 1):\n odd = expand_from_center(i, i)\n even = expand_from_center(i, i + 1)\n\n if len(odd) > len(max_str):\n max_str = odd\n if len(even) > len(max_str):\n max_str = even\n\n return max_str\n```\n``` C++ []\nclass Solution {\npublic:\n std::string longestPalindrome(std::string s) {\n if (s.length() <= 1) {\n return s;\n }\n\n auto expand_from_center = [&](int left, int right) {\n while (left >= 0 && right < s.length() && s[left] == s[right]) {\n left--;\n right++;\n }\n return s.substr(left + 1, right - left - 1);\n };\n\n std::string max_str = s.substr(0, 1);\n\n for (int i = 0; i < s.length() - 1; i++) {\n std::string odd = expand_from_center(i, i);\n std::string even = expand_from_center(i, i + 1);\n\n if (odd.length() > max_str.length()) {\n max_str = odd;\n }\n if (even.length() > max_str.length()) {\n max_str = even;\n }\n }\n\n return max_str;\n }\n};\n```\n``` Java []\npublic class Solution {\n public String longestPalindrome(String s) {\n if (s.length() <= 1) {\n return s;\n }\n\n String maxStr = s.substring(0, 1);\n\n for (int i = 0; i < s.length() - 1; i++) {\n String odd = expandFromCenter(s, i, i);\n String even = expandFromCenter(s, i, i + 1);\n\n if (odd.length() > maxStr.length()) {\n maxStr = odd;\n }\n if (even.length() > maxStr.length()) {\n maxStr = even;\n }\n }\n\n return maxStr;\n }\n\n private String expandFromCenter(String s, int left, int right) {\n while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {\n left--;\n right++;\n }\n return s.substring(left + 1, right);\n }\n}\n\n```\n# Approach 3: Dynamic Programming\n\n\n\n# Intuition :\n![image.png]()\n\n**To improve over the brute force solution, we first observe how we can avoid unnecessary re-computation while validating palindromes. Consider the case "ababa". If we already knew that "bab" is a palindrome, it is obvious that "ababa" must be a palindrome since the two left and right end letters are the same.**\n\n# Algorithm :\n1. We initialize a boolean table dp and mark all the values as false.\n2. We will use a variable max_len to keep track of the maximum length of the palindrome.\n3. We will iterate over the string and mark the diagonal elements as true as every single character is a palindrome.\n4. Now, we will iterate over the string and for every character we will expand around its center.\n5. For odd length palindrome, we will consider the current character as the center and expand around it.\n6. For even length palindrome, we will consider the current character and the next character as the center and expand around it.\n7. We will keep track of the maximum length and the maximum substring.\n8. Print the maximum substring.\n\n# Complexity Analysis\n- Time complexity : ***O(n^2)***. This gives us a runtime complexity of O(n^2).\n\n- Space complexity : ***O(n^2)***. It uses O(n^2) space to store the table.\n# Code\n``` Python []\nclass Solution:\n def longestPalindrome(self, s: str) -> str:\n if len(s) <= 1:\n return s\n \n Max_Len=1\n Max_Str=s[0]\n dp = [[False for _ in range(len(s))] for _ in range(len(s))]\n for i in range(len(s)):\n dp[i][i] = True\n for j in range(i):\n if s[j] == s[i] and (i-j <= 2 or dp[j+1][i-1]):\n dp[j][i] = True\n if i-j+1 > Max_Len:\n Max_Len = i-j+1\n Max_Str = s[j:i+1]\n return Max_Str\n```\n``` C++ []\nclass Solution {\npublic:\n std::string longestPalindrome(std::string s) {\n if (s.length() <= 1) {\n return s;\n }\n \n int max_len = 1;\n int start = 0;\n int end = 0;\n std::vector<std::vector<bool>> dp(s.length(), std::vector<bool>(s.length(), false));\n \n for (int i = 0; i < s.length(); ++i) {\n dp[i][i] = true;\n for (int j = 0; j < i; ++j) {\n if (s[j] == s[i] && (i - j <= 2 || dp[j + 1][i - 1])) {\n dp[j][i] = true;\n if (i - j + 1 > max_len) {\n max_len = i - j + 1;\n start = j;\n end = i;\n }\n }\n }\n }\n \n return s.substr(start, end - start + 1);\n }\n};\n\n```\n``` Java []\npublic class Solution {\n public String longestPalindrome(String s) {\n if (s.length() <= 1) {\n return s;\n }\n\n int maxLen = 1;\n int start = 0;\n int end = 0;\n boolean[][] dp = new boolean[s.length()][s.length()];\n\n for (int i = 0; i < s.length(); ++i) {\n dp[i][i] = true;\n for (int j = 0; j < i; ++j) {\n if (s.charAt(j) == s.charAt(i) && (i - j <= 2 || dp[j + 1][i - 1])) {\n dp[j][i] = true;\n if (i - j + 1 > maxLen) {\n maxLen = i - j + 1;\n start = j;\n end = i;\n }\n }\n }\n }\n\n return s.substring(start, end + 1);\n }\n}\n\n```\n\n# Approach 4: Manacher\'s Algorithm\n![image.png]()\n\n# Intuition :\n\n**To avoid the unnecessary validation of palindromes, we can use Manacher\'s algorithm. The algorithm is explained brilliantly in this article. The idea is to use palindrome property to avoid unnecessary validations. We maintain a center and right boundary of a palindrome. We use previously calculated values to determine if we can expand around the center or not. If we can expand, we expand and update the center and right boundary. Otherwise, we move to the next character and repeat the process. We also maintain a variable max_len to keep track of the maximum length of the palindrome. We also maintain a variable max_str to keep track of the maximum substring.**\n\n# Algorithm :\n1. We initialize a boolean table dp and mark all the values as false.\n2. We will use a variable max_len to keep track of the maximum length of the palindrome.\n3. We will iterate over the string and mark the diagonal elements as true as every single character is a palindrome.\n4. Now, we will iterate over the string and for every character we will expand around its center.\n5. For odd length palindrome, we will consider the current character as the center and expand around it.\n6. For even length palindrome, we will consider the current character and the next character as the center and expand around it.\n7. We will keep track of the maximum length and the maximum substring.\n8. Print the maximum substring.\n\n# Complexity Analysis\n- Time complexity : ***O(n)***. Since expanding a palindrome around its center could take O(n) time, the overall complexity is O(n).\n\n- Space complexity : ***O(n)***. It uses O(n) space to store the table.\n\n# Code\n``` Python []\nclass Solution:\n def longestPalindrome(self, s: str) -> str:\n if len(s) <= 1:\n return s\n \n Max_Len=1\n Max_Str=s[0]\n s = \'#\' + \'#\'.join(s) + \'#\'\n dp = [0 for _ in range(len(s))]\n center = 0\n right = 0\n for i in range(len(s)):\n if i < right:\n dp[i] = min(right-i, dp[2*center-i])\n while i-dp[i]-1 >= 0 and i+dp[i]+1 < len(s) and s[i-dp[i]-1] == s[i+dp[i]+1]:\n dp[i] += 1\n if i+dp[i] > right:\n center = i\n right = i+dp[i]\n if dp[i] > Max_Len:\n Max_Len = dp[i]\n Max_Str = s[i-dp[i]:i+dp[i]+1].replace(\'#\',\'\')\n return Max_Str\n```\n``` C++ []\nclass Solution {\npublic:\n std::string longestPalindrome(std::string s) {\n if (s.length() <= 1) {\n return s;\n }\n \n int maxLen = 1;\n std::string maxStr = s.substr(0, 1);\n s = "#" + std::regex_replace(s, std::regex(""), "#") + "#";\n std::vector<int> dp(s.length(), 0);\n int center = 0;\n int right = 0;\n \n for (int i = 0; i < s.length(); ++i) {\n if (i < right) {\n dp[i] = std::min(right - i, dp[2 * center - i]);\n }\n \n while (i - dp[i] - 1 >= 0 && i + dp[i] + 1 < s.length() && s[i - dp[i] - 1] == s[i + dp[i] + 1]) {\n dp[i]++;\n }\n \n if (i + dp[i] > right) {\n center = i;\n right = i + dp[i];\n }\n \n if (dp[i] > maxLen) {\n maxLen = dp[i];\n maxStr = s.substr(i - dp[i], 2 * dp[i] + 1);\n maxStr.erase(std::remove(maxStr.begin(), maxStr.end(), \'#\'), maxStr.end());\n }\n }\n \n return maxStr;\n }\n};\n\n```\n``` Java []\npublic class Solution {\n public String longestPalindrome(String s) {\n if (s.length() <= 1) {\n return s;\n }\n\n int maxLen = 1;\n String maxStr = s.substring(0, 1);\n s = "#" + s.replaceAll("", "#") + "#";\n int[] dp = new int[s.length()];\n int center = 0;\n int right = 0;\n\n for (int i = 0; i < s.length(); i++) {\n if (i < right) {\n dp[i] = Math.min(right - i, dp[2 * center - i]);\n }\n\n while (i - dp[i] - 1 >= 0 && i + dp[i] + 1 < s.length() && s.charAt(i - dp[i] - 1) == s.charAt(i + dp[i] + 1)) {\n dp[i]++;\n }\n\n if (i + dp[i] > right) {\n center = i;\n right = i + dp[i];\n }\n\n if (dp[i] > maxLen) {\n maxLen = dp[i];\n maxStr = s.substring(i - dp[i], i + dp[i] + 1).replaceAll("#", "");\n }\n }\n\n return maxStr;\n }\n}\n```\n\n# Approach 5: Recursive TLE(Time Limit Exceeded)\n\n# Intuition :\n\n**The obvious brute force solution is to pick all possible starting and ending positions for a substring, and verify if it is a palindrome. There are a total of n^2 such substrings (excluding the trivial solution where a character itself is a palindrome). Since verifying each substring takes O(n) time, the run time complexity is O(n^3). But in this approach we will use recursion to solve the problem. We will check if the string is a palindrome or not. If it is a palindrome, we will return the string. Otherwise, we will recursively call the function for the string excluding the first character and for the string excluding the last character. We will check the length of the returned strings and return the string with the maximum length.**\n\n# Algorithm :\n1. If the string is a palindrome, we will return the string.\n2. Otherwise, we will recursively call the function for the string excluding the first character and for the string excluding the last character.\n3. We will check the length of the returned strings and return the string with the maximum length.\n\n# Complexity Analysis \n- Time complexity : ***O(n^3)***. Assume that n is the length of the input string, there are a total of C(n, 2) = n(n-1)/2 substrings (excluding the trivial solution where a character itself is a palindrome). Since verifying each substring takes O(n) time, the run time complexity is O(n^3).\n\n- Space complexity : ***O(n)***. The recursion stack may go up to n levels deep.\n# Code\n``` Python []\nclass Solution:\n def longestPalindrome(self, s: str) -> str:\n\n if s==s[::-1]: \n return s\n left = self.longestPalindrome(s[1:])\n right = self.longestPalindrome(s[:-1])\n\n if len(left)>len(right):\n return left\n else:\n return right\n```\n``` C++ []\nclass Solution {\npublic:\n string longestPalindrome(string s) {\n if (s == string(s.rbegin(), s.rend())) {\n return s;\n }\n\n string left = longestPalindrome(s.substr(1));\n string right = longestPalindrome(s.substr(0, s.size() - 1));\n\n if (left.length() > right.length()) {\n return left;\n } else {\n return right;\n }\n }\n};\n\n```\n``` Java []\npublic class Solution {\n public String longestPalindrome(String s) {\n if (s.equals(new StringBuilder(s).reverse().toString())) {\n return s;\n }\n\n String left = longestPalindrome(s.substring(1));\n String right = longestPalindrome(s.substring(0, s.length() - 1));\n\n if (left.length() > right.length()) {\n return left;\n } else {\n return right;\n }\n }\n}\n```\n\n![image.png]()\n

Longest Palindromic Substring

longest-palindromic-substring

Given a string s, return the longest palindromic substring in s.

String,Dynamic Programming

Medium

How can we reuse a previously computed palindrome to compute a larger palindrome? If “aba” is a palindrome, is “xabax” a palindrome? Similarly is “xabay” a palindrome? Complexity based hint: If we use brute-force and check whether for every start and end position a substring is a palindrome we have O(n^2) start - end pairs and O(n) palindromic checks. Can we reduce the time for palindromic checks to O(1) by reusing some previous computation.

# Approach\n[![LPS0.png]()]()\n\n\n\n\n\n>The only tricky thing is that you have to be sure the right substring is returned in `expand()`. The loop ends only after expanding the range by 1 on both sides, so you have to remove those in the final returned string.\n\n>Here we basically choose each centre and try expanding from each and every specific node thus we call expand functionas `expand(i,i)` and `expand(i,i+1)` and later we apply two pointers on each node to find the longest palindrome \n\n\n\n\n\n\n![LPS.png]()\n\n\n\n\n\n> In fact, we could solve it in $$O(n^2)$$ time using only constant space.\n\nWe observe that a palindrome mirrors around its center. Therefore, a palindrome can be expanded from its center, and there are only $$2n\u22121$$ such centers.\n\nYou might be asking why there are $$2n - 1$$ but not $$n$$ centers? The reason is the center of a palindrome can be in between two letters. Such palindromes have even number of letters (such as "abba") and its center are between the two \'b\'s.\n\n\n---\n\n# Code\n\n```C++ []\nclass Solution {\npublic:\n string ans = "";\n void expand(string &s , int left ,int right)\n {\n while(left >= 0 && right < s.size())\n {\n if(s[left] != s[right])\n break;\n left--,right++;\n }\n if(ans.size() < right - left )\n ans = s.substr(left + 1 , right - left - 1);\n }\n string longestPalindrome(string s) {\n for(int i = 0 ; i < s.size() ; i++)\n {\n expand(s , i , i);\n expand(s , i , i+1);\n }\n return ans;\n }\n};\n```\n```java []\nclass Solution {\n int maxLen = 0;\n int lo = 0;\n public String longestPalindrome(String s) {\n char[] input = s.toCharArray();\n if(s.length() < 2) {\n return s;\n }\n \n for(int i = 0; i<input.length; i++) {\n expandPalindrome(input, i, i);\n expandPalindrome(input, i, i+1);\n }\n return s.substring(lo, lo+maxLen);\n }\n \n public void expandPalindrome(char[] s, int j, int k) {\n while(j >= 0 && k < s.length && s[j] == s[k]) {\n j--;\n k++;\n }\n if(maxLen < k - j - 1) {\n maxLen = k - j - 1;\n lo = j+1;\n }\n }\n}\n```\n```python []\nclass Solution:\n def longestPalindrome(self, s: str) -> str:\n ans=\'\'\n for i in range(len(s)):\n ans=max(ans,expand(s,i,i), expand(s,i,i+1), key=len)\n return ans\n \ndef expand(s,i,j):\n while i>=0 and j<len(s) and s[i]==s[j]:\n i-=1\n j+=1\n return s[i+1:j]\n```\n```c []\nint maxVal(int a, int b) {\n return a > b ? a : b;\n}\n\nint extend(char *s, int start, int end) {\n int len = strlen(s);\n for(; start >= 0 && end < len; start--, end++) {\n if(*(s + start) != *(s + end))\n break;\n }\n return end - start - 1;\n}\n\nchar * longestPalindrome(char * s){\n int max = 0, idx = 0, len = strlen(s);\n for(int i = 0; i < len; i++) {\n int len1 = extend(s, i, i); /* For even string */\n int len2 = extend(s, i, i + 1); /* For odd string */\n if (max < maxVal(len1, len2)) {\n idx = (len1 > len2) ? (i - len1 / 2) : (i - len2 / 2 + 1);\n max = maxVal(len1, len2);\n }\n }\n char *res = malloc((max+1) *sizeof(char));\n memcpy(res, &s[idx], max);\n res[max] = \'\\0\';\n return res;\n}\n```\n---\n# Complexity\n> **Time Complexity:** $$O(n^2)$$ as there is two recursion calls which are applied as two pointers so here Complexity would be$$ O(n^2).$$\n\n> **Space Complexity:** $$O(n)$$ which is nothing but the storage consumed in this process.\n\n---\n**IF YOU LIKE THE SOLUTION THEN PLEASE UPVOTE MY SOLUTION BECAUSE IT GIVES ME MOTIVATION TO REGULARLY POST THE SOLUTION.**\n\n![UPVOTE.jpg]()\n\n

Longest Palindromic Substring

longest-palindromic-substring

Given a string s, return the longest palindromic substring in s.

String,Dynamic Programming

Medium

How can we reuse a previously computed palindrome to compute a larger palindrome? If “aba” is a palindrome, is “xabax” a palindrome? Similarly is “xabay” a palindrome? Complexity based hint: If we use brute-force and check whether for every start and end position a substring is a palindrome we have O(n^2) start - end pairs and O(n) palindromic checks. Can we reduce the time for palindromic checks to O(1) by reusing some previous computation.

\n\nA brute force solution would first require generating every possible substring, which runs in O(n²) time. Then, <i>for each</i> of those substrings, we have to check if they are a palindrome. Since palindromes read the same forwards and backwards, we know that they have to be mirrored across the center. So one way of testing for palindromes is to start in the middle of the string and work outwards, checking at each step to see if the characters are equal. Since each palindrome check runs in O(n), the overall algorithm ends up running in O(n³) time.\n\nInstead, we can reduce this to O(n²) time by eliminating some redundant steps. This is because we can find the longest palindromic substring for <i>all</i> substrings that have the <i>same</i> center in a single O(n) pass. For example, if the string is `abcdedcfa`, and since we know that `e` is a palindrome by itself, then when we test `ded`, we don\'t need to start from the center again. We can only test the outer characters, the `d`. And when we test `cdedc`, then since we know `ded` is a palindrome, again, we don\'t need to start from the middle again. We can just confirm that the `c`\'s match up.\n\nNow if we expanded one more character, we would see that `b` does NOT equal `f`. Not only does this mean that this substring is not a palindrome, it also means that all other longer palindromes centered on `e` won\'t be palindromes either, so we don\'t need to test the other substrings and we can just exit early.\n\nSo now the question is, how many different centers can a string have? If the length of the substring is odd, then the center could be any of the characters. If the length of the substring is even, then the center could lie <i>between</i> any two characters. So in total, there are 2n - 1 centers (please see the video for a visualization of this).\n\nSo if visiting each center is O(n) and each palindrome check is O(n), then the algorithm now runs in O(n²) time.\n\n# Code\n```\nclass Solution:\n def longestPalindrome(self, s):\n def expand(l, r):\n while l >= 0 and r < len(s) and s[l] == s[r]:\n l -= 1\n r += 1\n return s[l+1:r]\n\n result = ""\n for i in range(len(s)):\n sub1 = expand(i, i)\n if len(sub1) > len(result):\n result = sub1\n sub2 = expand(i, i+1)\n if len(sub2) > len(result):\n result = sub2\n return result\n```

Longest Palindromic Substring

longest-palindromic-substring

Given a string s, return the longest palindromic substring in s.

String,Dynamic Programming

Medium

How can we reuse a previously computed palindrome to compute a larger palindrome? If “aba” is a palindrome, is “xabax” a palindrome? Similarly is “xabay” a palindrome? Complexity based hint: If we use brute-force and check whether for every start and end position a substring is a palindrome we have O(n^2) start - end pairs and O(n) palindromic checks. Can we reduce the time for palindromic checks to O(1) by reusing some previous computation.

# Intuition\nUsing two pointers\n\n---\n\n# Solution Video\n\n\n\n\u25A0 Timeline of the video\n`0:04` How did you find longest palindromic substring?\n`0:59` What is start point?\n`1:44` Demonstrate how it works with odd case\n`4:36` How do you calculate length of palindrome we found?\n`7:35` Will you pass all test cases?\n`7:53` Consider even case\n`9:03` How to deal with even case\n`11:26` Coding\n`14:52` Explain how to calculate range of palindrome substring\n`17:18` Time Complexity and Space Complexity\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,844\nMy initial goal is 10,000\nThank you for your support!\n\n---\n\n# Approach\n\n### How we think about a solution\n\n---\n\n\nFirst of all, Manacher\'s Algorithm solves this question with $$O(n)$$ time. But in real interviews, nobody will come up with such a solution, so I think $$O(n^2)$$ time is enough to pass the interviews.\n\nIf interviewers ask you about a solution with $$O(n)$$. just leave the room. lol\n\n---\n\nSeriously from here, first of all, we need to understand Palindromic Substring.\n\nWhen I think about a solution, I usually start with the small and simple input, because it\'s easy to understand and find a solution. But this time let\'s start with a big input.\n\n```\nInput: "xkarqzghhgfedcbabcdefgzdekx"\n```\n\n---\n\n\u25A0 Question\n\nHow did you find longest palindromic substring?\n\n---\n\nI believe you choose one character, then expand the range to left and right at the same time. If you find longest palindromic substring directly, you are not a human. lol\n\nActually, that is main idea of my solution today. But problem is that we don\'t know where to start. That\'s why we need to shift start point one by one.\n\n---\n\n\u2B50\uFE0F Points\n\nWe need to shift a start point one by one to check longest palindromic substring.\n\n- What is the start point?\n\nSince palindromic substring is like a mirror from some character, it\'s good idea to consider current index as a center of palindromic substring and expand left and right at the same time.\n\nFor example,\n\n```\nInput = "abcba"\n```\nIf we start from `c`, then\n\n```\n"ab" "c" "ba"\n i\n\ni = curerent index\n```\n"ab" and "ba" is a mirror when "c" is center.\n\n---\n\nLet\'s see one by one.\n\n```\nInput = "abcba"\n```\nWe use `left` and `right` pointers. The both pointers start from index `i` but let me start from next to index `i` to make my explanation short. A single character is definitely a palindrome which is length of `1`.\n```\ni = 0\n\n"abcba"\nlir\n \nCheck left(= out of bounds) and right(= "b")\nmax_length = 1 (= "a")\n\n```\n```\ni = 1\n\n"abcba"\n lir\n\nCheck left(= "a") and right(= "c")\nmax_length = 1 (= "a" or "b")\n\n```\n```\ni = 2\n\n"abcba"\n lir\n\nl = 1\nr = 3\nCheck left(= "b") and right(= "b") \u2192 "bcb" is a palindrome.\uD83D\uDE06\n\nLet\'s expand the range!\n\n"abcba"\n l i r\n\nl = 0\nr = 4\nCheck left(= "a") and right(= "a") \u2192 "abcba" is a palindrome.\uD83D\uDE06\nmax_length = 5 (= "abcba")\n\n "abcba"\n l i r\n\nl = -1\nr = 5\nNow left and right are out of bounds, so we finish iteration.\n\n```\n\nLet me skip the cases where we start from later "b" and "a". We already found the max length. (of course solution code will check the later part)\n\n- How do you calculate length of palindrome we found?\n\nFrom the example above, we found `5` as a max length. how do you calculate it? Simply\n\n```\nright - left\n```\nRight? So,\n```\nright - left\n5 - (-1)\n= 6\n```\n\nWait? It\'s longer than max length we found. The reason why this happens is because the two pointers stop at the next position of max length of palindrome.\n\n```\n"abcba"\n l i r\n```\nWhen `i = 2 left = 0 and right = 4`, we found `5` as a max length, but we don\'t know `5` is the max length in the current iteration, so we try to move to the next place to find longer palindrome, even if we don\'t find it in the end.\n\nThat\'s why, left and right pointer always `overrun` and stop at max length in current iteration + 1, so we need to subtract -1 from right - left.\n```\n\u274C right - left\n\uD83D\uDD34 right - left - 1\n```\nBut still you don\'t get it because we have two pointers expanding at the same time? you think we should subtract `-2`?\n\nThis is calculation of index number, so index number usually starts from `0` not `1`, so right - left includes `-1` already. For example,\n\n```\n"aba"\n l r\n```\nActual length is `3`, but if we calculate the length with index number, that should be `2`(index 2 - index 0), so it\'s already including `-1` compared with actual length. That\'s why when we have two pointers and calculate actual length, right - left - 1 works well.\n\nNow you understand main idea of my solution, but I\'m sure you will not pass all cases. Can you geuss why?\n\nThe answer is I explain the case where we have odd length of input string.\n\n---\n\n\u2B50\uFE0F Points\n\nWe have to care about both odd length of input string and even length of input string\n\n---\n\n```\nInput: "abbc"\n ```\nLet\'s see one by one. we can use the same idea. Let me write briefly.\n\n```\n"abbc"\nlir\n\nmax length = 1\n```\n```\n"abbc"\n lir\n\nmax length = 1\n```\n```\n"abbc"\n lir\n\nmax length = 1\n```\n```\n"abbc"\n lir\n\nmax length = 1\n```\n```\n\u274C Output: "a" or "b" or "c" \n```\nOutput should be\n```\n\uD83D\uDD34 Output: "bb" \n```\n- Why this happens?\n\nRegarding odd length of input array, center position of palindrome is definitely on some charcter.\n```\n"abcba", center is "c"\n```\nHow about even length of input string\n```\n"abbc"\nCenter of palindrome is "b | b" \n```\n`|` is center of palindrome. Not on some character.\n\n- So how can you avoid this?\n\nMy idea to avoid this is we start left with current index and right with current index + 1, so we start interation as if we are coming from between the characters. Let me write only when index = 1.\n```\ncurrent index = 1\n\n lr\n"abbc"\n i\n\nWe found palindrome "bb"\n\n l r\n"abbc"\n i\n\nFinish iteration.\n```\nThen\n```\nright - left - 1\n3 - 0 - 1\n= 2(= length of "bb")\n```\n\nWe can use the same idea for both cases but start position is different, that\'s why we call the same function twice in one iteration.\n\nLet\'s see a real algorithm!\n\n### Algorithm Overview:\n1. Initialize `start` and `end` variables to keep track of the starting and ending indices of the longest palindromic substring.\n2. Iterate through each character of the input string `s`.\n3. For each character, expand around it by calling the `expand_around_center` function with two different center possibilities: (i) the current character as the center (odd length palindrome), and (ii) the current character and the next character as the center (even length palindrome).\n4. Compare the lengths of the two expanded palindromes and update `start` and `end` if a longer palindrome is found.\n5. Finally, return the longest palindromic substring by slicing the input string `s` based on the `start` and `end` indices.\n\n### Detailed Explanation:\n1. Check if the input string `s` is empty. If it is, return an empty string, as there can be no palindromic substring in an empty string.\n\n2. Define a helper function `expand_around_center` that takes three arguments: the input string `s`, and two indices `left` and `right`. This function is responsible for expanding the palindrome around the center indices and returns the length of the palindrome.\n\n3. Initialize `start` and `end` variables to 0. These variables will be used to keep track of the indices of the longest palindromic substring found so far.\n\n4. Iterate through each character of the input string `s` using a for loop.\n\n5. Inside the loop, call the `expand_around_center` function twice: once with `i` as the center for an odd length palindrome and once with `i` and `i + 1` as the center for an even length palindrome.\n\n6. Calculate the length of the palindrome for both cases (odd and even) and store them in the `odd` and `even` variables.\n\n7. Calculate the maximum of the lengths of the two palindromes and store it in the `max_len` variable.\n\n8. Check if the `max_len` is greater than the length of the current longest palindromic substring (`end - start`). If it is, update the `start` and `end` variables to include the new longest palindromic substring. The new `start` is set to `i - (max_len - 1) // 2`, and the new `end` is set to `i + max_len // 2`.\n\n9. Continue the loop until all characters in the input string have been processed.\n\n10. After the loop, return the longest palindromic substring by slicing the input string `s` using the `start` and `end` indices. This substring is inclusive of the characters at the `start` and `end` indices.\n\n\n\n# Complexity\n- Time complexity: $$O(n^2)$$\n\n "n" is the length of the input string "s." This is because the code uses nested loops. The outer loop runs for each character in the string, and the inner loop, expand_around_center, can potentially run for the entire length of the string in the worst case, leading to a quadratic time complexity.\n\n- Space complexity: $$O(1)$$\n\nthe code uses a constant amount of extra space for variables like "start," "end," "left," "right," and function parameters. The space used does not depend on the size of the input string.\n\n```python []\nclass Solution:\n def longestPalindrome(self, s: str) -> str:\n if not s:\n return ""\n\n def expand_around_center(s: str, left: int, right: int):\n while left >= 0 and right < len(s) and s[left] == s[right]:\n left -= 1\n right += 1\n return right - left - 1\n\n\n start = 0\n end = 0\n\n for i in range(len(s)):\n odd = expand_around_center(s, i, i)\n even = expand_around_center(s, i, i + 1)\n max_len = max(odd, even)\n \n if max_len > end - start:\n start = i - (max_len - 1) // 2\n end = i + max_len // 2\n \n return s[start:end+1]\n```\n```javascript []\n/**\n * @param {string} s\n * @return {string}\n */\nvar longestPalindrome = function(s) {\n if (!s) {\n return "";\n }\n\n function expandAroundCenter(s, left, right) {\n while (left >= 0 && right < s.length && s[left] === s[right]) {\n left--;\n right++;\n }\n return right - left - 1;\n }\n\n let start = 0;\n let end = 0;\n\n for (let i = 0; i < s.length; i++) {\n const odd = expandAroundCenter(s, i, i);\n const even = expandAroundCenter(s, i, i + 1);\n const max_len = Math.max(odd, even);\n\n if (max_len > end - start) {\n start = i - Math.floor((max_len - 1) / 2);\n end = i + Math.floor(max_len / 2);\n }\n }\n\n return s.substring(start, end + 1); \n};\n```\n```java []\nclass Solution {\n public String longestPalindrome(String s) {\n if (s == null || s.length() == 0) {\n return "";\n }\n\n int start = 0;\n int end = 0;\n\n for (int i = 0; i < s.length(); i++) {\n int odd = expandAroundCenter(s, i, i);\n int even = expandAroundCenter(s, i, i + 1);\n int max_len = Math.max(odd, even);\n\n if (max_len > end - start) {\n start = i - (max_len - 1) / 2;\n end = i + max_len / 2;\n }\n }\n\n return s.substring(start, end + 1); \n }\n\n private int expandAroundCenter(String s, int left, int right) {\n while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {\n left--;\n right++;\n }\n return right - left - 1;\n } \n}\n```\n```C++ []\nclass Solution {\npublic:\n string longestPalindrome(string s) {\n if (s.empty()) {\n return "";\n }\n\n int start = 0;\n int end = 0;\n\n for (int i = 0; i < s.length(); i++) {\n int odd = expandAroundCenter(s, i, i);\n int even = expandAroundCenter(s, i, i + 1);\n int max_len = max(odd, even);\n\n if (max_len > end - start) {\n start = i - (max_len - 1) / 2;\n end = i + max_len / 2;\n }\n }\n\n return s.substr(start, end - start + 1); \n }\n\nprivate:\n int expandAroundCenter(string s, int left, int right) {\n while (left >= 0 && right < s.length() && s[left] == s[right]) {\n left--;\n right++;\n }\n return right - left - 1;\n } \n};\n```\n\nLet me explain this.\n```[]\nif max_len > end - start:\n start = i - (max_len - 1) // 2\n end = i + max_len // 2\n```\nif statement means just when we find longer length.\n\nLet\'s use the same example again.\n```\nInput = "abcba"\n\n```\nWhen `i = 2`, we find 5 as a max length. Let\'s see what will happen.\n\n```[]\nstart = i(2) - (max_len(5) - 1) // 2\nend = i(2) + max_len(5) // 2\n\u2193\nstart = 2 - 2\nend = 2 + 2\n\u2193\nstart = 0\nend = 4\n```\n- Why -1?\n\nThe `-1` is used to calculate the length of the palindrome correctly based on whether it is of odd or even length.\n\nHere, we try to get length of half palindrome except center chracters.\n\nRegarding odd case, actually it works if we don\'t subtract `-1`, because we have only one center chracter and we start from the character.\n\nFor example\n```\n"abcba"\n \u2191\nCenter of palindrome is "c" \n```\nWe will get length of "ab"\n```[]\nno -1 case, 5 // 2 = 2\n-1 case, 4 // 2 = 2\n```\nThe result is the same.\n\nBut regarding even case we start from between characters.\n```\n"abbc"\nCenter of palindrome is "bb" \n```\n\nWe will get length of ""(empty = 0), because center character "bb" itself is whole length of palindrome.\n\n```[]\nno -1 case, 2 // 2 = 1\n-1 case, 1 // 2 = 0\n```\nThe result is different.\n\nIn this case, we have two center charcters, if we remove one character, we can create the same odd case situation from even situaiton, so that we can get correct length except center charcters.\n\nIn this case, i = 1, we get 2 as a max length.\n```\n"abbc"\n```\n\n```[]\nstart = i(1) - (max_len(2) - 1) // 2\nend = i(1) + max_len(2) // 2\n\u2193\nstart = 1 - 0\nend = 1 + 1\n\u2193\nstart = 1\nend = 2\n```\n\nLooks good! \uD83D\uDE06\n\nSince the result is not affected by `-1` in odd case, we subtract `-1` both odd case and even case.\n\n---\n\nThank you for reading my post.\n\u2B50\uFE0F Please upvote it and don\'t forget to subscribe to my channel!\n\n\u25A0 Subscribe URL\n\n\n### My next daily coding challenge post and video.\n\npost\n\n\nvideo\n\n\n\u25A0 Timeline of the video\n`0:04` Convert rules to a diagram\n`1:14` How do you count strings with length of n?\n`3:58` Coding\n`7:39` Time Complexity and Space Complexity\n\n### My previous daily coding challenge post and video.\n\npost\n\n\nvideo\n\n\n\u25A0 Timeline of video\n`0:04` Understand question exactly and approach to solve this question\n`1:33` How can you calculate number of subtrees?\n`4:12` Demonstrate how it works\n`8:40` Coding\n`11:32` Time Complexity and Space Complexity

Longest Palindromic Substring

longest-palindromic-substring

Given a string s, return the longest palindromic substring in s.

String,Dynamic Programming

Medium

How can we reuse a previously computed palindrome to compute a larger palindrome? If “aba” is a palindrome, is “xabax” a palindrome? Similarly is “xabay” a palindrome? Complexity based hint: If we use brute-force and check whether for every start and end position a substring is a palindrome we have O(n^2) start - end pairs and O(n) palindromic checks. Can we reduce the time for palindromic checks to O(1) by reusing some previous computation.

# 1st Method :- Expand Around Center \uD83D\uDEA9\n## Intuition \uD83D\uDE80:\n\nThe intuition behind this code is to find the longest palindromic substring within a given input string `s`. A palindromic substring is a string that reads the same forwards and backward. To achieve this, the code explores the input string character by character, checking both odd and even-length palindromes by expanding around the center of each character and updating the longest palindrome found so far.\n\n## Approach \uD83D\uDE80:\n\n1. **Initialization**: \n - Check if the input string `s` is empty. If it is, return an empty string because there can\'t be any palindromes in an empty string.\n - Initialize a variable `longestPalindromeIndices` to store the indices of the longest palindrome found. Initially, it\'s set to [0, 0].\n\n2. **Main Loop**:\n - Iterate through the characters of the input string `s` using a for loop.\n\n3. **Odd-Length Palindromes**:\n - For each character at position `i`, check if there is a palindrome centered at that character. This is done by calling the `expandAroundCenter` function with `i` as both the start and end positions.\n - If a longer palindrome is found than the current longest one, update `longestPalindromeIndices` with the new indices.\n\n4. **Even-Length Palindromes**:\n - Check if there is a palindrome centered between the characters at positions `i` and `i + 1`. This is done by calling the `expandAroundCenter` function with `i` as the start position and `i + 1` as the end position.\n - If a longer even-length palindrome is found, update `longestPalindromeIndices` with the new indices.\n\n5. **Continuation**:\n - Continue this process for all characters in the input string. By the end of the loop, you will have identified the indices of the longest palindromic substring.\n\n6. **Result Extraction**:\n - Finally, extract the longest palindromic substring from the input string `s` using the indices obtained in `longestPalindromeIndices`.\n - Return this extracted substring as the result.\n\nThe key idea is to systematically explore the input string, checking both odd and even-length palindromes by expanding around the center of each character and maintaining the information about the longest palindrome found throughout the process. This approach ensures that you find the maximum length palindromic substring within the input string.\n## Complexity \uD83D\uDE81\n### \uD83C\uDFF9 Time complexity: O(N^2)\n\n1. The `expandAroundCenter` function has a time complexity of O(N), where N is the length of the input string `s`. This is because in the worst case, it can expand all the way to the ends of the string.\n2. The `longestPalindrome` function iterates through the characters of the string, and for each character, it may call `expandAroundCenter` once or twice (in the case of even-length palindromes). Therefore, the time complexity of the `longestPalindrome` function is O(N^2).\n\nSo, the overall time complexity of the code is O(N^2) due to the nested loops in the `longestPalindrome` function.\n\n### \uD83C\uDFF9 Space complexity: O(1)\n\nThe space complexity is primarily determined by the additional space used for variables and the recursive call stack.\n\n1. The `expandAroundCenter` function uses a constant amount of extra space, so its space complexity is O(1).\n2. The `longestPalindrome` function uses a few additional integer variables to store indices, but the space used by these variables is also constant, so its space complexity is O(1).\n3. The recursive calls in the `expandAroundCenter` function do not use significant additional space because they are tail-recursive. The stack space used by these calls is O(1).\n\nSo, the overall space complexity of the code is O(1).\n\n## Code \u2712\uFE0F\n``` Java []\nclass Solution {\n public String longestPalindrome(String s) {\n // Check if the input string is empty, return an empty string if so\n if (s.isEmpty())\n return "";\n\n // Initialize variables to store the indices of the longest palindrome found\n int[] longestPalindromeIndices = { 0, 0 };\n\n // Loop through the characters in the input string\n for (int i = 0; i < s.length(); ++i) {\n // Find the indices of the longest palindrome centered at character i\n int[] currentIndices = expandAroundCenter(s, i, i);\n\n // Compare the length of the current palindrome with the longest found so far\n if (currentIndices[1] - currentIndices[0] > longestPalindromeIndices[1] - longestPalindromeIndices[0]) {\n // Update the longest palindrome indices if the current one is longer\n longestPalindromeIndices = currentIndices;\n }\n\n // Check if there is a possibility of an even-length palindrome centered at\n // character i and i+1\n if (i + 1 < s.length() && s.charAt(i) == s.charAt(i + 1)) {\n // Find the indices of the longest even-length palindrome centered at characters\n // i and i+1\n int[] evenIndices = expandAroundCenter(s, i, i + 1);\n\n // Compare the length of the even-length palindrome with the longest found so\n // far\n if (evenIndices[1] - evenIndices[0] > longestPalindromeIndices[1] - longestPalindromeIndices[0]) {\n // Update the longest palindrome indices if the even-length one is longer\n longestPalindromeIndices = evenIndices;\n }\n }\n }\n\n // Extract and return the longest palindrome substring using the indices\n return s.substring(longestPalindromeIndices[0], longestPalindromeIndices[1] + 1);\n }\n\n // Helper function to find and return the indices of the longest palindrome\n // extended from s[i..j] (inclusive) by expanding around the center\n private int[] expandAroundCenter(final String s, int i, int j) {\n // Expand the palindrome by moving outward from the center while the characters\n // match\n while (i >= 0 && j < s.length() && s.charAt(i) == s.charAt(j)) {\n i--; // Move the left index to the left\n j++; // Move the right index to the right\n }\n // Return the indices of the longest palindrome found\n return new int[] { i + 1, j - 1 };\n }\n}\n\n```\n``` C++ []\nclass Solution {\npublic:\n std::string longestPalindrome(std::string s) {\n // Check if the input string is empty, return an empty string if so\n if (s.empty())\n return "";\n\n // Initialize variables to store the indices of the longest palindrome found\n std::vector<int> longestPalindromeIndices = {0, 0};\n\n for (int i = 0; i < s.length(); ++i) {\n // Find the indices of the longest palindrome centered at character i\n std::vector<int> currentIndices = expandAroundCenter(s, i, i);\n\n // Compare the length of the current palindrome with the longest found so far\n if (currentIndices[1] - currentIndices[0] > longestPalindromeIndices[1] - longestPalindromeIndices[0]) {\n longestPalindromeIndices = currentIndices;\n }\n\n // Check if there is a possibility of an even-length palindrome centered at\n // character i and i+1\n if (i + 1 < s.length() && s[i] == s[i + 1]) {\n // Find the indices of the longest even-length palindrome centered at characters\n // i and i+1\n std::vector<int> evenIndices = expandAroundCenter(s, i, i + 1);\n\n // Compare the length of the even-length palindrome with the longest found so far\n if (evenIndices[1] - evenIndices[0] > longestPalindromeIndices[1] - longestPalindromeIndices[0]) {\n longestPalindromeIndices = evenIndices;\n }\n }\n }\n\n // Extract and return the longest palindrome substring using the indices\n return s.substr(longestPalindromeIndices[0], longestPalindromeIndices[1] - longestPalindromeIndices[0] + 1);\n }\n\nprivate:\n // Helper function to find and return the indices of the longest palindrome\n // extended from s[i..j] (inclusive) by expanding around the center\n std::vector<int> expandAroundCenter(const std::string &s, int i, int j) {\n while (i >= 0 && j < s.length() && s[i] == s[j]) {\n --i;\n ++j;\n }\n return {i + 1, j - 1};\n }\n};\n\n```\n``` Python []\nclass Solution:\n def longestPalindrome(self, s: str) -> str:\n # Check if the input string is empty, return an empty string if so\n if not s:\n return ""\n\n # Initialize variables to store the indices of the longest palindrome found\n longest_palindrome_indices = [0, 0]\n\n def expand_around_center(s, i, j):\n # Helper function to find and return the indices of the longest palindrome\n # extended from s[i..j] (inclusive) by expanding around the center\n while i >= 0 and j < len(s) and s[i] == s[j]:\n i -= 1\n j += 1\n return [i + 1, j - 1]\n\n for i in range(len(s)):\n current_indices = expand_around_center(s, i, i)\n\n # Compare the length of the current palindrome with the longest found so far\n if current_indices[1] - current_indices[0] > longest_palindrome_indices[1] - longest_palindrome_indices[0]:\n longest_palindrome_indices = current_indices\n\n if i + 1 < len(s) and s[i] == s[i + 1]:\n even_indices = expand_around_center(s, i, i + 1)\n\n # Compare the length of the even-length palindrome with the longest found so far\n if even_indices[1] - even_indices[0] > longest_palindrome_indices[1] - longest_palindrome_indices[0]:\n longest_palindrome_indices = even_indices\n\n # Extract and return the longest palindrome substring using the indices\n return s[longest_palindrome_indices[0]:longest_palindrome_indices[1] + 1]\n\n```\n``` JavaScript []\nvar longestPalindrome = function(s) {\n // Check if the input string is empty, return an empty string if so\n if (s.length === 0)\n return "";\n\n // Initialize variables to store the indices of the longest palindrome found\n let longestPalindromeIndices = [0, 0];\n\n // Loop through the characters in the input string\n for (let i = 0; i < s.length; ++i) {\n // Find the indices of the longest palindrome centered at character i\n let currentIndices = expandAroundCenter(s, i, i);\n\n // Compare the length of the current palindrome with the longest found so far\n if (currentIndices[1] - currentIndices[0] > longestPalindromeIndices[1] - longestPalindromeIndices[0]) {\n // Update the longest palindrome indices if the current one is longer\n longestPalindromeIndices = currentIndices;\n }\n\n // Check if there is a possibility of an even-length palindrome centered at\n // character i and i+1\n if (i + 1 < s.length && s[i] === s[i + 1]) {\n // Find the indices of the longest even-length palindrome centered at characters\n // i and i+1\n let evenIndices = expandAroundCenter(s, i, i + 1);\n\n // Compare the length of the even-length palindrome with the longest found so\n // far\n if (evenIndices[1] - evenIndices[0] > longestPalindromeIndices[1] - longestPalindromeIndices[0]) {\n // Update the longest palindrome indices if the even-length one is longer\n longestPalindromeIndices = evenIndices;\n }\n }\n }\n\n // Extract and return the longest palindrome substring using the indices\n return s.slice(longestPalindromeIndices[0], longestPalindromeIndices[1] + 1);\n}\n\n// Helper function to find and return the indices of the longest palindrome\n// extended from s[i..j] (inclusive) by expanding around the center\nfunction expandAroundCenter(s, i, j) {\n // Expand the palindrome by moving outward from the center while the characters match\n while (i >= 0 && j < s.length && s[i] === s[j]) {\n i--; // Move the left index to the left\n j++; // Move the right index to the right\n }\n // Return the indices of the longest palindrome found\n return [i + 1, j - 1];\n}\n\n```\n``` C# []\npublic class Solution {\n public string LongestPalindrome(string s) {\n // Check if the input string is empty, return an empty string if so\n if (string.IsNullOrEmpty(s))\n return "";\n\n // Initialize variables to store the indices of the longest palindrome found\n int[] longestPalindromeIndices = { 0, 0 };\n\n // Loop through the characters in the input string\n for (int i = 0; i < s.Length; ++i) {\n // Find the indices of the longest palindrome centered at character i\n int[] currentIndices = ExpandAroundCenter(s, i, i);\n\n // Compare the length of the current palindrome with the longest found so far\n if (currentIndices[1] - currentIndices[0] > longestPalindromeIndices[1] - longestPalindromeIndices[0]) {\n // Update the longest palindrome indices if the current one is longer\n longestPalindromeIndices = currentIndices;\n }\n\n // Check if there is a possibility of an even-length palindrome centered at\n // character i and i+1\n if (i + 1 < s.Length && s[i] == s[i + 1]) {\n // Find the indices of the longest even-length palindrome centered at characters\n // i and i+1\n int[] evenIndices = ExpandAroundCenter(s, i, i + 1);\n\n // Compare the length of the even-length palindrome with the longest found so\n // far\n if (evenIndices[1] - evenIndices[0] > longestPalindromeIndices[1] - longestPalindromeIndices[0]) {\n // Update the longest palindrome indices if the even-length one is longer\n longestPalindromeIndices = evenIndices;\n }\n }\n }\n\n // Extract and return the longest palindrome substring using the indices\n return s.Substring(longestPalindromeIndices[0], longestPalindromeIndices[1] - longestPalindromeIndices[0] + 1);\n }\n\n // Helper function to find and return the indices of the longest palindrome\n // extended from s[i..j] (inclusive) by expanding around the center\n private int[] ExpandAroundCenter(string s, int i, int j) {\n // Expand the palindrome by moving outward from the center while the characters match\n while (i >= 0 && j < s.Length && s[i] == s[j]) {\n i--; // Move the left index to the left\n j++; // Move the right index to the right\n }\n // Return the indices of the longest palindrome found\n return new int[] { i + 1, j - 1 };\n }\n}\n```\n``` PHP []\nclass Solution {\n public function longestPalindrome($s) {\n // Check if the input string is empty, return an empty string if so\n if (empty($s)) {\n return "";\n }\n\n // Initialize variables to store the indices of the longest palindrome found\n $longestPalindromeIndices = array(0, 0);\n\n // Loop through the characters in the input string\n for ($i = 0; $i < strlen($s); ++$i) {\n // Find the indices of the longest palindrome centered at character i\n $currentIndices = $this->expandAroundCenter($s, $i, $i);\n\n // Compare the length of the current palindrome with the longest found so far\n if ($currentIndices[1] - $currentIndices[0] > $longestPalindromeIndices[1] - $longestPalindromeIndices[0]) {\n // Update the longest palindrome indices if the current one is longer\n $longestPalindromeIndices = $currentIndices;\n }\n\n // Check if there is a possibility of an even-length palindrome centered at\n // character i and i+1\n if ($i + 1 < strlen($s) && $s[$i] == $s[$i + 1]) {\n // Find the indices of the longest even-length palindrome centered at characters\n // i and i+1\n $evenIndices = $this->expandAroundCenter($s, $i, $i + 1);\n\n // Compare the length of the even-length palindrome with the longest found so\n // far\n if ($evenIndices[1] - $evenIndices[0] > $longestPalindromeIndices[1] - $longestPalindromeIndices[0]) {\n // Update the longest palindrome indices if the even-length one is longer\n $longestPalindromeIndices = $evenIndices;\n }\n }\n }\n\n // Extract and return the longest palindrome substring using the indices\n return substr($s, $longestPalindromeIndices[0], $longestPalindromeIndices[1] - $longestPalindromeIndices[0] + 1);\n }\n\n // Helper function to find and return the indices of the longest palindrome\n // extended from s[i..j] (inclusive) by expanding around the center\n private function expandAroundCenter($s, $i, $j) {\n // Expand the palindrome by moving outward from the center while the characters match\n while ($i >= 0 && $j < strlen($s) && $s[$i] == $s[$j]) {\n $i--; // Move the left index to the left\n $j++; // Move the right index to the right\n }\n // Return the indices of the longest palindrome found\n return array($i + 1, $j - 1);\n }\n}\n```\n![vote.jpg]()\n\n---\n\n# 2nd Method :- Manacher\'s Algorithm \uD83D\uDEA9\n\n## Intuition \uD83D\uDE80:\nThe code implements Manacher\'s algorithm, which is designed to find the longest palindromic substring in a given string. The algorithm is an efficient way to tackle this problem and is based on the following key ideas:\n\n1. Utilize symmetry: Palindromes have a property of symmetry, which means their left and right sides are mirror images of each other. Manacher\'s algorithm takes advantage of this property to optimize the process.\n\n2. Avoid redundant computations: The algorithm uses previously computed information to avoid redundant checks, which makes it more efficient than brute force methods.\n\n## Approach \uD83D\uDE80:\n\n1. **Preprocessing**:\n - The input string `s` is preprocessed to create a modified string `T` with special characters (^, #, and dollar ) inserted between each character to simplify palindrome detection.\n\n2. **Initialization**:\n - Initialize variables:\n - `strLength` for the length of the modified string `T`.\n - `palindromeLengths`, an array to store the lengths of palindromes centered at each position in `T`.\n - `center` for the current center of the palindrome being processed.\n - `rightEdge` for the rightmost edge of the palindrome found so far.\n\n3. **Palindrome Detection**:\n - Loop through the modified string `T` to find palindromes centered at each position.\n - Calculate the length of the palindrome at the current position `i` based on previously computed information and expand it if possible. This is done by comparing characters around the current position.\n - Update `center` and `rightEdge` if a longer palindrome is found.\n\n4. **Find the Longest Palindrome**:\n - After processing the entire modified string `T`, identify the longest palindrome by searching the `palindromeLengths` array for the maximum value.\n - Determine the center of this longest palindrome.\n\n5. **Extract the Result**:\n - Use the information about the longest palindrome (center and length) in the modified string `T` to extract the corresponding substring from the original input string `s`.\n\nThe code effectively implements this approach to find and return the longest palindromic substring in the input string `s`. Manacher\'s algorithm is more efficient than naive methods because it takes advantage of the properties of palindromes and avoids redundant comparisons, making it a good choice for solving this problem.\n\n\n## Complexity \uD83D\uDE81\n### \uD83C\uDFF9 Time complexity: O(N)\nThe time complexity of Manacher\'s algorithm is O(N), where N is the length of the input string `s`. This is because the algorithm processes each character of the modified string exactly once (with some constant factor overhead) in a linear pass. The key factor in achieving this efficiency is the "center expansion" technique used to find palindromes, which avoids unnecessary character comparisons. \n\n### \uD83C\uDFF9 Space complexity: O(N)\nThe space complexity of the code is O(N) as well. This is primarily due to the creation of the modified string `T`, which is constructed by adding extra characters, such as \'^\', \'#\', and \'$\', to the original string. The `P` array used to store the lengths of palindromes at each position also has a space complexity of O(N) because it is an array of the same length as the modified string. The other variables used in the algorithm (e.g., `C`, `R`, and loop counters) have constant space requirements and do not significantly contribute to the space complexity.\n\nSo, in terms of both time and space complexity, this code is very efficient for finding the longest palindromic substring in a string.\n\n\n## Code \u2712\uFE0F\n``` Java []\npublic class Solution {\n public String longestPalindrome(String s) {\n // Step 1: Preprocess the input string\n StringBuilder processedStr = new StringBuilder("^#");\n for (char c : s.toCharArray()) {\n processedStr.append(c).append("#");\n }\n processedStr.append("$");\n String modifiedString = processedStr.toString();\n\n // Step 2: Initialize variables for the algorithm\n int strLength = modifiedString.length();\n int[] palindromeLengths = new int[strLength];\n int center = 0; // Current center of the palindrome\n int rightEdge = 0; // Rightmost edge of the palindrome\n\n // Step 3: Loop through the modified string to find palindromes\n for (int i = 1; i < strLength - 1; i++) {\n palindromeLengths[i] = (rightEdge > i) ? Math.min(rightEdge - i, palindromeLengths[2 * center - i]) : 0;\n \n // Expand the palindrome around the current character\n while (modifiedString.charAt(i + 1 + palindromeLengths[i]) == modifiedString.charAt(i - 1 - palindromeLengths[i])) {\n palindromeLengths[i]++;\n }\n \n // Update the rightmost edge and center if necessary\n if (i + palindromeLengths[i] > rightEdge) {\n center = i;\n rightEdge = i + palindromeLengths[i];\n }\n }\n\n // Step 4: Find the longest palindrome and its center\n int maxLength = 0;\n int maxCenter = 0;\n for (int i = 0; i < strLength; i++) {\n if (palindromeLengths[i] > maxLength) {\n maxLength = palindromeLengths[i];\n maxCenter = i;\n }\n }\n \n // Step 5: Extract the longest palindrome from the modified string\n int start = (maxCenter - maxLength) / 2;\n int end = start + maxLength;\n\n // Return the longest palindrome in the original string\n return s.substring(start, end);\n }\n}\n```\n``` C++ []\nclass Solution {\npublic:\n std::string longestPalindrome(std::string s) {\n // Step 1: Preprocess the input string\n std::string processedStr = "^#";\n for (char c : s) {\n processedStr.push_back(c);\n processedStr.push_back(\'#\');\n }\n processedStr.push_back(\'$\');\n\n // Step 2: Initialize variables for the algorithm\n int strLength = processedStr.length();\n std::vector<int> palindromeLengths(strLength, 0);\n int center = 0; // Current center of the palindrome\n int rightEdge = 0; // Rightmost edge of the palindrome\n\n // Step 3: Loop through the modified string to find palindromes\n for (int i = 1; i < strLength - 1; i++) {\n palindromeLengths[i] = (rightEdge > i) ? std::min(rightEdge - i, palindromeLengths[2 * center - i]) : 0;\n\n // Expand the palindrome around the current character\n while (processedStr[i + 1 + palindromeLengths[i]] == processedStr[i - 1 - palindromeLengths[i]]) {\n palindromeLengths[i]++;\n }\n\n // Update the rightmost edge and center if necessary\n if (i + palindromeLengths[i] > rightEdge) {\n center = i;\n rightEdge = i + palindromeLengths[i];\n }\n }\n\n // Step 4: Find the longest palindrome and its center\n int maxLength = 0;\n int maxCenter = 0;\n for (int i = 0; i < strLength; i++) {\n if (palindromeLengths[i] > maxLength) {\n maxLength = palindromeLengths[i];\n maxCenter = i;\n }\n }\n\n // Step 5: Extract the longest palindrome from the modified string\n int start = (maxCenter - maxLength) / 2;\n int end = start + maxLength;\n\n // Return the longest palindrome in the original string\n return s.substr(start, end - start);\n }\n};\n```\n``` Python []\nclass Solution:\n def longestPalindrome(self, s: str) -> str:\n # Step 1: Preprocess the input string\n processed_str = "^#"\n for c in s:\n processed_str += c + "#"\n processed_str += "$"\n\n # Step 2: Initialize variables for the algorithm\n str_length = len(processed_str)\n palindrome_lengths = [0] * str_length\n center = 0 # Current center of the palindrome\n right_edge = 0 # Rightmost edge of the palindrome\n\n # Step 3: Loop through the modified string to find palindromes\n for i in range(1, str_length - 1):\n palindrome_lengths[i] = min(right_edge - i, palindrome_lengths[2 * center - i]) if right_edge > i else 0\n\n # Expand the palindrome around the current character\n while processed_str[i + 1 + palindrome_lengths[i]] == processed_str[i - 1 - palindrome_lengths[i]]:\n palindrome_lengths[i] += 1\n\n # Update the rightmost edge and center if necessary\n if i + palindrome_lengths[i] > right_edge:\n center = i\n right_edge = i + palindrome_lengths[i]\n\n # Step 4: Find the longest palindrome and its center\n max_length = 0\n max_center = 0\n for i in range(str_length):\n if palindrome_lengths[i] > max_length:\n max_length = palindrome_lengths[i]\n max_center = i\n\n # Step 5: Extract the longest palindrome from the modified string\n start = (max_center - max_length) // 2\n end = start + max_length\n\n # Return the longest palindrome in the original string\n return s[start:end]\n```\n``` JavaScript []\nclass Solution {\n longestPalindrome(s) {\n // Step 1: Preprocess the input string\n let processedStr = "^#";\n for (let i = 0; i < s.length; i++) {\n processedStr += s[i] + "#";\n }\n processedStr += "$";\n let modifiedString = processedStr;\n\n // Step 2: Initialize variables for the algorithm\n let strLength = modifiedString.length;\n let palindromeLengths = new Array(strLength).fill(0);\n let center = 0; // Current center of the palindrome\n let rightEdge = 0; // Rightmost edge of the palindrome\n\n // Step 3: Loop through the modified string to find palindromes\n for (let i = 1; i < strLength - 1; i++) {\n palindromeLengths[i] = (rightEdge > i) ? Math.min(rightEdge - i, palindromeLengths[2 * center - i]) : 0;\n\n // Expand the palindrome around the current character\n while (modifiedString[i + 1 + palindromeLengths[i]] === modifiedString[i - 1 - palindromeLengths[i]]) {\n palindromeLengths[i]++;\n }\n\n // Update the rightmost edge and center if necessary\n if (i + palindromeLengths[i] > rightEdge) {\n center = i;\n rightEdge = i + palindromeLengths[i];\n }\n }\n\n // Step 4: Find the longest palindrome and its center\n let maxLength = 0;\n let maxCenter = 0;\n for (let i = 0; i < strLength; i++) {\n if (palindromeLengths[i] > maxLength) {\n maxLength = palindromeLengths[i];\n maxCenter = i;\n }\n }\n\n // Step 5: Extract the longest palindrome from the modified string\n let start = (maxCenter - maxLength) / 2;\n let end = start + maxLength;\n\n // Return the longest palindrome in the original string\n return s.substring(start, end);\n }\n}\n```\n``` C# []\npublic class Solution {\n public string LongestPalindrome(string s) {\n // Step 1: Preprocess the input string\n StringBuilder processedStr = new StringBuilder("^#");\n foreach (char c in s) {\n processedStr.Append(c).Append("#");\n }\n processedStr.Append("$");\n string modifiedString = processedStr.ToString();\n\n // Step 2: Initialize variables for the algorithm\n int strLength = modifiedString.Length;\n int[] palindromeLengths = new int[strLength];\n int center = 0; // Current center of the palindrome\n int rightEdge = 0; // Rightmost edge of the palindrome\n\n // Step 3: Loop through the modified string to find palindromes\n for (int i = 1; i < strLength - 1; i++) {\n palindromeLengths[i] = (rightEdge > i) ? Math.Min(rightEdge - i, palindromeLengths[2 * center - i]) : 0;\n\n // Expand the palindrome around the current character\n while (modifiedString[i + 1 + palindromeLengths[i]] == modifiedString[i - 1 - palindromeLengths[i]]) {\n palindromeLengths[i]++;\n }\n\n // Update the rightmost edge and center if necessary\n if (i + palindromeLengths[i] > rightEdge) {\n center = i;\n rightEdge = i + palindromeLengths[i];\n }\n }\n\n // Step 4: Find the longest palindrome and its center\n int maxLength = 0;\n int maxCenter = 0;\n for (int i = 0; i < strLength; i++) {\n if (palindromeLengths[i] > maxLength) {\n maxLength = palindromeLengths[i];\n maxCenter = i;\n }\n }\n\n // Step 5: Extract the longest palindrome from the modified string\n int start = (maxCenter - maxLength) / 2;\n int end = start + maxLength;\n\n // Return the longest palindrome in the original string\n return s.Substring(start, end - start);\n }\n}\n```\n``` PHP []\nclass Solution {\n public function longestPalindrome($s) {\n // Step 1: Preprocess the input string\n $processedStr = "^#";\n for ($i = 0; $i < strlen($s); $i++) {\n $processedStr .= $s[$i] . "#";\n }\n $processedStr .= "$";\n $modifiedString = $processedStr;\n\n // Step 2: Initialize variables for the algorithm\n $strLength = strlen($modifiedString);\n $palindromeLengths = array_fill(0, $strLength, 0);\n $center = 0; // Current center of the palindrome\n $rightEdge = 0; // Rightmost edge of the palindrome\n\n // Step 3: Loop through the modified string to find palindromes\n for ($i = 1; $i < $strLength - 1; $i++) {\n $palindromeLengths[$i] = ($rightEdge > $i) ? min($rightEdge - $i, $palindromeLengths[2 * $center - $i]) : 0;\n\n // Expand the palindrome around the current character\n while ($modifiedString[$i + 1 + $palindromeLengths[$i]] == $modifiedString[$i - 1 - $palindromeLengths[$i]]) {\n $palindromeLengths[$i]++;\n }\n\n // Update the rightmost edge and center if necessary\n if ($i + $palindromeLengths[$i] > $rightEdge) {\n $center = $i;\n $rightEdge = $i + $palindromeLengths[$i];\n }\n }\n\n // Step 4: Find the longest palindrome and its center\n $maxLength = 0;\n $maxCenter = 0;\n for ($i = 0; $i < $strLength; $i++) {\n if ($palindromeLengths[$i] > $maxLength) {\n $maxLength = $palindromeLengths[$i];\n $maxCenter = $i;\n }\n }\n\n // Step 5: Extract the longest palindrome from the modified string\n $start = ($maxCenter - $maxLength) / 2;\n $end = $start + $maxLength;\n\n // Return the longest palindrome in the original string\n return substr($s, $start, $end - $start);\n }\n}\n```\n\n![upvote.png]()\n# Up Vote Guys\n

Longest Palindromic Substring

longest-palindromic-substring

Given a string s, return the longest palindromic substring in s.

String,Dynamic Programming

Medium

How can we reuse a previously computed palindrome to compute a larger palindrome? If “aba” is a palindrome, is “xabax” a palindrome? Similarly is “xabay” a palindrome? Complexity based hint: If we use brute-force and check whether for every start and end position a substring is a palindrome we have O(n^2) start - end pairs and O(n) palindromic checks. Can we reduce the time for palindromic checks to O(1) by reusing some previous computation.

# Intuition\nWhen tackling the problem of finding the longest palindromic substring, one might initially think of generating all possible substrings and checking each for palindromicity. However, this approach is inefficient. A more nuanced understanding would lead us to the realization that for each character in the string, it could potentially be the center of a palindrome. Using this intuition, we can attempt to expand around each character to check for palindromes. But how can we make sure to handle palindromes of both even and odd lengths? This is where Manacher\'s algorithm comes in, transforming the string in a way that we only need to handle palindromes centered around a single character.\n\n## Live Codding & Comments\n\n\n# Approach\n\n**Manacher\'s Algorithm** is a powerful technique that allows us to find the longest palindromic substring in a given string in linear time. Here\'s a detailed breakdown of the algorithm\'s approach:\n\n### 1. String Transformation\nWe first transform the original string to simplify the algorithm. This transformation achieves two things:\n- It ensures that every potential center of a palindrome is surrounded by identical characters (`#`), which simplifies the process of expanding around a center.\n- It adds special characters `^` at the beginning and `$` at the end of the string to avoid any boundary checks during the palindrome expansion.\n\nFor instance, the string `"babad"` is transformed into `"^#b#a#b#a#d#$"`.\n\n### 2. Initialization\nWe maintain an array `P` with the same length as the transformed string. Each entry `P[i]` denotes the radius (half-length) of the palindrome centered at position `i`.\n\nWe also introduce two critical pointers:\n- `C`: The center of the palindrome that has the rightmost boundary.\n- `R`: The right boundary of this palindrome.\n\nBoth `C` and `R` start at the beginning of the string.\n\n### 3. Iterating Through the String\nFor every character in the transformed string, we consider it as a potential center for a palindrome.\n\n**a. Using Previously Computed Information**: \nIf the current position is to the left of `R`, its mirror position about the center `C` might have information about a palindrome centered at the current position. We can leverage this to avoid unnecessary calculations.\n\n**b. Expanding Around the Center**: \nStarting from the current radius at position `i` (which might be derived from its mirror or initialized to 0), we attempt to expand around `i` and check if the characters are the same.\n\n**c. Updating `C` and `R`**: \nIf the palindrome centered at `i` extends beyond `R`, we update `C` to `i` and `R` to the new boundary.\n\n### 4. Extracting the Result\nOnce we\'ve computed the palindromic radii for all positions in the transformed string, we find the position with the largest radius in `P`. This position represents the center of the longest palindromic substring. We then extract and return this palindrome from the original string.\n\n# Complexity\n- Time complexity: $O(n)$\nManacher\'s algorithm processes each character in the transformed string once, making the time complexity linear.\n\n- Space complexity: $O(n)$\nWe use an array `P` to store the palindrome radii, making the space complexity linear as well.\n\n# Code\n``` Python []\nclass Solution:\n def longestPalindrome(self, s: str) -> str:\n T = \'#\'.join(\'^{}$\'.format(s))\n n = len(T)\n P = [0] * n\n C = R = 0\n \n for i in range(1, n-1):\n P[i] = (R > i) and min(R - i, P[2*C - i])\n while T[i + 1 + P[i]] == T[i - 1 - P[i]]:\n P[i] += 1\n \n if i + P[i] > R:\n C, R = i, i + P[i]\n \n max_len, center_index = max((n, i) for i, n in enumerate(P))\n return s[(center_index - max_len) // 2: (center_index + max_len) // 2]\n```\n``` Go []\nfunc longestPalindrome(s string) string {\n T := "^#" + strings.Join(strings.Split(s, ""), "#") + "#$"\n n := len(T)\n P := make([]int, n)\n C, R := 0, 0\n \n for i := 1; i < n-1; i++ {\n if R > i {\n P[i] = min(R-i, P[2*C-i])\n }\n for T[i+1+P[i]] == T[i-1-P[i]] {\n P[i]++\n }\n if i + P[i] > R {\n C, R = i, i + P[i]\n }\n }\n \n maxLen := 0\n centerIndex := 0\n for i, v := range P {\n if v > maxLen {\n maxLen = v\n centerIndex = i\n }\n }\n return s[(centerIndex-maxLen)/2 : (centerIndex+maxLen)/2]\n}\n\nfunc min(a, b int) int {\n if a < b {\n return a\n }\n return b\n}\n```\n``` Java []\npublic class Solution {\n public String longestPalindrome(String s) {\n StringBuilder sb = new StringBuilder("^#");\n for (char c : s.toCharArray()) {\n sb.append(c).append("#");\n }\n sb.append("$");\n String T = sb.toString();\n \n int n = T.length();\n int[] P = new int[n];\n int C = 0, R = 0;\n \n for (int i = 1; i < n-1; i++) {\n P[i] = (R > i) ? Math.min(R - i, P[2*C - i]) : 0;\n while (T.charAt(i + 1 + P[i]) == T.charAt(i - 1 - P[i]))\n P[i]++;\n \n if (i + P[i] > R) {\n C = i;\n R = i + P[i];\n }\n }\n \n int max_len = 0, center_index = 0;\n for (int i = 0; i < n; i++) {\n if (P[i] > max_len) {\n max_len = P[i];\n center_index = i;\n }\n }\n return s.substring((center_index - max_len) / 2, (center_index + max_len) / 2);\n }\n}\n```\n``` C++ []\nclass Solution {\npublic:\n std::string longestPalindrome(std::string s) {\n std::string T = "^#";\n for (char c : s) {\n T += c;\n T += \'#\';\n }\n T += "$";\n\n int n = T.size();\n std::vector<int> P(n, 0);\n int C = 0, R = 0;\n\n for (int i = 1; i < n-1; ++i) {\n P[i] = (R > i) ? std::min(R - i, P[2*C - i]) : 0;\n while (T[i + 1 + P[i]] == T[i - 1 - P[i]])\n P[i]++;\n\n if (i + P[i] > R) {\n C = i;\n R = i + P[i];\n }\n }\n\n int max_len = *std::max_element(P.begin(), P.end());\n int center_index = std::distance(P.begin(), std::find(P.begin(), P.end(), max_len));\n return s.substr((center_index - max_len) / 2, max_len);\n }\n};\n```\n``` PHP []\nclass Solution {\n function longestPalindrome($s) {\n $T = "^#".implode("#", str_split($s))."#$";\n $n = strlen($T);\n $P = array_fill(0, $n, 0);\n $C = $R = 0;\n \n for ($i = 1; $i < $n-1; $i++) {\n $P[$i] = ($R > $i) ? min($R - $i, $P[2*$C - $i]) : 0;\n while ($T[$i + 1 + $P[$i]] == $T[$i - 1 - $P[$i]])\n $P[$i]++;\n \n if ($i + $P[$i] > $R) {\n $C = $i;\n $R = $i + $P[$i];\n }\n }\n \n $max_len = max($P);\n $center_index = array_search($max_len, $P);\n return substr($s, ($center_index - $max_len) / 2, $max_len);\n }\n}\n```\n``` C# []\npublic class Solution {\n public string LongestPalindrome(string s) {\n string T = "^#" + string.Join("#", s.ToCharArray()) + "#$";\n int n = T.Length;\n int[] P = new int[n];\n int C = 0, R = 0;\n \n for (int i = 1; i < n-1; i++) {\n P[i] = (R > i) ? Math.Min(R - i, P[2*C - i]) : 0;\n while (T[i + 1 + P[i]] == T[i - 1 - P[i]])\n P[i]++;\n \n if (i + P[i] > R) {\n C = i;\n R = i + P[i];\n }\n }\n \n int max_len = P.Max();\n int center_index = Array.IndexOf(P, max_len);\n return s.Substring((center_index - max_len) / 2, max_len);\n }\n}\n```\n``` JavaScript []\nvar longestPalindrome = function(s) {\n let T = "^#" + s.split("").join("#") + "#$";\n let n = T.length;\n let P = new Array(n).fill(0);\n let C = 0, R = 0;\n \n for (let i = 1; i < n-1; i++) {\n P[i] = (R > i) ? Math.min(R - i, P[2*C - i]) : 0;\n while (T[i + 1 + P[i]] === T[i - 1 - P[i]])\n P[i]++;\n \n if (i + P[i] > R) {\n C = i;\n R = i + P[i];\n }\n }\n \n let max_len = Math.max(...P);\n let center_index = P.indexOf(max_len);\n return s.substring((center_index - max_len) / 2, (center_index + max_len) / 2);\n }\n```\n\n# Performance\n| Language | Runtime (ms) | Memory (MB) |\n|------------|--------------|-------------|\n| Go | 5 | 5.2 |\n| Java | 8 | 43.2 |\n| C++ | 11 | 8.7 |\n| PHP | 18 | 19.4 |\n| C# | 67 | 40.5 |\n| JavaScript | 71 | 45.6 |\n| Python3 | 90 | 16.4 |\n\n![v445.png]()\n\n\n# What did we learn?\nWe learned about Manacher\'s algorithm, a linear-time solution to the longest palindromic substring problem. By transforming the string and leveraging the properties of palindromes, we can efficiently determine the longest palindrome without checking every possible substring.\n\n# Why does it work?\nManacher\'s algorithm works by taking advantage of the symmetrical nature of palindromes. It avoids redundant checks by using the information from previously computed palindromes. The transformation of the string ensures that we don\'t need to separately handle even and odd length palindromes.\n\n# What is the optimization here?\nThe brilliance of Manacher\'s algorithm lies in its ability to reduce the problem from quadratic to linear time. By using the palindrome information already computed and the nature of palindromes themselves, the algorithm avoids unnecessary checks, making it one of the most optimal solutions for this problem.

Longest Palindromic Substring

longest-palindromic-substring

Given a string s, return the longest palindromic substring in s.

String,Dynamic Programming

Medium

How can we reuse a previously computed palindrome to compute a larger palindrome? If “aba” is a palindrome, is “xabax” a palindrome? Similarly is “xabay” a palindrome? Complexity based hint: If we use brute-force and check whether for every start and end position a substring is a palindrome we have O(n^2) start - end pairs and O(n) palindromic checks. Can we reduce the time for palindromic checks to O(1) by reusing some previous computation.

#### Approach (implemented Dp rules)\n* ##### Definition : the row and col in the dp table represent the slicing index on the string s (inclusive)\n* ##### example s = \'babad\' -- > dp[2][3] = s[2:3] = ba\n##### Steps : \n* ##### Fill the diagonal with True, b/c every single character by itself is palindrom \n* ##### Don\'t traverse in the bottom part of the diagonal \n\t* ##### Becuase, that represent reverse slicing (which is not valid)\n##### \n* ##### Iterate backward starting from the most right bottom cell to top (only on the right side of the digonal) \n\t* ##### How ? \n\t\t* ##### \t\tStart itertating backward for the outer loop (i) and for the inner loop (j) iterate forward starting from the index of outer loop ) : see the code (the for loops) \n##### \n* ##### - Pick character from the input string based on the at i and j position, If the characters matches : you need to check two conditions\n\t* ##### 1. If the length of the sub_string is just one (a letter matching is good to be a palindrom)\n\t* ##### 2. But if the length of the sub_string is > 1 \n\t\t* ##### - You need to check if the inner sub_sting is also palindrom\n\t\t* ##### - How ?\n\t\t\t* ##### - You go to the left bottom corner and check if it is True \n\t\t\t* ##### - Left bottom corrner represent the inner sub_string of the current_sub_string \n\t\t\t\t* ##### -Eg. if dp[i][j]= cur_sub_string = \'ababa\' --> True because dp[i+1][j-1] is True\n\t\t\t\t* ##### dp[i+1][j-1] = \'bab\' = True\n\t\t\t\t* ##### .Howerver if dp[i][j]= cur_sub_string = \'abaca\' --> False because dp[i+1][j-1] is False\n\t\t\t\t* ##### dp[i+1][j-1] = \'bac\' = False --> not palindrom \n\t\t* ##### \n\t\t* ##### If dp[i+1][j-1] == True:\n\t\t\t* ##### Ok that means the current sub_string is also palindrom \n\t\t* ##### - Now compare the length of the current_palindrom sub_string with the prvious longest one and take the max\n* ##### - Else : the characters don\'t match\n\t* ##### Just pass\n* ##### - Finally return the maximum number in the dp\n* ##### If this solution/explanation helps you, don\'t forget to upvote as appreciation\n\n```\ndef longestPalindrome(self, s):\n longest_palindrom = \'\'\n dp = [[0]*len(s) for _ in range(len(s))]\n #filling out the diagonal by 1\n for i in range(len(s)):\n dp[i][i] = True\n longest_palindrom = s[i]\n\t\t\t\n # filling the dp table\n for i in range(len(s)-1,-1,-1):\n\t\t\t\t# j starts from the i location : to only work on the upper side of the diagonal \n for j in range(i+1,len(s)): \n if s[i] == s[j]: #if the chars mathces\n # if len slicied sub_string is just one letter if the characters are equal, we can say they are palindomr dp[i][j] =True \n #if the slicied sub_string is longer than 1, then we should check if the inner string is also palindrom (check dp[i+1][j-1] is True)\n if j-i ==1 or dp[i+1][j-1] is True:\n dp[i][j] = True\n # we also need to keep track of the maximum palindrom sequence \n if len(longest_palindrom) < len(s[i:j+1]):\n longest_palindrom = s[i:j+1]\n \n return longest_palindrom\n```

Longest Palindromic Substring

longest-palindromic-substring

Given a string s, return the longest palindromic substring in s.

String,Dynamic Programming

Medium

How can we reuse a previously computed palindrome to compute a larger palindrome? If “aba” is a palindrome, is “xabax” a palindrome? Similarly is “xabay” a palindrome? Complexity based hint: If we use brute-force and check whether for every start and end position a substring is a palindrome we have O(n^2) start - end pairs and O(n) palindromic checks. Can we reduce the time for palindromic checks to O(1) by reusing some previous computation.

# Hello LeetCode fans,\nBelow I presented a solution to the problem (5.Longest Palindromic Substring).\nIf you found it `useful or informative`,\nClick the "`UPVOTE`" button below and it means I was able to `help someone`.\nYour UPVOTES encourage me and others who are`working hard` to improve their problem solving skills.\n\n# Code\n# Solution C++\n```\nclass Solution {\npublic:\n string ans = "";\n void expand(string &s , int left ,int right)\n {\n while(left >= 0 && right < s.size())\n {\n if(s[left] != s[right])\n break;\n left--,right++;\n }\n if(ans.size() < right - left )\n ans = s.substr(left + 1 , right - left - 1);\n }\n string longestPalindrome(string s) {\n for(int i = 0 ; i < s.size() ; i++)\n {\n expand(s , i , i);\n expand(s , i , i+1);\n }\n return ans;\n }\n};\n```\n# Solution JAVA\n````\nclass Solution {\n int maxLen = 0;\n int lo = 0;\n public String longestPalindrome(String s) {\n char[] input = s.toCharArray();\n if(s.length() < 2) {\n return s;\n }\n \n for(int i = 0; i<input.length; i++) {\n expandPalindrome(input, i, i);\n expandPalindrome(input, i, i+1);\n }\n return s.substring(lo, lo+maxLen);\n }\n \n public void expandPalindrome(char[] s, int j, int k) {\n while(j >= 0 && k < s.length && s[j] == s[k]) {\n j--;\n k++;\n }\n if(maxLen < k - j - 1) {\n maxLen = k - j - 1;\n lo = j+1;\n }\n }\n}\n````\n# Solution Python\n```\nclass Solution:\n def longestPalindrome(self, s: str) -> str:\n ans=\'\'\n for i in range(len(s)):\n ans=max(ans,expand(s,i,i), expand(s,i,i+1), key=len)\n return ans\n \ndef expand(s,i,j):\n while i>=0 and j<len(s) and s[i]==s[j]:\n i-=1\n j+=1\n return s[i+1:j]\n\n```\n# Solution C\n```\nint maxVal(int a, int b) {\n return a > b ? a : b;\n}\n\nint extend(char *s, int start, int end) {\n int len = strlen(s);\n for(; start >= 0 && end < len; start--, end++) {\n if(*(s + start) != *(s + end))\n break;\n }\n return end - start - 1;\n}\n\nchar * longestPalindrome(char * s){\n int max = 0, idx = 0, len = strlen(s);\n for(int i = 0; i < len; i++) {\n int len1 = extend(s, i, i); /* For even string */\n int len2 = extend(s, i, i + 1); /* For odd string */\n if (max < maxVal(len1, len2)) {\n idx = (len1 > len2) ? (i - len1 / 2) : (i - len2 / 2 + 1);\n max = maxVal(len1, len2);\n }\n }\n char *res = malloc((max+1) *sizeof(char));\n memcpy(res, &s[idx], max);\n res[max] = \'\\0\';\n return res;\n}\n```\n![image.png]()\n\n# Thanks for all!\n

Longest Palindromic Substring

longest-palindromic-substring

Given a string s, return the longest palindromic substring in s.

String,Dynamic Programming

Medium

How can we reuse a previously computed palindrome to compute a larger palindrome? If “aba” is a palindrome, is “xabax” a palindrome? Similarly is “xabay” a palindrome? Complexity based hint: If we use brute-force and check whether for every start and end position a substring is a palindrome we have O(n^2) start - end pairs and O(n) palindromic checks. Can we reduce the time for palindromic checks to O(1) by reusing some previous computation.

# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nThe given code is an implementation of the "Expand Around Center" approach for finding the longest palindromic substring in a given string. This approach works by iterating through each character in the string and expanding around it to check for palindromes. It takes advantage of the fact that a palindrome can be centered around a single character (in the case of odd-length palindromes) or between two characters (in the case of even-length palindromes). By expanding from each character, it identifies the longest palindrome.\n\n---\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n1. The `expandAroundCenter` function takes a string `s` and two indices `left` and `right`. It starts from the characters at these indices and expands outwards while checking if the characters are the same. When different characters are encountered, the function returns the substring between `left` and `right`, which is a palindrome.\n\n2. The `longestPalindrome` function initializes an empty string longest to keep track of the `longest` palindromic substring found.\n\n3. It iterates through the characters of the input string s. For each character, it calls `expandAroundCenter` twice, once assuming an odd-length palindrome (with the character as the center) and once assuming an even-length palindrome (with the character and the next character as the center).\n\n4. If the length of the palindrome found (either odd or even) is greater than the length of the `longest` palindrome found so far, it updates the `longest` substring.\n\n5. After iterating through all characters, it returns the longest palindromic substring found.\n\n---\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\nThe time complexity of this code is O(n^2), where \'n\' is the length of the input string \'s\'. This is because, in the worst case, for each of the \'n\' characters in \'s\', we may expand to both the left and the right, resulting in a quadratic time complexity.\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\nThe space complexity of this code is O(1) because it doesn\'t use any additional data structures that grow with the input size. The space is primarily used for the variables and temporary substrings, which don\'t depend on the input size.\n\n---\n\n# \uD83D\uDCA1If you have come this far, then i would like to request you to please upvote this solution\u2763\uFE0F\uD83D\uDCA1So that it could reach out to another one\uD83D\uDD25\uD83D\uDD25\n\n---\n\n```C++ []\n#include <iostream>\nusing namespace std;\n\nclass Solution {\npublic:\nstring expandAroundCenter(string s, int left, int right) {\n while (left >= 0 && right < s.length() && s[left] == s[right]) {\n left--;\n right++;\n }\n return s.substr(left + 1, right - left - 1);\n}\n\nstring longestPalindrome(string s) {\n string longest = "";\n for (int i = 0; i < s.length(); i++) {\n string odd = expandAroundCenter(s, i, i);\n string even = expandAroundCenter(s, i, i + 1);\n if (odd.length() > longest.length()) longest = odd;\n if (even.length() > longest.length()) longest = even;\n }\n return longest;\n}\n};\n```\n```Java []\npublic class Solution {\n public String expandAroundCenter(String s, int left, int right) {\n while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {\n left--;\n right++;\n }\n return s.substring(left + 1, right);\n }\n\n public String longestPalindrome(String s) {\n String longest = "";\n for (int i = 0; i < s.length(); i++) {\n String odd = expandAroundCenter(s, i, i);\n String even = expandAroundCenter(s, i, i + 1);\n if (odd.length() > longest.length()) {\n longest = odd;\n }\n if (even.length() > longest.length()) {\n longest = even;\n }\n }\n return longest;\n }\n\n public static void main(String[] args) {\n Solution solution = new Solution();\n String s = "babad";\n String result = solution.longestPalindrome(s);\n System.out.println("Longest Palindromic Substring: " + result);\n }\n}\n\n```\n```Python []\nclass Solution:\n def expandAroundCenter(self, s, left, right):\n while left >= 0 and right < len(s) and s[left] == s[right]:\n left -= 1\n right += 1\n return s[left + 1:right]\n\n def longestPalindrome(self, s):\n longest = ""\n for i in range(len(s)):\n odd = self.expandAroundCenter(s, i, i)\n even = self.expandAroundCenter(s, i, i + 1)\n if len(odd) > len(longest):\n longest = odd\n if len(even) > len(longest):\n longest = even\n return longest\n\nsolution = Solution()\ns = "babad"\nresult = solution.longestPalindrome(s)\nprint("Longest Palindromic Substring:", result)\n\n```\n```Javascript []\n/**\n * @param {string} s\n * @return {string}\n */\nvar longestPalindrome = function(s) {\n function expandAroundCenter(left, right) {\n while (left >= 0 && right < s.length && s[left] === s[right]) {\n left--;\n right++;\n }\n return s.substring(left + 1, right);\n }\n\n let longest = "";\n\n for (let i = 0; i < s.length; i++) {\n let odd = expandAroundCenter(i, i);\n let even = expandAroundCenter(i, i + 1);\n\n if (odd.length > longest.length) {\n longest = odd;\n }\n\n if (even.length > longest.length) {\n longest = even;\n }\n }\n\n return longest;\n};\n\n// Example usage\nconst s = "babad";\nconst result = longestPalindrome(s);\nconsole.log("Longest Palindromic Substring: " + result);\n\n```\n```Ruby []\n# @param {String} s\n# @return {String}\ndef longest_palindrome(s)\n def expand_around_center(s, left, right)\n while left >= 0 && right < s.length && s[left] == s[right]\n left -= 1\n right += 1\n end\n s[left + 1...right]\n end\n\n longest = ""\n\n (0...s.length).each do |i|\n odd = expand_around_center(s, i, i)\n even = expand_around_center(s, i, i + 1)\n\n if odd.length > longest.length\n longest = odd\n end\n\n if even.length > longest.length\n longest = even\n end\n end\n\n return longest\nend\n\n# Example usage\ns = "babad"\nresult = longest_palindrome(s)\nputs "Longest Palindromic Substring: #{result}"\n\n```\n```Typescript []\nfunction longestPalindrome(s: string): string {\n function expandAroundCenter(left: number, right: number): string {\n while (left >= 0 && right < s.length && s[left] === s[right]) {\n left--;\n right++;\n }\n return s.substring(left + 1, right);\n }\n\n let longest = "";\n\n for (let i = 0; i < s.length; i++) {\n let odd = expandAroundCenter(i, i);\n let even = expandAroundCenter(i, i + 1);\n\n if (odd.length > longest.length) {\n longest = odd;\n }\n\n if (even.length > longest.length) {\n longest = even;\n }\n }\n\n return longest;\n}\n\n// Example usage\nconst s = "babad";\nconst result = longestPalindrome(s);\nconsole.log("Longest Palindromic Substring: " + result);\n\n```

Longest Palindromic Substring

longest-palindromic-substring

Given a string s, return the longest palindromic substring in s.

String,Dynamic Programming

Medium

How can we reuse a previously computed palindrome to compute a larger palindrome? If “aba” is a palindrome, is “xabax” a palindrome? Similarly is “xabay” a palindrome? Complexity based hint: If we use brute-force and check whether for every start and end position a substring is a palindrome we have O(n^2) start - end pairs and O(n) palindromic checks. Can we reduce the time for palindromic checks to O(1) by reusing some previous computation.

![Screenshot 2023-10-26 095237.png]()\n\n# YouTube Video Explanation:\n[]()\n\n**\uD83D\uDD25 Please like, share, and subscribe to support our channel\'s mission of making complex concepts easy to understand.**\n\nSubscribe Link: \n\n*Subscribe Goal: 150 Subscribers*\n*Current Subscribers: 133*\n# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nThe problem requires us to find the longest palindromic substring within a given string. A simple approach is to check every possible substring within the given string and determine if it\'s a palindrome. However, this brute-force approach results in a time complexity of O(n^3), which is highly inefficient.\n\nA more efficient approach is to use dynamic programming, which allows us to optimize the solution to O(n^2). The key idea is to recognize that a palindrome reads the same backward as forward. Therefore, we can efficiently identify palindromes by expanding around a center. We start with a single character as a center and expand it in both directions, keeping track of the longest palindrome found.\n\n\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n1. Initialize two variables, maxLen and lo, to keep track of the maximum palindrome length and the starting index of the longest palindrome.\n2. Iterate through the characters of the input string.\n3. For each character, expand around the center, considering both odd and even-length palindromes.\n4. While expanding, check if the substring is a palindrome.\n5. If a longer palindrome is found, update maxLen and lo accordingly.\n6. After iterating through all characters, return the longest palindrome substring using the lo and maxLen variables.\n\n\n# Complexity\n- Time Complexity: O(n^2) - We expand around each character once, leading to a quadratic time complexity.\n- Space Complexity: O(1) - We use a constant amount of extra space.\n\nThis optimized solution efficiently finds the longest palindromic substring in a given string.\n\n# Code\n## Java\n```\nclass Solution {\n int maxLen = 0;\n int lo = 0;\n\n public String longestPalindrome(String s) {\n char[] input = s.toCharArray();\n if (s.length() < 2) {\n return s;\n }\n\n for (int i = 0; i < input.length; i++) {\n expandPalindrome(input, i, i);\n expandPalindrome(input, i, i + 1);\n }\n return s.substring(lo, lo + maxLen);\n }\n\n public void expandPalindrome(char[] s, int j, int k) {\n while (j >= 0 && k < s.length && s[j] == s[k]) {\n j--;\n k++;\n }\n if (maxLen < k - j - 1) {\n maxLen = k - j - 1;\n lo = j + 1;\n }\n }\n}\n\n```\n## C++\n```\nclass Solution {\npublic:\n string longestPalindrome(string s) {\n if (s.length() < 2) {\n return s;\n }\n \n int maxLen = 0;\n int lo = 0;\n std::string result = s;\n \n for (int i = 0; i < s.length(); i++) {\n expandPalindrome(s, i, i, maxLen, lo);\n expandPalindrome(s, i, i + 1, maxLen, lo);\n }\n \n return result.substr(lo, maxLen);\n }\n \n void expandPalindrome(const std::string& s, int j, int k, int& maxLen, int& lo) {\n while (j >= 0 && k < s.length() && s[j] == s[k]) {\n j--;\n k++;\n }\n if (maxLen < k - j - 1) {\n maxLen = k - j - 1;\n lo = j + 1;\n }\n }\n};\n```\n## JavaScript\n```\n/**\n * @param {string} s\n * @return {string}\n */\nvar longestPalindrome = function(s) {\n if (s.length < 2) {\n return s;\n }\n\n let maxLen = 0;\n let lo = 0;\n let result = s;\n\n const expandPalindrome = (j, k) => {\n while (j >= 0 && k < s.length && s[j] === s[k]) {\n j--;\n k++;\n }\n if (maxLen < k - j - 1) {\n maxLen = k - j - 1;\n lo = j + 1;\n }\n };\n\n for (let i = 0; i < s.length; i++) {\n expandPalindrome(i, i);\n expandPalindrome(i, i + 1);\n }\n\n return result.substring(lo, lo + maxLen);\n};\n```\n## Python3\n```\nclass Solution:\n def longestPalindrome(self, s: str) -> str:\n def expand(l,r):\n while l >=0 and r < len(s) and s[l] == s[r]:\n l -= 1\n r += 1\n return s[l+1:r]\n \n res = \'\'\n\n for i in range(len(s)):\n sub1 = expand(i,i)\n if len(sub1) > len(res):\n res = sub1\n sub2 = expand(i,i+1)\n if len(sub2) > len(res):\n res = sub2\n return res\n```\n---\n![upvote1.jpeg]()

Longest Palindromic Substring

longest-palindromic-substring

Given a string s, return the longest palindromic substring in s.

String,Dynamic Programming

Medium

How can we reuse a previously computed palindrome to compute a larger palindrome? If “aba” is a palindrome, is “xabax” a palindrome? Similarly is “xabay” a palindrome? Complexity based hint: If we use brute-force and check whether for every start and end position a substring is a palindrome we have O(n^2) start - end pairs and O(n) palindromic checks. Can we reduce the time for palindromic checks to O(1) by reusing some previous computation.

\n def longestPalindrome(self, s):\n res = ""\n for i in xrange(len(s)):\n # odd case, like "aba"\n tmp = self.helper(s, i, i)\n if len(tmp) > len(res):\n res = tmp\n # even case, like "abba"\n tmp = self.helper(s, i, i+1)\n if len(tmp) > len(res):\n res = tmp\n return res\n \n # get the longest palindrome, l, r are the middle indexes \n # from inner to outer\n def helper(self, s, l, r):\n while l >= 0 and r < len(s) and s[l] == s[r]:\n l -= 1; r += 1\n return s[l+1:r]

Zigzag Conversion

zigzag-conversion

The string "PAYPALISHIRING" is written in a zigzag pattern on a given number of rows like this: (you may want to display this pattern in a fixed font for better legibility) And then read line by line: "PAHNAPLSIIGYIR" Write the code that will take a string and make this conversion given a number of rows:

String

Medium

\n\nThe key to solving this problem is to understand that we assign characters to rows by <i>oscillating</i> between the top and bottom rows. In other words, if we traversed the string and looked at which row each character belonged to (let\u2019s say numRows is 3), the pattern would be 1 2 3 2 1 2 3 2 1.. so the first character goes in row 1, the second character goes in rows 2, the third character goes in row 3 - which is the bottom row - so now you go back up to row 2, then row 1.\n\nTo represent the rows, we\u2019ll use a 2D array named `rows`, where each inner list represents a row. We then use a variable called `index` that will oscillate between the top and bottom rows and assign characters to rows.\n\nWe\u2019ll control the direction that index moves by using a variable called `step`. `step` will either be 1 or -1, where a value of 1 means we need to increment the index (so move DOWN a row) and a value of -1 means we need to decrement the index (move UP a row). Whenever we reach either the first or last row, we\'ll switch the direction to move `index` in the opposite direction.\n\nA common mistake I see is creating a 1D list and initializing an empty string for each row. Then, instead of appending to a list, each character is added by using string concatenation. While this works, this is not O(n) because strings are immutable. In other words, string concatenation allocates new memory and copies over each character from both strings to create an entirely new string. That means that the string concatenation runs in O(n), so the overall algorithm runs in O(n²) time.\n\nInstead, by using lists (since lists are mutable), appending to a list runs in constant time - or more precisely, the amortized complexity of appending to a list is constant. So that allows everything inside the loop to run in constant time, so the algorithm now runs in O(n) time. \n\n# Code\n```\nclass Solution(object):\n def convert(self, s, numRows):\n if numRows == 1 or numRows >= len(s):\n return s\n \n rows = [[] for row in range(numRows)]\n index = 0\n step = -1\n for char in s:\n rows[index].append(char)\n if index == 0:\n step = 1\n elif index == numRows - 1:\n step = -1\n index += step\n\n for i in range(numRows):\n rows[i] = \'\'.join(rows[i])\n return \'\'.join(rows)\n```

Zigzag Conversion

zigzag-conversion

The string "PAYPALISHIRING" is written in a zigzag pattern on a given number of rows like this: (you may want to display this pattern in a fixed font for better legibility) And then read line by line: "PAHNAPLSIIGYIR" Write the code that will take a string and make this conversion given a number of rows:

String

Medium

![image]()\n\n\nThings become clear with the above image.\n\n# Intuition:\n1. Just look at the top row what is the difference b/w each char i.e A and I and I and Q = 8\n 5*2-2 == numberOf rows *2 - 2 (The corner elements are excluded).\nSimilarly for each row i.e B and J the diff is 8, C and K is 8\n2. The interesting part comes when the char in the diagnoal has to be added, but even this has a pattern\n\t\n\tThere will be no char in between for row 0 and row n.\n\tThere can be only one diagonal char and the diagonal diff is original diff -2 at each step or diff - (rowNumber*2);\n\n# Approach\n\n1. Create an empty StringBuilder which is our ans.\n2. Calculate the diff = numRows*2 -2;\n3. Iterate over 0 to rowNumber in a for loop \nThe first char will be row number or i (append to String)\n4. Write a while loop in the above for loop :\n5. The first char will be row number or i (append to String)\n6. Calculate the diagonalDiff if any and append to the String.\n7. Increase the index by diff and return ans.\n\n\n\n# If you find this useful\n![image]()\n\n```\nclass Solution {\n public String convert(String s, int numRows) {\n if (numRows == 1) {\n return s;\n }\n \n StringBuilder answer = new StringBuilder();\n int n = s.length();\n int diff = 2 * (numRows - 1);\n int diagonalDiff = diff;\n int secondIndex;\n int index;\n for (int i = 0; i < numRows; i++) {\n index = i;\n\n while (index < n) {\n answer.append(s.charAt(index));\n if (i != 0 && i != numRows - 1) {\n diagonalDiff = diff-2*i;\n secondIndex = index + diagonalDiff;\n \n if (secondIndex < n) {\n answer.append(s.charAt(secondIndex));\n }\n }\n index += diff;\n }\n }\n \n return answer.toString();\n }\n}\n```\n\n```\nclass Solution {\npublic:\n string convert(string s, int numRows) {\n if (numRows == 1) {\n return s;\n }\n \n stringstream answer;\n int n = s.length();\n int diff = 2 * (numRows - 1);\n int diagonalDiff = diff;\n int secondIndex;\n int index;\n for (int i = 0; i < numRows; i++) {\n index = i;\n\n while (index < n) {\n answer << s[index];\n if (i != 0 && i != numRows - 1) {\n diagonalDiff = diff-2*i;\n secondIndex = index + diagonalDiff;\n \n if (secondIndex < n) {\n answer << s[secondIndex];\n }\n }\n index += diff;\n }\n }\n \n return answer.str();\n }\n};\n\n```\n\n```\nclass Solution:\n def convert(self, s: str, numRows: int) -> str:\n if numRows == 1:\n return s\n answer = \'\'\n n = len(s)\n diff = 2 * (numRows - 1)\n diagonal_diff = diff\n second_index = 0\n index = 0\n for i in range(numRows):\n index = i\n while index < n:\n answer += s[index]\n if i != 0 and i != numRows - 1:\n diagonal_diff = diff - 2 * i\n second_index = index + diagonal_diff\n if second_index < n:\n answer += s[second_index]\n index += diff\n return answer\n```\n

Zigzag Conversion

zigzag-conversion

The string "PAYPALISHIRING" is written in a zigzag pattern on a given number of rows like this: (you may want to display this pattern in a fixed font for better legibility) And then read line by line: "PAHNAPLSIIGYIR" Write the code that will take a string and make this conversion given a number of rows:

String

Medium

class Solution(object):\n def convert(self, s, numRows):\n """\n :type s: str\n :type numRows: int\n :rtype: str\n """\n if numRows == 1 or numRows >= len(s):\n return s\n \n L = [''] * numRows\n index, step = 0, 1\n \n for x in s:\n L[index] += x\n if index == 0:\n step = 1\n elif index == numRows -1:\n step = -1\n index += step\n \n return ''.join(L)

Zigzag Conversion

zigzag-conversion

The string "PAYPALISHIRING" is written in a zigzag pattern on a given number of rows like this: (you may want to display this pattern in a fixed font for better legibility) And then read line by line: "PAHNAPLSIIGYIR" Write the code that will take a string and make this conversion given a number of rows:

String

Medium

# Intuition\nThink of it like bouncing a ball: it goes down, hits the floor, and bounces back up. This is like our zigzag pattern with the string.\n\n# Approach\n1. If we only have one row or more rows than letters, just give back the original word.\n2. I used a jump thing to know if I should go up or down. If I\'m at the top, I\'ll go down. If I\'m at the bottom, I\'ll go up.\n3. For each letter in the word, I put it in the right row and then decide if I should move up or down next.\n4. After placing all the letters, I put all the rows together for the final word.\n\n# Complexity\n- Time complexity:\nIt\'s pretty quick. It goes through the word once, so $$O(n)$$.\n\n- Space complexity:\nI saved space. I only made room for the letters in the word, so $$O(n)$$ space.\n\n# Code\n```\nclass Solution(object):\n def convert(self, s, numRows):\n """\n :type s: str\n :type numRows: int\n :rtype: str\n """\n if numRows == 1 or numRows >= len(s):\n return s\n result = [\'\'] * numRows\n row, jump = 0, 1\n\n for char in s:\n result[row] += char\n if row == 0:\n jump = 1\n elif row == numRows - 1:\n jump = -1\n row += jump\n \n return \'\'.join(result)\n```

Zigzag Conversion

zigzag-conversion

The string "PAYPALISHIRING" is written in a zigzag pattern on a given number of rows like this: (you may want to display this pattern in a fixed font for better legibility) And then read line by line: "PAHNAPLSIIGYIR" Write the code that will take a string and make this conversion given a number of rows:

String

Medium

\n# Intuition:\nThe problem asks to convert a given string into a zigzag pattern with a given number of rows, and then read the converted string row by row. One way to approach the problem is to simulate the process of converting the given string into the zigzag pattern by iterating over the string and filling each row in the pattern.\n\n# Approach:\nWe can use two nested loops, one for iterating over the rows, and one for iterating over the characters in each row. We can also use a variable to keep track of the length of each cycle, which is 2 * numRows - 2 in this case. In each iteration, we can add the character to the corresponding row in the pattern, and also add the corresponding character in the next cycle if it exists.\n\n- For each row, we need to skip characters for the first and last row, as there is no corresponding character in the next cycle.\n- For the rows in between, we need to add the corresponding character in the next cycle.\n- We can use a string variable to store the converted string, and return it at the end.\n# Complexity:\n\n- Time Complexity: O(n), where n is the length of the input string. We iterate over each character in the string once.\n- Space Complexity: O(n), where n is the length of the input string. We use a string variable to store the converted string, which takes O(n) space.\n\n# C++\n```\nclass Solution {\npublic:\n string convert(string s, int numRows) {\n if (numRows == 1) {\n return s;\n }\n string result;\n int n = s.length();\n int cycleLen = 2 * numRows - 2;\n for (int i = 0; i < numRows; i++) {\n for (int j = 0; j + i < n; j += cycleLen) {\n result += s[j + i];\n if (i != 0 && i != numRows - 1 && j + cycleLen - i < n) {\n result += s[j + cycleLen - i];\n }\n }\n }\n return result;\n } \n};\n```\n\n---\n# Java\n```\npublic class Solution {\n public String convert(String s, int numRows) {\n if (numRows == 1) {\n return s;\n }\n StringBuilder result = new StringBuilder();\n int n = s.length();\n int cycleLen = 2 * numRows - 2;\n for (int i = 0; i < numRows; i++) {\n for (int j = 0; j + i < n; j += cycleLen) {\n result.append(s.charAt(j + i));\n if (i != 0 && i != numRows - 1 && j + cycleLen - i < n) {\n result.append(s.charAt(j + cycleLen - i));\n }\n }\n }\n return result.toString();\n }\n}\n\n```\n\n---\n# Python\n```\nclass Solution(object):\n def convert(self, s, numRows):\n if numRows == 1:\n return s\n result = \'\'\n n = len(s)\n cycleLen = 2 * numRows - 2\n for i in range(numRows):\n for j in range(0, n - i, cycleLen):\n result += s[j + i]\n if i != 0 and i != numRows - 1 and j + cycleLen - i < n:\n result += s[j + cycleLen - i]\n return result\n\n```\n---\n# JavaScript\n```\nvar convert = function(s, numRows) {\n if (numRows === 1) {\n return s;\n }\n let result = \'\';\n const n = s.length;\n const cycleLen = 2 * numRows - 2;\n for (let i = 0; i < numRows; i++) {\n for (let j = 0; j + i < n; j += cycleLen) {\n result += s[j + i];\n if (i !== 0 && i !== numRows - 1 && j + cycleLen - i < n) {\n result += s[j + cycleLen - i];\n }\n }\n }\n return result;\n}\n```

Zigzag Conversion

zigzag-conversion

The string "PAYPALISHIRING" is written in a zigzag pattern on a given number of rows like this: (you may want to display this pattern in a fixed font for better legibility) And then read line by line: "PAHNAPLSIIGYIR" Write the code that will take a string and make this conversion given a number of rows:

String

Medium

In this question the most important thing is getting the pattern correct. It is very easy to go down the wrong path and spend 10 minutes trying to figure out how to make a complicated algorithm work when a very easy one would suffice.\n\n> Thinking process\n\n1. First I looked at the problem and thought about how the printed pattern looked like it would be mapped out on a matrix. I wrote out the number of "main" columns and then the number of "middle" columns\n ```\n P I N\n A L S I G\n Y A H R\n P I\n ------------------------\n 4 2 4 2 2(*)\n ``` \n The last line is 2 only because the word ends, but we can see that the pattern is `4-2-4-2-4-...`. When drawing it out for `numRows = 3`, the pattern became \n\n ```\n P A H N\n A P L S I I G\n Y I R\n ---------------------------------\n 3 1 3 1 3 1 2(*)\n ``` \n Again we can see the pattern is `3-1-3-1-3-...`\n\n So the pattern of "main" rows to "mid" rows is `n, n-2, n, n-2, ...`\n\n When I tried to build an algorithm for this pattern I got stuck. How would I make the index move up `n`, then down `n-2` without confusing myself or missing edge cases?\n2. Next I tried to write out the row of each letter in the string. For numRows = 4, it became:\n ```\n P A Y P A L I S H I R I N G\n -----------------------------------------\n 1 2 3 4 3 2 1 2 3 4 3 2 1 2\n ```\n For numRows = 3, it became:\n ```\n P A Y P A L I S H I R I N G\n -----------------------------------------\n 1 2 3 2 1 2 3 2 1 2 3 2 1 2\n ```\n\n This is where I found the correct pattern. Basically instead of worrying about "main" rows vs. "mid" rows, it easily maps into moving the index from 1 -> numRows, and then from numRows -> 1. We don\'t even need to think about a matrix and worrying about rows vs. columns.\n\n> Algorithm\n\nAt first I thought about how to make the different rows as strings. How would I make `row1`, `row2`, `row3`? Sure if there were only a few rows I could hardcode them, but then how would I be able to add the character to each row easily? It is too difficult, so I thought using an array would be much better. \n\nThen I thought how would we make sure that we are going up and down in the correct pattern? The easiest way was to use a `going_up` flag to make sure to switch the direction of the index.\n\nLastly the only thing to check was edge cases, which by this point was pretty easy with a simple run through of the algorithm.\n\n> Code:\n\n```py\nclass Solution:\n def convert(self, s: str, numRows: int) -> str:\n if numRows == 1:\n return s\n \n row_arr = [""] * numRows\n row_idx = 1\n going_up = True\n\n for ch in s:\n row_arr[row_idx-1] += ch\n if row_idx == numRows:\n going_up = False\n elif row_idx == 1:\n going_up = True\n \n if going_up:\n row_idx += 1\n else:\n row_idx -= 1\n \n return "".join(row_arr)\n```\n\n> Time & Space Complexity\n\nTime: `O(n)`\n- We run through the whole string once: `O(n)`\n - everything we do inside the for loop: `O(1)`\n- Finally we join the whole array int a string: `O(n)`\n\nSpace: `O(n)`\n- We are creating a new array: `O(n)`\n- We are using join to put it back into a string: `O(n)`

Zigzag Conversion

zigzag-conversion

The string "PAYPALISHIRING" is written in a zigzag pattern on a given number of rows like this: (you may want to display this pattern in a fixed font for better legibility) And then read line by line: "PAHNAPLSIIGYIR" Write the code that will take a string and make this conversion given a number of rows:

String

Medium

```\nclass Solution:\n def convert(self, s: str, numRows: int) -> str:\n template = list(range(numRows)) + list(range(numRows - 2, 0, -1))\n\n result = [\'\'] * numRows\n for i, char in enumerate(s):\n result[template[i % len(template)]] += char\n return \'\'.join(result)\n```\n![image]()

Zigzag Conversion

zigzag-conversion

The string "PAYPALISHIRING" is written in a zigzag pattern on a given number of rows like this: (you may want to display this pattern in a fixed font for better legibility) And then read line by line: "PAHNAPLSIIGYIR" Write the code that will take a string and make this conversion given a number of rows:

String

Medium

[]()

Zigzag Conversion

zigzag-conversion

The string "PAYPALISHIRING" is written in a zigzag pattern on a given number of rows like this: (you may want to display this pattern in a fixed font for better legibility) And then read line by line: "PAHNAPLSIIGYIR" Write the code that will take a string and make this conversion given a number of rows:

String

Medium

\uD83D\uDD34 Check out [LeetCode The Hard Way]() for more solution explanations and tutorials. \n\uD83D\uDFE0 Check out our [Discord Study Group]() for live discussion.\n\uD83D\uDFE2 Give a star on [Github Repository]() and upvote this post if you like it.\n\uD83D\uDD35 Check out [Screencast]() if you are interested.\n\n**Python**\n\n```py\n# simulate and add each character to the corresponding row\n# go down -> reach bottom -> go up -> reach top -> go down ...\nclass Solution:\n def convert(self, s: str, n: int) -> str:\n # edge case\n if n == 1: return s\n rows = [\'\' for _ in range(n)]\n # j is the index to track which rows a character should be added to\n # d is the direction: -1 means go up, 1 means go down\n j, d = 0, 1\n for i in range(len(s)):\n # add the current character to corresponding row\n rows[j] += s[i]\n # if it reaches to the last row, we need to go up\n if j == n - 1: d = -1\n # if it reaches to the first row, we need to go down\n elif j == 0: d = 1\n # move j pointer\n j += d;\n # rows would look like below in the first example\n # [\'PAHN\', \'APLSIIG\', \'YIR\']\n # we use join to build the final answer\n return \'\'.join(rows)\n```\n\n**C++ (Modified from Dev_1)**\n\n```cpp\n// simulate and add each character to the corresponding row\n// go down -> reach bottom -> go up -> reach top -> go down ...\nclass Solution {\npublic:\n string convert(string s, int n) {\n // edge case\n if (n == 1) return s;\n vector<string> rows(n);\n // j is the index to track which rows a character should be added to\n // d is the direction: -1 means go up, 1 means go down\n int j = 0, d = 1;\n for (int i = 0; i < s.size(); i++) {\n // add the current character to corresponding row\n rows[j] += s[i];\n // if it reaches to the last row, we need to go up\n if(j == n - 1) d = -1;\n // if it reaches to the first row, we need to go down\n else if(j == 0) d = 1;\n // move j pointer\n j += d;\n }\n // rows would look like below in the first example\n // [\'PAHN\', \'APLSIIG\', \'YIR\']\n // we use `accumulate` to build the final answer (in C++ 20, it takes O(n) only)\n return accumulate(rows.begin(), rows.end(), string{});\n }\n};\n```

Zigzag Conversion

zigzag-conversion

The string "PAYPALISHIRING" is written in a zigzag pattern on a given number of rows like this: (you may want to display this pattern in a fixed font for better legibility) And then read line by line: "PAHNAPLSIIGYIR" Write the code that will take a string and make this conversion given a number of rows:

String

Medium

**Explanation :**\n* As you can see in this picture we have to convert given string into a ZigZag form with the given row.\n* Starting index is always 0 so i have taken ```startIndex``` variable and initialize with zero.\n* And Created ```idx``` variable to get current index characher in ```ans``` string.\n* As you can observe in the given row the next index is always comes at ```idx += row + (row - 2)``` , so i used this formula. when ```startIndex = 0 or startIndex = row - 1``` then we don\'t need to take between character\'s.\n* and for when ```startIndex is between 1 and row-2``` we have to take between character\'s.\n* and you can observe there is a difference between middle character and next columns character is two and it by two always by row wise. So i have taken ```count``` variable to count their difference.\n* For the first time we have to always take columns characher an then middle character so for this condition i have used ```flag``` logic.\n* if our curret index ie. ```idx``` is reached out off index then i just increased ```startIndex``` by 1 and ```idx = startIndex``` and also increase ```count``` variable by 2\n\n\nI hope you understand my explanation.\nIf any Doubts or Suggestions Put in Comments..\n\nPlease **UpVote**, if it helps a little to you **:)**\n![image]()\n\n**Solution :**\n```\n def convert(self, s, row):\n n = len(s)\n if n <= row: #this is base contions if row is greater than the length of string. so just return string\n return s\n ans, startIndex, idx, flag, count = \'\', 0, 0, 0, 2\n for i in range(n):\n if startIndex == 0 or startIndex == row-1:\n ans += s[idx]\n idx += row + (row - 2)\n if i == n-1: break\n if idx > n - 1 or idx <= 0: #this another or condition is for when we have given two length string and row is 1 \n\t\t\t\t\t\t\t\t\t\t\t#then for the second time that idx value goes to -ve that\'s why it is written\n startIndex += 1\n idx = startIndex\n else:\n if flag == 0:\n ans += s[idx]\n flag = 1\n idx += row + (row - 2) - count\n else:\n ans += s[idx]\n idx += count\n flag = 0\n if idx > n-1 or idx <= 0:\n startIndex += 1\n idx, flag = startIndex, 0\n count += 2\n return ans\n```\n**UpVote :)**

Reverse Integer

reverse-integer

Given a signed 32-bit integer x, return x with its digits reversed. If reversing x causes the value to go outside the signed 32-bit integer range [-231, 231 - 1], then return 0. Assume the environment does not allow you to store 64-bit integers (signed or unsigned).

Math

Medium

\n\nStep 1: Extract the digit in the ones place of `x` by using the modulo operator and store it in `digit`\n\nStep 2: Add that digit to `reverse` as the rightmost digit\n\nStep 3: Remove the ones digit from `x` and continue until `x` equals 0.\n\nIn Python, the modulo operator works slightly differently than other languages (such as Java or C) when it comes to negative numbers. Basically, you will get weird results if you try to do [positive number] mod [negative number]. If you want the modulo to behave the same way with negative numbers as it does with positive numbers, but just have the result be negative, then you need to make sure the divisor is also negative, since the modulo operation will always return a number with the same sign as the divisor.\n\nLastly, I use `math.trunc` instead of just using floor division `//` because of negative numbers. When dividing `x` by 10 and truncating the decimal, if the number is negative, then it would round down <i>away</i> from zero, when really, we want it to round up <i>towards</i> zero.\n\n# Code\n```\nclass Solution:\n def reverse(self, x: int) -> int:\n MAX_INT = 2 ** 31 - 1 # 2,147,483,647\n MIN_INT = -2 ** 31 #-2,147,483,648\n reverse = 0\n\n while x != 0:\n if reverse > MAX_INT / 10 or reverse < MIN_INT / 10:\n return 0\n digit = x % 10 if x > 0 else x % -10\n reverse = reverse * 10 + digit\n x = math.trunc(x / 10)\n\n return reverse\n\n```

Reverse Integer

reverse-integer

Given a signed 32-bit integer x, return x with its digits reversed. If reversing x causes the value to go outside the signed 32-bit integer range [-231, 231 - 1], then return 0. Assume the environment does not allow you to store 64-bit integers (signed or unsigned).

Math

Medium

# Intuition:\nThe problem asks to reverse the digits of a given integer. The approach is to extract the digits one by one using modulo operator and then add them in reverse order.\n\n# Approach:\n\n1. Initialize a variable \'reverse\' to 0. This variable will hold the reversed integer.\n\n2. Initialize another variable \'num\' to the given integer. We will use \'num\' to avoid modifying the original input integer.\n\n3. While the \'num\' is not equal to 0, extract the rightmost digit of \'num\' using the modulo operator (%). Store this digit in a variable called \'digit\'.\n\n4. Multiply \'reverse\' by 10 and add the extracted digit \'digit\' to it.\n\n5. Divide \'num\' by 10 and update \'num\' with the quotient. This will remove the rightmost digit of \'num\' in each iteration.\n\n6. Repeat steps 3-5 until \'num\' becomes 0.\n\n7. Check if the reversed integer \'reverse\' is within the range of a 32-bit signed integer. If it is not, return 0.\n\n8. Return the reversed integer \'reverse\'.\n\n# Complexity:\n- Time Complexity: The time complexity of the solution is O(log(x)). We need to extract the digits of the integer one by one until there are no more digits left. This process continues until the integer becomes 0. The number of iterations required depends on the number of digits in the integer, which is proportional to log(x) with base 10.\n- Space Complexity: The space complexity of the solution is O(1). We are only using a constant amount of extra space to store the reversed integer and a few other variables.\n---\n# C++\n```cpp\nclass Solution {\npublic:\n int reverse(int x) {\n long reverse = 0;\n while(x!=0){\n int digit = x%10;\n reverse = reverse*10 + digit;\n x=x/10;\n }\n if(reverse>INT_MAX || reverse<INT_MIN) return 0;\n return reverse;\n }\n};\n```\n\n---\n# JAVA\n```java\nclass Solution {\n public int reverse(int x) {\n long reverse = 0;\n while (x != 0) {\n int digit = x % 10;\n reverse = reverse * 10 + digit;\n x = x / 10;\n }\n if (reverse > Integer.MAX_VALUE || reverse < Integer.MIN_VALUE) return 0;\n return (int) reverse;\n }\n}\n\n```\n---\n# Python\n```py\nclass Solution(object):\n def reverse(self, x):\n reverse = 0\n sign = -1 if x < 0 else 1\n x = abs(x)\n while x:\n digit = x % 10\n reverse = reverse * 10 + digit\n x /= 10\n result = sign * reverse\n if result > 2 ** 31 - 1 or result < -(2 ** 31):\n return 0\n return result\n\n```\n---\n# JavaScript\n```js\nvar reverse = function(x) {\n let rev = 0;\n const sign = x < 0 ? -1 : 1;\n x = Math.abs(x);\n while (x !== 0) {\n const digit = x % 10;\n rev = rev * 10 + digit;\n x = Math.floor(x / 10);\n }\n const result = sign * rev;\n if (result > 2 ** 31 - 1 || result < -(2 ** 31)) return 0;\n return result;\n}\n```

Reverse Integer

reverse-integer

Given a signed 32-bit integer x, return x with its digits reversed. If reversing x causes the value to go outside the signed 32-bit integer range [-231, 231 - 1], then return 0. Assume the environment does not allow you to store 64-bit integers (signed or unsigned).

Math

Medium

# Intuition\nEasy solution in python\n\n# Code\n```\nMIN=-2**31\nMAX=(2**31)-1\nclass Solution:\n def __init__(self):\n self.rev=0\n self.is_neg=False\n def reverse(self, x: int) -> int:\n if x < 0:\n self.is_neg=True\n x=abs(x)\n while(x!=0):\n digit=x%10\n x=x//10\n\n if self.rev > MAX//10 or (self.rev==MAX//10 and digit>MAX%10):\n return 0\n if self.rev<MIN//10 or (self.rev==MIN//10 and digit <MIN%10):\n return 0\n \n self.rev=10*self.rev+digit\n if self.is_neg:\n self.rev=-self.rev\n return self.rev\n \n```\n\n\n![upvote.jpg]()\n

String to Integer (atoi)

string-to-integer-atoi

Implement the myAtoi(string s) function, which converts a string to a 32-bit signed integer (similar to C/C++'s atoi function). The algorithm for myAtoi(string s) is as follows: Note:

String

Medium

A fast and (probably) **much simpler and easier to understand DFA solution** than the others when you search for the keyword `DFA`:\n\n```python\nclass Solution:\n def myAtoi(self, str: str) -> int:\n value, state, pos, sign = 0, 0, 0, 1\n\n if len(str) == 0:\n return 0\n\n while pos < len(str):\n current_char = str[pos]\n if state == 0:\n if current_char == " ":\n state = 0\n elif current_char == "+" or current_char == "-":\n state = 1\n sign = 1 if current_char == "+" else -1\n elif current_char.isdigit():\n state = 2\n value = value * 10 + int(current_char)\n else:\n return 0\n elif state == 1:\n if current_char.isdigit():\n state = 2\n value = value * 10 + int(current_char)\n else:\n return 0\n elif state == 2:\n if current_char.isdigit():\n state = 2\n value = value * 10 + int(current_char)\n else:\n break\n else:\n return 0\n pos += 1\n\n value = sign * value\n value = min(value, 2 ** 31 - 1)\n value = max(-(2 ** 31), value)\n\n return value\n```\n\nDFA, which stands for Deterministic finite automaton, is a state machine that either accepts or rejects a sequence of symbols by running through a state sequence uniquely determined by the string. The DFA I used to implement this answer is very simple:\n\n![image]()\n\n

String to Integer (atoi)

string-to-integer-atoi

Implement the myAtoi(string s) function, which converts a string to a 32-bit signed integer (similar to C/C++'s atoi function). The algorithm for myAtoi(string s) is as follows: Note:

String

Medium

```\nclass Solution:\n def myAtoi(self, s: str) -> int:\n if not s:\n return 0\n\n # remove leading and trailing whitespace\n s = s.strip()\n\n # save sign if one exists\n pos = True\n if s and s[0] == \'-\':\n pos = False\n s = s[1:]\n elif s and s[0] == \'+\':\n s = s[1:]\n \n # ignore leading zeros\n i = 0\n while i < len(s) and s[i] == \'0\':\n i += 1\n\n # apply relevant digits\n res = None\n while i < len(s) and s[i] in \'0123456789\':\n if res is None:\n res = int(s[i])\n else:\n res = (res * 10) + int(s[i])\n i += 1\n res = 0 if res is None else res\n\n # apply sign\n res = res if pos else -res\n\n # clip result\n res = max(res, -2**31)\n res = min(res, (2**31)-1)\n\n return res\n\n```

String to Integer (atoi)

string-to-integer-atoi

Implement the myAtoi(string s) function, which converts a string to a 32-bit signed integer (similar to C/C++'s atoi function). The algorithm for myAtoi(string s) is as follows: Note:

String

Medium

# Intuition\n*Paper and pen and try to figure out all the possible edge cases, The question was easy, but the question explanation was poor.No need to worry about the **least acceptance rate** that the question has.*\n\n# Approach\nThis code defines a class called Solution with a method named `myAtoi` which takes a string `s` as input and returns an integer as output. The method has some considerations which are mentioned in its docstring ***`(please do read)`***. The method performs the following steps:\n\n1. Define two constants `maxInt` and `minInt` as the maximum and minimum integer values that can be represented using 32 bits.\n\n2. Initialize the integer variables `result`, `startIdx`, and `sign` to 0, 0, and 1, respectively. \n\n3. Remove any leading whitespace characters from the input string `s` using the `lstrip()` method and store it in a variable called `cleanStr`. If `cleanStr` is an empty string, return `result`.\n\n4. Check if the first character of `cleanStr` at `startIdx` is either `"+"` or `"-"`. If it is `"-"`, set the `sign` variable to -1, otherwise, leave it as 1. If the first character is a sign, increment `startIdx` by 1.\n\n5. Iterate through the remaining characters in `cleanStr` starting at index `startIdx`. If a non-digit character is encountered, break the loop. If a digit is encountered, add it to the `result` variable by multiplying it by 10 and adding the integer value of the character.\n\n6. Check if the final result multiplied by `sign` is greater than `maxInt`. If it is, return `maxInt`. If it is less than or equal to `minInt`, return `minInt`.\n\n7. If the value is within the range of `maxInt` and `minInt`, return the value multiplied by `sign`.\n\n\n# Complexity\n- Time complexity:\nO(n)\n\n- Space complexity:\nO(1)\n\n`Time complexity`:\n- The method performs a single pass through the input string, which takes `O(n)` time, where `n` is the length of the input string.\n- The string operations such as `lstrip()` and `isdigit()` take constant time per character, so they don\'t affect the overall time complexity of the algorithm.\n- Therefore, the `time complexity` of the method is `O(n)`.\n\n`Space complexity`:\n- The method uses a constant amount of extra space to store integer variables and constants, so the `space complexity` is `O(1)`.\n- The additional space required by the method doesn\'t depend on the input size, so it is considered `constant`.\n\nTherefore, the overall `time complexity` is `O(n)` and the `space complexity` is `O(1)`.\n\n# Code\n```\nclass Solution:\n def myAtoi(self, s: str) -> int:\n """\n Considerations: \n 1. If there is a leading whitespace at start, remove it.\n 2. Check the sign and store it in a varible.\n 3. try adding the digits to the result.\n 4. witnessing anything other than a digit break the loop.\n\t 5. check the range and return accordingly.\n """\n\n maxInt, minInt = 2**31 - 1 , -2**31\n result, startIdx, sign = 0,0,1\n cleanStr = s.lstrip()\n \n if not cleanStr: return result\n\n if cleanStr[startIdx] in ("-", "+"):\n sign = -1 if cleanStr[startIdx] == "-" else 1 \n startIdx += 1\n \n for i in range(startIdx, len(cleanStr)):\n char = cleanStr[i]\n if not char.isdigit():\n break\n else:\n # read note at the end, if confusing\n result = (result * 10) + int(char)\n\n if result * sign > maxInt:\n return maxInt\n elif result * sign <= minInt:\n return minInt\n \n return result * sign\n\n"""\nNote: \nQ1. why int(char)?\nAns: The char will be x, where x is a digit in string format\n\nQ2. why result * 10?\nAns: We need to shift the current value of result\n to the left by one decimal place (i.e., multiply it by 10) \n and then add the integer value of the new digit to the result\n"""\n \n```

String to Integer (atoi)

string-to-integer-atoi

Implement the myAtoi(string s) function, which converts a string to a 32-bit signed integer (similar to C/C++'s atoi function). The algorithm for myAtoi(string s) is as follows: Note:

String

Medium

# Intuition:\nThe problem is to reverse an integer value. For example, if the input is 123, then the output should be 321. Similarly, if the input is -123, then the output should be -321.\n\n# Approach:\n1. Initialize a variable \'reverse\' to store the reversed number. Also, initialize a variable \'num\' to store the input number \'x\'.\n2. Use a while loop to iterate until the input number \'x\' becomes 0.\n3. Inside the loop, find the last digit of the input number \'x\' using the modulo operator and store it in a variable \'digit\'.\n4. Multiply the \'reverse\' variable by 10 and add the \'digit\' variable to it. This will reverse the number digit by digit.\n5. Divide the input number \'x\' by 10 and store the quotient back to \'x\'. This will remove the last digit of \'x\' in each iteration.\n6. Check if the \'reverse\' variable overflows the integer range or not. If it overflows, then return 0.\n7. Return the \'reverse\' variable as the output.\n\n# Complexity:\n- Time Complexity: O(log(x)), where x is the input number.\nIn each iteration, the input number is divided by 10, so the time complexity will be proportional to the number of digits in the input number, which is log(x).\n- Space Complexity: O(1)\nWe are not using any extra data structure to store the input or output, so the space complexity is constant.\n---\n# C++\n```\nclass Solution {\npublic:\n int myAtoi(string s) {\n int len = s.size();\n double num = 0;\n int i=0;\n while(s[i] == \' \'){\n i++;\n }\n bool positive = s[i] == \'+\';\n bool negative = s[i] == \'-\';\n positive == true ? i++ : i;\n negative == true ? i++ : i;\n while(i < len && s[i] >= \'0\' && s[i] <= \'9\'){\n num = num*10 + (s[i]-\'0\');\n i++;\n }\n num = negative ? -num : num;\n num = (num > INT_MAX) ? INT_MAX : num;\n num = (num < INT_MIN) ? INT_MIN : num;\n return int(num);\n }\n};\n```\n---\n# JAVA\n```\nclass Solution {\n public int myAtoi(String s) {\n int len = s.length();\n if (len == 0) {\n return 0; // Handle empty string case\n }\n double num = 0;\n int i = 0;\n while (i < len && s.charAt(i) == \' \') {\n i++;\n }\n if (i == len) {\n return 0; // All characters are whitespace\n }\n boolean positive = s.charAt(i) == \'+\';\n boolean negative = s.charAt(i) == \'-\';\n if (positive) {\n i++;\n }\n if (negative) {\n i++;\n }\n while (i < len && s.charAt(i) >= \'0\' && s.charAt(i) <= \'9\') {\n num = num * 10 + (s.charAt(i) - \'0\');\n i++;\n }\n num = negative ? -num : num;\n num = (num > Integer.MAX_VALUE) ? Integer.MAX_VALUE : num;\n num = (num < Integer.MIN_VALUE) ? Integer.MIN_VALUE : num;\n return (int) num;\n }\n}\n\n```\n---\n# Python\n```\nclass Solution(object):\n def myAtoi(self, s):\n s = s.strip() # Remove leading and trailing whitespace\n if not s:\n return 0 # Handle empty string case\n num = 0\n i = 0\n sign = 1 # 1 for positive, -1 for negative\n if s[i] == \'+\':\n i += 1\n elif s[i] == \'-\':\n i += 1\n sign = -1\n while i < len(s) and s[i].isdigit():\n num = num * 10 + int(s[i])\n i += 1\n num *= sign\n num = max(min(num, 2 ** 31 - 1), -2 ** 31) # Check for integer overflow\n return num\n\n\n```\n---\n# JavaScript\n```\nvar myAtoi = function(s) {\n s = s.trim(); // Remove leading and trailing whitespace\n if (s.length === 0) {\n return 0; // Handle empty string case\n }\n let num = 0;\n let i = 0;\n let sign = 1; // 1 for positive, -1 for negative\n if (s[i] === \'+\') {\n i++;\n } else if (s[i] === \'-\') {\n i++;\n sign = -1;\n }\n while (i < s.length && /^\\d$/.test(s[i])) {\n num = num * 10 + parseInt(s[i]);\n i++;\n }\n num *= sign;\n num = Math.max(Math.min(num, Math.pow(2, 31) - 1), -Math.pow(2, 31)); // Check for integer overflow\n return num;\n}\n\n```\n

String to Integer (atoi)

string-to-integer-atoi

Implement the myAtoi(string s) function, which converts a string to a 32-bit signed integer (similar to C/C++'s atoi function). The algorithm for myAtoi(string s) is as follows: Note:

String

Medium

**PLEASE UPVOTE if you like** \uD83D\uDE01 **If you have any question, feel free to ask.** \n\n* Some special cases that may help you understand the problem, **\'_\' means whitespace**\n\t* `____123`\n\t* `___-123`\n\t* `____+123`\n\t* `_____-+123`\n\t* `____+-123`\n\t* `abc123`\n\t* `00123`\n\t* `___123-`\n\t* `123abc`\n\t* `123 1234`\n\t* `-99999999999999999`\n\t* `00999999999999999`\n\t* `2147483648`\n\t* `-2147483648`\n\n```\nclass Solution(object):\n def myAtoi(self, s):\n MIN, MAX = -2 ** 31, 2 ** 31 - 1\n n, empty, sign = 0, True, 1 # empty denotes we have not seen any number, sign is -1 or 1\n for c in s:\n if empty:\n if c == \' \': continue # ignore the leading whitespace\n elif c == \'-\': sign = -1 # final answer is a negative number\n elif c.isdigit(): n = int(c) # the first digit of number\n elif c != \'+\': return 0 # the first char is not a digit and not in (\' \', \'+\', \'-\'), so s is invalid\n empty = False # the first char is a digit or \'+\' or \'-\', valid number starts\n else:\n if c.isdigit():\n n = n * 10 + int(c)\n if sign * n > MAX: return MAX\n elif sign * n < MIN: return MIN\n else: break # end of valid number\n return sign * n # sign is 1 or -1 \n```\n\n**PLEASE UPVOTE if you like** \uD83D\uDE01 **If you have any question, feel free to ask.** \n

String to Integer (atoi)

string-to-integer-atoi

Implement the myAtoi(string s) function, which converts a string to a 32-bit signed integer (similar to C/C++'s atoi function). The algorithm for myAtoi(string s) is as follows: Note:

String

Medium

```\nclass Solution:\n def myAtoi(self, s: str) -> int:\n su,num,flag = 1,0,0\n s = s.strip()\n if len(s) == 0: return 0\n if s[0] == "-":\n su = -1\n for i in s:\n if i.isdigit():\n num = num*10 + int(i)\n flag = 1\n elif (i == "+" or i == "-") and (flag == 0):\n flag = 1\n pass\n else: break\n num = num*su\n if (-2**31<=num<=(2**31)-1): return num\n if num<0: return -2**31\n else: return 2**31-1

String to Integer (atoi)

string-to-integer-atoi

Implement the myAtoi(string s) function, which converts a string to a 32-bit signed integer (similar to C/C++'s atoi function). The algorithm for myAtoi(string s) is as follows: Note:

String

Medium

\n def myAtoi(self, s: str) -> int:\n # ^ matches beginging of string \n # \\s* any nunber of whitspaces (zero or more)\n # [+-] either a + or -\n # [+-]? zero or one of either +/-\n # \\d a digit \n # \\d + one or more digit\n # the the pattern inside () is a group where you can access \n\n REGEX = r\'^\\s*([-+]?\\d+)\'\n MAX = 2147483647\n MIN = -2147483648\n\n if not re.search(REGEX, s):\n return 0\n num = int(re.findall(REGEX, s)[0]) # first_match\n return min(MAX, max(num, MIN))\n \n

String to Integer (atoi)

string-to-integer-atoi

Implement the myAtoi(string s) function, which converts a string to a 32-bit signed integer (similar to C/C++'s atoi function). The algorithm for myAtoi(string s) is as follows: Note:

String

Medium

class Solution(object):\n def myAtoi(self, s):\n """\n :type str: str\n :rtype: int\n """\n ###better to do strip before sanity check (although 8ms slower):\n #ls = list(s.strip())\n #if len(ls) == 0 : return 0\n if len(s) == 0 : return 0\n ls = list(s.strip())\n \n sign = -1 if ls[0] == '-' else 1\n if ls[0] in ['-','+'] : del ls[0]\n ret, i = 0, 0\n while i < len(ls) and ls[i].isdigit() :\n ret = ret*10 + ord(ls[i]) - ord('0')\n i += 1\n return max(-2**31, min(sign * ret,2**31-1))

Palindrome Number

palindrome-number

Given an integer x, return true if x is palindrome integer. An integer is a palindrome when it reads the same backward as forward.

Math

Easy

Beware of overflow when you reverse the integer.

# Intuition:\nThe intuition behind this code is to reverse the entire input number and check if the reversed number is equal to the original number. If they are the same, then the number is a palindrome.\n\n# Approach 1: Reversing the Entire Number\n# Explanation:\n1. We begin by performing an initial check. If the input number `x` is negative, it cannot be a palindrome since palindromes are typically defined for positive numbers. In such cases, we immediately return `false`.\n\n2. We initialize two variables:\n - `reversed`: This variable will store the reversed value of the number `x`.\n - `temp`: This variable is a temporary placeholder to manipulate the input number without modifying the original value.\n\n3. We enter a loop that continues until `temp` becomes zero:\n - Inside the loop, we extract the last digit of `temp` using the modulo operator `%` and store it in the `digit` variable.\n - To reverse the number, we multiply the current value of `reversed` by 10 and add the extracted `digit`.\n - We then divide `temp` by 10 to remove the last digit and move on to the next iteration.\n\n4. Once the loop is completed, we have reversed the entire number. Now, we compare the reversed value `reversed` with the original input value `x`.\n - If they are equal, it means the number is a palindrome, so we return `true`.\n - If they are not equal, it means the number is not a palindrome, so we return `false`.\n\nThe code uses a `long long` data type for the `reversed` variable to handle potential overflow in case of large input numbers.\n\n# Code\n\n```C++ []\nclass Solution {\npublic:\n bool isPalindrome(int x) {\n if (x < 0) {\n return false;\n }\n\n long long reversed = 0;\n long long temp = x;\n\n while (temp != 0) {\n int digit = temp % 10;\n reversed = reversed * 10 + digit;\n temp /= 10;\n }\n\n return (reversed == x);\n }\n};\n\n```\n```Java []\nclass Solution {\n public boolean isPalindrome(int x) {\n if (x < 0) {\n return false;\n }\n\n long reversed = 0;\n long temp = x;\n\n while (temp != 0) {\n int digit = (int) (temp % 10);\n reversed = reversed * 10 + digit;\n temp /= 10;\n }\n\n return (reversed == x);\n }\n}\n\n```\n```Python3 []\nclass Solution:\n def isPalindrome(self, x: int) -> bool:\n if x < 0:\n return False\n\n reversed_num = 0\n temp = x\n\n while temp != 0:\n digit = temp % 10\n reversed_num = reversed_num * 10 + digit\n temp //= 10\n\n return reversed_num == x\n\n```\n\n# Approach 2: Reversing Half of the Number\nInstead of reversing the entire number, we can reverse only the last half of the number. This approach is tricky because when we reverse the last half of the number, we don\'t want the middle digit to be reversed back to its original value. This can happen if the number has an odd number of digits. To resolve this, we can compare the first half of the number with the reversed second half of the number.\n# Explanation:\n1. We begin with an initial check to handle special cases:\n - If the input number `x` is negative, it cannot be a palindrome since palindromes are typically defined for positive numbers. In such cases, we immediately return `false`.\n - If `x` is non-zero and ends with a zero, it cannot be a palindrome because leading zeros are not allowed in palindromes. We return `false` for such cases.\n\n2. We initialize two variables:\n - `reversed`: This variable will store the reversed second half of the digits of the number.\n - `temp`: This variable is a temporary placeholder to manipulate the input number without modifying the original value.\n\n3. We enter a loop that continues until the first half of the digits (`x`) becomes less than or equal to the reversed second half (`reversed`):\n - Inside the loop, we extract the last digit of `x` using the modulo operator `%` and add it to the `reversed` variable after multiplying it by 10 (shifting the existing digits to the left).\n - We then divide `x` by 10 to remove the last digit and move towards the center of the number.\n\n4. Once the loop is completed, we have reversed the second half of the digits. Now, we compare the first half of the digits (`x`) with the reversed second half (`reversed`) to determine if the number is a palindrome:\n - For an even number of digits, if `x` is equal to `reversed`, then the number is a palindrome. We return `true`.\n - For an odd number of digits, if `x` is equal to `reversed / 10` (ignoring the middle digit), then the number is a palindrome. We return `true`.\n - If none of the above conditions are met, it means the number is not a palindrome, so we return `false`.\n\nThe code avoids the need for reversing the entire number by comparing only the necessary parts. This approach reduces both time complexity and memory usage, resulting in a more efficient solution.\n\n# Code\n\n```C++ []\nclass Solution {\npublic:\n bool isPalindrome(int x) {\n if (x < 0 || (x != 0 && x % 10 == 0)) {\n return false;\n }\n\n int reversed = 0;\n while (x > reversed) {\n reversed = reversed * 10 + x % 10;\n x /= 10;\n }\n return (x == reversed) || (x == reversed / 10);\n }\n};\n```\n```Java []\nclass Solution {\n public boolean isPalindrome(int x) {\n if (x < 0 || (x != 0 && x % 10 == 0)) {\n return false;\n }\n\n int reversed = 0;\n int original = x;\n\n while (x > reversed) {\n reversed = reversed * 10 + x % 10;\n x /= 10;\n }\n\n return (x == reversed) || (x == reversed / 10);\n }\n}\n```\n```Python3 []\nclass Solution:\n def isPalindrome(self, x: int) -> bool:\n if x < 0 or (x != 0 and x % 10 == 0):\n return False\n\n reversed_num = 0\n original = x\n\n while x > reversed_num:\n reversed_num = reversed_num * 10 + x % 10\n x //= 10\n\n return x == reversed_num or x == reversed_num // 10\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\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\n

Palindrome Number

palindrome-number

Given an integer x, return true if x is palindrome integer. An integer is a palindrome when it reads the same backward as forward.

Math

Easy

Beware of overflow when you reverse the integer.

**Note:**\n\n**`Check only half of the digits of given number to prevent OVERFLOW`**\n\n# Complexity\n- Time complexity: $$O(n/2)$$\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# JAVA :-\n -- | Details | --\n--- | --- | ---:\n**Runtime** | **9** *ms* | *Beats* **98%**\n**Memory** | **40** *MB* | *Beats* **67%**\n```\nclass Solution {\n public boolean isPalindrome(int x) {\n if(x<0 || x!=0 && x%10 ==0 ) return false;\n int check=0;\n while(x>check){\n check = check*10 + x%10;\n x/=10;\n }\n return (x==check || x==check/10);\n }\n}\n````\n# C :-\n -- | Details | --\n--- | --- | ---:\n**Runtime** | **15** *ms* | *Beats* **80%**\n**Memory** | **6** *MB* | *Beats* **93%**\n```\nbool isPalindrome(int x){\n if(x<0 || x!=0 && x%10 ==0 ) return false;\n int check=0;\n while(x>check){\n check = check*10 + x%10;\n x/=10;\n }\n return (x==check || x==check/10);\n}\n```\n```\n ** Use similar Math in PYTHON / C++ **\n```\n## UPVOTE : |\n![waiting-tom-and-jerry.gif]()\n

Palindrome Number

palindrome-number

Given an integer x, return true if x is palindrome integer. An integer is a palindrome when it reads the same backward as forward.

Math

Easy

Beware of overflow when you reverse the integer.

\n\nThe idea here is that we don\'t need to reverse all the digits, only <i>half</i> the digits. The first line checks some edge cases, and returns False immediately if the number is negative or ends with a 0 (with the exception of the number 0 itself). The loop then uses the modulo and floor division operators to reverse the digits and transfer them to the `half` variable.\n\nOnce the halfway point is reached, we return True if the two halves are equal to each other. If the number originally had an <i>odd</i> number of digits, then the two halves will be off by 1 digit, so we also remove that digit using floor division, then compare for equality.\n# Code\n```\nclass Solution(object):\n def isPalindrome(self, x):\n if x < 0 or (x != 0 and x % 10 == 0):\n return False\n\n half = 0\n while x > half:\n half = (half * 10) + (x % 10)\n x = x // 10\n\n return x == half or x == half // 10\n```\n\n# Alternate solution\n```\nclass Solution(object):\n def isPalindrome(self, x):\n x = str(x)\n return x == x[::-1]\n```\nAlternate solution: turn the number into a string, reverse it, and see if they\'re equal. This is the simplest solution, but the question does challenge us to solve it <i>without</i> turning the number into a string.\n

Palindrome Number

palindrome-number

Given an integer x, return true if x is palindrome integer. An integer is a palindrome when it reads the same backward as forward.

Math

Easy

Beware of overflow when you reverse the integer.

**Suggestions to make them better are always welcomed.**\n\n**Solution 1: 89.20% faster**\nThis is the easiest way to check if integer is palindrome. \n\nConvert the number to string and compare it with the reversed string.\n\nI wrote this working solution first and then found in the description that we need to solve this problem without converting the input to string. Then I wrote solution 2.\n```\ndef isPalindrome(self, x: int) -> bool:\n\tif x < 0:\n\t\treturn False\n\t\n\treturn str(x) == str(x)[::-1]\n```\n\nIf we don\'t want to convert the number to string, then recreate a new number in reverse order.\n```\ndef isPalindrome(self, x: int) -> bool:\n\tif x<0:\n\t\treturn False\n\n\tinputNum = x\n\tnewNum = 0\n\twhile x>0:\n\t\tnewNum = newNum * 10 + x%10\n\t\tx = x//10\n\treturn newNum == inputNum\n```\n\n**Solution 2: 99.14% faster.**\nI\'d recommend you to solve leetcode question 7 (reverse integer) to understand the logic behind this solution.\n\nPython3 int type has no lower or upper bounds. But if there are constraints given then we have to make sure that while reversing the integer we don\'t cross those constraints.\n\nSo, instead of reversing the whole integer, let\'s convert half of the integer and then check if it\'s palindrome.\nBut we don\'t know when is that half going to come. \n\nExample, if x = 15951, then let\'s create reverse of x in loop. Initially, x = 15951, revX = 0\n1. x = 1595, revX = 1\n2. x = 159, revX = 15\n3. x = 15, revX = 159\n\nWe see that revX > x after 3 loops and we crossed the half way in the integer bcoz it\'s an odd length integer.\nIf it\'s an even length integer, our loop stops exactly in the middle.\n\nNow we can compare x and revX, if even length, or x and revX//10 if odd length and return True if they match.\n\nThere\'s a difference between / and // division in Python3. Read it here on [stackoverflow]().\n```\ndef isPalindrome(self, x: int) -> bool:\n\tif x < 0 or (x > 0 and x%10 == 0): # if x is negative, return False. if x is positive and last digit is 0, that also cannot form a palindrome, return False.\n\t\treturn False\n\t\n\tresult = 0\n\twhile x > result:\n\t\tresult = result * 10 + x % 10\n\t\tx = x // 10\n\t\t\n\treturn True if (x == result or x == result // 10) else False\n```\n\n **If you like the solutions, please upvote it for better reach to other people.**

Palindrome Number

palindrome-number

Given an integer x, return true if x is palindrome integer. An integer is a palindrome when it reads the same backward as forward.

Math

Easy

Beware of overflow when you reverse the integer.

# 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$$O(N)$$\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n$$O(N)$$\n# Code\n```\nclass Solution(object):\n def isPalindrome(self, x):\n """\n :type x: int\n :rtype: bool\n """\n if x < 0:\n return False\n lis = []\n while x >= 10:\n lis.append(x % 10)\n x //= 10\n lis.append(x)\n for i in range(int(math.ceil(len(lis)/2))):\n if lis[i] != lis[len(lis)-i-1]:\n return False\n return True\n\n```

Palindrome Number

palindrome-number

Given an integer x, return true if x is palindrome integer. An integer is a palindrome when it reads the same backward as forward.

Math

Easy

Beware of overflow when you reverse the integer.

# Problem Description\n**Given** an integer x, return **true** if x is a **palindrome**, and **false** otherwise.\n\n**Palindrome** is a **word**, **phrase**, **number**, or **other sequence of characters** that **reads** the **same** **forward** and **backward**. In simpler terms, it\'s something that `remains unchanged when its order is reversed`.\n\n- Here are a few **examples** of palindromes:\n - Words :"racecar", "madam"\n - Numbers: 121, 1331, 12321\n\n- **Constraints:**\n - `-2e31 <= x <= 2e31 - 1`\n\n---\n# Intuition\n## First Approach (Convert to String)\nThe **first** approach is to **convert our number into a string** and there we can **access** any digit **freely** unlike the integer that we can\'t do that there.\nthen we can make a **mirror** around the middle of the string and **compare** the first char with last char, the second with the one before last and so on.\nif there is a **difference** then return false otherwise return true. \n\n![image.png]()\n\n![image.png]()\n\n\n## Second Approach (Extract Digits using %)\n\n**Modulo operation** is is a mathematical operation that returns the remainder when one number is divided by another.\n- 7 % 3 = 1\n- 9 % 5 = 4\n\nModulo operation is very helpful in our problem since it helps us to **extract the least digit in our number**.\nThe solution is **extract** the digit from the original number then **put it as least digit** in our new reversed number then **delete** that digit by dividing by 10.\n\n**Example : 121**\n```\nnumber = 121 , reversed = 0 \ndigit = 121 % 10 = 1 \nreversed = 0 * 10 + 1 = 1\nnumber = 121 / 10 = 12\n```\n```\nnumber = 12 , reversed = 1 \ndigit = 12 % 10 = 2 \nreversed = 1 * 10 + 2 = 2\nnumber = 12 / 10 = 1\n```\n```\nnumber = 1 , reversed = 12\ndigit = 1 % 10 = 1 \nreversed = 12 * 10 + 1 = 121\nnumber = 1 / 10 = 0\n```\nWe can see that reversed number **equal** to original number which means it is palindrome.\n\n\n---\n\n\n# Approach\n## First Approach (Convert to String)\n- **Convert** the integer x to a string representation.\n- Determine the **length** of the string.\n- Set up a for **loop** that iterates from the beginning of the string (index 0) to halfway through the string (length / 2).\n- Inside the loop, **compare** the character at the **current** position (number[i]) with the character at the **corresponding** position from the end of the string (number[length - i - 1]).\n- If the characters **do not match** (i.e., the number is not palindrome from the center outward), return **false** immediately, indicating that it\'s not a palindrome.\n- If the **loop** **completes** without finding any mismatches (all digits match), return **true**, indicating that the integer is a palindrome.\n\n# Complexity\n- **Time complexity:**$$O(N)$$\nSince we are iterating over all the digits.\n- **Space complexity:**$$O(N)$$\nSince we are storing the number as a string where `N` here is the number of the digits.\n---\n## Second Approach (Extract Digits using %)\n- Create **two long variables**, number and reversed, both initially set to the value of the input integer x. The number variable stores the **original** number, and reversed will store the **number in reverse order**.\n- Enter a while **loop** that continues as long as the value of x is greater than 0.\n- Inside the **loop**:\n - Calculate the **last digit of x** by taking the remainder of x when divided by 10 **(x % 10)**. This digit is stored in the digit variable.\n - **Update the reversed variable** by multiplying it by 10 (shifting digits left) and then adding the digit to it. This effectively builds the reversed number digit by digit.\n - **Remove the last digit** from x by dividing it by 10 (x /= 10).\n- After the loop completes, all digits of x have been processed and reversed in reversed.\n- Check if the number (the original input) is **equal** to the reversed (the reversed input). If they are equal, return **true**, indicating that the integer is a palindrome. If they are not equal, return **false**.\n\n# Complexity\n- **Time complexity:**$$O(N)$$\nSince we are iterating over all the digits.\n- **Space complexity:**$$O(1)$$\nWe only store two additional variables.\n\n# Code\n## First Approach (Convert to String)\n```C++ []\nclass Solution {\npublic:\n bool isPalindrome(int x) {\n string number = to_string(x) ;\n int length = number.size() ;\n for(int i = 0 ; i < length / 2 ; i ++){\n if(number[i] != number[length - i - 1])\n return false ;\n }\n return true;\n }\n};\n```\n```Java []\nclass Solution {\n public boolean isPalindrome(int x) {\n String number = Integer.toString(x);\n int length = number.length();\n for (int i = 0; i < length / 2; i++) {\n if (number.charAt(i) != number.charAt(length - i - 1)) {\n return false;\n }\n }\n return true;\n }\n}\n```\n```Python []\nclass Solution:\n def isPalindrome(self, x: int) -> bool:\n number = str(x)\n length = len(number)\n \n for i in range(length // 2):\n if number[i] != number[length - i - 1]:\n return False\n \n return True\n```\n## Second Approach (Extract Digits using %)\n```C++ []\nclass Solution {\npublic:\n bool isPalindrome(int x) {\n long long number = x, reversed = 0;\n while(x > 0){\n int digit = x % 10 ;\n reversed = (reversed * 10) + digit ; \n x /= 10 ;\n }\n return number == reversed ;\n }\n};\n```\n```Java []\nclass Solution {\n public boolean isPalindrome(int x) {\n long number = x;\n long reversed = 0;\n \n while (x > 0) {\n int digit = x % 10;\n reversed = (reversed * 10) + digit;\n x /= 10;\n }\n return number == reversed;\n }\n}\n```\n```Python []\nclass Solution:\n def isPalindrome(self, x: int) -> bool:\n number = x\n reversed_num = 0\n \n while x > 0:\n digit = x % 10\n reversed_num = (reversed_num * 10) + digit\n x //= 10\n \n return number == reversed_num\n```\n\n![HelpfulJerry.jpg]()\n\n\n\n

Palindrome Number

palindrome-number

Given an integer x, return true if x is palindrome integer. An integer is a palindrome when it reads the same backward as forward.

Math

Easy

Beware of overflow when you reverse the integer.

# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nIntution is to check whether the given integer is a palindrome\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\nwhat i have done here is convert the integer into list and using slicing notation reverse matched\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\no(n) is the time complexity of this code\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\nspace complexity of this code is also o(n)\n# Code\n```\nclass Solution:\n def isPalindrome(self, x: int) -> bool:\n return True if list(str(x))==list(str(x))[::-1] else False\n \n```

Palindrome Number

palindrome-number

Given an integer x, return true if x is palindrome integer. An integer is a palindrome when it reads the same backward as forward.

Math

Easy

Beware of overflow when you reverse the integer.

# 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:O(n)\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:O(n)\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\nclass Solution(object):\n def isPalindrome(self, x):\n if x<0:\n return False\n\n empty = []\n\n while x > 0:\n x, remd = divmod(x, 10)\n empty.append(remd)\n\n a=empty[::-1]\n if a==empty:\n return True\n \n else:\n return False\n```

Palindrome Number

palindrome-number

Given an integer x, return true if x is palindrome integer. An integer is a palindrome when it reads the same backward as forward.

Math

Easy

Beware of overflow when you reverse the integer.

# Brute Force Solution:\n\n### Intuition: \nConvert the integer to a string and check if the string is equal to its reverse.\n\n### Approach:\n1. Convert the integer to a string using to_string() method.\n2. Reverse the string using the reverse() method.\n3. Compare the original and reversed strings to check if they are equal.\n4. If they are equal, return true. Otherwise, return false.\n\n## Time Complexity:\nO(n), where n is the number of digits in the integer.\n## Space Complexity: \nO(n), where n is the number of digits in the integer.\n\n---\n\n\n# Optimized Solution:\n\n### Intuition: \nCheck half of the digits of the integer by extracting the last digit of the integer and adding it to a new integer.\n\n### Approach:\n1. Check if the integer is negative or ends with a zero. If it is, return false.\n2. Initialize a new integer half to 0.\n3. While the original integer x is greater than half, extract the last digit of x and add it to half by multiplying half by 10 and adding the last digit of x.\n4. If the length of x is odd, we need to remove the middle digit from half. To do this, we can simply divide half by 10.\n5. Check if x is equal to half or half divided by 10.\n6. If they are equal, return true. Otherwise, return false.\n\n### Time Complexity: \nO(log n), where n is the value of the integer.\n### Space Complexity: \nO(1), as we only need to store two integers, x and half.\n\n---\n# C++\n### Brute Force\n```\nclass Solution {\npublic:\n bool isPalindrome(int x) {\n string s = to_string(x);\n string t = s;\n reverse(t.begin(), t.end());\n return s == t;\n }\n};\n```\n### Optimized\n```\nclass Solution {\npublic:\n bool isPalindrome(int x) {\n if (x < 0 || (x != 0 && x % 10 == 0)) {\n return false;\n }\n int half = 0;\n while (x > half) {\n half = half * 10 + x % 10;\n x /= 10;\n }\n return x == half || x == half / 10;\n }\n};\n\n```\n\n---\n# JAVA\n### Brute Force\n```\nclass Solution {\n public boolean isPalindrome(int x) {\n String s = Integer.toString(x);\n String t = new StringBuilder(s).reverse().toString();\n return s.equals(t);\n }\n}\n```\n### Optimized\n```\nclass Solution {\n public boolean isPalindrome(int x) {\n if (x < 0 || (x != 0 && x % 10 == 0)) {\n return false;\n }\n int half = 0;\n while (x > half) {\n half = half * 10 + x % 10;\n x /= 10;\n }\n return x == half || x == half / 10;\n }\n}\n\n```\n---\n# Python\n### Brute Force\n```\nclass Solution(object):\n def isPalindrome(self, x):\n s = str(x)\n t = s[::-1]\n return s == t\n```\n### Optimized\n```\nclass Solution(object):\n def isPalindrome(self, x):\n if x < 0 or (x != 0 and x % 10 == 0):\n return False\n half = 0\n while x > half:\n half = half * 10 + x % 10\n x //= 10\n return x == half or x == half // 10\n```\n\n---\n# JavaScript\n### Brute Force\n```\nvar isPalindrome = function(x) {\n var s = x.toString();\n var t = s.split("").reverse().join("");\n return s === t;\n};\n```\n### Optimized\n```\nvar isPalindrome = function(x) {\n if (x < 0 || (x !== 0 && x % 10 === 0)) {\n return false;\n }\n var half = 0;\n while (x > half) {\n half = half * 10 + x % 10;\n x = Math.floor(x / 10);\n }\n return x === half || x === Math.floor(half / 10);\n};\n```

Palindrome Number

palindrome-number

Given an integer x, return true if x is palindrome integer. An integer is a palindrome when it reads the same backward as forward.

Math

Easy

Beware of overflow when you reverse the integer.

# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nThe hint was not to use convertation x to string , so I used tricks of division. \n\n# Approach\nWe start from the latest digit of initial number and build reverted number. Then check is real number equals to reverted and returns the result. \n\n# Complexity\n- Time complexity: O(n) \n*where n is length of x , we just go through all numbers of initial x \n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\nclass Solution(object):\n def isPalindrome(self, x):\n if x < 0:\n return False\n reversed_number = 0\n number = x\n while x > 0:\n digit = x % 10\n x = x // 10\n reversed_number = reversed_number * 10 + digit\n\n return number == reversed_number\n```

Palindrome Number

palindrome-number

Given an integer x, return true if x is palindrome integer. An integer is a palindrome when it reads the same backward as forward.

Math

Easy

Beware of overflow when you reverse the integer.

# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nTo check if an integer is a palindrome, we reverse the integer and compare it with the original number. If they are the same, the number is a palindrome. However, we need to handle some special cases like negative numbers and numbers ending with zero.\n\n---\n# Do upvote if you like the solution and explanation \uD83D\uDCA1\uD83D\uDE04\n\n---\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n1. If the input number x is negative or ends with a zero (except when x is 0 itself), it cannot be a palindrome. In such cases, we return false.\n\n2. We initialize a variable reversed to 0. We use a while loop to reverse the second half of the integer x. In each iteration of the loop:\n\n3. Multiply reversed by 10 to shift its digits to the left.\nAdd the last digit of x to reversed (obtained using x % 10).\nDivide x by 10 to remove the last digit.\n- After the loop, we check if x is equal to reversed or if x is equal to reversed / 10. This step handles both even and odd-length palindromes. If the condition is true, we return true, indicating that x is a palindrome; otherwise, we return false.\n\n---\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\nThe time complexity of this code is O(log10(x)), where log10(x) is the number of digits in x. In the worst case, the while loop runs for half of the digits in x, so the time complexity is proportional to the number of digits.\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\nThe space complexity of this code is O(1) because it uses a fixed amount of extra space regardless of the input x.\n\n---\n\n# \uD83D\uDCA1"If you have journeyed this far, I would kindly beseech you to consider upvoting this solution, thereby facilitating its reach to a wider audience."\u2763\uFE0F\uD83D\uDCA1\n\n---\n\n\n# Code\n```\nclass Solution {\npublic:\n bool isPalindrome(int x) {\n // If x is negative or ends with 0 but is not 0 itself, it cannot be a palindrome.\n if (x < 0 || (x % 10 == 0 && x != 0)) {\n return false;\n }\n\n int reversed = 0;\n while (x > reversed) {\n reversed = reversed * 10 + x % 10;\n x /= 10;\n }\n\n // When the length of the remaining number is odd, we can remove the middle digit.\n // For example, in the number 12321, we can remove the middle \'3\'.\n return x == reversed || x == reversed / 10;\n }\n};\n\n```

Palindrome Number

palindrome-number

Given an integer x, return true if x is palindrome integer. An integer is a palindrome when it reads the same backward as forward.

Math

Easy

Beware of overflow when you reverse the integer.

# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nString has method to reverse\n# Approach\n<!-- Describe your approach to solving the problem. -->\nwith reversing it is possible to write in one line\n\'[::]\' this means print all, and this \'[::-1]\' reverses, it is mostly used with list in python \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 isPalindrome(self, x: int) -> bool:\n return True if str(x)==str(x)[::-1] else False

Regular Expression Matching

regular-expression-matching

Given an input string s and a pattern p, implement regular expression matching with support for '.' and '*' where: The matching should cover the entire input string (not partial).

String,Dynamic Programming,Recursion

Hard

```C++ []\nclass Solution {\npublic:\n bool isMatch(string s, string p) {\n int n = s.length(), m = p.length();\n bool dp[n+1][m+1];\n memset(dp, false, sizeof(dp));\n dp[0][0] = true;\n \n for(int i=0; i<=n; i++){\n for(int j=1; j<=m; j++){\n if(p[j-1] == \'*\'){\n dp[i][j] = dp[i][j-2] || (i > 0 && (s[i-1] == p[j-2] || p[j-2] == \'.\') && dp[i-1][j]);\n }\n else{\n dp[i][j] = i > 0 && dp[i-1][j-1] && (s[i-1] == p[j-1] || p[j-1] == \'.\');\n }\n }\n }\n \n return dp[n][m];\n }\n};\n```\n\n```Python3 []\nclass Solution:\n def isMatch(self, s: str, p: str) -> bool:\n i, j = len(s) - 1, len(p) - 1\n return self.backtrack({}, s, p, i, j)\n\n def backtrack(self, cache, s, p, i, j):\n key = (i, j)\n if key in cache:\n return cache[key]\n\n if i == -1 and j == -1:\n cache[key] = True\n return True\n\n if i != -1 and j == -1:\n cache[key] = False\n return cache[key]\n\n if i == -1 and p[j] == \'*\':\n k = j\n while k != -1 and p[k] == \'*\':\n k -= 2\n \n if k == -1:\n cache[key] = True\n return cache[key]\n \n cache[key] = False\n return cache[key]\n \n if i == -1 and p[j] != \'*\':\n cache[key] = False\n return cache[key]\n\n if p[j] == \'*\':\n if self.backtrack(cache, s, p, i, j - 2):\n cache[key] = True\n return cache[key]\n \n if p[j - 1] == s[i] or p[j - 1] == \'.\':\n if self.backtrack(cache, s, p, i - 1, j):\n cache[key] = True\n return cache[key]\n \n if p[j] == \'.\' or s[i] == p[j]:\n if self.backtrack(cache, s, p, i - 1, j - 1):\n cache[key] = True\n return cache[key]\n\n cache[key] = False\n return cache[key]\n```\n\n```Java []\nenum Result {\n TRUE, FALSE\n}\n\nclass Solution {\n Result[][] memo;\n\n public boolean isMatch(String text, String pattern) {\n memo = new Result[text.length() + 1][pattern.length() + 1];\n return dp(0, 0, text, pattern);\n }\n\n public boolean dp(int i, int j, String text, String pattern) {\n if (memo[i][j] != null) {\n return memo[i][j] == Result.TRUE;\n }\n boolean ans;\n if (j == pattern.length()){\n ans = i == text.length();\n } else{\n boolean first_match = (i < text.length() &&\n (pattern.charAt(j) == text.charAt(i) ||\n pattern.charAt(j) == \'.\'));\n\n if (j + 1 < pattern.length() && pattern.charAt(j+1) == \'*\'){\n ans = (dp(i, j+2, text, pattern) ||\n first_match && dp(i+1, j, text, pattern));\n } else {\n ans = first_match && dp(i+1, j+1, text, pattern);\n }\n }\n memo[i][j] = ans ? Result.TRUE : Result.FALSE;\n return ans;\n }\n}\n```\n

Regular Expression Matching

regular-expression-matching

Given an input string s and a pattern p, implement regular expression matching with support for '.' and '*' where: The matching should cover the entire input string (not partial).

String,Dynamic Programming,Recursion

Hard

# Approach\n- Here the approach is very simple we basically must create a DP to store the states. For any DP problem all follow the same rule that we should memoize the truth value of $$(n,m)$$ then we need the values of $$(n-1 , m)$$ or $$(n ,m-1)$$ or $$(n-1 , m-1)$$ this would be the whole point of DP.\n\n\n---\n\n\n\n![pic0.png]()\n\n>The example of mississippi is taken and the DP table is depicted below and the explaination is provided down.\n\n![pic1.png]()\n\n>Here we basically broke the entire one into three cases as shown in the below picture.Now we procced based on the below three cases and construct our DP table and thus we finally obtain our answer.\n\n![pic 2.png]()\n\n\n---\n\n\n\n# Complexity\n> - Time complexity: Here the complexity would be $$O(n^2)$$ as we need a 2D loop for keeping the track of length of both the strings.\n\n>- Space complexity: Here the space would also be $$O(n^2)$$ which can later be optimised to $$O(n)$$ by making space optimisation into two 1D arrays but we must do this to store the truth values of the lengths.\n\n\n---\n\n\n\n# Code\n```C++ []\nclass Solution {\npublic:\n bool isMatch(string s, string p) {\n int n = s.length(), m = p.length();\n bool dp[n+1][m+1];\n memset(dp, false, sizeof(dp));\n dp[0][0] = true;\n \n for(int i=0; i<=n; i++){\n for(int j=1; j<=m; j++){\n if(p[j-1] == \'*\'){\n dp[i][j] = dp[i][j-2] || (i > 0 && (s[i-1] == p[j-2] || p[j-2] == \'.\') && dp[i-1][j]);\n }\n else{\n dp[i][j] = i > 0 && dp[i-1][j-1] && (s[i-1] == p[j-1] || p[j-1] == \'.\');\n }\n }\n }\n \n return dp[n][m];\n }\n};\n```\n```java []\nenum Result {\n TRUE, FALSE\n}\n\nclass Solution {\n Result[][] memo;\n\n public boolean isMatch(String text, String pattern) {\n memo = new Result[text.length() + 1][pattern.length() + 1];\n return dp(0, 0, text, pattern);\n }\n\n public boolean dp(int i, int j, String text, String pattern) {\n if (memo[i][j] != null) {\n return memo[i][j] == Result.TRUE;\n }\n boolean ans;\n if (j == pattern.length()){\n ans = i == text.length();\n } else{\n boolean first_match = (i < text.length() &&\n (pattern.charAt(j) == text.charAt(i) ||\n pattern.charAt(j) == \'.\'));\n\n if (j + 1 < pattern.length() && pattern.charAt(j+1) == \'*\'){\n ans = (dp(i, j+2, text, pattern) ||\n first_match && dp(i+1, j, text, pattern));\n } else {\n ans = first_match && dp(i+1, j+1, text, pattern);\n }\n }\n memo[i][j] = ans ? Result.TRUE : Result.FALSE;\n return ans;\n }\n}\n```\n```python []\nclass Solution:\n def isMatch(self, s: str, p: str) -> bool:\n i, j = len(s) - 1, len(p) - 1\n return self.backtrack({}, s, p, i, j)\n\n def backtrack(self, cache, s, p, i, j):\n key = (i, j)\n if key in cache:\n return cache[key]\n\n if i == -1 and j == -1:\n cache[key] = True\n return True\n\n if i != -1 and j == -1:\n cache[key] = False\n return cache[key]\n\n if i == -1 and p[j] == \'*\':\n k = j\n while k != -1 and p[k] == \'*\':\n k -= 2\n \n if k == -1:\n cache[key] = True\n return cache[key]\n \n cache[key] = False\n return cache[key]\n \n if i == -1 and p[j] != \'*\':\n cache[key] = False\n return cache[key]\n\n if p[j] == \'*\':\n if self.backtrack(cache, s, p, i, j - 2):\n cache[key] = True\n return cache[key]\n \n if p[j - 1] == s[i] or p[j - 1] == \'.\':\n if self.backtrack(cache, s, p, i - 1, j):\n cache[key] = True\n return cache[key]\n \n if p[j] == \'.\' or s[i] == p[j]:\n if self.backtrack(cache, s, p, i - 1, j - 1):\n cache[key] = True\n return cache[key]\n\n cache[key] = False\n return cache[key]\n```\n\n\n---\n\n\n\nIF YOU LIKE THE SOLUTION THEN PLEASE UPVOTE MY SOLUTION BECAUSE IT GIVES ME MOTIVATION TO REGULARLY POST THE SOLUTION.\n\n![UPVOTE.jpg]()\n

Regular Expression Matching

regular-expression-matching

Given an input string s and a pattern p, implement regular expression matching with support for '.' and '*' where: The matching should cover the entire input string (not partial).

String,Dynamic Programming,Recursion

Hard

\n# Intuition:\nThe problem requires to match a given string s with a pattern p. The pattern p can contain two special characters, \'\' and \'.\'. The \'\' matches zero or more of the preceding character and \'.\' matches any single character.\n\n# Approach:\nWe can use dynamic programming to solve this problem. Let dp[i][j] be a boolean value representing whether the first i characters of s match the first j characters of p.\n\nFirst, we initialize dp[0][0] to true since an empty pattern matches an empty string.\n\nNext, we need to consider the first row of the dp matrix. If the pattern p starts with a \'*\' then it can match zero occurrences, so we set dp[0][j] to dp[0][j-2] for all j where p[j-1] == \'*\'.\n\nNow we fill in the remaining cells of the dp matrix using the following rules:\n\n1. If the i-1th character of s matches the j-1th character of p or the j-1th character of p is \'.\', then dp[i][j] is equal to dp[i-1][j-1].\n2. If the j-1th character of p is \'*\', then we have two cases:\na) Zero occurrences: dp[i][j] is equal to dp[i][j-2]\nb) One or more occurrences: dp[i][j] is equal to dp[i-1][j] if the i-1th character of s matches the j-2th character of p or the j-2th character of p is \'.\'.\n\nFinally, we return dp[m][n], which represents whether the entire string s matches the entire pattern p.\n# Complexity:\n- Time Complexity:\nThe time complexity of the algorithm is O(m * n), where m and n are the lengths of s and p, respectively. This is because we need to fill in the entire dp matrix.\n\n- Space Complexity:\nThe space complexity of the algorithm is also O(m * n) because we need to create a dp matrix of size (m+1) x (n+1).\n\n---\n\n\n# C++\n```\nclass Solution {\npublic:\n bool isMatch(string s, string p) {\n int m = s.size(), n = p.size();\n std::vector<std::vector<bool>> dp(m+1, std::vector<bool>(n+1, false));\n dp[0][0] = true; // empty pattern matches empty string\n\n // initialize first row (empty string)\n for (int j = 1; j <= n; j++) {\n if (p[j-1] == \'*\')\n dp[0][j] = dp[0][j-2];\n }\n\n // fill in remaining cells\n for (int i = 1; i <= m; i++) {\n for (int j = 1; j <= n; j++) {\n if (s[i-1] == p[j-1] || p[j-1] == \'.\') {\n dp[i][j] = dp[i-1][j-1];\n } else if (p[j-1] == \'*\') {\n dp[i][j] = dp[i][j-2]; // zero occurrences\n if (s[i-1] == p[j-2] || p[j-2] == \'.\') {\n dp[i][j] = dp[i][j] || dp[i-1][j]; // one or more occurrences\n }\n }\n }\n }\n return dp[m][n];\n }\n};\n```\n\n---\n# JAVA\n```\nclass Solution {\n public boolean isMatch(String s, String p) {\n int m = s.length(), n = p.length();\n boolean[][] dp = new boolean[m+1][n+1];\n dp[0][0] = true; // empty pattern matches empty string\n\n // initialize first row (empty string)\n for (int j = 1; j <= n; j++) {\n if (p.charAt(j-1) == \'*\')\n dp[0][j] = dp[0][j-2];\n }\n\n // fill in remaining cells\n for (int i = 1; i <= m; i++) {\n for (int j = 1; j <= n; j++) {\n if (s.charAt(i-1) == p.charAt(j-1) || p.charAt(j-1) == \'.\') {\n dp[i][j] = dp[i-1][j-1];\n } else if (p.charAt(j-1) == \'*\') {\n dp[i][j] = dp[i][j-2]; // zero occurrences\n if (s.charAt(i-1) == p.charAt(j-2) || p.charAt(j-2) == \'.\') {\n dp[i][j] = dp[i][j] || dp[i-1][j]; // one or more occurrences\n }\n }\n }\n }\n return dp[m][n];\n }\n}\n\n```\n\n---\n# Python\n```\nclass Solution(object):\n def isMatch(self, s, p):\n m, n = len(s), len(p)\n dp = [[False] * (n+1) for _ in range(m+1)]\n dp[0][0] = True # empty pattern matches empty string\n\n # initialize first row (empty string)\n for j in range(1, n+1):\n if p[j-1] == \'*\':\n dp[0][j] = dp[0][j-2]\n\n # fill in remaining cells\n for i in range(1, m+1):\n for j in range(1, n+1):\n if s[i-1] == p[j-1] or p[j-1] == \'.\':\n dp[i][j] = dp[i-1][j-1]\n elif p[j-1] == \'*\':\n dp[i][j] = dp[i][j-2]\n if s[i-1] == p[j-2] or p[j-2] == \'.\':\n dp[i][j] |= dp[i-1][j]\n\n return dp[m][n]\n\n```\n---\n# JavaScript\n```\nvar isMatch = function(s, p) {\n const m = s.length, n = p.length;\n const dp = new Array(m+1).fill().map(() => new Array(n+1).fill(false));\n dp[0][0] = true; // empty pattern matches empty string\n\n // initialize first row (empty string)\n for (let j = 1; j <= n; j++) {\n if (p[j-1] === \'*\')\n dp[0][j] = dp[0][j-2];\n }\n\n // fill in remaining cells\n for (let i = 1; i <= m; i++) {\n for (let j = 1; j <= n; j++) {\n if (s[i-1] === p[j-1] || p[j-1] === \'.\') {\n dp[i][j] = dp[i-1][j-1];\n } else if (p[j-1] === \'*\') {\n dp[i][j] = dp[i][j-2]; // zero occurrences\n if (s[i-1] === p[j-2] || p[j-2] === \'.\') {\n dp[i][j] = dp[i][j] || dp[i-1][j]; // one or more occurrences\n }\n }\n }\n }\n return dp[m][n];\n}\n```

Regular Expression Matching

regular-expression-matching

Given an input string s and a pattern p, implement regular expression matching with support for '.' and '*' where: The matching should cover the entire input string (not partial).

String,Dynamic Programming,Recursion

Hard

# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nThis problem can be solved by using dynamic programming. We can define dp(i, j) as the boolean value indicating whether the substring s[i:] matches the pattern p[j:].\n# Approach\n<!-- Describe your approach to solving the problem. -->\nWe can solve the problem by defining a recursive function that tries to match s[i:] with p[j:] for all possible i and j indices. The function should return true if and only if it matches the entire string.\n\nTo avoid redundant computation, we can use memoization to store the previously computed results of dp(i, j) in a memo dictionary. The recursive function first checks if the result is already computed in the memo dictionary and returns it if so.\n\nIf j reaches the end of p, the function returns true if and only if i also reaches the end of s.\n\nIf the next character in p is followed by a \'\', the function can match zero or more occurrences of the preceding character. The function recursively tries two cases: either skip the preceding character and the \'\', or match the preceding character and recursively try to match the remaining part of s and p. The function returns true if either case succeeds.\n\nOtherwise, the function simply checks if the next character in p matches the next character in s or is a dot character (\'.\') that matches any character. If so, the function recursively tries to match the remaining part of s and p. The function returns true if both cases succeed.\n# Complexity\n- Time complexity: O(SP), where S is the length of the string s and P is the length of the pattern p. The function tries to match each character in s with each character in p at most once and uses memoization to avoid redundant computation.\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity: O(SP), where S is the length of the string s and P is the length of the pattern p. The function uses memoization to store the previously computed results of dp(i, j).\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\nclass Solution:\n def isMatch(self, s: str, p: str) -> bool:\n memo = {}\n \n def dp(i: int, j: int) -> bool:\n if (i, j) in memo:\n return memo[(i, j)]\n \n if j == len(p):\n return i == len(s)\n \n first_match = i < len(s) and (p[j] == s[i] or p[j] == \'.\')\n \n if j + 1 < len(p) and p[j+1] == \'*\':\n ans = dp(i, j+2) or (first_match and dp(i+1, j))\n else:\n ans = first_match and dp(i+1, j+1)\n \n memo[(i, j)] = ans\n return ans\n \n return dp(0, 0)\n```

Regular Expression Matching

regular-expression-matching

Given an input string s and a pattern p, implement regular expression matching with support for '.' and '*' where: The matching should cover the entire input string (not partial).

String,Dynamic Programming,Recursion

Hard

Hello!\n\nTo solve this problem we have to go through all possible states. State is defined by **s_index** and **p_index** where they define current char from **s** and **p** strings.\n\nWe return **True** if both **s_index** and **p_index** are out of bounds (it means that we were able to construct **s** string from **p** pattern and there are no chars left in **p**).\n\nIf **s_index** is out of bounds, but **p_index** is not out of bounds it means that we were able to construct **s** string from **p**, but there are some chars left in **p**. We can delete them only, if there are only letter + star pairs left. If there is at least one letter (or dot) without star after it, then we have to return **False**.\n\n\nFor example if we have s = **abc** and p = **abcz(star)b(star)** then we are able to remove **z** and **b** occurencies, because there is **star** after **z** and after **b**, so we return **True**.\n\n\nIf **p_index** is out of bounds while **s_index** is still not out of bounds it means that we are not able to construct **s** from **p**, because there are no letters left, so we return **False**.\n\nThen there are 4 options:\n\n1) If next char in **p** is a **star** and char in **s** match char in **p** (if char in **p** is dot, then we assume that we change dot to the char that is in **s**) then we have two options: we can use current char in **p** to match char in **s** or go to next char in **p** (because next char is a **star**, so we can use previous char 0 or more times).\n\n2) If next char in **p** is a **star** and char in **s** **DOES NOT** match char in **p**, then we can only explore going to the next char in **p** option (so we increase **p_index** by 2, because we have to skip the **star**).\n\n3) If next char in **p** **IS NOT** a **star** and char in **s** match char in **p**, then we can only explore current char option to match char in **s** (so we increase both **p_index** and **s_index** by 1)\n\n4) If next char in **p** **IS NOT** a **star** and char in **s** **DOES NOT** match char in **p**, then there is no option left, so we have to return **False**.\n\nWe will use **memory** to store previous state and at the start of the function we check if current state was already explored. If **yes** then we just return value stored in **memory**.\n\nCode:\n```\nclass Solution:\n def isMatch(self, s: str, p: str) -> bool:\n memory = {}\n \n def explore_state(s_index, p_index):\n if (s_index, p_index) in memory:\n return memory[(s_index, p_index)]\n \n s_index_out_of_border = s_index >= len(s)\n p_index_out_of_border = p_index >= len(p)\n next_char_is_a_star = p_index+1 < len(p) and p[p_index+1] == "*"\n \n if s_index_out_of_border is True:\n if p_index_out_of_border is True:\n return True\n elif next_char_is_a_star is True:\n memory[(s_index, p_index)] = explore_state(s_index, p_index+2)\n return memory[(s_index, p_index)]\n else:\n memory[(s_index, p_index)] = False\n return memory[(s_index, p_index)]\n \n if p_index_out_of_border:\n return False\n \n match = s[s_index] == p[p_index] or p[p_index] == "."\n \n if next_char_is_a_star is True and match is True:\n memory[(s_index, p_index)] = explore_state(s_index, p_index+2) or explore_state(s_index+1, p_index)\n elif next_char_is_a_star is True and match is False:\n memory[(s_index, p_index)] = explore_state(s_index, p_index+2)\n elif next_char_is_a_star is False and match is True:\n memory[(s_index, p_index)] = explore_state(s_index+1, p_index+1)\n elif next_char_is_a_star is False and match is False:\n memory[(s_index, p_index)] = False\n\t\t\t\t\n return memory[(s_index, p_index)]\n \n return explore_state(0, 0)\n```\n\nPlease upvote if it was helpful :))

Regular Expression Matching

regular-expression-matching

Given an input string s and a pattern p, implement regular expression matching with support for '.' and '*' where: The matching should cover the entire input string (not partial).

String,Dynamic Programming,Recursion

Hard

```\n def isMatch(self, s: str, p: str) -> bool:\n s, p = \' \'+ s, \' \'+ p\n lenS, lenP = len(s), len(p)\n dp = [[0]*(lenP) for i in range(lenS)]\n dp[0][0] = 1\n\n for j in range(1, lenP):\n if p[j] == \'*\':\n dp[0][j] = dp[0][j-2]\n\n for i in range(1, lenS):\n for j in range(1, lenP):\n if p[j] in {s[i], \'.\'}:\n dp[i][j] = dp[i-1][j-1]\n elif p[j] == "*":\n dp[i][j] = dp[i][j-2] or int(dp[i-1][j] and p[j-1] in {s[i], \'.\'})\n\n return bool(dp[-1][-1])\n```\nRuntime: 56 ms, faster than 70.79% of Python3 online submissions for Regular Expression Matching.\nMemory Usage: 13.9 MB, less than 5.55% of Python3 online submissions for Regular Expression Matching.\n\nSee the [explanation of the idea]()

Regular Expression Matching

regular-expression-matching

Given an input string s and a pattern p, implement regular expression matching with support for '.' and '*' where: The matching should cover the entire input string (not partial).

String,Dynamic Programming,Recursion

Hard

(Note: This is part of a series of Leetcode solution explanations. If you like this solution or find it useful, ***please upvote*** this post.)\n***Take care brother, peace, love!***\n\n```\n```\n\nThe best result for the code below is ***0ms / 38.2MB*** (beats 92.04% / 24.00%).\n* *** Python ***\n\n```\n\n def isMatch(self, s: str, p: str) -> bool:\n s, p = \' \'+ s, \' \'+ p\n lenS, lenP = len(s), len(p)\n dp = [[0]*(lenP) for i in range(lenS)]\n dp[0][0] = 1\n\n for j in range(1, lenP):\n if p[j] == \'*\':\n dp[0][j] = dp[0][j-2]\n\n for i in range(1, lenS):\n for j in range(1, lenP):\n if p[j] in {s[i], \'.\'}:\n dp[i][j] = dp[i-1][j-1]\n elif p[j] == "*":\n dp[i][j] = dp[i][j-2] or int(dp[i-1][j] and p[j-1] in {s[i], \'.\'})\n\n return bool(dp[-1][-1])\n\n```\n\n```\n```\n\n```\n```\n***"We are Anonymous. We are legion. We do not forgive. We do not forget. Expect us. Open your eyes.." - \uD835\uDCD0\uD835\uDCF7\uD835\uDCF8\uD835\uDCF7\uD835\uDD02\uD835\uDCF6\uD835\uDCF8\uD835\uDCFE\uD835\uDCFC***

Regular Expression Matching

regular-expression-matching

Given an input string s and a pattern p, implement regular expression matching with support for '.' and '*' where: The matching should cover the entire input string (not partial).

String,Dynamic Programming,Recursion

Hard

\n(Note: This is part of a series of Leetcode solution explanations. If you like this solution or find it useful, ***please upvote*** this post.)\n***Take care brother, peace, love!***\n\n```\n```\n\nThe best result for the code below is ***0ms / 3.27MB*** (beats 99.04% / 90.42%).\n* *** Java ***\n\n```\n\npublic boolean isMatch(String s, String p) {\n\t\t/**\n\t\t * This solution is assuming s has no regular expressions.\n\t\t * \n\t\t * dp: res[i][j]=is s[0,...,i-1] matched with p[0,...,j-1];\n\t\t * \n\t\t * If p[j-1]!=\'*\', res[i][j] = res[i-1][j-1] &&\n\t\t * (s[i-1]==p[j-1]||p[j-1]==\'.\'). Otherwise, res[i][j] is true if\n\t\t * res[i][j-1] or res[i][j-2] or\n\t\t * res[i-1][j]&&(s[i-1]==p[j-2]||p[j-2]==\'.\'), and notice the third\n\t\t * \'or\' case includes the first \'or\'.\n\t\t * \n\t\t * \n\t\t * Boundaries: res[0][0]=true;//s=p="". res[i][0]=false, i>0.\n\t\t * res[0][j]=is p[0,...,j-1] empty, j>0, and so res[0][1]=false,\n\t\t * res[0][j]=p[j-1]==\'*\'&&res[0][j-2].\n\t\t * \n\t\t * O(n) space is enough to store a row of res.\n\t\t */\n\n\t\tint m = s.length(), n = p.length();\n\t\tboolean[] res = new boolean[n + 1];\n\t\tres[0] = true;\n\n\t\tint i, j;\n\t\tfor (j = 2; j <= n; j++)\n\t\t\tres[j] = res[j - 2] && p.charAt(j - 1) == \'*\';\n\n\t\tchar pc, sc, tc;\n\t\tboolean pre, cur; // pre=res[i - 1][j - 1], cur=res[i-1][j]\n\n\t\tfor (i = 1; i <= m; i++) {\n\t\t\tpre = res[0];\n\t\t\tres[0] = false;\n\t\t\tsc = s.charAt(i - 1);\n\n\t\t\tfor (j = 1; j <= n; j++) {\n\t\t\t\tcur = res[j];\n\t\t\t\tpc = p.charAt(j - 1);\n\t\t\t\tif (pc != \'*\')\n\t\t\t\t\tres[j] = pre && (sc == pc || pc == \'.\');\n\t\t\t\telse {\n\t\t\t\t\t// pc == \'*\' then it has a preceding char, i.e. j>1\n\t\t\t\t\ttc = p.charAt(j - 2);\n\t\t\t\t\tres[j] = res[j - 2] || (res[j] && (sc == tc || tc == \'.\'));\n\t\t\t\t}\n\t\t\t\tpre = cur;\n\t\t\t}\n\t\t}\n\n\t\treturn res[n];\n\t}\n\n```\n\n```\n```\n\n```\n```\n\nThe best result for the code below is ***0ms / 10MB*** (beats 100.00% / 95.49%).\n* *** Python ***\n\n```\n\ncache = {}\ndef isMatch(self, s, p):\n if (s, p) in self.cache:\n return self.cache[(s, p)]\n if not p:\n return not s\n if p[-1] == \'*\':\n if self.isMatch(s, p[:-2]):\n self.cache[(s, p)] = True\n return True\n if s and (s[-1] == p[-2] or p[-2] == \'.\') and self.isMatch(s[:-1], p):\n self.cache[(s, p)] = True\n return True\n if s and (p[-1] == s[-1] or p[-1] == \'.\') and self.isMatch(s[:-1], p[:-1]):\n self.cache[(s, p)] = True\n return True\n self.cache[(s, p)] = False\n return False\n\n```\n\n```\ndef isMatch(self, s, p):\n dp = [[False] * (len(s) + 1) for _ in range(len(p) + 1)]\n dp[0][0] = True\n for i in range(1, len(p)):\n dp[i + 1][0] = dp[i - 1][0] and p[i] == \'*\'\n for i in range(len(p)):\n for j in range(len(s)):\n if p[i] == \'*\':\n dp[i + 1][j + 1] = dp[i - 1][j + 1] or dp[i][j + 1]\n if p[i - 1] == s[j] or p[i - 1] == \'.\':\n dp[i + 1][j + 1] |= dp[i + 1][j]\n else:\n dp[i + 1][j + 1] = dp[i][j] and (p[i] == s[j] or p[i] == \'.\')\n return dp[-1][-1]\n```\n\n```\n```\n\n```\n```\n\nThe best result for the code below is ***0ms / 23.7MB*** (beats 59.24% / 60.42%).\n* *** C++ ***\n\n\nWe can solve the problem using recursion. We need the helper function to keep track of the current indices of the pattern and the string. The basic condition would be when pattern index reaches the end, then we will check if the string index has also reached the end or not.\n\nNow we will check if the pattern current index matches the string current index character, this would be true either when the characters are equal i.e. s[i]==p[j] or if the p[j]==\'.\' since \'.\' can be replaced by any character.\n\nIf the next pattern character is \'\' that means the current pattern character p[j] could occur 0 or infinite times. So, then there would be two possibility either we can take match the current pattern character with the string and move i by 1 or we can just take zero occurence of the current pattern character and move the pattern character by 2. We will apply the OR condition between these two conditions since if either of them matches then it solves our problem and if next pattern character is not \'\' , then we need to check if the current character matches or not and also move both string and pattern character by 1.\n\nThe time complexity of this brute force approach is O(3^(max(m,n)) and space complexity is O(max(m,n)) where m and n are the length of pattern and string respectively.\n\n```\nclass Solution {\npublic:\n bool isMatch(string s, string p) {\n return helper(s,p,0,0);\n }\n \n bool helper(string s, string p, int i, int j)\n {\n if(j==p.length())\n return i==s.length();\n bool first_match=(i<s.length() && (s[i]==p[j] || p[j]==\'.\' ));\n \n if(j+1<p.length() && p[j+1]==\'*\')\n {\n return (helper(s,p,i,j+2)|| (first_match && helper(s,p,i+1,j) ));\n }\n else\n {\n return (first_match && helper(s,p,i+1,j+1));\n }\n }\n};\n```\n\nWe are actually recomputing the solution for the same subproblems many times. So to avoid that we can initialize dp matrix with all values with being -1. Now if dp[i][j]>=0 then that means this has been already computed so we can return the results here only, thus, it saves time and we don\'t need to recompute that again. Notice that we are saving the results in dp[i][j] in the second last line and this result would always be positive either 0 or 1.\n\nThe time complexity is now O(mn) and space complexity is O(mn) where m and n are the length of pattern and string respectively.\n\n```\nclass Solution {\npublic:\n bool isMatch(string s, string p) {\n vector<vector<int>> dp(s.length()+1,vector<int>(p.length(),-1));\n return helper(s,p,0,0,dp);\n }\n \n bool helper(string s, string p, int i, int j,vector<vector<int>> &dp)\n {\n if(j==p.length())\n return i==s.length();\n if(dp[i][j]>=0)\n return dp[i][j];\n bool first_match=(i<s.length() && (s[i]==p[j] || p[j]==\'.\' ));\n bool ans=0;\n if(j+1<p.length() && p[j+1]==\'*\')\n {\n ans= (helper(s,p,i,j+2,dp)|| (first_match && helper(s,p,i+1,j,dp) ));\n }\n else\n {\n ans= (first_match && helper(s,p,i+1,j+1,dp));\n }\n dp[i][j]=ans;\n return ans;\n }\n};\n```\n\nBottom up solution\n\nWe can derive the bottom up solution from top down approach only. We will make the matrix of length (s.length()+1)* (p.length()+1) . dp[s.length()][p.length()]=1 since both have ended at that point.\n\n```\nclass Solution {\npublic:\n bool isMatch(string s, string p) {\n vector<vector<int>> dp(s.length()+1,vector<int>(p.length()+1,0));\n dp[s.length()][p.length()]=1;\n \n for(int i=s.length();i>=0;i--)\n {\n for(int j=p.length()-1;j>=0;j--)\n {\n bool first_match=(i<s.length() && (p[j]==s[i]|| p[j]==\'.\'));\n if(j+1<p.length() && p[j+1]==\'*\')\n {\n dp[i][j]=dp[i][j+2] || (first_match && dp[i+1][j]);\n }\n else\n {\n dp[i][j]=first_match && dp[i+1][j+1];\n }\n }\n }\n \n return dp[0][0];\n }\n};\n```\n\n```\n```\n\n```\n```\n\nThe best result for the code below is ***0ms / 78MB*** (beats 100.00% / 100.00%).\n* *** JavaScript ***\n\n\n```\n\nfunction isMatch(s, p) {\n var lenS = s.length;\n var lenP = p.length;\n var map = {};\n\n return check(0, 0);\n\n function check(idxS, idxP) {\n if (map[idxS + \':\' + idxP] !== undefined) return map[idxS + \':\' + idxP];\n if (idxS > lenS) return false;\n if (idxS === lenS && idxP === lenP) return true;\n\n if (p[idxP] === \'.\' || p[idxP] === s[idxS]) {\n map[idxS + \':\' + idxP] = p[idxP + 1] === \'*\' ?\n check(idxS + 1, idxP) || check(idxS, idxP + 2) :\n check(idxS + 1, idxP + 1);\n } else {\n map[idxS + \':\' + idxP] = p[idxP + 1] === \'*\' ?\n check(idxS, idxP + 2) : false;\n }\n return map[idxS + \':\' + idxP];\n }\n}\n\n```\n\n```\nconst isMatch = (string, pattern) => {\n // early return when pattern is empty\n if (!pattern) {\n\t\t// returns true when string and pattern are empty\n\t\t// returns false when string contains chars with empty pattern\n return !string;\n }\n \n\t// check if the current char of the string and pattern match when the string has chars\n const hasFirstCharMatch = Boolean(string) && (pattern[0] === \'.\' || pattern[0] === string[0]);\n\n // track when the next character * is next in line in the pattern\n if (pattern[1] === \'*\') {\n // if next pattern match (after *) is fine with current string, then proceed with it (s, p+2). That\'s because the current pattern may be skipped.\n // otherwise check hasFirstCharMatch. That\'s because if we want to proceed with the current pattern, we must be sure that the current pattern char matches the char\n\t\t// If hasFirstCharMatch is true, then do the recursion with next char and current pattern (s+1, p). That\'s because current char matches the pattern char. \n return (\n isMatch(string, pattern.slice(2)) || \n (hasFirstCharMatch && isMatch(string.slice(1), pattern))\n );\n }\n \n // now we know for sure that we need to do 2 simple actions\n\t// check the current pattern and string chars\n\t// if so, then can proceed with next string and pattern chars (s+1, p+1)\n return hasFirstCharMatch ? isMatch(string.slice(1), pattern.slice(1)) : false;\n};\n```\n\n```\n```\n\n```\n```\n\nThe best result for the code below is ***0ms / 15.23MB*** (beats 89.94% / 90.99%).\n* *** Python3 ***\n\n\nIf dp[i][j] == False, it means s[:i] doesn\'t match p[:j]\u2028If dp[i][j] == True, it means s[:i] matches p[:j]\u2028\'.\' Matches any single character.\u2028\'\' Matches zero or more of the preceding element.\u2028s = "aa"\u2028p = "a"\u2028Output: true\u2028Explanation: \'*\' means zero or more of the preceding element, \'a\'. Therefore, by repeating \'a\' once, it becomes "aa".\n\n```\ns = "aab"\np = "c*a*b"\n c * a * b\ndp = [ \n [True, False, True, False, True, False], \n\t a [False, False, False, True, True, False], \n\t a [False, False, False, False, True, False], \n\t b\t[False, False, False, False, False, True]] \n\t\n# Case 1 p[:j] == alphabet or \'.\'\n# Case 2: p[:j] is \'*\'\n\t# Case 2a: p[:j-1] doesn\'t need a \'*\' to match the substring s[:i]\n\t #1 p[:j-1] ==s[:i] dp[i][j] =d[i-1][j]\n\t\t 0 a * 0 a a \n 0 0\n a T ---> a\n a T a T\n\t\t#2 p[:j-1] == \'.\' dp[i][j]=dp[i][j-2]\n\t\t 0 a b *\n 0 \n a T T \n \n\t# Case 2b: p[:j] needs \'*\' to match the substring s[:i]\n```\n```\n # about *:\n case 1: 0 preceding element\n case 2: 1 or more preceding element\n\t\t\t the preceding element could be a \'.\' or an alpharbet.\n\t\t\t more proceding element is easy to handle once you use dynamic programming. \n ```\n ```\nclass Solution:\n def isMatch(self, s, p):\n n = len(s)\n m = len(p)\n dp = [[False for _ in range (m+1)] for _ in range (n+1)]\n dp[0][0] = True\n for c in range(1,m+1):\n if p[c-1] == \'*\' and c > 1:\n dp[0][c] = dp[0][c-2]\n for r in range(1,n+1):\n for c in range(1,m+1):\n if p[c-1] == s[r-1] or p[c-1] == \'.\':\n dp[r][c] = dp[r-1][c-1]\n elif c > 1 and p[c-1] == \'*\':\n if p[c-2] ==\'.\' or s[r-1]==p[c-2]:\n dp[r][c] =dp[r][c-2] or dp[r-1][c]\n else:\n dp[r][c] = dp[r][c-2]\n return dp[n][m]\n```\n\n```\n```\n\n```\n```\n\nThe best result for the code below is ***0ms / 33.33MB*** (beats 99.00% / 60.12%).\n* *** Kotlin ***\n\n\n```\n\nclass Solution {\n fun isMatch(s: String, p: String): Boolean {\n return isMatchRecursive(s, p)\n }\n \n fun isMatchRecursive(s: String, p: String): Boolean {\n if (p == "") return s == ""\n \n if (p.length >= 2 && p[1] == \'*\' && s.length > 0 && (s[0] == p[0] || p[0] == \'.\')) {\n return isMatchRecursive(s.substring(1), p) || isMatchRecursive(s, p.substring(2))\n } else if (p.length >= 2 && p[1] == \'*\') {\n return isMatchRecursive(s, p.substring(2))\n }\n \n return if (s.length > 0) {\n if (s[0] == p[0] || p[0] == \'.\') {\n isMatchRecursive(s.substring(1), p.substring(1))\n } else {\n false\n }\n } else {\n false\n }\n }\n}\n\n```\n\n```\nclass Solution {\n fun isMatch(s: String, p: String): Boolean {\n return p.toRegex().matches(s)\n }\n}\n```\n\n```\n```\n\n```\n```\n\nThe best result for the code below is ***0ms / 13.17MB*** (beats 79.34% / 99.92%).\n* *** Swift ***\n\n\n```\n\nclass Solution {\n func isMatch(_ s: String, _ p: String) -> Bool {\n \n var visit = [[Bool]]()\n let sLength = s.count, pCount = p.count\n \n for _ in 0...sLength + 1 {\n visit.append([Bool](repeating: false, count: pCount + 1))\n }\n \n visit[sLength][pCount] = true\n \n for i in stride(from: sLength, through: 0, by: -1) {\n for j in stride(from: pCount - 1, through: 0, by: -1) {\n \n let arrS = Array(s), arrP = Array(p)\n \n let first = i < sLength && (arrS[i] == arrP[j] || arrP[j] == ".")\n \n if j + 1 < pCount && arrP[j + 1] == "*" {\n visit[i][j] = visit[i][j + 2] || first && visit[i + 1][j]\n } else {\n visit[i][j] = first && visit[i + 1][j + 1]\n }\n }\n }\n return visit[0][0]\n }\n}\n\n```\n\n```\n```\n\n```\n```\n\nThe best result for the code below is ***0ms / 62.07MB*** (beats 99.99% / 99.99%).\n* *** PHP ***\n\n\n```\nclass Solution {\n\n /**\n * @param String $s\n * @param String $p\n * @return Boolean\n */\n function isMatch($s, $p) {\n return preg_match("/^{$p}$/", $s);\n }\n}\n```\n\nHowever, that kinda defeats the point of the exercise, which is to show you can write a regex matcher. So here is my solution.\n```\nclass Solution {\n \n const WILDCARD = "*";\n const ANY_CHAR = ".";\n \n /**\n * @param String $string\n * @param String $pattern\n * @return Boolean\n */\n function isMatch($string, $pattern) \n {\n if (!$pattern) {\n return !$string;\n }\n \n $matchResult = $string && ($string[0] === $pattern[0] || self::ANY_CHAR === $pattern[0]);\n $greedyMatch = !empty($pattern[1]) && $pattern[1] == self::WILDCARD;\n\n if (!$matchResult && !$greedyMatch) {\n return false;\n }\n\n if ($greedyMatch) {\n return ($matchResult && $this->isMatch(substr($string, 1), $pattern)) || $this->isMatch($string, substr($pattern, 2));\n }\n \n return $matchResult && $this->isMatch(substr($string, 1), substr($pattern, 1));\n }\n}\n```\n\n```\n```\n\n```\n```\n\nThe best result for the code below is ***0ms / 1.17MB*** (beats 99.64% / 99.92%).\n* *** C ***\n\n\n```\n\nbool match(char* s, char* p) {\n return (s[0] == p[0]) || (p[0] == \'.\' && s[0]);\n}\n\nbool isMatch(char * s, char * p){\n if (!p[0]) return !s[0];\n if (p[1] == \'*\') return isMatch(s, p+2) || match(s, p) && isMatch(s+1, p);\n if (p[0] == \'.\') return s[0] && isMatch(s+1, p+1);\n return match(s, p) && isMatch(s+1, p+1);\n}\n\n```\n\n```\n```\n\n```\n```\n\n***"Open your eyes. Expect us." - \uD835\uDCD0\uD835\uDCF7\uD835\uDCF8\uD835\uDCF7\uD835\uDD02\uD835\uDCF6\uD835\uDCF8\uD835\uDCFE\uD835\uDCFC***\n

Regular Expression Matching

regular-expression-matching

Given an input string s and a pattern p, implement regular expression matching with support for '.' and '*' where: The matching should cover the entire input string (not partial).

String,Dynamic Programming,Recursion

Hard

# 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 isMatch(self, s: str, p: str) -> bool:\n return re.match(fr"^{p}$", s) is not None\n```

Regular Expression Matching

regular-expression-matching

Given an input string s and a pattern p, implement regular expression matching with support for '.' and '*' where: The matching should cover the entire input string (not partial).

String,Dynamic Programming,Recursion

Hard

Takes about 174ms:\n\n \n cache = {}\n def isMatch(self, s, p):\n if (s, p) in self.cache:\n return self.cache[(s, p)]\n if not p:\n return not s\n if p[-1] == '*':\n if self.isMatch(s, p[:-2]):\n self.cache[(s, p)] = True\n return True\n if s and (s[-1] == p[-2] or p[-2] == '.') and self.isMatch(s[:-1], p):\n self.cache[(s, p)] = True\n return True\n if s and (p[-1] == s[-1] or p[-1] == '.') and self.isMatch(s[:-1], p[:-1]):\n self.cache[(s, p)] = True\n return True\n self.cache[(s, p)] = False\n return False\n\n\nDP version:\n \n def isMatch(self, s, p):\n dp = [[False] * (len(s) + 1) for _ in range(len(p) + 1)]\n dp[0][0] = True\n for i in range(1, len(p)):\n dp[i + 1][0] = dp[i - 1][0] and p[i] == '*'\n for i in range(len(p)):\n for j in range(len(s)):\n if p[i] == '*':\n dp[i + 1][j + 1] = dp[i - 1][j + 1] or dp[i][j + 1]\n if p[i - 1] == s[j] or p[i - 1] == '.':\n dp[i + 1][j + 1] |= dp[i + 1][j]\n else:\n dp[i + 1][j + 1] = dp[i][j] and (p[i] == s[j] or p[i] == '.')\n return dp[-1][-1]

Regular Expression Matching

regular-expression-matching

Given an input string s and a pattern p, implement regular expression matching with support for '.' and '*' where: The matching should cover the entire input string (not partial).

String,Dynamic Programming,Recursion

Hard

This problem can be solved using dynamic programming. Let dp[i][j] be a boolean indicating whether the first i characters of s match the first j characters of p. We can initialize dp[0][0] = True because an empty string matches an empty pattern.\n\nFor the first row dp[0][j], we need to consider two cases: if p[j-1] is \'*\', we can ignore it and look at dp[0][j-2] (the pattern without the \'*\' and its preceding character), or if p[j-2] matches the empty string, we can look at dp[0][j-1] (the pattern with only the \'*\' and its preceding character).\n\nFor each subsequent cell dp[i][j], we need to consider three cases: if p[j-1] is a regular character and matches s[i-1], then dp[i][j] = dp[i-1][j-1]. If p[j-1] is a \'*\', then we can either ignore the preceding character and look at dp[i][j-2] (the pattern without the \'*\' and its preceding character), or if the preceding character matches s[i-1], we can look at dp[i-1][j] (the pattern with the \'*\' and one more repetition of the preceding character), or if the preceding character does not match s[i-1], we can ignore both the preceding character and the \'*\' and look at dp[i][j-2]. If p[j-1] is a ., then dp[i][j] = dp[i-1][j-1].\n\nThe final answer is dp[m][n], where m and n are the lengths of s and p, respectively.\n\nThe time complexity of this algorithm is O(mn) and the space complexity is O(mn), where m and n are the lengths of s and p, respectively.\n\n# Code\n```\nclass Solution:\n def isMatch(self, s: str, p: str) -> bool:\n m, n = len(s), len(p)\n dp = [[False] * (n+1) for _ in range(m+1)]\n dp[0][0] = True\n for j in range(1, n+1):\n if p[j-1] == \'*\':\n dp[0][j] = dp[0][j-2]\n else:\n dp[0][j] = j > 1 and p[j-2] == \'*\' and dp[0][j-2]\n for i in range(1, m+1):\n for j in range(1, n+1):\n if p[j-1] == s[i-1] or p[j-1] == \'.\':\n dp[i][j] = dp[i-1][j-1]\n elif p[j-1] == \'*\':\n dp[i][j] = dp[i][j-2] or (p[j-2] == s[i-1] or p[j-2] == \'.\') and dp[i-1][j]\n else:\n dp[i][j] = False\n return dp[m][n]\n```

Container With Most Water

container-with-most-water

You are given an integer array height of length n. There are n vertical lines drawn such that the two endpoints of the ith line are (i, 0) and (i, height[i]). Find two lines that together with the x-axis form a container, such that the container contains the most water. Return the maximum amount of water a container can store. Notice that you may not slant the container.

Array,Two Pointers,Greedy

Medium

The aim is to maximize the area formed between the vertical lines. The area of any container is calculated using the shorter line as length and the distance between the lines as the width of the rectangle. Area = length of shorter vertical line * distance between lines We can definitely get the maximum width container as the outermost lines have the maximum distance between them. However, this container might not be the maximum in size as one of the vertical lines of this container could be really short. Start with the maximum width container and go to a shorter width container if there is a vertical line longer than the current containers shorter line. This way we are compromising on the width but we are looking forward to a longer length container.

# Intuition:\nThe two-pointer technique starts with the widest container and moves the pointers inward based on the comparison of heights. \nIncreasing the width of the container can only lead to a larger area if the height of the new boundary is greater. By moving the pointers towards the center, we explore containers with the potential for greater areas.\n\n# Explanation:\n1. Initialize the variables:\n - `left` to represent the left pointer, starting at the beginning of the container (index 0).\n - `right` to represent the right pointer, starting at the end of the container (index `height.size() - 1`).\n - `maxArea` to keep track of the maximum area found, initially set to 0.\n\n2. Enter a loop using the condition `left < right`, which means the pointers have not crossed each other yet.\n\n3. Calculate the current area:\n - Use the `min` function to find the minimum height between the `left` and `right` pointers.\n - Multiply the minimum height by the width, which is the difference between the indices of the pointers: `(right - left)`.\n - Store this value in the `currentArea` variable.\n\n4. Update the maximum area:\n - Use the `max` function to compare the `currentArea` with the `maxArea`.\n - If the `currentArea` is greater than the `maxArea`, update `maxArea` with the `currentArea`.\n\n5. Move the pointers inward: (Explained in detail below)\n - Check if the height at the `left` pointer is smaller than the height at the `right` pointer.\n - If so, increment the `left` pointer, moving it towards the center of the container.\n - Otherwise, decrement the `right` pointer, also moving it towards the center.\n\n6. Repeat steps 3 to 5 until the pointers meet (`left >= right`), indicating that all possible containers have been explored.\n\n7. Return the `maxArea`, which represents the maximum area encountered among all the containers.\n\n# Update the maximum area:\nThe purpose of this condition is to determine which pointer to move inward, either the left pointer (`i`) or the right pointer (`j`), based on the comparison of heights at their respective positions.\n\nImagine you have two containers represented by the heights at the left and right pointers. The condition checks which container has a smaller height and moves the pointer corresponding to that container.\n\n1. If `height[i] > height[j]`:\n - This means that the height of the left container is greater than the height of the right container.\n - Moving the right pointer (`j`) would not increase the potential area because the height of the right container is the limiting factor.\n - So, to explore containers with the possibility of greater areas, we need to move the right pointer inward by decrementing `j`.\n\n2. If `height[i] <= height[j]`:\n - This means that the height of the left container is less than or equal to the height of the right container.\n - Moving the left pointer (`i`) would not increase the potential area because the height of the left container is the limiting factor.\n - So, to explore containers with the possibility of greater areas, we need to move the left pointer inward by incrementing `i`.\n\nBy making these pointer movements, we ensure that we are always exploring containers with the potential for larger areas. The approach is based on the observation that increasing the width of the container can only lead to a larger area if the height of the new boundary is greater.\nBy following this condition and moving the pointers accordingly, the algorithm explores all possible containers and finds the one with the maximum area.\n\n# Code\n```C++ []\nclass Solution {\npublic:\n int maxArea(vector<int>& height) {\n int left = 0;\n int right = height.size() - 1;\n int maxArea = 0;\n\n while (left < right) {\n int currentArea = min(height[left], height[right]) * (right - left);\n maxArea = max(maxArea, currentArea);\n\n if (height[left] < height[right]) {\n left++;\n } else {\n right--;\n }\n }\n\n return maxArea;\n }\n};\n```\n```Java []\nclass Solution {\n public int maxArea(int[] height) {\n int left = 0;\n int right = height.length - 1;\n int maxArea = 0;\n\n while (left < right) {\n int currentArea = Math.min(height[left], height[right]) * (right - left);\n maxArea = Math.max(maxArea, currentArea);\n\n if (height[left] < height[right]) {\n left++;\n } else {\n right--;\n }\n }\n\n return maxArea;\n }\n}\n```\n```Python3 []\nclass Solution:\n def maxArea(self, height: List[int]) -> int:\n left = 0\n right = len(height) - 1\n maxArea = 0\n\n while left < right:\n currentArea = min(height[left], height[right]) * (right - left)\n maxArea = max(maxArea, currentArea)\n\n if height[left] < height[right]:\n left += 1\n else:\n right -= 1\n\n return maxArea\n```\n\n![CUTE_CAT.png]()\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.**

Container With Most Water

container-with-most-water

You are given an integer array height of length n. There are n vertical lines drawn such that the two endpoints of the ith line are (i, 0) and (i, height[i]). Find two lines that together with the x-axis form a container, such that the container contains the most water. Return the maximum amount of water a container can store. Notice that you may not slant the container.

Array,Two Pointers,Greedy

Medium

The aim is to maximize the area formed between the vertical lines. The area of any container is calculated using the shorter line as length and the distance between the lines as the width of the rectangle. Area = length of shorter vertical line * distance between lines We can definitely get the maximum width container as the outermost lines have the maximum distance between them. However, this container might not be the maximum in size as one of the vertical lines of this container could be really short. Start with the maximum width container and go to a shorter width container if there is a vertical line longer than the current containers shorter line. This way we are compromising on the width but we are looking forward to a longer length container.

# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nThe problem involves finding two lines in a set of vertical lines (represented by an array of heights) that can form a container to hold the maximum amount of water. The water\'s capacity is determined by the height of the shorter line and the distance between the two lines. We want to find the maximum capacity among all possible combinations of two lines.\n\n---\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n1. We use a two-pointer approach, starting with the left pointer at the leftmost edge of the array (left = 0) and the right pointer at the rightmost edge of the array (right = height.size() - 1).\n\n2. We initialize a variable maxWater to store the maximum water capacity, initially set to 0.\n\n3. We enter a while loop, which continues as long as the left pointer is less than the right pointer. This loop allows us to explore all possible combinations of two lines.\n\n4. Inside the loop, we calculate the width of the container by subtracting the positions of the two pointers: width = right - left.\n\n5. We calculate the height of the container by finding the minimum height between the two lines at positions height[left] and height[right]: h = min(height[left], height[right]).\n\n6. We calculate the water capacity of the current container by multiplying the width and height: water = width * h.\n\n7. We update the maxWater variable if the current container holds more water than the previous maximum: maxWater = max(maxWater, water).\n\n8. Finally, we adjust the pointers: if the height at the left pointer is smaller than the height at the right pointer (height[left] < height[right]), we move the left pointer to the right (left++); otherwise, we move the right pointer to the left (right--).\n\n9. We repeat steps 4-8 until the left pointer is less than the right pointer. Once the pointers meet, we have explored all possible combinations, and the maxWater variable contains the maximum water capacity.\n\n10. We return the maxWater value as the final result.\n\n---\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\nThe time complexity of this algorithm is O(n), where n is the number of elements in the height array. This is because we explore all possible combinations of two lines once, and each operation inside the loop is performed in constant time.\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\nThe space complexity is O(1), which means the algorithm uses a constant amount of extra space regardless of the input size. We only use a few extra variables (left, right, maxWater, width, h, and water) that do not depend on the input size.\n\n---\n\n\n```C++ []\nclass Solution {\npublic:\n int maxArea(vector<int>& height) {\n int left = 0; // Left pointer starting from the leftmost edge\n int right = height.size() - 1; // Right pointer starting from the rightmost edge\n int maxWater = 0; // Initialize the maximum water capacity\n \n while (left < right) {\n // Calculate the width of the container\n int width = right - left;\n \n // Calculate the height of the container (the minimum height between the two lines)\n int h = min(height[left], height[right]);\n \n // Calculate the water capacity of the current container\n int water = width * h;\n \n // Update the maximum water capacity if the current container holds more water\n maxWater = max(maxWater, water);\n \n // Move the pointers towards each other\n if (height[left] < height[right]) {\n left++;\n } else {\n right--;\n }\n }\n \n return maxWater;\n }\n};\n```\n```Java []\nclass Solution {\n public int maxArea(int[] height) {\n int left = 0; // Left pointer starting from the leftmost edge\n int right = height.length - 1; // Right pointer starting from the rightmost edge\n int maxWater = 0; // Initialize the maximum water capacity\n \n while (left < right) {\n // Calculate the width of the container\n int width = right - left;\n \n // Calculate the height of the container (the minimum height between the two lines)\n int h = Math.min(height[left], height[right]);\n \n // Calculate the water capacity of the current container\n int water = width * h;\n \n // Update the maximum water capacity if the current container holds more water\n maxWater = Math.max(maxWater, water);\n \n // Move the pointers towards each other\n if (height[left] < height[right]) {\n left++;\n } else {\n right--;\n }\n }\n \n return maxWater;\n }\n}\n\n```\n```Python []\nclass Solution:\n def maxArea(self, height):\n left = 0 # Left pointer starting from the leftmost edge\n right = len(height) - 1 # Right pointer starting from the rightmost edge\n maxWater = 0 # Initialize the maximum water capacity\n \n while left < right:\n # Calculate the width of the container\n width = right - left\n \n # Calculate the height of the container (the minimum height between the two lines)\n h = min(height[left], height[right])\n \n # Calculate the water capacity of the current container\n water = width * h\n \n # Update the maximum water capacity if the current container holds more water\n maxWater = max(maxWater, water)\n \n # Move the pointers towards each other\n if height[left] < height[right]:\n left += 1\n else:\n right -= 1\n \n return maxWater\n\n```\n```Javascript []\nvar maxArea = function(height) {\n let left = 0; // Left pointer starting from the leftmost edge\n let right = height.length - 1; // Right pointer starting from the rightmost edge\n let maxWater = 0; // Initialize the maximum water capacity\n \n while (left < right) {\n // Calculate the width of the container\n let width = right - left;\n \n // Calculate the height of the container (the minimum height between the two lines)\n let h = Math.min(height[left], height[right]);\n \n // Calculate the water capacity of the current container\n let water = width * h;\n \n // Update the maximum water capacity if the current container holds more water\n maxWater = Math.max(maxWater, water);\n \n // Move the pointers towards each other\n if (height[left] < height[right]) {\n left++;\n } else {\n right--;\n }\n }\n \n return maxWater;\n};\n\n```\n```Ruby []\nclass Solution\n def max_area(height)\n left = 0 # Left pointer starting from the leftmost edge\n right = height.size - 1 # Right pointer starting from the rightmost edge\n max_water = 0 # Initialize the maximum water capacity\n \n while left < right\n # Calculate the width of the container\n width = right - left\n \n # Calculate the height of the container (the minimum height between the two lines)\n h = [height[left], height[right]].min\n \n # Calculate the water capacity of the current container\n water = width * h\n \n # Update the maximum water capacity if the current container holds more water\n max_water = [max_water, water].max\n \n # Move the pointers towards each other\n if height[left] < height[right]\n left += 1\n else\n right -= 1\n end\n end\n \n max_water\n end\nend\n\n```\n```C []\nint maxArea(int* height, int heightSize) {\n int left = 0; // Left pointer starting from the leftmost edge\n int right = heightSize - 1; // Right pointer starting from the rightmost edge\n int maxWater = 0; // Initialize the maximum water capacity\n\n while (left < right) {\n // Calculate the width of the container\n int width = right - left;\n\n // Calculate the height of the container (the minimum height between the two lines)\n int h = height[left] < height[right] ? height[left] : height[right];\n\n // Calculate the water capacity of the current container\n int water = width * h;\n\n // Update the maximum water capacity if the current container holds more water\n if (water > maxWater) {\n maxWater = water;\n }\n\n // Move the pointers towards each other\n if (height[left] < height[right]) {\n left++;\n } else {\n right--;\n }\n }\n\n return maxWater;\n}\n\n```\n\n# \uD83D\uDCA1If you come this far, then i would like to request you to please upvote this solution so that it could reach out to another one \u2763\uFE0F\uD83D\uDCA1\n\n\n\n

Container With Most Water

container-with-most-water

You are given an integer array height of length n. There are n vertical lines drawn such that the two endpoints of the ith line are (i, 0) and (i, height[i]). Find two lines that together with the x-axis form a container, such that the container contains the most water. Return the maximum amount of water a container can store. Notice that you may not slant the container.

Array,Two Pointers,Greedy

Medium

The aim is to maximize the area formed between the vertical lines. The area of any container is calculated using the shorter line as length and the distance between the lines as the width of the rectangle. Area = length of shorter vertical line * distance between lines We can definitely get the maximum width container as the outermost lines have the maximum distance between them. However, this container might not be the maximum in size as one of the vertical lines of this container could be really short. Start with the maximum width container and go to a shorter width container if there is a vertical line longer than the current containers shorter line. This way we are compromising on the width but we are looking forward to a longer length container.

\n\nThe strategy is to start with the container of the <i>longest</i> width and move the sides inwards one by one to see if we can get a larger area by shortening the width but getting a taller height. But how do we know which side to move?\n\nThe key insight here is that moving the <i>longer</i> side inwards is completely unnecessary because the height of the water is bounded by the <i>shorter</i> side. In other words, we will never be able to get a greater area by moving the longer side inwards because the height will either stay the same or get shorter, and the width will keep decreasing.\n\nSo we can skip all those calculations and instead move the <i>shorter</i> side inwards. This way, we <i>might</i> get a taller height and a larger area. So at each step, we calculate the area then move the shorter side inwards. When the left and right sides meet, we are done and we can return the largest area calculated so far.\n\n# Code\n```\nclass Solution(object):\n def maxArea(self, height):\n max_area = 0\n l = 0\n r = len(height) - 1\n while l < r:\n area = (r - l) * min(height[r], height[l])\n max_area = max(max_area, area)\n if height[l] < height[r]:\n l += 1\n else:\n r -= 1\n return max_area\n```

Container With Most Water

container-with-most-water

You are given an integer array height of length n. There are n vertical lines drawn such that the two endpoints of the ith line are (i, 0) and (i, height[i]). Find two lines that together with the x-axis form a container, such that the container contains the most water. Return the maximum amount of water a container can store. Notice that you may not slant the container.

Array,Two Pointers,Greedy

Medium

The aim is to maximize the area formed between the vertical lines. The area of any container is calculated using the shorter line as length and the distance between the lines as the width of the rectangle. Area = length of shorter vertical line * distance between lines We can definitely get the maximum width container as the outermost lines have the maximum distance between them. However, this container might not be the maximum in size as one of the vertical lines of this container could be really short. Start with the maximum width container and go to a shorter width container if there is a vertical line longer than the current containers shorter line. This way we are compromising on the width but we are looking forward to a longer length container.

\n\n# Two Pointer Logic : TC----->O(N)\n```\nclass Solution:\n def maxArea(self, height: List[int]) -> int:\n left,right,answer=0,len(height)-1,0\n while left<=right:\n area=min(height[right],height[left])*(right-left)\n answer=max(answer,area)\n if height[right]>height[left]:\n left+=1\n else:\n right-=1\n return answer\n```\n# please upvote me it would encourage me alot\n

Container With Most Water

container-with-most-water

You are given an integer array height of length n. There are n vertical lines drawn such that the two endpoints of the ith line are (i, 0) and (i, height[i]). Find two lines that together with the x-axis form a container, such that the container contains the most water. Return the maximum amount of water a container can store. Notice that you may not slant the container.

Array,Two Pointers,Greedy

Medium

The aim is to maximize the area formed between the vertical lines. The area of any container is calculated using the shorter line as length and the distance between the lines as the width of the rectangle. Area = length of shorter vertical line * distance between lines We can definitely get the maximum width container as the outermost lines have the maximum distance between them. However, this container might not be the maximum in size as one of the vertical lines of this container could be really short. Start with the maximum width container and go to a shorter width container if there is a vertical line longer than the current containers shorter line. This way we are compromising on the width but we are looking forward to a longer length container.

**UPVOTE if you like (\uD83C\uDF38\u25E0\u203F\u25E0), If you have any question, feel free to ask.**\n\nFirst, we check the widest possible container starting from the first line to the last one. Next, we ask ourselves, how is it possible to form an even bigger container? Every time we narrow the container, the width becomes smaller so the only way to get a bigger area is to find higher lines. So why not just greedily shrink the container on the side that has a shorter line? Every time we shrink the container, we calculate the area and save the maximum.\n\nTime: **O(n)** \nSpace: **O(1)**\n\nRuntime: 819 ms, faster than **75.10%** of Python3 online submissions for Container With Most Water.\nMemory Usage: 27.4 MB, less than **58.32%** of Python3 online submissions for Container With Most Water.\n\n```\nclass Solution:\n def maxArea(self, height: List[int]) -> int:\n l, r, area = 0, len(height) - 1, 0\n while l < r:\n area = max(area, (r - l) * min(height[l], height[r]))\n if height[l] < height[r]:\n\t\t\t\tl += 1\n else:\n\t\t\t\tr -= 1\n\t\t\t\t\n return area\n```\n\n**UPVOTE if you like (\uD83C\uDF38\u25E0\u203F\u25E0), If you have any question, feel free to ask.**

Container With Most Water

container-with-most-water

You are given an integer array height of length n. There are n vertical lines drawn such that the two endpoints of the ith line are (i, 0) and (i, height[i]). Find two lines that together with the x-axis form a container, such that the container contains the most water. Return the maximum amount of water a container can store. Notice that you may not slant the container.

Array,Two Pointers,Greedy

Medium

The aim is to maximize the area formed between the vertical lines. The area of any container is calculated using the shorter line as length and the distance between the lines as the width of the rectangle. Area = length of shorter vertical line * distance between lines We can definitely get the maximum width container as the outermost lines have the maximum distance between them. However, this container might not be the maximum in size as one of the vertical lines of this container could be really short. Start with the maximum width container and go to a shorter width container if there is a vertical line longer than the current containers shorter line. This way we are compromising on the width but we are looking forward to a longer length container.

*(Note: This is part of a series of Leetcode solution explanations. If you like this solution or find it useful,* ***please upvote*** *this post.)*\n\n---\n\n***Idea:***\n\nThe first thing we should realize is that the amount of water contained is always going to be a rectangle whose area is defined as **length * width**. The width of any container will be the difference between the index of the two lines (**i** and **j**), and the height will be whichever of the two sides is the lowest (**min(H[i], H[j])**).\n\nThe brute force approach would be to compare every single pair of indexes in **H**, but that would be far too slow. Instead, we can observe that if we start with the lines on the opposite ends and move inward, the only possible time the area could be larger is when the height increases, since the width will continuously get smaller.\n\nThis is very easily observed with the use of visuals. Let\'s say we start with a graph of **H** like this:\n\n![Visual 1]()\n\nThe first step would be to find our starting container described by the lines on either end:\n\n![Visual 2]()\n\nWe can tell that the line on the right end will never make a better match, because any further match would have a smaller width and the container is already the maximum height that that line can support. That means that our next move should be to slide **j** to the left and pick a new line:\n\n![Visual 3]()\n\nThis is a clear improvement over the last container. We only moved over one line, but we more than doubled the height. Now, it\'s the line on the left end that\'s the limiting factor, so the next step will be to slide **i** to the right. Just looking at the visual, however, it\'s obvious that we can skip the next few lines because they\'re already underwater, so we should go to the first line that\'s larger than the current water height:\n\n![Visual 4]()\n\nThis time, it doesn\'t look like we made much of a gain, despite the fact that the water level rose a bit, because we lost more in width than we made up for in height. That means that we always have to check at each new possible stop to see if the new container area is better than the current best. Just lik before we can slide **j** to the left again:\n\n![Visual 5]()\n\nThis move also doesn\'t appear to have led to a better container. But here we can see that it\'s definitely possible to have to move the same side twice in a row, as the **j** line is still the lower of the two:\n\n![Visual 6]()\n\nThis is obviously the last possible container to check, and like the last few before it, it doesn\'t appear to be the best match. Still, we can understand that it\'s entirely possible for the best container in a different example to be only one index apart, if both lines are extremely tall.\n\nPutting together everything, it\'s clear that we need to make a **2-pointer sliding window solution**. We\'ll start from either end and at each step we\'ll check the container area, then we\'ll shift the lower-valued pointer inward. Once the two pointers meet, we know that we must have exhausted all possible containers and we should **return** our answer (**ans**).\n\n---\n\n***Implementation:***\n\nJavascript was weirdly more performant when using both **Math.max()** and **Math.min()** rather than performing more basic comparisons, even with duplicated effort in the ternary.\n\nFor the other languages, it made more sense (and was ultimately more performant) to only have to do the basic comparisons once each.\n\n---\n\n***Javascript Code:***\n\nThe best result for the code below is **68ms / 41.1MB** (beats 100% / 41%).\n```javascript\nvar maxArea = function(H) {\n let ans = 0, i = 0, j = H.length-1\n while (i < j) {\n ans = Math.max(ans, Math.min(H[i], H[j]) * (j - i))\n H[i] <= H[j] ? i++ : j--\n }\n return ans\n};\n```\n\n---\n\n***Python Code:***\n\nThe best result for the code below is **140ms / 16.4MB** (beats 100% / 75%).\n```python\nclass Solution:\n def maxArea(self, H: List[int]) -> int:\n ans, i, j = 0, 0, len(H)-1\n while (i < j):\n if H[i] <= H[j]:\n res = H[i] * (j - i)\n i += 1\n else:\n res = H[j] * (j - i)\n j -= 1\n if res > ans: ans = res\n return ans\n```\n\n---\n\n***Java Code:***\n\nThe best result for the code below is **1ms / 40.3MB** (beats 100% / 88%).\n```java\nclass Solution {\n public int maxArea(int[] H) {\n int ans = 0, i = 0, j = H.length-1, res = 0;\n while (i < j) {\n if (H[i] <= H[j]) {\n res = H[i] * (j - i);\n i++;\n } else {\n res = H[j] * (j - i);\n j--;\n }\n if (res > ans) ans = res;\n }\n return ans;\n }\n}\n```\n\n---\n\n***C++ Code:***\n\nThe best result for the code below is **12ms / 17.6MB** (beats 100% / 100%).\n```c++\nclass Solution {\npublic:\n int maxArea(vector<int>& H) {\n int ans = 0, i = 0, j = H.size()-1, res = 0;\n while (i < j) {\n if (H[i] <= H[j]) {\n res = H[i] * (j - i);\n i++;\n } else {\n res = H[j] * (j - i);\n j--;\n }\n if (res > ans) ans = res;\n }\n return ans;\n }\n};\n```

Container With Most Water

container-with-most-water

You are given an integer array height of length n. There are n vertical lines drawn such that the two endpoints of the ith line are (i, 0) and (i, height[i]). Find two lines that together with the x-axis form a container, such that the container contains the most water. Return the maximum amount of water a container can store. Notice that you may not slant the container.

Array,Two Pointers,Greedy

Medium

The aim is to maximize the area formed between the vertical lines. The area of any container is calculated using the shorter line as length and the distance between the lines as the width of the rectangle. Area = length of shorter vertical line * distance between lines We can definitely get the maximum width container as the outermost lines have the maximum distance between them. However, this container might not be the maximum in size as one of the vertical lines of this container could be really short. Start with the maximum width container and go to a shorter width container if there is a vertical line longer than the current containers shorter line. This way we are compromising on the width but we are looking forward to a longer length container.

# Intuition\nAn esoteric solution to a reasonable interview question!\n\n# Approach\nSolve normally using two pointer approach. Purposefully obfuscate to one line.\n\nUses the exec() function from Python to encode a solution into a one-line string with escape codes.\n\n\\- Please, do not do this in an interview.\n\n# Complexity\n- Time complexity:\nO(n) maybe? Underlying function is still two pointer.\n\n- Space complexity:\nexec() statement makes this abhorrent.\n\n# Code\n```\nclass Solution:\n def maxArea(self, h: List[int]) -> int:\n global w, g; w, g = 0, h; exec(\'l, r, w = 0, len(g)-1, 0\\nwhile l < r:\\n\\tw = max(w, min(g[l], g[r]) * (r-l))\\n\\tif g[l] >= g[r]: r -=1\\n\\telse: l +=1\', globals()); return w\n```

Container With Most Water

container-with-most-water

You are given an integer array height of length n. There are n vertical lines drawn such that the two endpoints of the ith line are (i, 0) and (i, height[i]). Find two lines that together with the x-axis form a container, such that the container contains the most water. Return the maximum amount of water a container can store. Notice that you may not slant the container.

Array,Two Pointers,Greedy

Medium

The aim is to maximize the area formed between the vertical lines. The area of any container is calculated using the shorter line as length and the distance between the lines as the width of the rectangle. Area = length of shorter vertical line * distance between lines We can definitely get the maximum width container as the outermost lines have the maximum distance between them. However, this container might not be the maximum in size as one of the vertical lines of this container could be really short. Start with the maximum width container and go to a shorter width container if there is a vertical line longer than the current containers shorter line. This way we are compromising on the width but we are looking forward to a longer length container.

\n# Approach\n<!-- Describe your approach to solving the problem. -->\nFor maximinzing the area , breadth should be maximum , so thats why we start our "j" pointer from the last and "i" pointer to the start .\n\n# Complexity\n- Time complexity: O(N)\n<!-- Add your time complexity here, e.g. $$O(n)$$ --> \n\n- Space complexity: O(1)\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# C++\n```\nclass Solution {\npublic:\n int maxArea(vector<int>& v) {\n\n int i = 0;\n int n = v.size();\n int j = n - 1;\n int area = 0;\n\n while(j > i){\n area = max(area, min(v[i],v[j]) * abs(i - j));\n if(v[i] < v[j]) i++;\n else j--;\n }\n\n return area;\n \n }\n};\n```\n\n# Python \n```\nclass Solution:\n def maxArea(self, v):\n i = 0\n n = len(v)\n j = n - 1\n area = 0\n while j > i:\n area = max(area, min(v[i], v[j]) * abs(i - j))\n if v[i] < v[j]:\n i += 1\n else:\n j -= 1\n return area\n\n```\n\n# Java\n```\nclass Solution {\n public int maxArea(int[] arr) {\n final int N = arr.length;\n int max = 0 , area, i=0, j=N-1;\n while(j>i){\n area = arr[i] < arr[j] ? arr[i] : arr[j];\n area = (j - i) * area;\n if(max < area) max = area;\n if(arr[i] < arr[j]) i++ ;\n else j--;\n }\n return max;\n }\n}\n\n```\n# Tom need a UPVOTE : |\n\n![Upvote.gif]()\n

Integer to Roman

integer-to-roman

Roman numerals are represented by seven different symbols: I, V, X, L, C, D and M. For example, 2 is written as II in Roman numeral, just two one's added together. 12 is written as XII, which is simply X + II. The number 27 is written as XXVII, which is XX + V + II. Roman numerals are usually written largest to smallest from left to right. However, the numeral for four is not IIII. Instead, the number four is written as IV. Because the one is before the five we subtract it making four. The same principle applies to the number nine, which is written as IX. There are six instances where subtraction is used: Given an integer, convert it to a roman numeral.

Hash Table,Math,String

Medium

# Intuition of this Problem:\nThis code takes a non-negative integer as input and converts it into its corresponding Roman numeral representation. The approach used here is to store the Roman numeral values and their corresponding symbols in a vector of pairs. The algorithm then iterates through the vector and repeatedly adds the corresponding symbols to the result string while subtracting the corresponding value from the input integer until the input integer becomes zero.\n<!-- Describe your first thoughts on how to solve this problem. -->\n**NOTE - PLEASE READ APPROACH FIRST THEN SEE THE CODE. YOU WILL DEFINITELY UNDERSTAND THE CODE LINE BY LINE AFTER SEEING THE APPROACH.**\n\n# Approach for this Problem:\n1. Initialize an empty string called Roman to store the resulting Roman numeral.\n2. Create a vector of pairs called storeIntRoman, to store the Roman numeral values and their corresponding symbols.\n3. Iterate through the storeIntRoman vector using a for loop.\n4. For each pair, check if the input integer is greater than or equal to the Roman numeral value.\n5. If it is, add the corresponding symbol to the Roman string and subtract the corresponding value from the input integer.\n6. Repeat steps 4-5 until the input integer becomes zero.\n7. Return the Roman string.\n<!-- Describe your approach to solving the problem. -->\n\n# Humble Request:\n- If my solution is helpful to you then please **UPVOTE** my solution, your **UPVOTE** motivates me to post such kind of solution.\n- Please let me know in comments if there is need to do any improvement in my approach, code....anything.\n- **Let\'s connect on** \n\n![57jfh9.jpg]()\n\n# Code:\n```C++ []\n//Approach 1 : \n//time complexity - O(1) since the algorithm always iterates through a constant number of values (13 in this case).\n//O(1) since the amount of extra space used is constant (the size of the storeIntRoman vector, which is also 13 in this case\nclass Solution {\npublic:\n string intToRoman(int num) {\n string Roman = "";\n // Creating vector of pairs to store the Roman numeral values and their corresponding symbols\n vector<pair<int, string>> storeIntRoman = {{1000, "M"}, {900, "CM"}, {500, "D"}, {400, "CD"}, {100, "C"}, {90, "XC"}, {50, "L"}, {40, "XL"}, {10, "X"}, {9, "IX"}, {5, "V"}, {4, "IV"}, {1, "I"}};\n // Iterating through the vector and repeatedly adds the corresponding symbols to the result string while subtracting the corresponding value from the input integer until the input integer becomes zero.\n for (int i = 0; i < storeIntRoman.size(); i++) {\n while (num >= storeIntRoman[i].first) {\n Roman += storeIntRoman[i].second;\n num -= storeIntRoman[i].first;\n }\n }\n return Roman;\n }\n};\n```\n```C++ []\n//Approach 2\n//time complexity - O(1) since the algorithm always iterates through a constant number of values (13 in this case).\n//O(1) since the amount of extra space used is constant (the size of the storeIntRoman vector, which is also 13 in this case\nclass Solution {\npublic:\n string intToRoman(int num) {\n string ones[] = {"", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"};\n string tens[] = {"", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"};\n string hundreds[] = {"", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"};\n string thousands[]= {"", "M", "MM", "MMM"};\n \n string Roman = thousands[num / 1000] + hundreds[(num % 1000) / 100] + tens[(num % 100) / 10] + ones[num % 10];\n return Roman;\n }\n};\n```\n```Java []\nclass Solution {\n public String intToRoman(int num) {\n String Roman = "";\n int[][] storeIntRoman = {{1000, "M"}, {900, "CM"}, {500, "D"}, {400, "CD"}, {100, "C"}, {90, "XC"}, {50, "L"}, {40, "XL"}, {10, "X"}, {9, "IX"}, {5, "V"}, {4, "IV"}, {1, "I"}};\n for (int i = 0; i < storeIntRoman.length; i++) {\n while (num >= storeIntRoman[i][0]) {\n Roman += storeIntRoman[i][1];\n num -= storeIntRoman[i][0];\n }\n }\n return Roman;\n }\n}\n\n```\n```Python []\nclass Solution:\n def intToRoman(self, num: int) -> str:\n Roman = ""\n storeIntRoman = [[1000, "M"], [900, "CM"], [500, "D"], [400, "CD"], [100, "C"], [90, "XC"], [50, "L"], [40, "XL"], [10, "X"], [9, "IX"], [5, "V"], [4, "IV"], [1, "I"]]\n for i in range(len(storeIntRoman)):\n while num >= storeIntRoman[i][0]:\n Roman += storeIntRoman[i][1]\n num -= storeIntRoman[i][0]\n return Roman\n\n```\n\n# Time Complexity and Space Complexity:\n- Time complexity: **O(13) = O(1)** - Approach 1\n\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity: **O(13) = O(1)** - Approach 1\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->