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/best-poker-hand/discuss/2322339/Simple-Solution-Simulation
|
class Solution:
def bestHand(self, ranks: List[int], suits: List[str]) -> str:
r = collections.Counter(ranks)
s = collections.Counter(suits)
for i in s:
if s[i] >= 5:
return "Flush"
for i in r:
if r[i] >= 3:
return "Three of a Kind"
for i in r:
if r[i] >= 2:
return "Pair"
return "High Card"
|
best-poker-hand
|
Simple Solution Simulation
|
abhijeetmallick29
| 0
| 2
|
best poker hand
| 2,347
| 0.606
|
Easy
| 32,200
|
https://leetcode.com/problems/number-of-zero-filled-subarrays/discuss/2322455/Python-oror-Two-pointers-oror-Easy-Approach
|
class Solution:
def zeroFilledSubarray(self, nums: List[int]) -> int:
n = len(nums)
ans = 0
i, j = 0, 0
while i <= n - 1:
j = 0
if nums[i] == 0:
while i + j <= n - 1 and nums[i + j] == 0:
j += 1
ans += (j + 1) * j // 2
i = i + j + 1
return ans
|
number-of-zero-filled-subarrays
|
✅Python || Two-pointers || Easy Approach
|
chuhonghao01
| 2
| 72
|
number of zero filled subarrays
| 2,348
| 0.571
|
Medium
| 32,201
|
https://leetcode.com/problems/number-of-zero-filled-subarrays/discuss/2333158/Python3-one-liner
|
class Solution:
def zeroFilledSubarray(self, nums: List[int]) -> int:
return reduce(lambda acc,y: (acc[0],0) if y else (sum(acc)+1,acc[1]+1), nums, (0,0))[0]
|
number-of-zero-filled-subarrays
|
Python3 one-liner
|
vsavkin
| 1
| 8
|
number of zero filled subarrays
| 2,348
| 0.571
|
Medium
| 32,202
|
https://leetcode.com/problems/number-of-zero-filled-subarrays/discuss/2323148/Python-Solution
|
class Solution:
def zeroFilledSubarray(self, nums: List[int]) -> int:
ans = 0
l = 0
for i in range(len(nums)):
if nums[i] == 0:
ans += i - l + 1
else:
l = i + 1
return ans
|
number-of-zero-filled-subarrays
|
Python Solution
|
user6397p
| 1
| 23
|
number of zero filled subarrays
| 2,348
| 0.571
|
Medium
| 32,203
|
https://leetcode.com/problems/number-of-zero-filled-subarrays/discuss/2751973/Three-different-Solution-or-Easy-to-Understand-or-DP-Solution-or-Python
|
class Solution(object):
def zeroFilledSubarray(self, nums):
ans, count = 0, 1
for i in range(len(nums)):
if nums[i] == 0:
ans += count
count += 1
else: count = 1
return ans
|
number-of-zero-filled-subarrays
|
Three different Solution | Easy to Understand | DP Solution | Python
|
its_krish_here
| 0
| 2
|
number of zero filled subarrays
| 2,348
| 0.571
|
Medium
| 32,204
|
https://leetcode.com/problems/number-of-zero-filled-subarrays/discuss/2751973/Three-different-Solution-or-Easy-to-Understand-or-DP-Solution-or-Python
|
class Solution(object):
def zeroFilledSubarray(self, nums):
arr, count = [0] * len(nums), 1
for i in range(len(nums)):
if nums[i] == 0:
arr[i] = count
count += 1
else: count = 1
return sum(arr)
|
number-of-zero-filled-subarrays
|
Three different Solution | Easy to Understand | DP Solution | Python
|
its_krish_here
| 0
| 2
|
number of zero filled subarrays
| 2,348
| 0.571
|
Medium
| 32,205
|
https://leetcode.com/problems/number-of-zero-filled-subarrays/discuss/2751973/Three-different-Solution-or-Easy-to-Understand-or-DP-Solution-or-Python
|
class Solution(object):
def zeroFilledSubarray(self, nums):
dp = [0] * len(nums)
if nums[0] == 0: dp[0] = 1
for i in range(1, len(nums)):
if nums[i] == 0:
dp[i] = dp[i - 1] + 1
return sum(dp)
|
number-of-zero-filled-subarrays
|
Three different Solution | Easy to Understand | DP Solution | Python
|
its_krish_here
| 0
| 2
|
number of zero filled subarrays
| 2,348
| 0.571
|
Medium
| 32,206
|
https://leetcode.com/problems/number-of-zero-filled-subarrays/discuss/2666341/Python-3-O(n)-using-a-Sliding-Window-(faster-than-95-)
|
class Solution:
def zeroFilledSubarray(self, nums: List[int]) -> int:
total_amount = 0
left = 0
for right in range(len(nums)):
if nums[right] != 0:
left = right + 1
continue
if nums[right] == 0:
total_amount += right - left + 1
return total_amount
|
number-of-zero-filled-subarrays
|
Python 3 O(n) using a Sliding Window (faster than 95 %)
|
lksmrqrdt
| 0
| 15
|
number of zero filled subarrays
| 2,348
| 0.571
|
Medium
| 32,207
|
https://leetcode.com/problems/number-of-zero-filled-subarrays/discuss/2643334/Fast-Python3-or-Single-Iteration-w-Math
|
class Solution:
def zeroFilledSubarray(self, nums: List[int]) -> int:
chain0 = sub0 = 0
for num in nums:
if num == 0:
chain0 += 1
elif chain0 > 0:
sub0 += chain0 * (chain0 + 1) // 2
chain0 = 0
return sub0 + chain0 * (chain0 + 1) // 2
|
number-of-zero-filled-subarrays
|
Fast Python3 | Single Iteration w/ Math
|
ryangrayson
| 0
| 9
|
number of zero filled subarrays
| 2,348
| 0.571
|
Medium
| 32,208
|
https://leetcode.com/problems/number-of-zero-filled-subarrays/discuss/2332036/Groupby-zeros-80-speed
|
class Solution:
def zeroFilledSubarray(self, nums: List[int]) -> int:
zeros_groups = [len(list(g)) + 1 for k, g in groupby(nums) if k == 0]
return (sum(sum(n - i for n in zeros_groups if n > i)
for i in range(1, max(zeros_groups) + 1))
if zeros_groups else 0)
|
number-of-zero-filled-subarrays
|
Groupby zeros, 80% speed
|
EvgenySH
| 0
| 10
|
number of zero filled subarrays
| 2,348
| 0.571
|
Medium
| 32,209
|
https://leetcode.com/problems/number-of-zero-filled-subarrays/discuss/2324368/Python3-dp
|
class Solution:
def zeroFilledSubarray(self, nums: List[int]) -> int:
ans = cnt = 0
for x in nums:
if x: cnt = 0
else: cnt += 1
ans += cnt
return ans
|
number-of-zero-filled-subarrays
|
[Python3] dp
|
ye15
| 0
| 8
|
number of zero filled subarrays
| 2,348
| 0.571
|
Medium
| 32,210
|
https://leetcode.com/problems/number-of-zero-filled-subarrays/discuss/2323542/Python3-Groupby-to-count-continuous-0's
|
class Solution:
def zeroFilledSubarray(self, A: List[int]) -> int:
ans = 0
for k, v in groupby(A):
if k==0:
cnt = len(list(v))
ans += cnt*(cnt+1)//2
return ans
|
number-of-zero-filled-subarrays
|
[Python3] Groupby to count continuous 0's
|
zhuzhengyuan824
| 0
| 6
|
number of zero filled subarrays
| 2,348
| 0.571
|
Medium
| 32,211
|
https://leetcode.com/problems/number-of-zero-filled-subarrays/discuss/2323390/Python-or-Easy-and-Understanding-Solution-or-One-Pass-Solution
|
class Solution:
def zeroFilledSubarray(self, nums: List[int]) -> int:
n=len(nums)
c=0
ans=0
for i in range(n):
if(nums[i]!=0):
c=0
else:
c+=1
ans+=c
return ans
|
number-of-zero-filled-subarrays
|
Python | Easy & Understanding Solution | One Pass Solution
|
backpropagator
| 0
| 12
|
number of zero filled subarrays
| 2,348
| 0.571
|
Medium
| 32,212
|
https://leetcode.com/problems/number-of-zero-filled-subarrays/discuss/2322335/Python-DP
|
class Solution:
def zeroFilledSubarray(self, nums: List[int]) -> int:
temp = [0] * (len(nums) + 1)
for index, num in enumerate(nums, start=1):
if num == 0:
temp[index] = 1 + temp[index - 1]
return sum(temp)
|
number-of-zero-filled-subarrays
|
[Python] DP
|
zonda_yang
| 0
| 20
|
number of zero filled subarrays
| 2,348
| 0.571
|
Medium
| 32,213
|
https://leetcode.com/problems/shortest-impossible-sequence-of-rolls/discuss/2351553/100-faster-at-my-time-or-easy-python3-solution
|
class Solution:
def shortestSequence(self, rolls: List[int], k: int) -> int:
ans = 0
seen = set()
for x in rolls:
seen.add(x)
if len(seen) == k:
ans += 1
seen.clear()
return ans+1
|
shortest-impossible-sequence-of-rolls
|
100% faster at my time | easy python3 solution
|
vimla_kushwaha
| 1
| 40
|
shortest impossible sequence of rolls
| 2,350
| 0.684
|
Hard
| 32,214
|
https://leetcode.com/problems/shortest-impossible-sequence-of-rolls/discuss/2322381/Python-easy-understanding-solution
|
class Solution:
def shortestSequence(self, rolls: List[int], k: int) -> int:
s = set()
res = 0
for r in rolls:
s.add(r)
if len(s) == k: # All possible number has appeared once.
res += 1 # So you must "at least" use one more place to store it.
s.clear() # Clear the set.
return res + 1
|
shortest-impossible-sequence-of-rolls
|
Python easy understanding solution
|
byroncharly3
| 1
| 26
|
shortest impossible sequence of rolls
| 2,350
| 0.684
|
Hard
| 32,215
|
https://leetcode.com/problems/shortest-impossible-sequence-of-rolls/discuss/2757347/Python-3-Solution
|
class Solution:
def shortestSequence(self, rolls: List[int], k: int) -> int:
z = set()
res = 0
for x in rolls:
z.add(x)
if len(z) == k:
res += 1
z.clear()
return res + 1
|
shortest-impossible-sequence-of-rolls
|
Python 3 Solution
|
mati44
| 0
| 1
|
shortest impossible sequence of rolls
| 2,350
| 0.684
|
Hard
| 32,216
|
https://leetcode.com/problems/shortest-impossible-sequence-of-rolls/discuss/2324377/Python3-hash-set
|
class Solution:
def shortestSequence(self, rolls: List[int], k: int) -> int:
ans = 1
seen = set()
for x in rolls:
seen.add(x)
if len(seen) == k:
ans += 1
seen.clear()
return ans
|
shortest-impossible-sequence-of-rolls
|
[Python3] hash set
|
ye15
| 0
| 8
|
shortest impossible sequence of rolls
| 2,350
| 0.684
|
Hard
| 32,217
|
https://leetcode.com/problems/shortest-impossible-sequence-of-rolls/discuss/2323029/Python3-One-Pass-oror-Set
|
class Solution:
def shortestSequence(self, rolls: List[int], k: int) -> int:
res = 0
s = set()
for i in range(len(rolls)):
num = rolls[i]
if num not in s:
s.add(num)
if len(s) == k:
res+=1
s = set()
return res+1
|
shortest-impossible-sequence-of-rolls
|
[Python3] One Pass || Set
|
abhijeetmallick29
| 0
| 3
|
shortest impossible sequence of rolls
| 2,350
| 0.684
|
Hard
| 32,218
|
https://leetcode.com/problems/first-letter-to-appear-twice/discuss/2324754/Python-oror-Map-oror-Easy-Approach
|
class Solution:
def repeatedCharacter(self, s: str) -> str:
setS = set()
for x in s:
if x in setS:
return x
else:
setS.add(x)
|
first-letter-to-appear-twice
|
✅Python || Map || Easy Approach
|
chuhonghao01
| 17
| 1,100
|
first letter to appear twice
| 2,351
| 0.76
|
Easy
| 32,219
|
https://leetcode.com/problems/first-letter-to-appear-twice/discuss/2334483/Python3-O(n)-oror-O(1)-Runtime%3A-30ms-90.00-oror-Memory%3A-13.9mb-10.00
|
class Solution:
# O(n) || O(1)
# Runtime: 30ms 90.00% || Memory: 13.9mb 10.00%
def repeatedCharacter(self, string: str) -> str:
strAlphaFreq = [0] * 26
for char in string:
index = ord(char) - ord('a')
strAlphaFreq[index] += 1
if strAlphaFreq[index] > 1:
return char
|
first-letter-to-appear-twice
|
Python3 O(n) || O(1) # Runtime: 30ms 90.00% || Memory: 13.9mb 10.00%
|
arshergon
| 3
| 229
|
first letter to appear twice
| 2,351
| 0.76
|
Easy
| 32,220
|
https://leetcode.com/problems/first-letter-to-appear-twice/discuss/2324736/Python3-mask
|
class Solution:
def repeatedCharacter(self, s: str) -> str:
mask = 0
for ch in s:
if mask & 1<<ord(ch)-97: return ch
mask ^= 1<<ord(ch)-97
|
first-letter-to-appear-twice
|
[Python3] mask
|
ye15
| 3
| 163
|
first letter to appear twice
| 2,351
| 0.76
|
Easy
| 32,221
|
https://leetcode.com/problems/first-letter-to-appear-twice/discuss/2671372/Beats-99.86-Python-3
|
class Solution:
def repeatedCharacter(self, s: str) -> str:
dicta={}
for i in s:
if i in dicta:
return i
else:
dicta[i]=1
|
first-letter-to-appear-twice
|
Beats 99.86% [Python 3]
|
Sneh713
| 2
| 123
|
first letter to appear twice
| 2,351
| 0.76
|
Easy
| 32,222
|
https://leetcode.com/problems/first-letter-to-appear-twice/discuss/2843730/Very-easy
|
class Solution:
def repeatedCharacter(self, s: str) -> str:
res =[]
for i in s:
if i in res:
return i
break
else:
res.append(i)
|
first-letter-to-appear-twice
|
Very easy
|
khanismail_1
| 0
| 1
|
first letter to appear twice
| 2,351
| 0.76
|
Easy
| 32,223
|
https://leetcode.com/problems/first-letter-to-appear-twice/discuss/2833647/Python-solution-using-dictionary.-Return-once-you-see-a-character-that-already-exist-in-the-dict.
|
class Solution:
def repeatedCharacter(self, s: str) -> str:
dict_s = {}
for ch in s:
if ch not in dict_s:
dict_s[ch] = 1
else:
return ch
|
first-letter-to-appear-twice
|
Python solution using dictionary. Return once you see a character that already exist in the dict.
|
samanehghafouri
| 0
| 1
|
first letter to appear twice
| 2,351
| 0.76
|
Easy
| 32,224
|
https://leetcode.com/problems/first-letter-to-appear-twice/discuss/2821468/Python-easy-solution
|
class Solution:
def repeatedCharacter(self, s: str) -> str:
rech = {}
for i in s:
if i not in rech:
rech[i]=1
else:
return i
break
|
first-letter-to-appear-twice
|
Python easy solution
|
ameenusyed09
| 0
| 1
|
first letter to appear twice
| 2,351
| 0.76
|
Easy
| 32,225
|
https://leetcode.com/problems/first-letter-to-appear-twice/discuss/2786230/pyton-easy-solution
|
class Solution:
def repeatedCharacter(self, s: str) -> str:
s = list(s);
x=[];
for i in s :
if i not in x:
x.append(i);
else:
return i[0]
|
first-letter-to-appear-twice
|
pyton easy solution
|
seifsoliman
| 0
| 1
|
first letter to appear twice
| 2,351
| 0.76
|
Easy
| 32,226
|
https://leetcode.com/problems/first-letter-to-appear-twice/discuss/2767063/Python3-or-Easy-to-understand-or-With-explanation
|
class Solution:
# Time complexity O(n)
# Space complexity O(n)
def repeatedCharacter(self, s: str) -> str:
charSet = set()
# Check if each character in input string exists in set, if yes, return the char.
# If not, add the char to the set so that you can lookup later if it reoccures.
for char in s:
if char in charSet:
return char
charSet.add(char)
|
first-letter-to-appear-twice
|
Python3 | Easy to understand | With explanation
|
sj92
| 0
| 3
|
first letter to appear twice
| 2,351
| 0.76
|
Easy
| 32,227
|
https://leetcode.com/problems/first-letter-to-appear-twice/discuss/2738456/BEATS-99-OF-THE-SOLUTIONS-PYTHON-EASY-HASHMAP-SOLUTION
|
class Solution:
def repeatedCharacter(self, s: str) -> str:
dic = {}
ss = ''
for i, w in enumerate(s):
if w in dic:
dic[w].append(i)
else:
dic[w] = [i]
mi = 10000
for key, value in dic.items():
if len(value)>=2:
if value[1]<mi:
mi = value[1]
ss = key
return ss
|
first-letter-to-appear-twice
|
BEATS 99% OF THE SOLUTIONS - PYTHON EASY HASHMAP SOLUTION
|
jacobsimonareickal
| 0
| 1
|
first letter to appear twice
| 2,351
| 0.76
|
Easy
| 32,228
|
https://leetcode.com/problems/first-letter-to-appear-twice/discuss/2726745/Python3-Solution-with-using-hashset
|
class Solution:
def repeatedCharacter(self, s: str) -> str:
seen = set()
for char in s:
if char in seen:
return char
seen.add(char)
return None
|
first-letter-to-appear-twice
|
[Python3] Solution with using hashset
|
maosipov11
| 0
| 3
|
first letter to appear twice
| 2,351
| 0.76
|
Easy
| 32,229
|
https://leetcode.com/problems/first-letter-to-appear-twice/discuss/2711325/Python-solution-clean-code-with-comments.
|
class Solution:
def repeatedCharacter(self, s: str) -> str:
return str_to_dict(s)
def str_to_dict(s: str):
dic = {}
for i in s:
if i in dic:
dic[i] += 1
# Return the first character that appear twice.
if dic[i] == 2:
return str(i)
else:
dic[i] = 1
return None
# Runtime: 49 ms, faster than 57.39% of Python3 online submissions for First Letter to Appear Twice.
# Memory Usage: 13.9 MB, less than 50.91% of Python3 online submissions for First Letter to Appear Twice.
# If you like my work and found it helpful, then I'll appreciate a like. Thanks!
|
first-letter-to-appear-twice
|
Python solution, clean code with comments.
|
375d
| 0
| 10
|
first letter to appear twice
| 2,351
| 0.76
|
Easy
| 32,230
|
https://leetcode.com/problems/first-letter-to-appear-twice/discuss/2683239/100-EASY-TO-UNDERSTANDSIMPLECLEAN
|
class Solution:
def repeatedCharacter(self, s: str) -> str:
seenAlready = []
for c in s:
if c not in seenAlready:
seenAlready.append(c)
else:
return c
|
first-letter-to-appear-twice
|
🔥100% EASY TO UNDERSTAND/SIMPLE/CLEAN🔥
|
YuviGill
| 0
| 52
|
first letter to appear twice
| 2,351
| 0.76
|
Easy
| 32,231
|
https://leetcode.com/problems/first-letter-to-appear-twice/discuss/2644635/First-Letter-to-Appear-Twice-oror-Python3-oror-Dictionary
|
class Solution:
def repeatedCharacter(self, s: str) -> str:
d={}
for i in s:
if i in d:
d[i]+=1
if d[i]==2:
return i
else:
d[i]=1
|
first-letter-to-appear-twice
|
First Letter to Appear Twice || Python3 || Dictionary
|
shagun_pandey
| 0
| 5
|
first letter to appear twice
| 2,351
| 0.76
|
Easy
| 32,232
|
https://leetcode.com/problems/first-letter-to-appear-twice/discuss/2643076/Python-Code-oror-Simplest-solution
|
class Solution:
def repeatedCharacter(self, s: str) -> str:
stack=[]
for i in range(len(s)):
if s[i] in stack:
return s[i]
else:
stack.append(s[i])
|
first-letter-to-appear-twice
|
Python Code || Simplest solution
|
sinjan_singh
| 0
| 1
|
first letter to appear twice
| 2,351
| 0.76
|
Easy
| 32,233
|
https://leetcode.com/problems/first-letter-to-appear-twice/discuss/2625098/dictionary-solution-very-easy!!
|
class Solution:
def repeatedCharacter(self, s: str) -> str:
dict={}
for i in s:
if i not in dict:
dict[i]=1
else:
return i
|
first-letter-to-appear-twice
|
dictionary solution very easy!!
|
lin11116459
| 0
| 9
|
first letter to appear twice
| 2,351
| 0.76
|
Easy
| 32,234
|
https://leetcode.com/problems/first-letter-to-appear-twice/discuss/2571956/Python-Simple-Python-Solution-Using-Dictionary
|
class Solution:
def repeatedCharacter(self, s: str) -> str:
d = {}
result = ''
min_index = 1000000
for index in range(len(s)):
if s[index] not in d:
d[s[index]] = [index]
else:
d[s[index]].append(index)
for key in d:
if len(d[key]) > 1:
second_index = d[key][1]
if second_index < min_index:
result = key
min_index = min(min_index, second_index)
return result
|
first-letter-to-appear-twice
|
[ Python ] ✅✅ Simple Python Solution Using Dictionary 🥳✌👍
|
ASHOK_KUMAR_MEGHVANSHI
| 0
| 35
|
first letter to appear twice
| 2,351
| 0.76
|
Easy
| 32,235
|
https://leetcode.com/problems/first-letter-to-appear-twice/discuss/2555561/Python-95.9-Faster.-Easy-to-Follow-Comments
|
class Solution:
def repeatedCharacter(self, s: str) -> str:
#var to hold the output value
ovalue = 100
#create a unique list of values
ul = set(list(s))
#iterate throught the unique letters
for letter in ul:
#check if letter count is greater than 2 in the string
if s.count(letter) >=2:
#if more than 2, check second position, set ovalue if lower than previous value
if ovalue > (s.find(letter) + s[s.find(letter)+1::].find(letter) + 1):
ovalue = (s.find(letter) + s[s.find(letter)+1::].find(letter) + 1)
#return index position within the string
return(s[ovalue])
|
first-letter-to-appear-twice
|
Python 95.9% Faster. Easy to Follow Comments
|
ovidaure
| 0
| 30
|
first letter to appear twice
| 2,351
| 0.76
|
Easy
| 32,236
|
https://leetcode.com/problems/first-letter-to-appear-twice/discuss/2534660/simple-clean
|
class Solution:
def repeatedCharacter(self, s: str) -> str:
# use a hashmap to store the seen characters
# if the char is in the hashmap, we've seen it once so...
# return that character
# Time O(N) Space O(N)
seen = dict()
for char in s:
if char in seen:
return char
else:
seen[char] = None
|
first-letter-to-appear-twice
|
simple clean
|
andrewnerdimo
| 0
| 26
|
first letter to appear twice
| 2,351
| 0.76
|
Easy
| 32,237
|
https://leetcode.com/problems/first-letter-to-appear-twice/discuss/2490955/Faster-than-90.08-of-Python3
|
class Solution:
def repeatedCharacter(self, s: str) -> str:
s=tuple(s)
s2=tuple()
for letter in s:
if letter in s2:
return letter
s2=s2+tuple(letter)
|
first-letter-to-appear-twice
|
Faster than 90.08% of Python3
|
1_d99
| 0
| 17
|
first letter to appear twice
| 2,351
| 0.76
|
Easy
| 32,238
|
https://leetcode.com/problems/first-letter-to-appear-twice/discuss/2489304/Simple-solution-using-set
|
class Solution:
def repeatedCharacter(self, s: str) -> str:
seen = set()
for i in s:
if i in seen:
return i
else:
seen.add(i)
|
first-letter-to-appear-twice
|
Simple solution using set
|
aruj900
| 0
| 18
|
first letter to appear twice
| 2,351
| 0.76
|
Easy
| 32,239
|
https://leetcode.com/problems/first-letter-to-appear-twice/discuss/2479030/Python-code-faster-than-92.23-of-online-submissions
|
class Solution:
def repeatedCharacter(self, s: str) -> str:
a=[]
for i in s:
if(i in a):
return i
break
else:
a.append(i)
|
first-letter-to-appear-twice
|
Python code faster than 92.23% of online submissions
|
Durgavamsi
| 0
| 23
|
first letter to appear twice
| 2,351
| 0.76
|
Easy
| 32,240
|
https://leetcode.com/problems/first-letter-to-appear-twice/discuss/2468907/Python-O(n)-time-complexity-O(1)-space-complexity-using-hashMap.
|
class Solution:
def repeatedCharacter(self, s):
set1 = set() # O(1) space complexity
for i in range(len(s)): # O(n)
if s[i] in set1: # O(1)
return s[i]
set1.add(s[i]) # O(1)
|
first-letter-to-appear-twice
|
Python O(n) time complexity, O(1) space complexity using hashMap.
|
OsamaRakanAlMraikhat
| 0
| 24
|
first letter to appear twice
| 2,351
| 0.76
|
Easy
| 32,241
|
https://leetcode.com/problems/first-letter-to-appear-twice/discuss/2436060/Simple-array-append-Python-80-faster
|
class Solution:
def repeatedCharacter(self, s: str) -> str:
a = []
for i in s:
if i not in a:
a.append(i)
else:
return i
|
first-letter-to-appear-twice
|
Simple array append Python 80% faster
|
amit0693
| 0
| 12
|
first letter to appear twice
| 2,351
| 0.76
|
Easy
| 32,242
|
https://leetcode.com/problems/first-letter-to-appear-twice/discuss/2435539/Solution-Using-List-or-Python
|
class Solution:
def repeatedCharacter(self, s: str) -> str:
for i in range(len(s)):
if s[i] in s[:i]:
return s[i]
|
first-letter-to-appear-twice
|
Solution Using List | Python
|
Abhi_-_-
| 0
| 19
|
first letter to appear twice
| 2,351
| 0.76
|
Easy
| 32,243
|
https://leetcode.com/problems/first-letter-to-appear-twice/discuss/2422049/Python-Bitmask
|
class Solution:
def repeatedCharacter(self, s: str) -> str:
bitmask = 0
i = 0
while i < 0 + len(s):
offset = ord(s[i]) - ord('a')
seen = bitmask & (1 << offset)
now = 1 << offset
if seen and now:
return s[i]
else:
bitmask |= now
i += 1
|
first-letter-to-appear-twice
|
[Python] Bitmask
|
DG_stamper
| 0
| 9
|
first letter to appear twice
| 2,351
| 0.76
|
Easy
| 32,244
|
https://leetcode.com/problems/first-letter-to-appear-twice/discuss/2367254/Simple-hashset-python-fast-solution
|
class Solution:
def repeatedCharacter(self, s: str) -> str:
h=set()
for i in s:
if i in h:
return i
else:
h.add(i)
|
first-letter-to-appear-twice
|
Simple hashset python fast solution
|
sunakshi132
| 0
| 36
|
first letter to appear twice
| 2,351
| 0.76
|
Easy
| 32,245
|
https://leetcode.com/problems/first-letter-to-appear-twice/discuss/2352976/easy-python-solution
|
class Solution:
def repeatedCharacter(self, s: str) -> str:
unique_letter = []
for i in range(len(s)) :
if s[i] not in unique_letter :
unique_letter.append(s[i])
else :
return s[i]
|
first-letter-to-appear-twice
|
easy python solution
|
sghorai
| 0
| 33
|
first letter to appear twice
| 2,351
| 0.76
|
Easy
| 32,246
|
https://leetcode.com/problems/first-letter-to-appear-twice/discuss/2347771/python-Solution-O(n)
|
class Solution:
def repeatedCharacter(self, s: str) -> str:
d = {}
for i in s:
if i not in d:
d[i] = d.get(i, 0) +1
else:
return i
|
first-letter-to-appear-twice
|
python Solution O(n)
|
Tobi_Akin
| 0
| 24
|
first letter to appear twice
| 2,351
| 0.76
|
Easy
| 32,247
|
https://leetcode.com/problems/first-letter-to-appear-twice/discuss/2344721/Python-simple-solution
|
class Solution:
def repeatedCharacter(self, s: str) -> str:
sett = set()
for i in s:
if i in sett:
return i
else:
sett.add(i)
|
first-letter-to-appear-twice
|
Python simple solution
|
StikS32
| 0
| 30
|
first letter to appear twice
| 2,351
| 0.76
|
Easy
| 32,248
|
https://leetcode.com/problems/first-letter-to-appear-twice/discuss/2335499/Python-or-Simple-Solution-or-Hashmap
|
class Solution:
def repeatedCharacter(self, s: str) -> str:
hash_map = {}
for char in s:
hash_map[char] = hash_map.get(char, 0) + 1
# when the freq of any char becomes greater than 1 simply return that character
if hash_map[char] > 1: return i
|
first-letter-to-appear-twice
|
✅ Python | Simple Solution | Hashmap
|
Nk0311
| 0
| 24
|
first letter to appear twice
| 2,351
| 0.76
|
Easy
| 32,249
|
https://leetcode.com/problems/first-letter-to-appear-twice/discuss/2332101/Python-easy-solution-for-beginners-using-Sets
|
class Solution:
def repeatedCharacter(self, s: str) -> str:
seen = set()
for i in s:
if i in seen:
return i
else:
seen.add(i)
|
first-letter-to-appear-twice
|
Python easy solution for beginners using Sets
|
alishak1999
| 0
| 13
|
first letter to appear twice
| 2,351
| 0.76
|
Easy
| 32,250
|
https://leetcode.com/problems/first-letter-to-appear-twice/discuss/2329012/Python-100-Memory
|
class Solution:
def repeatedCharacter(self, s: str) -> str:
for i in range(len(s)):
if s[i] in s[:i]: # O(n) worse case, O(1) average
return s[i]
|
first-letter-to-appear-twice
|
Python 100% Memory
|
heyitsmass
| 0
| 8
|
first letter to appear twice
| 2,351
| 0.76
|
Easy
| 32,251
|
https://leetcode.com/problems/first-letter-to-appear-twice/discuss/2327695/One-loop-one-set-80-speed
|
class Solution:
def repeatedCharacter(self, s: str) -> str:
seen = set()
for c in s:
if c in seen:
return c
seen.add(c)
return ""
|
first-letter-to-appear-twice
|
One loop, one set, 80% speed
|
EvgenySH
| 0
| 22
|
first letter to appear twice
| 2,351
| 0.76
|
Easy
| 32,252
|
https://leetcode.com/problems/first-letter-to-appear-twice/discuss/2327077/Python-one-for-loop
|
class Solution:
def repeatedCharacter(self, s: str) -> str:
letters = [0] * 26
for c in s:
idx = ord(c) - ord('a')
if letters[idx]:
return c
letters[idx] = 1
|
first-letter-to-appear-twice
|
Python, one for loop
|
blue_sky5
| 0
| 12
|
first letter to appear twice
| 2,351
| 0.76
|
Easy
| 32,253
|
https://leetcode.com/problems/first-letter-to-appear-twice/discuss/2326389/SIMPLE-PYTHON-SOLUTION
|
class Solution:
def repeatedCharacter(self, s: str) -> str:
arr=[]
for i in s:
if i not in arr:
arr.append(i)
else:
return i
|
first-letter-to-appear-twice
|
SIMPLE PYTHON SOLUTION
|
vijayvardhan6
| 0
| 14
|
first letter to appear twice
| 2,351
| 0.76
|
Easy
| 32,254
|
https://leetcode.com/problems/first-letter-to-appear-twice/discuss/2325687/PYTHON-EASY-IMPLEMENTATION-oror-DICTIONARY
|
class Solution:
def repeatedCharacter(self, s: str) -> str:
d = {}
for idx, ch in enumerate(s):
if ch not in d:
d[ch] = [idx]
else:
d[ch].append(idx)
curr = float("inf")
for k,v in d.items():
if len(v) > 1:
curr = min(curr, min(v[1:]))
return s[curr]
|
first-letter-to-appear-twice
|
PYTHON EASY IMPLEMENTATION || DICTIONARY
|
varunshrivastava2706
| 0
| 5
|
first letter to appear twice
| 2,351
| 0.76
|
Easy
| 32,255
|
https://leetcode.com/problems/first-letter-to-appear-twice/discuss/2325586/Python-3-or-Hash_Map
|
class Solution:
def repeatedCharacter(self, s: str) -> str:
hash_map = {s[0]:1}
for i in range(1,len(s)):
if s[i] not in hash_map.keys():
hash_map[s[i]] = 1
else:
return s[i]
|
first-letter-to-appear-twice
|
Python 3 | Hash_Map
|
user7457RV
| 0
| 9
|
first letter to appear twice
| 2,351
| 0.76
|
Easy
| 32,256
|
https://leetcode.com/problems/first-letter-to-appear-twice/discuss/2383591/For-beginners-99.98-faster-in-python-O(n)-time
|
class Solution:
def repeatedCharacter(self, s: str) -> str:
l = []
for i in s:
if i in l:
return i
else:
l.append(i)
|
first-letter-to-appear-twice
|
For beginners 99.98% faster in python O(n) time
|
yashsanghani310
| -1
| 37
|
first letter to appear twice
| 2,351
| 0.76
|
Easy
| 32,257
|
https://leetcode.com/problems/equal-row-and-column-pairs/discuss/2328910/Python3-oror-3-lines-transpose-Ctr-w-explanation-oror-TM%3A-100100
|
class Solution: # Consider this grid for an example:
# grid = [[1,2,1,9]
# [2,8,9,2]
# [1,2,1,9]
# [9,2,6,3]]
# Here's the plan:
# • Determine tpse, the transpose of grid (using zip(*grid)):
# tspe = [[1,2,1,9]
# [2,8,2,2]
# [1,9,1,6]
# [9,2,9,3]]
# The problem now is to determine the pairs of
# identical rows, one row in tpse and the other in grid.
# • We hash grid and tspe:
#
# Counter(tuple(grid)):
# {(1,2,1,9): 2, (2,8,9,2): 1, (9,2,6,3): 1}
#
# Counter(zip(*grid)):
# {(1,2,1,9): 1, (2,8,2,2): 1, (1,9,1,6): 1, (9,2,9,3): 1}
#
# • We determine the number of pairs:
# (1,2,1,9): 2 and (1,2,1,9): 1 => 2x1 = 2
def equalPairs(self, grid: List[List[int]]) -> int:
tpse = Counter(zip(*grid)) # <-- determine the transpose
# and hash the rows
grid = Counter(map(tuple,grid)) # <-- hash the rows of grid. (Note the tuple-map, so
# we can compare apples w/ apples in next step.)
return sum(tpse[t]*grid[t] for t in tpse) # <-- compute the number of identical pairs
# https://leetcode.com/submissions/detail/755717162/
|
equal-row-and-column-pairs
|
Python3 || 3 lines, transpose, Ctr w/ explanation || T/M: 100%/100%
|
warrenruud
| 12
| 443
|
equal row and column pairs
| 2,352
| 0.71
|
Medium
| 32,258
|
https://leetcode.com/problems/equal-row-and-column-pairs/discuss/2643204/Python-Elegant-and-Short-or-O(n3)-vs-O(n2)-or-Hashing
|
class Solution:
"""
Time: O(n^3)
Memory: O(1)
"""
def equalPairs(self, grid: List[List[int]]) -> int:
n = len(grid)
pairs = 0
for i in range(n):
for j in range(n):
for k in range(n):
if grid[i][k] != grid[k][j]:
break
else:
pairs += 1
return pairs
|
equal-row-and-column-pairs
|
Python Elegant & Short | O(n^3) vs O(n^2) | Hashing
|
Kyrylo-Ktl
| 4
| 94
|
equal row and column pairs
| 2,352
| 0.71
|
Medium
| 32,259
|
https://leetcode.com/problems/equal-row-and-column-pairs/discuss/2643204/Python-Elegant-and-Short-or-O(n3)-vs-O(n2)-or-Hashing
|
class Solution:
"""
Time: O(n^2)
Memory: O(n)
"""
def equalPairs(self, grid: List[List[int]]) -> int:
mp = defaultdict(int)
for col in zip(*grid):
mp[self.serialize(col)] += 1
return sum(mp[self.serialize(row)] for row in grid)
@staticmethod
def serialize(nums: Generator) -> str:
return ','.join(map(str, nums))
|
equal-row-and-column-pairs
|
Python Elegant & Short | O(n^3) vs O(n^2) | Hashing
|
Kyrylo-Ktl
| 4
| 94
|
equal row and column pairs
| 2,352
| 0.71
|
Medium
| 32,260
|
https://leetcode.com/problems/equal-row-and-column-pairs/discuss/2324772/Python3-freq-table-O(N2)
|
class Solution:
def equalPairs(self, grid: List[List[int]]) -> int:
freq = Counter(tuple(row) for row in grid)
return sum(freq[tuple(col)] for col in zip(*grid))
|
equal-row-and-column-pairs
|
[Python3] freq table O(N^2)
|
ye15
| 2
| 129
|
equal row and column pairs
| 2,352
| 0.71
|
Medium
| 32,261
|
https://leetcode.com/problems/equal-row-and-column-pairs/discuss/2324775/Python-oror-Easy-Approach
|
class Solution:
def equalPairs(self, grid: List[List[int]]) -> int:
n = len(grid)
ans = 0
for i in range(n):
res = []
for j in range(n):
res = []
for k in range(n):
res.append(grid[k][j])
if res == grid[i]:
ans += 1
return ans
|
equal-row-and-column-pairs
|
✅Python || Easy Approach
|
chuhonghao01
| 1
| 70
|
equal row and column pairs
| 2,352
| 0.71
|
Medium
| 32,262
|
https://leetcode.com/problems/equal-row-and-column-pairs/discuss/2847926/Py-Hash-O(N2)
|
class Solution:
def equalPairs(self, arr: List[List[int]]) -> int:
def convert_key(arr):
return tuple(arr)
dic = defaultdict(int)
for row in arr:
dic[convert_key(row)] += 1
dic2 = defaultdict(int)
for column in range(len(arr)):
temp = []
for row in arr:
temp.append(row[column])
dic2[convert_key(temp)] += 1
ans = 0
for item in dic:
ans += dic[item] * dic2[item]
return ans
|
equal-row-and-column-pairs
|
Py Hash O(N^2)
|
haly-leshchuk
| 0
| 1
|
equal row and column pairs
| 2,352
| 0.71
|
Medium
| 32,263
|
https://leetcode.com/problems/equal-row-and-column-pairs/discuss/2834658/solution-using-4-dictionaries
|
class Solution:
def equalPairs(self, grid: List[List[int]]) -> int:
from collections import defaultdict
mydict1 = defaultdict(list) #O(N)
mydict2 = defaultdict(list) #O(N)
for i in range(len(grid)):
for j in range(len(grid[i])):
mydict1[i].append(grid[i][j])
mydict2[j].append(grid[i][j])
d1 = defaultdict(int)
d2 = defaultdict(int)
for k1,v1 in mydict1.items():
d1[tuple(v1)]+=1
for k2,v2 in mydict2.items():
d2[tuple(v2)]+=1
nIdentical =0
for k in d1:
nIdentical += d1[k]*d2[k]
return nIdentical
|
equal-row-and-column-pairs
|
solution using 4 dictionaries
|
user5580aS
| 0
| 2
|
equal row and column pairs
| 2,352
| 0.71
|
Medium
| 32,264
|
https://leetcode.com/problems/equal-row-and-column-pairs/discuss/2760969/python-O(n*n)-T.C
|
class Solution:
def equalPairs(self, grid: List[List[int]]) -> int:
#row and col hash-maps
row = {}
col = {}
n = len(grid)
#extracting the rows
for i in grid:
if tuple(i) in row:
row[tuple(i)] += 1
else:
row[tuple(i)] = 1
#extracting the coloumns
for j in range(0 , n):
temp = []
for i in range(0 , n):
temp.append(grid[i][j])
if tuple(temp) in col:
col[tuple(temp)] += 1
else:
col[tuple(temp)] = 1
pairs = 0
#finding out the no of pairs
for i in row:
if i in col:
pairs += row[i]*col[i]
return pairs
|
equal-row-and-column-pairs
|
python O(n*n) T.C
|
akashp2001
| 0
| 2
|
equal row and column pairs
| 2,352
| 0.71
|
Medium
| 32,265
|
https://leetcode.com/problems/equal-row-and-column-pairs/discuss/2758735/Python-easy-to-read-and-understand
|
class Solution:
def equalPairs(self, grid: List[List[int]]) -> int:
n = len(grid)
rows = grid
cols = []
for i in range(n):
temp = []
for j in range(n):
temp.append(grid[j][i])
cols.append(temp)
res = 0
for row in rows:
for col in cols:
#print(row, col)
if row == col:
res += 1
return res
|
equal-row-and-column-pairs
|
Python easy to read and understand
|
sanial2001
| 0
| 4
|
equal row and column pairs
| 2,352
| 0.71
|
Medium
| 32,266
|
https://leetcode.com/problems/equal-row-and-column-pairs/discuss/2756177/Python3-Easy-O(n2)-Solution-using-Hashing
|
class Solution:
MOD = 10 ** 9 + 7
BASE = 10 ** 5 + 1
def equalPairs(self, grid: List[List[int]]) -> int:
row_arr, col_arr = [0] * len(grid), [0] * len(grid)
for i, row in enumerate(grid):
for j, col in enumerate(row):
row_arr[i] = (row_arr[i] * Solution.BASE + col) % Solution.MOD
col_arr[j] = (col_arr[j] * Solution.BASE + col) % Solution.MOD
ans = 0
for row_sum in row_arr:
for col_sum in col_arr:
if row_sum == col_sum:
ans += 1
return ans
|
equal-row-and-column-pairs
|
[Python3] Easy O(n^2) Solution using Hashing
|
huangweijing
| 0
| 4
|
equal row and column pairs
| 2,352
| 0.71
|
Medium
| 32,267
|
https://leetcode.com/problems/equal-row-and-column-pairs/discuss/2438979/Python3-Solution-with-using-hashmap
|
class Solution:
def equalPairs(self, grid: List[List[int]]) -> int:
d = collections.defaultdict(int)
for row in grid:
d[tuple(row)] += 1
res = 0
for j in range(len(grid[0])):
res += d[tuple([grid[i][j] for i in range(len(grid[0]))])]
return res
|
equal-row-and-column-pairs
|
[Python3] Solution with using hashmap
|
maosipov11
| 0
| 23
|
equal row and column pairs
| 2,352
| 0.71
|
Medium
| 32,268
|
https://leetcode.com/problems/equal-row-and-column-pairs/discuss/2429015/easy-python-solution
|
class Solution:
def makeColumns(self, grid) :
output = []
for i in range(len(grid)) :
col = []
for j in range(len(grid)) :
col.append(grid[j][i])
output.append(col)
return output
def equalPairs(self, grid: List[List[int]]) -> int:
cols = self.makeColumns(grid)
count = 0
for col in cols :
if col in grid :
count += grid.count(col)
return count
|
equal-row-and-column-pairs
|
easy python solution
|
sghorai
| 0
| 15
|
equal row and column pairs
| 2,352
| 0.71
|
Medium
| 32,269
|
https://leetcode.com/problems/equal-row-and-column-pairs/discuss/2409504/Easy-python-solution
|
class Solution:
def equalPairs(self, rows: List[List[int]]) -> int:
columns = []
rows_length = len(rows)
cols_length = len(rows[0])
for i in range(0, rows_length):
res = []
for j in range(0, cols_length):
res.append(rows[j][i])
columns.append(res)
#print(columns)
ans = 0
for i in columns:
for j in rows:
if i == j:
ans+=1
return ans
|
equal-row-and-column-pairs
|
Easy python solution 💯
|
EbrahimMG
| 0
| 23
|
equal row and column pairs
| 2,352
| 0.71
|
Medium
| 32,270
|
https://leetcode.com/problems/equal-row-and-column-pairs/discuss/2351472/Python-HashMap-or-beats-90-by-runtime-or-100-by-memory
|
class Solution:
def equalPairs(self, grid: List[List[int]]) -> int:
s_rows = defaultdict(int)
for i in range(len(grid)):
row = " ".join([str(g) for g in grid[i]])
s_rows[row] += 1
answer = 0
for i in range(len(grid[0])):
col = " ".join([str(grid[j][i]) for j in range(len(grid))])
if col in s_rows:
answer += s_rows[col]
return answer
|
equal-row-and-column-pairs
|
Python HashMap | beats 90% by runtime | 100% by memory
|
pivovar3al
| 0
| 62
|
equal row and column pairs
| 2,352
| 0.71
|
Medium
| 32,271
|
https://leetcode.com/problems/equal-row-and-column-pairs/discuss/2332084/Python-easy-solution-for-beginners-memory-less-than-100
|
class Solution:
def equalPairs(self, grid: List[List[int]]) -> int:
res = 0
transpose = list(list(x) for x in zip(*grid))
for i in grid:
if i in transpose:
res += transpose.count(i)
return res
|
equal-row-and-column-pairs
|
Python easy solution for beginners, memory less than 100%
|
alishak1999
| 0
| 35
|
equal row and column pairs
| 2,352
| 0.71
|
Medium
| 32,272
|
https://leetcode.com/problems/equal-row-and-column-pairs/discuss/2331851/Counter-of-tuples-90-speed
|
class Solution:
def equalPairs(self, grid: List[List[int]]) -> int:
cnt = Counter(tuple(g) for g in grid)
return sum(cnt[row] for row in zip(*grid))
|
equal-row-and-column-pairs
|
Counter of tuples, 90% speed
|
EvgenySH
| 0
| 13
|
equal row and column pairs
| 2,352
| 0.71
|
Medium
| 32,273
|
https://leetcode.com/problems/equal-row-and-column-pairs/discuss/2329225/Python3-faster-than-100
|
class Solution:
def equalPairs(self, grid: List[List[int]]) -> int:
new_arr=[]
n=len(grid)
for i in range(n):
new_arr.append([0]*n)
for i in range(n):
for j in range(n):
new_arr[i][j]=grid[j][i]
d={}
for i in grid:
if tuple(i) in d:
d[tuple(i)]+=1
else:
d[tuple(i)]=1
ans=0
for i in new_arr:
if tuple(i) in d:
ans+=d[tuple(i)]
return ans
|
equal-row-and-column-pairs
|
Python3 faster than 100%
|
svr300
| 0
| 14
|
equal row and column pairs
| 2,352
| 0.71
|
Medium
| 32,274
|
https://leetcode.com/problems/equal-row-and-column-pairs/discuss/2328906/python-hashmap-easy-understand
|
class Solution(object):
def equalPairs(self, grid):
"""
:type grid: List[List[int]]
:rtype: int
"""
m, n = len(grid), len(grid[0])
dic = defaultdict(int)
res = 0
for i in range(m):
cur = []
for j in range(n):
cur.append(str(grid[i][j]))
dic[','.join(cur)] += 1
for j in range(n):
cur = []
for i in range(m):
cur.append(str(grid[i][j]))
if ','.join(cur) in dic:
res += dic[','.join(cur)]
return res
|
equal-row-and-column-pairs
|
python hashmap easy understand
|
Kennyyhhu
| 0
| 31
|
equal row and column pairs
| 2,352
| 0.71
|
Medium
| 32,275
|
https://leetcode.com/problems/equal-row-and-column-pairs/discuss/2328801/Python-2-lines
|
class Solution:
def equalPairs(self, grid: List[List[int]]) -> int:
colCounter = Counter(zip(*grid))
return sum(colCounter[row] for row in map(tuple, grid))
|
equal-row-and-column-pairs
|
Python 2 lines
|
SmittyWerbenjagermanjensen
| 0
| 18
|
equal row and column pairs
| 2,352
| 0.71
|
Medium
| 32,276
|
https://leetcode.com/problems/equal-row-and-column-pairs/discuss/2326526/Python-Easy-Understanding-Solution
|
class Solution:
def equalPairs(self, grid: List[List[int]]) -> int:
m = n = len(grid)
res = 0
for i in range(n):
for j in range(n):
tmp = [grid[k][j] for k in range(n)]
if grid[i] == tmp:
res += 1
return res
|
equal-row-and-column-pairs
|
Python Easy Understanding Solution
|
blazers08
| 0
| 6
|
equal row and column pairs
| 2,352
| 0.71
|
Medium
| 32,277
|
https://leetcode.com/problems/equal-row-and-column-pairs/discuss/2325728/PYTHON-3-BRUTE-FORCE-SOLUTION
|
class Solution:
def equalPairs(self, grid: List[List[int]]) -> int:
col = list(list(item) for item in zip(*grid))
count = 0
for arr in grid:
for arr1 in col:
if arr == arr1:
count += 1
return count
|
equal-row-and-column-pairs
|
PYTHON 3 BRUTE FORCE SOLUTION
|
varunshrivastava2706
| 0
| 5
|
equal row and column pairs
| 2,352
| 0.71
|
Medium
| 32,278
|
https://leetcode.com/problems/equal-row-and-column-pairs/discuss/2325260/Intutive-Python-solution
|
class Solution:
def equalPairs(self, grid: List[List[int]]) -> int:
cols = []
for c in range(len(grid[0])):
temp = []
for r in range(len(grid)):
temp.append(grid[r][c])
cols.append(temp)
count = 0
for r in grid:
for c in cols:
if r==c:
count+=1
return count
|
equal-row-and-column-pairs
|
Intutive Python solution
|
pradeep288
| 0
| 23
|
equal row and column pairs
| 2,352
| 0.71
|
Medium
| 32,279
|
https://leetcode.com/problems/equal-row-and-column-pairs/discuss/2325119/Python3-Easy-hashmap-solution
|
class Solution:
def equalPairs(self, grid: List[List[int]]) -> int:
m = len(grid)
n = len(grid[0])
check = collections.defaultdict(int)
for row in grid:
s = "-".join(map(str, row))
check[s] += 1
ans = 0
for col in range(n):
arr = []
for r in range(m):
arr.append(grid[r][col])
s = "-".join(map(str, arr))
if s in check:
ans += check[s]
return ans
|
equal-row-and-column-pairs
|
[Python3] Easy hashmap solution
|
nightybear
| 0
| 21
|
equal row and column pairs
| 2,352
| 0.71
|
Medium
| 32,280
|
https://leetcode.com/problems/equal-row-and-column-pairs/discuss/2324778/Python-or-Counting
|
class Solution:
def equalPairs(self, grid: List[List[int]]) -> int:
rows = grid.copy()
cols = []
N = len(grid)
for c in range(N):
each_col = []
for r in range(N):
each_col.append(grid[r][c])
cols.append(each_col)
print(rows, cols)
count = 0
for r in rows:
for c in cols:
if r == c:
count += 1
return count
|
equal-row-and-column-pairs
|
[Python] | Counting
|
tejeshreddy111
| 0
| 18
|
equal row and column pairs
| 2,352
| 0.71
|
Medium
| 32,281
|
https://leetcode.com/problems/equal-row-and-column-pairs/discuss/2324753/Python3-Prefix-Tree-Solution
|
class Solution:
def equalPairs(self, grid: List[List[int]]) -> int:
root = {}
n = len(grid)
for i in range(n):
tmp = root
for j in range(n):
if grid[i][j] not in tmp:
tmp[grid[i][j]] = {}
tmp = tmp[grid[i][j]]
if '#' in tmp:
tmp['#'] += 1
else:
tmp['#'] = 1
numPair = 0
for j in range(n):
tmp = root
for i in range(n):
if grid[i][j] not in tmp:
break
tmp = tmp[grid[i][j]]
if '#' in tmp:
numPair += tmp['#']
return numPair
|
equal-row-and-column-pairs
|
Python3 Prefix Tree Solution
|
TongHeartYes
| 0
| 6
|
equal row and column pairs
| 2,352
| 0.71
|
Medium
| 32,282
|
https://leetcode.com/problems/number-of-excellent-pairs/discuss/2324641/Python3-Sorting-Hamming-Weights-%2B-Binary-Search-With-Detailed-Explanations
|
class Solution:
def countExcellentPairs(self, nums: List[int], k: int) -> int:
hamming = sorted([self.hammingWeight(num) for num in set(nums)])
ans = 0
for h in hamming:
ans += len(hamming) - bisect.bisect_left(hamming, k - h)
return ans
def hammingWeight(self, n):
ans = 0
while n:
n &= (n - 1)
ans += 1
return ans
|
number-of-excellent-pairs
|
[Python3] Sorting Hamming Weights + Binary Search With Detailed Explanations
|
xil899
| 20
| 674
|
number of excellent pairs
| 2,354
| 0.458
|
Hard
| 32,283
|
https://leetcode.com/problems/number-of-excellent-pairs/discuss/2324641/Python3-Sorting-Hamming-Weights-%2B-Binary-Search-With-Detailed-Explanations
|
class Solution:
def countExcellentPairs(self, nums: List[int], k: int) -> int:
hamming = sorted([num.bit_count() for num in set(nums)])
ans = 0
for h in hamming:
ans += len(hamming) - bisect.bisect_left(hamming, k - h)
return ans
|
number-of-excellent-pairs
|
[Python3] Sorting Hamming Weights + Binary Search With Detailed Explanations
|
xil899
| 20
| 674
|
number of excellent pairs
| 2,354
| 0.458
|
Hard
| 32,284
|
https://leetcode.com/problems/number-of-excellent-pairs/discuss/2324641/Python3-Sorting-Hamming-Weights-%2B-Binary-Search-With-Detailed-Explanations
|
class Solution:
def countExcellentPairs(self, nums: List[int], k: int) -> int:
hamming = Counter([num.bit_count() for num in set(nums)])
ans = 0
for h1 in hamming:
for h2 in hamming:
if h1 + h2 < k:
continue
ans += hamming[h1] * hamming[h2]
return ans
|
number-of-excellent-pairs
|
[Python3] Sorting Hamming Weights + Binary Search With Detailed Explanations
|
xil899
| 20
| 674
|
number of excellent pairs
| 2,354
| 0.458
|
Hard
| 32,285
|
https://leetcode.com/problems/number-of-excellent-pairs/discuss/2353661/python-or-O(nlogn)-sorting-%2B-binary-search-solution-explained
|
class Solution:
def countExcellentPairs(self, nums: List[int], k: int) -> int:
# Count the Number of Bits in Each Unique Number - O(n)
# Tally the Number of Times Each Bit Count Occurs - O(n)
# Sort the (bit count, tally) pairs by bit count - O(nlogn)
counts = sorted(Counter(map(int.bit_count, set(nums))).items()) # (I am fully aware that this line of code is really doing too much work)
# Compute the Reversed Prefix Sum of the Tallies (i.e. sums[i] is how many numbers have at least counts[i][0] '1' bits) - O(n)
sums = [0]*len(counts)
sums[-1] = counts[-1][1]
for i in range(len(sums) - 2, -1, -1):
sums[i] += counts[i][1] + sums[i + 1]
# Choose Each Number as the First Number of a Pair - O(nlogn)
pairs = 0
for n, c in counts:
# Find the Smallest Number Which Forms a Valid Pair - O(logn)
i = bisect_left(counts, k - n, key = lambda x: x[0])
# Check if Any Pairs Can be Formed
if i < len(sums):
# Compute the Number of Pairs Which Start With the Given Collection of Numbers
pairs += c*sums[i]
# Return the Number of Pairs
return pairs
|
number-of-excellent-pairs
|
python | O(nlogn) sorting + binary search solution explained
|
queenTau
| 4
| 100
|
number of excellent pairs
| 2,354
| 0.458
|
Hard
| 32,286
|
https://leetcode.com/problems/number-of-excellent-pairs/discuss/2472142/Python-Solution-or-Brute-Force-or-Optimized-or-O(N)
|
class Solution:
def countExcellentPairs(self, nums: List[int], k: int) -> int:
count=0
n=len(nums)
# Brute Force
# s=set()
# for i in range(n):
# for j in range(n):
# a=nums[i] | nums[j]
# b=nums[i] & nums[j]
# a_count=bin(a).count('1')
# b_count=bin(b).count('1')
# if a_count+b_count>=k and (nums[i], nums[j]) not in s:
# s.add((nums[i], nums[j]))
# count+=1
# return count
arr=[]
for num in set(nums):
arr.append(bin(num).count('1'))
arr.sort()
l=0
r=len(arr)-1
ans=0
while l<=r:
if arr[l]+arr[r]>=k:
ans+=(r-l)*2 + 1
r-=1
else:
l+=1
return ans
|
number-of-excellent-pairs
|
Python Solution | Brute Force | Optimized | O(N)
|
Siddharth_singh
| 1
| 41
|
number of excellent pairs
| 2,354
| 0.458
|
Hard
| 32,287
|
https://leetcode.com/problems/number-of-excellent-pairs/discuss/2325096/Python-Simple-Solution
|
class Solution:
def countExcellentPairs(self, nums: List[int], k: int) -> int:
nums.sort()
mapp = defaultdict(set)
ans = 0
last = None
for i in nums:
if i==last:
continue
b = format(i,'b').count('1')
mapp[b].add(i)
t = k-b
for j in range(max(0,t),31):
ans+=len(mapp[j])*2
if i in mapp[j]:
ans-=1
last = i
return ans
|
number-of-excellent-pairs
|
Python Simple Solution
|
RedHeadphone
| 1
| 52
|
number of excellent pairs
| 2,354
| 0.458
|
Hard
| 32,288
|
https://leetcode.com/problems/number-of-excellent-pairs/discuss/2324816/Python3-sum-of-set-bits
|
class Solution:
def countExcellentPairs(self, nums: List[int], k: int) -> int:
nums = set(nums)
freq = [0]*30
for x in nums: freq[bin(x).count('1')] += 1
prefix = list(accumulate(freq, initial=0))
ans = 0
for x in nums:
bits = bin(x).count('1')
lo = min(30, max(0, k-bits))
ans += prefix[-1] - prefix[lo]
return ans
|
number-of-excellent-pairs
|
[Python3] sum of set bits
|
ye15
| 1
| 56
|
number of excellent pairs
| 2,354
| 0.458
|
Hard
| 32,289
|
https://leetcode.com/problems/number-of-excellent-pairs/discuss/2324816/Python3-sum-of-set-bits
|
class Solution:
def countExcellentPairs(self, nums: List[int], k: int) -> int:
freq = Counter(map(int.bit_count, set(nums)))
return sum(v1*v2 for k1, v1 in freq.items() for k2, v2 in freq.items() if k1+k2 >= k)
|
number-of-excellent-pairs
|
[Python3] sum of set bits
|
ye15
| 1
| 56
|
number of excellent pairs
| 2,354
| 0.458
|
Hard
| 32,290
|
https://leetcode.com/problems/make-array-zero-by-subtracting-equal-amounts/discuss/2357747/Set
|
class Solution:
def minimumOperations(self, nums: List[int]) -> int:
return len(set(nums) - {0})
|
make-array-zero-by-subtracting-equal-amounts
|
Set
|
votrubac
| 17
| 1,500
|
make array zero by subtracting equal amounts
| 2,357
| 0.727
|
Easy
| 32,291
|
https://leetcode.com/problems/make-array-zero-by-subtracting-equal-amounts/discuss/2357890/Python-easy-solution
|
class Solution:
def minimumOperations(self, nums: List[int]) -> int:
n = len(nums)
count = 0
while nums != [0]*n:
count += 1
small = min([i for i in nums if i > 0])
for i in range(n):
if nums[i] != 0:
nums[i] -= small
return count
|
make-array-zero-by-subtracting-equal-amounts
|
Python easy solution
|
ratre21
| 5
| 658
|
make array zero by subtracting equal amounts
| 2,357
| 0.727
|
Easy
| 32,292
|
https://leetcode.com/problems/make-array-zero-by-subtracting-equal-amounts/discuss/2532978/Python3-Solution
|
class Solution:
def minimumOperations(self, nums: List[int]) -> int:
nums = set(nums)
if 0 in nums:
return(len(nums)-1)
else:
return(len(nums))
|
make-array-zero-by-subtracting-equal-amounts
|
Python3 Solution
|
nkrishk
| 3
| 134
|
make array zero by subtracting equal amounts
| 2,357
| 0.727
|
Easy
| 32,293
|
https://leetcode.com/problems/make-array-zero-by-subtracting-equal-amounts/discuss/2358185/Python-oror-Easy-Approach
|
class Solution:
def minimumOperations(self, nums: List[int]) -> int:
num = set(nums)
a = list(num)
a.sort()
ans = 0
for i in range(len(a)):
if a[i] != 0:
ans += 1
for j in range(i + 1, len(a)):
a[j] -= a[i]
return ans
|
make-array-zero-by-subtracting-equal-amounts
|
✅Python || Easy Approach
|
chuhonghao01
| 2
| 138
|
make array zero by subtracting equal amounts
| 2,357
| 0.727
|
Easy
| 32,294
|
https://leetcode.com/problems/make-array-zero-by-subtracting-equal-amounts/discuss/2358185/Python-oror-Easy-Approach
|
class Solution:
def minimumOperations(self, nums: List[int]) -> int:
count = 0
while max(nums) != 0:
minValue = float('inf')
for i in range(len(nums)):
if nums[i] != 0 and nums[i] < minValue:
minValue = nums[i]
for i in range(len(nums)):
nums[i] = max(nums[i] - minValue, 0)
count += 1
return count
|
make-array-zero-by-subtracting-equal-amounts
|
✅Python || Easy Approach
|
chuhonghao01
| 2
| 138
|
make array zero by subtracting equal amounts
| 2,357
| 0.727
|
Easy
| 32,295
|
https://leetcode.com/problems/make-array-zero-by-subtracting-equal-amounts/discuss/2563261/Make-Array-Zero-by-Subtracting-Equal-Amounts
|
class Solution:
def minimumOperations(self, nums: List[int]) -> int:
uniqueNumbers = set()
for i in nums:
if i==0:
continue
if i in uniqueNumbers:
continue
uniqueNumbers.add(i)
return len(uniqueNumbers)
|
make-array-zero-by-subtracting-equal-amounts
|
Make Array Zero by Subtracting Equal Amounts
|
dhananjayaduttmishra
| 1
| 37
|
make array zero by subtracting equal amounts
| 2,357
| 0.727
|
Easy
| 32,296
|
https://leetcode.com/problems/make-array-zero-by-subtracting-equal-amounts/discuss/2394569/Heap-PYTHON3-Solution
|
class Solution:
def minimumOperations(self, nums: List[int]) -> int:
minHeap=[]
for i in nums:
if i!=0:
heappush(minHeap,i)
ans=0
while minHeap:
t=heappop(minHeap)
while minHeap and t==minHeap[0]:
heappop(minHeap)
ans+=1
for i in range(len(minHeap)):
minHeap[i]-=t
return ans
|
make-array-zero-by-subtracting-equal-amounts
|
Heap PYTHON3 Solution
|
shambhavi_gupta
| 1
| 70
|
make array zero by subtracting equal amounts
| 2,357
| 0.727
|
Easy
| 32,297
|
https://leetcode.com/problems/make-array-zero-by-subtracting-equal-amounts/discuss/2381544/Python-easy-solution-for-beginners-using-slicing-and-sorting
|
class Solution:
def minimumOperations(self, nums: List[int]) -> int:
if nums == [0] * len(nums):
return 0
count_op = 0
while True:
nums.sort()
count_zero = nums.count(0)
nums = nums[count_zero:]
if nums == []:
return count_op
choose = nums[0]
for i in range(len(nums)):
nums[i] -= choose
count_op += 1
|
make-array-zero-by-subtracting-equal-amounts
|
Python easy solution for beginners using slicing and sorting
|
alishak1999
| 1
| 98
|
make array zero by subtracting equal amounts
| 2,357
| 0.727
|
Easy
| 32,298
|
https://leetcode.com/problems/make-array-zero-by-subtracting-equal-amounts/discuss/2793353/Brute-force-python-solution-or-Faster-than-86
|
class Solution:
def minimumOperations(self, nums: List[int]) -> int:
count = 0
while sum(nums) != 0:
min_elem = min([i for i in nums if i != 0])
for index, num in enumerate(nums):
if num != 0:
nums[index] -= min_elem
count += 1
return count
|
make-array-zero-by-subtracting-equal-amounts
|
Brute force python solution | Faster than 86%
|
prameshbajra
| 0
| 5
|
make array zero by subtracting equal amounts
| 2,357
| 0.727
|
Easy
| 32,299
|
Subsets and Splits
Top 2 Solutions by Upvotes
Identifies the top 2 highest upvoted Python solutions for each problem, providing insight into popular approaches.