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/valid-perfect-square/discuss/2092461/Python-or-O(logn)-solution
|
class Solution:
def isPerfectSquare(self, num: int) -> bool:
if num == 1:
return True
start = 0
end = num
while start <= end:
mid = (start + end) // 2
if mid*mid == num:
return True
if mid*mid < num:
start = mid + 1
else:
end = mid - 1
return False
|
valid-perfect-square
|
Python | O(logn) solution
|
rahulsh31
| 0 | 64 |
valid perfect square
| 367 | 0.433 |
Easy
| 6,300 |
https://leetcode.com/problems/valid-perfect-square/discuss/2057210/Python-3-or-Really-Simple-Solution
|
class Solution:
def isPerfectSquare(self, num: int) -> bool:
root = math.sqrt(num)
if root % 1 == 0:
return True
else:
return False
|
valid-perfect-square
|
Python 3 | Really Simple Solution
|
quiseo
| 0 | 55 |
valid perfect square
| 367 | 0.433 |
Easy
| 6,301 |
https://leetcode.com/problems/valid-perfect-square/discuss/2045562/The-simplest-way
|
class Solution(object):
def isPerfectSquare(self, num):
"""
:type num: int
:rtype: bool
"""
if num**(0.5)%1 == 0:
return True
else:
return False
|
valid-perfect-square
|
The simplest way
|
shubhsach16
| 0 | 32 |
valid perfect square
| 367 | 0.433 |
Easy
| 6,302 |
https://leetcode.com/problems/valid-perfect-square/discuss/2032396/Binary-Search-in-python3-without-functions
|
class Solution:
def isPerfectSquare(self, num: int) -> bool:
if num == 1 or num == 0:
return True
low , high = 0, num
mid = 0
while low +1 < high:
mid = (low + high ) // 2
if (mid*mid) > num: high = mid
elif (mid*mid) < num: low = mid
else: return True
return False
|
valid-perfect-square
|
Binary Search in python3 without functions
|
Yodawgz0
| 0 | 36 |
valid perfect square
| 367 | 0.433 |
Easy
| 6,303 |
https://leetcode.com/problems/valid-perfect-square/discuss/1964202/Python-oror-Clean-and-Simple-Binary-Search
|
class Solution:
def isPerfectSquare(self, num: int) -> bool:
start, end = 0 , num
while start <= end:
mid = (start+end)//2
if mid*mid == num: return True
elif mid*mid < num:
start = mid + 1
else: end = mid-1
return False
|
valid-perfect-square
|
Python || Clean and Simple Binary Search
|
morpheusdurden
| 0 | 50 |
valid perfect square
| 367 | 0.433 |
Easy
| 6,304 |
https://leetcode.com/problems/valid-perfect-square/discuss/1945496/java-python3-binary-search-(Time-O1-space-O1)
|
class Solution:
def isPerfectSquare(self, num: int) -> bool:
l = 0
r = 2**31 - 1
while l <= r :
m = (l + r) // 2
n = m * m
if n == num : return True
if n > num : r = m - 1
else : l = m + 1
return False
|
valid-perfect-square
|
java, python3 - binary search (Time O1, space O1)
|
ZX007java
| 0 | 44 |
valid perfect square
| 367 | 0.433 |
Easy
| 6,305 |
https://leetcode.com/problems/valid-perfect-square/discuss/1920518/simple-python-solution
|
class Solution:
def isPerfectSquare(self, num: int) -> bool:
return pow(num,0.5).is_integer()
|
valid-perfect-square
|
simple python solution
|
jaymishpatel
| 0 | 47 |
valid perfect square
| 367 | 0.433 |
Easy
| 6,306 |
https://leetcode.com/problems/valid-perfect-square/discuss/1907801/Python-easy-to-understand-code
|
class Solution:
def isPerfectSquare(self, num: int) -> bool:
num = num**0.5
if num - int(num) == 0:
return True
else:
return False
|
valid-perfect-square
|
Python easy to understand code
|
aashnachib17
| 0 | 53 |
valid perfect square
| 367 | 0.433 |
Easy
| 6,307 |
https://leetcode.com/problems/valid-perfect-square/discuss/1675020/Python-solution-using-Binary-Search
|
class Solution:
def isPerfectSquare(self, num: int) -> bool:
s = 1
l = num
ans = 0
while s <= l:
mid = s + (l - s) // 2
square = mid * mid
if (square > num):
l = mid - 1
else:
ans = mid
s = mid + 1
if ans * ans == num:
return True
else:
return False
|
valid-perfect-square
|
Python solution using Binary Search
|
Joe-Felix
| 0 | 103 |
valid perfect square
| 367 | 0.433 |
Easy
| 6,308 |
https://leetcode.com/problems/valid-perfect-square/discuss/1588909/Python-quick-solution-without-using-sqrt
|
class Solution:
def isPerfectSquare(self, num):
return str(num**(1/2))[-1] == "0"
|
valid-perfect-square
|
Python quick solution without using sqrt
|
Novand2121
| 0 | 91 |
valid perfect square
| 367 | 0.433 |
Easy
| 6,309 |
https://leetcode.com/problems/valid-perfect-square/discuss/1585209/Python-Easy-Solution-or-Faster-than-98
|
class Solution:
def isPerfectSquare(self, num: int) -> bool:
start = 0
end = num
while start <= end:
mid = start+(end-start)//2
if mid*mid == num:
root = mid
break
if mid*mid > num:
end = mid-1
else:
start = mid+1
root = mid
if root*root == num:
return True
return False
|
valid-perfect-square
|
Python Easy Solution | Faster than 98%
|
leet_satyam
| 0 | 109 |
valid perfect square
| 367 | 0.433 |
Easy
| 6,310 |
https://leetcode.com/problems/valid-perfect-square/discuss/1568547/max-runtime-993-real-working-code-O-log(n)
|
class Solution:
def isPerfectSquare(self, num: int) -> bool:
le = 1
ri = 46341
while le <= ri:
mid = (le + ri) // 2
if mid * mid == num:
return mid
if mid * mid < num:
le = mid + 1
else:
ri = mid - 1
|
valid-perfect-square
|
max runtime 99,3% real working code O = log(n)
|
petros000
| 0 | 55 |
valid perfect square
| 367 | 0.433 |
Easy
| 6,311 |
https://leetcode.com/problems/valid-perfect-square/discuss/1526548/Python-Three-Solutions-Brute-Force-greater-AC
|
class Solution:
def isPerfectSquare(self, num: int) -> bool:
num = str(num ** 0.5)
trail = num[len(num)-2:]
return trail == ".0"
|
valid-perfect-square
|
[Python] Three Solutions, Brute Force --> AC
|
dev-josh
| 0 | 50 |
valid perfect square
| 367 | 0.433 |
Easy
| 6,312 |
https://leetcode.com/problems/valid-perfect-square/discuss/1526548/Python-Three-Solutions-Brute-Force-greater-AC
|
class Solution:
def isPerfectSquare(self, num: int) -> bool:
for i in range(num+1):
if i*i == num:
return True
return False
|
valid-perfect-square
|
[Python] Three Solutions, Brute Force --> AC
|
dev-josh
| 0 | 50 |
valid perfect square
| 367 | 0.433 |
Easy
| 6,313 |
https://leetcode.com/problems/valid-perfect-square/discuss/1526548/Python-Three-Solutions-Brute-Force-greater-AC
|
class Solution:
def isPerfectSquare(self, num: int) -> bool:
lo, hi = 1, num+1
while lo < hi:
mid = (lo+hi) // 2
guess = mid*mid
if guess == num:
return True
elif guess < num:
lo = mid+1
elif guess > num:
hi = mid
return False
|
valid-perfect-square
|
[Python] Three Solutions, Brute Force --> AC
|
dev-josh
| 0 | 50 |
valid perfect square
| 367 | 0.433 |
Easy
| 6,314 |
https://leetcode.com/problems/valid-perfect-square/discuss/1250531/Python3-simple-solution-%22one-liner%22
|
class Solution:
def isPerfectSquare(self, num: int) -> bool:
return num**.5%1 == 0
|
valid-perfect-square
|
Python3 simple solution "one-liner"
|
EklavyaJoshi
| 0 | 44 |
valid perfect square
| 367 | 0.433 |
Easy
| 6,315 |
https://leetcode.com/problems/largest-divisible-subset/discuss/1127633/Python-Dynamic-Programming-with-comments
|
class Solution:
def largestDivisibleSubset(self, nums: List[int]) -> List[int]:
if not nums or len(nums) == 0:
return []
# since we are doing a "subset" question
# sorting does not make any differences
nums.sort()
n = len(nums)
# initilization
# f[i] represents the size of LDS ended with nums[i]
f = [1 for _ in range(n)]
for i in range(1, n):
for j in range(i):
# since we have already sorted,
# then nums[j] % nums[i] will never equals zero
# unless nums[i] == nums[j]
if nums[i] % nums[j] == 0:
f[i] = max(f[i], f[j] + 1)
# extract result from dp array
max_size = max(f)
max_idx = f.index(max_size) # since we can return one of the largest
prev_num, prev_size = nums[max_idx], f[max_idx]
res = [prev_num]
for curr_idx in range(max_idx, -1, -1):
if prev_num % nums[curr_idx] == 0 and f[curr_idx] == prev_size - 1:
# update
res.append(nums[curr_idx])
prev_num = nums[curr_idx]
prev_size = f[curr_idx]
return res[::-1]
|
largest-divisible-subset
|
Python Dynamic Programming with comments
|
zna2
| 3 | 227 |
largest divisible subset
| 368 | 0.413 |
Medium
| 6,316 |
https://leetcode.com/problems/largest-divisible-subset/discuss/2811050/Python-(Simple-Dynamic-Programming)
|
class Solution:
def largestDivisibleSubset(self, nums):
nums.sort()
n = len(nums)
dp = [[nums[i]] for i in range(n)]
for i in range(n):
for j in range(i):
if nums[i]%nums[j] == 0 and len(dp[j]) + 1 > len(dp[i]):
dp[i] = dp[j] + [nums[i]]
return max(dp, key = len)
|
largest-divisible-subset
|
Python (Simple Dynamic Programming)
|
rnotappl
| 0 | 6 |
largest divisible subset
| 368 | 0.413 |
Medium
| 6,317 |
https://leetcode.com/problems/largest-divisible-subset/discuss/2647795/Python3-solution-with-comments-(similar-to-300.-Longest-Increasing-Subsequence)
|
class Solution:
def lengthOfLIS(self, nums: List[int]) -> int:
# tuition: dp[i] represents the length of the longest strictly increasing subsequence ending with nums[i]. recursive formula: dp[i]=max(dp[j]+1, dp[i]) with 0 < j < i. This takes O(n^2) time.
n = len(nums)
if n <= 1: return n
dp = [1 for _ in range(n)]
for i in range(n):
for j in range(i):
if nums[j] < nums[i]: # strictly increasing
dp[i] = max(dp[i], dp[j] + 1)
return max(dp)
|
largest-divisible-subset
|
Python3 solution with comments (similar to #300. Longest Increasing Subsequence)
|
cutesunny
| 0 | 1 |
largest divisible subset
| 368 | 0.413 |
Medium
| 6,318 |
https://leetcode.com/problems/largest-divisible-subset/discuss/2647795/Python3-solution-with-comments-(similar-to-300.-Longest-Increasing-Subsequence)
|
class Solution:
def largestDivisibleSubset(self, nums: List[int]) -> List[int]:
# O(n^2) time
nums.sort() # so that divisors appear ahead of each number
n = len(nums)
if n == 0: return []
dp = [[num] for num in nums] # dp[i] represents the valid solution including nums[i]
for i in range(n):
for j in range(i):
if nums[i] % nums[j] == 0 and len(dp[i]) < len(dp[j]) + 1: # find better solution, update
dp[i] = dp[j] + [nums[i]]
return max(dp, key = len) # customer sort based on length
|
largest-divisible-subset
|
Python3 solution with comments (similar to #300. Longest Increasing Subsequence)
|
cutesunny
| 0 | 1 |
largest divisible subset
| 368 | 0.413 |
Medium
| 6,319 |
https://leetcode.com/problems/largest-divisible-subset/discuss/2322104/Python3-Solution-with-using-dp
|
class Solution:
def largestDivisibleSubset(self, nums: List[int]) -> List[int]:
if len(nums) == 0:
return []
nums.sort()
dp = [[num] for num in nums]
for i in range(len(nums)):
for j in range(i):
if nums[i] % nums[j] == 0 and len(dp[j]) >= len(dp[i]):
dp[i] = dp[j] + [nums[i]]
max_len = 0
res = []
for subset in dp:
if len(subset) > max_len:
max_len = len(subset)
res = subset
return res
|
largest-divisible-subset
|
[Python3] Solution with using dp
|
maosipov11
| 0 | 40 |
largest divisible subset
| 368 | 0.413 |
Medium
| 6,320 |
https://leetcode.com/problems/largest-divisible-subset/discuss/2146559/Python-3-or-DP-or-Easy-Understand
|
class Solution:
def largestDivisibleSubset(self, nums: List[int]) -> List[int]:
nums.sort()
dp = [[i] for i in nums]
for i in range(1, len(nums)):
for j in range(i):
if nums[i] % nums[j] == 0:
if len(dp[j]) + 1 > len(dp[i]):
dp[i] = [nums[i]] + dp[j]
else:
pass
else:
continue
max_len = 1
for lst in dp:
max_len = max(max_len, len(lst))
for lst in dp:
if max_len == len(lst):
return lst
|
largest-divisible-subset
|
Python 3 | DP | Easy Understand
|
itachieve
| 0 | 23 |
largest divisible subset
| 368 | 0.413 |
Medium
| 6,321 |
https://leetcode.com/problems/largest-divisible-subset/discuss/1122066/Python-DP-Solution
|
class Solution:
def largestDivisibleSubset(self, nums: List[int]) -> List[int]:
nums.sort()
t = [1 for _ in range(len(nums))]
for i in range(1,len(t)):
for j in range(i):
if nums[i]%nums[j]==0:
t[i] = max(t[i],1+t[j])
maxi = float('-inf')
for i in range(len(t)):
if maxi<t[i]:
maxi=t[i]
ind = i
subset = [nums[ind]]
max_ = maxi-1
prev = subset[0]
for i in range(len(t)-1,-1,-1):
if t[i]==max_ and prev%nums[i]==0:
subset.append(nums[i])
prev = nums[i]
max_-=1
return subset
|
largest-divisible-subset
|
Python DP Solution
|
bharatgg
| 0 | 106 |
largest divisible subset
| 368 | 0.413 |
Medium
| 6,322 |
https://leetcode.com/problems/largest-divisible-subset/discuss/685654/Python3-6-line
|
class Solution:
def largestDivisibleSubset(self, nums: List[int]) -> List[int]:
nums.sort()
dp = []
for i, x in enumerate(nums):
dp.append([x])
for ii in range(i):
if x % nums[ii] == 0:
dp[-1] = max(dp[-1], dp[ii] + [x], key=len)
return max(dp, key=len)
|
largest-divisible-subset
|
[Python3] 6-line
|
ye15
| 0 | 60 |
largest divisible subset
| 368 | 0.413 |
Medium
| 6,323 |
https://leetcode.com/problems/sum-of-two-integers/discuss/1876632/Python-one-line-solution-using-the-logic-of-logs-and-powers
|
class Solution:
def getSum(self, a: int, b: int) -> int:
return int(math.log2(2**a * 2**b))
|
sum-of-two-integers
|
Python one line solution using the logic of logs and powers
|
alishak1999
| 7 | 596 |
sum of two integers
| 371 | 0.507 |
Medium
| 6,324 |
https://leetcode.com/problems/sum-of-two-integers/discuss/1413403/Not-weeb-does-python
|
class Solution:
def getSum(self, a: int, b: int) -> int:
return int(log2(2**a * 2**b))
|
sum-of-two-integers
|
Not weeb does python
|
blackcoffee
| 5 | 336 |
sum of two integers
| 371 | 0.507 |
Medium
| 6,325 |
https://leetcode.com/problems/sum-of-two-integers/discuss/1680696/Python3-or-Bit-manipulation-solution-handling-subtracts-and-adds
|
class Solution:
def getSum(self, a: int, b: int) -> int:
self.level = -1
self.sum = 0
self.neg = False
self.subtract = False
def doSum(m, n):
if not m and not n:
return self.sum
elif not m and n:
return n
elif not n and m:
if m == 1:
self.level += 1
self.sum += 1*2**self.level
return self.sum
else:
return m
elif self.subtract:
carry = (m%2) ^ (n%2)
self.level += 1
self.sum += carry*2**self.level
if not m%2 and n%2:
m = (m-1)>>1
else:
m >>= 1
return doSum(m, n>>1)
else:
return doSum(m^n, (m&n)<<1)
if a < 0 and b < 0:
a, b = -a, -b
self.neg = True
if a*b < 0:
self.subtract = True
if abs(a) == abs(b):
return 0
elif abs(a) > abs(b):
if a < b:
a, b = -a, b
self.neg = True
else:
if a < b:
a, b = b, -a
else:
a, b = -b, a
self.neg = True
self.sum = doSum(a, b)
return -self.sum if self.neg else self.sum
|
sum-of-two-integers
|
Python3 | Bit manipulation solution handling subtracts and adds
|
elainefaith0314
| 3 | 868 |
sum of two integers
| 371 | 0.507 |
Medium
| 6,326 |
https://leetcode.com/problems/sum-of-two-integers/discuss/810086/Python3-bit-xorand
|
class Solution:
def getSum(self, a: int, b: int) -> int:
mask = 0xffffffff
while b & mask:
a, b = a^b, (a&b) << 1
return a & mask if b > mask else a
|
sum-of-two-integers
|
[Python3] bit xor/and
|
ye15
| 3 | 558 |
sum of two integers
| 371 | 0.507 |
Medium
| 6,327 |
https://leetcode.com/problems/sum-of-two-integers/discuss/2699859/PYTHON-oror-EASY-TO-READ
|
class Solution:
def getSum(self, a: int, b: int) -> int:
return eval(f'{a}{chr(43)}{b}')
|
sum-of-two-integers
|
✅ 🔥 🎉 PYTHON || EASY TO READ 🎉 🔥✅
|
neet_n_niftee
| 2 | 748 |
sum of two integers
| 371 | 0.507 |
Medium
| 6,328 |
https://leetcode.com/problems/sum-of-two-integers/discuss/2835718/SIMPLE-SOLUTION-USING-LISToror-3-LINESoror-EASY
|
class Solution:
def getSum(self, a: int, b: int) -> int:
l=[]
l.append(a)
l.append(b)
return sum(l)
|
sum-of-two-integers
|
SIMPLE SOLUTION USING LIST|| 3 LINES|| EASY
|
thezealott
| 1 | 42 |
sum of two integers
| 371 | 0.507 |
Medium
| 6,329 |
https://leetcode.com/problems/sum-of-two-integers/discuss/656176/python3-beats-98
|
class Solution:
def getSum(self, a: int, b: int) -> int:
MAX_INT = 0x7FFFFFFF
MIN_INT = 0x80000000
MASK = 0x100000000
while b:
carry = (a & b)
a = (a ^ b) % MASK
b = (carry << 1) % MASK
if(a <= MAX_INT):
return a
else:
return ~((a % MIN_INT) ^ MAX_INT)
|
sum-of-two-integers
|
python3 beats 98%
|
hunnain_a
| 1 | 505 |
sum of two integers
| 371 | 0.507 |
Medium
| 6,330 |
https://leetcode.com/problems/sum-of-two-integers/discuss/2839117/Python3-1-liner-without-%2B-
|
class Solution:
def getSum(self, a: int, b: int) -> int:
return sum([a, b])
|
sum-of-two-integers
|
Python3 - 1 liner without +/-
|
mediocre-coder
| 0 | 7 |
sum of two integers
| 371 | 0.507 |
Medium
| 6,331 |
https://leetcode.com/problems/sum-of-two-integers/discuss/2834651/Crude-solution
|
class Solution:
def sameNegative(self, a: int, b: int) -> bool:
if ( b < 0 ) and (a < 0):
return True
else:
return False
def getSum(self, a: int, b: int) -> int:
start = 1
if (self.sameNegative(a, b)):
max_range=abs(b)
max_range+=1
a= abs(a)
for i in range(start, max_range):
# use a as an anchor
a+=1
a=-abs(a)
elif(a>0) and (b < 0):
max_range=abs(b)
max_range+=1
for i in range(start, max_range):
# use a as an anchor
a-=1
elif(a<0) and (b > 0):
max_range=abs(b)
max_range+=1
for i in range(start, max_range):
# use a as an anchor
a+=1
elif(b==0):
return a
elif(a==0):
return b
else:
max_range=abs(b)
max_range+=1
a= abs(a)
for i in range(start, max_range):
print("In here!")
# use a as an anchor
a+=1
return a
|
sum-of-two-integers
|
Crude solution
|
malfyore
| 0 | 2 |
sum of two integers
| 371 | 0.507 |
Medium
| 6,332 |
https://leetcode.com/problems/sum-of-two-integers/discuss/2833879/For-Begginers
|
class Solution:
def getSum(self, a: int, b: int) -> int:
return eval("a"+str(chr(43))+"b")
|
sum-of-two-integers
|
For Begginers
|
19121A04N7
| 0 | 3 |
sum of two integers
| 371 | 0.507 |
Medium
| 6,333 |
https://leetcode.com/problems/sum-of-two-integers/discuss/2830158/Python3-One-Liner-using-a-recursive-Bitshifting-Logic
|
class Solution:
def getSum(self, a: int, b: int) -> int:
return a if b == 0 else self.getSum(a^b, (a&b)<<1)
|
sum-of-two-integers
|
Python3 One Liner, using a recursive Bitshifting Logic
|
Aleph-Null
| 0 | 8 |
sum of two integers
| 371 | 0.507 |
Medium
| 6,334 |
https://leetcode.com/problems/sum-of-two-integers/discuss/2804781/Python-or-O(n)-or-Easy-to-understand-Code
|
class Solution:
def getSum(self, a: int, b: int) -> int:
if a >= 0 and b >= 0:
for i in range(b):
a += 1
return a
elif a < 0 and b >= 0:
for i in range(b):
a += 1
return a
elif a >= 0 and b <= 0:
for i in range(-b):
a -= 1
return a
elif a <= 0 and b <= 0:
for i in range(-b):
a -= 1
return a
|
sum-of-two-integers
|
Python | O(n) | Easy to understand Code
|
bhuvneshwar906
| 0 | 5 |
sum of two integers
| 371 | 0.507 |
Medium
| 6,335 |
https://leetcode.com/problems/sum-of-two-integers/discuss/2779414/python-very-easy-solution
|
class Solution:
def getSum(self, a: int, b: int) -> int:
return sum([a,b])
|
sum-of-two-integers
|
python very easy solution
|
seifsoliman
| 0 | 20 |
sum of two integers
| 371 | 0.507 |
Medium
| 6,336 |
https://leetcode.com/problems/sum-of-two-integers/discuss/2596892/Python-Solution-or-Beats-99-or-Trick-or-Bit-Manipulation
|
class Solution:
def getSum(self, a: int, b: int) -> int:
# Bit Manipulation: TLE (eg. -1, 1)
# while b:
# carry=(a&b)<<1 # to carry it forward
# a=a^b # it acts a sum
# b=carry
# return a
# Way around ;)
return sum([a,b])
|
sum-of-two-integers
|
Python Solution | Beats 99% | Trick | Bit-Manipulation
|
Siddharth_singh
| 0 | 274 |
sum of two integers
| 371 | 0.507 |
Medium
| 6,337 |
https://leetcode.com/problems/sum-of-two-integers/discuss/1665375/Python-recursive-solution-for-positive-numbers-only
|
class Solution:
def getSum(self, a: int, b: int) -> int:
s, carry = a ^ b, a & b
return s if not carry else self.getSum(s, carry << 1)
|
sum-of-two-integers
|
Python, recursive solution for positive numbers only
|
blue_sky5
| 0 | 146 |
sum of two integers
| 371 | 0.507 |
Medium
| 6,338 |
https://leetcode.com/problems/sum-of-two-integers/discuss/1615895/Python-3-Not-Using-Mask
|
class Solution:
def getSum(self, a: int, b: int) -> int:
plist = []
nlist = []
def run_a():
if a > 0:
for i in range(a):
plist.append(0)
else:
for i in range(abs(a)):
nlist.append(0)
def run_b():
if b > 0:
for i in range(b):
plist.append(0)
else:
for i in range(abs(b)):
nlist.append(0)
run_a()
run_b()
if len(nlist) == len(plist):
return 0
if len(nlist) == 0 or len(plist)== 0:
if len(nlist) == 0:
return len(plist)
else:
nlist.append(a)
nlist.append(b)
return sum(nlist)
if len(nlist) < len(plist):
for n in nlist:
plist.pop()
return len(plist)
if len(nlist) > len(plist):
for n in plist:
nlist.pop()
return len(nlist)
|
sum-of-two-integers
|
Python 3 - Not Using Mask
|
hudsonh
| 0 | 998 |
sum of two integers
| 371 | 0.507 |
Medium
| 6,339 |
https://leetcode.com/problems/sum-of-two-integers/discuss/627502/Intuitive-approach-by-rule-based
|
class Solution:
def getSum(self, a: int, b: int) -> int:
def bin2int(bin_list):
result = 0
for i, v in enumerate(bin_list):
result += pow(2, i) * v
return result
if a == 0 or b == 0:
return a if b == 0 else b
elif (a > 0 and b > 0) or (a < 0 and b < 0):
a_bin = list(map(lambda e: int(e), "{:032b}".format(abs(a))[::-1]))
b_bin = list(map(lambda e: int(e), "{:032b}".format(abs(b))[::-1]))
cb = 0
r_bin = []
for av, bv in zip(a_bin, b_bin):
if av == 0 and bv == 0:
r_bin.append(cb)
cb = 0
elif (av == 0 and bv == 1) or (av == 1 and bv == 0):
if cb:
r_bin.append(0)
else:
r_bin.append(1)
else:
if cb:
r_bin.append(1)
else:
r_bin.append(0)
cb = 1
result = bin2int(r_bin)
return result if a > 0 else -1 * result
else:
is_negative = False
if a > 0:
if a < abs(b):
is_negative = True
a, b = abs(b), a
else:
a, b = a, abs(b)
else:
if b < abs(a):
is_negative = True
a, b = abs(a), b
else:
a, b = b, abs(a)
a_bin = list(map(lambda e: int(e), "{:032b}".format(a)[::-1]))
b_bin = list(map(lambda e: int(e), "{:032b}".format(b)[::-1]))
r_bin = []
for av, bv in zip(a_bin, b_bin):
if av == bv:
r_bin.append(0)
elif av == 1 and bv == 0:
r_bin.append(1)
else:
r_bin.append(-1)
for i in range(len(r_bin)):
if r_bin[i] < 0:
for j in range(i+1, len(r_bin)):
if r_bin[j] == 0:
r_bin[j] == 1
else:
r_bin[j] == 0
break
r_bin[i] == 1
result = bin2int(r_bin)
return result if not is_negative else -1 * result
|
sum-of-two-integers
|
Intuitive approach by rule based
|
puremonkey2001
| 0 | 189 |
sum of two integers
| 371 | 0.507 |
Medium
| 6,340 |
https://leetcode.com/problems/sum-of-two-integers/discuss/419864/Accepted-Answer-Python3%3A-One-Liner-return-a.__add__(b)
|
class Solution:
def getSum(self, a: int, b: int) -> int:
return a.__add__(b)
|
sum-of-two-integers
|
Accepted Answer Python3: One-Liner `return a.__add__(b)`
|
i-i
| -1 | 736 |
sum of two integers
| 371 | 0.507 |
Medium
| 6,341 |
https://leetcode.com/problems/sum-of-two-integers/discuss/1235588/Simplest-Solution-in-python
|
class Solution:
def getSum(self, a: int, b: int) -> int:
return sum([a,b])
|
sum-of-two-integers
|
Simplest Solution in python
|
dhrumilg699
| -20 | 621 |
sum of two integers
| 371 | 0.507 |
Medium
| 6,342 |
https://leetcode.com/problems/super-pow/discuss/400893/Python-3-(With-Explanation)-(Handles-All-Test-Cases)-(one-line)-(beats-~97)
|
class Solution:
def superPow(self, a: int, b: List[int]) -> int:
return (a % 1337)**(1140 + int(''.join(map(str, b))) % 1140) % 1337
- Junaid Mansuri
|
super-pow
|
Python 3 (With Explanation) (Handles All Test Cases) (one line) (beats ~97%)
|
junaidmansuri
| 11 | 1,900 |
super pow
| 372 | 0.371 |
Medium
| 6,343 |
https://leetcode.com/problems/super-pow/discuss/1420565/Python-3-or-Naive-array-operation-Euler's-theorem-(and-optimization)-or-Explanation
|
class Solution(object):
def superPow(self, a, b):
@cache
def cus_pow(a, b): # A customized pow(a, b)
if b == 0 or a == 1: return 1
if b % 2:
return a * cus_pow(a, b - 1) % 1337
return cus_pow((a * a) % 1337, b / 2) % 1337
res = 1
for x in b: # power on array
res = cus_pow(res, 10) * cus_pow(a, x) % 1337
return res
|
super-pow
|
Python 3 | Naïve array operation, Euler's theorem (and optimization) | Explanation
|
idontknoooo
| 2 | 317 |
super pow
| 372 | 0.371 |
Medium
| 6,344 |
https://leetcode.com/problems/super-pow/discuss/1420565/Python-3-or-Naive-array-operation-Euler's-theorem-(and-optimization)-or-Explanation
|
class Solution:
def superPow(self, a: int, b: List[int]) -> int:
if a % 1337 == 0:
return 0
else:
exponent = int(''.join(map(str, b)))
return pow(a, exponent % 1140 + 1140, 1337)
|
super-pow
|
Python 3 | Naïve array operation, Euler's theorem (and optimization) | Explanation
|
idontknoooo
| 2 | 317 |
super pow
| 372 | 0.371 |
Medium
| 6,345 |
https://leetcode.com/problems/super-pow/discuss/1420565/Python-3-or-Naive-array-operation-Euler's-theorem-(and-optimization)-or-Explanation
|
class Solution:
def superPow(self, a: int, b: List[int]) -> int:
if a % 1337 == 0:
return 0
else:
exponent = int(''.join(map(str, b)))
return pow(a, exponent % 1140, 1337)
|
super-pow
|
Python 3 | Naïve array operation, Euler's theorem (and optimization) | Explanation
|
idontknoooo
| 2 | 317 |
super pow
| 372 | 0.371 |
Medium
| 6,346 |
https://leetcode.com/problems/super-pow/discuss/2645771/Python-EXPLAINED-or-recursive-or-O(log(n))-or-comparison-with-Pow(x-n)
|
class Solution:
def superPow(self, a: int, b: List[int]) -> int:
b = [str(i) for i in b]
n = int("".join(b)) #converting list into integer
def pow(x, n):
if n == 0:
return 1
elif n%2==0:
res = pow(x, n>>1)%1337
return res**2
else:
res = pow(x, (n-1)>>1)%1337
return x*(res**2)
return pow(a, n)%1337
|
super-pow
|
Python [EXPLAINED] | recursive | O(log(n)) | comparison with Pow(x, n)
|
diwakar_4
| 1 | 168 |
super pow
| 372 | 0.371 |
Medium
| 6,347 |
https://leetcode.com/problems/super-pow/discuss/2645771/Python-EXPLAINED-or-recursive-or-O(log(n))-or-comparison-with-Pow(x-n)
|
class Solution:
def myPow(self, x: float, n: int) -> float:
def pow(x, n):
if n == 0:
return 1
elif n%2==0:
res = pow(x, n/2)
return res*res
else:
res = pow(x, (n-1)/2)
return x*(res**2)
if n>=0:
return pow(x, n)
else:
return 1/pow(x, abs(n))
|
super-pow
|
Python [EXPLAINED] | recursive | O(log(n)) | comparison with Pow(x, n)
|
diwakar_4
| 1 | 168 |
super pow
| 372 | 0.371 |
Medium
| 6,348 |
https://leetcode.com/problems/super-pow/discuss/1920679/Simple-Python-Solution
|
class Solution:
def calc_pow(self,x,n):
if n == 0: return 1
mid = self.calc_pow(x,n//2)
if n%2==0:
return (mid*mid)%1337
else:
return (x*mid*mid)%1337
def superPow(self, a: int, b: List[int]) -> int:
b_str = "".join([str(i) for i in b])
power = int(b_str)
return self.calc_pow(a,power)
|
super-pow
|
Simple Python Solution
|
palakmehta
| 1 | 213 |
super pow
| 372 | 0.371 |
Medium
| 6,349 |
https://leetcode.com/problems/super-pow/discuss/1709461/Python-oror-Explanation-oror-Built-in-function-oror-DP-DFS-oror-Easy-to-understand
|
class Solution:
def superPow(self, a: int, b: List[int]) -> int:
if a==1:
return 1
c=0
for i in b:
c=10*c+i
return pow(a,c,1337)
|
super-pow
|
Python || Explanation || Built-in function || ❌ DP ❌ DFS || Easy to understand
|
rushi_javiya
| 1 | 212 |
super pow
| 372 | 0.371 |
Medium
| 6,350 |
https://leetcode.com/problems/super-pow/discuss/2843437/Pythonor-fast-power
|
class Solution:
def mypaw(self, a, b):
a %= 1337
res = 1
for _ in range(b):
res *= a
res %= 1337
return res
def superPow(self, a: int, b: List[int]) -> int:
if len(b) == 0:
return 1
if a == 1:
return 1
last = b.pop()
part1 = self.mypaw(a, last)
part2 = self.mypaw(self.superPow(a,b), 10)
return (part1*part2)%1337
|
super-pow
|
Python| fast power
|
lucy_sea
| 0 | 3 |
super pow
| 372 | 0.371 |
Medium
| 6,351 |
https://leetcode.com/problems/super-pow/discuss/2834338/Recursion-and-Mod
|
class Solution:
def __init__(self):
self.base = 1337
def superPow(self, a: int, b: List[int]) -> int:
if not b: return 1
last = b.pop()
part1 = self.my_power(a, last)
part2 = self.my_power(self.superPow(a, b), 10)
return (part1 * part2) % self.base
def my_power(self, a, k):
a %= self.base
res = 1
for _ in range(k):
res *= a
res %= self.base
return res
|
super-pow
|
Recursion & Mod
|
lillllllllly
| 0 | 3 |
super pow
| 372 | 0.371 |
Medium
| 6,352 |
https://leetcode.com/problems/super-pow/discuss/2747913/Python3-Solution
|
class Solution:
def superPow(self, a: int, b: List[int]) -> int:
b = int("".join(map(str, b)))
return pow(a,b,1337)
|
super-pow
|
Python3 Solution
|
vivekrajyaguru
| 0 | 10 |
super pow
| 372 | 0.371 |
Medium
| 6,353 |
https://leetcode.com/problems/super-pow/discuss/2747577/recursion-solution
|
class Solution:
def mypow(self, n, k):
if k == 0:
return 1
base = 1337
n %= base
print(k)
if(k % 2 == 0):
sub = self.mypow(n, k//2)
return (sub * sub) % base
else:
return (n * self.mypow(n, k-1)) % base
def superPow(self, a: int, b: List[int]) -> int:
base = 1337
if not b:
return 1
last = b[-1]
b = b[:-1]
prev = self.mypow(a, last)
latter = self.mypow(self.superPow(a, b) , 10)
return (prev * latter) % base
|
super-pow
|
recursion solution
|
yhu415
| 0 | 2 |
super pow
| 372 | 0.371 |
Medium
| 6,354 |
https://leetcode.com/problems/super-pow/discuss/2652806/Easy-loop-finding-with-explanation
|
class Solution:
def superPow(self, a: int, b: List[int]) -> int:
loop = []
loopset = set()
cur = a % 1337
while cur not in loopset:
loopset.add(cur)
loop.append(cur)
cur *= a
cur %= 1337
loop_len = len(loop)
print(loop_len, loop)
p = 0
cur = 0
while p<len(b):
cur *= 10
cur += b[p]
cur %= loop_len
p+=1
return loop[cur-1]
|
super-pow
|
Easy loop finding with explanation
|
FrankYJY
| 0 | 6 |
super pow
| 372 | 0.371 |
Medium
| 6,355 |
https://leetcode.com/problems/super-pow/discuss/2635593/Python-1-Liner-easy-solution
|
class Solution:
def superPow(self, a: int, b: List[int]) -> int:
return pow(a, int(''.join([str(i) for i in b])), 1337)
|
super-pow
|
Python 1 Liner easy solution
|
code_snow
| 0 | 20 |
super pow
| 372 | 0.371 |
Medium
| 6,356 |
https://leetcode.com/problems/super-pow/discuss/2053437/Python-simple-oneliner
|
class Solution:
def superPow(self, a: int, b: List[int]) -> int:
return pow(a,int(''.join(map(str,b))),mod=1337)
|
super-pow
|
Python simple oneliner
|
StikS32
| 0 | 242 |
super pow
| 372 | 0.371 |
Medium
| 6,357 |
https://leetcode.com/problems/super-pow/discuss/1893630/Python3-pow-Solution-or-faster-than-77-or-less-than-33
|
class Solution:
def superPow(self, a: int, b: List[int]) -> int:
if a == 1:
return 1
else:
return pow(a, int("".join(map(lambda s:str(s),b))),1337)
|
super-pow
|
Python3 pow Solution | faster than 77% | less than 33%
|
khRay13
| 0 | 177 |
super pow
| 372 | 0.371 |
Medium
| 6,358 |
https://leetcode.com/problems/super-pow/discuss/1876654/Python-solution-using-strings-faster-than-66-memory-less-than-94
|
class Solution:
def superPow(self, a: int, b: List[int]) -> int:
if a == 1 or a == 0:
return 1
b_num = int(''.join([str(x) for x in b]))
return pow(a, b_num, 1337)
|
super-pow
|
Python solution using strings faster than 66%, memory less than 94%
|
alishak1999
| 0 | 145 |
super pow
| 372 | 0.371 |
Medium
| 6,359 |
https://leetcode.com/problems/super-pow/discuss/1806330/Easy-to-understand-(faster-than-43.71-of-Python3)
|
class Solution:
def modpow(self, a: int, b: int, m: int) -> int:
""" Compute a^b mod m with fast exponentiation"""
if b == 0:
return 1
r = self.modpow(a, b//2, m)
if b % 2 == 0:
return (r * r) % m
else:
return (a * r * r) % m
def superPow(self, a: int, b: List[int]) -> int:
m = 1337
r = 1 # this will contain the final result
base = a # this is the starting base
for e in b[::-1]: # note that I will traverse the list backward
r = (r * self.modpow(base, e, m)) % m
base = self.modpow(base, 10, m) # updating base
if base == 1: # this trick will save computation: if you find a base==1 no need to compute more
return r
return r
|
super-pow
|
Easy to understand (faster than 43.71% of Python3)
|
pierluigif
| 0 | 175 |
super pow
| 372 | 0.371 |
Medium
| 6,360 |
https://leetcode.com/problems/super-pow/discuss/813810/Python3-leveraging-on-pow()
|
class Solution:
def superPow(self, a: int, b: List[int]) -> int:
ans = 1
for bb in b:
ans = pow(ans, 10, 1337) * pow(a, bb, 1337)
return ans % 1337
|
super-pow
|
[Python3] leveraging on pow()
|
ye15
| 0 | 290 |
super pow
| 372 | 0.371 |
Medium
| 6,361 |
https://leetcode.com/problems/super-pow/discuss/1214436/using-modular-expansion
|
class Solution:
def superPow(self, a: int, b: List[int]) -> int:
b=int(''.join(map(str,b)))
res = 1
a = a % 1337
if (a == 0) :
return 0
while (b>0) :
if ((b & 1) == 1):
res=(res*a)%1337
b=b>>1
a=(a*a)%1337
return res
|
super-pow
|
using modular expansion
|
janhaviborde23
| -3 | 179 |
super pow
| 372 | 0.371 |
Medium
| 6,362 |
https://leetcode.com/problems/find-k-pairs-with-smallest-sums/discuss/1701122/Python-Simple-heap-solution-explained
|
class Solution:
def kSmallestPairs(self, nums1: List[int], nums2: List[int], k: int) -> List[List[int]]:
hq = []
heapq.heapify(hq)
# add all the pairs that we can form with
# all the (first k) items in nums1 with the first
# item in nums2
for i in range(min(len(nums1), k)):
heapq.heappush(hq, (nums1[i]+nums2[0], nums1[i], nums2[0], 0))
# since the smallest pair will
# be the first element from both nums1 and nums2. We'll
# start with that and then subsequently, we'll pop it out
# from the heap and also insert the pair of the current
# element from nums1 with the next nums2 element
out = []
while k > 0 and hq:
_, n1, n2, idx = heapq.heappop(hq)
out.append((n1, n2))
if idx + 1 < len(nums2):
# the heap will ensure that the smallest element
# based on the sum will remain on top and the
# next iteration will give us the pair we require
heapq.heappush(hq, (n1+nums2[idx+1], n1, nums2[idx+1], idx+1))
k -= 1
return out
|
find-k-pairs-with-smallest-sums
|
[Python] Simple heap solution explained
|
buccatini
| 11 | 1,400 |
find k pairs with smallest sums
| 373 | 0.383 |
Medium
| 6,363 |
https://leetcode.com/problems/find-k-pairs-with-smallest-sums/discuss/1103290/Python-7-line-Simple-Heap-36-ms
|
class Solution:
def kSmallestPairs(self, nums1: List[int], nums2: List[int], k: int) -> List[List[int]]:
if not nums2 or not nums1: return []
heap = []
heapq.heapify(heap)
for i, num1 in enumerate(nums1[:k]):
for num2 in nums2[:k//(i+1)]:
heapq.heappush(heap, [num1+num2, num1, num2])
return [x[1:] for x in heapq.nsmallest(k, heap)]
|
find-k-pairs-with-smallest-sums
|
[Python] 7-line Simple Heap, 36 ms
|
cloverpku
| 6 | 1,100 |
find k pairs with smallest sums
| 373 | 0.383 |
Medium
| 6,364 |
https://leetcode.com/problems/find-k-pairs-with-smallest-sums/discuss/492422/Python-Min-Heap
|
class Solution:
def kSmallestPairs(self, nums1, nums2, k):
if not nums1 or not nums2 or not k: return []
i = j = 0
minHeap = []
for _ in range(k):
if i < len(nums1) and j < len(nums2):
if nums1[i] <= nums2[j]:
for x in nums2[j:]: heapq.heappush(minHeap, (nums1[i], x))
i += 1
else:
for x in nums1[i:]: heapq.heappush(minHeap, (x, nums2[j]))
j += 1
return heapq.nsmallest(k, minHeap, key = sum)
|
find-k-pairs-with-smallest-sums
|
Python - Min Heap
|
mmbhatk
| 4 | 1,700 |
find k pairs with smallest sums
| 373 | 0.383 |
Medium
| 6,365 |
https://leetcode.com/problems/find-k-pairs-with-smallest-sums/discuss/1058117/Python-or-Heap-Push-Heap-Pop
|
class Solution:
def kSmallestPairs(self, nums1: List[int], nums2: List[int], k: int) -> List[List[int]]:
result, min_heap = [], []
for i in nums1:
for j in nums2:
heapq.heappush(min_heap, (i+j, i, j))
for _ in range(k):
if not min_heap: break
result.append(heapq.heappop(min_heap)[1:])
return result
|
find-k-pairs-with-smallest-sums
|
Python | Heap Push Heap Pop
|
dev-josh
| 2 | 426 |
find k pairs with smallest sums
| 373 | 0.383 |
Medium
| 6,366 |
https://leetcode.com/problems/find-k-pairs-with-smallest-sums/discuss/658086/Python3-heapq.merge-generator-Find-K-Pairs-with-Smallest-Sums
|
class Solution:
def kSmallestPairs(self, nums1: List[int], nums2: List[int], k: int) -> List[List[int]]:
def generator(n1):
for n2 in nums2:
yield [n1+n2, n1, n2]
merged = heapq.merge(*map(generator, nums1))
return [p[1:] for p in itertools.islice(merged, k) if p]
|
find-k-pairs-with-smallest-sums
|
Python3 heapq.merge generator - Find K Pairs with Smallest Sums
|
r0bertz
| 2 | 478 |
find k pairs with smallest sums
| 373 | 0.383 |
Medium
| 6,367 |
https://leetcode.com/problems/find-k-pairs-with-smallest-sums/discuss/811844/Python3-via-heap
|
class Solution:
def kSmallestPairs(self, nums1: List[int], nums2: List[int], k: int) -> List[List[int]]:
if not nums1 or not nums2: return [] # edge case
hp = [(nums1[0] + nums2[j], 0, j) for j in range(len(nums2))] # min heap of size n
heapify(hp)
ans = []
while k and hp:
k -= 1
_, i, j = heappop(hp)
ans.append([nums1[i], nums2[j]])
if i+1 < len(nums1): heappush(hp, (nums1[i+1] + nums2[j], i+1, j))
return ans
|
find-k-pairs-with-smallest-sums
|
[Python3] via heap
|
ye15
| 1 | 222 |
find k pairs with smallest sums
| 373 | 0.383 |
Medium
| 6,368 |
https://leetcode.com/problems/find-k-pairs-with-smallest-sums/discuss/2816924/Modified-BFS-by-selectively-branching-from-the-lowest-sum-nodes
|
class Solution:
def kSmallestPairs(self, nums1: List[int], nums2: List[int], k: int) -> List[List[int]]:
ans = []
candidates = [(0,0)] # first pair is always give the smallest sum
seen = set(['0,0']) # do not visit the indexes we have seen
while len(candidates) > 0:
listOfChosenNumber = self.getLowestN(candidates, nums1, nums2) # we choose the smallest n out of all the possible candidates
for num in listOfChosenNumber[0]:
if len(ans) == k:
ans = [[nums1[x[0]],nums2[x[1]]] for x in ans]
return ans
else:
ans.append(num)
# we get the possible choices of the pairs we chose & add it the pairs we didn't choose
# for the next iteration
listOfChosenNumber[1].extend(self.getChoices(listOfChosenNumber[0], len(nums1), len(nums2), seen))
candidates = listOfChosenNumber[1]
ans = [[nums1[x[0]],nums2[x[1]]] for x in ans] # convert the index into values
return ans
def getChoices(self,listOfChosenNumber, num1Len, num2Len, seen):
choices = []
for c in listOfChosenNumber:
addNum1 = str(c[0]+1) + ',' + str(c[1])
addNum2 = str(c[0]) + ',' + str(c[1]+1)
# we increment nums1 in the pair
if c[0]+1 < num1Len and addNum1 not in seen:
choices.append((c[0]+1, c[1]))
seen.add(addNum1)
# we increment nums2 in the pair
if c[1]+1 < num2Len and addNum2 not in seen:
choices.append((c[0], c[1]+1))
seen.add(addNum2)
return choices
def getLowestN(self,candidates,nums1,nums2):
# getting the n smallest sum of the list of candidates
selected = []
notSelected = []
minSum = None
for pair in candidates:
numSum = nums1[pair[0]]+nums2[pair[1]]
if minSum == None:
minSum = numSum
selected.append(pair)
elif numSum < minSum:
notSelected.extend(selected)
selected = [pair]
minSum = numSum
elif numSum > minSum:
notSelected.append(pair)
else:
selected.append(pair)
return [selected,notSelected]
|
find-k-pairs-with-smallest-sums
|
Modified BFS by selectively branching from the lowest sum nodes
|
yellowduckyugly
| 0 | 1 |
find k pairs with smallest sums
| 373 | 0.383 |
Medium
| 6,369 |
https://leetcode.com/problems/find-k-pairs-with-smallest-sums/discuss/2800118/Python-or-SImple-or-Max-Heap
|
class Solution:
def kSmallestPairs(self, nums1: List[int], nums2: List[int], k: int) -> List[List[int]]:
max_heap, result = [], []
for i in range(min(k, len(nums1))):
for j in range(min(k, len(nums2))):
sum_val = nums1[i] + nums2[j]
if len(max_heap) < k:
heappush(max_heap, (-sum_val, i, j))
else:
if sum_val > -max_heap[0][0]:
break
else:
heappushpop(max_heap, (-sum_val, i, j))
for _, i, j in max_heap:
result.append([nums1[i], nums2[j]])
return result
|
find-k-pairs-with-smallest-sums
|
Python | SImple | Max Heap
|
david-cobbina
| 0 | 7 |
find k pairs with smallest sums
| 373 | 0.383 |
Medium
| 6,370 |
https://leetcode.com/problems/find-k-pairs-with-smallest-sums/discuss/2661685/Heap-or-Python-or-O(klogn)
|
class Solution:
def kSmallestPairs(self, nums1: List[int], nums2: List[int], k: int) -> List[List[int]]:
flag = (n := len(nums1)) > (m := len(nums2))
if flag:
n, m, nums1, nums2 = m, n, nums2, nums1
heap = []
for i in range(min(k, n)):
heappush(heap, (nums1[i] + nums2[0], i, 0))
ans = []
while heap and len(ans) < k:
s, i, j = heappop(heap)
ans.append([nums1[i], nums2[j]] if not flag else [nums2[j], nums1[i]])
if j + 1 < min(k, m):
heappush(heap, (nums1[i] + nums2[j + 1], i, j + 1))
return ans
|
find-k-pairs-with-smallest-sums
|
Heap | Python | O(klogn)
|
Kiyomi_
| 0 | 52 |
find k pairs with smallest sums
| 373 | 0.383 |
Medium
| 6,371 |
https://leetcode.com/problems/find-k-pairs-with-smallest-sums/discuss/2643855/Python-Solution-using-Heap
|
class Solution:
def kSmallestPairs(self, nums1: List[int], nums2: List[int], k: int) -> List[List[int]]:
ans = []
heapq.heapify(ans)
second = (min(k, len(nums2)))
first = min(k, len(nums1))
for i in nums1[:first+1]:
for j in nums2[:second + 1]:
if len(ans) < k:
heapq.heappush(ans, [-(i + j), [i,j]])
else:
if (i + j) > -ans[0][0]:
break
heapq.heappush(ans, [-(i + j), [i,j]])
heapq.heappop(ans)
return [j for i, j in ans[::-1]]
|
find-k-pairs-with-smallest-sums
|
Python Solution using Heap
|
vijay_2022
| 0 | 19 |
find k pairs with smallest sums
| 373 | 0.383 |
Medium
| 6,372 |
https://leetcode.com/problems/find-k-pairs-with-smallest-sums/discuss/2348052/simple-python-heap
|
class Solution:
def kSmallestPairs(self, nums1, nums2, k):
res = []
if not nums1 or not nums2 or not k:
return res
heap = []
visited = set()
heapq.heappush(heap, (nums1[0] + nums2[0], 0, 0))
visited.add((0, 0))
while len(res) < k and heap:
_, i, j = heapq.heappop(heap)
res.append([nums1[i], nums2[j]])
if i + 1 < len(nums1) and (i + 1, j) not in visited:
heapq.heappush(heap, (nums1[i + 1] + nums2[j], i + 1, j))
visited.add((i + 1, j))
if j + 1 < len(nums2) and (i, j + 1) not in visited:
heapq.heappush(heap, (nums1[i] + nums2[j + 1], i, j + 1))
visited.add((i, j + 1))
return res
|
find-k-pairs-with-smallest-sums
|
simple python heap
|
gasohel336
| 0 | 151 |
find k pairs with smallest sums
| 373 | 0.383 |
Medium
| 6,373 |
https://leetcode.com/problems/find-k-pairs-with-smallest-sums/discuss/1249301/Python-Space-optimsed-as-well-as-time-optimised-Solution(HEAP-DS)
|
class Solution:
def kSmallestPairs(self, nums1: List[int], nums2: List[int], k: int) -> List[List[int]]:
min_heap=[]
if(len(nums1)*len(nums2)<k):
k=len(nums1)*len(nums2)
for i in range(0,len(nums1)):
for j in range(0,len(nums2)):
s=nums1[i]+nums2[j]
heappush(min_heap,(-s,nums1[i],nums2[j]))
if(len(min_heap)>k):
heappop(min_heap)
j=0
ans=[]
while j<k:
res,a,b=heappop(min_heap)
ans.append([a,b])
j+=1
return ans
|
find-k-pairs-with-smallest-sums
|
Python Space optimsed as well as time optimised Solution(HEAP DS)
|
Amans82702
| -2 | 136 |
find k pairs with smallest sums
| 373 | 0.383 |
Medium
| 6,374 |
https://leetcode.com/problems/find-k-pairs-with-smallest-sums/discuss/1249301/Python-Space-optimsed-as-well-as-time-optimised-Solution(HEAP-DS)
|
class Solution:
def kSmallestPairs(self, nums1: List[int], nums2: List[int], k: int) -> List[List[int]]:
min_heap=[]
if(len(nums1)*len(nums2)<k):
k=len(nums1)*len(nums2)
for i in range(0,len(nums1)):
for j in range(0,len(nums2)):
s=nums1[i]+nums2[j]
heappush(min_heap,(s,nums1[i],nums2[j]))
j=0
ans=[]
while j<k:
res,a,b=heappop(min_heap)
ans.append([a,b])
j+=1
return ans
|
find-k-pairs-with-smallest-sums
|
Python Space optimsed as well as time optimised Solution(HEAP DS)
|
Amans82702
| -2 | 136 |
find k pairs with smallest sums
| 373 | 0.383 |
Medium
| 6,375 |
https://leetcode.com/problems/find-k-pairs-with-smallest-sums/discuss/1319295/Easy-to-Understand-Python-Solution
|
class Solution:
def kSmallestPairs(self, nums1, nums2, k: int):
temp=[]
res=[]
tot=[]
end=0
for i in nums1:
for j in nums2:
temp.append([i,j])
tot.append(sum([i,j]))
for i,v in sorted(zip(temp,tot),key = lambda x: x[1]):
if end<k:
res.append(i)
end+=1
return res
|
find-k-pairs-with-smallest-sums
|
Easy to Understand Python Solution
|
sangam92
| -3 | 365 |
find k pairs with smallest sums
| 373 | 0.383 |
Medium
| 6,376 |
https://leetcode.com/problems/guess-number-higher-or-lower/discuss/2717871/DONT-TRY-THIS-CODE-or-ONE-LINE-PYTHON-CODE
|
class Solution:
def guessNumber(self, n: int) -> int:
return __pick__
|
guess-number-higher-or-lower
|
DONT TRY THIS CODE | ONE LINE PYTHON CODE
|
raghavdabra
| 9 | 441 |
guess number higher or lower
| 374 | 0.514 |
Easy
| 6,377 |
https://leetcode.com/problems/guess-number-higher-or-lower/discuss/2164730/Python3-extension-of-Binary-Search
|
class Solution:
def guessNumber(self, n: int) -> int:
low = 1
high = n
while low<=high:
mid = (low+high)//2
gussed = guess(mid)
if gussed == 0:
return mid
if gussed<0:
high = mid-1
else:
low = mid+1
return low
|
guess-number-higher-or-lower
|
📌 Python3 extension of Binary Search
|
Dark_wolf_jss
| 5 | 145 |
guess number higher or lower
| 374 | 0.514 |
Easy
| 6,378 |
https://leetcode.com/problems/guess-number-higher-or-lower/discuss/2819214/Easy-Python-Solution
|
class Solution:
def guessNumber(self, n: int) -> int:
low = 1
high = n
while low <= high:
mid = (low + high)//2
res = guess(mid)
if res == 0 :
return mid
elif res == -1:
high = mid - 1
else:
low = mid + 1
|
guess-number-higher-or-lower
|
Easy Python Solution
|
Vistrit
| 3 | 248 |
guess number higher or lower
| 374 | 0.514 |
Easy
| 6,379 |
https://leetcode.com/problems/guess-number-higher-or-lower/discuss/1259722/Python3-dollarolution-(memory-99.87)
|
class Solution:
def guessNumber(self, n: int) -> int:
l, h = 1, n+1
while True:
m = int((l+h)/2)
if guess(m) == 0:
return m
elif guess(m) == -1:
h = m
else:
l = m
|
guess-number-higher-or-lower
|
Python3 $olution (memory - 99.87%)
|
AakRay
| 2 | 334 |
guess number higher or lower
| 374 | 0.514 |
Easy
| 6,380 |
https://leetcode.com/problems/guess-number-higher-or-lower/discuss/1241261/Python3-simple-solution-using-binary-search
|
class Solution:
def guessNumber(self, n: int) -> int:
l,h = 1,n
mid = (l + h)//2
while True:
if guess(mid) < 0:
h = mid-1
mid = (l + h)//2
elif guess(mid) > 0:
l = mid+1
mid = (l + h)//2
else:
return mid
|
guess-number-higher-or-lower
|
Python3 simple solution using binary search
|
EklavyaJoshi
| 2 | 83 |
guess number higher or lower
| 374 | 0.514 |
Easy
| 6,381 |
https://leetcode.com/problems/guess-number-higher-or-lower/discuss/2820807/C%2B%2B-Python-Java-oror-Videos-of-Binary-Search-by-Experts-oror-Easy-to-Understand-oror-Binary-Search
|
class Solution:
def guessNumber(self, n: int) -> int:
low = 0
high = n
while low<=high:
mid = low+(high-low)//2
num = guess(mid)
if num == 0:
return mid
elif num == -1:
high = mid-1
else:
low = mid+1
|
guess-number-higher-or-lower
|
C++, Python, Java || Videos of Binary-Search by Experts || Easy to Understand || Binary-Search
|
mataliaprajit
| 1 | 27 |
guess number higher or lower
| 374 | 0.514 |
Easy
| 6,382 |
https://leetcode.com/problems/guess-number-higher-or-lower/discuss/2819629/Python-Classic-Binary-Search-Problem-with-Explaination-or-99-Faster-or-Fastest-Solution
|
class Solution:
def guessNumber(self, n: int) -> int:
left, right = 0, n
while left<=right:
mid = (left+right)//2
num = guess(mid)
if num == 0:
return mid
elif num == -1:
right = mid-1
else:
left = mid+1
|
guess-number-higher-or-lower
|
✔️ Python Classic Binary Search Problem with Explaination | 99% Faster | Fastest Solution 🔥
|
pniraj657
| 1 | 39 |
guess number higher or lower
| 374 | 0.514 |
Easy
| 6,383 |
https://leetcode.com/problems/guess-number-higher-or-lower/discuss/2819624/99.04-Faster-Python-binary-search-easiest-approach-O(log-N)
|
class Solution:
def guessNumber(self, n: int) -> int:
l = 1
r = n
while l<=r:
mid = l + (r-l)//2
result = guess(mid)
if result == 0:
return mid
elif result == -1:
r = mid -1
elif result == 1:
l = mid + 1
return mid
|
guess-number-higher-or-lower
|
99.04% Faster Python binary search easiest approach O(log N)
|
mohitOnlyCodeLover
| 1 | 47 |
guess number higher or lower
| 374 | 0.514 |
Easy
| 6,384 |
https://leetcode.com/problems/guess-number-higher-or-lower/discuss/1930437/Python-Binary-Search-or-Simple-and-Clean
|
class Solution:
def guessNumber(self, n):
l, r = 1, n
while True:
m = (l+r)//2
match guess(m):
case 0: return m
case 1: l = m+1
case -1: r = m-1
|
guess-number-higher-or-lower
|
Python - Binary Search | Simple and Clean
|
domthedeveloper
| 1 | 116 |
guess number higher or lower
| 374 | 0.514 |
Easy
| 6,385 |
https://leetcode.com/problems/guess-number-higher-or-lower/discuss/1517044/Python3-binary-search
|
class Solution:
def guessNumber(self, n: int) -> int:
lo, hi = 1, n
while lo <= hi:
mid = lo + hi >> 1
val = guess(mid)
if val == -1: hi = mid - 1
elif val == 0: return mid
else: lo = mid + 1
|
guess-number-higher-or-lower
|
[Python3] binary search
|
ye15
| 1 | 58 |
guess number higher or lower
| 374 | 0.514 |
Easy
| 6,386 |
https://leetcode.com/problems/guess-number-higher-or-lower/discuss/1378302/Easy-Fast-Memory-Efficient-Python-O(log-n)-Solution
|
class Solution:
def guessNumber(self, n: int) -> int:
l, h = 0, n+1
ret = guess(n)
if ret == 0:
return n
while l < h:
m = (h+l)//2
ret = guess(m)
if ret == 0:
return m
elif ret == -1:
h = m+1
elif ret == 1:
l = m-1
|
guess-number-higher-or-lower
|
Easy, Fast, Memory Efficient Python O(log n) Solution
|
the_sky_high
| 1 | 179 |
guess number higher or lower
| 374 | 0.514 |
Easy
| 6,387 |
https://leetcode.com/problems/guess-number-higher-or-lower/discuss/2830091/Python-Solution-Binary-Search-Approach
|
class Solution:
def guessNumber(self, n: int) -> int:
#BASED ON BINARY SEARCH
l=1
h=n
while l<=h:
mid=(l+h)//2
pick=guess(mid)
if pick==0:
return mid
if pick==-1:
h=mid
elif pick==1:
l=mid+1
|
guess-number-higher-or-lower
|
Python Solution - Binary Search Approach ✔
|
T1n1_B0x1
| 0 | 4 |
guess number higher or lower
| 374 | 0.514 |
Easy
| 6,388 |
https://leetcode.com/problems/guess-number-higher-or-lower/discuss/2827778/Python3%3A-Runtime%3A-98.96-Memory%3A-97.83
|
class Solution:
def guessNumber(self, n: int) -> int:
left = 1
right = n
while left <= right:
mid = (left + right) // 2
(res := guess(mid))
if res == 1:
left = mid + 1
elif res == -1:
right = mid - 1
else:
return mid
return -1
|
guess-number-higher-or-lower
|
Python3: Runtime: 98.96%, Memory: 97.83%
|
Leyonad
| 0 | 2 |
guess number higher or lower
| 374 | 0.514 |
Easy
| 6,389 |
https://leetcode.com/problems/guess-number-higher-or-lower/discuss/2821787/oror-C%2B%2B-and-PYTHON-oror-EASY-SOLUTION-oror-BEATS-100-oror-BINARY-SEARCH-oror
|
class Solution:
def guessNumber(self, n: int) -> int:
l = 1
r = n
p = l + (r - l) / 2
g = guess(p)
while(g != 0):
r = p-1 if g == -1 else r
l = p+1 if g == 1 else l
p = l + (r - l) / 2
g = guess(p)
return int(p)
|
guess-number-higher-or-lower
|
|| C++ & PYTHON || EASY SOLUTION || BEATS 100% || BINARY SEARCH ||
|
michalwesolowski
| 0 | 4 |
guess number higher or lower
| 374 | 0.514 |
Easy
| 6,390 |
https://leetcode.com/problems/guess-number-higher-or-lower/discuss/2821478/C%2B%2B.-oror-Binary-Search-Based-Solution
|
class Solution:
def guessNumber(self, n: int) -> int:
i, j = 1, n
while i <= j:
m = (i+j)//2
g = guess(m)
if g > 0:
i = m+1
elif g < 0:
j = m-1
else:
return m
return -1
|
guess-number-higher-or-lower
|
C++. || Binary Search Based Solution
|
Anup_1999
| 0 | 5 |
guess number higher or lower
| 374 | 0.514 |
Easy
| 6,391 |
https://leetcode.com/problems/guess-number-higher-or-lower/discuss/2821389/Binary-search-solution
|
class Solution:
def guessNumber(self, n: int) -> int:
low = 1
high = n
mid = n//2
g = guess(mid)
while g!=0:
if g==-1:
high = mid - 1
elif g==1:
low = mid + 1
mid = (low+high)//2
g = guess(mid)
return mid
|
guess-number-higher-or-lower
|
Binary search solution
|
pratiklilhare
| 0 | 2 |
guess number higher or lower
| 374 | 0.514 |
Easy
| 6,392 |
https://leetcode.com/problems/guess-number-higher-or-lower/discuss/2821149/Solution-The-Best
|
class Solution:
def guessNumber(self, j: int, i=1) -> int:
while True:
m = (i + j) >> 1
g = guess(m)
if g == 0:
return m
g = (g + 1) >> 1
i += g * (m + 1 - i)
j += (1 - g) * (m - 1 - j)
|
guess-number-higher-or-lower
|
Solution, The Best
|
Triquetra
| 0 | 4 |
guess number higher or lower
| 374 | 0.514 |
Easy
| 6,393 |
https://leetcode.com/problems/guess-number-higher-or-lower/discuss/2821131/Changing-guess-one-digit-at-a-time
|
class Solution:
def guessNumber(self, n):
number = 2147483648
exponent = 9
while True:
if guess(number) == -1:
number -= 10**exponent
if guess(number) == 1:
exponent -= 1
elif guess(number) == 1:
number += 10**exponent
if guess(number) == -1:
exponent -= 1
else:
return number
|
guess-number-higher-or-lower
|
Changing guess one digit at a time
|
OSTERIE
| 0 | 1 |
guess number higher or lower
| 374 | 0.514 |
Easy
| 6,394 |
https://leetcode.com/problems/guess-number-higher-or-lower/discuss/2821007/Python-or-Binary-Search-O(log-n)-Time-O(1)-Space
|
class Solution:
def guessNumber(self, n: int, lo = 1) -> int:
low, high = 1, n+1
while True:
num = int((low+high)/2)
attempt = guess(num)
if attempt == -1: high = num
elif attempt == 1: low = num
else: return num
|
guess-number-higher-or-lower
|
Python | Binary Search O(log n) Time, O(1) Space
|
jessewalker2010
| 0 | 3 |
guess number higher or lower
| 374 | 0.514 |
Easy
| 6,395 |
https://leetcode.com/problems/guess-number-higher-or-lower/discuss/2820991/Python-solution-with-explanation
|
class Solution:
def guessNumber(self, n: int) -> int:
left = 1
right = n
while(left<=right):
mid = left + (right-left)//2
val = guess(mid)
if(val==0):
return mid
elif(val==-1):
right = mid-1
else:
left = mid+1
return -1
|
guess-number-higher-or-lower
|
Python solution with explanation
|
yashkumarjha
| 0 | 2 |
guess number higher or lower
| 374 | 0.514 |
Easy
| 6,396 |
https://leetcode.com/problems/guess-number-higher-or-lower/discuss/2820865/Simple-Solution%3A-Recursive-Binary-Search
|
class Solution:
def guessNumber(self, n: int, m=1) -> int:
i = int((n+m)/2)
g = guess(i)
if not g: return i
if g == 1: return self.guessNumber(n, i+1)
return self.guessNumber(i-1, m)
|
guess-number-higher-or-lower
|
Simple Solution: Recursive Binary Search
|
Mencibi
| 0 | 2 |
guess number higher or lower
| 374 | 0.514 |
Easy
| 6,397 |
https://leetcode.com/problems/guess-number-higher-or-lower/discuss/2820143/Python-(Faster-than-97)-or-Binary-search
|
class Solution:
def guessNumber(self, n: int) -> int:
l, r = 1, n
while l <= r:
mid = (l + r) // 2
val = guess(mid)
if val == -1:
r = mid - 1
elif val == 1:
l = mid + 1
elif val == 0:
return mid
|
guess-number-higher-or-lower
|
Python (Faster than 97%) | Binary search
|
KevinJM17
| 0 | 2 |
guess number higher or lower
| 374 | 0.514 |
Easy
| 6,398 |
https://leetcode.com/problems/guess-number-higher-or-lower-ii/discuss/1510747/Python-DP-beat-97.52-in-time-99-in-memory-(with-explanation)
|
class Solution:
def getMoneyAmount(self, n: int) -> int:
if n == 1:
return 1
starting_index = 1 if n % 2 == 0 else 2
selected_nums = [i for i in range(starting_index, n, 2)]
selected_nums_length = len(selected_nums)
dp = [[0] * selected_nums_length for _ in range(selected_nums_length)]
for i in range(selected_nums_length):
dp[i][i] = selected_nums[i]
for length in range(2, selected_nums_length + 1):
for i in range(selected_nums_length - length + 1):
j = i + length - 1
dp[i][j] = float("inf")
for k in range(i, j + 1):
dp_left = dp[i][k - 1] if k != 0 else 0
dp_right = dp[k + 1][j] if k != j else 0
dp[i][j] = min(dp[i][j], selected_nums[k] + max(dp_left, dp_right))
return dp[0][-1]
|
guess-number-higher-or-lower-ii
|
[Python] DP, beat 97.52% in time, 99% in memory (with explanation)
|
wingskh
| 31 | 1,100 |
guess number higher or lower ii
| 375 | 0.465 |
Medium
| 6,399 |
Subsets and Splits
Top 2 Solutions by Upvotes
Identifies the top 2 highest upvoted Python solutions for each problem, providing insight into popular approaches.