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/minimum-moves-to-reach-target-score/discuss/1694801/python-simple-recursive-solution | class Solution:
def minMoves(self, target: int, maxDoubles: int) -> int:
@lru_cache(maxsize=1000)
def count(n, doubles):
if n == 1:
return 0
elif doubles == 0:
return n-1
elif n % 2 == 1:
return count(n-1, doubles) + 1
else: # doubles >= 1 and n % 2 == 0
return count(n//2, doubles-1) +1
return count(target, maxDoubles) | minimum-moves-to-reach-target-score | python simple recursive solution | byuns9334 | 0 | 19 | minimum moves to reach target score | 2,139 | 0.484 | Medium | 29,700 |
https://leetcode.com/problems/minimum-moves-to-reach-target-score/discuss/1693736/python3-ez-greedy-solution | class Solution:
def minMoves(self, target: int, maxDoubles: int) -> int:
step = 0
while target > 1:
if maxDoubles == 0:
return target - 1 + step
if target % 2 == 0 and maxDoubles > 0:
target //= 2
maxDoubles -= 1
else:
target -= 1
step += 1
return step | minimum-moves-to-reach-target-score | python3 ez greedy solution | yingziqing123 | 0 | 13 | minimum moves to reach target score | 2,139 | 0.484 | Medium | 29,701 |
https://leetcode.com/problems/minimum-moves-to-reach-target-score/discuss/1693601/Easy-Python-Solution(100) | class Solution:
def minMoves(self, target: int, maxDoubles: int) -> int:
count=0
while maxDoubles:
if target==1:
break
if target%2==0:
target//=2
maxDoubles-=1
count+=1
else:
target-=1
count+=1
count+=target-1
return count | minimum-moves-to-reach-target-score | Easy Python Solution(100%) | Sneh17029 | 0 | 45 | minimum moves to reach target score | 2,139 | 0.484 | Medium | 29,702 |
https://leetcode.com/problems/minimum-moves-to-reach-target-score/discuss/1693505/Python-or-Reduce-target-to-1 | class Solution:
def minMoves(self, target: int, maxDoubles: int) -> int:
ans = 0
while target > 1:
if maxDoubles < 1:
ans += target - 1
break
half = target // 2
ans = ans + 1 + target % 2
maxDoubles = maxDoubles - 1
target = half
return ans | minimum-moves-to-reach-target-score | Python | Reduce target to 1 | AsifIqbal1997 | 0 | 10 | minimum moves to reach target score | 2,139 | 0.484 | Medium | 29,703 |
https://leetcode.com/problems/minimum-moves-to-reach-target-score/discuss/1693295/Python-3-Go-backwards-solution | class Solution:
def minMoves(self, target: int, maxDoubles: int) -> int:
step = 0
while target > 1:
if target % 2 == 0:
if maxDoubles > 0:
target //= 2
maxDoubles -= 1
step += 1
else:
n = target - 1
step += n
break
else:
target -= 1
step += 1
return step | minimum-moves-to-reach-target-score | [Python 3] Go backwards solution | Lanzhou | 0 | 14 | minimum moves to reach target score | 2,139 | 0.484 | Medium | 29,704 |
https://leetcode.com/problems/minimum-moves-to-reach-target-score/discuss/1693291/python3-solution | class Solution:
def minMoves(self, target: int, maxDoubles: int) -> int:
ans=0
while target>1:
if maxDoubles and target%2==0:
ans+=1
maxDoubles-=1
target//=2
elif maxDoubles==0:
return ans+target-1
else:
target-=1
ans+=1
return ans | minimum-moves-to-reach-target-score | python3 solution | shreyasjain0912 | 0 | 10 | minimum moves to reach target score | 2,139 | 0.484 | Medium | 29,705 |
https://leetcode.com/problems/minimum-moves-to-reach-target-score/discuss/1693216/Python3-O(lg-maxDoubles)-greedy-algo.-w-explanation | class Solution:
def minMoves(self, target: int, maxDoubles: int) -> int:
steps = 0
while target != 1:
if maxDoubles == 0:
return steps + target- 1
elif target & 1:
target -= 1
steps += 1
elif maxDoubles:
target = target // 2
steps += 1
maxDoubles -= 1
else:
target -= 1
steps +=1
return steps | minimum-moves-to-reach-target-score | [Python3] O(lg maxDoubles) greedy algo. w/ explanation | dwschrute | 0 | 18 | minimum moves to reach target score | 2,139 | 0.484 | Medium | 29,706 |
https://leetcode.com/problems/minimum-moves-to-reach-target-score/discuss/1693203/Python-3-Solution-Faster-than-100-of-Python-online-submissions-Easy-way | class Solution:
def minMoves(self, target: int, maxDoubles: int) -> int:
step = 0
while target != 1 :
if target % 2 == 1:
if maxDoubles == 0:
step += target -1
target = 1
else:
target -= 1
step +=1
else:
if maxDoubles > 0:
target = target/ 2
step +=1
maxDoubles -=1
else:
step +=1
target -=1
return int(step) | minimum-moves-to-reach-target-score | Python 3 - Solution - Faster than 100% of Python online submissions - Easy way | Cheems_Coder | 0 | 17 | minimum moves to reach target score | 2,139 | 0.484 | Medium | 29,707 |
https://leetcode.com/problems/minimum-moves-to-reach-target-score/discuss/1693200/Python-or-Easy-and-fast-solution | class Solution:
def minMoves(self, target: int, maxDoubles: int) -> int:
if target == 1:
return 0
step = 0
while target:
if target == 2:
step += 1
break
if target % 2:
target -= 1
step += 1
else:
if maxDoubles:
target = target // 2
maxDoubles -= 1
step += 1
else:
step += target - 1
break
return step | minimum-moves-to-reach-target-score | Python | Easy and fast solution | ljinuw | 0 | 14 | minimum moves to reach target score | 2,139 | 0.484 | Medium | 29,708 |
https://leetcode.com/problems/minimum-moves-to-reach-target-score/discuss/1693164/Time-limit-exceeded-how-to-make-it-time-efficient | class Solution:
def minMoves(self, target: int, maxDoubles: int) -> int:
# target = 10
# maxDoubles = 4
steps = 0
if maxDoubles == 0:
return(target-1)
else:
while target!=1 :
if target%2 == 0 and maxDoubles > 0:
target = target/2
steps = steps + 1
maxDoubles = maxDoubles - 1
else:
target = target - 1
steps = steps + 1
# while target!= 1:
# if maxDoubles > 0:
# if target%2 == 0:
# target = target/2
# maxDoubles = maxDoubles - 1
# else:
# target = target -1
# # while maxDoubles!= 0:
# # if target%2 == 0:
# # target = target/2
# # maxDoubles = maxDoubles - 1
# # else:
# # target = target - 1
# steps = steps + 1
return(steps) | minimum-moves-to-reach-target-score | Time limit exceeded , how to make it time efficient? | menlam3 | 0 | 31 | minimum moves to reach target score | 2,139 | 0.484 | Medium | 29,709 |
https://leetcode.com/problems/minimum-moves-to-reach-target-score/discuss/1692970/Python3-Solution-oror-For-beginner-oror-Easy-way | class Solution:
def minMoves(self, target: int, maxDoubles: int) -> int:
step = 0
while target != 1 :
if target % 2 == 1:
if maxDoubles == 0:
step += target -1
target = 1
else:
target -= 1
step +=1
else:
if maxDoubles > 0:
target = target/ 2
step +=1
maxDoubles -=1
else:
step +=1
target -=1
return int(step) | minimum-moves-to-reach-target-score | [Python3] - Solution || For beginner || Easy way | Cheems_Coder | 0 | 21 | minimum moves to reach target score | 2,139 | 0.484 | Medium | 29,710 |
https://leetcode.com/problems/solving-questions-with-brainpower/discuss/1692963/DP | class Solution:
def mostPoints(self, q: List[List[int]]) -> int:
@cache
def dfs(i: int) -> int:
return 0 if i >= len(q) else max(dfs(i + 1), q[i][0] + dfs(i + 1 + q[i][1]))
return dfs(0) | solving-questions-with-brainpower | DP | votrubac | 132 | 5,500 | solving questions with brainpower | 2,140 | 0.46 | Medium | 29,711 |
https://leetcode.com/problems/solving-questions-with-brainpower/discuss/1693569/Simple-DP-%2B-Memoization-Solution-or-Python-or-Beats-100-Time-and-Space | class Solution:
def mostPoints(self, questions: List[List[int]]) -> int:
n = len(questions) # total number of questions
memo = [-1] * n # memo array of size n.
# If memo[i] is not computed then its value must be -1 and we need to find memo[i]
# If memo[i] != -1, this means we have already calculated this and we dont need to recompute it
def rec_func(index, current_val) -> int: # index is the current question number to process and current_val is the max marks upto this question
if index >= n: # It means that we have gone through all the questions thus return the current_val
return current_val
if memo[index] == -1: # memo[i] == -1, not computed before and so we need to solve it
points = questions[index][0] # points for current question
brainpower = questions[index][1] # brainpower for current question
a = rec_func(index + brainpower + 1, points) # Recursive call considering we solve the current question
b = rec_func(index + 1, 0) # Recursive call considering we skip the current question
memo[index] = max(a, b) # choose which ever choice yields us the best result
return current_val+memo[index]
return rec_func(0, 0) | solving-questions-with-brainpower | Simple DP + Memoization Solution | Python | Beats 100% Time and Space | anCoderr | 4 | 111 | solving questions with brainpower | 2,140 | 0.46 | Medium | 29,712 |
https://leetcode.com/problems/solving-questions-with-brainpower/discuss/1692910/Python3-House-Robber-Variation-or-DP-Bottom-Up | class Solution:
def mostPoints(self, questions: List[List[int]]) -> int:
dp = [(0, 0)] * (len(questions) + 1)
for i in range(len(questions) - 1, -1, -1):
score, delay = questions[i]
dp[i] = score + (max(dp[i + delay + 1]) if i + delay + 1 < len(questions) else 0), max(dp[i + 1])
return max(dp[0]) | solving-questions-with-brainpower | ✅ [Python3] House Robber Variation | DP Bottom-Up | PatrickOweijane | 2 | 168 | solving questions with brainpower | 2,140 | 0.46 | Medium | 29,713 |
https://leetcode.com/problems/solving-questions-with-brainpower/discuss/1695208/Python3-Dp-sol-for-reference. | class Solution:
def mostPoints(self, questions: List[List[int]]) -> int:
dp = [0 for _ in range(len(questions)+1)]
for index, value in enumerate(questions):
points, brainpower = value
if brainpower + index + 1 < len(questions):
dp[brainpower+index+1] = max(dp[brainpower+index+1], points+dp[index])
else:
dp[-1] = max(dp[-1], dp[index]+points)
if index + 1 < len(questions):
dp[index+1] = max(dp[index], dp[index+1])
return dp[-1] | solving-questions-with-brainpower | [Python3] Dp sol for reference. | vadhri_venkat | 1 | 41 | solving questions with brainpower | 2,140 | 0.46 | Medium | 29,714 |
https://leetcode.com/problems/solving-questions-with-brainpower/discuss/1694979/Python3Heap-A-different-heap-solution-iterate-from-left-to-right | class Solution:
def mostPoints(self, questions: List[List[int]]) -> int:
n = len(questions)
h = [] # (point, idx)
candi = [] # (idx, point)
for i in range(n):
while candi: # we have candidates
if candi[0][0] < i: # this means the current i bigger than the right bound of the candidate which has the smallest bound
idx, point = heappop(candi)
heappush(h, (point, idx))
else:
break
if h:
point, idx = h[0] # h[0] is the highest points we can get from prevous questions, and we can access
heappush(candi, (i + questions[i][1], point - questions[i][0]))
else:
heappush(candi, (i + questions[i][1], -questions[i][0]))
r1 = -h[0][0] if h else 0
r2 = max([-v[1] for v in candi]) if candi else 0
return max(r1, r2) | solving-questions-with-brainpower | [Python3/Heap] A different heap solution - iterate from left to right | pureme | 1 | 25 | solving questions with brainpower | 2,140 | 0.46 | Medium | 29,715 |
https://leetcode.com/problems/solving-questions-with-brainpower/discuss/1693993/Memoization-soln | class Solution:
def mostPoints(self, questions: List[List[int]]) -> int:
dp=[-1 for i in range(len(questions)+1)]
return self.recur(0,questions,dp)
def recur(self,i,questions,dp):
if i>len(questions)-1:
return 0
if dp[i]!=-1:
return dp[i]
dp[i]=max(questions[i][0]+self.recur(i+questions[i][1]+1,questions,dp),self.recur(i+1,questions,dp))
return dp[i]
``` | solving-questions-with-brainpower | Memoization soln | Adolf988 | 1 | 43 | solving questions with brainpower | 2,140 | 0.46 | Medium | 29,716 |
https://leetcode.com/problems/solving-questions-with-brainpower/discuss/1692942/Python3-dp | class Solution:
def mostPoints(self, questions: List[List[int]]) -> int:
n = len(questions)
dp = [0]*(n+1)
for i in range(n-1, -1, -1):
dp[i] = dp[i+1]
cand = questions[i][0]
if i+questions[i][1]+1 <= n: cand += dp[i+questions[i][1]+1]
dp[i] = max(dp[i], cand)
return dp[0] | solving-questions-with-brainpower | [Python3] dp | ye15 | 1 | 64 | solving questions with brainpower | 2,140 | 0.46 | Medium | 29,717 |
https://leetcode.com/problems/solving-questions-with-brainpower/discuss/2797240/Python-(Simple-Dynamic-Programming) | class Solution:
def mostPoints(self, questions):
n = len(questions)
dp = [0]*(n+1)
for i in range(n-1,-1,-1):
points, jump = questions[i]
dp[i] = max(points + dp[min(i+1+jump,n)],dp[i+1])
return dp[0] | solving-questions-with-brainpower | Python (Simple Dynamic Programming) | rnotappl | 0 | 3 | solving questions with brainpower | 2,140 | 0.46 | Medium | 29,718 |
https://leetcode.com/problems/solving-questions-with-brainpower/discuss/2774506/Python3-Commented-and-Concise-DP-Solution | class Solution:
def mostPoints(self, questions: List[List[int]]) -> int:
# this is a dynamic programming problem
qss = len(questions)
dp = [0]*(qss+1)
# go through the questions, for each question make the two decisions
for idx, (points, brainpower) in enumerate(questions):
# calculate our jumping point (and keep it in bounds)
next_q = min(idx + brainpower + 1, qss)
# update the dp array right next to us
dp[idx+1] = max(dp[idx+1], dp[idx])
# update the dp array of the jumping point
dp[next_q] = max(dp[next_q], points + dp[idx])
return dp[-1] | solving-questions-with-brainpower | [Python3] - Commented and Concise DP Solution | Lucew | 0 | 2 | solving questions with brainpower | 2,140 | 0.46 | Medium | 29,719 |
https://leetcode.com/problems/solving-questions-with-brainpower/discuss/2422983/Python-memoization | class Solution:
def mostPoints(self, questions: List[List[int]]) -> int:
n = len(questions)
lookup ={}
def f(ind, lookup):
if ind == n-1: return questions[n-1][0]
if ind >= n: return 0
if ind in lookup: return lookup[ind]
skip = f(ind + 1, lookup)
solve = questions[ind][0] + f(ind + questions[ind][1] + 1, lookup)
lookup[ind] = max(solve, skip)
return lookup[ind]
return f(0, lookup) | solving-questions-with-brainpower | Python memoization | logeshsrinivasans | 0 | 22 | solving questions with brainpower | 2,140 | 0.46 | Medium | 29,720 |
https://leetcode.com/problems/solving-questions-with-brainpower/discuss/2317655/Python-Solution-or-Recursion-or-DP-or-O(n) | class Solution:
def mostPoints(self, questions: List[List[int]]) -> int:
n=len(questions)
dp=[-1]*(n)
def helper(ind):
if ind==n-1:
return questions[n-1][0]
if ind>=n:
return 0
if dp[ind]!=-1:
return dp[ind]
notTake=helper(ind+1)
take=questions[ind][0] + helper(ind+questions[ind][1]+1)
dp[ind] = max(take, notTake)
return dp[ind]
return helper(0) | solving-questions-with-brainpower | Python Solution | Recursion | DP | O(n) | Siddharth_singh | 0 | 21 | solving questions with brainpower | 2,140 | 0.46 | Medium | 29,721 |
https://leetcode.com/problems/solving-questions-with-brainpower/discuss/2184764/Fast-easy-python-solution-with-recursion-and-memoization | class Solution:
def mostPoints(self, questions: List[List[int]]) -> int:
memo = {}
def dfs(i: int = 0):
if i >= len(questions):
return 0
elif i in memo:
return memo[i]
else:
points, brainpower = questions[i]
a = dfs(i + 1 + brainpower) + points
b = dfs(i+1)
best = max(a, b)
memo[i] = best
return best
return dfs()
``` | solving-questions-with-brainpower | Fast easy python solution with recursion and memoization | user2855PM | 0 | 33 | solving questions with brainpower | 2,140 | 0.46 | Medium | 29,722 |
https://leetcode.com/problems/solving-questions-with-brainpower/discuss/1918455/python-3-oror-recursive-memoization | class Solution:
def mostPoints(self, questions: List[List[int]]) -> int:
dp = {}
def helper(i):
if i >= len(questions):
return 0
if i in dp:
return dp[i]
points, power = questions[i]
dp[i] = max(helper(i + 1), helper(i + 1 + power) + points)
return dp[i]
return helper(0) | solving-questions-with-brainpower | python 3 || recursive memoization | dereky4 | 0 | 48 | solving questions with brainpower | 2,140 | 0.46 | Medium | 29,723 |
https://leetcode.com/problems/solving-questions-with-brainpower/discuss/1825229/python-recursive-to-DP | class Solution:
def mostPoints(self, q: List[List[int]]) -> int:
n = len(q)
def dp(i):
if i >= n:
return 0
return max(q[i][0] + dp(i+q[i][1]+1), dp(i+1))
return dp(0) | solving-questions-with-brainpower | python recursive to DP | abkc1221 | 0 | 36 | solving questions with brainpower | 2,140 | 0.46 | Medium | 29,724 |
https://leetcode.com/problems/solving-questions-with-brainpower/discuss/1825229/python-recursive-to-DP | class Solution:
def mostPoints(self, q: List[List[int]]) -> int:
n = len(q)
@functools.lru_cache(None)
def dp(i):
if i >= n:
return 0
return max(q[i][0] + dp(i+q[i][1]+1), dp(i+1))
return dp(0) | solving-questions-with-brainpower | python recursive to DP | abkc1221 | 0 | 36 | solving questions with brainpower | 2,140 | 0.46 | Medium | 29,725 |
https://leetcode.com/problems/solving-questions-with-brainpower/discuss/1825229/python-recursive-to-DP | class Solution:
def mostPoints(self, q: List[List[int]]) -> int:
n = len(q)
dp = [0]*(n+1)
for i in range(n-1, -1, -1):
dp[i] = max(q[i][0] + dp[min(n, i + q[i][1] + 1)], dp[i+1])
return dp[0] | solving-questions-with-brainpower | python recursive to DP | abkc1221 | 0 | 36 | solving questions with brainpower | 2,140 | 0.46 | Medium | 29,726 |
https://leetcode.com/problems/solving-questions-with-brainpower/discuss/1723015/Easy-Python-Solution | class Solution:
def mostPoints(self, questions: List[List[int]]) -> int:
n=len(questions)
profit=[0]*n
rightmax=[0]*n
profit[-1]=questions[-1][0]
rightmax[-1]=profit[-1]
for i in range(n-1,-1,-1):
profit[i]=questions[i][0]
nextindex=i+questions[i][1]+1
if nextindex<n:
profit[i]+=rightmax[nextindex]
if i!=n-1:
rightmax[i]=max(rightmax[i+1],profit[i])
return rightmax[0] | solving-questions-with-brainpower | Easy Python Solution | Sneh17029 | 0 | 88 | solving questions with brainpower | 2,140 | 0.46 | Medium | 29,727 |
https://leetcode.com/problems/solving-questions-with-brainpower/discuss/1699852/DP-solution-of-python3(hope-it's-good-to-understand) | class Solution:
def mostPoints(self, questions: List[List[int]]) -> int:
#define dp[i] is the most point I can get before land on question i.
n = len(questions)
dp = [0 for _ in range(n+1)]
ans = 0
for i in range(n):
dp[i+1] = max(dp[i+1],dp[i])
if i+questions[i][1]+1<n+1:
dp[i+questions[i][1]+1] = max(dp[i+questions[i][1]+1], questions[i][0]+dp[i])
else:
ans=max(ans,questions[i][0]+dp[i])
return ans
``` | solving-questions-with-brainpower | DP solution of python3(hope it's good to understand) | Jeff871025 | 0 | 33 | solving questions with brainpower | 2,140 | 0.46 | Medium | 29,728 |
https://leetcode.com/problems/solving-questions-with-brainpower/discuss/1694707/Python-3-oror-recursion-%2B-memoization-oror-self-understandable-oror-easy-understanding | class Solution:
def mostPoints(self, questions: List[List[int]]) -> int:
memo={}
def getPoints(index):
if index in memo:
return memo[index]
if index>=len(questions):
return 0
p1=questions[index][0]+getPoints(index+(questions[index][1]+1))
p2=getPoints(index+1)
memo[index]=max(p1,p2)
return memo[index]
return getPoints(0) | solving-questions-with-brainpower | Python 3 || recursion + memoization || self-understandable || easy-understanding | bug_buster | 0 | 20 | solving questions with brainpower | 2,140 | 0.46 | Medium | 29,729 |
https://leetcode.com/problems/solving-questions-with-brainpower/discuss/1694672/Python-DP-solution-with-explanation | class Solution:
def mostPoints(self, questions: List[List[int]]) -> int:
dp = [0 for _ in range(len(questions))] # stores max score if started from that point
dp[-1] = questions[-1][0]
i = len(questions)-2
dp_max = [-1 for _ in range(len(questions))] # stores max seen upto that point in reverse direction
dp_max[-1] = questions[-1][0]
while i >= 0:
dp[i] = questions[i][0]
if i+questions[i][1]+1 < len(questions):
dp[i] += dp_max[i+questions[i][1]+1]
dp_max[i] = max(dp[i], dp_max[i+1])
i -= 1
return max(dp) | solving-questions-with-brainpower | Python DP solution with explanation | 96sayak | 0 | 33 | solving questions with brainpower | 2,140 | 0.46 | Medium | 29,730 |
https://leetcode.com/problems/solving-questions-with-brainpower/discuss/1693834/Python-3-Approaches-or-Brute-Force-To-Optimal-or-Time-and-Space-Complexity. | class Solution:
def mostPoints(self, questions: List[List[int]]) -> int:
def max_points_earned(ind,questions):
if ind>=len(questions):
return 0
left=questions[ind][0]+max_points_earned(ind+questions[ind][1]+1,questions)
right=max_points_earned(ind+1,questions)
return max(left,right)
ind=0
return max_points_earned(ind,questions) | solving-questions-with-brainpower | Python 3 Approaches | Brute Force To Optimal | Time and Space Complexity. | aryanagrawal2310 | 0 | 35 | solving questions with brainpower | 2,140 | 0.46 | Medium | 29,731 |
https://leetcode.com/problems/solving-questions-with-brainpower/discuss/1693834/Python-3-Approaches-or-Brute-Force-To-Optimal-or-Time-and-Space-Complexity. | class Solution:
def mostPoints(self, questions: List[List[int]]) -> int:
def max_points_earned(ind,questions,dp):
if ind>=len(questions):
return 0
if dp[ind]!=-1:
return dp[ind]
left=questions[ind][0]+max_points_earned(ind+questions[ind][1]+1,questions,dp)
right=max_points_earned(ind+1,questions,dp)
dp[ind]=max(left,right)
return dp[ind]
ind=0
n=len(questions)
dp=[-1]*n
return max_points_earned(ind,questions,dp) | solving-questions-with-brainpower | Python 3 Approaches | Brute Force To Optimal | Time and Space Complexity. | aryanagrawal2310 | 0 | 35 | solving questions with brainpower | 2,140 | 0.46 | Medium | 29,732 |
https://leetcode.com/problems/solving-questions-with-brainpower/discuss/1693834/Python-3-Approaches-or-Brute-Force-To-Optimal-or-Time-and-Space-Complexity. | class Solution:
def mostPoints(self, questions: List[List[int]]) -> int:
def max_points_earned(questions):
n=len(questions)
dp=[-1]*n
dp[n-1]=questions[n-1][0]
for i in range(n-2,-1,-1):
first=dp[i+1]
second=questions[i][0]
if (i+questions[i][1])+1<n:
second=questions[i][0]+dp[i+questions[i][1]+1]
dp[i]=max(first,second)
return dp[0]
return max_points_earned(questions) | solving-questions-with-brainpower | Python 3 Approaches | Brute Force To Optimal | Time and Space Complexity. | aryanagrawal2310 | 0 | 35 | solving questions with brainpower | 2,140 | 0.46 | Medium | 29,733 |
https://leetcode.com/problems/solving-questions-with-brainpower/discuss/1693628/DP-with-explanation | class Solution:
def mostPoints(self, questions: List[List[int]]) -> int:
dp = [0 for i in range(len(questions))]
dp[-1] = questions[-1][0]
for i in range(len(questions) - 2, -1, -1):
points, brainpower = questions[i]
toAdd = 0
if i + brainpower + 1 < len(questions):
toAdd = dp[i + brainpower + 1]
dp[i] = max(dp[i + 1], points + toAdd)
# print(dp)
return dp[0] | solving-questions-with-brainpower | DP with explanation | jdot593 | 0 | 21 | solving questions with brainpower | 2,140 | 0.46 | Medium | 29,734 |
https://leetcode.com/problems/solving-questions-with-brainpower/discuss/1693515/Python3-or-DP-%2B-DFS-%2B-Cache | class Solution:
def mostPoints(self, questions: List[List[int]]) -> int:
dp = {}
def dfs(i):
if i >= len(questions):
return 0
if i in dp:
return dp[i]
dp[i] = max( dfs(i+questions[i][1]+1) + questions[i][0], dfs(i+1) )
return dp[i]
dfs(0)
return dp[0] | solving-questions-with-brainpower | Python3 | DP + DFS + Cache | AsifIqbal1997 | 0 | 18 | solving questions with brainpower | 2,140 | 0.46 | Medium | 29,735 |
https://leetcode.com/problems/solving-questions-with-brainpower/discuss/1693487/Python3-Dynamic-Programming | class Solution:
def mostPoints(self, questions: List[List[int]]) -> int:
@cache
def helper(i):
pts, skip = questions[i]
if i+skip+1 < len(questions):
notSkip = pts + helper(i+skip+1)
else:
notSkip = pts
skip = helper(i+1) if i + 1 < len(questions) else 0
return max(notSkip, skip)
maxPoints = 0
for i in range(len(questions)):
maxPoints = max(helper(i),maxPoints)
return maxPoints | solving-questions-with-brainpower | [Python3] Dynamic Programming | Rainyforest | 0 | 14 | solving questions with brainpower | 2,140 | 0.46 | Medium | 29,736 |
https://leetcode.com/problems/solving-questions-with-brainpower/discuss/1693313/Python3-or-DP-or-Simple | class Solution:
def mostPoints(self, questions: List[List[int]]) -> int:
n = len(questions)
matrix = [ 0 for _ in range(n)]
matrix[n-1] = questions[n-1][0]
for i in range(n-2, -1, -1):
points = questions[i][0]
skip = questions[i][1]
max_value = float("-inf")
if i+skip+1 <= n-1:
max_value = max(max_value, points+matrix[i+skip+1])
else:
max_value = max(max_value, points)
max_value = max(max_value, matrix[i+1])
matrix[i] = max_value
return max(matrix) | solving-questions-with-brainpower | Python3 | DP | Simple | letyrodri | 0 | 23 | solving questions with brainpower | 2,140 | 0.46 | Medium | 29,737 |
https://leetcode.com/problems/solving-questions-with-brainpower/discuss/1693147/Python3-13-lines-DP%3A-Top-down-1D-memo-w-explanation | class Solution:
@cache
def dp(self, i):
if i >= self.n:
return 0
return max(
self.dp(i + self.Q[i][1] + 1) + self.Q[i][0],
self.dp(i + 1)
)
def mostPoints(self, questions: List[List[int]]) -> int:
self.n = len(questions)
self.Q = questions
return self.dp(0) | solving-questions-with-brainpower | [Python3] 13 lines DP: Top-down 1D memo w/ explanation | dwschrute | 0 | 36 | solving questions with brainpower | 2,140 | 0.46 | Medium | 29,738 |
https://leetcode.com/problems/solving-questions-with-brainpower/discuss/1692943/Dynamic-Programming-oror-Python | class Solution:
def mostPoints(self, questions: List[List[int]]) -> int:
length = len(questions)
dp = [0]*length
dp[-1] = questions[-1][0];
for i in range(length - 2, -1, - 1):
if (i + questions[i][1] + 1 < length and i + 1 < length):
dp[i] = max(questions[i][0] + dp[i + questions[i][1] + 1], dp[i + 1])
else:
dp[i] = max(questions[i][0], dp[i + 1])
return dp[0] | solving-questions-with-brainpower | Dynamic Programming || Python | siddp6 | 0 | 78 | solving questions with brainpower | 2,140 | 0.46 | Medium | 29,739 |
https://leetcode.com/problems/solving-questions-with-brainpower/discuss/1692926/Python-or-Bottom-Up-Dynamic-Programming-or-O(N)-Time-and-Space | class Solution:
def mostPoints(self, questions: List[List[int]]) -> int:
n = len(questions)
# set dp array
dp = [0]*n
# start from last
dp [-1] = questions[-1][0]
# start setting the rest
for i in reversed(range(n-1)):
points, skip = questions[i]
# dp formula
if i + skip + 1 < n : dp[i] = max(dp[i+1], points + dp[i + skip + 1])
else: dp [i] = max(points, dp[i+1])
return dp[0] | solving-questions-with-brainpower | Python | Bottom Up Dynamic Programming | O(N) Time and Space | rbhandu | 0 | 38 | solving questions with brainpower | 2,140 | 0.46 | Medium | 29,740 |
https://leetcode.com/problems/maximum-running-time-of-n-computers/discuss/1692965/Python3-greedy | class Solution:
def maxRunTime(self, n: int, batteries: List[int]) -> int:
batteries.sort()
extra = sum(batteries[:-n])
batteries = batteries[-n:]
ans = prefix = 0
for i, x in enumerate(batteries):
prefix += x
if i+1 < len(batteries) and batteries[i+1]*(i+1) - prefix > extra: return (prefix + extra) // (i+1)
return (prefix + extra) // n | maximum-running-time-of-n-computers | [Python3] greedy | ye15 | 39 | 1,400 | maximum running time of n computers | 2,141 | 0.389 | Hard | 29,741 |
https://leetcode.com/problems/maximum-running-time-of-n-computers/discuss/1695541/Python3-Not-fancy-simulation-solution.-(make-a-barrel-that-can-hold-most-water-with-planks) | class Solution:
def maxRunTime(self, n: int, batteries: List[int]) -> int:
batteries.sort(reverse=True)
refills = batteries[n:]
s = sum(refills)
res = 0
for i in range(n-1, 0, -1):
cur = batteries[i]
prev = batteries[i-1]
if prev == cur:
continue
smaller_batteries = n-i
need_for_refill = smaller_batteries * (prev-cur)
if need_for_refill <= s:
s -= need_for_refill
else:
return cur + s // smaller_batteries
return batteries[0] + s // n | maximum-running-time-of-n-computers | [Python3] Not-fancy, simulation solution. (make a barrel that can hold most water with planks) | mteng8 | 4 | 88 | maximum running time of n computers | 2,141 | 0.389 | Hard | 29,742 |
https://leetcode.com/problems/maximum-running-time-of-n-computers/discuss/1694815/Python-3-Binary-search-with-comments | class Solution:
def maxRunTime(self, n: int, batteries: List[int]) -> int:
l, h = min(batteries), sum(batteries)
batteries.sort()
cands = batteries[-n:]
rest = sum(batteries[:-n])
def bs(t):
tmp = rest
for x in cands:
# all rest batteries on computer can run more than t time
if x >= t: return True
# need t - x batteries to fill
tmp -= t - x
if tmp < 0: return False
return True
while l < h:
mid = l + (h - l + 1) // 2
if bs(mid):
l = mid
else:
h = mid - 1
return l | maximum-running-time-of-n-computers | [Python 3] Binary search with comments | chestnut890123 | 0 | 61 | maximum running time of n computers | 2,141 | 0.389 | Hard | 29,743 |
https://leetcode.com/problems/minimum-cost-of-buying-candies-with-discount/discuss/1712364/Python-Simple-solution-or-100-faster-or-O(N-logN)-Time-or-O(1)-Space | class Solution:
def minimumCost(self, cost: List[int]) -> int:
cost.sort(reverse=True)
res, i, N = 0, 0, len(cost)
while i < N:
res += sum(cost[i : i + 2])
i += 3
return res | minimum-cost-of-buying-candies-with-discount | [Python] Simple solution | 100% faster | O(N logN) Time | O(1) Space | eshikashah | 9 | 454 | minimum cost of buying candies with discount | 2,144 | 0.609 | Easy | 29,744 |
https://leetcode.com/problems/minimum-cost-of-buying-candies-with-discount/discuss/1709772/Greedy-solution-in-Python-beats-100-(36ms) | class Solution:
def minimumCost(self, cost: List[int]) -> int:
cost.sort(reverse=True)
res, idx, N = 0, 0, len(cost)
while idx < N:
res += sum(cost[idx : idx + 2])
idx += 3
return res | minimum-cost-of-buying-candies-with-discount | Greedy solution in Python, beats 100% (36ms) | kryuki | 6 | 273 | minimum cost of buying candies with discount | 2,144 | 0.609 | Easy | 29,745 |
https://leetcode.com/problems/minimum-cost-of-buying-candies-with-discount/discuss/1709683/Python3-greedy-1-line | class Solution:
def minimumCost(self, cost: List[int]) -> int:
return sum(x for i, x in enumerate(sorted(cost, reverse=True)) if (i+1)%3) | minimum-cost-of-buying-candies-with-discount | [Python3] greedy 1-line | ye15 | 3 | 126 | minimum cost of buying candies with discount | 2,144 | 0.609 | Easy | 29,746 |
https://leetcode.com/problems/minimum-cost-of-buying-candies-with-discount/discuss/1710875/Python3-Sort-%2B-One-Pass-%2B-Greedy-or-O(n)-Time-or-O(1)-Space | class Solution:
def minimumCost(self, cost: List[int]) -> int:
cost.sort(reverse=True)
bought = res = 0
for p in cost:
if bought < 2:
res += p
bought += 1
else:
bought = 0
return res | minimum-cost-of-buying-candies-with-discount | [Python3] Sort + One Pass + Greedy | O(n) Time | O(1) Space | PatrickOweijane | 2 | 85 | minimum cost of buying candies with discount | 2,144 | 0.609 | Easy | 29,747 |
https://leetcode.com/problems/minimum-cost-of-buying-candies-with-discount/discuss/1709673/Python-Solution-using-Heap-or-Sorting | class Solution:
def minimumCost(self, cost: List[int]) -> int:
cost.sort()
cost = cost[::-1]
ans = 0
n = len(cost)
for i in range(n):
if (i+1)%3!=0:
ans += cost[i]
return ans | minimum-cost-of-buying-candies-with-discount | Python Solution using Heap or Sorting | anCoderr | 2 | 66 | minimum cost of buying candies with discount | 2,144 | 0.609 | Easy | 29,748 |
https://leetcode.com/problems/minimum-cost-of-buying-candies-with-discount/discuss/1709673/Python-Solution-using-Heap-or-Sorting | class Solution:
def minimumCost(self, cost: List[int]) -> int:
max_heap = []
for i in cost:
heappush(max_heap, -i) # make max heap with given costs
ans, n = 0, len(cost)
while n > 0:
# take 2 candies out with their costs added to ans
ans += -heappop(max_heap) # - used to negate the -ve sign
n -= 1
if n > 0:
ans += -heappop(max_heap) # - used to negate the -ve sign
n -= 1
# if heap is not empty take 3rd candy out with discount, so costs not added to ans
if n > 0:
heappop(max_heap)
n -= 1
return ans | minimum-cost-of-buying-candies-with-discount | Python Solution using Heap or Sorting | anCoderr | 2 | 66 | minimum cost of buying candies with discount | 2,144 | 0.609 | Easy | 29,749 |
https://leetcode.com/problems/minimum-cost-of-buying-candies-with-discount/discuss/1855077/Python-solution-faster-than-94 | class Solution:
def minimumCost(self, cost: List[int]) -> int:
cost.sort(reverse = True)
hops = 1
min_cost = 0
for i in range(len(cost)):
if hops == 1 or hops == 2:
min_cost += cost[i]
hops += 1
elif hops == 3:
hops = 1
return min_cost | minimum-cost-of-buying-candies-with-discount | Python solution faster than 94% | alishak1999 | 1 | 49 | minimum cost of buying candies with discount | 2,144 | 0.609 | Easy | 29,750 |
https://leetcode.com/problems/minimum-cost-of-buying-candies-with-discount/discuss/2801866/python-sort-and-sum | class Solution:
def minimumCost(self, cost: List[int]) -> int:
desc_sorted_cost = sorted(cost, reverse=True)
num_of_candy = len(desc_sorted_cost)
required_cost = 0
for i in range(num_of_candy):
if i % 3 == 0 or i % 3 == 1:
required_cost += desc_sorted_cost[i]
return required_cost | minimum-cost-of-buying-candies-with-discount | python - sort and sum | prravda | 0 | 6 | minimum cost of buying candies with discount | 2,144 | 0.609 | Easy | 29,751 |
https://leetcode.com/problems/minimum-cost-of-buying-candies-with-discount/discuss/2799747/Python-sorting-buy-and-jump | class Solution:
def minimumCost(self, cost: List[int]) -> int:
cost.sort(reverse=True)
jump = 0
res = 0
cnt = 0
for i in range(len(cost)):
if jump == 1:
jump = 0
cnt = 0
continue
cnt += 1
if cnt == 2:
jump = 1
res += cost[i]
return res | minimum-cost-of-buying-candies-with-discount | Python sorting - buy and jump | pandish | 0 | 1 | minimum cost of buying candies with discount | 2,144 | 0.609 | Easy | 29,752 |
https://leetcode.com/problems/minimum-cost-of-buying-candies-with-discount/discuss/2756254/Pythn3-simple-solution | class Solution:
def minimumCost(self, cost: List[int]) -> int:
cost.sort()
count = 0
i = len(cost)-1
while i >= 0:
count += cost[i]
i -= 1
if i >= 0:
count += cost[i]
i -= 1
i -= 1
return count | minimum-cost-of-buying-candies-with-discount | Pythn3 simple solution | EklavyaJoshi | 0 | 1 | minimum cost of buying candies with discount | 2,144 | 0.609 | Easy | 29,753 |
https://leetcode.com/problems/minimum-cost-of-buying-candies-with-discount/discuss/2753252/Reverse-Sort-and-then-skip-every-third-element | class Solution:
def minimumCost(self, cost: List[int]) -> int:
cost.sort()
k,sums=0,0
for i in range(len(cost)-1,-1,-1):
k+=1
if k%3==0:
continue
else:
sums+=cost[i]
return sums | minimum-cost-of-buying-candies-with-discount | Reverse Sort and then skip every third element | sowmika_chaluvadi | 0 | 2 | minimum cost of buying candies with discount | 2,144 | 0.609 | Easy | 29,754 |
https://leetcode.com/problems/minimum-cost-of-buying-candies-with-discount/discuss/2651190/Simple-Python-Solution-or-Sorting | class Solution:
def minimumCost(self, cost: List[int]) -> int:
cost.sort()
n=len(cost)
if n<=2:
return sum(cost)
i=n-1
ans=0
while i>0:
print(cost[i-1], cost[i])
ans+=cost[i-1]+cost[i]
i-=3
if i==0:
ans+=cost[0]
return ans | minimum-cost-of-buying-candies-with-discount | Simple Python Solution | Sorting | Siddharth_singh | 0 | 2 | minimum cost of buying candies with discount | 2,144 | 0.609 | Easy | 29,755 |
https://leetcode.com/problems/minimum-cost-of-buying-candies-with-discount/discuss/2623179/sorting-approach | class Solution:
def minimumCost(self, cost: List[int]) -> int:
# the goal is to buy the cost of candies for cheap
# sort the array in ascending order
# we can buy the two most expensive
# then take the next most cheap candy (skip)
# we can repeat this process until there's no more candies
# we can keep a accumulative sum as we process
# time O(n^2) space O(1)
cost.sort()
n = len(cost)
count = 0
res = 0
for i in range(n - 1, -1, -1):
if count < 2:
count += 1
res += cost[i]
else:
count = 0
return res | minimum-cost-of-buying-candies-with-discount | sorting approach | andrewnerdimo | 0 | 5 | minimum cost of buying candies with discount | 2,144 | 0.609 | Easy | 29,756 |
https://leetcode.com/problems/minimum-cost-of-buying-candies-with-discount/discuss/2586072/Simple-Python3-Optimal-solution-easy | class Solution:
def minimumCost(self, cost: List[int]) -> int:
total_cost = 0
cost.sort(reverse=True)
for i in range(1,len(cost)+1):
if i%3==0:
continue
total_cost += cost[i-1]
return total_cost | minimum-cost-of-buying-candies-with-discount | Simple Python3 Optimal solution easy | abhisheksanwal745 | 0 | 24 | minimum cost of buying candies with discount | 2,144 | 0.609 | Easy | 29,757 |
https://leetcode.com/problems/minimum-cost-of-buying-candies-with-discount/discuss/1940988/Python-dollarolution-(reverse-sort-and-subtract-every-3rd-element) | class Solution:
def minimumCost(self, cost: List[int]) -> int:
cost = sorted(cost, reverse= True)
s = sum(cost)
for i in range(2,len(cost),3):
s -= cost[i]
return s | minimum-cost-of-buying-candies-with-discount | Python $olution (reverse sort & subtract every 3rd element) | AakRay | 0 | 41 | minimum cost of buying candies with discount | 2,144 | 0.609 | Easy | 29,758 |
https://leetcode.com/problems/minimum-cost-of-buying-candies-with-discount/discuss/1920911/Python-Greedy-Solution-Easy-To-Understand | class Solution:
def minimumCost(self, cost: List[int]) -> int:
if len(cost) < 3:
return sum(cost)
cost.sort()
sm = 0
for i in range(len(cost) - 1, -1, -3):
sm += cost[i]
if i > 0:
sm += cost[i - 1]
return sm | minimum-cost-of-buying-candies-with-discount | Python Greedy Solution Easy To Understand | Hejita | 0 | 41 | minimum cost of buying candies with discount | 2,144 | 0.609 | Easy | 29,759 |
https://leetcode.com/problems/minimum-cost-of-buying-candies-with-discount/discuss/1794202/1-Line-Python-Solution-oror-40-Faster-oror-Memory-less-than-92 | class Solution:
def minimumCost(self, cost: List[int]) -> int:
return sum([sorted(cost)[::-1][i] for i in range(len(cost)) if i%3!=2]) | minimum-cost-of-buying-candies-with-discount | 1-Line Python Solution || 40% Faster || Memory less than 92% | Taha-C | 0 | 50 | minimum cost of buying candies with discount | 2,144 | 0.609 | Easy | 29,760 |
https://leetcode.com/problems/minimum-cost-of-buying-candies-with-discount/discuss/1775190/Python-Solution-or-O(n)-or-92.93-Memory-efficient | class Solution:
def minimumCost(self, cost: List[int]) -> int:
cost = sorted(cost)
i = -1
c = 0
while(i>=(-1*len(cost))): # Reverse Traversal
if i%3 == 0: # Skip every 3rd index
i -= 1
continue
c += cost[i]
i -= 1
return c | minimum-cost-of-buying-candies-with-discount | Python Solution | O(n) | 92.93% Memory efficient | Coding_Tan3 | 0 | 65 | minimum cost of buying candies with discount | 2,144 | 0.609 | Easy | 29,761 |
https://leetcode.com/problems/minimum-cost-of-buying-candies-with-discount/discuss/1762478/Simple-and-Easy-Python-Solution | class Solution:
def minimumCost(self, cost: List[int]) -> int:
if len(cost)<3:
return sum(cost)
cost = sorted(cost,reverse=True)
total=sum(cost)
for i in range(0,len(cost)-2,3):
total-=cost[i+2]
return total | minimum-cost-of-buying-candies-with-discount | Simple and Easy Python Solution | sangam92 | 0 | 26 | minimum cost of buying candies with discount | 2,144 | 0.609 | Easy | 29,762 |
https://leetcode.com/problems/minimum-cost-of-buying-candies-with-discount/discuss/1720579/Python-3-two-line-solution | class Solution:
def minimumCost(self, costs: List[int]) -> int:
costs.sort(reverse=True)
return sum(cost for i, cost in enumerate(costs) if i % 3 != 2) | minimum-cost-of-buying-candies-with-discount | Python 3, two line solution | dereky4 | 0 | 55 | minimum cost of buying candies with discount | 2,144 | 0.609 | Easy | 29,763 |
https://leetcode.com/problems/minimum-cost-of-buying-candies-with-discount/discuss/1710804/Python-using-a-heap-queue | class Solution:
def minimumCost(self, cost: List[int]) -> int:
q = [-v for v in cost]
heapq.heapify(q)
ans = 0
while len(q) >= 3:
ans += heapq.heappop(q)
ans += heapq.heappop(q)
heapq.heappop(q)
return -1 * (ans + sum(q)) | minimum-cost-of-buying-candies-with-discount | Python, using a heap queue | emwalker | 0 | 21 | minimum cost of buying candies with discount | 2,144 | 0.609 | Easy | 29,764 |
https://leetcode.com/problems/minimum-cost-of-buying-candies-with-discount/discuss/1710318/Python-sort | class Solution:
def minimumCost(self, cost: List[int]) -> int:
cost.sort(reverse=True)
return sum(cost) - sum(cost[2::3]) | minimum-cost-of-buying-candies-with-discount | Python, sort | blue_sky5 | 0 | 29 | minimum cost of buying candies with discount | 2,144 | 0.609 | Easy | 29,765 |
https://leetcode.com/problems/minimum-cost-of-buying-candies-with-discount/discuss/1709876/Reversed-and-skipped-every-third-but-still-got-wrong-answer | class Solution:
def minimumCost(self, cost: List[int]) -> int:
l= sorted(cost,reverse=True)
totco = 0
# print(sorted(cost,reverse=True))
if len(cost) < 3:
totco = totco + sum(cost)
else:
free = 3
for i in range(0,len(l)):
if free != 1:
totco = totco + l[i]
free = free - 1
else:
free = free + 1
return(totco) | minimum-cost-of-buying-candies-with-discount | Reversed and skipped every third but still got wrong answer | menlam3 | 0 | 13 | minimum cost of buying candies with discount | 2,144 | 0.609 | Easy | 29,766 |
https://leetcode.com/problems/minimum-cost-of-buying-candies-with-discount/discuss/1709839/Python3-Easy-greedy-algorithm | class Solution:
def minimumCost(self, cost: List[int]) -> int:
cost.sort(reverse=True)
ans = 0
count = 0
for i in range(len(cost)):
if count % 3 == 2:
pass
else:
ans += cost[i]
count += 1
return ans | minimum-cost-of-buying-candies-with-discount | [Python3] Easy greedy algorithm | dwschrute | 0 | 21 | minimum cost of buying candies with discount | 2,144 | 0.609 | Easy | 29,767 |
https://leetcode.com/problems/minimum-cost-of-buying-candies-with-discount/discuss/1709829/python-simple-sort | class Solution:
def minimumCost(self, cost: List[int]) -> int:
cost.sort(reverse=True)
res = sum(cost)
i = 2
while i < len(cost):
res -= cost[i]
i += 3 #skip every 2 elements to eliminate the max possible price
return res | minimum-cost-of-buying-candies-with-discount | python simple sort | abkc1221 | 0 | 27 | minimum cost of buying candies with discount | 2,144 | 0.609 | Easy | 29,768 |
https://leetcode.com/problems/count-the-hidden-sequences/discuss/1714246/Right-Left | class Solution:
def numberOfArrays(self, diff: List[int], lower: int, upper: int) -> int:
diff = list(accumulate(diff, initial = 0))
return max(0, upper - lower - (max(diff) - min(diff)) + 1) | count-the-hidden-sequences | Right - Left | votrubac | 5 | 266 | count the hidden sequences | 2,145 | 0.365 | Medium | 29,769 |
https://leetcode.com/problems/count-the-hidden-sequences/discuss/1709694/Python3-compare-range | class Solution:
def numberOfArrays(self, differences: List[int], lower: int, upper: int) -> int:
prefix = mn = mx = 0
for x in differences:
prefix += x
mn = min(mn, prefix)
mx = max(mx, prefix)
return max(0, (upper-lower) - (mx-mn) + 1) | count-the-hidden-sequences | [Python3] compare range | ye15 | 2 | 68 | count the hidden sequences | 2,145 | 0.365 | Medium | 29,770 |
https://leetcode.com/problems/count-the-hidden-sequences/discuss/2824240/Easiest-possible-solution-with-explaination. | class Solution:
def numberOfArrays(self, differences: List[int], lower: int, upper: int) -> int:
l = lower
r = upper
right = float("-inf")
while l <= r:
mid = l+r>>1
isHidden,condition = self.isHiddenSequence(differences,mid,lower,upper)
if isHidden:
right = mid
l = mid + 1
else:
if condition == "HIGH": r = mid - 1
else: l = mid + 1
l = lower
r = upper
left = float("inf")
while l <= r:
mid = l+r>>1
isHidden,condition = self.isHiddenSequence(differences,mid,lower,upper)
if isHidden:
left = mid
r = mid - 1
else:
if condition == "HIGH": r = mid - 1
else: l = mid + 1
if right == float("-inf") or left == float("inf"): return 0
return right - left + 1
def isHiddenSequence(self,differences,start,lower,upper):
cur_sum = start
for difference in differences:
cur_sum += difference
if cur_sum < lower: return False,"LOW"
if cur_sum > upper: return False,"HIGH"
return True,"PERFECT" | count-the-hidden-sequences | Easiest possible solution with explaination. | shriyansnaik | 0 | 1 | count the hidden sequences | 2,145 | 0.365 | Medium | 29,771 |
https://leetcode.com/problems/count-the-hidden-sequences/discuss/2675107/Python3-Solution-oror-O(N)-Time-and-O(1)-Space-Complexity | class Solution:
def numberOfArrays(self, differences: List[int], lower: int, upper: int) -> int:
prev=0
minVal,maxVal=0,0
#min max initialize
for i in differences:
curr=i+prev
if curr<minVal:
minVal=curr
elif curr>maxVal:
maxVal=curr
prev=curr
if lower-minVal<=upper-maxVal:
return (upper-maxVal)-(lower-minVal)+1
return 0 | count-the-hidden-sequences | Python3 Solution || O(N) Time & O(1) Space Complexity | akshatkhanna37 | 0 | 3 | count the hidden sequences | 2,145 | 0.365 | Medium | 29,772 |
https://leetcode.com/problems/count-the-hidden-sequences/discuss/2201845/Python-Easy-understand-solution | class Solution:
def numberOfArrays(self, differences: List[int], lower: int, upper: int) -> int:
cum_sum = [0]
for diff in differences:
cum_sum.append(cum_sum[-1]+diff)
max_diff = max(cum_sum)-min(cum_sum)
if upper-lower < max_diff:
return 0
return upper-lower-max_diff+1 | count-the-hidden-sequences | Python Easy understand solution | prejudice23 | 0 | 32 | count the hidden sequences | 2,145 | 0.365 | Medium | 29,773 |
https://leetcode.com/problems/count-the-hidden-sequences/discuss/1979873/python-3-oror-prefix-sum-oror-O(n)O(1) | class Solution:
def numberOfArrays(self, differences: List[int], lower: int, upper: int) -> int:
low = high = cur = 0
for diff in differences:
cur += diff
low = min(low, cur)
high = max(high, cur)
return max(0, 1 + upper - lower - (high - low)) | count-the-hidden-sequences | python 3 || prefix sum || O(n)/O(1) | dereky4 | 0 | 87 | count the hidden sequences | 2,145 | 0.365 | Medium | 29,774 |
https://leetcode.com/problems/count-the-hidden-sequences/discuss/1721112/One-pass-75-speed | class Solution:
def numberOfArrays(self, differences: List[int], lower: int, upper: int) -> int:
n = min_n = max_n = 0
for diff in differences:
n += diff
min_n = min(min_n, n)
max_n = max(max_n, n)
upper_start_n = upper - max_n
lower_start_n = lower - min_n
return (upper_start_n - lower_start_n + 1
if upper_start_n >= lower_start_n else 0) | count-the-hidden-sequences | One pass, 75% speed | EvgenySH | 0 | 29 | count the hidden sequences | 2,145 | 0.365 | Medium | 29,775 |
https://leetcode.com/problems/count-the-hidden-sequences/discuss/1709824/Python3-one-pass-straight-forward-solution-O(N) | class Solution:
def numberOfArrays(self, differences: List[int], lower: int, upper: int) -> int:
min_diff_sum, max_diff_sum = 0, 0
cur_diff_sum = 0
for diff in differences:
cur_diff_sum += diff
min_diff_sum = min(min_diff_sum, cur_diff_sum)
max_diff_sum = max(max_diff_sum, cur_diff_sum)
# a0 >= lower - min_diff_sum
a0_lower = lower - min_diff_sum
# a0 <= upper - max_d_s
a0_upper = upper - max_diff_sum
len_range = a0_upper - a0_lower + 1
return max(len_range, 0) | count-the-hidden-sequences | [Python3] one-pass straight forward solution O(N) | dwschrute | 0 | 26 | count the hidden sequences | 2,145 | 0.365 | Medium | 29,776 |
https://leetcode.com/problems/count-the-hidden-sequences/discuss/1709740/Python-prefix-sum | class Solution:
def numberOfArrays(self, d: List[int], l: int, h: int) -> int:
n = len(d)
res = 0
preSum = [d[0]] + [0]*(n-1)
max_d = min_d = d[0]
for i in range(1, n):
preSum[i] = preSum[i-1] + d[i]
min_d = min(min_d, preSum[i])
max_d = max(max_d, preSum[i])
for i in range(l, h+1):
if i + min_d >= l and i + max_d <= h:
res += 1
return res | count-the-hidden-sequences | Python prefix sum | abkc1221 | 0 | 42 | count the hidden sequences | 2,145 | 0.365 | Medium | 29,777 |
https://leetcode.com/problems/count-the-hidden-sequences/discuss/1709669/Python-O(N) | class Solution:
def numberOfArrays(self, differences: List[int], lower: int, upper: int) -> int:
total_sequences = 0
sequence = [lower]
for j in range(len(differences)):
x = sequence[j] + differences[j]
sequence.append(x)
minn, maxx = min(sequence), max(sequence)
if lower <= minn <= upper and lower <= maxx <= upper: total_sequences += 1
for i in range(lower + 1, upper+1):
minn = minn + 1
maxx = maxx + 1
if lower <= minn <= upper and lower <= maxx <= upper: total_sequences += 1
return total_sequences | count-the-hidden-sequences | Python - O(N) | rbhandu | 0 | 53 | count the hidden sequences | 2,145 | 0.365 | Medium | 29,778 |
https://leetcode.com/problems/k-highest-ranked-items-within-a-price-range/discuss/1709702/Python3-bfs | class Solution:
def highestRankedKItems(self, grid: List[List[int]], pricing: List[int], start: List[int], k: int) -> List[List[int]]:
m, n = len(grid), len(grid[0])
ans = []
queue = deque([(0, *start)])
grid[start[0]][start[1]] *= -1
while queue:
x, i, j = queue.popleft()
if pricing[0] <= -grid[i][j] <= pricing[1]: ans.append((x, -grid[i][j], i, j))
for ii, jj in (i-1, j), (i, j-1), (i, j+1), (i+1, j):
if 0 <= ii < m and 0 <= jj < n and grid[ii][jj] > 0:
queue.append((x+1, ii, jj))
grid[ii][jj] *= -1
return [[i, j] for _, _, i, j in sorted(ans)[:k]] | k-highest-ranked-items-within-a-price-range | [Python3] bfs | ye15 | 1 | 32 | k highest ranked items within a price range | 2,146 | 0.412 | Medium | 29,779 |
https://leetcode.com/problems/k-highest-ranked-items-within-a-price-range/discuss/1718454/Using-heap-for-ranking-no-sorting-76-speed | class Solution:
def highestRankedKItems(self, grid: List[List[int]], pricing: List[int], start: List[int], k: int) -> List[List[int]]:
allowed = dict()
for r, row in enumerate(grid):
for c, v in enumerate(row):
if v > 0:
allowed[(r, c)] = v
heap_ans = []
low_price, high_price = pricing
start_r, start_c = start
start_tpl = (start_r, start_c)
distance = 0
if low_price <= allowed[start_tpl] <= high_price:
heappush(heap_ans, (distance, allowed[start_tpl], start_r, start_c))
allowed.pop(start_tpl)
level = [start_tpl]
while len(heap_ans) < k and level:
new_level = []
distance += 1
for r, c in level:
for new_tpl in [(r + 1, c), (r, c + 1), (r - 1, c), (r, c - 1)]:
if new_tpl in allowed:
if low_price <= allowed[new_tpl] <= high_price:
heappush(heap_ans, (distance, allowed[new_tpl],
new_tpl[0], new_tpl[1]))
allowed.pop(new_tpl)
new_level.append(new_tpl)
level = new_level
ans = []
count = 0
while heap_ans and count < k:
_, _, r, c = heappop(heap_ans)
ans.append([r, c])
count += 1
return ans | k-highest-ranked-items-within-a-price-range | Using heap for ranking, no sorting, 76% speed | EvgenySH | 0 | 50 | k highest ranked items within a price range | 2,146 | 0.412 | Medium | 29,780 |
https://leetcode.com/problems/k-highest-ranked-items-within-a-price-range/discuss/1710142/python-bfs-solution | class Solution:
def highestRankedKItems(self, grid: List[List[int]], pricing: List[int], start: List[int], k: int) -> List[List[int]]:
m, n = len(grid), len(grid[0])
row, col = start
seen = set()
seen.add((row, col))
q = collections.deque([(0, grid[row][col], row, col)])
res = []
while q:
dist, cost, row, col = q.popleft()
if pricing[0] <= cost <= pricing[1]:
res += [(dist, cost, row, col)]
for x, y in (row - 1, col), (row + 1, col), (row, col - 1), (row, col + 1):
if 0 <= x <= m-1 and 0 <= y <= n-1 and (x, y) not in seen and grid[x][y] != 0:
q.append((dist + 1, grid[x][y], x, y))
seen.add((x, y))
res.sort()
return [[x, y] for _, _, x, y in res[:k]] | k-highest-ranked-items-within-a-price-range | python bfs solution | abkc1221 | 0 | 43 | k highest ranked items within a price range | 2,146 | 0.412 | Medium | 29,781 |
https://leetcode.com/problems/k-highest-ranked-items-within-a-price-range/discuss/1709795/Python3-iterative-BFS-%2B-sorting-with-explanation | class Solution:
def highestRankedKItems(self, grid: List[List[int]], pricing: List[int], start: List[int], k: int) -> List[List[int]]:
q = deque([tuple(start)])
m, n = len(grid), len(grid[0])
lower, upper = pricing[0], pricing[1]
ranked_arr = []
visited = {tuple(start)}
adj = [(-1, 0), (0, -1), (0, 1), (1, 0)]
while q:
next_q = []
for _ in range(len(q)):
cur = q.popleft()
x, y = cur
if lower <= grid[x][y] <= upper:
ranked_arr.append(list(cur))
for dx, dy in adj:
if ((x + dx, y + dy) in visited or
not (0 <= x + dx < m and 0 <= y + dy < n) or
grid[x + dx][y + dy] == 0
):
continue
next_q.append((x + dx, y + dy))
visited.add((x + dx, y + dy))
next_q.sort(key=lambda xy: xy[1])
next_q.sort(key=lambda xy: xy[0])
next_q.sort(key=lambda xy: grid[xy[0]][xy[1]])
q = deque(next_q)
return ranked_arr[:k] | k-highest-ranked-items-within-a-price-range | [Python3] iterative BFS + sorting - with explanation | dwschrute | 0 | 31 | k highest ranked items within a price range | 2,146 | 0.412 | Medium | 29,782 |
https://leetcode.com/problems/number-of-ways-to-divide-a-long-corridor/discuss/1709706/simple-Python-solution-(time%3A-O(N)-space%3A-O(1)) | class Solution:
def numberOfWays(self, corridor: str) -> int:
#edge case
num_S = corridor.count('S')
if num_S == 0 or num_S % 2 == 1:
return 0
mod = 10 ** 9 + 7
curr_s = 0
divide_spots = []
for char in corridor:
curr_s += (char == 'S')
if curr_s > 0 and curr_s % 2 == 0:
divide_spots[-1] += 1
else:
if not divide_spots or divide_spots[-1] > 0:
divide_spots.append(0)
res = 1
for num in divide_spots[:-1]:
res = res * num % mod
return res | number-of-ways-to-divide-a-long-corridor | simple Python solution (time: O(N), space: O(1)) | kryuki | 2 | 92 | number of ways to divide a long corridor | 2,147 | 0.399 | Hard | 29,783 |
https://leetcode.com/problems/number-of-ways-to-divide-a-long-corridor/discuss/1709706/simple-Python-solution-(time%3A-O(N)-space%3A-O(1)) | class Solution:
def numberOfWays(self, corridor: str) -> int:
#edge case
num_S = corridor.count('S')
if num_S == 0 or num_S % 2 == 1:
return 0
mod = 10 ** 9 + 7
curr_s = 0
res = 1
spots = 0
for char in corridor:
curr_s += (char == 'S')
if curr_s > 0 and curr_s % 2 == 0:
spots += 1
else:
if spots != 0:
res = res * spots % mod
spots = 0
return res | number-of-ways-to-divide-a-long-corridor | simple Python solution (time: O(N), space: O(1)) | kryuki | 2 | 92 | number of ways to divide a long corridor | 2,147 | 0.399 | Hard | 29,784 |
https://leetcode.com/problems/number-of-ways-to-divide-a-long-corridor/discuss/1710028/Easy-python-O(n)-time-and-O(n)-space-complexity-with-explanation | class Solution:
def numberOfWays(self, corridor: str) -> int:
seat_idx = list()
for i in range(len(corridor)):
if corridor[i] == 'S':
seat_idx.append(i)
if len(seat_idx) == 0 or len(seat_idx) % 2:
# if there are 0 or odd number of seats, we cannot divide sections with 2 seats each
return 0
ways = 1
for i in range(2, len(seat_idx)-1, 2): # ignore first and last seat
ways *= seat_idx[i] - seat_idx[i-1]
return ways % (10**9 + 7) | number-of-ways-to-divide-a-long-corridor | Easy python O(n) time and O(n) space complexity with explanation | himanshushah808 | 1 | 26 | number of ways to divide a long corridor | 2,147 | 0.399 | Hard | 29,785 |
https://leetcode.com/problems/number-of-ways-to-divide-a-long-corridor/discuss/1709713/Python3-multiplication | class Solution:
def numberOfWays(self, corridor: str) -> int:
ans = 1
seats = ii = 0
for i, x in enumerate(corridor):
if x == 'S':
if seats and seats % 2 == 0: ans = ans * (i-ii) % 1_000_000_007
seats += 1
ii = i
return ans if seats and seats % 2 == 0 else 0 | number-of-ways-to-divide-a-long-corridor | [Python3] multiplication | ye15 | 1 | 37 | number of ways to divide a long corridor | 2,147 | 0.399 | Hard | 29,786 |
https://leetcode.com/problems/number-of-ways-to-divide-a-long-corridor/discuss/2774207/Python3-Commented-Single-Pass-Solution | class Solution:
def numberOfWays(self, corridor: str) -> int:
# go through the corridor and count seats
# after that check whether there are plants
# and we have several places to divide
# go through the chairs and count
chairs = 0
positions = 1
plants = 1
for idx, element in enumerate(corridor):
# check if we reached two chairs
if chairs > 0 and chairs % 2 == 0:
# check if current element is plant
if element == 'S':
positions *= plants
plants = 1
elif element == 'P':
plants += 1
# count the chairs
if element == 'S':
chairs += 1
return (positions % 1_000_000_007) if chairs > 0 and chairs % 2 == 0 else 0 | number-of-ways-to-divide-a-long-corridor | [Python3] - Commented Single Pass Solution | Lucew | 0 | 1 | number of ways to divide a long corridor | 2,147 | 0.399 | Hard | 29,787 |
https://leetcode.com/problems/number-of-ways-to-divide-a-long-corridor/discuss/2666017/Python3-Indicies-Combinatorial | class Solution:
def numberOfWays(self, A: str) -> int:
# edge cases
count = Counter(A)
if count["S"] % 2 != 0:
return 0
if count["S"] == 0:
return 0
if count["S"] == 2:
return 1
# count chairs by twos, between which there must be put a divider
# if there are n plants between two pairs, there are n + 1 options
# for where to put the divider
# multiply these options to get the final count
chairlocs = [i for i, val in enumerate(A) if val == "S"]
pairdists = [chairlocs[i] - chairlocs[i-1] for i in range(2, len(chairlocs), 2)]
return reduce((lambda x, y: (x * y) % (10 ** 9 + 7)), pairdists) | number-of-ways-to-divide-a-long-corridor | Python3 Indicies Combinatorial | jbradleyglenn | 0 | 3 | number of ways to divide a long corridor | 2,147 | 0.399 | Hard | 29,788 |
https://leetcode.com/problems/number-of-ways-to-divide-a-long-corridor/discuss/2476121/python-3-or-simple-O(n)O(1) | class Solution:
M = 10 ** 9 + 7
def numberOfWays(self, corridor: str) -> int:
prevSeat = corridor.find('S')
divide = False
res = 1
for i in range(prevSeat + 1, len(corridor)):
if corridor[i] == 'P':
continue
if divide:
res = (res * (i - prevSeat)) % Solution.M
prevSeat = i
divide = not divide
return res if divide else 0 | number-of-ways-to-divide-a-long-corridor | python 3 | simple O(n)/O(1) | dereky4 | 0 | 16 | number of ways to divide a long corridor | 2,147 | 0.399 | Hard | 29,789 |
https://leetcode.com/problems/number-of-ways-to-divide-a-long-corridor/discuss/1731884/Linear-solution-83-speed | class Solution:
def numberOfWays(self, corridor: str) -> int:
seat_idx = [i for i, c in enumerate(corridor) if c == "S"]
len_seat_idx = len(seat_idx)
if not len_seat_idx % 2 and len_seat_idx > 1:
ans = 1
for i, idx in enumerate(seat_idx):
if i > 0 and not i % 2:
ans *= (idx - seat_idx[i - 1])
return ans % 1_000_000_007
return 0 | number-of-ways-to-divide-a-long-corridor | Linear solution, 83% speed | EvgenySH | 0 | 49 | number of ways to divide a long corridor | 2,147 | 0.399 | Hard | 29,790 |
https://leetcode.com/problems/number-of-ways-to-divide-a-long-corridor/discuss/1710512/Python-3-Just-do-it! | class Solution:
def numberOfWays(self, corridor: str) -> int:
loc = []
seats = 0
# keep track of the start and end position of two seat cluster
for i, x in enumerate(corridor):
if x == 'S':
seats += 1
if seats % 2:
loc.append([i])
else:
loc[-1] += [i]
# corner case (no seats or odd number seats)
if not loc or len(loc[-1]) < 2: return 0
M = 10 ** 9 + 7
ans = 1
for i in range(1, len(loc)):
ans *= loc[i][0] - loc[i-1][1]
ans %= M
return ans | number-of-ways-to-divide-a-long-corridor | [Python 3] Just do it! | chestnut890123 | 0 | 23 | number of ways to divide a long corridor | 2,147 | 0.399 | Hard | 29,791 |
https://leetcode.com/problems/number-of-ways-to-divide-a-long-corridor/discuss/1710030/Simple-Python-solution | class Solution:
def numberOfWays(self, corridor: str) -> int:
n = len(corridor)
if n==1:
return 0
d = defaultdict(int)
numS = 0
for i in range(n):
if (numS==0 or numS%2==1) and corridor[i]=='P':
continue
if corridor[i]=='P':
d[numS//2] += 1
else:
numS += 1
if numS==0 or numS%2:
return 0
if corridor[-1]=='P':
d[numS//2] = 0
ret = 1
for v in d.values():
ret *= (v+1)
return ret%(10**9+7) | number-of-ways-to-divide-a-long-corridor | Simple Python solution | 1579901970cg | 0 | 16 | number of ways to divide a long corridor | 2,147 | 0.399 | Hard | 29,792 |
https://leetcode.com/problems/count-elements-with-strictly-smaller-and-greater-elements/discuss/2507825/Very-very-easy-code-in-just-3-lines-using-Python | class Solution:
def countElements(self, nums: List[int]) -> int:
res = 0
mn = min(nums)
mx = max(nums)
for i in nums:
if i > mn and i < mx:
res += 1
return res | count-elements-with-strictly-smaller-and-greater-elements | Very very easy code in just 3 lines using Python | ankurbhambri | 7 | 44 | count elements with strictly smaller and greater elements | 2,148 | 0.6 | Easy | 29,793 |
https://leetcode.com/problems/count-elements-with-strictly-smaller-and-greater-elements/discuss/1711447/Easy-Python-Solution(100) | class Solution:
def countElements(self, nums: List[int]) -> int:
mi=min(nums)
ma=max(nums)
c=0
for i in range(len(nums)):
if nums[i]>mi and nums[i]<ma:
c+=1
return c | count-elements-with-strictly-smaller-and-greater-elements | Easy Python Solution(100%) | Sneh17029 | 3 | 116 | count elements with strictly smaller and greater elements | 2,148 | 0.6 | Easy | 29,794 |
https://leetcode.com/problems/count-elements-with-strictly-smaller-and-greater-elements/discuss/1711239/Python-Solution-Using-Sorting-and-Counter | class Solution:
def countElements(self, nums: List[int]) -> int:
nums.sort()
freq_table = Counter(nums)
arr = list(freq_table.keys())
arr.sort()
ans = len(nums)
ans -= freq_table[arr[0]]
ans -= freq_table[arr[-1]]
return max(ans,0) | count-elements-with-strictly-smaller-and-greater-elements | Python Solution Using Sorting and Counter | anCoderr | 3 | 58 | count elements with strictly smaller and greater elements | 2,148 | 0.6 | Easy | 29,795 |
https://leetcode.com/problems/count-elements-with-strictly-smaller-and-greater-elements/discuss/2372110/Very-easy-Python | class Solution:
def countElements(self, nums: List[int]) -> int:
min_=min(nums)
max_=max(nums)
c=0
for i in nums:
if min_<i<max_:
c+=1
return c | count-elements-with-strictly-smaller-and-greater-elements | Very easy [Python] | sunakshi132 | 1 | 17 | count elements with strictly smaller and greater elements | 2,148 | 0.6 | Easy | 29,796 |
https://leetcode.com/problems/count-elements-with-strictly-smaller-and-greater-elements/discuss/1818673/1-Line-Python-Solution-oror-Memory-less-than-99 | class Solution:
def countElements(self, nums: List[int]) -> int:
return len([num for num in nums if num not in {min(nums),max(nums)}]) | count-elements-with-strictly-smaller-and-greater-elements | 1-Line Python Solution || Memory less than 99% | Taha-C | 1 | 41 | count elements with strictly smaller and greater elements | 2,148 | 0.6 | Easy | 29,797 |
https://leetcode.com/problems/count-elements-with-strictly-smaller-and-greater-elements/discuss/1715168/Python-oror-Easy-oror-100-faster-oror-2-lines-oror-Simple-Method | class Solution:
def countElements(self, nums: List[int]) -> int:
count=len(nums)-nums.count(max(nums))-nums.count(min(nums))
return max(count,0) | count-elements-with-strictly-smaller-and-greater-elements | Python || Easy || 100% faster || 2 lines || Simple Method | rushi_javiya | 1 | 27 | count elements with strictly smaller and greater elements | 2,148 | 0.6 | Easy | 29,798 |
https://leetcode.com/problems/count-elements-with-strictly-smaller-and-greater-elements/discuss/1712661/!-min-and-!max | class Solution:
def countElements(self, nums: List[int]) -> int:
mn = min(nums)
mx = max(nums)
res = 0
for i in nums:
if i!=mn and i!=mx:
res += 1
return res | count-elements-with-strictly-smaller-and-greater-elements | != min and !=max | lokeshsenthilkumar | 1 | 22 | count elements with strictly smaller and greater elements | 2,148 | 0.6 | Easy | 29,799 |
Subsets and Splits