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/unique-paths-iii/discuss/1061049/Python-or-Backtracking-with-comments | class Solution:
def uniquePathsIII(self, grid: List[List[int]]) -> int:
global result
result = 0
def backtrack(i, j, squares):
global result
# all the code below here is pretty much termination conditions from above bullet points...
... | unique-paths-iii | Python | Backtracking with comments | dev-josh | 2 | 109 | unique paths iii | 980 | 0.797 | Hard | 15,900 |
https://leetcode.com/problems/unique-paths-iii/discuss/1061049/Python-or-Backtracking-with-comments | class Solution:
def uniquePathsIII(self, grid: List[List[int]]) -> int:
global result
result = 0
def backtrack(i, j, squares):
global result
if not (0 <= i < len(grid)): return
if not (0 <= j < len(grid[0]))... | unique-paths-iii | Python | Backtracking with comments | dev-josh | 2 | 109 | unique paths iii | 980 | 0.797 | Hard | 15,901 |
https://leetcode.com/problems/unique-paths-iii/discuss/1534269/WEEB-DOES-PYTHON-BFS | class Solution:
def uniquePathsIII(self, grid: List[List[int]]) -> int:
row, col = len(grid), len(grid[0])
queue = deque([])
numSquare = 1 # include starting point
visited = set()
for x in range(row):
for y in range(col):
if grid[x][y] == 1:
visited.add((x,y))
queue.append((x, y, visited))
... | unique-paths-iii | WEEB DOES PYTHON BFS | Skywalker5423 | 1 | 118 | unique paths iii | 980 | 0.797 | Hard | 15,902 |
https://leetcode.com/problems/unique-paths-iii/discuss/1195823/Python-Iterative-dfs | class Solution:
def uniquePathsIII(self, grid: List[List[int]]) -> int:
rows = len(grid)
cols = len(grid[0])
nonObstacle = 0
for i in range(rows):
for j in range(cols):
if grid[i][j] == 1:
start = [i,j]
if grid[i][j] == ... | unique-paths-iii | Python - Iterative dfs | anusharp | 1 | 72 | unique paths iii | 980 | 0.797 | Hard | 15,903 |
https://leetcode.com/problems/unique-paths-iii/discuss/1172665/easy-python-solution-with-comments-(44ms) | class Solution:
def uniquePathsIII(self, A: List[List[int]]) -> int:
m, n = len(A), len(A[0])
start = end = p = 0
# Flatten the array for better performance
A = reduce(operator.add, A)
for key, val in enumerate(A):
if val >= 0:
p += 1 # Count the ... | unique-paths-iii | easy python solution with comments (44ms) | TimSYQQX | 1 | 167 | unique paths iii | 980 | 0.797 | Hard | 15,904 |
https://leetcode.com/problems/unique-paths-iii/discuss/1172665/easy-python-solution-with-comments-(44ms) | class Solution:
def uniquePathsIII(self, A: List[List[int]]) -> int:
m, n = len(A) + 2, len(A[0]) + 2
start = end = p = 0
# Flatten the array for better performance
# and padd the array to avoid boundary condition
A = [-1] * n + reduce(operator.add, map(lambda x: [-... | unique-paths-iii | easy python solution with comments (44ms) | TimSYQQX | 1 | 167 | unique paths iii | 980 | 0.797 | Hard | 15,905 |
https://leetcode.com/problems/unique-paths-iii/discuss/462896/Python-3-(DFS)-(14-lines)-O(1)-space-(beats-~93)-(52-ms) | class Solution:
def uniquePathsIII(self, G: List[List[int]]) -> int:
M, N, t, z = len(G), len(G[0]), [0], 0
for i,j in itertools.product(range(M),range(N)):
if G[i][j] == 0: z += 1
if G[i][j] == 1: a,b = i,j
if G[i][j] == 2: e,f = i,j
G[a][b] = 0
d... | unique-paths-iii | Python 3 (DFS) (14 lines) O(1) space (beats ~93%) (52 ms) | junaidmansuri | 1 | 420 | unique paths iii | 980 | 0.797 | Hard | 15,906 |
https://leetcode.com/problems/unique-paths-iii/discuss/2775551/Python-or-Easy-Solution-or-DFS-and-Backtracking | class Solution:
def uniquePathsIII(self, grid: List[List[int]]) -> int:
rows = len(grid)
cols = len(grid[0])
start_row,start_col,end_row,end_col = 0,0,0,0
empty_cells = 0
# Traversing the grid to find the start and end index
for i in range(0,rows):
for j... | unique-paths-iii | [Python] | Easy Solution | DFS & Backtracking ✅ | tharunbalaji31 | 0 | 6 | unique paths iii | 980 | 0.797 | Hard | 15,907 |
https://leetcode.com/problems/unique-paths-iii/discuss/2692734/Straightforward-Python-DFS-solution. | class Solution:
def uniquePathsIII(self, grid: List[List[int]]) -> int:
directions = [-1, 0, 1, 0, -1]
m, n = len(grid), len(grid[0])
def helper(ans, start, target, cur_count, M, visited, grid):
if start == target:
if cur_count == M:
return an... | unique-paths-iii | Straightforward Python DFS solution. | yiming999 | 0 | 5 | unique paths iii | 980 | 0.797 | Hard | 15,908 |
https://leetcode.com/problems/unique-paths-iii/discuss/2558677/Intuitive-Python-DFS-Solution | class Solution:
def uniquePathsIII(self, grid: List[List[int]]) -> int:
ROWS, COLS = len(grid), len(grid[0])
ROBOT = TARGET = ()
zeros = 0
# Locate robot and target positions and count number of zeros.
for r in range(ROWS):
for c in range(COLS):
if grid... | unique-paths-iii | Intuitive Python DFS Solution | Nibba2018 | 0 | 48 | unique paths iii | 980 | 0.797 | Hard | 15,909 |
https://leetcode.com/problems/unique-paths-iii/discuss/2318256/Python3-Clean-Iterative-DFS | class Solution:
def uniquePathsIII(self, grid: List[List[int]]) -> int:
m, n = len(grid), len(grid[0])
def dfs(start, empty):
res = 0
stack = [(start, set([start]), empty - 1)]
while stack:
(i, j), seen, empty_left = stack.pop()
... | unique-paths-iii | [Python3] Clean Iterative DFS | 0xRoxas | 0 | 35 | unique paths iii | 980 | 0.797 | Hard | 15,910 |
https://leetcode.com/problems/unique-paths-iii/discuss/2309001/Recursive-Tryout-with-Simple-Stop-Condition | class Solution:
def uniquePathsIII(self, grid: List[List[int]]) -> int:
M=len(grid) # row"
N=len(grid[0]) #col
obstacles=[]
for m in range(M):
for n in range(N):
if grid[m][n]==1:
s=(m,n)
if grid[m][n]==2:
... | unique-paths-iii | Recursive Tryout with Simple Stop Condition | syhaung | 0 | 10 | unique paths iii | 980 | 0.797 | Hard | 15,911 |
https://leetcode.com/problems/unique-paths-iii/discuss/2270783/Easy-Understanding-soln | class Solution:
def uniquePathsIII(self, grid: List[List[int]]) -> int:
# 1 -> starting
# 2 -> ending
# 0 -> empty spaces ( can walk over)
# -1 -> obstacles( can't walk over)
m, n = len(grid), len(grid[0])
zeros = 0
startingX, starting... | unique-paths-iii | Easy Understanding soln | logeshsrinivasans | 0 | 38 | unique paths iii | 980 | 0.797 | Hard | 15,912 |
https://leetcode.com/problems/unique-paths-iii/discuss/1983553/PYTHON-SOL-oror-FASTER-THAN-95-oror-BACKTRACKING-oror-WELL-EXPLAINED-oror-COMMENTED-oror | class Solution:
def backtracking(self,row,col,count):
# reach the end
if row == self.endrow and col == self.endcol:
if count == self.counts: self.ans += 1
return
# mark block as visited
self.vis[row][col] = True
# now we will try all ... | unique-paths-iii | PYTHON SOL || FASTER THAN 95% || BACKTRACKING || WELL EXPLAINED || COMMENTED || | reaper_27 | 0 | 116 | unique paths iii | 980 | 0.797 | Hard | 15,913 |
https://leetcode.com/problems/unique-paths-iii/discuss/1780324/Bitmask-python | class Solution:
def uniquePathsIII(self, grid: List[List[int]]) -> int:
m, n = len(grid), len(grid[0])
start = si = sj = 0
endgame = 0
for i in range(m):
for j in range(n):
idx = i * n + j
if grid[i][j] != -1:
... | unique-paths-iii | Bitmask python | yshawn | 0 | 37 | unique paths iii | 980 | 0.797 | Hard | 15,914 |
https://leetcode.com/problems/unique-paths-iii/discuss/1555492/Python3-or-Easy-or-DFS-Explained | class Solution:
def _dfs(self, i,j, grid, _visited, non_blocker_nodes, m,n):
_visited.add((i,j))
if grid[i][j] == 2 and len(_visited) == non_blocker_nodes:
_visited.remove((i,j))
return 1
_steps = [(0,1),(0,-1),(1,0),(-1,0)]
_ans = 0
for ... | unique-paths-iii | Python3 | Easy | DFS Explained | tg68 | 0 | 26 | unique paths iii | 980 | 0.797 | Hard | 15,915 |
https://leetcode.com/problems/unique-paths-iii/discuss/1555259/Using-sets-for-walked-paths-96-speed | class Solution:
def uniquePathsIII(self, grid: List[List[int]]) -> int:
zeros = set()
start, end = (0, 0), (0, 0)
for r, row in enumerate(grid):
for c, v in enumerate(row):
if v == 1:
start = (r, c)
elif v == 2:
... | unique-paths-iii | Using sets for walked paths, 96% speed | EvgenySH | 0 | 61 | unique paths iii | 980 | 0.797 | Hard | 15,916 |
https://leetcode.com/problems/unique-paths-iii/discuss/1554249/Python3-Fast-and-Memory-efficient | class Solution:
def uniquePathsIII(self, grid: List[List[int]]) -> int:
self.ans = 0
m = len(grid)
n = len(grid[0])
target_sum = 5 - m*n # start: 1, end: 2
start_i, start_j = None, None
for i, row in enumerate(grid):
for j, col in enumerate(row)... | unique-paths-iii | Python3 Fast and Memory-efficient | ynnekuw | 0 | 17 | unique paths iii | 980 | 0.797 | Hard | 15,917 |
https://leetcode.com/problems/unique-paths-iii/discuss/1462752/Simple-Python-O(3n)-brute-force-dfs-solution | class Solution:
def uniquePathsIII(self, grid: List[List[int]]) -> int:
def dfs(cur_i, cur_j):
if (cur_i, cur_j) == end or not empties:
if not empties:
self.ret += 1
return
for d_i, d_j in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
... | unique-paths-iii | Simple Python O(3^n) brute force dfs solution | Charlesl0129 | 0 | 87 | unique paths iii | 980 | 0.797 | Hard | 15,918 |
https://leetcode.com/problems/unique-paths-iii/discuss/1458196/PyPy3-Solution-using-DFS-w-comments | class Solution:
def uniquePathsIII(self, grid: List[List[int]]) -> int:
# Init
count = 0
m = len(grid)
n = len(grid[0])
# Assign start, end, obstacles and calculate total no. of
# nodes which can be visited before reaching the
# destination
... | unique-paths-iii | [Py/Py3] Solution using DFS w/ comments | ssshukla26 | 0 | 74 | unique paths iii | 980 | 0.797 | Hard | 15,919 |
https://leetcode.com/problems/unique-paths-iii/discuss/1409924/Fastest-Python-solution-(Backtrackingdfs)-with-better-understanding | class Solution:
def dfs(self, grid: List[List[int]], visitContext: List[List[bool]], x: int, y: int, remaining: int) -> int:
direction, output = [(0,1), (0,-1), (1,0), (-1,0)], 0
visitContext[x][y] = False
for i,j in direction:
dx, dy = x+i, y+j
if dx<0 or dx>len(grid... | unique-paths-iii | Fastest Python solution (Backtracking/dfs) with better understanding | abrarjahin | 0 | 76 | unique paths iii | 980 | 0.797 | Hard | 15,920 |
https://leetcode.com/problems/unique-paths-iii/discuss/1376595/python3-or-48ms-Backtracking | class Solution:
def uniquePathsIII(self, grid: List[List[int]]) -> int:
self.noc=0 #no of non-obstacle cell
self.ans=0
for i in range(len(grid)):
for j in range(len(grid[0])):
if grid[i][j]==0:
self.noc+=1 #counting no of non-obstacle cell
... | unique-paths-iii | python3 | 48ms Backtracking | swapnilsingh421 | 0 | 57 | unique paths iii | 980 | 0.797 | Hard | 15,921 |
https://leetcode.com/problems/unique-paths-iii/discuss/903602/Python-Clean-and-Simple | class Solution:
directions = [(1, 0), (0, 1), (-1, 0), (0, -1)]
def uniquePathsIII(self, grid: List[List[int]]) -> int:
row, col = len(grid), len(grid[0])
result, empty = [0], 1
sX, sY = 0, 0
for x, y in product(range(row), range(col)):
if grid[x][y] == 1:
... | unique-paths-iii | [Python] Clean & Simple | yo1995 | 0 | 66 | unique paths iii | 980 | 0.797 | Hard | 15,922 |
https://leetcode.com/problems/unique-paths-iii/discuss/856993/Python3-or-Simple-or-DFS-or-Explained-or-Annotated | class Solution:
def uniquePathsIII(self, grid):
self.ans = 0
n = len(grid)
m = len(grid[0])
def dfs(point, remain):
x = point[0]
y = point[1]
if grid[x][y] == -1:
return
if grid[x][y] == 2 and not r... | unique-paths-iii | [Python3] | Simple | DFS | Explained | Annotated | TanishqChaudhary | 0 | 35 | unique paths iii | 980 | 0.797 | Hard | 15,923 |
https://leetcode.com/problems/unique-paths-iii/discuss/804132/Python%3A-Easy!-Simple-DFS-Solution-oror-97-Faster | class Solution:
def uniquePathsIII(self, grid: List[List[int]]) -> int:
moves = ((1, 0), (-1, 0), (0, 1), (0, -1))
ans = 0
# ----------------------------------------------
def dfs(grid, r, c, vertexSet):
nonlocal ans, moves
vertexSet.remove((r, c))
... | unique-paths-iii | Python: Easy! Simple DFS Solution || 97% Faster | sameerkhurd | 0 | 130 | unique paths iii | 980 | 0.797 | Hard | 15,924 |
https://leetcode.com/problems/triples-with-bitwise-and-equal-to-zero/discuss/1257470/Python3-hash-table | class Solution:
def countTriplets(self, nums: List[int]) -> int:
freq = defaultdict(int)
for x in nums:
for y in nums:
freq[x&y] += 1
ans = 0
for x in nums:
mask = x = x ^ 0xffff
while x:
ans += freq... | triples-with-bitwise-and-equal-to-zero | [Python3] hash table | ye15 | 4 | 222 | triples with bitwise and equal to zero | 982 | 0.577 | Hard | 15,925 |
https://leetcode.com/problems/triples-with-bitwise-and-equal-to-zero/discuss/2667308/Python-Easy-Solution-beats-69.73 | class Solution:
def countTriplets(self, nums: List[int]) -> int:
freq = defaultdict(int)
for x in nums:
for y in nums:
freq[x&y] += 1
ans = 0
for x in nums:
mask = x = x ^ 0xffff
while x:
ans += freq... | triples-with-bitwise-and-equal-to-zero | Python Easy Solution beats 69.73% | mritunjayyy | 0 | 8 | triples with bitwise and equal to zero | 982 | 0.577 | Hard | 15,926 |
https://leetcode.com/problems/triples-with-bitwise-and-equal-to-zero/discuss/2483331/This-is-my-Python3-solution-oror-Easy-to-understand | class Solution:
def countTriplets(self, nums: List[int]) -> int:
ans = 0
mem = [0] * (1 << 16)
size = len(nums)
for i in range(size):
for j in range(i, size):
mem[nums[i]&nums[j]] += 2 if i != j else 1
for ij in range(1 << 16):
... | triples-with-bitwise-and-equal-to-zero | ✔️ This is my Python3 solution || Easy to understand | explusar | 0 | 33 | triples with bitwise and equal to zero | 982 | 0.577 | Hard | 15,927 |
https://leetcode.com/problems/minimum-cost-for-tickets/discuss/1219272/Python-O(N)-Runtime-O(N)-with-explanation | class Solution:
def mincostTickets(self, days: List[int], costs: List[int]) -> int:
#create the total costs for the days
costForDays = [0 for _ in range(days[-1] + 1) ]
#since days are sorted in ascending order, we only need the index of the days we haven't visited yet
curIdx = 0
for... | minimum-cost-for-tickets | Python O(N) Runtime O(N) with explanation | sherlockieee | 3 | 244 | minimum cost for tickets | 983 | 0.644 | Medium | 15,928 |
https://leetcode.com/problems/minimum-cost-for-tickets/discuss/1877186/Python3oror-O(n)-time-oror-O(max(days))-space | class Solution:
def mincostTickets(self, days: List[int], costs: List[int]) -> int:
dp = [0] * (days[-1]+1)
date = 0
for idx in range(1,len(dp)):
if idx == days[date]:
one_day = dp[idx-1] + costs[0]
seven_day = dp[idx-7] + costs[1] if idx - 7 >= 0... | minimum-cost-for-tickets | Python3|| O(n) time || O(max(days)) space | s_m_d_29 | 2 | 79 | minimum cost for tickets | 983 | 0.644 | Medium | 15,929 |
https://leetcode.com/problems/minimum-cost-for-tickets/discuss/1674020/Simple-DP-solution-in-Python | class Solution:
def mincostTickets(self, days: List[int], costs: List[int]) -> int:
# map the number of days per ticket to the cost
cost_map = {
1: costs[0],
7: costs[1],
30: costs[2],
}
travelling_days = set(days) # set of active travel ... | minimum-cost-for-tickets | Simple DP solution in Python | nat_5t34 | 1 | 84 | minimum cost for tickets | 983 | 0.644 | Medium | 15,930 |
https://leetcode.com/problems/minimum-cost-for-tickets/discuss/1199803/Python-Basic-Recursion | class Solution:
def mincostTickets(self, days: List[int], costs: List[int]) -> int:
days = set(days)
graph = {0 : 1, 1 : 7, 2: 30}
@functools.lru_cache(None)
def recurse(day, end):
if day > end:
return 0
... | minimum-cost-for-tickets | Python Basic Recursion | dev-josh | 1 | 159 | minimum cost for tickets | 983 | 0.644 | Medium | 15,931 |
https://leetcode.com/problems/minimum-cost-for-tickets/discuss/811167/Python3-dp-and-binary-search | class Solution:
def mincostTickets(self, days: List[int], costs: List[int]) -> int:
@lru_cache(None)
def fn(i):
"""Return minimum cost of traveling on days[i:]"""
if i == len(days): return 0 # boundary condition (no more travel)
ans = inf
for ... | minimum-cost-for-tickets | [Python3] dp & binary search | ye15 | 1 | 81 | minimum cost for tickets | 983 | 0.644 | Medium | 15,932 |
https://leetcode.com/problems/minimum-cost-for-tickets/discuss/347934/DP-python3-99 | class Solution:
def mincostTickets(self, days: List[int], costs: List[int]) -> int:
cost_of_day = [0] * 366
for index, day in enumerate(days):
if index == 0:
cost_of_day[day] = min(costs)
continue
for i in range(days[index-1]+1, d... | minimum-cost-for-tickets | DP python3 99% | pingruchou1125tw | 1 | 107 | minimum cost for tickets | 983 | 0.644 | Medium | 15,933 |
https://leetcode.com/problems/minimum-cost-for-tickets/discuss/2656214/Easy-Python-DP-with-comments | class Solution:
def mincostTickets(self, days: List[int], costs: List[int]) -> int:
days = sorted(days)
res = [0] * (days[-1] + 1) # represent each day.
start = days[0]
res[start] = min(costs) # in case day 7 pass is cheaper than day 1
days = set(days)
for d in r... | minimum-cost-for-tickets | Easy Python DP with comments | xiangyupeng1994 | 0 | 6 | minimum cost for tickets | 983 | 0.644 | Medium | 15,934 |
https://leetcode.com/problems/minimum-cost-for-tickets/discuss/2636741/Clean-Fast-Python3-or-Bottom-Up-DP-or-9-Lines | class Solution:
def mincostTickets(self, days: List[int], costs: List[int]) -> int:
travel = [False] * (days[-1]) + [True] * 31
for day in days: travel[day] = True
dp = [0] * (days[-1] + 31)
for i in range(days[-1], -1, -1):
if travel[i]:
dp[i] = min(costs... | minimum-cost-for-tickets | Clean, Fast Python3 | Bottom Up DP | 9 Lines | ryangrayson | 0 | 7 | minimum cost for tickets | 983 | 0.644 | Medium | 15,935 |
https://leetcode.com/problems/minimum-cost-for-tickets/discuss/2495967/Python3-solution%3A-faster-than-most-submissions-oror-Very-simple | class Solution:
def mincostTickets(self, days: List[int], costs: List[int]) -> int:
min_cost = float('inf')
que = deque()
# enqueue the possible state of day 1
que.append((days[0], costs[0]))
que.append((days[0]+7-1, costs[1]))
que.append((days[0]+30-1, costs[2]))
... | minimum-cost-for-tickets | ✔️ Python3 solution: faster than most submissions || Very simple | explusar | 0 | 57 | minimum cost for tickets | 983 | 0.644 | Medium | 15,936 |
https://leetcode.com/problems/minimum-cost-for-tickets/discuss/2318046/Python-Memoized-Solution | class Solution(object):
def mincostTickets(self,days, costs):
dp = {}
def index_finder(i,days,arr):
key = arr[i]
while i<len(arr) and arr[i]< key+days:
i+=1
return i
def solve(days,i,costs):
if i>=len(days):
... | minimum-cost-for-tickets | Python Memoized Solution | Abhi_009 | 0 | 34 | minimum cost for tickets | 983 | 0.644 | Medium | 15,937 |
https://leetcode.com/problems/minimum-cost-for-tickets/discuss/2156588/Python-clean-DP | class Solution:
def mincostTickets(self, days: List[int], costs: List[int]) -> int:
dp = [0] * (366 + 30)
days = set(days)
for day in range(365, 0, -1):
if day in days:
dp[day] = min(dp[day+1] + costs[0], dp[day+7] + costs[1], dp[day+30] + costs[2])
el... | minimum-cost-for-tickets | Python, clean DP | blue_sky5 | 0 | 35 | minimum cost for tickets | 983 | 0.644 | Medium | 15,938 |
https://leetcode.com/problems/minimum-cost-for-tickets/discuss/1984076/PYTHON-SOL-oror-DP-oror-TABULAR-METHOR-oror-LINEAR-SOLUTION-oror-WELL-EXPLAINED-oror | class Solution:
def mincostTickets(self, days: List[int], costs: List[int]) -> int:
dp = [0]*366
d = {x:True for x in days}
for i in range(366):
if i in d:
tmp1 = dp[i-1] if i>=1 else 0
tmp2 = dp[i-7] if i>=7 else 0
tmp3 = dp[i-30] ... | minimum-cost-for-tickets | PYTHON SOL || DP || TABULAR METHOR || LINEAR SOLUTION || WELL EXPLAINED || | reaper_27 | 0 | 61 | minimum cost for tickets | 983 | 0.644 | Medium | 15,939 |
https://leetcode.com/problems/minimum-cost-for-tickets/discuss/1817389/Python-easy-to-read-and-understand-or-DP | class Solution:
def find(self, days, i, target):
while i < len(days) and days[i] <= target:
i = i+1
return i
def solve(self, days, costs, i):
if i >= len(days):
return 0
x1 = self.solve(days, costs, i+1) + costs[0]
index = self.find(days, i, d... | minimum-cost-for-tickets | Python easy to read and understand | DP | sanial2001 | 0 | 137 | minimum cost for tickets | 983 | 0.644 | Medium | 15,940 |
https://leetcode.com/problems/minimum-cost-for-tickets/discuss/1817389/Python-easy-to-read-and-understand-or-DP | class Solution:
def find(self, days, i, target):
while i < len(days) and days[i] <= target:
i = i+1
return i
def solve(self, days, costs, i, d):
if i >= len(days):
return 0
if i in d:
return d[i]
x1 = self.solve(days, costs, i+1, d... | minimum-cost-for-tickets | Python easy to read and understand | DP | sanial2001 | 0 | 137 | minimum cost for tickets | 983 | 0.644 | Medium | 15,941 |
https://leetcode.com/problems/minimum-cost-for-tickets/discuss/1782976/Java-Python3-Simple-DP-Solution-(Top-Down-and-Bottom-Up) | class Solution:
def mincostTickets(self, days: List[int], costs: List[int]) -> int:
@lru_cache(None)
def dp(day: int) -> int:
if day > days[-1]:
return 0
if day == days[-1]:
return min(costs)
else:
i = 0
... | minimum-cost-for-tickets | ✅ [Java / Python3] Simple DP Solution (Top-Down & Bottom-Up) | JawadNoor | 0 | 56 | minimum cost for tickets | 983 | 0.644 | Medium | 15,942 |
https://leetcode.com/problems/minimum-cost-for-tickets/discuss/1782976/Java-Python3-Simple-DP-Solution-(Top-Down-and-Bottom-Up) | class Solution:
def mincostTickets(self, days: List[int], costs: List[int]) -> int:
dp = [0]*(days[-1]+1)
for i in range(len(dp)):
if i in days:
dp[i] = min(dp[max(0, i-1)]+costs[0],
dp[max(0, i-7)]+costs[1], dp[max(0, i-30)]+costs[2])
... | minimum-cost-for-tickets | ✅ [Java / Python3] Simple DP Solution (Top-Down & Bottom-Up) | JawadNoor | 0 | 56 | minimum cost for tickets | 983 | 0.644 | Medium | 15,943 |
https://leetcode.com/problems/string-without-aaa-or-bbb/discuss/1729883/Python-beats-91 | class Solution:
def strWithout3a3b(self, a: int, b: int) -> str:
res = []
while a + b > 0:
if len(res) >= 2 and res[-2:] == ['a', 'a']:
res.append('b')
b-=1
elif len(res) >= 2 and res[-2:] == ['b', 'b']:
res.append('a')
... | string-without-aaa-or-bbb | Python beats 91% | leopardcoderd | 1 | 104 | string without aaa or bbb | 984 | 0.43 | Medium | 15,944 |
https://leetcode.com/problems/string-without-aaa-or-bbb/discuss/984024/Python3-greedy-O(N) | class Solution:
def strWithout3a3b(self, a: int, b: int) -> str:
ans = []
while a and b:
if ans[-2:] == ["b"]*2 or 2*b < a:
ans.append("a")
a -= 1
else:
ans.append("b")
b -= 1
ans.extend(a*["a"] + b*["... | string-without-aaa-or-bbb | [Python3] greedy O(N) | ye15 | 1 | 63 | string without aaa or bbb | 984 | 0.43 | Medium | 15,945 |
https://leetcode.com/problems/string-without-aaa-or-bbb/discuss/1984137/PYTHON-SOL-oror-VERY-EASY-AND-INTUATIVE-oror-WELL-EXPLAINED-oror-GREEDY-oror | class Solution:
def strWithout3a3b(self, a: int, b: int) -> str:
n = a + b
fill = 'a' if a >= b else 'b'
ma = a if a >= b else b
mi = a if a < b else b
string = [None]*n
index = 0
while ma > 0 :
string[index] = fill
index += 3
... | string-without-aaa-or-bbb | PYTHON SOL || VERY EASY AND INTUATIVE || WELL EXPLAINED || GREEDY || | reaper_27 | 0 | 80 | string without aaa or bbb | 984 | 0.43 | Medium | 15,946 |
https://leetcode.com/problems/string-without-aaa-or-bbb/discuss/1856391/Python-Solution-Heap | class Solution:
def strWithout3a3b(self, a: int, b: int) -> str:
heap = []
if a > 0:
heapq.heappush(heap, (-a, 'a'))
if b > 0:
heapq.heappush(heap, (-b, 'b'))
s = ''
while heap:
try:
curr_char_remain, current_char =... | string-without-aaa-or-bbb | Python Solution Heap | DietCoke777 | 0 | 19 | string without aaa or bbb | 984 | 0.43 | Medium | 15,947 |
https://leetcode.com/problems/string-without-aaa-or-bbb/discuss/1625750/Python-3-O(n)-solution | class Solution:
def strWithout3a3b(self, a: int, b: int) -> str:
# n = current # of consecutive chracters in res that are the same
# positive if it's consecutive as, negative if it's bs
n = 0
res = ''
while a and b:
if n == -2 or (n != 2 and a >= b):
res += 'a... | string-without-aaa-or-bbb | Python 3 O(n) solution | dereky4 | 0 | 116 | string without aaa or bbb | 984 | 0.43 | Medium | 15,948 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/2603372/LeetCode-The-Hard-Way-Explained-Line-By-Line | class Solution:
# the idea is we don't calculate the even sum from scratch for each query
# instead, we calculate it at the beginning
# since each query only updates one value,
# so we can adjust the even sum base on the original value and new value
def sumEvenAfterQueries(self, nums: List[int], qu... | sum-of-even-numbers-after-queries | 🔥 [LeetCode The Hard Way] 🔥 Explained Line By Line | wingkwong | 58 | 3,200 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,949 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/2603332/Easy-python-solution | class Solution:
def sumEvenAfterQueries(self, nums: List[int], queries: List[List[int]]) -> List[int]:
sm=0
for i in range(len(nums)):
if nums[i]%2==0:
sm+=nums[i]
lst=[]
for i in range(len(queries)):
prev=nums[queries[i][1]]
nums[q... | sum-of-even-numbers-after-queries | Easy python solution | shubham_1307 | 5 | 575 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,950 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/2603228/Python-Segment-Tree-Approach-%2B-Query-Traversal-Approach | class Solution:
# Simple query traversal approach
# Check if previously the nums element was even or odd
# If it was even we just need to remove it or update the ressum based on the new result being even or odd
# If it was odd we need to add to the ressum only if the new value becomes even
def sumEvenAfterQu... | sum-of-even-numbers-after-queries | Python Segment Tree Approach + Query Traversal Approach | shiv-codes | 2 | 80 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,951 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/2169359/Python3-Runtime%3A-583ms-72.40-oror-memory%3A-20.5mb-37.69 | class Solution:
# O(n) || O(1)
# Runtime: 583ms 72.40% || memory: 20.5mb 37.69%
def sumEvenAfterQueries(self, nums: List[int], queries: List[List[int]]) -> List[int]:
totalEvenNumSum = sum([num for num in nums if num % 2 == 0])
result = []
for val, idx in queries:
oldVal = ... | sum-of-even-numbers-after-queries | Python3 Runtime: 583ms 72.40% || memory: 20.5mb 37.69% | arshergon | 2 | 101 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,952 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/2606821/python3-pretty-short-solution | class Solution:
def sumEvenAfterQueries(self, nums: List[int], queries: List[List[int]]) -> List[int]:
res=[]
cur_sum=sum([i for i in nums if not i%2])
for q in queries:
if not nums[q[1]]%2:
cur_sum-=nums[q[1]]
nums[q[1]]+=q[0]
if not nums[... | sum-of-even-numbers-after-queries | python3 pretty short solution | benon | 1 | 38 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,953 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/2605677/SIMPLEST-PYTHON-SOLUTION(Memory-Usage%3A-20.4-MB-less-than-75.51-of-Python3) | class Solution:
def sumEvenAfterQueries(self, nums: List[int], queries: List[List[int]]) -> List[int]:
ans=list()
asum=0
for i in nums:
if i%2==0:
asum+=i
else: continue
subans=asum
for j in queries:
if nums[j[1]]%2==0:
... | sum-of-even-numbers-after-queries | SIMPLEST PYTHON SOLUTION(Memory Usage: 20.4 MB, less than 75.51% of Python3) | DG-Problemsolver | 1 | 39 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,954 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/2605548/Python-Easy-Solution-~-Brute-force | class Solution:
def sumEvenAfterQueries(self, nums: List[int], queries: List[List[int]]) -> List[int]:
res = []
total = sum(list(filter(lambda x: (x%2==0),nums)))
for i in range(len(queries)):
val = queries[i][0]
index = queries[i][1]
num = nums[i... | sum-of-even-numbers-after-queries | Python Easy Solution ~ Brute force | Shivam_Raj_Sharma | 1 | 18 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,955 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/2603527/Python-O(n) | class Solution:
def sumEvenAfterQueries(self, nums: List[int], queries: List[List[int]]) -> List[int]:
se = 0
ans = []
for i in nums:
if(i%2==0):
se += i
for i in queries:
if(nums[i[1]]%2 and i[0]%2):
se+= nums[i[1]] + i[0]
... | sum-of-even-numbers-after-queries | Python O(n) | Pradyumankannan | 1 | 47 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,956 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/2603266/python3-or-easy-or-array-or-even-sum | class Solution:
def sumEvenAfterQueries(self, nums: List[int], queries: List[List[int]]) -> List[int]:
res, s = [], 0
for i, e in enumerate(nums):
if e%2==0: s += e
for val, index in queries:
if nums[index] % 2 == 0: s -= nums[index]
nums[index] += val
... | sum-of-even-numbers-after-queries | python3 | easy | array | even sum | H-R-S | 1 | 49 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,957 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/1033838/Same-Idea-As-the-Solution-(though-slightly-complex)-With-Clear-Comments! | class Solution:
def sumEvenAfterQueries(self, A: List[int], queries: List[List[int]]) -> List[int]:
# time limit exceeded
# outSum = []
# for query in queries:
# A[query[1]] += query[0]
# outSum.append(sum([i for i in A if i%2 == 0 ]))
# return outSum
... | sum-of-even-numbers-after-queries | Same Idea As the Solution (though slightly complex) With Clear Comments! | Yan_Air | 1 | 168 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,958 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/805245/simple-of-simple | class Solution:
def sumEvenAfterQueries(self, A: List[int], queries: List[List[int]]) -> List[int]:
answer = []
s = 0
for i in A:
if i % 2 == 0:
s += i
for q in queries:
t = A[q[1]]
if t % 2 == 0:
... | sum-of-even-numbers-after-queries | simple of simple | seunggabi | 1 | 101 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,959 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/2803265/Python-or-Simple-or-Short | class Solution:
def sumEvenAfterQueries(self, nums: List[int], queries: List[List[int]]) -> List[int]:
s = 0
ans = []
# storing sum of all even elements in s
for ele in nums:
if ele % 2 == 0:
s += ele
# iterating queries
for q in q... | sum-of-even-numbers-after-queries | Python | Simple | Short | imkprakash | 0 | 1 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,960 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/2607559/Java-or-Python3-or-JavaScript-Solution-simple-few-lines.-O(N-%2B-M)-time-O(1)-space. | class Solution:
def sumEvenAfterQueries(self, nums: List[int], queries: List[List[int]]) -> List[int]:
sum = 0
res = []
for num in nums:
if num%2 == 0:
sum += num
for query in queries:
if nums[query[1]]%2 == 0:
sum -= nums[query... | sum-of-even-numbers-after-queries | Java | Python3 | JavaScript Solution simple, few lines. O(N + M) time O(1) space. | Angelus_ | 0 | 13 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,961 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/2607011/Python3-or-CPP-or-O(N)-or-Simple | class Solution:
def sumEvenAfterQueries(self, nums: List[int], queries: List[List[int]]) -> List[int]:
ans = []
even_nums = [num for num in nums if not num % 2 ]
sm = sum(even_nums)
for val, index in queries:
num = nums[index]
tmp = num + val
if no... | sum-of-even-numbers-after-queries | Python3 | CPP | O(N) | Simple | joshua_mur | 0 | 9 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,962 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/2606987/Python-Straight-forward | class Solution:
def sumEvenAfterQueries(self, nums: List[int], queries: List[List[int]]) -> List[int]:
# even + even = add value to tot
# odd + odd = add both
# even + odd = subtract nums[i]
# odd + even = no changes
tot = sum(i for i in nums if i%2==0)
... | sum-of-even-numbers-after-queries | Python - Straight forward | lokeshsenthilkumar | 0 | 8 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,963 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/2606333/Python-or-Simple-or-SOLUTION-or-FASTER-than-93.37 | class Solution:
def sumEvenAfterQueries(self, nums: List[int], queries: List[List[int]]) -> List[int]:
res=[]
s=0
for i in nums:
if i%2==0:
s+=i
for v,i in queries:
if nums[i]%2==0:
s=s-nums[i]
t=nums[i]+v
... | sum-of-even-numbers-after-queries | Python | Simple | SOLUTION | FASTER than 93.37% | manav023 | 0 | 13 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,964 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/2606175/Intuitive-solution-in-Python-3-with-inline-comments | class Solution:
def sumEvenAfterQueries(self, N: List[int], Q: List[List[int]]) -> List[int]:
def gen():
s = sum(n for n in N if not n & 1)
for v, index in Q:
# prev is the value before N[index] gets queried
prev, N[index] = N[index], N[index] + v
... | sum-of-even-numbers-after-queries | Intuitive solution in Python 3 with inline comments | mousun224 | 0 | 3 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,965 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/2605568/Python-Simple-Python-Solution | class Solution:
def sumEvenAfterQueries(self, nums: List[int], queries: List[List[int]]) -> List[int]:
result = []
even_sum = 0
for num in nums:
if num % 2 == 0:
even_sum = even_sum + num
for query in queries:
value, index = query
current_value = nums[index]
updated_value = nums[index]... | sum-of-even-numbers-after-queries | [ Python ] ✅✅ Simple Python Solution 🥳✌👍 | ASHOK_KUMAR_MEGHVANSHI | 0 | 26 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,966 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/2605391/Python-or-Easy-understanding-or-based-on-just-even-odd | class Solution:
def sumEvenAfterQueries(self, nums: List[int], queries: List[List[int]]) -> List[int]:
even_sum=0
for i in nums:
if i%2==0:
even_sum+=i
res=[]
for i in range(0,len(queries)):
x,y=queries[i]
if nums[y]%2==0:
... | sum-of-even-numbers-after-queries | Python | Easy understanding | based on just even odd | Mom94 | 0 | 3 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,967 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/2605261/python3-or-easy-or-O(N) | class Solution:
def sumEvenAfterQueries(self, nums: List[int], queries: List[List[int]]) -> List[int]:
s = 0
ans = []
for i in nums:
if i %2 == 0:
s += i
for v,i in queries:
if nums[i] % 2 != 0:
nums[i] += v
... | sum-of-even-numbers-after-queries | python3 | easy | O(N) | jayeshmaheshwari555 | 0 | 5 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,968 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/2605039/python-code | class Solution:
def sumEvenAfterQueries(self, nums: List[int], queries: List[List[int]]) -> List[int]:
answer=[]
currsum=0
#find sum of all even numbers in nums and store in a variable
for i in nums:
if i%2==0:
currsum+=i
for i in queries:
... | sum-of-even-numbers-after-queries | python code | ayushigupta2409 | 0 | 13 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,969 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/2605008/Python3-oror-99-Fasteroror-O(N%2BQ)-Time | class Solution:
def sumEvenAfterQueries(self, nums: List[int], queries: List[List[int]]) -> List[int]:
evesum = 0
for num in nums:
if not num%2: evesum += num
res = []
for val, ind in queries:
if not nums[ind] % 2:
evesum -= n... | sum-of-even-numbers-after-queries | Python3 || 99% Faster🚀|| O(N+Q) Time | Dewang_Patil | 0 | 6 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,970 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/2604826/Python-Simple-Solution-or-O(n)-or-99-faster | class Solution:
def sumEvenAfterQueries(self, nums: List[int], queries: List[List[int]]) -> List[int]:
running_even_sum = sum(i for i in nums if i % 2 == 0)
res = []
for val, idx in queries:
# Check if the initial value / final value at the particular index are even or not... | sum-of-even-numbers-after-queries | ✅ Python Simple Solution | O(n) | 99% faster | Nk0311 | 0 | 9 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,971 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/2604819/Python-easy-solution | class Solution:
def sumEvenAfterQueries(self, nums: List[int], queries: List[List[int]]) -> List[int]:
answer = []
sum_even = sum([num for num in nums if num%2 == 0]) # sum of even numbers at first
for val, index in queries:
if nums[index] % 2 == 0:... | sum-of-even-numbers-after-queries | Python easy solution | remenraj | 0 | 5 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,972 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/2604762/Simple-%22python%22-Solution | class Solution:
def sumEvenAfterQueries(self, nums: List[int], queries: List[List[int]]) -> List[int]:
evnesum = sum(i for i in nums if i % 2 == 0)
for i in range(len(queries)):
val, id = queries[i]
if nums[id] % 2 == 0: evnesum -= nums[id]
nums[id] += val
... | sum-of-even-numbers-after-queries | Simple "python" Solution | anandchauhan8791 | 0 | 8 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,973 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/2604652/Ezy-to-understand-python3-solution | class Solution:
# O(n+q) time, q --> len(queries), n --> len(nums)
# O(q) space,
# Approach: simulation,
def sumEvenAfterQueries(self, nums: List[int], queries: List[List[int]]) -> List[int]:
even_sum = 0
ans = []
for num in nums:
if num % 2 == 0:
... | sum-of-even-numbers-after-queries | Ezy to understand python3 solution | destifo | 0 | 3 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,974 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/2604610/Python3-Straightforward-Solution | class Solution:
def sumEvenAfterQueries(self, nums: List[int], queries: List[List[int]]) -> List[int]:
res = []
sumEven = sum(n for n in nums if not n%2)
for q,i in queries:
if nums[i]%2 and q%2:
sumEven += nums[i]+q
elif not nums[i]%2 and q%2:
... | sum-of-even-numbers-after-queries | [Python3] Straightforward Solution | ruosengao | 0 | 5 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,975 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/2604514/Python3-Runtime%3A-497-ms-faster-than-100.00-of-Python3-online-submissions | class Solution:
def sumEvenAfterQueries(self, nums: List[int], queries: List[List[int]]) -> List[int]:
ret = []
evenSum = 0
for _ in nums:
if not _ & 1:
evenSum += _
for val, idx in queries:
num = nums[idx]
evenSum = evenSum - n... | sum-of-even-numbers-after-queries | [Python3] Runtime: 497 ms, faster than 100.00% of Python3 online submissions | geka32 | 0 | 8 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,976 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/2604472/Easy-Python-Solution-with-comments-oror-O(n)-Time-complexity | class Solution:
def sumEvenAfterQueries(self, nums: List[int], queries: List[List[int]]) -> List[int]:
# Calculating the initial even_sum
even_sum = 0
for num in nums:
if(num % 2 == 0):
even_sum += num
ans = []
# Loop in each ... | sum-of-even-numbers-after-queries | Easy Python Solution with comments || O(n) Time complexity | vanshika_2507 | 0 | 6 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,977 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/2604242/Easy-Python-Solution-or-Basic-intuition | class Solution:
def sumEvenAfterQueries(self, nums: List[int], queries: List[List[int]]) -> List[int]:
ans = []
res = 0
for j in nums:
if j&1==0:
res += j
for i in queries:
temp = nums[i[1]]
nums[i[1]] = nums[i[1]] + i[0]
... | sum-of-even-numbers-after-queries | Easy Python Solution | Basic intuition | RajatGanguly | 0 | 5 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,978 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/2604214/Python3-or-Easy-solutionor-Faster-97 | class Solution:
def sumEvenAfterQueries(self, nums: List[int], queries: List[List[int]]) -> List[int]:
res, even = [], sum(num for num in nums if not num % 2)
for v, i in queries:
if not nums[i] % 2: even -= nums[i]
nums[i] += v
if not nums[i] % 2: even += nums[i]... | sum-of-even-numbers-after-queries | ✅ Python3 | Easy solution| Faster 97% ✅ | abdoohossamm | 0 | 7 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,979 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/2604083/Python3-or-O(n)-Easy-Solution | class Solution:
def sumEvenAfterQueries(self, nums: List[int], queries: List[List[int]]) -> List[int]:
es = 0
arr = []
for i in nums:
if i%2 == 0:
es += i
for i in queries:
if((nums[i[1]]+i[0])%2 == 0 and nums[i[1]]%2 == 0):
es ... | sum-of-even-numbers-after-queries | Python3 | O(n) Easy Solution | urmil_kalaria | 0 | 4 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,980 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/2604064/GolangPython-O(N%2BQ)-time-or-O(Q)-space | class Solution:
def sumEvenAfterQueries(self, nums: List[int], queries: List[List[int]]) -> List[int]:
evens_sum = 0
for item in nums:
if item % 2 == 0:
evens_sum+=item
answer = []
for add,i in queries:
if nums[i] % 2 == 0:
even... | sum-of-even-numbers-after-queries | Golang/Python O(N+Q) time | O(Q) space | vtalantsev | 0 | 6 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,981 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/2603905/Python-Simple-O(n)-Solution-or-Beats-90-time | class Solution:
def sumEvenAfterQueries(self, nums: List[int], queries: List[List[int]]) -> List[int]:
res = []
total_sum = 0
for i in range(len(nums)):
if nums[i] % 2 == 0:
total_sum += nums[i]
for v, i in queries:
p... | sum-of-even-numbers-after-queries | Python Simple O(n) Solution | Beats 90% time | dos_77 | 0 | 5 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,982 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/2603749/SIMPLE-PYTHON3-SOLUTION-faster-and-easy-to-understand | class Solution:
def sumEvenAfterQueries(self, nums: List[int], queries: List[List[int]]) -> List[int]:
even_sum = sum(v for v in nums if v % 2 == 0)
res: list[int] = []
for val, idx in queries:
if nums[idx] % 2 == 0:
even_sum -= nums[idx]
... | sum-of-even-numbers-after-queries | ✅✔ SIMPLE PYTHON3 SOLUTION ✅✔ faster and easy to understand | rajukommula | 0 | 6 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,983 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/2603692/Python-Solution-or-Simulation-or-Brute-Force | class Solution:
def sumEvenAfterQueries(self, nums: List[int], queries: List[List[int]]) -> List[int]:
ans=[]
evenSum=0
for num in nums:
if num%2==0:
evenSum+=num
for query in queries:
val=query[0]
index=query[1]
if nums... | sum-of-even-numbers-after-queries | Python Solution | Simulation | Brute Force | Siddharth_singh | 0 | 7 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,984 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/2603603/Sum-of-Even-Numbers-After-Queries-Python-or-Java | class Solution:
def sumEvenAfterQueries(self, nums: List[int], queries: List[List[int]]) -> List[int]:
sm=0
for i in range(len(nums)):
if nums[i]%2==0:
sm+=nums[i]
lst=[]
for i in range(len(queries)):
prev=nums[queries[i][1]]
nums[q... | sum-of-even-numbers-after-queries | Sum of Even Numbers After Queries [ Python | Java ] | klu_2100031497 | 0 | 11 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,985 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/2603574/Easy-Python-Accepted | class Solution:
def sumEvenAfterQueries(self, A: List[int], queries: List[List[int]]) -> List[int]:
S, Q = sum([i for i in A if i % 2 == 0]), []
for [v,i] in queries:
a = A[i]
A[i] += v
if a % 2 == 0:
if v % 2 == 0: S += v
else: S -= a
elif v % 2 == 1: S += A[i]
... | sum-of-even-numbers-after-queries | Easy Python Accepted ✅ | Khacker | 0 | 11 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,986 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/2603562/Python3-Runtime%3A-510-ms-faster-than-99.12-or-Memory%3A-20.3-MB-less-than-97.08 | class Solution:
def sumEvenAfterQueries(self, nums: List[int], queries: List[List[int]]) -> List[int]:
even_sum = 0
for n in nums:
if n & 1 == 0:
even_sum += n
ans = []
for val, idx in queries:
new_val = nums[idx] + val
if nums[... | sum-of-even-numbers-after-queries | [Python3] Runtime: 510 ms, faster than 99.12% | Memory: 20.3 MB, less than 97.08% | anubhabishere | 0 | 6 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,987 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/2603391/Python-or-Hash(dict)-or-Straight-solution-or | class Solution:
def sumEvenAfterQueries(self, nums: List[int], queries: List[List[int]]) -> List[int]:
ans = []
h = {}
for i in range(len(nums)):
if nums[i]%2==0:
h[i] = nums[i]
s = sum(h.values())
for val,idx in queries:... | sum-of-even-numbers-after-queries | Python | Hash(dict) | Straight solution | | Brillianttyagi | 0 | 8 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,988 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/2603337/Python-or-O(n)-or-Easy-and-simple-solution-explained | class Solution(object):
def sumEvenAfterQueries(self, nums, queries):
"""
:type nums: List[int]
:type queries: List[List[int]]
:rtype: List[int]
"""
current_sum = 0
res = []
#Summing all the even numbers in num
for num in nums:
... | sum-of-even-numbers-after-queries | Python | O(n) | Easy and simple solution explained | iLikeBreathing | 0 | 13 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,989 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/2144005/python-3-oror-simple-O(n)-solution | class Solution:
def sumEvenAfterQueries(self, nums: List[int], queries: List[List[int]]) -> List[int]:
evenSum = sum(num for num in nums if not num % 2)
answer = []
for val, i in queries:
if not nums[i] % 2:
if not val % 2:
evenSum += ... | sum-of-even-numbers-after-queries | python 3 || simple O(n) solution | dereky4 | 0 | 58 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,990 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/1993750/Python-Solution-or-Over-90-Faster-or-Conditional-Arithmetic-Based-or-Clean-Code | class Solution:
def sumEvenAfterQueries(self, nums: List[int], queries: List[List[int]]) -> List[int]:
total = sum(n for n in nums if not (n & 1))
store = []
for val,idx in queries:
ogVal = nums[idx]
nums[idx] += val
if not (ogVal & 1):
... | sum-of-even-numbers-after-queries | Python Solution | Over 90% Faster | Conditional Arithmetic Based | Clean Code | Gautam_ProMax | 0 | 39 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,991 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/1986072/PYTHON-SOL-oror-EXPLAINED-oror-LINEAR-SOL-oror-COMMENTED-oror-EASY-oror | class Solution:
def sumEvenAfterQueries(self, nums: List[int], queries: List[List[int]]) -> List[int]:
# queries[i] = [val,index]
# for each query i
# nums[index] = nums[index] + bal
# print the sum of the even values of nums
# nums = [1,2,3,4] , queries = [[1,0],[-... | sum-of-even-numbers-after-queries | PYTHON SOL || EXPLAINED || LINEAR SOL || COMMENTED || EASY || | reaper_27 | 0 | 38 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,992 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/1445985/python-or-better-than-99 | class Solution:
def sumEvenAfterQueries(self, arr: List[int], queries: List[List[int]]) -> List[int]:
es=0
for i in arr:
if i%2==0:
es+=i
ans=[]
print(es)
for i,j in queries:
if (arr[j]%2==0 and i%2==0):
es+=i
... | sum-of-even-numbers-after-queries | python | better than 99% | heisenbarg | 0 | 136 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,993 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/1415519/Detailed-Explanation-Keep-track-of-even_sum-at-all-times-%3A) | class Solution:
def sumEvenAfterQueries(self, nums: List[int], queries: List[List[int]]) -> List[int]:
even_sum = sum(x for x in nums if x % 2 == 0)
answer = []
for val, idx in queries:
if nums[idx] % 2 == 0:
# his old value was a part of even_sum!
... | sum-of-even-numbers-after-queries | Detailed Explanation Keep track of even_sum at all times :) | yozaam | 0 | 51 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,994 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/924715/Python%3A-O(N)-Time-%2B-Space-(No-CounterZip) | class Solution:
def sumEvenAfterQueries(self, A: List[int], queries: List[List[int]]) -> List[int]:
output = []
even_sum = sum(filter(lambda x: x%2==0, A))
# Linear Scan
# the even_sum changes depending on the parity of the element before
# and after the new value is added
for i in ran... | sum-of-even-numbers-after-queries | Python: O(N) Time + Space (No Counter/Zip) | JuanTheDoggo | 0 | 120 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,995 |
https://leetcode.com/problems/sum-of-even-numbers-after-queries/discuss/751235/Fast-and-easy-python-solution | class Solution:
def sumEvenAfterQueries(self, A: List[int], queries: List[List[int]]) -> List[int]:
s=0
a=[0]*len(queries)
for i in A:
if i%2==0:
s+=i
for i in range(len(queries)):
indx=queries[i][1]
val=queries[i][... | sum-of-even-numbers-after-queries | Fast and easy python solution | NvsYashwanth | 0 | 107 | sum of even numbers after queries | 985 | 0.682 | Medium | 15,996 |
https://leetcode.com/problems/interval-list-intersections/discuss/646939/Python-O(m%2Bn)-by-two-pointers.w-Graph | class Solution:
def intervalIntersection(self, A: List[List[int]], B: List[List[int]]) -> List[List[int]]:
idx_a, idx_b = 0, 0
size_a, size_b = len(A), len(B)
intersection = []
# Scan each possible interval pair
while idx_a < size_a and idx_b < size... | interval-list-intersections | Python O(m+n) by two-pointers.[w/ Graph] | brianchiang_tw | 3 | 264 | interval list intersections | 986 | 0.714 | Medium | 15,997 |
https://leetcode.com/problems/interval-list-intersections/discuss/2215014/Python-or-Using-two-pointers-or-99-faster-submissions-with-comments | class Solution:
def intervalIntersection(self, firstList: List[List[int]], secondList: List[List[int]]) -> List[List[int]]:
res = []
s,e = 0,1
i,j = 0,0
while i < len(firstList) and j < len(secondList):
a = firstList[i] # fetching the interval
b = sec... | interval-list-intersections | Python | Using two pointers | 99% faster submissions with comments | __Asrar | 2 | 82 | interval list intersections | 986 | 0.714 | Medium | 15,998 |
https://leetcode.com/problems/interval-list-intersections/discuss/1854925/Python-easy-to-read-and-understand-or-two-pointers | class Solution:
def intervalIntersection(self, a: List[List[int]], b: List[List[int]]) -> List[List[int]]:
ans = []
i, j = 0, 0
while i < len(a) and j < len(b):
ai, aj = a[i]
bi, bj = b[j]
if bj >= ai and aj >= bi:
ans... | interval-list-intersections | Python easy to read and understand | two pointers | sanial2001 | 2 | 84 | interval list intersections | 986 | 0.714 | Medium | 15,999 |
Subsets and Splits
Top 2 Solutions by Upvotes
Identifies the top 2 highest upvoted Python solutions for each problem, providing insight into popular approaches.