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/using-a-robot-to-print-the-lexicographically-smallest-string/discuss/2679020/Python-or-Stack-or-Clean-Explained-and-Easy-to-Understand | class Solution:
def robotWithString(self, s: str) -> str:
st = []
g = Counter(s)
f = sorted(list(set(s)))
f.append('z')
cur = 0
re = []
for i in s:
if i != f[cur]:
st.append(i)
g[i] -= 1
while(g[f[cur]] == 0) and cur < len(f) - 1: cur+=1
else:
re.append(i)
g[i] -= 1
while(g[f[cur]] == 0) and cur < len(f) - 1: cur+=1
while(st and st[-1] <= f[cur]):
re.append(st.pop())
while st: re.append(st.pop())
# print(cur, f, g, re)
return ''.join(re) | using-a-robot-to-print-the-lexicographically-smallest-string | Python | Stack | Clean, Explained, and Easy to Understand | lukewu28 | 4 | 260 | using a robot to print the lexicographically smallest string | 2,434 | 0.381 | Medium | 33,300 |
https://leetcode.com/problems/using-a-robot-to-print-the-lexicographically-smallest-string/discuss/2679754/Python3-Suffix-Minimum | class Solution:
def robotWithString(self, s: str) -> str:
ret, n = "", len(s)
suffixMin = [None]*n
# construct suffix minimum array
for i in range(n-1, -1, -1):
if i == n-1: suffixMin[i] = s[i]
else: suffixMin[i] = min(s[i], suffixMin[i+1])
t = []
for i in range(n):
# append character at current index i to string t
t.append(s[i])
# check whether the last character of string t is not larger than the suffix min at index i+1,
# if so, it means we cannot find a smaller character from the characters on the right side of current index i,
# and we should print out the last character of string t
while t and (i == n-1 or t[-1] <= suffixMin[i+1]): ret += t.pop()
return ret | using-a-robot-to-print-the-lexicographically-smallest-string | [Python3] Suffix Minimum | teyuanliu | 2 | 26 | using a robot to print the lexicographically smallest string | 2,434 | 0.381 | Medium | 33,301 |
https://leetcode.com/problems/using-a-robot-to-print-the-lexicographically-smallest-string/discuss/2686943/Python-oror-Easy-Solution-oror-HashMap-oror-Stack | class Solution:
def robotWithString(self, s: str) -> str:
# Count the Occurence of characters in the String.
charMap = Counter(s)
p = "" # Final Output or Operation 2.
t = [] # Auxillary or Operation 1.
"---------Next--Minimum--Character---------"
def minInCharMap():
for char in string.ascii_lowercase:
if charMap[char] > 0:
return char
return "#"
"------------------------------------------"
# main body
i = 0
while (i < len(s)):
next_min_ch_St = minInCharMap() #next minimum Character from charMap.
if (len(t) == 0): # Mandatory when t is empty.
t.append(s[i])
charMap[s[i]] -= 1
i += 1
elif (next_min_ch_St < t[-1]): # if next minimum element after ith character is smaller than last element in then perform Operation 1.
t.append(s[i])
charMap[s[i]] -= 1
i += 1
else: # if next minimum element after ith character is greater than last element in then perform Operation 2.
p += t.pop()
while(len(t) > 0):
p += t.pop()
return p | using-a-robot-to-print-the-lexicographically-smallest-string | Python || Easy Solution || HashMap || Stack | dib_675 | 0 | 19 | using a robot to print the lexicographically smallest string | 2,434 | 0.381 | Medium | 33,302 |
https://leetcode.com/problems/using-a-robot-to-print-the-lexicographically-smallest-string/discuss/2683811/Python-Intuitive-Explanation-oror-Beats-100-of-the-Python-Submissions. | class Solution:
def robotWithString(self, s: str) -> str:
n=len(s)
m=[0]*n+[s[n-1]]
for i in range(n-1,-1,-1):
if s[i]<m[i+1]:
m[i]=s[i]
else:
m[i]=m[i+1]
t=[]
p=[]
for i in range(len(s)):
t.append(s[i])
while t and t[-1]<=m[i+1]:
p.append(t.pop())
while t :
p.append(t.pop())
return "".join(p) | using-a-robot-to-print-the-lexicographically-smallest-string | Python Intuitive Explanation || Beats 100% of the Python Submissions. | code_is_in_my_veins | 0 | 14 | using a robot to print the lexicographically smallest string | 2,434 | 0.381 | Medium | 33,303 |
https://leetcode.com/problems/using-a-robot-to-print-the-lexicographically-smallest-string/discuss/2683430/Python3-Recursive-Solution | class Solution:
def robotWithString(self, s: str) -> str:
def helper(string, target, carryon, res):
index = None
for t in range(len(carryon)-1, -1, -1):
if carryon[t] <= target:
index = t
else:
break
if index != None:
res.append(carryon[index:][::-1])
carryon = carryon[:index]
if target in string:
temp_res = string.split(target)
carryon += ''.join(temp_res[:-1])
res.append(target*(len(temp_res)-1))
if target == 'z':
res.append(carryon[::-1])
else:
helper(temp_res[-1], chr(ord(target)+1), carryon, res)
else:
if target == 'z':
res += carryon[::-1]
else:
helper(string, chr(ord(target)+1), carryon, res)
res = []
helper(s, 'a', '', res)
return ''.join(res) | using-a-robot-to-print-the-lexicographically-smallest-string | Python3 Recursive Solution | xxHRxx | 0 | 42 | using a robot to print the lexicographically smallest string | 2,434 | 0.381 | Medium | 33,304 |
https://leetcode.com/problems/using-a-robot-to-print-the-lexicographically-smallest-string/discuss/2683319/Using-a-suffix-array-dollardollarO(n)dollardollar | class Solution:
def robotWithString(self, s: str) -> str:
suff = []
N = len(s)
suff.append('{}')
for i in range(N - 1, -1, -1):
suff.append(min(suff[-1], s[i]))
suff = suff[::-1]
res = []
st = []
for i, c in enumerate(s):
if suff[i + 1] <= c:
st.append(c)
else:
res.append(c)
while st and st[-1] <= suff[i + 1]:
res.append(st.pop())
return "".join(res + st[::-1]) | using-a-robot-to-print-the-lexicographically-smallest-string | Using a suffix array $$O(n)$$ | mohitkumar36 | 0 | 3 | using a robot to print the lexicographically smallest string | 2,434 | 0.381 | Medium | 33,305 |
https://leetcode.com/problems/using-a-robot-to-print-the-lexicographically-smallest-string/discuss/2683310/Python-O(n)-time-greedy-simulate-the-whole-process. | class Solution:
def robotWithString(self, s: str) -> str:
suffix_min = [(s[-1], len(s) - 1)]
for i in range(len(s) - 2, -1, -1):
prev_min = suffix_min[-1]
if prev_min[0] < s[i]:
suffix_min.append(prev_min)
else:
suffix_min.append((s[i], i))
suffix_min = suffix_min[-1::-1]
p = list()
t = list()
s = list(s)
min_char, index = suffix_min[0]
p += min_char
t += s[:index]
l = index + 1
while l < len(s):
min_char, index = suffix_min[l]
while t and t[-1] <= min_char:
p.append(t.pop())
p.append(min_char)
t += s[l:index]
l = index + 1
p += t[-1::-1]
return "".join(p) | using-a-robot-to-print-the-lexicographically-smallest-string | Python O(n) time, greedy, simulate the whole process. | yiming999 | 0 | 11 | using a robot to print the lexicographically smallest string | 2,434 | 0.381 | Medium | 33,306 |
https://leetcode.com/problems/using-a-robot-to-print-the-lexicographically-smallest-string/discuss/2682467/Python3-or-Using-Stack-or-O(n) | class Solution:
def robotWithString(self, s: str) -> str:
def getMinChar(freq):
for f in range(len(freq)):
if freq[f]>0:
return f+97
return -1
freq=[0]*26
for c in s:
freq[ord(c)-97]+=1
stack=[]
ans=''
for c in s:
stack.append(c)
freq[ord(c)-97]-=1
while stack and ord(stack[-1])<=getMinChar(freq):
ans+=stack.pop()
while stack:
ans+=stack.pop()
return ans | using-a-robot-to-print-the-lexicographically-smallest-string | [Python3] | Using Stack | O(n) | swapnilsingh421 | 0 | 71 | using a robot to print the lexicographically smallest string | 2,434 | 0.381 | Medium | 33,307 |
https://leetcode.com/problems/using-a-robot-to-print-the-lexicographically-smallest-string/discuss/2681939/Python-3Stack-(hint-solution)-with-comments | class Solution:
def robotWithString(self, s: str) -> str:
# last index for each letter
last_idx = {}
for i, x in enumerate(s):
last_idx[x] = i
ans = ""
t = []
# current smallest letter
q = sorted(set(s))
cur = q.pop(0)
for i, x in enumerate(s):
# if smallest letter then write down to paper
if x == cur:
ans += x
# if this is the last occurance
if i == last_idx[x]:
# look for next smallest letter in the remaining string
while q and last_idx[q[0]] < i:
q.pop(0)
# if all letter were in t then return the answer
if not q: return ans + "".join(t[::-1])
cur = q.pop(0)
# look for any smaller letter occurred before and add to the answer
while t and t[-1] <= cur:
ans += t.pop()
# record previous occurance of letter
else:
t += [x]
return ans + "".join(t[::-1]) | using-a-robot-to-print-the-lexicographically-smallest-string | [Python 3]Stack (hint solution) with comments | chestnut890123 | 0 | 80 | using a robot to print the lexicographically smallest string | 2,434 | 0.381 | Medium | 33,308 |
https://leetcode.com/problems/using-a-robot-to-print-the-lexicographically-smallest-string/discuss/2681285/python3-Iteration-sol-for-reference | class Solution:
def robotWithString(self, s: str) -> str:
idx = 0
robot = []
paper = []
minchars = []
dp = list(s)
for i in range(len(s)-2, -1, -1):
dp[i] = min(dp[i], dp[i+1])
for i in range(len(s)):
if s[i] == dp[i]:
minchars.append((i, s[i]))
for c in s:
if idx < len(minchars) and minchars[idx][1] == c:
while robot and c >= robot[-1]:
paper.append(robot.pop())
paper.append(c)
idx += 1
else:
if idx < len(minchars):
nmc = minchars[idx][1]
while robot and robot[-1] <= nmc and c >= robot[-1]:
paper.append(robot.pop())
robot.append(c)
return "".join(paper + robot[::-1]) | using-a-robot-to-print-the-lexicographically-smallest-string | [python3] Iteration sol for reference | vadhri_venkat | 0 | 12 | using a robot to print the lexicographically smallest string | 2,434 | 0.381 | Medium | 33,309 |
https://leetcode.com/problems/using-a-robot-to-print-the-lexicographically-smallest-string/discuss/2680695/greedy-approach-or-stack-solution | class Solution:
def robotWithString(self, s: str) -> str:
#count of each albhabet
hashmap=[0]*26
for i in range(len(s)):
temp=ord(s[i])-ord('a')
hashmap[temp]+=1
#i pointing to array ,j pointing to string
res=""
j=0
i=0
temp=[]
while(i<26):
val=chr(ord('a')+i)
#add each albhabet to stack,decrease the counter of each albhabet till hashmap[i]==0
while(hashmap[i]!=0):
if s[j]==val:
res+=val
hashmap[i]-=1
else:
temp.append(s[j])
hashmap[ord(s[j])-ord('a')]-=1
j+=1
i+=1
#i pointing to next non zero count albhabet
while(i<26 and hashmap[i]==0):
i+=1
#check whether top of stack is less than albhabet corresponding to i,if yes pop and add to answer
while(temp and j<len(s) and i<26 and ord(temp[-1])<=i+ord('a')):
res+=temp.pop()
while(temp):
res+=temp.pop()
return(res) | using-a-robot-to-print-the-lexicographically-smallest-string | greedy approach | stack solution | sundram_somnath | 0 | 61 | using a robot to print the lexicographically smallest string | 2,434 | 0.381 | Medium | 33,310 |
https://leetcode.com/problems/using-a-robot-to-print-the-lexicographically-smallest-string/discuss/2679716/Python-Solve-by-tracking-what-the-next-minimum-character-is | class Solution:
def robotWithString(self, s: str) -> str:
res = ""
next_min = [""] * len(s)
next_min[-1] = s[-1]
for i in range(len(s)-2, -1, -1):
next_min[i] = min(next_min[i+1], s[i])
i = 0
t = []
res = ""
while i < len(s):
t.append(s[i])
j = i + 1
if s[i] == next_min[i]:
res += t.pop()
if j < len(s):
while t and t[-1] <= next_min[j]:
res += t.pop()
else:
while t:
res += t.pop()
i += 1
return res | using-a-robot-to-print-the-lexicographically-smallest-string | [Python] Solve by tracking what the next minimum character is | sharma_shubham | 0 | 12 | using a robot to print the lexicographically smallest string | 2,434 | 0.381 | Medium | 33,311 |
https://leetcode.com/problems/using-a-robot-to-print-the-lexicographically-smallest-string/discuss/2678999/Python | class Solution:
def robotWithString(self, s: str) -> str:
prf = []
mi = 'z'
for i in range(len(s) - 1, -1, -1):
if s[i] < mi:
mi = s[i]
prf.append(mi)
prf = prf[::-1]
res = []
left = [s[0]]
right = 1
while right < len(s):
if not left or prf[right] < left[-1]:
left.append(s[right])
right += 1
else:
res.append(left.pop())
while left:
res.append(left.pop())
return ''.join(res) | using-a-robot-to-print-the-lexicographically-smallest-string | Python | JSTM2022 | 0 | 33 | using a robot to print the lexicographically smallest string | 2,434 | 0.381 | Medium | 33,312 |
https://leetcode.com/problems/using-a-robot-to-print-the-lexicographically-smallest-string/discuss/2678978/Python3-Dictionaries-and-Pointers | class Solution:
def robotWithString(self, s: str) -> str:
n=len(s)
d={}
dIndex={}
for i in range(n):
ch=s[i]
if ch not in d:
d[ch]=[]
dIndex[ch]=0
d[ch].append(i)
t=['']*n
answ=[]
sIndex=0
tIndex=-1
lex=sorted(d.keys())
for ch in lex:
while 0<=tIndex and t[tIndex]<=ch:
answ.append(t[tIndex])
tIndex-=1
while dIndex[ch]<len(d[ch]):
chIndex=d[ch][dIndex[ch]]
dIndex[ch]+=1
while n>sIndex<chIndex:
dIndex[s[sIndex]]+=1
tIndex+=1
t[tIndex]=s[sIndex]
sIndex+=1
answ.append(ch)
sIndex+=1
return ''.join(answ) | using-a-robot-to-print-the-lexicographically-smallest-string | Python3, Dictionaries and Pointers | Silvia42 | 0 | 26 | using a robot to print the lexicographically smallest string | 2,434 | 0.381 | Medium | 33,313 |
https://leetcode.com/problems/using-a-robot-to-print-the-lexicographically-smallest-string/discuss/2678903/Python-based-on-intuition | class Solution:
def robotWithString(self, s: str) -> str:
t= []
res = []
#counter would tell if there is any smaller character on the right
counter = [0]*26
for char in s:
counter[ord(char)-97] += 1
for idx, char in enumerate(s):
t.append(char)
counter[ord(char)-97] -= 1
while len(t) != 0:
value = ord(t[-1])-97
ifc = False
for i in range(value):
if counter[i] > 0:
ifc = True
break
if ifc:
break
res.append(t[-1])
t.pop()
return "".join(res) | using-a-robot-to-print-the-lexicographically-smallest-string | Python based on intuition | Yihang-- | 0 | 75 | using a robot to print the lexicographically smallest string | 2,434 | 0.381 | Medium | 33,314 |
https://leetcode.com/problems/paths-in-matrix-whose-sum-is-divisible-by-k/discuss/2702890/Python-or-3d-dynamic-programming-approach-or-O(m*n*k) | class Solution:
def numberOfPaths(self, grid: List[List[int]], k: int) -> int:
dp = [[[0 for i in range(k)] for _ in range(len(grid[0]))] for _ in range(len(grid))]
rem = grid[0][0] % k
dp[0][0][rem] = 1
for i in range(1, len(grid[0])):
dp[0][i][(rem + grid[0][i]) % k] = 1
rem = (rem + grid[0][i]) % k
rem = grid[0][0] % k
for j in range(1, len(grid)):
dp[j][0][(rem + grid[j][0]) % k] = 1
rem = (rem + grid[j][0]) % k
for i in range(1, len(grid)):
for j in range(1, len(grid[0])):
for rem in range(k):
dp[i][j][(rem + grid[i][j]) % k] = dp[i - 1][j][rem] + dp[i][j - 1][rem]
return dp[-1][-1][0] % (10**9 + 7) | paths-in-matrix-whose-sum-is-divisible-by-k | Python | 3d dynamic programming approach | O(m*n*k) | LordVader1 | 1 | 16 | paths in matrix whose sum is divisible by k | 2,435 | 0.41 | Hard | 33,315 |
https://leetcode.com/problems/paths-in-matrix-whose-sum-is-divisible-by-k/discuss/2825474/Faster-than-98 | class Solution:
def numberOfPaths(self, grid: List[List[int]], k: int) -> int:
p=10**9+7
m=len(grid)
n=len(grid[0])
lst=[([0]*k if j else [1]+[0]*(k-1)) for j in range(n)]
for i in range(m):
gr=grid[i]
klst=[0]*k
for j in range(n):
g=gr[j]
l=lst[j]
klst=[(klst[(r-g)%k]+l[(r-g)%k])%p for r in range(k)]
lst[j]=klst
return lst[-1][0] | paths-in-matrix-whose-sum-is-divisible-by-k | Faster than 98% | mbeceanu | 0 | 3 | paths in matrix whose sum is divisible by k | 2,435 | 0.41 | Hard | 33,316 |
https://leetcode.com/problems/paths-in-matrix-whose-sum-is-divisible-by-k/discuss/2699332/Python-3-or-dp-or-O(mnk)O(nk) | class Solution:
MOD = 1000000007
def numberOfPaths(self, grid: List[List[int]], k: int) -> int:
m, n = len(grid), len(grid[0])
prev = [[0] * k for _ in range(n + 1)]
for i in range(m - 1, -1, -1):
cur = [[0] * k for _ in range(n + 1)]
for j in range(n - 1, -1, -1):
for s in range(k):
new = (s + grid[i][j]) % k
if i == m - 1 and j == n - 1:
cur[j][s] = int(new == 0)
else:
cur[j][s] = (prev[j][new] +
cur[j + 1][new]) % Solution.MOD
prev = cur
return prev[0][0] | paths-in-matrix-whose-sum-is-divisible-by-k | Python 3 | dp | O(mnk)/O(nk) | dereky4 | 0 | 9 | paths in matrix whose sum is divisible by k | 2,435 | 0.41 | Hard | 33,317 |
https://leetcode.com/problems/paths-in-matrix-whose-sum-is-divisible-by-k/discuss/2693760/Python-or-Bottom-up-DP | class Solution:
def numberOfPaths(self, grid: List[List[int]], k: int) -> int:
m = len(grid)
n = len(grid[0])
P = 10**9 + 7
if k == 1:
return self.binom(n + m - 2, n - 1, P)
dp = [[[0 for r in range(k)] for _ in range(n)] for _ in range(m)]
dp[0][0][grid[0][0] % k] = 1
for j in range(1,n):
for r in range(k):
r_p = (r - grid[0][j] % k) % k
dp[0][j][r] = dp[0][j-1][r_p]
for i in range(1,m):
for r in range(k):
r_p = (r - grid[i][0] % k) % k
dp[i][0][r] = dp[i-1][0][r_p]
for i in range(1,m):
for j in range(1,n):
for r in range(k):
r_p = (r - grid[i][j] % k) % k
dp[i][j][r] = (dp[i-1][j][r_p] + dp[i][j-1][r_p]) % P
return dp[m-1][n-1][0]
# Compute the binomial coefficient n C r modulo p, where
# p is prime.
def binom(self, n, r, p):
prod = 1
for i in range(r):
prod = (prod * (n - i) * self.inv(i + 1, p)) % p
return prod
# Use the Euclidean algorithm to find the inverse of x (mod p).
def inv(self, x, p):
return self.bezout(x, p)[0] % p
def bezout(self, a, b):
if b == 0:
return (1, 0)
u, v = self.bezout (b, a % b)
return (v, u - (a // b) * v) | paths-in-matrix-whose-sum-is-divisible-by-k | Python | Bottom-up DP | on_danse_encore_on_rit_encore | 0 | 15 | paths in matrix whose sum is divisible by k | 2,435 | 0.41 | Hard | 33,318 |
https://leetcode.com/problems/paths-in-matrix-whose-sum-is-divisible-by-k/discuss/2688549/Python-DP-solution-with-visual-explanation | class Solution:
def numberOfPaths(self, grid: List[List[int]], k: int) -> int:
R, C = len(grid), len(grid[0])
dp = defaultdict(lambda: defaultdict(lambda: 0))
dp[(0,0)][grid[0][0]%k] = 1
for i in range(R):
for j in range(C):
if i > 0:
for n, val in dp[(i-1, j)].items(): dp[(i, j)][(n+grid[i][j])%k] += val
if j > 0:
for n, val in dp[(i, j-1)].items(): dp[(i, j)][(n+grid[i][j])%k] += val
return dp[(R-1, C-1)][0] % (10**9 + 7) | paths-in-matrix-whose-sum-is-divisible-by-k | Python DP solution with visual explanation | kaichamp101 | 0 | 24 | paths in matrix whose sum is divisible by k | 2,435 | 0.41 | Hard | 33,319 |
https://leetcode.com/problems/paths-in-matrix-whose-sum-is-divisible-by-k/discuss/2687550/Simple-O(nmk)-DP-in-Python | class Solution:
def numberOfPaths(self, grid: List[List[int]], k: int) -> int:
n, m = len(grid), len(grid[0])
dp = [[[0] * k for _ in range(m)] for _ in range(n)]
dp[0][0][grid[0][0] % k] = 1
for i in range(n):
for j in range(m):
for r in range(k):
if i > 0:
dp[i][j][r] += dp[i-1][j][(r-grid[i][j]) % k]
if j > 0:
dp[i][j][r] += dp[i][j-1][(r-grid[i][j]) % k]
dp[i][j][r] %= 1000000007
return dp[n-1][m-1][0] | paths-in-matrix-whose-sum-is-divisible-by-k | Simple O(nmk) DP in Python | metaphysicalist | 0 | 36 | paths in matrix whose sum is divisible by k | 2,435 | 0.41 | Hard | 33,320 |
https://leetcode.com/problems/paths-in-matrix-whose-sum-is-divisible-by-k/discuss/2683672/Python3-O(MN)-Dynamic-Programming-Solution | class Solution:
def numberOfPaths(self, grid: List[List[int]], k: int) -> int:
m, n = len(grid), len(grid[0])
remainder = [[defaultdict(int) for _ in range(n)] for _ in range(m)]
for i in range(m):
num = grid[i][0] % k
if i == 0:
remainder[i][0][num] = 1
else:
for key, value in remainder[i-1][0].items():
new_val = (key + num) % k
remainder[i][0][new_val] += value
for j in range(1,n):
num = grid[0][j] % k
for key,value in remainder[0][j-1].items():
new_val = (key + num) % k
remainder[0][j][new_val] += value
for i in range(1, m):
for j in range(1, n):
num = grid[i][j] % k
for key,value in remainder[i-1][j].items():
new_val = (key + num) % k
remainder[i][j][new_val] += value
for key,value in remainder[i][j-1].items():
new_val = (key + num) % k
remainder[i][j][new_val] += value
return remainder[-1][-1][0] % (10**9 + 7) | paths-in-matrix-whose-sum-is-divisible-by-k | Python3 O(MN) Dynamic Programming Solution | xxHRxx | 0 | 59 | paths in matrix whose sum is divisible by k | 2,435 | 0.41 | Hard | 33,321 |
https://leetcode.com/problems/paths-in-matrix-whose-sum-is-divisible-by-k/discuss/2682892/Python3-or-Tabular-DP | class Solution:
def numberOfPaths(self, grid: List[List[int]], k: int) -> int:
n,m=len(grid),len(grid[0])
dp=[[[0 for i in range(k)] for i in range(m)] for j in range(n)]
dp[0][0][grid[0][0]%k]=1
for i in range(1,m):
for j in range(k):
curr=(j+grid[0][i])%k
dp[0][i][curr]+=dp[0][i-1][j]
for i in range(1,n):
for j in range(k):
curr=(j+grid[i][0])%k
dp[i][0][curr]+=dp[i-1][0][j]
for i in range(1,n):
for j in range(1,m):
for v in range(k):
curr=(v+grid[i][j])%k
dp[i][j][curr]+=dp[i-1][j][v]
curr=(v+grid[i][j])%k
dp[i][j][curr]+=dp[i][j-1][v]
return dp[n-1][m-1][0]%1000000007 | paths-in-matrix-whose-sum-is-divisible-by-k | [Python3] | Tabular DP | swapnilsingh421 | 0 | 34 | paths in matrix whose sum is divisible by k | 2,435 | 0.41 | Hard | 33,322 |
https://leetcode.com/problems/paths-in-matrix-whose-sum-is-divisible-by-k/discuss/2682398/python3-DP-sol-for-reference | class Solution:
def numberOfPaths(self, grid: List[List[int]], k: int) -> int:
M = len(grid)
N = len(grid[0])
MOD = 10**9+7
dp = defaultdict(lambda: defaultdict(lambda: defaultdict(int)))
dp[0][0][grid[0][0]%k] = 1
for x in range(M):
for y in range(N):
for i in dp[x][y]:
if x+1 < M:
key = (i+grid[x+1][y])%k
dp[x+1][y][key] += dp[x][y][i]
if y+1 < N:
key = (i+grid[x][y+1])%k
dp[x][y+1][key] += dp[x][y][i]
return dp[M-1][N-1][0]%MOD | paths-in-matrix-whose-sum-is-divisible-by-k | [python3] DP sol for reference | vadhri_venkat | 0 | 14 | paths in matrix whose sum is divisible by k | 2,435 | 0.41 | Hard | 33,323 |
https://leetcode.com/problems/paths-in-matrix-whose-sum-is-divisible-by-k/discuss/2682293/Python-is-getting-TLE-but-C%2B%2B-is-getting-AC-with-same-solution. | class Solution:
def numberOfPaths(self, grid: List[List[int]], k: int) -> int:
n, m = len(grid), len(grid[0])
dp = [[[0] * (k + 1) for _ in range(m + 1)] for _ in range(n + 1)]
dp[0][0][grid[0][0] % k] = 1
mod = 10 ** 9 + 7
for x in range(0, n):
for y in range(0, m):
for q in range(k):
if x + 1 < n:
dp[x + 1][y][(q + grid[x + 1][y]) % k] += dp[x][y][q]
dp[x + 1][y][(q + grid[x + 1][y]) % k] %= mod
if y + 1 < m:
dp[x][y + 1][(q + grid[x][y + 1]) % k] += dp[x][y][q]
dp[x][y + 1][(q + grid[x][y + 1]) % k] %= mod
return dp[n - 1][m - 1][0] | paths-in-matrix-whose-sum-is-divisible-by-k | Python is getting TLE but C++ is getting AC with same solution. | bayarkhuu | 0 | 13 | paths in matrix whose sum is divisible by k | 2,435 | 0.41 | Hard | 33,324 |
https://leetcode.com/problems/paths-in-matrix-whose-sum-is-divisible-by-k/discuss/2682286/Python-is-getting-TLE-but-C%2B%2B-is-getting-AC-with-same-solution. | class Solution:
def numberOfPaths(self, grid: List[List[int]], k: int) -> int:
n, m = len(grid), len(grid[0])
dp = [[[0] * (k + 1) for _ in range(m + 1)] for _ in range(n + 1)]
dp[0][0][grid[0][0] % k] = 1
mod = 10 ** 9 + 7
for x in range(0, n):
for y in range(0, m):
for q in range(k):
if x + 1 < n:
dp[x + 1][y][(q + grid[x + 1][y]) % k] += dp[x][y][q]
dp[x + 1][y][(q + grid[x + 1][y]) % k] %= mod
if y + 1 < m:
dp[x][y + 1][(q + grid[x][y + 1]) % k] += dp[x][y][q]
dp[x][y + 1][(q + grid[x][y + 1]) % k] %= mod
return dp[n - 1][m - 1][0] | paths-in-matrix-whose-sum-is-divisible-by-k | Python is getting TLE but C++ is getting AC with same solution. | bayarkhuu | 0 | 10 | paths in matrix whose sum is divisible by k | 2,435 | 0.41 | Hard | 33,325 |
https://leetcode.com/problems/paths-in-matrix-whose-sum-is-divisible-by-k/discuss/2681474/Python-Bottom-Up-3D-Dp-oror-Time%3A-6876-ms-Space%3A-146.9-MB | class Solution:
def numberOfPaths(self, grid: List[List[int]], k: int) -> int:
# TLE
# @cache
# def valid(i,j):
# return 1 if(i>=0 and i<n and j>=0 and j<m) else 0
# @cache
# def solve(i,j,s):
# if(valid(i,j)):
# return solve(i+1,j,(s+grid[i][j])%k)+ solve(i,j+1,(s+grid[i][j])%k)
# else:
# return 1 if(s==0 and ((i==n-1 and j==m) or (i==n and j==m-1))) else 0
# return (solve(0,0,0)//2)%(int(1e9+7))
#Accepted
n=len(grid)
m=len(grid[0])
dp=[[[0 for i in range(k+1)] for j in range(m+1)] for p in range(n+1)]
dp[n-1][m][0]=1
dp[n][m-1][0]=1
for i in range(n-1,-1,-1):
for j in range(m-1,-1,-1):
for p in range(k,-1,-1):
dp[i][j][p]=dp[i+1][j][(p+grid[i][j])%k]+dp[i][j+1][(p+grid[i][j])%k]
return (dp[0][0][0]//2)%int(1e9+7) | paths-in-matrix-whose-sum-is-divisible-by-k | Python Bottom-Up 3D-Dp || Time: 6876 ms , Space: 146.9 MB | koder_786 | 0 | 18 | paths in matrix whose sum is divisible by k | 2,435 | 0.41 | Hard | 33,326 |
https://leetcode.com/problems/paths-in-matrix-whose-sum-is-divisible-by-k/discuss/2679590/Python3-Dynamic-Programming | class Solution:
def numberOfPaths(self, grid: List[List[int]], k: int) -> int:
# m: number of rows; n: number of columns
m, n = len(grid), len(grid[0])
# cur: result of current row; pre: result of previous row
# we initialize the current row as it contains one cell (-1, 0),
# and this cell has one pair of path_sum_modulo_k: frequency (0: 1)
cur, pre = {(-1,0):{0:1}}, None
# loop over the rows from row index 0 to m-1
for i in range(m):
# reinitialize current row and set the result from previous row as pre
cur, pre = defaultdict(dict), cur
# loop over the columns from column index 0 to n-1
for j in range(n):
# if result of cell (i-1, j) exists, merge it into the result of current cell (i, j)
if (i-1, j) in pre:
# loop over the pairs (path_sum_modulo_k: frequency) stored in the result of cell (i-1, j)
for (s, f) in pre[(i-1, j)].items():
# add current cell value to the path_sum_modulo_k
cs = (s+grid[i][j])%k
# update the result of current cell
if cs not in cur[(i, j)]: cur[(i, j)][cs] = f
else: cur[(i, j)][cs] += f
# if result of cell (i, j-1) exists, merge it into the result of current cell (i, j)
if (i, j-1) in cur:
for (s, f) in cur[(i, j-1)].items():
cs = (s+grid[i][j])%k
if cs not in cur[(i, j)]: cur[(i, j)][cs] = f
else: cur[(i, j)][cs] += f
# return the frequency of path sum divisible by k if it exists, otherwise return 0
return cur[(m-1, n-1)][0] % (10**9+7) if 0 in cur[(m-1, n-1)] else 0 | paths-in-matrix-whose-sum-is-divisible-by-k | [Python3] Dynamic Programming | teyuanliu | 0 | 39 | paths in matrix whose sum is divisible by k | 2,435 | 0.41 | Hard | 33,327 |
https://leetcode.com/problems/paths-in-matrix-whose-sum-is-divisible-by-k/discuss/2679545/11-lines-3d-dp | class Solution:
def numberOfPaths(self, grid: List[List[int]], k: int) -> int:
N = 10 ** 9 + 7
m, n = len(grid), len(grid[0])
dp = [[[0] * k for i in range(n+1)] for j in range(m+1)]
dp[1][1][grid[0][0] % k] = 1
for i in range(m):
for j in range(n):
for t in range(k):
dp[i+1][j+1][(t + grid[i][j]) % k] += (dp[i+1][j][t] + dp[i][j+1][t]) % N
return dp[m][n][0] | paths-in-matrix-whose-sum-is-divisible-by-k | 11 lines 3d dp | A_Pinterest_Employee | 0 | 18 | paths in matrix whose sum is divisible by k | 2,435 | 0.41 | Hard | 33,328 |
https://leetcode.com/problems/paths-in-matrix-whose-sum-is-divisible-by-k/discuss/2679309/Python-Answer-DP-using-Double-Array-of-Dictionary | class Solution:
def numberOfPaths(self, grid: List[List[int]], k: int) -> int:
m = len(grid)
n = len(grid[0])
mod = 10**9 + 7
k = k
tmp = [[defaultdict(int) for i in range(len(grid[0]))] for j in range(len(grid))]
tmp[0][0][grid[0][0] %k] = 1
for i in range(1,len(grid)):
s = tmp[i-1][0].keys()
tmp[i][0][(list(s)[0] +grid[i][0]) %k] =1
for j in range(1,len(grid[0])):
s = tmp[0][j-1].keys()
tmp[0][j][(list(s)[0] + grid[0][j])%k] = 1
for i in range(1,len(grid)):
for j in range(1,len(grid[0])):
for l in tmp[i-1][j].keys():
s1 = tmp[i-1][j][l] #+ grid[i][j]
tmp[i][j][(l+grid[i][j])%k] += s1 % mod
for l in tmp[i][j-1].keys():
s1 = tmp[i][j-1][l] #+ grid[i][j]
tmp[i][j][(l+grid[i][j])%k] += s1 % mod
return tmp[m-1][n-1][0] % mod | paths-in-matrix-whose-sum-is-divisible-by-k | [Python Answer🤫🐍🐍🐍] DP using Double Array of Dictionary | xmky | 0 | 36 | paths in matrix whose sum is divisible by k | 2,435 | 0.41 | Hard | 33,329 |
https://leetcode.com/problems/paths-in-matrix-whose-sum-is-divisible-by-k/discuss/2679007/Python-DFS-%2B-Memoization | class Solution:
def numberOfPaths(self, grid: List[List[int]], k: int) -> int:
import copy
hm = defaultdict(list)
m, n = len(grid), len(grid[0])
def dfs(r, c):
if r >= len(grid) or c >= len(grid[0]):
return []
if r == m - 1 and c == n - 1:
hm[(r, c)] = {grid[r][c] : 1}
return
if (r, c) not in hm:
dfs(r + 1, c)
dfs(r, c + 1)
it = defaultdict(int)
if (r + 1, c) in hm:
for i in hm[(r + 1, c)]:
it[(grid[r][c] + i) % k] += hm[(r + 1, c)][i]
if (r, c + 1) in hm:
for i in hm[(r, c + 1)]:
it[(grid[r][c] + i) % k] += hm[(r, c + 1)][i]
hm[(r, c)] = it
return
dfs(0, 0)
res = 0
for i in hm[(0, 0)]:
if i % k == 0:
res += hm[(0, 0)][i]
res %= (10 ** 9 + 7)
return res | paths-in-matrix-whose-sum-is-divisible-by-k | Python DFS + Memoization | JSTM2022 | 0 | 89 | paths in matrix whose sum is divisible by k | 2,435 | 0.41 | Hard | 33,330 |
https://leetcode.com/problems/number-of-valid-clock-times/discuss/2706741/Structural-pattern-matching | class Solution:
def countTime(self, t: str) -> int:
mm = (6 if t[3] == '?' else 1) * (10 if t[4] == '?' else 1)
match [t[0], t[1]]:
case ('?', '?'):
return mm * 24
case ('?', ('0' | '1' | '2' | '3')):
return mm * 3
case ('?', _):
return mm * 2
case (('0' | '1'), '?'):
return mm * 10
case (_, '?'):
return mm * 4
return mm | number-of-valid-clock-times | Structural pattern matching | votrubac | 24 | 806 | number of valid clock times | 2,437 | 0.42 | Easy | 33,331 |
https://leetcode.com/problems/number-of-valid-clock-times/discuss/2706665/Understandable-If-Else-python-solution | class Solution:
def countTime(self, time: str) -> int:
res = 1
# split hour and minute digits
h1, h2, _ , m1, m2 = time
if h1 == "?" and h2 == "?":
res*=24
elif h1 == "?":
if int(h2) >=4:
res*=2
else:
res*=3
elif h2 == "?":
if int(h1) <= 1:
res*=10
elif h1 == "2":
res*=4
if m1 == "?" and m2 == "?":
res*=60
elif m1 == "?":
res*=6
elif m2 == "?":
res*=10
return res | number-of-valid-clock-times | Understandable If-Else python solution | namanxk | 5 | 179 | number of valid clock times | 2,437 | 0.42 | Easy | 33,332 |
https://leetcode.com/problems/number-of-valid-clock-times/discuss/2706726/Python-No-math-simple-pattern-check-O(1)-Clean-and-Concise | class Solution:
def countTime(self, time: str) -> int:
def getString2Chars(value):
if value < 10:
return "0" + str(value)
return str(value)
def isMatching(clock, pattern):
s = getString2Chars(clock)
if pattern[0] != "?" and s[0] != pattern[0] or pattern[1] != "?" and s[1] != pattern[1]:
return False
return True
hPattern, mPattern = time.split(":")
ans = 0
hhCnt, mmCnt = 0, 0
for hh in range(24):
if isMatching(hh, hPattern):
hhCnt += 1
for mm in range(60):
if isMatching(mm, mPattern):
mmCnt += 1
return hhCnt * mmCnt | number-of-valid-clock-times | [Python] No math, simple pattern check - O(1) - Clean & Concise | hiepit | 2 | 177 | number of valid clock times | 2,437 | 0.42 | Easy | 33,333 |
https://leetcode.com/problems/number-of-valid-clock-times/discuss/2799275/JAVAC%2B%2BPY-100-or-0-MS-or-faster-or-simple-or-TIME-and-SPACE-O(1) | class Solution {
public int countTime(String time) {
if(time.equals("??:??")) return 1440;
int ans=1;
if(time.charAt(0)=='?' && time.charAt(1)=='?') ans*=24;
else if(time.charAt(0)=='?') ans*=(time.charAt(1)-'0'>=4)?2:3;
else if(time.charAt(1)=='?') ans *=(time.charAt(0)-'0'>=2)?4:10;
if(time.charAt(3)=='?') ans *=6;
if(time.charAt(4)=='?') ans *=10;
return ans;
}
}
CPP:
int countTime(string time) {
if(time=="??:??") return 1440;
int ans=1;
if(time[0]=='?' && time[1]=='?') ans*=24;
else if(time[0]=='?') ans*=(time[1]-'0'>=4)?2:3;
else if(time[1]=='?') ans *=(time[0]-'0'>=2)?4:10;
if(time[3]=='?') ans *=6;
if(time[4]=='?') ans *=10;
return ans;
}
PY :
def countTime(self, time: str) -> int:
if(time=="??:??"): return 1440;
ans=1;
if(time[0]=='?' and time[1]=='?'): ans=ans*24;
elif (time[0]=='?'):
if(ord(time[1])-ord('0')>=4): ans = ans*2;
else: ans=ans*3;
elif (time[1]=='?'):
if(ord(time[0])-ord('0')>=2): ans = ans*4;
else:ans= ans*10;
if(time[3]=='?'): ans = ans * 6;
if(time[4]=='?'): ans = ans * 10;
return ans;CPP | number-of-valid-clock-times | ✅⬆️ [JAVA/C++/PY] 100 % | 0 MS | faster | simple | TIME & SPACE O(1) | ManojKumarPatnaik | 0 | 2 | number of valid clock times | 2,437 | 0.42 | Easy | 33,334 |
https://leetcode.com/problems/number-of-valid-clock-times/discuss/2772366/Python-with-easy-to-understand-hours-minutes-matching | class Solution:
def countTime(self, time: str) -> int:
# hours
if time[:2] == "??":
combinations = 24
elif time[1] == "?":
if time [0] in "01":
combinations = 10
else:
combinations = 4
elif time[0] == "?" and time[1] in "0123":
combinations = 3
elif time[0] == "?" and time[1] in "456789":
combinations = 2
else:
combinations = 1
# minutes
if time[3] == "?": combinations *= 6
if time[4] == "?": combinations *= 10
return combinations | number-of-valid-clock-times | Python with easy to understand hours / minutes matching | mjavka | 0 | 4 | number of valid clock times | 2,437 | 0.42 | Easy | 33,335 |
https://leetcode.com/problems/number-of-valid-clock-times/discuss/2749145/Two-if-..-elif-94-speed | class Solution:
def countTime(self, time: str) -> int:
ans = 1
if time[0] == time[1] == "?":
ans *= 24
elif time[0] == "?":
if time[1] < "4":
ans *= 3
else:
ans *= 2
elif time[1] == "?":
if time[0] < "2":
ans *= 10
else:
ans *= 4
if time[3] == time[4] == "?":
ans *= 60
elif time[3] == "?":
ans *= 6
elif time[4] == "?":
ans *= 10
return ans | number-of-valid-clock-times | Two if .. elif, 94% speed | EvgenySH | 0 | 5 | number of valid clock times | 2,437 | 0.42 | Easy | 33,336 |
https://leetcode.com/problems/number-of-valid-clock-times/discuss/2732777/Faster-than-98-of-python-submissions | class Solution:
def countTime(self, time: str) -> int:
l = time[:2]
r = time[-2:]
if time == "??:??":
return 1440
if l == "??":
poss = 24
else:
# l_l (left_left = Ones) l_r(left_right = Tens )
l_l = 0 if l[0].isnumeric() else 3 if int(l[1]) <= 3 else 2
l_r = 0 if l[1].isnumeric() else 10 if int(l[0]) < 2 else 4
poss = 1 if l_r + l_l == 0 else l_r + l_l
#for the right side xx:{??}
if r == "??":
poss2 = 60
else:
r_l = 0 if r[0].isnumeric() else 6
r_r = 0 if r[1].isnumeric() else 10
poss2 = 1 if r_l + r_r == 0 else r_l + r_r
return poss * poss2 | number-of-valid-clock-times | Faster than 98% of python submissions | ayoubprog61 | 0 | 4 | number of valid clock times | 2,437 | 0.42 | Easy | 33,337 |
https://leetcode.com/problems/number-of-valid-clock-times/discuss/2730360/Easy-understanding-python-solution-with-explanation | class Solution:
def countTime(self, t: str) -> int:
# ?0: 00
# 0?:00
# ??:00
# 00: 0?
# 00:?0
# 00:??
a, b, c, d = t[0], t[1], t[3], t[4]
left, right = 0, 0
if a == "?" and b == "?":
left = 24
elif a == "?":
if int(b) < 4:
left = 3
else:
left = 2
elif b == "?":
if int(a) < 2:
left = 10
else:
left = 4
else:
left = 1
if c == "?" and d == "?":
right = 60
elif c == "?":
right = 6
elif d == "?":
right = 10
else:
right = 1
return left * right | number-of-valid-clock-times | Easy understanding python solution with explanation | jackson-cmd | 0 | 1 | number of valid clock times | 2,437 | 0.42 | Easy | 33,338 |
https://leetcode.com/problems/number-of-valid-clock-times/discuss/2712868/Python-or-Regex-or-7-lines | class Solution:
def countTime(self, time: str) -> int:
time, ans = time.replace('?', '.'), 0
for i in range(60 * 24):
hours = i // 60
mins = i - 60 * hours
candidate = f'{hours:02}:{mins:02}'
ans += re.match(time, candidate) is not None
return ans | number-of-valid-clock-times | Python | Regex | 7 lines | leeteatsleep | 0 | 10 | number of valid clock times | 2,437 | 0.42 | Easy | 33,339 |
https://leetcode.com/problems/number-of-valid-clock-times/discuss/2709229/Faster-than-100-or-Easy-to-Understand-or-Python | class Solution(object):
def countTime(self, time):
h, m = 0, 0
if time[0] == '?' and time[1] == '?': h = 24
elif time[0] == '?':
if int(time[1]) > 3: h = 2
else: h = 3
elif time[1] == '?':
if int(time[0]) == 2: h = 4
else: h = 10
else: h = 1
if time[3] == '?' and time[4] == '?': m = 60
elif time[3] == '?': m = 6
elif time[4] == '?': m = 10
else: m = 1
return h * m | number-of-valid-clock-times | Faster than 100% | Easy to Understand | Python | its_krish_here | 0 | 6 | number of valid clock times | 2,437 | 0.42 | Easy | 33,340 |
https://leetcode.com/problems/number-of-valid-clock-times/discuss/2708978/Python3-Brute-Force-(With-Recursion) | class Solution:
def countTime(self, time: str) -> int:
t = 0
def rec(x, r):
nonlocal t
if len(r) == 0:
ps = x.split(':')
if int(ps[0])<24 and int(ps[1])<60:
t+=1
elif r[0]=='?':
for i in range(10):
rec(f"{x}{i}", r[1:])
else:
rec(x+r[0], r[1:])
rec("", time)
return t | number-of-valid-clock-times | Python3 Brute Force (With Recursion) | godshiva | 0 | 4 | number of valid clock times | 2,437 | 0.42 | Easy | 33,341 |
https://leetcode.com/problems/number-of-valid-clock-times/discuss/2708459/Python-oror-Simple-Greedy-Solution | class Solution:
def countTime(self, time: str) -> int:
count_h =1
count_m=1
if time[0] == '?':
if time[1] == '?': # If both hours are '?' then we will have 24 combinations for hours
count_h =24
elif time[1] >'3':
count_h=2
else:
count_h=3
elif time[1]=='?':
if time[0] == '2':
count_h=4
else:
count_h=10
if time[3] == '?':
if time[4] == '?': # If both minutes are '?' we have 60 combination for minutes
count_m=60
else:
count_m=6
elif time[4] == '?':
count_m=10
return count_m*count_h # Return the product of hours count and minute count | number-of-valid-clock-times | Python || Simple Greedy Solution | Graviel77 | 0 | 4 | number of valid clock times | 2,437 | 0.42 | Easy | 33,342 |
https://leetcode.com/problems/number-of-valid-clock-times/discuss/2707957/Easy-Python-or-Multiplication-or-Lots-of-ifs | class Solution:
def countTime(self, time: str) -> int:
hour, minute = time.split(':')
ans = 1
if minute[0] == '?':
ans *= 6
if minute[1] == '?':
ans *= 10
if hour[0] == '?':
if hour[1] == '?':
ans *= 24
elif '4' <= hour[1] <= '9':
ans *= 2
else:
ans *= 3
elif hour[1] == '?':
if hour[0] == '2':
ans *= 4
else:
ans *= 10
return ans | number-of-valid-clock-times | Easy Python | Multiplication | Lots of ifs | on_danse_encore_on_rit_encore | 0 | 3 | number of valid clock times | 2,437 | 0.42 | Easy | 33,343 |
https://leetcode.com/problems/number-of-valid-clock-times/discuss/2707298/Python3-if-else | class Solution:
def countTime(self, time: str) -> int:
ans = 1
if time[0:2] == "??": ans *= 24
elif time[0] == '?': ans *= 3 if time[1] < '4' else 2
elif time[1] == '?': ans *= 4 if time[0] == '2' else 10
if time[3] == '?': ans *= 6
if time[4] == '?': ans *= 10
return ans | number-of-valid-clock-times | [Python3] if-else | ye15 | 0 | 5 | number of valid clock times | 2,437 | 0.42 | Easy | 33,344 |
https://leetcode.com/problems/number-of-valid-clock-times/discuss/2707007/Python-(Beats-100)-or-Mathematical-solution | class Solution:
def countTime(self, time: str) -> int:
hh, mm = time.split(':')
mchoice, hchoice = 1, 1
if mm == '??':
mchoice = 60
else:
if mm[0] == '?':
mchoice = 6
elif mm[1] == '?':
mchoice = 10
if hh == '??':
hchoice = 24
else:
if hh[0] == '?':
if int(hh[1]) < 4:
hchoice = 3
else:
hchoice = 2
elif hh[1] == '?':
if hh[0] == '2':
hchoice = 4
else:
hchoice = 10
return mchoice * hchoice | number-of-valid-clock-times | Python (Beats 100%) | Mathematical solution | KevinJM17 | 0 | 4 | number of valid clock times | 2,437 | 0.42 | Easy | 33,345 |
https://leetcode.com/problems/number-of-valid-clock-times/discuss/2706887/Python-Answer-Queue | class Solution:
def countTime(self, time: str) -> int:
pot = Deque([time])
while any(['?' in p for p in pot]):
for _ in range(len(pot)):
p = pot.popleft()
if '?' in p:
for i in range(0,10):
q = p.replace('?', str(i), 1)
#print(q)
if '?' in q:
pot.append(q)
continue
k = q.split(':')
if 0 <= int(k[0]) <= 23 and 0 <= int(k[1]) <= 59:
pot.append(q)
else:
pot.append(p)
return len(pot) | number-of-valid-clock-times | [Python Answer🤫🐍🐍🐍] Queue | xmky | 0 | 4 | number of valid clock times | 2,437 | 0.42 | Easy | 33,346 |
https://leetcode.com/problems/number-of-valid-clock-times/discuss/2706824/Python-easy-simple-check-or-explain-with-comments | class Solution:
def countTime(self, time: str) -> int:
ans = 1
# for hour first index
if time[0] == "?":
# if hour second index
if time[1] == "?":
# we know we will get 24 times (0 to 23) value of counter
ans *= 24
elif time[1] < "4":
# if hour second index is less than 4
# then we can say we have only 3 options (0th, 10th, 20th) for hour first index
# so we multiply by 3
ans *= 3
else:
# else we have only 2 options (10th, 20th)
# so we multiply by 2
ans *= 2
# for hour second index
if time[1] == "?":
# check if hour first digit is in 20th place
if time[0] == "2":
# if so then multiply with 4 (24 - 20 = 4)
ans *= 4
elif time[0] < "2":
# if this is less than 2 then we have only 1 hour
# so for 1 hour we have (0 to 9) = 10 times
ans *= 10
# for minute 1st index
if time[3] == "?":
# if the first index of minute is missing then we have only (0th to 60th) option => 6 times
# so we multiply by 6
ans *= 6
# for minute 2nd index
if time[4] == "?":
# if the second index of minute is missing then we have only (0 to 9) option => 10 times
# so we multiply by 10
ans *= 10
return ans | number-of-valid-clock-times | ✅ Python easy simple check | explain with comments | sezanhaque | 0 | 4 | number of valid clock times | 2,437 | 0.42 | Easy | 33,347 |
https://leetcode.com/problems/number-of-valid-clock-times/discuss/2706709/Python-a-bunch-of-if-statements | class Solution:
def countTime(self, time: str) -> int:
hours = 1
if '?' not in time[:2]:
pass
else:
if time[0] == '?':
if time[1] == '?':
hours = 24
elif time[1] < '4':
hours = 3
else:
hours = 2
elif time[0] == '2':
hours = 4
else:
hours = 10
minutes = 1
if time[-2] == '?':
minutes *= 6
if time[-1] == '?':
minutes *= 10
return hours * minutes | number-of-valid-clock-times | Python, a bunch of if statements | blue_sky5 | 0 | 5 | number of valid clock times | 2,437 | 0.42 | Easy | 33,348 |
https://leetcode.com/problems/number-of-valid-clock-times/discuss/2706681/Python-solution-with-loop-and-string-comparison-only-53ms-runtime | class Solution:
def countTime(self, time: str) -> int:
h0, h1, m0, m1 = time[0], time[1], time[3], time[4]
res = 0
for h in range(24):
hour = "{:02d}".format(h)
for m in range(60):
minute = "{:02d}".format(m)
if h0 != '?' and h0 != hour[0]: continue
if h1 != '?' and h1 != hour[1]: continue
if m0 != '?' and m0 != minute[0]: continue
if m1 != '?' and m1 != minute[1]: continue
res += 1
return res | number-of-valid-clock-times | Python solution with loop and string comparison only; 53ms runtime | llJll | 0 | 5 | number of valid clock times | 2,437 | 0.42 | Easy | 33,349 |
https://leetcode.com/problems/number-of-valid-clock-times/discuss/2706620/Python-or-Corner-cases-Pitfall | class Solution:
def countTime(self, time: str) -> int:
ans=1
h=time[0:2]
m=time[3:]
if h=="??":
ans*=24
elif h[0]=="?":
if int(h[1])>3:
ans*=2
else:
ans*=3
elif h[1]=="?":
if int(h[0])<2:
ans*=10
else:
ans*=4
else:
pass
if m=="??":
ans*=60
elif m[0]=="?":
ans*=6
elif m[1]=="?":
ans*=10
else:
pass
return ans | number-of-valid-clock-times | Python | Corner cases Pitfall | Prithiviraj1927 | 0 | 6 | number of valid clock times | 2,437 | 0.42 | Easy | 33,350 |
https://leetcode.com/problems/number-of-valid-clock-times/discuss/2706605/Python3-Easy-Brute-Force-Solution | class Solution:
def countTime(self, time: str) -> int:
if time.count('?') == 4:
return 1440
else:
def helper(string):
if string.count('?') == 0:
return [string]
else:
index = string.index('?')
temp_res = helper(string[index+1:])
res = []
for element in [str(i) for i in range(10)]:
res += [string[:index] + element + x for x in temp_res]
return res
candidates = helper(time)
res = 0
for element in candidates:
hour, minute = int(element[:2]), int(element[3:])
if 0 <= hour <= 23 and 0 <= minute <= 59:
res += 1
return res | number-of-valid-clock-times | Python3 Easy Brute Force Solution | xxHRxx | 0 | 3 | number of valid clock times | 2,437 | 0.42 | Easy | 33,351 |
https://leetcode.com/problems/number-of-valid-clock-times/discuss/2706547/Easy-to-understand | class Solution:
def countTime(self, time: str) -> int:
missing = set()
for i in range(len(time)):
if time[i] == "?":
missing.add(i)
hours_val, min_val = 1, 1
if 0 in missing and 1 in missing:
hours_val = 24
elif 0 in missing:
hours_val = 3 if int(time[1])<=3 else 2
elif 1 in missing:
hours_val = 4 if int(time[0])==2 else 10
if 3 in missing and 4 in missing:
min_val = 60
elif 3 in missing:
min_val = 6
elif 4 in missing:
min_val = 10
return hours_val*min_val | number-of-valid-clock-times | Easy to understand | np137 | 0 | 7 | number of valid clock times | 2,437 | 0.42 | Easy | 33,352 |
https://leetcode.com/problems/number-of-valid-clock-times/discuss/2706529/Easy-Python3-Solution | class Solution:
def countTime(self, time: str) -> int:
a=time[0]+time[1]
b=time[3]+time[4]
qa=0
for c in a:
if c=='?':
qa+=1
aa=1
if qa==2:
aa=24
elif qa==1:
if a[1]=='?':
if a[0]=='2':
aa=4
else:
aa=10
else:
if int(a[1])<=3:
aa=3
else:
aa=2
qb=0
for d in b:
if d=='?':
qb+=1
ab=1
if qb==2:
ab=60
elif qb==1:
if b[1]=='?':
ab=10
else:
ab=6
return aa*ab | number-of-valid-clock-times | Easy [Python3] Solution | shreyasjain0912 | 0 | 6 | number of valid clock times | 2,437 | 0.42 | Easy | 33,353 |
https://leetcode.com/problems/number-of-valid-clock-times/discuss/2706492/Python-O(1)-easy-solution | class Solution:
def countTime(self, time: str) -> int:
h,m = time.split(":")
ans = 0
#00:00~23:59
#Hours
tempH = 1
if h =="??":
tempH = 24
elif h[0] == "?" and h[1]>"3":# "?4","?5","?6","?7"
tempH = 2 #0,1
elif h[0] == "?" and h[1]<="3":
tempH = 3 #0,1,2
elif h[1] == "?" and h[0] == "2": #"2?"
tempH = 4 #0,1,2,3
elif h[1] == "?" and h[0] <"2": # "1?","0?"
tempH = 10 #0,1,2,3,4,5,6,7,8,9
tempM = 1
#Minutes
if m == "??": #
tempM = 60 #0~60 min
elif m[1] == "?": #"0?"~"5?"
tempM = 10 #0,1,2,3,4,5,6,7,8,9
elif m[0] == "?": #"?0"
tempM = 6 #0,1,2,3,4,5
# print(tempH,tempM)
return tempH*tempM | number-of-valid-clock-times | Python O(1) easy solution | tryit163281 | 0 | 14 | number of valid clock times | 2,437 | 0.42 | Easy | 33,354 |
https://leetcode.com/problems/number-of-valid-clock-times/discuss/2706485/Python3-O(1)-Space-and-O(1)-Time-Brute-Force | class Solution:
def countTime(self, findings: str) -> int:
ans = 1
if findings[-1]=='?' and findings[-2]=='?':
ans = 60
elif findings[-1]=='?':
ans = 10
elif findings[-2]=='?':
ans = 6
if findings[0]=='?' and findings[1]=='?':
ans=ans*24
elif findings[0]=='0'and findings[1]=='?':
ans = ans*10
elif findings[0]=='1' and findings[1]=='?':
ans = ans*10
elif findings[0]=='2' and findings[1]=='?':
ans = ans*4
elif findings[0]=='?' and int(findings[1])<=3:
ans = ans * 3
elif findings[0]=='?' and int(findings[1])>=4:
ans = ans * 2
return ans | number-of-valid-clock-times | [Python3] O(1) Space and O(1) Time, Brute Force | chandu71202 | 0 | 5 | number of valid clock times | 2,437 | 0.42 | Easy | 33,355 |
https://leetcode.com/problems/number-of-valid-clock-times/discuss/2706482/O(1)-O(1)-or-Bunch-of-If-Elif-statements-%3AD | class Solution:
def countTime(self, time: str) -> int:
answer = 1
n = 5
i = 0
while i != n:
if time[i] != '?' and i == 0 and time[i+1] != '?':
i = 3
elif time[i] == '?' and i == 0 and time[i+1] == '?': # ?3 - 00-23 choices
answer *= 24
i = 3
elif time[i] == '?' and i == 0 and time[i+1] != '?' and int(time[i+1]) > 3: # ?4 - 0,1 choices
answer *= 2
i = 3
elif time[i] == '?' and i == 0 and time[i+1] != '?' and int(time[i+1]) <= 3: # ?3 - 0,1,2 choices
answer *= 3
i = 3
elif time[i] == '2' and i == 0 and time[i+1] == '?': # 2? - 0,1,2,3 choices
answer *= 4
i = 3
elif time[i] != '?' and (time[i] == '0' or time[i] == '1') and i == 0 and time[i+1] == '?': # 1? 0? - 0-9 choices
answer *= 10
i = 3
elif time[i] == '?' and i == 3 and time[i+1] != '?': # ?4 - 0-5 choices
answer *= 6
i = 5
elif time[i] != '?' and i == 3 and time[i+1] == '?': # 2? - 0-9 choices
answer *= 10
i = 5
elif time[i] == '?' and i == 3 and time[i+1] == '?': # ?3 - 00-59 choices
answer *= 60
i = 5
elif time[i] != '?' and i== 3 and time[i+1] != '?':
i = 5
if answer == 1:
return 1
return answer
``` | number-of-valid-clock-times | O(1) O(1) | Bunch of If-Elif statements :D | bighornsheep | 0 | 10 | number of valid clock times | 2,437 | 0.42 | Easy | 33,356 |
https://leetcode.com/problems/number-of-valid-clock-times/discuss/2706456/Python-Solution-with-Proof-and-Explanation-(For-Beginners) | class Solution:
def countTime(self, time: str) -> int:
a = time[0]
b = time[1]
c = time[3]
d = time[4]
result = 1
if a == "?" and b != "?":
a1 = 3 if b <= '3' else 2
else:
a1 = 1
if b =="?":
if a <= "1":
b1 = 10
elif a == "2":
b1 = 4
elif a == "?":
b1 = 24
else:
b1 = 1
c1 = 6 if c == "?" else 1
d1 = 10 if d == "?" else 1
return a1 * b1 * c1 * d1 | number-of-valid-clock-times | Python Solution with Proof and Explanation (For Beginners) | Jiganesh | 0 | 41 | number of valid clock times | 2,437 | 0.42 | Easy | 33,357 |
https://leetcode.com/problems/number-of-valid-clock-times/discuss/2706425/Python3-ugly-Brute-Force-is-easy | class Solution:
def countTime(self, time: str) -> int:
if '?' not in time: return 1
hh,mm=time.split(':')
tH,th=hh
tM,tm=mm
answ=0
d='0123456789'
for H in d:
for h in d:
for M in d:
for m in d:
Hh=int(H+h)
Mm=int(M+m)
if Hh<24 and Mm<60:
if H!=tH!='?' or h!=th!='?' or M!=tM!='?' or m!=tm!='?': continue
answ+=1
return answ | number-of-valid-clock-times | Python3, ugly Brute Force is easy | Silvia42 | 0 | 14 | number of valid clock times | 2,437 | 0.42 | Easy | 33,358 |
https://leetcode.com/problems/range-product-queries-of-powers/discuss/2706690/Python-or-Prefix-Product | class Solution:
def productQueries(self, n: int, queries: List[List[int]]) -> List[int]:
MOD = (10**9)+7
binary = bin(n)[2:]
powers = []
result = []
for index, val in enumerate(binary[::-1]):
if val == "1":
powers.append(2**index)
for index in range(1, len(powers)):
powers[index] = powers[index] * powers[index - 1]
for l,r in queries:
if l == 0:
result.append(powers[r]%MOD)
else:
result.append((powers[r]//powers[l-1])%MOD)
return result | range-product-queries-of-powers | Python | Prefix Product | Dhanush_krish | 8 | 320 | range product queries of powers | 2,438 | 0.384 | Medium | 33,359 |
https://leetcode.com/problems/range-product-queries-of-powers/discuss/2796984/fast-python-solution | class Solution:
def productQueries(self, n: int, queries: List[List[int]]) -> List[int]:
a=bin(n)[2:]
# print(a)
a=a[::-1]
arr=[1]
p=1
for i in range(len(a)):
if(a[i]=="1"):
p*=2**i
arr.append(p)
ans=[]
print(arr)
for q in queries:
p=arr[q[1]+1]//arr[q[0]]
ans.append(p%(10**9+7))
return ans | range-product-queries-of-powers | fast python solution | droj | 4 | 42 | range product queries of powers | 2,438 | 0.384 | Medium | 33,360 |
https://leetcode.com/problems/range-product-queries-of-powers/discuss/2724547/Python3-Solution-or-Prefix-Sum-or-2-Line-Solution | class Solution:
def productQueries(self, n, Q):
A = list(accumulate([i for i in range(31) if n & (1 << i)])) + [0]
return [pow(2, A[r] - A[l - 1], 10 ** 9 + 7) for l, r in Q] | range-product-queries-of-powers | ✔ Python3 Solution | Prefix Sum | 2 Line Solution | satyam2001 | 2 | 15 | range product queries of powers | 2,438 | 0.384 | Medium | 33,361 |
https://leetcode.com/problems/range-product-queries-of-powers/discuss/2784166/Python-Beats-97-Easy-to-understand-solution | class Solution:
def productQueries(self, n: int, queries: List[List[int]]) -> List[int]:
MOD = (10**9)+7
powers, res = [], []
binary_list = [int(i) for i in bin(n)[2:]] # convert n to binary
for i, n in enumerate(binary_list[::-1]): # create powers list
if n:
powers.append(pow(2, i))
for i in range(1, len(powers)): # prefix product
powers[i] = powers[i] * powers[i-1]
for l, r in queries:
if l == 0:
res.append(powers[r] % MOD)
else:
res.append((powers[r] // powers[l-1]) % MOD)
return res | range-product-queries-of-powers | [Python] Beats 97%, Easy to understand solution | hunarbatra | 0 | 10 | range product queries of powers | 2,438 | 0.384 | Medium | 33,362 |
https://leetcode.com/problems/range-product-queries-of-powers/discuss/2710457/python3-Binary-search-and-prefix-product-sol-for-reference | class Solution:
def productQueries(self, n: int, queries: List[List[int]]) -> List[int]:
powersOf2 = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144, 524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, 67108864, 134217728, 268435456, 536870912, 1073741824]
p = []
ans = []
MOD = 10**9+7
while n > 0:
idx = bisect_left(powersOf2, n)
if idx and powersOf2[idx] != n:
idx -= 1
p.append(powersOf2[idx])
n -= powersOf2[idx]
p = p[::-1]
for i in range(1, len(p)):
p[i] *= p[i-1]
for l, r in queries:
if l:
ans.append((p[r]//p[l-1])%MOD)
else:
ans.append(p[r]%MOD)
return ans | range-product-queries-of-powers | [python3] Binary search and prefix product sol for reference | vadhri_venkat | 0 | 10 | range product queries of powers | 2,438 | 0.384 | Medium | 33,363 |
https://leetcode.com/problems/range-product-queries-of-powers/discuss/2709516/Python-solution | class Solution:
def productQueries(self, n: int, queries: List[List[int]]) -> List[int]:
powers = []
res = []
v = []
mod = (10 ** 9) + 7
while n > 0:
v.append(n % 2)
n = n // 2
for i in range(len(v)):
if v[i] == 1:
powers.append(2 ** i)
for start, end in queries:
prod = 1
for i in range(start, end + 1):
prod *= powers[i]
res.append(prod % mod)
return res | range-product-queries-of-powers | Python solution | KevinJM17 | 0 | 5 | range product queries of powers | 2,438 | 0.384 | Medium | 33,364 |
https://leetcode.com/problems/range-product-queries-of-powers/discuss/2708896/Python-or-Prefix-sum-of-powers-or-Bit-manipulation | class Solution:
def productQueries(self, n: int, queries: List[List[int]]) -> List[int]:
p = 10**9 + 7
powers_prefix = []
mask, power = 1, 0
while mask <= n:
if mask & n:
powers_prefix.append(power)
mask *= 2
power += 1
# Calculate prefix sum of powers.
for i in range(1, len(powers_prefix)):
powers_prefix[i] += powers_prefix[i-1]
ans = [1] * len(queries)
for i, (l, r) in enumerate (queries):
power = powers_prefix[r]
if l > 0:
power -= powers_prefix[l-1]
ans[i] = (1 << power) % p
return ans | range-product-queries-of-powers | Python | Prefix sum of powers | Bit manipulation | on_danse_encore_on_rit_encore | 0 | 9 | range product queries of powers | 2,438 | 0.384 | Medium | 33,365 |
https://leetcode.com/problems/range-product-queries-of-powers/discuss/2707300/Python3-simulation | class Solution:
def productQueries(self, n: int, queries: List[List[int]]) -> List[int]:
powers = []
for i in range(30):
if n & 1<<i: powers.append(1<<i)
ans = []
for lo, hi in queries:
val = 1
for ii in range(lo, hi+1):
val = (val * powers[ii]) % 1_000_000_007
ans.append(val)
return ans | range-product-queries-of-powers | [Python3] simulation | ye15 | 0 | 10 | range product queries of powers | 2,438 | 0.384 | Medium | 33,366 |
https://leetcode.com/problems/range-product-queries-of-powers/discuss/2707190/Easy-python-solution | class Solution:
def productQueries(self, n: int, queries: List[List[int]]) -> List[int]:
//this will gives us the binary representation of the number
binary_of_n = bin(n).replace("0b", "")
result = []
powers = []
//Iterate through the binary number and when ever we
//find 1 we add that to the power array.
for i in range(len(binary_of_n)-1, -1, -1):
if binary_of_n[len(binary_of_n)-1-i] == '1':
powers.append(2**i)
// now the power are in reverse order so sorting it
powers.sort();
for query in queries:
first = query[0]
second = query[1]
temp = 1
for i in range(first, second+1):
temp = temp * powers[i] % (10**9 + 7)
result.append(temp)
return result | range-product-queries-of-powers | Easy python solution | Yuvraj-50 | 0 | 8 | range product queries of powers | 2,438 | 0.384 | Medium | 33,367 |
https://leetcode.com/problems/range-product-queries-of-powers/discuss/2707049/python-solution | class Solution:
def productQueries(self, n: int, queries: List[List[int]]) -> List[int]:
p,c=[],0
while n>0:
if n&1==1:
p.append(pow(2,c))
c+=1
n=n>>1
ans=[]
for i in queries:
s=1
for j in range(i[0],i[1]+1):
s*=p[j]
ans.append(s%(pow(10,9)+7))
return ans | range-product-queries-of-powers | python solution | cheems_ds_side | 0 | 6 | range product queries of powers | 2,438 | 0.384 | Medium | 33,368 |
https://leetcode.com/problems/range-product-queries-of-powers/discuss/2706859/Python3-Prefix-Sum-Solution | class Solution:
def productQueries(self, n: int, queries: List[List[int]]) -> List[int]:
bin_rep = bin(n)[2:]
data = [t for t in range(0, len(bin_rep)) if bin_rep[-t-1] == '1']
start = 0
for i in range(len(data)):
start += data[i]
data[i] = start
data.insert(0, 0)
res = []
for start, end in queries:
res.append((2**(data[end+1] - data[start])) % (10**9 + 7))
return res | range-product-queries-of-powers | Python3 Prefix Sum Solution | xxHRxx | 0 | 5 | range product queries of powers | 2,438 | 0.384 | Medium | 33,369 |
https://leetcode.com/problems/range-product-queries-of-powers/discuss/2706747/Bit-manipulation-or-Python-3 | class Solution:
def productQueries(self, n: int, queries: List[List[int]]) -> List[int]:
binary=bin(n).replace("0b",'')[::-1]
powers=[]
ans=[]
powe=0
for i in range(len(binary)):
if binary[i]=='1':
powers.append(2**i)
for i in range(1,len(powers)):
powers[i]*=powers[i-1]
for i,j in queries:
if i==0:
val=powers[j]
else:
val=powers[j]//powers[i-1]
ans.append(val%1000000007)
return ans | range-product-queries-of-powers | Bit manipulation | Python 3 | RickSanchez101 | 0 | 6 | range product queries of powers | 2,438 | 0.384 | Medium | 33,370 |
https://leetcode.com/problems/range-product-queries-of-powers/discuss/2706564/Straightforward-PYTHON3-Solution | class Solution:
def productQueries(self, n: int, queries: List[List[int]]) -> List[int]:
mod=10**9+7
powers=[]
a=bin(n)[2:]
j=0
for i in range(len(a)-1,-1,-1):
if a[i]=='1':
powers.append(2**j)
j+=1
answers=[]
for a,b in queries:
c=powers[a]
for i in range(a+1,b+1):
c*=powers[i]
answers.append(c%mod)
return answers | range-product-queries-of-powers | Straightforward [PYTHON3] Solution | shreyasjain0912 | 0 | 13 | range product queries of powers | 2,438 | 0.384 | Medium | 33,371 |
https://leetcode.com/problems/range-product-queries-of-powers/discuss/2706500/Python3-Straightforward | class Solution:
def productQueries(self, n: int, queries: List[List[int]]) -> List[int]:
big=10**9 + 7
nBinary=bin(n)[2:][::-1]
powers=[2**x for x in range(len(nBinary)) if nBinary[x]=='1']
answ=[]
for left,right in queries:
q=1
for i in range(left,right+1):
q*=powers[i]
answ.append(q%big)
return answ | range-product-queries-of-powers | Python3, Straightforward | Silvia42 | 0 | 13 | range product queries of powers | 2,438 | 0.384 | Medium | 33,372 |
https://leetcode.com/problems/range-product-queries-of-powers/discuss/2706429/Python3-Easy-to-understand | class Solution:
def productQueries(self, n: int, queries: List[List[int]]) -> List[int]:
MOD = 10**9+7
v = []
ans1 = []
while (n > 0):
v.append(int(n % 2))
n = int(n / 2)
for i in range(0, len(v)):
if (v[i] == 1):
ans1.append(2**i)
ans = []
for i,j in queries:
val = 1
for x in range(i,j+1):
val*=ans1[x]
ans.append(val%MOD)
return ans | range-product-queries-of-powers | [Python3] Easy to understand | chandu71202 | 0 | 15 | range product queries of powers | 2,438 | 0.384 | Medium | 33,373 |
https://leetcode.com/problems/range-product-queries-of-powers/discuss/2706423/python-oror-easy-soln | class Solution:
def productQueries(self, n: int, queries: List[List[int]]) -> List[int]:
def min_arr(x):
k = bin(x)[2:]
k = k[::-1]
ans = []
for i in range(0, len(k)):
if (k[i] == '1'):
ans.append(2**i)
return ans
nums = min_arr(n)
prod = [1]
for i in range(len(nums)):
k = (prod[-1]*nums[i])
prod.append(k)
res = []
for i in range(len(queries)):
b = prod[queries[i][1]+1]
a = prod[queries[i][0]]
res.append((b//a))
res[i] = res[i]%(10**9 + 7)
return res | range-product-queries-of-powers | python || easy soln | deepakchowdary866 | 0 | 14 | range product queries of powers | 2,438 | 0.384 | Medium | 33,374 |
https://leetcode.com/problems/minimize-maximum-of-array/discuss/2706472/Average | class Solution:
def minimizeArrayValue(self, nums: List[int]) -> int:
return max(ceil(n / (i + 1)) for i, n in enumerate(accumulate(nums))) | minimize-maximum-of-array | Average | votrubac | 45 | 2,800 | minimize maximum of array | 2,439 | 0.331 | Medium | 33,375 |
https://leetcode.com/problems/minimize-maximum-of-array/discuss/2706976/Python-simple-solution-explained-(rolling-average)-O(n) | class Solution:
def minimizeArrayValue(self, nums: List[int]) -> int:
max_ = sum_ = 0
for i, num in enumerate(nums, start = 1):
sum_ += num
ave, modulo = divmod(sum_, i)
if modulo: ave += 1
max_ = max(ave, max_)
return max_
# end minimizeArrayValue() | minimize-maximum-of-array | Python simple solution explained (rolling average) O(n) | olzh06 | 10 | 216 | minimize maximum of array | 2,439 | 0.331 | Medium | 33,376 |
https://leetcode.com/problems/minimize-maximum-of-array/discuss/2836579/Easy-to-understand-O(n)-time-and-O(1)-space-solution-with-detailed-explanation. | class Solution:
def minimizeArrayValue(self, nums: List[int]) -> int:
maxim = nums[0]
prefix_sum = nums[0]
for idx in range(1, len(nums)):
curr = nums[idx]
prefix_sum += curr
if curr > maxim:
maxim = max(maxim, math.ceil(prefix_sum / (idx + 1)))
return maxim | minimize-maximum-of-array | Easy to understand O(n) time and O(1) space solution with detailed explanation. | Henok2011 | 1 | 17 | minimize maximum of array | 2,439 | 0.331 | Medium | 33,377 |
https://leetcode.com/problems/minimize-maximum-of-array/discuss/2708695/Python3-Minecraft | class Solution:
def minimizeArrayValue(self, nums: List[int]) -> int:
maxx = nums[0]
hole = 0
for i, x in enumerate(nums[1:], 1):
if x - maxx > hole:
extra_blocks = x - maxx - hole # extra blocks after filling hole
cols = i + 1
if extra_blocks % cols == 0:
maxx = maxx + extra_blocks // cols
hole = 0
else:
maxx = maxx + extra_blocks // cols + 1
hole = cols - extra_blocks % cols
else:
hole = hole + (maxx - x)
return maxx | minimize-maximum-of-array | [Python3] Minecraft | rt500 | 1 | 24 | minimize maximum of array | 2,439 | 0.331 | Medium | 33,378 |
https://leetcode.com/problems/minimize-maximum-of-array/discuss/2706483/Short-Python3 | class Solution:
def minimizeArrayValue(self, nums: List[int]) -> int:
mn = nums[0]
nums = list(accumulate(nums))
for i, n in enumerate(nums):
mn = max(mn, ceil(n/(i+1)))
return mn | minimize-maximum-of-array | Short Python3 | tglukhikh | 1 | 51 | minimize maximum of array | 2,439 | 0.331 | Medium | 33,379 |
https://leetcode.com/problems/minimize-maximum-of-array/discuss/2706374/Python3-Binary-Search-on-the-Answer | class Solution:
def minimizeArrayValue(self, nums: List[int]) -> int:
start, end = 0, max(nums)
while start + 1 < end:
mid = (start + end) // 2
if self.check(nums, mid):
end = mid
else:
start = mid
if self.check(nums, start):
return start
else:
return end
def check(self, nums, k):
n = len(nums)
temp = 0
for i in range(n - 1, 0, -1):
if temp + nums[i] > k:
temp += nums[i] - k
else:
temp = 0
return False if temp + nums[0] > k else True | minimize-maximum-of-array | [Python3] Binary Search on the Answer | xil899 | 1 | 87 | minimize maximum of array | 2,439 | 0.331 | Medium | 33,380 |
https://leetcode.com/problems/minimize-maximum-of-array/discuss/2817979/Python-(Simple-DP) | class Solution:
def minimizeArrayValue(self, nums):
n = len(nums)
dp = [0]*n
running_sum, dp[0] = nums[0], nums[0]
for i in range(1,n):
running_sum += nums[i]
dp[i] = max(dp[i-1],(running_sum+i)//(i+1))
return max(dp) | minimize-maximum-of-array | Python (Simple DP) | rnotappl | 0 | 3 | minimize maximum of array | 2,439 | 0.331 | Medium | 33,381 |
https://leetcode.com/problems/minimize-maximum-of-array/discuss/2806905/Python3Monotonic-Stack-O(n)-with-explanation | class Solution:
def minimizeArrayValue(self, nums: List[int]) -> int:
stk = []
for num in nums:
total, cnt = num, 1
while len(stk) > 0 and stk[-1][0] / stk[-1][1] <= total / cnt:
top = stk.pop()
total += top[0]
cnt += top[1]
stk.append([total, cnt])
ans = math.ceil(stk[0][0] / stk[0][1])
return ans | minimize-maximum-of-array | [Python3]Monotonic Stack O(n) with explanation | huangweijing | 0 | 3 | minimize maximum of array | 2,439 | 0.331 | Medium | 33,382 |
https://leetcode.com/problems/minimize-maximum-of-array/discuss/2806878/Easy-to-understand | class Solution:
def minimizeArrayValue(self, nums: List[int]) -> int:
s,n = 0,len(nums)
res = 0
for i in range(n):
s+=nums[i]
res = max(res,math.ceil(s/(i+1)))
return res | minimize-maximum-of-array | Easy to understand | Rtriders | 0 | 3 | minimize maximum of array | 2,439 | 0.331 | Medium | 33,383 |
https://leetcode.com/problems/minimize-maximum-of-array/discuss/2755712/Binary-search-for-the-max | class Solution:
def minimizeArrayValue(self, nums: List[int]) -> int:
left, right = nums[0], max(nums)
n1 = len(nums) - 1
while left < right:
middle = (left + right) // 2
lst = nums.copy()
for i in range(n1, 0, -1):
diff = lst[i] - middle
if diff > 0:
lst[i] = middle
lst[i - 1] += diff
if lst[0] <= middle:
right = middle
else:
left = middle + 1
return right | minimize-maximum-of-array | Binary search for the max | EvgenySH | 0 | 11 | minimize maximum of array | 2,439 | 0.331 | Medium | 33,384 |
https://leetcode.com/problems/minimize-maximum-of-array/discuss/2711576/Python-Binary-Search-solution-easy-to-understand | class Solution:
def minimizeArrayValue(self, nums: List[int]) -> int:
n = len(nums)
def canForm(k):
rest = 0
for i in range(n - 1, 0, -1):
cur = nums[i]
if rest + cur <= k:
rest = 0
else:
rest = (cur + rest) - k
return rest + nums[0] <= k
#binary search: find the first true of canForm
lo = 0
hi = max(nums) + 1
while lo < hi:
mid = (hi + lo) // 2
if canForm(mid):
hi = mid
else:
lo = mid + 1
return lo | minimize-maximum-of-array | [Python] Binary Search solution, easy to understand | cosmicshuai | 0 | 18 | minimize maximum of array | 2,439 | 0.331 | Medium | 33,385 |
https://leetcode.com/problems/minimize-maximum-of-array/discuss/2710839/Python3-Binary-Search-Solution | class Solution:
def minimizeArrayValue(self, nums: List[int]) -> int:
start, end = 0, max(nums)
size_t = len(nums)
while start < end:
mid = floor((start + end) / 2)
i = 0
flag = True
remain = 0
for i in range(size_t):
remain += max(mid - nums[i], 0)
remain -= max(nums[i] - mid, 0)
if remain < 0: flag = False; break
if flag:
end = mid
else:
start = mid + 1
return start | minimize-maximum-of-array | Python3 Binary Search Solution | xxHRxx | 0 | 10 | minimize maximum of array | 2,439 | 0.331 | Medium | 33,386 |
https://leetcode.com/problems/minimize-maximum-of-array/discuss/2710490/Easy-Python-soln | class Solution:
def minimizeArrayValue(self, nums: List[int]) -> int:
i=1
while i<len(nums):
nums[i]+=nums[i-1]
i+=1
i=0
while i<len(nums):
nums[i]/=i+1
i+=1
m=max(nums)
if int(m)==m:
return int(m)
else:
return int(m)+1 | minimize-maximum-of-array | Easy Python soln | DhruvBagrecha | 0 | 9 | minimize maximum of array | 2,439 | 0.331 | Medium | 33,387 |
https://leetcode.com/problems/minimize-maximum-of-array/discuss/2709857/Python-O(n)-time-O(1)-extra-space-beats-100 | class Solution:
def minimizeArrayValue(self, nums: List[int]) -> int:
curSum = nums[0]
curMax = nums[0]
for i in range(1, len(nums)):
curSum += nums[i]
if nums[i] > curMax:
bal = curSum//(i+1)
curMax = max(curMax, bal + (1 if curSum % (i+1) > 0 else 0))
return curMax | minimize-maximum-of-array | Python O(n) time O(1) extra space beats 100% | AkshayDagar | 0 | 6 | minimize maximum of array | 2,439 | 0.331 | Medium | 33,388 |
https://leetcode.com/problems/minimize-maximum-of-array/discuss/2708743/python-oror-simple-binary-search | class Solution:
def minimizeArrayValue(self, nums: List[int]) -> int:
def ispossible(target,arr):
for i in range(len(arr)-1):
if arr[i] > target:
return False
arr[i+1] -= target-arr[i]
if arr[len(arr)-1]<=target:
return True
return False
ans = 0
l = 0
r = max(nums)
while l<=r:
mid = (l+r)>>1
arr = nums[:]
if ispossible(mid,arr):
r = mid-1
ans = mid
else:
l = mid+1
return ans
#please upvote if youlike | minimize-maximum-of-array | python || simple binary search | deepakchowdary866 | 0 | 20 | minimize maximum of array | 2,439 | 0.331 | Medium | 33,389 |
https://leetcode.com/problems/minimize-maximum-of-array/discuss/2707303/Python3-greedy | class Solution:
def minimizeArrayValue(self, nums: List[int]) -> int:
return max((x+i)//(i+1) for i, x in enumerate(accumulate(nums))) | minimize-maximum-of-array | [Python3] greedy | ye15 | 0 | 17 | minimize maximum of array | 2,439 | 0.331 | Medium | 33,390 |
https://leetcode.com/problems/minimize-maximum-of-array/discuss/2706562/Binary-Search-in-Python | class Solution:
def minimizeArrayValue(self, nums: List[int]) -> int:
def isPossible(arr,mid):
n = len(arr)
if arr[0] > mid:
return False
p = arr[0]
for i in range(1,n):
d = mid - p
p = arr[i] - d
if p > mid:
return False
return True
l,h = 1,max(nums)
ans = h
while l<=h:
mid = (l+h)//2
if isPossible(nums,mid):
ans = min(mid,ans)
h = mid-1
else:
l = mid+1
return ans | minimize-maximum-of-array | Binary Search in Python | fahadahasmi | 0 | 24 | minimize maximum of array | 2,439 | 0.331 | Medium | 33,391 |
https://leetcode.com/problems/minimize-maximum-of-array/discuss/2706524/O(n)-oror-DP-oror-Prefix-sum | class Solution:
def minimizeArrayValue(self, nums: List[int]) -> int:
n = len(nums)
pr = [0]
for i in range(n):
pr.append(pr[-1] + nums[i])
dp = [0] * n
dp[0] = nums[0]
for i in range(1, n):
if nums[i] < dp[i - 1]:
dp[i] = dp[i - 1]
else:
dp[i] = max(dp[i - 1], math.ceil(pr[i + 1] / (i + 1)))
return dp[-1] | minimize-maximum-of-array | O(n) || DP || Prefix sum | ser0p | 0 | 41 | minimize maximum of array | 2,439 | 0.331 | Medium | 33,392 |
https://leetcode.com/problems/create-components-with-same-value/discuss/2707304/Python3-post-order-dfs | class Solution:
def componentValue(self, nums: List[int], edges: List[List[int]]) -> int:
tree = [[] for _ in nums]
for u, v in edges:
tree[u].append(v)
tree[v].append(u)
def fn(u, p):
"""Post-order dfs."""
ans = nums[u]
for v in tree[u]:
if v != p: ans += fn(v, u)
return 0 if ans == cand else ans
total = sum(nums)
for cand in range(1, total//2+1):
if total % cand == 0 and fn(0, -1) == 0: return total//cand-1
return 0 | create-components-with-same-value | [Python3] post-order dfs | ye15 | 11 | 264 | create components with same value | 2,440 | 0.543 | Hard | 33,393 |
https://leetcode.com/problems/create-components-with-same-value/discuss/2706535/Python-Get-factors-of-sum-all-nodes-then-check | class Solution:
def getFactors(self, x):
factors = []
for i in range(1, int(sqrt(x)) + 1):
if x % i != 0: continue
factors.append(i)
if x // i != i: factors.append(x // i)
return factors
def componentValue(self, nums: List[int], edges: List[List[int]]) -> int:
n = len(nums)
graph = defaultdict(list)
for a, b in edges:
graph[a].append(b)
graph[b].append(a)
self.cntRemainZero = 0
def dfs(u, p, sumPerComponent): # return remain of the subtree with root `u`
remain = nums[u]
for v in graph[u]:
if v == p: continue
remain += dfs(v, u, sumPerComponent)
remain %= sumPerComponent
if remain == 0:
self.cntRemainZero += 1
return remain
def isGood(sumPerComponent, expectedNumOfComponents):
self.cntRemainZero = 0
dfs(0, -1, sumPerComponent)
return self.cntRemainZero == expectedNumOfComponents
sumAllNodes, maxNum = sum(nums), max(nums)
for sumPerComponent in sorted(self.getFactors(sumAllNodes)):
if sumPerComponent < maxNum: continue # at least maxNum
expectedNumOfComponents = sumAllNodes // sumPerComponent
if isGood(sumPerComponent, expectedNumOfComponents):
return expectedNumOfComponents - 1 # Need to cut `numOfComponent - 1` edges to make `numOfComponent` connected component
return 0 | create-components-with-same-value | [Python] Get factors of sum all nodes then check | hiepit | 4 | 337 | create components with same value | 2,440 | 0.543 | Hard | 33,394 |
https://leetcode.com/problems/largest-positive-integer-that-exists-with-its-negative/discuss/2774238/Easy-Python-Solution | class Solution:
def findMaxK(self, nums: List[int]) -> int:
nums.sort()
for i in nums[::-1]:
if -i in nums:
return i
return -1 | largest-positive-integer-that-exists-with-its-negative | Easy Python Solution | Vistrit | 3 | 64 | largest positive integer that exists with its negative | 2,441 | 0.678 | Easy | 33,395 |
https://leetcode.com/problems/largest-positive-integer-that-exists-with-its-negative/discuss/2708513/largest-positive-integer-that-exists-with-its-negative | class Solution:
def findMaxK(self, nums: List[int]) -> int:
nums=sorted(nums,reverse=True)
s=set(nums)
for i in range(len(nums)):
if 0-nums[i] in s:
return nums[i]
return -1 | largest-positive-integer-that-exists-with-its-negative | largest-positive-integer-that-exists-with-its-negative | meenu155 | 1 | 35 | largest positive integer that exists with its negative | 2,441 | 0.678 | Easy | 33,396 |
https://leetcode.com/problems/largest-positive-integer-that-exists-with-its-negative/discuss/2708334/Python-1-liner-simple | class Solution:
def findMaxK(self, nums: List[int]) -> int:
return max(list(filter(lambda x: nums.count(x) >= 1 and nums.count(-x) >= 1, nums)) + [-1]) | largest-positive-integer-that-exists-with-its-negative | Python 1-liner simple | dhnam2234 | 1 | 82 | largest positive integer that exists with its negative | 2,441 | 0.678 | Easy | 33,397 |
https://leetcode.com/problems/largest-positive-integer-that-exists-with-its-negative/discuss/2708275/Python-O(n) | class Solution:
def findMaxK(self, nums: List[int]) -> int:
d = {}
for i in nums:
d[i] = d.get(i, 0)+1
ans = -1
for i in sorted(d.keys()):
if i<0:
continue
elif i>0 and -i in d:
ans = i
return ans | largest-positive-integer-that-exists-with-its-negative | Python O(n) | diwakar_4 | 1 | 31 | largest positive integer that exists with its negative | 2,441 | 0.678 | Easy | 33,398 |
https://leetcode.com/problems/largest-positive-integer-that-exists-with-its-negative/discuss/2846890/Python-Super-Easy-One-Pass-Solution | class Solution:
def findMaxK(self, nums: List[int]) -> int:
res = -1
s = set()
for num in nums:
if -num in s:
res = max(res, abs(num))
s.add(num)
return res | largest-positive-integer-that-exists-with-its-negative | Python Super Easy One Pass Solution | kaien | 0 | 2 | largest positive integer that exists with its negative | 2,441 | 0.678 | Easy | 33,399 |