Datasets:

kreimben

/

leetcode_user_submissions

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?

```\nclass Solution {\n public int[] twoSum(int[] nums, int target) {\n int n=nums.length;\n Map<Integer,Integer> map=new HashMap<>();\n int[] result=new int[2];\n for(int i=0;i<n;i++){\n if(map.containsKey(target-nums[i])){\n result[1]=i;\n result[0]=map.get(target-nums[i]);\n return result;\n }\n map.put(nums[i],i);\n }\n return result;\n }\n}\n```\n**Please Upvote if u like it**

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?

# 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 {\npublic:\n vector<int> twoSum(vector<int>& nums, int target) {\n vector<int> ans;\n unordered_map<int,int> mp;\n for(int i =0;i<nums.size();i++){\n if(mp.find(target-nums[i])!=mp.end()){\n ans.push_back(mp[target-nums[i]]);\n ans.push_back(i); \n }\n mp[nums[i]]=i; \n }\n return ans;\n }\n};\n```\nPlease upvote to motivate me to write more solutions

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 {\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) return {i,j};\n }\n }\n return {};\n }\n};\n```\n![c5b565d0-6f8d-49f1-92c3-b618d8997854_1674098653.7034152.jpeg]()

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 hashMap = {} # key: value -> number:index\n \n for i in range(len(nums)): \n diff = target - nums[i] \n \n if diff in hashMap:\n return [hashMap[diff], i]\n else:\n hashMap[nums[i]] = 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?

# Approach\n\nThe way to approach this problem is to iterate over every single item in the array and find difference between target and current number being processed.\n\nLet\u2019s keep the processed items and their index in a map (nums[i], i), so that every time we calculate the new difference, we quickly check whether that map has that item or not.\n\nLet\u2019s take 2 and 7 as an example. These are their differences and the order of when they\'ll be processed:\n```\n1. 9 - 2 = 7\n2. 9 - 7 = 2\n```\n\nFirst processed is `9 - 2`. Since difference is `7`, check if there is an element with key `7` in the map. In this case, not yet. But store `2, 0` pair.\nThe next pair that will be processed: `9 - 7`. Check for existence of 2 in the map. In this case it exists so pull out the assigned index to it and create a resulting array.\n\n# Complexity\n- Time complexity: O(n) - worse case, there are no pairs and we iterate over every single item; fetching items from a map is 0(1)\n\n- Space complexity: O(n) - we are using map to store the pairs\n\n# Code\n```\n/**\n * @param {number[]} nums\n * @param {number} target\n * @return {number[]}\n */\nvar twoSum = function(nums, target) {\n let mp = new Map()\n \n for (let i = 0; i < nums.length; i++) {\n let diff = target - nums[i]\n \n if (mp.has(diff)) {\n return [i, mp.get(diff)]\n }\n \n mp.set(nums[i], i)\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?

# 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\n<!-- Describe your first thoughts on how to solve this problem. -->\n(1) Start by sorting the input vector in ascending order. This step allows us to utilize the binary search algorithm efficiently.\n(2) For each element num in the sorted vector, calculate its complement complement by subtracting it from the target value. Then, perform a binary search on the sorted vector to find complement.\n(3) If complement is found in the sorted vector and is not the same as num, then we have found a valid pair. Return the indices of num and complement in the original unsorted vector.\n# Approach\n<!-- Describe your approach to solving the problem. -->\nBinary Search\n# Complexity\n- Time complexity: O(logN)\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 {\npublic:\n vector<int> twoSum(vector<int>& nums, int target) {\n vector<int> sortedNums = nums;\n sort(sortedNums.begin(), sortedNums.end());\n \n int left = 0;\n int right = sortedNums.size() - 1;\n \n while (left < right) {\n int sum = sortedNums[left] + sortedNums[right];\n \n if (sum == target) {\n break;\n } else if (sum < target) {\n left++;\n } else {\n right--;\n }\n }\n \n vector<int> result;\n for (int i = 0; i < nums.size(); i++) {\n if (nums[i] == sortedNums[left] || nums[i] == sortedNums[right]) {\n result.push_back(i);\n }\n }\n \n return result;\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?

# 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# Code\n```JAVA []\nclass Solution {\n public int[] twoSum(int[] A, int k) {\n HashMap<Integer, Integer> map = new HashMap<>();\n for(int i = 0, a;; i++){\n if(map.containsKey(A[i]))\n return new int[]{i, map.get(A[i])};\n map.put(k - A[i], i);\n }\n }\n}\n```\n```C []\nint* twoSum(int* nums, int N, int target, int* returnSize){\n int *arr = malloc(2*sizeof(int));\n *returnSize = 2;\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 arr[0] = i; arr[1] = j;\n return arr;\n }\n }\n }\n return arr;\n}\n```\n>>> ## Upvote\uD83D\uDC4D if you find helpful\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\nBasically, Here instead of using an extra loop, we will use the HashMap to check if the other element i.e. target-(selected element) exists. Thus we can trim down the time complexity of the problem.\n\nAnd for the second variant, we will store the element along will its index in the HashMap. Thus we can easily retrieve the index of the other element i.e. target-(selected element) without iterating the array.\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\nThe steps are as follows:\n\n1) We will select the element of the array one by one using a loop(say i).\n\n2) Then we will check if the other required element(i.e. target-arr[i]) exists in the hashMap.\n\n If that element exists, then we will return \u201CYES\u201D for the first variant or we will return the current index i.e. i, and the index of the element found using map i.e. mp[target-arr[i]].\n\n If that element does not exist, then we will just store the current element in the hashMap along with its index. Because in the future, the current element might be a part of our answer.\n\n3) Finally, if we are out of the loop, that means there is no such pair whose sum is equal to the target. In this case, we will return either \u201CNO\u201D or {-1, -1} as per the variant of the question.\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) as we use the map data structure.\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\nclass Solution {\n public int[] twoSum(int[] nums, int target) {\n int ans[] = new int [2];\n ans[0] = ans[1] = -1;\n HashMap<Integer , Integer>mapp = new HashMap<>();\n for(int i =0 ; i<nums.length ; i++){\n int G = nums[i];\n int R = target - G ;\n if(mapp.containsKey(R)){\n ans[0] = i;\n ans[1] = mapp.get(R);\n\n return ans;\n }\n\n\n mapp.put(nums[i],i);\n }\n return ans;\n }\n}\n```\n\nYour 1 upvote will make me happy...\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?

# First solution using Brute Force\n\n## Approach\n\nThe approach used in this solution is a brute force approach which involves iterating through each element of the array and checking if there is another element in the array that can be added to it to get the target value.\n\nThe function starts by getting the length of the input array. It then iterates through each element of the array using a nested loop. The outer loop iterates through the array from the first element to the second last element. The inner loop iterates through the array from the next element after the current outer loop index to the last element of the array.\n\nFor each iteration of the inner loop, the function checks if the sum of the current element and the element pointed to by the inner loop index is equal to the target value. If it is, the function returns an array of the two indices.\n\nIf no two elements in the array add up to the target value, the function returns an empty array.\n\n## Complexity\n\nAlthough this approach is simple and easy to understand, it has a *time complexity* of $$O(n^2)$$ which is not very efficient for large input arrays.\n\nThe *space complexity* of the function is $$O(1)$$.\n\n## Code\n```swift\nclass Solution {\n func twoSum(_ nums: [Int], _ target: Int) -> [Int] {\n let n = nums.count\n\n for i in 0 ..< n {\n for j in i + 1 ..< n {\n if nums[i] + nums[j] == target {\n return [i, j]\n }\n }\n }\n \n return []\n }\n}\n```\n\n---\n\n# Second solution using Dictionary\n\n## Approach\n\nThis approach to solving the problem uses a dictionary to keep track of the difference between the target and each element in the input array. \n\nThe function first initializes an empty dictionary called `dict`. \n\nThen, it loops through the array using the `enumerated()` method to get both the `index` and `value` of each element in the array. For each element, it checks if the difference between the `target` and the element is already in the dictionary. If it is, that means the current element plus the element at the index in the dictionary adds up to the `target`, so it returns the indices of those two elements. If the difference is not in the dictionary, it adds the difference as a key and the `index` as a value to the dictionary. \n\nIf the loop is completed and no two elements in the array add up to the target, the function returns an empty array. \n\n## Complexity\n\nOverall, this approach has a time complexity of $$O(n)$$ because it only needs to loop through the array once, and a space complexity of $$O(n)$$ because it needs to store the dictionary.\n\n## Code\n```swift\nclass Solution {\n func twoSum(_ nums: [Int], _ target: Int) -> [Int] {\n var dict = [Int: Int]()\n \n for (index, value) in nums.enumerated() {\n if let addent = dict[value] {\n return [addent, index]\n } else {\n dict[target - value] = index\n }\n }\n \n return []\n }\n}\n```\n\n---\n\n# Third solution using Two Pointer\n\n## Approach\n\nThe approach used in this solution is a two-pointer approach. The given array of integers `nums` is first sorted in ascending order in the line `let sortedNums = nums.sorted()`.\n\nAfter sorting, two pointers `left` and `right` are initialized at the beginning and end of the sorted array respectively. The pointers are then moved inward from both ends towards the middle of the array while checking whether the sum of the values at these pointers is equal to the target value.\n\nIf the sum of the values at the `left` and `right` pointers is equal to the `target` value, the indices of these values in the initial unsorted array are returned. If the sum is less than the `target` value, the `left` pointer is moved one step to the `right`. If the sum is greater than the `target` value, the `right` pointer is moved one step to the `left`.\n\nThis process of incrementing and decrementing the pointers continues until the sum of the values at the pointers is equal to the `target` value, or the pointers meet in the middle and there are no more values to check.\n\n## Complexity\n\nThe time complexity of this approach is $$O(n^2)$$.\n\nThe space complexity is $$O(n)$$ due to the creation of a new sorted array.\n\n## Code\n```\nclass Solution {\n func twoSum(_ nums: [Int], _ target: Int) -> [Int] {\n let sortedNums = nums.sorted()\n var left = 0\n var right = nums.count - 1\n\n while left < right {\n let sum = sortedNums[left] + sortedNums[right]\n if sum == target {\n if let index1 = nums.firstIndex(of: sortedNums[left]),\n let index2 = nums.lastIndex(of: sortedNums[right]) {\n return [index1, index2]\n }\n } else if sum < target {\n left += 1\n } else {\n right -= 1\n }\n }\n\n return []\n }\n}\n```\n\n# Upvote ^^\n\n![upvote.png]()\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?

# Pair Approach:\n\n---\n\n\n# Intuition\nCreating a pair then sort it and using two pointer. **Approach understood by example.**\n\n# Approach\nI provide the approach with a test cases. The test case is as follows --->>>\n\n**Test Case 1:**\n[2,9,7,5] and target = 9.\n1. Making a vector of pair [[2,0], [9,1], [7,2], [5,3]].\n2. Now sort it and the pair becomes --- [[2,0], [5,1], [7,2], [9,3]].\n3. Now applying two pointer on it.\n\n1. Here low is set to 0 and high is set to 3\n2. Now sum = 2+9 = 11 which is grater than target 9, sow high pointer will be decreased.\n3. Now sum = 2+7 = 9 == target.\n4. So we push index of 2 and 7 to the ans vector and return it.\n# Complexity\n- Time complexity:\n**O(nlogn)**\n\n- Space complexity:\n**O(n)**\n\n# Code\n```\nclass Solution {\npublic:\n vector<int> twoSum(vector<int>& nums, int target) {\n \n vector<pair<int, int>> v;\n vector<int> v2;\n pair<int, int> p;\n for(int i=0; i<nums.size(); i++){\n p.first = nums[i];\n p.second = i;\n v.push_back(p);\n }\n sort(v.begin(), v.end());\n auto it = v.begin(), it2 = v.end();\n it2 --;\n while(it < it2){\n int sum = it->first + it2->first;\n if(sum == target){\n v2.push_back(it->second);\n v2.push_back(it2->second);\n return v2;\n }\n else if(sum < target)\n it ++;\n else \n it2 --;\n }\n \n return v2;\n }\n};\n```\n\n\n\n\n# Map Approach:\n\n---\n\n# Intuition\nCreating a map and searching through it. **Approach understood by example.**\n\n# Approach\nI provide the approach with two test cases. If approach of test case 1 can\'t understood by you then see approach 2 also. The test cases are as follows --->>>\n\n**Test Case 1:**\n[2,5,7,9] and target = 9.\n1. First we insert the first element of the array i.e. 2 into the map.\n2. Now the map contain [2,0], where 2 is key and 0 is index.\n3. Now we iterate the for loop from 1. So nums[i] i.e. nums[1]=5. To make the some 9 we need the element, 9-5 i.e. 4.\n4. So we store in temp i.e. temp = target-nums[i] i.e. 4.\n5. Now checking that is 4 present in the map. If present then push the index of it to the vector i.e. v.push_back(mp[temp]) and v.push_back(i). But the if condition does not satisfy here.\n6. Else if the temp value not present in the map insert the current element with it index into the map i.e. the else statement is executed here. So after this the map will contain [[2,0], [5,1]].\n7. For second ieration of the loop the element is 7 and to make sum 9 we need the element 9-7=2. Now searching that if two presented in the map and the ans is yes so if condition executed and pushing the index of element 2 to the vector and the inde of 7 also and return it.\n\n**Test Case 2:**\n[3,3] and target = 6.\n1. First we insert the first element of the array i.e. 3 into the map.\n2. Now the map contain [3,0].\n3. Now we iterate the for loop from 1. So nums[i] i.e. nums[1]=3. To make the some 6 we need the element, 6-3 i.e. 3.\n4. So we store in temp i.e. temp = target-nums[i] i.e. 3.\n5. Now checking that is 3 present in the map. Here it present so push the index of it to the vector i.e. v.push_back(mp[temp]) which will push 0 and v.push_back(i) which will push the current index 1.\n# Complexity\n- Time complexity:\n**O(n)**\n\n- Space complexity:\n**O(n)**\n\n# Code\n```\nclass Solution {\npublic:\n vector<int> twoSum(vector<int>& nums, int target) {\n unordered_map<int,int> mp;\n vector<int> v;\n mp[nums[0]] = 0;\n for(int i=1; i<nums.size(); i++){\n int temp = target-nums[i];\n if(mp.find(temp) != mp.end()){\n v.push_back(mp[temp]);\n v.push_back(i);\n return v;\n }\n else\n mp[nums[i]] = i;\n }\n return v;\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?

Hi, this is my accepted JAVA solution. It only go through the list once. It\'s shorter and easier to understand. Hope this can help someone. Please tell me if you know how to make this better :)\n\n\n public int[] twoSum(int[] numbers, int target) {\n int[] result = new int[2];\n Map<Integer, Integer> map = new HashMap<Integer, Integer>();\n for (int i = 0; i < numbers.length; i++) {\n if (map.containsKey(target - numbers[i])) {\n result[1] = i;\n result[0] = map.get(target - numbers[i]);\n return result;\n }\n map.put(numbers[i], i);\n }\n return result;\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\n1. The problem requires finding two numbers in the given vector that add up to a target value.\n\n1. By using an unordered map, we can efficiently store the elements of the vector along with their indices for quick access.\n\n1. The idea is to iterate through the vector and for each element, calculate the required number needed to reach the target value.\n\n1. We check if the required number is already present in the map. If it is, it means we have found a pair of numbers that add up to the target.\n\n1. If the required number is not found in the map, we store the current element and its index in the map.\n\n1. This way, as we iterate through the vector, we can quickly check if the required number for each element is present in the map.\n\n1. Once we find a pair of numbers that add up to the target, we return their indices.\n\n1. If we iterate through the entire vector without finding a solution, we return {-1, -1} to indicate that no valid pair of numbers was found.\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\nO(N)\n\n- Space complexity:\nO(N)\n# Code\n```\nclass Solution {\npublic:\n vector<int> twoSum(vector<int>& nums, int target) {\n unordered_map<int, int> mp; // Map to store number-index pairs\n vector<int> ans; // Vector to store the indices of the two numbers\n \n for (int i = 0; i < nums.size(); i++) {\n int required = target - nums[i]; // Calculate the number required to achieve the target\n \n // Check if the required number is already in the map\n if (mp.find(required) != mp.end()) {\n ans.push_back(i); // Index of the current number\n ans.push_back(mp[required]); // Index of the required number\n return ans; // Return the indices and exit the loop\n }\n \n mp[nums[i]] = i; // Add the number-index pair to the map\n }\n \n return {-1, -1}; // Return {-1, -1} if no solution is found\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?

\n# Code\n```\nclass Solution {\n public int[] twoSum(int[] nums, int target) {\n \n Map<Integer, Integer> indexMap = new HashMap<Integer, Integer>();\n \n for (int i = 0; i < nums.length; i++) {\n if (indexMap.containsKey(target - nums[i])) {\n return new int[]{indexMap.get(target - nums[i]), i};\n }\n indexMap.put(nums[i], i);\n }\n \n return null;\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\nYou can use Brute Force to sovle this ques in O(n^2) but the task was to reduce the time complexity .\n\n# Approach\n1--> If we sort this array and use 2 pointer to find sum of the target then the time complexity can be reducted .\n\n2--> Put s on 0 and e on n-1 then is nums[s]+nums[e]>target ; e-- and if it is less than target than s++; eventually you fill find those numbers .\n\n2--> Create a copy of origanl vector and find those number in it for index value .\n\n3--> Included a variable p so that it does not returns the same index again for same numbers .\n\n# Complexity\n- Time complexity:\nO(n log n)\n\n- Space complexity:\nO(n)\n\n# Code\n```\nclass Solution {\npublic:\n int indexFinder(vector<int> v,int n,int &p){\n for(int i=0; i<v.size(); i++){\n if(v[i]==n && p!=i){\n p=i;\n return i;\n }\n }\n return -1;\n }\n\n vector<int> twoSum(vector<int>& nums, int target) {\n vector<int> ans;\n vector<int> orignal = nums;\n sort(nums.begin(),nums.end());\n int s=0;\n int e=nums.size()-1;\n while(s<e){\n if(nums[s]+nums[e]==target){\n break;\n }\n else if(nums[s]+nums[e]>target){\n e--;\n }\n else{\n s++;\n }\n }\n int i=-2;\n ans.push_back(indexFinder(orignal,nums[s],i));\n ans.push_back(indexFinder(orignal,nums[e],i));\n return ans;\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\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 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```

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?

The key to the problem is that there is ALWAYS only 1 pair of numbers that satisfy the condition of adding together to be the target value. \nWe can assume that for all the numbers in the list (**x1, x2, ... xn**) that there exists a pair such that **xa + xb = target** \nTo solve this with a single pass of the list we can change the equation above to **xa = target - xb** and since we know the target as long as we maintain a record of all previous values in the list we can compare the current value (**xa**) to it\'s ONLY pair, if it exists, in record of all previous values (**xb**)\n\nTo keep a record of the previous values and their indices I have used a dictionary. Commonly known as a map in other languages. This allows me to record each previous number in the dictionary alongside the indice as a key value pair (target-number, indice). \n```\nclass Solution(object):\n\tdef twoSum(self, nums, target):\n\t\tbuffer_dictionary = {}\n\t\tfor i in rangenums.__len()):\n\t\t\tif nums[i] in buffer_dictionary:\n\t\t\t\treturn [buffer_dictionary[nums[i]], i] #if a number shows up in the dictionary already that means the \n\t\t\t\t\t\t\t\t\t\t\t\t\t\t#necesarry pair has been iterated on previously\n\t\t\telse: # else is entirely optional\n\t\t\t\tbuffer_dictionary[target - nums[i]] = i \n\t\t\t\t# we insert the required number to pair with should it exist later in the list of numbers\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 really found my solution helpful please upvote it, as it motivates me to post such kind of codes and help the coding community, if you have some queries or some improvements please feel free to comment and share your views.**\n```\n//Ist Approach\n vector<int> twoSum(vector<int>& nums, int target) {\n vector<pair<int,int>> v;\n for(int i=0;i<nums.size();i++)\n v.push_back({nums[i],i});\n sort(v.begin(),v.end());\n int i=0;\n int j=v.size()-1;\n int idx1=0;\n int idx2=0;\n while(i<j)\n {\n if(v[i].first+v[j].first==target)\n {\n idx1=v[i].second;\n idx2=v[j].second;\n break;\n \n }\n if(v[i].first+v[j].first<target)\n i++;\n if(v[i].first+v[j].first>target)\n j--;\n }\n return {idx1,idx2};\n }\n//Time Complexity:O(nlogn)\n//Time Complexity:O(n)\n\n//Second Approach\n\n vector<int> twoSum(vector<int>& nums, int target) {\n vector<int> v;\n unordered_map<int,int> m;\n for(int i=0;i<nums.size();i++)\n {\n if(m.find(target-nums[i])!=m.end())\n {\n v.push_back(m[target-nums[i]]);\n v.push_back(i);\n return v;\n }\n else\n m[nums[i]]=i;\n }\n return v;\n }\n\n//Time Complexity:O(n)\n//Space Complexity:O(n)\n\n//Third Approach\nvector<int> twoSum(vector<int>& nums, int target) {\n vector<int> index;\n int size=nums.size();\n for(int i=0;i<size;i++)\n {\n int k=target-nums[i];\n for(int j=i+1;j<size;j++)\n {\n if(nums[j]==k)\n {\n index.push_back(i);\n index.push_back(j);\n break;\n }\n }\n if(index.size()==2)\n break;\n }\n return index;\n }\n\t//Time Complexity: O(n^2)\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?

**\u2714\uFE0F Solution 1: HashMap**\n- We need to find 2 numbers `a`, `b` so that `a + b = target`.\n- We need a HashMap datastructure to store elements in the past, let name it `seen`. \n- The idea is that we iterate `b` as each element in `nums`, we check if we found `a` (where `a = target - b`) in the past.\n\t- If `a` exists in `seen` then we already found 2 numbers `a` and `b`, so that `a + b = target`, just output their indices.\n\t- Else add `b` to the `seen`.\n<iframe src="" frameBorder="0" width="100%" height="280"></iframe>\n\n**Complexity**\n- Time: `O(N)`, where `N <= 10^4` is number of elements in the array `nums`.\n- Space: `O(N)`\n\n---\n\n**\u2714\uFE0F Solution 2: Sort then Two Pointers**\n- Since this problem require to output **pair of indices** instead of **pair of values**, so we need an array, let say `arr` to store their value with their respective indices. \n- Sort array `arr` in increasing order by their values.\n- Then use two pointer, left point to first element, right point to last element.\n\n<iframe src="" frameBorder="0" width="100%" height="450"></iframe>\n\n**Complexity**\n- Time: `O(N * logN)`, where `N <= 10^4` is number of elements in the array `nums`.\n- Space: `O(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?

# Intuition\nThe Two Sum issue requires us to discover two integers in an array that add up to a certain goal value. We must return the indices of these two integers.\n\n# Approach\nA hash table (unordered_map in C++) is a more efficient technique. We may cycle through the array once and verify if the goal minus the current element exists in the hash table for each element. If it does, we\'ve discovered a legitimate pair of numbers. If not, the current element is added to the hash table.\n\n\n\n\n\n**Approach using a hash table**:\n\n1Make an empty hash table to to store elements and their indices.\n\n2.Iterate through the array from left to right.\n\n3.For each element nums[i], calculate the complement by subtracting it from the target: complement = target - nums[i].\n\n4.Determine whether the complement exists in the hash table. If it does, we have found a solution.\n\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.\n\n6.Repeat steps 3-5 until a solution is found or reach the end of the array.\n\n7.Return an empty array or an acceptable indication if no solution is discovered.\n\n\n\nThis method has a time complexity of **O(n)** because the average lookup time in a hash table is constant. By iterating through the array only once, we can efficiently solve the Two Sum problem using this approach.\n\n\n\n\n\n# Code\n```\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 {}; \n }\n};\n```\n\n**If you found my solution to be useful, I would greatly appreciate your upvote, as it would encourage me to continue sharing more solutions.**\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\n<!-- Describe your first thoughts on how to solve this problem. -->\nTo find the pair of numbers that sum up to the given target, we can try to find the $$complement$$ of each number and if it is present in the array, we can return it as our answer. \n\nHere, the term \'complement\' refers to the following equation-\n\nLet \'n\' be an element in the given array.\nComplement of n = target-n\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\nTraverse through the given array and try to find $$complement$$ of it in the hashtable. If found, return the indices of both the numbers. Else, add the element and its index to the hashmap and repeat the process for the subsequent elements in the array.\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**NOTE:** The space complexity for the above question can be reduced by sorting the array and using two-pointer approach. However, this will be at the cost of the time complexity as sorting the given array will bump it upto $$O(NlogN)$$.\n\n# Code\n```\nclass Solution {\npublic:\n vector<int> twoSum(vector<int>& nums, int target) {\n unordered_map<int, int> numsMap;\n\n for(int i=0;i<nums.size();i++){\n auto it=numsMap.find(target-nums[i]);\n\n if(it!=numsMap.end()) return {i, it->second};\n numsMap.insert({nums[i], i});\n }\n return {-1, -1};\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?

# 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?

\nit\'s easy.\n# Code\n```\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[j]==target-nums[i]){\n return new int[]{i,j};\n }\n }\n }\n return null;\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?

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

**//Brute force method**\n\n# Complexity\n- Time complexity:O(n^2)\n- Space complexity:O(1)\n\n# Code\n```\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 //Here we can return like this without creating new vector for answer\n return {i,j}; \n }\n }\n }\n return {};\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?

\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n* An **unordered map** `mp` is created to store the elements of the array a and their indices.\n\n* For loop is used to iterate over each element in the array a.\n\n* For each element, the difference between the target value and the element is calculated and stored in the variable `diff`.\n\n* If the difference `diff` is** not present** in the map `mp`, the element **a[i]** is added to the map with its index as the value.\n\n* If the difference `diff` is present in the map `mp`, the indices of the two numbers that add up to the target are returned as a vector.\n\nIf no such pair is found in the array, the function returns the vector `{-1,-1}`.\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n$$O(n)$$\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n$$O(n)$$\n\n# Code\n```\nclass Solution {\npublic:\n vector<int> twoSum(vector<int>& a , int target) {\n\n int n=a.size();\n unordered_map<int,int>mp;\n\n for(int i=0;i<n;i++){\n int diff=target-a[i];\n if(mp.find(diff)==mp.end()) mp[a[i]]=i;\n else return {mp[diff],i};\n }\n return {-1,-1};\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?

\n~~~\nclass Solution:\n def twoSum(self, nums: List[int], target: int) -> List[int]:\n for i in range(len(nums)):\n j = target - nums[i]\n if j in nums and nums.index(j) != i:\n return [i,nums.index(j)]

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?

# 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 1.1\n```\nclass Solution {\npublic:\n vector<int> twoSum(vector<int>& nums, int target) {\n\n unordered_map<int, int> mp;\n\n for(int i = 0; i < nums.size(); i++){\n if(mp.count(target - nums[i]))\n return {mp[target - nums[i]], i};\n else\n mp[nums[i]] = i;\n }\n return {};\n } \n};\n```\n# Code 1.2\n```\nclass Solution {\npublic:\n vector<int> twoSum(vector<int>& nums, int target) {\n unordered_map<int, int> mp;\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 return {};\n } \n};\n```\n# Code 2\n```\nclass Solution {\npublic:\n vector<int> twoSum(vector<int>& nums, int target) {\n int l=0;\n int r=1;\n while(l<nums.size()-1){\n while(r<nums.size()){\n if(nums[l]+nums[r] == target){\n return {l,r};\n }\n r++;\n }\n l++;\n r=l+1;\n }\n return {};\n } \n};\n```\n![4i5ri4f9.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?

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

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?

* class Solution {\npublic:\n vector<int> twoSum(vector<int>& nums, int target) {\n unordered_map<int, int> seen;\n for (int i = 0; i < nums.size(); ++i) {\n int b = nums[i], a = target - b;\n if (seen.count(a)) return {seen[a], i}; // Found pair of (a, b), so that a + b = target\n seen[b] = i;\n }\n return {};\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?

```\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 nums[i] + nums[j] == target:\n return [i, j]\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?

import java.util.Scanner;\n class Solution {\n public static int[] twoSum(int[] nums, int target) {\n int addOfIndex;\n // System.out.println("Number of elements in nums :"+nums.length);\n for (int i = 0; i < nums.length; i++) {\n for (int j = i + 1; j < nums.length; j++) {\n int[] add = new int[2];\n addOfIndex = nums[i] + nums[j];\n if (addOfIndex == target) {\n add[0] = i;\n add[1] = j;\n return add;\n }\n }\n }\n\n return null;\n }\n public static void main(String []args){\n Scanner sc=new Scanner(System.in);\n // Solution s1=new Solution;\n System.out.println("Enter number of element :");\n int n=sc.nextInt();\n System.out.println("Enter your elements :");\n int [] nums=new int[n];\n for(int k=0; k<n; k++){\n nums[k]=sc.nextInt();\n }\n System.out.println("Enter your target :");\n int target= sc.nextInt();\n int[] ret = new Solution().twoSum(nums, target);\n// System.out.println(ret);\n System.out.println("["+ret[0]+","+ret[1]+"]");\n }\n }\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

# 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

# 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(max(l1,l2)).\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```\n/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\n ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {\n ListNode* dummy=new ListNode();\n ListNode* temp=dummy;\n int carry=0;\n while(l1!=NULL || l2!=NULL || carry){\n int sum=0;\n if(l1!=NULL){\n sum+=l1->val;\n l1=l1->next;\n }\n if(l2!=NULL){\n sum+=l2->val;\n l2=l2->next;\n }\n sum+=carry;\n carry=sum/10;\n ListNode* newnode=new ListNode(sum%10);\n temp->next=newnode;\n temp=temp->next;\n }\n return dummy->next;\n }\n};\nif it helps plzz dont\'t forget to upvote it :)\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

\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

How\'s going, Ladies n Gentlemen, today we are going to solve one of the coolest problem **Add Two Numbers**\n\nSo, what the problem statement is saying we have given 2 linkedlist we have to add them and get the sum in another linkedlist.\n\nWhat, am saying let\'s understand with an example:-\n**Input**: l1 = [1,2,4,3], l2 = [5,4,6]\n**Output**: [6,6,0,4]\n\n![image]()\n\nNow let\'s create another list in which we will get our sum. So, that list intially we will called as dummy list with any value of your choice present in that. *I\'ll put 0 as we indian has invented that. <^^>*\n\nAnd one more last thing, we\'ll gonna create one pointer and let\'s say i\'ll call it **curr** which is pointing on dummy node and traverse along with it\n\n![image]()\n\nAlright so, here we go ladies n gentlemen, It\'s time to sum up these node value, for that we will create one another variable let\'s called it **sum** and put the sum of **l1 & l2** them into our dummy list. So, we start it from all the way left go to all the way right. Now you will ask, dude what about the carry values we get after sum up.\nWell, hold on i\'m coming on that point don\'t worry.\n\nSo, for that what you have to do is, we will intialize one more variable name **carry** if we found carry of let\'s say 10. First we will modulo it like carry = sum % 10 i.e. carry = 10 % 10 i.e. 0 we will add 0 into our node and after that what we will do is get the carry as carry = sum / 10 i.e. carry = 10 / 10 i.e. 1. Now we are having carry as 1. So, in the next node sum of l1 & l2 we will add carry as well.\n\nFor sum we will use this formula :- **sum = l1 + l2 + carry**\n\nWe did a lot of talk, let\'s understand it visually:-\n* 1st step->\n![image]()\n\n* 2nd Step->\n![image]()\n* 3rd Step->\n![image]()\n\nNow I hope Ladies n Gentlemen, you got the crystal clear idea, what we are doing. So, without any further due ***let\'s code up***\n\n**Java**\n\n```\nclass Solution {\n public ListNode addTwoNumbers(ListNode l1, ListNode l2) {\n ListNode dummy = new ListNode(0); // creating an dummy list\n ListNode curr = dummy; // intialising an pointer\n int carry = 0; // intialising our carry with 0 intiall\n // while loop will run, until l1 OR l2 not reaches null OR if they both reaches null. But our carry has some value in it. \n\t\t// We will add that as well into our list\n while(l1 != null || l2 != null || carry == 1){\n int sum = 0; // intialising our sum\n if(l1 != null){ // adding l1 to our sum & moving l1\n sum += l1.val;\n l1 = l1.next;\n }\n if(l2 != null){ // adding l2 to our sum & moving l2\n sum += l2.val;\n l2 = l2.next;\n }\n sum += carry; // if we have carry then add it into our sum\n carry = sum/10; // if we get carry, then divide it by 10 to get the carry\n ListNode node = new ListNode(sum % 10); // the value we\'ll get by moduloing it, will become as new node so. add it to our list\n curr.next = node; // curr will point to that new node if we get\n curr = curr.next; // update the current every time\n }\n return dummy.next; // return dummy.next bcz, we don\'t want the value we have consider in it intially!!\n }\n}\n```\n\n**C++**\n```\nclass Solution {\npublic:\n ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {\n ListNode *dummy = new ListNode(0);\n ListNode *curr = dummy;\n int carry = 0;\n \n while(l1 != NULL || l2 != NULL || carry == 1){\n int sum = 0;\n if(l1 != NULL){\n sum += l1->val;\n l1 = l1->next;\n }\n if(l2 != NULL){\n sum += l2->val;\n l2 = l2->next;\n }\n sum += carry;\n carry = sum/10;\n ListNode *node = new ListNode(sum % 10);\n curr->next = node;\n curr = curr->next;\n }\n return dummy->next;\n }\n};\n```\n\nANALYSIS :-\n* **Time Complexity :-** BigO(max(N, M)) where N is length of l1 & M is length of l2\n\n* **Space Complexity :-** BigO(max(N,M))

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<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\n/**\n * Definition for singly-linked list.\n * public class ListNode {\n * int val;\n * ListNode next;\n * ListNode() {}\n * ListNode(int val) { this.val = val; }\n * ListNode(int val, ListNode next) { this.val = val; this.next = next; }\n * }\n */\nclass Solution {\n public ListNode addTwoNumbers(ListNode l1, ListNode l2) {\n int c=0;\n ListNode head=new ListNode(0);\n ListNode l3=head,p1=l1,p2=l2;\n while(p1!=null||p2!=null){\n if(p1!=null){\n c+=p1.val;\n p1=p1.next;\n }\n if(p2!=null){\n c+=p2.val;\n p2=p2.next;\n }\n l3.next=new ListNode(c%10);\n l3=l3.next;\n c/=10; \n }\n if(c==1){\n l3.next=new ListNode(1);\n \n }\n return head.next;\n }\n}\n```\nUpvotes are encouraging

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

### Description\nOne of the basic structures in algorithm which can be used to achieve lots of funny algorithms and problems. \n\n### Problems\nThere will be some of the most typical problems in this aspect, which I believe almost covers all the basic techniques that you need to solve a linked list problem.\n\n#### Remove Duplicates from Sorted List\nGiven a sorted linked list, delete all duplicates such that each element appear only once.\n\n> For example,\nGiven 1->1->2, return 1->2.\nGiven 1->1->2->3->3, return 1->2->3.\n\n##### Solution\n\nWe can just solve it like in an array using another index to collect the valid nodes. Here, once I made a serious mistake inserting extra `;` after `while` which directly result in an in-debuggeable situation.\n\n```\nListNode* deleteDuplicates(ListNode* head) {\n if(!head) return head;\n ListNode *t = head, *p = head->next;\n int pre = head->val;\n while(p) {\n if(pre != p->val) {\n t->next = p;\n pre = p->val;\n t = t->next;\n }\n p = p->next;\n }\n t->next = NULL;\n return head;\n}\n```\n#### Remove Duplicates from Sorted List II\nGiven a sorted linked list, delete all nodes that have duplicate numbers, leaving only distinct numbers from the original list.\n\n> For example,\nGiven 1->2->3->3->4->4->5, return 1->2->5.\nGiven 1->1->1->2->3, return 2->3.\n\n##### Solution\n###### Iterative\n```\nListNode* deleteDuplicates(ListNode* head) {\n\tListNode* dummy = new ListNode(0);\n\tdummy->next = head;\n\tListNode* cur = dummy;\n\tint duplicate;\n\twhile (cur->next && cur->next->next) {\n\t\tif (cur->next->val == cur->next->next->val) {\n\t\t\tduplicate = cur->next->val;\n\t\t\twhile (cur->next && cur->next->val == duplicate) \n\t\t\t\tcur->next = cur->next->next;\n\t\t}\n\t\telse cur = cur->next;\n\t}\n\treturn dummy->next;\n}\n```\n###### Recursive\n```\nListNode* deleteDuplicates(ListNode* head) {\n if (!head) return 0;\n if (!head->next) return head;\n int val = head->val;\n ListNode* p = head->next;\n if (p->val != val) { head->next = deleteDuplicates(p); return head;} \n else { \n while (p && p->val == val) p = p->next; \n return deleteDuplicates(p); \n }\n}\n```\n\n#### Palindrome Linked List\nGiven a singly linked list, determine if it is a palindrome. \n\n> Follow up:\nCould you do it in O(n) time and O(1) space?\n\n##### Solution\nConverting the linked list into an array to simplify the checking.\n```\nbool isPalindrome(ListNode* head) {\n vector<int> v;\n while(head) {\n v.push_back(head->val);\n head = head->next;\n }\n for(int i = 0; i < v.size()/2; ++i) {\n if(v[i] != v[v.size()-i-1]) return false;\n }\n return true;\n}\n```\n\nJust do it using linked list\n\n```\nbool isPalindrome(ListNode* head) {\n if(!head || !head->next) return true;\n ListNode *slow = head, *fast = head->next;\n while(fast && fast->next) {//split into two halves while the first half can be one-node longer;\n slow = slow->next;\n fast = fast->next->next;\n }\n fast = slow->next;\n slow->next = NULL;\n ListNode newHead(0); //reverse the second half;\n ListNode *next = NULL, *p = fast;\n while(p) {\n next = p->next;\n p->next = newHead.next;\n newHead.next = p;\n p = next;\n }\n fast = newHead.next; //compare the two lists;\n while(fast) {\n if(fast->val != head->val) return false;\n fast = fast->next;\n head = head->next;\n }\n return fast == NULL;\n}\n```\n\n#### Rotate List\nGiven a list, rotate the list to the right by k places, where k is non-negative.\n\n> For example:\nGiven 1->2->3->4->5->NULL and k = 2,\nreturn 4->5->1->2->3->NULL.\n\n##### Solution\n\n```\nListNode* rotateRight(ListNode* head, int k) {\n if(!head) return head;\n int len = 1;\n ListNode *p = head;\n while(p->next) { len++; p = p->next; }\n p->next = head;\n if(k %= len)\n for(int i = 0; i < len-k; ++i, p=p->next) ; \n ListNode* newHead = p->next;\n p->next = NULL;\n return newHead;\n}\n```\n\n#### Add Two Numbers\nYou are given two linked lists representing two non-negative numbers. The digits are stored in reverse order and each of their nodes contain a single digit. Add the two numbers and return it as a linked list.\n\n> Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)\nOutput: 7 -> 0 -> 8\n\n##### Solution\n\n###### Iterative \n\n```\nListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {\n int c = 0;\n ListNode newHead(0);\n ListNode *t = &newHead;\n while(c || l1 || l2) {\n c += (l1? l1->val : 0) + (l2? l2->val : 0);\n t->next = new ListNode(c%10);\n t = t->next;\n c /= 10;\n if(l1) l1 = l1->next;\n if(l2) l2 = l2->next;\n }\n return newHead.next;\n}\n```\n\n###### Recursive\n```\nListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {\n if(!l1 && !l2) return NULL;\n int c = (l1? l1->val:0) + (l2? l2->val:0);\n ListNode *newHead = new ListNode(c%10), *next = l1? l1->next:NULL;\n c /= 10;\n if(next) next->val += c;\n else if(c) next = new ListNode(c);\n newHead->next = addTwoNumbers(l2? l2->next:NULL, next);\n return newHead;\n}\n```\n\n#### Reverse Linked List II\nReverse a linked list from position m to n. Do it in-place and in one-pass.\n\n> For example:\nGiven 1->2->3->4->5->NULL, m = 2 and n = 4, \nreturn 1->4->3->2->5->NULL.\n\n> Note: Given m, n satisfy the following condition: 1 \u2264 m \u2264 n \u2264 length of list.\n\n##### Solution\n\n```\nListNode* reverseBetween(ListNode* head, int m, int n) {\n ListNode newHead(0);\n newHead.next = head;\n ListNode *pre = &newHead, *cur = head, *next = NULL;\n int i = 1;\n while(i < n) {\n if(i++ < m) { pre = cur; cur = cur->next; }\n else { \n next = cur->next; \n cur->next = cur->next->next; \n next->next = pre->next; \n pre->next = next; \n }\n }\n return newHead.next;\n}\n```\n\n#### Linked List Cycle II\nGiven a linked list, return the node where the cycle begins. If there is no cycle, return null. Note: Do not modify the linked list. \n\n> Follow up:\nCan you solve it without using extra space?\n\n##### Solution\nActually we can just use `set.insert(key).second` to check but it will take up O(n) space which is quite an awful waste, so here we just going to check the circle and then locate it.\n\n- If there is a circle then once the slow meets the fast the first time, there will be a formula as follows: a+b+kl = 2(a+b) -> kl-b = a (a is the length between the head and the start of the circle, b is the steps the slow pointer moves in the circle while l is the length of the circle).\n- After that we can reset the fast and slow down the fast (same speed as the slow using kl-b = a) then once they meet again, the location will be the start of the circle.\n\nAt last we take up constant space to solve this and traverse the linked list twice at most (as for the slow pointer).\n\n```\nListNode *detectCycle(ListNode *head) {\n ListNode *slow = head, *fast = head; \n while(fast && fast->next) {\n slow = slow->next;\n fast = fast->next->next;\n if(slow == fast) break;\n }\n if(slow != fast) return NULL;\n fast = head;\n while(fast && fast->next) {\n if(slow == fast) return slow;\n slow = slow->next;\n fast = fast->next;\n }\n return NULL;\n}\n```\n\n#### Copy List with Random Pointer\n linked list is given such that each node contains an additional random pointer which could point to any node in the list or null. \nReturn a deep copy of the list.\n\n[test]()\n\n##### Solution\n\n\n###### Recursive\n\n```\nclass Solution {\n unordered_map<RandomListNode*, RandomListNode*> cloneMap;\n RandomListNode *helper(RandomListNode* head){\n if(head == NULL) return NULL;\n if(cloneMap.count(head)) return cloneMap[head];\n RandomListNode *cloned = new RandomListNode(head->label);\n cloneMap[head] = cloned; //crucial;\n cloned->next = helper(head->next);\n cloned->random = helper(head->random);\n return cloned;\n }\npublic:\n RandomListNode *copyRandomList(RandomListNode *head) {\n return helper(head);\n } \n};\n```\n\n###### Iterative\n\n```\nRandomListNode *copyRandomList(RandomListNode *head) {\n\tRandomListNode newHead(0), *p = head, *t = NULL;\n\twhile(p) {\n\t\tRandomListNode *cloned = new RandomListNode(p->label);\n\t\tcloned->next = p->next;\n\t\tp->next = cloned;\n\t\tp = cloned->next;\n\t}\n\tp = head;\n\twhile(p && p->next) {\n\t\tif(p->random) p->next->random = p->random->next;\n\t\tp = p->next->next;\n\t}\n\tp = head;\n\tt = &newHead;\n\twhile(p && p->next) {\n\t\tt->next = p->next;\n\t\tp->next = p->next->next;\n\t\tt = t->next;\n\t\tp = p->next;\n\t}\n\tt->next = NULL;\n\treturn newHead.next;\n}\n```\n\n#### Reverse Nodes in k-Group\nGiven a linked list, reverse the nodes of a linked list k at a time and return its modified list. If the number of nodes is not a multiple of k then left-out nodes in the end should remain as it is. You may not alter the values in the nodes, only nodes itself may be changed. Only constant memory is allowed.\n\n> For example,\nGiven this linked list: 1->2->3->4->5 \nFor k = 2, you should return: 2->1->4->3->5 \nFor k = 3, you should return: 3->2->1->4->5\n\n##### Solution\n\n```\nListNode* reverseKGroup(ListNode* head, int k) {\n\tif(!head || !head->next) return head;\n\tListNode newHead(0);\n\tListNode *pre = &newHead, *cur = head, *next = NULL;\n\tnewHead.next = head;\n\tint len = 0;\n\tfor(ListNode *p = head; p; p = p->next) len++;\n\tint times = len/k;\n\twhile(times) {\n\t\tfor(int i = 1; i < k; ++i) {\n\t\t\tnext = cur->next;\n\t\t\tcur->next = cur->next->next;\n\t\t\tnext->next = pre->next;\n\t\t\tpre->next = next;\n\t\t\tif(i == k-1) {\n\t\t\t\tpre = cur;\n\t\t\t\tcur = cur->next;\n\t\t\t}\n\t\t}\n\t\ttimes--;\n\t}\n\treturn newHead.next;\n}\n```\n\nAlways welcome new ideas and `practical` tricks, just leave them in the comments!

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

```\nclass Solution{\npublic:\n int len(ListNode *&head){\n ListNode *p = head;\n int c = 0;\n while (p){\n c++;\n p = p->next;\n }\n return c;\n }\n ListNode *addTwoNumbers(ListNode *l1, ListNode *l2){\n ListNode *p = l1, *q = l2, *temp;\n bool c = 0;\n bool bre = 0;\n if (len(l1) >= len(l2)){\n while (p){\n if (q == NULL){\n bre = 1;\n break;\n }\n p->val += (q->val + c);\n if (p->val > 9){\n c = 1;\n p->val = p->val - 10;\n }\n else{\n c = 0;\n }\n if (p->next == NULL){\n temp = p;\n }\n p = p->next;\n q = q->next;\n }\n if(bre){\n while (p){\n p->val += c;\n if (p->val == 10){\n p->val = 0;\n c = 1;\n }\n else{\n c = 0;\n }\n if (p->next == NULL){\n temp = p;\n }\n p = p->next;\n }\n }\n if (c){\n ListNode *n = new ListNode(1);\n temp->next = n;\n }\n return l1;\n }\n while (q){\n if (p == NULL){\n bre = 1;\n break;\n }\n q->val += p->val + c;\n if (q->val > 9){\n c = 1;\n q->val = q->val - 10;\n }\n else{\n c = 0;\n }\n if (q->next == NULL){\n temp = q;\n }\n p = p->next;\n q = q->next;\n }\n while (q){\n q->val += c;\n if (q->val == 10){\n q->val = 0;\n c = 1;\n }\n else{\n c = 0;\n }\n if (q->next == NULL){\n temp = q;\n }\n q = q->next;\n }\n if (c){\n ListNode *n = new ListNode(1);\n temp->next = n;\n }\n return l2;\n }\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

# 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

\n# Code\n```\nclass Solution {\n public ListNode addTwoNumbers(ListNode list1, ListNode list2) {\n ListNode dummyHead = new ListNode(0);\n ListNode result = dummyHead;\n int sum = 0, carry = 0;\n \n while (list1 != null || list2 != null) {\n sum = 0;\n \n if (list1 != null) {\n sum += list1.val;\n list1 = list1.next;\n }\n \n if (list2 != null) {\n sum += list2.val;\n list2 = list2.next;\n }\n \n if (carry != 0) {\n sum += carry;\n }\n \n if (sum / 10 != 0) {\n ListNode newNode = new ListNode(sum % 10);\n result.next = newNode;\n carry = sum / 10;\n result = newNode;\n } else {\n ListNode newNode = new ListNode(sum);\n result.next = newNode;\n carry = 0;\n result = newNode;\n }\n }\n \n if (carry != 0) {\n ListNode newNode = new ListNode(carry);\n result.next = newNode;\n result = newNode;\n }\n \n return dummyHead.next;\n }\n}\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

# **PLEASE UPVOTE IF YOU LIKE THE SOLUTION**\n[]()\n[]()\n# Approach\nnitialization:\n\ncarry is initialized to 0, which represents the carry-over value when adding digits.\nA new linked list l3 is created with a dummy node containing value 0. The head points to the start of this list, and l3 is used to build the result linked list.\nMain Loop:\nThe main loop iterates through both input linked lists (l1 and l2) until either of them becomes NULL. The loop performs the following steps:\n\nCalculate the sum of the corresponding digits from l1 and l2, along with the carry value.\nUpdate carry with the value of sum / 10 (integer division).\nAdd a new node to the l3 linked list with a value of sum % 10 (remainder of the division).\nMove to the next nodes in l1, l2, and l3.\nRemaining Digits:\nAfter the main loop, there might be remaining digits in either l1 or l2. Two separate loops handle these remaining digits:\n\nIf there are remaining digits in l1, add them to the current l3 node along with the carry.\nIf there are remaining digits in l2, add them to the current l3 node along with the carry.\nFinal Carry:\nIf there is a carry value left after all addition operations, add a new node with the carry value to the end of the l3 linked list.\n\nReturn Result:\nThe result linked list is stored in l3, but since the first node of l3 is a dummy node, the actual result starts from the second node. The head->next node is returned as the result, representing the sum of the two input linked lists.\n\nThe approach is based on simulating the process of adding digits manually, carrying over the excess value when necessary. The code handles cases where one linked list is longer than the other or when there\'s a final carry left after all additions.\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:0(N)\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:0(N)(whichever linkedlist is longer + 1)\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\nclass Solution {\npublic:\n ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {\n int carry=0;\n ListNode* l3= new ListNode(0);\n ListNode* head= l3;\n\n while(l1!=NULL && l2!=NULL)\n {\n int value= l1->val+l2->val+carry;\n carry = value/10;\n l3->next= new ListNode(value%10);\n l3=l3->next;\n l1=l1->next;\n l2=l2->next;\n }\n while(l1)\n {\n int value= l1->val+carry;\n carry = value/10;\n l3->next= new ListNode(value%10);\n l3=l3->next;\n l1=l1->next;\n }\n while(l2)\n {\n int value= l2->val+carry;\n carry = value/10;\n l3->next= new ListNode(value%10);\n l3=l3->next;\n l2=l2->next;\n }\n if(carry)\n {\n l3->next=new ListNode(carry);\n }\n return head->next;\n\n }\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

```\nvar addTwoNumbers = function(l1, l2) {\n const iter = (n1, n2, rest = 0) => {\n if (!n1 && !n2 && !rest) return null;\n const newVal = (n1?.val || 0) + (n2?.val || 0) + rest;\n const nextNode = iter(n1?.next, n2?.next, Math.floor(newVal / 10));\n return new ListNode(newVal % 10, nextNode);\n }\n return iter(l1, l2);\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

```\n# Definition for singly-linked list.\nclass ListNode:\n def __init__(self, val=0, next=None):\n self.val = val\n self.next = next\n \nclass Solution:\n def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:\n num1, num2 = \'\', \'\'\n node1, node2 = l1, l2\n while node1 is not None:\n num1 = str(node1.val) + num1\n node1 = node1.next\n while node2 is not None:\n num2 = str(node2.val) + num2\n node2 = node2.next\n num1 = int(num1)\n num2 = int(num2)\n summ = num1 + num2\n summ = str(summ)\n \n digitnodes = list(summ)\n \n for idx, digit in enumerate(summ):\n if idx == 0:\n digitnodes[idx] = ListNode(val = digit, next=None)\n else: \n digitnodes[idx] = ListNode(val = digit, next=digitnodes[idx-1])\n \n \n return(digitnodes[len(digitnodes)-1]) \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

# Approach\nThis is a simple addition flow. \n1. 2 numbers like ( 743, 564 )\n2. Start from the left to right ( loop - index)\n3. Get the number by index ( index = 0 => 7, 5 )\n4. Add those numbers ( 7 + 5 => 12 )\n5. Carry it if it is greater than 9 ( var carry = 12 / 10 => 1 )\n6. Increase the index ( index + 1 )\n7. Go to step 3 ( We need to pass carry value )\n\nlet\'s revise the steps\n\n3. Get the number by index ( index = 1 => 4, 6 )\n4. Add those numbers and carry ( 4 + 6 + 1)\n5. Carry it if it is greater than 9 ( var carry = 11 / 10 => 1 )\n6. Increase the index ( index + 1 => 2 )\n7. Go to step 3 ( We need to pass carry value )\n\nActually it is done if we know all the number places and length of the numbers.\n\nHowever we don\'t know it. It is a linked list. So we don\'t have the length and index. But we can use infinity loops. Let\'s start with a while loop.\n\n1_) let\'s start coding\n```\nwhile(true)\n{\n\t// step-3 : l1.val and l2.val \n\t// step-4\n\tint total = l1.val + l2.val;\n\t// step - 5\n\tint carry = total / 10;\n int val = total % 10;\n\t// step-6 : we don\'t have index but we have l1 and l2, so we can set them for the next loop\n\tl1 = l1.next;\n\tl2 = l2.next;\n // We need to store the val field and set the next field in the next loop, it seems a perfect sample for recursive methods\n // let\'s create a method then\n} \n```\n2_) we need pass value of 1 and 2 and carry values\n\n```\nnewMethod(int val1, int val2, int carry, ListNode next1, ListNode next2)\n{\n\tint total = val1 + val2;\n\tcarry = total / 10;\n\tint place = total % 10;\n\treturn new ListNode(place, /* we need to do the same for the next values */)\n}\n```\n\n3_) make it recursive. You can run the program and see the errors.\n\n```\nnewMethod(ListNode next1, ListNode next2, int carry)\n{\n\tint total = next1.val + next2.val + carry;\n\tcarry = total / 10;\n\tint val = total % 10;\n\treturn new ListNode(val, newMethod(next1.next, next2.next, carry))\n}\n\n\npublic ListNode AddTwoNumbers(ListNode l1, ListNode l2) \n{\n\treturn newMethod(l1, l2, 0);\n}\n```\n\n4_) add null check\n\n```\nnewMethod(ListNode next1, ListNode next2, int carry)\n{\n\tint total = (next1 != null ? next1.val : 0) + (next2 != null ? next2.val : 0) + carry;\n\tcarry = total / 10;\n\treturn new ListNode(total % 10, newMethod(next1?.next, next2?.next, carry))\n}\n```\n\n5_) stop the recursive method when next1 and next2 null\n\n```\nnewMethod(ListNode next1, ListNode next2, int carry)\n{\n\tif(next1 == null && next2 == null && carry == 0) return null;\n\n\tint total = (next1 != null ? next1.val : 0) + (next2 != null ? next2.val : 0) + carry;\n\tcarry = total / 10;\n\treturn new ListNode(total % 10, newMethod(next1?.next, next2?.next, carry))\n}\n```\n\n6_) AddTwoNumbers and newMethod are almost same parameters. So if I add carry as an optional parameter, it would be great.\n```\npublic ListNode AddTwoNumbers(ListNode l1, ListNode l2, int carry = 0) \n{\n\tif(l1 == null && l2 == null && carry == 0) return null;\n\n\tint total = (l1 != null ? l1.val : 0) + (l2 != null ? l2.val : 0) + carry;\n\tcarry = total / 10;\n\treturn new ListNode(total % 10, AddTwoNumbers(l1?.next, l2?.next, carry));\n}\n\n```\n\n> You can also use `l1?.val ?? 0` instead of using ternary operators.\n\n> JS version: `l1?.val || 0`\n\n\n# Final Code C#\n```\n/**\n * Definition for singly-linked list.\n * public class ListNode {\n * public int val;\n * public ListNode next;\n * public ListNode(int val=0, ListNode next=null) {\n * this.val = val;\n * this.next = next;\n * }\n * }\n */\npublic class Solution \n{\n public ListNode AddTwoNumbers(ListNode l1, ListNode l2, int carry = 0) \n {\n if(l1 == null && l2 == null && carry == 0) return null;\n\n int total = (l1 != null ? l1.val : 0) + (l2 != null ? l2.val : 0) + carry;\n carry = total / 10;\n return new ListNode(total % 10, AddTwoNumbers(l1?.next, l2?.next, carry));\n }\n}\n```\n\n\n# Final Code Typescript\n```\n/**\n * Definition for singly-linked list.\n * class ListNode {\n * val: number\n * next: ListNode | null\n * constructor(val?: number, next?: ListNode | null) {\n * this.val = (val===undefined ? 0 : val)\n * this.next = (next===undefined ? null : next)\n * }\n * }\n */\n\nfunction addTwoNumbers(l1: ListNode | null, l2: ListNode | null, carry: number = 0): ListNode | null {\n if(!l1 && !l2 && !carry) return null;\n\n var total : number = (l1 ? l1.val : 0) + (l2 ? l2.val : 0) + (carry || 0);\n carry = parseInt(total / 10 + \'\');\n return new ListNode(total % 10, addTwoNumbers(l1?.next, l2?.next, carry));\n};\n```\n\n# Final Code Javascript\n```\n/**\n * Definition for singly-linked list.\n * function ListNode(val, next) {\n * this.val = (val===undefined ? 0 : val)\n * this.next = (next===undefined ? null : next)\n * }\n */\n/**\n * @param {ListNode} l1\n * @param {ListNode} l2\n * @return {ListNode}\n */\nvar addTwoNumbers = function(l1, l2, carry) {\n if(!l1 && !l2 && !carry) return null;\n\n var total = (l1 ? l1.val : 0) + (l2 ? l2.val : 0) + (carry || 0);\n carry = parseInt(total / 10);\n return new ListNode(total % 10, addTwoNumbers(l1?.next, l2?.next, carry));\n};\n```\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

public class Solution {\n public ListNode addTwoNumbers(ListNode l1, ListNode l2) {\n ListNode c1 = l1;\n ListNode c2 = l2;\n ListNode sentinel = new ListNode(0);\n ListNode d = sentinel;\n int sum = 0;\n while (c1 != null || c2 != null) {\n sum /= 10;\n if (c1 != null) {\n sum += c1.val;\n c1 = c1.next;\n }\n if (c2 != null) {\n sum += c2.val;\n c2 = c2.next;\n }\n d.next = new ListNode(sum % 10);\n d = d.next;\n }\n if (sum / 10 == 1)\n d.next = new ListNode(1);\n return sentinel.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

# 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```\n/**\n * Definition for singly-linked list.\n * public class ListNode {\n * int val;\n * ListNode next;\n * ListNode() {}\n * ListNode(int val) { this.val = val; }\n * ListNode(int val, ListNode next) { this.val = val; this.next = next; }\n * }\n */\nclass Solution {\n public ListNode addTwoNumbers(ListNode l1, ListNode l2) {\n ListNode res = new ListNode();\n ListNode r = res;\n int carry = 0;\n while(l1 != null || l2 != null || carry != 0) {\n int n1 = l1 != null ? l1.val : 0;\n int n2 = l2 != null ? l2.val : 0;\n int sum = carry + n1 + n2;\n r.next = new ListNode(sum % 10);\n r = r.next;\n carry = sum / 10;\n l1 = l1 != null ? l1.next : null;\n l2 = l2 != null ? l2.next : null;\n }\n return res.next;\n }\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

\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

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

ListNode *addTwoNumbers(ListNode *l1, ListNode *l2) {\n ListNode preHead(0), *p = &preHead;\n int extra = 0;\n while (l1 || l2 || extra) {\n int sum = (l1 ? l1->val : 0) + (l2 ? l2->val : 0) + extra;\n extra = sum / 10;\n p->next = new ListNode(sum % 10);\n p = p->next;\n l1 = l1 ? l1->next : l1;\n l2 = l2 ? l2->next : l2;\n }\n return preHead.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

# Intuition\nMy initial approach to solving this problem involves simulating the process of adding two numbers represented as linked lists. I\'ll iterate through both linked lists simultaneously, adding corresponding digits along with any carry from the previous sum.\n\n# Approach\nI will use a dummy node to keep track of the resulting linked list. I\'ll initialize a carry variable to store any carry from the previous sum. I\'ll iterate through both linked lists while there are still digits left to process or a carry exists. For each step, I\'ll calculate the sum of the corresponding digits from both linked lists along with the carry. I\'ll update the carry for the next step and add the current digit to the result linked list. Finally, I\'ll move the pointers to the next nodes in both linked lists.\n\n# Complexity\n- Time complexity: O(max(N, M))\n Here, \'N\' is the length of the first linked list and \'M\' is the length of the second linked list. The algorithm iterates through both linked lists simultaneously, performing constant-time operations for each step.\n- Space complexity: O(max(N, M))\n The algorithm uses extra space for the result linked list, which can have a length of at most max(N, M) + 1.\n\n\n# Code\n```\n/**\n * Definition for singly-linked list.\n * public class ListNode {\n * int val;\n * ListNode next;\n * ListNode() {}\n * ListNode(int val) { this.val = val; }\n * ListNode(int val, ListNode next) { this.val = val; this.next = next; }\n * }\n */\nclass Solution {\n public ListNode addTwoNumbers(ListNode l1, ListNode l2) {\n ListNode temp = new ListNode(0);\n ListNode head = temp;\n int carry = 0;\n while (l1 != null || l2 != null || carry>0 ) {\n int sum = carry;\n if (l1 != null) {\n sum += l1.val;\n l1 = l1.next;\n }\n\n if (l2 != null) {\n sum += l2.val;\n l2 = l2.next;\n }\n\n carry=sum/10;\n\n sum %=10;\n\n head.next = new ListNode(sum);\n\n head = head.next;\n\n }\n\n return temp.next;\n\n\n\n \n }\n}\n```\n![c0504eaf-5fb8-4a1d-a769-833262d1b86e_1674433591.3836212.webp]()

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/**\n * Definition for singly-linked list.\n * public class ListNode {\n * int val;\n * ListNode next;\n * ListNode() {}\n * ListNode(int val) { this.val = val; }\n * ListNode(int val, ListNode next) { this.val = val; this.next = next; }\n * }\n */\nclass Solution {\n public ListNode addTwoNumbers(ListNode l1, ListNode l2) {\n ListNode l3 = new ListNode();\n ListNode head = l3;\n int num = 0;\n int h = 0;\n \n while(l1 != null || l2 != null){\n if(l1 != null && l2 != null)\n num = l1.val + l2.val + h;\n else if(l1 == null)\n num = l2.val + h;\n else if(l2 == null)\n num = l1.val + h;\n \n if(l1 != null)\n l1 = l1.next;\n if(l2 != null)\n l2 = l2.next;\n \n if(num > 9){\n l3.val = num%10;\n h = 1;\n }\n else{\n l3.val = num;\n h = 0;\n }\n \n if(l1 != null || l2 != null){\n l3.next = new ListNode();\n l3 = l3.next;\n }\n }\n if(h == 1){\n l3.next = new ListNode(1);\n }\n return head;\n }\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

\n\n# Code\n```\n/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\n \n ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {\n if(l1==NULL &&l2==NULL) return l2;\n else if(l1==NULL) return l2;\n else if(l2==NULL) return l1;\n\n int a =l1->val+l2->val;\n //taking the unit digit only in consideration \n ListNode* p=new ListNode(a%10);\n p->next=addTwoNumbers(l1->next,l2->next);\n //if the sum has carry it will be not more than 1 so \n //we introduce a new node and add the next value of the\n //linkedlist with the carry one \n if(a>=10){\n p->next=addTwoNumbers(p->next,new ListNode(1));\n }\n return p;\n\n\t}\n};\n```