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/number-of-ways-to-split-array/discuss/2039264/Python-O(1)-space-Beats-100
|
class Solution:
def waysToSplitArray(self, nums: List[int]) -> int:
count, left_sum, right_sum = 0, 0, sum(nums)
for i in range(len(nums)-1):
left_sum+=nums[i]
right_sum-=nums[i]
if left_sum>=right_sum:
count+=1
return count
|
number-of-ways-to-split-array
|
✅ Python O(1) space Beats 100%
|
constantine786
| 0
| 12
|
number of ways to split array
| 2,270
| 0.446
|
Medium
| 31,400
|
https://leetcode.com/problems/number-of-ways-to-split-array/discuss/2038251/Python-3-Prefix-Sum-Easy-and-Clear-Solution
|
class Solution:
def waysToSplitArray(self, nums: List[int]) -> int:
running_sum = []
total = 0
for i, num in enumerate(nums):
total += num
running_sum.append(total)
total = sum(nums)
splits = 0
n = len(nums)
for i in range(n-1):
if running_sum[i] >= total-running_sum[i]:
splits += 1
return splits
|
number-of-ways-to-split-array
|
[Python 3] Prefix Sum Easy and Clear Solution
|
hari19041
| 0
| 89
|
number of ways to split array
| 2,270
| 0.446
|
Medium
| 31,401
|
https://leetcode.com/problems/maximum-white-tiles-covered-by-a-carpet/discuss/2148636/Python3-greedy
|
class Solution:
def maximumWhiteTiles(self, tiles: List[List[int]], carpetLen: int) -> int:
tiles.sort()
ans = ii = val = 0
for i in range(len(tiles)):
hi = tiles[i][0] + carpetLen - 1
while ii < len(tiles) and tiles[ii][1] <= hi:
val += tiles[ii][1] - tiles[ii][0] + 1
ii += 1
partial = 0
if ii < len(tiles): partial = max(0, hi - tiles[ii][0] + 1)
ans = max(ans, val + partial)
val -= tiles[i][1] - tiles[i][0] + 1
return ans
|
maximum-white-tiles-covered-by-a-carpet
|
[Python3] greedy
|
ye15
| 1
| 105
|
maximum white tiles covered by a carpet
| 2,271
| 0.327
|
Medium
| 31,402
|
https://leetcode.com/problems/maximum-white-tiles-covered-by-a-carpet/discuss/2061324/Python-Prefixsum-Binary-Search
|
class Solution:
def maximumWhiteTiles(self, tiles: List[List[int]], carpetLen: int) -> int:
tiles = sorted(tiles, key = lambda x : x[0])
prefix_sum = [0]
res = 0
for idx, (start, end) in enumerate(tiles):
cur_cover = 0
prefix_sum.append(prefix_sum[-1] + (end - start + 1))
begin = max(0, end - carpetLen + 1)
l, r = -1, len(tiles)
while l + 1 < r:
mid = (l + r) // 2 # >> 1
if tiles[mid][0] <= begin:
l = mid
else:
r = mid
if tiles[max(0, l)][0] <= begin <= tiles[max(0, l)][1]:
cur_cover += tiles[l][1] - begin + 1
cur_cover += prefix_sum[idx + 1] - prefix_sum[l + 1]
res = max(res, cur_cover)
return res
|
maximum-white-tiles-covered-by-a-carpet
|
Python, Prefixsum, Binary Search
|
yzhao156
| 1
| 73
|
maximum white tiles covered by a carpet
| 2,271
| 0.327
|
Medium
| 31,403
|
https://leetcode.com/problems/maximum-white-tiles-covered-by-a-carpet/discuss/2714775/Python3-or-Self-Explanatory-Code-with-Comments-or-Sliding-Window
|
class Solution:
def maximumWhiteTiles(self, tiles: List[List[int]], carpetLength: int) -> int:
n=len(tiles)
tiles.sort(key=lambda x:x[0]) #sorting on starting point
i,j,whiteMarbel,ans=[0]*4
while i<n:
nextStartingPoint=tiles[i][0]+carpetLength #carpet will cover till nextStartingPoint-1.
partial=0
while j<n and tiles[j][1]<nextStartingPoint:
whiteMarbel+=tiles[j][1]-tiles[j][0]+1 #storing all whitemarbels which are covered by carpet.
j+=1
if j<n:
partial=max(0,nextStartingPoint-tiles[j][0]) #if current laid carpet overlap with partial interval
ans=max(ans,whiteMarbel+partial) #calculating max value
whiteMarbel-=tiles[i][1]-tiles[i][0]+1 #removing value at ith index as we are sliding starting point of carpet to next index
i+=1
return ans
|
maximum-white-tiles-covered-by-a-carpet
|
[Python3] | Self Explanatory Code with Comments | Sliding Window
|
swapnilsingh421
| 0
| 8
|
maximum white tiles covered by a carpet
| 2,271
| 0.327
|
Medium
| 31,404
|
https://leetcode.com/problems/maximum-white-tiles-covered-by-a-carpet/discuss/2047734/java-python-sorting-and-sliding-window
|
class Solution:
def maximumWhiteTiles(self, tiles: List[List[int]], carpetLen: int) -> int:
if carpetLen == 1 : return 1
tiles.sort()
ans = i = j = tmp = 0
while ans != carpetLen :
end = tiles[i][0] + carpetLen - 1
while j != len(tiles) and tiles[j][1] <= end:
tmp += tiles[j][1] - tiles[j][0] + 1
j += 1
if j == len(tiles) : return max(ans, tmp)
if end >= tiles[j][0] : ans = max(ans, tmp + min(end, tiles[j][1]) - tiles[j][0] + 1)
else :ans = max(ans, tmp)
if tmp == 0 : j += 1
else : tmp -= (tiles[i][1] - tiles[i][0] + 1)
i += 1
return ans
|
maximum-white-tiles-covered-by-a-carpet
|
java, python - sorting & sliding window
|
ZX007java
| 0
| 77
|
maximum white tiles covered by a carpet
| 2,271
| 0.327
|
Medium
| 31,405
|
https://leetcode.com/problems/maximum-white-tiles-covered-by-a-carpet/discuss/2039156/Python-3Prefix-Sum-%2B-Two-Way-Binary-Search
|
class Solution:
def maximumWhiteTiles(self, tiles: List[List[int]], carpetLen: int) -> int:
tiles.sort()
starts, ends = [], []
acc = [0]
for a, b in tiles:
starts.append(a)
ends.append(b)
acc.append(acc[-1] + b - a + 1)
ans = 0
for i, (a, b) in enumerate(tiles):
# from start to right
cover = min(tiles[-1][-1], a + carpetLen - 1)
loc = bisect.bisect(starts, cover)
if cover - starts[loc - 1] + 1 >= acc[loc] - acc[loc - 1]:
ans = max(ans, acc[loc] - acc[i])
else:
ans = max(ans, acc[loc - 1] - acc[i] + cover - starts[loc - 1] + 1)
# from end to left
cover2 = max(tiles[0][0], b - carpetLen + 1)
loc2 = bisect.bisect_left(ends, cover2)
if ends[loc2] - cover2 + 1 >= acc[loc2+1] - acc[loc2]:
ans = max(ans, acc[i + 1] - acc[loc2])
else:
ans = max(ans, acc[i + 1] - acc[loc2 + 1] + ends[loc2] - cover2 + 1)
return ans
|
maximum-white-tiles-covered-by-a-carpet
|
[Python 3]Prefix Sum + Two Way Binary Search
|
chestnut890123
| 0
| 52
|
maximum white tiles covered by a carpet
| 2,271
| 0.327
|
Medium
| 31,406
|
https://leetcode.com/problems/maximum-white-tiles-covered-by-a-carpet/discuss/2038987/2-Python-Solutions
|
class Solution:
def maximumWhiteTiles(self, T: List[List[int]], k: int) -> int:
T.sort()
l=0 ; r=0 ; tot=0 ; ans=0
while l<len(T):
if r==l or T[r][0]+k>T[l][1]:
tot+=T[l][1]-T[l][0]+1
ans=max(ans,tot)
l+=1
else:
ans=max(ans,tot+T[r][0]+k-T[l][0])
tot-=T[r][1]-T[r][0]+1
r+=1
return ans
|
maximum-white-tiles-covered-by-a-carpet
|
2 Python Solutions
|
Taha-C
| 0
| 61
|
maximum white tiles covered by a carpet
| 2,271
| 0.327
|
Medium
| 31,407
|
https://leetcode.com/problems/maximum-white-tiles-covered-by-a-carpet/discuss/2038987/2-Python-Solutions
|
class Solution:
def maximumWhiteTiles(self, T: List[List[int]], k: int) -> int:
T.sort() ; ans=0
A=list(accumulate([h-l+1 for l,h in T], initial=0))
L=[T[i][0] for i in range(len(T))]
for i in range(len(L)):
end=bisect_right(L,L[i]+k-1)
ans=max(ans,A[end]-A[i]-(T[end-1][1]-(L[i]+k-1) if T[end-1][1]>L[i]+k-1 else 0))
return ans
|
maximum-white-tiles-covered-by-a-carpet
|
2 Python Solutions
|
Taha-C
| 0
| 61
|
maximum white tiles covered by a carpet
| 2,271
| 0.327
|
Medium
| 31,408
|
https://leetcode.com/problems/maximum-white-tiles-covered-by-a-carpet/discuss/2038232/Python-O(len(tiles))
|
class Solution:
def maximumWhiteTiles(self, tiles: List[List[int]], carpetLen: int) -> int:
if not carpetLen or not tiles: return 0
def get_next(itl, lf, rt):
if itl < lf - 1:
next_itr = lf - 1
elif itl == lf - 1:
next_itr = lf
elif lf <= itl < rt:
next_itr = rt
elif itl == rt:
next_itr = rt + 1
else:
next_itr = itl + 1
return next_itr
tiles.sort()
itl = -1
itr = 0
iwl = iwr = 0
nw = 0
max_w = 0
max_iter = tiles[-1][1]
prev_itr = -1
while itr < (tiles[-1][1] + 1):
itl = itr - carpetLen
njump = itr - prev_itr
if njump == 1:
while itr > tiles[iwr][1] and iwr < len(tiles) - 1:
iwr += 1
lf, rt = tiles[iwr]
if lf <= itr <= rt:
nw += 1
next_itr = get_next(itr, lf, rt)
if itl >= 0:
while itl > tiles[iwl][1] and iwl < len(tiles) - 1:
iwl += 1
lf, rt = tiles[iwl]
if lf <= itl <= rt:
nw -= 1
next_itr2 = get_next(itl, lf, rt) + carpetLen
else:
next_itr2 = math.inf
prev_itr = itr
itr = min(next_itr, next_itr2)
else:
lf, rt = tiles[iwr]
if lf <= prev_itr <= rt:
nw += itr - prev_itr
if prev_itr - carpetLen >= 0:
lf, rt = tiles[iwl]
if lf <= prev_itr - carpetLen <= rt:
nw -= itr - prev_itr
prev_itr = itr
itr += 1
max_w = max(max_w, nw)
return max_w
|
maximum-white-tiles-covered-by-a-carpet
|
Python O(len(tiles))
|
yag313
| 0
| 66
|
maximum white tiles covered by a carpet
| 2,271
| 0.327
|
Medium
| 31,409
|
https://leetcode.com/problems/substring-with-largest-variance/discuss/2148640/Python3-pairwise-prefix-sum
|
class Solution:
def largestVariance(self, s: str) -> int:
ans = 0
seen = set(s)
for x in ascii_lowercase:
for y in ascii_lowercase:
if x != y and x in seen and y in seen:
vals = []
for ch in s:
if ch == x: vals.append(1)
elif ch == y: vals.append(-1)
cand = prefix = least = 0
ii = -1
for i, v in enumerate(vals):
prefix += v
if prefix < least:
least = prefix
ii = i
ans = max(ans, min(prefix-least, i-ii-1))
return ans
|
substring-with-largest-variance
|
[Python3] pairwise prefix sum
|
ye15
| 3
| 620
|
substring with largest variance
| 2,272
| 0.374
|
Hard
| 31,410
|
https://leetcode.com/problems/substring-with-largest-variance/discuss/2042949/Python-3-or-Kadane's-Algorithm-Two-Pointers-or-Explanation
|
class Solution:
def largestVariance(self, s: str) -> int:
d = collections.defaultdict(list)
for i, c in enumerate(s): # for each letter, create a list of its indices
d[c].append(i)
ans = 0
for x, chr1 in enumerate(string.ascii_lowercase): # character 1
for chr2 in string.ascii_lowercase[x+1:]: # character 2
if chr1 == chr2 or chr1 not in d or chr2 not in d:
continue
prefix = i = p1 = p2 = 0
hi = hi_idx = lo = lo_idx = 0
n1, n2 = len(d[chr1]), len(d[chr2])
while p1 < n1 or p2 < n2: # two pointers
if p1 < n1 and p2 < n2:
if d[chr1][p1] < d[chr2][p2]:
prefix, p1 = prefix+1, p1+1 # count prefix
else:
prefix, p2 = prefix-1, p2+1
elif p1 < n1:
prefix, p1 = prefix+1, p1+1
else:
prefix, p2 = prefix-1, p2+1
if prefix > hi: # update high value
hi, hi_idx = prefix, i
if prefix < lo: # update low value
lo, lo_idx = prefix, i
ans = max(ans, min(prefix-lo, i-lo_idx-1)) # update ans by calculate difference, i-lo_idx-1 is to handle when only one elements are showing up
ans = max(ans, min(hi-prefix, i-hi_idx-1))
i += 1
return ans
|
substring-with-largest-variance
|
Python 3 | Kadane's Algorithm, Two Pointers | Explanation
|
idontknoooo
| 3
| 1,100
|
substring with largest variance
| 2,272
| 0.374
|
Hard
| 31,411
|
https://leetcode.com/problems/substring-with-largest-variance/discuss/2786797/Python3-%2B-Explanation
|
class Solution:
def largestVariance(self, s: str) -> int:
# This is similar to the Kadane's algorithm, see problem 53 before attempting this one
# Here we take every permutation of 2 characters in a string and then apply Kadane algo to it
# Say string is 'abcdab'
# From the perspective of characters a, b the string is +1, -1, +0, +0, +1, -1
# and we want to maximize this sum
# note that we also want to make sure both a and b are in there, otherwise the numbers
# will be incorrect.
# Also, our operation of finding the sum is not commutative, so we need permutations and
# not combinations.
cntr = Counter(s)
res = 0
for a, b in itertools.permutations(cntr, 2):
a_cnt, b_cnt = cntr[a], cntr[b]
var = 0; seen_a = seen_b = False
for c in s:
# this won't impact the variance -- so ignore
if c not in (a, b): continue
if var < 0:
# we have more b's than a's
# if no more a's left, var would ultimately be -ve -- so break
if not a_cnt: break
# just add the remaining a's to var
if not b_cnt:
res = max(res, var + a_cnt)
break
# we have a's and b's remaining, so restart
seen_a = seen_b = False
var = 0
if c == a:
var += 1
a_cnt -= 1
seen_a = True
if c == b:
var -= 1
b_cnt -= 1
seen_b = True
if seen_a and seen_b:
res = max(res, var)
return res
|
substring-with-largest-variance
|
Python3 + Explanation
|
rasnouk
| 1
| 56
|
substring with largest variance
| 2,272
| 0.374
|
Hard
| 31,412
|
https://leetcode.com/problems/substring-with-largest-variance/discuss/2044294/Python-Kadane's-Algorithm-Simple-Solution
|
class Solution:
def largestVariance(self, s: str) -> int:
counter = Counter(s)
res = 0
for a, b in permutations(counter, 2):
count_a, count_b = 0, 0
remain_b = counter[b]
for ch in s:
if ch not in {a, b}:
continue
if ch == a:
count_a += 1
elif ch == b:
count_b += 1
remain_b -= 1
# Kadane's Algorithm, modified
if count_a < count_b and remain_b > 0:
count_a, count_b = 0, 0
if count_b > 0:
res = max(res, count_a - count_b)
return res
|
substring-with-largest-variance
|
[Python] Kadane's Algorithm, Simple Solution
|
feifei2016
| 0
| 488
|
substring with largest variance
| 2,272
| 0.374
|
Hard
| 31,413
|
https://leetcode.com/problems/find-resultant-array-after-removing-anagrams/discuss/2039752/Weird-Description
|
class Solution:
def removeAnagrams(self, w: List[str]) -> List[str]:
return [next(g) for _, g in groupby(w, sorted)]
|
find-resultant-array-after-removing-anagrams
|
Weird Description
|
votrubac
| 39
| 2,900
|
find resultant array after removing anagrams
| 2,273
| 0.583
|
Easy
| 31,414
|
https://leetcode.com/problems/find-resultant-array-after-removing-anagrams/discuss/2039752/Weird-Description
|
class Solution:
def removeAnagrams(self, w: List[str]) -> List[str]:
return [w[i] for i in range(0, len(w)) if i == 0 or sorted(w[i]) != sorted(w[i - 1])]
|
find-resultant-array-after-removing-anagrams
|
Weird Description
|
votrubac
| 39
| 2,900
|
find resultant array after removing anagrams
| 2,273
| 0.583
|
Easy
| 31,415
|
https://leetcode.com/problems/find-resultant-array-after-removing-anagrams/discuss/2039900/Python-3-or-Intuitive-%2B-How-to-approach-or-O(n)-without-sorting
|
class Solution:
def removeAnagrams(self, words: List[str]) -> List[str]:
res = []
anagrams = {}
for i in range(len(words)):
word = words[i]
counter = [0]*26
for c in word:
counter[ord(c)-ord('a')] += 1
if tuple(counter) not in anagrams:
res.append(word)
else:
if anagrams[tuple(counter)] != words[i-1]:
res.append(word)
anagrams[tuple(counter)] = word
return res
|
find-resultant-array-after-removing-anagrams
|
Python 3 | Intuitive + How to approach | O(n) without sorting
|
ndus
| 11
| 719
|
find resultant array after removing anagrams
| 2,273
| 0.583
|
Easy
| 31,416
|
https://leetcode.com/problems/find-resultant-array-after-removing-anagrams/discuss/2039900/Python-3-or-Intuitive-%2B-How-to-approach-or-O(n)-without-sorting
|
class Solution:
def removeAnagrams(self, words: List[str]) -> List[str]:
res = []
prev = []
for i in range(len(words)):
word = words[i]
counter = [0]*26
for c in word:
counter[ord(c)-ord('a')] += 1
if counter != prev:
res.append(word)
prev = counter
return res
|
find-resultant-array-after-removing-anagrams
|
Python 3 | Intuitive + How to approach | O(n) without sorting
|
ndus
| 11
| 719
|
find resultant array after removing anagrams
| 2,273
| 0.583
|
Easy
| 31,417
|
https://leetcode.com/problems/find-resultant-array-after-removing-anagrams/discuss/2056341/python-small-and-easy-to-understand-solution
|
class Solution:
def removeAnagrams(self, words: List[str]) -> List[str]:
key = ""
result = []
for word in words:
letters = list(word)
letters.sort()
new_key = "".join(letters)
if new_key != key :
key = new_key
result.append(word)
return result
|
find-resultant-array-after-removing-anagrams
|
python - small & easy to understand solution
|
ZX007java
| 3
| 255
|
find resultant array after removing anagrams
| 2,273
| 0.583
|
Easy
| 31,418
|
https://leetcode.com/problems/find-resultant-array-after-removing-anagrams/discuss/2056341/python-small-and-easy-to-understand-solution
|
class Solution:
def removeAnagrams(self, words: List[str]) -> List[str]:
def sort_construct(word):
letters = list(word)
letters.sort()
return "".join(letters)
key = sort_construct(words[0])
result = [words[0]]
for i in range(1, len(words)):
new_key = sort_construct(words[i])
if new_key != key :
key = new_key
result.append(words[i])
return result
|
find-resultant-array-after-removing-anagrams
|
python - small & easy to understand solution
|
ZX007java
| 3
| 255
|
find resultant array after removing anagrams
| 2,273
| 0.583
|
Easy
| 31,419
|
https://leetcode.com/problems/find-resultant-array-after-removing-anagrams/discuss/2040051/Python-Easy-Solution-with-Comments
|
class Solution:
def removeAnagrams(self, words: List[str]) -> List[str]:
if len(words) == 1:
return words
i = 1
while i < len(words):
anagram = "".join(sorted(words[i]))
# check if words[i-1] and words[i] are anagrams
if anagram == "".join(sorted(words[i - 1])):
# if anagrams then remove second instance from the list of words
words.pop(i)
else:
i += 1
return words
|
find-resultant-array-after-removing-anagrams
|
Python Easy Solution with Comments
|
MiKueen
| 2
| 86
|
find resultant array after removing anagrams
| 2,273
| 0.583
|
Easy
| 31,420
|
https://leetcode.com/problems/find-resultant-array-after-removing-anagrams/discuss/2751510/Python-counter-oror-Solution
|
class Solution:
def removeAnagrams(self, words: List[str]) -> List[str]:
res=[words[0]]
for i in range(1,len(words)):
mp1,mp2=Counter(words[i-1]),Counter(words[i])
if mp1!=mp2:
res.append(words[i])
return res
#misread easy to medium
# s=[]
# ans=[]
# for i in words:
# mp=[0]*26
# for j in i:
# mp[ord(j)-ord("a")]+=1
# if str(mp) in s:
# continue
# else:
# ans.append(i)
# s.append(str(mp))
# return ans
|
find-resultant-array-after-removing-anagrams
|
Python counter || Solution
|
cheems_ds_side
| 1
| 98
|
find resultant array after removing anagrams
| 2,273
| 0.583
|
Easy
| 31,421
|
https://leetcode.com/problems/find-resultant-array-after-removing-anagrams/discuss/2451358/Python%3A-Faster-than-upto-97-quick-hashmaplist-answer
|
class Solution:
def removeAnagrams(self, words: List[str]) -> List[str]:
#automatically get first word
hashMap ={0: words[0]}
for i in range(1,len(words)):
notAnagram = words[i]
#sort words in alphabetical order
#if not the same add to hashMap
if sorted(words[i]) != sorted(words[i-1]):
hashMap[i] = notAnagram
return list(hashMap.values())
|
find-resultant-array-after-removing-anagrams
|
Python: Faster than upto 97% quick hashmap/list answer
|
BasedBrenden
| 1
| 95
|
find resultant array after removing anagrams
| 2,273
| 0.583
|
Easy
| 31,422
|
https://leetcode.com/problems/find-resultant-array-after-removing-anagrams/discuss/2345429/Python-or-5-lines
|
class Solution:
def removeAnagrams(self, words: List[str]) -> List[str]:
res = [words[0]]
for i in range(len(words)):
#check anagram
if sorted(words[i-1])!=sorted(words[i]):
res.append(words[i])
return res
|
find-resultant-array-after-removing-anagrams
|
Python | 5 lines
|
ana_2kacer
| 1
| 100
|
find resultant array after removing anagrams
| 2,273
| 0.583
|
Easy
| 31,423
|
https://leetcode.com/problems/find-resultant-array-after-removing-anagrams/discuss/2054810/4-lines-solution-with-Counter
|
class Solution:
def removeAnagrams(self, words: List[str]) -> List[str]:
# `Counter` makes a letter frequency dictionary
# the == operator compares the two dictionaries
# if anagrams then delete the next word
# otherwise, we increment the pointer
pointer = 0
while pointer < len(words)-1:
if ( Counter(words[pointer]) == Counter(words[pointer+1]) ):
words.pop(pointer+1)
else:
pointer+=1
return words
```
|
find-resultant-array-after-removing-anagrams
|
4 lines solution with Counter
|
fhhh09
| 1
| 31
|
find resultant array after removing anagrams
| 2,273
| 0.583
|
Easy
| 31,424
|
https://leetcode.com/problems/find-resultant-array-after-removing-anagrams/discuss/2848766/Counter-and-Stack-Easy-Python3
|
class Solution:
def removeAnagrams(self, words: List[str]) -> List[str]:
from collections import Counter
previous_c = Counter(words[0])
stack = [words[0]]
for i in range(1, len(words)):
current_c = Counter(words[i])
if current_c == previous_c:
continue
else:
previous_c = current_c
stack.append(words[i])
return stack
|
find-resultant-array-after-removing-anagrams
|
Counter and Stack Easy Python3
|
ben_wei
| 0
| 1
|
find resultant array after removing anagrams
| 2,273
| 0.583
|
Easy
| 31,425
|
https://leetcode.com/problems/find-resultant-array-after-removing-anagrams/discuss/2733306/An-Optimized-Python-Sorting-Solution
|
class Solution:
def removeAnagrams(self, words: List[str]) -> List[str]:
prevAna, result = sorted(words[0]), [words[0]]
for word in words[1:]:
currAna = sorted(word)
if currAna != prevAna:
prevAna = currAna
result.append(word)
return result
|
find-resultant-array-after-removing-anagrams
|
An Optimized Python Sorting Solution
|
kcstar
| 0
| 1
|
find resultant array after removing anagrams
| 2,273
| 0.583
|
Easy
| 31,426
|
https://leetcode.com/problems/find-resultant-array-after-removing-anagrams/discuss/2714250/Literally-do-the-operation-in-description.
|
class Solution:
def removeAnagrams(self, words: List[str]) -> List[str]:
"""
Literally do the operation in description.
TC: O(n), SC: O(1)
"""
i = 1
while i < len(words):
if sorted(words[i-1]) == sorted(words[i]):
words.pop(i)
else:
i += 1
return words
|
find-resultant-array-after-removing-anagrams
|
Literally do the operation in description.
|
woora3
| 0
| 1
|
find resultant array after removing anagrams
| 2,273
| 0.583
|
Easy
| 31,427
|
https://leetcode.com/problems/find-resultant-array-after-removing-anagrams/discuss/2697533/Simple-Python-Solution-or-Sorting
|
class Solution:
def removeAnagrams(self, words: List[str]) -> List[str]:
start=0
while start<len(words)-1:
curr=list(words[start])
nxt=list(words[start+1])
curr.sort()
nxt.sort()
if nxt==curr:
words.pop(start+1)
else:
start+=1
return words
|
find-resultant-array-after-removing-anagrams
|
Simple Python Solution | Sorting
|
Siddharth_singh
| 0
| 2
|
find resultant array after removing anagrams
| 2,273
| 0.583
|
Easy
| 31,428
|
https://leetcode.com/problems/find-resultant-array-after-removing-anagrams/discuss/2675799/Simple-Python-Solution
|
class Solution:
def removeAnagrams(self, words: List[str]) -> List[str]:
frequency = dict()
result = []
for word in words:
frequency[word] = Counter(word)
w1 = words[0]
result.append(w1)
for i in range(1, len(words)):
w2 = words[i]
if frequency[w1] != frequency[w2]:
w1 = w2
result.append(w1)
return result
|
find-resultant-array-after-removing-anagrams
|
Simple Python Solution
|
mansoorafzal
| 0
| 23
|
find resultant array after removing anagrams
| 2,273
| 0.583
|
Easy
| 31,429
|
https://leetcode.com/problems/find-resultant-array-after-removing-anagrams/discuss/2649571/Python3-Just-Use-Counter
|
class Solution:
def removeAnagrams(self, words: List[str]) -> List[str]:
w = list(zip(words, [Counter(i) for i in words]))
found = True
while found:
found = False
for i in range(1,len(w)):
if w[i][1] == w[i-1][1]:
del w[i]
found=True
break
return [w[i][0] for i in range(len(w))]
|
find-resultant-array-after-removing-anagrams
|
Python3 Just Use Counter
|
godshiva
| 0
| 8
|
find resultant array after removing anagrams
| 2,273
| 0.583
|
Easy
| 31,430
|
https://leetcode.com/problems/find-resultant-array-after-removing-anagrams/discuss/2572068/3-Python-solutions....Easy-to-understand
|
class Solution:
def removeAnagrams(self, words: List[str]) -> List[str]:
i=1
while i<len(words):
if (''.join(sorted(words[i])))==(''.join(sorted(words[i-1]))):
words.remove(words[i])
else:
i+=1
return words
|
find-resultant-array-after-removing-anagrams
|
3 Python solutions....Easy to understand
|
guneet100
| 0
| 43
|
find resultant array after removing anagrams
| 2,273
| 0.583
|
Easy
| 31,431
|
https://leetcode.com/problems/find-resultant-array-after-removing-anagrams/discuss/2572068/3-Python-solutions....Easy-to-understand
|
class Solution:
def removeAnagrams(self, words: List[str]) -> List[str]:
i=1
while i<len(words):
if sorted(words[i])==sorted(words[i-1]):
words.remove(words[i])
else:
i+=1
return words
|
find-resultant-array-after-removing-anagrams
|
3 Python solutions....Easy to understand
|
guneet100
| 0
| 43
|
find resultant array after removing anagrams
| 2,273
| 0.583
|
Easy
| 31,432
|
https://leetcode.com/problems/find-resultant-array-after-removing-anagrams/discuss/2572068/3-Python-solutions....Easy-to-understand
|
class Solution:
def removeAnagrams(self, words: List[str]) -> List[str]:
i=1
while i<len(words):
if Counter(words[i])==Counter(words[i-1]):
words.remove(words[i])
else:
i+=1
return words
|
find-resultant-array-after-removing-anagrams
|
3 Python solutions....Easy to understand
|
guneet100
| 0
| 43
|
find resultant array after removing anagrams
| 2,273
| 0.583
|
Easy
| 31,433
|
https://leetcode.com/problems/find-resultant-array-after-removing-anagrams/discuss/2385060/Faster-than-90-easy-to-understand-Time-Complexity-O(n)
|
class Solution:
def removeAnagrams(self, words: List[str]) -> List[str]:
n = len(words)
ans = []
j = 0
for i in range(n):
if ("".join(sorted(words[i])) != "".join(sorted(words[j]))) or i == n-1 :
ans.append(words[j])
j = i
if "".join(sorted(words[n-1])) != "".join(sorted(words[n-2])):
ans.append(words[n-1])
return ans
|
find-resultant-array-after-removing-anagrams
|
Faster than 90%, easy to understand, Time Complexity O(n)
|
Virus_003
| 0
| 71
|
find resultant array after removing anagrams
| 2,273
| 0.583
|
Easy
| 31,434
|
https://leetcode.com/problems/find-resultant-array-after-removing-anagrams/discuss/2156510/bottom-up-solution
|
class Solution:
def removeAnagrams(self, words: List[str]) -> List[str]:
# iterate from the bottom up
# keep track of the most recent anagram (start from last word)
# create a helper function that indicates True/False if words are anagrams
# iterate from the second to last word down and compare it to the current
# possible anagram. if they are anagrams, pop(i + 1) and set the new
# anagram to i. if they're not, just reset the new anagram
# do this until i is -1
# Time O(N) Space: O(1)
curr = words[-1]
for i in range(len(words) - 2, -1, -1):
if sorted(words[i]) == sorted(curr):
words.pop(i + 1)
curr = words[i]
return words
|
find-resultant-array-after-removing-anagrams
|
bottom up solution
|
andrewnerdimo
| 0
| 28
|
find resultant array after removing anagrams
| 2,273
| 0.583
|
Easy
| 31,435
|
https://leetcode.com/problems/find-resultant-array-after-removing-anagrams/discuss/2042592/Python-3-or-Easy-to-understand-%2B-short-answer-or-Using-Sorting
|
class Solution:
def removeAnagrams(self, words: List[str]) -> List[str]:
result=[]
result.append(words[0])
for i in words:
if sorted(i)!=sorted(result[-1]):
result.append(i)
return result
|
find-resultant-array-after-removing-anagrams
|
Python 3 | Easy to understand + short answer | Using Sorting
|
Sasuke_U
| 0
| 37
|
find resultant array after removing anagrams
| 2,273
| 0.583
|
Easy
| 31,436
|
https://leetcode.com/problems/find-resultant-array-after-removing-anagrams/discuss/2040849/Python3-using-recursive
|
class Solution:
def removeAnagrams(self, words: List[str]) -> List[str]:
def check(words, anagram):
if not anagram:
return words
else:
for i in range(len(words)):
if i + 1 < len(words):
c1 = Counter(words[i]); c2 = Counter(words[i + 1])
if c1 == c2:
words.pop(i + 1)
return check(words, True)
return check(words, False)
return check(words, True)
|
find-resultant-array-after-removing-anagrams
|
[Python3] using recursive
|
Shiyinq
| 0
| 13
|
find resultant array after removing anagrams
| 2,273
| 0.583
|
Easy
| 31,437
|
https://leetcode.com/problems/find-resultant-array-after-removing-anagrams/discuss/2040183/Python-Simple-O(n)-solution-Beats-~95
|
class Solution:
def removeAnagrams(self, words: List[str]) -> List[str]:
prev = Counter('0')
res = []
for word in words:
hashed = Counter(word)
if prev != hashed:
res.append(word)
prev=hashed
return res
|
find-resultant-array-after-removing-anagrams
|
✅ Python Simple O(n) solution - Beats ~95%
|
constantine786
| 0
| 31
|
find resultant array after removing anagrams
| 2,273
| 0.583
|
Easy
| 31,438
|
https://leetcode.com/problems/find-resultant-array-after-removing-anagrams/discuss/2040093/Python-or-Simple-Solution-with-sorting
|
class Solution:
def removeAnagrams(self, words: List[str]) -> List[str]:
ans = []
group = {}
cur = 0
for ind, word in enumerate(words):
cur = ind
tmp = ''.join(sorted(word))
if tmp in group and group[tmp] == cur - 1:
group[tmp] = cur
else:
ans.append(word)
group[tmp] = cur
return ans
|
find-resultant-array-after-removing-anagrams
|
Python | Simple Solution with sorting
|
blazers08
| 0
| 16
|
find resultant array after removing anagrams
| 2,273
| 0.583
|
Easy
| 31,439
|
https://leetcode.com/problems/find-resultant-array-after-removing-anagrams/discuss/2040076/Python3-1-line
|
class Solution:
def removeAnagrams(self, words: List[str]) -> List[str]:
return [w for i, w in enumerate(words) if i == 0 or sorted(words[i-1]) != sorted(w)]
|
find-resultant-array-after-removing-anagrams
|
[Python3] 1-line
|
ye15
| 0
| 15
|
find resultant array after removing anagrams
| 2,273
| 0.583
|
Easy
| 31,440
|
https://leetcode.com/problems/find-resultant-array-after-removing-anagrams/discuss/2040076/Python3-1-line
|
class Solution:
def removeAnagrams(self, words: List[str]) -> List[str]:
return [w for i, w in enumerate(words) if i == 0 or Counter(words[i-1]) != Counter(w)]
|
find-resultant-array-after-removing-anagrams
|
[Python3] 1-line
|
ye15
| 0
| 15
|
find resultant array after removing anagrams
| 2,273
| 0.583
|
Easy
| 31,441
|
https://leetcode.com/problems/find-resultant-array-after-removing-anagrams/discuss/2040050/Python-Solution-Using-Stack-oror-O(n)
|
class Solution:
def removeAnagrams(self, words: List[str]) -> List[str]:
st=[]
for i in range(len(words)):
if not st:
st.append(words[i])
elif st and sorted(st[-1])==sorted(words[i]):
pass
else:
st.append(words[i])
return st
|
find-resultant-array-after-removing-anagrams
|
Python Solution Using Stack || O(n)
|
a_dityamishra
| 0
| 19
|
find resultant array after removing anagrams
| 2,273
| 0.583
|
Easy
| 31,442
|
https://leetcode.com/problems/find-resultant-array-after-removing-anagrams/discuss/2039989/Python-using-Counter
|
class Solution:
def removeAnagrams(self, words: List[str]) -> List[str]:
result = [words[0]]
for i in range(1, len(words)):
if Counter(words[i]) != Counter(result[-1]):
result.append(words[i])
return result
|
find-resultant-array-after-removing-anagrams
|
Python, using Counter
|
blue_sky5
| 0
| 34
|
find resultant array after removing anagrams
| 2,273
| 0.583
|
Easy
| 31,443
|
https://leetcode.com/problems/find-resultant-array-after-removing-anagrams/discuss/2039881/Python-Counter
|
class Solution:
def removeAnagrams(self, words: List[str]) -> List[str]:
new = [words[0]]
for i in range(1, len(words)):
if Counter(words[i - 1]) == Counter(words[i]):
continue
else:
new.append(words[i])
return new
|
find-resultant-array-after-removing-anagrams
|
Python - Counter
|
GigaMoksh
| 0
| 20
|
find resultant array after removing anagrams
| 2,273
| 0.583
|
Easy
| 31,444
|
https://leetcode.com/problems/maximum-consecutive-floors-without-special-floors/discuss/2039754/Python-Simulation-Just-sort-the-array-special
|
class Solution:
def maxConsecutive(self, bottom: int, top: int, special: list[int]) -> int:
special.sort()
res = special[0] - bottom
for i in range(1, len(special)):
res = max(res, special[i] - special[i - 1] - 1)
return max(res, top - special[-1])
|
maximum-consecutive-floors-without-special-floors
|
Python Simulation - Just sort the array special
|
GigaMoksh
| 7
| 326
|
maximum consecutive floors without special floors
| 2,274
| 0.521
|
Medium
| 31,445
|
https://leetcode.com/problems/maximum-consecutive-floors-without-special-floors/discuss/2039808/Python-Simple-Solution-or-Single-Iteration-or-Optimized-solution-or-Difference-between-floors
|
class Solution:
def maxConsecutive(self, bottom: int, top: int, special: List[int]) -> int:
c = 0
special.sort()
c = special[0]-bottom
bottom = special[0]
for i in range(1,len(special)):
if special[i]-bottom>1:
c = max(c,special[i]-bottom-1)
bottom = special[i]
if top-bottom>1:
c = max(c,top-bottom)
return c
|
maximum-consecutive-floors-without-special-floors
|
Python Simple Solution | Single Iteration | Optimized solution | Difference between floors
|
AkashHooda
| 2
| 91
|
maximum consecutive floors without special floors
| 2,274
| 0.521
|
Medium
| 31,446
|
https://leetcode.com/problems/maximum-consecutive-floors-without-special-floors/discuss/2098273/JAVA-oror-PYTHON-oror-100-oror-EASY
|
class Solution:
def maxConsecutive(self, x: int, y: int, a: List[int]) -> int:
a.sort()
r=max(a[0]-x,y-a[-1])
for i in range(len(a)-1):
a[i]=a[i+1]-a[i]
a[-1]=0
r=max(max(a)-1,r)
return r
|
maximum-consecutive-floors-without-special-floors
|
✔️JAVA || PYTHON ||✔️ 100% || EASY
|
karan_8082
| 1
| 66
|
maximum consecutive floors without special floors
| 2,274
| 0.521
|
Medium
| 31,447
|
https://leetcode.com/problems/maximum-consecutive-floors-without-special-floors/discuss/2040148/Python-Simple-Solution-Beats-~95-(with-explanation)
|
class Solution:
def maxConsecutive(self, bottom: int, top: int, special: List[int]) -> int:
special.sort()
special_floors=[bottom-1] + special + [top+1]
res = 0
for i in range(1, len(special_floors)):
res = max(res, special_floors[i] - special_floors[i-1] - 1)
return res
|
maximum-consecutive-floors-without-special-floors
|
Python Simple Solution Beats ~95% (with explanation)
|
constantine786
| 1
| 111
|
maximum consecutive floors without special floors
| 2,274
| 0.521
|
Medium
| 31,448
|
https://leetcode.com/problems/maximum-consecutive-floors-without-special-floors/discuss/2040058/Python-Solution-oror-Easy-To-Understand
|
class Solution:
def maxConsecutive(self, bottom: int, top: int, special: List[int]) -> int:
c=0
l=[]
special.sort()
a=special[0]-bottom
b=top-special[-1]
for i in range(len(special)-1):
l.append(special[i+1]-special[i]-1)
if len(l)>=1:
c=max(l)
return max(a,b,c)
|
maximum-consecutive-floors-without-special-floors
|
Python Solution || Easy To Understand
|
a_dityamishra
| 1
| 25
|
maximum consecutive floors without special floors
| 2,274
| 0.521
|
Medium
| 31,449
|
https://leetcode.com/problems/maximum-consecutive-floors-without-special-floors/discuss/2317468/Python3-Using-Sort
|
class Solution:
def maxConsecutive(self, bottom: int, top: int, special: List[int]) -> int:
"""
# TLE
special.sort()
spec = 0
seq = max_seq = 0
for floor in range(bottom, top+1):
if spec < len(special) and floor == special[spec]:
max_seq = max(max_seq, seq)
seq = 0
spec += 1
continue
seq += 1
return max(max_seq, seq)
"""
special.sort()
i = 0
max_seq = 0
while i + 1 < len(special):
max_seq = max(max_seq, special[i+1] - special[i] - 1)
i += 1
max_seq = max(max_seq, special[0] - bottom)
max_seq = max(max_seq, top - special[-1])
return max_seq
|
maximum-consecutive-floors-without-special-floors
|
[Python3] Using Sort
|
Gp05
| 0
| 9
|
maximum consecutive floors without special floors
| 2,274
| 0.521
|
Medium
| 31,450
|
https://leetcode.com/problems/maximum-consecutive-floors-without-special-floors/discuss/2289973/Python3-Sorting-approach
|
class Solution:
def maxConsecutive(self, bottom: int, top: int, special: List[int]) -> int:
special.sort()
max_count = special[0] - bottom
for idx in range(1, len(special)):
max_count = max(max_count, special[idx] - special[idx-1] - 1)
max_count = max(max_count, (top - special[-1]))
return max_count
|
maximum-consecutive-floors-without-special-floors
|
Python3 Sorting approach
|
yashchandani98
| 0
| 11
|
maximum consecutive floors without special floors
| 2,274
| 0.521
|
Medium
| 31,451
|
https://leetcode.com/problems/maximum-consecutive-floors-without-special-floors/discuss/2059681/python-java-sort-%3A-small-and-easy-to-understand
|
class Solution:
def maxConsecutive(self, bottom: int, top: int, special: List[int]) -> int:
special.sort()
answer = special[0] - bottom + 1
for floor in special :
answer = max(answer, floor - bottom)
bottom = floor
return max(answer, top - special[-1] + 1) - 1
|
maximum-consecutive-floors-without-special-floors
|
python, java - sort : small & easy to understand
|
ZX007java
| 0
| 37
|
maximum consecutive floors without special floors
| 2,274
| 0.521
|
Medium
| 31,452
|
https://leetcode.com/problems/maximum-consecutive-floors-without-special-floors/discuss/2044776/Sort-zip-max-85-speed
|
class Solution:
def maxConsecutive(self, bottom: int, top: int, special: List[int]) -> int:
if len(special) == 1:
return max(special[0] - bottom, top - special[0])
special.sort()
return (max(max(b - a for a, b in zip(special, special[1:])) - 1,
special[0] - bottom, top - special[-1]))
|
maximum-consecutive-floors-without-special-floors
|
Sort, zip, max, 85% speed
|
EvgenySH
| 0
| 16
|
maximum consecutive floors without special floors
| 2,274
| 0.521
|
Medium
| 31,453
|
https://leetcode.com/problems/maximum-consecutive-floors-without-special-floors/discuss/2041138/python-oror-sorting-oror-Easy-oror-Comments
|
class Solution:
def maxConsecutive(self, bottom: int, top: int, special: List[int]) -> int:
maxi=0
# consider the lowermost possible values
special.sort()
a=special[0]-bottom
# consider the uppermost possible values
b=top-special[-1]
# when both the specials floor lies in b/w top and bottom , we'd consider
# case when diff is greater than 1 and count it as 1 less.
for i in range(1,len(special)):
c=special[i]-special[i-1]
if c>1:
maxi=max(maxi,c-1)
return max(a,b,maxi)
|
maximum-consecutive-floors-without-special-floors
|
python || sorting || Easy || Comments
|
Aniket_liar07
| 0
| 8
|
maximum consecutive floors without special floors
| 2,274
| 0.521
|
Medium
| 31,454
|
https://leetcode.com/problems/maximum-consecutive-floors-without-special-floors/discuss/2040688/Python-oror-Sort-the-array
|
class Solution:
def maxConsecutive(self, bottom: int, top: int, special: List[int]) -> int:
mx=0
special=sorted(special)
for i in range(1,len(special)):
mx=max(special[i]-special[i-1],mx)
return max(mx-1,special[0]-bottom,top-special[-1])
|
maximum-consecutive-floors-without-special-floors
|
Python || Sort the array
|
aditya1292
| 0
| 15
|
maximum consecutive floors without special floors
| 2,274
| 0.521
|
Medium
| 31,455
|
https://leetcode.com/problems/maximum-consecutive-floors-without-special-floors/discuss/2040100/Python3-2-line
|
class Solution:
def maxConsecutive(self, bottom: int, top: int, special: List[int]) -> int:
aug = [bottom-1] + sorted(special) + [top+1]
return max(aug[i]-aug[i-1]-1 for i in range(1, len(aug)))
|
maximum-consecutive-floors-without-special-floors
|
[Python3] 2-line
|
ye15
| 0
| 14
|
maximum consecutive floors without special floors
| 2,274
| 0.521
|
Medium
| 31,456
|
https://leetcode.com/problems/largest-combination-with-bitwise-and-greater-than-zero/discuss/2039717/Check-Each-Bit
|
class Solution:
def largestCombination(self, candidates: List[int]) -> int:
return max(sum(n & (1 << i) > 0 for n in candidates) for i in range(0, 24))
|
largest-combination-with-bitwise-and-greater-than-zero
|
Check Each Bit
|
votrubac
| 55
| 3,600
|
largest combination with bitwise and greater than zero
| 2,275
| 0.724
|
Medium
| 31,457
|
https://leetcode.com/problems/largest-combination-with-bitwise-and-greater-than-zero/discuss/2039741/Python-Count-the-Number-of-Ones-at-Each-Bit-Clean-and-Concise
|
class Solution:
def largestCombination(self, candidates: List[int]) -> int:
s = [0 for _ in range(30)]
for c in candidates:
b = bin(c)[2:][::-1]
for i, d in enumerate(b):
if d == '1':
s[i] += 1
return max(s)
|
largest-combination-with-bitwise-and-greater-than-zero
|
[Python] Count the Number of Ones at Each Bit, Clean & Concise
|
xil899
| 2
| 109
|
largest combination with bitwise and greater than zero
| 2,275
| 0.724
|
Medium
| 31,458
|
https://leetcode.com/problems/largest-combination-with-bitwise-and-greater-than-zero/discuss/2040092/Python-Check-Each-Bit-O(30*N)
|
class Solution:
def largestCombination(self, candidates: List[int]) -> int:
arr = [0]*32
for c in candidates:
for i in range(0, 30):
if c & (1<<i) :
arr[i] += 1
return max(arr)
|
largest-combination-with-bitwise-and-greater-than-zero
|
[Python] Check Each Bit O(30*N)
|
akwal
| 1
| 33
|
largest combination with bitwise and greater than zero
| 2,275
| 0.724
|
Medium
| 31,459
|
https://leetcode.com/problems/largest-combination-with-bitwise-and-greater-than-zero/discuss/2039878/Python-Efficient-Solution-or-O(30*N)-solution-or-Easy-to-understand
|
class Solution:
def largestCombination(self, candidates: List[int]) -> int:
d = {}
for i in range(32):
d[i] = 0
for a in candidates:
x = bin(a)[2:][::-1]
for j in range(len(x)):
if x[j]=='1':
d[j]+=1
return max(d.values())
|
largest-combination-with-bitwise-and-greater-than-zero
|
Python Efficient Solution | O(30*N) solution | Easy to understand
|
AkashHooda
| 1
| 47
|
largest combination with bitwise and greater than zero
| 2,275
| 0.724
|
Medium
| 31,460
|
https://leetcode.com/problems/largest-combination-with-bitwise-and-greater-than-zero/discuss/2788458/Python3-or-Bit-manipulation
|
class Solution:
def largestCombination(self, A: List[int]) -> int:
n = len(A)
ans= 0
for i in range(32):
maxCol = 0
for j in range(n):
if (A[j]>>i) & 1 == 1:
maxCol += 1
ans = max(ans,maxCol)
return ans
|
largest-combination-with-bitwise-and-greater-than-zero
|
[Python3] | Bit - manipulation
|
swapnilsingh421
| 0
| 8
|
largest combination with bitwise and greater than zero
| 2,275
| 0.724
|
Medium
| 31,461
|
https://leetcode.com/problems/largest-combination-with-bitwise-and-greater-than-zero/discuss/2087933/Python3-or-Simple-Approach
|
class Solution:
def largestCombination(self, candidates: List[int]) -> int:
ans = 0
for i in range(0,32):
temp = 0
for candidate in candidates:
temp += ((1<<i)&(candidate))>>i
ans = max(temp, ans)
return ans
|
largest-combination-with-bitwise-and-greater-than-zero
|
Python3 | Simple Approach
|
goyaljatin9856
| 0
| 61
|
largest combination with bitwise and greater than zero
| 2,275
| 0.724
|
Medium
| 31,462
|
https://leetcode.com/problems/largest-combination-with-bitwise-and-greater-than-zero/discuss/2069487/java-c%2B%2B-python-bit-manipulation
|
class Solution:
def largestCombination(self, candidates: List[int]) -> int:
bits = [0]*32
for x in candidates :
i = 0
while x != 0 :
bits[i] += x&1
i +=1
x >>= 1
ans = 0
for b in bits : ans = max(ans, b)
return ans
|
largest-combination-with-bitwise-and-greater-than-zero
|
java, c++, python - bit manipulation
|
ZX007java
| 0
| 84
|
largest combination with bitwise and greater than zero
| 2,275
| 0.724
|
Medium
| 31,463
|
https://leetcode.com/problems/largest-combination-with-bitwise-and-greater-than-zero/discuss/2045623/Binary-string-of-each-number-100-speed
|
class Solution:
def largestCombination(self, candidates: List[int]) -> int:
bit_counts = [0] * 24
for n in candidates:
for i, digit in enumerate(bin(n)[2:][::-1]):
if digit == "1":
bit_counts[i] += 1
return max(bit_counts)
|
largest-combination-with-bitwise-and-greater-than-zero
|
Binary string of each number, 100% speed
|
EvgenySH
| 0
| 24
|
largest combination with bitwise and greater than zero
| 2,275
| 0.724
|
Medium
| 31,464
|
https://leetcode.com/problems/largest-combination-with-bitwise-and-greater-than-zero/discuss/2043970/bitwise-oror-python-oror-bit-masking-oror-easy
|
class Solution:
def largestCombination(self, candidates: List[int]) -> int:
res=0
# Logic is simple and operation is !=0 only when all the ith bit of a no. is set for each candidates
for i in range(32):
count=0
# create mask at ith bit
mask=1<<i
# check for how many candidate '^' is not zero at particular bit , increase that count
for val in candidates:
if val&mask != 0:
count+=1
# for each bit count max no. of candidates whose '^' is not zero
res=max(res,count)
# Finally return max. candidates for particular bit
return res
|
largest-combination-with-bitwise-and-greater-than-zero
|
bitwise || python || bit-masking || easy
|
Aniket_liar07
| 0
| 8
|
largest combination with bitwise and greater than zero
| 2,275
| 0.724
|
Medium
| 31,465
|
https://leetcode.com/problems/largest-combination-with-bitwise-and-greater-than-zero/discuss/2040115/Python3-1-line
|
class Solution:
def largestCombination(self, candidates: List[int]) -> int:
return max(sum(bool(x & 1<<i) for x in candidates) for i in range(24))
|
largest-combination-with-bitwise-and-greater-than-zero
|
[Python3] 1-line
|
ye15
| 0
| 11
|
largest combination with bitwise and greater than zero
| 2,275
| 0.724
|
Medium
| 31,466
|
https://leetcode.com/problems/largest-combination-with-bitwise-and-greater-than-zero/discuss/2039860/Python3-Easy-to-understand-Explained
|
class Solution:
def largestCombination(self, candidates: List[int]) -> int:
lst, n = [], len(str(bin(max(candidates)))[2:])
for x in candidates:
lst.append(str(bin(x))[2:].zfill(n))
counter = Counter()
for x in lst:
for i, y in enumerate(x):
if y == "1":
counter[i] += 1
return max(counter.values())
|
largest-combination-with-bitwise-and-greater-than-zero
|
Python3 - Easy to understand - Explained
|
WoodlandXander
| 0
| 40
|
largest combination with bitwise and greater than zero
| 2,275
| 0.724
|
Medium
| 31,467
|
https://leetcode.com/problems/percentage-of-letter-in-string/discuss/2061930/Simple-Python-Solution-or-Easy-to-Understand-or-Two-Liner-Solution-or-O(N)-Solution
|
class Solution:
def percentageLetter(self, s: str, letter: str) -> int:
a = s.count(letter)
return (a*100)//len(s)
|
percentage-of-letter-in-string
|
Simple Python Solution | Easy to Understand | Two Liner Solution | O(N) Solution
|
AkashHooda
| 2
| 63
|
percentage of letter in string
| 2,278
| 0.741
|
Easy
| 31,468
|
https://leetcode.com/problems/percentage-of-letter-in-string/discuss/2710506/Python-ororO(N)-Runtime-50-ms-Beats-56.36-Memory-13.9-MB-Beats-10.66
|
class Solution:
def percentageLetter(self, s: str, letter: str) -> int:
c=0
for i in s:
if i==letter:
c+=1
n=len(s)
return int(c/n*100)
|
percentage-of-letter-in-string
|
[Python ||O(N)] Runtime 50 ms Beats 56.36% Memory 13.9 MB Beats 10.66%
|
Sneh713
| 1
| 47
|
percentage of letter in string
| 2,278
| 0.741
|
Easy
| 31,469
|
https://leetcode.com/problems/percentage-of-letter-in-string/discuss/2061914/Python-Easy-Solution
|
class Solution:
def percentageLetter(self, s: str, letter: str) -> int:
cnt = 0
for char in s:
if char == letter:
cnt += 1
res = math.floor((cnt / len(s)) * 100)
return res
|
percentage-of-letter-in-string
|
Python Easy Solution
|
MiKueen
| 1
| 40
|
percentage of letter in string
| 2,278
| 0.741
|
Easy
| 31,470
|
https://leetcode.com/problems/percentage-of-letter-in-string/discuss/2848335/Python-1-liner-beats-99.91
|
class Solution:
def percentageLetter(self, s: str, letter: str) -> int:
return int(s.count(letter)*100/len(s))
|
percentage-of-letter-in-string
|
Python 1 liner, beats 99.91%
|
Spex924
| 0
| 2
|
percentage of letter in string
| 2,278
| 0.741
|
Easy
| 31,471
|
https://leetcode.com/problems/percentage-of-letter-in-string/discuss/2811204/Python-Solution-EASY-oror-EASY-TO-UNDERSTAND
|
class Solution:
def percentageLetter(self, s: str, letter: str) -> int:
c=0
for i in s:
if i==letter:
c+=1
a=(c/len(s))*100
return int(a)
|
percentage-of-letter-in-string
|
Python Solution - EASY || EASY TO UNDERSTAND
|
T1n1_B0x1
| 0
| 6
|
percentage of letter in string
| 2,278
| 0.741
|
Easy
| 31,472
|
https://leetcode.com/problems/percentage-of-letter-in-string/discuss/2771174/Python-or-LeetCode-or-2278.-Percentage-of-Letter-in-String
|
class Solution:
def percentageLetter(self, s: str, letter: str) -> int:
x = 0
for i in s:
if i == letter:
x += 1
return (100 * x) // len(s)
|
percentage-of-letter-in-string
|
Python | LeetCode | 2278. Percentage of Letter in String
|
UzbekDasturchisiman
| 0
| 5
|
percentage of letter in string
| 2,278
| 0.741
|
Easy
| 31,473
|
https://leetcode.com/problems/percentage-of-letter-in-string/discuss/2771174/Python-or-LeetCode-or-2278.-Percentage-of-Letter-in-String
|
class Solution:
def percentageLetter(self, s: str, letter: str) -> int:
return (100 * s.count(letter)) // len(s)
|
percentage-of-letter-in-string
|
Python | LeetCode | 2278. Percentage of Letter in String
|
UzbekDasturchisiman
| 0
| 5
|
percentage of letter in string
| 2,278
| 0.741
|
Easy
| 31,474
|
https://leetcode.com/problems/percentage-of-letter-in-string/discuss/2711068/100-EASY-TO-UNDERSTANDSIMPLECLEAN
|
class Solution:
def percentageLetter(self, s: str, letter: str) -> int:
count = 0
for c in s:
if c == letter:
count += 1
return int(count/len(s)*100)
|
percentage-of-letter-in-string
|
🔥100% EASY TO UNDERSTAND/SIMPLE/CLEAN🔥
|
YuviGill
| 0
| 5
|
percentage of letter in string
| 2,278
| 0.741
|
Easy
| 31,475
|
https://leetcode.com/problems/percentage-of-letter-in-string/discuss/2553429/Python-Simple-Python-Solution
|
class Solution:
def percentageLetter(self, s: str, letter: str) -> int:
frequency_count = s.count(letter)
result = (frequency_count * 100) // len(s)
return result
|
percentage-of-letter-in-string
|
[ Python ] ✅✅ Simple Python Solution 🥳✌👍
|
ASHOK_KUMAR_MEGHVANSHI
| 0
| 10
|
percentage of letter in string
| 2,278
| 0.741
|
Easy
| 31,476
|
https://leetcode.com/problems/percentage-of-letter-in-string/discuss/2519134/Simple-Python-solution
|
class Solution:
def percentageLetter(self, s: str, letter: str) -> int:
n = len(s)
count = 0
for i in s:
if i == letter:
count += 1
return floor((count/n)*100)
|
percentage-of-letter-in-string
|
Simple Python solution
|
aruj900
| 0
| 18
|
percentage of letter in string
| 2,278
| 0.741
|
Easy
| 31,477
|
https://leetcode.com/problems/percentage-of-letter-in-string/discuss/2507980/Python3-Easy-One-liner-str.count()-method-%2B-division
|
class Solution:
def percentageLetter(self, s: str, letter: str) -> int:
return 100 * s.count(letter) // len(s)
|
percentage-of-letter-in-string
|
[Python3] Easy One-liner str.count() method + // division
|
ivnvalex
| 0
| 9
|
percentage of letter in string
| 2,278
| 0.741
|
Easy
| 31,478
|
https://leetcode.com/problems/percentage-of-letter-in-string/discuss/2451450/Python-simple-solution
|
class Solution:
def percentageLetter(self, s: str, letter: str) -> int:
return round((s.count(letter) / len(s)) * 100)
|
percentage-of-letter-in-string
|
Python simple solution
|
VoidCupboard
| 0
| 15
|
percentage of letter in string
| 2,278
| 0.741
|
Easy
| 31,479
|
https://leetcode.com/problems/percentage-of-letter-in-string/discuss/2360497/29-ms-faster-than-95.49
|
class Solution:
def percentageLetter(self, s: str, letter: str) -> int:
return int(s.count(letter)/len(s)*100)
|
percentage-of-letter-in-string
|
29 ms, faster than 95.49%
|
siktorovich
| 0
| 21
|
percentage of letter in string
| 2,278
| 0.741
|
Easy
| 31,480
|
https://leetcode.com/problems/percentage-of-letter-in-string/discuss/2165103/Percentage-of-Letter-in-String-or-Python-One-Line-or-Easy-way
|
class Solution:
def percentageLetter(self, s: str, letter: str) -> int:
return int(Counter(s)[letter] / len(s) * 100)
|
percentage-of-letter-in-string
|
Percentage of Letter in String | Python One-Line | Easy way
|
YangJenHao
| 0
| 15
|
percentage of letter in string
| 2,278
| 0.741
|
Easy
| 31,481
|
https://leetcode.com/problems/percentage-of-letter-in-string/discuss/2152532/Python-or-Simple-and-clean-solution
|
class Solution:
def percentageLetter(self, s: str, letter: str) -> int:
count = 0
n = len(s)
for c in s:
if c == letter:
count += 1
# print(count,n)
return int((count / n) * 100)
|
percentage-of-letter-in-string
|
Python | Simple and clean solution
|
__Asrar
| 0
| 39
|
percentage of letter in string
| 2,278
| 0.741
|
Easy
| 31,482
|
https://leetcode.com/problems/percentage-of-letter-in-string/discuss/2135380/Python-oror-Straight-Forward
|
class Solution:
def percentageLetter(self, s: str, letter: str) -> int:
count = 0
for l in s:
if l == letter: count += 1
ans = (count / len(s))*100
return int(ans)
|
percentage-of-letter-in-string
|
Python || Straight Forward
|
morpheusdurden
| 0
| 24
|
percentage of letter in string
| 2,278
| 0.741
|
Easy
| 31,483
|
https://leetcode.com/problems/percentage-of-letter-in-string/discuss/2116183/Python-Easy-to-understand-Solution
|
class Solution:
def percentageLetter(self, s: str, letter: str) -> int:
m = s.count(letter)
n = len(s)
x = int(100 * m / n)
return x
|
percentage-of-letter-in-string
|
✅Python Easy-to-understand Solution
|
chuhonghao01
| 0
| 14
|
percentage of letter in string
| 2,278
| 0.741
|
Easy
| 31,484
|
https://leetcode.com/problems/percentage-of-letter-in-string/discuss/2094854/Python-one-liner-faster-than-95
|
class Solution:
def percentageLetter(self, s: str, letter: str) -> int:
return int((s.count(letter) / len(s)) * 100)
|
percentage-of-letter-in-string
|
Python one liner faster than 95%
|
alishak1999
| 0
| 21
|
percentage of letter in string
| 2,278
| 0.741
|
Easy
| 31,485
|
https://leetcode.com/problems/percentage-of-letter-in-string/discuss/2089121/Python-Easy-solution-with-complexities
|
class Solution:
def percentageLetter(self, s: str, letter: str) -> int:
count = 0
for i in s:
if i == letter:
count = count + 1
answer = ( count / len (s) ) * 100
return int(answer)
# time O(N)
# space O(1)
|
percentage-of-letter-in-string
|
[Python] Easy solution with complexities
|
mananiac
| 0
| 19
|
percentage of letter in string
| 2,278
| 0.741
|
Easy
| 31,486
|
https://leetcode.com/problems/percentage-of-letter-in-string/discuss/2076313/Python-oneliner
|
class Solution:
def percentageLetter(self, s: str, letter: str) -> int:
from math import floor
return floor(s.count(letter)/len(s)*100)
|
percentage-of-letter-in-string
|
Python oneliner
|
StikS32
| 0
| 17
|
percentage of letter in string
| 2,278
| 0.741
|
Easy
| 31,487
|
https://leetcode.com/problems/percentage-of-letter-in-string/discuss/2070620/Python-One-Line
|
class Solution:
def percentageLetter(self, s: str, letter: str) -> int:
return s.count(letter) * 100 // len(s)
|
percentage-of-letter-in-string
|
Python One Line
|
Hejita
| 0
| 28
|
percentage of letter in string
| 2,278
| 0.741
|
Easy
| 31,488
|
https://leetcode.com/problems/percentage-of-letter-in-string/discuss/2068286/Python3-1-line
|
class Solution:
def percentageLetter(self, s: str, letter: str) -> int:
return 100*s.count(letter)//len(s)
|
percentage-of-letter-in-string
|
[Python3] 1-line
|
ye15
| 0
| 10
|
percentage of letter in string
| 2,278
| 0.741
|
Easy
| 31,489
|
https://leetcode.com/problems/percentage-of-letter-in-string/discuss/2065988/java-python-counter
|
class Solution:
def percentageLetter(self, s: str, letter: str) -> int:
counter = 0
for i in range(len(s)):
if s[i] == letter : counter += 1
return counter*100//len(s)
|
percentage-of-letter-in-string
|
java, python - counter
|
ZX007java
| 0
| 24
|
percentage of letter in string
| 2,278
| 0.741
|
Easy
| 31,490
|
https://leetcode.com/problems/percentage-of-letter-in-string/discuss/2062470/Simple-Python-Solution
|
class Solution:
def percentageLetter(self, s: str, letter: str) -> int:
c=0
for i in letter:
if i in s:
c+=s.count(i)
return c*100//len(s)
|
percentage-of-letter-in-string
|
Simple Python Solution
|
a_dityamishra
| 0
| 12
|
percentage of letter in string
| 2,278
| 0.741
|
Easy
| 31,491
|
https://leetcode.com/problems/maximum-bags-with-full-capacity-of-rocks/discuss/2062186/Python-Easy-Solution
|
class Solution:
def maximumBags(self, capacity: List[int], rocks: List[int], additionalRocks: int) -> int:
remaining = [0] * len(capacity)
res = 0
for i in range(len(capacity)):
remaining[i] = capacity[i] - rocks[i]
remaining.sort()
for i in range(len(remaining)):
if remaining[i] > additionalRocks:
break
additionalRocks -= remaining[i]
res += 1
return res
|
maximum-bags-with-full-capacity-of-rocks
|
Python Easy Solution
|
MiKueen
| 1
| 28
|
maximum bags with full capacity of rocks
| 2,279
| 0.626
|
Medium
| 31,492
|
https://leetcode.com/problems/maximum-bags-with-full-capacity-of-rocks/discuss/2061885/Python-Simple-Solution-or-Easy-to-Understand-or-O(NLogN)
|
class Solution:
def maximumBags(self, capacity: List[int], rocks: List[int], additionalRocks: int) -> int:
l = []
c = 0
for i in range(len(capacity)):
if capacity[i]-rocks[i]:
l.append(capacity[i]-rocks[i])
else:
c+=1
l.sort()
for i in range(len(l)):
a = l[i]
if a<=additionalRocks:
c+=1
additionalRocks-=a
else:
break
return c
|
maximum-bags-with-full-capacity-of-rocks
|
Python Simple Solution | Easy to Understand | O(NLogN)
|
AkashHooda
| 1
| 50
|
maximum bags with full capacity of rocks
| 2,279
| 0.626
|
Medium
| 31,493
|
https://leetcode.com/problems/maximum-bags-with-full-capacity-of-rocks/discuss/2061860/Python-or-Sort-on-basis-of-difference
|
class Solution:
def maximumBags(self, c: List[int], r: List[int], a: int) -> int:
n = len(c)
new = [[c[i], r[i]] for i in range(n)]
new.sort(key=lambda x: x[0] - x[1])
count = 0
for i in range(n):
if new[i][0] > new[i][1]:
x = new[i][0] - new[i][1]
if a < x:
continue
else:
count += 1
a -= x
else:
count += 1
return count
|
maximum-bags-with-full-capacity-of-rocks
|
Python | Sort on basis of difference
|
GigaMoksh
| 1
| 9
|
maximum bags with full capacity of rocks
| 2,279
| 0.626
|
Medium
| 31,494
|
https://leetcode.com/problems/maximum-bags-with-full-capacity-of-rocks/discuss/2824614/Python-greedy-solution
|
class Solution:
def maximumBags(self, capacity: List[int], rocks: List[int], additionalRocks: int) -> int:
empty = []
for i in range(len(rocks)):
empty.append(capacity[i]-rocks[i])
empty.sort()
bags = 0
for i in range(len(empty)):
additionalRocks -= empty[i]
if additionalRocks < 0:
return bags
bags += 1
return bags
|
maximum-bags-with-full-capacity-of-rocks
|
Python greedy solution
|
ankurkumarpankaj
| 0
| 1
|
maximum bags with full capacity of rocks
| 2,279
| 0.626
|
Medium
| 31,495
|
https://leetcode.com/problems/maximum-bags-with-full-capacity-of-rocks/discuss/2806309/Understanding-Solution-(Python3)
|
class Solution:
def maximumBags(self, capacity: List[int], rocks: List[int], additionalRocks: int) -> int:
n = len(capacity)
if len(capacity) == len(rocks) :
arr = {}
for i in range(n):
arr[i] = capacity[i]-rocks[i]
arr = sorted(arr.values())
val = additionalRocks
answer = 0
for j in range(n):
if val >= arr[j]:
val = val - arr[j]
answer = answer + 1
return answer
|
maximum-bags-with-full-capacity-of-rocks
|
Understanding Solution (Python3)
|
Kasun98
| 0
| 1
|
maximum bags with full capacity of rocks
| 2,279
| 0.626
|
Medium
| 31,496
|
https://leetcode.com/problems/maximum-bags-with-full-capacity-of-rocks/discuss/2688359/Python-or-Greedy-%2B-Min-heap-or-Beats-95
|
class Solution:
def maximumBags(self, capacity: List[int], rocks: List[int], additional_rocks: int) -> int:
rocks_needed = [c - r for c, r in zip(capacity, rocks)]
heapq.heapify(rocks_needed)
bags = 0
while rocks_needed:
r = heapq.heappop(rocks_needed)
if additional_rocks >= r:
bags += 1
additional_rocks -= r
if additional_rocks == 0:
break
else:
# We cannot cover even the minimum number of rocks
# required!
break
return bags
|
maximum-bags-with-full-capacity-of-rocks
|
Python | Greedy + Min-heap | Beats 95%
|
on_danse_encore_on_rit_encore
| 0
| 4
|
maximum bags with full capacity of rocks
| 2,279
| 0.626
|
Medium
| 31,497
|
https://leetcode.com/problems/maximum-bags-with-full-capacity-of-rocks/discuss/2248139/Python-oror-Easy-Solution
|
class Solution:
def maximumBags(self, capacity: List[int], rocks: List[int], additionalRocks: int) -> int:
difflist = []
fullcapacity = 0
for i in range(0,len(rocks)):
difflist.append(capacity[i] - rocks[i])
difflist.sort()
for i in range(len(difflist)):
if difflist[i] == 0:
fullcapacity += 1
else:
if additionalRocks >= difflist[i]:
additionalRocks -= difflist[i]
fullcapacity += 1
return fullcapacity
|
maximum-bags-with-full-capacity-of-rocks
|
Python || Easy Solution
|
dyforge
| 0
| 15
|
maximum bags with full capacity of rocks
| 2,279
| 0.626
|
Medium
| 31,498
|
https://leetcode.com/problems/maximum-bags-with-full-capacity-of-rocks/discuss/2221329/Intuitive-Approach-and-Solution
|
class Solution:
def maximumBags(self, capacity: List[int], rocks: List[int], additionalRocks: int) -> int:
n = len(capacity)
maximumBags = 0
for i in range(n):
if capacity[i] - rocks[i] == 0:
maximumBags += 1
difference = sorted([capacity[i] - rocks[i] for i in range(n)])
for diff in difference:
if diff != 0:
if additionalRocks >= diff:
additionalRocks -= diff
maximumBags += 1
else:
break
return maximumBags
|
maximum-bags-with-full-capacity-of-rocks
|
Intuitive Approach and Solution
|
Vaibhav7860
| 0
| 7
|
maximum bags with full capacity of rocks
| 2,279
| 0.626
|
Medium
| 31,499
|
Subsets and Splits
Top 2 Solutions by Upvotes
Identifies the top 2 highest upvoted Python solutions for each problem, providing insight into popular approaches.