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/append-k-integers-with-minimal-sum/discuss/1823927/Python-O(nlogn)-solution-with-n(n%2B1)-2-Range-Sum | class Solution:
def minimalKSum(self, nums: List[int], k: int) -> int:
# define range sum
def range_sum(start, stop, step=1):
number_of_terms = (stop - start) // step
sum_of_extrema = start + (stop - step)
return number_of_terms * sum_of_extrema // 2
nums = list(set(nums)) # remove repeats
nums.sort() # O(nlogn)
# total sum
sol = 0
prev = 0
ptr = 0
while k > 0:
if ptr < len(nums):
# potential window to add nums
gap = nums[ptr] - prev - 1
sol += range_sum(prev+1, min(nums[ptr], prev+k+1)) # add range sum O(1)
k -= gap
prev = nums[ptr]
ptr += 1
else: # draw numbers after all numbers in the list
sol += range_sum(prev+1, prev + remaining + 1)
k = 0
return sol | append-k-integers-with-minimal-sum | Python O(nlogn) solution with n(n+1) / 2 Range Sum | MaanavS | 3 | 207 | append k integers with minimal sum | 2,195 | 0.25 | Medium | 30,500 |
https://leetcode.com/problems/append-k-integers-with-minimal-sum/discuss/2209384/python-or-O(nlogn)-solution-using-sort-or-97.65-faster | class Solution:
def minimalKSum(self, nums: List[int], k: int) -> int:
k_sum = k * (k + 1) // 2
nums = [*set(nums)]
nums.sort()
for num in nums:
if num > k:
break
else:
k += 1
k_sum += k - num
return k_sum | append-k-integers-with-minimal-sum | python | O(nlogn) solution using sort | 97.65% faster | ahmadheshamzaki | 1 | 146 | append k integers with minimal sum | 2,195 | 0.25 | Medium | 30,501 |
https://leetcode.com/problems/append-k-integers-with-minimal-sum/discuss/1825525/Python-3-Arithmatic-progression | class Solution:
def minimalKSum(self, nums: List[int], k: int) -> int:
# remove dupliate nums and sort
nums = sorted(set(nums))
nums = [0] + nums + [float("inf")]
ans = 0
for i in range(1, len(nums)):
# difference between two adjacent numbers
diff = nums[i] - nums[i-1] - 1
if diff <= 0: continue
# fill in the gap from nums[i-1] + 1 to nums[i] - 1
if diff < k:
k -= diff
ans += (nums[i-1] + 1) * diff + diff * (diff - 1) // 2
# fill the first k nums from nums[i-1] + 1
else:
return ans + (nums[i-1] + 1) * k + k * (k - 1) // 2
return ans | append-k-integers-with-minimal-sum | [Python 3] Arithmatic progression | chestnut890123 | 1 | 58 | append k integers with minimal sum | 2,195 | 0.25 | Medium | 30,502 |
https://leetcode.com/problems/append-k-integers-with-minimal-sum/discuss/1824079/Python-sum-all-nums-between-a-b-using-n-*-(n-%2B-1)-2 | class Solution:
def minimalKSum(self, nums: List[int], k: int) -> int:
def sum_between(a, b):
# inclusive sum all nums between a, b
# eg: 40, 41, 42, 43, 44
# = 40 + 40 + 40 + 40 + 40
# +1 +2 +3 +4
# = 40 * 5 + sum of 1 to 4
# formula for sum of 1 to n: (n * (n + 1))//2
if b < a: return 0
dist = b - a + 1
n = dist - 1
return a * dist + (n * (n + 1))//2
nums.append(0)
nums.sort()
res = 0
# sum between all the gaps in the list
for i in range(1, len(nums)):
last = nums[i-1] + 1
cur = min(last + k - 1, nums[i] - 1)
if last > cur: continue
res += sum_between(last, cur)
k -= cur-last+1
if k == 0:
return res
# add additional
res += sum_between(nums[-1] + 1, nums[-1] + k)
return res | append-k-integers-with-minimal-sum | Python sum all nums between a, b using n * (n + 1) / 2 | davidc360 | 1 | 71 | append k integers with minimal sum | 2,195 | 0.25 | Medium | 30,503 |
https://leetcode.com/problems/append-k-integers-with-minimal-sum/discuss/1823825/Python3-Sorting-One-Pass-greedy-11-line-solution-(explained) | class Solution:
def minimalKSum(self, nums: List[int], k: int) -> int:
nums = sorted(set(nums))
full_series = k * (k + 1) // 2
for n in nums:
if n <= k:
full_series += k - n + 1
k += 1
else:
break
return full_series | append-k-integers-with-minimal-sum | [Python3] Sorting, One-Pass greedy 11-line solution (explained) | dwschrute | 1 | 51 | append k integers with minimal sum | 2,195 | 0.25 | Medium | 30,504 |
https://leetcode.com/problems/append-k-integers-with-minimal-sum/discuss/2837153/Python-sorting | class Solution:
def minimalKSum(self, nums: List[int], k: int) -> int:
if k == 0:
return 0
result = 0
nums.sort()
nums = [0] + nums
for i in range(1, len(nums)):
diff = nums[i] - nums[i - 1]
if diff <= 1:
continue
n = min(k, (nums[i] - nums[i - 1]) - 1)
left = nums[i - 1] + 1
right = nums[i - 1] + n
result += (n / 2) * (left + right)
k -= n
if k == 0:
return int(result)
if k > 0:
left = nums[-1] + 1
right = nums[-1] + k
result += (k / 2) * (left + right)
return int(result) | append-k-integers-with-minimal-sum | Python, sorting | swepln | 0 | 3 | append k integers with minimal sum | 2,195 | 0.25 | Medium | 30,505 |
https://leetcode.com/problems/append-k-integers-with-minimal-sum/discuss/2755901/JavaPython3-or-Sorting-or-O(nlogn) | class Solution:
def minimalKSum(self, nums: List[int], k: int) -> int:
nums.sort()
vis=set()
currSum=k*(k+1)//2
ptr=0
for num in nums:
if 1<=num<=k+ptr and num not in vis:
currSum-=num
ptr+=1
currSum+=k+ptr
vis.add(num)
return currSum | append-k-integers-with-minimal-sum | [Java/Python3] | Sorting | O(nlogn) | swapnilsingh421 | 0 | 8 | append k integers with minimal sum | 2,195 | 0.25 | Medium | 30,506 |
https://leetcode.com/problems/append-k-integers-with-minimal-sum/discuss/1953013/Python.-Easy-and-Concise.-Math.-T.C%3A-O(nlogn) | class Solution:
def minimalKSum(self, nums: List[int], k: int) -> int:
# Append 0 and +inf to avoid extra checks in the for loop
nums.append(0)
nums.append(float("+inf"))
nums.sort()
total = 0
for i in range(1, len(nums)):
if k == 0:
break
# check that the numbers are different
elif nums[i] == nums[i-1]:
continue
else:
# calculate the sum between n1 and n2 in O(1)
n1, n2 = nums[i-1]+1, nums[i]-1
# Special check in case that there more numbers than k
if n2 - n1 + 1 > k:
n2 = n1 + k - 1
remaining = k
k = 0
else:
remaining = n2 - n1 + 1
k -= n2 - n1 + 1
total += remaining * (n2 + n1) // 2
return total | append-k-integers-with-minimal-sum | Python. Easy & Concise. Math. T.C: O(nlogn) | asbefu | 0 | 110 | append k integers with minimal sum | 2,195 | 0.25 | Medium | 30,507 |
https://leetcode.com/problems/append-k-integers-with-minimal-sum/discuss/1886212/Python-3-oror-O(nlogn) | class Solution:
def minimalKSum(self, nums: List[int], k: int) -> int:
def sumToN(n):
return n * (n + 1) // 2
nums.sort()
prev = res = 0
for num in nums:
x = max(0, min(k, num - prev - 1))
res += sumToN(prev + x) - sumToN(prev)
k -= x
if k == 0:
return res
prev = num
return res + sumToN(prev + k) - sumToN(prev) | append-k-integers-with-minimal-sum | Python 3 || O(nlogn) | dereky4 | 0 | 132 | append k integers with minimal sum | 2,195 | 0.25 | Medium | 30,508 |
https://leetcode.com/problems/append-k-integers-with-minimal-sum/discuss/1836762/Sort-and-count-sums-between-numbers-71-speed | class Solution:
def minimalKSum(self, nums: List[int], k: int) -> int:
start, ans = 1, 0
for n in sorted(nums):
if start < n:
if n - start <= k:
ans += (start + n - 1) * (n - start) // 2
k -= n - start
else:
ans += (2 * start + k - 1) * k // 2
return ans
if not k:
break
start = n + 1
if k:
ans += (2 * start + k - 1) * k // 2
return ans | append-k-integers-with-minimal-sum | Sort and count sums between numbers, 71% speed | EvgenySH | 0 | 76 | append k integers with minimal sum | 2,195 | 0.25 | Medium | 30,509 |
https://leetcode.com/problems/append-k-integers-with-minimal-sum/discuss/1825003/Python-Easy-O(n)-solution. | class Solution:
def minimalKSum(self, nums: List[int], k: int) -> int:
nums.sort()
start = 1
ans = 0
for num in nums:
if k<=0:
break
while start < num and k>0:
dist = min(num-start,k)
l = start-1
r = start+dist-1
ans+= (r*(r+1)//2) - (l*(l+1)//2)
start = num
k-= dist
start = num+1
if k > 0:
l = start-1
r = start+(k-1)
ans+= (r*(r+1)//2) - (l*(l+1)//2)
return ans******** | append-k-integers-with-minimal-sum | [Python] Easy O(n) solution. | imadilkhan | 0 | 30 | append k integers with minimal sum | 2,195 | 0.25 | Medium | 30,510 |
https://leetcode.com/problems/append-k-integers-with-minimal-sum/discuss/1824546/Different-results-between-''-and-''.-Does-anyone-know-why | class Solution:
def minimalKSum(self, nums: List[int], k: int) -> int:
nums = list(set(nums))
nums.sort()
n = len(nums)
tarEnd = k
p = 0
while p < n and nums[p] <= tarEnd:
tarEnd += 1
p += 1
# return (tarEnd+1)*tarEnd // 2 - sum(nums[:p]) # correct 500000000500000001
# return ((tarEnd+1)*tarEnd >> 1) - sum(nums[:p]) # correct 500000000500000001
return int((tarEnd+1)*tarEnd / 2) - sum(nums[:p]) # wrong 500000000500000000 | append-k-integers-with-minimal-sum | Different results between '/' and '//'. Does anyone know why? | CxSomebody | 0 | 10 | append k integers with minimal sum | 2,195 | 0.25 | Medium | 30,511 |
https://leetcode.com/problems/append-k-integers-with-minimal-sum/discuss/1823923/Python-or-Arithmetic-Progression-with-Explanation | class Solution:
def minimalKSum(self, nums: List[int], k: int) -> int:
summ = 0
nums.sort()
for i in range(len(nums) + 1):
# skip computation if we have already fulfilled requirements
if k <= 0: break
# just skip if the 2 terms are equal
if i > 0 and i < len(nums) and nums[i] == nums[i-1]: continue
# Find the start
if i == 0: start = 1
else: start = nums[i-1] + 1
# find the end
if i == len(nums): end = start + k - 1
else: end = min(start + k - 1, nums[i] - 1)
# number of terms in arithmatic progression = last - first + 1
n = end - start + 1
# sum of arithmatic progression, given first and last term and number of terms = n * (first + last) / 2
summ += (n * (start + end)) // 2
# decrease k since we have added n terms
k -= n
return summ | append-k-integers-with-minimal-sum | Python | Arithmetic Progression with Explanation | rbhandu | 0 | 25 | append k integers with minimal sum | 2,195 | 0.25 | Medium | 30,512 |
https://leetcode.com/problems/append-k-integers-with-minimal-sum/discuss/1823793/Could-some-one-tell-why-my-code-is-too-slow | class Solution:
def minimalKSum(self, A: List[int], k: int) -> int:
ans=0
maxi=max(A)
temp=[]
A=set(A)
for i in range(1,maxi):
if i not in A:
temp.append(i)
if len(temp)> k :
return sum(temp[:k])
elif len(temp)==k:
return sum(temp)
else:
ans=sum(temp)
diff=k-len(temp)
ans+=((maxi+diff)*(maxi+1+diff)/2)-((maxi)*(maxi+1)/2)
return(int(ans)) | append-k-integers-with-minimal-sum | Could some one tell why my code is too slow ?? | amit_upadhyay | 0 | 16 | append k integers with minimal sum | 2,195 | 0.25 | Medium | 30,513 |
https://leetcode.com/problems/append-k-integers-with-minimal-sum/discuss/1823642/Python-or-Sort-before-traverse-or-Greedy-or-Easy-Understanding | class Solution:
def minimalKSum(self, nums: List[int], k: int) -> int:
nums.sort()
n = len(nums)
result = 0
if nums[0] > k:
return self.calSum(0, k+1)
if nums[0] != 1:
k -= (nums[0] - 1)
result += self.calSum(0, nums[0])
for i in range(n-1):
numOfCandidates = nums[i+1] - nums[i] -1
if numOfCandidates >= 1:
if numOfCandidates >= k:
result += self.calSum(nums[i], nums[i] + k +1)
k = 0
return result
elif numOfCandidates < k:
k -= numOfCandidates
result += self.calSum(nums[i], nums[i+1])
if k > 0:
result += self.calSum(nums[-1], nums[-1] +k+1)
return result
# calculate the sum between start and end, both exclude
def calSum(self, start, end):
return int((end + start) / 2 * (end -start -1)) | append-k-integers-with-minimal-sum | Python | Sort before traverse | Greedy | Easy Understanding | Mikey98 | 0 | 50 | append k integers with minimal sum | 2,195 | 0.25 | Medium | 30,514 |
https://leetcode.com/problems/create-binary-tree-from-descriptions/discuss/1823644/Python3-simulation | class Solution:
def createBinaryTree(self, descriptions: List[List[int]]) -> Optional[TreeNode]:
mp = {}
seen = set()
for p, c, left in descriptions:
if p not in mp: mp[p] = TreeNode(p)
if c not in mp: mp[c] = TreeNode(c)
if left: mp[p].left = mp[c]
else: mp[p].right = mp[c]
seen.add(c)
for p, _, _ in descriptions:
if p not in seen: return mp[p] | create-binary-tree-from-descriptions | [Python3] simulation | ye15 | 8 | 191 | create binary tree from descriptions | 2,196 | 0.722 | Medium | 30,515 |
https://leetcode.com/problems/create-binary-tree-from-descriptions/discuss/1823678/Python-Solution-using-HashMap-with-Steps | class Solution:
def createBinaryTree(self, descriptions: List[List[int]]) -> Optional[TreeNode]:
root = None
table = {}
for arr in descriptions:
parent = arr[0]
child = arr[1]
isleft = arr[2]
if table.get(parent, None) is None: # If key parent does not exist in table
table[parent] = [TreeNode(parent), False]
if table.get(child, None) is None: If key child does not exist in table
table[child] = [TreeNode(child), False]
table[child][1] = True # Since child is going to have a parent in the current iteration, set its has parent property to True
if isleft == 1:
table[parent][0].left = table[child][0]
else:
table[parent][0].right = table[child][0]
# Now traverse the hashtable and check which node still has no parent
for k, v in table.items():
if not v[1]: # Has parent is False, so root is found.
root = k
break
return table[root][0] | create-binary-tree-from-descriptions | Python Solution using HashMap with Steps | anCoderr | 5 | 280 | create binary tree from descriptions | 2,196 | 0.722 | Medium | 30,516 |
https://leetcode.com/problems/create-binary-tree-from-descriptions/discuss/1966088/Python-Faster-then-100-solution | class Solution:
def createBinaryTree(self, descriptions: List[List[int]]) -> Optional[TreeNode]:
tree = dict()
children = set()
for parent, child, isLeft in descriptions:
if parent not in tree : tree[parent] = TreeNode(parent)
if child not in tree : tree[child] = TreeNode(child)
if isLeft : tree[parent].left = tree[child]
else : tree[parent].right = tree[child]
children.add(child)
for parent in tree:
if parent not in children:
return tree[parent] | create-binary-tree-from-descriptions | [ Python ] Faster then 100% solution | crazypuppy | 3 | 119 | create binary tree from descriptions | 2,196 | 0.722 | Medium | 30,517 |
https://leetcode.com/problems/create-binary-tree-from-descriptions/discuss/2162621/Python3-Solution-with-using-hashmap-and-hashset | class Solution:
def createBinaryTree(self, descriptions: List[List[int]]) -> Optional[TreeNode]:
val2node = {}
child_set = set()
parent_set = set()
for parent_val, child_val, is_left in descriptions:
if child_val not in val2node:
val2node[child_val] = TreeNode(child_val)
if parent_val not in val2node:
val2node[parent_val] = TreeNode(parent_val)
if is_left == 1:
val2node[parent_val].left = val2node[child_val]
else:
val2node[parent_val].right = val2node[child_val]
child_set.add(child_val)
parent_set.discard(child_val)
if parent_val not in child_set:
parent_set.add(parent_val)
else:
parent_set.discard(parent_val)
return val2node[parent_set.pop()] | create-binary-tree-from-descriptions | [Python3] Solution with using hashmap and hashset | maosipov11 | 1 | 26 | create binary tree from descriptions | 2,196 | 0.722 | Medium | 30,518 |
https://leetcode.com/problems/create-binary-tree-from-descriptions/discuss/1823788/Treat-it-as-a-DAG-%2B-Kahn's-Topo-Algorithm-with-Images-or-Easy-to-understand | class Solution:
def construct_graph_and_indegree(self, descriptions):
g = {}
in_degree = {}
for parent, child, is_left in descriptions:
if parent not in g:
g[parent] = [None, None]
if child not in g:
g[child] = [None, None]
if parent not in in_degree: in_degree[parent] = 0
if child not in in_degree: in_degree[child] = 0
in_degree[child] += 1
# if is_left is true will be in 1st pos, else it will be inserted in right child
g[parent][is_left] = child
return [g, in_degree]
def createBinaryTree(self, descriptions: List[List[int]]) -> Optional[TreeNode]:
g, in_degree = self.construct_graph_and_indegree(descriptions)
root = None
for vertex, in_deg in in_degree.items():
if in_deg == 0:
root = vertex
break
root_node = TreeNode(root)
q = deque([root_node])
while q:
curr_node = q.popleft()
if g[curr_node.val][0]:
right_node = TreeNode(g[curr_node.val][0])
curr_node.right = right_node
q.append(right_node)
if g[curr_node.val][1]:
left_node = TreeNode(g[curr_node.val][1])
curr_node.left = left_node
q.append(left_node)
return root_node | create-binary-tree-from-descriptions | Treat it as a DAG + Kahn's Topo Algorithm with Images | Easy to understand | prudentprogrammer | 1 | 25 | create binary tree from descriptions | 2,196 | 0.722 | Medium | 30,519 |
https://leetcode.com/problems/create-binary-tree-from-descriptions/discuss/2817762/python | class Solution:
def createBinaryTree(self, descriptions: List[List[int]]) -> Optional[TreeNode]:
isRoot = {}
node = {}
for p, c, left in descriptions:
if p not in isRoot:
isRoot[p] = True
isRoot[c] = False
if p not in node:
node[p] = TreeNode(p)
if c not in node:
node[c] = TreeNode(c)
if left:
node[p].left = node[c]
else:
node[p].right = node[c]
for val, r in isRoot.items():
if r:
root = val
break
return node[root] | create-binary-tree-from-descriptions | python | xy01 | 0 | 1 | create binary tree from descriptions | 2,196 | 0.722 | Medium | 30,520 |
https://leetcode.com/problems/create-binary-tree-from-descriptions/discuss/2476696/Using-set-and-hashmap-and-BFS.-Python-solution | class Solution:
def createBinaryTree(self, descriptions: List[List[int]]) -> Optional[TreeNode]:
parents = set()
children = set()
for i in descriptions:
parents.add(i[0])
children.add(i[1])
rootvalue = list(parents-children)[0]#root node
parentlist = {}
for desc in descriptions:
if desc[0] not in parentlist:
parentlist[desc[0]] = [[desc[1], desc[2]]]
else:
parentlist[desc[0]] +=[[desc[1], desc[2]]]
root = TreeNode(val=rootvalue)
queue = [root]
while len(queue)>0:
node = queue.pop(0)
if node.val in parentlist:
children = parentlist[node.val]
for i in children:
if i[1]==1:
node.left = TreeNode(i[0])
queue.append(node.left)
else:
node.right = TreeNode(i[0])
queue.append(node.right)
return root | create-binary-tree-from-descriptions | Using set and hashmap and BFS. Python solution | Arana | 0 | 26 | create binary tree from descriptions | 2,196 | 0.722 | Medium | 30,521 |
https://leetcode.com/problems/create-binary-tree-from-descriptions/discuss/2164765/Python3-solution-with-dictionary-and-sets | class Solution:
def createBinaryTree(self, descriptions: List[List[int]]) -> Optional[TreeNode]:
dicts={}
set1=set()
set2=set()
for i in range(len(descriptions)):
set1.add(descriptions[i][0])
set2.add(descriptions[i][1])
if descriptions[i][0] not in dicts.keys():
dicts[descriptions[i][0]] = TreeNode(descriptions[i][0])
if descriptions[i][1] not in dicts.keys():
dicts[descriptions[i][1]] = TreeNode(descriptions[i][1])
if descriptions[i][2] == 1:
dicts[descriptions[i][0]].left = dicts[descriptions[i][1]]
else:
dicts[descriptions[i][0]].right = dicts[descriptions[i][1]]
asd=set1-set2
return dicts[asd.pop()] | create-binary-tree-from-descriptions | Python3 solution with dictionary and sets | chandkommanaboyina | 0 | 43 | create binary tree from descriptions | 2,196 | 0.722 | Medium | 30,522 |
https://leetcode.com/problems/create-binary-tree-from-descriptions/discuss/2068306/Python-80-easy-understanding | class Solution:
def createBinaryTree(self, d: List[List[int]]) -> Optional[TreeNode]:
h = {n : [-1,-1] for _,n,_ in d}
r = None
for p, c, l in d:
if p not in h:
r = p
h[p] = [-1,-1]
if l == 1:
h[p][0] = c
else:
h[p][1] = c
return self.b(h,r)
def b(self,h,r):
if r == -1:
return None
root = TreeNode(r)
root.left = self.b(h,h[r][0])
root.right = self.b(h,h[r][1])
return root | create-binary-tree-from-descriptions | Python 80% easy understanding | shuchen666 | 0 | 60 | create binary tree from descriptions | 2,196 | 0.722 | Medium | 30,523 |
https://leetcode.com/problems/create-binary-tree-from-descriptions/discuss/2040600/Python-Solution | class Solution:
def createBinaryTree(self, descriptions: List[List[int]]) -> Optional[TreeNode]:
root = None
nodes = {}
for parent, child, isLeft in descriptions:
if parent not in nodes:
nodes[parent] = [TreeNode(parent), None]
if child not in nodes:
nodes[child] = [TreeNode(child), None]
if isLeft == 1:
nodes[parent][0].left = nodes[child][0]
nodes[child][1] = parent
if isLeft == 0:
nodes[parent][0].right = nodes[child][0]
nodes[child][1] = parent
for key in nodes:
if nodes[key][1] == None:
root = nodes[key][0]
return root | create-binary-tree-from-descriptions | Python Solution | b160106 | 0 | 25 | create binary tree from descriptions | 2,196 | 0.722 | Medium | 30,524 |
https://leetcode.com/problems/create-binary-tree-from-descriptions/discuss/1886416/Python-using-hashmap-and-dict%3A%3Asetdefault.-Simple-solution | class Solution:
def createBinaryTree(self, descriptions: List[List[int]]) -> Optional[TreeNode]:
map_val_to_node = {}
map_child_to_parent = {}
for p_val, c_val, is_left in descriptions:
parent_node = map_val_to_node.setdefault(p_val, TreeNode(p_val))
child_node = map_val_to_node.setdefault(c_val, TreeNode(c_val))
map_child_to_parent[child_node] = parent_node
if is_left:
parent_node.left = child_node
else:
parent_node.right = child_node
root = parent_node
while root in map_child_to_parent:
root = map_child_to_parent[root]
return root | create-binary-tree-from-descriptions | Python using hashmap and dict::setdefault. Simple solution | sEzio | 0 | 48 | create binary tree from descriptions | 2,196 | 0.722 | Medium | 30,525 |
https://leetcode.com/problems/create-binary-tree-from-descriptions/discuss/1877862/python-simple-O(n)-time-O(n)-space-solution-using-hashmap-and-indegree-array | class Solution:
def createBinaryTree(self, descriptions: List[List[int]]) -> Optional[TreeNode]:
nodes = {}
indeg = defaultdict(int)
for parent, child, left in descriptions:
indeg[child] += 1
if parent not in nodes:
nodes[parent] = TreeNode(parent)
if child not in nodes:
nodes[child] = TreeNode(child)
parent_node = nodes[parent]
child_node = nodes[child]
if left == 1:
parent_node.left = child_node
else: # left == 0
parent_node.right = child_node
root = None
for node in nodes:
if indeg[node] == 0:
root = nodes[node]
return root | create-binary-tree-from-descriptions | python simple O(n) time, O(n) space solution using hashmap and indegree array | byuns9334 | 0 | 50 | create binary tree from descriptions | 2,196 | 0.722 | Medium | 30,526 |
https://leetcode.com/problems/create-binary-tree-from-descriptions/discuss/1834279/Create-new-nodes-row-by-row-82-speed | class Solution:
def createBinaryTree(self, descriptions: List[List[int]]) -> Optional[TreeNode]:
left_i, right_i, ref = 0, 1, 2
children, all_nodes = set(), set()
nodes = dict()
for parent, child, is_left in descriptions:
all_nodes.add(parent)
all_nodes.add(child)
children.add(child)
if parent in nodes:
nodes[parent][1 - is_left] = child
else:
nodes[parent] = [0, 0, None]
nodes[parent][1 - is_left] = child
root_val = (all_nodes - children).pop()
root = TreeNode(root_val)
nodes[root_val][ref] = root
row = {root_val}
while row:
new_row = set()
for v in row:
if v in nodes:
left_val, right_val, node_ref = nodes[v]
if left_val:
node_ref.left = TreeNode(left_val)
if left_val in nodes:
nodes[left_val][ref] = node_ref.left
new_row.add(left_val)
if right_val:
node_ref.right = TreeNode(right_val)
if right_val in nodes:
nodes[right_val][ref] = node_ref.right
new_row.add(right_val)
row = new_row
return root | create-binary-tree-from-descriptions | Create new nodes row by row, 82% speed | EvgenySH | 0 | 20 | create binary tree from descriptions | 2,196 | 0.722 | Medium | 30,527 |
https://leetcode.com/problems/create-binary-tree-from-descriptions/discuss/1826980/Python-bfs-solution | class Solution:
def createBinaryTree(self, descriptions: List[List[int]]) -> Optional[TreeNode]:
par,child=set(),set()
d=defaultdict(lambda : [0,0])
for n in descriptions:
if n[2]==1:
d[n[0]][0]=n[1]
else:
d[n[0]][1]=n[1]
par.add(n[0])
child.add(n[1])
main=list(par-child).pop()
q=deque()
root=TreeNode(main)
q.append(root)
while q:
for i in range(len(q)):
node=q.popleft()
if d[node.val][0]!=0:
node.left=TreeNode(d[node.val][0])
q.append(node.left)
if d[node.val][1]!=0:
node.right=TreeNode(d[node.val][1])
q.append(node.right)
return root | create-binary-tree-from-descriptions | Python bfs solution | amlanbtp | 0 | 32 | create binary tree from descriptions | 2,196 | 0.722 | Medium | 30,528 |
https://leetcode.com/problems/create-binary-tree-from-descriptions/discuss/1824275/Python-3-or-HashMap-O(N)-or-Explanation | class Solution:
def createBinaryTree(self, descriptions: List[List[int]]) -> Optional[TreeNode]:
d = dict()
s = set()
for par, child, is_left in descriptions:
s.add(child)
if par not in d:
d[par] = TreeNode(par)
if child not in d:
d[child] = TreeNode(child)
if is_left:
d[par].left = d[child]
else:
d[par].right = d[child]
root = set(d.keys()) - s
return d[root.pop()] | create-binary-tree-from-descriptions | Python 3 | HashMap, O(N) | Explanation | idontknoooo | 0 | 49 | create binary tree from descriptions | 2,196 | 0.722 | Medium | 30,529 |
https://leetcode.com/problems/create-binary-tree-from-descriptions/discuss/1823818/Python3-O(nlogn)-DictionaryHashmap | class Solution:
def createBinaryTree(self, descriptions: List[List[int]]) -> Optional[TreeNode]:
node_dict = defaultdict(TreeNode)
ins = defaultdict(int)
for p, c, isleft in descriptions:
ins[p] = ins[p]
ins[c] += 1
node_dict.setdefault(p, TreeNode(p))
node_dict.setdefault(c, TreeNode(c))
if isleft:
node_dict[p].left = node_dict[c]
else:
node_dict[p].right = node_dict[c]
return node_dict[min((indegree, node) for node, indegree in ins.items())[1]] | create-binary-tree-from-descriptions | [Python3] O(nlogn) - Dictionary/Hashmap | dwschrute | 0 | 20 | create binary tree from descriptions | 2,196 | 0.722 | Medium | 30,530 |
https://leetcode.com/problems/replace-non-coprime-numbers-in-array/discuss/1825538/Python-3-Stack-solution | class Solution:
def replaceNonCoprimes(self, nums: List[int]) -> List[int]:
stack = nums[:1]
for j in range(1, len(nums)):
cur = nums[j]
while stack and math.gcd(stack[-1], cur) > 1:
prev = stack.pop()
cur = math.lcm(prev, cur)
stack.append(cur)
return stack | replace-non-coprime-numbers-in-array | [Python 3] Stack solution | chestnut890123 | 2 | 125 | replace non coprime numbers in array | 2,197 | 0.387 | Hard | 30,531 |
https://leetcode.com/problems/replace-non-coprime-numbers-in-array/discuss/1823742/Python3-stack | class Solution:
def replaceNonCoprimes(self, nums: List[int]) -> List[int]:
stack = []
for x in nums:
while stack and gcd(stack[-1], x) > 1: x = lcm(x, stack.pop())
stack.append(x)
return stack | replace-non-coprime-numbers-in-array | [Python3] stack | ye15 | 2 | 113 | replace non coprime numbers in array | 2,197 | 0.387 | Hard | 30,532 |
https://leetcode.com/problems/replace-non-coprime-numbers-in-array/discuss/2799444/Python-in-place-(O(1)-space) | class Solution:
def replaceNonCoprimes(self, nums: List[int]) -> List[int]:
i = 0
while i < len(nums) - 1:
gcd = math.gcd(nums[i], nums[i + 1])
if gcd > 1:
nums[i] = abs(nums[i] * nums[i + 1]) // gcd # lcm
del nums[i + 1]
i = max(0, i - 1)
else:
i += 1
return nums | replace-non-coprime-numbers-in-array | Python in place (O(1) space) | user2341El | 0 | 4 | replace non coprime numbers in array | 2,197 | 0.387 | Hard | 30,533 |
https://leetcode.com/problems/replace-non-coprime-numbers-in-array/discuss/2742419/Python3-O(N)-time-O(N)-Space-Stack | class Solution:
def replaceNonCoprimes(self, nums: List[int]) -> List[int]:
stack = []
for idx in range(len(nums)):
cur_num = nums[idx]
while len(stack) > 0:
cur_gcd = self.calculate_gcd(numA=stack[-1], numB=cur_num)
if cur_gcd > 1:
cur_num = self.calculate_lcm(gcd=cur_gcd, numA=stack[-1], numB=cur_num)
stack.pop()
else:
break
stack.append(cur_num)
return stack
def calculate_gcd(self, numA: int, numB: int) -> int:
while numA > 0 and numB > 0:
if numA == numB:
return numA
if numA > numB:
numA %= numB
else:
numB %= numA
if numA > 0:
return numA
return numB
def calculate_lcm(self, gcd: int, numA: int, numB: int) -> int:
return (numA * numB) // gcd | replace-non-coprime-numbers-in-array | [Python3] O(N) time, O(N) Space, Stack | SoluMilken | 0 | 6 | replace non coprime numbers in array | 2,197 | 0.387 | Hard | 30,534 |
https://leetcode.com/problems/replace-non-coprime-numbers-in-array/discuss/2013948/Python-Stack-Clean-and-Simple! | class Solution:
def replaceNonCoprimes(self, nums):
stack = []
for num in nums:
while stack and gcd(num,stack[-1]) >= 2:
num = lcm(num,stack[-1])
stack.pop()
stack.append(num)
return stack | replace-non-coprime-numbers-in-array | Python - Stack - Clean and Simple! | domthedeveloper | 0 | 116 | replace non coprime numbers in array | 2,197 | 0.387 | Hard | 30,535 |
https://leetcode.com/problems/replace-non-coprime-numbers-in-array/discuss/1830696/One-pass-with-stack-97-speed | class Solution:
def replaceNonCoprimes(self, nums: List[int]) -> List[int]:
stack = []
for n in nums:
if not stack:
stack.append(n)
else:
last_gcd = gcd(stack[-1], n)
while last_gcd > 1:
stack[-1] *= n
stack[-1] //= last_gcd
if len(stack) > 1:
n = stack.pop()
last_gcd = gcd(stack[-1], n)
else:
break
else:
stack.append(n)
return stack | replace-non-coprime-numbers-in-array | One pass with stack, 97% speed | EvgenySH | 0 | 53 | replace non coprime numbers in array | 2,197 | 0.387 | Hard | 30,536 |
https://leetcode.com/problems/replace-non-coprime-numbers-in-array/discuss/1823799/Python3-One-pass | class Solution:
def replaceNonCoprimes(self, nums: List[int]) -> List[int]:
if len(nums) == 1: return nums
@cache
def compute_gcd(x, y) -> int:
while y:
x, y = y, x % y
return x
@cache
def compute_lcm(x, y) -> int:
r = (x*y)//compute_gcd(x,y)
return r
i, j = 0, 1
while j < len(nums):
if compute_gcd(min(nums[i],nums[j]), max(nums[i],nums[j])) != 1:
nums[i]=compute_lcm(min(nums[i],nums[j]), max(nums[i],nums[j]))
nums.pop(j)
if i != 0:
i-=1
j-=1
else:
i+=1
j+=1
return nums | replace-non-coprime-numbers-in-array | [Python3] One pass | SHaaD94 | 0 | 25 | replace non coprime numbers in array | 2,197 | 0.387 | Hard | 30,537 |
https://leetcode.com/problems/find-all-k-distant-indices-in-an-array/discuss/2171271/Python-easy-to-understand-oror-Beginner-friendly | class Solution:
def findKDistantIndices(self, nums: List[int], key: int, k: int) -> List[int]:
ind_j = []
for ind, elem in enumerate(nums):
if elem == key:
ind_j.append(ind)
res = []
for i in range(len(nums)):
for j in ind_j:
if abs(i - j) <= k:
res.append(i)
break
return sorted(res) | find-all-k-distant-indices-in-an-array | ✅Python easy to understand || Beginner friendly | Shivam_Raj_Sharma | 4 | 147 | find all k distant indices in an array | 2,200 | 0.646 | Easy | 30,538 |
https://leetcode.com/problems/find-all-k-distant-indices-in-an-array/discuss/1844619/O(N)-two-pass-solution-in-Python | class Solution:
def findKDistantIndices(self, nums: List[int], key: int, k: int) -> List[int]:
keys = [-math.inf] + [idx for idx, num in enumerate(nums) if num == key] + [math.inf]
N = len(nums)
res = []
left = 0
for i in range(N):
if i - keys[left] <= k or keys[left + 1] - i <= k:
res.append(i)
if keys[left + 1] == i:
left += 1
return res | find-all-k-distant-indices-in-an-array | O(N) two-pass solution in Python | kryuki | 3 | 390 | find all k distant indices in an array | 2,200 | 0.646 | Easy | 30,539 |
https://leetcode.com/problems/find-all-k-distant-indices-in-an-array/discuss/1886150/python-3-oror-O(n)-O(1) | class Solution:
def findKDistantIndices(self, nums: List[int], key: int, k: int) -> List[int]:
res = []
high = -1
n = len(nums)
for i, num in enumerate(nums):
if num == key:
for j in range(max(high + 1, i - k), min(n, i + k + 1)):
res.append(j)
high = i + k
return res | find-all-k-distant-indices-in-an-array | python 3 || O(n) / O(1) | dereky4 | 1 | 102 | find all k distant indices in an array | 2,200 | 0.646 | Easy | 30,540 |
https://leetcode.com/problems/find-all-k-distant-indices-in-an-array/discuss/1846739/Python3-scan | class Solution:
def findKDistantIndices(self, nums: List[int], key: int, k: int) -> List[int]:
ans = []
ii = 0
for i, x in enumerate(nums):
if x == key:
lo, hi = max(ii, i-k), min(i+k+1, len(nums))
ans.extend(list(range(lo, hi)))
ii = hi
return ans | find-all-k-distant-indices-in-an-array | [Python3] scan | ye15 | 1 | 27 | find all k distant indices in an array | 2,200 | 0.646 | Easy | 30,541 |
https://leetcode.com/problems/find-all-k-distant-indices-in-an-array/discuss/1844400/Python-5-lines | class Solution:
def findKDistantIndices(self, nums: List[int], key: int, k: int) -> List[int]:
ans = set()
for i, num in enumerate(nums):
if num == key:
ans.update(range(max(0, i-k), min(i+k+1, len(nums))))
return sorted(list(res)) | find-all-k-distant-indices-in-an-array | Python 5 lines | trungnguyen276 | 1 | 170 | find all k distant indices in an array | 2,200 | 0.646 | Easy | 30,542 |
https://leetcode.com/problems/find-all-k-distant-indices-in-an-array/discuss/1844137/Clean-Python-Brute-Force-Solution | class Solution:
def findKDistantIndices(self, nums: List[int], key: int, k: int) -> List[int]:
n, ans = len(nums), []
keys_index = [i for i in range(n) if nums[i] == key] # Holds the indices of all elements equal to key.
m = len(keys_index)
for i in range(n):
for j in range(m):
if abs(i - keys_index[j]) <= k: # If the conditions are met then add ith index to the answer array.
ans.append(i)
break
return sorted(ans) # Return sorted ans according to problem | find-all-k-distant-indices-in-an-array | Clean Python Brute Force Solution | anCoderr | 1 | 81 | find all k distant indices in an array | 2,200 | 0.646 | Easy | 30,543 |
https://leetcode.com/problems/find-all-k-distant-indices-in-an-array/discuss/2789398/Naive-Approach | class Solution:
def findKDistantIndices(self, nums: List[int], key: int, k: int) -> List[int]:
# k distant index is an index difference that
# doesn't exceed k and the value at the index
# is the key
# it's important to maintain order of nums
# you only care about the key at that pos
# find locations of the key and iterate through nums
# to find values of i (can be flipped w/ j because of abs)
# if i - j is less k append i to res and sort it afterwards
# time O(n ^ 2) spcae O(n)
res = set()
indices = []
n = len(nums)
for i, num in enumerate(nums):
if num == key:
indices.append(i)
for key_idx in indices:
for i in range(n):
if abs(i - key_idx) <= k:
res.add(i)
return sorted(res) | find-all-k-distant-indices-in-an-array | Naive Approach | andrewnerdimo | 0 | 1 | find all k distant indices in an array | 2,200 | 0.646 | Easy | 30,544 |
https://leetcode.com/problems/find-all-k-distant-indices-in-an-array/discuss/2385058/Ugly-but-faster-than-97 | class Solution:
def findKDistantIndices(self, nums: List[int], key: int, k: int) -> List[int]:
keys = []
l=len(nums)
for i in range(l):
if nums[i]==key:
keys.append(i)
j=0
i=0
c=[]
l_k=len(keys)
while i<l:
if abs(i-keys[j]) <= k:
c.append(i)
if i-keys[j]==k:
j+=1
if j==l_k:
break
i+=1
return c | find-all-k-distant-indices-in-an-array | Ugly but faster than 97% | sunakshi132 | 0 | 25 | find all k distant indices in an array | 2,200 | 0.646 | Easy | 30,545 |
https://leetcode.com/problems/find-all-k-distant-indices-in-an-array/discuss/1975087/Python3-Sliding-window-O(N)-beats-98 | class Solution:
def findKDistantIndices(self, nums: List[int], key: int, k: int) -> List[int]:
result = []
n = len(nums)
window_start = 0
num_freq = {}
# create a window of size k
for window_end in range(min(k, n)):
right_num = nums[window_end]
num_freq[right_num] = num_freq.get(right_num, 0) + 1
# loop on each index and expand the window to the right if possible
# and shrink it from the left if necessary
for i in range(n):
if window_end + 1 < n:
window_end += 1
right_num = nums[window_end]
num_freq[right_num] = num_freq.get(right_num, 0) + 1
if i - window_start > k:
left_num = nums[window_start]
num_freq[left_num] -= 1
if num_freq[left_num] == 0:
num_freq.pop(left_num)
window_start += 1
if key in num_freq:
result.append(i)
return result | find-all-k-distant-indices-in-an-array | [Python3] Sliding window O(N), beats 98% | mostafaa | 0 | 67 | find all k distant indices in an array | 2,200 | 0.646 | Easy | 30,546 |
https://leetcode.com/problems/find-all-k-distant-indices-in-an-array/discuss/1944117/Python-dollarolution-(97-Faster) | class Solution:
def findKDistantIndices(self, nums: List[int], key: int, k: int) -> List[int]:
v = []
for i in range(len(nums)):
if key == nums[i]:
v.append(i)
j, i = 0, 0
l = []
while i < len(nums):
if abs(v[j]-i) > k:
if v[j] < i:
j += 1
if j > len(v)-1:
break
else:
i += 1
continue
l.append(i)
i += 1
return l | find-all-k-distant-indices-in-an-array | Python $olution (97% Faster) | AakRay | 0 | 50 | find all k distant indices in an array | 2,200 | 0.646 | Easy | 30,547 |
https://leetcode.com/problems/find-all-k-distant-indices-in-an-array/discuss/1860190/Python-easy-solution | class Solution:
def findKDistantIndices(self, nums: List[int], key: int, k: int) -> List[int]:
res = set()
n = len(nums)
for i in range(n):
if nums[i] == key:
for x in range(max(i-k, 0), min(i+k, n-1)+1):
res.add(x)
return list(res) | find-all-k-distant-indices-in-an-array | Python easy solution | byuns9334 | 0 | 50 | find all k distant indices in an array | 2,200 | 0.646 | Easy | 30,548 |
https://leetcode.com/problems/find-all-k-distant-indices-in-an-array/discuss/1854536/5-Lines-Python-Solution-oror-90-Faster-oror-Memory-less-than-98 | class Solution:
def findKDistantIndices(self, nums: List[int], key: int, k: int) -> List[int]:
J = [i for i,x in enumerate(nums) if x==key] ; ans=[]
for i in range(len(nums)):
for j in J:
if abs(i-j)<=k: ans.append(i) ; break
return ans | find-all-k-distant-indices-in-an-array | 5-Lines Python Solution || 90% Faster || Memory less than 98% | Taha-C | 0 | 94 | find all k distant indices in an array | 2,200 | 0.646 | Easy | 30,549 |
https://leetcode.com/problems/find-all-k-distant-indices-in-an-array/discuss/1854536/5-Lines-Python-Solution-oror-90-Faster-oror-Memory-less-than-98 | class Solution:
def findKDistantIndices(self, nums: List[int], key: int, k: int) -> List[int]:
J = [i for i,x in enumerate(nums) if x==key]
for i in range(len(nums)):
for j in J:
if abs(i-j)<=k: yield i ; break | find-all-k-distant-indices-in-an-array | 5-Lines Python Solution || 90% Faster || Memory less than 98% | Taha-C | 0 | 94 | find all k distant indices in an array | 2,200 | 0.646 | Easy | 30,550 |
https://leetcode.com/problems/find-all-k-distant-indices-in-an-array/discuss/1851691/List-extend-no-sorting-94-speed | class Solution:
def findKDistantIndices(self, nums: List[int], key: int, k: int) -> List[int]:
len_nums = len(nums)
ans = list()
last = 0
for i, n in enumerate(nums):
if n == key:
ans.extend(range(max(i - k, last), min(i + k + 1, len_nums)))
last = i + k + 1
return ans | find-all-k-distant-indices-in-an-array | List extend, no sorting, 94% speed | EvgenySH | 0 | 28 | find all k distant indices in an array | 2,200 | 0.646 | Easy | 30,551 |
https://leetcode.com/problems/find-all-k-distant-indices-in-an-array/discuss/1848678/Python-100-Time-and-100-Space-or-Proof-Attached | class Solution:
def findKDistantIndices(self, nums: List[int], key: int, k: int) -> List[int]:
res = []
start =end = 0
for i in range(len(nums)):
if nums[i] == key:
if i - k < end:
start = end
else:
start = i - k
if i+k+1 > len(nums):
end = len(nums)
else:
end = i + k + 1
for j in range(start,end):
res.append(j)
return res | find-all-k-distant-indices-in-an-array | Python 100% Time and 100% Space | Proof Attached | vedank98 | 0 | 43 | find all k distant indices in an array | 2,200 | 0.646 | Easy | 30,552 |
https://leetcode.com/problems/find-all-k-distant-indices-in-an-array/discuss/1847224/Python3-One-Pass-or-6-Lines | class Solution:
def findKDistantIndices(self, nums: List[int], key: int, k: int) -> List[int]:
N, res = len(nums), deque([-1])
for j, num in enumerate(nums):
if num == key:
res.extend(i for i in range(max(res[-1] + 1, j - k), min(N, j + k + 1)))
res.popleft()
return res | find-all-k-distant-indices-in-an-array | [Python3] One Pass | 6 Lines | PatrickOweijane | 0 | 33 | find all k distant indices in an array | 2,200 | 0.646 | Easy | 30,553 |
https://leetcode.com/problems/find-all-k-distant-indices-in-an-array/discuss/1845621/Simple-Python-Solution-or-With-Sorting | class Solution:
def findKDistantIndices(self, nums: List[int], key: int, k: int) -> List[int]:
output = set()
for i, n in enumerate(nums):
if n == key:
# Move right
for j in range(i, len(nums)):
if abs(i - j) <= k:
output.add(j)
else:
break
# Move left
for j in range(i - 1, -1, -1):
if abs(i - j) <= k:
output.add(j)
else:
break
if len(output) == len(nums):
break
output = list(output)
output.sort()
return output | find-all-k-distant-indices-in-an-array | ✅ Simple Python Solution | With Sorting | chetankalra11 | 0 | 12 | find all k distant indices in an array | 2,200 | 0.646 | Easy | 30,554 |
https://leetcode.com/problems/find-all-k-distant-indices-in-an-array/discuss/1844804/Python-using-range | class Solution:
def findKDistantIndices(self, nums: List[int], key: int, k: int) -> List[int]:
result = []
for i, n in enumerate(nums):
if n == key:
result.extend(range(max(0 if not result else result[-1]+1, i-k), min(i+k+1, len(nums))))
return result | find-all-k-distant-indices-in-an-array | Python, using range | blue_sky5 | 0 | 31 | find all k distant indices in an array | 2,200 | 0.646 | Easy | 30,555 |
https://leetcode.com/problems/find-all-k-distant-indices-in-an-array/discuss/1844513/O(n)-Python-Simple-Solution-(5-lines)-or-Explained | class Solution:
def findKDistantIndices(self, nums: List[int], key: int, k: int) -> List[int]:
k_distant_indices = set()
for num_index, num in enumerate(nums):
if num == key or key in nums[max(0,num_index-k):min(len(nums),num_index+k+1)]:
k_distant_indices.add(num_index)
return k_distant_indices | find-all-k-distant-indices-in-an-array | O(n) Python Simple Solution (5 lines) | Explained | Math_Prandini | 0 | 15 | find all k distant indices in an array | 2,200 | 0.646 | Easy | 30,556 |
https://leetcode.com/problems/find-all-k-distant-indices-in-an-array/discuss/1844434/python-or-python3 | class Solution:
def findKDistantIndices(self, nums: List[int], key: int, k: int) -> List[int]:
ans=[]
z=[]
for i in range(len(nums)):
if nums[i]==key:
z.append(i)
for i in z:
for j in range(i-k,i+k+1):
if (-1<j <= len(nums)-1) :
ans.append(j)
return sorted(list(set(ans))) | find-all-k-distant-indices-in-an-array | python | python3 | YaBhiThikHai | 0 | 22 | find all k distant indices in an array | 2,200 | 0.646 | Easy | 30,557 |
https://leetcode.com/problems/find-all-k-distant-indices-in-an-array/discuss/1844191/Short-elegant-Python-one-pass-solution-O(nk)-easy-to-understand-%2B-explanations | class Solution:
def findKDistantIndices(self, nums: List[int], key: int, k: int) -> List[int]:
# Time: O(nk) which at the worst case could be O(n^2)
# Space: O(n) because result will never exceed N values
res = set()
for index, num in enumerate(nums):
if num == key:
for i in range(max(0, index - k), min(len(nums), index + k + 1)):
res.add(i)
return list(res) | find-all-k-distant-indices-in-an-array | 💯 Short elegant Python one-pass solution O(nk), easy to understand + explanations | yangshun | 0 | 69 | find all k distant indices in an array | 2,200 | 0.646 | Easy | 30,558 |
https://leetcode.com/problems/count-artifacts-that-can-be-extracted/discuss/1844361/Python-elegant-short-and-simple-to-understand-with-explanations | class Solution:
def digArtifacts(self, n: int, artifacts: List[List[int]], dig: List[List[int]]) -> int:
# Time: O(max(artifacts, dig)) which is O(N^2) as every position in the grid can be in dig
# Space: O(dig) which is O(N^2)
result, dig_pos = 0, set(tuple(pos) for pos in dig)
for pos in artifacts:
if all((x, y) in dig_pos for x in range(pos[0], pos[2] + 1) for y in range(pos[1], pos[3] + 1)):
result += 1
return result | count-artifacts-that-can-be-extracted | 💯 Python elegant, short and simple to understand with explanations | yangshun | 6 | 352 | count artifacts that can be extracted | 2,201 | 0.551 | Medium | 30,559 |
https://leetcode.com/problems/count-artifacts-that-can-be-extracted/discuss/1844361/Python-elegant-short-and-simple-to-understand-with-explanations | class Solution:
def digArtifacts(self, n: int, artifacts: List[List[int]], dig: List[List[int]]) -> int:
pos_to_artifacts = {} # (x, y) => artifact unique index
artifacts_to_remaining = {} # artifact unique index to remaining spots for artifact to dig up
results = 0
# Each artifact is identified by a unique index.
for id, artifact in enumerate(artifacts):
start, end = (artifact[0], artifact[1]), (artifact[2], artifact[3])
size = 0
for x in range(start[0], end[0] + 1):
for y in range(start[1], end[1] + 1):
pos_to_artifacts[(x, y)] = id
size += 1
artifacts_to_remaining[id] = size
for pos in dig:
if tuple(pos) not in pos_to_artifacts:
continue
id = pos_to_artifacts[tuple(pos)]
artifacts_to_remaining[id] = artifacts_to_remaining[id] - 1
if artifacts_to_remaining[id] == 0:
results += 1
return results | count-artifacts-that-can-be-extracted | 💯 Python elegant, short and simple to understand with explanations | yangshun | 6 | 352 | count artifacts that can be extracted | 2,201 | 0.551 | Medium | 30,560 |
https://leetcode.com/problems/count-artifacts-that-can-be-extracted/discuss/1844168/Python-Solution-using-Matrix-and-Simple-Counting | class Solution:
def digArtifacts(self, n: int, artifacts: List[List[int]], dig: List[List[int]]) -> int:
grid, artifact_id = [[-1] * n for _ in range(n)], 0 # Making the grid
for r1, c1, r2, c2 in artifacts: # Populate the grid matrix
for r in range(r1, r2 + 1):
for c in range(c1, c2 + 1):
grid[r][c] = artifact_id
artifact_id += 1
for r, c in dig: # Change the grid row, col to -1 by traversing dig array.
if grid[r][c] >= 0:
grid[r][c] = -1
artifacts_remaining = set()
for r in range(n):
for c in range(n):
if grid[r][c] >= 0: # > 0 means that there still remains an artifact underneath, thus add it to the array
artifacts_remaining.add(grid[r][c])
return artifact_id - len(artifacts_remaining) | count-artifacts-that-can-be-extracted | Python Solution using Matrix and Simple Counting | anCoderr | 3 | 198 | count artifacts that can be extracted | 2,201 | 0.551 | Medium | 30,561 |
https://leetcode.com/problems/count-artifacts-that-can-be-extracted/discuss/1844345/Python-6-lines | class Solution:
def digArtifacts(self, n: int, artifacts: List[List[int]], dig: List[List[int]]) -> int:
dig = set((r, c) for r, c in dig)
ans = 0
for r0, c0, r1, c1 in artifacts:
if all((r, c) in dig for r in range(r0, r1 + 1) for c in range(c0, c1 + 1)):
ans += 1
return ans | count-artifacts-that-can-be-extracted | Python 6 lines | trungnguyen276 | 2 | 130 | count artifacts that can be extracted | 2,201 | 0.551 | Medium | 30,562 |
https://leetcode.com/problems/count-artifacts-that-can-be-extracted/discuss/1846781/Python3-enumerate | class Solution:
def digArtifacts(self, n: int, artifacts: List[List[int]], dig: List[List[int]]) -> int:
dig = {(x, y) for x, y in dig}
ans = 0
for i1, j1, i2, j2 in artifacts:
for i in range(i1, i2+1):
for j in range(j1, j2+1):
if (i, j) not in dig: break
else: continue
break
else: ans += 1
return ans | count-artifacts-that-can-be-extracted | [Python3] enumerate | ye15 | 1 | 18 | count artifacts that can be extracted | 2,201 | 0.551 | Medium | 30,563 |
https://leetcode.com/problems/count-artifacts-that-can-be-extracted/discuss/1846781/Python3-enumerate | class Solution:
def digArtifacts(self, n: int, artifacts: List[List[int]], dig: List[List[int]]) -> int:
grid = [[0]*n for _ in range(n)]
for i, j in dig: grid[i][j] = 1
prefix = [[0]*(n+1) for _ in range(n+1)]
for i in range(n):
for j in range(n):
prefix[i+1][j+1] = grid[i][j] + prefix[i][j+1] + prefix[i+1][j] - prefix[i][j]
ans = 0
for i1, j1, i2, j2 in artifacts:
area = prefix[i2+1][j2+1] - prefix[i2+1][j1] - prefix[i1][j2+1] + prefix[i1][j1]
if area == (i2-i1+1) * (j2-j1+1): ans += 1
return ans | count-artifacts-that-can-be-extracted | [Python3] enumerate | ye15 | 1 | 18 | count artifacts that can be extracted | 2,201 | 0.551 | Medium | 30,564 |
https://leetcode.com/problems/count-artifacts-that-can-be-extracted/discuss/2831348/Python-simple-solution | class Solution:
def digArtifacts(self, n: int, artifacts: List[List[int]], dig: List[List[int]]) -> int:
cells = {}
artMap = {}
for i in range(len(artifacts)):
x1, y1, x2, y2 = artifacts[i]
cells[i] = (x2 - x1 + 1) * (y2 - y1 + 1)
for j in range(x1, x2 + 1):
for k in range(y1, y2 + 1):
artMap[(j, k)] = i
result = 0
for x, y in dig:
if (x, y) in artMap:
cells[artMap[(x, y)]] -= 1
if cells[artMap[(x, y)]] == 0:
result += 1
return result | count-artifacts-that-can-be-extracted | Python, simple solution | swepln | 0 | 1 | count artifacts that can be extracted | 2,201 | 0.551 | Medium | 30,565 |
https://leetcode.com/problems/count-artifacts-that-can-be-extracted/discuss/2014470/Python3-Hashmap-Solution | class Solution:
def digArtifacts(self, n: int, artifacts: List[List[int]], dig: List[List[int]]) -> int:
counter = 0
dicts = {}
for a,b,c,d in artifacts:
for t in range(a, c+1):
for k in range(b, d+1):
dicts[(t,k)] = counter
counter += 1
for a,b in dig:
if (a,b) in dicts:
del dicts[(a,b)]
remain = set()
for value in dicts.values():
remain.add(value)
return len(artifacts) - len(remain) | count-artifacts-that-can-be-extracted | Python3 Hashmap Solution | xxHRxx | 0 | 46 | count artifacts that can be extracted | 2,201 | 0.551 | Medium | 30,566 |
https://leetcode.com/problems/count-artifacts-that-can-be-extracted/discuss/1995281/Python-Faster-than-81-of-other-submissions | class Solution:
def digArtifacts(self, n: int, artifact: List[List[int]], dig: List[List[int]]) -> int:
dig_set = set()
for i in dig:
dig_set.add(tuple(i))
count = 0
for afact in artifact:
flag = True
r1,c1,r2,c2 = afact
for i in range(r1,r2+1):
for j in range(c1,c2+1):
if (i,j) not in dig_set:
flag = False
break
if(flag == True):
count += 1
return count | count-artifacts-that-can-be-extracted | Python , Faster than 81% of other submissions | pragyagautam02 | 0 | 38 | count artifacts that can be extracted | 2,201 | 0.551 | Medium | 30,567 |
https://leetcode.com/problems/maximize-the-topmost-element-after-k-moves/discuss/1844186/Python-3-Find-Maximum-of-first-k-1-elements-or-(k%2B1)th-element-or-Beats-100 | class Solution:
def maximumTop(self, nums: List[int], k: int) -> int:
if len(nums) == 1:
if k%2 != 0:
return -1
return nums[0]
if k == 0:
return nums[0]
if k == len(nums):
return max(nums[:-1])
if k > len(nums):
return max(nums)
if k == 1:
return nums[1]
m = max(nums[:k-1])
m = max(m, nums[k])
return m | maximize-the-topmost-element-after-k-moves | [Python 3] Find Maximum of first k-1 elements or (k+1)th element | Beats 100% | hari19041 | 9 | 369 | maximize the topmost element after k moves | 2,202 | 0.228 | Medium | 30,568 |
https://leetcode.com/problems/maximize-the-topmost-element-after-k-moves/discuss/1844225/Python-Solution-by-Analyzing-All-Cases. | class Solution:
def maximumTop(self, nums: List[int], k: int) -> int:
n = len(nums)
if k == 0:
return nums[0]
if k == 1:
if n == 1:
return -1
else:
return nums[1]
if n == 1:
if k % 2 != 0:
return -1
else:
return nums[0]
if k - n - 1 >= 0:
return max(nums)
if n == k:
return max(nums[0:k - 1])
if n > k:
return max(max(nums[0:k - 1]), nums[k]) | maximize-the-topmost-element-after-k-moves | Python Solution by Analyzing All Cases. | anCoderr | 3 | 224 | maximize the topmost element after k moves | 2,202 | 0.228 | Medium | 30,569 |
https://leetcode.com/problems/maximize-the-topmost-element-after-k-moves/discuss/1844385/Python-9-lines | class Solution:
def maximumTop(self, nums: List[int], k: int) -> int:
if len(nums) == 1:
return -1 if k % 2 == 1 else nums[0]
if k <= 1:
return nums[k]
if k < len(nums):
return max(max(nums[:k-1]), nums[k])
if k < len(nums) + 2:
return max(nums[:k-1])
return max(nums) | maximize-the-topmost-element-after-k-moves | Python 9 lines | trungnguyen276 | 2 | 72 | maximize the topmost element after k moves | 2,202 | 0.228 | Medium | 30,570 |
https://leetcode.com/problems/maximize-the-topmost-element-after-k-moves/discuss/1846786/Python3-scan-the-array | class Solution:
def maximumTop(self, nums: List[int], k: int) -> int:
if len(nums) == 1 and k&1: return -1
ans = 0
for i in range(min(k-1, len(nums))): ans = max(ans, nums[i])
if k < len(nums): ans = max(ans, nums[k])
return ans | maximize-the-topmost-element-after-k-moves | [Python3] scan the array | ye15 | 1 | 24 | maximize the topmost element after k moves | 2,202 | 0.228 | Medium | 30,571 |
https://leetcode.com/problems/maximize-the-topmost-element-after-k-moves/discuss/1844637/Simulating-all-cases | class Solution:
def maximumTop(self, nums: List[int], k: int) -> int:
N = len(nums)
#edge cases
if N == 1 and k % 2 == 1:
return -1
if k == 0:
return nums[0]
if k > N:
return max(nums)
if k == N:
return max(nums[:N - 1])
#non-edge cases
return max(nums[:k - 1] + [nums[k]]) | maximize-the-topmost-element-after-k-moves | Simulating all cases | kryuki | 1 | 73 | maximize the topmost element after k moves | 2,202 | 0.228 | Medium | 30,572 |
https://leetcode.com/problems/maximize-the-topmost-element-after-k-moves/discuss/1844545/Easy-to-understand-solution-with-comments | class Solution:
def maximumTop(self, nums: List[int], k: int) -> int:
# made 0 moves so return top most element
if k == 0:
return nums[0]
n = len(nums)
# odd k won't work with len = 1 because we will end up empty array state
if n == 1:
return -1 if k % 2 != 0 else nums[0]
# we have a lot of moves so we can do anything to make sure the first element is always the max
if k > n:
return max(nums)
else: # k<=n scenario
# make sure you don't exceed the array size
upper_bound = min(n, k - 1)
# consider first k - 1 elements (aka upper bound)
# for kth index, we have the option to use the kth element if it's available (k < len(nums))
# or replace it with the previous seen max in which case we don't consider it
return max(nums[:upper_bound] + [nums[k] if k < n else float('-inf')]) | maximize-the-topmost-element-after-k-moves | Easy to understand solution with comments | prudentprogrammer | 1 | 27 | maximize the topmost element after k moves | 2,202 | 0.228 | Medium | 30,573 |
https://leetcode.com/problems/maximize-the-topmost-element-after-k-moves/discuss/1844147/Python3-simple-O(n)-solution | class Solution:
def maximumTop(self, nums: List[int], k: int) -> int:
n = len(nums)
if n == 1 and k%2 == 1:
return -1
if k == 0:
return nums[0]
if k == 1:
return nums[1]
if k > n:
return max(nums)
if k == n:
return max(nums[:k-1])
if k < n:
return max(max(nums[:k-1]),nums[k]) | maximize-the-topmost-element-after-k-moves | Python3 simple O(n) solution | Yihang-- | 1 | 52 | maximize the topmost element after k moves | 2,202 | 0.228 | Medium | 30,574 |
https://leetcode.com/problems/maximize-the-topmost-element-after-k-moves/discuss/2046477/python-3-oror-greedy-solution-oror-O(n)O(1) | class Solution:
def maximumTop(self, nums: List[int], k: int) -> int:
n = len(nums)
if n == 1:
return nums[0] if k % 2 == 0 else -1
return max(nums[i] for i in range(min(n, k + 1)) if i != k - 1) | maximize-the-topmost-element-after-k-moves | python 3 || greedy solution || O(n)/O(1) | dereky4 | 0 | 102 | maximize the topmost element after k moves | 2,202 | 0.228 | Medium | 30,575 |
https://leetcode.com/problems/maximize-the-topmost-element-after-k-moves/discuss/1849371/Python-Very-Easy-Solution-or-Explained | class Solution:
def maximumTop(self, nums: List[int], k: int) -> int:
if len(nums) <= 1 and k & 1: return -1 # Case 1: triggered
end = min(k-1, len(nums)) # If k is greater than len(nums), end = len(nums), because Case 2 is triggered, else case 3 is triggered, we still need to find max till k-1
maxi = max(nums[:end]) if k > 1 else 0 # we calculated the max element based on our end. k > 1 I have given to save from error, beacuse if k <= 1, spliced list will be empty.
kplusOne = nums[k % len(nums)] # this is for case 3, finding the k + 1 element, k +1 can give array index out of bound exception, so i did %
return max(maxi, kplusOne) # Case 3, we have to decide either we choose to put the max from removed or (k+1) element | maximize-the-topmost-element-after-k-moves | ✅ Python Very Easy Solution | Explained | dhananjay79 | 0 | 24 | maximize the topmost element after k moves | 2,202 | 0.228 | Medium | 30,576 |
https://leetcode.com/problems/minimum-weighted-subgraph-with-the-required-paths/discuss/1867689/Three-min-costs-to-every-node-97-speed | class Solution:
def minimumWeight(self, n: int, edges: List[List[int]], src1: int, src2: int, dest: int) -> int:
forward, backward = dict(), dict()
for start, end, weight in edges:
if start in forward:
if end in forward[start]:
forward[start][end] = min(weight, forward[start][end])
else:
forward[start][end] = weight
else:
forward[start] = {end: weight}
if end in backward:
if start in backward[end]:
backward[end][start] = min(weight, backward[end][start])
else:
backward[end][start] = weight
else:
backward[end] = {start: weight}
def travel(origin: int, relations: dict, costs: list) -> None:
level = {origin}
costs[origin] = 0
while level:
new_level = set()
for node in level:
if node in relations:
for next_node, w in relations[node].items():
if w + costs[node] < costs[next_node]:
new_level.add(next_node)
costs[next_node] = w + costs[node]
level = new_level
from_src1 = [inf] * n
from_src2 = [inf] * n
from_dest = [inf] * n
travel(src1, forward, from_src1)
travel(src2, forward, from_src2)
travel(dest, backward, from_dest)
combined_cost = min(sum(tpl)
for tpl in zip(from_src1, from_src2, from_dest))
return combined_cost if combined_cost < inf else -1 | minimum-weighted-subgraph-with-the-required-paths | Three min costs to every node, 97% speed | EvgenySH | 1 | 144 | minimum weighted subgraph with the required paths | 2,203 | 0.357 | Hard | 30,577 |
https://leetcode.com/problems/minimum-weighted-subgraph-with-the-required-paths/discuss/1846788/Python3-bfs | class Solution:
def minimumWeight(self, n: int, edges: List[List[int]], src1: int, src2: int, dest: int) -> int:
graph = [[] for _ in range(n)]
trans = [[] for _ in range(n)]
for u, v, w in edges:
graph[u].append((v, w))
trans[v].append((u, w))
def bfs(x, graph):
dist = [inf] * n
dist[x] = 0
queue = deque([(x, 0)])
while queue:
u, w = queue.popleft()
if dist[u] == w:
for v, ww in graph[u]:
if w+ww < dist[v]:
dist[v] = w+ww
queue.append((v, w+ww))
return dist
ds1 = bfs(src1, graph)
ds2 = bfs(src2, graph)
dd = bfs(dest, trans)
ans = min(x+y+z for x, y, z in zip(ds1, ds2, dd))
return ans if ans < inf else -1 | minimum-weighted-subgraph-with-the-required-paths | [Python3] bfs | ye15 | 1 | 43 | minimum weighted subgraph with the required paths | 2,203 | 0.357 | Hard | 30,578 |
https://leetcode.com/problems/minimum-weighted-subgraph-with-the-required-paths/discuss/1852639/Python-3-BFS-with-comments | class Solution:
def minimumWeight(self, n: int, edges: List[List[int]], src1: int, src2: int, dest: int) -> int:
g = defaultdict(lambda: defaultdict(lambda: float('inf')))
for u, v, w in edges:
g[u][v] = min(g[u][v], w)
# first to calculate the optimal solution for distance from src node to other node
def helper(start):
vis1 = defaultdict(lambda: float('inf'), {start: 0})
q = [(0, start)]
while q:
s1, node1 = heappop(q)
if node1 == dest:
continue
for nei1 in g[node1]:
w1 = g[node1][nei1]
if vis1[nei1] <= s1 + w1: continue
vis1[nei1] = s1 + w1
heappush(q, (s1 + w1, nei1))
return vis1
vis1, vis2 = helper(src1), helper(src2)
# can't reach destination
if dest not in vis1 or dest not in vis2: return -1
# distance after collided node
def rest(start, vis):
q = [(0, start, 0)] # distance, current node, already collide with path from other source node
tmp = defaultdict(lambda: float('inf'), {(start, 0): 0})
if start in vis:
heappush(q, (vis[start], start, 1))
tmp[start, 1] = vis[start]
while q:
s2, node2, reached = heappop(q)
if node2 == dest and reached: #not only need to reach dest but also need to collide with path from other source node
return s2
for nei2 in g[node2]:
w2 = g[node2][nei2]
#if not collide before then check for collision
if not reached and nei2 in vis:
if tmp[(nei2, 1)] <= s2 + w2 + vis[dest]: continue
tmp[(nei2, 1)] = s2 + w2 + vis[nei2]
heappush(q, (s2 + w2 + vis[nei2], nei2, 1))
# otherwise goes for the rest path
else:
if tmp[(nei2, reached)] <= s2 + w2: continue
tmp[(nei2, reached)] = s2 + w2
heappush(q, (s2 + w2, nei2, reached))
return min(rest(src1, vis2), rest(src2, vis1)) | minimum-weighted-subgraph-with-the-required-paths | [Python 3] BFS with comments | chestnut890123 | 0 | 59 | minimum weighted subgraph with the required paths | 2,203 | 0.357 | Hard | 30,579 |
https://leetcode.com/problems/minimum-weighted-subgraph-with-the-required-paths/discuss/1844288/Python-3-recursive-and-iterative | class Solution:
def minimumWeight(self, n: int, edges: List[List[int]], src1: int, src2: int, dest: int) -> int:
graph,regra = defaultdict(list),defaultdict(list)
for x,y,d in edges:
graph[x].append((y,d))
regra[y].append((x,d))
for x in graph.keys():
graph[x].sort(key=lambda p: p[1])
for x in regra.keys():
regra[x].sort(key=lambda p: p[1])
pathfromdest = [float('inf') for _ in range(n)]
psrcjeden = [float('inf') for _ in range(n)]
psrcdwa = [float('inf') for _ in range(n)]
##
def expdes(nod,d):
if d < pathfromdest[nod]:
pathfromdest[nod] = d
for som,da in regra[nod]:
expdes(som,d+da)
def expsje(nod,d):
if d < psrcjeden[nod]:
psrcjeden[nod] = d
for som,da in graph[nod]:
expsje(som,d+da)
def expesdwa(nod,d):
if d < psrcdwa[nod]:
psrcdwa[nod] = d
for som,da in graph[nod]:
expesdwa(som,d+da)
expdes(dest,0)
if pathfromdest[src1] == float('inf') or pathfromdest[src2] == float('inf'): return -1
expsje(src1,0)
expesdwa(src2,0)
##
# q = [dest]
# cu = 0
# while cu < len(q):
# m = q[cu]
# cu += 1
# for som,d in regra[m]:
# if pathfromdest[m] + d < pathfromdest[som]:
# pathfromdest[som] = pathfromdest[m] + d
# q.append(som)
# ##
# q = [src1]
# cu = 0
# while cu < len(q):
# m = q[cu]
# cu += 1
# for som,d in graph[m]:
# if psrcjeden[m] + d < psrcjeden[som]:
# psrcjeden[som] = psrcjeden[m] + d
# q.append(som)
# ##
# q = [src2]
# cu = 0
# while cu < len(q):
# m = q[cu]
# cu += 1
# for som,d in graph[m]:
# if psrcdwa[m] + d < psrcdwa[som]:
# psrcdwa[som] = psrcdwa[m] + d
# q.append(som)
##
ans = min(pathfromdest[ii]+psrcjeden[ii]+psrcdwa[ii] for ii in range(n))
if ans == float('inf'): return -1
else: return ans | minimum-weighted-subgraph-with-the-required-paths | Python 3 recursive and iterative | nonieno | 0 | 24 | minimum weighted subgraph with the required paths | 2,203 | 0.357 | Hard | 30,580 |
https://leetcode.com/problems/divide-array-into-equal-pairs/discuss/1864079/Python-Solution-Using-Counter-oror-Beats-99-oror-O(n) | class Solution:
def divideArray(self, nums: List[int]) -> bool:
lena = len(nums)
count = sum(num//2 for num in Counter(nums).values())
return (lena/2 == count) | divide-array-into-equal-pairs | Python Solution Using Counter || Beats 99% || O(n) | IvanTsukei | 6 | 698 | divide array into equal pairs | 2,206 | 0.746 | Easy | 30,581 |
https://leetcode.com/problems/divide-array-into-equal-pairs/discuss/2072603/Python-Easy-1-liner-using-set-operation | class Solution:
def divideArray(self, nums: List[int]) -> bool:
return not reduce(lambda x,elem: x ^ {elem}, nums, set()) | divide-array-into-equal-pairs | Python Easy 1 liner using set operation | constantine786 | 1 | 129 | divide array into equal pairs | 2,206 | 0.746 | Easy | 30,582 |
https://leetcode.com/problems/divide-array-into-equal-pairs/discuss/2072603/Python-Easy-1-liner-using-set-operation | class Solution:
def divideArray(self, nums: List[int]) -> bool:
not_a_pair = set()
for x in nums:
if x not in not_a_pair:
not_a_pair.add(x)
else:
not_a_pair.remove(x)
return not not_a_pair | divide-array-into-equal-pairs | Python Easy 1 liner using set operation | constantine786 | 1 | 129 | divide array into equal pairs | 2,206 | 0.746 | Easy | 30,583 |
https://leetcode.com/problems/divide-array-into-equal-pairs/discuss/2849206/Python-SOLUTION | class Solution:
def divideArray(self, nums: List[int]) -> bool:
nums.sort()
pairs = len(nums) // 2
for i in range(0,len(nums)-1,2):
if nums[i] != nums[i+1]:
return False
return True | divide-array-into-equal-pairs | Python SOLUTION | kruzhilkin | 0 | 1 | divide array into equal pairs | 2,206 | 0.746 | Easy | 30,584 |
https://leetcode.com/problems/divide-array-into-equal-pairs/discuss/2847260/Python3-solution | class Solution:
def divideArray(self, nums: List[int]) -> bool:
for num in set(nums):
if nums.count(num) % 2 != 0:
return False
return True | divide-array-into-equal-pairs | Python3 solution | SupriyaArali | 0 | 1 | divide array into equal pairs | 2,206 | 0.746 | Easy | 30,585 |
https://leetcode.com/problems/divide-array-into-equal-pairs/discuss/2846126/Python-Sort-and-Count-O(n-log(n))-time-O(1)-space | class Solution:
def divideArray(self, nums: List[int]) -> bool:
if len(nums) % 2:
return False
nums.sort()
last, count = nums[0], 1
for i in range(1, len(nums)):
if (n := nums[i]) == last:
count += 1
elif count % 2 == 0:
last, count = n, 1
else:
break
return count % 2 == 0 | divide-array-into-equal-pairs | [Python] Sort and Count - O(n log(n)) time, O(1) space | Lindelt | 0 | 1 | divide array into equal pairs | 2,206 | 0.746 | Easy | 30,586 |
https://leetcode.com/problems/divide-array-into-equal-pairs/discuss/2839415/91.7-or-Python-or-LeetCode-or-2206.-Divide-Array-Into-Equal-Pairs-(Easy) | class Solution:
def divideArray(self, nums: List[int]) -> bool:
count = 0
n = len(nums) // 2
set_ = set()
for i in nums:
if i in set_:
count += 1
set_.remove(i)
else:
set_.add(i)
if count == n:
return True
return False | divide-array-into-equal-pairs | 91.7% | Python | LeetCode | 2206. Divide Array Into Equal Pairs (Easy) | UzbekDasturchisiman | 0 | 2 | divide array into equal pairs | 2,206 | 0.746 | Easy | 30,587 |
https://leetcode.com/problems/divide-array-into-equal-pairs/discuss/2839415/91.7-or-Python-or-LeetCode-or-2206.-Divide-Array-Into-Equal-Pairs-(Easy) | class Solution:
def divideArray(self, nums: List[int]) -> bool:
nums.sort()
for i in range(0,len(nums),2):
if nums[i] ^ nums[i + 1] != 0:
return False
return True | divide-array-into-equal-pairs | 91.7% | Python | LeetCode | 2206. Divide Array Into Equal Pairs (Easy) | UzbekDasturchisiman | 0 | 2 | divide array into equal pairs | 2,206 | 0.746 | Easy | 30,588 |
https://leetcode.com/problems/divide-array-into-equal-pairs/discuss/2785855/Best-Easy-Solution-oror-TC-O(N)-oror-Easy-approach | class Solution:
def divideArray(self, nums: List[int]) -> bool:
a=Counter(nums)
for i,j in a.items():
if j%2!=0:
return False
return True | divide-array-into-equal-pairs | Best Easy Solution || TC O(N) || Easy approach | Kaustubhmishra | 0 | 3 | divide array into equal pairs | 2,206 | 0.746 | Easy | 30,589 |
https://leetcode.com/problems/divide-array-into-equal-pairs/discuss/2785156/python-all | class Solution:
def divideArray(self, nums: List[int]) -> bool:
return all([v % 2 == 0 for v in Counter(nums).values()]) | divide-array-into-equal-pairs | python all | JasonDecode | 0 | 3 | divide array into equal pairs | 2,206 | 0.746 | Easy | 30,590 |
https://leetcode.com/problems/divide-array-into-equal-pairs/discuss/2783042/Python-using-dictionary | class Solution:
def divideArray(self, nums: List[int]) -> bool:
count=0
dic={}
for i in range(len(nums)):
if nums[i] not in dic:
dic[nums[i]]=i
elif nums[i] in dic:
count+=1
del dic[nums[i]]
return count==len(nums)//2 | divide-array-into-equal-pairs | Python using dictionary | Bhuvan1234 | 0 | 2 | divide array into equal pairs | 2,206 | 0.746 | Easy | 30,591 |
https://leetcode.com/problems/divide-array-into-equal-pairs/discuss/2755848/Easy-Dictionary-Solution | class Solution:
def divideArray(self, nums: List[int]) -> bool:
d={}
for i in nums:
if i not in d:
d[i]=1
else:
d[i]+=1
check=0
for k,v in d.items():
if v % 2 == 0:
check+=v
return True if check == len(nums) else False | divide-array-into-equal-pairs | Easy Dictionary Solution | beingab329 | 0 | 4 | divide array into equal pairs | 2,206 | 0.746 | Easy | 30,592 |
https://leetcode.com/problems/divide-array-into-equal-pairs/discuss/2711370/Python-solution-clean-code-with-full-comments. | class Solution:
def divideArray(self, nums: List[int]) -> bool:
return even_value(list_to_dict(nums))
# Convert integer list into a dictionary.
def list_to_dict(nums: List[int]):
dic = {}
for i in nums:
if i in dic:
dic[i] += 1
else:
dic[i] = 1
return dic
# Iterate through the dictionarys value and if we get odd value, then we return false
# beacuse we cannot divide the array into equal pairs.
# For this to work, we need that all the value to be even.
def even_value(dic):
for key in dic.keys():
if dic[key] % 2 != 0:
return False
return True
# Runtime: 129 ms, faster than 76.08% of Python3 online submissions for Divide Array Into Equal Pairs.
# Memory Usage: 14 MB, less than 63.78% of Python3 online submissions for Divide Array Into Equal Pairs.
# If you like my work and found it helpful, then I'll appreciate a like. Thanks! | divide-array-into-equal-pairs | Python solution, clean code with full comments. | 375d | 0 | 16 | divide array into equal pairs | 2,206 | 0.746 | Easy | 30,593 |
https://leetcode.com/problems/divide-array-into-equal-pairs/discuss/2654819/Easy-and-faster-solution-using-Counter | class Solution:
def divideArray(self, nums: List[int]) -> bool:
c=Counter(nums)
for i in c:
if(c[i]%2!=0):
return False
return True | divide-array-into-equal-pairs | Easy and faster solution using Counter | Raghunath_Reddy | 0 | 4 | divide array into equal pairs | 2,206 | 0.746 | Easy | 30,594 |
https://leetcode.com/problems/divide-array-into-equal-pairs/discuss/2519054/Simple-Python-solution-using-hashmap | class Solution:
def divideArray(self, nums: List[int]) -> bool:
n = len(nums)
if n % 2 == 1:
return False
dic = collections.Counter(nums)
for k,v in dic.items():
if v % 2 == 1:
return False
return True | divide-array-into-equal-pairs | Simple Python solution using hashmap | aruj900 | 0 | 19 | divide array into equal pairs | 2,206 | 0.746 | Easy | 30,595 |
https://leetcode.com/problems/divide-array-into-equal-pairs/discuss/2478679/Python3-Simple-using-dicts-explanation-no-imports-memory-efficient | class Solution:
def divideArray(self, nums: List[int]) -> bool:
# Let's start by creating a python dictionary to count the occurances of each number in the list
n_dict = {}
for n in nums:
n_dict[n] = n_dict.get(n, 0) + 1
#print(n_dict) # Uncomment this to see the dict. It has the form {(key: value), } or in our case {(number: occurances), ...}
# Now we can loop through the dictionary, and if any of the occurance counts are not divisible by 2, then we know the answer is false
# We can determine if something is divisible by 2 by using the modulus operator which returns the remainder after a division (4 % 2 = 0, 5 % 2 = 1)
for n in n_dict:
if n_dict[n] % 2 != 0: return False
# If we didn't find any occurances not divisable by 2, we know the answer must be true
return True | divide-array-into-equal-pairs | [Python3] Simple using dicts - explanation - no imports - memory efficient | connorthecrowe | 0 | 34 | divide array into equal pairs | 2,206 | 0.746 | Easy | 30,596 |
https://leetcode.com/problems/divide-array-into-equal-pairs/discuss/2471290/Python-solution-faster-than-99.05-using-set-and-collections | class Solution:
def divideArray(self, nums: List[int]) -> bool:
set_nums = set(nums)
dict_nums = collections.Counter(nums)
count_even_val = 0
for k, v in dict_nums.items():
if v % 2 == 0:
count_even_val += 1
if count_even_val == len(set_nums):
return True
return False | divide-array-into-equal-pairs | Python solution faster than 99.05% using set and collections | samanehghafouri | 0 | 31 | divide array into equal pairs | 2,206 | 0.746 | Easy | 30,597 |
https://leetcode.com/problems/divide-array-into-equal-pairs/discuss/2149454/One-liner | class Solution:
def divideArray(self, nums: List[int]) -> bool:
return all(v % 2 == 0 for _, v in Counter(nums).items()) | divide-array-into-equal-pairs | One liner | dima62 | 0 | 30 | divide array into equal pairs | 2,206 | 0.746 | Easy | 30,598 |
https://leetcode.com/problems/divide-array-into-equal-pairs/discuss/2092117/PYTHON-or-Super-simple-python-solution-or-HashMap | class Solution:
def divideArray(self, nums: List[int]) -> bool:
numMap = {}
for i in nums:
numMap[i] = 1 + numMap.get(i, 0)
for i in numMap:
if numMap[i] % 2 != 0:
return False
return True | divide-array-into-equal-pairs | PYTHON | Super simple python solution | HashMap | shreeruparel | 0 | 58 | divide array into equal pairs | 2,206 | 0.746 | Easy | 30,599 |
Subsets and Splits