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/longest-palindrome-by-concatenating-two-letter-words/discuss/2825459/Python-3-greedy-easy-to-understand-with-comments | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
dct = {}
sum_ = 0
cc_odd_ind = 0 # word that contains 2 identical letters (for instance, 'aa') - flag of odd number
# create dictionary
for wrd in words:
dct[wrd] = dct.get(wrd, 0) + 1
# iterate through dictionary
for k, v in dct.items():
# the first letter == the second letter
if k[0] == k[1]:
sum_ += v // 2 * 2 # add the nearest even number (7 --> 6, 6 --> 6, 5 --> 4, 4 --> 4)
# odd number
if v % 2 == 1:
cc_odd_ind = 1 # create flag of odd number
# the first letter == the second letter
else:
sum_ += min(dct.get(k, 0), \
dct.get(k[::-1], 0)) # add minimum of 2 pairs (for instance, 'cl' and 'lc')
return (sum_ + cc_odd_ind) * 2 | longest-palindrome-by-concatenating-two-letter-words | Python 3 - greedy - easy to understand - with comments | noob_in_prog | 0 | 2 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,500 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2818612/Python-3-Simple-and-Intuitive-Explanation-beating-95. | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
length = 0
seen = dict()
middle_used = False
for word in words:
seen[word] = seen.get(word, 0) + 1
for word in seen.keys():
if word[1] + word[0] in seen.keys():
length += min(seen[word], seen[word[1] + word[0]])
if word[0] == word[1] and (seen[word] % 2) != 0:
if middle_used:
length -= 1
else:
middle_used = True
return length * 2 | longest-palindrome-by-concatenating-two-letter-words | [Python 3] Simple and Intuitive Explanation beating 95%. | user7530s | 0 | 1 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,501 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2786586/Pretty-Clear-Solution-Python-or-O(N)-Hashmap | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
d=defaultdict(int)
for word in words:
d[word]+=1
cnt=0
if_odd=False
vis=set()
for key,val in d.items():
if key not in vis:
if key[0]==key[1]:
if d[key]%2!=0:
if_odd=True
cnt+=2*d[key]-2
else:
cnt+=2*d[key]
else:
if key[::-1] in d:
min_cnt=min(d[key],d[key[::-1]])
cnt+=4*min_cnt
vis.add(key[::-1])
vis.add(key)
if if_odd:
return cnt+2
return cnt | longest-palindrome-by-concatenating-two-letter-words | Pretty Clear Solution Python | O(N) Hashmap | praveen0906 | 0 | 1 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,502 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2782874/Simple-yet-Best-Interview-Code-or-Python-Beginner-Friendly | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
n = len(words)
hashmap = {}
LPCount = 0
for i in range(n):
word = words[i]
reverse_word = word[::-1]
if reverse_word in hashmap:
LPCount += 4
hashmap[reverse_word] -= 1
if hashmap[reverse_word] == 0:
del hashmap[reverse_word]
else:
if word in hashmap:
hashmap[word] += 1
else:
hashmap[word] = 1
for word in hashmap:
if word[0] == word[1]:
LPCount += 2
break
return LPCount | longest-palindrome-by-concatenating-two-letter-words | Simple yet Best Interview Code | Python Beginner Friendly | reinkarnation | 0 | 5 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,503 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2778830/Easy-PYTHON | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
x=Counter(words)
count=0
mid=False
for i,j in x.items():
if i[0]==i[1]:
if j%2==0:
count+=2*j
else:
count+=(j-1)*2
mid=True
continue
if i[1]+i[0] in x:
count+=2*min(j,x[i[1]+i[0]])
return count+2 if mid else count | longest-palindrome-by-concatenating-two-letter-words | Easy PYTHON | Chetan_007 | 0 | 3 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,504 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2778535/Python-solution-using-set | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
cnt = collections.Counter(words)
aa, ab = 0, 0
cond = True
st = set(words)
for w in st:
if w in cnt and w[::-1] in cnt:
if w[0] == w[1]:
if cnt[w] % 2 and cond:
aa += min(cnt[w], cnt[w[::-1]])
cond = False
elif cnt[w]% 2:
aa += (min(cnt[w], cnt[w[::-1]]) - 1)
else:
aa += (min(cnt[w], cnt[w[::-1]]))
else:
ab += min(cnt[w], cnt[w[::-1]])
return (aa + ab) * 2 | longest-palindrome-by-concatenating-two-letter-words | Python solution using set | EraCoding | 0 | 3 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,505 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2777458/Python-Solution | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
count = 0
frequency = defaultdict(int)
seen = set()
for word in words:
if frequency[word] > 0:
frequency[word] -= 1
count += 4
else:
frequency[word[::-1]] += 1
if word[0] == word[1]:
if word in seen:
seen.remove(word)
else:
seen.add(word)
return count if len(seen) == 0 else count + 2 | longest-palindrome-by-concatenating-two-letter-words | Python Solution | mansoorafzal | 0 | 2 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,506 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2777252/Python-Simple-Python-Solution-Using-HashMap-or-Dictionary | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
different = {}
same = {}
for word in words:
if word[0] != word[1]:
if word not in different:
different[word] = 1
else:
different[word] = different[word] + 1
else:
if word not in same:
same[word] = 1
else:
same[word] = same[word] + 1
result = 0
visited = []
for key in different:
if key not in visited and key[::-1] not in visited and key[::-1] in different:
result = result + min(different[key], different[key[::-1]]) * 4
visited.append(key)
visited.append(key[::-1])
odd_check = False
for key in same:
if same[key] % 2 == 0:
result = result + same[key] * 2
else:
if odd_check == False:
result = result + (same[key] // 2) * 4 + 2
odd_check = True
else:
result = result + (same[key] // 2) * 4
return result | longest-palindrome-by-concatenating-two-letter-words | [ Python ] ✅✅ Simple Python Solution Using HashMap | Dictionary 🥳✌👍 | ASHOK_KUMAR_MEGHVANSHI | 0 | 10 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,507 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2775442/Longest-Palindrome-python-O(n) | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
n = len(words)
totalw = 0
waiting = collections.Counter()
waiting_special = collections.Counter()
for i in range(n):
word = words[i]
if word[-1] == word[0]:
waiting_special[word] += 1
if waiting_special[word] == 2:
totalw += 4
waiting_special.pop(word)
continue
if waiting[word[::-1]]>=1:
word = word[::-1]
waiting[word] -= 1
totalw += 4
else:
waiting[word] += 1
if len(waiting_special) > 0:
totalw += 2
return totalw | longest-palindrome-by-concatenating-two-letter-words | Longest Palindrome - python - O(n) | DavidCastillo | 0 | 4 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,508 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2774926/Python.-As-short-as-it-gets! | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
count = collections.Counter(words)
diff, same, odd = 0, 0, 0
for word, c in count.items():
if word[0] == word[1]:
same += (c // 2) * 2
odd = odd | (c & 1)
else:
diff += min(c, count[word[::-1]])
return (diff + same + odd) * 2 | longest-palindrome-by-concatenating-two-letter-words | 😎Python. As short as it gets! | aminjun | 0 | 5 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,509 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2774695/beats-more-than-80 | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
dic = {}
sum = 0
t = []
for i in words:
if dic.get(i) == None and (dic.get(i[::-1]) == None or dic.get(i[::-1]) == 0) :
if i == i[::-1]:
t.append(i)
dic[i] = 1
elif dic.get(i[::-1]) != None and dic.get(i[::-1]) != 0:
dic[i[::-1]] -= 1
sum += 4
else:
dic[i] += 1
for i in t:
if dic[i]==1:
sum+=2
break
return sum | longest-palindrome-by-concatenating-two-letter-words | beats more than 80% | sivamani921124 | 0 | 5 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,510 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2774461/python3-hashtable-approach-O(n)-time | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
d, res, centerWords = {}, 0, 0
for w in words: d[w] = d[w] + 1 if w in d else 1
for key in list(d.keys()):
if key[0] == key[1]:
res += 4 * (d[key] // 2)
if not centerWords and d[key] % 2 == 1:
centerWords = 2
elif key[::-1] in d:
res += 4 * min(d[key], d[key[::-1]])
d[key[::-1]] = d[key] = 0
return res + centerWords | longest-palindrome-by-concatenating-two-letter-words | python3 hashtable approach, O(n) time | tinmanSimon | 0 | 8 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,511 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2774404/python3-easily-understandeble-code-with-98-runtime | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
l = Counter(words)
p_len = 0
mid = 0
print(l)
for word in l.keys():
if word[0] == word[1]:
if l[word]%2 == 0:
p_len += l[word]
else:
p_len += l[word]-1
mid = 1
elif word[::-1] in l:
p_len += min(l[word], l[word[::-1]])
return (p_len + mid) * 2 | longest-palindrome-by-concatenating-two-letter-words | python3 easily understandeble code with 98% runtime👍🙌 | V_Bhavani_Prasad | 0 | 8 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,512 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2774216/Python3-or-Runtime-95-or-Memory-Space-54 | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
result = max_padding = 0
# build a hashmap to reduce the search space
hashmap = defaultdict(int)
for word in words:
hashmap[word] += 1
words = [w for w in hashmap.keys()]
# search
ignored_idx = set()
for i, word in enumerate(words):
if i in ignored_idx:
continue
# check self
if len(set(word)) == 1:
result += hashmap[word] // 2 * 2 * len(word)
max_padding = max(max_padding, hashmap[word] % 2 * len(word))
continue
# check pair
rword = word[::-1]
for j in range(i+1, len(words)):
if j in ignored_idx:
continue
if rword == words[j]:
result += len(word) * 2 * min(hashmap[word], hashmap[rword])
ignored_idx.add(j)
break
return result + max_padding | longest-palindrome-by-concatenating-two-letter-words | Python3 | Runtime 95% | Memory Space 54% | afunTW | 0 | 9 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,513 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2773850/Short-and-easy-code | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
s = collections.defaultdict(int)
l, pair = 0, 0
for w in words:
k = w[::-1]
if s[k]:
pair -= 1 if k == w else 0
s[k] -= 1
l += 4
else:
pair += 1 if k == w else 0
s[w] += 1
return l+2 if pair else l | longest-palindrome-by-concatenating-two-letter-words | Short and easy code | Opheodrys | 0 | 12 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,514 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2773723/Python-3-Solution | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
D = defaultdict(int)
res = 0
p = False
for x in words:
D[x] += 1
for x in list(D.keys()):
if x[0] == x[1]:
if D[x]%2 == 1: p = True
res += (D[x]//2)*4
else:
res += 2*min(D[x],D[x[::-1]])
if p:
return res + 2
return res | longest-palindrome-by-concatenating-two-letter-words | Python 3 Solution | mati44 | 0 | 7 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,515 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2773639/python3-98-speed | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
counter = collections.Counter(words)
ans1, ans2, ans3 = 0, 0, False
for i in list(counter):
r = i[::-1]
if i == r:
ans2 += (counter[i] // 2)
ans3 |= (counter[i] % 2)
else:
v = min(counter[i], counter[r])
ans1 += (2*v)
counter[i] -= v
counter[r] -= v
return ans1*2+ans2*4+(2 if ans3 else 0) | longest-palindrome-by-concatenating-two-letter-words | python3, 98% speed | pjy953 | 0 | 10 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,516 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2773627/3-hash-Solution | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
pair1, pair2, same = dict(), dict(), dict()
for word in words:
# case2, making "cc" dict(same)
if len(set(word))==1:
if word not in same:
same[word] = 1
else:
same[word] += 1
# case1, making "ab" dict(pair1) & "ba" dict(pair2)
# if word already in pair2, then add 1 in pair2[word]
elif word in pair2:
pair2[word] += 1
else:
# basic case, add 1 in pair1[word]
if word not in pair1:
pair1[word] = 1
else:
pair1[word] += 1
# if word.reverse() not in pair2, then init to 0 in pair2[word]
if word[::-1] not in pair2:
pair2[word[::-1]] = 0
ans = 0
# calculate case1 : "ab" & "ba"
for k, v in pair1.items():
ans += min(v, pair2[k[::-1]])*4
# calculate case2 : "cc"
remain1 = False # check if there is any remaining "cc"
for v in same.values():
ans += v//2*4
if v%2: # if any count("cc") is odd
remain1 = True
return ans+2 if remain1 else ans | longest-palindrome-by-concatenating-two-letter-words | 3 hash Solution | child70370636 | 0 | 9 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,517 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2773569/Simple-intuitive-solution-with-HashMap-counter-O(n) | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
max_length = 0
word_counts = Counter()
middles = set()
for word in words:
revword = word[::-1]
if word_counts[revword] > 0:
word_counts[revword] -= 1
max_length += 2 * 2
if revword == word:
middles.remove(word)
else:
word_counts[word] += 1
if revword == word:
middles.add(word)
if middles:
max_length += 2
return max_length | longest-palindrome-by-concatenating-two-letter-words | Simple intuitive solution with HashMap counter, O(n) | romansalin | 0 | 8 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,518 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2773478/Python3-Commented-and-Readable-Hashmap | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
# we should go through each of the words and
# check whether it is a palindrome itself or
# we have a pair that forms a palindrome
palindromes = set()
opened = collections.Counter()
result = 0
for idx, word in enumerate(words):
# check whether it is in open pairs
if opened[word] > 0:
# we found a pair and can attach it to
# the palindromes
# also decrease the counter
result += 4
opened[word] -= 1
# put it in opened pairs
else:
opened[word[::-1]] += 1
# check whether it self is a palindrome
if word[1] == word[0]:
palindromes.add(word)
# check whether there is still one palindrome left
return result + (2 if any(opened[pal] > 0 for pal in palindromes) else 0) | longest-palindrome-by-concatenating-two-letter-words | [Python3] - Commented and Readable Hashmap | Lucew | 0 | 10 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,519 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2773363/Python-or-beats-99-or-using-Counter-(dictionary) | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
count = Counter(words)
length = 0
central_word = False
for key,value in count.items():
if key[0] == key[1]:
if value%2 != 0:
if central_word == False:
length += value * 2
central_word = True
else:
length += (value - 1) * 2
else:
length += value * 2
else:
reversed_word = key[1] + key[0]
if reversed_word in count and count[reversed_word] > 0:
n = min(value, count[reversed_word])
length += n * 4
count[key] = 0
count[reversed_word] = 0
return length | longest-palindrome-by-concatenating-two-letter-words | Python | beats 99% | using Counter (dictionary) | anandanshul001 | 0 | 11 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,520 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2773228/Python-(Faster-than-93)-or-O(N)-solution-using-HashMap | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
wordCount = {}
for word in words:
wordCount[word] = wordCount.get(word, 0) + 1
palinLen = 0
for w in wordCount:
if w == w[::-1]:
if wordCount[w] % 2 == 0:
palinLen += 2 * wordCount[w]
wordCount[w] = 0
else:
palinLen += 2 * (wordCount[w] - 1)
wordCount[w] = 1
elif w[::-1] in wordCount:
reflection = min(wordCount[w], wordCount[w[::-1]])
palinLen += reflection * 4
wordCount[w] -= reflection
wordCount[w[::-1]] -= reflection
for w in wordCount:
if w == w[::-1] and wordCount[w] == 1:
palinLen += 2
break
return palinLen | longest-palindrome-by-concatenating-two-letter-words | Python (Faster than 93%) | O(N) solution using HashMap | KevinJM17 | 0 | 5 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,521 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2773224/Simple-Descriptive-oror-Python-solution-oror-For-New-coders | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
dict_2 = {}
d = {}
count = 0
# creating main_dictonary
for i in range(0, len(words)):
if words[i] not in d:
d.update({words[i]: 1})
elif words[i] in d:
d[words[i]] += 1
# creating new same_letter dict, as the operations performed on same_letter & diff_letter dicts are different
for k, v in d.items():
if k[0] == k[1]:
dict_2.update({k: v})
# deleting same_letter dict from main dict.
for key in dict_2.keys():
del d[key]
# if same_letter dict has more than one key->value pairs than,
# we will check for the no of keys with odd values.
# if only 1 key has odd value and other keys have even value then we add twice as all the values
# if more than 1 keys have odd values than we add twice as all the even values and max_odd value from all the odds.
if len(dict_2) > 1:
odd_counter = 0
for k, v in dict_2.items():
if dict_2[k] % 2 != 0:
odd_counter += 1
if odd_counter > 1:
max_odd_val = 0
for k, v in dict_2.items():
if dict_2[k] % 2 == 0:
count += 2 * dict_2[k]
else:
if max_odd_val < dict_2[k]:
max_odd_val = dict_2[k]
pass_count = 0
for k, v in dict_2.items():
if dict_2[k] == max_odd_val and pass_count == 0:
count += 2 * max_odd_val
pass_count += 1
elif dict_2[k] % 2 != 0 or (
dict_2[k] == max_odd_val and pass_count != 0
):
count += 2 * (dict_2[k]) - 2
elif odd_counter == 1:
for k, v in dict_2.items():
count += 2 * dict_2[k]
elif odd_counter == 0:
for k, v in dict_2.items():
count += 2 * dict_2[k]
else:
for k, v in dict_2.items():
count += 2 * dict_2[k]
# here, we have diff_letter dict,
# we will double nest loop for checking the reverse keys pairs ex-> 'ab':3 and 'ba':5
# if we find them, we will decrease value till one of thier values becomes 0, for above it will be -> 'ab':0 and 'ba':2
for k1, v1 in d.items():
for k2, v2 in d.items():
if k1[0] == k2[1] and k1[1] == k2[0]:
while d[k1] > 0 and d[k2] > 0:
d[k1] -= 1
d[k2] -= 1
count += 4
return count | longest-palindrome-by-concatenating-two-letter-words | ✅ Simple Descriptive ||🐍 Python solution 🐍|| For New coders | 1905761 | 0 | 4 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,522 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2773155/Easy-to-understand-or-Python-or-dictionary | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
dict_word=defaultdict(int)
for i,word in enumerate(words):
dict_word[word]+=1
ans=0
visited=set()
odd_val=False
for word in dict_word.keys():
if word not in visited:
if word[0]!=word[1]:
visited.add(word)
if word[::-1] in dict_word:
ans+=4*min(dict_word[word],dict_word[word[::-1]])
visited.add(word[::-1])
elif word[0]==word[1] and dict_word[word]%2==0:
#if even number of times, then all considered
ans+=2*dict_word[word]
elif word[0]==word[1] and dict_word[word]%2!=0:
#if odd times present, we need to remeber that #time-1 will always be present for all odd letters and set odd_val as True.
odd_val=True
ans+=2*(dict_word[word]-1)
if odd_val:
#as there is occurence of odd count, we will add 1 word with same leeters, which occurs idd #times
ans+=2
return ans | longest-palindrome-by-concatenating-two-letter-words | Easy to understand | Python | dictionary | ankush_A2U8C | 0 | 7 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,523 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2773057/Python-O(n)-solution-Accepted | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
hash_map = collections.Counter(words)
ans = 0
central = 0
for word, cnt in hash_map.items():
if word[0] == word[1]:
ans += cnt if cnt % 2 == 0 else cnt - 1
central |= cnt % 2 != 0
elif word[::-1] in hash_map:
ans += min(cnt, hash_map[word[::-1]])
return (ans + central) * 2 | longest-palindrome-by-concatenating-two-letter-words | Python O(n) solution [Accepted] | lllchak | 0 | 5 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,524 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2773036/Python3-Counting-the-reversed-word-%3A%3A-1-%3A-) | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
mpp = defaultdict(lambda : 0)
cnt = 0
for word in words:
mpp[word]+=1
for word in words:
if word in mpp and word[::-1] in mpp and mpp[word] != 0 and mpp[word[::-1]] != 0:
if word[0] == word[1]:
if mpp[word] > 1:
cnt += 4
mpp[word] -= 2
else:
cnt += 4
mpp[word] -= 1
mpp[word[::-1]] -= 1
for key in mpp:
if mpp[key] >= 1:
if key[0] == key[1]:
cnt += 2
break
return cnt | longest-palindrome-by-concatenating-two-letter-words | Python3 Counting the reversed word [::-1] :-) | DigantaC | 0 | 6 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,525 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2773015/oror-Python-3-oror-hashing-oror-Easy-to-understand | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
word_dict = {}
ans = 0
center = False
for item in words:
word_dict[item] = word_dict.get(item, 0) + 1
for item in word_dict:
reverse = item[::-1]
if item[0] == item[1]:
if word_dict[item] % 2 == 0:
ans += word_dict[item]
else:
ans += (word_dict[item] - 1)
center = True
elif reverse in word_dict:
reverse_count = word_dict[reverse]
item_count = word_dict[item]
ans += min(reverse_count, item_count)
if center:
ans += 1
return ans * 2 | longest-palindrome-by-concatenating-two-letter-words | || Python 3 || hashing || Easy to understand | parth_panchal_10 | 0 | 9 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,526 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2772961/Python-or-Greedy-count-solution | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
s = defaultdict(int)
for w in words:
s[w] += 1
used = set()
ans = 0
for word in s:
if word in used:
continue
if word[0] != word[1]:
if word[::-1] in s:
ans += min(s[word]*2, s[word[::-1]]*2)*2
used.add(word)
used.add(word[::-1])
else:
carry = s[word] - 1 if s[word] % 2 else s[word]
ans += carry*2
for word, val in s.items():
if word[0] == word[1] and val % 2:
ans += 2
break
return ans | longest-palindrome-by-concatenating-two-letter-words | Python | Greedy count solution | LordVader1 | 0 | 12 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,527 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2772931/Space-optimized-2-Hashmap-based-solution-in-Python | class Solution:
# Intuitive 2-Hashmap based solution
def longestPalindrome(self, words: List[str]) -> int:
mapper = defaultdict(int)
seen = defaultdict(int)
# Check for eligible words that can make a palindrome
for word in words:
if word[::-1] in seen and seen[word[::-1]] > 0:
mapper[word] += 1
seen[word[::-1]] -= 1
else:
seen[word] += 1
# Each word in mapper will give the res a 4 length palindrome adding palindromes in the right way
# gives another palindrome of double length
# Hence adding the length * 4 to res
res = 0
for _, cnt in mapper.items():
res += cnt * 4
# Now seen has words which were in the words list and if we have some leftover
# which is a palindrome in itself we can place it in the middle to increase the overall length by 2
# This can only be done once and hence i have exited the loop once i achieve this
for word in seen:
if seen[word] > 0 and word == word[::-1]: res += 2;break
return res | longest-palindrome-by-concatenating-two-letter-words | Space optimized 2 Hashmap based solution in Python | shiv-codes | 0 | 6 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,528 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2772929/Hashmap-Fast-and-Easy-Solution | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
c = Counter(words)
found = 0
temp = 0
for word in c.keys():
if word == word[::-1]:
if c[word] % 2 == 1:
found = 2
temp += (c[word] // 2 * 4)
else:
temp += min(c[word], c[word[::-1]]) * 2
return temp + found | longest-palindrome-by-concatenating-two-letter-words | Hashmap - Fast and Easy Solution | user6770yv | 0 | 9 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,529 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2772926/Easy-to-follow-python-3-Counter-Greedy-Solution | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
wordsCounter = collections.Counter(words)
longestSameChar = 0
longestNonSameChar = 0
for word in wordsCounter:
if word[0] == word[1]:
if wordsCounter[word] == 1:
if longestSameChar < 4:
longestSameChar = 2
elif (longestSameChar//2) % 2 == 0:
longestSameChar += 2
else:
if (longestSameChar//2) % 2 == 1:
longestSameChar += 2 * (wordsCounter[word] - wordsCounter[word] % 2)
else:
longestSameChar += 2 * wordsCounter[word]
else:
if word[::-1] in wordsCounter and wordsCounter[word[::-1]] != 0:
minCounter = min(wordsCounter[word[::-1]], wordsCounter[word])
longestNonSameChar += 4 * minCounter
wordsCounter[word[::-1]] -= minCounter
wordsCounter[word] -= minCounter
return longestSameChar + longestNonSameChar | longest-palindrome-by-concatenating-two-letter-words | Easy to follow python 3 - Counter, Greedy Solution | zxia545 | 0 | 4 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,530 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2772722/python3-Solution | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
freq = Counter(words) # obtain frequencies
pp, p = 0, 0
for w, f in freq.items():
if w[0] == w[1]:
p = max(p, f % 2) # odd-count symmetric word detector
pp += f//2 * 2 # count paired symmetric words
else:
pp += min(f, freq[w[::-1]]) # count paired asymmetric words
return (pp + p) * 2 | longest-palindrome-by-concatenating-two-letter-words | python3 Solution | rupamkarmakarcr7 | 0 | 12 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,531 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2772696/python-solution-or-counter | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
res = 0
mid = 0
counter = Counter(words)
for key in counter.keys():
reverse = key[::-1]
if reverse in counter:
if key != reverse:
res += 2 * min(counter[key], counter[reverse])
else:
if counter[key] > 1:
res += 4 * (counter[key]//2)
if counter[key] % 2 == 1:
mid = 2
return mid + res | longest-palindrome-by-concatenating-two-letter-words | python solution | counter | maomao1010 | 0 | 8 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,532 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2772617/Easy-Python-or-Faster-or-Dictionary-%2B-Counter-or-O(n)-Time-or-O(n)-Space | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
Map = Counter(words)
ans = 0
center = False
for word, count in Map.items():
if word[0]==word[1]:
if count%2==0:
ans += count
else:
ans += count-1
center = True
elif word[0]<word[1]:
ans += 2*min(count, Map[word[1]+word[0]])
if center:
ans+=1
return 2*ans | longest-palindrome-by-concatenating-two-letter-words | Easy Python | Faster | Dictionary + Counter | O(n) Time | O(n) Space | coolakash10 | 0 | 9 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,533 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2772545/Python3-Look-for-mirrored-entries | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
single_found = False
c = Counter(words)
pairs = 0
for k in list(c.keys()):
if c[k]<1:
continue
a, b = k[0], k[1]
if a==b:
if c[k]%2==1:
single_found = True
pairs+=c[k]//2
else:
ns = (b+a)
pairs += min(c[ns], c[k])
c[ns]=0
pairs *= 4
if single_found:
pairs += 2
return pairs | longest-palindrome-by-concatenating-two-letter-words | Python3 Look for mirrored entries | godshiva | 0 | 5 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,534 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2772478/Python-Solution-With-Dictionary | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
d = Counter(words)
di = {}
s = set()
ans = 0
c = 0
for k,v in d.items():
# If any word is pallindrom store it in a different dictionary
if k == k[::-1]:
di[k] = v
elif k[::-1] in d and k[::-1] not in s:
ans += min(v,d[k[::-1]]) * 2
s.add(k[::-1])
# Sort the second dictionay according to frquency of words.
# The first word has always maximum frequency.
di = dict(sorted(di.items(),key = lambda x:x[1])[::-1])
od = 0
for k,v in di.items():
if c == 0:
if v % 2 == 1:
od += 1
ans += v * 2
c += 1
else:
if v % 2 == 1 and od == 0:
ans += v * 2
od += 1
elif v % 2 == 1 and od == 1:
ans += (v - 1) * 2
else:
ans += v * 2
return ans | longest-palindrome-by-concatenating-two-letter-words | Python Solution With Dictionary | a_dityamishra | 0 | 9 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,535 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2772448/Python-Counter-Aprroach-using-Set | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
word_map = collections.Counter(words)
odd_dbl_in_words, count = 0, 0
for word in set(words):
if word[0] == word[1]:
if word_map[word] % 2 == 0:
count += 2 * word_map[word]
else:
odd_dbl_in_words = 1
count += 2 * (word_map[word] - 1)
else:
count += 2 * min(word_map[word], word_map[word[::-1]])
return count + odd_dbl_in_words * 2 | longest-palindrome-by-concatenating-two-letter-words | Python Counter Aprroach using Set | gkpani97 | 0 | 18 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,536 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2772442/Python-easy-to-read-and-understand-or-hashmap | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
m = collections.defaultdict(int)
res = 0
for word in words:
if word[::-1] in m and m[word[::-1]] > 0:
res += 4
m[word[::-1]] -= 1
else:
m[word] += 1
for word in words:
if word[0] == word[1] and m[word] == 1:
res += 2
break
return res | longest-palindrome-by-concatenating-two-letter-words | Python easy to read and understand | hashmap | sanial2001 | 0 | 8 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,537 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2772425/WEEB-EXPLAINS-PYTHONC%2B%2B | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
memo = Counter(words)
visited = set()
result = 0
flag = False
for word, count in memo.items():
if word in visited: continue
reverse = word[::-1]
if reverse in memo:
if reverse == word:
if memo[word] % 2 == 1 and not flag:
result += 2 * memo[word]
flag = True
elif memo[word] % 2 == 1 and flag:
result += 2 * (memo[word] - 1)
else:
result += 2 * memo[word]
else:
result += 4 * min(memo[word], memo[reverse])
visited.add(reverse)
return result | longest-palindrome-by-concatenating-two-letter-words | WEEB EXPLAINS PYTHON/C++ | Skywalker5423 | 0 | 6 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,538 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2772380/Simple-Python-Solution-Hashmaps | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
hm=collections.defaultdict(lambda:0)
res=0
for i in words:
tmp=i[::-1]
if hm[tmp]>=1:
hm[tmp]-=1
res+=4
else:
hm[i]+=1
for i in hm:
if hm[i]>=1:
if i[0]==i[1]:
res+=2
break
print(hm,res)
return res | longest-palindrome-by-concatenating-two-letter-words | Simple Python Solution - Hashmaps | umarfarooqngm | 0 | 6 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,539 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2772277/Python3-or-intuitive-approach-or-hashmap | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
hashmap = {}
result = 0
picked = False
for i in range(len(words)):
hashmap[words[i]] = hashmap.get(words[i],0)+1
for word in words:
revword = word[::-1]
if word == revword and word in hashmap and hashmap[word] == 1:
picked = True #Can be picked and added in the center'
if word == revword and word in hashmap and hashmap[word] >= 2 :
picked = False
result += 4 #adding both revword and word count
hashmap[word] -= 2
if hashmap[word] == 0:
del hashmap[word]
if word in hashmap and revword in hashmap and word != revword:
result += 4
hashmap[word] -= 1
hashmap[revword] -= 1
if hashmap[word] == 0:
del hashmap[word]
if hashmap[revword] == 0:
del hashmap[revword]
if not result and not picked:
return 0
if result and picked:
return (result + 2)
if result and not picked:
return result
if not result and picked:
return 2 | longest-palindrome-by-concatenating-two-letter-words | Python3 | intuitive approach | hashmap | Brutal7skull | 0 | 13 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,540 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2772227/Python-Intuitive-and-Easy-solution | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
res = 0
oddFlag = False
freq = {}
for word in words:
freq[word] = freq.get(word, 0) + 1
for word, frequency in freq.items():
if word[0] == word[1]:
if frequency % 2 == 0:
res += frequency
else:
oddFlag = True
res += frequency - 1
elif word[0] < word[1]:
res += 2 * min(frequency, freq.get(word[1] + word[0], 0))
if oddFlag:
res += 1
return 2 * res | longest-palindrome-by-concatenating-two-letter-words | Python Intuitive and Easy solution | MaverickEyedea | 0 | 10 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,541 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2772211/Python-O(n) | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
memo = defaultdict(int)
for w in words:
memo[w] += 1
added = 1
res = 0
for w in words:
if memo[w] > 0:
w_needed = w[1] + w[0]
memo[w] -= 1
if memo[w_needed] > 0:
res += 4
memo[w_needed] -= 1
elif w == w_needed and added == 1:
added = 0
res += 2
return res | longest-palindrome-by-concatenating-two-letter-words | Python O(n) | chingisoinar | 0 | 9 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,542 |
https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/discuss/2772154/Python3-or-Greedy-%2B-Counter-(hashmap) | class Solution:
def longestPalindrome(self, words: List[str]) -> int:
palindromicPairsFinder = collections.Counter(); count = 0
for word in words:
reversedWord = word[::-1]
if palindromicPairsFinder[reversedWord] > 0:
count += 1
palindromicPairsFinder[reversedWord] -= 1
else:
palindromicPairsFinder[word] += 1
return 2 * (2 * count + any(word[0] == word[1] for word in palindromicPairsFinder if palindromicPairsFinder[word] > 0)) | longest-palindrome-by-concatenating-two-letter-words | Python3 | Greedy + Counter (hashmap) | sr_vrd | 0 | 9 | longest palindrome by concatenating two letter words | 2,131 | 0.491 | Medium | 29,543 |
https://leetcode.com/problems/stamping-the-grid/discuss/2489712/Python3-solution%3A-faster-than-most-submissions-oror-Very-simple | class Solution:
def prefix_sum(self, grid: List[List[int]]) -> List[List[int]]:
ps = [[grid[row][col] for col in range(len(grid[0]))]for row in range(len(grid))]
for row in range(len(grid)):
for col in range(1, len(grid[0])):
ps[row][col] = ps[row][col-1] + grid[row][col]
for row in range(1, len(grid)):
for col in range(len(grid[0])):
ps[row][col] = ps[row-1][col] + ps[row][col]
return ps
def sumRegion(self, ps, row1: int, col1: int, row2: int, col2: int) -> int:
ans = 0
if row1 == 0 and col1 == 0:
ans = ps[row2][col2]
elif row1 == 0:
ans = ps[row2][col2] - ps[row2][col1-1]
elif col1 == 0:
ans = ps[row2][col2] - ps[row1-1][col2]
else:
ans = ps[row2][col2] - ps[row1-1][col2] - ps[row2][col1-1] + ps[row1-1][col1-1]
return ans
def possibleToStamp(self, grid: List[List[int]], stampHeight: int, stampWidth: int) -> bool:
diff = [[0 for col in range(len(grid[0])+1)]for row in range(len(grid)+1)]
ps = self.prefix_sum(grid)
cover = 0
for row in range(len(grid)-(stampHeight-1)):
for col in range(len(grid[0])-(stampWidth-1)):
sub_sum = self.sumRegion(ps, row, col, row+stampHeight-1, col+stampWidth-1)
if sub_sum == 0:
diff[row][col] += 1
diff[row][col+stampWidth] -= 1
diff[row+stampHeight][col] -= 1
diff[row+stampHeight][col+stampWidth] = 1
pref_diff = self.prefix_sum(diff)
m, n = len(grid), len(grid[0])
for row in range(len(grid)):
for col in range(len(grid[0])):
if grid[row][col] == 0 and pref_diff[row][col] == 0: return False
return True | stamping-the-grid | ✔️ Python3 solution: faster than most submissions || Very simple | Omegang | 0 | 40 | stamping the grid | 2,132 | 0.309 | Hard | 29,544 |
https://leetcode.com/problems/stamping-the-grid/discuss/1684292/Python3-prefix-sum | class Solution:
def possibleToStamp(self, grid: List[List[int]], stampHeight: int, stampWidth: int) -> bool:
m, n = len(grid), len(grid[0])
prefix = [[0]*(n+1) for _ in range(m+1)]
for i in range(m):
for j in range(n):
prefix[i+1][j+1] = grid[i][j] + prefix[i+1][j] + prefix[i][j+1] - prefix[i][j]
seen = [[0]*n for _ in range(m)]
for i in range(m-stampHeight+1):
for j in range(n-stampWidth+1):
diff = prefix[i+stampHeight][j+stampWidth] - prefix[i+stampHeight][j] - prefix[i][j+stampWidth] + prefix[i][j]
if diff == 0: seen[i][j] = 1
prefix = [[0]*(n+1) for _ in range(m+1)]
for i in range(m):
for j in range(n):
prefix[i+1][j+1] = seen[i][j] + prefix[i+1][j] + prefix[i][j+1] - prefix[i][j]
for i in range(m):
ii = max(0, i-stampHeight+1)
for j in range(n):
jj = max(0, j-stampWidth+1)
if grid[i][j] == 0 and prefix[i+1][j+1] - prefix[i+1][jj] - prefix[ii][j+1] + prefix[ii][jj] == 0: return False
return True | stamping-the-grid | [Python3] prefix sum | ye15 | 0 | 82 | stamping the grid | 2,132 | 0.309 | Hard | 29,545 |
https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/discuss/1775747/Python-3-or-7-Line-solution-or-87-Faster-runtime-or-92.99-lesser-memory | class Solution:
def checkValid(self, matrix: List[List[int]]) -> bool:
lst = [0]*len(matrix)
for i in matrix:
if len(set(i)) != len(matrix):
return False
for j in range(len(i)):
lst[j] += i[j]
return len(set(lst)) == 1 | check-if-every-row-and-column-contains-all-numbers | ✔Python 3 | 7 Line solution | 87% Faster runtime | 92.99% lesser memory | Coding_Tan3 | 6 | 855 | check if every row and column contains all numbers | 2,133 | 0.53 | Easy | 29,546 |
https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/discuss/1684643/A-simple-and-CORRECT-XOR-method | class Solution:
def checkValid(self, matrix: List[List[int]]) -> bool:
# bitmask
n = len(matrix)
for i in range(n):
row_bit, col_bit, bitmask = 1, 1, 1
for j in range(n):
row_bit ^= 1 << matrix[i][j]
col_bit ^= 1 << matrix[j][i]
bitmask |= 1 << j + 1
if row_bit ^ bitmask or col_bit ^ bitmask:
return False
return True | check-if-every-row-and-column-contains-all-numbers | A simple and CORRECT XOR method | pwang72 | 5 | 415 | check if every row and column contains all numbers | 2,133 | 0.53 | Easy | 29,547 |
https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/discuss/1684643/A-simple-and-CORRECT-XOR-method | class Solution:
def checkValid(self, matrix: List[List[int]]) -> bool:
# bitmask
n = len(matrix)
for i in range(n):
row_bit, col_bit, bitmask = 1, 1, 1
for j in range(n):
row_bit ^= 1 << matrix[i][j]
col_bit ^= 1 << matrix[j][i]
bitmask |= 1 << j + 1
if row_bit ^ bitmask or col_bit ^ bitmask:
return False
return True | check-if-every-row-and-column-contains-all-numbers | A simple and CORRECT XOR method | pwang72 | 5 | 415 | check if every row and column contains all numbers | 2,133 | 0.53 | Easy | 29,548 |
https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/discuss/1676835/Python3-1-line | class Solution:
def checkValid(self, matrix: List[List[int]]) -> bool:
return all(len(set(row)) == len(matrix) for row in matrix) and all(len(set(col)) == len(matrix) for col in zip(*matrix)) | check-if-every-row-and-column-contains-all-numbers | [Python3] 1-line | ye15 | 4 | 838 | check if every row and column contains all numbers | 2,133 | 0.53 | Easy | 29,549 |
https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/discuss/1975051/Python-easy-or-Set-or-98-faster-and-memory-efficient | class Solution:
def checkValid(self, matrix: List[List[int]]) -> bool:
for r in range(len(matrix)):
colSet = set()
rowSet = set()
for c in range(len(matrix)):
if matrix[r][c] in colSet or matrix[c][r] in rowSet:
return False
colSet.add(matrix[r][c])
rowSet.add(matrix[c][r])
return True | check-if-every-row-and-column-contains-all-numbers | Python easy | Set | 98% faster and memory efficient | CSociety | 3 | 233 | check if every row and column contains all numbers | 2,133 | 0.53 | Easy | 29,550 |
https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/discuss/2777852/use-DP-tabulation | class Solution:
def checkValid(self, matrix: List[List[int]]) -> bool:
dp_col = [[False for _ in range(len(matrix[0]))] for _ in range(len(matrix))]
dp_row = [[False for _ in range(len(matrix[0]))] for _ in range(len(matrix))]
for i in range(len(matrix)):
for j in range(len(matrix[0])):
if dp_row[i][matrix[i][j]-1] or dp_col[j][matrix[i][j]-1]:
return False
dp_row[i][matrix[i][j]-1] = True
dp_col[j][matrix[i][j]-1] = True
return True | check-if-every-row-and-column-contains-all-numbers | use DP tabulation | harrychen1995 | 1 | 5 | check if every row and column contains all numbers | 2,133 | 0.53 | Easy | 29,551 |
https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/discuss/2077833/Python-Solution | class Solution:
def checkValid(self, matrix: List[List[int]]) -> bool:
n = len(matrix)
vaild = set(range(1, n + 1))
for i in range(n):
set1, set2 = set(), set()
for j in range(n):
set1.add(matrix[i][j])
set2.add(matrix[j][i])
if set1 != vaild or set2 != vaild:
return False
return True | check-if-every-row-and-column-contains-all-numbers | Python Solution | hgalytoby | 1 | 151 | check if every row and column contains all numbers | 2,133 | 0.53 | Easy | 29,552 |
https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/discuss/2077833/Python-Solution | class Solution:
def checkValid(self, matrix: List[List[int]]) -> bool:
n = len(matrix)
valid = set(range(1, n + 1))
return all(set(m) == valid for m in matrix + list(zip(*matrix))) | check-if-every-row-and-column-contains-all-numbers | Python Solution | hgalytoby | 1 | 151 | check if every row and column contains all numbers | 2,133 | 0.53 | Easy | 29,553 |
https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/discuss/2848414/Easy-and-understandable-solution-beats-99.2 | class Solution:
def checkValid(self, matrix: List[List[int]]) -> bool:
N = len(matrix)
for row in matrix:
if len(set(row)) != N:
return False
for i in range(N):
for j in range(N):
if i < j:
matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]
for row in matrix:
if len(set(row)) != N:
return False
return True | check-if-every-row-and-column-contains-all-numbers | Easy and understandable solution beats 99.2% | MaxYazev | 0 | 2 | check if every row and column contains all numbers | 2,133 | 0.53 | Easy | 29,554 |
https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/discuss/2842805/Set-or-Python3 | class Solution:
def checkValid(self, matrix: List[List[int]]) -> bool:
tran_matrix = list(zip(*matrix))
n = len(matrix)
mat_sum = 0.5 * n * (n + 1)
for i in range(n):
s_1 = set(matrix[i])
s_2 = set(tran_matrix[i])
if len(s_1) != n or len(s_2) != n or sum(s_1) != mat_sum or sum(s_2) != mat_sum :
return False
return True | check-if-every-row-and-column-contains-all-numbers | Set | Python3 | user8403D | 0 | 3 | check if every row and column contains all numbers | 2,133 | 0.53 | Easy | 29,555 |
https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/discuss/2841145/python-code | class Solution:
def checkValid(self, matrix: List[List[int]]) -> bool:
for row in matrix:
if set(row)!=set(range(1,len(matrix)+1)):
return False
for col in zip(*matrix):
if set(col)!=set(range(1,len(matrix)+1)):
return False
return True | check-if-every-row-and-column-contains-all-numbers | python code | ayushigupta2409 | 0 | 5 | check if every row and column contains all numbers | 2,133 | 0.53 | Easy | 29,556 |
https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/discuss/2841115/Simple-solution-by-using-hashmap | class Solution:
def checkValid(self, matrix: List[List[int]]) -> bool:
n = len(matrix)
for i in range(n):
dic1 = {}
dic2 = {}
for j in range(n):
if matrix[i][j] not in dic1:
dic1[matrix[i][j]] = 1
else:
return False
if matrix[j][i] not in dic2:
dic2[matrix[j][i]] = 1
else:
return False
return True | check-if-every-row-and-column-contains-all-numbers | Simple solution by using hashmap | Tonmoy-saha18 | 0 | 3 | check if every row and column contains all numbers | 2,133 | 0.53 | Easy | 29,557 |
https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/discuss/2840827/PythonTypescriptJavascript-Simple-intuitive-easy-to-understand-approach-(100-faster) | class Solution:
def checkValid(self, matrix: List[List[int]]) -> bool:
n = len(matrix)
for i in range(0,n):
arr = [False] * (n+1)
arr[0] = None
for j in range(0,n):
num = matrix[i][j]
if num >= 1 and num <= n:
arr[num] = True
for k in arr:
if k == False:
return False
for i in range(0,n):
arr = [False] * (n+1)
arr[0] = None
for j in range(0,n):
num = matrix[j][i]
if num >= 1 and num <= n:
arr[num] = True
for k in arr:
if k == False:
return False
return True | check-if-every-row-and-column-contains-all-numbers | [Python/Typescript/Javascript] Simple, intuitive, easy-to-understand approach (100% faster) | KarmaRekts | 0 | 2 | check if every row and column contains all numbers | 2,133 | 0.53 | Easy | 29,558 |
https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/discuss/2840469/Beats-90-Python3-Easy-to-understand-with-comments! | class Solution:
def checkValid(self, matrix: List[List[int]]) -> bool:
# We need to check each row and column, and keep track that each number from 1-n is included in each.
n = len(matrix)
valid_set = set()
# Add valid numbers from 1 to n
for i in range(1, n + 1):
valid_set.add(i)
# Check each row
for i in range(0, n):
curr_row_seen = set()
for j in range(0, n):
curr = matrix[i][j]
if curr not in valid_set or curr in curr_row_seen:
return False
curr_row_seen.add(curr)
for i in range(0, n):
curr_column_seen = set()
for j in range(0, n):
curr = matrix[j][i]
if curr not in valid_set or curr in curr_column_seen:
return False
curr_column_seen.add(curr)
return True | check-if-every-row-and-column-contains-all-numbers | Beats 90% Python3 Easy to understand with comments! | BlueBoi904 | 0 | 1 | check if every row and column contains all numbers | 2,133 | 0.53 | Easy | 29,559 |
https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/discuss/2746168/Check-every-rows-and-colums. | class Solution:
def checkValid(self, matrix: List[List[int]]) -> bool:
"""Constraint of n is small, so BF is ok. TC is O(n^2), SC is O(n^2)"""
n = len(matrix)
for row in matrix:
if len(set(row)) != n:
return False
for col_idx in range(n):
column = [row[col_idx] for row in matrix]
if len(set(column)) != n:
return False
return True | check-if-every-row-and-column-contains-all-numbers | Check every rows and colums. | woora3 | 0 | 3 | check if every row and column contains all numbers | 2,133 | 0.53 | Easy | 29,560 |
https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/discuss/2691004/Python-easy-updated-solution-using-Zip | class Solution:
def checkValid(self, matrix: List[List[int]]) -> bool:
n = len(matrix)
for item in matrix:
if(n != len(set(item))):
return False
for i in zip(*matrix):
if(n != len(set(i))):
return False
return True | check-if-every-row-and-column-contains-all-numbers | Python easy updated solution using Zip | user2800NJ | 0 | 13 | check if every row and column contains all numbers | 2,133 | 0.53 | Easy | 29,561 |
https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/discuss/2492289/Python-simple-solution-using-a-hashset | class Solution:
def checkValid(self, matrix: list[list[int]]) -> bool:
n = len(matrix)
matrix_cols = [[matrix[i][j] for i in range(len(matrix))] for j in range(len(matrix[0]))]
def has_all_nums(nums: list[int]) -> bool:
nums_needed = set(range(1,n+1))
for num in nums:
nums_needed.discard(num)
return len(nums_needed) == 0
for row, col in zip(matrix, matrix_cols):
if not has_all_nums(row) or not has_all_nums(col):
return False
return True | check-if-every-row-and-column-contains-all-numbers | Python simple solution using a hashset | xgmichael | 0 | 55 | check if every row and column contains all numbers | 2,133 | 0.53 | Easy | 29,562 |
https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/discuss/2492289/Python-simple-solution-using-a-hashset | class Solution:
def checkValid(self, matrix: list[list[int]]) -> bool:
n = len(matrix)
row_nums: set[int] = set()
col_nums: set[int] = set()
for i in range(len(matrix)):
row_nums.clear()
col_nums.clear()
for j in range(len(matrix[0])):
row_nums.add(matrix[j][i])
col_nums.add(matrix[i][j])
if len(row_nums) != n or len(col_nums) != n:
return False
return True | check-if-every-row-and-column-contains-all-numbers | Python simple solution using a hashset | xgmichael | 0 | 55 | check if every row and column contains all numbers | 2,133 | 0.53 | Easy | 29,563 |
https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/discuss/2467929/Python-Solution-or-Easy-and-Straightforward-Logic-or-Store-and-Check-or-Clean-Code | class Solution:
def checkValid(self, matrix: List[List[int]]) -> bool:
# define N
n = len(matrix)
# generate set of [1,N]
store = set([i for i in range(1,n+1)])
# check in row
for row in matrix:
if set(row) != store:
return False
# check in column
for col in zip(*matrix):
if set(col) != store:
return False
# all good
return True | check-if-every-row-and-column-contains-all-numbers | Python Solution | Easy and Straightforward Logic | Store and Check | Clean Code | Gautam_ProMax | 0 | 71 | check if every row and column contains all numbers | 2,133 | 0.53 | Easy | 29,564 |
https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/discuss/2068671/Python-Easy-Understanding-or-Using-Set | class Solution:
def checkValid(self, matrix: List[List[int]]) -> bool:
# check in the row
for i in range(len(matrix)):
if len(matrix[i]) != len(set(matrix[i])):
return False
#chaeck in the column
for i in range(len(matrix)):
st=set()
lt=[]
for j in range(len(matrix)):
st.add(matrix[j][i])
lt.append(matrix[j][i])
if len(st) != len(lt):
return False
return True | check-if-every-row-and-column-contains-all-numbers | [Python] Easy Understanding | Using Set 💥 | imjenit | 0 | 121 | check if every row and column contains all numbers | 2,133 | 0.53 | Easy | 29,565 |
https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/discuss/2011111/Python-O(1)-space-single-pass-no-sorting-needed | class Solution:
def checkValid(self, matrix: List[List[int]]) -> bool:
n = len(matrix)
for i in range(n):
for j in range(n):
# take absolute value since mod of a positive number is different from mod of its negative counterpart
val = abs(matrix[i][j])%n
# We'll mark the val-th element as negative once some "val" appears in a row i
if matrix[i][val] < 0:
return False
# Make element negative to save the occurance of "val" in row i
matrix[i][val] *= -1
# We'll make the absolute value of j-th element for row "val" greater than n to mark that "val" appeared in the column
if abs(matrix[val][j]) > n:
return False
# Change the absolute value to mark the occurance of "val" in column j
# Reduce n if negative, add n if positive. Don't add a negative and positive, since the absolute value will change
if matrix[val][j] < 0:
matrix[val][j] -= n
else:
matrix[val][j] += n
return True | check-if-every-row-and-column-contains-all-numbers | Python O(1) space, single pass, no sorting needed | code_rookie | 0 | 92 | check if every row and column contains all numbers | 2,133 | 0.53 | Easy | 29,566 |
https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/discuss/1992162/Python3-99-Faster-oror-100-Memory-efficient | class Solution:
def checkValid(self, matrix: List[List[int]]) -> bool:
N = len(matrix)
arr = [i+1 for i in range(N)]
#print(arr)
for i in range(N):
if sorted(matrix[i]) != arr:
return False
for i in range(N):
temp = []
for j in range(N):
temp.append(matrix[j][i])
if sorted(temp) != arr:
return False
return True | check-if-every-row-and-column-contains-all-numbers | Python3 - 99% Faster || 100% Memory efficient | dayaniravi123 | 0 | 78 | check if every row and column contains all numbers | 2,133 | 0.53 | Easy | 29,567 |
https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/discuss/1982596/Python3-one-line-faster-than-96.94-(757ms) | class Solution:
def checkValid(self, matrix: list[list[int]]) -> bool:
n = len(matrix)
return all(set(matrix[i]) == set(range(1, n+1)) for i in range(n)) and all(set(matrix[i][j] for i in range(n)) == set(range(1,n+1)) for j in range(n)) | check-if-every-row-and-column-contains-all-numbers | Python3 one-line faster than 96.94% (757ms) | Minh4893IT | 0 | 105 | check if every row and column contains all numbers | 2,133 | 0.53 | Easy | 29,568 |
https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/discuss/1957724/Python3-or-Simple-or-93-Faster-runtime-or-O(1)-Space | class Solution:
def checkValid(self, matrix: List[List[int]]) -> bool:
n = len(matrix)
def not_valid(block):
return len(set(block)) != len(block)
if any(
not_valid([matrix[i][j] for j in range(n)]) or
not_valid([matrix[j][i] for j in range(n)])
for i in range(n)):
return False
return True | check-if-every-row-and-column-contains-all-numbers | ✅Python3 | Simple | 93% Faster runtime | O(1) Space | PaulOkewunmi | 0 | 53 | check if every row and column contains all numbers | 2,133 | 0.53 | Easy | 29,569 |
https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/discuss/1940883/Python-dollarolution-(97-Faster) | class Solution:
def checkValid(self, matrix: List[List[int]]) -> bool:
m = list(zip(*matrix))
k = len(matrix)
for i in range(k):
if len(set(matrix[i])) != k or len(set(m[i])) != k:
return False
return True | check-if-every-row-and-column-contains-all-numbers | Python $olution (97% Faster) | AakRay | 0 | 76 | check if every row and column contains all numbers | 2,133 | 0.53 | Easy | 29,570 |
https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/discuss/1938779/Python-Simple-and-Clean!-One-Liner-%2B-Bonus%3A-Space-Efficient-Version | class Solution:
def checkValid(self, matrix):
expected = set(range(1,len(matrix[0])+1))
for row in matrix:
if set(row) != expected: return False
for col in zip(*matrix):
if set(col) != expected: return False
return True | check-if-every-row-and-column-contains-all-numbers | Python - Simple and Clean! One Liner + Bonus: Space Efficient Version | domthedeveloper | 0 | 75 | check if every row and column contains all numbers | 2,133 | 0.53 | Easy | 29,571 |
https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/discuss/1938779/Python-Simple-and-Clean!-One-Liner-%2B-Bonus%3A-Space-Efficient-Version | class Solution:
def checkValid(self, matrix):
s = set(range(1,len(matrix[0])+1))
return all(set(x)==s for x in matrix+list(zip(*matrix))) | check-if-every-row-and-column-contains-all-numbers | Python - Simple and Clean! One Liner + Bonus: Space Efficient Version | domthedeveloper | 0 | 75 | check if every row and column contains all numbers | 2,133 | 0.53 | Easy | 29,572 |
https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/discuss/1938779/Python-Simple-and-Clean!-One-Liner-%2B-Bonus%3A-Space-Efficient-Version | class Solution:
def checkValid(self, matrix):
return all(set(x)==set(range(1,len(matrix[0])+1)) for x in matrix+list(zip(*matrix))) | check-if-every-row-and-column-contains-all-numbers | Python - Simple and Clean! One Liner + Bonus: Space Efficient Version | domthedeveloper | 0 | 75 | check if every row and column contains all numbers | 2,133 | 0.53 | Easy | 29,573 |
https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/discuss/1938779/Python-Simple-and-Clean!-One-Liner-%2B-Bonus%3A-Space-Efficient-Version | class Solution:
def checkValid(self, matrix: List[List[int]]) -> bool:
m,n = len(matrix), len(matrix[0])
# mark rows
for i in range(m):
for j in range(n):
v = abs(matrix[i][j])-1
matrix[i][v] *= -1
# check rows
for i in range(m):
for j in range(n):
if matrix[i][j] > 0: return False
# mark cols
for j in range(n):
for i in range(m):
v = abs(matrix[i][j])-1
matrix[v][j] *= -1
# check cols
for j in range(n):
for i in range(m):
if matrix[i][j] < 0: return False
return True | check-if-every-row-and-column-contains-all-numbers | Python - Simple and Clean! One Liner + Bonus: Space Efficient Version | domthedeveloper | 0 | 75 | check if every row and column contains all numbers | 2,133 | 0.53 | Easy | 29,574 |
https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/discuss/1932328/Python-(Simple-Approach-and-Beginner-Friendly) | class Solution:
def checkValid(self, matrix: List[List[int]]) -> bool:
a = []
for i in matrix:
if len(i) != len(set(i)):
return False
for j in range(0, len(matrix)):
for i in range(0, len(matrix)):
a.append(matrix[i][j])
if len(a) != len(set(a)):
return False
a = []
return True | check-if-every-row-and-column-contains-all-numbers | Python (Simple Approach and Beginner-Friendly) | vishvavariya | 0 | 63 | check if every row and column contains all numbers | 2,133 | 0.53 | Easy | 29,575 |
https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/discuss/1920539/Python-Solution-Using-Reference-Set-Comparison | class Solution:
def checkValid(self, matrix: List[List[int]]) -> bool:
cols, n = list(zip(*matrix)), len(matrix)
test = set([i for i in range(1, n + 1)])
for item1, item2 in zip(matrix, cols):
if set(item1) != test or set(item2) != test:
return False
return True | check-if-every-row-and-column-contains-all-numbers | Python Solution Using Reference Set Comparison | Hejita | 0 | 32 | check if every row and column contains all numbers | 2,133 | 0.53 | Easy | 29,576 |
https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/discuss/1831836/5-Lines-Python-Solution-oror-70-Faster-oror-Memory-less-than-82 | class Solution:
def checkValid(self, M: List[List[int]]) -> bool:
n=len(M) ; C=list(map(list, zip(*M))) ; REF=[i+1 for i in range(n)]
for i in range(n):
M[i].sort() ; C[i].sort()
if M[i]!=REF or C[i]!=REF: return False
return True | check-if-every-row-and-column-contains-all-numbers | 5-Lines Python Solution || 70% Faster || Memory less than 82% | Taha-C | 0 | 129 | check if every row and column contains all numbers | 2,133 | 0.53 | Easy | 29,577 |
https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/discuss/1793525/Python-easy-to-optimized-solution | class Solution:
def checkValid(self, arr: List[List[int]]) -> bool:
m, n = len(arr), len(arr[0])
row = defaultdict(set)
col = defaultdict(set)
for i in range(m):
for j in range(n):
if arr[i][j] in row[i]:
return False
else:
row[i].add(arr[i][j])
if arr[i][j] in col[j]:
return False
else:
col[j].add(arr[i][j])
return True | check-if-every-row-and-column-contains-all-numbers | Python easy to optimized solution | abkc1221 | 0 | 93 | check if every row and column contains all numbers | 2,133 | 0.53 | Easy | 29,578 |
https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/discuss/1793525/Python-easy-to-optimized-solution | class Solution:
def checkValid(self, arr: List[List[int]]) -> bool:
m, n = len(arr), len(arr[0])
# mark rows
for i in range(m):
for j in range(n):
pos = abs(arr[i][j]) - 1 # valid since arr[i][j] is in range[1, n]
if arr[i][pos] < 0: return False
arr[i][pos] *= -1 # marking for future use
# mark columns
for i in range(m):
for j in range(n):
pos = abs(arr[j][i]) - 1 # valid since arr[i][j] is in range[1, n]
if arr[pos][i] > 0: return False
arr[pos][i] = abs(arr[pos][i])
return True | check-if-every-row-and-column-contains-all-numbers | Python easy to optimized solution | abkc1221 | 0 | 93 | check if every row and column contains all numbers | 2,133 | 0.53 | Easy | 29,579 |
https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/discuss/1788076/matrix | class Solution:
def checkValid(self, matrix: List[List[int]]) -> bool:
n = len(matrix)
m = len(matrix[0])
for i in range(n):
s = set()
for j in range(m):
if matrix[i][j] in s:
return False
else:
s.add(matrix[i][j])
for i in range(m):
s = set()
for j in range(n):
if matrix[j][i] in s:
return False
else:
s.add(matrix[j][i])
return True | check-if-every-row-and-column-contains-all-numbers | matrix | lucifer_110001 | 0 | 37 | check if every row and column contains all numbers | 2,133 | 0.53 | Easy | 29,580 |
https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/discuss/1771978/Python-3-index-marking-O(n2)-time-O(1)-space | class Solution:
def checkValid(self, matrix: List[List[int]]) -> bool:
for i, row in enumerate(matrix):
for j, num in enumerate(row):
num = abs(num)
if matrix[i][num-1] < 0:
return False
matrix[i][num-1] *= -1
for i, row in enumerate(matrix):
for j, num in enumerate(row):
num = abs(num)
if matrix[num-1][j] > 0:
return False
matrix[num-1][j] *= -1
return True | check-if-every-row-and-column-contains-all-numbers | Python 3, index marking, O(n^2) time, O(1) space | dereky4 | 0 | 70 | check if every row and column contains all numbers | 2,133 | 0.53 | Easy | 29,581 |
https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/discuss/1692346/Simple-Python-solution | class Solution:
def checkValid(self, M: List[List[int]]) -> bool:
n = len(M)
nums = set(range(1, n+1))
def match(A):
return all(set(row) == nums for row in A)
return match(M) and match(zip(*M)) | check-if-every-row-and-column-contains-all-numbers | Simple Python solution | emwalker | 0 | 168 | check if every row and column contains all numbers | 2,133 | 0.53 | Easy | 29,582 |
https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/discuss/1681975/O(k2)-time-complexity-straightforward-solution.-K-is-row-size | class Solution:
def checkValid(self, matrix: List[List[int]]) -> bool:
# ROW CHECK
# Check if every row has unique digits, by constraint (1 <= matrix[i][j] <= n) on the problem
# if they are all unique, they should be between 1 to n for a row
# Quit early if false
for i in range(len(matrix)):
if len(set(matrix[i])) != len(matrix[i]):
return False
# COLUMN CHECK
# Create a temporary array of columns and check if it has unique numbers
# Quit early if false
for col in range(len(matrix)):
temp = []
for row in range(len(matrix)):
temp.append(matrix[row][col])
if len(set(temp)) != len(temp):
return False
# If all validations succeeded, matrix is valid
return True | check-if-every-row-and-column-contains-all-numbers | O(k^2) time complexity straightforward solution. K is row size | snagsbybalin | 0 | 54 | check if every row and column contains all numbers | 2,133 | 0.53 | Easy | 29,583 |
https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/discuss/1677109/Python3-Beginner-friendly-Solution | class Solution:
def checkValid(self, matrix: List[List[int]]) -> bool:
n=len(matrix)
for i in range(0,len(matrix)):
map=set()
for j in range(0,len(matrix)):
map.add(matrix[i][j])
if len(map)!=n:
return False
for i in range(0,len(matrix)):
map=set()
for j in range(0,len(matrix)):
map.add(matrix[j][i])
if len(map)!=n:
return False
return True | check-if-every-row-and-column-contains-all-numbers | Python3 Beginner friendly Solution | aryanagrawal2310 | 0 | 157 | check if every row and column contains all numbers | 2,133 | 0.53 | Easy | 29,584 |
https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/discuss/1676927/Python3-Solution-oror-Easy-to-understand-oror-For-beginner | class Solution:
def checkValid(self, matrix: List[List[int]]) -> bool:
def column(matrix, i):
return [row[i] for row in matrix]
n = len(matrix)
for x in range(len(matrix)):
i = 1
a = column(matrix, x)
while i <= n:
if i not in matrix[x] or i not in a:
return False
else:
i+=1
return True | check-if-every-row-and-column-contains-all-numbers | [Python3] Solution || Easy to understand || For beginner | Cheems_Coder | 0 | 90 | check if every row and column contains all numbers | 2,133 | 0.53 | Easy | 29,585 |
https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/discuss/1729088/Easy-to-understand-python3-solution | class Solution:
def checkValid(self, matrix: List[List[int]]) -> bool:
n=len(matrix)
return all(len(set(row))==n for row in matrix) and all(len(set(col))==n for col in zip(*matrix)) | check-if-every-row-and-column-contains-all-numbers | Easy to understand python3 solution | Karna61814 | -1 | 59 | check if every row and column contains all numbers | 2,133 | 0.53 | Easy | 29,586 |
https://leetcode.com/problems/minimum-swaps-to-group-all-1s-together-ii/discuss/1677262/Sliding-window-with-comments-Python | class Solution:
def minSwaps(self, nums: List[int]) -> int:
width = sum(num == 1 for num in nums) #width of the window
nums += nums
res = width
curr_zeros = sum(num == 0 for num in nums[:width]) #the first window is nums[:width]
for i in range(width, len(nums)):
curr_zeros -= (nums[i - width] == 0) #remove the leftmost 0 if exists
curr_zeros += (nums[i] == 0) #add the rightmost 0 if exists
res = min(res, curr_zeros) #update if needed
return res | minimum-swaps-to-group-all-1s-together-ii | Sliding window with comments, Python | kryuki | 21 | 645 | minimum swaps to group all 1s together ii | 2,134 | 0.507 | Medium | 29,587 |
https://leetcode.com/problems/minimum-swaps-to-group-all-1s-together-ii/discuss/1793862/Python-sliding-window-O(n) | class Solution:
def minSwaps(self, nums: List[int]) -> int:
ones = nums.count(1)
n = len(nums)
res = ones
start = 0
end = ones-1
zeroesInWindow = sum(num==0 for num in nums[start:end+1])
while start < n:
# print(start, end , zeroesInWindow)
res = min(res, zeroesInWindow)
if nums[start] == 0: zeroesInWindow -= 1
start += 1
end += 1
if nums[end%n] == 0: zeroesInWindow += 1
return res | minimum-swaps-to-group-all-1s-together-ii | Python sliding window O(n) | abkc1221 | 2 | 168 | minimum swaps to group all 1s together ii | 2,134 | 0.507 | Medium | 29,588 |
https://leetcode.com/problems/minimum-swaps-to-group-all-1s-together-ii/discuss/2628378/Sliding-window-approach | class Solution:
def minSwaps(self, nums: List[int]) -> int:
l = r = 0
zero = 0
k = nums.count(1) + 1 #our window size #O(n)
nums+=nums #double the array
mi = len(nums)*3 #just random higher number
while r < len(nums):
if (r - l + 1) == k: #if our window size is k increment left and add the minimum size
mi = min(mi, zero)
if nums[l] == 0:
zero-=1
l+=1
if nums[r] == 0:
zero+=1
r+=1
print(mi)
return mi | minimum-swaps-to-group-all-1s-together-ii | Sliding window approach | pandish | 1 | 50 | minimum swaps to group all 1s together ii | 2,134 | 0.507 | Medium | 29,589 |
https://leetcode.com/problems/minimum-swaps-to-group-all-1s-together-ii/discuss/2516892/Python3-Solution-or-Sliding-Window-or-O(n)-Time | class Solution:
def minSwaps(self, nums):
n, k, ans = len(nums), nums.count(1), float('inf')
c = nums[:k].count(1)
for i in range(n):
ans = min(ans, k - c)
c += nums[(i + k) % n] - nums[i]
return ans | minimum-swaps-to-group-all-1s-together-ii | ✔ Python3 Solution | Sliding Window | O(n) Time | satyam2001 | 1 | 61 | minimum swaps to group all 1s together ii | 2,134 | 0.507 | Medium | 29,590 |
https://leetcode.com/problems/minimum-swaps-to-group-all-1s-together-ii/discuss/1947891/python-3-oror-sliding-window-oror-O(n)O(1) | class Solution:
def minSwaps(self, nums: List[int]) -> int:
n, ones = len(nums), sum(nums)
window = max_window = sum(nums[i] for i in range(ones))
for i in range(n - 1):
window += nums[(i + ones) % n] - nums[i]
max_window = max(max_window, window)
return ones - max_window | minimum-swaps-to-group-all-1s-together-ii | python 3 || sliding window || O(n)/O(1) | dereky4 | 1 | 110 | minimum swaps to group all 1s together ii | 2,134 | 0.507 | Medium | 29,591 |
https://leetcode.com/problems/minimum-swaps-to-group-all-1s-together-ii/discuss/1710179/Python-3-Sliding-window.-Clean-and-concise | class Solution:
def minSwaps(self, nums: List[int]) -> int:
# The size of the sliding window
max_size = sum(nums)
# Create a window of max_size and count the number of ones and zeros
i, j = max_size, 0
current_ones = sum(nums[:max_size]) # Number of ones in the window.
minimum_number_of_zeros = max_size - current_ones # Number of zeros in the window. WE WANT TO MINIMIZE THIS.
# now we just need to add a new number from the right and remove one from the left
while i < len(nums)*2: # * 2 because the array is circular
# Add from the right
current_ones += nums[i % len(nums)]
# Remove from the left
current_ones -= nums[j % len(nums)]
# By writting the previous two lines we maintain the size of sliding window.
# Minimize the number of zeros
minimum_number_of_zeros = min(minimum_number_of_zeros, max_size - current_ones)
i += 1
j += 1
return minimum_number_of_zeros | minimum-swaps-to-group-all-1s-together-ii | [Python 3] Sliding window. Clean & concise | asbefu | 1 | 132 | minimum swaps to group all 1s together ii | 2,134 | 0.507 | Medium | 29,592 |
https://leetcode.com/problems/minimum-swaps-to-group-all-1s-together-ii/discuss/1676843/Python3-sliding-window | class Solution:
def minSwaps(self, nums: List[int]) -> int:
rsm = 0
ans = inf
ones = nums.count(1)
for i in range(len(nums) + ones):
rsm += nums[i % len(nums)]
if i >= ones: rsm -= nums[i - ones]
ans = min(ans, ones - rsm)
return ans | minimum-swaps-to-group-all-1s-together-ii | [Python3] sliding window | ye15 | 1 | 146 | minimum swaps to group all 1s together ii | 2,134 | 0.507 | Medium | 29,593 |
https://leetcode.com/problems/minimum-swaps-to-group-all-1s-together-ii/discuss/2778352/Accumulating-sliding-window-(possibly-one-liner) | class Solution:
def minSwaps(self, nums: List[int]) -> int:
window_size = sum(nums)
return min(itertools.accumulate(
iterable=range(1, len(nums)),
func=lambda acc, i: acc + nums[i % len(nums) - 1] - nums[(i+window_size-1) % len(nums)],
initial=window_size - sum(nums[:window_size]))) | minimum-swaps-to-group-all-1s-together-ii | Accumulating sliding window (possibly one-liner) | illyatawgerchuk | 0 | 2 | minimum swaps to group all 1s together ii | 2,134 | 0.507 | Medium | 29,594 |
https://leetcode.com/problems/minimum-swaps-to-group-all-1s-together-ii/discuss/2140392/Python-sliding-window-O(N)O(1) | class Solution:
def minSwaps(self, nums: List[int]) -> int:
num1 = sum(nums)
s = sum(nums[:num1])
result = num1 - s
n = len(nums)
for i in range(num1, 2*n - 2):
s += nums[i % n]
s -= nums[(i-num1) % n]
result = min(result, num1 - s)
return result | minimum-swaps-to-group-all-1s-together-ii | Python, sliding window O(N)/O(1) | blue_sky5 | 0 | 96 | minimum swaps to group all 1s together ii | 2,134 | 0.507 | Medium | 29,595 |
https://leetcode.com/problems/minimum-swaps-to-group-all-1s-together-ii/discuss/1681192/Linear-solution-87-speed | class Solution:
def minSwaps(self, nums: List[int]) -> int:
ones = nums.count(1)
if ones < 2 or ones == len(nums):
return 0
nums.extend(nums[:ones - 1])
max_ones = sliding_ones = nums[:ones].count(1)
for i in range(ones, len(nums)):
sliding_ones += nums[i] - nums[i - ones]
max_ones = max(max_ones, sliding_ones)
return ones - max_ones | minimum-swaps-to-group-all-1s-together-ii | Linear solution, 87% speed | EvgenySH | 0 | 36 | minimum swaps to group all 1s together ii | 2,134 | 0.507 | Medium | 29,596 |
https://leetcode.com/problems/minimum-swaps-to-group-all-1s-together-ii/discuss/1679478/python3-Sliding-window-with-appending-the-array-to-self-for-ref. | class Solution:
def minSwaps(self, nums: List[int]) -> int:
# sliding window
swindowlen = nums.count(1)
nums += nums
# number of zeros in the sliding window.
number_of_zeros_in_window = nums[:swindowlen].count(0)
ans = number_of_zeros_in_window
for x in range(swindowlen, swindowlen+(len(nums)//2)):
if nums[x-swindowlen] == 0:
number_of_zeros_in_window -= 1
if nums[x] == 0:
number_of_zeros_in_window += 1
ans = min(ans, number_of_zeros_in_window)
return ans | minimum-swaps-to-group-all-1s-together-ii | [python3] Sliding window with appending the array to self for ref. | vadhri_venkat | 0 | 45 | minimum swaps to group all 1s together ii | 2,134 | 0.507 | Medium | 29,597 |
https://leetcode.com/problems/minimum-swaps-to-group-all-1s-together-ii/discuss/1678771/Python3-Sliding-Window-Approach | class Solution:
def minSwaps(self, nums: List[int]) -> int:
k = nums.count(1)
combined_array = nums + nums
l, r = 0, 0
current_count = 0
min_count = float("inf")
while r < len(combined_array):
while (r - l) < k:
if combined_array[r] == 0:
current_count += 1
r = r + 1
min_count = min(min_count, current_count)
if combined_array[r] == 0:
current_count += 1
if combined_array[l] == 0:
current_count -= 1
r += 1
l += 1
return min_count | minimum-swaps-to-group-all-1s-together-ii | [Python3] Sliding Window Approach | venkateshyadava | 0 | 39 | minimum swaps to group all 1s together ii | 2,134 | 0.507 | Medium | 29,598 |
https://leetcode.com/problems/minimum-swaps-to-group-all-1s-together-ii/discuss/1677039/Python-3-Circular-Sliding-Window | class Solution:
def minSwaps(self, data: List[int]) -> int:
ones = sum(data)
cntOne = maxOne = 0
l = r = 0
n = len(data)
while r < n*2:
cntOne += data[r%n]
r += 1
while r - l > ones:
cntOne -= data[l%n]
l += 1
maxOne = max(maxOne,cntOne)
return ones - maxOne | minimum-swaps-to-group-all-1s-together-ii | Python 3 Circular Sliding Window | ezcat | 0 | 56 | minimum swaps to group all 1s together ii | 2,134 | 0.507 | Medium | 29,599 |
Subsets and Splits