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/make-array-zero-by-subtracting-equal-amounts/discuss/2790265/Python-3-Solution
|
class Solution:
def minimumOperations(self, nums: List[int]) -> int:
if 0 in nums: return len(set(nums)) - 1
return len(set(nums))
|
make-array-zero-by-subtracting-equal-amounts
|
Python 3 Solution
|
mati44
| 0
| 4
|
make array zero by subtracting equal amounts
| 2,357
| 0.727
|
Easy
| 32,300
|
https://leetcode.com/problems/make-array-zero-by-subtracting-equal-amounts/discuss/2789370/One-line-python-solution
|
class Solution(object):
def minimumOperations(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
return len({i for i in nums if i != 0})
|
make-array-zero-by-subtracting-equal-amounts
|
One-line python solution
|
csgogogo9527
| 0
| 3
|
make array zero by subtracting equal amounts
| 2,357
| 0.727
|
Easy
| 32,301
|
https://leetcode.com/problems/make-array-zero-by-subtracting-equal-amounts/discuss/2786349/Python-easy-solution-for-beginners-using-set
|
class Solution:
def minimumOperations(self, nums: List[int]) -> int:
s = set()
for num in nums:
if num > 0:
s.add(num)
return len(s)
|
make-array-zero-by-subtracting-equal-amounts
|
Python easy solution for beginners using set
|
AeRajya
| 0
| 7
|
make array zero by subtracting equal amounts
| 2,357
| 0.727
|
Easy
| 32,302
|
https://leetcode.com/problems/make-array-zero-by-subtracting-equal-amounts/discuss/2784438/Best-Easy-Approach-oror-96.1-Acceptance-oror-TC-O(N)
|
class Solution:
def minimumOperations(self, nums: List[int]) -> int:
a=set(nums)
a=list(a)
if 0 in a:
a.remove(0)
return (len(a))
return len(a)
|
make-array-zero-by-subtracting-equal-amounts
|
Best Easy Approach || 96.1% Acceptance || TC O(N)
|
Kaustubhmishra
| 0
| 9
|
make array zero by subtracting equal amounts
| 2,357
| 0.727
|
Easy
| 32,303
|
https://leetcode.com/problems/make-array-zero-by-subtracting-equal-amounts/discuss/2706377/The-answer-is-same-as-number-of-distinct-values-which-greater-0.
|
class Solution:
def minimumOperations(self, nums: List[int]) -> int:
"""
The answer is same as number of distinct values which > 0,
because same numbers will be subtracted at the same time.
TC: O(n)
SC: O(n)
"""
distinct_values_greater_than_0 = set(nums) - {0}
return len(distinct_values_greater_than_0)
"""
Testcases:
1.
import random
# Generate 50 random numbers between 0 and 100
random_list = random.sample(range(0, 101), 50)
2.
random_list1 + random_list2
"""
|
make-array-zero-by-subtracting-equal-amounts
|
The answer is same as number of distinct values which > 0.
|
woora3
| 0
| 8
|
make array zero by subtracting equal amounts
| 2,357
| 0.727
|
Easy
| 32,304
|
https://leetcode.com/problems/make-array-zero-by-subtracting-equal-amounts/discuss/2659739/Done-using-pure-coding
|
class Solution:
def minimumOperations(self, nums: List[int]) -> int:
counter=0
while max(nums)!=0:
arr=[]
m=max(nums)
print(m)
for i in range(len(nums)-1):
for j in range(1,len(nums)):
if nums[j]>=nums[i] and nums[i]<m and nums[i]>0:
m=nums[i]
elif nums[i]>=nums[j] and nums[j]<m and nums[j]>0:
m=nums[j]
print(m)
for i in nums:
if i-m<=0:
arr.append(0)
else:
arr.append(i-m)
print(arr)
nums=arr
counter+=1
return counter
|
make-array-zero-by-subtracting-equal-amounts
|
Done using pure coding
|
prashantdahiya711
| 0
| 22
|
make array zero by subtracting equal amounts
| 2,357
| 0.727
|
Easy
| 32,305
|
https://leetcode.com/problems/make-array-zero-by-subtracting-equal-amounts/discuss/2652227/Python3-Beats-98
|
class Solution:
def minimumOperations(self, nums: List[int]) -> int:
nums.sort()
t = 0
while True:
while nums and nums[0]==0:
del nums[0]
if len(nums)==0:
return t
t+=1
v = nums[0]
nums = [i-v for i in nums]
|
make-array-zero-by-subtracting-equal-amounts
|
Python3 Beats 98%
|
godshiva
| 0
| 13
|
make array zero by subtracting equal amounts
| 2,357
| 0.727
|
Easy
| 32,306
|
https://leetcode.com/problems/make-array-zero-by-subtracting-equal-amounts/discuss/2651201/Python-Solution-oror-98.99-faster-oror-simple-to-understand
|
class Solution:
def minimumOperations(self, nums: List[int]) -> int:
val = list(filter(lambda x: (x >0), nums))
val = set(val)
return len(val)
|
make-array-zero-by-subtracting-equal-amounts
|
Python Solution || 98.99 faster || simple to understand
|
kartik_5051
| 0
| 8
|
make array zero by subtracting equal amounts
| 2,357
| 0.727
|
Easy
| 32,307
|
https://leetcode.com/problems/make-array-zero-by-subtracting-equal-amounts/discuss/2559765/94.84-faster-python-solution-no-for-loops-used-set!
|
class Solution:
def minimumOperations(self, nums: List[int]) -> int:
set_nums = set(nums)
if len(nums) == 1 and 0 in set_nums:
return 0
elif 0 in set_nums:
set_nums.remove(0)
return len(set_nums)
else:
return len(set_nums)
|
make-array-zero-by-subtracting-equal-amounts
|
94.84% faster python solution, no for loops, used set!
|
samanehghafouri
| 0
| 18
|
make array zero by subtracting equal amounts
| 2,357
| 0.727
|
Easy
| 32,308
|
https://leetcode.com/problems/make-array-zero-by-subtracting-equal-amounts/discuss/2522312/Simple-python-solution
|
class Solution:
def minimumOperations(self, nums: List[int]) -> int:
while 0 in nums:
nums.remove(0)
return len(list(set(nums)))
|
make-array-zero-by-subtracting-equal-amounts
|
Simple python solution
|
aruj900
| 0
| 72
|
make array zero by subtracting equal amounts
| 2,357
| 0.727
|
Easy
| 32,309
|
https://leetcode.com/problems/make-array-zero-by-subtracting-equal-amounts/discuss/2503816/Python-Simple-Python-Solution-or-2-Ways
|
class Solution:
def minimumOperations(self, nums: List[int]) -> int:
return len(set(nums) - {0})
|
make-array-zero-by-subtracting-equal-amounts
|
[ Python ] ✔✔ Simple Python Solution | 2 Ways 🔥✌
|
divyamohan123
| 0
| 54
|
make array zero by subtracting equal amounts
| 2,357
| 0.727
|
Easy
| 32,310
|
https://leetcode.com/problems/make-array-zero-by-subtracting-equal-amounts/discuss/2489762/Two-Liner-Python-Solution-O(n)
|
class Solution:
def minimumOperations(self, nums: List[int]) -> int:
nums = set(nums)
return len(nums) if 0 not in nums else len(nums)-1
|
make-array-zero-by-subtracting-equal-amounts
|
Two Liner Python Solution O(n)
|
_jorjis
| 0
| 39
|
make array zero by subtracting equal amounts
| 2,357
| 0.727
|
Easy
| 32,311
|
https://leetcode.com/problems/make-array-zero-by-subtracting-equal-amounts/discuss/2394416/Python-3-solution
|
class Solution:
def minimumOperations(self, nums: List[int]) -> int:
nums = list(set(nums))
if (nums[0] == 0):
return len(nums) - 1
return len(nums)
|
make-array-zero-by-subtracting-equal-amounts
|
Python 3 solution
|
srikomm
| 0
| 57
|
make array zero by subtracting equal amounts
| 2,357
| 0.727
|
Easy
| 32,312
|
https://leetcode.com/problems/make-array-zero-by-subtracting-equal-amounts/discuss/2393429/Easy-and-Clear-Python3-Solution
|
class Solution:
def minimumOperations(self, nums: List[int]) -> int:
nums = [value for value in nums if value != 0]
s = set(nums)
return len(s)
|
make-array-zero-by-subtracting-equal-amounts
|
Easy & Clear Python3 Solution
|
moazmar
| 0
| 29
|
make array zero by subtracting equal amounts
| 2,357
| 0.727
|
Easy
| 32,313
|
https://leetcode.com/problems/make-array-zero-by-subtracting-equal-amounts/discuss/2367218/Easy-python-priority-queue-%2B-number-of-different-positives
|
class Solution:
def minimumOperations(self, nums: List[int]) -> int:
heapify(nums)
count=0
max_=max(nums)
last=0 #sum of last subtracted elements
while nums:
x1=heappop(nums)-last #sum of last elements will be subtracted each time
while (x1==0) and nums: #iterate till we have a positive integer
x1=heappop(nums)-last
if x1>0:
max_-=x1
last+=x1
count+=1 #number of rounds taken
if max_<=0:
return count
return count
|
make-array-zero-by-subtracting-equal-amounts
|
Easy python priority queue + number of different positives
|
sunakshi132
| 0
| 29
|
make array zero by subtracting equal amounts
| 2,357
| 0.727
|
Easy
| 32,314
|
https://leetcode.com/problems/make-array-zero-by-subtracting-equal-amounts/discuss/2367218/Easy-python-priority-queue-%2B-number-of-different-positives
|
class Solution:
def minimumOperations(self, nums: List[int]) -> int:
return len(set(nums) - {0})
|
make-array-zero-by-subtracting-equal-amounts
|
Easy python priority queue + number of different positives
|
sunakshi132
| 0
| 29
|
make array zero by subtracting equal amounts
| 2,357
| 0.727
|
Easy
| 32,315
|
https://leetcode.com/problems/make-array-zero-by-subtracting-equal-amounts/discuss/2361892/Python-Javascript-without-set
|
class Solution:
def minimumOperations(self, nums: List[int]) -> int:
min = float('inf')
for num in nums:
if num > 0 and num < min: min = num
if min == float('inf'): return 0
counter = 0
while True:
counter += 1
newMin = float('inf')
for i in range(len(nums)):
if nums[i] > 0:
nums[i] -= min
if nums[i] > 0 and nums[i] < newMin:
newMin = nums[i]
if newMin == float('inf'): break
min = newMin
return counter
|
make-array-zero-by-subtracting-equal-amounts
|
Python / Javascript without set
|
ChaseDho
| 0
| 36
|
make array zero by subtracting equal amounts
| 2,357
| 0.727
|
Easy
| 32,316
|
https://leetcode.com/problems/make-array-zero-by-subtracting-equal-amounts/discuss/2359682/Python-Easy-Solution
|
class Solution:
def minimumOperations(self, nums: List[int]) -> int:
nums.sort()
count = 0
i = 0
while (max(nums) > 0):
if nums[i] <= 0:
i += 1
if nums[i] != 0:
count += 1
nums = [a - nums[i] for a in nums]
return count
|
make-array-zero-by-subtracting-equal-amounts
|
Python Easy Solution
|
YangJenHao
| 0
| 13
|
make array zero by subtracting equal amounts
| 2,357
| 0.727
|
Easy
| 32,317
|
https://leetcode.com/problems/make-array-zero-by-subtracting-equal-amounts/discuss/2359232/Python-simple-solution
|
class Solution:
def minimumOperations(self, nums: List[int]) -> int:
return len({x for x in nums if x})
|
make-array-zero-by-subtracting-equal-amounts
|
Python simple solution
|
StikS32
| 0
| 22
|
make array zero by subtracting equal amounts
| 2,357
| 0.727
|
Easy
| 32,318
|
https://leetcode.com/problems/make-array-zero-by-subtracting-equal-amounts/discuss/2358396/Python-Clean-Code-Solution%3A-Make-Array-Zero-by-Subracting-Equal-Amounts
|
class Solution:
def minimumOperations(self, nums: List[int]) -> int:
minOperations = 0
tempList = nums[:]
while not isAllElementsZero(tempList):
minElement = getMinNonZeroElement(tempList)
minOperations += 1
for j in range(len(tempList)):
if tempList[j] != 0:
tempList[j] -= minElement
else: continue
return minOperations
def isAllElementsZero(nums):
for element in nums:
if element != 0 :
return False
return True
def getMinNonZeroElement(nums):
minElem = float('inf')
for element in nums:
if element != 0 and element < minElem:
minElem = element
else:
continue
return minElem
|
make-array-zero-by-subtracting-equal-amounts
|
Python Clean Code Solution: Make Array Zero by Subracting Equal Amounts
|
Nab110
| 0
| 10
|
make array zero by subtracting equal amounts
| 2,357
| 0.727
|
Easy
| 32,319
|
https://leetcode.com/problems/make-array-zero-by-subtracting-equal-amounts/discuss/2358188/Python-or-1-Liner-or-Set-Cardinality
|
class Solution:
def minimumOperations(self, nums: List[int]) -> int:
return len(set(nums) - {0})
|
make-array-zero-by-subtracting-equal-amounts
|
Python | 1 Liner | Set Cardinality
|
leeteatsleep
| 0
| 7
|
make array zero by subtracting equal amounts
| 2,357
| 0.727
|
Easy
| 32,320
|
https://leetcode.com/problems/make-array-zero-by-subtracting-equal-amounts/discuss/2358135/Python-Very-simple-solution-with-set
|
class Solution:
def minimumOperations(self, nums: List[int]) -> int:
## RC ##
un = set()
for num in nums:
if num:
un.add(num)
return len(un)
|
make-array-zero-by-subtracting-equal-amounts
|
[Python] Very simple solution with set
|
101leetcode
| 0
| 15
|
make array zero by subtracting equal amounts
| 2,357
| 0.727
|
Easy
| 32,321
|
https://leetcode.com/problems/make-array-zero-by-subtracting-equal-amounts/discuss/2358012/Python-Count-Unique-Number
|
class Solution:
def minimumOperations(self, nums: List[int]) -> int:
return len(set(nums)) - (0 in nums)
|
make-array-zero-by-subtracting-equal-amounts
|
[Python] Count Unique Number
|
sodinfeliz
| 0
| 11
|
make array zero by subtracting equal amounts
| 2,357
| 0.727
|
Easy
| 32,322
|
https://leetcode.com/problems/make-array-zero-by-subtracting-equal-amounts/discuss/2357815/Python-Simple-Python-Solution
|
class Solution:
def minimumOperations(self, nums: List[int]) -> int:
result = 0
while True:
if nums.count(0) == len(nums):
break
min_value = 100000
for num in nums:
if num < min_value and num != 0:
min_value = num
for i in range(len(nums)):
if nums[i] >= min_value:
nums[i] = nums[i] - min_value
result = result + 1
return result
|
make-array-zero-by-subtracting-equal-amounts
|
[ Python ] ✅✅ Simple Python Solution 🥳✌👍
|
ASHOK_KUMAR_MEGHVANSHI
| 0
| 44
|
make array zero by subtracting equal amounts
| 2,357
| 0.727
|
Easy
| 32,323
|
https://leetcode.com/problems/make-array-zero-by-subtracting-equal-amounts/discuss/2357727/easy-python-solution
|
class Solution:
def minimumOperations(self, nums: List[int]) -> int:
nums.sort()
count = 0
while nums.count(0) != len(nums) :
count += 1
nums.sort()
flag, min_num = True, 0
for i in range(len(nums)) :
if (nums[i] != 0) and flag :
min_num = nums[i]
flag = False
nums[i] -= min_num
return count
|
make-array-zero-by-subtracting-equal-amounts
|
easy python solution
|
sghorai
| 0
| 66
|
make array zero by subtracting equal amounts
| 2,357
| 0.727
|
Easy
| 32,324
|
https://leetcode.com/problems/maximum-number-of-groups-entering-a-competition/discuss/2358259/Python-oror-Math-oror-Two-Easy-Approaches
|
class Solution:
def maximumGroups(self, grades: List[int]) -> int:
x = len(grades)
n = 0.5 * ((8 * x + 1) ** 0.5 - 1)
ans = int(n)
return ans
|
maximum-number-of-groups-entering-a-competition
|
✅Python || Math || Two Easy Approaches
|
chuhonghao01
| 4
| 155
|
maximum number of groups entering a competition
| 2,358
| 0.675
|
Medium
| 32,325
|
https://leetcode.com/problems/maximum-number-of-groups-entering-a-competition/discuss/2358259/Python-oror-Math-oror-Two-Easy-Approaches
|
class Solution:
def maximumGroups(self, grades: List[int]) -> int:
sortedGrades = sorted(grades)
groupNums = 0
total = 0
while total <= len(sortedGrades):
groupNums += 1
total += groupNums
return groupNums - 1
|
maximum-number-of-groups-entering-a-competition
|
✅Python || Math || Two Easy Approaches
|
chuhonghao01
| 4
| 155
|
maximum number of groups entering a competition
| 2,358
| 0.675
|
Medium
| 32,326
|
https://leetcode.com/problems/maximum-number-of-groups-entering-a-competition/discuss/2357724/Simple-Greedy-with-Explanation
|
class Solution:
def maximumGroups(self, g: List[int]) -> int:
n = len(g)
g.sort()
curr_group = 1
curr_group_sum = 0
idx = 0
count = 0
while idx < n:
# We don't have enough elements to put in the next group, let's put them in the current group and return.
if n - idx < curr_group:
return count
# Calculate the next group sum.
next_group_sum = 0
c = 0
while c < curr_group:
next_group_sum += g[idx]
idx += 1
c += 1
# If the next group sum is not enough, put the remaining elements in the current group and return early.
if next_group_sum <= curr_group_sum:
return count
count += 1
curr_group_sum = next_group_sum
curr_group += 1
return count
|
maximum-number-of-groups-entering-a-competition
|
Simple Greedy with Explanation
|
wickedmishra
| 2
| 99
|
maximum number of groups entering a competition
| 2,358
| 0.675
|
Medium
| 32,327
|
https://leetcode.com/problems/maximum-number-of-groups-entering-a-competition/discuss/2671078/Python-3-O(N)
|
class Solution:
def maximumGroups(self, grades: List[int]) -> int:
n=len(grades)
k=0
while n>=k+1:
k+=1
n-=k
return k
|
maximum-number-of-groups-entering-a-competition
|
Python 3 O(N)
|
Sneh713
| 1
| 19
|
maximum number of groups entering a competition
| 2,358
| 0.675
|
Medium
| 32,328
|
https://leetcode.com/problems/maximum-number-of-groups-entering-a-competition/discuss/2360455/Python3-or-Linear-Traversal-with-Sorting
|
class Solution:
def maximumGroups(self, grades: List[int]) -> int:
#we can solve by traversing linearly using one pointer!
pointer = 0
prev_sum, prev_size = 0,0
cur_sum, cur_size = 0,0
ans = 0
#we have to make sure array is sorted in ascending order though!
grades.sort()
#as long as pointer is not out of bounds!
while pointer < len(grades):
#process current right element!
cur_sum += grades[pointer]
cur_size += 1
#we formed a new group
if(cur_sum > prev_sum and cur_size > prev_size):
ans += 1
prev_sum, prev_size = cur_sum, cur_size
cur_sum, cur_size = 0, 0
pointer += 1
continue
pointer += 1
return ans
|
maximum-number-of-groups-entering-a-competition
|
Python3 | Linear Traversal with Sorting
|
JOON1234
| 1
| 9
|
maximum number of groups entering a competition
| 2,358
| 0.675
|
Medium
| 32,329
|
https://leetcode.com/problems/maximum-number-of-groups-entering-a-competition/discuss/2803349/Python-One-line-O(1)-without-loop
|
class Solution:
def maximumGroups(self, grades: List[int]) -> int:
return int(math.sqrt(2 * len(grades) + 0.25) - 0.5)
|
maximum-number-of-groups-entering-a-competition
|
[Python] One line O(1) without loop
|
huangweijing
| 0
| 2
|
maximum number of groups entering a competition
| 2,358
| 0.675
|
Medium
| 32,330
|
https://leetcode.com/problems/maximum-number-of-groups-entering-a-competition/discuss/2384730/python-3-or-one-line-O(1)-time-O(1)-space
|
class Solution:
def maximumGroups(self, grades: List[int]) -> int:
return (-1 + int(math.sqrt(1 + 8*len(grades)))) // 2
|
maximum-number-of-groups-entering-a-competition
|
python 3 | one line, O(1) time, O(1) space
|
dereky4
| 0
| 65
|
maximum number of groups entering a competition
| 2,358
| 0.675
|
Medium
| 32,331
|
https://leetcode.com/problems/maximum-number-of-groups-entering-a-competition/discuss/2358055/Python-solution-with-explanation
|
class Solution:
def maximumGroups(self, grades: List[int]) -> int:
n=len(grades)
t=0
g=0
count=2
while(t<n):
t+=count
g+=1
count+=1
return g
|
maximum-number-of-groups-entering-a-competition
|
Python solution with explanation
|
saurabhvarade0903
| 0
| 18
|
maximum number of groups entering a competition
| 2,358
| 0.675
|
Medium
| 32,332
|
https://leetcode.com/problems/maximum-number-of-groups-entering-a-competition/discuss/2357783/easy-python-solution-using-dict
|
class Solution:
def maximumGroups(self, grades: List[int]) -> int:
if len(grades) <= 2 :
return 1
else :
grades.sort()
dict_group ={}
group_len = 1
i = 0
end = 0
while end < len(grades) :
start, end = i, i + group_len
# if end >= len(grades) :
# break
if group_len != 1 :
if (sum(grades[start: end]) > sum(dict_group[group_len - 1])) and (len(grades[start: end]) == (end - start)) :
# print(start, end)
dict_group[group_len] = grades[start: end]
else :
return len(dict_group)
else :
dict_group[group_len] = grades[start: end]
group_len += 1
i = end
# print(dict_group)
return len(dict_group)
|
maximum-number-of-groups-entering-a-competition
|
easy python solution using dict
|
sghorai
| 0
| 9
|
maximum number of groups entering a competition
| 2,358
| 0.675
|
Medium
| 32,333
|
https://leetcode.com/problems/find-closest-node-to-given-two-nodes/discuss/2357692/Simple-Breadth-First-Search-with-Explanation
|
class Solution:
def get_neighbors(self, start: int) -> Dict[int, int]:
distances = defaultdict(lambda: math.inf)
queue = deque([start])
level = 0
while queue:
for _ in range(len(queue)):
curr = queue.popleft()
if distances[curr] <= level:
continue
distances[curr] = level
for neighbor in graph[curr]:
queue.append(neighbor)
level += 1
return distances
def closestMeetingNode(self, edges: List[int], node1: int, node2: int) -> int:
n = len(edges)
graph = [[] for _ in range(n)]
for _from, to in enumerate(edges):
if to != -1:
graph[_from].append(to)
a = self.get_neighbors(node1)
b = self.get_neighbors(node2)
options = []
for idx in range(n):
if a[idx] != math.inf and b[idx] != math.inf:
options.append((max(a[idx], b[idx]), idx))
if not options:
return -1
return min(options)[1]
|
find-closest-node-to-given-two-nodes
|
Simple Breadth First Search with Explanation
|
wickedmishra
| 2
| 137
|
find closest node to given two nodes
| 2,359
| 0.342
|
Medium
| 32,334
|
https://leetcode.com/problems/find-closest-node-to-given-two-nodes/discuss/2754800/JavaPython3-or-DFS-%2BMap
|
class Solution:
def closestMeetingNode(self, edges: List[int], node1: int, node2: int) -> int:
count,ans=len(edges),float('inf')
graph=[[] for i in range(count)]
reach1,reach2={},{}
vis=set()
reach1[node1]=0
reach2[node2]=0
curr=float('inf')
for u,v in enumerate(edges):
if v!=-1:
graph[u].append(v)
def dfs(node,reach,dist):
for it in graph[node]:
if it not in vis:
vis.add(it)
reach[it]=dist+1
dfs(it,reach,dist+1)
vis.remove(it)
return
vis.add(node1)
dfs(node1,reach1,0)
vis.remove(node1)
vis.clear()
vis.add(node2)
dfs(node2,reach2,0)
vis.remove(node2)
for node in reach2:
if node in reach1:
if curr>max(reach1[node],reach2[node]):
ans=node
curr=max(reach1[node],reach2[node])
elif curr==max(reach1[node],reach2[node]) and node<ans:
ans=node
curr=max(reach1[node],reach2[node])
if ans==float('inf'):
return -1
else:
return ans
|
find-closest-node-to-given-two-nodes
|
[Java/Python3] | DFS +Map
|
swapnilsingh421
| 0
| 6
|
find closest node to given two nodes
| 2,359
| 0.342
|
Medium
| 32,335
|
https://leetcode.com/problems/find-closest-node-to-given-two-nodes/discuss/2388006/Find-distances-from-nodes-1and2-to-other-nodes-95-speed
|
class Solution:
def closestMeetingNode(self, edges: List[int], node1: int, node2: int) -> int:
n = len(edges)
def distances_to_nodes(start: int) -> list:
res = [inf] * n
res[start] = 0
next_node = edges[start]
count = 1
while (next_node != -1 and
count < res[next_node]):
res[next_node] = count
next_node = edges[next_node]
count += 1
return res
ans, min_max_d = -1, inf
for i, (a, b) in enumerate(zip(distances_to_nodes(node1),
distances_to_nodes(node2))):
if (distance := max(a, b)) < min_max_d:
ans = i
min_max_d = distance
return ans
|
find-closest-node-to-given-two-nodes
|
Find distances from nodes 1&2 to other nodes, 95% speed
|
EvgenySH
| 0
| 50
|
find closest node to given two nodes
| 2,359
| 0.342
|
Medium
| 32,336
|
https://leetcode.com/problems/find-closest-node-to-given-two-nodes/discuss/2362590/Python-bfs-solution-easy
|
class Solution:
def closestMeetingNode(self, edges: List[int], node1: int, node2: int) -> int:
def get_dist(graph,n):
dist = [-1 for i in range(len(graph))]
queue = [(n,0)]
while queue:
x,count = queue.pop(0)
dist[x] = count
for i in graph[x]:
if dist[i]==-1:
queue.append((i,count+1))
return dist
graph = {}
for i in range(len(edges)):
graph[i] = []
for i in range(len(edges)):
if edges[i]!=-1:
graph[i].append(edges[i])
li1 = get_dist(graph,node1)
li2 = get_dist(graph,node2)
ans = -1
result = 99999999
for i in range(len(edges)):
if li1[i]!=-1 and li2[i]!=-1:
max_dist = max(li1[i],li2[i])
if max_dist<result:
result = max_dist
ans = i
return ans
|
find-closest-node-to-given-two-nodes
|
Python bfs solution easy
|
Brillianttyagi
| 0
| 9
|
find closest node to given two nodes
| 2,359
| 0.342
|
Medium
| 32,337
|
https://leetcode.com/problems/find-closest-node-to-given-two-nodes/discuss/2359489/python3-Solution-for-reference-dfs-keeping-track-of-source.
|
class Solution:
def closestMeetingNode(self, edges: List[int], node1: int, node2: int) -> int:
s = [(node1, 0, 0), (node2, 0, 1)]
v = defaultdict(list)
ansnode = -1
dist = float('inf')
while s:
node, distance, source = s.pop()
if not v[node]:
v[node] = [float('inf'),float('inf')]
elif v[node][source] != float('inf'):
continue
v[node][source] = min(v[node][source], distance)
if v[node][0] != float('inf') and v[node][1] != float('inf'):
dmax = max(v[node][0], v[node][1])
if dmax < dist:
dist = dmax
ansnode = node
elif dmax == dist:
ansnode = min(ansnode, node)
if edges[node] != -1:
next_node = edges[node]
s.append((next_node, distance+1, source))
return ansnode
|
find-closest-node-to-given-two-nodes
|
[python3] Solution for reference dfs keeping track of source.
|
vadhri_venkat
| 0
| 2
|
find closest node to given two nodes
| 2,359
| 0.342
|
Medium
| 32,338
|
https://leetcode.com/problems/find-closest-node-to-given-two-nodes/discuss/2358169/python-Simple-DFS-solution
|
class Solution:
def closestMeetingNode(self, edges: List[int], node1: int, node2: int) -> int:
## RC ##
## APPROACH: GRAPH ##
## LOGIC ##
## 1. Typical Graph problem, just do what the question asks
## 2. Watch out for race conditions, a) when no common node b) multiple paths for the same node
graph = collections.defaultdict(list)
for u, v in enumerate(edges):
if v != -1:
graph[u].append(v)
res = float('inf')
ans = -1
visited1 = {}
def dfs1(node, d):
nonlocal res
nonlocal ans
if node == node2:
res=min(res, d)
ans=node
if node in visited1:
if visited1[node] > d:
visited1[node] = d
return
visited1[node] = d
if node in graph:
dfs1(graph[node][0], d +1)
dfs1(node1, 0)
visited2 = {}
def dfs2(node, d):
nonlocal res
nonlocal ans
if node == node1:
if res > d: # if already found in first node, then check for max distance
res = d
ans=node
if node in visited2:
if visited2[node] > d:
visited2[node] = d
return
visited2[node] = d
if node in graph:
dfs2(graph[node][0], d +1)
dfs2(node2, 0)
for node in sorted(visited1.keys()):
if node in visited2:
if max(visited1[node], visited2[node]) < res:
res = max(visited1[node], visited2[node])
ans = node
return ans
|
find-closest-node-to-given-two-nodes
|
[python] Simple DFS solution
|
101leetcode
| 0
| 16
|
find closest node to given two nodes
| 2,359
| 0.342
|
Medium
| 32,339
|
https://leetcode.com/problems/longest-cycle-in-a-graph/discuss/2357772/Python3-One-pass-dfs
|
class Solution:
def longestCycle(self, edges: List[int]) -> int:
in_d = set()
out_d = set()
for i, j in enumerate(edges):
if j != -1:
in_d.add(j)
out_d.add(i)
potential = in_d & out_d
visited = set()
self.ans = -1
def dfs(node, curr, v):
visited.add(node)
v[node] = curr
nei = edges[node]
if nei in v:
self.ans = max(self.ans, curr - v[nei] + 1)
visited.add(nei)
return
if nei not in visited and nei in potential:
dfs(nei, curr + 1, v)
for node in potential:
dfs(node, 1, {})
return self.ans
|
longest-cycle-in-a-graph
|
[Python3] One pass dfs
|
Remineva
| 5
| 257
|
longest cycle in a graph
| 2,360
| 0.386
|
Hard
| 32,340
|
https://leetcode.com/problems/longest-cycle-in-a-graph/discuss/2360079/O(n)-Python-Solution-Beats-100
|
class Solution:
def longestCycle(self, edges: List[int]) -> int:
res, seenSet = -1, set()
for element in range(len(edges)): #traverses all possible nodes
count, currNode = 0, element
cycleMap = dict() #tabulates all distances
while currNode not in seenSet and currNode != -1:
count += 1
seenSet.add(currNode); cycleMap[currNode] = count #adds nodes to the hashmap and the hashset
currNode = edges[currNode] #moves on to the next node
res = max(res, count + 1 - cycleMap.get(currNode, 200000)) #gets the max distance
return res
|
longest-cycle-in-a-graph
|
O(n) Python Solution, Beats 100%
|
ZivSucksBallsDaLimmy
| 3
| 65
|
longest cycle in a graph
| 2,360
| 0.386
|
Hard
| 32,341
|
https://leetcode.com/problems/longest-cycle-in-a-graph/discuss/2385580/VISUAL-or-PYTHON-or-DFS-or-Easy-to-Understand-or-O(N)-Time-or-O(N)-Space
|
class Solution:
def longestCycle(self, edges: List[int]) -> int:
def get_length(i, length):
#end of path
if i ==-1:
return -1
#path previously seen
if i in prev_seen:
return -1
#cycle detected
if i in cur_seen:
return length - cur_seen[i]+1
cur_seen[i] = length+1
return get_length(edges[i], length+1)
res = -1
prev_seen = {}
for i in range(len(edges)):
cur_seen={}
length = get_length(i, 0)
res = max(res, length)
prev_seen |= cur_seen
return res
|
longest-cycle-in-a-graph
|
📌 [VISUAL] | [PYTHON] | DFS | Easy to Understand | O(N) Time | O(N) Space
|
matthewlkey
| 1
| 33
|
longest cycle in a graph
| 2,360
| 0.386
|
Hard
| 32,342
|
https://leetcode.com/problems/longest-cycle-in-a-graph/discuss/2378505/Python-oror-Simple-DFS-solution
|
class Solution:
def longestCycle(self, edges: List[int]) -> int:
N = len(edges)
def dfs(node, step):
if node in total:
return total[node]
if node in visited:
return step-visited[node]
else:
visited[node] = step
next_node = edges[node]
if next_node == -1:
return -1
return dfs(next_node, step+1)
total = defaultdict(int)
for e in range(len(edges)):
if e not in total:
visited = defaultdict(int)
res = dfs(e, 0)
for v in visited:
total[v] = res
ans = max(total.values())
return -1 if ans == 0 else ans
|
longest-cycle-in-a-graph
|
Python || Simple DFS solution
|
pivovar3al
| 1
| 52
|
longest cycle in a graph
| 2,360
| 0.386
|
Hard
| 32,343
|
https://leetcode.com/problems/longest-cycle-in-a-graph/discuss/2357678/Python-3-oror-Easy-to-understand-solution
|
class Solution:
def longestCycle(self, edges: List[int]) -> int:
n = len(edges)
colors = [0] * n
dis = [0] * n
def dfs(u, d):
colors[u] = 1
dis[u] = d
ans = -1
if edges[u] == -1:
colors[u] = 2
return -1
if colors[edges[u]] == 0:
ans = max(ans, dfs(edges[u], d + 1))
elif colors[edges[u]] == 1:
return dis[u] - dis[edges[u]] + 1
colors[u] = 2
return ans
res = -1
for i in range(n):
if colors[i] == 0:
res = max(res, dfs(i, 0))
return res
s = Solution()
print(s.longestCycle([-1, 4, -1, 2, 0, 4]))
|
longest-cycle-in-a-graph
|
Python 3 || Easy to understand solution
|
pramodjoshi_22
| 1
| 37
|
longest cycle in a graph
| 2,360
| 0.386
|
Hard
| 32,344
|
https://leetcode.com/problems/longest-cycle-in-a-graph/discuss/2827238/Python-easy-to-read-and-understand-or-dfs
|
class Solution:
def cycle(self, graph, visit, node, mp):
# print(visit)
if visit[node] == 2:
# print(node, self.cnt)
self.cnt = self.cnt - mp[node]
return True
visit[node] = 2
mp[node] = self.cnt
for nei in graph[node]:
if visit[nei] != 1:
self.cnt += 1
if self.cycle(graph, visit, nei, mp):
return True
visit[node] = 1
return False
def longestCycle(self, edges: List[int]) -> int:
n = len(edges)
graph = {i: [] for i in range(n)}
for u, v in enumerate(edges):
if v != -1:
graph[u].append(v)
res = -1
visit = [0] * n
for i in range(n):
if visit[i] == 0:
self.cnt = 0
mp = {i: 0 for i in range(n)}
if self.cycle(graph, visit, i, mp):
res = max(res, self.cnt)
return res
|
longest-cycle-in-a-graph
|
Python easy to read and understand | dfs
|
sanial2001
| 0
| 6
|
longest cycle in a graph
| 2,360
| 0.386
|
Hard
| 32,345
|
https://leetcode.com/problems/longest-cycle-in-a-graph/discuss/2807663/tarjan-algorithm
|
class Solution:
def longestCycle(self, edges: List[int]) -> int:
def tarjan():
stack = []
vis = defaultdict(int)
low = defaultdict(int)
self.ts = 1
ret = []
def dfs(node):
vis[node] = self.ts
low[node] = self.ts
self.ts += 1
stack.append(node)
nex = edges[node]
if nex != -1:
if vis[nex] == 0:
dfs(nex)
low[node] = min(low[node], low[nex])
elif nex in stack:
low[node] = min(low[node], low[nex])
if vis[node] == low[node]:
tmp = []
while stack[-1] != node:
tmp.append(stack.pop())
tmp.append(stack.pop())
ret.append(tmp)
for i in range(len(edges)):
if vis[i] == 0:
dfs(i)
return ret
ret = tarjan()
cir = max(len(r) for r in ret)
if cir == 1:
return -1
else:
return cir
|
longest-cycle-in-a-graph
|
tarjan algorithm
|
xsdnmg
| 0
| 1
|
longest cycle in a graph
| 2,360
| 0.386
|
Hard
| 32,346
|
https://leetcode.com/problems/longest-cycle-in-a-graph/discuss/2480549/python-3-or-dfs
|
class Solution:
def longestCycle(self, edges: List[int]) -> int:
seen = {-1}
self.res = -1
def dfs(i):
if i in seen:
return i, 1
seen.add(i)
cycleNode, length = dfs(edges[i])
if i == cycleNode:
self.res = max(self.res, length)
return cycleNode, length + 1
for i in range(len(edges)):
dfs(i)
return self.res
|
longest-cycle-in-a-graph
|
python 3 | dfs
|
dereky4
| 0
| 69
|
longest cycle in a graph
| 2,360
| 0.386
|
Hard
| 32,347
|
https://leetcode.com/problems/longest-cycle-in-a-graph/discuss/2375901/Analogy-with-find-method-in-union-find-ADT-or-Python3-or-DFS
|
class Solution:
def longestCycle(self, edges: List[int]) -> int:
# 1. init
n = len(edges)
res = -1
visited = set([-1])
# 2. main loop
for i in range(n):
if i not in visited:
# do traversal
start = i
current_visited = set()
while start not in visited:
visited.add(start)
current_visited.add(start)
start = edges[start]
if start in current_visited:
cycle_length = 1
node = edges[start]
while node != start:
node = edges[node]
cycle_length += 1
res = max(res, cycle_length)
return res
|
longest-cycle-in-a-graph
|
Analogy with find method in union-find ADT | Python3 | DFS
|
wxy0925
| 0
| 8
|
longest cycle in a graph
| 2,360
| 0.386
|
Hard
| 32,348
|
https://leetcode.com/problems/longest-cycle-in-a-graph/discuss/2361213/DFS-as-simple-as-possible-with-few-optimizations.
|
class Solution:
def longestCycle(self, edges: List[int]) -> int:
lookup = defaultdict(list)
self.max_depth = -1
# optimization
# calculating the lookup for only edges that have indegree and outdegree.
# Because if nodes do not have both indegree and outdegree, then they can't form a cycle.
indegree, outdegree = set(), set()
for i in range(0, len(edges)):
indegree.add(edges[i])
outdegree.add(i)
all_nodes = indegree & outdegree
for i in range(0, len(edges)):
if i in all_nodes and edges[i] in all_nodes:
lookup[i].append(edges[i])
def dfs(i, cnt, curr_dict):
if i not in seen:
seen.add(i)
curr_dict[i] = cnt
for each in lookup[i]:
del lookup[i] # optimization # this can be applied because every node has
# at most one outgoing edge.
dfs(each, cnt + 1, curr_dict)
else:
self.max_depth = max(self.max_depth, cnt - curr_dict.get(i, float("inf")))
seen = set()
for each in all_nodes:
if each not in seen: # optimization # avoiding visiting the nodes multiple times.
dfs(each, 0, {})
return self.max_depth
|
longest-cycle-in-a-graph
|
DFS as simple as possible with few optimizations.
|
devanshihdesai
| 0
| 15
|
longest cycle in a graph
| 2,360
| 0.386
|
Hard
| 32,349
|
https://leetcode.com/problems/longest-cycle-in-a-graph/discuss/2360300/DFSDFS%2BKahn's-Algorithm
|
class Solution:
def longestCycle(self, edges: List[int]) -> int:
# degree of inbounds
deg = Counter(edges)
# cycle length
cycle = defaultdict(int)
n = len(edges)
def dfs(node, path, dis):
dis += 1
nei = edges[node]
# cycle found
if nei in path:
# cycle length = total travel distance - distance when node first traversed
cycle[nei] = dis - path[nei]
# check whether all inbounds have been traversed
elif nei > -1 and deg[nei]:
deg[nei] -= 1
path[nei] = dis
dfs(nei, path, dis)
for i in range(n):
if not deg[i]: continue
dfs(i, {}, 0)
return max(cycle.values()) if cycle else -1
|
longest-cycle-in-a-graph
|
[DFS]DFS+Kahn's Algorithm
|
chestnut890123
| 0
| 35
|
longest cycle in a graph
| 2,360
| 0.386
|
Hard
| 32,350
|
https://leetcode.com/problems/longest-cycle-in-a-graph/discuss/2359899/python3-Reference-solution-DFS-traversal-keeping-track-of-distance
|
class Solution:
def longestCycle(self, edges) -> int:
N = len(edges)
indegree = [0] * len(edges)
cycles = defaultdict(int)
for x in edges:
if x != -1:
indegree[x] += 1
def dfs(n, d):
ret = 0
if cycles[n] > 0:
return cycles[n]
if dist[n] > -1:
cycles[n] = d - dist[n]
return d - dist[n]
if visited[n] == True:
return 0
visited[n] = True
dist[n] = d
if edges[n] != -1:
ret = max(ret, dfs(edges[n], d+1))
dist[n] = -1
return ret
visited = defaultdict(bool)
ans = 0
dist = [-1] * N
for n in range(N):
if visited[n] == False and indegree[n] > 0:
ans = max(ans, dfs(n, 0))
return ans if ans else -1
|
longest-cycle-in-a-graph
|
[python3] Reference solution - DFS traversal keeping track of distance
|
vadhri_venkat
| 0
| 8
|
longest cycle in a graph
| 2,360
| 0.386
|
Hard
| 32,351
|
https://leetcode.com/problems/longest-cycle-in-a-graph/discuss/2358132/Python-Simple-Python-Solution-Using-Dictionary
|
class Solution:
def longestCycle(self, edges: List[int]) -> int:
result = -1
visited_node = set([-1])
for i in range(len(edges)):
if i not in visited_node:
start_node = i
current_visit = set()
while start_node not in visited_node:
visited_node.add(start_node)
current_visit.add(start_node)
start_node = edges[start_node]
if start_node in current_visit:
current_cycle_length = 1
scan = edges[start_node]
while scan != start_node:
scan = edges[scan]
current_cycle_length = current_cycle_length + 1
result = max(result, current_cycle_length)
return result
|
longest-cycle-in-a-graph
|
[ Python ] ✅✅ Simple Python Solution Using Dictionary 🥳✌👍
|
ASHOK_KUMAR_MEGHVANSHI
| 0
| 43
|
longest cycle in a graph
| 2,360
| 0.386
|
Hard
| 32,352
|
https://leetcode.com/problems/longest-cycle-in-a-graph/discuss/2357836/Simple-Python-Dictionary-and-Set
|
class Solution:
def longestCycle(self, edges: List[int]) -> int:
ans = -1
def checkLoop(start):
temp = {}
count = 0
while start != -1:
if start in temp:
return count - temp[start]
elif start in visited:
return -1
visited.add(start)
temp[start] = count
count += 1
start = edges[start]
return -1
visited = set()
for value in edges:
if value in visited:
continue
else:
ans = max(ans, checkLoop(value))
return ans
|
longest-cycle-in-a-graph
|
Simple Python Dictionary and Set
|
syji
| 0
| 15
|
longest cycle in a graph
| 2,360
| 0.386
|
Hard
| 32,353
|
https://leetcode.com/problems/merge-similar-items/discuss/2388802/Python-Simple-Python-Solution-Using-HashMap
|
class Solution:
def mergeSimilarItems(self, items1: List[List[int]], items2: List[List[int]]) -> List[List[int]]:
merge_item = items1 + items2
d = defaultdict(int)
for i in merge_item:
value,weight = i
d[value] = d[value] + weight
result = []
for j in sorted(d):
result.append([j,d[j]])
return result
|
merge-similar-items
|
[ Python ] ✅✅ Simple Python Solution Using HashMap 🥳✌👍
|
ASHOK_KUMAR_MEGHVANSHI
| 8
| 393
|
merge similar items
| 2,363
| 0.753
|
Easy
| 32,354
|
https://leetcode.com/problems/merge-similar-items/discuss/2388677/One-Liner
|
class Solution:
def mergeSimilarItems(self, i1: List[List[int]], i2: List[List[int]]) -> List[List[int]]:
return sorted((Counter({i[0] : i[1] for i in i1}) + Counter({i[0] : i[1] for i in i2})).items())
|
merge-similar-items
|
One Liner
|
votrubac
| 8
| 683
|
merge similar items
| 2,363
| 0.753
|
Easy
| 32,355
|
https://leetcode.com/problems/merge-similar-items/discuss/2388275/Python-oror-Easy-Approaches
|
class Solution:
def mergeSimilarItems(self, items1: List[List[int]], items2: List[List[int]]) -> List[List[int]]:
hashset = {}
for i in range(len(items1)):
if items1[i][0] in hashset:
hashset[items1[i][0]] += items1[i][1]
else:
hashset[items1[i][0]] = items1[i][1]
for i in range(len(items2)):
if items2[i][0] in hashset:
hashset[items2[i][0]] += items2[i][1]
else:
hashset[items2[i][0]] = items2[i][1]
ans = []
for i in sorted(hashset):
ans.append([i, hashset[i]])
return ans
|
merge-similar-items
|
✅Python || Easy Approaches
|
chuhonghao01
| 5
| 340
|
merge similar items
| 2,363
| 0.753
|
Easy
| 32,356
|
https://leetcode.com/problems/merge-similar-items/discuss/2421396/Python-Elegant-and-Short-or-HashMap-or-Sorting
|
class Solution:
"""
Time: O((n+m)*log(n+m))
Memory: O(n+m)
"""
def mergeSimilarItems(self, first: List[List[int]], second: List[List[int]]) -> List[List[int]]:
merged = defaultdict(int)
for value, weight in first + second:
merged[value] += weight
return sorted(merged.items())
|
merge-similar-items
|
Python Elegant & Short | HashMap | Sorting
|
Kyrylo-Ktl
| 3
| 128
|
merge similar items
| 2,363
| 0.753
|
Easy
| 32,357
|
https://leetcode.com/problems/merge-similar-items/discuss/2848454/Python-oror-Different-Technique-oror-Easy-for-Beginners
|
class Solution:
def mergeSimilarItems(self, items1: List[List[int]], items2: List[List[int]]) -> List[List[int]]:
final=items1+items2
final.sort(key=lambda i:(i[0]))
for i in range(0,len(final)):
for j in range(i+1,len(final)-1):
if(final[i][0]==final[j][0]):
final[i][1]=final[i][1]+final[j][1]
del final[j]
if final[-1][0]==final[-2][0]:
final[-2][1]=final[-2][1]+final[-1][1]
del final[-1]
return final
|
merge-similar-items
|
Python || Different Technique || Easy for Beginners
|
jannat99
| 0
| 1
|
merge similar items
| 2,363
| 0.753
|
Easy
| 32,358
|
https://leetcode.com/problems/merge-similar-items/discuss/2835870/Python-O(n**2)-complexity-beats-98.71-memory-usage
|
class Solution:
def mergeSimilarItems(self, items1: List[List[int]], items2: List[List[int]]) -> List[List[int]]:
for i1 in items1:
for i2 in items2:
if i1[0] == i2[0]:
i1[1] += i2[1]
items2.remove(i2)
items1.extend(items2)
return sorted(items1, key=lambda x: x[0])
|
merge-similar-items
|
Python O(n**2) complexity beats 98.71% memory usage
|
Molot84
| 0
| 4
|
merge similar items
| 2,363
| 0.753
|
Easy
| 32,359
|
https://leetcode.com/problems/merge-similar-items/discuss/2820023/simple-python-solution-using-hashmap-and-merge-sort-beats-80
|
class Solution:
def mergeSimilarItems(self, items1: List[List[int]], items2: List[List[int]]) -> List[List[int]]:
hashmap = {}
for items in items1:
if hashmap.get(items[0]) is not None:
hashmap[items[0]]+=items[1]
else:
hashmap[items[0]]=items[1]
for items in items2:
if hashmap.get(items[0]) is not None:
hashmap[items[0]]+=items[1]
else:
hashmap[items[0]]=items[1]
result = [k for k in hashmap.keys() ]
self.mergeSort(result)
return [[k,hashmap[k]] for k in result ]
def mergeSort(self,arr):
if len(arr)>1:
mid = len(arr)//2
left = arr[:mid]
right = arr[mid:]
self.mergeSort(left)
self.mergeSort(right)
i,j,k =0,0,0
while i<len(left) and j<len(right):
if left[i]<right[j]:
arr[k]=left[i]
i+=1
k+=1
else:
arr[k]=right[j]
j+=1
k+=1
while i<len(left):
arr[k]=left[i]
i+=1
k+=1
while j<len(right):
arr[k]=right[j]
j+=1
k+=1
|
merge-similar-items
|
simple python solution using hashmap and merge sort beats 80%
|
sudharsan1000m
| 0
| 1
|
merge similar items
| 2,363
| 0.753
|
Easy
| 32,360
|
https://leetcode.com/problems/merge-similar-items/discuss/2787575/Python-Solution-Using-HashMap
|
class Solution:
def mergeSimilarItems(self, items1: List[List[int]], items2: List[List[int]]) -> List[List[int]]:
merge_item = items1 + items2
hashMap = defaultdict(int)
for i in merge_item:
value,weight = i
hashMap[value] = hashMap[value] + weight
lst = []
for i in sorted(hashMap):
lst.append([i,hashMap[i]])
return lst
|
merge-similar-items
|
Python Solution - Using HashMap
|
danishs
| 0
| 7
|
merge similar items
| 2,363
| 0.753
|
Easy
| 32,361
|
https://leetcode.com/problems/merge-similar-items/discuss/2738523/Easy-Python3-solution-using-Dictionary-Comprehension-and-Sorting
|
class Solution:
def mergeSimilarItems(self, items1: List[List[int]], items2: List[List[int]]) -> List[List[int]]:
dic = {i[0]:[i[-1]] for i in items1}
for i in items2:
if i[0] in dic:
dic[i[0]].append(i[-1])
else:
dic[i[0]] = [i[-1]]
l = sorted([[key, sum(dic[key])] for key in dic.keys()] , key = lambda x:x[0])
return l
|
merge-similar-items
|
Easy Python3 solution using Dictionary Comprehension and Sorting
|
jacobsimonareickal
| 0
| 2
|
merge similar items
| 2,363
| 0.753
|
Easy
| 32,362
|
https://leetcode.com/problems/merge-similar-items/discuss/2685671/Python-oror-Using-Hashmap-oror-beats-93
|
class Solution:
def mergeSimilarItems(self, items1: List[List[int]], items2: List[List[int]]) ->List[List[int]]:
d={}
for i in items1:
d[i[0]]=i[1]
#print(d)
for i in items2:
if i[0] in d.keys():
d[i[0]]+=i[1]
else:
d[i[0]]=i[1]
l=list(d.keys())
l.sort()
ans=[]
for i in range(len(l)):
if l[i] in d.keys():
ans.append([l[i],d[l[i]]])
return ans
|
merge-similar-items
|
Python || Using Hashmap || beats 93%
|
utsa_gupta
| 0
| 8
|
merge similar items
| 2,363
| 0.753
|
Easy
| 32,363
|
https://leetcode.com/problems/merge-similar-items/discuss/2667197/Python3-or-When-in-doubt-throw-in-a-dict
|
class Solution:
def mergeSimilarItems(self, items1: List[List[int]], items2: List[List[int]]) -> List[List[int]]:
d = {}
res = []
for i in items1:
if i[0] in d:
d[i[0]] = d[i[0]] + i[1]
else:
d[i[0]] = i[1]
for i in items2:
if i[0] in d:
d[i[0]] = d[i[0]] + i[1]
else:
d[i[0]] = i[1]
for [key, value] in d.items():
res.append([key, value])
return sorted(res)
|
merge-similar-items
|
Python3 | When in doubt throw in a dict
|
prameshbajra
| 0
| 6
|
merge similar items
| 2,363
| 0.753
|
Easy
| 32,364
|
https://leetcode.com/problems/merge-similar-items/discuss/2586613/Python-Solution-using-Dictionary
|
class Solution:
def mergeSimilarItems(self, items1: List[List[int]], items2: List[List[int]]) -> List[List[int]]:
visited={}
for v,w in items1:
for j in range(len(items2)):
if v == items2[j][0] and v not in visited:
visited[v]=[v,w+items2[j][1]]
if v not in visited.keys():
visited[v]=[v,w]
for v,w in items2:
if v not in visited.keys():
visited[v]=[v,w]
return sorted(visited.values())
|
merge-similar-items
|
Python Solution using Dictionary
|
beingab329
| 0
| 34
|
merge similar items
| 2,363
| 0.753
|
Easy
| 32,365
|
https://leetcode.com/problems/merge-similar-items/discuss/2519079/Simple-Python-solution-using-hashmap-oror-beats-93
|
class Solution:
def mergeSimilarItems(self, items1: List[List[int]], items2: List[List[int]]) -> List[List[int]]:
items = items1 + items2
res = []
dic = collections.defaultdict(list)
for i,w in items:
dic[i].append(w)
for k,v in dic.items():
res.append([k,sum(v)])
res.sort(key=lambda x : x[0])
return res
|
merge-similar-items
|
Simple Python solution using hashmap || beats 93%
|
aruj900
| 0
| 38
|
merge similar items
| 2,363
| 0.753
|
Easy
| 32,366
|
https://leetcode.com/problems/merge-similar-items/discuss/2497089/Python-solution
|
class Solution:
def mergeSimilarItems(self, items1: List[List[int]], items2: List[List[int]]) -> List[List[int]]:
map_ = {item[0]: item[1] for item in items2}
for item in items1:
item[1] += map_.get(item[0], 0)
map_[item[0]] = 0
for key, val in map_.items():
# {3: 0, 6: 2}
if val:
items1.append([key, val])
items1.sort(key=lambda x:x[0])
return items1
|
merge-similar-items
|
Python solution
|
yash921
| 0
| 39
|
merge similar items
| 2,363
| 0.753
|
Easy
| 32,367
|
https://leetcode.com/problems/merge-similar-items/discuss/2483203/Python-for-beginners
|
class Solution:
def mergeSimilarItems(self, items1: List[List[int]], items2: List[List[int]]) -> List[List[int]]:
#Runtime:130ms
dic={}
lis=[]
for value,weight in items1:
dic[value]=dic.get(value,0)+weight
for value2,weight2 in items2:
dic[value2]=dic.get(value2,0)+weight2
for i in sorted(dic.keys()):
lis.append([i,dic[i]])
return lis
|
merge-similar-items
|
Python for beginners
|
mehtay037
| 0
| 30
|
merge similar items
| 2,363
| 0.753
|
Easy
| 32,368
|
https://leetcode.com/problems/merge-similar-items/discuss/2481522/Python-solution-faster-than-85.5-using-dictionary-O(n)
|
class Solution:
def mergeSimilarItems(self, items1: List[List[int]], items2: List[List[int]]) -> List[List[int]]:
item1_dict = {}
for i in items1:
item1_dict[i[0]] = i[1]
result = []
for j in items2:
if j[0] in item1_dict:
result.append([j[0], item1_dict[j[0]] + j[1]])
del item1_dict[j[0]]
else:
result.append(j)
if len(item1_dict) != 0:
for k, v in item1_dict.items():
result.append([k, v])
return sorted(result)
|
merge-similar-items
|
Python solution faster than 85.5% using dictionary O(n)
|
samanehghafouri
| 0
| 23
|
merge similar items
| 2,363
| 0.753
|
Easy
| 32,369
|
https://leetcode.com/problems/merge-similar-items/discuss/2469932/Easy-Python-solution-without-Counter
|
class Solution:
def mergeSimilarItems(self, items1: List[List[int]], items2: List[List[int]]) -> List[List[int]]:
d = {}
for i, j in items1+items2:
d[i] = d.get(i, 0)+j
ret = [list(i) for i in d.items()]
ret.sort(key = lambda x: x[0])
return ret
|
merge-similar-items
|
Easy Python solution without Counter
|
yhc22593
| 0
| 17
|
merge similar items
| 2,363
| 0.753
|
Easy
| 32,370
|
https://leetcode.com/problems/merge-similar-items/discuss/2409147/Python3-Counter
|
class Solution:
def mergeSimilarItems(self, items1: List[List[int]], items2: List[List[int]]) -> List[List[int]]:
mp = Counter(dict(items1)) + Counter(dict(items2))
return sorted(mp.items())
|
merge-similar-items
|
[Python3] Counter
|
ye15
| 0
| 17
|
merge similar items
| 2,363
| 0.753
|
Easy
| 32,371
|
https://leetcode.com/problems/merge-similar-items/discuss/2393820/Python-Simple-with-Explanation-Solution
|
class Solution:
def mergeSimilarItems(self, items1: List[List[int]], items2: List[List[int]]) -> List[List[int]]:
items1+=items2[:]
items1.sort()
ans,i=[],0
while i!=len(items1):
# check if it is not last element, if it is it will go in else part to append in ans
if i!= len(items1)-1 and items1[i][0]==items1[i+1][0]:
ans.append([items1[i][0],items1[i][1]+items1[i+1][1]])
i=i+2
else:
ans.append(items1[i])
i+=1
return ans
|
merge-similar-items
|
Python Simple with Explanation Solution
|
ayushrawat11562
| 0
| 17
|
merge similar items
| 2,363
| 0.753
|
Easy
| 32,372
|
https://leetcode.com/problems/merge-similar-items/discuss/2391499/Easy-hashmap-python3
|
class Solution:
def mergeSimilarItems(self, items1: List[List[int]], items2: List[List[int]]) -> List[List[int]]:
w = {}
for i in items1:
w[i[0]] = i[1]
for i in items2:
if i[0] in w:
w[i[0]] += i[1]
else:
w[i[0]] = i[1]
ans=[]
w_s=sorted(w)
for i in w_s:
ans.append([i,w[i]])
return ans
|
merge-similar-items
|
Easy hashmap [python3]
|
sunakshi132
| 0
| 12
|
merge similar items
| 2,363
| 0.753
|
Easy
| 32,373
|
https://leetcode.com/problems/merge-similar-items/discuss/2389970/Python3-or-Hashmap-%2B-Sorting-O(1)-time-O(1)-Space-Solution
|
class Solution:
#Time-Complexity: O(2000 + 1000 + 1000lg(1000)), in worst case first two for loops run 1000 times based on constraints on #items1 and items2 arrays' length! In worst case, each item has distinct value for its worth -> at most 1000 keys in hashmap! #Lastly, the in-place sorting algorithm(timsort) is going to be 1000*log(1000) in worst case! -> O(1)
#S.C = O(1000*1 + 1000*2) -> O(1)
def mergeSimilarItems(self, items1: List[List[int]], items2: List[List[int]]) -> List[List[int]]:
hashmap = {}
for item1 in items1:
if item1[0] not in hashmap:
hashmap[item1[0]] = item1[1]
else:
hashmap[item1[0]] += item1[1]
for item2 in items2:
if item2[0] not in hashmap:
hashmap[item2[0]] = item2[1]
else:
hashmap[item2[0]] += item2[1]
sort = []
for k,v in hashmap.items():
sort.append([k, v])
sort.sort(key = lambda x: x[0])
return sort
|
merge-similar-items
|
Python3 | Hashmap + Sorting O(1) time O(1) Space Solution
|
JOON1234
| 0
| 11
|
merge similar items
| 2,363
| 0.753
|
Easy
| 32,374
|
https://leetcode.com/problems/merge-similar-items/discuss/2389688/Python-simple-solutiion
|
class Solution:
def mergeSimilarItems(self, items1: List[List[int]], items2: List[List[int]]) -> List[List[int]]:
ans = {}
for k, v in items1+items2:
if k in ans:
ans[k] += v
else:
ans[k] = v
return sorted([[k,v] for k,v in ans.items()], key=lambda x: x[0])
|
merge-similar-items
|
Python simple solutiion
|
StikS32
| 0
| 32
|
merge similar items
| 2,363
| 0.753
|
Easy
| 32,375
|
https://leetcode.com/problems/merge-similar-items/discuss/2389377/Python-Simple-Solution-HashMap-oror-Documented
|
class Solution:
def mergeSimilarItems(self, items1: List[List[int]], items2: List[List[int]]) -> List[List[int]]:
dict = defaultdict(int) # dictionary
for val, weight in items1:
dict[val] = weight # add value: weight
for val, weight in items2:
dict[val] += weight # add value: weight (if exist do addition)
# convert dict into the sorted [value, weight] list
keys = sorted(dict.keys())
return [[key, dict[key]] for key in keys]
|
merge-similar-items
|
[Python] Simple Solution - HashMap || Documented
|
Buntynara
| 0
| 7
|
merge similar items
| 2,363
| 0.753
|
Easy
| 32,376
|
https://leetcode.com/problems/merge-similar-items/discuss/2389186/Python-or-Default-Dict-or-4-lines
|
class Solution:
def mergeSimilarItems(self, items1: List[List[int]], items2: List[List[int]]) -> List[List[int]]:
ans = defaultdict(int)
for value, weight in items1: ans[value] += weight
for value, weight in items2: ans[value] += weight
return list(sorted(ans.items()))
|
merge-similar-items
|
Python | Default Dict | 4 lines
|
leeteatsleep
| 0
| 15
|
merge similar items
| 2,363
| 0.753
|
Easy
| 32,377
|
https://leetcode.com/problems/merge-similar-items/discuss/2388961/Python-or-Easy-and-Understanding-Solution
|
class Solution:
def mergeSimilarItems(self, items1: List[List[int]], items2: List[List[int]]) -> List[List[int]]:
n1=len(items1)
n2=len(items2)
items1.sort(key=lambda item:(item[0]))
items2.sort(key=lambda item:(item[0]))
i=j=0
ans=[]
while(i<n1 and j<n2):
if(items1[i][0]==items2[j][0]):
ans.append([items1[i][0],items1[i][1]+items2[j][1]])
i+=1
j+=1
elif(items1[i][0]<items2[j][0]):
ans.append([items1[i][0],items1[i][1]])
i+=1
else:
ans.append([items2[j][0],items2[j][1]])
j+=1
while(i<n1):
ans.append([items1[i][0],items1[i][1]])
i+=1
while(j<n2):
ans.append([items2[j][0],items2[j][1]])
j+=1
return ans
|
merge-similar-items
|
Python | Easy & Understanding Solution
|
backpropagator
| 0
| 21
|
merge similar items
| 2,363
| 0.753
|
Easy
| 32,378
|
https://leetcode.com/problems/merge-similar-items/discuss/2388531/Python-dictionary
|
class Solution:
def mergeSimilarItems(self, items1: List[List[int]], items2: List[List[int]]) -> List[List[int]]:
weight = {} # or defaultdict(int)
values, weights = zip(*items1, *items2)
for val, wt in zip(values, weights):
weight[val] = weight.get(val, 0) + wt
return sorted(weight.items())
|
merge-similar-items
|
Python dictionary
|
blest
| 0
| 14
|
merge similar items
| 2,363
| 0.753
|
Easy
| 32,379
|
https://leetcode.com/problems/count-number-of-bad-pairs/discuss/2388687/Python-oror-Detailed-Explanation-oror-Faster-Than-100-oror-Less-than-100-oror-Simple-oror-MATH
|
class Solution:
def countBadPairs(self, nums: List[int]) -> int:
nums_len = len(nums)
count_dict = dict()
for i in range(nums_len):
nums[i] -= i
if nums[i] not in count_dict:
count_dict[nums[i]] = 0
count_dict[nums[i]] += 1
count = 0
for key in count_dict:
count += math.comb(count_dict[key], 2)
return math.comb(nums_len, 2) - count
|
count-number-of-bad-pairs
|
🔥 Python || Detailed Explanation ✅ || Faster Than 100% ✅|| Less than 100% ✅ || Simple || MATH
|
wingskh
| 32
| 648
|
count number of bad pairs
| 2,364
| 0.408
|
Medium
| 32,380
|
https://leetcode.com/problems/count-number-of-bad-pairs/discuss/2388329/Python-oror-O(n)-oror-Count-oror-Easy-Approaches
|
class Solution:
def countBadPairs(self, nums: List[int]) -> int:
n = len(nums)
res = []
for i in range(n):
res.append(nums[i] - i)
a = Counter(res)
ans = n * (n - 1) // 2
for x in a:
if a[x] > 1:
ans -= a[x] * (a[x] - 1) // 2
return ans
|
count-number-of-bad-pairs
|
✅Python || O(n) || Count || Easy Approaches
|
chuhonghao01
| 2
| 207
|
count number of bad pairs
| 2,364
| 0.408
|
Medium
| 32,381
|
https://leetcode.com/problems/count-number-of-bad-pairs/discuss/2471871/Python-Solution-or-Brute-Force-or-Hashing-or-O(N)
|
class Solution:
def countBadPairs(self, nums: List[int]) -> int:
count=0
n=len(nums)
# for i in range(n):
# for j in range(i+1, n):
# if j-i!=nums[j]-nums[i]:
# count+=1
# return count
d={}
for i in range(n):
if nums[i]-i in d:
count+=d[nums[i]-i]
d[nums[i]-i]+=1
else:
d[nums[i]-i]=1
return (n*(n-1)//2) - count
|
count-number-of-bad-pairs
|
Python Solution | Brute Force | Hashing | O(N)
|
Siddharth_singh
| 1
| 119
|
count number of bad pairs
| 2,364
| 0.408
|
Medium
| 32,382
|
https://leetcode.com/problems/count-number-of-bad-pairs/discuss/2388262/Remove-good-pairs-from-total-no-of-pairs
|
class Solution:
def countBadPairs(self, nums: List[int]) -> int:
res = 0
d = defaultdict(int)
l = len(nums)
total = l*(l-1)//2
for i,n in enumerate(nums):
res += d[n-i]
d[n-i] += 1
return total - res
|
count-number-of-bad-pairs
|
Remove good pairs from total no of pairs
|
amlanbtp
| 1
| 33
|
count number of bad pairs
| 2,364
| 0.408
|
Medium
| 32,383
|
https://leetcode.com/problems/count-number-of-bad-pairs/discuss/2737064/Count-bad-pairs
|
class Solution:
def countBadPairs(self, nums: List[int]) -> int:
n=len(nums)
countgood=0
d=dict()
for i in range(len(nums)):
diff=i-nums[i]
if diff not in d:
d[diff]=1
else:
d[diff]+=1
for key,value in d.items():
countgood+=(value*(value-1)//2)
totalpairs=n*(n-1)//2
return totalpairs-countgood
|
count-number-of-bad-pairs
|
Count bad pairs
|
shivansh2001sri
| 0
| 6
|
count number of bad pairs
| 2,364
| 0.408
|
Medium
| 32,384
|
https://leetcode.com/problems/count-number-of-bad-pairs/discuss/2411422/100-Time-Efficient-100-Memory-Efficient
|
class Solution:
def countBadPairs(self, nums: List[int]) -> int:
d=defaultdict(int)
for i in range(len(nums)):
d[i-nums[i]]+=1 # create dictionary (hashmap) whose key is i-nums[i] and value is the frequency of i-nums[i] in nums array
res=0
for i in d:
x=d[i]
res+=x*(len(nums)-x)
return res//2 # since evry pair is taken twice in res
|
count-number-of-bad-pairs
|
100% Time Efficient, 100% Memory Efficient
|
pbhuvaneshwar
| 0
| 86
|
count number of bad pairs
| 2,364
| 0.408
|
Medium
| 32,385
|
https://leetcode.com/problems/count-number-of-bad-pairs/discuss/2409156/Python3-2-line
|
class Solution:
def countBadPairs(self, nums: List[int]) -> int:
freq = Counter(i-x for i, x in enumerate(nums))
return sum(v*(len(nums)-v) for v in freq.values())//2
|
count-number-of-bad-pairs
|
[Python3] 2-line
|
ye15
| 0
| 9
|
count number of bad pairs
| 2,364
| 0.408
|
Medium
| 32,386
|
https://leetcode.com/problems/count-number-of-bad-pairs/discuss/2390048/Python3-or-Little-Math-Trick-(check-all-positions-such-at-Ai-i-Aj-j)-with-Hashmap-DS
|
class Solution:
#Time-Complexity: O(n)
#Space-Complexity: O(n * 1 + n + n*n) -> O(n^2)
def countBadPairs(self, nums: List[int]) -> int:
#instead of thinking to computing total number of bad pairs, try thinking of computing
#total number of good pairs -> thinking problem in reverse angle!
#bad = total - good!
#total pairs = len(nums)-1 + len(nums) - 2 + ... + 0
#a pair is bad if i < j and nums[j] - j != nums[i] - i
#we can phrase good pair then as being opposite as i < j and nums[j] - j == nums[i] - i!
#so transform array by taking each element and subtracting it by its index position!
#linearly traverse L to R and if not already in hashmap add it!
#if already in hashmap: update key's val += 1
#for each key in hashmap, if its val > 1: take the val -1 and sum from there down to 0
#and increment tot_good_pairs by this!
for i in range(len(nums)):
nums[i] -= i
hashmap = {}
for num in nums:
if num not in hashmap:
hashmap[num] = 1
else:
hashmap[num] += 1
#iterate through each key value pair and see if val > 1:
total_pairs_array = [i for i in range(len(nums))]
total_pairs = sum(total_pairs_array)
good_pairs = 0
for k,v in hashmap.items():
#if value is greater than 1, that means that nums[i] - i specific value
#occurs somewhere else at jth index for nums[j] - j -> potential good pair!
if v > 1:
good_pairs_array = [i for i in range(v)]
good_pairs += sum(good_pairs_array)
bad_pairs = total_pairs - good_pairs
return bad_pairs
|
count-number-of-bad-pairs
|
Python3 | Little Math Trick (check all positions such at A[i]-i == A[j]-j) with Hashmap DS
|
JOON1234
| 0
| 11
|
count number of bad pairs
| 2,364
| 0.408
|
Medium
| 32,387
|
https://leetcode.com/problems/count-number-of-bad-pairs/discuss/2389510/Python-Accurate-Faster-Solution-HashMap
|
class Solution:
def countBadPairs(self, nums: List[int]) -> int:
dict, ans = defaultdict(int), 0
for i, v in enumerate(nums):
diff = v - i
ans += i - dict[diff]
dict[diff] += 1
return ans
|
count-number-of-bad-pairs
|
[Python] Accurate Faster Solution - HashMap
|
Buntynara
| 0
| 9
|
count number of bad pairs
| 2,364
| 0.408
|
Medium
| 32,388
|
https://leetcode.com/problems/count-number-of-bad-pairs/discuss/2388996/Python-or-Easy-and-Understanding-Solution
|
class Solution:
def countBadPairs(self, nums: List[int]) -> int:
n=len(nums)
mapp={}
for i in range(n):
if(i-nums[i] not in mapp):
mapp[i-nums[i]]=1
else:
mapp[i-nums[i]]+=1
ans=0
for i in range(n):
diff=i-nums[i]
mapp[diff]-=1
ans+=n-i-1-mapp[diff]
return ans
|
count-number-of-bad-pairs
|
Python | Easy & Understanding Solution
|
backpropagator
| 0
| 19
|
count number of bad pairs
| 2,364
| 0.408
|
Medium
| 32,389
|
https://leetcode.com/problems/count-number-of-bad-pairs/discuss/2388110/Python3-Count-the-good-pairs-6-lines
|
class Solution:
def countBadPairs(self, nums: List[int]) -> int:
k = len(nums)
res = k * (k - 1) // 2 # (1)
c = Counter([i - n for i, n in enumerate(nums)]) # (2) and (3)
for n in c.values():
res -= n * (n - 1) // 2 # (4)
return res
|
count-number-of-bad-pairs
|
[Python3] Count the good pairs, 6 lines
|
Unwise
| 0
| 41
|
count number of bad pairs
| 2,364
| 0.408
|
Medium
| 32,390
|
https://leetcode.com/problems/task-scheduler-ii/discuss/2388355/Python-oror-Easy-Approach
|
class Solution:
def taskSchedulerII(self, tasks: List[int], space: int) -> int:
ans = 0
hashset = {}
n = len(tasks)
for x in set(tasks):
hashset[x] = 0
i = 0
while i <= n - 1:
flag = ans - hashset[tasks[i]]
if flag >= 0:
ans += 1
hashset[tasks[i]] = ans + space
i += 1
else:
ans += -flag
return ans
|
task-scheduler-ii
|
✅Python || Easy Approach
|
chuhonghao01
| 2
| 75
|
task scheduler ii
| 2,365
| 0.462
|
Medium
| 32,391
|
https://leetcode.com/problems/task-scheduler-ii/discuss/2388216/Python-easy-solution
|
class Solution:
def taskSchedulerII(self, tasks: List[int], space: int) -> int:
Dict = {}
ans,l = 0,len(tasks)
for i,n in enumerate(tasks):
if n in Dict:
ans += max(1,space-(ans-Dict[n])+1)
else:
ans+=1
Dict[n] = ans
return ans
|
task-scheduler-ii
|
Python easy solution
|
amlanbtp
| 1
| 36
|
task scheduler ii
| 2,365
| 0.462
|
Medium
| 32,392
|
https://leetcode.com/problems/task-scheduler-ii/discuss/2576924/Python-Easy-to-Understand-Solution
|
class Solution:
def taskSchedulerII(self, tasks: List[int], space: int) -> int:
day_checker = {}
day = 1
for i in range(len(tasks)):
if tasks[i] not in day_checker:
day_checker[tasks[i]] = day
else:
if abs(day_checker[tasks[i]] - day) <= space:
day = day_checker[tasks[i]] + space + 1
day_checker[tasks[i]] = day
else:
day_checker[tasks[i]] = day
day += 1
return day - 1
```
|
task-scheduler-ii
|
Python Easy to Understand Solution
|
NiazAhmad
| 0
| 21
|
task scheduler ii
| 2,365
| 0.462
|
Medium
| 32,393
|
https://leetcode.com/problems/task-scheduler-ii/discuss/2497539/Python-90-faster
|
class Solution:
def taskSchedulerII(self, tasks: List[int], space: int) -> int:
map = {tasks[0]:0}
i = 1
n = len(tasks)
j = 1
dash = 0
while i<n:
if tasks[i] in map and (i+dash)-map[tasks[i]] -1< space:
count = space-((i+dash)-map[tasks[i]]-1)
dash+=count
j+= count
map[tasks[i]] = i+dash
i+=1
j+=1
else:
map[tasks[i]] = i+dash
j+=1
i+=1
return j
|
task-scheduler-ii
|
Python 90% faster
|
Abhi_009
| 0
| 46
|
task scheduler ii
| 2,365
| 0.462
|
Medium
| 32,394
|
https://leetcode.com/problems/task-scheduler-ii/discuss/2443897/One-pass-80-speed
|
class Solution:
def taskSchedulerII(self, tasks: List[int], space: int) -> int:
day = 1
allowed = dict()
space1 = space + 1
for task in tasks:
if task in allowed:
if day >= allowed[task]:
allowed[task] = day + space1
else:
day = allowed[task]
allowed[task] = day + space1
else:
allowed[task] = day + space1
day += 1
return day - 1
|
task-scheduler-ii
|
One pass, 80% speed
|
EvgenySH
| 0
| 25
|
task scheduler ii
| 2,365
| 0.462
|
Medium
| 32,395
|
https://leetcode.com/problems/task-scheduler-ii/discuss/2409166/Python3-4-line
|
class Solution:
def taskSchedulerII(self, tasks: List[int], space: int) -> int:
ans = 0
prev = defaultdict(lambda: -inf)
for t in tasks: ans = prev[t] = max(ans, prev[t]+space)+1
return ans
|
task-scheduler-ii
|
[Python3] 4-line
|
ye15
| 0
| 19
|
task scheduler ii
| 2,365
| 0.462
|
Medium
| 32,396
|
https://leetcode.com/problems/task-scheduler-ii/discuss/2389975/Python3-or-Basic-Traversal-and-Usage-of-Hashmap-or-Linear-Time-and-Space-Solution!
|
class Solution:
#let n = tasks.length!
#Time-Complexity: O(n)
#Space-Complexity: O(n*1) -> O(n)
def taskSchedulerII(self, tasks: List[int], space: int) -> int:
#we need someway to keep track of each type of tasks when it was most recently completed!
#We can utilize a hashmap -> Key: type of task mapped to Value: most recent day the type of task was completed!
#I will use i as pointer that goes through each task one by one!
#I will also use day counter to keep track of the current day!
#If we ever encounter a task we did not do before, we can immediately do it now and record when we did it
#in hashmap!
#Otherwise, we need to check if the current day > space + hashmap[type of task] -> Only then can we do the task
#we did before now! Otherwise, we need to wait certain number of days until day > space + hashmap[type_of_task]
hashmap = {}
day = 1
i= 0
#as long as pointer i is in-bounds, we can continue!
while i < len(tasks):
#check if current task is not seen yet! -> Do it now!
if(tasks[i] not in hashmap):
hashmap[tasks[i]] = day
day += 1
i += 1
continue
#otherwise, if the task is what we already seen before...
else:
last_completed = hashmap[tasks[i]]
#then, we can do now!
if(day > space + last_completed):
hashmap[tasks[i]] = day
day += 1
i += 1
continue
#otherwise, we need to bring current day number to be 1 more than space + last_completed! Gotta
#wait that many more days!
else:
day = last_completed + space + 1
hashmap[tasks[i]] = day
day += 1
i += 1
#we should have days be min number of days + 1
return day - 1
|
task-scheduler-ii
|
Python3 | Basic Traversal and Usage of Hashmap | Linear Time and Space Solution!
|
JOON1234
| 0
| 9
|
task scheduler ii
| 2,365
| 0.462
|
Medium
| 32,397
|
https://leetcode.com/problems/task-scheduler-ii/discuss/2389917/PYTHON-or-HASH-or-KEEP-TRACK
|
class Solution:
def taskSchedulerII(self, tasks: List[int], space: int) -> int:
"""
Input: tasks = [1,2,1,2,3,1], space = 3
Output: 9
"""
last = {}
days = 0
for i in range(len(tasks)):
days+=1
if len(last)==0:
last[tasks[i]]=days+space+1
else:
if tasks[i] in last:
n = last[tasks[i]]
days = max(days,n)
last[tasks[i]] = days+space+1
else:
last[tasks[i]]=days+space+1
return days
|
task-scheduler-ii
|
PYTHON | HASH | KEEP TRACK
|
Brillianttyagi
| 0
| 15
|
task scheduler ii
| 2,365
| 0.462
|
Medium
| 32,398
|
https://leetcode.com/problems/task-scheduler-ii/discuss/2389107/Python-or-Easy-and-Understanding-Solution
|
class Solution:
def taskSchedulerII(self, tasks: List[int], space: int) -> int:
mapp={}
ans=0
for task in tasks:
ans+=1
if task not in mapp:
mapp[task]=ans
else:
if(ans-mapp[task]<=space):
ans+=(space-(ans-mapp[task]))+1
mapp[task]=ans
else:
mapp[task]=ans
return ans
|
task-scheduler-ii
|
Python | Easy & Understanding Solution
|
backpropagator
| 0
| 4
|
task scheduler ii
| 2,365
| 0.462
|
Medium
| 32,399
|
Subsets and Splits
Top 2 Solutions by Upvotes
Identifies the top 2 highest upvoted Python solutions for each problem, providing insight into popular approaches.