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/min-stack/discuss/2092529/Python3-Runtime%3A-55ms-98.00-O(1) | class MinStack:
def __init__(self):
self.stack = []
self.minStack = []
def push(self, val: int) -> None:
self.stack.append(val)
if len(self.minStack) == 0:
self.minStack.append(val)
elif val <= self.minStack[-1]:
self.minStack.append(val)
def pop(self) -> None:
if self.stack[-1] == self.minStack[-1]:
self.minStack.pop()
self.stack.pop()
def top(self) -> int:
return self.stack[-1]
def getMin(self) -> int:
return self.minStack[-1] | min-stack | Python3 Runtime: 55ms 98.00% O(1) | mingwheel | 0 | 123 | min stack | 155 | 0.519 | Medium | 2,500 |
https://leetcode.com/problems/min-stack/discuss/1987514/Python-or-99.96-faster-or-2-methods-with-O(1)-time-complexity-or-Complexity-Analysis | class MinStack:
def __init__(self):
self.stack = []
self.stackHash = {}
def push(self, val: int) -> None:
self.stack.append(val)
self.stackHash[len(self.stack)-1] = min(self.stackHash.get(len(self.stack)-2, float('inf')), val)
def pop(self) -> None:
self.stack.pop()
def top(self) -> int:
return self.stack[-1]
def getMin(self) -> int:
return self.stackHash[len(self.stack)-1] | min-stack | Python | 99.96% faster | 2 methods with O(1) time complexity | Complexity Analysis | CSociety | 0 | 166 | min stack | 155 | 0.519 | Medium | 2,501 |
https://leetcode.com/problems/min-stack/discuss/1987514/Python-or-99.96-faster-or-2-methods-with-O(1)-time-complexity-or-Complexity-Analysis | class MinStack:
def __init__(self):
self.stack = []
def push(self, val: int) -> None:
# for first element
if not self.stack:
self.stack.append((val, val))
else:
self.stack.append((val, min(self.getMin(), val)))
def pop(self) -> None:
self.stack.pop()
def top(self) -> int:
return self.stack[-1][0]
def getMin(self) -> int:
return self.stack[-1][1] | min-stack | Python | 99.96% faster | 2 methods with O(1) time complexity | Complexity Analysis | CSociety | 0 | 166 | min stack | 155 | 0.519 | Medium | 2,502 |
https://leetcode.com/problems/min-stack/discuss/1970247/Simple-Python-Solution-oror-70-Faster-oror-Memory-less-than-60 | class MinStack:
def __init__(self):
self.N=[] ; self.M=[]
def push(self, val: int) -> None:
self.N.append(val)
self.M.append(val if not self.M else min(val,self.M[-1]) )
def pop(self) -> None:
self.N.pop() ; self.M.pop()
def top(self) -> int:
return self.N[-1]
def getMin(self) -> int:
return self.M[-1] | min-stack | Simple Python Solution || 70% Faster || Memory less than 60% | Taha-C | 0 | 132 | min stack | 155 | 0.519 | Medium | 2,503 |
https://leetcode.com/problems/min-stack/discuss/1912563/Python-solution-with-one-line-for-every-function | class MinStack:
def __init__(self):
self.stack = []
def push(self, val: int) -> None:
self.stack.append(val)
def pop(self) -> None:
self.stack.pop(-1)
def top(self) -> int:
return self.stack[-1]
def getMin(self) -> int:
return min(self.stack)
# Your MinStack object will be instantiated and called as such:
# obj = MinStack()
# obj.push(val)
# obj.pop()
# param_3 = obj.top()
# param_4 = obj.getMin() | min-stack | Python solution with one line for every function | alishak1999 | 0 | 162 | min stack | 155 | 0.519 | Medium | 2,504 |
https://leetcode.com/problems/min-stack/discuss/1882731/Python-Simple-and-Elegant!-Multiple-Solutions! | class MinStack:
def __init__(self):
self.stack, self.minStack = [], []
def push(self, val):
self.stack.append(val)
self.minStack.append(val if not self.minStack else min(val, self.minStack[-1]))
def pop(self):
self.stack.pop()
self.minStack.pop()
def top(self):
return self.stack[-1]
def getMin(self):
return self.minStack[-1] | min-stack | Python - Simple and Elegant! Multiple Solutions! | domthedeveloper | 0 | 118 | min stack | 155 | 0.519 | Medium | 2,505 |
https://leetcode.com/problems/min-stack/discuss/1882731/Python-Simple-and-Elegant!-Multiple-Solutions! | class MinStack:
def __init__(self):
self.stack, self.minStack = [], []
def push(self, val):
self.stack.append(val)
if not self.minStack or val <= self.minStack[-1]:
self.minStack.append(val)
def pop(self):
val = self.stack.pop()
if val == self.minStack[-1]:
self.minStack.pop()
def top(self):
return self.stack[-1]
def getMin(self):
return self.minStack[-1] | min-stack | Python - Simple and Elegant! Multiple Solutions! | domthedeveloper | 0 | 118 | min stack | 155 | 0.519 | Medium | 2,506 |
https://leetcode.com/problems/min-stack/discuss/1882731/Python-Simple-and-Elegant!-Multiple-Solutions! | class MinStack:
def __init__(self): self.stack = []
def push(self, val): self.stack.append((val,val) if not self.stack else (val,min(val,self.stack[-1][1])))
def pop(self): self.stack.pop()
def top(self): return self.stack[-1][0]
def getMin(self): return self.stack[-1][1] | min-stack | Python - Simple and Elegant! Multiple Solutions! | domthedeveloper | 0 | 118 | min stack | 155 | 0.519 | Medium | 2,507 |
https://leetcode.com/problems/min-stack/discuss/1871125/Python-or-Approach-800%2B-ms-greater-76ms-TCO(1)-Optimized-solutionor-TCO(1)SCO(1)-or-Easy-to-understand | class MinStack(object):
def __init__(self):
self.stack = []
def push(self, val):
return self.stack.append(val)
def pop(self):
return self.stack.pop()
def top(self):
return self.stack[-1]
def getMin(self):
return min(self.stack) | min-stack | Python | Approach = 800+ ms -> 76ms TC=O(1) Optimized solution| TC=O(1)/SC=O(1) | Easy to understand | Patil_Pratik | 0 | 160 | min stack | 155 | 0.519 | Medium | 2,508 |
https://leetcode.com/problems/min-stack/discuss/1871125/Python-or-Approach-800%2B-ms-greater-76ms-TCO(1)-Optimized-solutionor-TCO(1)SCO(1)-or-Easy-to-understand | class MinStack(object):
def __init__(self):
self.stack = []
self.minStack = []
def push(self, val):
newMin = val
if self.minStack:
lastMin = self.minStack[-1]
newMin = min(lastMin, newMin)
self.minStack.append(newMin)
return self.stack.append(val)
def pop(self):
self.minStack.pop()
return self.stack.pop()
def top(self):
return self.stack[-1]
def getMin(self):
return self.minStack[-1] | min-stack | Python | Approach = 800+ ms -> 76ms TC=O(1) Optimized solution| TC=O(1)/SC=O(1) | Easy to understand | Patil_Pratik | 0 | 160 | min stack | 155 | 0.519 | Medium | 2,509 |
https://leetcode.com/problems/min-stack/discuss/1863037/Python-Straight-And-Easy-solution | class MinStack:
def __init__(self):
self.items = []
def push(self, val: int) -> None:
self.items.append(val)
def pop(self) -> None:
self.items.pop(-1)
def top(self) -> int:
return self.items[-1]
def getMin(self) -> int:
return min(self.items) | min-stack | Python Straight And Easy solution | hardik097 | 0 | 124 | min stack | 155 | 0.519 | Medium | 2,510 |
https://leetcode.com/problems/min-stack/discuss/1840510/PYTHON3-EFFICIENT-SOLUTION-oror-BEATS-90 | class MinStack:
def __init__(self):
self.stack = list()
self.minStack = list()
def push(self, val: int) -> None:
#Normal Push into Stack
self.stack.append(val)
#check if minStack.top()>val, then push it.
if not len(self.minStack) or self.minStack[-1]>=val:
self.minStack.append(val)
def pop(self) -> None:
#Normal Pop from the Stack
if len(self.stack):
removed = self.stack.pop()
#If removed element is minimum/ Top in minStack, then we'll pop it from minStack
if len(self.minStack) and removed == self.minStack[-1]:
self.minStack.pop()
return
def top(self) -> int:
if len(self.stack):
return self.stack[-1]
return -1
def getMin(self) -> int:
if len(self.minStack):
return self.minStack[-1]
return -1 | min-stack | PYTHON3 EFFICIENT SOLUTION || BEATS 90% | yolo_man | 0 | 93 | min stack | 155 | 0.519 | Medium | 2,511 |
https://leetcode.com/problems/min-stack/discuss/1687376/Python3-Simple-using-List | class MinStack:
def __init__(self):
self.myStack = list()
self.min = math.inf
def push(self, val: int) -> None:
self.myStack.append(val)
if val < self.min:
self.min = val
def pop(self) -> None:
if len(self.myStack) == 0:
return
self.myStack.pop()
if len(self.myStack) == 0:
self.min = math.inf
return
self.min = min(self.myStack)
def top(self) -> int:
if len(self.myStack) == 0:
return
return self.myStack[-1]
def getMin(self) -> int:
if len(self.myStack) == 0:
return
return self.min | min-stack | Python3, Simple, using List | kukamble | 0 | 73 | min stack | 155 | 0.519 | Medium | 2,512 |
https://leetcode.com/problems/intersection-of-two-linked-lists/discuss/2116127/Python-oror-Easy-2-approaches-oror-O(1)-space | class Solution:
def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:
first_set=set()
curr=headA
while curr:
first_set.add(curr)
curr=curr.next
curr = headB
while curr:
if curr in first_set:
return curr
curr=curr.next
return None | intersection-of-two-linked-lists | Python || Easy 2 approaches || O(1) space | constantine786 | 75 | 5,200 | intersection of two linked lists | 160 | 0.534 | Easy | 2,513 |
https://leetcode.com/problems/intersection-of-two-linked-lists/discuss/2116127/Python-oror-Easy-2-approaches-oror-O(1)-space | class Solution:
def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:
one = headA
two = headB
while one != two:
one = headB if one is None else one.next
two = headA if two is None else two.next
return one | intersection-of-two-linked-lists | Python || Easy 2 approaches || O(1) space | constantine786 | 75 | 5,200 | intersection of two linked lists | 160 | 0.534 | Easy | 2,514 |
https://leetcode.com/problems/intersection-of-two-linked-lists/discuss/1093186/Python.-Magic-solution.-O(n)-time.-O(1)-solution. | class Solution:
def changeSign(self, head: ListNode):
while ( head ):
head.val *= -1
head = head.next
def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
self.changeSign(headA)
while ( headB ):
if headB.val < 0:break
headB = headB.next
self.changeSign(headA)
return headB | intersection-of-two-linked-lists | Python. Magic solution. O(n) time. O(1) solution. | m-d-f | 20 | 1,600 | intersection of two linked lists | 160 | 0.534 | Easy | 2,515 |
https://leetcode.com/problems/intersection-of-two-linked-lists/discuss/1056026/Python.-Super-simple-easy-and-clear-solution.-O(n)-time-O(1)-memory. | class Solution:
def changeSign(self, head: ListNode):
while ( head ):
head.val *= -1
head = head.next
def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
self.changeSign(headA)
while ( headB ):
if headB.val < 0:break
headB = headB.next
self.changeSign(headA)
return headB | intersection-of-two-linked-lists | Python. Super simple, easy & clear solution. O(n) time, O(1) memory. | m-d-f | 5 | 443 | intersection of two linked lists | 160 | 0.534 | Easy | 2,516 |
https://leetcode.com/problems/intersection-of-two-linked-lists/discuss/467993/Python-3-(five-lines)-(beats-~99) | class Solution:
def getIntersectionNode(self, A: ListNode, B: ListNode) -> ListNode:
S = set()
while A != None: A, _ = A.next, S.add(A)
while B != None:
if B in S: return B
B = B.next
- Junaid Mansuri
- Chicago, IL | intersection-of-two-linked-lists | Python 3 (five lines) (beats ~99%) | junaidmansuri | 5 | 1,200 | intersection of two linked lists | 160 | 0.534 | Easy | 2,517 |
https://leetcode.com/problems/intersection-of-two-linked-lists/discuss/1196770/Python-solution-O-(m%2Bn)-time-O(1)-memory | class Solution:
def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
lenA = 0
lenB = 0
# calculate length for both linked lists
currA = headA
while currA:
lenA = lenA+1
currA = currA.next
currB = headB
while currB:
lenB = lenB + 1
currB = currB.next
# reset pointer back to start of the linked lists
currA = headA
currB = headB
# the possibility of the intersection (if any) will be within the length of the shorter linked list
# so skip through the longer list until the lengths match
if lenA > lenB:
while lenA != lenB:
lenA = lenA-1
currA = currA.next
else:
while lenA != lenB:
lenB = lenB-1
currB = currB.next
# once the remaining lengths for both linked lists are same, compare each of the nodes
while lenA > 0:
if currA == currB:
return currA
currA = currA.next
currB = currB.next
lenA = lenA-1
return | intersection-of-two-linked-lists | Python solution, O (m+n) time, O(1) memory | _choksi | 4 | 477 | intersection of two linked lists | 160 | 0.534 | Easy | 2,518 |
https://leetcode.com/problems/intersection-of-two-linked-lists/discuss/366774/Python-multiple-solutions | class Solution(object):
def getIntersectionNode(self, headA, headB):
"""
:type head1, head1: ListNode
:rtype: ListNode
"""
node1 = headA
node2 = headB
while node1 != node2:
node1 = node1.next if node1 else headB
node2 = node2.next if node2 else headA | intersection-of-two-linked-lists | Python multiple solutions | amchoukir | 4 | 1,000 | intersection of two linked lists | 160 | 0.534 | Easy | 2,519 |
https://leetcode.com/problems/intersection-of-two-linked-lists/discuss/366774/Python-multiple-solutions | class Solution(object):
def _length(self, head):
count = 0
while head:
count += 1
head = head.next
return count
def getIntersectionNode(self, headA, headB):
"""
:type head1, head1: ListNode
:rtype: ListNode
"""
lenA = self._length(headA)
lenB = self._length(headB)
(headS, lenS), (headL, lenL) = sorted([(headA, lenA),
(headB, lenB)],
key=lambda x: x[1])
diff = lenL - lenS
while diff:
headL = headL.next
diff -= 1
while headS != headL:
headS = headS.next
headL = headL.next
return headS | intersection-of-two-linked-lists | Python multiple solutions | amchoukir | 4 | 1,000 | intersection of two linked lists | 160 | 0.534 | Easy | 2,520 |
https://leetcode.com/problems/intersection-of-two-linked-lists/discuss/366774/Python-multiple-solutions | class Solution(object):
def getIntersectionNode(self, headA, headB):
"""
:type head1, head1: ListNode
:rtype: ListNode
"""
cache = set()
while headA:
cache.add(headA)
headA = headA.next
while headB:
if headB in cache:
return headB
headB = headB.next
return None | intersection-of-two-linked-lists | Python multiple solutions | amchoukir | 4 | 1,000 | intersection of two linked lists | 160 | 0.534 | Easy | 2,521 |
https://leetcode.com/problems/intersection-of-two-linked-lists/discuss/2278151/Simple-Python-Solution.-Beats-96.-with-comments | class Solution(object):
def getIntersectionNode(self, headA, headB):
seen = set() #Create a set for seen nodes
while headA or headB:
if headA:
if headA in seen: # If B has passed the node previously, then this is the intersect
return headA
else:
seen.add(headA) # record the node if not previously seen
headA = headA.next
if headB:
if headB in seen:
return headB
else:
seen.add(headB)
headB = headB.next
return # if no intersect, return None
#If you find this solution helpful, please upvote :) | intersection-of-two-linked-lists | Simple Python Solution. Beats 96%. with comments | cz2105 | 3 | 203 | intersection of two linked lists | 160 | 0.534 | Easy | 2,522 |
https://leetcode.com/problems/intersection-of-two-linked-lists/discuss/2118895/Python-oror-O(N) | class Solution:
def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:
# calculate length of lists
a = headA
alen = 0
while a:
alen += 1
a = a.next
b = headB
blen = 0
while b:
blen += 1
b = b.next
# check which list is longer
s = None
g = None
if alen > blen:
g = headA
s = headB
else:
g = headB
s = headA
# equalize lengths
for i in range(max(alen, blen) - min(alen, blen)):
g = g.next
# check intersection node wise
while s and g:
if s == g: return s
s = s.next
g = g.next
return None | intersection-of-two-linked-lists | Python || O(N) | Pootato | 3 | 159 | intersection of two linked lists | 160 | 0.534 | Easy | 2,523 |
https://leetcode.com/problems/intersection-of-two-linked-lists/discuss/2025817/Python-Easy-2-Pointers-Solution | class Solution:
def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:
a = headA
b = headB
loopCount = 0 # if no intersection
while True:
if a == b: return a
a = a.next
b = b.next
if not a: a = headB; loopCount += 1
if not b: b = headA
if loopCount > 1: return None
# Time: O(n + m)
# Space: O(1) | intersection-of-two-linked-lists | Python Easy 2 Pointers Solution | samirpaul1 | 3 | 164 | intersection of two linked lists | 160 | 0.534 | Easy | 2,524 |
https://leetcode.com/problems/intersection-of-two-linked-lists/discuss/1554184/faster-than-82.67%3A-Python-O(1)-and-O(n)-space | class Solution:
# O(n) Space
def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
hashset = set()
curr = headA
while curr:
hashset.add(curr)
curr = curr.next
curr = headB
while curr:
if curr in hashset:
return curr
curr = curr.next
return None
# O(1) Space
def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
sizeA = self.count(headA)
sizeB = self.count(headB)
if sizeA > sizeB:
diff = sizeA - sizeB
return self.get_result(diff, headA, headB)
else:
diff = sizeB - sizeA
return self.get_result(diff, headB, headA)
def get_result(self, diff, long_node, short_node):
while diff:
diff -= 1
long_node = long_node.next
while long_node != short_node:
if long_node is None or short_node is None:
return None
long_node = long_node.next
short_node = short_node.next
return long_node
def count(self, node):
count = 0
while node:
count += 1
node = node.next
return count | intersection-of-two-linked-lists | faster than 82.67%: Python O(1) and O(n) space | SleeplessChallenger | 3 | 468 | intersection of two linked lists | 160 | 0.534 | Easy | 2,525 |
https://leetcode.com/problems/intersection-of-two-linked-lists/discuss/2151429/Python-Solution-100 | class Solution:
def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:
a=headA
b=headB
while a!=b:
if a==None:
a=headB
else:
a=a.next
if b==None:
b=headA
else:
b=b.next
return a | intersection-of-two-linked-lists | Python Solution 100% | Siddharth_singh | 2 | 243 | intersection of two linked lists | 160 | 0.534 | Easy | 2,526 |
https://leetcode.com/problems/intersection-of-two-linked-lists/discuss/1401392/Python-or-Constant-Memory-or-O(N)-time-or-O(1)-space | class Solution:
def getLength(self,head):
cnt = 0
while head!=None:
cnt+=1
head = head.next
return cnt
def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
n1, n2 = self.getLength(headA), self.getLength(headB)
h1,h2 = headA, headB
ans = None
if n2 > n1:
h1, h2 = h2, h1
n1, n2 = n2, n1
#now n1 >= n2
skip_h1 = n1-n2
for i in range(skip_h1):
h1 = h1.next
while h1 != None:
if h1==h2:
return h1
h1 = h1.next
h2 = h2.next
return None | intersection-of-two-linked-lists | Python | Constant Memory | O(N) time | O(1) space | sathwickreddy | 2 | 259 | intersection of two linked lists | 160 | 0.534 | Easy | 2,527 |
https://leetcode.com/problems/intersection-of-two-linked-lists/discuss/1401392/Python-or-Constant-Memory-or-O(N)-time-or-O(1)-space | class Solution:
def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
h1, h2 = headA, headB
if h1 == None or h2 == None:
return None
while h1!=h2:
h1 = headB if h1==None else h1.next
h2 = headA if h2==None else h2.next
#even if no intersection they will equal at some point of time i.e., h1=None, h2=None
#at max 2 passess will be happened
return h1 | intersection-of-two-linked-lists | Python | Constant Memory | O(N) time | O(1) space | sathwickreddy | 2 | 259 | intersection of two linked lists | 160 | 0.534 | Easy | 2,528 |
https://leetcode.com/problems/intersection-of-two-linked-lists/discuss/1092876/Python3-Easy-soln-for-Intersection-of-Two-Linked-Lists-O(n)-time | class Solution:
def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
pointer1 = headA
pointer2 = headB
while pointer1 != pointer2: #if pointers are not the same
if pointer1: #if pointer1 is not at the end, it advances by one step
pointer1 = pointer1.next
else: #if pointer1 is at the end, it becomes headB
pointer1 = headB
#same should be done for pointer2
if pointer2: #if pointer1 is not at the end, it advances by one step
pointer2 = pointer2.next
else: #if pointer1 is at the end, it becomes headB
pointer2 = headA
return pointer1 #if the pointers are te same | intersection-of-two-linked-lists | [Python3] Easy soln for Intersection of Two Linked Lists, O(n) time | avEraGeC0der | 2 | 142 | intersection of two linked lists | 160 | 0.534 | Easy | 2,529 |
https://leetcode.com/problems/intersection-of-two-linked-lists/discuss/2366113/Python-oror-Easy-oror-O(m%2Bn)-time-oror-O(1)-space | class Solution:
def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:
m = 0
n = 0
temp = headA
while temp != None:
m+=1
temp = temp.next
temp = headB
while temp != None:
n+=1
temp = temp.next
diff = 0
if m>=n :
diff = m-n
else:
diff = n-m
p1 = headA
p2 = headB
if max(m,n) == m:
while diff > 0:
p1 = p1.next
diff-=1
else:
while diff > 0:
p2 = p2.next
diff-=1
while p1 != None and p2!=None:
if p1 == p2:
return p1
p1 = p1.next
p2 = p2.next
return None | intersection-of-two-linked-lists | Python || Easy || O(m+n) time || O(1) space | nitisanand | 1 | 220 | intersection of two linked lists | 160 | 0.534 | Easy | 2,530 |
https://leetcode.com/problems/intersection-of-two-linked-lists/discuss/2126395/Python-Simple-Python-Solution-Using-Difference-of-Node-Counts | class Solution:
def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:
total_node_A = 0
total_node_B = 0
new_headA = headA
new_headB = headB
while new_headA:
total_node_A = total_node_A + 1
new_headA = new_headA.next
while new_headB:
total_node_B = total_node_B + 1
new_headB = new_headB.next
diffrence = total_node_A - total_node_B
if diffrence < 0:
count = 0
while count < abs(diffrence):
count = count + 1
headB = headB.next
else:
count = 0
while count < diffrence:
count = count + 1
headA = headA.next
while headA and headB:
if headA is headB:
return headA
headA = headA.next
headB = headB.next
return None | intersection-of-two-linked-lists | [ Python ] ✅✅ Simple Python Solution Using Difference of Node Counts 🥳✌👍 | ASHOK_KUMAR_MEGHVANSHI | 1 | 154 | intersection of two linked lists | 160 | 0.534 | Easy | 2,531 |
https://leetcode.com/problems/intersection-of-two-linked-lists/discuss/2117785/java-python-easy-linear-solution-(space-O1) | class Solution:
def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:
if headA == None or headB == None : return None
lena, lenb = 0, 0
w = headA
while w.next != None : w, lena = w.next, lena+1
w = headB
while w.next != None : w, lenb = w.next, lenb+1
i, shift = 0, lena-lenb
while i < shift : headA, i = headA.next, i+1
i, shift = 0, lenb-lena
while i < shift : headB, i = headB.next, i+1
while headA != headB : headA, headB = headA.next, headB.next
return headA | intersection-of-two-linked-lists | java, python - easy linear solution (space O1) | ZX007java | 1 | 84 | intersection of two linked lists | 160 | 0.534 | Easy | 2,532 |
https://leetcode.com/problems/intersection-of-two-linked-lists/discuss/2117192/Python-easy-solution-for-beginners-using-seen-set | class Solution:
def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
seen = set()
while headA:
seen.add(headA)
headA = headA.next
while headB:
if headB in seen:
return headB
seen.add(headB)
headB = headB.next | intersection-of-two-linked-lists | Python easy solution for beginners using seen set | alishak1999 | 1 | 110 | intersection of two linked lists | 160 | 0.534 | Easy | 2,533 |
https://leetcode.com/problems/intersection-of-two-linked-lists/discuss/1740195/only-3-lines-of-operation-or-easy-to-understand-or-O(1)-space | class Solution:
def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:
if headA == None or headB == None:
return None
n1 = headA
n2 = headB
while n1 != n2:
n1 = headB if n1 == None else n1.next
n2 = headA if n2 == None else n2.next
return n1 | intersection-of-two-linked-lists | only 3 lines of operation | easy to understand | O(1) space | prankurgupta18 | 1 | 92 | intersection of two linked lists | 160 | 0.534 | Easy | 2,534 |
https://leetcode.com/problems/intersection-of-two-linked-lists/discuss/1188963/Runtime%3A-faster-than-74-.Memory-Usage%3A-less-than-95-of-Python3 | class Solution:
def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
listA = headA
listB = headB
semaphore = 2
while(listA or listB):
if semaphore == 0 or listA == listB:
break
if listA:
listA = listA.next
else:
listA = headB
semaphore -= 1
if listB:
listB = listB.next
else:
listB = headA
semaphore -= 1
while(listA or listB):
if listA is listB:
return listA
listA = listA.next
listB = listB.next
return listA | intersection-of-two-linked-lists | Runtime: faster than 74% .Memory Usage: less than 95% of Python3 | BanarasiVaibhav | 1 | 178 | intersection of two linked lists | 160 | 0.534 | Easy | 2,535 |
https://leetcode.com/problems/intersection-of-two-linked-lists/discuss/1188963/Runtime%3A-faster-than-74-.Memory-Usage%3A-less-than-95-of-Python3 | class Solution:
def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
len_headA = self.count_length(headA)
len_headB = self.count_length(headB)
for i in range(len_headA - len_headB):
headA = headA.next
for i in range(len_headB - len_headA):
headB = headB.next
while(headA):
if headA is headB:
return headA
headA=headA.next
headB=headB.next
return headA
def count_length(self,some_head):
count = 0
while(some_head):
count += 1
some_head=some_head.next
return count | intersection-of-two-linked-lists | Runtime: faster than 74% .Memory Usage: less than 95% of Python3 | BanarasiVaibhav | 1 | 178 | intersection of two linked lists | 160 | 0.534 | Easy | 2,536 |
https://leetcode.com/problems/intersection-of-two-linked-lists/discuss/1092856/Python-Using-Dictionaries-or-Easy-Solution | class Solution:
def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
d={}
temp = headA
tempB = headB
# Storing all links of A
while temp!=None:
d[temp]=1
temp = temp.next
# Checking if any of the links of B are present in the Dict.
while tempB!= None:
if tempB in d:
return tempB
tempB = tempB.next
return | intersection-of-two-linked-lists | Python - Using Dictionaries | Easy Solution | adz0612 | 1 | 37 | intersection of two linked lists | 160 | 0.534 | Easy | 2,537 |
https://leetcode.com/problems/intersection-of-two-linked-lists/discuss/1080397/Python-O(n)-easy-to-understand | class Solution:
def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
alen = 0
blen = 0
ptra = headA
ptrb = headB
#2 while loops to find the length of the linked list
while ptra:
alen+=1
ptra= ptra.next
while ptrb:
blen +=1
ptrb = ptrb.next
if alen==0 or blen==0:
return None
dif = abs(alen-blen) #difference between their lengths
#below 2 if statements make the length of both the linked list equal by deleting the starting node of the larger linked list
if alen>blen:
while dif:
headA = headA.next
dif-=1
elif blen>alen:
while dif:
headB= headB.next
dif-=1
#iterate through both the linked list together and once they point to the same node return that node
while headA and headB:
if headA == headB:
return headA
headA = headA.next
headB = headB.next
#if there is no common node return None
return None | intersection-of-two-linked-lists | Python O(n) easy to understand | abhishekm2106 | 1 | 298 | intersection of two linked lists | 160 | 0.534 | Easy | 2,538 |
https://leetcode.com/problems/intersection-of-two-linked-lists/discuss/642385/JavaPython3-traverse-A-greaterB-and-B-greaterA-at-the-same-time | class Solution:
def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
nodeA, nodeB = headA, headB
while nodeA != nodeB:
nodeA = nodeA.next if nodeA else headB
nodeB = nodeB.next if nodeB else headA
return nodeA | intersection-of-two-linked-lists | [Java/Python3] traverse A->B and B->A at the same time | ye15 | 1 | 124 | intersection of two linked lists | 160 | 0.534 | Easy | 2,539 |
https://leetcode.com/problems/intersection-of-two-linked-lists/discuss/250387/two-pointer-python-solution | class Solution(object):
def getIntersectionNode(self, headA, headB):
"""
:type head1, head1: ListNode
:rtype: ListNode
"""
curA = headA
curB = headB
while curA != curB:
curA = curA.next if curA else headB
curB = curB.next if curB else headA
return curA | intersection-of-two-linked-lists | two pointer python solution | mazheng | 1 | 278 | intersection of two linked lists | 160 | 0.534 | Easy | 2,540 |
https://leetcode.com/problems/intersection-of-two-linked-lists/discuss/2831326/python-oror-simple-solution-oror-o(1)-memory | class Solution:
def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:
itrA, itrB = headA, headB # iterators for A and B
# iterate through A+B and B+A simultaneously, first shared node is the intersection
while itrA is not itrB:
# if end of either reached, loop back to beginning of other linkedlist
itrA = itrA.next if itrA else headB
itrB = itrB.next if itrB else headA
# return either intersection node or null if end of headB reached
return itrA | intersection-of-two-linked-lists | python || simple solution || o(1) memory | wduf | 0 | 6 | intersection of two linked lists | 160 | 0.534 | Easy | 2,541 |
https://leetcode.com/problems/intersection-of-two-linked-lists/discuss/2784624/Bruteforce-Method | class Solution:
def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:
# get the lenght of the two heads
d1, d2 = ListNode(0, headA), ListNode(0, headB)
l1, l2 = 0,0
while d1:
d1 = d1.next
l1 += 1
while d2:
d2 = d2.next
l2 += 1
if l1 > l2:
while l1 > l2:
headA = headA.next
l1 -= 1
else:
while l2 > l1:
headB = headB.next
l2 -= 1
while headA and headB:
if headA == headB:
return headA
headA, headB = headA.next, headB.next
return None | intersection-of-two-linked-lists | Bruteforce Method | keshan-spec | 0 | 2 | intersection of two linked lists | 160 | 0.534 | Easy | 2,542 |
https://leetcode.com/problems/intersection-of-two-linked-lists/discuss/2773191/Using-a-dictionary-Python3 | class Solution:
def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:
node_dict = {}
node = headA
while node:
node_dict[node] = True
node = node.next
node = headB
while node:
if node in node_dict:
return node
node = node.next
return None | intersection-of-two-linked-lists | Using a dictionary - Python3 | divesh-panwar | 0 | 4 | intersection of two linked lists | 160 | 0.534 | Easy | 2,543 |
https://leetcode.com/problems/intersection-of-two-linked-lists/discuss/2702220/Python3-Easy-and-fast-Sol-90 | class Solution:
def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:
Set=set()
curr= headA
while curr:
Set.add(curr)
curr=curr.next
curr=headB
while curr:
if curr in Set:
return curr
curr=curr.next
return None | intersection-of-two-linked-lists | Python3 Easy and fast Sol 90% | pranjalmishra334 | 0 | 7 | intersection of two linked lists | 160 | 0.534 | Easy | 2,544 |
https://leetcode.com/problems/find-peak-element/discuss/1440424/Python-oror-Easy-Solution | class Solution:
def findPeakElement(self, lst: List[int]) -> int:
start, end = 0, len(lst) - 1
while start < end:
mid = start + (end - start) // 2
if lst[mid] > lst[mid + 1]:
end = mid
else:
start = mid + 1
return start | find-peak-element | Python || Easy Solution | naveenrathore | 8 | 619 | find peak element | 162 | 0.462 | Medium | 2,545 |
https://leetcode.com/problems/find-peak-element/discuss/2120747/PYTHON-oror-O-(-LOG-N-)-oror-EXPANATION | class Solution:
def findPeakElement(self, nums: List[int]) -> int:
if len(nums)==1:
return 0
if nums[0]>nums[1]:
return 0
if nums[-1]>nums[-2]:
return len(nums)-1
l=1
h=len(nums)-1
while l<h:
m=(l+h)//2
if nums[m-1]<nums[m]>nums[m+1]:
return m
elif nums[m-1]<nums[m]<nums[m+1]:
l=m+1
else:
h=m
return l | find-peak-element | ✔️ PYTHON || O ( LOG N ) || EXPANATION | karan_8082 | 4 | 346 | find peak element | 162 | 0.462 | Medium | 2,546 |
https://leetcode.com/problems/find-peak-element/discuss/1335946/Linear-time-Solution(python) | class Solution:
def findPeakElement(self, nums: List[int]) -> int:
for i in range(len(nums)-1):
if nums[i]>nums[i+1]:
return i
return len(nums)-1 | find-peak-element | Linear time Solution(python) | _jorjis | 3 | 139 | find peak element | 162 | 0.462 | Medium | 2,547 |
https://leetcode.com/problems/find-peak-element/discuss/2670585/Python-solution-or-Binary-search | class Solution:
def findPeakElement(self, nums: List[int]) -> int:
left = 0
right = len(nums) - 1
if len(nums) == 1:
return 0
while right > left:
mid = (left + right)//2
if nums[mid] > nums[mid-1] and nums[mid] > nums[mid+1]:
return mid
if nums[mid] < nums[mid+1]:
left = mid + 1
else:
right = mid - 1
return right if nums[right] > nums[mid] else mid | find-peak-element | Python solution | Binary search | maomao1010 | 1 | 575 | find peak element | 162 | 0.462 | Medium | 2,548 |
https://leetcode.com/problems/find-peak-element/discuss/2185102/Super-simple-easy-to-understand-python-one-liner | class Solution:
def findPeakElement(self, nums: List[int]) -> int:
return nums.index(max(nums)) | find-peak-element | Super simple, easy to understand, python one-liner | pro6igy | 1 | 113 | find peak element | 162 | 0.462 | Medium | 2,549 |
https://leetcode.com/problems/find-peak-element/discuss/2000054/Easy-one-liner-Python-faster-than-88.55-of-Python3-online-submissions | class Solution:
def findPeakElement(self, nums: List[int]) -> int:
return nums.index(max(nums)) | find-peak-element | Easy one liner Python faster than 88.55% of Python3 online submissions | James-Kosinar | 1 | 110 | find peak element | 162 | 0.462 | Medium | 2,550 |
https://leetcode.com/problems/find-peak-element/discuss/1772943/Python-Code-or-99-Faster-or-O(log-N) | class Solution:
def findPeakElement(self, arr: List[int]) -> int:
n=len(arr)
l,e=0,n-1
while l<e:
mid=l+(e-l)//2
if arr[mid]>=arr[mid+1] and arr[mid]>=arr[mid-1]:
return mid
else:
if arr[mid]<arr[mid+1]:
l=mid+1
elif arr[mid]<arr[mid-1]:
e=mid-1
return l | find-peak-element | Python Code | 99% Faster | O(log N) | rackle28 | 1 | 96 | find peak element | 162 | 0.462 | Medium | 2,551 |
https://leetcode.com/problems/find-peak-element/discuss/1431737/WEEB-DOES-PYTHON | class Solution:
def findPeakElement(self, nums: List[int]) -> int:
low, high = 0, len(nums)-1
while low<high:
mid = low + (high-low)//2
if nums[mid] < nums[mid+1]:
low = mid + 1
else:
high = mid
return low | find-peak-element | WEEB DOES PYTHON | Skywalker5423 | 1 | 134 | find peak element | 162 | 0.462 | Medium | 2,552 |
https://leetcode.com/problems/find-peak-element/discuss/724744/Python3-binary-search | class Solution:
def findPeakElement(self, nums: List[int]) -> int:
lo, hi = 0, len(nums)-1
while lo < hi:
mid = lo + hi >> 1
if nums[mid] < nums[mid+1]: lo = mid+1
else: hi = mid
return lo | find-peak-element | [Python3] binary search | ye15 | 1 | 100 | find peak element | 162 | 0.462 | Medium | 2,553 |
https://leetcode.com/problems/find-peak-element/discuss/397476/Solution-in-Python-3-(beats-~100) | class Solution:
def findPeakElement(self, N: List[int]) -> int:
L, _ = len(N), N.append(-math.inf)
for i in range(L):
if N[i] > N[i+1]: return i
- Junaid Mansuri
(LeetCode ID)@hotmail.com | find-peak-element | Solution in Python 3 (beats ~100%) | junaidmansuri | 1 | 331 | find peak element | 162 | 0.462 | Medium | 2,554 |
https://leetcode.com/problems/find-peak-element/discuss/2847773/Python-binary-search-beat-90 | class Solution:
def findPeakElement(self, nums: List[int]) -> int:
start=0
end=len(nums)-1
while(start<end):
mid=(start+end)//2
if(nums[mid]<nums[mid+1]):
start=mid+1
else:
end=mid
return start | find-peak-element | Python binary search beat 90% | Akash2907 | 0 | 1 | find peak element | 162 | 0.462 | Medium | 2,555 |
https://leetcode.com/problems/find-peak-element/discuss/2829136/O(n)-solution-in-Python | class Solution:
def findPeakElement(self, nums: List[int]) -> int:
m = max(nums)
for i in range(len(nums) + 1):
if nums[i] == m:
return i | find-peak-element | O(n) solution in Python | 123liamspillane | 0 | 1 | find peak element | 162 | 0.462 | Medium | 2,556 |
https://leetcode.com/problems/find-peak-element/discuss/2821965/Python-O(log(n))-solution-Accepted | class Solution:
def findPeakElement(self, nums: List[int]) -> int:
if len(nums) == 1:
return 0
left: int = 0
right: int = len(nums) - 1
while left <= right:
if right == len(nums) - 1:
if nums[right - 1] < nums[right]:
return right
else:
if nums[right - 1] < nums[right] and nums[right + 1] < nums[right]:
return right
if left == 0:
if nums[left + 1] < nums[left]:
return left
else:
if nums[left - 1] < nums[left] and nums[left + 1] < nums[left]:
return left
left += 1
right -= 1 | find-peak-element | Python O(log(n)) solution [Accepted] | lllchak | 0 | 3 | find peak element | 162 | 0.462 | Medium | 2,557 |
https://leetcode.com/problems/find-peak-element/discuss/2810485/Easy-Python-solution-EXPLAINED | class Solution:
def findPeakElement(self, nums: List[int]) -> int:
n = len(nums)
left = 0
right = n - 1
while left <= right:
mid = (right + left) // 2
l = nums[mid - 1] if mid > 0 else -float('inf')
r = nums[mid + 1] if mid < n - 1 else -float('inf')
if l < nums[mid] and nums[mid] > r:
return mid
elif nums[mid] < r:
left = mid + 1
else:
right = mid - 1 | find-peak-element | Easy Python solution [EXPLAINED] | tleuliyev | 0 | 5 | find peak element | 162 | 0.462 | Medium | 2,558 |
https://leetcode.com/problems/find-peak-element/discuss/2799432/Simple-python-codeororBinary-SearchororO(log2n) | class Solution:
def findPeakElement(self, nums: List[int]) -> int:
n=len(nums)
low=0
high=n-1
if(low==high):
return low
while(low<=high):
mid=(low+high)//2
if(mid==0):
if nums[mid]>nums[mid+1]:
return mid
else:
low=mid+1
elif (mid==len(nums)-1):
if nums[mid]>nums[mid-1]:
return mid
else:
high=mid-1
elif(mid>0 and mid <n-1 and nums[mid+1]<nums[mid] and nums[mid-1]<nums[mid]):
return mid
elif(mid>0 and nums[mid]<nums[mid-1]):
high=mid-1
elif(mid<n-1 and nums[mid]<nums[mid+1]):
low=mid+1
return -1 | find-peak-element | Simple python code||Binary Search||O(log2n) | Ankit_Verma03 | 0 | 2 | find peak element | 162 | 0.462 | Medium | 2,559 |
https://leetcode.com/problems/find-peak-element/discuss/2796813/Python-or-Simple-or-Binary-Search-or-O(log-n) | class Solution:
def findPeakElement(self, nums: List[int]) -> int:
start, end = 0, len(nums) - 1
while start < end:
mid = start + (end - start) // 2
if nums[mid] > nums[mid+1]:
end = mid
else:
start = mid + 1
return start | find-peak-element | Python | Simple | Binary Search | O(log n) | david-cobbina | 0 | 4 | find peak element | 162 | 0.462 | Medium | 2,560 |
https://leetcode.com/problems/find-peak-element/discuss/2793534/Python3-Straightforward-Binary-Search | class Solution:
def findPeakElement(self, nums: List[int]) -> int:
l, r = 0, len(nums)-1
while l <= r:
mid = (l+r)//2
# midpoint is peak
if ((mid-1 < 0 or nums[mid] > nums[mid-1])
and (mid+1 == len(nums) or nums[mid] > nums[mid+1])):
return mid
# peak is in the left partition
elif (mid-1 >=0 and
(mid+1 == len(nums) or (nums[mid-1] > nums[mid+1]))):
r = mid-1
# peak is in the right partition
else:
l = mid+1 | find-peak-element | [Python3] Straightforward Binary Search | jonathanbrophy47 | 0 | 2 | find peak element | 162 | 0.462 | Medium | 2,561 |
https://leetcode.com/problems/find-peak-element/discuss/2750381/Funny-python | class Solution:
def findPeakElement(self, nums: List[int]) -> int:
return nums.index(max(nums)) | find-peak-element | Funny python | rajubuet24 | 0 | 2 | find peak element | 162 | 0.462 | Medium | 2,562 |
https://leetcode.com/problems/find-peak-element/discuss/2745441/python-binary-search-O(log(n)) | class Solution:
def findPeakElement(self, nums: List[int]) -> int:
# O(log n), O(1)
l, r = 0, len(nums) - 1
while l < r:
mid = l + (r-l)//2
if nums[mid] < nums[mid + 1]:
l = mid + 1
else:
r = mid
return l | find-peak-element | python binary search O(log(n)) | sahilkumar158 | 0 | 1 | find peak element | 162 | 0.462 | Medium | 2,563 |
https://leetcode.com/problems/find-peak-element/discuss/2740091/Simple-Beginner-Friendly-Approach-or-One-Pass-or-no-built-in-function-or-O(LogN)-or-O(1) | class Solution:
def findPeakElement(self, nums: List[int]) -> int:
left, right = 0, len(nums) - 1
while left <= right:
mid = (left + right) // 2
if left == mid:
if nums[left] >= nums[right]:
return left
else:
return right
elif nums[mid] < nums[mid + 1]:
left = mid + 1
elif nums[mid] < nums[mid - 1]:
right = mid - 1
elif nums[mid] > nums[mid - 1] and nums[mid] > nums[mid + 1]:
return mid | find-peak-element | Simple Beginner Friendly Approach | One Pass | no built-in function | O(LogN) | O(1) | sonnylaskar | 0 | 2 | find peak element | 162 | 0.462 | Medium | 2,564 |
https://leetcode.com/problems/find-peak-element/discuss/2737245/Iterative-python3-solution-with-documentation-TC%3A-O(log2n)-SC%3A-O(1) | class Solution:
def findPeakElement(self, nums: List[int]) -> int:
## SC O(1)
## TC O(log2n)
# Extreme cases, array with one and two elements
if len(nums) == 1:
return 0
if len(nums) == 2:
return 0 if nums[0] > nums[1] else 1
# binary search alogorithm
left = 0
right = len(nums) - 1
while left < right:
# find mid value
M = left + (right-left)//2
# peak is found nums[M-1] < nums[M] > nums[M+1]
if nums[M] > nums[M-1] and nums[M] > nums[M+1]:
return M
# divide remaining array in 2 and
# move right to M-1 if nums[M-1] > nums[M] > nums[M+1]
if nums[M] < nums[M-1] and nums[M] > nums[M+1]:
right = M -1
# move left to M+1 if nums[M-1] < nums[M] < nums[M+1]
# and if nums[M-1] > nums[M] < nums[M+1] - > arbitrary decision, you could also
# add a new case where nums[M-1] > nums[M] < nums[M+1] and decide if go left or right
else:
left = M + 1
# end of loop left == right and num[right] is at a peak
return right | find-peak-element | Iterative python3 solution with documentation TC: O(log2n) SC: O(1) | MPoinelli | 0 | 2 | find peak element | 162 | 0.462 | Medium | 2,565 |
https://leetcode.com/problems/find-peak-element/discuss/2678548/Python-Solution-beats-runtime-by-93.44-using-Binary-Search | class Solution:
def findPeakElement(self, nums: List[int]) -> int:
start = 0
end = len(nums) - 1
while start <= end:
mid = (start + end) // 2
if ((mid == 0) or (nums[mid] > nums[mid-1])) and ((mid == len(nums) - 1) or (nums[mid] > nums[mid+1])) :
return mid
elif (mid==0 or nums[mid]>nums[mid-1]):
start = mid + 1
else:
end = mid - 1
return -1 | find-peak-element | Python Solution beats runtime by 93.44% using Binary Search | user2385PN | 0 | 7 | find peak element | 162 | 0.462 | Medium | 2,566 |
https://leetcode.com/problems/find-peak-element/discuss/2674449/Python-Binary-Search-or-With-some-explanation | class Solution:
def findPeakElement(self, nums: List[int]) -> int:
# Handle edge cases for 1 or 2 element arrays
if len(nums) == 1:
return 0
n = len(nums)
if nums[0] > nums[1]:
return 0
if nums[-1] > nums[-2]:
return n - 1
start = 0
end = len(nums) - 1
while start <= end:
mid = (start + end) // 2
if nums[mid] > nums[mid - 1] and nums[mid] > nums[mid + 1]:
return mid
elif nums[mid] < nums[mid + 1]:
start = mid + 1
else:
end = mid - 1 | find-peak-element | Python - Binary Search | With some explanation | saadbash | 0 | 4 | find peak element | 162 | 0.462 | Medium | 2,567 |
https://leetcode.com/problems/find-peak-element/discuss/2674035/Easy-and-clean-Python-solution | class Solution:
def findPeakElement(self, nums: List[int]) -> int:
TOWARD_RIGHT = -1 # look like this: /
PEAK = 0 # look like this: ^
TOWARD_LEFT = 1 # look like this: \
def explore_neighbors(pos: int):
# three status: toward left, right and peak
cur = nums[pos]
left = float('-inf') if pos == 0 else nums[pos-1]
right = float('-inf') if pos == len(nums) else nums[pos+1]
if cur > left and cur > right:
return PEAK
elif cur < left:
return TOWARD_LEFT
else:
return TOWARD_RIGHT
l, r = 0, len(nums) - 1
while l < r:
mid = (l + r) // 2
mid_status = explore_neighbors(mid)
if mid_status == PEAK:
return mid
elif mid_status == TOWARD_RIGHT:
l = mid + 1
else:
r = mid
return l | find-peak-element | Easy and clean Python solution | Starboy69 | 0 | 1 | find peak element | 162 | 0.462 | Medium | 2,568 |
https://leetcode.com/problems/find-peak-element/discuss/2645257/Python-explanation-with-graph-explanation | class Solution:
# Append the nums with -infinity and prepend the nums with -infinity as per the question
# This ensures atleast one peak will always exist
# Think of 3 graphs before approaching the problem
# For the first and the last graph we can just keep on increasing or decresing the l as per the binary search algo
# The same applies to multiple peaks on right and left
# For the middle graph if such a case or multiple peak case happens by default the first peak can be found easily
# just by decreasing l as per the binary search algo
def findPeakElement(self, nums: List[int]) -> int:
l, r = 0, len(nums) - 1
while l < r:
m = l + ((r - l) >> 1)
if nums[m] > nums[m + 1]:
r = m
else:
l = m + 1
return | find-peak-element | Python explanation with graph explanation | shiv-codes | 0 | 47 | find peak element | 162 | 0.462 | Medium | 2,569 |
https://leetcode.com/problems/find-peak-element/discuss/2498096/Easy-Python-Solution-or-Binary-Search | class Solution:
def findPeakElement(self, nums: List[int]) -> int:
if len(nums)==1:
return 0
if nums[0]>nums[1]:
return 0
if nums[-1]>nums[-2]:
return len(nums)-1
low=0
high=len(nums)-1
while low<=high:
mid=(low+high)//2
if mid>0 and mid<len(nums)-1 and nums[mid]>nums[mid+1] and nums[mid]>nums[mid-1]:
return mid
if mid>0 and nums[mid-1]>nums[mid]:
high=mid-1
else:
low=mid+1
return -1 | find-peak-element | Easy Python Solution | Binary Search | Siddharth_singh | 0 | 119 | find peak element | 162 | 0.462 | Medium | 2,570 |
https://leetcode.com/problems/find-peak-element/discuss/2485302/Python3-or-Solved-Using-Binary-Search-With-Simple-Intuition | class Solution:
#Time-Complexity: O(logn)
#Space-Complexity: O(1)
def findPeakElement(self, nums: List[int]) -> int:
#Approach: Start with left boundary being index 0 position and right boundary
#being first out of bounds position: index len(nums)!
#At every iteration of binary search, we will get the middle index, see if middle
#index element is a peak, and if it's not a peak, I will reduce search space towards
#the greater of the two neighboring elements and reduce search by approximately half each
#time!
L, R = 0, len(nums)
while L < R:
mid = (L + R) // 2
left_n, right_n = None, None
if(mid == 0):
left_n = float(-inf)
else:
left_n = nums[mid - 1]
if(mid == len(nums) - 1):
right_n = float(-inf)
else:
right_n = nums[mid + 1]
#now check if middle element is peak!
if(nums[mid] > left_n and nums[mid] > right_n):
return mid
#only greater than left neighbor: reduce search space to right portion!
elif(nums[mid] > left_n):
L = mid + 1
continue
else:
R = mid
continue
#Post-Processing: Could there potentially be peak element with only single element
#remaining in search space?
#Yes, if input array is already sorted in strictly decreasing order!
#But, we see we would eventually return peak index of 0 by returning from while loop!
#Also, I dry runned my code where peak element was only last element where input array
#is sorted in increasing order, and it also returned correct answer by returning
#from while loop!
#No post processing needed! | find-peak-element | Python3 | Solved Using Binary Search With Simple Intuition | JOON1234 | 0 | 34 | find peak element | 162 | 0.462 | Medium | 2,571 |
https://leetcode.com/problems/find-peak-element/discuss/2455098/Python-easy-binary-search | class Solution:
def findPeakElement(self, nums: list[int]) -> int:
left, right = 0, len(nums) - 1
while left < right:
mid = (left + right) // 2
if nums[mid] > nums[mid + 1]:
right = mid
else:
left = mid + 1
return left | find-peak-element | Python easy binary search | Mark_computer | 0 | 86 | find peak element | 162 | 0.462 | Medium | 2,572 |
https://leetcode.com/problems/find-peak-element/discuss/2432044/Python-O(log(N)) | class Solution:
def findPeakElement(self, nums: List[int]) -> int:
l = 0
r = len(nums)
while l < r:
mid = (l+r) // 2
# greater than left
gl = (mid == 0 or nums[mid] > nums[mid-1])
# greater than right
gr = (mid == len(nums)-1 or nums[mid] > nums[mid+1])
# find the peak
if gl and gr:
return mid
# left > mid and mid < right
# left side has at least one peak, right has at least one peak
# left > mid > right
# left side has at least one peak
elif (not gl and not gr) or (not gl and gr):
r = mid
# left < mid < right
# right side has at least one peak
else:
l = mid + 1
return l | find-peak-element | Python O(log(N)) | TerryHung | 0 | 61 | find peak element | 162 | 0.462 | Medium | 2,573 |
https://leetcode.com/problems/find-peak-element/discuss/2403154/98-python3-solution-easily-understandable | class Solution:
def findPeakElement(self, nums: List[int]) -> int:
n = len(nums)
if n < 3:
max_val = max(nums)
return nums.index(max_val)
def binarySearchPeek(lo: int, hi: int) -> int:
result = -1
while lo <= hi:
mid = (lo+hi)//2
prev = (mid-1)
nxt = (mid+1)
if (prev < 0 or nums[mid] > nums[prev]) and (nxt >= n or nums[mid] > nums[nxt]):
return mid
elif lo == hi-1:
lo = hi
elif nums[prev] > nums[nxt]:
hi = mid
else:
lo = mid
return lo
return binarySearchPeek(0, n-1) | find-peak-element | 98% python3 solution, easily understandable | destifo | 0 | 29 | find peak element | 162 | 0.462 | Medium | 2,574 |
https://leetcode.com/problems/find-peak-element/discuss/2214914/Python-pure-binary-search | class Solution:
def findPeakElement(self, nums: List[int]) -> int:
nums = [-math.inf] + nums + [-math.inf]
left = 0
right = len(nums) - 1
while left <= right:
mid = (left + right) // 2
if nums[mid-1] < nums[mid] > nums[mid+1]:
return mid - 1
elif nums[mid-1] > nums[mid]:
right = mid - 1
else:
left = mid + 1 | find-peak-element | Python, pure binary search | blue_sky5 | 0 | 51 | find peak element | 162 | 0.462 | Medium | 2,575 |
https://leetcode.com/problems/find-peak-element/discuss/2108398/Find-Peak-Element | class Solution:
def findPeakElement(self, nums: List[int]) -> int:
return nums.index(max(nums)) | find-peak-element | Find Peak Element | anil5829354 | 0 | 14 | find peak element | 162 | 0.462 | Medium | 2,576 |
https://leetcode.com/problems/find-peak-element/discuss/2078912/O(LogN)-Approach-for-the-solution | class Solution:
def findPeakElement(self, nums: List[int]) -> int:
s = 0
e = len(nums)-1
mid = int(s+(e-s)/2)
while(s<e):
if(nums[mid]<nums[mid+1]):
s=mid+1
else:
e = mid
mid = int(s+(e-s)/2)
return mid | find-peak-element | O(LogN) Approach for the solution | arpit3043 | 0 | 113 | find peak element | 162 | 0.462 | Medium | 2,577 |
https://leetcode.com/problems/find-peak-element/discuss/2040977/Simple-Python-Binary-Search-sol | class Solution:
def findPeakElement(self, nums: List[int]) -> int:
start = 0
end = len(nums) - 1
while start < end:
mid = start + (end - start) // 2
if nums[mid] > nums[mid + 1]: #If currently in decreasing order of the list
end = mid
else: #If in increasing order of the list, start after mid element
start = mid + 1
return start | find-peak-element | Simple Python Binary Search sol | abhay147 | 0 | 47 | find peak element | 162 | 0.462 | Medium | 2,578 |
https://leetcode.com/problems/find-peak-element/discuss/1950470/Python-oror-Clean-Binary-Search | class Solution:
def findPeakElement(self, nums: List[int]) -> int:
start, end = 0 , len(nums)-1
nums.append(-inf)
while start <= end:
mid = (start+end)//2
if mid == 0:
if nums[mid] > nums[mid+1]: return mid
else: start = mid+1
elif nums[mid-1] < nums[mid] and nums[mid] > nums[mid+1]:
return mid
elif nums[mid] < nums[mid-1] or nums[mid] < nums[mid+1]:
if nums[mid-1] < nums[mid+1]: start = mid+1
else: end = mid-1 | find-peak-element | Python || Clean Binary Search | morpheusdurden | 0 | 98 | find peak element | 162 | 0.462 | Medium | 2,579 |
https://leetcode.com/problems/find-peak-element/discuss/1855998/Python-easy-to-read-and-understand-or-binary-search | class Solution:
def findPeakElement(self, nums: List[int]) -> int:
if len(nums) == 1:
return 0
if len(nums) == 2:
return 0 if nums[0] > nums[1] else 1
start, end = 0, len(nums)-1
while start <= end:
mid = (start+end) // 2
#print(mid)
if mid > 0 and mid < len(nums)-1 and nums[mid-1] < nums[mid] > nums[mid+1]:
return mid
if mid < len(nums)-1 and nums[mid] < nums[mid+1]:
start = mid+1
else:
end = mid-1
return start | find-peak-element | Python easy to read and understand | binary search | sanial2001 | 0 | 59 | find peak element | 162 | 0.462 | Medium | 2,580 |
https://leetcode.com/problems/find-peak-element/discuss/1593230/Python-Binary-Search | class Solution:
def findPeakElement(self, nums: List[int]) -> int:
l, r = 0, len(nums)-1
while l <= r:
mid = (l+r)//2
midVal = nums[mid]
if mid+1 == len(nums):
return mid
if midVal > nums[mid+1] and midVal> nums[mid-1]:
return mid
elif midVal > nums[mid+1] and midVal < nums[mid-1]:
r = mid -1
else:
l = mid + 1
return -1 | find-peak-element | Python Binary Search | flora_1888 | 0 | 168 | find peak element | 162 | 0.462 | Medium | 2,581 |
https://leetcode.com/problems/find-peak-element/discuss/929554/Python3-Faster-than-90-Solutions-and-100-Memory-less | class Solution:
def findPeakElement(self, nums: List[int]) -> int:
if len(nums) == 1:
return 0
if len(nums) == 2:
if nums[0] > nums[1]:
return 0
else:
return 1
for i in range(0,len(nums)):
if i == 0 and nums[i] > nums[i+1]:
return 0
if i == len(nums)-1 and nums[i] > nums[i-1]:
return len(nums)-1
if nums[i-1] < nums[i] and nums[i] > nums[i+1]:
return i
return 0 | find-peak-element | Python3 Faster than 90% Solutions and 100% Memory less | tgoel219 | 0 | 163 | find peak element | 162 | 0.462 | Medium | 2,582 |
https://leetcode.com/problems/find-peak-element/discuss/524156/Python-3-Binary-Search.-O(logn) | class Solution:
def findPeakElement(self, nums: List[int]) -> int:
left, right = 0, len(nums)-1
while left<=right:
mid = left+(right-left)//2
if mid == len(nums)-1:
return mid
elif nums[mid]>nums[mid+1]:
right = mid-1
else:
left = mid+1
return left | find-peak-element | Python 3, Binary Search. O(logn) | timzeng | 0 | 79 | find peak element | 162 | 0.462 | Medium | 2,583 |
https://leetcode.com/problems/find-peak-element/discuss/505362/Python3-both-linear-and-logarithmic-solutions | class Solution:
def findPeakElement(self, nums: List[int]) -> int:
def binary_search(left,right):
if left==right: return left
pivot=(left+right)//2
if nums[pivot]>nums[pivot+1]: return binary_search(left,pivot)
return binary_search(pivot+1,right)
return binary_search(0,len(nums)-1)
def findPeakElement1(self, nums: List[int]) -> int:
for i in range(len(nums)-1):
if nums[i]>nums[i+1]: return i
return len(nums)-1 | find-peak-element | Python3 both linear and logarithmic solutions | jb07 | 0 | 75 | find peak element | 162 | 0.462 | Medium | 2,584 |
https://leetcode.com/problems/find-peak-element/discuss/405681/One-liner-using-Python-STL | class Solution:
def findPeakElement(self, nums: List[int]) -> int:
return nums.index(max(nums)) | find-peak-element | One liner using Python STL | saffi | 0 | 138 | find peak element | 162 | 0.462 | Medium | 2,585 |
https://leetcode.com/problems/find-peak-element/discuss/1727578/Python-99.9-Less-Memory-45-Faster | class Solution:
def findPeakElement(self, nums: List[int]) -> int:
#sort the list, take the last value, find that via index in the original nums list
return(nums.index((sorted(nums)[-1::])[0])) | find-peak-element | Python 99.9% Less Memory, 45% Faster | ovidaure | -1 | 149 | find peak element | 162 | 0.462 | Medium | 2,586 |
https://leetcode.com/problems/find-peak-element/discuss/1610689/Short-and-readable-binary-search-for-Py3 | class Solution:
def findPeakElement(self, nums: List[int]) -> int:
l,r = 0, len(nums)-1
while l<r:
mid = l +(r-l)//2
if nums[mid]< nums[mid+1]:
l = mid+1
else:
r = mid
return l | find-peak-element | Short and readable binary search for Py3 | ys258 | -2 | 124 | find peak element | 162 | 0.462 | Medium | 2,587 |
https://leetcode.com/problems/find-peak-element/discuss/1334815/One-line-solution-or-python | class Solution:
def findPeakElement(self, nums: List[int]) -> int:
return nums.index(max(nums)) | find-peak-element | One line solution | python | maitysourab | -2 | 61 | find peak element | 162 | 0.462 | Medium | 2,588 |
https://leetcode.com/problems/maximum-gap/discuss/727709/Python3-group-data-into-buckets | class Solution:
def maximumGap(self, nums: List[int]) -> int:
if len(nums) == 0: return 0 #edge case
mn, mx = min(nums), max(nums)
step = max(1, (mx - mn)//(len(nums)-1)) #n-1 holes
size = (mx - mn)//step + 1
buckets = [[inf, -inf] for _ in range(size)]
for num in nums:
i = (num - mn)//step
x, xx = buckets[i]
buckets[i] = min(x, num), max(xx, num)
ans = 0
prev = mn
for i in range(size):
x, xx = buckets[i]
if x < inf:
ans = max(ans, x - prev)
prev = xx
return ans | maximum-gap | [Python3] group data into buckets | ye15 | 6 | 291 | maximum gap | 164 | 0.428 | Hard | 2,589 |
https://leetcode.com/problems/maximum-gap/discuss/499481/Python3-super-simple-nlog(n)-solution | class Solution:
def maximumGap(self, nums: List[int]) -> int:
if len(nums)==1: return 0
nums.sort()
max_diff=0
for i in range(len(nums)-1):
max_diff=max(max_diff,nums[i+1]-nums[i])
return max_diff | maximum-gap | Python3 super simple nlog(n) solution | jb07 | 3 | 131 | maximum gap | 164 | 0.428 | Hard | 2,590 |
https://leetcode.com/problems/maximum-gap/discuss/2735237/PythonororO(NlogN)ororRuntime-1123-ms-Beats-91.69-Memory-28.2-MB-Beats-42.79 | class Solution:
def maximumGap(self, nums: List[int]) -> int:
nums.sort()
n=len(nums)
m=0
for i in range(n-1):
m=max(m,abs(nums[i]-nums[i+1]))
return m | maximum-gap | Python||O(NlogN)||Runtime 1123 ms Beats 91.69% Memory 28.2 MB Beats 42.79% | Sneh713 | 1 | 143 | maximum gap | 164 | 0.428 | Hard | 2,591 |
https://leetcode.com/problems/maximum-gap/discuss/1967826/python-3-oror-bucket-sort | class Solution:
def maximumGap(self, nums: List[int]) -> int:
if len(nums) < 2:
return 0
maxNum = max(nums)
digit = 1
base = 16
while maxNum >= digit:
buckets = [[] for _ in range(base)]
for num in nums:
buckets[num // digit % base].append(num)
nums = []
for bucket in buckets:
nums.extend(bucket)
digit *= base
return max(nums[i] - nums[i - 1] for i in range(1, len(nums))) | maximum-gap | python 3 || bucket sort | dereky4 | 1 | 173 | maximum gap | 164 | 0.428 | Hard | 2,592 |
https://leetcode.com/problems/maximum-gap/discuss/1352305/Python-Bucket-Sort-Solution-(-Not-comparison-based-soritng) | class Solution:
def BucketSort(self,arr,n):
max_ele=max(arr)
size=max_ele/n
bucketList=[[] for i in range(n)]
for i in range(n):
j=int(arr[i]/size)
if j==n:bucketList[j-1].append(arr[i])
else:bucketList[j].append(arr[i])
for i in bucketList:
if i:i.sort()
k=0
for lst in bucketList:
if lst:
for i in lst:
arr[k]=i
k+=1
def maximumGap(self, nums: List[int]) -> int:
n=len(nums)
if n<2:return 0
self.BucketSort(nums,n)
ans=0
for i in range(n-1):
x=nums[i+1]-nums[i]
if x>ans:ans=x
return ans | maximum-gap | Python Bucket Sort Solution ( Not comparison based soritng) | reaper_27 | 1 | 201 | maximum gap | 164 | 0.428 | Hard | 2,593 |
https://leetcode.com/problems/maximum-gap/discuss/1240367/Maximum-Gap-oror-Python-oror-Easy-to-understand-code | class Solution:
def maximumGap(self, nums: List[int]) -> int:
n=len(nums)
if n<2:
return 0
diff=0
nums.sort()
for i in range(1,n):
diff=max(diff,abs(nums[i]-nums[i-1]))
return diff | maximum-gap | Maximum Gap || Python || Easy to understand code | jaipoo | 1 | 224 | maximum gap | 164 | 0.428 | Hard | 2,594 |
https://leetcode.com/problems/maximum-gap/discuss/2823056/Maximum-Gap | class Solution:
def maximumGap(self, nums: List[int]) -> int:
n = len(nums)
if (n < 2):
return 0
maxm = float('-inf')
minm = float('inf')
i = 0
j = n-1
while (i <= j):
maxm = max(maxm, nums[i], nums[j])
minm = min(minm, nums[i], nums[j])
i += 1
j -= 1
if (maxm == minm):
return 0
gap = (maxm - minm)//(n-1)
if ((maxm - minm)%(n-1) != 0):
gap += 1
maxArr = [float('-inf')]*n
minArr = [float('inf')]*n
for i in range(n):
bkt = (nums[i] - minm)//gap
maxArr[bkt] = max(maxArr[bkt], nums[i])
minArr[bkt] = min(minArr[bkt], nums[i])
ans = float('-inf')
prev = float('-inf')
for i in range(n):
if (maxArr[i] == float('-inf')):
continue
if (prev == float('-inf')):
prev = maxArr[i]
else:
ans = max(ans, minArr[i]-prev)
prev = maxArr[i]
return ans | maximum-gap | Maximum Gap | CodeReactor8bits | 0 | 2 | maximum gap | 164 | 0.428 | Hard | 2,595 |
https://leetcode.com/problems/maximum-gap/discuss/2685584/Python-3-Brute-Force | class Solution:
def maximumGap(self, nums: List[int]) -> int:
if len(nums) < 2:
return 0
nums.sort()
res = 0
for i in range(len(nums)-1):
res = max(nums[i+1]-nums[i], res)
return res | maximum-gap | Python 3 [Brute Force] | faraaz_usmani | 0 | 6 | maximum gap | 164 | 0.428 | Hard | 2,596 |
https://leetcode.com/problems/maximum-gap/discuss/2661906/Simple-python-code-with-explanation | class Solution:
def maximumGap(self, nums):
#if the length of the list(nums) is 1
if len(nums) == 1:
#then return 0
return 0
#create a empty list(a)
a = []
#sort the elements in list(nums)
nums = sorted(nums)
#iterate over the elements in the list(nums) upto last but one
for i in range(len(nums)-1):
#add the difference of (next index and curr index) values to list(a)
a.append(nums[i+1] - nums[i])
#return the maximum of list(a)
return max(a) | maximum-gap | Simple python code with explanation | thomanani | 0 | 17 | maximum gap | 164 | 0.428 | Hard | 2,597 |
https://leetcode.com/problems/maximum-gap/discuss/2661906/Simple-python-code-with-explanation | class Solution:
def maximumGap(self, nums):
#if length of list(nums) is 1
if len(nums) == 1:
#then return 0
return 0
#sort the elements in the list(nums) upto last but one
nums = sorted(nums)
#iterate over the elements in list(nums)
for i in range(len(nums)-1):
#change the curr element as difference of (next element and curr element)
nums[i] = nums[i+1]-nums[i]
#change the last element to 0
nums[-1] = 0
#return the maximum of list(nums)
return max(nums) | maximum-gap | Simple python code with explanation | thomanani | 0 | 17 | maximum gap | 164 | 0.428 | Hard | 2,598 |
https://leetcode.com/problems/maximum-gap/discuss/2592606/Simple-solution-using-python | class Solution:
def maximumGap(self, nums: List[int]) -> int:
if len(nums)==1: return 0
mx = 0
nums = sorted(nums)
for i in range(1,len(nums)):
if(nums[i]-nums[i-1]>mx):
mx = nums[i] - nums[i-1]
return mx | maximum-gap | Simple solution using python | abdulrazak01 | 0 | 50 | maximum gap | 164 | 0.428 | Hard | 2,599 |
Subsets and Splits