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/reverse-odd-levels-of-binary-tree/discuss/2590340/Mind-blowing-Python-Answer-BFS-%2B-Queue | class Solution:
def reverseOddLevels(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
q = Deque()
q.append(root)
level = 1
while q:
lev = []
for _ in range(len(q)):
n = q.popleft()
if n.left is not None:
q.append(n.left)
lev.append(n.left)
if n.right is not None:
q.append(n.right)
lev.append(n.right)
if level %2 == 1:
tot = len(lev)
for i,l in enumerate(lev):
if i >= tot //2:
break
lev[i].val, lev[tot-1-i].val = lev[tot-1-i].val, lev[i].val
level += 1
return root | reverse-odd-levels-of-binary-tree | [Mind 🤯 blowing Python Answer🤫🐍👌😍] BFS + Queue | xmky | 0 | 24 | reverse odd levels of binary tree | 2,415 | 0.757 | Medium | 33,000 |
https://leetcode.com/problems/reverse-odd-levels-of-binary-tree/discuss/2590277/python3-Detailed-explanation-or-intuitive-approach-or-bfs-to-get-nodes-or-update-value-IN-PLACE | class Solution:
def reverseOddLevels(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
bfs_traversal = self.bfs(root)
for level in range(len(bfs_traversal)):
if level % 2 == 0:
continue
reversed_values = [node.val for node in reversed(bfs_traversal[level])]
for index, node in enumerate(bfs_traversal[level]):
node.val = reversed_values[index]
return root
def bfs(self, root):
traversal = []
queue = deque()
queue.append(root)
while queue:
current = []
for _ in range(len(queue)):
node = queue.popleft()
if not node:
continue
current.append(node)
if node.left: queue.append(node.left)
if node.right: queue.append(node.right)
traversal.append(current)
return traversal | reverse-odd-levels-of-binary-tree | [python3] Detailed explanation | intuitive approach | bfs to get nodes | update value IN PLACE | _snake_case | 0 | 31 | reverse odd levels of binary tree | 2,415 | 0.757 | Medium | 33,001 |
https://leetcode.com/problems/reverse-odd-levels-of-binary-tree/discuss/2590180/Python-or-Hashmap-of-odd-level-lists | class Solution:
def reverseOddLevels(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
def reverseLevel(nodes: List[Optional[TreeNode]]) -> None:
for i in range(len(nodes) // 2):
nodes[i].val, nodes[~i].val = nodes[~i].val, nodes[i].val
levels = defaultdict(list)
nodeQueue = [(root, 0)]
while nodeQueue:
node, level = nodeQueue.pop()
if level % 2 == 1:
levels[level].append(node)
for child in [node.left, node.right]:
if child is not None:
nodeQueue.append((child, level + 1))
for level in levels.values():
reverseLevel(level)
return root | reverse-odd-levels-of-binary-tree | Python | Hashmap of odd level lists | sr_vrd | 0 | 7 | reverse odd levels of binary tree | 2,415 | 0.757 | Medium | 33,002 |
https://leetcode.com/problems/sum-of-prefix-scores-of-strings/discuss/2590687/Python-Simple-Python-Solution-Using-Dictionary | class Solution:
def sumPrefixScores(self, words: List[str]) -> List[int]:
d = defaultdict(int)
for word in words:
for index in range(1, len(word) + 1):
d[word[:index]] += 1
result = []
for word in words:
current_sum = 0
for index in range(1, len(word) + 1):
current_sum = current_sum + d[word[:index]]
result.append(current_sum)
return result | sum-of-prefix-scores-of-strings | [ Python ] ✅✅ Simple Python Solution Using Dictionary 🥳✌👍 | ASHOK_KUMAR_MEGHVANSHI | 1 | 70 | sum of prefix scores of strings | 2,416 | 0.426 | Hard | 33,003 |
https://leetcode.com/problems/sum-of-prefix-scores-of-strings/discuss/2590476/Easy-Python-Solution-With-Dictionary | class Solution:
def sumPrefixScores(self, words: List[str]) -> List[int]:
d = dict()
for i in words:
s=""
for j in range(len(i)):
s+=i[j]
if s in d:
d[s]+=1
else:
d[s]=1
l=[]
for i in words:
c = 0
s=""
for j in range(len(i)):
s+=i[j]
c+=d[s]
l.append(c)
return l | sum-of-prefix-scores-of-strings | Easy Python Solution With Dictionary | a_dityamishra | 1 | 61 | sum of prefix scores of strings | 2,416 | 0.426 | Hard | 33,004 |
https://leetcode.com/problems/sum-of-prefix-scores-of-strings/discuss/2590174/Not-optimal-but-easy-to-understanding | class Solution:
def sumPrefixScores(self, words: List[str]) -> List[int]:
prefs = {}
ans = []
for w in words:
for i in range(1, len(w)+1):
if w[0:i] not in prefs:
prefs[w[0:i]] = 1
else:
prefs[w[0:i]] += 1
for i, w in enumerate(words):
for j in range(1, len(w)+1):
if i >= len(ans):
ans.append(prefs[w[0:j]])
else:
ans[i] += prefs[w[0:j]]
return ans | sum-of-prefix-scores-of-strings | Not optimal, but easy to understanding | fuglaeff | 1 | 44 | sum of prefix scores of strings | 2,416 | 0.426 | Hard | 33,005 |
https://leetcode.com/problems/sum-of-prefix-scores-of-strings/discuss/2789995/Python-Trie%3A-70-time-12-space | class Solution:
def sumPrefixScores(self, words: List[str]) -> List[int]:
trie = {}
def populateTrie(trie, word):
for i in range(len(word)):
letter = word[i]
if letter in trie:
trie[letter]['count'] += 1
else:
trie[letter] = {}
trie[letter]['count'] = 1
trie = trie[letter]
for word in words: populateTrie(trie, word)
def countPrefix(trie, word):
count = 0
for i in range(len(word)):
letter = word[i]
count += trie[letter]['count']
trie = trie[letter]
return count
output = []
for word in words:
output.append(countPrefix(trie, word))
return output | sum-of-prefix-scores-of-strings | Python Trie: 70% time, 12% space | hqz3 | 0 | 1 | sum of prefix scores of strings | 2,416 | 0.426 | Hard | 33,006 |
https://leetcode.com/problems/sum-of-prefix-scores-of-strings/discuss/2690996/My-Python-Trie-solution | class Solution:
def sumPrefixScores(self, words: List[str]) -> List[int]:
trie = {}
for w in words:
node = trie
for ch in w:
if ch in node:
node = node[ch]
node["$"] += 1
else:
node[ch] = {"$": 1}
node = node[ch]
result = []
for w in words:
node = trie
total = 0
for ch in w:
total += node[ch]["$"]
node = node[ch]
result.append(total)
return result | sum-of-prefix-scores-of-strings | My Python Trie solution | MonQiQi | 0 | 7 | sum of prefix scores of strings | 2,416 | 0.426 | Hard | 33,007 |
https://leetcode.com/problems/sum-of-prefix-scores-of-strings/discuss/2690995/My-Python-Trie-solution | class Solution:
def sumPrefixScores(self, words: List[str]) -> List[int]:
trie = {}
for w in words:
node = trie
for ch in w:
if ch in node:
node = node[ch]
node["$"] += 1
else:
node[ch] = {"$": 1}
node = node[ch]
result = []
for w in words:
node = trie
total = 0
for ch in w:
total += node[ch]["$"]
node = node[ch]
result.append(total)
return result | sum-of-prefix-scores-of-strings | My Python Trie solution | MonQiQi | 0 | 3 | sum of prefix scores of strings | 2,416 | 0.426 | Hard | 33,008 |
https://leetcode.com/problems/sum-of-prefix-scores-of-strings/discuss/2591170/python3-Trie-sol-for-reference | class Solution:
def sumPrefixScores(self, words: List[str]) -> List[int]:
T = {}
z = []
for w in words:
t = T
for c in w:
if c not in t:
t[c] = {'cnt': 0}
t = t[c]
t['cnt'] += 1
for w in words:
acc = 0
t = T
for c in w:
t = t[c]
acc += t['cnt']
z.append(acc)
return z | sum-of-prefix-scores-of-strings | [python3] Trie sol for reference | vadhri_venkat | 0 | 10 | sum of prefix scores of strings | 2,416 | 0.426 | Hard | 33,009 |
https://leetcode.com/problems/sum-of-prefix-scores-of-strings/discuss/2590425/PYTHON-Using-Dictionary | class Solution:
def sumPrefixScores(self, words: List[str]) -> List[int]:
# words=['a'*1000 for i in range(1000)]
ans=[0 for w in words]
d={}
for w in words:
for i in range(len(w)):
c=w[:i+1]
if not c in d:
d[c]=1
else:
d[c]+=1
for i in range(len(words)):
for j in range(len(words[i])):
c=words[i][:j+1]
if c in d.keys():
ans[i]+=d[c]
else:
break
return ans | sum-of-prefix-scores-of-strings | [PYTHON] Using Dictionary | shreyasjain0912 | 0 | 9 | sum of prefix scores of strings | 2,416 | 0.426 | Hard | 33,010 |
https://leetcode.com/problems/sum-of-prefix-scores-of-strings/discuss/2590389/Python3-trie | class Solution:
def sumPrefixScores(self, words: List[str]) -> List[int]:
root = {}
for word in words:
node = root
for ch in word:
node = node.setdefault(ch, {})
node['#'] = node.get('#', 0) + 1
ans = []
for word in words:
val = 0
node = root
for ch in word:
node = node[ch]
val += node['#']
ans.append(val)
return ans | sum-of-prefix-scores-of-strings | [Python3] trie | ye15 | 0 | 10 | sum of prefix scores of strings | 2,416 | 0.426 | Hard | 33,011 |
https://leetcode.com/problems/sum-of-prefix-scores-of-strings/discuss/2590237/Clever-Python-Solution-Special-Trie | class Solution:
def sumPrefixScores(self, words: List[str]) -> List[int]:
class TrieNode():
def __init__(self):
self.children = defaultdict(TrieNode)
self.isWord = False
self.count = 0
class Trie():
def __init__(self):
self.root = TrieNode()
def insert(self, word):
node = self.root
for w in word:
node.count += 1
node = node.children[w]
node.count += 1
node.isWord = True
def searchCC(self, word):
tot = 0
node = self.root
for w in word:
node = node.children.get(w)
if not node:
return tot
tot += node.count
return tot
t = Trie()
for w in words:
t.insert(w)
r = []
for w in words:
r.append( t.searchCC(w) )
return r | sum-of-prefix-scores-of-strings | [Clever Python Solution🤫🐍👌😍] Special Trie | xmky | 0 | 12 | sum of prefix scores of strings | 2,416 | 0.426 | Hard | 33,012 |
https://leetcode.com/problems/sum-of-prefix-scores-of-strings/discuss/2590114/O(n)-using-HashMap-of-all-prefix-words-(Example-Illustrations) | class Solution:
def sumPrefixScores(self, words: List[str]) -> List[int]:
keys = {}
values = []
windex = []
for word in words:
w = []
for i in range(len(word)):
prefix = word[:i+1]
key = keys.get(prefix, -1)
if key == -1:
keys[prefix] = len(values)
key = keys[prefix]
values.append(1)
else:
values[key] += 1
w.append(key)
windex.append(w)
print("words:", words)
print("keys:", keys)
print("values:", values)
print("word index:", windex)
ans = []
for wi in windex:
t = 0
for idx in wi:
t += values[idx]
ans.append(t)
print("ans:", ans)
print("="*20, "\n")
return ans
print = lambda *a, **aa: () | sum-of-prefix-scores-of-strings | O(n) using HashMap of all prefix words (Example Illustrations) | dntai | 0 | 42 | sum of prefix scores of strings | 2,416 | 0.426 | Hard | 33,013 |
https://leetcode.com/problems/sum-of-prefix-scores-of-strings/discuss/2590037/Python3-Brute-Force | class Solution:
def sumPrefixScores(self, words: List[str]) -> List[int]:
cnter = defaultdict(int)
res = []
#Adding all prefixes to counter
for word in words:
for idx in range(1, len(word) + 1):
cnter[word[:idx]] += 1
#Adding up occurrences
for word in words:
cnt = 0
for idx in range(1, len(word) + 1):
cnt += cnter[word[:idx]]
res.append(cnt)
return res | sum-of-prefix-scores-of-strings | [Python3] Brute Force | 0xRoxas | 0 | 33 | sum of prefix scores of strings | 2,416 | 0.426 | Hard | 33,014 |
https://leetcode.com/problems/sort-the-people/discuss/2627285/python3-oror-2-lines-with-example-oror-TM-42ms14.3MB | class Solution: # Ex: names = ["Larry","Curly","Moe"] heights = [130,125,155]
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
_,names = zip(*sorted(zip(heights,names), reverse = True))
# zipped --> [(130,"Larry"), (125,"Curly"), (155,"Moe") ]
# sorted --> [(155,"Moe" ), (130,"Larry"), (125,"Curly")]
# unzipped --> _ = (155,130,125) , names = ("Moe","Larry","Curly")
return list(names) # list(names) = ["Moe","Larry","Curly"] | sort-the-people | python3 || 2 lines with example || T/M = 42ms/14.3MB | warrenruud | 7 | 575 | sort the people | 2,418 | 0.82 | Easy | 33,015 |
https://leetcode.com/problems/sort-the-people/discuss/2627803/Python-Elegant-and-Short-or-One-line | class Solution:
"""
Time: O(n*log(n))
Memory: O(n)
"""
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
return [name for _, name in sorted(zip(heights, names), reverse=True)] | sort-the-people | Python Elegant & Short | One line | Kyrylo-Ktl | 5 | 240 | sort the people | 2,418 | 0.82 | Easy | 33,016 |
https://leetcode.com/problems/sort-the-people/discuss/2670358/PYTHON-or-ONE-LINER-or-99.01-SPEED | class Solution:
def sortPeople(self, n: List[str], h: List[int]) -> List[str]:
return [c for _, c in sorted(zip(h, n), reverse=True)] | sort-the-people | PYTHON | ONE LINER | 99.01% SPEED | omkarxpatel | 4 | 130 | sort the people | 2,418 | 0.82 | Easy | 33,017 |
https://leetcode.com/problems/sort-the-people/discuss/2648273/Python-is-your-friend | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
return [b for a, b in sorted(zip(heights, names), reverse=True)] | sort-the-people | Python is your friend | votrubac | 4 | 310 | sort the people | 2,418 | 0.82 | Easy | 33,018 |
https://leetcode.com/problems/sort-the-people/discuss/2656840/Simple-Python-solution-using-sorting | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
comb = zip(names,heights)
res = []
comb = sorted(comb, key =lambda x: x[1],reverse=True)
for i in comb:
res.append(i[0])
return res | sort-the-people | Simple Python solution using sorting | aruj900 | 3 | 203 | sort the people | 2,418 | 0.82 | Easy | 33,019 |
https://leetcode.com/problems/sort-the-people/discuss/2620548/Python-Simple-Python-Solution-Using-Sorting | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
result = []
sort_heights = sorted(heights, reverse = True)
for height in sort_heights:
index = heights.index(height)
result.append(names[index])
return result | sort-the-people | [ Python ] ✅✅ Simple Python Solution Using Sorting 🥳✌👍 | ASHOK_KUMAR_MEGHVANSHI | 3 | 216 | sort the people | 2,418 | 0.82 | Easy | 33,020 |
https://leetcode.com/problems/sort-the-people/discuss/2774379/Easy-Python-Solution | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
l=[]
for i in range(len(heights)):
l.append([heights[i],names[i]])
l.sort(reverse=True)
k=[]
for i in l:
k.append(i[1])
return k | sort-the-people | Easy Python Solution | Vistrit | 2 | 480 | sort the people | 2,418 | 0.82 | Easy | 33,021 |
https://leetcode.com/problems/sort-the-people/discuss/2837222/Easy-Python-One-Line-Solution | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
return [j for i,j in sorted([(h,n) for h,n in zip(heights,names)],reverse=True)] | sort-the-people | Easy Python One Line Solution | rpatra332 | 1 | 39 | sort the people | 2,418 | 0.82 | Easy | 33,022 |
https://leetcode.com/problems/sort-the-people/discuss/2835936/Python-or-Sorted-ReverseTrueor-Simple-solution | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
hgts=sorted(heights,reverse=True)
p=[]
for i in hgts:
p.append(names[heights.index(i)])
return p | sort-the-people | Python | Sorted Reverse=True| Simple solution | priyanshupriyam123vv | 1 | 27 | sort the people | 2,418 | 0.82 | Easy | 33,023 |
https://leetcode.com/problems/sort-the-people/discuss/2804691/Python-Fast-O(n-log-n)-solution-using-sorting | class Solution:
def sortPeople(self, names: list[str], heights: list[int]) -> list[str]:
l = zip(names, heights)
l = sorted(l, key=lambda x: x[1], reverse=True)
return [i[0] for i in l] | sort-the-people | [Python] Fast O(n log n) solution using sorting | Mark_computer | 1 | 8 | sort the people | 2,418 | 0.82 | Easy | 33,024 |
https://leetcode.com/problems/sort-the-people/discuss/2638062/Python3-easy-solution-with-explanation | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
hash = dict(zip(heights,names))
res = []
heights.sort(reverse=True)
for h in heights:
res.append(hash[h])
return res | sort-the-people | Python3 easy solution with explanation | khushie45 | 1 | 82 | sort the people | 2,418 | 0.82 | Easy | 33,025 |
https://leetcode.com/problems/sort-the-people/discuss/2623427/Simple-Python-Dictionary | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
myDict = {}
res=[]
#add key value pairs to dictionary
for i in range(len(heights)):
myDict[heights[i]] = names[i]
#sort the keys in order of height
myList = sorted(myDict.keys())
#add names using key/value pair from myDict and the sorted list of keys
for i in myList:
res.append(myDict[i])
#because names are appended to the end of res, the answer must be reversed before being returned
return res[::-1] | sort-the-people | Simple Python Dictionary | Gooby | 1 | 38 | sort the people | 2,418 | 0.82 | Easy | 33,026 |
https://leetcode.com/problems/sort-the-people/discuss/2623421/Dictionary-height%3A-name | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
dict_hn = {h: n for h, n in zip(heights, names)}
heights.sort(reverse=True)
return [dict_hn[h] for h in heights] | sort-the-people | Dictionary height: name | EvgenySH | 1 | 20 | sort the people | 2,418 | 0.82 | Easy | 33,027 |
https://leetcode.com/problems/sort-the-people/discuss/2621567/Python3-or-n(log(n)-or-one-liner-or-beginner-friendly! | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
#beginner friendly!
#creating tuple (packing) of height & names.
#Tips: We have to sort according to height so put hieght first then name
HeightNameTup = []
for height,name in zip(heights,names):
HeightNameTup.append((height,name))
# print(HeightNameTup)
#just sort
HeightNameTup.sort()
#unpacking return list of name only
ls=[]
for height, name in HeightNameTup:
ls.append(name)
#return list
return ls[::-1] | sort-the-people | Python3 | n(log(n) | one liner | beginner friendly! | YaBhiThikHai | 1 | 79 | sort the people | 2,418 | 0.82 | Easy | 33,028 |
https://leetcode.com/problems/sort-the-people/discuss/2850579/Python-Solution-using-Bubble-Sort | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
for i in range(len(heights)):
for j in range(len(heights)-1):
if heights[j] < heights[j+1]:
heights[j], heights[j + 1] = heights[j + 1], heights[j]
names[j], names[j+1] = names[j+1], names[j]
return names | sort-the-people | Python Solution using Bubble Sort | nikhilthoratofficial | 0 | 2 | sort the people | 2,418 | 0.82 | Easy | 33,029 |
https://leetcode.com/problems/sort-the-people/discuss/2847777/Fastest-and-simple-Python-Solution | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
res = {}
l = 0
for i in heights:
if i not in res:
res[i] = names[l]
l+=1
heights.sort(reverse = True)
for i in range(0,len(names)):
names[i] = res[heights[i]]
return names | sort-the-people | Fastest and simple Python Solution | khanismail_1 | 0 | 2 | sort the people | 2,418 | 0.82 | Easy | 33,030 |
https://leetcode.com/problems/sort-the-people/discuss/2846707/sortPerson | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
#names : List[str]
#heights : List[int]
#rtype : List[str]
d={}
for i in range(len(names)):
d[heights[i]]=names[i]
heights.sort(reverse=True)
answer=[]
for height in heights:
answer.append(d.get(height))
return answer | sort-the-people | sortPerson | happyhillll | 0 | 1 | sort the people | 2,418 | 0.82 | Easy | 33,031 |
https://leetcode.com/problems/sort-the-people/discuss/2846638/Python-or-Simple-solution | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
i = 0
# Saving zipped pairs of (name, height)
for name, height in zip(names, heights):
names[i] = (name, height)
i += 1
# Sorting names according to heights value
names.sort(key=lambda x:x[1], reverse=True)
# Extracting names from zipped pairs of (name, height)
result = [name[0] for name in names]
return result | sort-the-people | Python | Simple solution | pawangupta | 0 | 1 | sort the people | 2,418 | 0.82 | Easy | 33,032 |
https://leetcode.com/problems/sort-the-people/discuss/2834742/One-liner-in-Python | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
return [names for heights, names in sorted(zip(heights,names), reverse=True)] | sort-the-people | One liner in Python | ksinar | 0 | 2 | sort the people | 2,418 | 0.82 | Easy | 33,033 |
https://leetcode.com/problems/sort-the-people/discuss/2817127/python-hash-map-and-merge-sort | class Solution:
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 = 0
j = 0
k = 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
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
hashmap = {}
for i in range(len(names)):
hashmap[heights[i]] = names[i]
self.mergeSort(heights)
result = [hashmap[i] for i in heights]
return result | sort-the-people | python hash map and merge sort | sudharsan1000m | 0 | 2 | sort the people | 2,418 | 0.82 | Easy | 33,034 |
https://leetcode.com/problems/sort-the-people/discuss/2816815/easy-python-using-dictionary | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
mydict=dict(zip(heights,names))
l=[]
heights.sort(reverse=True)
for i in heights:
l.append(mydict[i])
return l | sort-the-people | easy python using dictionary | giftyaustin | 0 | 4 | sort the people | 2,418 | 0.82 | Easy | 33,035 |
https://leetcode.com/problems/sort-the-people/discuss/2812001/Bubble-Sort-Method-Easy-Solution-Beginner | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
l = len(heights)
while l:
l-=1
for i in range(len(names)-1):
if heights[i] < heights[i+1]:
heights[i], heights[i+1] =heights[i+1], heights[i]
temp = names[i]
names[i] = names[i+1]
names[i+1] = temp
return names | sort-the-people | Bubble Sort Method Easy Solution Beginner | Jashan6 | 0 | 4 | sort the people | 2,418 | 0.82 | Easy | 33,036 |
https://leetcode.com/problems/sort-the-people/discuss/2811192/Python-zip | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
a = [n for h, n in sorted(set(zip(heights, names)))]
return a[::-1] | sort-the-people | Python zip | Teyllayka | 0 | 3 | sort the people | 2,418 | 0.82 | Easy | 33,037 |
https://leetcode.com/problems/sort-the-people/discuss/2809541/python-oror-one-line-solution | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
return [names[heights.index(i)] for i in sorted(heights,reverse=True)] | sort-the-people | python || one line solution | Nikhil2532 | 0 | 4 | sort the people | 2,418 | 0.82 | Easy | 33,038 |
https://leetcode.com/problems/sort-the-people/discuss/2801647/Python-or-single-line | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
return [i[1] for i in sorted(zip(heights,names),reverse = True)] | sort-the-people | Python | single line | SAI_KRISHNA_PRATHAPANENI | 0 | 3 | sort the people | 2,418 | 0.82 | Easy | 33,039 |
https://leetcode.com/problems/sort-the-people/discuss/2800452/python-easy-solution(well-explained-beginner-friendly) | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
new=list() #taking a new list
for i in range(len(names)):
new.append([heights[i],names[i]]) #adding heights and names together in our new list
#remember we want to sort our list according to heights so heights will be appended first
new.sort(reverse=True) #sorting it in decreasing heights
res=list() #final list to add only names for our output
for i in new:
res.append(i[1]) #here i[0]=heights and i[1]=names so output needs only names so adding only names i.e(i[1])
return(res) #return the final list | sort-the-people | python easy solution(well explained beginner friendly) | ZEdd123 | 0 | 8 | sort the people | 2,418 | 0.82 | Easy | 33,040 |
https://leetcode.com/problems/sort-the-people/discuss/2792885/python3-solution | class Solution(object):
def sortPeople(self, names, heights):
enum = list(enumerate(heights))
enum.sort(key = lambda x : x[1], reverse = True)
res = []
for i in range(len(enum)):
idx = enum[i][0]
res.append(names[idx])
return res | sort-the-people | python3 solution | rachelchee25 | 0 | 6 | sort the people | 2,418 | 0.82 | Easy | 33,041 |
https://leetcode.com/problems/sort-the-people/discuss/2789412/python-solution | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
h=sorted(heights,reverse=1)
newlist=[]
for i in range(len(h)):
s=heights.index(h[i])
newlist.append(names[s])
return newlist | sort-the-people | python solution | sindhu_300 | 0 | 2 | sort the people | 2,418 | 0.82 | Easy | 33,042 |
https://leetcode.com/problems/sort-the-people/discuss/2784707/python-zip | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
res = []
for name, height in zip(names, heights):
res.append((height, name))
res.sort(key = lambda x: x[0], reverse = True)
return [item[1] for item in res] | sort-the-people | python zip | JasonDecode | 0 | 3 | sort the people | 2,418 | 0.82 | Easy | 33,043 |
https://leetcode.com/problems/sort-the-people/discuss/2779688/Easy-Python-Solution | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
res = []
list1 = sorted(heights,reverse = True)
for i in list1:
index = heights.index(i)
res.append(names[index])
return res | sort-the-people | Easy Python Solution | dnvavinash | 0 | 3 | sort the people | 2,418 | 0.82 | Easy | 33,044 |
https://leetcode.com/problems/sort-the-people/discuss/2778812/easy-approach!! | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
list_ = []
for i in range(len(heights)):
list_.append([heights[i],names[i]])
list_.sort(reverse=True)
output_ = []
for i in list_:
output_.append(i[1])
return output_ | sort-the-people | easy approach!! | sanjeevpathak | 0 | 1 | sort the people | 2,418 | 0.82 | Easy | 33,045 |
https://leetcode.com/problems/sort-the-people/discuss/2770247/Python-easy-to-understand-solution | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
edict={}
for i in range(len(heights)):
for j in range(len(names)):
if i==j:
edict.update({heights[i]:names[j]})
new_edict=sorted(edict.items(),reverse = True)
print(new_edict)
new_list=[]
final_list=[]
for item in new_edict:
new_list.append(item[1])
return new_list | sort-the-people | Python easy to understand solution | user7798V | 0 | 4 | sort the people | 2,418 | 0.82 | Easy | 33,046 |
https://leetcode.com/problems/sort-the-people/discuss/2760727/Python3-or-Sorted-ZIP | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
return [x[0] for x in sorted(zip(names, heights), key=lambda x: x[1], reverse=True)] | sort-the-people | Python3 | Sorted ZIP | joshua_mur | 0 | 3 | sort the people | 2,418 | 0.82 | Easy | 33,047 |
https://leetcode.com/problems/sort-the-people/discuss/2759386/1-line-solution-Python | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
return [b for a, b in sorted(zip(heights, names), key=lambda x: x[0], reverse=True)] | sort-the-people | 1 line solution - Python | avs-abhishek123 | 0 | 4 | sort the people | 2,418 | 0.82 | Easy | 33,048 |
https://leetcode.com/problems/sort-the-people/discuss/2759235/Python-or-Easy-or-HashMap | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
n = len(names)
hashMap = {}
for i in range(n):
hashMap[heights[i]] = names[i]
heights.sort(reverse=True)
ans = []
for i in range(len(heights)):
ans.append(hashMap[heights[i]])
return ans | sort-the-people | Python | Easy | HashMap | LittleMonster23 | 0 | 12 | sort the people | 2,418 | 0.82 | Easy | 33,049 |
https://leetcode.com/problems/sort-the-people/discuss/2759235/Python-or-Easy-or-HashMap | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
hashMap = dict(zip(heights,names))
res = []
heights.sort(reverse=True)
for h in heights:
res.append(hashMap[h])
return res | sort-the-people | Python | Easy | HashMap | LittleMonster23 | 0 | 12 | sort the people | 2,418 | 0.82 | Easy | 33,050 |
https://leetcode.com/problems/sort-the-people/discuss/2750187/Python3-Solution-with-using-hashmap | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
d = {}
for idx, height in enumerate(heights):
d[height] = names[idx]
heights.sort(reverse=True)
res = []
for height in heights:
res.append(d[height])
return res | sort-the-people | [Python3] Solution with using hashmap | maosipov11 | 0 | 7 | sort the people | 2,418 | 0.82 | Easy | 33,051 |
https://leetcode.com/problems/sort-the-people/discuss/2741539/PYTHONEASYAPPROACH | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
lookup = dict(zip(heights, names))
hSorted = sorted(lookup.keys(), reverse=True)
ans = []
for h in hSorted:
ans.append(lookup[h])
return ans | sort-the-people | ✔PYTHON🐍EASY💥APPROACH | shubhamdraj | 0 | 8 | sort the people | 2,418 | 0.82 | Easy | 33,052 |
https://leetcode.com/problems/sort-the-people/discuss/2721623/One-liner-EZZZ-solution-Python | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
return [x[0] for x in sorted(list(zip(names,heights)), key = lambda x:x[1], reverse = True)] | sort-the-people | One liner EZZZ solution Python | jacobsimonareickal | 0 | 5 | sort the people | 2,418 | 0.82 | Easy | 33,053 |
https://leetcode.com/problems/sort-the-people/discuss/2719701/Python-or-Simple-and-faster-solution | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
height_name_map = {}
for i in range(len(names)):
height_name_map[heights[i]] = names[i]
sorted_height_name_list = sorted(height_name_map.items(), reverse=True)
return [v[1] for v in sorted_height_name_list] | sort-the-people | Python | Simple and faster solution | kawamataryo | 0 | 9 | sort the people | 2,418 | 0.82 | Easy | 33,054 |
https://leetcode.com/problems/sort-the-people/discuss/2718736/One-liner | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
return [dict(zip(heights, names))[i] for i in sorted(dict(zip(heights, names)).keys())][::-1] | sort-the-people | One liner | iakylbek | 0 | 5 | sort the people | 2,418 | 0.82 | Easy | 33,055 |
https://leetcode.com/problems/sort-the-people/discuss/2710178/Python3-one-line-solution-with-explanation | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
return [i[1] for i in sorted(list(zip(heights,names)), key=lambda x:x[0], reverse=True)] | sort-the-people | Python3 one-line solution with explanation | sipi09 | 0 | 8 | sort the people | 2,418 | 0.82 | Easy | 33,056 |
https://leetcode.com/problems/sort-the-people/discuss/2703609/Python-3-Lines-easy-understanding-using-zip-lambda-and-no-for-loop. | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
a = sorted(zip(names, heights), key = lambda t: t[1], reverse=True)
ans = list(zip(*a))
return ans[0] | sort-the-people | Python 3 Lines easy understanding using zip lambda and no for loop. | user2800NJ | 0 | 5 | sort the people | 2,418 | 0.82 | Easy | 33,057 |
https://leetcode.com/problems/sort-the-people/discuss/2698942/python-1-line | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
return [name for (name, height) in sorted([(name, height) for name, height in zip(names, heights)], key = lambda x: -x[1])] | sort-the-people | python 1-line | emersonexus | 0 | 9 | sort the people | 2,418 | 0.82 | Easy | 33,058 |
https://leetcode.com/problems/sort-the-people/discuss/2677734/Python-Solution-using-arrays | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
ar, res = [], []
for n , h in zip(names,heights):
ar.append([n,h])
ar = sorted(ar, key = lambda x:x[1],reverse = True)
for val in ar:
res.append(val[0])
return res | sort-the-people | Python Solution using arrays | saumya_0606 | 0 | 3 | sort the people | 2,418 | 0.82 | Easy | 33,059 |
https://leetcode.com/problems/sort-the-people/discuss/2673366/easy-solution-python | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
return [row[1] for row in sorted(zip(heights, names), reverse = True)] | sort-the-people | easy solution python | MaryLuz | 0 | 1 | sort the people | 2,418 | 0.82 | Easy | 33,060 |
https://leetcode.com/problems/sort-the-people/discuss/2668241/easy-python-soln-with-explanation | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
d={}#to link the heights with names
#ex names=["Amber","Fatima"]
#height=[5,2]
#then d={5:"Amber,2:"Fatima"}
for height in heights:
for name in names:
d[height]=name#here key would be height and value will be name
names.remove(name)
break# breaking out of the first loop
f=[d[l] for l in sorted(d)[::-1]]# sorting and reversing the key and returning the value assigned to that key
return (f) | sort-the-people | easy python soln with explanation | AMBER_FATIMA | 0 | 6 | sort the people | 2,418 | 0.82 | Easy | 33,061 |
https://leetcode.com/problems/sort-the-people/discuss/2648156/Python-or-One-Line-Functional | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
return map(lambda t : t[1], sorted (zip(heights, names), reverse=True)) | sort-the-people | Python | One Line Functional | on_danse_encore_on_rit_encore | 0 | 6 | sort the people | 2,418 | 0.82 | Easy | 33,062 |
https://leetcode.com/problems/sort-the-people/discuss/2641488/O(nlogn)-Solution | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
lis = sorted(list(zip(heights,names)),reverse=True)
a,b = zip(*lis)
return list(b) | sort-the-people | O(nlogn) Solution | anup_omkar | 0 | 5 | sort the people | 2,418 | 0.82 | Easy | 33,063 |
https://leetcode.com/problems/sort-the-people/discuss/2639180/Python-two-line-of-code-explained!!! | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
z = sorted(list(zip(heights, names)),key=lambda x: (-x[0]))
return [y for x,y in z]
'''
1. zip(heights, names) connects height[0] with names[0].......
2. 2.sorted() key -> is used to sort by to determine by which indices to sort the array
3. the last one is list comprehension and unpacking the zipped list
''' | sort-the-people | Python two line of code explained!!! | pandish | 0 | 21 | sort the people | 2,418 | 0.82 | Easy | 33,064 |
https://leetcode.com/problems/sort-the-people/discuss/2634136/Sort-the-People-oror-Python-oror-Dictionary | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
d={}
for i in range(len(names)):
d[heights[i]]=names[i]
#print(d)
s={}
s=sorted(d.items(),reverse=True)
#print(s)
ans=[]
for i in range(len(s)):
ans.append(s[i][1])
return ans` | sort-the-people | Sort the People || Python || Dictionary | shagun_pandey | 0 | 18 | sort the people | 2,418 | 0.82 | Easy | 33,065 |
https://leetcode.com/problems/sort-the-people/discuss/2633562/One-line-solution-in-Python-faster-than-94 | class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
return [n for _, n in sorted((-h, n) for h, n in zip(heights, names))] | sort-the-people | One line solution in Python, faster than 94% | metaphysicalist | 0 | 22 | sort the people | 2,418 | 0.82 | Easy | 33,066 |
https://leetcode.com/problems/longest-subarray-with-maximum-bitwise-and/discuss/2648255/Group-By-and-One-Pass | class Solution:
def longestSubarray(self, nums: List[int]) -> int:
max_n = max(nums)
return max(len(list(it)) for n, it in groupby(nums) if n == max_n) | longest-subarray-with-maximum-bitwise-and | Group By and One-Pass | votrubac | 7 | 63 | longest subarray with maximum bitwise and | 2,419 | 0.477 | Medium | 33,067 |
https://leetcode.com/problems/longest-subarray-with-maximum-bitwise-and/discuss/2741891/Python-O(N)-with-explanation | class Solution:
def longestSubarray(self, nums: List[int]) -> int:
maxim = max(nums)
result = 1
current = 0
for num in nums:
if (num == maxim):
current = current + 1
result = max(result, current)
else:
current = 0
return result | longest-subarray-with-maximum-bitwise-and | Python O(N) with explanation | hallucinogen | 0 | 1 | longest subarray with maximum bitwise and | 2,419 | 0.477 | Medium | 33,068 |
https://leetcode.com/problems/longest-subarray-with-maximum-bitwise-and/discuss/2715773/Python-3-Two-lines-O(n) | class Solution:
def longestSubarray(self, nums: List[int]) -> int:
mx = max(nums)
return max(map(len, ''.join(map(lambda y: ('0', '1')[mx == y], nums)).split('0'))) | longest-subarray-with-maximum-bitwise-and | [Python 3] Two lines O(n) | qsqnk | 0 | 7 | longest subarray with maximum bitwise and | 2,419 | 0.477 | Medium | 33,069 |
https://leetcode.com/problems/longest-subarray-with-maximum-bitwise-and/discuss/2669704/Python3-one-liner-using-itertools.groupby | class Solution:
def longestSubarray(self, nums: List[int]) -> int:
x = max(nums)
res = 1
for c, g in itertools.groupby(nums):
if c == x:
res = max(res, len(list(g)))
return res | longest-subarray-with-maximum-bitwise-and | Python3 one liner using itertools.groupby | acerunner | 0 | 5 | longest subarray with maximum bitwise and | 2,419 | 0.477 | Medium | 33,070 |
https://leetcode.com/problems/longest-subarray-with-maximum-bitwise-and/discuss/2669704/Python3-one-liner-using-itertools.groupby | class Solution:
def longestSubarray(self, nums: List[int]) -> int:
return max([(n, len(list(g))) for n, g in itertools.groupby(nums)])[1] | longest-subarray-with-maximum-bitwise-and | Python3 one liner using itertools.groupby | acerunner | 0 | 5 | longest subarray with maximum bitwise and | 2,419 | 0.477 | Medium | 33,071 |
https://leetcode.com/problems/longest-subarray-with-maximum-bitwise-and/discuss/2621437/O(n)-with-maximum-length-of-sub-array-consisting-of-highest-values | class Solution:
def longestSubarray(self, nums: List[int]) -> int:
ans = 0
vmax = -1
cmax = 0
for i in range(len(nums)):
if vmax==-1 or nums[vmax]<nums[i]:
vmax = i
cmax = 1
ans = 1
elif nums[vmax]==nums[i]:
cmax = cmax + 1
ans = max(ans, cmax)
elif nums[vmax]>nums[i]:
cmax = 0
return ans | longest-subarray-with-maximum-bitwise-and | O(n) with maximum length of sub-array consisting of highest values | dntai | 0 | 4 | longest subarray with maximum bitwise and | 2,419 | 0.477 | Medium | 33,072 |
https://leetcode.com/problems/longest-subarray-with-maximum-bitwise-and/discuss/2620799/Python3-O(n)-count-maximum-length-of-continuous-maximum-numbers | class Solution:
def longestSubarray(self, nums: List[int]) -> int:
maxi = max(nums)
res = 1
current = 0
for i in range(len(nums)):
if nums[i] == maxi:
current += 1
else:
res = max(res, current)
current = 0
return max(res, current) | longest-subarray-with-maximum-bitwise-and | Python3 O(n) count maximum length of continuous maximum numbers | xxHRxx | 0 | 3 | longest subarray with maximum bitwise and | 2,419 | 0.477 | Medium | 33,073 |
https://leetcode.com/problems/longest-subarray-with-maximum-bitwise-and/discuss/2620742/Python-Simple-Python-Solution | class Solution:
def longestSubarray(self, nums: List[int]) -> int:
result = 0
current_subarry_length = 0
max_value_of_nums = max(nums)
for index in range(len(nums)):
if nums[index] == max_value_of_nums:
current_subarry_length = current_subarry_length + 1
result = max(result, current_subarry_length)
else:
current_subarry_length = 0
return result | longest-subarray-with-maximum-bitwise-and | [ Python ] ✅✅ Simple Python Solution 🥳✌👍 | ASHOK_KUMAR_MEGHVANSHI | 0 | 28 | longest subarray with maximum bitwise and | 2,419 | 0.477 | Medium | 33,074 |
https://leetcode.com/problems/longest-subarray-with-maximum-bitwise-and/discuss/2620615/Python3-or-longest-Consecutive-occurrence-of-max-element | class Solution:
def longestSubarray(self, nums: List[int]) -> int:
mx=max(nums)
ans=0
v=0
for i in range(len(nums)):
if nums[i]==mx:
v+=1
ans=max(ans,v)
else:
v=0
return ans | longest-subarray-with-maximum-bitwise-and | [Python3] | longest Consecutive occurrence of max element | swapnilsingh421 | 0 | 3 | longest subarray with maximum bitwise and | 2,419 | 0.477 | Medium | 33,075 |
https://leetcode.com/problems/find-all-good-indices/discuss/2620637/Python3-Two-passes-O(n)-with-line-by-line-comments. | class Solution:
def goodIndices(self, nums: List[int], k: int) -> List[int]:
### forward pass.
forward = [False]*len(nums) ### For the forward pass, store if index i is good or not.
stack = []
for i in range(len(nums)):
### if the leangth of stack is greater or equal to k, it means this index is good.
if len(stack)>=k:
forward[i] = True
### if the stack is empty, just add the current number to it.
if not stack:
stack.append(nums[i])
### check to see if the current number is smaller or equal to the last number in stack, if it is not, put this number into the stack.
else:
if nums[i]<=stack[-1]:
stack.append(nums[i])
else:
stack = [nums[i]]
### backward pass
res = []
stack = []
for i in reversed(range(len(nums))):
### Check to see if the length of stack is greater or equal to k and also check if the forward pass at this index is Ture.
if len(stack)>=k and forward[i]:
res.append(i)
if not stack:
stack.append(nums[i])
else:
if nums[i]<=stack[-1]:
stack.append(nums[i])
else:
stack = [nums[i]]
return res[::-1] | find-all-good-indices | [Python3] Two passes O(n) with line by line comments. | md2030 | 34 | 1,400 | find all good indices | 2,420 | 0.372 | Medium | 33,076 |
https://leetcode.com/problems/find-all-good-indices/discuss/2845486/Clean-Fast-Python3-or-Prefix-and-Suffix | class Solution:
def goodIndices(self, nums: List[int], k: int) -> List[int]:
n = len(nums)
non_inc_prefix = [1] * n
for i in range(1, n-1):
if nums[i-1] >= nums[i]:
non_inc_prefix[i] += non_inc_prefix[i-1]
non_dec_suffix = [1] * n
for i in range(n-2, 0, -1):
if nums[i] <= nums[i+1]:
non_dec_suffix[i] += non_dec_suffix[i+1]
good = []
for i in range(k, n - k):
if non_inc_prefix[i-1] >= k <= non_dec_suffix[i+1]:
good.append(i)
return good | find-all-good-indices | Clean, Fast Python3 | Prefix & Suffix | ryangrayson | 0 | 1 | find all good indices | 2,420 | 0.372 | Medium | 33,077 |
https://leetcode.com/problems/find-all-good-indices/discuss/2836594/Python-(Simple-DP) | class Solution:
def goodIndices(self, nums, k):
n, res = len(nums), []
dec, inc = [1]*n, [1]*n
for i in range(1,n):
if nums[i] <= nums[i-1]:
dec[i] = dec[i-1] + 1
for i in range(n-2,-1,-1):
if nums[i] <= nums[i+1]:
inc[i] = inc[i+1] + 1
for i in range(k,n-k):
if dec[i-1] >= k and inc[i+1] >= k:
res.append(i)
return res | find-all-good-indices | Python (Simple DP) | rnotappl | 0 | 3 | find all good indices | 2,420 | 0.372 | Medium | 33,078 |
https://leetcode.com/problems/find-all-good-indices/discuss/2627671/Linear-solution-three-passes | class Solution:
def goodIndices(self, nums: List[int], k: int) -> List[int]:
len_nums = len(nums)
decreasing = [1] * len_nums
left = nums[0]
count = 0
for i, n in enumerate(nums):
if n <= left:
count += 1
else:
count = 1
left = n
decreasing[i] = count
increasing = [1] * len_nums
right = nums[-1]
count = 0
for i in range(len_nums - 1, -1, -1):
if nums[i] <= right:
count += 1
else:
count = 1
right = nums[i]
increasing[i] = count
return [i for i in range(k, len_nums - k)
if decreasing[i - 1] >= k and increasing[i + 1] >= k] | find-all-good-indices | Linear solution, three passes | EvgenySH | 0 | 14 | find all good indices | 2,420 | 0.372 | Medium | 33,079 |
https://leetcode.com/problems/find-all-good-indices/discuss/2624366/Python3-O(n)-build-lookup-table | class Solution:
def goodIndices(self, nums: List[int], k: int) -> List[int]:
size_t = len(nums)
grid1, grid2 = [1], [1]
for t in range(0, size_t-1):
src, tar = nums[t], nums[t+1]
if tar <= src:
if not grid1: grid1.append(1)
else: grid1.append(grid1[-1] + 1)
else:
grid1.append(1)
for t in range(size_t-2, -1, -1):
src, tar = nums[t], nums[t+1]
if tar >= src:
if not grid2: grid2.append(1)
else: grid2.append(grid2[-1] + 1)
else:
grid2.append(1)
grid2 = grid2[::-1]
res = []
for t in range(k, size_t - k):
if grid1[t-1] >= k and grid2[t+1] >= k:
res.append(t)
return res | find-all-good-indices | Python3 O(n) build lookup table | xxHRxx | 0 | 8 | find all good indices | 2,420 | 0.372 | Medium | 33,080 |
https://leetcode.com/problems/find-all-good-indices/discuss/2621424/O(n)-using-updating-in-sliding-window-by-first-last-pairs-(Example-Illustration) | class Solution:
def goodIndices(self, nums: List[int], k: int) -> List[int]:
n = len(nums)
n1 = 0
for i in range(1, k):
if nums[i-1]>=nums[i]:
n1 += 1
n2 = 0
if 2*k<=n-1:
for i in range(k+2, 2*k+1):
if nums[i-1]<=nums[i]:
n2 += 1
print(nums, k)
ans = []
for i in range(k, n-k, 1):
print("++ ", i, nums[i-k:i], nums[i+1:i+k+1], n1, n2)
if k==1 or (n1==k-1 and n2==k-1):
ans.append(i)
if i+k+1<=n-1:
# before
if nums[i-k]>=nums[i-k+1]:
n1 -= 1
if nums[i-1]>=nums[i]:
n1 += 1
# after
if nums[i+1]<=nums[i+2]:
n2 -= 1
if nums[i+k]<=nums[i+k+1]:
n2 += 1
print("ans:", ans)
print("=" * 20, "\n")
return ans
print = lambda *a, **aa: () | find-all-good-indices | O(n) using updating in sliding window by first, last pairs (Example Illustration) | dntai | 0 | 7 | find all good indices | 2,420 | 0.372 | Medium | 33,081 |
https://leetcode.com/problems/find-all-good-indices/discuss/2621252/Python3-Clean-One-Pass-O(n)-Time-O(1)-Space-(excluding-output) | class Solution:
def goodIndices(self, nums: List[int], k: int) -> List[int]:
res = []
left_count = 1
right_count = 0
prev_left = nums[0]
prev_right = float('-inf')
for i in range(1, len(nums)-k):
if prev_left >= nums[i-1]:
left_count += 1
else:
left_count = 1
prev_left = nums[i-1]
if prev_right <= nums[i+k]:
right_count += 1
else:
right_count = 1
prev_right = nums[i+k]
if left_count >= k and right_count >= k:
res.append(i)
return res | find-all-good-indices | [Python3] Clean One Pass O(n) Time, O(1) Space (excluding output) | rt500 | 0 | 35 | find all good indices | 2,420 | 0.372 | Medium | 33,082 |
https://leetcode.com/problems/find-all-good-indices/discuss/2620777/Python-prefix-and-suffix-arrays-explained | class Solution:
# Create prefix and suffix arrays
# Count elements in pre and suf for i that follow the specified pattern
# if number of elements following the pattern is greater than k then add i to the answer
# return sorted answer as specified in the question
def goodIndices(self, nums: List[int], k: int) -> List[int]:
n = len(nums)
pre, suf = [0] * n, [0] * n
l = 1
for i in range(1, n):
pre[i] = l
if nums[i] <= nums[i - 1]: l += 1
else: l = 1
l = 1
for i in range(n - 2, -1, -1):
suf[i] = l
if nums[i] <= nums[i + 1]: l += 1
else: l = 1
res = []
for i in range(1, n - 1):
if pre[i] >= k and suf[i] >= k: res.append(i)
return res | find-all-good-indices | Python prefix and suffix arrays explained | shiv-codes | 0 | 25 | find all good indices | 2,420 | 0.372 | Medium | 33,083 |
https://leetcode.com/problems/find-all-good-indices/discuss/2620572/Python3-or-Easy-O(N) | class Solution:
def goodIndices(self, nums: List[int], k: int) -> List[int]:
n=len(nums)
left=[False for i in range(n)]
right=[False for i in range(n)]
ls,rs=-1,n
for i in range(1,n):
if i>=k:
if i-ls>k:
left[i]=True
if nums[i]>nums[i-1]:
ls=i-1
for j in range(n-2,-1,-1):
if j<n-k:
if rs-j>k:
right[j]=True
if nums[j]>nums[j+1]:
rs=j+1
ans=[]
for i in range(n):
if left[i] and right[i]:
ans.append(i)
return ans | find-all-good-indices | [Python3] | Easy O(N) | swapnilsingh421 | 0 | 28 | find all good indices | 2,420 | 0.372 | Medium | 33,084 |
https://leetcode.com/problems/number-of-good-paths/discuss/2623051/Python-3Hint-solution-Heap-%2B-Union-find | class Solution:
def numberOfGoodPaths(self, vals: List[int], edges: List[List[int]]) -> int:
n = len(vals)
g = defaultdict(list)
# start from node with minimum val
for a, b in edges:
heappush(g[a], (vals[b], b))
heappush(g[b], (vals[a], a))
loc = list(range(n))
def find(x):
if loc[x] != x:
loc[x] = find(loc[x])
return loc[x]
def union(x, y):
a, b = find(x), find(y)
if a != b:
loc[b] = a
# node by val
v = defaultdict(list)
for i, val in enumerate(vals):
v[val].append(i)
ans = n
for k in sorted(v):
for node in v[k]:
# build graph if neighboring node <= current node val
while g[node] and g[node][0][0] <= k:
nei_v, nei = heappop(g[node])
union(node, nei)
# Count unioned groups
grp = Counter([find(x) for x in v[k]])
# for each unioned group, select two nodes (order doesn't matter)
ans += sum(math.comb(x, 2) for x in grp.values())
return ans | number-of-good-paths | [Python 3]Hint solution Heap + Union find | chestnut890123 | 0 | 57 | number of good paths | 2,421 | 0.398 | Hard | 33,085 |
https://leetcode.com/problems/number-of-good-paths/discuss/2621342/O(nlogn)-using-Union-Find-Merging-and-counting-from-low-to-high-values-(Example-Illustration) | class Solution:
def numberOfGoodPaths(self, vals: List[int], edges: List[List[int]]) -> int:
def find(root, x):
if root[x]==x:
return x
else:
root[x] = find(root, root[x])
return root[x]
n = len(vals)
nodes = {}
for i in range(n):
nodes[vals[i]] = nodes.get(vals[i], set([]))
nodes[vals[i]].add(i)
print("nodes:", nodes)
adj = [[] for _ in range(n)]
for ai, bi in edges:
adj[ai].append(bi)
adj[bi].append(ai)
print("adj:", adj)
keys = sorted(nodes.keys(), key = lambda x: x)
root = list(range(n))
ans = len(root)
print("Init:", "root:", root, "ans:", ans)
for k in keys:
q = nodes[k]
for u in q:
for v in adj[u]:
if vals[v]<=vals[u]:
root_u = find(root, u)
root_v = find(root, v)
if root_u != root_v:
root[root_u] = root_v
levels = {}
for u in q:
root_u = find(root, u)
levels[root_u] = levels.get(root_u, 0) + 1
cnt = sum([levels[i]*(levels[i]-1)//2 for i in levels])
ans = ans + cnt
print("+ val", k, root, levels, cnt)
print("ans:", ans)
print("=" * 20, "\n")
return ans
pass
print = lambda *a, **aa: () | number-of-good-paths | O(nlogn) using Union-Find Merging and counting from low to high values (Example Illustration) | dntai | 0 | 31 | number of good paths | 2,421 | 0.398 | Hard | 33,086 |
https://leetcode.com/problems/number-of-good-paths/discuss/2621342/O(nlogn)-using-Union-Find-Merging-and-counting-from-low-to-high-values-(Example-Illustration) | class Solution:
def numberOfGoodPaths(self, vals: List[int], edges: List[List[int]]) -> int:
n = len(vals)
nodes = {}
for i in range(n):
nodes[vals[i]] = nodes.get(vals[i], set([]))
nodes[vals[i]].add(i)
# print(nodes)
adj = [set([]) for _ in range(n)]
for ai, bi in edges:
adj[ai].add(bi)
adj[bi].add(ai)
# print(adj)
def bfs(s, chk):
ret = [s]
q = [s]
chk[s] = True
while len(q)>0:
u = q.pop(0)
for v in adj[u]:
if chk[v]==False and vals[s]>=vals[v]:
q.append(v)
chk[v] = True
if vals[v]==vals[s]:
ret.append(v)
return ret
keys = sorted(nodes.keys(), key = lambda x: x)
chk = [False] * n
ans = len(vals)
for k in keys:
qq = nodes[k]
print("++ ", k, len(qq))
sys.stdout.flush()
while len(qq)>0:
v = qq.pop()
ret = bfs(v, chk)
nr = len(ret)
ans = ans + (nr * (nr-1)) // 2
for t in ret:
qq.discard(t)
return ans
print = lambda *a, **aa: () | number-of-good-paths | O(nlogn) using Union-Find Merging and counting from low to high values (Example Illustration) | dntai | 0 | 31 | number of good paths | 2,421 | 0.398 | Hard | 33,087 |
https://leetcode.com/problems/remove-letter-to-equalize-frequency/discuss/2660629/Counter-of-Counter | class Solution:
def equalFrequency(self, word: str) -> bool:
cnt = Counter(Counter(word).values())
if (len(cnt) == 1):
return list(cnt.keys())[0] == 1 or list(cnt.values())[0] == 1
if (len(cnt) == 2):
f1, f2 = min(cnt.keys()), max(cnt.keys())
return (f1 + 1 == f2 and cnt[f2] == 1) or (f1 == 1 and cnt[f1] == 1)
return False | remove-letter-to-equalize-frequency | Counter of Counter | votrubac | 9 | 336 | remove letter to equalize frequency | 2,423 | 0.193 | Easy | 33,088 |
https://leetcode.com/problems/remove-letter-to-equalize-frequency/discuss/2647798/Python3-OneLine-BruteForce | class Solution:
def equalFrequency(self, word: str) -> bool:
return any(len(set(Counter(word[:i]+word[i+1:]).values()))==1 for i in range(len(word))) | remove-letter-to-equalize-frequency | Python3, OneLine BruteForce | Silvia42 | 1 | 17 | remove letter to equalize frequency | 2,423 | 0.193 | Easy | 33,089 |
https://leetcode.com/problems/remove-letter-to-equalize-frequency/discuss/2647798/Python3-OneLine-BruteForce | class Solution:
def equalFrequency(self, word: str) -> bool:
for i in range(len(word)):
z=word[:i]+word[i+1:]
if len(set(Counter(z).values()))==1:
return True
return False | remove-letter-to-equalize-frequency | Python3, OneLine BruteForce | Silvia42 | 1 | 17 | remove letter to equalize frequency | 2,423 | 0.193 | Easy | 33,090 |
https://leetcode.com/problems/remove-letter-to-equalize-frequency/discuss/2647389/Python-Solution-or-An-Easy-Solution | class Solution:
def isequal(self, c):
c = Counter(c)
return len(list(set(list(c.values())))) == 1
def equalFrequency(self, word: str) -> bool:
for i in range(len(word)):
if self.isequal(word[:i] + word[i + 1:]):
return True
return False | remove-letter-to-equalize-frequency | Python Solution | An Easy Solution | cyber_kazakh | 1 | 55 | remove letter to equalize frequency | 2,423 | 0.193 | Easy | 33,091 |
https://leetcode.com/problems/remove-letter-to-equalize-frequency/discuss/2646978/Four-conditions-(hard-problem!) | class Solution:
def equalFrequency(self, word: str) -> bool:
counter = Counter(word)
list = []
for _, v in counter.items():
if v:
list.append(v)
list.sort()
if len(list) == 1: # example: 'ddddd'
return True
if list[-1] == 1: # example: 'abcdefg'
return True
if list[0] == 1 and list[1] == list[-1]: # example: 'bdddfff'
return True
if list[-1] == list[-2] + 1 and list[0] == list[-2]: # example: 'bbbdddgggg'
return True
# all other cases are bad conditions
return False | remove-letter-to-equalize-frequency | Four conditions (hard problem!) | pya | 1 | 58 | remove letter to equalize frequency | 2,423 | 0.193 | Easy | 33,092 |
https://leetcode.com/problems/remove-letter-to-equalize-frequency/discuss/2646871/Python-frequency-Counter | class Solution:
def equalFrequency(self, word: str) -> bool:
freq = Counter(word).values()
return (len(freq) == 1 or
min(freq) == max(freq) == 1 or
(min(freq) == max(freq) - 1 and (
len(word) == min(freq) * len(freq) + 1 or
len(word) == max(freq) * len(freq) - 1)
)
) | remove-letter-to-equalize-frequency | Python, frequency Counter | blue_sky5 | 1 | 55 | remove letter to equalize frequency | 2,423 | 0.193 | Easy | 33,093 |
https://leetcode.com/problems/remove-letter-to-equalize-frequency/discuss/2646748/Easy-to-understand. | class Solution:
def equalFrequency(self, word: str) -> bool:
m = {}
flag = True
for i in word:
if i in m:
m[i]+=1
else:
m[i]=1
m1 = {}
for key,val in m.items():
if m[key] in m1:
m1[m[key]]+=1
else:
m1[m[key]] = 1
if len(m1)>2:
return False
maxi = -sys.maxsize
mini = sys.maxsize
for key,val in m1.items():
maxi = max(maxi,key)
mini = min(mini,key)
if len(m1)==1 and maxi==1: #eg: abcd
return True
if (maxi==mini and len(m1)==1 and m1[maxi]==1): #eg: aaaa
return True
if maxi-mini==1 and (m1[maxi]==1 or m1[mini]==1): #remaining all
return True
else:
return False | remove-letter-to-equalize-frequency | Easy to understand. | kamal0308 | 1 | 86 | remove letter to equalize frequency | 2,423 | 0.193 | Easy | 33,094 |
https://leetcode.com/problems/remove-letter-to-equalize-frequency/discuss/2807473/O(n)-32ms-Python-use-word-only-once! | class Solution:
def equalFrequency(self, word: str) -> bool:
#go over a word and get the frequencies for every char a-z
#return int[26]
#constraint: only accepts words with lowercase chars a-z inside
def getCharFreqs(word: str) -> int:
counts = [0 for i in range(26)] #alphabet freqs initial 0
for n in range(len(word)): #go over word
counts[ord(word[n])-97] += 1 #add the char to the freqs
return counts
#If there are only zeros and maybe one other frequency in the counts, return true
def checkCounts(counts: list) -> bool:
freq = 0
for i in range(26):
if counts[i] == 0: continue #Just unused char
if counts[i] != 0 and freq == 0: freq = counts[i] #Not unused char, initialize the var to look for more
if counts[i] == freq: continue #just another one with known frequency
if counts[i] != freq: return False #Found another unknown frequency!
return True #There is only one known frequency or not even one
counts = getCharFreqs(word) #O(n) go over word, extract frequencies for every char a-z
for i in range(26): #For each char in the alphabet
if counts[i] > 0: #Only test if this char got used
counts[i] -= 1 #Remove one of these chars
if (checkCounts(counts)): return True #Check for true-condition
counts[i] += 1 #Else take back the useless change
return False #Didnt found a solution | remove-letter-to-equalize-frequency | O(n) 32ms Python - use word only once! | lucasscodes | 0 | 6 | remove letter to equalize frequency | 2,423 | 0.193 | Easy | 33,095 |
https://leetcode.com/problems/remove-letter-to-equalize-frequency/discuss/2729822/Easy-understanding-python-solution-with-explanation | class Solution:
def equalFrequency(self, w: str) -> bool:
#pattern 1: 1, x, x (delete 1)
#pattern 2: x, x, x + 1 (delete 1 from x + 1)
mp = {}
n = len(w)
for i in range(len(w)):
mp[w[i]] = mp.get(w[i], 0) + 1
print(mp)
freq = list(mp.values())
freq.sort()
print(freq)
# pattern 1
p1, p2 = False, False
if freq[0] == 1:
p1 = True
for i in range(1, len(freq) - 1):
if freq[i] != freq[i + 1]:
p1 = False
if p1:
return True
# pattern 2
p2 = True
freq[len(freq)-1] -= 1
for i in range(len(freq) - 1):
if freq[i] != freq[i + 1]:
p2 = False
if p2:
return True
return False | remove-letter-to-equalize-frequency | Easy understanding python solution with explanation | jackson-cmd | 0 | 6 | remove letter to equalize frequency | 2,423 | 0.193 | Easy | 33,096 |
https://leetcode.com/problems/remove-letter-to-equalize-frequency/discuss/2694141/2423.-Remove-Letters-to-Equalize-Frequency. | class Solution:
def equalFrequency(self, word: str) -> bool:
dic={}
for i in range(len(word)):
if word[i] not in dic:
dic[word[i]]=1
else:
dic[word[i]]+=1
arr=[]
for i in dic:
arr.append(dic[i])
for i in range(len(arr)):
arr[i]=arr[i]-1
if len(set(arr))==1:
return 1
if len(set(arr))==2 and min(arr)==0:
return 1
else:
arr[i]+=1
return 0 | remove-letter-to-equalize-frequency | 2423. Remove Letters to Equalize Frequency. | rinkon | 0 | 5 | remove letter to equalize frequency | 2,423 | 0.193 | Easy | 33,097 |
https://leetcode.com/problems/remove-letter-to-equalize-frequency/discuss/2679224/Python-Solution-Beats-around-88-in-speed | class Solution:
def equalFrequency(self, word: str) -> bool:
counter = {}
maxValue = -1
oneCounter = 0
maxCounter = 0
maxMinusCounter = 0
for letter in word:
if letter not in counter:
counter[letter] = 0
counter[letter] += 1
maxValue = max(maxValue, counter[letter])
for letter in counter:
if counter[letter] == 1:
oneCounter += 1
if counter[letter] == maxValue:
maxCounter += 1
if counter[letter] == maxValue - 1:
maxMinusCounter += 1
return (oneCounter == len(counter) or
oneCounter == 1 and maxCounter + 1 >= len(counter) or
maxMinusCounter + 1 == len(counter)); | remove-letter-to-equalize-frequency | Python Solution Beats around 88% in speed | Omyx | 0 | 8 | remove letter to equalize frequency | 2,423 | 0.193 | Easy | 33,098 |
https://leetcode.com/problems/remove-letter-to-equalize-frequency/discuss/2670999/Easy-and-fast-Python3-solution%3A-Faster-than-97-of-submissions | class Solution:
def equalFrequency(self, word: str) -> bool:
frequencies = [word.count(i) for i in sorted(set(word))]
for i in range(len(frequencies)):
frequencies_copy = frequencies[:]
if frequencies_copy[i] == 1:
frequencies_copy.pop(i)
else:
frequencies_copy[i] -= 1
if len(set(frequencies_copy)) == 1:
return True
return False | remove-letter-to-equalize-frequency | Easy and fast Python3 solution: Faster than 97% of submissions | y-arjun-y | 0 | 78 | remove letter to equalize frequency | 2,423 | 0.193 | Easy | 33,099 |
Subsets and Splits