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/best-time-to-buy-and-sell-stock/discuss/2692912/Python-2-Easy-Way-To-Solve-or-95-Faster-or-Fast-and-Simple-Solution | class Solution:
def maxProfit(self, prices: List[int]) -> int:
left = 0
right = 1
maxProfit = 0
while right < len(prices):
currProfit = prices[right] - prices[left]
if prices[left] < prices[right]:
maxProfit = max(currProfit, maxProfit)
else:
left = right
right+=1
return maxProfit | best-time-to-buy-and-sell-stock | ✔️ Python 2 Easy Way To Solve | 95% Faster | Fast and Simple Solution | pniraj657 | 4 | 538 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,200 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/1645300/PYTHON-Simple-One-Pass-O(n)-solution-beats-98.66-explained | class Solution:
def maxProfit(self, prices: List[int]) -> int:
maxProfit = 0
for i in range(len(prices) - 1):
for j in range(i + 1, len(prices)):
temp = prices[j] - prices[i]
if temp > maxProfit:
maxProfit = temp
return maxProfit
# O(n^2) time
# O(1) space | best-time-to-buy-and-sell-stock | [PYTHON] Simple One Pass O(n) solution, beats 98.66%, explained | mateoruiz5171 | 4 | 607 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,201 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/695515/Python3-dp | class Solution:
def maxProfit(self, prices: List[int]) -> int:
buy, sell = inf, 0
for x in prices:
buy = min(buy, x)
sell = max(sell, x - buy)
return sell | best-time-to-buy-and-sell-stock | [Python3] dp | ye15 | 4 | 389 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,202 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/695515/Python3-dp | class Solution:
def maxProfit(self, prices: List[int]) -> int:
ans = most = 0
for i in range(1, len(prices)):
most = max(0, most + prices[i] - prices[i-1])
ans = max(ans, most)
return ans | best-time-to-buy-and-sell-stock | [Python3] dp | ye15 | 4 | 389 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,203 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/2367463/O(n)timeBEATS-99.97-MEMORYSPEED-0ms-AUG-2022 | class Solution:
def maxProfit(self,prices):
left = 0 #Buy
right = 1 #Sell
max_profit = 0
while right < len(prices):
currentProfit = prices[right] - prices[left] #our current Profit
if prices[left] < prices[right]:
max_profit =max(currentProfit,max_profit)
else:
left = right
right += 1
return max_profit | best-time-to-buy-and-sell-stock | O(n)time/BEATS 99.97% MEMORY/SPEED 0ms AUG 2022 | cucerdariancatalin | 3 | 383 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,204 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/2193558/Python-Fastest-easy-Solution | class Solution:
def maxProfit(self, prices: List[int]) -> int:
min_p = float('inf')
max_p = float('-inf')
profit = set()
for p in prices:
if p > max_p:
max_p = p
print("222 :",max_p)
if p < min_p:
min_p = p
max_p = min_p
profit.add(max_p-min_p)
return max(profit) | best-time-to-buy-and-sell-stock | Python Fastest easy Solution | vaibhav0077 | 3 | 163 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,205 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/2135452/Python-Easy-Solution-Time-Comp-O(N) | class Solution:
def maxProfit(self, prices: List[int]) -> int:
maxprofit=0
curprice = prices[0]
for i in range(1,len(prices)):
maxprofit=max(maxprofit, prices[i]-curprice)
curprice=min(curprice, prices[i])
return maxprofit | best-time-to-buy-and-sell-stock | Python Easy Solution - Time Comp O(N) | pruthashouche | 3 | 260 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,206 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/1698905/Python3-oror-easy-to-understand | class Solution:
def maxProfit(self, prices: List[int]) -> int:
mn, mx = float('inf'), 0
for i in range(len(prices)):
mn = min(prices[i], mn)
mx = max(mx, prices[i] - mn)
return mx | best-time-to-buy-and-sell-stock | Python3 || easy to understand | Anilchouhan181 | 3 | 431 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,207 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/1657293/Python-canonical-solution.-Complexity%3A-O(N)O(1) | class Solution:
def maxProfit(self, prices: List[int]) -> int:
min_ = prices[0]
max_profit = 0
for p in prices:
min_ = min(p, min_)
max_profit = max(p - min_, max_profit)
return max_profit | best-time-to-buy-and-sell-stock | Python canonical solution. Complexity: O(N)/O(1) | blue_sky5 | 3 | 242 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,208 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/1601029/Python-solution-with-easy-explanation-for-each-line-of-code | class Solution:
def maxProfit(self, prices: List[int]) -> int:
# 1.Initially the lowest price would be the first price in the given array
lowest_price = prices[0] # Accessing the first element from the given array "prices"
# And Profit would be Zero
profit = 0
# Now As we've accessed the first element from the given array we'll loop from the 2nd element upto the last last element in the array
for i in range(1,len(prices)): # looping from 2nd element upto the last element in the given array
# Check if the current price is smaller than the lowest_price
if prices[i] < lowest_price:
#If yes then make the current price as the lowest price since is the new lowest price in the given array
lowest_price = prices[i]
else: # If not then check if it maximizes the profit
profit = max(profit, prices[i] - lowest_price # compares both the values i.e profit and difference between prices[i] and lowest_price within the parenthesis and returns the maximum value
return profit #returns the profits | best-time-to-buy-and-sell-stock | Python solution with easy explanation for each line of code | pawelborkar | 3 | 387 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,209 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/946817/python3 | class Solution:
def maxProfit(self, prices: List[int]) -> int:
num_days = len(prices)
output = 0
min_price = sys.maxsize
for i in range(num_days):
if prices[i] < min_price:
min_price = prices[i]
output = max(output, prices[i] - min_price)
return output | best-time-to-buy-and-sell-stock | python3 | siyu14 | 3 | 227 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,210 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/366702/Python-linear-solution | class Solution:
def maxProfit(self, prices: List[int]) -> int:
max_profit, cur_min = 0, float('inf')
for price in prices:
cur_min = min(price, cur_min)
max_profit = max(price - cur_min, max_profit)
return max_profit | best-time-to-buy-and-sell-stock | Python linear solution | amchoukir | 3 | 577 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,211 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/2618291/SIMPLE-PYTHON3-SOLUTION-easy-to-understand-with-lineartime | class Solution:
def maxProfit(self, prices: List[int]) -> int:
maxpro = 0
n = len(prices)
minprice = prices[0]
for i in range(n):
minprice = min(minprice,prices[i])
maxpro = max(maxpro,prices[i] - minprice)
return maxpro | best-time-to-buy-and-sell-stock | ✅✔ SIMPLE PYTHON3 SOLUTION ✅✔ easy to understand with lineartime | rajukommula | 2 | 125 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,212 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/2424244/Python-simple-GRAPHICAL-explanation-or-Easy-to-understand-or-Beginners | class Solution:
def maxProfit(self, prices: List[int]) -> int:
# Step 1
low_buy = 100000 # set a very high value
high_sell = 0
#Step 2
for i in range(len(prices)):
# Step 2.1
if prices[i] < low_buy:
low_buy = prices[i]
# Step 2.2
if (prices[i] - low_buy) > high_sell:
high_sell = prices[i] - low_buy
return high_sell | best-time-to-buy-and-sell-stock | Python simple GRAPHICAL explanation | Easy to understand | Beginners | harishmanjunatheswaran | 2 | 71 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,213 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/2351965/Python-Efficient-Solution-Nice-Naming-Convention-oror-Documented | class Solution:
def maxProfit(self, prices: List[int]) -> int:
buyPrice = prices[0] # buy price at day 0
maxProfit = 0 # profit = 0, we have not sold yet.. :)
# find the sell price when have max profit: start from day 1 to last
for price in prices[1:]:
# price increased, calculate profit, if more than previous one, update it
if price > buyPrice:
maxProfit = max(maxProfit, price - buyPrice)
else:
buyPrice = price # price is dropped, set buyPrice to it
return maxProfit | best-time-to-buy-and-sell-stock | [Python] Efficient Solution Nice Naming Convention || Documented | Buntynara | 2 | 86 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,214 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/2341106/Faster-Than-99.70-or-Python-Solution | class Solution:
def maxProfit(self, prices: List[int]) -> int:
minprice = 9999999999
maxprofit = 0
for i in range(len(prices)):
if prices[i] < minprice:
minprice = prices[i]
elif (prices[i] - minprice > maxprofit):
maxprofit = prices[i] - minprice
return maxprofit | best-time-to-buy-and-sell-stock | Faster Than 99.70% | Python Solution | zip_demons | 2 | 309 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,215 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/2279038/Easy-python3-using-two-pointers | class Solution:
def maxProfit(self, prices: List[int]) -> int:
l,r = 0, 1
maxP = 0
while r < len(prices):
if prices[l] < prices[r]:
profit = prices[r] - prices[l]
maxP = max(maxP, profit)
else:
l = r
r += 1
return maxP | best-time-to-buy-and-sell-stock | Easy python3 using two pointers | __Simamina__ | 2 | 144 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,216 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/2238937/Python-Sliding-Window-Time-O(N)-or-Space-O(1)-Explained | class Solution:
def maxProfit(self, prices: List[int]) -> int:
maxProfit = 0
windowStart = 0
for windowEnd in range(len(prices)):
buyPrice = prices[windowStart]
sellPrice = prices[windowEnd]
if buyPrice > sellPrice:
windowStart = windowEnd
maxProfit = max(maxProfit, sellPrice - buyPrice)
return maxProfit | best-time-to-buy-and-sell-stock | [Python] Sliding Window - Time O(N) | Space O(1) Explained | Symbolistic | 2 | 148 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,217 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/2219558/Faster-than-96.49-of-Python3-online-submissions | class Solution:
def maxProfit(self, prices: List[int]) -> int:
n=len(prices)
max_profit=0
buy=prices[0]
for sell in range(1,n):
profit=prices[sell]-buy
max_profit=max(max_profit,profit)
buy=min(buy,prices[sell])
return max_profit | best-time-to-buy-and-sell-stock | Faster than 96.49% of Python3 online submissions | Khan_Baba | 2 | 30 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,218 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/2174124/Kadane's-Algorithm%3A-Python-Solution | class Solution:
def maxProfit(self, prices: List[int]) -> int:
maxCur = maxSoFar = 0
for i in range(1, len(prices)):
maxCur = max(0, maxCur + prices[i] - prices[i-1])
maxSoFar = max(maxCur, maxSoFar)
return maxSoFar | best-time-to-buy-and-sell-stock | Kadane's Algorithm: Python Solution | kanchitank | 2 | 227 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,219 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/1956412/Python3-Top-Down-Recursion-Memoization | class Solution:
def maxProfit(self, prices: List[int]) -> int:
@lru_cache(None)
def rec(i, k, f):
if k == 0 or i == len(prices):
return 0
c1 = rec(i+1, k, f) # we dont buy or sell
c2 = 0
if f:
c2 = rec(i+1, k-1, False) + prices[i] # we sell
else:
c2 = rec(i+1, k, True) - prices[i] # we buy
return max(c1, c2)
return rec(0, 1, False) # k == 1, means, can do only 1 transaction | best-time-to-buy-and-sell-stock | [Python3] Top Down Recursion Memoization | tushar_prajapati | 2 | 171 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,220 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/1828569/Python-solution-clear-and-simple! | class Solution:
def maxProfit(self, prices: List[int]) -> int:
maxProfit, minPrice = 0, prices[0]
for price in prices:
minPrice = min(price, minPrice)
profit = price - minPrice
maxProfit = max(profit, maxProfit)
return maxProfit | best-time-to-buy-and-sell-stock | Python solution - clear and simple! | domthedeveloper | 2 | 204 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,221 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/1736020/Python-oror-95-faster-oror-95-Space-Efficient-oror-Linear-Soln | class Solution:
def maxProfit(self, prices: List[int]) -> int:
maxi = 0
mini = 1000000
for _ in prices:
if mini > _:
mini = _
elif _ - mini > maxi:
maxi = _ - mini
return maxi | best-time-to-buy-and-sell-stock | Python || 95% faster || 95% Space Efficient || Linear Soln | cherrysri1997 | 2 | 72 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,222 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/1735950/Python3-or-beginner-friendly-or-O(n)-Solution | class Solution:
def maxProfit(self, prices: List[int]) -> int:
mn, mx = float('inf'), 0
for i in range(len(prices)):
mn= min(prices[i],mn)
mx= max(mx, prices[i]-mn)
return mx | best-time-to-buy-and-sell-stock | Python3 | beginner-friendly | O(n) Solution | Anilchouhan181 | 2 | 90 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,223 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/1735592/Python-3-EASY-Intuitive-Solution | class Solution:
def maxProfit(self, prices: List[int]) -> int:
minimum = prices[0]
profit = 0
for i in range(1, len(prices)):
if prices[i] < minimum:
minimum = prices[i]
else:
profit = max(profit, prices[i]-minimum)
return profit | best-time-to-buy-and-sell-stock | ✅ [Python 3] EASY Intuitive Solution | JawadNoor | 2 | 152 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,224 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/1681031/Simple-and-Intuitive-Python-O(n)-time-explained | class Solution:
def maxProfit(self, prices: List[int]) -> int:
minValue = pow(10,5)
maxProfit = 0
for price in prices:
if price < minValue:
minValue = price
if (price - minValue) > maxProfit:
maxProfit = price - minValue
return maxProfit | best-time-to-buy-and-sell-stock | Simple and Intuitive Python O(n) time, explained | kenanR | 2 | 310 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,225 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/1515151/Simple-Dynamic-Programming-Solution-in-Python3 | class Solution:
def maxProfit(self, prices: List[int]) -> int:
#set max profit to 0
max_profit=0
#set min price to the first price in the prices array
min_price=prices[0]
#loop from the second price in the array since first price is captured in min_price
for i in range(1,len(prices)):
#update min_price
min_price=min(min_price, prices[i])
#updte max profit
max_profit=max(max_profit,prices[i]-min_price)
return max_profit | best-time-to-buy-and-sell-stock | Simple Dynamic Programming Solution in Python3 | ninahuang2002 | 2 | 585 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,226 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/1506229/python-3-oror-easy-oror-beginner-oror-97.86-82.17 | class Solution:
def maxProfit(self, prices: List[int]) -> int:
minn=float('+inf')
profit=0
today=0
for i in range(len(prices)):
if prices[i] < minn:
minn=prices[i]
today=prices[i]-minn
if today > profit:
profit=today
return profit | best-time-to-buy-and-sell-stock | python 3 || easy || beginner || 97.86 %,82.17% | minato_namikaze | 2 | 357 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,227 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/1339895/Python-simple-sol'n-using-kadane-and-pointers-orAccepted | class Solution:
def maxProfit(self, nums: List[int]) -> int:
i = 0
j = 1
n = len(nums)
max_so_far = 0
while i<n and j<n:
if nums[i]<=nums[j]:
max_so_far = max(max_so_far,nums[j]-nums[i])
j+=1
elif nums[i]>nums[j] or j==n-1:
i+=1
j=i+1
if i==n-1:
break
return max_so_far | best-time-to-buy-and-sell-stock | [Python] simple sol'n using kadane and pointers |Accepted | pheraram | 2 | 185 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,228 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/1227318/Easy-understand-Solution-of-Python3 | class Solution:
def maxProfit(self, prices: List[int]) -> int:
length = len(prices)
if length <= 1:
return 0
max_one = 0
best_to_buy = prices[0]
for price in prices:
if price < best_to_buy:
best_to_buy = price # always buy at the lowest level
else:
max_one = max(max_one, price - best_to_buy) # try to compare every sell day
return max_one | best-time-to-buy-and-sell-stock | Easy understand Solution of Python3 | faris-shi | 2 | 101 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,229 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/2647024/How-not-to-solve-this-problem-using-Python | class Solution:
def maxProfit(self, prices: List[int]) -> int:
max_profit = []
for i in range(len(stock_val)-1):
for j in range(i+1, len(stock_val)):
if stock_val[i] < stock_val[j]:
max_profit.append(stock_val[j] - stock_val[i])
return max(max_profit)) | best-time-to-buy-and-sell-stock | How not to solve this problem using Python | code_snow | 1 | 136 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,230 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/2581079/Easy-Python-3-Solution-with-comments | class Solution:
def maxProfit(self, prices: List[int]) -> int:
max_profit = 0 #Worst case there is no profit so it stays at zero..
left = 0 #This is our buy price we want it to be less than our sell price
for right in range(left, len(prices)):
if prices[right] < prices[left]:
left = right #If not a profitable transaction then we will continue moving down the array.
else:
#See if the new transaction we just found has a higher profit than max profit
max_profit = max(max_profit, prices[right] - prices[left])
#If it the new profit is higher than the max profit then we set it to max_profit
return max_profit #Finally return the max profit! | best-time-to-buy-and-sell-stock | Easy Python 3 Solution with comments | eddie1322 | 1 | 67 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,231 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/2561632/EASY-PYTHON3-SOLUTION-two-solutions | class Solution:
def maxProfit(self, prices: List[int]) -> int:
low=10**4
max_profit=0
for i,val in enumerate(prices):
p=val-low
if val < low:
low=val
if p > max_profit:
max_profit=p
return max_profit | best-time-to-buy-and-sell-stock | ✅✔EASY PYTHON3 SOLUTION ✅✔ two solutions | rajukommula | 1 | 148 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,232 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/2561632/EASY-PYTHON3-SOLUTION-two-solutions | class Solution:
def maxProfit(self,prices):
left = 0 #Buy
right = 1 #Sell
max_profit = 0
while right < len(prices):
currentProfit = prices[right] - prices[left] #our current Profit
if prices[left] < prices[right]:
max_profit =max(currentProfit,max_profit)
else:
left = right
right += 1
return max_profit | best-time-to-buy-and-sell-stock | ✅✔EASY PYTHON3 SOLUTION ✅✔ two solutions | rajukommula | 1 | 148 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,233 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/2399585/Python3-or-Solved-Iterative-Bottom-Up-Approach-Using-Tabulation-DP | class Solution:
#Time-Complexity: O(n + n-2) -> O(n)
#Space-Complexity: O(n * 2) -> O(n)
def maxProfit(self, prices: List[int]) -> int:
if(len(prices) == 1):
return 0
first_diff = prices[1] - prices[0]
buy_price = min(prices[0], prices[1])
#dp for tabulation!
dp = [[] for _ in range(len(prices))]
#if we consider up to first 2 days, we already know max revenue which is just
#difference of first two days' prices as well as the optimal buy price!
dp[1].append(first_diff)
dp[1].append(buy_price)
#bottom-up approach! -> Finding max profit i can get if I consider each and every
#additional ith day I did not take account in prev. iteration!
#Basically, checking if current day price if i sell on minus the lowest buy price
#in previous time frame could potentially beat the already computed max profit
#of using prices up to i-1th day!
for i in range(2, len(prices)):
dp[i].append(max(dp[i-1][0], prices[i] - dp[i-1][1]))
dp[i].append(min(dp[i-1][1], prices[i]))
#now once we are done with for loop solving for finding
#max profit if we consider subset of prices up to 3rd day or
#all the way up to last day!
#we get the last dp array's first element! -> If the best profit we could do is negative,
#then return 0 as it is rather a loss!
return dp[-1][0] if dp[-1][0] > 0 else 0 | best-time-to-buy-and-sell-stock | Python3 | Solved Iterative Bottom-Up Approach Using Tabulation DP | JOON1234 | 1 | 74 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,234 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/2329066/O(N)-Approach-for-C%2B%2BPython-best-optimized-one | class Solution:
def maxProfit(self, prices: List[int]) -> int:
minPrice = 9999999999
maxProfit = 0
for i in range(len(prices)):
profit = prices[i] - minPrice
minPrice = min(minPrice, prices[i])
maxProfit = max(maxProfit, profit)
return maxProfit | best-time-to-buy-and-sell-stock | O(N) Approach for C++/Python best optimized one | arpit3043 | 1 | 59 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,235 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/2297079/Simple-python3-using-two-pointers(updated) | class Solution:
def maxProfit(self, prices: List[int]) -> int:
l,r = 0, 1
maxP = 0
while r < len(prices):
if prices[l] < prices[r]:
profit = prices[r] - prices[l]
maxP = max(maxP, profit)
else:
l = r
r += 1
return maxP | best-time-to-buy-and-sell-stock | Simple python3 using two pointers(updated) | __Simamina__ | 1 | 89 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,236 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/2156028/Python-solution | class Solution:
def maxProfit(self, prices: List[int]) -> int:
res = 0 # Initializing result to 0.
buy = prices[0] # Buy is intialized to the first element
for sell in prices: # Looping in the prices list
if(buy<sell): # Comparing if first element is less than any other element in the list.
profit = sell - buy # If yes, then profit would be sell-buy.
res = max(res, profit) # And we'll calculate the result as maximum of result and profit.
else: # If not, then buy would be equal to sell, so now buy would be reinitialized.
buy = sell
return res # We'll return the result as res. | best-time-to-buy-and-sell-stock | Python solution | yashkumarjha | 1 | 88 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,237 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/2086701/Python3-Clean-and-Fast | class Solution:
# O(n) time | O(1) space
def maxProfit(self, prices: List[int]) -> int:
max_profit, min_price = 0, float("inf")
for i, price in enumerate(prices):
max_profit = max(max_profit, price - min_price)
min_price = min(min_price, price)
return max_profit | best-time-to-buy-and-sell-stock | Python3 - Clean and Fast | ig051 | 1 | 156 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,238 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/2075714/Python3-its-similar-to-Kadane's-algorithm | class Solution:
def maxProfit(self, prices: List[int]) -> int:
return self.maxProfitOptimal(prices)
# return self.maxProfitByTwoLoops(prices)
# O(n) || O(1) 1778ms 15.94%
def maxProfitOptimal(self, prices):
if not prices:
return 0
minVal = prices[0]
maxVal = float('-inf')
for i in range(1, len(prices)):
profit = prices[i] - minVal
maxVal = max(maxVal, profit)
minVal = min(minVal, prices[i])
return maxVal if maxVal > 0 else 0
# O(N^2) || O(1) TLE
def maxProfitByTwoLoops(self, prices):
if not prices:
return prices
maxVal = float('-inf')
for i in range(len(prices)):
for j in range(i+1, len(prices)):
maxVal = max(maxVal, prices[j] - prices[i])
return maxVal if maxVal > 0 else 0 | best-time-to-buy-and-sell-stock | Python3 its similar to Kadane's algorithm | arshergon | 1 | 94 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,239 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/2058036/Python-or-Recursion | class Solution:
def maxProfit(self, pr: List[int]) -> int:
def solve(i,j):
if i==j:
return 0
if i>j:
return -1
mid = (i+j)//2
# print(i,mid,j)
t = min(pr[i:mid+1])
t1 = max(pr[mid+1:j+1])
if t1-t>=0:
return max(t1-t,solve(i,mid),solve(mid+1,j))
else:
return max(solve(i,mid),solve(mid+1,j))
return solve(0,len(pr) - 1) | best-time-to-buy-and-sell-stock | Python | Recursion | Shivamk09 | 1 | 185 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,240 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/2023726/Python-easy-O(n)-solution | class Solution:
def maxProfit(self, prices: List[int]) -> int:
buy_price = sys.maxsize
max_profit = 0
for current_price in prices:
if current_price < buy_price:
buy_price = current_price
else:
max_profit = max(max_profit, current_price - buy_price)
return max_profit | best-time-to-buy-and-sell-stock | Python easy O(n) solution | AlexChantsev | 1 | 194 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,241 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/1947996/Super-simple-answer-in-python.-8588 | class Solution:
def maxProfit(self, prices: List[int]) -> int:
max_gain = 0
min_price = prices[0]
for current_price in prices[1:]:
current_gain = current_price - min_price #calculate current gain
max_gain = max(max_gain, current_gain) #update max gain
min_price = min(min_price, current_price) #update min price
return max_gain | best-time-to-buy-and-sell-stock | Super simple answer in python. 85%/88% | user4553BE | 1 | 63 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,242 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/1713935/simple-python-solution-0(n) | class Solution:
def maxProfit(self, prices: List[int]) -> int:
#prices = [7,1,5,3,6,4]
right_side=1
max_pr = 0
size = len(prices)
buy_price = prices[0] # 7
while right_side < size:
if buy_price <= prices[right_side]:
diff = prices[right_side] - buy_price
max_pr = max(max_pr, diff )
else:
buy_price = prices[right_side]
right_side+=1
return max_pr | best-time-to-buy-and-sell-stock | simple python solution 0(n) | suman2020 | 1 | 151 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,243 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/1671779/python-Iteration-%2B-variable | class Solution:
def maxProfit(self, prices: List[int]) -> int:
# Time:O(n), Space: O(1)
lowest = prices[0]
maxvalue = 0
for i in range(1,len(prices)):
maxvalue = max(maxvalue, prices[i]-lowest)
lowest = min(lowest,prices[i])
return maxvalue | best-time-to-buy-and-sell-stock | [python] Iteration + variable | JackYeh17 | 1 | 97 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,244 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/1598519/Python3-One-pass-O(1)-space-solution | class Solution:
def maxProfit(self, prices: List[int]) -> int:
_min_price = float('inf')
res = 0
for price in prices:
if price < _min_price:
_min_price = price
else:
res = max(res, price - _min_price)
return res | best-time-to-buy-and-sell-stock | [Python3] One pass, O(1) space solution | maosipov11 | 1 | 128 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,245 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock/discuss/1589431/Python3-one-pass-O(n)-time-and-O(1)-space | class Solution:
def maxProfit(self, prices: List[int]) -> int:
min_price, max_profit = math.inf, 0
for p in prices:
if p < min_price:
min_price = p
elif p-min_price > max_profit:
max_profit = p-min_price
return max_profit | best-time-to-buy-and-sell-stock | [Python3] one-pass O(n) time & O(1) space | JosephJia | 1 | 251 | best time to buy and sell stock | 121 | 0.544 | Easy | 1,246 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/2040292/O(n)timeBEATS-99.97-MEMORYSPEED-0ms-MAY-2022 | class Solution:
def maxProfit(self, prices: List[int]) -> int:
@cache
def trade(day_d):
if day_d == 0:
# Hold on day_#0 = buy stock at the price of day_#0
# Not-hold on day_#0 = doing nothing on day_#0
return -prices[day_d], 0
prev_hold, prev_not_hold = trade(day_d-1)
hold = max(prev_hold, prev_not_hold - prices[day_d] )
not_hold = max(prev_not_hold, prev_hold + prices[day_d] )
return hold, not_hold
# --------------------------------------------------
last_day= len(prices)-1
# Max profit must come from not_hold state (i.e., no stock position) on last day
return trade(last_day)[1] | best-time-to-buy-and-sell-stock-ii | O(n)time/BEATS 99.97% MEMORY/SPEED 0ms MAY 2022 | cucerdariancatalin | 12 | 605 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,247 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/2434293/Easy-oror-100-oror-4-Line-oror-Fully-Explained-(Java-C%2B%2B-Python-JS-C-Python3) | class Solution(object):
def maxProfit(self, prices):
# Initialize the max profit...
maximumProfit = 0
# Traverse all the element through loop...
for i in range(1, len(prices)):
# check if the price is greater at i...
if prices[i] > prices[i-1]:
# Add the difference to profit and increse it...
maximumProfit += prices[i] - prices[i-1]
return maximumProfit # Return the max profit... | best-time-to-buy-and-sell-stock-ii | Easy || 100% || 4 Line || Fully Explained (Java, C++, Python, JS, C, Python3) | PratikSen07 | 7 | 430 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,248 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/2434293/Easy-oror-100-oror-4-Line-oror-Fully-Explained-(Java-C%2B%2B-Python-JS-C-Python3) | class Solution:
def maxProfit(self, prices: List[int]) -> int:
# Initialize the max profit...
maximumProfit = 0
# Traverse all the element through loop...
for i in range(1, len(prices)):
# check if the price is greater at i...
if prices[i] > prices[i-1]:
# Add the difference to profit and increse it...
maximumProfit += prices[i] - prices[i-1]
return maximumProfit # Return the max profit... | best-time-to-buy-and-sell-stock-ii | Easy || 100% || 4 Line || Fully Explained (Java, C++, Python, JS, C, Python3) | PratikSen07 | 7 | 430 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,249 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/565654/Python3-greedy-and-dp | class Solution:
def maxProfit(self, prices: List[int]) -> int:
return sum(max(0, prices[i] - prices[i-1]) for i in range(1, len(prices))) | best-time-to-buy-and-sell-stock-ii | [Python3] greedy & dp | ye15 | 4 | 241 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,250 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/565654/Python3-greedy-and-dp | class Solution:
def maxProfit(self, prices: List[int]) -> int:
ans = 0
for i in range(1, len(prices)):
ans += max(0, prices[i] - prices[i-1])
return ans | best-time-to-buy-and-sell-stock-ii | [Python3] greedy & dp | ye15 | 4 | 241 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,251 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/565654/Python3-greedy-and-dp | class Solution:
def maxProfit(self, prices: List[int]) -> int:
buy, sell = [0]*len(prices), [0]*len(prices)
buy[0] = prices[0]
for i in range(1, len(prices)):
buy[i] = min(buy[i-1], prices[i] - sell[i-1])
sell[i] = max(sell[i-1], prices[i] - buy[i])
return sell[-1] | best-time-to-buy-and-sell-stock-ii | [Python3] greedy & dp | ye15 | 4 | 241 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,252 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/565654/Python3-greedy-and-dp | class Solution:
def maxProfit(self, prices: List[int]) -> int:
buy, sell = inf, 0
for x in prices:
buy = min(buy, x - sell)
sell = max(sell, x - buy)
return sell | best-time-to-buy-and-sell-stock-ii | [Python3] greedy & dp | ye15 | 4 | 241 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,253 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/565654/Python3-greedy-and-dp | class Solution:
def maxProfit(self, prices: List[int]) -> int:
ans = most = 0
for i in range(1, len(prices)):
most = max(0, prices[i] - prices[i-1])
ans += most
return ans | best-time-to-buy-and-sell-stock-ii | [Python3] greedy & dp | ye15 | 4 | 241 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,254 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/1116903/WEEB-DOES-PYTHON-FOR-YOU | class Solution:
def maxProfit(self, prices: List[int]) -> int:
profit = 0
for i in range(len(prices)-1):
if prices[i] < prices[i+1]:
profit += prices[i+1] - prices[i]
return profit | best-time-to-buy-and-sell-stock-ii | WEEB DOES PYTHON FOR YOU | Skywalker5423 | 3 | 319 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,255 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/2797655/Linear-Order-Python-Solution | class Solution:
def maxProfit(self, prices: List[int]) -> int:
n=len(prices)
buy=0
dp=[[-1]*2 for i in range(n+1)]
(dp[n])[0]=(dp[n])[0]=0
for ind in range(n-1,-1,-1):
for buy in range(0,2):
if buy==0:
(dp[ind])[buy]=max((-prices[ind]+(dp[ind+1])[1]),(dp[ind+1])[0])
else:
(dp[ind])[buy]=max((+prices[ind]+(dp[ind+1])[0]),(dp[ind+1])[1])
return (dp[0])[0] | best-time-to-buy-and-sell-stock-ii | Linear Order Python Solution | Khan_Baba | 2 | 373 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,256 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/2113567/Python-or-4-Approaches-or-Entire-DP-or | class Solution:
def maxProfit(self, prices: List[int]) -> int:
n = len(prices)
dp = [[-1 for i in range(2)] for i in range(n+1)]
dp[n][0] = dp[n][1] = 0
ind = n-1
while(ind>=0):
for buy in range(2):
if(buy):
profit = max(-prices[ind] + dp[ind+1][0], 0 + dp[ind+1][1])
else:
profit = max(prices[ind] + dp[ind+1][1], 0 + dp[ind+1][0])
dp[ind][buy] = profit
ind -= 1
return dp[0][1] | best-time-to-buy-and-sell-stock-ii | Python | 4 Approaches | Entire DP | | LittleMonster23 | 2 | 150 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,257 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/2113567/Python-or-4-Approaches-or-Entire-DP-or | class Solution:
def maxProfit(self, prices: List[int]) -> int:
n = len(prices)
ahead = [0 for i in range(2)]
curr = [0 for i in range(2)]
ahead[0] = ahead[1] = 0
ind = n-1
while(ind>=0):
for buy in range(2):
if(buy):
profit = max(-prices[ind] + ahead[0], 0 + ahead[1])
else:
profit = max(prices[ind] + ahead[1], 0 + ahead[0])
curr[buy] = profit
ahead = [x for x in curr]
ind -= 1
return ahead[1] | best-time-to-buy-and-sell-stock-ii | Python | 4 Approaches | Entire DP | | LittleMonster23 | 2 | 150 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,258 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/337075/Python-simple-solution-O(n) | class Solution:
def maxProfit(self, prices: List[int]) -> int:
maxpro=0
if not prices:return 0
for i in range(len(prices)-1):
if prices[i]<prices[i+1]:
maxpro+=prices[i+1]-prices[i]
return maxpro | best-time-to-buy-and-sell-stock-ii | Python simple solution O(n) | ketan35 | 2 | 331 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,259 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/255013/Python-Easy-to-Understand | class Solution:
def maxProfit(self, prices: List[int]) -> int:
maxProfit = 0
for i in range(1, len(prices)):
if prices[i] > prices[i-1]:
maxProfit += prices[i] - prices[i-1]
return maxProfit | best-time-to-buy-and-sell-stock-ii | Python Easy to Understand | ccparamecium | 2 | 284 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,260 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/2816169/One-pass-straightforward-or-SC%3A-O(N)-TC%3A-O(1) | class Solution:
def maxProfit(self, prices: List[int]) -> int:
# Buy very first stock
buy = prices[0]
profit = 0
for i in range(1, len(prices)):
# If you find stock less than what you bought, take that instead
if prices[i] < buy:
buy = prices[i]
# If you find stock greater than what you bought, sell that
# Also buy it as you want to sell if you see greater stock in future
else:
profit += prices[i] - buy
buy = prices[i]
return profit | best-time-to-buy-and-sell-stock-ii | One-pass, straightforward | SC: O(N), TC: O(1) | bikcrum | 1 | 187 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,261 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/2558060/Python3-Solution-or-Sliding-Window-or-Beats-97-Time | class Solution:
def maxProfit(self, prices: List[int]) -> int:
total_profit = 0
i = 0
j = 0
while j < len(prices):
if prices[j] <= prices[i]:
i = j
else:
while j < len(prices)-1 and prices[j+1] > prices[j]:
j += 1
profit = prices[j] - prices[i]
total_profit += profit
i = j + 1
j += 1
return total_profit | best-time-to-buy-and-sell-stock-ii | Python3 Solution | Sliding Window | Beats 97% Time | dos_77 | 1 | 10 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,262 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/2429685/Python-DP-Solution-(Memoization) | class Solution:
def maxProfit(self, prices: List[int]) -> int:
d = {}
def bs(index, buyOrNotBuy):
if index >= len(prices):
return 0
# if we are able to buy the stock, if we already sold it before or
# if we have not bought any stock
if buyOrNotBuy == "buy":
# if buy stock at this index
if (index+1, "notBuy") not in d:
profit = -1 * prices[index] + bs(index+1, "notBuy")
else:
profit = -1 * prices[index] + d[(index+1, "notBuy")]
# if buy later, not now at this index
if (index+1, "buy") not in d:
profit1 = bs(index+1, "buy")
else:
profit1 = d[(index+1, "buy")]
d[(index, buyOrNotBuy)] = max(profit, profit1)
return d[(index, buyOrNotBuy)]
else:
# sell stock, if we sell 2nd argument is buy
# sell stock at this index
if (index+1, "buy") not in d:
profit = prices[index] + bs(index+1, "buy")
else:
profit = prices[index] + d[(index+1, "buy")]
# sell stock not at this index now, sell it later
if (index+1, "notBuy") not in d:
profit1 = bs(index+1, "notBuy")
else:
profit1 = d[(index+1, "notBuy")]
d[(index, buyOrNotBuy)] = max(profit, profit1)
return d[(index, buyOrNotBuy)]
return bs(0, "buy") | best-time-to-buy-and-sell-stock-ii | Python DP Solution (Memoization) | DietCoke777 | 1 | 53 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,263 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/2398678/Python-91.76-faster-or-Simplest-solution-with-explanation-or-Beg-to-Adv-or-Greedy | class Solution:
def maxProfit(self, prices: List[int]) -> int:
profit = 0 # to store the total profit
for i in range(1, len(prices)): # traversing the prices list, taking it from 1st index so that we could compare the day gain or loss by comparing it to previous value.
if prices[i]>prices[i-1]: # comparing current value with last value
profit += (prices[i] - prices[i-1]) # if we have a great value implies we have profit. But we need total profit means after removing losses thats why we are subtracting previous value which is low.
return profit # returning total profit earned. | best-time-to-buy-and-sell-stock-ii | Python 91.76% faster | Simplest solution with explanation | Beg to Adv | Greedy | rlakshay14 | 1 | 71 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,264 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/2060124/Python-or-Easy-Understanding | class Solution:
def maxProfit(self, pr: List[int]) -> int:
ans = 0
for i in range(len(pr)):
if i==0:
mi = pr[i]
else:
if pr[i]<pr[i-1]:
ans += pr[i-1]-mi
mi = pr[i]
ans += pr[i]-mi
return ans | best-time-to-buy-and-sell-stock-ii | Python | Easy Understanding | Shivamk09 | 1 | 50 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,265 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/1792067/Concise-Code-or-Python | class Solution:
def maxProfit(self, prices: List[int]) -> int:
tot_profit = 0
buy_price = prices[0]
for i in range(1,len(prices)):
if prices[i] > buy_price:
tot_profit += prices[i] - buy_price
buy_price = prices[i]
return tot_profit | best-time-to-buy-and-sell-stock-ii | Concise Code | Python | iamskd03 | 1 | 63 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,266 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/1782181/Python-easy-to-read-and-understand-or-DP | class Solution:
def maxProfit(self, prices: List[int]) -> int:
profit, buy = 0, prices[0]
for i in range(1, len(prices)):
if prices[i] > prices[i-1]:
profit += (prices[i]-buy)
buy = prices[i]
else:
buy = prices[i]
return profit | best-time-to-buy-and-sell-stock-ii | Python easy to read and understand | DP | sanial2001 | 1 | 172 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,267 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/1564442/Python3-Solution-or-O(n) | class Solution:
def maxProfit(self, prices: List[int]) -> int:
profit = 0
for i in range(1,len(prices)):
if prices[i] > prices[i-1]:
profit += prices[i]-prices[i-1]
return profit | best-time-to-buy-and-sell-stock-ii | Python3 Solution | O(n) | satyam2001 | 1 | 116 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,268 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/1564442/Python3-Solution-or-O(n) | class Solution:
def maxProfit(self, prices: List[int]) -> int:
profit = 0
for i in range(1,len(prices)):
profit += max(prices[i]-prices[i-1],0)
return profit | best-time-to-buy-and-sell-stock-ii | Python3 Solution | O(n) | satyam2001 | 1 | 116 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,269 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/1522537/O(n)-with-O(1)-space. | class Solution:
def maxProfit(self, prices: List[int]) -> int:
profit = 0
for x in range(1,len(prices)):
profit+=max(0, prices[x]-prices[x-1])
return profit | best-time-to-buy-and-sell-stock-ii | O(n), with O(1) space. | user7797Mu | 1 | 81 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,270 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/1441331/Python-3-Solution-(DO-NOT-MAKE-THIS-MISTAKE) | class Solution:
def maxProfit(self, prices: List[int]) -> int:
def strictly_increasing(buy_d,arr):
for i in range(buy_d-1,len(arr)-1):
if arr[i] < arr[i+1]:
continue
else:
return i
return len(arr)-1
a = 0
max_profit = 0
while a < len(prices)-1:
buy_price = prices[a]
sell_price = prices[strictly_increasing(a+1,prices)]
profit = sell_price - buy_price
max_profit += profit
a = strictly_increasing(a+1,prices) + 1
return max_profit | best-time-to-buy-and-sell-stock-ii | Python 3 Solution (DO NOT MAKE THIS MISTAKE) | deleted_user | 1 | 98 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,271 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/1441331/Python-3-Solution-(DO-NOT-MAKE-THIS-MISTAKE) | class Solution:
def maxProfit(self, prices: List[int]) -> int:
profit = 0
for i in range(1, len(prices)):
profit += max(0, prices[i] - prices[i-1])
return profit | best-time-to-buy-and-sell-stock-ii | Python 3 Solution (DO NOT MAKE THIS MISTAKE) | deleted_user | 1 | 98 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,272 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/1370396/O(n)-97.96-faster-Python-Simple-solution | class Solution:
def maxProfit(self, prices: List[int]) -> int:
profit = 0
for i in range(1,len(prices)):
if(prices[i]>prices[i-1]):
profit+=prices[i]-prices[i-1]
return profit
```
 | best-time-to-buy-and-sell-stock-ii | O(n), 97.96% faster, Python, Simple solution | unKNOWN-G | 1 | 331 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,273 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/1065440/python | class Solution:
def maxProfit(self, prices: List[int]) -> int:
minprice = prices[0]
profit = 0
for i in prices:
if i > minprice:
profit += i - minprice
minprice = i
return profit | best-time-to-buy-and-sell-stock-ii | python | nancyszy | 1 | 132 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,274 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/617637/Intuitive-approach-with-intuitive-buyingselling-strategy | class Solution:
def maxProfit(self, prices: List[int]) -> int:
pp = prices[0]
r'''
* Buy at point where next point will rise
* Sell at point where next point will drop
'''
sum_of_earned = 0
''' Total earned from selling stock'''
buy_price = -1
''' Used to keep the price of stock being bought'''
prices_size = len(prices)
''' Length of price array '''
for i in range(len(prices)-1):
now_p = prices[i] # Current price
next_p = prices[i+1] # Tomorrow's price
if next_p < now_p:
# stock will drop tomorrow
if buy_price >= 0:
sum_of_earned += (now_p - buy_price)
buy_price = -1
elif next_p > now_p:
# stock will rise tomorrow
if buy_price < 0:
buy_price = now_p
if buy_price >= 0 and prices[-1] > buy_price:
# We still have stock in hand
# Sell it if the price is higher than the price we bought
sum_of_earned += (prices[-1] - buy_price)
return sum_of_earned | best-time-to-buy-and-sell-stock-ii | Intuitive approach with intuitive buying/selling strategy | puremonkey2001 | 1 | 77 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,275 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/268595/Python-40ms | class Solution:
def maxProfit(self, prices: List[int]) -> int:
total = 0
for day in range(len(prices)-1):
if prices[day] < prices[day+1]:
total += prices[day+1] - prices[day]
return total | best-time-to-buy-and-sell-stock-ii | Python 40ms | mobiplayer | 1 | 115 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,276 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/2845477/Easy-to-understand-beats-75 | class Solution:
def maxProfit(self, prices: List[int]) -> int:
dp=[0]*len(prices)
for i in range(0,len(prices)-1,1):
for j in range(i+1,i+2):
if(max(prices[i],prices[j]))==prices[j]:
dp[i]=prices[j]-prices[i]
else:
pass
return sum(dp) | best-time-to-buy-and-sell-stock-ii | Easy to understand , beats 75% | varunmuthannaka | 0 | 2 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,277 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/2839408/Surprisingly-easy-to-understand-O(n)-solution-in-Python | class Solution:
def maxProfit(self, prices: List[int]) -> int:
diff = []
profit = 0
for i in range(1, len(prices)):
diff.append(prices[i] - prices[i - 1])
for d in diff:
profit = profit + d if d > 0 else profit
return profit | best-time-to-buy-and-sell-stock-ii | Surprisingly easy to understand O(n) solution in Python | Whateverokokokok | 0 | 2 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,278 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/2839408/Surprisingly-easy-to-understand-O(n)-solution-in-Python | class Solution:
def maxProfit(self, prices: List[int]) -> int:
profit = 0
for i in range(1, len(prices)):
diff = prices[i] - prices[i - 1]
profit = profit + diff if diff >0 else profit
return profit | best-time-to-buy-and-sell-stock-ii | Surprisingly easy to understand O(n) solution in Python | Whateverokokokok | 0 | 2 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,279 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/2837612/Python-90-faster | class Solution:
def maxProfit(self, prices: List[int]) -> int:
pft = 0
i = 0
while i + 1 < len(prices):
diff = prices[i + 1] - prices[i]
if diff > 0:
pft += diff
i += 1
return pft | best-time-to-buy-and-sell-stock-ii | Python = 90% faster | fatalbanana | 0 | 4 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,280 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/2825831/o(n)-Python | class Solution:
def maxProfit(self, prices: List[int]) -> int:
profit_ = 0
buy = float("inf")
for i in range(len(prices)):
if prices[i] < buy:
buy = prices[i]
elif prices[i] - buy > 0:
profit_ += prices [i] - buy
buy = prices[i]
return profit_ | best-time-to-buy-and-sell-stock-ii | o(n) Python | AkshayVijayBidwai | 0 | 3 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,281 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/2823401/O(n)-time-complexity-Python-easy-solution | class Solution:
def maxProfit(self, prices: List[int]) -> int:
mini,maxi = prices[0],-1
cost = 0
for val in prices:
if val < mini:
mini = val
if val > mini:
maxi = val
cost += maxi-mini
mini = val
maxi = -1
return cost | best-time-to-buy-and-sell-stock-ii | O(n) time complexity - Python easy solution | vasanth180799 | 0 | 2 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,282 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/2820825/Optimized-and-Easy-Solution | class Solution:
def maxProfit(self, prices: List[int]) -> int:
profit = 0
for i in range(1, len(prices)):
if prices[i] > prices[i - 1]:
profit += (prices[i] - prices[i - 1])
return profit | best-time-to-buy-and-sell-stock-ii | Optimized and Easy Solution | swaruptech | 0 | 1 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,283 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/2816135/Python-Solution | class Solution:
def maxProfit(self, prices: List[int]) -> int:
p = 0
b = prices[0]
l = prices[0]
for idx, i in enumerate(prices):
if i < l:
p += (l - b)
b = i
l = i
else:
l = i
p += (l - b)
return p | best-time-to-buy-and-sell-stock-ii | Python Solution | jaisalShah | 0 | 1 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,284 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/2792622/Best-Time-to-Buy-and-to-Sell-Stock-II-(Python-optimal-solution) | class Solution:
def maxProfit(self, prices: List[int]) -> int:
profit = 0
for i in range(1, len(prices)):
if prices[i] > prices[i-1]:
# sell
profit += prices[i] - prices[i-1]
return profit | best-time-to-buy-and-sell-stock-ii | Best Time to Buy and to Sell Stock II (Python optimal solution) | riya_gupta28 | 0 | 1 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,285 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/2785091/40-faster-Python-Code-TC%3AO(N)-and-SC%3AO(1) | class Solution:
def maxProfit(self, prices: List[int]) -> int:
maxProfit = 0
for i in range(1,len(prices)):
if prices[i] - prices[i-1] > 0:
maxProfit += prices[i] - prices[i-1]
return maxProfit | best-time-to-buy-and-sell-stock-ii | 40% faster Python Code TC:O(N) and SC:O(1) | sudharshan1706 | 0 | 3 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,286 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/2776415/Greedy-simple-modification-from-Best-Time-to-Buy-and-Sell-Stock-I | class Solution:
def maxProfit(self, prices: List[int]) -> int:
if len(prices) < 2:
return 0
resultList = []
MaxProfit = 0
CurrVal = prices[0]
for i in range(len(prices)):
if prices[i] > CurrVal:
MaxProfit += (prices[i] - CurrVal) #Sell the stock
CurrVal = prices[i]
if prices[i] < CurrVal:
CurrVal = prices[i]
return MaxProfit | best-time-to-buy-and-sell-stock-ii | Greedy, simple modification from Best Time to Buy and Sell Stock I | ZihanWang1819 | 0 | 1 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,287 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/2775302/Python-Easy-solution-O(n) | class Solution:
def maxProfit(self, prices: List[int]) -> int:
holding = False
day = 0
N = len(prices)
buy = 0
profit = 0
while day < N-1:
if not holding:
if prices[day] > prices[day+1]:
pass
else:
buy = prices[day]
holding = True
else:
if prices[day+1] > prices[day] and prices[day] >= buy:
pass
else:
profit += prices[day] - buy
holding = False
day += 1
if holding:
sale = prices[day] - buy
if sale > 0:
profit += sale
return profit | best-time-to-buy-and-sell-stock-ii | [Python] Easy solution O(n) | koff82 | 0 | 5 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,288 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/2767533/Python-four-approach-very-easy | class Solution:
def solve(self , i , buy , prices , n):
if i >= n:
return 0
if buy == 0:
no = 0 + self.solve(i+1 , 0 , prices , n)
take = -prices[i] + self.solve(i+1 , 1 , prices , n)
profit = max( take , no)
if buy == 1:
profit = max(0 + self.solve(i+1 , 1 , prices , n) , prices[i] + self.solve(i+1 , 0 , prices , n))
return profit
def maxProfit(self, prices: List[int]) -> int:
n = len(prices)
return self.solve(0 , 0 , prices , n)
""" memorization """
class Solution:
def solve(self , i , buy , prices , n , memo):
if i >= n:
return 0
if memo[i][buy] != -1:
return memo[i][buy]
if buy == 0:
no = 0 + self.solve(i+1 , 0 , prices , n , memo)
take = -prices[i] + self.solve(i+1 , 1 , prices , n , memo)
profit = max( take , no)
memo[i][buy] = profit
if buy == 1:
profit = max(0 + self.solve(i+1 , 1 , prices , n , memo) , prices[i] + self.solve(i+1 , 0 , prices , n , memo))
memo[i][buy] = profit
memo[i][buy] = profit
return memo[i][buy]
def maxProfit(self, prices: List[int]) -> int:
n = len(prices)
memo = [[-1 for j in range(2)] for i in range(n)]
return self.solve(0 , 0 , prices , n , memo)
""" Bottom up """
class Solution:
def maxProfit(self, prices: List[int]) -> int:
n = len(prices)
dp = [[0 for j in range(2)] for i in range(n+1)]
dp[n][0] = dp[n][1] = 0
for i in range(n-1 , -1 , -1):
for j in range(2):
if j == 0:
no = 0 + dp[i+1][0]
take = -prices[i] + dp[i+1][1]
profit = max(no , take)
dp[i][j] = profit
if j == 1:
no = 0 + dp[i+1][1]
take = prices[i] + dp[i+1][0]
profit = max(no , take)
dp[i][j] = profit
return dp[0][0]
""" my fav solution """
class Solution:
def maxProfit(self, prices: List[int]) -> int:
profit = 0
cost = prices[0]
for i in range(1 , len(prices)):
if prices[i] > cost:
profit += prices[i] - cost
cost = prices[i]
return profit | best-time-to-buy-and-sell-stock-ii | Python four approach very easy | rajitkumarchauhan99 | 0 | 2 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,289 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/2760390/Easiest-Python-Solution-you-are-looking-for! | class Solution:
def maxProfit(self, prices: List[int]) -> int:
minimum=+math.inf
profit=0
for i in prices:
minimum=min(minimum,i)
if i>minimum:
profit+=i-minimum
minimum=i
return profit | best-time-to-buy-and-sell-stock-ii | Easiest Python Solution you are looking for! | Nikhil_Namburi | 0 | 3 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,290 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/2754672/Simple-Iterative-Approach-or-Python | class Solution:
def maxProfit(self, prices: List[int]) -> int:
ans, res = 0, prices[0]
n = len(prices)
for i in range(1,n):
if prices[i]>res:
ans += prices[i]-res
res = prices[i]
else:
res = prices[i]
return ans | best-time-to-buy-and-sell-stock-ii | Simple Iterative Approach | Python | RajatGanguly | 0 | 3 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,291 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/2734321/better-than-97.5-percentage-PYTHON | class Solution:
def maxProfit(self, prices: List[int]) -> int:
buy = prices[0]
maxProfit = 0
for i in range(1,len(prices)):
if buy > prices[i]:
buy = prices[i]
elif 0 < prices[i] - buy:
maxProfit += prices[i] - buy
buy = prices[i]
return maxProfit | best-time-to-buy-and-sell-stock-ii | better than 97.5 percentage PYTHON | Taksh_beladiya | 0 | 6 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,292 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/2732895/Fast-and-Easy-Solution | class Solution:
def maxProfit(self, prices: List[int]) -> int:
buying_price = prices[0]
max_profit = 0
for selling_price in prices[1 : ]:
if buying_price > selling_price:
buying_price = selling_price
else:
max_profit += (selling_price - buying_price)
buying_price = selling_price
return max_profit | best-time-to-buy-and-sell-stock-ii | Fast and Easy Solution | user6770yv | 0 | 4 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,293 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/2730129/same-as-leetcode-1911-easy-dp | class Solution:
def maxProfit(self, prices: List[int]) -> int:
even = 0
odd = 0
for num in prices[::-1] :
temp_even = even
even = max(even, odd + num)
odd = max(odd, temp_even - num)
return odd
#def maxAlternatingSum(self, nums: List[int]) -> int:
#even = 0
#odd = 0
#for num in nums :
# even = max(even, odd + num)
# odd = max(odd, even - num)
#return even | best-time-to-buy-and-sell-stock-ii | same as leetcode 1911, easy dp | user8498Sr | 0 | 3 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,294 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/2683018/Python-solution-beats-99-users | class Solution:
def maxProfit(self, prices: List[int]) -> int:
p=prices
return sum([max(0,p[i]-p[i-1]) for i in range(1,len(p))]) | best-time-to-buy-and-sell-stock-ii | Python solution beats 99% users | mritunjayyy | 0 | 4 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,295 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/2681512/Positive-Pair-Difference-Approach-oror-Intuitive-oror-Beats-92 | class Solution:
def maxProfit(self, prices: List[int]) -> int:
if len(prices) <= 1:
return 0
totalProfit = 0
for i in range(1,len(prices)):
totalProfit +=
prices[i]-prices[i-1] if prices[i]-prices[i-1] > 0 else 0
return totalProfit | best-time-to-buy-and-sell-stock-ii | Positive Pair Difference Approach || Intuitive || Beats 92% | mayankleetcode | 0 | 1 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,296 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/2653158/Easy-Understandable-Python-Solution-Beats-99-or-O(N) | class Solution:
def maxProfit(self, prices: List[int]) -> int:
cumulativeProfit = 0
for i in range(1,len(prices)):
if prices[i-1] < prices[i]:
cumulativeProfit+=(prices[i]-prices[i-1])
return cumulativeProfit | best-time-to-buy-and-sell-stock-ii | Easy Understandable Python Solution Beats 99% | O(N) | perabjoth | 0 | 1 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,297 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/2594213/Message-usage-less-than-97.74 | class Solution:
def maxProfit(self, prices: List[int]) -> int:
profit = 0
for i in range(1,len(prices)):
if prices[i]>prices[i-1]:
profit += prices[i]-prices[i-1]
return profit | best-time-to-buy-and-sell-stock-ii | Message usage less than 97.74% | jayeshvarma | 0 | 31 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,298 |
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/2584233/Python-easy-solution | class Solution(object):
def maxProfit(self, prices):
"""
:type prices: List[int]
:rtype: int
"""
pos = 0
profit = 0
start = None
while pos < (len(prices) - 1):
today = prices[pos]
tomorrow = prices[pos + 1]
if today < tomorrow: # tomorrow's more expensive
if start is None:
start = today
else: # tomorrow's cheaper so we need to sell if we hold anything
if start is not None:
profit += (today - start)
start = None # reset today - we're not holding anything
pos += 1
if start is not None:
profit += (prices[-1] - start)
return profit | best-time-to-buy-and-sell-stock-ii | Python easy solution | zakmatt | 0 | 57 | best time to buy and sell stock ii | 122 | 0.634 | Medium | 1,299 |
Subsets and Splits