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/reverse-bits/discuss/1623974/Python-Solution-or-String-Manipulation-or-Bit-Manipulation-or-O(n)-or-90-Faster
|
class Solution:
def reverseBits(self, n: int) -> int:
reverse_binary = ""
while n > 0:
reverse_binary += str(n%2)
n = n//2
for i in range(0, 32-len(reverse_binary)):
reverse_binary += "0"
return int(reverse_binary, 2)
|
reverse-bits
|
Python Solution | String Manipulation | Bit Manipulation | O(n) | 90% Faster
|
avi-arora
| 0 | 106 |
reverse bits
| 190 | 0.525 |
Easy
| 3,100 |
https://leetcode.com/problems/reverse-bits/discuss/1623974/Python-Solution-or-String-Manipulation-or-Bit-Manipulation-or-O(n)-or-90-Faster
|
class Solution:
def reverseBits(self, n: int) -> int:
reverse_binary, count = 0, 0
while n > 0:
reverse_binary = (reverse_binary << 1) | (n&1)
n, count = n >> 1, count+1
return reverse_binary << 32-count
|
reverse-bits
|
Python Solution | String Manipulation | Bit Manipulation | O(n) | 90% Faster
|
avi-arora
| 0 | 106 |
reverse bits
| 190 | 0.525 |
Easy
| 3,101 |
https://leetcode.com/problems/reverse-bits/discuss/1442747/Python3-One-Line-Faster-Than-99.56
|
class Solution:
def reverseBits(self, n: int) -> int:
return int((bin(n)[2:].zfill(32))[::-1], 2)
|
reverse-bits
|
Python3 One-Line Faster Than 99.56%
|
Hejita
| 0 | 88 |
reverse bits
| 190 | 0.525 |
Easy
| 3,102 |
https://leetcode.com/problems/reverse-bits/discuss/1238619/Python3-one-liner-wo-explications
|
class Solution:
def reverseBits(self, n: int) -> int:
return int(str(bin(n)[2:]).rjust(32,'0')[::-1], 2)
|
reverse-bits
|
Python3 one-liner w/o explications
|
S-c-r-a-t-c-h-y
| 0 | 68 |
reverse bits
| 190 | 0.525 |
Easy
| 3,103 |
https://leetcode.com/problems/number-of-1-bits/discuss/2074152/Easy-O(1)-Space-PythonC%2B%2B
|
class Solution:
def hammingWeight(self, n: int) -> int:
return sum((n & (1<<i))!=0 for i in range(32))
|
number-of-1-bits
|
Easy O(1) Space - Python/C++
|
constantine786
| 21 | 2,800 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,104 |
https://leetcode.com/problems/number-of-1-bits/discuss/2074152/Easy-O(1)-Space-PythonC%2B%2B
|
class Solution:
def hammingWeight(self, n: int) -> int:
cnt = 0
while n :
cnt+=1
n = n & (n-1)
return cnt
|
number-of-1-bits
|
Easy O(1) Space - Python/C++
|
constantine786
| 21 | 2,800 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,105 |
https://leetcode.com/problems/number-of-1-bits/discuss/1044847/Python.-Simple-and-easy-solution.
|
class Solution:
def hammingWeight(self, n: int) -> int:
ans = 0
while n:
ans += n % 2
n = n >> 1
return ans
|
number-of-1-bits
|
Python. Simple & easy solution.
|
m-d-f
| 10 | 1,800 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,106 |
https://leetcode.com/problems/number-of-1-bits/discuss/377550/Python-multiple-solutions-including-O(1)
|
class Solution(object):
def hammingWeight(self, n):
mask_sum_2bit = 0x55555555
mask_sum_4bit = 0x33333333
mask_sum_8bit = 0x0F0F0F0F
mask_sum_16bit = 0x00FF00FF
mask_sum_32bit = 0x0000FFFF
n = (n & mask_sum_2bit) + ((n >> 1) & mask_sum_2bit)
n = (n & mask_sum_4bit) + ((n >> 2) & mask_sum_4bit)
n = (n & mask_sum_8bit) + ((n >> 4) & mask_sum_8bit)
n = (n & mask_sum_16bit) + ((n >> 8) & mask_sum_16bit)
n = (n & mask_sum_32bit) + ((n >> 16) & mask_sum_32bit)
return n
|
number-of-1-bits
|
Python multiple solutions including O(1)
|
amchoukir
| 10 | 1,100 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,107 |
https://leetcode.com/problems/number-of-1-bits/discuss/377550/Python-multiple-solutions-including-O(1)
|
class Solution(object):
def hammingWeight(self, n):
count = 0
while n:
count += 1
n = n & (n - 1)
return count
|
number-of-1-bits
|
Python multiple solutions including O(1)
|
amchoukir
| 10 | 1,100 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,108 |
https://leetcode.com/problems/number-of-1-bits/discuss/2215997/Python3-simple-solution%3A-Do-nand(n-1)
|
class Solution:
def hammingWeight(self, n: int) -> int:
result = 0
while n:
n = n & (n-1)
result+=1
return result
|
number-of-1-bits
|
📌 Python3 simple solution: Do n&(n-1)
|
Dark_wolf_jss
| 6 | 149 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,109 |
https://leetcode.com/problems/number-of-1-bits/discuss/1304131/Easy-Python-Solution(95.81)
|
class Solution:
def hammingWeight(self, n: int) -> int:
c=0
while n:
if(n&1):
c+=1
n=n>>1
return c
|
number-of-1-bits
|
Easy Python Solution(95.81%)
|
Sneh17029
| 5 | 915 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,110 |
https://leetcode.com/problems/number-of-1-bits/discuss/890389/Python-simple-solution-using-bit-operations
|
class Solution:
def hammingWeight(self, n: int) -> int:
res = 0
while n:
res += n & 1
n >>= 1
return res
|
number-of-1-bits
|
Python simple solution using bit operations
|
stom1407
| 5 | 561 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,111 |
https://leetcode.com/problems/number-of-1-bits/discuss/1791085/Python-3-(40ms)-or-BIT-AND-Formula-(nandn(n-1))-Solution-or-Easy-to-Understand
|
class Solution:
def hammingWeight(self, n: int) -> int:
c=0
while n:
n=n&(n-1)
c+=1
return c
|
number-of-1-bits
|
Python 3 (40ms) | BIT AND Formula (n&n(n-1)) Solution | Easy to Understand
|
MrShobhit
| 3 | 297 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,112 |
https://leetcode.com/problems/number-of-1-bits/discuss/1543854/Python-bits-%2B-explanation
|
class Solution:
def hammingWeight(self, n: int) -> int:
count = 0
while n:
curr = n & 1
count += curr
n = n >> 1
return count
|
number-of-1-bits
|
Python bits + explanation
|
SleeplessChallenger
| 3 | 277 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,113 |
https://leetcode.com/problems/number-of-1-bits/discuss/2658811/Python-or-1-liner-string-solution
|
class Solution:
def hammingWeight(self, n: int) -> int:
return str(bin(n))[2:].count('1')
|
number-of-1-bits
|
Python | 1-liner string solution
|
LordVader1
| 2 | 291 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,114 |
https://leetcode.com/problems/number-of-1-bits/discuss/2645553/Useing-bin()
|
class Solution:
def hammingWeight(self, n: int) -> int:
x = str(bin(n))
output_ = 0
for i in x:
if i == '1':
output_ += 1
return output_
|
number-of-1-bits
|
Useing bin()
|
sanjeevpathak
| 2 | 16 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,115 |
https://leetcode.com/problems/number-of-1-bits/discuss/2074519/O(log(n))-Divide-by-2
|
class Solution:
def hammingWeight(self, n: int) -> int
count = 0
while n > 0:
count += n % 2
n //= 2
return count
|
number-of-1-bits
|
O(log(n)) Divide by 2
|
Eba472
| 2 | 124 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,116 |
https://leetcode.com/problems/number-of-1-bits/discuss/1643854/Simple-Python3-Solution-or-Beginner-friendly
|
class Solution:
def hammingWeight(self, n: int) -> int:
count = 0 # Count variable to maintain the number of '1' bits
while n > 0:
# Add the last bit i.e. either 1 or 0 to the counter
count += n % 2
# Divide the number by 2, same as shift right by 1 (n = n >> 1)
# Then we obtain the bit in the next position iteratively
n = n // 2
return count
|
number-of-1-bits
|
Simple Python3 Solution | Beginner friendly
|
Sparkles4
| 2 | 225 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,117 |
https://leetcode.com/problems/number-of-1-bits/discuss/1266260/Python3-Simple-Solution
|
class Solution:
def hammingWeight(self, n: int) -> int:
num = 0
while n:
if n & 1:
num += 1
n >>= 1
return num
|
number-of-1-bits
|
Python3 Simple Solution
|
yeefun
| 2 | 293 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,118 |
https://leetcode.com/problems/number-of-1-bits/discuss/2434721/C%2B%2BPython-Optimized-Bits-shift-approach
|
class Solution:
def hammingWeight(self, n: int) -> int:
count = 0
while n>0:
if (n&1)>0:
count=count+1
n=n>>1
return count
|
number-of-1-bits
|
C++/Python Optimized Bits shift approach
|
arpit3043
| 1 | 103 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,119 |
https://leetcode.com/problems/number-of-1-bits/discuss/2377012/Python-O(no-of-1-bits)-Efficient-Solution
|
class Solution:
def hammingWeight(self, n: int) -> int:
res = 0
while n:
n = n & (n - 1)#Removing no of 1 bits only
res += 1
return res
|
number-of-1-bits
|
Python O(no of 1 bits) Efficient Solution
|
soumyadexter7
| 1 | 123 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,120 |
https://leetcode.com/problems/number-of-1-bits/discuss/2126514/Memory-Usage%3A-13.8-MB-less-than-94.79-of-Python3
|
class Solution:
def hammingWeight(self, n: int) -> int:
return str(bin(n)).count('1')
|
number-of-1-bits
|
Memory Usage: 13.8 MB, less than 94.79% of Python3
|
writemeom
| 1 | 241 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,121 |
https://leetcode.com/problems/number-of-1-bits/discuss/2089879/Python3-O(1)-oror-O(1)
|
class Solution:
def hammingWeight(self, n: int) -> int:
return self.optimalSol(n)
return self.bruteForce(n)
return self.builtInMethod(n)
# O(1) || O(1)
# runtime: 35ms 81.75% memory: 13.9mb 49.97%
def optimalSol(self, n):
if not n:
return 0
count = 0
while n > 0:
count += 1 if n % 2 == 1 else 0
n >>= 1
return count
# O(n) || O(1)
# runtime: 42ms 58.55%; memory" 13.9mb 7.77%
def bruteForce(self, n):
count = 0
while n > 0:
count += 1 if n % 2 == 1 else 0
n //= 2
return count
def builtInMethod(self, n):
return bin(n)[2:].count('1')
|
number-of-1-bits
|
Python3 O(1) || O(1)
|
arshergon
| 1 | 232 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,122 |
https://leetcode.com/problems/number-of-1-bits/discuss/1851717/Number-Of-1-Bits-easy-solution
|
class Solution:
def hammingWeight(self, n: int) -> int:
return bin(n).count('1')
|
number-of-1-bits
|
Number Of 1 Bits - easy solution
|
jenil_095
| 1 | 169 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,123 |
https://leetcode.com/problems/number-of-1-bits/discuss/1823320/Python-simple-solution
|
class Solution(object):
def hammingWeight(self, n):
count = 0
while n:
count += n & 1
n >>= 1
return count
|
number-of-1-bits
|
Python - simple solution
|
domthedeveloper
| 1 | 166 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,124 |
https://leetcode.com/problems/number-of-1-bits/discuss/1774658/Python-One-Line-Linear-Solution-By-Counting-One-in-Binary-String
|
class Solution:
def hammingWeight(self, n: int) -> int:
return bin(n)[2:].count('1')
|
number-of-1-bits
|
[ Python ] ✔✔ One Line Linear Solution By Counting One in Binary String 🔥✌
|
ASHOK_KUMAR_MEGHVANSHI
| 1 | 266 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,125 |
https://leetcode.com/problems/number-of-1-bits/discuss/1695038/Python-one-line-solution-very-simple
|
class Solution:
def hammingWeight(self, n: int) -> int:
return bin(n).count('1')
|
number-of-1-bits
|
Python one-line-solution very simple
|
chandanasamineni23
| 1 | 129 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,126 |
https://leetcode.com/problems/number-of-1-bits/discuss/1394827/Python-Easy-Solution-Right-shift
|
class Solution:
def hammingWeight(self, n: int) -> int:
c=0
while(n):
if n%2==1:
c+=1
n=n>>1
return c
|
number-of-1-bits
|
Python Easy Solution Right shift
|
harshmalviya7
| 1 | 177 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,127 |
https://leetcode.com/problems/number-of-1-bits/discuss/2847124/python-solution-with-time-O(1)-space-O(1)-using-bit-manipulation
|
class Solution:
def hammingWeight(self, n: int) -> int:
t=1
count=0
for i in range(0 , 32):
# print('n&t' , n&t)
if (n&t!=0):
count+=1
t=t<<1
return count
|
number-of-1-bits
|
python solution with time O(1) , space O(1) using bit manipulation
|
sintin1310
| 0 | 1 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,128 |
https://leetcode.com/problems/number-of-1-bits/discuss/2840071/four-python-solution-.-bit-recursive-iterative-dummy
|
class Solution:
def hammingWeight(self, n: int) -> int:
# first solution :)
# return list(bin(n)[2:]).count('1')
# second solution
# cnt = 0
# while n > 0:
# if n%2 == 1 :
# cnt+=1
# n //= 2
#return cnt
# third solution
#if n == 0:
# return 0
#if n == 1 :
# return 1
#else :
# return (1 if n%2 == 1 else 0 ) + self.hammingWeight(n//2)
#'''
# fourth solution
b = 0
m = 1
for i in range(32):
if m & n != 0 :
b +=1
m<<=1
return b
|
number-of-1-bits
|
four python solution . bit / recursive / iterative / dummy
|
Cosmodude
| 0 | 1 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,129 |
https://leetcode.com/problems/number-of-1-bits/discuss/2836497/Pythonor-By-Operators
|
class Solution:
def hammingWeight(self, n: int) -> int:
i = 0
while n!= 0:
n = n&(n-1)
i += 1
return i
|
number-of-1-bits
|
Python| By Operators
|
lucy_sea
| 0 | 4 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,130 |
https://leetcode.com/problems/number-of-1-bits/discuss/2834323/Bit-calculation
|
class Solution:
def hammingWeight(self, n: int) -> int:
res = 0
while n != 0:
n = n & (n - 1)
res += 1
return res
|
number-of-1-bits
|
Bit calculation
|
lillllllllly
| 0 | 1 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,131 |
https://leetcode.com/problems/number-of-1-bits/discuss/2827848/Python-One-Liner
|
class Solution:
def hammingWeight(self, n: int) -> int:
return bin(n).count('1')
|
number-of-1-bits
|
Python One Liner
|
ShauryaGopu
| 0 | 3 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,132 |
https://leetcode.com/problems/number-of-1-bits/discuss/2819452/Python-function-n.bit_count()
|
class Solution:
def hammingWeight(self, n: int) -> int:
return n.bit_count()
|
number-of-1-bits
|
Python function n.bit_count()
|
JakhongirMurodov
| 0 | 2 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,133 |
https://leetcode.com/problems/number-of-1-bits/discuss/2781810/Easy-to-Understand-Python-Solution!
|
class Solution:
def hammingWeight(self, n: int) -> int:
one_count = 0
bits = f'{n:032b}'
for bit in bits:
if bit == '1':
one_count += 1
return one_count
|
number-of-1-bits
|
Easy to Understand Python Solution!
|
shanemmay
| 0 | 3 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,134 |
https://leetcode.com/problems/number-of-1-bits/discuss/2774158/python-easy-soution
|
class Solution:
def hammingWeight(self, n: int) -> int:
c=0
while n:
n=n&(n-1)
c=c+1
return c
|
number-of-1-bits
|
python easy so;ution
|
dummu_chandini
| 0 | 2 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,135 |
https://leetcode.com/problems/number-of-1-bits/discuss/2774155/python-easy-solution
|
class Solution:
def hammingWeight(self, n: int) -> int:
c=0
while n:
n=n&(n-1)
c=c+1
return c
|
number-of-1-bits
|
python easy solution
|
dummu_chandini
| 0 | 3 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,136 |
https://leetcode.com/problems/number-of-1-bits/discuss/2766125/Python3%3A-Easy-to-understand-solution
|
class Solution:
def hammingWeight(self, n: int) -> int:
# convert int to binary string
s = str(bin(n).replace("0b",""))
while len(s) != 32:
s = '0' + s
# count number of 1's in this string
count = 0
for i, char in enumerate(s):
if char == '1':
count += 1
# return count
return count
|
number-of-1-bits
|
Python3: Easy to understand solution
|
sourav_ravish
| 0 | 5 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,137 |
https://leetcode.com/problems/number-of-1-bits/discuss/2761271/Simple-Bitwise-Python3-*beats-91*
|
class Solution:
def hammingWeight(self, n: int) -> int:
c = 0
while n > 0:
if n & 1:
c += 1
n = n>>1
return c
|
number-of-1-bits
|
Simple Bitwise Python3 *beats 91%*
|
allisone4
| 0 | 5 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,138 |
https://leetcode.com/problems/number-of-1-bits/discuss/2756973/Python3-solution-Single-line
|
class Solution:
def hammingWeight(self, n: int) -> int:
return str(bin(n)).count('1')
|
number-of-1-bits
|
Python3 solution - Single line
|
NikhileshNanduri
| 0 | 3 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,139 |
https://leetcode.com/problems/number-of-1-bits/discuss/2751125/Simple-One-Liner-Python3-Solution-using-bin-and-count-function
|
class Solution:
def hammingWeight(self, n: int) -> int:
return bin(n)[2:].count("1")
|
number-of-1-bits
|
Simple One Liner Python3 Solution using bin and count function
|
vivekrajyaguru
| 0 | 6 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,140 |
https://leetcode.com/problems/number-of-1-bits/discuss/2751116/Simple-Pyhon3-Solution-using-Bin-function-and-for-loop
|
class Solution:
def hammingWeight(self, n: int) -> int:
result = 0
n = bin(n)[2:]
for i in str(n):
if i == '1':
result += 1
return result
|
number-of-1-bits
|
Simple Pyhon3 Solution using Bin function and for loop
|
vivekrajyaguru
| 0 | 2 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,141 |
https://leetcode.com/problems/number-of-1-bits/discuss/2716031/Easy-and-Fast-Bit-Manipulation-Solution
|
class Solution:
def hammingWeight(self, n: int) -> int:
ones = 0
for i in range(32):
if (n >> i) & 1 == 1:
ones += 1
return ones
|
number-of-1-bits
|
Easy & Fast Bit Manipulation Solution
|
user6770yv
| 0 | 5 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,142 |
https://leetcode.com/problems/number-of-1-bits/discuss/2694585/Easy-solution
|
class Solution:
def hammingWeight(self, n: int) -> int:
res = 0
while n:
if n & 1:
res += 1
n >>= 1
return res
|
number-of-1-bits
|
Easy solution
|
alperthod
| 0 | 6 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,143 |
https://leetcode.com/problems/number-of-1-bits/discuss/2680013/Python-1-line-solution-beats-97.45
|
class Solution:
def hammingWeight(self, n: int) -> int:
return bin(n).count('1')
|
number-of-1-bits
|
Python 1 line solution beats 97.45%
|
trickycat10
| 0 | 70 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,144 |
https://leetcode.com/problems/number-of-1-bits/discuss/2630112/One-line-solution-in-Python
|
class Solution:
def hammingWeight(self, n: int) -> int:
return sum((n >> i) & 1 for i in range(32))
|
number-of-1-bits
|
One line solution in Python
|
metaphysicalist
| 0 | 29 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,145 |
https://leetcode.com/problems/number-of-1-bits/discuss/2622366/Python-1-Liner-or-Simple
|
class Solution:
def hammingWeight(self, n: int) -> int:
return str(bin(n)).count('1')
|
number-of-1-bits
|
Python 1 Liner | Simple
|
sharondev
| 0 | 15 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,146 |
https://leetcode.com/problems/number-of-1-bits/discuss/2562091/Python-one-liner-with-explanation
|
class Solution:
def hammingWeight(self, n: int) -> int:
return f"{n: b}".count("1")
|
number-of-1-bits
|
Python one-liner with explanation
|
ComputerWiz
| 0 | 186 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,147 |
https://leetcode.com/problems/number-of-1-bits/discuss/2562091/Python-one-liner-with-explanation
|
class Solution:
def hammingWeight(self, n: int) -> int:
return len([c for c in f"{n: b}" if c=="1"])
|
number-of-1-bits
|
Python one-liner with explanation
|
ComputerWiz
| 0 | 186 |
number of 1 bits
| 191 | 0.65 |
Easy
| 3,148 |
https://leetcode.com/problems/house-robber/discuss/378700/Python-multiple-solutions
|
class Solution:
def __init__(self):
self.cache = {}
def rob_rec(self, nums, start):
if start >= len(nums):
return 0
if start in self.cache:
return self.cache[start]
self.cache[start] = nums[start] + max(self.rob_rec(nums, start+2), self.rob_rec(nums, start+3))
return self.cache[start]
def rob(self, nums: List[int]) -> int:
return max(self.rob_rec(nums, 0), self.rob_rec(nums, 1))
|
house-robber
|
Python multiple solutions
|
amchoukir
| 23 | 2,500 |
house robber
| 198 | 0.488 |
Medium
| 3,149 |
https://leetcode.com/problems/house-robber/discuss/378700/Python-multiple-solutions
|
class Solution:
def __init__(self):
self.cache = {}
def rob_rec(self, nums, current):
if current < 0: # Beyond array boundary
return 0
try:
return self.cache[current]
except:
self.cache[current] = max(self.rob_rec(nums, current - 1),
nums[current] + self.rob_rec(nums, current - 2))
return self.cache[current]
def rob(self, nums: List[int]) -> int:
return self.rob_rec(nums, len(nums) - 1)
|
house-robber
|
Python multiple solutions
|
amchoukir
| 23 | 2,500 |
house robber
| 198 | 0.488 |
Medium
| 3,150 |
https://leetcode.com/problems/house-robber/discuss/378700/Python-multiple-solutions
|
class Solution:
def rob(self, nums: List[int]) -> int:
house_1 = 0
house_2 = 0
house_3 = 0
for num in reversed(nums):
temp = house_1
house_1 = max(num + house_2, num + house_3)
house_3 = house_2
house_2 = temp
return max(house_1, house_2)
|
house-robber
|
Python multiple solutions
|
amchoukir
| 23 | 2,500 |
house robber
| 198 | 0.488 |
Medium
| 3,151 |
https://leetcode.com/problems/house-robber/discuss/378700/Python-multiple-solutions
|
class Solution:
def rob(self, nums: List[int]) -> int:
prev1, prev2 = 0, 0
for num in nums:
prev1, prev2 = max(prev2 + num, prev1), prev1
return prev1
|
house-robber
|
Python multiple solutions
|
amchoukir
| 23 | 2,500 |
house robber
| 198 | 0.488 |
Medium
| 3,152 |
https://leetcode.com/problems/house-robber/discuss/1605193/With-explanation-DP-with-O(L)-time-and-O(1)-space-in-Python
|
class Solution:
def rob(self, nums: List[int]) -> int:
#edge case
if len(nums) <= 2:
return max(nums)
#dp
L = len(nums)
dp = [0 for _ in range(L)]
dp[0], dp[1] = nums[0], max(nums[0], nums[1])
for i in range(2, L):
dp[i] = max(dp[i - 2] + nums[i], dp[i - 1])
return dp[-1]
|
house-robber
|
[With explanation] DP with O(L) time and O(1) space in Python
|
kryuki
| 11 | 729 |
house robber
| 198 | 0.488 |
Medium
| 3,153 |
https://leetcode.com/problems/house-robber/discuss/1605193/With-explanation-DP-with-O(L)-time-and-O(1)-space-in-Python
|
class Solution:
def rob(self, nums: List[int]) -> int:
#edge case
if len(nums) <= 2:
return max(nums)
#dp (less space)
L = len(nums)
a, b = nums[0], max(nums[0], nums[1])
for i in range(2, L):
a, b = b, max(a + nums[i], b)
return b
|
house-robber
|
[With explanation] DP with O(L) time and O(1) space in Python
|
kryuki
| 11 | 729 |
house robber
| 198 | 0.488 |
Medium
| 3,154 |
https://leetcode.com/problems/house-robber/discuss/2818729/Python3-or-Four-lines-w-Explanation!-or-Faster-than-96.97-or-Dynamic-Programming
|
class Solution:
def rob(self, nums: List[int]) -> int:
bag = (0, 0)
for house in nums:
bag = (bag[1], max(bag[0] + house, bag[1]))
return bag[1]
|
house-robber
|
Python3 | Four lines w/ Explanation! | Faster than 96.97% | Dynamic Programming
|
thomwebb
| 6 | 175 |
house robber
| 198 | 0.488 |
Medium
| 3,155 |
https://leetcode.com/problems/house-robber/discuss/1791061/Python-3-(50ms)-or-3-Lines-DP-Formula
|
class Solution:
def rob(self, nums: List[int]) -> int:
last, now = 0, 0
for i in nums: last, now = now, max(last + i, now)
return now
|
house-robber
|
Python 3 (50ms) | 3 Lines DP Formula
|
MrShobhit
| 6 | 435 |
house robber
| 198 | 0.488 |
Medium
| 3,156 |
https://leetcode.com/problems/house-robber/discuss/1579854/Python-or-From-Recursion-to-Top-Down-to-Bottom-Up
|
class Solution:
def rob(self, nums: List[int]) -> int:
if len(nums) <= 2:
return max(nums)
return self.robMax(nums, len(nums) - 1) # start from the last/top
def robMax(self, nums, i):
if i < 0:
return 0 # when i < 0 we just have to return 0
return max(nums[i] + self.robMax(nums, i - 2), self.robMax(nums, i - 1))
|
house-robber
|
Python | From Recursion to Top-Down to Bottom-Up
|
GigaMoksh
| 5 | 337 |
house robber
| 198 | 0.488 |
Medium
| 3,157 |
https://leetcode.com/problems/house-robber/discuss/1579854/Python-or-From-Recursion-to-Top-Down-to-Bottom-Up
|
class Solution:
def rob(self, nums: List[int]) -> int:
if len(nums) <= 2:
return max(nums)
dp = [-1 for _ in range(len(nums))] # cache
return self.robMax(nums, dp, len(nums) - 1)
def robMax(self, nums, dp, i):
if i < 0:
return 0
if dp[i] != -1: # if the value of dp[i] is not default i.e. -1 that means we have already calculated it so we dont have to do it again we just have to return it
return dp[i]
dp[i] = max(nums[i] + self.robMax(nums, dp, i - 2), self.robMax(nums, dp, i - 1))
return dp[i]
|
house-robber
|
Python | From Recursion to Top-Down to Bottom-Up
|
GigaMoksh
| 5 | 337 |
house robber
| 198 | 0.488 |
Medium
| 3,158 |
https://leetcode.com/problems/house-robber/discuss/1579854/Python-or-From-Recursion-to-Top-Down-to-Bottom-Up
|
class Solution:
def rob(self, nums: List[int]) -> int:
if len(nums) <= 2:
return max(nums)
dp = [-1 for _ in range(len(nums))]
dp[0], dp[1] = nums[0], max(nums[0], nums[1]) # the base cases where rob1 is the amount you can take from 1 house and rob2 is the amount you can take from 2 houses (that will be the maximum of nums[0] and nums[1])
for i in range(2, len(nums)):
dp[i] = max(nums[i] + dp[i - 2], dp[i - 1]) # the recurrence relation
return dp[len(nums) - 1] # the last value will be your maximum amount of robbery
|
house-robber
|
Python | From Recursion to Top-Down to Bottom-Up
|
GigaMoksh
| 5 | 337 |
house robber
| 198 | 0.488 |
Medium
| 3,159 |
https://leetcode.com/problems/house-robber/discuss/1579854/Python-or-From-Recursion-to-Top-Down-to-Bottom-Up
|
class Solution:
def rob(self, nums: List[int]) -> int:
if len(nums) <= 2:
return max(nums)
rob1, rob2 = nums[0], max(nums[0], nums[1])
for n in nums[2:]:
temp = max(rob1 + n, rob2) # the max amount we can rob from the given house and from the prev's previous and from the previous house
rob1, rob2 = rob2, temp # update both the variables
return temp # return the max amount
|
house-robber
|
Python | From Recursion to Top-Down to Bottom-Up
|
GigaMoksh
| 5 | 337 |
house robber
| 198 | 0.488 |
Medium
| 3,160 |
https://leetcode.com/problems/house-robber/discuss/733107/Python3-dp-(top-down-and-bottom-up)
|
class Solution:
def rob(self, nums: List[int]) -> int:
@lru_cache(None)
def fn(i):
"""Return the maximum amount of money robbing up to ith house."""
if i < 0: return 0
return max(fn(i-1), fn(i-2) + nums[i])
return fn(len(nums)-1)
|
house-robber
|
[Python3] dp (top-down & bottom-up)
|
ye15
| 5 | 226 |
house robber
| 198 | 0.488 |
Medium
| 3,161 |
https://leetcode.com/problems/house-robber/discuss/733107/Python3-dp-(top-down-and-bottom-up)
|
class Solution:
def rob(self, nums: List[int]) -> int:
f0 = f1 = 0
for x in nums: f0, f1 = f1, max(f1, f0+x)
return f1
|
house-robber
|
[Python3] dp (top-down & bottom-up)
|
ye15
| 5 | 226 |
house robber
| 198 | 0.488 |
Medium
| 3,162 |
https://leetcode.com/problems/house-robber/discuss/1124703/Python3-All-Three-Approaches
|
class Solution:
def rob(self, nums: List[int]) -> int:
length = len(nums)
# Memoization (Top-Down)
memo = [-1] * length
def robFrom(nums, i):
if i == 0:
return nums[0]
if i == 1:
return max(nums[0], nums[1])
if memo[i] != -1:
return memo[i]
memo[i] = max(robFrom(nums, i-2) + nums[i], robFrom(nums, i-1))
return memo[i]
return robFrom(nums, length-1)
# Dynamic Programming (Bottom-Up)
if length == 1:
return nums[0]
if length == 2:
return max(nums[0], nums[1])
dp = [-1] * length
dp[0] = nums[0]
dp[1] = max(nums[0], nums[1])
for i in range(2, length):
dp[i] = max(dp[i-2] + nums[i], dp[i-1])
return dp[length-1]
# Optimized Dynamic Programming
if length == 1:
return nums[0]
if length == 2:
return max(nums[0], nums[1])
robFirst = nums[0]
robSecond = max(nums[0], nums[1])
for i in range(2, length):
current = max(robSecond, robFirst + nums[i])
robFirst = robSecond
robSecond = current
return robSecond
|
house-robber
|
Python3 All Three Approaches
|
doubleimpostor
| 4 | 364 |
house robber
| 198 | 0.488 |
Medium
| 3,163 |
https://leetcode.com/problems/house-robber/discuss/2034783/Pythonor-Easy-few-Lines-Solutionor-T%3AO(N)-S%3AO(1)
|
class Solution:
def rob(self, nums: List[int]) -> int:
rob1, rob2 = 0, 0
for n in nums:
temp = max(n + rob1, rob2)
rob1 = rob2
rob2 = temp
return rob2
|
house-robber
|
Python| Easy few Lines Solution| T:O(N) S:O(1)
|
shikha_pandey
| 3 | 160 |
house robber
| 198 | 0.488 |
Medium
| 3,164 |
https://leetcode.com/problems/house-robber/discuss/1605364/Python3-DYNAMIC-PROGRAMMING-O(1)-Space-Explained
|
class Solution:
def rob(self, nums: List[int]) -> int:
max1, max2 = 0, 0
for n in nums:
max1, max2 = max2, max(max2, max1 + n)
return max2
|
house-robber
|
[Python3] DYNAMIC PROGRAMMING, O(1) Space, Explained
|
artod
| 3 | 138 |
house robber
| 198 | 0.488 |
Medium
| 3,165 |
https://leetcode.com/problems/house-robber/discuss/2779551/Python-solution
|
class Solution:
def rob(self, nums: List[int]) -> int:
if len(nums) <= 2:
return max(nums)
memorize = [0]*len(nums)
memorize[-1] = nums[-1]
memorize[-2] = nums[-2]
for i in range(len(nums)-3, -1, -1):
memorize[i] = max(nums[i], nums[i] + max(memorize[i+2:]))
return max(memorize[0], memorize[1])
|
house-robber
|
🥐🫶🏻 Python solution 🙌🏻
|
ihedzde
| 2 | 188 |
house robber
| 198 | 0.488 |
Medium
| 3,166 |
https://leetcode.com/problems/house-robber/discuss/2172617/Python-DP-and-DFS-or-95-Solution-or-Very-clearly-explained!
|
class Solution:
def rob(self, nums: List[int]) -> int:
n = len(nums)
if n == 1:
return nums[0]
if n == 2:
return max(nums[0], nums[1])
dp = [0] * n
dp[0], dp[1], dp[2] = nums[0], nums[1], nums[2] + nums[0]
for i in range(3, n):
dp[i] = max(dp[i-2], dp[i-3]) + nums[i]
return max(dp[-1], dp[-2])
|
house-robber
|
✅Python DP and DFS | 95% Solution | Very clearly explained!
|
PythonerAlex
| 2 | 159 |
house robber
| 198 | 0.488 |
Medium
| 3,167 |
https://leetcode.com/problems/house-robber/discuss/2172617/Python-DP-and-DFS-or-95-Solution-or-Very-clearly-explained!
|
class Solution:
def rob(self, nums: List[int]) -> int:
n = len(nums)
if n == 1:
return nums[0]
@cache
def dfs(i):
if i < 0:
return 0
return max(dfs(i-2), dfs(i-3)) + nums[i]
return max(dfs(n-1), dfs(n-2))
|
house-robber
|
✅Python DP and DFS | 95% Solution | Very clearly explained!
|
PythonerAlex
| 2 | 159 |
house robber
| 198 | 0.488 |
Medium
| 3,168 |
https://leetcode.com/problems/house-robber/discuss/1766104/Top-Down-or-Bottom-Up-or-2-methods-or-DP
|
class Solution:
def rob(self, nums: List[int]) -> int:
#recursive dp[i] = max(dp[i-1],dp[i-2]+nums[i]])
#base case : dp[0] = nums[0] and dp[1] = max(nums[0],nunms[1])
#then our answer will be the dp[n-1]
#TOP DOWN
def dp(i):
#Base cases
if i==0:
return nums[0]
if i==1:
return max(nums[1],nums[0])
#recursion cases
#wrap inside memo
if i not in memo:
memo[i] = max(dp(i-1),dp(i-2)+nums[i])
#return the final base case
return memo[i]
memo = {}
n = len(nums)
return dp(n-1)
|
house-robber
|
Top Down | Bottom Up | 2 methods | DP
|
ana_2kacer
| 2 | 149 |
house robber
| 198 | 0.488 |
Medium
| 3,169 |
https://leetcode.com/problems/house-robber/discuss/1766104/Top-Down-or-Bottom-Up-or-2-methods-or-DP
|
class Solution:
def rob(self, nums: List[int]) -> int:
#recursive dp[i] = max(dp[i-1],dp[i-2]+nums[i]])
#base case : dp[0] = nums[0] and dp[1] = max(nums[0],nunms[1])
#then our answer will be the dp[n-1]
#BOTTOM DOWN
n = len(nums)
if n==1:
return nums[0]
#Base Case
dp = [0]*(n)
dp[0] = nums[0]
dp[1] = max(nums[1],nums[0])
for i in range(2,n):
dp[i] = max(dp[i-1],dp[i-2]+nums[i])#Recursion statement
return dp[-1]
|
house-robber
|
Top Down | Bottom Up | 2 methods | DP
|
ana_2kacer
| 2 | 149 |
house robber
| 198 | 0.488 |
Medium
| 3,170 |
https://leetcode.com/problems/house-robber/discuss/1606287/Python-oror-Very-Easy-Solution-oror-T.C.-O(n)
|
class Solution:
def rob(self, nums: List[int]) -> int:
inc = nums[0]
exc = 0
for i in range(1, len(nums)):
include = nums[i] + exc
exclude = max(inc, exc)
inc = include
exc = exclude
return max(inc, exc)
|
house-robber
|
Python || Very Easy Solution || T.C. - O(n)
|
naveenrathore
| 2 | 74 |
house robber
| 198 | 0.488 |
Medium
| 3,171 |
https://leetcode.com/problems/house-robber/discuss/387224/Python-Solution-(DP)
|
class Solution:
def rob(self, nums: List[int]) -> int:
if not nums:
return 0
if len(nums) == 1:
return nums[0]
dp = [0]*len(nums)
dp[0] = nums[0]
dp[1] = max(nums[0], nums[1])
for i in range(2,len(nums)):
dp[i] = max(nums[i]+dp[i-2], dp[i-1])
return dp[-1]
|
house-robber
|
Python Solution (DP)
|
FFurus
| 2 | 369 |
house robber
| 198 | 0.488 |
Medium
| 3,172 |
https://leetcode.com/problems/house-robber/discuss/387224/Python-Solution-(DP)
|
class Solution:
def rob(self, nums: List[int]) -> int:
if not nums:
return 0
if len(nums) == 1:
return nums[0]
pre = nums[0]
cur = max(nums[0], nums[1])
for i in range(2,len(nums)):
cur, pre = max(nums[i]+pre, cur), cur
return cur
|
house-robber
|
Python Solution (DP)
|
FFurus
| 2 | 369 |
house robber
| 198 | 0.488 |
Medium
| 3,173 |
https://leetcode.com/problems/house-robber/discuss/2595953/Simple-python-code-with-explanation
|
class Solution:
#two pointers
def rob(self, nums: List[int]) -> int:
nums.insert(0,0)
nums.insert(0,0)
rob1 = 0
rob2 = 1
for i in range(2,len(nums)):
nums[i] = max((nums[i] + nums[rob1]),nums[rob2])
rob1 = rob2
rob2 = i
return nums[-1]
|
house-robber
|
Simple python code with explanation
|
thomanani
| 1 | 132 |
house robber
| 198 | 0.488 |
Medium
| 3,174 |
https://leetcode.com/problems/house-robber/discuss/2476883/Python-solution-very-easy-to-understand-with-explanation%3A)
|
class Solution:
def rob(self, nums: List[int]) -> int:
dp = [0]*(len(nums)+2)
for i in range(len(nums)-1,-1,-1):
dp[i] = max(nums[i]+dp[i+2],dp[i+1])
return dp[0]
|
house-robber
|
Python solution, very easy to understand with explanation:)
|
vilkinshay
| 1 | 43 |
house robber
| 198 | 0.488 |
Medium
| 3,175 |
https://leetcode.com/problems/house-robber/discuss/2344099/Python3-oror-Faster-than-98oror-O(N)-Time-O(1)-Space
|
class Solution:
def rob(self, nums: List[int]) -> int:
if not nums: return 0
if len(nums) == 1: return nums[0]
nonAdjacent = nums[0]
adjacent = max(nums[0], nums[1])
for i in range(2,len(nums)):
curr = max(nums[i] + nonAdjacent, adjacent)
nonAdjacent = adjacent
adjacent = curr
return adjacent
|
house-robber
|
Python3 || Faster than 98%|| O(N) Time, O(1) Space
|
hirosuki
| 1 | 43 |
house robber
| 198 | 0.488 |
Medium
| 3,176 |
https://leetcode.com/problems/house-robber/discuss/2281250/Python-DP-with-full-working-explanation
|
class Solution:
def rob(self, nums: List[int]) -> int: # Time: O(n) and Space: O(1)
rob1, rob2 = 0, 0 # rob1 and rob2 will point to two adjacent positions, starting at house 0 with zero profit
for i in nums:
# rob1 = house0 and rob2 = house0+house1 or rob till house0
# rob1 = house1 and rob2 = house0+house2 or rob till house1
# rob1 = house2 and rob2 = house1+house3 or rob till house2
# rob1 = house3 and rob2 = house2+house4 or rob till house3
rob1, rob2 = rob2, max(rob1 + i, rob2)
return rob2
|
house-robber
|
Python DP with full working explanation
|
DanishKhanbx
| 1 | 46 |
house robber
| 198 | 0.488 |
Medium
| 3,177 |
https://leetcode.com/problems/house-robber/discuss/2099794/dp
|
class Solution:
def rob(self, n) :
@cache
def helper(n): return max(helper(n[:-1]), n[-1]+helper(n[:-2])) if n else 0
return helper(tuple(n))
|
house-robber
|
dp ^^
|
andrii_khlevniuk
| 1 | 77 |
house robber
| 198 | 0.488 |
Medium
| 3,178 |
https://leetcode.com/problems/house-robber/discuss/2099794/dp
|
class Solution:
def rob(self, nn) :
p=out=0
for n in nn : p,out=out,max(p+n, out)
return out
|
house-robber
|
dp ^^
|
andrii_khlevniuk
| 1 | 77 |
house robber
| 198 | 0.488 |
Medium
| 3,179 |
https://leetcode.com/problems/house-robber/discuss/2087271/PYTHON-oror-ITERATIVE-oror-96.8-Faster-93-memory
|
class Solution:
def rob(self, a: List[int]) -> int:
n=len(a)-3
if n>=-1:
a[-2]=max(a[-2],a[-1])
while n>-1:
a[n]=max(a[n+1], a[n]+a[n+2])
a[n+1]=max(a[n+1],a[n+2])
n-=1
return a[0]
|
house-robber
|
PYTHON || ITERATIVE || 96.8% Faster 93% memory
|
karan_8082
| 1 | 65 |
house robber
| 198 | 0.488 |
Medium
| 3,180 |
https://leetcode.com/problems/house-robber/discuss/1978848/Python-oror-O(n)Time-O(1)-Space-oror-In-Depth-Explanation
|
class Solution:
def rob(self, nums: List[int]) -> int:
if len(nums) < 3: return max(nums[0], nums[-1])
nums[2] += nums[0]
for i in range(3, len(nums)):
nums[i] += max(nums[i-2], nums[i-3])
return max(nums[len(nums)-1], nums[len(nums)-2])
|
house-robber
|
Python || O(n)Time O(1) Space || In-Depth Explanation
|
brandonallen
| 1 | 105 |
house robber
| 198 | 0.488 |
Medium
| 3,181 |
https://leetcode.com/problems/house-robber/discuss/1978848/Python-oror-O(n)Time-O(1)-Space-oror-In-Depth-Explanation
|
class Solution:
def rob(self, nums: List[int]) -> int:
if len(nums) > 2: nums[2] += nums[0]
for i in range(3, len(nums)):
nums[i] += max(nums[i-2], nums[i-3])
return max(nums[len(nums)-1], nums[len(nums)-2])
|
house-robber
|
Python || O(n)Time O(1) Space || In-Depth Explanation
|
brandonallen
| 1 | 105 |
house robber
| 198 | 0.488 |
Medium
| 3,182 |
https://leetcode.com/problems/house-robber/discuss/1965103/Python-O(n)
|
class Solution:
def rob(self, nums: List[int]) -> int:
recent_max = remainest_max = 0
for value in nums:
#Multiple assignment or with temporary variable
recent_max, remainest_max = remainest_max + value, max(remainest_max,recent_max)
#temp = remainest_max + value
#remainest_max = max(remainest_max,recent_max)
#recent_max = temp
return max(recent_max,remainest_max)
|
house-robber
|
Python O(n)
|
89anisim89
| 1 | 47 |
house robber
| 198 | 0.488 |
Medium
| 3,183 |
https://leetcode.com/problems/house-robber/discuss/1676623/Python-Dynamic-programming.-Time%3A-O(n)-Space%3A-O(n)-greater-Time%3A-O(n)-Space%3A-O(1)
|
class Solution:
def rob(self, nums: List[int]) -> int:
# How many money we can make we we reach last house
# How many money we can make when we reach i house
# iterate from left to right
# when reach i'th house the money we can make is from
# (First) dp[i-2] which is the maimum value we can make when reach (i-2)'th house plus the curr nums[i]
# (Second) get the money from dp[i-1] which is the maximum value we can make when reach (i-1)'th house. However, we can't add current num[i], since when we take the money from (i-1)'th house, we can not take the adjacent house
# store the maximum between (First) and (Second)
# check the base case dp[0] give nums[0] is ok, However, dp[1] = max(dp[1-1],dp[1-2]+nums[1]), we don't have dp[-1], therefore we give a extra space at the frony.
# dp = [0]*(n+1). Therefore, i in dp correspond to i-1 in nums, That is now the dp[1] = nums[0]
# Method 1
# Time: O(n), Space: O(n)
n = len(nums)
dp = [0]*(n+1)
dp[1] = nums[0]
for i in range(2,n+1):
dp[i] = max(dp[i-1],dp[i-2]+nums[i-1])
return dp[-1]
# Method 2
# Since we only need dp[i-1], dp[i-2]. we can create variable and save space
# Time: O(n), Space: O(1)
first = 0
second = 0
for num in nums:
first, second = second, max(first + num, second)
return second
# Method 3 same as method 2
# Time: O(n), Space: O(1)
first_value = 0
second_value = 0
for num in nums:
temp = max(num + first_value, second_value)
first_value = second_value
second_value = temp
return second_value
|
house-robber
|
[Python] Dynamic programming. Time: O(n), Space: O(n) -> Time: O(n), Space: O(1)
|
JackYeh17
| 1 | 119 |
house robber
| 198 | 0.488 |
Medium
| 3,184 |
https://leetcode.com/problems/house-robber/discuss/1618057/Python-or-Recursion
|
class Solution:
def rob(self, nums: List[int]) -> int:
N = len(nums)
@lru_cache()
def travel(index):
if index >= N:
return 0
robber = nums[index] + travel(index+2)
not_robber = travel(index + 1)
return max(robber, not_robber)
return travel(0)
|
house-robber
|
Python | Recursion
|
Call-Me-AJ
| 1 | 152 |
house robber
| 198 | 0.488 |
Medium
| 3,185 |
https://leetcode.com/problems/house-robber/discuss/1502653/97.26-runtime-easy-to-understand
|
class Solution:
def rob(self, nums: List[int]) -> int:
if len(nums) <= 2: return max(nums)
d = [0]*len(nums)
d[0] = nums[0]
d[1] = max(nums[0], nums[1])
for i in range(2, len(nums)):
d[i] = max(d[i-2]+nums[i], d[i-1])
return d[i]
|
house-robber
|
97.26% runtime, easy to understand
|
siddp6
| 1 | 193 |
house robber
| 198 | 0.488 |
Medium
| 3,186 |
https://leetcode.com/problems/house-robber/discuss/1468662/Python-DP-solution
|
class Solution:
def rob(self, nums: List[int]) -> int:
dp = [0]*len(nums)
dp[0] = nums[0]
if len(nums)>1:
dp[1] = max(nums[0],nums[1])
for i in range(2,len(nums)):
dp[i] = max(nums[i]+dp[i-2],dp[i-1])
return dp[-1]
|
house-robber
|
Python DP solution
|
dhanikshetty
| 1 | 109 |
house robber
| 198 | 0.488 |
Medium
| 3,187 |
https://leetcode.com/problems/house-robber/discuss/1468486/Python-or-DP-or-Memoization-or-With-Comments
|
class Solution:
def rob(self, nums: List[int]) -> int:
dp=nums.copy() #memo table
if len(nums)<3: #if less than 3 numbers are present in array then no need to loop
return max(nums)
dp[1]=max(dp[0],dp[1])
#this loop stores the values in memo table as : highest amount that can be stolen upto that house
for i in range(2,len(nums)):
dp[i]=max(dp[i-2]+nums[i],dp[i-1])
return max(dp)
|
house-robber
|
Python | DP | Memoization | With Comments
|
nmk0462
| 1 | 124 |
house robber
| 198 | 0.488 |
Medium
| 3,188 |
https://leetcode.com/problems/house-robber/discuss/1459749/PyPy3-Solution-using-one-single-for-loop-w-comments
|
class Solution:
def rob(self, nums: List[int]) -> int:
# array is empty
if not len(nums):
return 0
# array length is less or equal to two
if len(nums) <= 2:
return max(nums)
# For all other cases
n = len(nums)
t = dict()
t[0] = nums[0] # Selecting when only one element present
t[1] = max(nums[0],nums[1]) # Selecting when two elements present
# From third element onwards, you iether take addition of
# current value with a value two steps previous to it, or
# you take the value one step previous to it and skip both
# current and value two steps previous to it
for i in range(2,n):
t[i] = max(nums[i] + t[i-2], t[i-1])
# Return the last result
return t[n-1]
|
house-robber
|
[Py/Py3] Solution using one single for loop w/ comments
|
ssshukla26
| 1 | 80 |
house robber
| 198 | 0.488 |
Medium
| 3,189 |
https://leetcode.com/problems/house-robber/discuss/1183568/python-dp-faster-than-90%2B-less-than-90%2B
|
class Solution:
def rob(self, nums: List[int]) -> int:
l = len(nums)
if l == 1: return nums[0]
elif l == 2: return max(nums)
elif l == 3: return max(nums[0] + nums[2], nums[1])
else:
x, y, z = nums[0], max(nums[0:2]), max(nums[0] + nums[2], nums[1])
for i in range(3, l):
#cur = max(max(x, y) + nums[i], z)
x, y, z = y, z, max(max(x, y) + nums[i], z)
return max(y, z)
```
|
house-robber
|
python dp, faster than 90+, less than 90+
|
dustlihy
| 1 | 113 |
house robber
| 198 | 0.488 |
Medium
| 3,190 |
https://leetcode.com/problems/house-robber/discuss/364728/Solution-in-Python-3-(beats-~93)-(three-lines)-(-O(1)-space-)-(-O(n)-time-)
|
class Solution:
def rob(self, n: List[int]) -> int:
a, b, L = 0, 0, len(n)
for i in range(L): b, a = max(a + n[i], b), b
return 0 if L == 0 else max(n) if L <= 2 else b
- Junaid Mansuri
(LeetCode ID)@hotmail.com
|
house-robber
|
Solution in Python 3 (beats ~93%) (three lines) ( O(1) space ) ( O(n) time )
|
junaidmansuri
| 1 | 324 |
house robber
| 198 | 0.488 |
Medium
| 3,191 |
https://leetcode.com/problems/house-robber/discuss/2846897/Python-or-Recursion-or-DP-(BOTH)
|
class Solution:
def rob(self, nums: List[int]) -> int:
def dfs(position):
if position == 1:
return nums[0]
if position == 2:
return nums[1]
return max(dfs(position-1), dfs(position-2)+nums[position-1])
return dfs(len(nums))
|
house-robber
|
Python | Recursion | DP (BOTH)
|
ajay_gc
| 0 | 1 |
house robber
| 198 | 0.488 |
Medium
| 3,192 |
https://leetcode.com/problems/house-robber/discuss/2846897/Python-or-Recursion-or-DP-(BOTH)
|
class Solution:
def rob(self, nums: List[int]) -> int:
n = len(nums)
if n == 1:
return nums[0]
if n == 2:
return max(nums)
dptable = [0]*n
dptable[0] = nums[0]
dptable[1] = max(nums[0], nums[1])
for index in range(2, len(nums)):
print(nums[index])
print(dptable)
dptable[index] = max(dptable[index-1], dptable[index-2]+nums[index])
return max(dptable[-1], dptable[-2])
|
house-robber
|
Python | Recursion | DP (BOTH)
|
ajay_gc
| 0 | 1 |
house robber
| 198 | 0.488 |
Medium
| 3,193 |
https://leetcode.com/problems/house-robber/discuss/2843132/Python-DP
|
class Solution:
def rob(self, nums):
DP0, DP1 = 0, 0
for i in nums:
DP0, DP1 = DP1, max(DP0 + i, DP1)
return DP1
|
house-robber
|
[Python] DP
|
i-hate-covid
| 0 | 2 |
house robber
| 198 | 0.488 |
Medium
| 3,194 |
https://leetcode.com/problems/house-robber/discuss/2837451/Python-Solution
|
class Solution:
def rob(self, nums: List[int]) -> int:
dp = []
for i in range(len(nums)):
if(i >= 2):
dp.append(max(dp[i-2] + nums[i], dp[i-1]))
elif(i >= 1):
dp.append(max(nums[i], dp[i-1]))
else:
dp.append(nums[i])
return dp[-1]
|
house-robber
|
Python Solution
|
charleswizards
| 0 | 4 |
house robber
| 198 | 0.488 |
Medium
| 3,195 |
https://leetcode.com/problems/house-robber/discuss/2829610/Robber-1-DP-Easy-Solution
|
class Solution:
def rob(self, nums: List[int]) -> int:
dp={}
def work(x):
if x<0:
return 0
if x in dp:
return dp[x]
p=nums[x]+work(x-2)
np=0+work(x-1)
dp[x]=max(p,np)
return dp[x]
return work(len(nums)-1)
|
house-robber
|
Robber 1 DP Easy Solution
|
soumya262003
| 0 | 4 |
house robber
| 198 | 0.488 |
Medium
| 3,196 |
https://leetcode.com/problems/house-robber/discuss/2829157/Python-Optimized-Solution-O(n)-Time-O(1)-Space-and-Tabulation-TC-O(n)-Space-(n)
|
class Solution:
def rob(self, nums: List[int]) -> int:
dp = [0]*len(nums)
# picking up the first house
dp[0] = nums[0]
for i in range(1,len(nums)):
pick = nums[i]
if i>1:
# since second has been picked the robber can add the prev2 as he has not robbed previous house
pick+=dp[i-2]
# since second is house is not picked for robbery so the first house is added
not_pick = 0+dp[i-1]
dp[i] = max(pick,not_pick)
return dp[-1]
|
house-robber
|
Python Optimized Solution O(n) Time O(1) Space and Tabulation TC O(n) Space (n)
|
nidhi_nishad26
| 0 | 5 |
house robber
| 198 | 0.488 |
Medium
| 3,197 |
https://leetcode.com/problems/house-robber/discuss/2829157/Python-Optimized-Solution-O(n)-Time-O(1)-Space-and-Tabulation-TC-O(n)-Space-(n)
|
class Solution:
def rob(self, nums: List[int]) -> int:
# rob the first house
prev = nums[0]
# no house from first
prev2 = 0
for i in range(1,len(nums)):
pick = nums[i]
if i>1:
# since second has been picked the robber can add the prev2 as he has not robbed previous house
pick+=prev2
# since second is house is not picked for robbery so the first house is added
not_pick = 0+prev
prev2 = prev
prev = max(pick,not_pick)
return prev
|
house-robber
|
Python Optimized Solution O(n) Time O(1) Space and Tabulation TC O(n) Space (n)
|
nidhi_nishad26
| 0 | 5 |
house robber
| 198 | 0.488 |
Medium
| 3,198 |
https://leetcode.com/problems/house-robber/discuss/2821870/Python-Current-%2B-LastLast-OR-Last.-Rinse-and-Repeat-)
|
class Solution:
def rob(self, nums: List[int]) -> int:
'''
The idea is, given we cannot rob 2 adjacent houses, we care
do we rob current-house + last-last-house
or do we forgo current-house, and take last-house
To make calculations and base cases easier, we can prefix 2 houses
0, 0,[2,7, 9, 3, 1] curr + last-last OR just last
0 0 2 2 + 0 = 2 or 0
0 0 2 7 7 + 0 = 7 or 2
0 0 2 7 11 9 + 2 = 11 or 7
0 0 2 7 11 11 3 + 7 = 10 or 11
0 0 2 7 11 11 12 1 + 11 = 12 or 12
'''
last_last = 0
last = 0
for house in nums:
curr = max(house + last_last, last)
last_last, last = last, curr
return last
|
house-robber
|
[Python] Current + LastLast OR Last. Rinse & Repeat =)
|
graceiscoding
| 0 | 3 |
house robber
| 198 | 0.488 |
Medium
| 3,199 |
Subsets and Splits
Top 2 Solutions by Upvotes
Identifies the top 2 highest upvoted Python solutions for each problem, providing insight into popular approaches.