Dataset Viewer
post_href
stringlengths 57
213
| python_solutions
stringlengths 71
22.3k
| slug
stringlengths 3
77
| post_title
stringlengths 1
100
| user
stringlengths 3
29
| upvotes
int64 -20
1.2k
| views
int64 0
60.9k
| problem_title
stringlengths 3
77
| number
int64 1
2.48k
| acceptance
float64 0.14
0.91
| difficulty
stringclasses 3
values | __index_level_0__
int64 0
34k
|
|---|---|---|---|---|---|---|---|---|---|---|---|
https://leetcode.com/problems/two-sum/discuss/2361743/Python-Simple-Solution-oror-O(n)-Time-oror-O(n)-Space
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
d = {}
for i, j in enumerate(nums):
r = target - j
if r in d: return [d[r], i]
d[j] = i
# An Upvote will be encouraging
|
two-sum
|
Python Simple Solution || O(n) Time || O(n) Space
|
rajkumarerrakutti
| 288 | 21,600 |
two sum
| 1 | 0.491 |
Easy
| 0 |
https://leetcode.com/problems/two-sum/discuss/1378197/Simple-oror-100-faster-oror-5-Lines-code-oror-Well-Explained
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
store = dict()
for i in range(len(nums)):
sec = target - nums[i]
if sec not in store:
store[nums[i]]=i
else:
return [store[sec],i]
|
two-sum
|
🐍 Simple || 100% faster || 5 Lines code || Well-Explained 📌📌
|
abhi9Rai
| 47 | 6,800 |
two sum
| 1 | 0.491 |
Easy
| 1 |
https://leetcode.com/problems/two-sum/discuss/1378197/Simple-oror-100-faster-oror-5-Lines-code-oror-Well-Explained
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
tmp = sorted(nums)
n, i, j = len(nums), 0, (n-1)
while True:
s = tmp[i]+tmp[j]
if s>target:
j-=1
elif s<target:
i+=1
else:
break
return [nums.index(tmp[i]),n-(nums[::-1].index(tmp[j]))-1]
|
two-sum
|
🐍 Simple || 100% faster || 5 Lines code || Well-Explained 📌📌
|
abhi9Rai
| 47 | 6,800 |
two sum
| 1 | 0.491 |
Easy
| 2 |
https://leetcode.com/problems/two-sum/discuss/2045849/1LINER-O(n)timeBEATS-99.97-MEMORYSPEED-0ms-MAY-2022
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
seen = {}
for i, value in enumerate(nums): #1
remaining = target - nums[i] #2
if remaining in seen: #3
return [i, seen[remaining]] #4
else:
seen[value] = i #5
|
two-sum
|
[1LINER] O(n)time/BEATS 99.97% MEMORY/SPEED 0ms MAY 2022
|
cucerdariancatalin
| 21 | 4,800 |
two sum
| 1 | 0.491 |
Easy
| 3 |
https://leetcode.com/problems/two-sum/discuss/1680976/Python-Simple-O(n)-time-solution-with-explanation-and-Big-O-analysis
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
prevTable = {}
for i,currVal in enumerate(nums):
complement = target - currVal
if complement in prevTable:
return [prevTable[complement],i]
prevTable[currVal] = i
|
two-sum
|
Python Simple O(n) time solution, with explanation and Big O analysis
|
kenanR
| 20 | 2,400 |
two sum
| 1 | 0.491 |
Easy
| 4 |
https://leetcode.com/problems/two-sum/discuss/1855612/Python3-direct-solution-faster-than-85.68-online-submissions-greater-O(n)
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
map = {}
for i,n in enumerate(nums):
diff = target - n
if diff in map:
return [map[diff],i]
map[n] = i
|
two-sum
|
Python3 direct solution faster than 85.68% online submissions -> O(n)
|
MaxKingson
| 13 | 1,100 |
two sum
| 1 | 0.491 |
Easy
| 5 |
https://leetcode.com/problems/two-sum/discuss/2806290/Python-4-Line-simple-solution
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
dict_nums = {}
for i, v in enumerate(nums):
if v in dict_nums: return [i, dict_nums[v]]
dict_nums[target - v] = i
|
two-sum
|
😎 Python 4-Line simple solution
|
Pragadeeshwaran_Pasupathi
| 7 | 2,200 |
two sum
| 1 | 0.491 |
Easy
| 6 |
https://leetcode.com/problems/two-sum/discuss/2391581/python3-O(n)-and-O(n2)-both-made-easy.-simple
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
for i in range(len(nums)-1):
for j in range(len(nums)):
if j!=i:
if (target == nums[i]+nums[j]):
return i,j
|
two-sum
|
python3 O(n) and O(n2) both made easy. simple
|
md-thayyib
| 7 | 734 |
two sum
| 1 | 0.491 |
Easy
| 7 |
https://leetcode.com/problems/two-sum/discuss/2391581/python3-O(n)-and-O(n2)-both-made-easy.-simple
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
lookup = {}
for position, number in enumerate(nums):
if target - number in lookup:
return lookup[target-number],position
else: lookup[number]=position
|
two-sum
|
python3 O(n) and O(n2) both made easy. simple
|
md-thayyib
| 7 | 734 |
two sum
| 1 | 0.491 |
Easy
| 8 |
https://leetcode.com/problems/two-sum/discuss/1744681/100-Python3-or-Faster-Solution-or-Easiest
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
checked={}
for index , item in enumerate(nums):
remaining = target - nums[index]
if remaining in checked:
return [index, checked[remaining]]
checked[item] = index
|
two-sum
|
✔ 100% Python3 | Faster Solution | Easiest
|
Anilchouhan181
| 7 | 933 |
two sum
| 1 | 0.491 |
Easy
| 9 |
https://leetcode.com/problems/two-sum/discuss/1634584/Python-Easy-Solution-or-Simple-Approach
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
res = {}
for idx, val in enumerate(nums):
remn = target-val
if remn in res:
return [res[remn], idx]
res[val] = idx
|
two-sum
|
Python Easy Solution | Simple Approach ✔
|
leet_satyam
| 7 | 1,400 |
two sum
| 1 | 0.491 |
Easy
| 10 |
https://leetcode.com/problems/two-sum/discuss/1503197/Move-from-O(N2)-to-O(N)-oror-Thought-Process-Explained
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
#Brute Force way of thinking
#Generate all subarrays and as soon as we find the condition getting fulfilled, append it to our answer
#Note - as per question, only 1 valid answer exists, so repetition will not be an issue
#If at all there was repetition, it can be avoided by traversing as below
#O(N^2) Time -- Accepted Solution
n = len(nums)
answer = list()
for i in range(n):
for j in range(i+1,n):
if (nums[i] + nums[j] == target):
answer.append(i)
answer.append(j)
return answer
#Let us try to optimize
#NOTE - We CANNOT SORT THIS array as we have to retrieve the indices and sorting it
#would change the original indices at which elements are present
#If the given array would have already been sorted, this would have worked completely fine
#if we fix one of the numbers as arr[i], so other would be arr[j] = (target - arr[i])
#now, we simply have to see if this arr[j] exists in the given array or not
#O(N) Time --- Accepted Solution (TAKEN HELP FROM DISCUSSION SECTION)
#NOTE - Looking up an element in a dictionary is O(1) and not O(N)
n = len(nums)
seen = {} #empty dictionary
for index, value in enumerate(nums):
remaining = target - value
#here, value is nums[i]
#we are looking for this remaining, which is nums[j]
#we have to find if remaining or nums[j] is present in the given array or not
#this equation comes from the fact that as per question :
#nums[i] + nums[j] = target
if remaining in seen:
#if nums[j] is present in dictionary
#just return index of nums[i] and nums[j]
return [index, seen[remaining]]
#index represents index of nums[i] and seen[remaining] will
#hold index of nums[j]
else:
#otherwise, add the value corresponding to its index in the dictionary
#so, if it searched again, we can directly retrieve its index
seen[value] = index
|
two-sum
|
Move from O(N^2) to O(N) || Thought Process Explained
|
aarushsharmaa
| 7 | 890 |
two sum
| 1 | 0.491 |
Easy
| 11 |
https://leetcode.com/problems/two-sum/discuss/2287919/Easy-python3-using-enumerate(updated)
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
prevMap = {}
for i, n in enumerate(nums):
diff = target - n
if diff in prevMap:
return [prevMap[diff], i]
prevMap[n] = i
|
two-sum
|
Easy python3 using enumerate(updated)
|
__Simamina__
| 6 | 513 |
two sum
| 1 | 0.491 |
Easy
| 12 |
https://leetcode.com/problems/two-sum/discuss/1812148/PythonJava-Hash-Map-of-Inverses-or-Beats-99
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
inverses = {}
for i, num in enumerate(nums):
if num in inverses:
return [inverses[num], i]
inverses[target-num] = i
|
two-sum
|
[Python/Java] Hash Map of Inverses | Beats 99%
|
hari19041
| 6 | 650 |
two sum
| 1 | 0.491 |
Easy
| 13 |
https://leetcode.com/problems/two-sum/discuss/1400832/Python-or-Easy-or-O(n)
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
#two pointer technique with sorting -> time -> O(nlogn)
#hashing technique -> time -> O(n)
di = {}
for i in range(len(nums)):
if target-nums[i] in di:
return [di[target-nums[i]], i]
else:
di[nums[i]] = i
#no need we will find solution in loop itself acc. to the question
|
two-sum
|
Python | Easy | O(n)
|
sathwickreddy
| 6 | 1,600 |
two sum
| 1 | 0.491 |
Easy
| 14 |
https://leetcode.com/problems/two-sum/discuss/1837631/Accepted-Python3-solution-with-2-lines
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
for i in nums:
if target - i in nums[nums.index(i) + 1:]: return [nums.index(i), nums[nums.index(i) + 1:].index(target - i) + nums.index(i) + 1]
|
two-sum
|
Accepted Python3 solution with 2 lines
|
ElizaZoldyck
| 5 | 608 |
two sum
| 1 | 0.491 |
Easy
| 15 |
https://leetcode.com/problems/two-sum/discuss/1769992/Python-solution-using-hash-map-with-O(n)-complexity
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
# construnct a empty hash map
val_index_map = {}
# hasmpa { value: index}
# iterate through given array with count, I used enumerate for count you guys can also add its mannually
for count, num in enumerate(nums):
# first i check the diff btw target and current value
req_diff = target - num
# if required difrence is exist in hashmap, then we are done
if req_diff in val_index_map:
# so current_value + required_diff = Traget
# mission accomplished
return [val_index_map.get(req_diff), count]
else:
# if required diff is not present in the hasmap then we add current number as a value and its index as a key
val_index_map[num] = count
return
|
two-sum
|
Python solution using hash map with O(n) complexity
|
rajat4665
| 5 | 929 |
two sum
| 1 | 0.491 |
Easy
| 16 |
https://leetcode.com/problems/two-sum/discuss/2737044/Python-Hash-table-O(n)-or-Full-explanation
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
"""Take each number and check if its complement has been seen before. If not,
add it to the list of known complements along with its index.
Args:
nums (List[int]): Input array of integers
target (int): Target integer
Returns:
List[int]: Indices of the two integers that sum to target
"""
# Initialise hash map to store known integers
complements = {}
# Iterate through the list
for i in range(len(nums)):
# Check if the current number's complement has been seen before
complement = target - nums[i]
if complement in complements:
return [complements[complement], i]
# Add the current number to the list of known complements
complements[nums[i]] = i
|
two-sum
|
🥇 [Python] Hash table - O(n) | Full explanation ✨
|
LloydTao
| 4 | 613 |
two sum
| 1 | 0.491 |
Easy
| 17 |
https://leetcode.com/problems/two-sum/discuss/2737044/Python-Hash-table-O(n)-or-Full-explanation
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
"""Take each pair of numbers and see if they add up to the target.
Args:
nums (List[int]): Input array of integers
target (int): Target integer
Returns:
List[int]: Indices of the two integers that sum to target
"""
# Get length of input array
n = len(nums)
# Iterate over all pairs (i,j)
for i in range(n):
for j in range(i + 1, n):
# Check if this pair equals the target
if nums[i] + nums[j] == target:
return [i, j]
|
two-sum
|
🥇 [Python] Hash table - O(n) | Full explanation ✨
|
LloydTao
| 4 | 613 |
two sum
| 1 | 0.491 |
Easy
| 18 |
https://leetcode.com/problems/two-sum/discuss/2603308/easy-python-solution
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
for i in range(len(nums)) :
num1 = nums[i]
if (target - num1) in nums[i+1:] :
return [i, (nums[i+1:].index((target - num1)))+i+1]
|
two-sum
|
easy python solution
|
sghorai
| 4 | 806 |
two sum
| 1 | 0.491 |
Easy
| 19 |
https://leetcode.com/problems/two-sum/discuss/2570856/SIMPLE-PYTHON3-SOLUTION
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
for i in range(len(nums)):
try:
if i != nums.index(target - nums[i]): return [i, nums.index(target - nums[i])]
except ValueError:
continue
|
two-sum
|
✅✔ SIMPLE PYTHON3 SOLUTION ✅✔
|
rajukommula
| 4 | 339 |
two sum
| 1 | 0.491 |
Easy
| 20 |
https://leetcode.com/problems/two-sum/discuss/2546192/Simple-dictionary-solution
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
pairs = {}
for i, v in enumerate(nums):
if target-v in pairs:
return [pairs[target-v], i]
else:
pairs[v] = i
|
two-sum
|
📌 Simple dictionary solution
|
croatoan
| 4 | 226 |
two sum
| 1 | 0.491 |
Easy
| 21 |
https://leetcode.com/problems/two-sum/discuss/2542771/1.-Two-Sum
|
class Solution:
def twoSum(self, nums: list[int], target: int) -> list[int]:
s =defaultdict(int)
for i, n in enumerate(nums):
if target - n in s:
return [i, s[target - n]]
s[n] =i
|
two-sum
|
1. Two Sum
|
warrenruud
| 4 | 543 |
two sum
| 1 | 0.491 |
Easy
| 22 |
https://leetcode.com/problems/two-sum/discuss/2454524/Optimal-PYTHON-3-Solution
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
hashmap = {} # val : index
for i, n in enumerate(nums):
#if n<=target:
diff = target-n
if diff in hashmap:
return [hashmap[diff],i]
hashmap[n]=i
return
|
two-sum
|
Optimal PYTHON 3 Solution
|
WhiteBeardPirate
| 4 | 473 |
two sum
| 1 | 0.491 |
Easy
| 23 |
https://leetcode.com/problems/two-sum/discuss/1691722/**-Python-code%3A-using-HashMap
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
checked={}
for index , item in enumerate(nums):
remaining = target - nums[index]
if remaining in checked:
return [index, checked[remaining]]
checked[item] = index
|
two-sum
|
** Python code: using HashMap
|
Anilchouhan181
| 4 | 407 |
two sum
| 1 | 0.491 |
Easy
| 24 |
https://leetcode.com/problems/two-sum/discuss/444887/Python3C%2B%2B-hash-table
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
seen = dict() #hash table of value-index pair
for i, num in enumerate(nums):
x = target - num #residual
if x in seen: return [seen[x], i]
seen[num] = i
return None
|
two-sum
|
[Python3/C++] hash table
|
ye15
| 4 | 774 |
two sum
| 1 | 0.491 |
Easy
| 25 |
https://leetcode.com/problems/two-sum/discuss/398550/Two-Solutions-in-Python-3-(Dictionary)-(-O(n)-)
|
class Solution:
def twoSum(self, N: List[int], t: int) -> List[int]:
D = {n:i for i,n in enumerate(N)}
for i,n in enumerate(N):
x = t - n
if x in D and D[x] != i: return [i,D[x]]
|
two-sum
|
Two Solutions in Python 3 (Dictionary) ( O(n) )
|
junaidmansuri
| 4 | 1,800 |
two sum
| 1 | 0.491 |
Easy
| 26 |
https://leetcode.com/problems/two-sum/discuss/398550/Two-Solutions-in-Python-3-(Dictionary)-(-O(n)-)
|
class Solution:
def twoSum(self, N: List[int], t: int) -> List[int]:
D = {}
for i,n in enumerate(N):
if n not in D: D[n] = i
x = t - n
if x in D and D[x] != i: return [i,D[x]]
- Junaid Mansuri
(LeetCode ID)@hotmail.com
|
two-sum
|
Two Solutions in Python 3 (Dictionary) ( O(n) )
|
junaidmansuri
| 4 | 1,800 |
two sum
| 1 | 0.491 |
Easy
| 27 |
https://leetcode.com/problems/two-sum/discuss/384034/super-basic-question...
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
|
two-sum
|
super basic question...
|
jstarrk
| 4 | 815 |
two sum
| 1 | 0.491 |
Easy
| 28 |
https://leetcode.com/problems/two-sum/discuss/2762217/Python-Simple-Solution-oror-Easy-to-Understand
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
for i in range(len(nums)-1):
for j in range(i+1,len(nums)):
if nums[i]+nums[j]==target: return [i,j]
|
two-sum
|
🐍🐍Python Simple Solution || Easy to Understand✅✅
|
sourav638
| 3 | 43 |
two sum
| 1 | 0.491 |
Easy
| 29 |
https://leetcode.com/problems/two-sum/discuss/2724248/Python's-Simple-and-Easy-to-Understand-Solution-Using-Dictionary-or-99-Faster
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
# Creating Dictonary for Lookup
lookup = {}
for i in range(len(nums)):
# if target-n in lookup return n index and current index
if target-nums[i] in lookup:
return [lookup[target-nums[i]], i]
lookup[nums[i]] = i
|
two-sum
|
✔️ Python's Simple and Easy to Understand Solution Using Dictionary | 99% Faster 🔥
|
pniraj657
| 3 | 639 |
two sum
| 1 | 0.491 |
Easy
| 30 |
https://leetcode.com/problems/two-sum/discuss/2671221/Python-three-solutions
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
for i in range(len(nums)):
for j in range(i + 1, len(nums)):
if nums[i] + nums[j] == target:
return [i, j]
|
two-sum
|
✔️ Python three solutions
|
QuiShimo
| 3 | 460 |
two sum
| 1 | 0.491 |
Easy
| 31 |
https://leetcode.com/problems/two-sum/discuss/2671221/Python-three-solutions
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
for i in range(len(nums)):
find_num = target - nums[i]
if find_num in nums and nums.index(find_num) != i:
return [i, nums.index(find_num)]
|
two-sum
|
✔️ Python three solutions
|
QuiShimo
| 3 | 460 |
two sum
| 1 | 0.491 |
Easy
| 32 |
https://leetcode.com/problems/two-sum/discuss/2671221/Python-three-solutions
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
nums_dict = {}
for i, j in enumerate(nums):
find_number = target - nums[i]
if find_number in nums_dict:
return [nums_dict[find_number], i]
nums_dict[j] = i
|
two-sum
|
✔️ Python three solutions
|
QuiShimo
| 3 | 460 |
two sum
| 1 | 0.491 |
Easy
| 33 |
https://leetcode.com/problems/two-sum/discuss/2269969/Python3-solution-using-enumerate
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
prevMap = {}
for i, n in enumerate(nums):
diff = target - n
if diff in prevMap:
return [prevMap[diff], i]
prevMap[n] = i
|
two-sum
|
Python3 solution using enumerate
|
__Simamina__
| 3 | 451 |
two sum
| 1 | 0.491 |
Easy
| 34 |
https://leetcode.com/problems/two-sum/discuss/2073481/Python-easy-to-understand-and-read-or-sorting
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
arr = []
for i, num in enumerate(nums):
arr.append([i, num])
arr.sort(key=lambda x:x[1])
ans = []
i, j = 0, len(arr)-1
while i < j:
sums = arr[i][1] + arr[j][1]
if sums == target:
return [arr[i][0], arr[j][0]]
if sums > target:
j = j-1
else:
i = i+1
|
two-sum
|
Python easy to understand and read | sorting
|
sanial2001
| 3 | 635 |
two sum
| 1 | 0.491 |
Easy
| 35 |
https://leetcode.com/problems/two-sum/discuss/1753486/brute-force
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
for i in range(len(nums)):
for j in range(i + 1, len(nums)):
if nums[i] + nums[j] == target:
return [i, j]
|
two-sum
|
brute force
|
ggeeoorrggee
| 3 | 238 |
two sum
| 1 | 0.491 |
Easy
| 36 |
https://leetcode.com/problems/two-sum/discuss/1653823/O(n)-Solution-using-dictionary-in-Python
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
# O(n) solution using HashMap or Dictionary
dict_nums = {}
for idx in range(0, len(nums)):
curr_num = nums[idx]
diff = target - curr_num
if diff in dict_nums:
return [idx, dict_nums[diff]]
else:
dict_nums[curr_num] = idx
# # Brute Force - O(n2)
# for i in range(0, len(nums)-1):
# for j in range(i+1, len(nums)):
# if nums[i] + nums[j] == target:
# return [i, j]
```
|
two-sum
|
O(n) Solution using dictionary in Python
|
coddify
| 3 | 275 |
two sum
| 1 | 0.491 |
Easy
| 37 |
https://leetcode.com/problems/two-sum/discuss/1630535/Python-3-oror-brute-force
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
for i in range(len(nums)):
for j in range(i):
if nums[i]+nums[j]==target: return [i,j]
|
two-sum
|
Python 3 || brute force
|
anon_python_coder
| 3 | 820 |
two sum
| 1 | 0.491 |
Easy
| 38 |
https://leetcode.com/problems/two-sum/discuss/1392824/Python3-96-faster-(52-ms)-Hash-Table-Solution
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
D = {}
for i in range(len(nums)):
temp = target-nums[i]
if temp in D:
return [i, D[temp]]
else:
D[nums[i]] = i
|
two-sum
|
[Python3] 96% faster (52 ms) - Hash Table Solution
|
Loqz
| 3 | 1,800 |
two sum
| 1 | 0.491 |
Easy
| 39 |
https://leetcode.com/problems/two-sum/discuss/1124970/Python3-Solution-using-Hashmap-by-dictionary
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
map = {}
for i in range(len(nums)):
map[nums[i]] = i
for i in range(len(nums)):
value = target - nums[i]
if value in map and map[value] != i:
return [i, map[value]]
|
two-sum
|
Python3 Solution using Hashmap by dictionary
|
vtthanh99
| 3 | 487 |
two sum
| 1 | 0.491 |
Easy
| 40 |
https://leetcode.com/problems/two-sum/discuss/967361/Python3-O(n)-with-explanation
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
seen = {}
for i in range(len(nums)):
key = target-nums[i]
if key in seen:
return [seen[key], i]
seen[nums[i]] = i
|
two-sum
|
[Python3] O(n) with explanation
|
gdm
| 3 | 527 |
two sum
| 1 | 0.491 |
Easy
| 41 |
https://leetcode.com/problems/two-sum/discuss/2426335/Python-Solution
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
hashMap = {}
for i in range(len(nums)):
hashMap[nums[i]] = i
for i in range(len(nums)):
rem = target -nums[i]
if rem in hashMap and hashMap[rem] != i:
return [i,hashMap[rem]]
#Upvote will be encouraging.
|
two-sum
|
Python Solution
|
anshsharma17
| 2 | 341 |
two sum
| 1 | 0.491 |
Easy
| 42 |
https://leetcode.com/problems/two-sum/discuss/2000886/Python-3-Solution-oror-Three-Approaches
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
# For storing answers in one hashmap also will check if any value exists in nums
checker = {}
for i, n in enumerate(nums):
diff_value = target - n
# If value already in answer checker
if diff_value in checker:
return [checker[diff_value],i]
checker[n] = i
|
two-sum
|
✅ Python 3 Solution || Three Approaches
|
mitchell000
| 2 | 459 |
two sum
| 1 | 0.491 |
Easy
| 43 |
https://leetcode.com/problems/two-sum/discuss/2000886/Python-3-Solution-oror-Three-Approaches
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
# For storing answers in one set also will check if any value exists in nums
checker = set()
for i in range(len(nums)):
# If value already in answer checker
if nums[i] in checker:
return [nums.index(target-nums[i]),i]
else:
checker.add(target-nums[i])
|
two-sum
|
✅ Python 3 Solution || Three Approaches
|
mitchell000
| 2 | 459 |
two sum
| 1 | 0.491 |
Easy
| 44 |
https://leetcode.com/problems/two-sum/discuss/2000886/Python-3-Solution-oror-Three-Approaches
|
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
left = 0
right = len(nums)
while left < right:
if target-nums[left] in nums and nums.index(target-nums[left]) != left:
return [left,nums.index(target-nums[left])]
else:
left+=1
|
two-sum
|
✅ Python 3 Solution || Three Approaches
|
mitchell000
| 2 | 459 |
two sum
| 1 | 0.491 |
Easy
| 45 |
https://leetcode.com/problems/add-two-numbers/discuss/1835217/Python3-DUMMY-CARRY-(-**-)-Explained
|
class Solution:
def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
res = dummy = ListNode()
carry = 0
while l1 or l2:
v1, v2 = 0, 0
if l1: v1, l1 = l1.val, l1.next
if l2: v2, l2 = l2.val, l2.next
val = carry + v1 + v2
res.next = ListNode(val%10)
res, carry = res.next, val//10
if carry:
res.next = ListNode(carry)
return dummy.next
|
add-two-numbers
|
✔️ [Python3] DUMMY CARRY ( •⌄• ू )✧, Explained
|
artod
| 44 | 7,100 |
add two numbers
| 2 | 0.398 |
Medium
| 46 |
https://leetcode.com/problems/add-two-numbers/discuss/452442/Python-3%3A-recursion
|
class Solution:
def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
_ = l1.val + l2.val
digit, tenth = _ % 10, _ // 10
answer = ListNode(digit)
if any((l1.next, l2.next, tenth)):
l1 = l1.next if l1.next else ListNode(0)
l2 = l2.next if l2.next else ListNode(0)
l1.val += tenth
answer.next = self.addTwoNumbers(l1, l2)
return answer
|
add-two-numbers
|
Python 3: recursion
|
deleted_user
| 39 | 4,200 |
add two numbers
| 2 | 0.398 |
Medium
| 47 |
https://leetcode.com/problems/add-two-numbers/discuss/486839/Python-Simple-Solution-8-Liner
|
class Solution:
def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
sumval = 0
root = curr = ListNode(0)
while l1 or l2 or sumval:
if l1: sumval += l1.val; l1 = l1.next
if l2: sumval += l2.val; l2 = l2.next
curr.next = curr = ListNode(sumval % 10)
sumval //= 10
return root.next
|
add-two-numbers
|
Python - Simple Solution - 8 Liner
|
mmbhatk
| 18 | 4,600 |
add two numbers
| 2 | 0.398 |
Medium
| 48 |
https://leetcode.com/problems/add-two-numbers/discuss/2024907/Simple-Python3-Solution
|
class Solution:
def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
dummy = ListNode()
cur = dummy
carry = 0
while l1 or l2 or carry:
v1 = l1.val if l1 else 0
v2 = l2.val if l2 else 0
# new digit val
val = v1 + v2 + carry
carry = val // 10
val = val % 10
cur.next = ListNode(val) # as in one place we have to put a single digit
# update pointers
cur = cur.next
l1 = l1.next if l1 else None
l2 = l2.next if l2 else None
return dummy.next
# Time: O(n + m)
# Space: O(n + m)
|
add-two-numbers
|
Simple Python3 Solution✨
|
samirpaul1
| 11 | 1,000 |
add two numbers
| 2 | 0.398 |
Medium
| 49 |
https://leetcode.com/problems/add-two-numbers/discuss/1353295/Python-Runtime-60ms
|
class Solution:
def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
start = curr = ListNode(0)
carry = 0
while(l1 or l2 or carry):
x = l1.val if l1 else 0
y = l2.val if l2 else 0
carry, val = divmod(x + y + carry, 10)
curr.next = ListNode(val)
curr = curr.next
l1 = l1.next if l1 else None
l2 = l2.next if l2 else None
return start.next
|
add-two-numbers
|
[Python] Runtime 60ms
|
yadvendra
| 11 | 1,200 |
add two numbers
| 2 | 0.398 |
Medium
| 50 |
https://leetcode.com/problems/add-two-numbers/discuss/2383456/Fastest-Solution-Explained0ms100-O(n)time-complexity-O(n)space-complexity
|
class Solution:
def addTwoNumbers(self, l1, l2):
list1 = make_list_from_ListNode(l1)
list2 = make_list_from_ListNode(l2)
### RIGHT PAD WITH ZEROES
len_list1 = len(list1)
len_list2 = len(list2)
if len_list1 > len_list2:
pad = len_list1 - len_list2
list2 = list2 + [0,] * pad
elif len_list2 > len_list1:
pad = len_list2 - len_list1
list1 = list1 + [0,] * pad
### DO THE MATH
d = 0
the_sum = list()
for x,y in zip(list1, list2):
d, m = divmod(x + y + d, 10)
the_sum.append(m)
if d != 0:
the_sum.append(d)
return make_ListNode_from_list(the_sum)
|
add-two-numbers
|
[Fastest Solution Explained][0ms][100%] O(n)time complexity O(n)space complexity
|
cucerdariancatalin
| 10 | 1,700 |
add two numbers
| 2 | 0.398 |
Medium
| 51 |
https://leetcode.com/problems/add-two-numbers/discuss/1636945/Python3-O(1)-Space-or-1-pass-or-Optimal-or-Beats-100
|
class Solution:
def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
carry, head = 0, l1
while l1 or l2:
if not l1.next and l2: l1.next, l2.next = l2.next, l1.next
val1 = l1.val if l1 else 0
val2 = l2.val if l2 else 0
carry, l1.val = divmod(val1 + val2 + carry, 10)
prev = l1
if l1: l1 = l1.next
if l2: l2 = l2.next
if carry: prev.next = ListNode(carry)
return head
|
add-two-numbers
|
[Python3] O(1) Space | 1 pass | Optimal | Beats 100%
|
PatrickOweijane
| 9 | 814 |
add two numbers
| 2 | 0.398 |
Medium
| 52 |
https://leetcode.com/problems/add-two-numbers/discuss/1784472/Python-3-greater-Simple-solution-that-was-asked-in-real-interview
|
class Solution:
def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
carryOver = 0
result = ListNode(-1)
resultTail = result
while l1 or l2:
total = 0
if l1:
total += l1.val
l1 = l1.next
if l2:
total += l2.val
l2 = l2.next
total += carryOver
carryOver, remainder = divmod(total, 10)
resultTail.next = ListNode(remainder)
resultTail = resultTail.next
if carryOver > 0:
resultTail.next = ListNode(carryOver)
return result.next
|
add-two-numbers
|
Python 3 -> Simple solution that was asked in real interview
|
mybuddy29
| 8 | 637 |
add two numbers
| 2 | 0.398 |
Medium
| 53 |
https://leetcode.com/problems/add-two-numbers/discuss/468242/Easy-to-follow-Python3-solution-(faster-than-96-and-memory-usage-less-than-100)
|
class Solution:
def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
r = None
p = None
c = 0
while l1 or l2 or c != 0:
v = (l1.val if l1 else 0) + (l2.val if l2 else 0) + c
c = v // 10
n = ListNode(v % 10)
if r is None:
r = n
if p is not None:
p.next = n
p = n
l1 = l1.next if l1 else None
l2 = l2.next if l2 else None
return r
|
add-two-numbers
|
Easy-to-follow Python3 solution (faster than 96% & memory usage less than 100%)
|
gizmoy
| 7 | 1,400 |
add two numbers
| 2 | 0.398 |
Medium
| 54 |
https://leetcode.com/problems/add-two-numbers/discuss/1836636/Python-Easy-Solution-or-Explained
|
class Solution:
def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
head = sm = ListNode() # head: we get the start to return, sm: to iterate and link the new sum nodes.
carry = 0 # carry starts with zero
while l1 or l2: # we are using or, because list sizes might not be equal.
if l1: carry, l1 = carry + l1.val, l1.next # if l1 is not null, add it to carry and update l1 to its next.
if l2: carry, l2 = carry + l2.val, l2.next # if l2 is not null, add it to carry and update l2 to its next.
sm.next = sm = ListNode(val = carry % 10) # make a new node with carry % 10(because carry can be greater than 9, ie two digits) and link the sm.next to it and now this new node is our sm
carry //= 10 # if carry is greater than 9, means we have to add it in next iteration
if carry: sm.next = ListNode(val = carry) # what if there is non zero carry left to be added.
return head.next # return head.next bcoz head is pointing to dummy node.
|
add-two-numbers
|
✅ Python Easy Solution | Explained
|
dhananjay79
| 5 | 397 |
add two numbers
| 2 | 0.398 |
Medium
| 55 |
https://leetcode.com/problems/add-two-numbers/discuss/2308917/Python3-using-two-pointers
|
class Solution:
def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
dummy = ListNode()
cur = dummy
carry = 0
while l1 or l2 or carry:
v1 = l1.val if l1 else 0
v2 = l2.val if l2 else 0
val = v1 + v2 + carry
carry = val // 10
val = val % 10
cur.next = ListNode(val)
cur = cur.next
l1 = l1.next if l1 else None
l2 = l2.next if l2 else None
return dummy.next
|
add-two-numbers
|
Python3 using two pointers
|
__Simamina__
| 4 | 249 |
add two numbers
| 2 | 0.398 |
Medium
| 56 |
https://leetcode.com/problems/add-two-numbers/discuss/1369722/python-3-solution-easyy
|
class Solution:
def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
carry=0
h=ListNode()
head=h
while l1 or l2 or carry:
result=0
if l1:
result+=l1.val
l1=l1.next
if l2:
result+=l2.val
l2=l2.next
if carry:
result+=carry
val=result%10
carry=result//10
head.next=ListNode(val)
head=head.next
return h.next
|
add-two-numbers
|
python 3 solution easyy
|
minato_namikaze
| 4 | 535 |
add two numbers
| 2 | 0.398 |
Medium
| 57 |
https://leetcode.com/problems/add-two-numbers/discuss/1515075/Python-solution-explained-(linked-list-greater-list-and-slice)
|
class Solution:
def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
list_l1 = []
list_l1_int = ''
list_l2 = []
list_l2_int = ''
# convert linked lists to lists
while l1:
list_l1.append(l1.val)
l1 = l1.next
while l2:
list_l2.append(l2.val)
l2 = l2.next
# iterate thru lists in reverse and recreate int from list
for x in list_l1[::-1]:
list_l1_int += str(x)
for x in list_l2[::-1]:
list_l2_int += str(x)
# sum
list_sum = int(list_l1_int) + int(list_l2_int)
# now create list node from the sum (use s, t to return linked list at right iteration)
s = t = ListNode()
# conv to str, iterate thru items in reverse, create linked list
for x in str(list_sum)[::-1]:
s.next = ListNode(x)
s = s.next
return t.next
|
add-two-numbers
|
Python solution explained (linked list -> list & slice)
|
jjluxton
| 3 | 964 |
add two numbers
| 2 | 0.398 |
Medium
| 58 |
https://leetcode.com/problems/add-two-numbers/discuss/1222978/python3-%3A-Easy-to-understand-and-straight-forward-approach
|
class Solution:
def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
# base cases
if l1==None:
return l2
if l2==None:
return l1
curr = ListNode(0)
head = curr
carry = 0
while l1 and l2:
total = 0
total += carry + l1.val + l2.val
curr.next = ListNode(total%10)
carry = total // 10
curr = curr.next
l1 = l1.next
l2 = l2.next
while (l1):
total = 0
total += carry + l1.val
curr.next = ListNode(total%10)
carry = total // 10
curr = curr.next
l1 = l1.next
while (l2):
total = 0
total += carry + l2.val
curr.next = ListNode(total%10)
carry = total // 10
curr = curr.next
l2 = l2.next
if carry:
curr.next = ListNode(carry)
return head.next
|
add-two-numbers
|
python3 : Easy to understand and straight forward approach
|
nandanabhishek
| 3 | 353 |
add two numbers
| 2 | 0.398 |
Medium
| 59 |
https://leetcode.com/problems/add-two-numbers/discuss/1081524/python3-easy-solution-with-detailed-comments-faster-than-96.55
|
class Solution:
def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
# Keep a dummy head for your return
sentinel = ListNode(0)
curr = sentinel
# Initializes two pointers pointing to two lists seperately
node1, node2 = l1, l2
# Check if we need add '1' to next calculation
carry = False
while node1 or node2:
# Calculate the current sum, if node is None then initializes to 0
i = node1.val if node1 else 0
y = node2.val if node2 else 0
total = i + y
# Check carry and update current sum
if carry:
total += 1
carry = False
# Modify total sum to one digit number and update carry
if total >= 10:
carry = True
total -= 10
# Initializes a new node based on current sum and link to the dummy head
to_add = ListNode(total)
curr.next = to_add
curr = to_add
# Update node1 and node2 for next calculation
node1 = node1.next if node1 else None
node2 = node2.next if node2 else None
# Check carry at the end of calculation
if carry:
extraDigit = ListNode(1)
curr.next = extraDigit
return sentinel.next
|
add-two-numbers
|
python3 easy solution with detailed comments, faster than 96.55%
|
IssacZ
| 3 | 554 |
add two numbers
| 2 | 0.398 |
Medium
| 60 |
https://leetcode.com/problems/add-two-numbers/discuss/972330/Python3-solution
|
class Solution:
def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
first_num=[]
second_num=[]
while l1 is not None:
first_num.append(l1.val)
l1=l1.next
while l2 is not None:
second_num.append(l2.val)
l2=l2.next
first_num.reverse()
second_num.reverse()
res1=int(''.join(map(str,first_num)))
res2=int(''.join(map(str,second_num)))
res3=str(res1+res2)
l3=None
for i in res3:
data=int(i)
newnode=ListNode(data)
if not l3:
l3=newnode
else:
newnode.next=l3
l3=newnode
return l3
|
add-two-numbers
|
Python3 solution
|
samarthnehe
| 3 | 453 |
add two numbers
| 2 | 0.398 |
Medium
| 61 |
https://leetcode.com/problems/add-two-numbers/discuss/2214565/Python3-or-Easy-to-Understand-or-Simple
|
class Solution:
def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
result = ListNode()
result_tail = result
carry = 0
while l1 or l2 or carry:
val1 = l1.val if l1 else 0
val2 = l2.val if l2 else 0
out = (val1 + val2 + carry) % 10
carry = (val1 + val2 + carry) // 10
result_tail.next = ListNode(out)
result_tail = result_tail.next
l1 = l1.next if l1 else None
l2 = l2.next if l2 else None
return result.next
|
add-two-numbers
|
✅Python3 | Easy to Understand | Simple
|
thesauravs
| 2 | 120 |
add two numbers
| 2 | 0.398 |
Medium
| 62 |
https://leetcode.com/problems/add-two-numbers/discuss/2127776/EASY-Python-Solution-O(n)
|
class Solution:
def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
s1, s2 = '', ''
while l1:
s1 += str(l1.val)
l1 = l1.next
while l2:
s2 += str(l2.val)
l2 = l2.next
s1 = int(s1[::-1])
s2 = int(s2[::-1])
total = str(s1 + s2)
head = None
for c in total:
n = ListNode(c)
n.next = head
head = n
return head
|
add-two-numbers
|
EASY Python Solution O(n)
|
anselchacko
| 2 | 406 |
add two numbers
| 2 | 0.398 |
Medium
| 63 |
https://leetcode.com/problems/add-two-numbers/discuss/2079491/Python-Very-Intuitive-Solution
|
class Solution:
def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
int_1 = int_2 = 0
i = 0
while l1 or l2:
if l1:
int_1 += l1.val * (10 ** i)
l1 = l1.next
if l2:
int_2 += l2.val * (10 ** i)
l2 = l2.next
i += 1
int_sum = int_1 + int_2
for i, char in enumerate(list(str(int_sum))):
if i == 0:
node = ListNode(int(char), None)
else:
node = ListNode(int(char), node)
return node
|
add-two-numbers
|
Python Very Intuitive Solution
|
codeee5141
| 2 | 378 |
add two numbers
| 2 | 0.398 |
Medium
| 64 |
https://leetcode.com/problems/add-two-numbers/discuss/1837667/Accepted-Python3-solution-DUMMY-DUMMY
|
class Solution:
def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
if l1 == None and l2 == None:
return ListNode(0)
a = b = i = 0
while l1 != None:
a += l1.val * (10 ** i)
i += 1
l1 = l1.next
i = 0
while l2 != None:
b += l2.val * (10 ** i)
i += 1
l2 = l2.next
ans = a + b
x = [int(l) for l in str(ans)][::-1]
ansll = dummy = ListNode()
for i in x[:-1]:
ansll.val = i
ansll.next = ListNode()
ansll = ansll.next
ansll.val = x[-1]
return dummy
|
add-two-numbers
|
Accepted Python3 solution DUMMY DUMMY
|
ElizaZoldyck
| 2 | 54 |
add two numbers
| 2 | 0.398 |
Medium
| 65 |
https://leetcode.com/problems/add-two-numbers/discuss/1811728/PythonJava-Simple-Addition-Algorithm-or-Digit-by-Digit
|
class Solution:
def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
temp = ListNode(0)
ptr1 = l1; ptr2 = l2
curr = temp; carry = 0
while ptr1 or ptr2:
x = ptr1.val if ptr1 else 0
y = ptr2.val if ptr2 else 0
s = x+y+carry
carry = s//10
curr.next = ListNode(s%10)
curr = curr.next
if ptr1:
ptr1 = ptr1.next
if ptr2:
ptr2 = ptr2.next
if carry:
curr.next = ListNode(carry)
return temp.next
|
add-two-numbers
|
[Python/Java] Simple Addition Algorithm | Digit by Digit
|
hari19041
| 2 | 537 |
add two numbers
| 2 | 0.398 |
Medium
| 66 |
https://leetcode.com/problems/add-two-numbers/discuss/1684721/Python-O(n)-and-in-place-beat-96
|
class Solution:
def addTwoNumbers(self, l1, l2):
"""
:type l1: ListNode
:type l2: ListNode
:rtype: ListNode
"""
# O(n) and O(1)
head = l1
carry, l1.val = divmod(l1.val + l2.val, 10)
while l1.next and l2.next:
l1 = l1.next
l2 = l2.next
carry, l1.val = divmod(l1.val + l2.val + carry, 10)
if l2.next:
l1.next = l2.next
while l1.next:
l1 = l1.next
carry, l1.val = divmod(l1.val + carry, 10)
if carry:
l1.next = ListNode(carry)
return head
|
add-two-numbers
|
Python, O(n) and in-place, beat 96%
|
yaok09
| 2 | 546 |
add two numbers
| 2 | 0.398 |
Medium
| 67 |
https://leetcode.com/problems/add-two-numbers/discuss/1409756/python-and-c%2B%2B-solution-(O(n)-most-efficient-solution-in-both-space-and-time-)
|
class Solution:
def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
ans=ListNode()
current=ans
carry=0
while l1 and l2 :
add=l1.val+l2.val+carry
val=add%10
carry=add//10
current.next=ListNode(val)
current=current.next
l1=l1.next
l2=l2.next
current.next=l1 or l2
while carry>0:
if current.next :
current=current.next
else:
current.next=ListNode(carry)
carry=0
add=carry+current.val
val=add%10
carry=add//10
current.val=val
return ans.next
|
add-two-numbers
|
python and c++ solution ,(O(n) most efficient solution in both space and time )
|
sagarhparmar12345
| 2 | 270 |
add two numbers
| 2 | 0.398 |
Medium
| 68 |
https://leetcode.com/problems/add-two-numbers/discuss/1401366/Python-easy-or-O(n)-or-Without-extra-space
|
class Solution:
def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
h1, h2, prev = l1, l2, None
carry = 0
while h1 != None and h2 != None:
sm = h1.val+h2.val+carry
carry = sm//10
h1.val = sm%10
prev = h1
h1 = h1.next
h2 = h2.next
if h2!=None:
h1 = h2
#since we are overriding the first linked list, so our priority is on head1
if prev!=None:
#if case will handle this edge case l1 = [] l2 = [1,2,3]
prev.next = h2
while h1!=None:
sm = h1.val+carry
carry = sm//10
h1.val = sm%10
prev = h1
h1 = h1.next
if carry:
prev.next = ListNode(carry)
return l1
|
add-two-numbers
|
Python easy | O(n) | Without extra space
|
sathwickreddy
| 2 | 909 |
add two numbers
| 2 | 0.398 |
Medium
| 69 |
https://leetcode.com/problems/add-two-numbers/discuss/262494/Python-faster-than-100-and-easy-to-read
|
class Solution:
def addTwoNumbers(self, l1: ListNode, l2: ListNode, over=0) -> ListNode:
if l1 is None and l2 is None:
if over > 0:
return ListNode(over)
return None
num = over
next1 = None
next2 = None
if not l1 is None:
num += l1.val
next1 = l1.next
if not l2 is None:
num += l2.val
next2 = l2.next
node = ListNode(num)
over = 0
if node.val > 9:
over = 1
node.val -= 10
node.next = self.addTwoNumbers(next1, next2, over)
return node
|
add-two-numbers
|
Python faster than 100% and easy to read
|
mpSchrader
| 2 | 595 |
add two numbers
| 2 | 0.398 |
Medium
| 70 |
https://leetcode.com/problems/add-two-numbers/discuss/2642238/Python-O(n)-Time-Space-Solution
|
class Solution: # Time: O(n) and Space: O(n)
def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
dummy = cur = ListNode() # Creating a new node to store l1 + l2 values, dummy will give us head address & cur will be used to append new nodes
carry = 0
while l1 or l2 or carry: # we will continue till either one of these have positive values left
v1 = l1.val if l1 else 0
v2 = l2.val if l2 else 0
# Addition: New digits
val = v1 + v2 + carry # in 1st iteration carry will be 0, but in next iterations previous iter generated carry will be added
carry = val // 10 # if val = 15 then 15//10 = 1 ie. (1.5)
val = val % 10 # 15 % 10 = 5
cur.next = ListNode(val) # dummy/cur --> val
# Update pointers
cur = cur.next # dummy --> val/cur
l1 = l1.next if l1 else None
l2 = l2.next if l2 else None
return dummy.next
|
add-two-numbers
|
Python O(n) Time-Space Solution
|
DanishKhanbx
| 1 | 221 |
add two numbers
| 2 | 0.398 |
Medium
| 71 |
https://leetcode.com/problems/add-two-numbers/discuss/1957325/python3-or-99.16-faster-and-O(n)-time-complexity
|
class Solution:
def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
dummy = curr = ListNode(0)
carry = 0
while l1 and l2 :
tsum = l1.val + l2.val + carry
num = tsum % 10
curr.next = ListNode(num)
curr = curr.next
carry = tsum // 10
l1 = l1.next
l2 = l2.next
while l1:
tsum = l1.val + carry
if tsum > 9:
num = tsum % 10
curr.next = ListNode(num)
carry = tsum // 10
else:
curr.next = ListNode(tsum)
carry = 0
curr = curr.next
l1 = l1.next
while l2:
tsum = l2.val + carry
if tsum > 9:
num = tsum % 10
curr.next = ListNode(num)
carry = tsum // 10
else:
curr.next = ListNode(tsum)
carry = 0
curr = curr.next
l2 = l2.next
if carry > 0:
curr.next = ListNode(carry)
return dummy.next
|
add-two-numbers
|
python3 | 99.16% faster and O(n) time complexity
|
sanketsans
| 1 | 187 |
add two numbers
| 2 | 0.398 |
Medium
| 72 |
https://leetcode.com/problems/add-two-numbers/discuss/1836620/Python-Simple-Solution
|
class Solution:
def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
res = 0
ans = ListNode()
cur = ans
while l1 and l2:
d = l1.val + l2.val + res
res = d//10
cur.next = ListNode(d%10)
cur = cur.next
l1 = l1.next
l2 = l2.next
cur1 = l2
if l1:
cur1 = l1
while cur1:
d = cur1.val + res
res = d//10
cur.next = ListNode(d%10)
cur = cur.next
cur1 = cur1.next
if res:
cur.next = ListNode(res)
return ans.next
|
add-two-numbers
|
[Python] Simple Solution
|
zouhair11elhadi
| 1 | 65 |
add two numbers
| 2 | 0.398 |
Medium
| 73 |
https://leetcode.com/problems/add-two-numbers/discuss/1761128/Easy-to-Understand-Python-Solution
|
class Solution:
def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
vals1 = []
vals2 = []
cur = dummy = ListNode(0)
while l1 is not None:
vals1.append(str(l1.val))
l1 = l1.next
while l2 is not None:
vals2.append(str(l2.val))
l2 = l2.next
vals1.reverse()
vals2.reverse()
c = int("".join(vals1))
d = int("".join(vals2))
amount = list(str(c + d))
amount.reverse()
for i in amount:
cur.next = ListNode(int(i))
cur = cur.next
return dummy.next
|
add-two-numbers
|
Easy to Understand Python Solution
|
newcomerlearn
| 1 | 304 |
add two numbers
| 2 | 0.398 |
Medium
| 74 |
https://leetcode.com/problems/add-two-numbers/discuss/1757973/Brief-and-pythonic
|
class Solution:
def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
def lstIter(lst):
while lst is not None:
yield lst.val
lst = lst.next
head = prev = ListNode(0)
carry = 0
for x in (ListNode(sum(x)) for x in zip_longest(lstIter(l1), lstIter(l2), fillvalue=0)):
prev.next = prev = x
x.val, carry = (carry + x.val) % 10, (carry + x.val) // 10
if carry:
prev.next = ListNode(carry)
return head.next
|
add-two-numbers
|
Brief and pythonic
|
Lrnx
| 1 | 110 |
add two numbers
| 2 | 0.398 |
Medium
| 75 |
https://leetcode.com/problems/add-two-numbers/discuss/1582607/Python-Solution
|
class Solution:
def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
output = curr = ListNode()
o = 0 #overflow
while l1 or l2:
n1, n2 = 0, 0
if l1:
n1 = l1.val
l1 = l1.next
if l2:
n2 = l2.val
l2 = l2.next
if n1 + n2 + o >= 10:
curr.next = ListNode(n1+n2+o-10)
o = 1
else:
curr.next = ListNode(n1+n2+o)
o = 0
curr = curr.next
if o:
curr.next = ListNode(o)
return output.next
|
add-two-numbers
|
Python Solution
|
overzh_tw
| 1 | 178 |
add two numbers
| 2 | 0.398 |
Medium
| 76 |
https://leetcode.com/problems/longest-substring-without-repeating-characters/discuss/742926/Simple-Explanation-or-Concise-or-Thinking-Process-and-Example
|
class Solution(object):
def lengthOfLongestSubstring(self, s):
"""
:type s: str
:rtype: int abcabcbb
"""
if len(s) == 0:
return 0
seen = {}
left, right = 0, 0
longest = 1
while right < len(s):
if s[right] in seen:
left = max(left,seen[s[right]]+1)
longest = max(longest, right - left + 1)
seen[s[right]] = right
right += 1
print(left, right, longest)
return longest
|
longest-substring-without-repeating-characters
|
Simple Explanation | Concise | Thinking Process & Example
|
ivankatrump
| 290 | 13,100 |
longest substring without repeating characters
| 3 | 0.338 |
Medium
| 77 |
https://leetcode.com/problems/longest-substring-without-repeating-characters/discuss/2132954/Python-Simple-Solution-w-Explanation-or-Brute-Force-%2B-Sliding-Window
|
class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
res = 0
seen = set()
for start_idx in range(len(s)):
seen.clear()
end_idx = start_idx
while end_idx < len(s):
if s[end_idx] in seen:
break
seen.add(s[end_idx])
end_idx += 1
res = max(res, end_idx - start_idx)
return res
|
longest-substring-without-repeating-characters
|
✅ [Python] Simple Solution w/ Explanation | Brute-Force + Sliding Window
|
r0gue_shinobi
| 26 | 1,900 |
longest substring without repeating characters
| 3 | 0.338 |
Medium
| 78 |
https://leetcode.com/problems/longest-substring-without-repeating-characters/discuss/2132954/Python-Simple-Solution-w-Explanation-or-Brute-Force-%2B-Sliding-Window
|
class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
prev = [-1] * 128
res, start_idx = 0, 0
for end_idx, char in enumerate(s):
if prev[ord(char)] >= start_idx:
start_idx = prev[ord(char)] + 1
prev[ord(char)] = end_idx
res = max(res, end_idx - start_idx + 1)
return res
|
longest-substring-without-repeating-characters
|
✅ [Python] Simple Solution w/ Explanation | Brute-Force + Sliding Window
|
r0gue_shinobi
| 26 | 1,900 |
longest substring without repeating characters
| 3 | 0.338 |
Medium
| 79 |
https://leetcode.com/problems/longest-substring-without-repeating-characters/discuss/2132791/Python-Easy-2-approaches
|
class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
counter = defaultdict(int) # track counts of each character
l=0
max_length=0
for r, c in enumerate(s):
counter[c]+=1
if counter[c] > 1:
while l<r and counter[c]>1: # iterate until window is valid
counter[s[l]]-=1
l+=1
max_length=max(max_length, r-l+1)
return max_length
|
longest-substring-without-repeating-characters
|
Python Easy 2 approaches ✅
|
constantine786
| 21 | 2,000 |
longest substring without repeating characters
| 3 | 0.338 |
Medium
| 80 |
https://leetcode.com/problems/longest-substring-without-repeating-characters/discuss/2132791/Python-Easy-2-approaches
|
class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
last_seen = {}
l=0
max_length=0
for r in range(len(s)):
if s[r] in last_seen:
l=max(last_seen[s[r]], l)
last_seen[s[r]]=r+1
max_length=max(max_length, r-l+1)
return max_length
|
longest-substring-without-repeating-characters
|
Python Easy 2 approaches ✅
|
constantine786
| 21 | 2,000 |
longest substring without repeating characters
| 3 | 0.338 |
Medium
| 81 |
https://leetcode.com/problems/longest-substring-without-repeating-characters/discuss/2799840/Python-or-Easy-Solution
|
class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
output = 0
count = {}
pos = -1
for index, letter in enumerate(s):
if letter in count and count[letter] > pos:
pos = count[letter]
count[letter] = index
output = max(output,index-pos)
return output
|
longest-substring-without-repeating-characters
|
Python | Easy Solution✔
|
manayathgeorgejames
| 18 | 2,800 |
longest substring without repeating characters
| 3 | 0.338 |
Medium
| 82 |
https://leetcode.com/problems/longest-substring-without-repeating-characters/discuss/1526581/Simplest-way-(with-explanation)-97-faster
|
class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
string = s
max_length = 0 # we set max_length to 0 because string may be empty.
seen_character = '' # a empty string to store the character that we have already seen.
for letter in string: # we are checking every letter/character in string...
if letter not in seen_character:
seen_character += letter # if letter not in there then we add to it.
else:
## now if the letter is already in seen_character then we get the index of that letter by using seen_character.index() and then we slice the string from that index+1 to last, so that the the first seen letter will be removed.
# for example - 'abcabbd' # here after 'abc' , again "a" was there so we get the index of first "a" and slice the string then be get string = "bc" .
seen_character = seen_character[seen_character.index(letter) + 1:] + letter
# and then we add the letter "a" to the last. so the string will become "bca"
max_length = max(max_length, len(seen_character)) # here we use a function max() that everytime return the maximum value between two number. it sets max_length each time the loop runs.
return max_length # finally return the maximum length.
#by - Tony Stark
|
longest-substring-without-repeating-characters
|
Simplest way (with explanation) [97% faster]
|
tony_stark_47
| 16 | 1,000 |
longest substring without repeating characters
| 3 | 0.338 |
Medium
| 83 |
https://leetcode.com/problems/longest-substring-without-repeating-characters/discuss/2219528/Simple-Python-Solution-oror-Sliding-Window
|
class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
set_ = set()
res = 0
l = 0
for r in range(len(s)):
while s[r] in set_:
set_.remove(s[l])
l += 1
set_.add(s[r])
res = max(res, r-l+1)
return res
# An Upvote will be encouraging
|
longest-substring-without-repeating-characters
|
Simple Python Solution || Sliding Window
|
rajkumarerrakutti
| 13 | 687 |
longest substring without repeating characters
| 3 | 0.338 |
Medium
| 84 |
https://leetcode.com/problems/longest-substring-without-repeating-characters/discuss/1074783/Python-Interview-Thought-Process%3A-O(2n)-greater-O(n)
|
class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
queue = collections.deque([])
window = set()
result = 0
for c in s:
if c in window:
while queue:
prev = queue.popleft()
window.remove(prev)
if prev == c:
break
queue.append(c)
window.add(c)
result = max(result, len(window))
return result
|
longest-substring-without-repeating-characters
|
Python Interview Thought Process: O(2^n) -> O(n)
|
dev-josh
| 11 | 1,300 |
longest substring without repeating characters
| 3 | 0.338 |
Medium
| 85 |
https://leetcode.com/problems/longest-substring-without-repeating-characters/discuss/1953837/Python-Easiest-Solution-With-Explanation-or-92.68-Fasteror-Beg-to-advor-Sliding-Window
|
class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
left = 0
res = 0
charSet = set() # taking set to have unique values.
for right in range(len(s)):
while s[right] in charSet: # if we are getting duplication character then we have to update our set.
charSet.remove(s[left])
left+=1
charSet.add(s[right]) # once duplicate value is removed we are going to add right most element to the set
res = max(res,right-left+1) # at this stage we are sure that we dont have any duplicate , so lets update the res variable now.
return res
|
longest-substring-without-repeating-characters
|
Python Easiest Solution With Explanation | 92.68 % Faster| Beg to adv| Sliding Window
|
rlakshay14
| 9 | 362 |
longest substring without repeating characters
| 3 | 0.338 |
Medium
| 86 |
https://leetcode.com/problems/longest-substring-without-repeating-characters/discuss/1431722/Python-easy-solution-using-hashMap
|
class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
if s is None:
return 0
if len(s) <= 1:
return len(s)
charMap = dict()
start = 0
longest = 0
for i,c in enumerate(s):
if c in charMap:
start = max(start, charMap[c]+1)
longest = max(longest, i-start+1)
charMap[c] = i
return longest
|
longest-substring-without-repeating-characters
|
Python easy solution using hashMap
|
bTest2
| 9 | 1,100 |
longest substring without repeating characters
| 3 | 0.338 |
Medium
| 87 |
https://leetcode.com/problems/longest-substring-without-repeating-characters/discuss/1325444/easiest-solution-python-3......fastest
|
class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
start = 0
end = 0
max_len = 0
d={}
while end<len(s):
if s[end] in d and d[s[end]] >= start:
start = d[s[end]]+1
max_len = max(max_len , end-start+1)
d[s[end]] = end
end+=1
return(max_len)
|
longest-substring-without-repeating-characters
|
easiest solution python 3......fastest
|
pravishbajpai06
| 9 | 2,100 |
longest substring without repeating characters
| 3 | 0.338 |
Medium
| 88 |
https://leetcode.com/problems/longest-substring-without-repeating-characters/discuss/2166571/Python-Sliding-Window-(Thought-Process)
|
class Solution:
def lengthOfLongestSubstring(self, str: str) -> int:
# Handle empty input
if not str:
return 0
# Define result, start/end pointers, hashmap for seen characters
length = 1
start = 0
end = 0
seen = {}
# Iterate through string using sliding window technique
while end < len(str):
# You don't have to do this, but slightly cleaner
startChar = str[start]
endChar = str[end]
# If our end character has already been seen...
if endChar in seen:
# We should reset our start to the new end (+1), or the new start (if our last seen "end" char is before our current start)
start = max(start, seen[endChar] + 1)
# We set the length of our longest known substring w/out repeating characters
length = max(length, end - start + 1)
# We reset the index we've last seen end char at (or add it, if never seen before)
seen[endChar] = end
# Expand our window
end += 1
# Return our longest substring w/ no repeating characters
return length
|
longest-substring-without-repeating-characters
|
[Python] Sliding Window (Thought Process)
|
ernestshackleton
| 8 | 424 |
longest substring without repeating characters
| 3 | 0.338 |
Medium
| 89 |
https://leetcode.com/problems/longest-substring-without-repeating-characters/discuss/1245216/Python-32ms-simple-and-easy
|
class Solution:
def lengthOfLongestSubstring(self, s):
unique=""
a=0
for c in s:
if c not in unique:
unique+=c
else:
unique = unique[unique.index(c)+1:]+c
a = max(a,len(unique))
return a
|
longest-substring-without-repeating-characters
|
Python- 32ms simple and easy
|
akashadhikari
| 8 | 664 |
longest substring without repeating characters
| 3 | 0.338 |
Medium
| 90 |
https://leetcode.com/problems/longest-substring-without-repeating-characters/discuss/1595492/Python3-40-ms-faster-than-99.69
|
class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
res = 0
longest_substr = ''
for ch in s:
if ch not in longest_substr:
longest_substr += ch
if len(longest_substr) > res:
res += 1
else:
i = longest_substr.find(ch)
longest_substr = longest_substr[i+1:] + ch
return res
|
longest-substring-without-repeating-characters
|
[Python3] 40 ms, faster than 99.69%
|
larysa_sh
| 6 | 576 |
longest substring without repeating characters
| 3 | 0.338 |
Medium
| 91 |
https://leetcode.com/problems/longest-substring-without-repeating-characters/discuss/1256739/Python3-simple-solution-using-sliding-window-and-set
|
class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
left = right = ans = 0
char = set()
res = 0
while right < len(s):
if s[right] not in char:
char.add(s[right])
right += 1
else:
char.remove(s[left])
res = max(res, right-left)
left += 1
res = max(res, right - left)
return res
|
longest-substring-without-repeating-characters
|
Python3 simple solution using sliding-window and set
|
EklavyaJoshi
| 6 | 342 |
longest substring without repeating characters
| 3 | 0.338 |
Medium
| 92 |
https://leetcode.com/problems/longest-substring-without-repeating-characters/discuss/240337/Python3-Simple-O(n)-Solution-68ms-runtime(99.52)-and-memory(100)
|
class Solution:
def lengthOfLongestSubstring(self, s: 'str') -> 'int':
max_sequence = ""
current_sequence = ""
for ch in s:
if ch in current_sequence:
if len(current_sequence) > len(max_sequence):
max_sequence = current_sequence
current_sequence = current_sequence[current_sequence.index(ch) + 1:] + ch
else:
current_sequence += ch
return max(len(max_sequence), len(current_sequence))
|
longest-substring-without-repeating-characters
|
Python3 - Simple O(n) Solution 68ms, runtime(99.52%) and memory(100%)
|
nikhil_g777
| 6 | 559 |
longest substring without repeating characters
| 3 | 0.338 |
Medium
| 93 |
https://leetcode.com/problems/longest-substring-without-repeating-characters/discuss/1453922/Python3-Hashmap-easy-solution-or-faster-than-99.94
|
class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
start = -1 # start index of current substring
longest = 0 # length of the longest substring
hash_map = dict() # hash map is to store the latest index of char
for i in range(len(s)):
if s[i] in hash_map and start < hash_map[s[i]]:
start = hash_map[s[i]]
hash_map[s[i]] = i
if i - start > longest:
longest = i - start
return longest
|
longest-substring-without-repeating-characters
|
Python3 Hashmap easy solution | faster than 99.94%
|
Janetcxy
| 5 | 607 |
longest substring without repeating characters
| 3 | 0.338 |
Medium
| 94 |
https://leetcode.com/problems/longest-substring-without-repeating-characters/discuss/2283305/Python-Sliding-Window-O(n)-beats-96.91-(Explanation)
|
class Solution(object):
def lengthOfLongestSubstring(self, s):
mostRecentIndexofChar = {}
longest = 0
firstGoodIndex = 0
for index in range(len(s)):
if firstGoodIndex > index:
continue
if s[index] in mostRecentIndexofChar:
firstGoodIndex = max(firstGoodIndex, mostRecentIndexofChar[s[index]])
longest = max(longest, index - firstGoodIndex + 1)
mostRecentIndexofChar[s[index]] = index + 1
return longest
|
longest-substring-without-repeating-characters
|
[Python] Sliding Window O(n) beats 96.91% (Explanation)
|
Derek_Shimoda
| 4 | 356 |
longest substring without repeating characters
| 3 | 0.338 |
Medium
| 95 |
https://leetcode.com/problems/longest-substring-without-repeating-characters/discuss/2133403/Python3-WINDOW-with-SET-(-*).-Explained
|
class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
hset, start, ans = set(), 0, 0
for ch in s:
while ch in hset:
hset.remove(s[start])
start += 1
hset.add(ch)
ans = max(ans, len(hset))
return max(ans, len(hset))
|
longest-substring-without-repeating-characters
|
✔️ [Python3] WINDOW with SET (^-^*)/. Explained
|
artod
| 4 | 153 |
longest substring without repeating characters
| 3 | 0.338 |
Medium
| 96 |
https://leetcode.com/problems/longest-substring-without-repeating-characters/discuss/1788064/Python3-oror-Strings-oror-98-Faster
|
class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
max_length = 0
non_rep_sub_str = ""
for i in s:
if i in non_rep_sub_str:
non_rep_sub_str = non_rep_sub_str.split(i)[1] + i
else:
non_rep_sub_str += i
max_length = max(max_length, len(non_rep_sub_str))
return max_length
|
longest-substring-without-repeating-characters
|
Python3 || Strings || 98% Faster
|
cherrysri1997
| 4 | 396 |
longest substring without repeating characters
| 3 | 0.338 |
Medium
| 97 |
https://leetcode.com/problems/longest-substring-without-repeating-characters/discuss/1621748/Python3-Sliding-Window-%2B-Hashmap-or-9-Lines-Short-or-O(n)-Time-and-Space
|
class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
maxSize = l = 0
window = {}
for r, char in enumerate(s):
l = window[char] + 1 if char in window and window[char] >= l else l
window[char] = r
maxSize = max(maxSize, r - l + 1)
return maxSize
|
longest-substring-without-repeating-characters
|
[Python3] Sliding Window + Hashmap | 9 Lines Short | O(n) Time & Space
|
PatrickOweijane
| 4 | 701 |
longest substring without repeating characters
| 3 | 0.338 |
Medium
| 98 |
https://leetcode.com/problems/longest-substring-without-repeating-characters/discuss/1539793/Python-Runtime-52-ms-94%2B%2B-Faster-Solution
|
class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
key = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '!', ' ','0','1','2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '!', '"', '#', '$', '%', '&', "'", '(', ')', '*', '+', ',', '-', '.', '/', ':', ';', '<', '=', '>', '?', '@', '[', '\\', ']', '^', '_', '`', '{', '|', '}', '~']
value = True
counter = dict.fromkeys(key, value)
i = j = r = 0
while True:
try:
if counter.get(s[j]):
counter[s[j]] = False
j += 1
else:
counter[s[i]] = True
l = j - i
i += 1
if l > r:
r = l
except:
l = j - i
return l if l > r else r
|
longest-substring-without-repeating-characters
|
Python Runtime 52 ms 94%++ Faster Solution
|
aaffriya
| 4 | 697 |
longest substring without repeating characters
| 3 | 0.338 |
Medium
| 99 |
End of preview. Expand
in Data Studio
YAML Metadata
Warning:
empty or missing yaml metadata in repo card
(https://huggingface.co/docs/hub/datasets-cards)
- Downloads last month
- 75