post_href
stringlengths 57
213
| python_solutions
stringlengths 71
22.3k
| slug
stringlengths 3
77
| post_title
stringlengths 1
100
| user
stringlengths 3
29
| upvotes
int64 -20
1.2k
| views
int64 0
60.9k
| problem_title
stringlengths 3
77
| number
int64 1
2.48k
| acceptance
float64 0.14
0.91
| difficulty
stringclasses 3
values | __index_level_0__
int64 0
34k
|
|---|---|---|---|---|---|---|---|---|---|---|---|
https://leetcode.com/problems/minimum-cost-homecoming-of-a-robot-in-a-grid/discuss/2714476/Python-O(N-%2B-M)-O(1)
|
class Solution:
def minCost(self, startPos: List[int], homePos: List[int], rowCosts: List[int], colCosts: List[int]) -> int:
row_cost = sum(rowCosts[min(startPos[0], homePos[0]):max(startPos[0], homePos[0]) + 1]) - rowCosts[startPos[0]]
col_cost = sum(colCosts[min(startPos[1], homePos[1]):max(startPos[1], homePos[1]) + 1]) - colCosts[startPos[1]]
return row_cost + col_cost
|
minimum-cost-homecoming-of-a-robot-in-a-grid
|
Python - O(N + M), O(1)
|
Teecha13
| 0
| 3
|
minimum cost homecoming of a robot in a grid
| 2,087
| 0.513
|
Medium
| 28,800
|
https://leetcode.com/problems/minimum-cost-homecoming-of-a-robot-in-a-grid/discuss/1599187/Python-with-explanation-O(n)-time-O(1)-space
|
class Solution:
def minCost(self, startPos: List[int], homePos: List[int], rowCosts: List[int], colCosts: List[int]) -> int:
rm=0
lm=0
rm=startPos[0]-homePos[0]# number of ups or downs
lm=startPos[1]-homePos[1] # number of lefts or rights
ans=0
if rm<0:#we need to down
a=startPos[0]
while rm!=0:
rm+=1
ans+=rowCosts[a+1]#add costs according to the row numbers
a+=1
elif rm>0:#up
a=startPos[0]
while rm!=0:
rm-=1
ans+=rowCosts[a-1]
a-=1
if lm<0:#left
a=startPos[1]
while lm!=0:
lm+=1
ans+=colCosts[a+1]
a+=1
elif lm>0:#right
a=startPos[1]
while lm!=0:
lm-=1
ans+=colCosts[a-1]
a-=1
return ans
|
minimum-cost-homecoming-of-a-robot-in-a-grid
|
Python with explanation O(n) time O(1) space
|
nmk0462
| 0
| 70
|
minimum cost homecoming of a robot in a grid
| 2,087
| 0.513
|
Medium
| 28,801
|
https://leetcode.com/problems/count-fertile-pyramids-in-a-land/discuss/1598873/Python3-just-count
|
class Solution:
def countPyramids(self, grid: List[List[int]]) -> int:
m, n = len(grid), len(grid[0])
vals = [[inf]*n for _ in range(m)]
for i in range(m):
for j in range(n):
if grid[i][j] == 0: vals[i][j] = 0
elif j == 0: vals[i][j] = 1
else: vals[i][j] = min(vals[i][j], 1 + vals[i][j-1])
if grid[i][~j] == 0: vals[i][~j] = 0
elif j == 0: vals[i][~j] = 1
else: vals[i][~j] = min(vals[i][~j], 1 + vals[i][~j+1])
def fn(vals):
"""Return count of pyramid in given grid."""
ans = 0
for j in range(n):
width = 0
for i in range(m):
if vals[i][j]: width = min(width+1, vals[i][j])
else: width = 0
ans += max(0, width-1)
return ans
return fn(vals) + fn(vals[::-1])
|
count-fertile-pyramids-in-a-land
|
[Python3] just count
|
ye15
| 5
| 415
|
count fertile pyramids in a land
| 2,088
| 0.635
|
Hard
| 28,802
|
https://leetcode.com/problems/count-fertile-pyramids-in-a-land/discuss/1599023/Python-dp-solution
|
class Solution:
def countPyramids(self, grid: List[List[int]]) -> int:
#checks if there are 3 ones below (x,y)
def check(x,y):
count = 0
to_check = {(1,0),(1,-1),(1,1)}
for dx,dy in to_check:
if(0<=x+dx<len(grid) and 0<=y+dy<len(grid[0]) and grid[x+dx][y+dy]==1):
count += 1
if(count == 3):
return True
else:
return False
memo = {}
#dp returns the number of pyramid levels under (x,y)
def dp(x,y):
if((x,y) in memo):
return memo[(x,y)]
levels = 0
if(check(x,y)==True):
levels += 1
else:
return levels
to_check = {(1,0),(1,-1),(1,1)}
t = float('inf')
#t is the number of additional levels
for dx,dy in to_check:
if(0<=x+dx<len(grid) and 0<=y+dy<len(grid[0]) and grid[x+dx][y+dy]==1):
t = min(t,dp(x+dx,y+dy))
memo[(x,y)] = levels + t
return levels + t
#check number of normal pyramidal plots
ans = 0
for i in range(len(grid)):
for j in range(len(grid[0])):
if(grid[i][j] == 1):
ans += dp(i,j)
#check number of inverse pyramidal plots
memo = {}
grid = grid[::-1]
for i in range(len(grid)):
for j in range(len(grid[0])):
if(grid[i][j] == 1):
ans += dp(i,j)
return ans
|
count-fertile-pyramids-in-a-land
|
Python dp solution
|
aakashc
| 1
| 64
|
count fertile pyramids in a land
| 2,088
| 0.635
|
Hard
| 28,803
|
https://leetcode.com/problems/count-fertile-pyramids-in-a-land/discuss/2609252/Python3-or-DP
|
class Solution:
def countPyramids(self, grid: List[List[int]]) -> int:
f_ans=0
def countPyramids(grid):
r,c=len(grid),len(grid[0])
dp=copy.deepcopy(grid)
ans=0
for i in range(r-2,-1,-1):
for j in range(1,c-1):
if dp[i][j]:
dp[i][j]=min(dp[i+1][j-1],dp[i+1][j],dp[i+1][j+1])+1
ans+=dp[i][j]-1
return ans
f_ans+=countPyramids(grid)
f_ans+=countPyramids(grid[::-1])
return f_ans
|
count-fertile-pyramids-in-a-land
|
[Python3] | DP
|
swapnilsingh421
| 0
| 5
|
count fertile pyramids in a land
| 2,088
| 0.635
|
Hard
| 28,804
|
https://leetcode.com/problems/count-fertile-pyramids-in-a-land/discuss/2490226/Python3-solution%3A-faster-than-97.2-of-other-submissions-oror-Easy-to-understand
|
class Solution:
def countPyramids(self, grid):
# dp[i][j] represents the number of layers of the largest pyramid with (i, j) as the vertex.
# Note that the 1-level pyramid is invalid in the problem, so it should be removed when summing.
# Note that if grid[i][j] is 0, dp[i][j] will always be 0.
# The dp recurrence formula is dp[i][j] = min(dp[i + 1][j - 1], dp[i + 1][j + 1]) + 1
m, n, dp, cnt = len(grid), len(grid[0]), copy.deepcopy(grid), 0
# triangle
for i in range(m - 2, -1, -1):
for j in range(1, n - 1):
if dp[i][j] > 0 and dp[i + 1][j] > 0:
dp[i][j] = min(dp[i + 1][j - 1], dp[i + 1][j + 1]) + 1
cnt += dp[i][j] - 1
# inverted triangle
dp = grid
for i in range(1, m):
for j in range(1, n - 1):
if dp[i][j] > 0 and dp[i - 1][j] > 0:
dp[i][j] = min(dp[i - 1][j - 1], dp[i - 1][j + 1]) + 1
cnt += dp[i][j] - 1
return cnt
|
count-fertile-pyramids-in-a-land
|
✔️ Python3 solution: faster than 97.2% of other submissions || Easy to understand
|
explusar
| 0
| 21
|
count fertile pyramids in a land
| 2,088
| 0.635
|
Hard
| 28,805
|
https://leetcode.com/problems/count-fertile-pyramids-in-a-land/discuss/2351936/Python3-or-DP-or-Memoization-or-O(m*n)
|
class Solution:
def countPyramids(self, grid: List[List[int]]) -> int:
m, n = len(grid), len(grid[0])
@cache
def countDown(i, j):
nonlocal m, n
if i + 1 < m and j - 1 > -1 and j + 1 < n and grid[i][j] == 1:
left = countDown(i+1, j-1)
bottom = countDown(i+1, j)
right = countDown(i+1, j+1)
return 1 + min(left, bottom, right)
else:
return grid[i][j]
@cache
def countUp(i, j):
nonlocal m, n
if i - 1 > -1 and j - 1 > -1 and j + 1 < n and grid[i][j] == 1:
left = countUp(i-1, j-1)
top = countUp(i-1, j)
right = countUp(i-1, j+1)
return 1 + min(left, top, right)
else:
return grid[i][j]
ans = 0
for i in range(m):
for j in range(n):
if countDown(i, j) != 0:
ans += countDown(i, j) - 1
if countUp(i, j) != 0:
ans += countUp(i, j) - 1
return ans
|
count-fertile-pyramids-in-a-land
|
Python3 | DP | Memoization | O(m*n)
|
DheerajGadwala
| 0
| 14
|
count fertile pyramids in a land
| 2,088
| 0.635
|
Hard
| 28,806
|
https://leetcode.com/problems/count-fertile-pyramids-in-a-land/discuss/1655710/Python-oror-2-Solutions-oror-Prefix-Sum-oror-DP
|
class Solution:
def countPyramids(self, grid: List[List[int]]) -> int:
m,n=len(grid),len(grid[0])
def solve(arr):
left,right=[[0]*n for _ in range(m)],[[0]*n for _ in range(m)]
ans=0
for i in range(m):
for j in range(1,n):
if arr[i][j]==1:
left[i][j]=left[i][j-1]+(1 if arr[i][j-1]==1 else 0)
for j in range(n-2,-1,-1):
if arr[i][j]==1:
right[i][j]=right[i][j+1]+(1 if arr[i][j+1]==1 else 0)
valid=[[0]*n for _ in range(m)]
for i in range(1,m):
for j in range(1,n):
dist=min(left[i][j],right[i][j])
order=valid[i-1][j]
if arr[i][j]==1:
if arr[i-1][j] and order<=dist-1:
ans+=order+1
valid[i][j]=order+1
elif arr[i-1][j] and dist:
ans+=dist
valid[i][j]=dist
return ans
new_grid=[[0]*n for _ in range(m)]
for i in range(m):
for j in range(n):
new_grid[i][j]=grid[m-i-1][n-j-1]
return solve(grid)+solve(new_grid)
|
count-fertile-pyramids-in-a-land
|
Python || 2 Solutions || Prefix-Sum || DP
|
ketan_raut
| 0
| 67
|
count fertile pyramids in a land
| 2,088
| 0.635
|
Hard
| 28,807
|
https://leetcode.com/problems/count-fertile-pyramids-in-a-land/discuss/1655710/Python-oror-2-Solutions-oror-Prefix-Sum-oror-DP
|
class Solution:
def countPyramids(self, grid: List[List[int]]) -> int:
m,n=len(grid),len(grid[0])
def solve(arr):
dp=arr
ans=0
for i in range(1,m):
for j in range(1,n-1):
if dp[i][j]:
dp[i][j]+=min(dp[i-1][j],dp[i-1][j-1],dp[i-1][j+1])
ans+=dp[i][j]-1
return ans
new_grid=[[0]*n for _ in range(m)]
for i in range(m):
for j in range(n):
new_grid[i][j]=grid[m-i-1][n-j-1]
return solve(grid)+solve(new_grid)
|
count-fertile-pyramids-in-a-land
|
Python || 2 Solutions || Prefix-Sum || DP
|
ketan_raut
| 0
| 67
|
count fertile pyramids in a land
| 2,088
| 0.635
|
Hard
| 28,808
|
https://leetcode.com/problems/count-fertile-pyramids-in-a-land/discuss/1599545/Python3%3A-Reduces-to-finding-an-increasing-sequence-in-columns
|
class Solution:
def countPyramids(self, grid: List[List[int]]) -> int:
m, n = len(grid), len(grid[0])
dp = [[0]*n for _ in range(m)]
# count "1" from left to right
for r in range(m):
for c in range(n):
if grid[r][c] == 0: continue
if c == 0:
dp[r][c] = grid[r][c]
else:
dp[r][c] += dp[r][c - 1] + 1
# count "1" from right to left and take min(left, right) in one loop
for c in range(n-1, -1, -1):
if grid[r][c] == 0: continue
if c == n - 1:
dp[r][c] = min(dp[r][c], grid[r][c])
else:
dp[r][c] = min(dp[r][c], dp[r][c + 1] + 1)
#print(dp)
ans = 0
for r in range(m):
for c in range(n):
if dp[r][c] == 0:
continue
k = 0
while (r + k) < m and dp[r + k][c] >= (k + 1): k += 1
ans += (k-1)
#print(ans)
k = 0
while (r - k) >= 0 and dp[r - k][c] >= k + 1: k += 1
ans += (k-1)
return ans
|
count-fertile-pyramids-in-a-land
|
Python3: Reduces to finding an increasing sequence in columns
|
abuOmar2
| 0
| 20
|
count fertile pyramids in a land
| 2,088
| 0.635
|
Hard
| 28,809
|
https://leetcode.com/problems/count-fertile-pyramids-in-a-land/discuss/1599532/python3-recursion-one-testcase-run-into-runtime-limit-though
|
class Solution(object):
ans = 0
def countPyramids(self, grid):
"""
:type grid: List[List[int]]
:rtype: int
"""
def isPyramidApex(g,i,j,c):
if (j - c) < 0:
return
try:
for x in range(j-c, j+c+1):
if g[i+1][x] != 1:
return
self.ans += 1
isPyramidApex(g, i+1, j, c+1)
except Exception as e:
return
def getPyrimadsCount(g):
n = len(g)
m = len(g[0])
for i in range(n):
for j in range(m):
# each point is a potential pyrmiad apex if it holds value of 1
if g[i][j]:
isPyramidApex(g, i,j, 1)
return
getPyrimadsCount(grid)
# flip array on X then Y direction and tally pyrimads
getPyrimadsCount([list(reversed(x)) for x in reversed(grid)])
return self.ans
|
count-fertile-pyramids-in-a-land
|
python3, recursion, one testcase run into runtime limit though
|
mhd
| 0
| 13
|
count fertile pyramids in a land
| 2,088
| 0.635
|
Hard
| 28,810
|
https://leetcode.com/problems/count-fertile-pyramids-in-a-land/discuss/1599149/Python3-DP-or-O(MN)-or-100-or-100
|
class Solution:
def countPyramids(self, grid: List[List[int]]) -> int:
m, n = len(grid), len(grid[0])
D = [[-1] * n for _ in range(2)] # D[i][j] = the number of pyramids where apex is (i, j)
DI = [[-1] * n for _ in range(2)] # for inverse
ans = 0
turn = 0
for j in range(n):
D[0][j] = 0 if grid[m - 1][j] else -1
DI[0][j] = 0 if grid[0][j] else -1
for i in range(m - 2, -1, -1):
for j in range(n):
if grid[i][j] == 0:
D[not turn][j] = -1
else:
if j == 0 or j == n - 1: D[not turn][j] = 0
else: D[not turn][j] = min(D[turn][j - 1], D[turn][j], D[turn][j + 1]) + 1
if grid[m - i - 1][j] == 0:
DI[not turn][j] = -1
else:
if j == 0 or j == n - 1: DI[not turn][j] = 0
else: DI[not turn][j] = min(DI[turn][j - 1], DI[turn][j], DI[turn][j + 1]) + 1
ans += max(D[not turn][j], 0) + max(DI[not turn][j], 0)
turn = not turn
return ans
|
count-fertile-pyramids-in-a-land
|
[Python3] DP | O(MN) | 100% | 100%
|
hooneken
| 0
| 21
|
count fertile pyramids in a land
| 2,088
| 0.635
|
Hard
| 28,811
|
https://leetcode.com/problems/count-fertile-pyramids-in-a-land/discuss/1599022/Python3-Short-DP
|
class Solution:
def countPyramids(self, grid: List[List[int]]) -> int:
m, n, res = len(grid), len(grid[0]), 0
dp = [row[:] for row in grid]
for i, j in product(range(m-2,-1,-1), range(1, n-1)):
if grid[i][j]:
dp[i][j] = min(dp[i+1][k] for k in range(j-1, j+2))+1
res += dp[i][j]-1
dp[0] = grid[0][:]
for i, j in product(range(1, m), range(1, n-1)):
if grid[i][j]:
dp[i][j] = min(dp[i-1][k] for k in range(j-1, j+2))+1
res += dp[i][j]-1
return res
|
count-fertile-pyramids-in-a-land
|
[Python3] Short DP
|
jl1230
| 0
| 24
|
count fertile pyramids in a land
| 2,088
| 0.635
|
Hard
| 28,812
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/2024498/Python-Solution-%2B-One-Line!
|
class Solution:
def targetIndices(self, nums, target):
ans = []
for i,num in enumerate(sorted(nums)):
if num == target: ans.append(i)
return ans
|
find-target-indices-after-sorting-array
|
Python - Solution + One-Line!
|
domthedeveloper
| 10
| 377
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,813
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/2024498/Python-Solution-%2B-One-Line!
|
class Solution:
def targetIndices(self, nums, target):
return [i for i,num in enumerate(sorted(nums)) if num==target]
|
find-target-indices-after-sorting-array
|
Python - Solution + One-Line!
|
domthedeveloper
| 10
| 377
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,814
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/2024498/Python-Solution-%2B-One-Line!
|
class Solution:
def targetIndices(self, nums, target):
idx = cnt = 0
for num in nums:
idx += num < target
cnt += num == target
return list(range(idx, idx+cnt))
|
find-target-indices-after-sorting-array
|
Python - Solution + One-Line!
|
domthedeveloper
| 10
| 377
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,815
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/2024498/Python-Solution-%2B-One-Line!
|
class Solution:
def targetIndices(self, nums, target):
idx = sum(num < target for num in nums)
cnt = sum(num == target for num in nums)
return list(range(idx, idx+cnt))
|
find-target-indices-after-sorting-array
|
Python - Solution + One-Line!
|
domthedeveloper
| 10
| 377
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,816
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/1672906/Two-Method-Soln-in-Python-Without-Sorting
|
class Solution:
def targetIndices(self, nums: List[int], target: int) -> List[int]:
m=c=0
for i in nums:
if i<target:
m+=1
if i==target:
c+= 1
if target not in nums:
return []
ans=[]
while c > 0:
ans.append(m)
m+=1
c-=1
return ans
|
find-target-indices-after-sorting-array
|
Two Method Soln in Python Without Sorting
|
gamitejpratapsingh998
| 4
| 196
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,817
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/1672906/Two-Method-Soln-in-Python-Without-Sorting
|
class Solution:
import heapq
def targetIndices(self, nums: List[int], target: int) -> List[int]:
heapq.heapify(nums)
i=0
ans=[]
while nums!=[]:
x = heapq.heappop(nums)
if x==target:
ans.append(i)
if x > target:
break
i+=1
return ans
|
find-target-indices-after-sorting-array
|
Two Method Soln in Python Without Sorting
|
gamitejpratapsingh998
| 4
| 196
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,818
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/2773394/Simple-Solution-O(n)
|
class Solution:
def targetIndices(self, N: List[int], T: int) -> List[int]:
c = i = 0
for n in N:
if n < T: i += 1
elif n == T: c += 1
return range(i, i+c)
|
find-target-indices-after-sorting-array
|
Simple Solution O(n)
|
Mencibi
| 1
| 81
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,819
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/1692419/Python-Binary-Search
|
class Solution:
def targetIndices(self, nums: List[int], target: int) -> List[int]:
nums.sort()
min = 0
max = len(nums) - 1
while min <= max:
pos = (min + max) // 2
if target == nums[pos]:
first = last = pos
# find first occurrence
if first - 1 >= 0:
while first != 0 and nums[first] == nums[first-1]:
first -= 1
# find last occurrence
if last != len(nums) - 1:
while last != len(nums) - 1 and nums[last] == nums[last+1]:
last += 1
else:
# only one 'target' was found
return [first]
return list(range(first,last+1))
elif target < nums[pos]:
max = pos - 1
else:
min = pos + 1
|
find-target-indices-after-sorting-array
|
Python Binary Search
|
manulik
| 1
| 399
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,820
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/1606050/One-pass-no-sorting-100-speed
|
class Solution:
def targetIndices(self, nums: List[int], target: int) -> List[int]:
n_lower = n_target = 0
for n in nums:
if n < target:
n_lower += 1
elif n == target:
n_target += 1
return list(range(n_lower, n_lower + n_target)) if n_target else []
|
find-target-indices-after-sorting-array
|
One pass, no sorting, 100% speed
|
EvgenySH
| 1
| 148
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,821
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/1601339/Python3-O(N)-Dijkstra's-3-way-partition
|
class Solution:
def targetIndices(self, nums: List[int], target: int) -> List[int]:
lo, mid, hi = 0, 0, len(nums)-1
while mid <= hi:
if nums[mid] < target:
nums[lo], nums[mid] = nums[mid], nums[lo]
lo += 1
mid += 1
elif nums[mid] == target: mid += 1
else:
nums[mid], nums[hi] = nums[hi], nums[mid]
hi -= 1
return range(lo, hi+1)
|
find-target-indices-after-sorting-array
|
[Python3] O(N) Dijkstra's 3-way partition
|
ye15
| 1
| 170
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,822
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/1599868/Python-lower-bound-or-upper-bound
|
class Solution:
def targetIndices(self, nums: List[int], target: int) -> List[int]:
nums.sort() # sorting array
return list(range(bisect_left(nums, target),bisect_right(nums, target))) #return range from left most occurrence to rightmost occurrence
|
find-target-indices-after-sorting-array
|
Python lower bound | upper bound
|
abkc1221
| 1
| 234
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,823
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/2848625/1-line-easy-code-in-Python3
|
class Solution:
def targetIndices(self, nums: List[int], target: int) -> List[int]:
return sorted([k[0] for k in list(enumerate(sorted(nums))) if k[1] == target])
|
find-target-indices-after-sorting-array
|
1 line easy code in Python3
|
DNST
| 0
| 1
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,824
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/2841292/onliner-python-faster-than-90
|
class Solution:
def targetIndices(self, nums: List[int], target: int) -> List[int]:
# d = sorted(nums)
# c=[]
# for x,y in enumerate(d):
# if y==target:
# c.append(x)
# return(c)
return [x for x, y in enumerate(sorted(nums)) if y==target ]
|
find-target-indices-after-sorting-array
|
onliner python faster than 90%
|
IronmanX
| 0
| 1
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,825
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/2815042/Easy-solution
|
class Solution:
def targetIndices(self, nums: List[int], target: int) -> List[int]:
n=len(nums)
list=[]
nums.sort()
for i in range (n):
if nums[i]==target:
list.append(i)
return list
|
find-target-indices-after-sorting-array
|
Easy solution
|
nishithakonuganti
| 0
| 1
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,826
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/2812278/2089.-Find-Target-Indices-After-Sorting-Array-with-Python
|
class Solution:
def targetIndices(self, nums: List[int], target: int) -> List[int]:
result = []
nums.sort()
for i in range(len(nums)):
if nums[i] == target:
result.append(i)
return result
|
find-target-indices-after-sorting-array
|
2089. Find Target Indices After Sorting Array with Python
|
Arsalan_Ahmed_07
| 0
| 1
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,827
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/2793443/Easy-to-understand-Python-Solution
|
class Solution:
def targetIndices(self, nums: List[int], target: int) -> List[int]:
lst = []
nums.sort()
for i in range(len(nums)):
if nums[i] == target:
lst.append(i)
return lst
|
find-target-indices-after-sorting-array
|
Easy to understand Python Solution
|
Aayush3014
| 0
| 1
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,828
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/2750459/Python-O(N)-Time
|
class Solution:
def targetIndices(self, nums: List[int], target: int) -> List[int]:
if target not in nums:
return []
greater, lower, equal = 0, 0,0
for i,num in enumerate(nums):
if num < target:
lower += 1
elif num > target:
greater += 1
else:
equal += 1
ans = []
ans.append(lower)
for i in range(equal-1):
ans.append(ans[-1] + 1)
return ans
|
find-target-indices-after-sorting-array
|
Python O(N) Time
|
vijay_2022
| 0
| 4
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,829
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/2730803/Python3-Short-Solution-!!!
|
class Solution:
def targetIndices(self, a: List[int], t: int) -> List[int]:
a = sorted(a)
return [i for i, v in enumerate(a) if v == t]
|
find-target-indices-after-sorting-array
|
[Python3] Short Solution !!!
|
kylewzk
| 0
| 7
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,830
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/2730681/Fast-and-Easy-Solution
|
class Solution:
def targetIndices(self, nums: List[int], target: int) -> List[int]:
nums.sort()
back = 0
for i in range(len(nums)):
if nums[i] == target:
nums[back] = i
back += 1
return nums[:back]
|
find-target-indices-after-sorting-array
|
Fast and Easy Solution
|
user6770yv
| 0
| 2
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,831
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/2690365/Python-Simple-Python-Solution-Using-Sorting
|
class Solution:
def targetIndices(self, nums: List[int], target: int) -> List[int]:
result = []
nums = sorted(nums)
for index in range(len(nums)):
if nums[index] > target:
break
if nums[index] == target:
result.append(index)
return result
|
find-target-indices-after-sorting-array
|
[ Python ] ✅✅ Simple Python Solution Using Sorting 🥳✌👍
|
ASHOK_KUMAR_MEGHVANSHI
| 0
| 13
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,832
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/2622479/Python-Solution-or-Two-Ways-Brute-Force-and-Counter-Based-or-Both-99-Faster
|
class Solution:
# brute force via sorting and linear search
def targetIndices(self, nums: List[int], target: int) -> List[int]:
nums.sort()
return [idx for idx, num in enumerate(nums) if num == target]
# counter based
def targetIndices(self, nums: List[int], target: int) -> List[int]:
counts = collections.Counter(nums)
smallEles = sum(ele for key, ele in counts.items() if key < target)
return list(range(smallEles, smallEles + counts[target]))
|
find-target-indices-after-sorting-array
|
Python Solution | Two Ways - Brute Force and Counter Based | Both 99% Faster
|
Gautam_ProMax
| 0
| 11
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,833
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/2568960/SIMPLE-PYTHON3-SOLUTION-O(logN)
|
class Solution:
def targetIndices(self, nums: List[int], target: int) -> List[int]:
nums.sort()
res = []
for i in range(nums.count(target)):
index = nums.index(target)
res.append(index)
nums[index] = target+2
return res
|
find-target-indices-after-sorting-array
|
✅✔ SIMPLE PYTHON3 SOLUTION ✅✔ O(logN)
|
rajukommula
| 0
| 33
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,834
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/2431185/2089.-Find-Target-Indices-After-Sorting-Array%3A-One-Liner
|
class Solution:
def targetIndices(self, nums: List[int], target: int) -> List[int]:
return [index for index,x in enumerate(sorted(nums)) if x == target]
|
find-target-indices-after-sorting-array
|
2089. Find Target Indices After Sorting Array: One Liner
|
rogerfvieira
| 0
| 16
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,835
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/2426724/Python-fast-and-easy-solution-using-built-in-function
|
class Solution:
def targetIndices(self, nums: List[int], target: int) -> List[int]:
sorted_nums = sorted(nums)
result = []
for i in range(len(sorted_nums)):
if sorted_nums[i] == target:
result.append(i)
return result
|
find-target-indices-after-sorting-array
|
Python fast and easy solution using built in function
|
samanehghafouri
| 0
| 12
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,836
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/2418558/Using-sort-function-Python
|
class Solution:
def targetIndices(self, nums: List[int], target: int) -> List[int]:
res = []
nums.sort()
for i in range(len(nums)):
if nums[i] == target:
res.append(i)
return res
|
find-target-indices-after-sorting-array
|
Using sort function Python
|
ankurbhambri
| 0
| 15
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,837
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/2385042/Python3-or-Easy-Sorting-Solution
|
class Solution:
#T.C = O(n)
#S.C = O(n)
def targetIndices(self, nums: List[int], target: int) -> List[int]:
nums.sort()
ans = []
for i in range(len(nums)):
if nums[i] == target:
ans.append(i)
return ans
|
find-target-indices-after-sorting-array
|
Python3 | Easy Sorting Solution
|
JOON1234
| 0
| 18
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,838
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/2376640/Python-O(N)-in-Time-and-O(1)-in-space-No-sorting
|
class Solution:
def targetIndices(self, nums: List[int], target: int) -> List[int]:
# only need to use two ints to record how many nums less than target, and how many nums equals to target
less = -1
equal = 0
for n in nums:
if n > target:
continue
elif n == target:
equal += 1
else:
less += 1
# if all the nums are large than target, return empty or
# if all the nums are smaller than target, return empty
if equal == 0:
return []
else: # if there are some nums equal target
return range(less+1,less+1+equal)
```
|
find-target-indices-after-sorting-array
|
Python O(N) in Time and O(1) in space, No sorting
|
meiyaowen
| 0
| 20
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,839
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/2286379/Simple-Python3-Solution
|
class Solution:
def targetIndices(self, nums: List[int], target: int) -> List[int]:
nums.sort()
l = list()
for i in range(len(nums)):
if nums[i] == target:
l.append(i)
return l
|
find-target-indices-after-sorting-array
|
Simple Python3 Solution
|
vem5688
| 0
| 34
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,840
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/2174894/Python-oneliner
|
class Solution:
def targetIndices(self, nums: List[int], target: int) -> List[int]:
return [x for x in range(sorted(nums).index(target),sorted(nums).index(target)+nums.count(target))] if target in nums else []
|
find-target-indices-after-sorting-array
|
Python oneliner
|
StikS32
| 0
| 58
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,841
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/2155841/Python3-Solution-with-using-counting
|
class Solution:
def targetIndices(self, nums: List[int], target: int) -> List[int]:
less_elems_cnt, more_elems_cnt = 0, 0
for num in nums:
if num < target:
less_elems_cnt += 1
elif num > target:
more_elems_cnt += 1
return [i for i in range(less_elems_cnt, len(nums) - more_elems_cnt)] if less_elems_cnt + more_elems_cnt < len(nums) else []
|
find-target-indices-after-sorting-array
|
[Python3] Solution with using counting
|
maosipov11
| 0
| 33
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,842
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/1988076/Python-Easiest-Solution-With-Explanation-or-88.79-Faster-or-Sorting-or-Beg-to-adv
|
class Solution:
def targetIndices(self, nums: List[int], target: int) -> List[int]:
res = [] # taking empty list for storing result
nums.sort() # sorting the provided list, as in the question its says after sorting the array.
for i in range(len(nums)): # traversing the array.
if nums[i] == target: # checking if the current element is equal to the provided target.
res.append(i) # appending index of the element to the resulting list.
return res # returning the list containing our result.
|
find-target-indices-after-sorting-array
|
Python Easiest Solution With Explanation | 88.79 % Faster | Sorting | Beg to adv
|
rlakshay14
| 0
| 90
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,843
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/1917559/Python3-Easy-solution-with-98-space-complexity
|
class Solution:
def targetIndices(self, nums: List[int], target: int) -> List[int]:
nums.sort()
li =[]
for i in range(len(nums)):
if nums[i]==target:
li.append(i)
return li
|
find-target-indices-after-sorting-array
|
Python3 Easy solution with 98% space complexity
|
VINOD27
| 0
| 82
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,844
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/1903078/Python-One-liner-easy-solution
|
class Solution:
def targetIndices(self, nums: List[int], target: int) -> List[int]:
return [ i for i,num in enumerate(sorted(nums)) if num==target]
|
find-target-indices-after-sorting-array
|
Python One liner easy solution
|
samuelstephen
| 0
| 46
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,845
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/1862060/Python-(Simple-Approach-and-Beginner-Friendly)
|
class Solution:
def targetIndices(self, nums: List[int], target: int) -> List[int]:
arr = []
nums.sort()
for i,n in enumerate(nums):
if n == target:
arr.append(i)
return arr
|
find-target-indices-after-sorting-array
|
Python (Simple Approach and Beginner-Friendly)
|
vishvavariya
| 0
| 56
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,846
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/1840535/Python-Easiest-Solution-With-Explanation-or-Beg-to-Adv
|
class Solution:
def targetIndices(self, nums: List[int], target: int) -> List[int]:
nums.sort() # as we might get unsorted list, so we have to sort it manually.
res = [] # creating empty list to store the result
for i in range(len(nums)): # checking each element of the giving.
if nums[i] == target: # checking each element if its equal to the target
res.append(i) # if yes append its index in the list we created.
return res # return the list we made, containing index.
|
find-target-indices-after-sorting-array
|
Python Easiest Solution With Explanation | Beg to Adv
|
rlakshay14
| 0
| 65
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,847
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/1837071/Simple-Python-Solution
|
class Solution:
def targetIndices(self, nums: List[int], target: int) -> List[int]:
nums.sort()
return [i for i in range(len(nums)) if nums[i] == target]
|
find-target-indices-after-sorting-array
|
Simple Python Solution
|
himanshu11sgh
| 0
| 33
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,848
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/1812659/1-Line-Python-Solution-oror-60-Faster-oror-Memory-less-than-99
|
class Solution:
def targetIndices(self, nums: List[int], target: int) -> List[int]:
return [idx for idx,val in enumerate(sorted(nums)) if val==target]
|
find-target-indices-after-sorting-array
|
1-Line Python Solution || 60% Faster || Memory less than 99%
|
Taha-C
| 0
| 90
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,849
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/1780290/Ugly-and-slow-one-liner
|
class Solution:
def targetIndices(self, nums: List[int], target: int) -> List[int]:
return [] if target not in nums else [x for x in range(sorted(nums).index(target), sorted(nums).index(target) + sorted(nums).count(target))]
|
find-target-indices-after-sorting-array
|
Ugly and slow one liner
|
rrrares
| 0
| 39
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,850
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/1739131/Python3-simple-solution
|
class Solution:
def targetIndices(self, nums: List[int], target: int) -> List[int]:
ans = []
nums.sort()
for i in range(len(nums)):
if nums[i] == target:
ans.append(i)
return ans
|
find-target-indices-after-sorting-array
|
Python3 simple solution
|
EklavyaJoshi
| 0
| 90
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,851
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/1720968/Python3-accepted-one-liner-solution
|
class Solution:
def targetIndices(self, nums: List[int], target: int) -> List[int]:
return [i for i,x in enumerate(sorted(nums)) if(x==target)]
|
find-target-indices-after-sorting-array
|
Python3 accepted one-liner solution
|
sreeleetcode19
| 0
| 62
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,852
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/1702335/Understandable-code-for-beginners-like-me-in-python-!!
|
class Solution:
def targetIndices(self, nums: List[int], target: int) -> List[int]:
nums.sort()
answer=[]
nums_len=len(nums)
flag=0
for index in range(nums_len):
if(nums[index]==target):
answer.append(index)
flag=1
elif(nums[index]!=target and flag==1):
break
return answer
|
find-target-indices-after-sorting-array
|
Understandable code for beginners like me in python !!
|
kabiland
| 0
| 58
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,853
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/1664277/Python-3-binary-search-(or-bisect-like)-solution-which-beats-86.71
|
class Solution:
def targetIndices(self, nums: List[int], target: int) -> List[int]:
if len(nums) == 0:
return []
nums.sort() # O(nlogn)
start = self._binary_search(nums, target, True # O(logn)
end = self._binary_search(nums, target, False) # O(logn)
return [x for x in range(start, end+1)] if start != None else []
# find the first or last index of target in nums
def _binary_search(self, nums, target, is_start):
end = len(nums) - 1
start = 0
while start <= end:
mid = start + (end - start) // 2
pivot = nums[mid]
if pivot == target:
if is_start:
if mid == start or nums[mid - 1] < target:
return mid
else:
end = mid - 1
else:
if mid == end or nums[mid + 1] > target:
return mid
else:
start = mid + 1
elif pivot < target:
start = mid + 1
else:
end = mid - 1
return None
|
find-target-indices-after-sorting-array
|
Python 3 binary search (or bisect like) solution which beats 86.71%
|
MichaelRays
| 0
| 114
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,854
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/1656545/EASY-SIMPLE-solution
|
class Solution:
def targetIndices(self, nums: List[int], target: int) -> List[int]:
nums.sort()
answer =[]
for i in range(len(nums)):
if nums[i]==target:
answer.append(i)
return answer
|
find-target-indices-after-sorting-array
|
EASY, SIMPLE solution
|
Buyanjargal
| 0
| 68
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,855
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/1646872/Python-O(nlogn)-using-bisect
|
class Solution:
def targetIndices(self, nums: List[int], target: int) -> List[int]:
nums.sort()
l, i = [], bisect.bisect_left(nums, target)
while i < len(nums):
if nums[i] == target:
l.append(i)
elif nums[i] > target:
break
i += 1
return l
|
find-target-indices-after-sorting-array
|
Python O(nlogn) using bisect
|
emwalker
| 0
| 55
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,856
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/1608267/O(n)-time-oror-O(1)-space-oror-Python-solution
|
class Solution:
def targetIndices(self, nums: List[int], target: int) -> List[int]:
#count occurence of the target
#count how many numbers are less than target
count = 0
isless = 0
for i in range(len(nums)):
if nums[i] == target:
count += 1
if nums[i] < target:
isless += 1
if count == 0:
return []
res = [isless]
while count > 1:
isless += 1
res.append(isless)
count -= 1
return res
|
find-target-indices-after-sorting-array
|
O(n) time || O(1) space || Python solution
|
s_m_d_29
| 0
| 126
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,857
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/1601478/Python-single-pass
|
class Solution:
def targetIndices(self, nums: List[int], target: int) -> List[int]:
start = 0
count = 0
for n in nums:
if n < target:
start += 1
elif n == target:
count += 1
return range(start, start + count)
|
find-target-indices-after-sorting-array
|
Python, single pass
|
blue_sky5
| 0
| 91
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,858
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/1599990/Python-3-O(n)-wo-sorting
|
class Solution:
def targetIndices(self, nums: List[int], target: int) -> List[int]:
start_idx, num_target = 0, 0
for num in nums:
if num < target:
start_idx += 1
elif num == target:
num_target += 1
return list(range(start_idx, start_idx+num_target))
# Time O(n)
# Space O(1) (O(n) w/ output)
|
find-target-indices-after-sorting-array
|
[Python 3] O(n) w/o sorting
|
JosephJia
| 0
| 61
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,859
|
https://leetcode.com/problems/find-target-indices-after-sorting-array/discuss/1599813/Python3-Solution
|
class Solution:
def targetIndices(self, nums: List[int], target: int) -> List[int]:
nums.sort()
output = []
for idx in range(len(nums)):
if nums[idx] == target:
output.append(idx)
return output
|
find-target-indices-after-sorting-array
|
Python3 Solution
|
michaelb072
| 0
| 43
|
find target indices after sorting array
| 2,089
| 0.766
|
Easy
| 28,860
|
https://leetcode.com/problems/k-radius-subarray-averages/discuss/1599973/Python-3-or-Sliding-Window-or-Illustration-with-picture
|
class Solution:
def getAverages(self, nums: List[int], k: int) -> List[int]:
res = [-1]*len(nums)
left, curWindowSum, diameter = 0, 0, 2*k+1
for right in range(len(nums)):
curWindowSum += nums[right]
if (right-left+1 >= diameter):
res[left+k] = curWindowSum//diameter
curWindowSum -= nums[left]
left += 1
return res
|
k-radius-subarray-averages
|
Python 3 | Sliding Window | Illustration with picture
|
ndus
| 48
| 1,300
|
k radius subarray averages
| 2,090
| 0.426
|
Medium
| 28,861
|
https://leetcode.com/problems/k-radius-subarray-averages/discuss/1599853/Python3-prefix-sum
|
class Solution:
def getAverages(self, nums: List[int], k: int) -> List[int]:
prefix = [0]
for x in nums: prefix.append(prefix[-1] + x)
ans = [-1]*len(nums)
for i, x in enumerate(nums):
if k <= i < len(nums)-k: ans[i] = (prefix[i+k+1] - prefix[i-k])//(2*k+1)
return ans
|
k-radius-subarray-averages
|
[Python3] prefix sum
|
ye15
| 11
| 411
|
k radius subarray averages
| 2,090
| 0.426
|
Medium
| 28,862
|
https://leetcode.com/problems/k-radius-subarray-averages/discuss/1599853/Python3-prefix-sum
|
class Solution:
def getAverages(self, nums: List[int], k: int) -> List[int]:
ans = [-1]*len(nums)
rsm = 0 # range sum
for i, x in enumerate(nums):
rsm += x
if i >= 2*k+1: rsm -= nums[i-(2*k+1)]
if i+1 >= 2*k+1: ans[i-k] = rsm//(2*k+1)
return ans
|
k-radius-subarray-averages
|
[Python3] prefix sum
|
ye15
| 11
| 411
|
k radius subarray averages
| 2,090
| 0.426
|
Medium
| 28,863
|
https://leetcode.com/problems/k-radius-subarray-averages/discuss/2797823/Python-oror-Easy-oror-Sliding-Window-oror-O(n)-Solution
|
class Solution:
def getAverages(self, nums: List[int], k: int) -> List[int]:
n=len(nums)
t=2*k+1
if n<t:
return [-1]*n
ans=[-1]*k
s=sum(nums[:t])
avg=s//t
ans.append(avg)
l,r=0,t
for i in range(k+1,n):
if i+k>=n:
ans.append(-1)
else:
s+=nums[r]-nums[l]
avg=s//t
ans.append(avg)
l+=1
r+=1
return ans
|
k-radius-subarray-averages
|
Python || Easy || Sliding Window || O(n) Solution
|
DareDevil_007
| 1
| 34
|
k radius subarray averages
| 2,090
| 0.426
|
Medium
| 28,864
|
https://leetcode.com/problems/k-radius-subarray-averages/discuss/1999858/python-3-oror-sliding-window
|
class Solution:
def getAverages(self, nums: List[int], k: int) -> List[int]:
x = 2*k + 1
n = len(nums)
if x > n:
return [-1] * n
s = sum(nums[i] for i in range(x))
res = [-1] * k + [s // x]
for i in range(k + 1, n - k):
s += nums[i + k] - nums[i - k - 1]
res.append(s // x)
res.extend([-1] * k)
return res
|
k-radius-subarray-averages
|
python 3 || sliding window
|
dereky4
| 1
| 67
|
k radius subarray averages
| 2,090
| 0.426
|
Medium
| 28,865
|
https://leetcode.com/problems/k-radius-subarray-averages/discuss/1999667/Simple-Python-3-Solution-with-Sliding-Window-and-Current-sum
|
class Solution:
def getAverages(self, nums: List[int], k: int) -> List[int]:
# The idea is quite simple.
# We will have a sliding window of 2k+1 since we need k to left and k to right numbers.
# We will keep track of the current sum
k = 2*k+1
res = [-1] * len(nums)
l, curr = 0, 0
for r, num in enumerate(nums):
curr += num
# r-l+1 == len of curr window
if r - l + 1 > k:
curr -= nums[l]
l += 1
if r - l + 1 == k:
# update the middle of the current window
ind = (l+r)//2
res[ind] = curr // k
return res
|
k-radius-subarray-averages
|
Simple Python 3 Solution with Sliding Window and Current sum
|
toredev
| 1
| 39
|
k radius subarray averages
| 2,090
| 0.426
|
Medium
| 28,866
|
https://leetcode.com/problems/k-radius-subarray-averages/discuss/1599881/Python3-O(n)-with-comments
|
class Solution:
def getAverages(self, nums: List[int], k: int) -> List[int]:
res = []
n = len(nums)
for i, num in enumerate(nums):
if i-k < 0 or i+k >= n:
res.append(-1)
else: # k<=i<n-k
if i-k == 0:
curSum = sum(nums[:i+k+1])
else:
curSum -= nums[i-k-1] # remove the first element of the previous window
curSum += nums[i+k] # add the new element that is the last element of the current window
res.append(curSum//(2*k+1))
return res
|
k-radius-subarray-averages
|
Python3 O(n) with comments
|
BetterLeetCoder
| 1
| 48
|
k radius subarray averages
| 2,090
| 0.426
|
Medium
| 28,867
|
https://leetcode.com/problems/k-radius-subarray-averages/discuss/2730824/Short-Solution-!!!
|
class Solution:
def getAverages(self, a: List[int], k: int) -> List[int]:
res = [-1]*len(a)
sum_v, diameter = 0, 2*k+1
for i in range(len(a)):
sum_v += a[i]
if i >= diameter-1:
res[i-k] = sum_v//diameter
sum_v -= a[i-diameter+1]
return res
|
k-radius-subarray-averages
|
Short Solution !!!
|
kylewzk
| 0
| 2
|
k radius subarray averages
| 2,090
| 0.426
|
Medium
| 28,868
|
https://leetcode.com/problems/k-radius-subarray-averages/discuss/1838307/Python-Sliding-Window-Solution
|
class Solution:
def getAverages(self, nums: List[int], k: int) -> List[int]:
rolling_sum = 0
if len(nums) < 2 * k + 1:
return [-1] * len(nums)
for i in range(0, 2*k + 1):
rolling_sum += nums[i]
ans = []
ans.append(rolling_sum // (2 * k + 1))
left, right = 0, 2 * k + 1
while right < len(nums):
rolling_sum -= nums[left]
rolling_sum += nums[right]
ans.append(rolling_sum // (2 * k + 1))
left += 1
right += 1
return [-1] * k + ans + [-1] * k
|
k-radius-subarray-averages
|
Python Sliding Window Solution
|
Vayne1994
| 0
| 41
|
k radius subarray averages
| 2,090
| 0.426
|
Medium
| 28,869
|
https://leetcode.com/problems/k-radius-subarray-averages/discuss/1818352/Python-easy-to-read-and-understand
|
class Solution:
def getAverages(self, nums: List[int], k: int) -> List[int]:
n = len(nums)
t = [-1 for _ in range(n)]
sums, i = 0, 0
radius = 2*k+1
for j in range(n):
sums += nums[j]
if j-i+1 == radius:
t[j-k] = sums//radius
sums -= nums[i]
i = i+1
return t
|
k-radius-subarray-averages
|
Python easy to read and understand
|
sanial2001
| 0
| 54
|
k radius subarray averages
| 2,090
| 0.426
|
Medium
| 28,870
|
https://leetcode.com/problems/k-radius-subarray-averages/discuss/1695002/python-simple-O(n)-time-sliding-window-solution
|
class Solution:
def getAverages(self, nums: List[int], k: int) -> List[int]:
n = len(nums)
res = [-1 for _ in range(n)]
if n < 2*k+1:
return res
if k == 0:
return nums
prevsum = sum(nums[:2*k+1])
res[k] = prevsum//(2*k+1)
for i in range(k+1, n-k):
s = prevsum - nums[i-k-1] + nums[i+k]
res[i] = s//(2*k+1)
prevsum = s
return res
|
k-radius-subarray-averages
|
python simple O(n) time sliding window solution
|
byuns9334
| 0
| 62
|
k radius subarray averages
| 2,090
| 0.426
|
Medium
| 28,871
|
https://leetcode.com/problems/k-radius-subarray-averages/discuss/1623279/python3-sliding-window-solution
|
class Solution:
def getAverages(self, nums: List[int], k: int) -> List[int]:
if k==0:
return nums
n=len(nums)
if n<=2*k:
return [-1]*(n)
res=[-1]*(n)
s=sum(nums[:2*k+1])
t=2*k+1
res[k]=s//t
for i in range(k+1,n-k):
s=s-nums[i-k-1]+nums[i+k]
res[i]=s//t
for j in range(len(res),len(nums)):
res.append(-1)
return res
|
k-radius-subarray-averages
|
python3 sliding window solution
|
Karna61814
| 0
| 35
|
k radius subarray averages
| 2,090
| 0.426
|
Medium
| 28,872
|
https://leetcode.com/problems/k-radius-subarray-averages/discuss/1607687/One-pass-with-moving-window-99-speed
|
class Solution:
def getAverages(self, nums: List[int], k: int) -> List[int]:
if not k:
return nums
len_nums = len(nums)
ans = [-1] * len_nums
len_window = 2 * k + 1
sum_window = sum(nums[: len_window - 1])
for i in range(k, len_nums - k):
sum_window += nums[i + k]
ans[i] = sum_window // len_window
sum_window -= nums[i - k]
return ans
|
k-radius-subarray-averages
|
One pass with moving window, 99% speed
|
EvgenySH
| 0
| 60
|
k radius subarray averages
| 2,090
| 0.426
|
Medium
| 28,873
|
https://leetcode.com/problems/k-radius-subarray-averages/discuss/1602031/Python3Java-Sliding-Window-Succinct
|
class Solution:
def getAverages(self, nums: List[int], k: int) -> List[int]:
# Accumulate all elements except the last one in the window
acc = sum(nums[0 : 2 * k])
i, result = k, [-1] * len(nums)
for i in range(k, len(nums) - k):
acc += nums[i + k]
result[i] = acc // (2 * k + 1)
acc -= nums[i - k]
return result
|
k-radius-subarray-averages
|
[Python3][Java] - Sliding Window - Succinct
|
mardlucca
| 0
| 29
|
k radius subarray averages
| 2,090
| 0.426
|
Medium
| 28,874
|
https://leetcode.com/problems/k-radius-subarray-averages/discuss/1600433/Sliding-Window-%2B-Prefix-Sum-Simple-approach-O(n)-space-and-time
|
class Solution:
def getAverages(self, nums: List[int], k: int) -> List[int]:
if k == 0: return nums
n = len(nums)
ans = [-1]*n
prefSum = [0]*n
for i in range(0, n):
if i == 0:
prefSum[0] = nums[i]
else:
prefSum[i] = prefSum[i-1] + nums[i]
#print(prefSum)
for i in range(k, n - k):
if i - k - 1 < 0:
ans[i] = (prefSum[i + k])//(2*k + 1)
else:
ans[i] = (prefSum[i + k] - prefSum[i - k - 1])//(2*k + 1)
return ans
|
k-radius-subarray-averages
|
Sliding Window + Prefix Sum - Simple approach- O(n) space and time
|
abuOmar2
| 0
| 14
|
k radius subarray averages
| 2,090
| 0.426
|
Medium
| 28,875
|
https://leetcode.com/problems/k-radius-subarray-averages/discuss/1600102/Sliding-Window-oror-For-Beginners-oror-Well-Coded
|
class Solution:
def getAverages(self, nums: List[int], k: int) -> List[int]:
n = len(nums)
if k*2+1>n:
return [-1]*n
total_len = 2*k+1
s = sum(nums[:2*k])
res = [-1]*n
for i in range(k,n-k):
s+=nums[i+k]
avg = s//total_len
res[i] = avg
s-=nums[i-k]
return res
|
k-radius-subarray-averages
|
📌📌 Sliding Window || For Beginners || Well-Coded 🐍
|
abhi9Rai
| 0
| 37
|
k radius subarray averages
| 2,090
| 0.426
|
Medium
| 28,876
|
https://leetcode.com/problems/k-radius-subarray-averages/discuss/1600016/Python3-Sliding-Window-Time-O(n)
|
class Solution:
def getAverages(self, nums: List[int], k: int) -> List[int]:
if k == 0:
return nums
avgs, wid_len, n = [], 2*k+1, len(nums)
for i in range(n):
if i-k < 0 or i+k>n-1:
avgs.append(-1)
else:
if i-k == 0:
running_sum = sum(nums[i-k:i+k+1])
else:
running_sum = running_sum + nums[i+k] - nums[i-k-1]
avgs.append(running_sum//wid_len)
return avgs
|
k-radius-subarray-averages
|
[Python3] Sliding-Window Time O(n)
|
JosephJia
| 0
| 25
|
k radius subarray averages
| 2,090
| 0.426
|
Medium
| 28,877
|
https://leetcode.com/problems/k-radius-subarray-averages/discuss/1599847/Python3-sliding-window
|
class Solution:
def getAverages(self, nums: List[int], k: int) -> List[int]:
output = [-1] * len(nums)
running = 0
for idx, i in enumerate(nums):
running += i
if idx >= k*2:
output[idx - k] = running // (k*2+1)
running -= nums[idx - k*2]
return output
|
k-radius-subarray-averages
|
Python3 sliding window
|
michaelb072
| 0
| 20
|
k radius subarray averages
| 2,090
| 0.426
|
Medium
| 28,878
|
https://leetcode.com/problems/removing-minimum-and-maximum-from-array/discuss/1599862/Python3-3-candidates
|
class Solution:
def minimumDeletions(self, nums: List[int]) -> int:
imin = nums.index(min(nums))
imax = nums.index(max(nums))
return min(max(imin, imax)+1, len(nums)-min(imin, imax), len(nums)+1+min(imin, imax)-max(imin, imax))
|
removing-minimum-and-maximum-from-array
|
[Python3] 3 candidates
|
ye15
| 5
| 226
|
removing minimum and maximum from array
| 2,091
| 0.566
|
Medium
| 28,879
|
https://leetcode.com/problems/removing-minimum-and-maximum-from-array/discuss/2201682/Basic-Python-Solution
|
class Solution:
def minimumDeletions(self, nums: List[int]) -> int:
n = len(nums)
x = nums.index(min(nums)) + 1
y = nums.index(max(nums)) + 1
res = min(max(n-x+1, n-y+1) , max(x,y)) #minimum of going from right and going from left
if x > y: #exchange if needed so as to do one operation later assuming x is the smaller index
x, y = y, x
option = x + (n - y) + 1 #going left for smaller and right for larger
res = min(res, option)
return res if n > 2 else n
|
removing-minimum-and-maximum-from-array
|
Basic Python Solution
|
nahomn7
| 3
| 96
|
removing minimum and maximum from array
| 2,091
| 0.566
|
Medium
| 28,880
|
https://leetcode.com/problems/removing-minimum-and-maximum-from-array/discuss/1609043/Python-3-O(n)-solution
|
class Solution:
def minimumDeletions(self, nums: List[int]) -> int:
min_i = max_i = None
min_num, max_num = math.inf, -math.inf
for i, num in enumerate(nums):
if num < min_num:
min_i, min_num = i, num
if num > max_num:
max_i, max_num = i, num
if min_i > max_i:
min_i, max_i = max_i, min_i
n = len(nums)
return min(min_i + 1 + n - max_i, # delete from left and right
max_i + 1, # delete from left only
n - min_i) # delete from right only
|
removing-minimum-and-maximum-from-array
|
Python 3 O(n) solution
|
dereky4
| 2
| 144
|
removing minimum and maximum from array
| 2,091
| 0.566
|
Medium
| 28,881
|
https://leetcode.com/problems/removing-minimum-and-maximum-from-array/discuss/1625106/Python-3-5-lines-oror90-faster-oror-3-diff-methods
|
class Solution:
def minimumDeletions(self, nums: List[int]) -> int:
front_idx_maxi = nums.index(max(nums))
front_idx_mini = nums.index(min(nums))
n = len(nums)
li = sorted([front_idx_maxi,front_idx_mini])
return min(li[1]+1,n-li[0],(li[0]+1)+(n-li[1]))
|
removing-minimum-and-maximum-from-array
|
Python 3 - 5 lines ||90% faster || 3 diff methods
|
ana_2kacer
| 1
| 141
|
removing minimum and maximum from array
| 2,091
| 0.566
|
Medium
| 28,882
|
https://leetcode.com/problems/removing-minimum-and-maximum-from-array/discuss/2848778/Easy-solution-on-Python3
|
class Solution:
def minimumDeletions(self, nums: List[int]) -> int:
minVal = min(nums)
maxVal = max(nums)
minIndex = nums.index(minVal)
maxIndex = nums.index(maxVal)
r1 = max(minIndex, maxIndex) + 1
r2 = len(nums) - min(minIndex, maxIndex)
r3 = min(minIndex, maxIndex) + 1 + len(nums) - max(minIndex, maxIndex)
return min(r1,r2,r3)
|
removing-minimum-and-maximum-from-array
|
Easy solution on Python3
|
DNST
| 0
| 2
|
removing minimum and maximum from array
| 2,091
| 0.566
|
Medium
| 28,883
|
https://leetcode.com/problems/removing-minimum-and-maximum-from-array/discuss/2839496/Python3-easy-to-understand
|
class Solution:
def minimumDeletions(self, nums: List[int]) -> int:
l = nums.index(min(nums))
h = nums.index(max(nums))
N = len(nums)
if len(nums) == 1: return 1
if len(nums) == 2: return 2
return min(max(l + 1, h + 1), max(N - l, N - h), min(l + 1, len(nums) - l) + min(h + 1, len(nums) - h))
|
removing-minimum-and-maximum-from-array
|
Python3 - easy to understand
|
mediocre-coder
| 0
| 2
|
removing minimum and maximum from array
| 2,091
| 0.566
|
Medium
| 28,884
|
https://leetcode.com/problems/removing-minimum-and-maximum-from-array/discuss/2817731/python-super-easy-to-understand-O(n)
|
class Solution:
def minimumDeletions(self, nums: List[int]) -> int:
min_val = float("inf")
max_val = float("-inf")
min_index = None
max_index = None
for i in range(len(nums)):
if nums[i] < min_val:
min_val = nums[i]
min_index = i
if nums[i] > max_val:
max_val = nums[i]
max_index = i
return min(len(nums) - abs(max_index - min_index) + 1, max(min_index, max_index) + 1, len(nums) - min(min_index, max_index))
|
removing-minimum-and-maximum-from-array
|
python super easy to understand O(n)
|
harrychen1995
| 0
| 1
|
removing minimum and maximum from array
| 2,091
| 0.566
|
Medium
| 28,885
|
https://leetcode.com/problems/removing-minimum-and-maximum-from-array/discuss/2812587/Python-clean-and-easy-code
|
class Solution:
def minimumDeletions(self, nums: List[int]) -> int:
max_v, min_v, max_i, min_i = -float('inf'), float('inf'), 0, 0
for i in range(len(nums)):
if nums[i] > max_v:
max_v, max_i = nums[i], i
if nums[i] < min_v:
min_v, min_i = nums[i], i
x, y = (max_i, min_i) if max_i < min_i else (min_i, max_i)
# delete from first ele to the last target ele, or vice versa,
# or from frist ele to the first target ele and back from last to the second target ele.
# the min of above is the answer
min_dnum = min(y+1, len(nums)-x, x+1 + len(nums)-y )
return min_dnum
|
removing-minimum-and-maximum-from-array
|
Python clean and easy code
|
jsyx1994
| 0
| 1
|
removing minimum and maximum from array
| 2,091
| 0.566
|
Medium
| 28,886
|
https://leetcode.com/problems/removing-minimum-and-maximum-from-array/discuss/2730851/Python3-Short-Solution-!!!
|
class Solution:
def minimumDeletions(self, A: List[int]) -> int:
i, j, n = A.index(min(A)), A.index(max(A)), len(A)
return min(max(i+1, j+1), max(n-i, n-j), i+1+n-j, j+1+n-i)
|
removing-minimum-and-maximum-from-array
|
[Python3] Short Solution !!!
|
kylewzk
| 0
| 5
|
removing minimum and maximum from array
| 2,091
| 0.566
|
Medium
| 28,887
|
https://leetcode.com/problems/removing-minimum-and-maximum-from-array/discuss/2669739/begginers-friendly-code...python
|
class Solution:
def minimumDeletions(self, nums: List[int]) -> int:
mini=nums.index(min(nums))#taking out the index of minimum element.
maxi=nums.index(max(nums))#taking out the element of maximum element.
a1=max(mini,maxi)+1 # calculate the no of steps removing from the left.
a2=max(len(nums)-mini,len(nums)-maxi)#calculate the no of steps removing from right.
a3=min(mini,maxi)+1+len(nums)-max(mini,maxi)#calculate the no of steps removing from both left and right
return min(a1,a2,a3)# at last find the minimum of all 3
|
removing-minimum-and-maximum-from-array
|
begginers friendly code...#python
|
insane_me12
| 0
| 3
|
removing minimum and maximum from array
| 2,091
| 0.566
|
Medium
| 28,888
|
https://leetcode.com/problems/removing-minimum-and-maximum-from-array/discuss/2441444/Python-two-pointers
|
class Solution:
def minimumDeletions(self, nums: List[int]) -> int:
if len(nums) == 1:
return 1
left, right = 0, 0
l, r = 0, len(nums) - 1
maximum = max(nums)
minimum = min(nums)
bothFind = 0
twoSide = 0
while l <= (len(nums)-1) and r >= 0:
if nums[l] == maximum or nums[l] == minimum:
left = l + 1
bothFind += 1
if bothFind <= 2:
twoSide += left
if nums[r] == maximum or nums[r] == minimum:
right = len(nums) - r
bothFind += 1
if bothFind <= 2:
twoSide += right
l += 1
r -= 1
return min(left, right, twoSide)
|
removing-minimum-and-maximum-from-array
|
Python two-pointers
|
scr112
| 0
| 33
|
removing minimum and maximum from array
| 2,091
| 0.566
|
Medium
| 28,889
|
https://leetcode.com/problems/removing-minimum-and-maximum-from-array/discuss/2339001/Python3-or-Spelled-out-for-readability
|
class Solution:
def minimumDeletions(self, nums: List[int]) -> int:
N = len(nums)
min_pos = nums.index(min(nums))
max_pos = nums.index(max(nums))
del_mn_from_left = min_pos + 1
del_mx_from_left = max_pos + 1
del_mn_from_right = N - min_pos
del_mx_from_right = N - max_pos
# Possible ways to deletet 'min & max'
ll = max(del_mn_from_left, del_mx_from_left)
rr = max(del_mn_from_right, del_mx_from_right)
lr = del_mn_from_left + del_mx_from_right
rl = del_mx_from_left + del_mn_from_right
return min(ll, rr, lr, rl)
|
removing-minimum-and-maximum-from-array
|
Python3 | Spelled out for readability
|
Ploypaphat
| 0
| 53
|
removing minimum and maximum from array
| 2,091
| 0.566
|
Medium
| 28,890
|
https://leetcode.com/problems/removing-minimum-and-maximum-from-array/discuss/2207610/Python-O(N)O(1)
|
class Solution:
def minimumDeletions(self, nums: List[int]) -> int:
min_idx = max_idx = 0
min_value = max_value = nums[0]
for i, n in enumerate(nums):
if n < min_value:
min_idx = i
min_value = n
if n > max_value:
max_idx = i
max_value = n
if min_idx > max_idx:
min_idx, max_idx = max_idx, min_idx
return min(min_idx + len(nums) - max_idx + 1, max_idx + 1, len(nums) - min_idx)
|
removing-minimum-and-maximum-from-array
|
Python, O(N)/O(1)
|
blue_sky5
| 0
| 21
|
removing minimum and maximum from array
| 2,091
| 0.566
|
Medium
| 28,891
|
https://leetcode.com/problems/removing-minimum-and-maximum-from-array/discuss/2199390/Simple-Logical-Solution-oror-Covering-all-3-possibilities
|
class Solution:
def minimumDeletions(self, nums: List[int]) -> int:
n = len(nums)
if n == 1:
return 1
maxIdx = nums.index(max(nums))
minIdx = nums.index(min(nums))
if maxIdx > minIdx:
a = maxIdx + 1
else:
a = minIdx + 1
revMaxIdx = n - 1 - maxIdx
revMinIdx = n - 1 - minIdx
if revMaxIdx > revMinIdx:
b = revMaxIdx + 1
else:
b = revMinIdx + 1
maxIdxFront = maxIdx
minIdxBack = revMinIdx
maxIdxBack = revMaxIdx
minIdxFront = minIdx
c = maxIdxFront + minIdxBack + 2
d = maxIdxBack + minIdxFront + 2
e = min(c, d)
return min(a, min(b, e))
|
removing-minimum-and-maximum-from-array
|
Simple Logical Solution || Covering all 3 possibilities
|
Vaibhav7860
| 0
| 16
|
removing minimum and maximum from array
| 2,091
| 0.566
|
Medium
| 28,892
|
https://leetcode.com/problems/removing-minimum-and-maximum-from-array/discuss/2164194/Simple-Logic-(Python)
|
class Solution:
def minimumDeletions(self, nums: List[int]) -> int:
i, j , n = nums.index(min(nums)), nums.index(max(nums)),len(nums)
return min(max(i+1,j+1), max(n-i,n-j), j+1+n-i, i+1+n-j)
|
removing-minimum-and-maximum-from-array
|
Simple Logic (Python)
|
writemeom
| 0
| 50
|
removing minimum and maximum from array
| 2,091
| 0.566
|
Medium
| 28,893
|
https://leetcode.com/problems/removing-minimum-and-maximum-from-array/discuss/2035134/Python-easy-to-read-and-understand
|
class Solution:
def minimumDeletions(self, nums: List[int]) -> int:
x, y = nums.index(max(nums)), nums.index(min(nums))
n = len(nums)
return min(x+1 + n-y, #if max on left and min on right
y+1 + n-x, #if min on left and max on right
max(x, y)+1, #deleting from left only
n-min(x, y)) #deleting from right only
|
removing-minimum-and-maximum-from-array
|
Python easy to read and understand
|
sanial2001
| 0
| 68
|
removing minimum and maximum from array
| 2,091
| 0.566
|
Medium
| 28,894
|
https://leetcode.com/problems/removing-minimum-and-maximum-from-array/discuss/1838328/Python-Math-Solution
|
class Solution:
def minimumDeletions(self, nums: List[int]) -> int:
s1 = sorted(nums)
L = len(nums)
max_index, min_index = 0, 0
min_num, max_num = s1[0], s1[-1]
for index in range(len(nums)):
if nums[index] == min_num:
min_index = index
elif nums[index] == max_num:
max_index = index
else:
continue
return min(max(max_index + 1, min_index + 1), max(L- max_index, L- min_index), min(min_index + 1, max_index + 1) + L - max(min_index, max_index))
|
removing-minimum-and-maximum-from-array
|
Python Math Solution
|
Vayne1994
| 0
| 23
|
removing minimum and maximum from array
| 2,091
| 0.566
|
Medium
| 28,895
|
https://leetcode.com/problems/removing-minimum-and-maximum-from-array/discuss/1798659/Python3-oror-O(n)-time-oror-O(1)-space
|
class Solution:
def minimumDeletions(self, nums: List[int]) -> int:
#we have three possibilities for each number:
#we can del only from left, only from right, both
min_idx, max_idx = 0, 0
min_val, max_val = nums[0], nums[0]
for idx in range(1,len(nums)):
if nums[idx] < min_val:
min_idx = idx
min_val = nums[idx]
if nums[idx] > max_val:
max_idx = idx
max_val = nums[idx]
size = len(nums)
idx1, idx2 = min(min_idx,max_idx), max(min_idx,max_idx)
left = idx2 + 1
right = size - idx1
both = idx1 + 1 + (size - idx2)
return min(left,right,both)
|
removing-minimum-and-maximum-from-array
|
Python3 || O(n) time || O(1) space
|
s_m_d_29
| 0
| 47
|
removing minimum and maximum from array
| 2,091
| 0.566
|
Medium
| 28,896
|
https://leetcode.com/problems/removing-minimum-and-maximum-from-array/discuss/1600056/Simple-and-Straight-oror-Well-Explained-and-Clean-Coded
|
class Solution:
def minimumDeletions(self, nums: List[int]) -> int:
mi,ma = min(nums),max(nums)
n = len(nums)
miind, maind = nums.index(mi), nums.index(ma) # index of minimum element and index of maximum element
mirind,marind = n-miind-1, n-maind-1 # index of minimum element and index of maximum element from backside
return min(max(miind,maind)+1,max(mirind,marind)+1,miind+marind+2,maind+mirind+2)
|
removing-minimum-and-maximum-from-array
|
📌📌 Simple and Straight || Well-Explained and Clean Coded 🐍
|
abhi9Rai
| 0
| 44
|
removing minimum and maximum from array
| 2,091
| 0.566
|
Medium
| 28,897
|
https://leetcode.com/problems/removing-minimum-and-maximum-from-array/discuss/1600025/Python3-O(n)-Time-Without-build-in-functions
|
class Solution:
def minimumDeletions(self, nums: List[int]) -> int:
n = len(nums)
min_element, min_idx, max_element, max_idx = math.inf, -1, -math.inf, -1
for idx, num in enumerate(nums):
if num < min_element:
min_element, min_idx = num, idx
if num > max_element:
max_element, max_idx = num, idx
return min(max(min_idx+1, max_idx+1),
max(n-min_idx, n-max_idx),
min_idx + 1 + n-max_idx,
max_idx + 1 + n-min_idx)
# Time O(n)
# Space O(1)
|
removing-minimum-and-maximum-from-array
|
[Python3] O(n) Time Without build-in functions
|
JosephJia
| 0
| 34
|
removing minimum and maximum from array
| 2,091
| 0.566
|
Medium
| 28,898
|
https://leetcode.com/problems/removing-minimum-and-maximum-from-array/discuss/1599898/Python-check-possibilities-of-minimum-or-easy
|
class Solution:
def minimumDeletions(self, nums: List[int]) -> int:
min_arr = max_arr = nums[0]
min_i = max_i = 0
n = len(nums)
# finding max and min indices
for i in range(1, n):
if nums[i] > max_arr:
max_arr = nums[i]
max_i = i
if nums[i] < min_arr:
min_arr = nums[i]
min_i = i
# checking possibilities
if min_i <= max_i:
return min(min_i+1+n-max_i, max_i+1, n-min_i)
else:
return min(max_i+1+n-min_i, min_i+1, n-max_i)
|
removing-minimum-and-maximum-from-array
|
Python check possibilities of minimum | easy
|
abkc1221
| 0
| 36
|
removing minimum and maximum from array
| 2,091
| 0.566
|
Medium
| 28,899
|
Subsets and Splits
Top 2 Solutions by Upvotes
Identifies the top 2 highest upvoted Python solutions for each problem, providing insight into popular approaches.