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/palindrome-number/discuss/2398263/9.-Palindrome-Number-solution-in-3-ways
|
class Solution:
def isPalindrome(self, x: int) -> bool:
x = str(x)
length = len(x)
l = int(length/2)
cnt = 0
for i in range(l):
if(x[i]==x[length-1-i]):
cnt += 1
else:
break
return cnt==l
|
palindrome-number
|
9. Palindrome Number solution in 3 ways
|
e-mm-u
| 1 | 364 |
palindrome number
| 9 | 0.53 |
Easy
| 400 |
https://leetcode.com/problems/palindrome-number/discuss/2398263/9.-Palindrome-Number-solution-in-3-ways
|
class Solution:
def isPalindrome(self, x: int) -> bool:
strX = str(x)
revStrX = strX[::-1]
return strX==revStrX[::-1]
|
palindrome-number
|
9. Palindrome Number solution in 3 ways
|
e-mm-u
| 1 | 364 |
palindrome number
| 9 | 0.53 |
Easy
| 401 |
https://leetcode.com/problems/palindrome-number/discuss/2398263/9.-Palindrome-Number-solution-in-3-ways
|
class Solution:
def isPalindrome(self, x: int) -> bool:
strX = str(x)
return strX==strX[::-1]
|
palindrome-number
|
9. Palindrome Number solution in 3 ways
|
e-mm-u
| 1 | 364 |
palindrome number
| 9 | 0.53 |
Easy
| 402 |
https://leetcode.com/problems/palindrome-number/discuss/2375083/90-99-fastest-solution-in-Python-to-the-Palindrome-problem
|
class Solution(object):
def isPalindrome(self,x):
return str(x) == str(x)[::-1]
|
palindrome-number
|
90-99% fastest solution in Python to the Palindrome problem
|
slzr_
| 1 | 187 |
palindrome number
| 9 | 0.53 |
Easy
| 403 |
https://leetcode.com/problems/palindrome-number/discuss/2319721/Python-one-liner
|
class Solution:
def isPalindrome(self, x: int) -> bool:
return str(x) == str(x)[::-1]
|
palindrome-number
|
Python one liner
|
Balance-Coffee
| 1 | 77 |
palindrome number
| 9 | 0.53 |
Easy
| 404 |
https://leetcode.com/problems/palindrome-number/discuss/2259801/python3
|
class Solution:
def isPalindrome(self, x: int) -> bool:
return str(x) == str(x)[::-1]
|
palindrome-number
|
python3
|
kobatatsu0514
| 1 | 175 |
palindrome number
| 9 | 0.53 |
Easy
| 405 |
https://leetcode.com/problems/palindrome-number/discuss/1914490/Python3-one-line-accepted-solution
|
class Solution:
def isPalindrome(self, x: int) -> bool:
return [a for a in str(x)] == [a for a in str(x)][::-1]
|
palindrome-number
|
Python3 one line accepted solution
|
ElizaZoldyck
| 1 | 45 |
palindrome number
| 9 | 0.53 |
Easy
| 406 |
https://leetcode.com/problems/palindrome-number/discuss/1678221/Easy-10-line-python-code
|
class Solution:
def isPalindrome(self, x: int) -> bool:
if x < 0:
return False
num = x
reverse = 0
while(num):
reverse = reverse * 10 + num % 10 #taking the reverse of the number
num //= 10
return x == reverse
|
palindrome-number
|
Easy 10 line python code
|
Unexpected_Error
| 1 | 281 |
palindrome number
| 9 | 0.53 |
Easy
| 407 |
https://leetcode.com/problems/palindrome-number/discuss/1475543/Python3-oror-Simple-and-Correct-Solution
|
class Solution:
def isPalindrome(self, x: int) -> bool:
if x<0:
return False
else:
result = 0
dummy = x
while x!=0:
result = result*10 + x%10
x = x//10
return result == dummy
|
palindrome-number
|
Python3 || Simple and Correct Solution
|
ajinkya2021
| 1 | 215 |
palindrome number
| 9 | 0.53 |
Easy
| 408 |
https://leetcode.com/problems/palindrome-number/discuss/1373902/Python-89.99-faster
|
class Solution:
def isPalindrome(self, x: int) -> bool:
if x >= 0:
x = str(x)
if x == x[::-1]:
return True
return False
|
palindrome-number
|
Python 89.99% faster
|
SnakeUser
| 1 | 234 |
palindrome number
| 9 | 0.53 |
Easy
| 409 |
https://leetcode.com/problems/palindrome-number/discuss/1314676/Easy-Solution_-Python-3
|
class Solution:
def isPalindrome(self, x: int) -> bool:
if x < 0:
return False # Negative number will not be Palindrome Number.
else:
rev = int(str(x)[::-1]) # Revise the number.
return rev == x # Compare the input number is equal to the revised number or not.
|
palindrome-number
|
Easy Solution_ Python 3
|
An_222
| 1 | 135 |
palindrome number
| 9 | 0.53 |
Easy
| 410 |
https://leetcode.com/problems/palindrome-number/discuss/824689/Python-One-Line-O(N)-oror-Easy
|
class Solution:
def isPalindrome(self, x: int) -> bool:
return str(x) == str(x)[::-1]
# TC: O(N)
# SC: O(1)
|
palindrome-number
|
Python One Line O(N) || Easy
|
airksh
| 1 | 89 |
palindrome number
| 9 | 0.53 |
Easy
| 411 |
https://leetcode.com/problems/palindrome-number/discuss/445882/Python3-via-str()-99.74-faster-100.00-less-memory
|
class Solution:
def isPalindrome(self, x: int) -> bool:
return str(x) == str(x)[::-1] if x >= 0 else False
|
palindrome-number
|
Python3 via str() 99.74% faster, 100.00% less memory
|
eQualo
| 1 | 339 |
palindrome number
| 9 | 0.53 |
Easy
| 412 |
https://leetcode.com/problems/palindrome-number/discuss/2846729/ProCode-from-palindrome
|
class Solution:
def isPalindrome(self, x: int) -> bool:
x=str(x)
if x==x[::-1]:
return True
else:
return False
|
palindrome-number
|
ProCode from palindrome
|
AhensInitiative
| 0 | 2 |
palindrome number
| 9 | 0.53 |
Easy
| 413 |
https://leetcode.com/problems/palindrome-number/discuss/2844948/it-works
|
class Solution:
def isPalindrome(self, x: int) -> bool:
x=str(x)
if x==x[::-1]:
return True
else:
return False
|
palindrome-number
|
it works
|
venkatesh402
| 0 | 1 |
palindrome number
| 9 | 0.53 |
Easy
| 414 |
https://leetcode.com/problems/palindrome-number/discuss/2841490/Beginner-friendly-logic-(Python3)
|
class Solution:
def isPalindrome(self, x: int) -> bool:
originalList = []
palindromeList = []
xString = str(x)
for i in range(len(xString)):
element = xString[i]
originalList.append(element)
palindromeList.append(element)
palindromeList.reverse()
m = len(originalList)
checkList = []
for t in range(m):
if originalList[t] == palindromeList[t]:
checkList.append('T')
continue
else:
return False
if len(checkList) == m:
return True
|
palindrome-number
|
Beginner friendly logic (Python3)
|
hmrealistic
| 0 | 5 |
palindrome number
| 9 | 0.53 |
Easy
| 415 |
https://leetcode.com/problems/palindrome-number/discuss/2841194/palindrome-number
|
class Solution:
def isPalindrome(self, x: int) -> bool:
return str(x)==str(x)[::-1]
|
palindrome-number
|
palindrome number
|
bhalke_216
| 0 | 1 |
palindrome number
| 9 | 0.53 |
Easy
| 416 |
https://leetcode.com/problems/palindrome-number/discuss/2840495/Simple-Solution
|
class Solution:
def isPalindrome(self, x: int) -> bool:
if str(x) == str(x)[::-1]:
return True
else:
return False
|
palindrome-number
|
Simple Solution
|
Haz03
| 0 | 2 |
palindrome number
| 9 | 0.53 |
Easy
| 417 |
https://leetcode.com/problems/palindrome-number/discuss/2839014/Python-one-line
|
class Solution:
def isPalindrome(self, x: int) -> bool:
return str(x) == str(x)[::-1]
|
palindrome-number
|
Python one line
|
samurai2
| 0 | 1 |
palindrome number
| 9 | 0.53 |
Easy
| 418 |
https://leetcode.com/problems/palindrome-number/discuss/2838247/Mathematical-solution
|
class Solution:
def isPalindrome(self, x: int) -> bool:
x1 = x
if x < 0:
return False
sum = 0
while x != 0:
rev = x%10 #last digit of integer goes to rev
sum = (sum * 10) + rev # multiplication of 10 here gives 0 to last digit of number after that adding rev value to 0.
x = x//10
if x1==sum:
return True
else:
return False
|
palindrome-number
|
Mathematical solution
|
viveksingh17
| 0 | 1 |
palindrome number
| 9 | 0.53 |
Easy
| 419 |
https://leetcode.com/problems/palindrome-number/discuss/2834950/Easy-way-to-slove
|
class Solution:
def isPalindrome(self, x: int) -> bool:
a=str(x)
s=int(len(a)/2)
if len(a)%2==1:
for i in range(0,s):
if a[i] != a[len(a)-1-i]:
return False
return True
elif len(a)%2==0:
for i in range(0,s):
if a[i] != a[len(a)-1-i]:
return False
return True
|
palindrome-number
|
Easy way to slove
|
NUUC_111356040
| 0 | 2 |
palindrome number
| 9 | 0.53 |
Easy
| 420 |
https://leetcode.com/problems/palindrome-number/discuss/2833114/Python-3-solution-using-slice
|
class Solution:
def isPalindrome(self, x: int) -> bool:
x2 = str(x)
x3 = x2[::-1]
if x3 == x2:
return True
return False
|
palindrome-number
|
Python 3 solution using slice
|
woxp
| 0 | 4 |
palindrome number
| 9 | 0.53 |
Easy
| 421 |
https://leetcode.com/problems/palindrome-number/discuss/2832577/Python-Easy-One-Line-Solution
|
class Solution:
def isPalindrome(self, x: int) -> bool:
return str(x) == str(x)[::-1]
|
palindrome-number
|
Python - Easy One-Line Solution
|
james_tf
| 0 | 2 |
palindrome number
| 9 | 0.53 |
Easy
| 422 |
https://leetcode.com/problems/palindrome-number/discuss/2830485/Simple-Solution
|
class Solution:
def isPalindrome(self, x: int) -> bool:
num_str = str(x)
size = len(num_str)
reversed_num = num_str[size::-1]
if str(x) == reversed_num:
return True
else:
return False
|
palindrome-number
|
Simple Solution
|
torzin
| 0 | 3 |
palindrome number
| 9 | 0.53 |
Easy
| 423 |
https://leetcode.com/problems/palindrome-number/discuss/2828822/List-and-Reversed
|
class Solution:
def isPalindrome(self, x: int) -> bool:
y = list(str(x))
return y== list(reversed(y))
|
palindrome-number
|
List and Reversed
|
user5687us
| 0 | 3 |
palindrome number
| 9 | 0.53 |
Easy
| 424 |
https://leetcode.com/problems/regular-expression-matching/discuss/2383634/Fastest-Solution-Explained0ms100-O(n)time-complexity-O(n)space-complexity
|
class Solution:
def isMatch(self, s, p):
n = len(s)
m = len(p)
dp = [[False for _ in range (m+1)] for _ in range (n+1)]
dp[0][0] = True
for c in range(1,m+1):
if p[c-1] == '*' and c > 1:
dp[0][c] = dp[0][c-2]
for r in range(1,n+1):
for c in range(1,m+1):
if p[c-1] == s[r-1] or p[c-1] == '.':
dp[r][c] = dp[r-1][c-1]
elif c > 1 and p[c-1] == '*':
if p[c-2] =='.' or s[r-1]==p[c-2]:
dp[r][c] =dp[r][c-2] or dp[r-1][c]
else:
dp[r][c] = dp[r][c-2]
return dp[n][m]
|
regular-expression-matching
|
[Fastest Solution Explained][0ms][100%] O(n)time complexity O(n)space complexity
|
cucerdariancatalin
| 10 | 1,300 |
regular expression matching
| 10 | 0.282 |
Hard
| 425 |
https://leetcode.com/problems/regular-expression-matching/discuss/366219/Python3dynamic-programming
|
class Solution:
def isMatch(self, s, p):
n = len(s)
m = len(p)
dp = [[False for _ in range (m+1)] for _ in range (n+1)]
dp[0][0] = True
for c in range(1,m+1):
if p[c-1] == '*' and c > 1:
dp[0][c] = dp[0][c-2]
for r in range(1,n+1):
for c in range(1,m+1):
if p[c-1] == s[r-1] or p[c-1] == '.':
dp[r][c] = dp[r-1][c-1]
elif c > 1 and p[c-1] == '*':
if p[c-2] =='.' or s[r-1]==p[c-2]:
dp[r][c] =dp[r][c-2] or dp[r-1][c]
else:
dp[r][c] = dp[r][c-2]
return dp[n][m]
|
regular-expression-matching
|
[Python3]dynamic programming
|
zhanweiting
| 7 | 1,000 |
regular expression matching
| 10 | 0.282 |
Hard
| 426 |
https://leetcode.com/problems/regular-expression-matching/discuss/2532721/Dynamic-programming-or-Python
|
class Solution:
def isMatch(self, s: str, p: str) -> bool:
n_s=len(s)
n_p=len(p)
dp=[[False]*(n_p+1) for _ in range(n_s+1)]
dp[0][0]=True
#For empty string but the "*" in pattern might return True
for i in range(1,n_p+1):
if p[i-1]=="*":
dp[0][i]=dp[0][i-2]
for i in range(1,n_s+1):
for j in range(1,n_p+1):
#When the character in string matches with the patter or the pattern has '.', which accepts any character
if s[i-1]==p[j-1] or p[j-1]=='.':
dp[i][j]=dp[i-1][j-1]
#When the pattern has "*", this shows that we need to check the [j-2] for the character, which can be the string character or '.'. In this case we will check the [i-1][j], to check if the character except the current one is True.
elif p[j-1]=="*":
dp[i][j]=dp[i][j-2]
if p[j-2]=='.' or p[j-2]==s[i-1]:
dp[i][j]=dp[i][j] or dp[i-1][j]
return dp[n_s][n_p]
|
regular-expression-matching
|
Dynamic programming | Python
|
ankush_A2U8C
| 4 | 343 |
regular expression matching
| 10 | 0.282 |
Hard
| 427 |
https://leetcode.com/problems/regular-expression-matching/discuss/2392690/Python-95-faster
|
class Solution:
def isMatch(self, s: str, p: str) -> bool:
dp = {}
def dfs(i,j):
if (i,j) in dp:
return dp[(i,j)]
if i>=len(s) and j>=len(p):
return True
if i<= len(s) and j>= len(p):
return False
match = i< len(s) and ((s[i] == p[j]) or (p[j] == '.'))
if j < len(p)-1 and p[j+1] == '*':
dp[(i,j)] = ( dfs(i,j+2) # dont use *
or (match and dfs(i+1,j)) )
return dp[(i,j)]
if match:
dp[(i,j)] = dfs(i+1,j+1)
return dp[(i,j)]
return dfs(0,0)
|
regular-expression-matching
|
Python 95% faster
|
Abhi_009
| 2 | 446 |
regular expression matching
| 10 | 0.282 |
Hard
| 428 |
https://leetcode.com/problems/regular-expression-matching/discuss/2199084/python-3-or-memoization
|
class Solution:
def isMatch(self, s: str, p: str) -> bool:
m, n = len(s), len(p)
@lru_cache(None)
def helper(i, j):
if j == n:
return i == m
match = i != m and (p[j] == '.' or s[i] == p[j])
if j == n - 1 or p[j + 1] != '*':
return match and helper(i + 1, j + 1)
return helper(i, j + 2) or (match and helper(i + 1, j))
return helper(0, 0)
|
regular-expression-matching
|
python 3 | memoization
|
dereky4
| 2 | 287 |
regular expression matching
| 10 | 0.282 |
Hard
| 429 |
https://leetcode.com/problems/regular-expression-matching/discuss/1270958/python3-can-I-use-regex
|
class Solution:
def isMatch(self, s: str, p: str) -> bool:
# when pattern(p) is "", check with string(s)
if not p:
return s == p
# when the last char of pattern(p) is *
if p[-1] == "*":
# *=0,the char before * is repeated 0 times
if self.isMatch(s, p[: -2]):
return True
# when string(s) is "" and pattern(p) has chars
if not s:
return False
# delete once repeated times
if p[-2] == "." or p[-2] == s[-1]:
return self.isMatch(s[: -1], p)
# when string(s) is "" and pattern(p) has chars
if not s:
return False
# delete last repeated cher
if p[-1] == "." or p[-1] == s[-1]:
return self.isMatch(s[: -1], p[: -1])
|
regular-expression-matching
|
python3 can I use regex?
|
haoIfrit
| 1 | 123 |
regular expression matching
| 10 | 0.282 |
Hard
| 430 |
https://leetcode.com/problems/regular-expression-matching/discuss/1193646/Could-this-be-the-shortest-and-fastest-Python-Solution
|
class Solution:
@lru_cache
def isMatch(self, s, p):
if not p: return s == p
if p[-1] == '*':
if self.isMatch(s, p[:-2]): return True
if s and (s[-1] == p[-2] or p[-2] == '.') and self.isMatch(s[:-1], p): return True
return s and (p[-1] == s[-1] or p[-1] == '.') and self.isMatch(s[:-1], p[:-1])
|
regular-expression-matching
|
Could this be the shortest and fastest Python Solution?
|
A88888
| 1 | 409 |
regular expression matching
| 10 | 0.282 |
Hard
| 431 |
https://leetcode.com/problems/regular-expression-matching/discuss/2843241/Straightforward-recursive-solution-in-Python
|
class Solution:
def isMatch(self, s: str, p: str) -> bool:
while not (s=='' and p==''):
if len(p) >= 2:
if p[:2] == '.*':
for m in range(len(s)+1):
if self.isMatch(s[m:], p[2:]):
return True
return False
elif p[1] == '*':
for m in range(len(s)+1):
if s[:m] != p[0] * m:
return False
if self.isMatch(s[m:], p[2:]):
return True
return False
if s == '' or p == '':
return False
if p[0].isalnum():
if p[0] != s[0]:
return False
elif p[0] == '.':
pass
else:
return False
p = p[1:]
s = s[1:]
else:
return True
|
regular-expression-matching
|
Straightforward recursive solution in Python
|
clavicordio
| 0 | 4 |
regular expression matching
| 10 | 0.282 |
Hard
| 432 |
https://leetcode.com/problems/regular-expression-matching/discuss/2841578/PYTHON-3-Part-by-Part-Explained-Solution-beginner-friendly-%3A)
|
class Solution:
def isMatch(self, s: str, p: str) -> bool:
def helper(s, p):
for i, j in zip(s, p):
if j != "." and i != j:
return False
return True if len(s) == len(p) else False
def starc(s, p, x=0, y=0):
key = y
while x < len(p) and y < len(s):
if len(p[x]) == 2:
if s[y] == p[x][0] or p[x][0] == ".":
y += 1
elif s[y] != p[x][0]:
x += 1
else:
break
return True if y - key == len(s) else False
if "*" in p:
memo = []
cut = ""
for x in range(len(p)):
if p[x] == "*":
if any(cut[:-1]):
memo.append([cut[:-1]])
memo.append(cut[-1]+"*")
cut = ""
elif p[x] != "*":
cut = cut + p[x]
if any(cut): memo.append([cut])
for i in range(len(memo)):
if type(memo[i]) == list:
y = 0
for v in memo:
if type(v) == list:
if len(v) > 1:
y = v[1] + len(v[0])
g = sum((len(x[0]) for x in memo[i + 1:] if type(x) == list))
while y + len(memo[i][0]) <= len(s) - g:
if helper(s[y: y + len(memo[i][0])], memo[i][0]):
memo[i] = memo[i] + [y]
y += 1
if len(memo[i]) == 1:
return False
if not any([x for x in memo if type(x)==list and len(x)>1]):
return starc(s,memo)
must = [x for x in range(len(memo)) if type(memo[x])==list]
place = []
for z in must:
if not any(place):
for i in memo[z][1:]:
place.append([i])
else:
cut = len(place)
for k in range(len(place)):
a = place[k]
for i in memo[z][1:]:
place.append(a+[i])
place = place[cut:]
for cp in place:
if len(set(cp)) != len(cp):
continue
d = 0
s2 = s
howcut = []
while d < len(cp):
if d < len(cp)-1:
if cp[d] + len(memo[must[d]][0]) > cp[d+1]: break
back = []
for e in memo[:must[d]][::-1]:
if type(e) == str:
back.append(e)
else:
break
cc = 0
if any(howcut):
cc = sum(howcut)
if starc(s2[:cp[d]-cc], back[::-1]):
howcut.append(len(s2[:cp[d]-cc + len(memo[must[d]][0])]))
s2 = s2[(cp[d]-cc) + len(memo[must[d]][0]):]
if any(s2):
d += 1
continue
else:
break
else:
break
elif d == len(cp) -1:
back = []
for e in memo[:must[d]][::-1]:
if type(e) == str:
back.append(e)
else:
break
cc = 0
if any(howcut):
cc = sum(howcut)
if starc(s2[:cp[d]-cc], back[::-1]):
howcut.append(len(s2[:cp[d]-cc + len(memo[must[d]][0])]))
s2 = s2[(cp[d]-cc) + len(memo[must[d]][0]):]
front = []
for e in memo[must[d]+1:]:
if type(e) == str:
front.append(e)
else:
break
if starc(s2, front):
return True
else:
break
else:
break
return False
else:
return helper(s,p)
|
regular-expression-matching
|
PYTHON 3 Part by Part Explained Solution beginner friendly :)
|
BladeRunner61
| 0 | 6 |
regular expression matching
| 10 | 0.282 |
Hard
| 433 |
https://leetcode.com/problems/regular-expression-matching/discuss/2824878/Python-solution-regex-xx
|
class Solution:
def isMatch(self, s: str, p: str) -> bool:
find = re.findall(p, s)
if not(len(find)) or (len(find) and find[0] != s):
return False
return True
|
regular-expression-matching
|
Python - solution - regex - xx
|
user6314wG
| 0 | 3 |
regular expression matching
| 10 | 0.282 |
Hard
| 434 |
https://leetcode.com/problems/regular-expression-matching/discuss/2806456/Python3-Backtracking-%2B-Stack-(83ms)
|
class Solution:
def isMatch(self, s: str, p: str) -> bool:
n, m = len(s), len(p)
i, j = n-1, m-1
wildcard_backtracking = []
while i >=0:
# single char case
if j >= 0 and (p[j] == '.' or p[j] == s[i]):
i-=1
j-=1
# zero or more case, start from zero precending
elif j >= 0 and p[j] == '*':
if p[j-1] == '.' and j == 1:
return True
else:
j-=2
wildcard_backtracking.append((p[j+1], j,i))
# not match, backtracking
elif len(wildcard_backtracking) > 0:
p_back, j_back, i_back = wildcard_backtracking.pop()
i, j = i_back, j_back
if p_back == '.' or p_back == s[i]:
i-=1
wildcard_backtracking.append((p_back, j_back, i))
else:
return False
# remove all matched zero or more case
while j >= 0 and p[j] == '*':
j-=2
return i == -1 and j == -1
|
regular-expression-matching
|
[Python3] Backtracking + Stack (83ms)
|
user4722lM
| 0 | 4 |
regular expression matching
| 10 | 0.282 |
Hard
| 435 |
https://leetcode.com/problems/regular-expression-matching/discuss/2581890/python3-one-command
|
class Solution:
def isMatch(self, s: str, p: str) -> bool:
return re.fullmatch(p, s)
|
regular-expression-matching
|
python3 one command
|
eazykaye
| 0 | 93 |
regular expression matching
| 10 | 0.282 |
Hard
| 436 |
https://leetcode.com/problems/regular-expression-matching/discuss/2192499/Python-easy-to-read-and-understand-or-DP
|
class Solution:
def isMatch(self, s: str, p: str) -> bool:
n, m = len(s), len(p)
t = [[-1 for _ in range(n+1)] for _ in range(m+1)]
t[0][0] = True
for j in range(1, n+1):
t[0][j] = False
for i in range(1, m+1):
if p[i-1] == '*':
t[i][0] = t[i-2][0]
else:
t[i][0] = False
for i in range(1, m+1):
for j in range(1, n+1):
if p[i-1].isalpha():
if p[i-1] == s[j-1]:
t[i][j] = t[i-1][j-1]
else:
t[i][j] = False
elif p[i-1] == '.':
t[i][j] = t[i-1][j-1]
elif p[i-1] == '*':
if p[i-2] == s[j-1] or p[i-2] == '.':
t[i][j] = t[i-2][j] or t[i][j-1]
else:
t[i][j] = t[i-2][j]
return t[m][n]
|
regular-expression-matching
|
Python easy to read and understand | DP
|
sanial2001
| 0 | 267 |
regular expression matching
| 10 | 0.282 |
Hard
| 437 |
https://leetcode.com/problems/regular-expression-matching/discuss/2030811/python3-linked-list-of-sub-parsers.-Object-oriented-with-inheritance
|
class ParserNode:
def __init__(self, nxt=None):
self.nxt = nxt
def __str__(self): pass
#using "generator" since a ParserNode may consume a variety of combinations from p,
#this is basic form
def genparse(self, s):
if s and self.match(s[0]):
yield s[1:]
def parsealong(self, s):
#print(self, s)
for s_ in self.genparse(s):
#success: s is consumed (s_ == []) and no nxt
if not s_ and not self.nxt:
return True
#success: any downstream ParserNodes find success
if self.nxt and self.nxt.parsealong(s_):
return True
return False
####################################
class DotParserNode(ParserNode):
def __str__(self):
return f"DotParserNode => {self.nxt}"
def match(self, ch):
return True
####################################
class CharParserNode(ParserNode):
def __init__(self, ch):
ParserNode.__init__(self)
self.ch = ch
def __str__(self):
return f"CharParserNode({self.ch}) => {self.nxt}"
def match(self, ch):
return self.ch == ch
####################################
class StarParserNode(ParserNode):
def __init__(self, prev):
ParserNode.__init__(self)
self.prev = prev
def __str__(self):
return f"StarParserNode({self.prev}) => {self.nxt}"
def match(self, ch):
if self.prev:
return self.prev.match(ch)
return False
def genparse(self, s):
#0
yield s
#1+
if s:
for i in range(len(s)):
if self.match(s[i]):
yield s[i+1:]
else:
break
####################################
class Solution:
def isMatch(self, s: str, p: str) -> bool:
p = list(p)
#helper function to get parserNode from current, next character pairs
def parserNodeFactory(c, n):
if n == '*':
return StarParserNode(parserNodeFactory(c, None))
if c == '*':
return None
if c == '.':
return DotParserNode()
return CharParserNode(c)
#build linked list of ParserNodes from p
head, tail = None, None
if len(p) == 1:
head = parserNodeFactory(p[0], None)
else:
itr = zip(p, p[1:] + [None])
head = parserNodeFactory(*next(itr))
tail = head
for c, n in itr:
node = parserNodeFactory(c, n)
if node:
tail.nxt = node
tail = tail.nxt
return head.parsealong(s)
####################################
|
regular-expression-matching
|
python3, linked list of sub-parsers. Object-oriented with inheritance
|
cunning_potato
| 0 | 56 |
regular expression matching
| 10 | 0.282 |
Hard
| 438 |
https://leetcode.com/problems/regular-expression-matching/discuss/1924897/Python3-Solution-beats-90%3A-Sequential-Verification
|
class Solution:
def isMatch(self, s: str, p: str) -> bool:
arr = []
i = 0
while i < len(p):
if i+1 < len(p) and p[i+1] == '*':
arr.append(p[i]+'*')
i+=2
else:
arr.append(p[i])
i += 1
verified = set([-1])
def verify(idx, op,s):
ans = set()
if idx <= len(s):
if '*' not in op and idx < len(s) and (s[idx] == op or op == '.'):
ans.add(idx)
elif '*' in op:
ans.add(idx-1)
for i in range(idx,len(s)):
if op[0] == '.' or s[i] == op[0]:
ans.add(i)
else:
break
return ans
for vLevel in range(len(arr)):
newVerified = set()
for v in verified:
newVerified |= verify(v+1,arr[vLevel],s)
verified = newVerified
return len(s)-1 in verified
|
regular-expression-matching
|
Python3 Solution beats 90%: Sequential Verification
|
johnnyvessey
| 0 | 127 |
regular expression matching
| 10 | 0.282 |
Hard
| 439 |
https://leetcode.com/problems/regular-expression-matching/discuss/1872215/Python-solution-using-built-in-functions
|
class Solution:
def isMatch(self, s: str, p: str) -> bool:
regex = re.compile(p)
if regex.fullmatch(s):
return True
return False
|
regular-expression-matching
|
Python solution using built-in functions
|
alishak1999
| 0 | 234 |
regular expression matching
| 10 | 0.282 |
Hard
| 440 |
https://leetcode.com/problems/regular-expression-matching/discuss/1787376/Python-DP-Solution-O(m*n)-time-O(n)-space
|
class Solution:
def isMatch(self, s: str, p: str) -> bool:
n = len(p)
dp = [False] * (n + 1)
prev = True
# pretreat dp for p like "a*b*ccc*", dp[2] and dp[4] ought to be true.
for j in range(2, n + 1, 2):
if p[j - 1] != '*':
break
dp[j] = True
for i in range(len(s)):
for j in range(1, n + 1):
temp = dp[j] # to store dp[i-1][j-1] (in the original big dp matrix)
if p[j - 1] == '*':
dp[j] = dp[j - 2] or dp[j - 1] or (
dp[j] and (s[i] == p[j - 2] or p[j - 2] == '.'))
else:
dp[j] = prev and (p[j - 1] == '.' or s[i] == p[j - 1])
prev = temp
prev = False # dp[i][0] should be false (in the original big dp matrix)
return dp[n]
|
regular-expression-matching
|
Python DP Solution, O(m*n) time, O(n) space
|
celestez
| 0 | 292 |
regular expression matching
| 10 | 0.282 |
Hard
| 441 |
https://leetcode.com/problems/regular-expression-matching/discuss/1659103/Python3-Top-Down-2D-DP-Limit-Recursion-93-runtime-91-Memory
|
class Solution(object):
def isMatch(self, s, p):
# To prevent hitting max recursion limit, iterate over list of test cases.
# This limits recursive calls to isMatch to only conditions when the
# entire string or entire pattern has been consumed.
test_cases = [[s, p]]
while len(test_cases) > 0:
s, p = test_cases.pop()
sl = len(s)
pl = len(p)
# Check success/failure conditions
if sl == 0 and pl == 0:
return True
elif pl == 0:
return False
elif sl == 0 and p[-1] == '*':
return self.isMatch(s, p[:-2])
elif sl == 0:
return False
# Iterate over the string and pattern
while len(s) > 0 and len(p) > 0:
# Handle wildcards
if p[-1] == '*':
# When wildcard character matches, add test cases for single-character
# matches and multi-character matches
if p[-2] == s[-1] or p[-2] == '.':
test_cases.append([s, p[:-1]])
test_cases.append([s[:-1], p])
# Whether the wildcard character matches or not, always check for
# zero-character matches
s, p = s, p[:-2]
# For non-wildcard matches, consume the last character of
# the pattern and the string
elif s[-1] == p[-1] or p[-1] == '.':
s = s[:-1]
p = p[:-1]
# For non-wildcard mismatches, terminate this test case
else:
s, p = '0', ''
# Once either the pattern or string has been consumed,
# recheck success/failure conditions. On failure, move
# on to next test case
if self.isMatch(s, p):
return True
# If loop is exited with no successful test cases, return False
return False
|
regular-expression-matching
|
[Python3] Top-Down 2D DP, Limit Recursion, 93% runtime, 91% Memory
|
nrscer
| 0 | 139 |
regular expression matching
| 10 | 0.282 |
Hard
| 442 |
https://leetcode.com/problems/regular-expression-matching/discuss/1650354/Use-a-FSM-(finite-state-machine)-to-find-the-solution-(faster-than-99)
|
class Solution:
def isMatch(self, s: str, p: str) -> bool:
next_= defaultdict(list)
state=lastnostar= 0
for c,nc in zip(p,p[1:]+" "):
if c == "*":
continue
state+= 1
for i in range(lastnostar,state):
next_[(i,c)].append(state)
if nc != "*":
lastnostar= state
else:
next_[(state,c)].append(state)
states, laststate= set([0]), state
for c in s:
states= {nextstate
for state in states
for symbol in (c,".")
if (state,symbol) in next_
for nextstate in next_[(state,symbol)]
}
if not states:
return False
return any(i in states for i in range(lastnostar,laststate+1))
|
regular-expression-matching
|
Use a FSM (finite-state machine) to find the solution (faster than 99%)
|
pknoe3lh
| 0 | 188 |
regular expression matching
| 10 | 0.282 |
Hard
| 443 |
https://leetcode.com/problems/regular-expression-matching/discuss/1149851/python-3-regex
|
class Solution:
def isMatch(self, s: str, p: str) -> bool:
import re
x=re.match(p,s)
if not x:
return False
if x.start()==0 and x.end()==len(s):
return True
return False
|
regular-expression-matching
|
python 3 regex
|
janhaviborde23
| 0 | 120 |
regular expression matching
| 10 | 0.282 |
Hard
| 444 |
https://leetcode.com/problems/regular-expression-matching/discuss/1173232/Could-this-be-the-shortest-python-solution
|
class Solution:
@lru_cache
def isMatch(self, s, p):
if not p: return not s
if p[-1] == '*':
return (self.isMatch(s, p[:-2])) or (s and (s[-1] == p[-2] or p[-2] == '.') and self.isMatch(s[:-1], p))
return s and (p[-1] == s[-1] or p[-1] == '.') and self.isMatch(s[:-1], p[:-1])
|
regular-expression-matching
|
Could this be the shortest python solution?
|
A88888
| -1 | 244 |
regular expression matching
| 10 | 0.282 |
Hard
| 445 |
https://leetcode.com/problems/container-with-most-water/discuss/1915108/Python3-GREEDY-TWO-POINTERS-~(~)-Explained
|
class Solution:
def maxArea(self, height: List[int]) -> int:
l, r, area = 0, len(height) - 1, 0
while l < r:
area = max(area, (r - l) * min(height[l], height[r]))
if height[l] < height[r]:
l += 1
else:
r -= 1
return area
|
container-with-most-water
|
✔️ [Python3] GREEDY TWO POINTERS ~(˘▾˘~), Explained
|
artod
| 133 | 9,600 |
container with most water
| 11 | 0.543 |
Medium
| 446 |
https://leetcode.com/problems/container-with-most-water/discuss/1038263/Python-Solution
|
class Solution:
def maxArea(self, height: List[int]) -> int:
l = 0
r = len(height)-1
res = 0
while l < r:
area = (r - l) * min(height[l], height[r])
res = max(area,res)
if height[l]<height[r]:
l = l+1
else:
r = r-1
return res
|
container-with-most-water
|
Python Solution
|
UttasargaSingh
| 18 | 3,000 |
container with most water
| 11 | 0.543 |
Medium
| 447 |
https://leetcode.com/problems/container-with-most-water/discuss/2803384/Python-or-Easy-Solution
|
class Solution:
def maxArea(self, height: List[int]) -> int:
maxx = 0
i = 0
j = len(height)-1
while i < j:
width = abs(i-j)
area = width * min(height[i],height[j])
maxx = max(area,maxx)
if height[i] > height[j]:
j -=1
else:
i +=1
return maxx
|
container-with-most-water
|
Python | Easy Solution✔
|
manayathgeorgejames
| 17 | 1,500 |
container with most water
| 11 | 0.543 |
Medium
| 448 |
https://leetcode.com/problems/container-with-most-water/discuss/1633791/python-fast-simple-faster-than-92
|
class Solution:
def maxArea(self, height: List[int]) -> int:
max_area, i, j = 0, 0, len(height)-1
while i != j:
if height[j] > height[i]:
area = height[i] * (j - i)
i += 1
else:
area = height[j] * (j - i)
j -= 1
max_area = max(max_area, area)
return max_area
|
container-with-most-water
|
python fast simple faster than 92%
|
fatmakahveci
| 6 | 485 |
container with most water
| 11 | 0.543 |
Medium
| 449 |
https://leetcode.com/problems/container-with-most-water/discuss/1296853/Python-solution
|
class Solution:
def maxArea(self, height: List[int]) -> int:
ret = 0
left, right = 0, len(height)-1
while left < right:
ret = max(ret, (right-left) * min(height[left], height[right]))
if height[left] < height[right]:
left += 1
else:
right -= 1
return ret
|
container-with-most-water
|
Python solution
|
5tigerjelly
| 5 | 310 |
container with most water
| 11 | 0.543 |
Medium
| 450 |
https://leetcode.com/problems/container-with-most-water/discuss/2716014/Python-Simple-Two-Pointer-Approach
|
class Solution:
def maxArea(self, height: List[int]) -> int:
l, r = 0, len(height)-1
res = 0
while l < r:
area = min(height[l], height[r]) * (r-l)
res = max(res, area)
if height[l] >= height[r]:
r -= 1
else:
l += 1
return res
|
container-with-most-water
|
Python Simple Two Pointer Approach
|
jonathanbrophy47
| 4 | 806 |
container with most water
| 11 | 0.543 |
Medium
| 451 |
https://leetcode.com/problems/container-with-most-water/discuss/1454052/Python3-two-pointers-solution
|
class Solution:
def maxArea(self, height: List[int]) -> int:
left, right = 0, len(height)-1
result = 0
while left < right:
result = max(result, min(height[left],height[right])*(right-left))
if height[left] < height[right]: left += 1
else: right -= 1
return result
|
container-with-most-water
|
Python3 two-pointers solution
|
Janetcxy
| 4 | 442 |
container with most water
| 11 | 0.543 |
Medium
| 452 |
https://leetcode.com/problems/container-with-most-water/discuss/330811/Simple-Python-3-Solution-Faster-than-99.8
|
class Solution:
def maxArea(self, height: List[int]) -> int:
h = height
A = 0
i, j = 0, len(h)-1
while j-i > 0:
if h[i] < h[j]:
a = (j-i)*h[i]
i += 1
else:
a = (j-i)*h[j]
j -= 1
if a > A:
A = a
return A
- Python 3
|
container-with-most-water
|
Simple Python 3 Solution - Faster than 99.8%
|
junaidmansuri
| 4 | 1,400 |
container with most water
| 11 | 0.543 |
Medium
| 453 |
https://leetcode.com/problems/container-with-most-water/discuss/2548410/Python-solution-using-two-pointers-and-current-max
|
class Solution:
def maxArea(self, height: List[int]) -> int:
l, r = 0, len(height)-1
cur_max = float('-inf')
while l < r:
cur_area = (r-l) * min(height[l], height[r])
cur_max = max(cur_max, cur_area)
if height[l] <= height[r]:
l+=1
else:
r-=1
return cur_max
|
container-with-most-water
|
📌 Python solution using two pointers and current max
|
croatoan
| 3 | 54 |
container with most water
| 11 | 0.543 |
Medium
| 454 |
https://leetcode.com/problems/container-with-most-water/discuss/2379254/Simple-and-easy-python3
|
class Solution:
def maxArea(self, height: List[int]) -> int:
res = 0
l, r = 0,len(height) - 1
while l < r:
res = max(res, min(height[l], height[r]) * (r - l))
if height[l] < height[r]:
l += 1
elif height[r] <= height[l]:
r -= 1
return res
|
container-with-most-water
|
Simple and easy python3
|
__Simamina__
| 3 | 136 |
container with most water
| 11 | 0.543 |
Medium
| 455 |
https://leetcode.com/problems/container-with-most-water/discuss/2332801/Easy-To-Understand-Python-Two-Pointers
|
class Solution:
def maxArea(self, height: List[int]) -> int:
area = 0
l,r= 0,len(height)-1
while l<r:
width_height = (r-l) * min(height[l],height[r]) #Compute the current area.
area = width_height if width_height > area else area #Compare area with previous computed area.
if height[l] < height[r] : #Close in the pointer depends on whichever one is shorter.
l+=1
else:
r-=1
return area
|
container-with-most-water
|
Easy To Understand Python Two Pointers
|
zhibin-wang09
| 3 | 169 |
container with most water
| 11 | 0.543 |
Medium
| 456 |
https://leetcode.com/problems/container-with-most-water/discuss/1923615/Easiest-and-most-efficient-python-solution
|
class Solution:
def maxArea(self, height: List[int]) -> int:
l,r=0,len(height)-1
ans=0
while l<r:
ans=max(ans,(r-l)*min(height[l],height[r]))
if height[l]<height[r]:
l+=1
else:
r-=1
return ans
|
container-with-most-water
|
Easiest and most efficient python solution
|
tkdhimanshusingh
| 3 | 163 |
container with most water
| 11 | 0.543 |
Medium
| 457 |
https://leetcode.com/problems/container-with-most-water/discuss/2798149/CJavaPython3JavaScript-Solution-(Faster-than-95-)
|
class Solution:
def maxArea(self, height: List[int]) -> int:
i = 0;
j = len(height)-1;
maxAmt = 0;
while(j>i):
iH = height[i];
jH = height[j];
if(iH>jH):
cal = jH*(j-i);
j-=1;
else:
cal = iH*(j-i);
i+=1;
if(cal>maxAmt):
maxAmt = cal;
return maxAmt;
|
container-with-most-water
|
👾C#,Java,Python3,JavaScript Solution (Faster than 95% )
|
HEWITT001
| 2 | 260 |
container with most water
| 11 | 0.543 |
Medium
| 458 |
https://leetcode.com/problems/container-with-most-water/discuss/2425738/Python-Beats-99-Faster-Solution-using-Two-Pointers-oror-Documented
|
class Solution:
def maxArea(self, height: List[int]) -> int:
l, r, = 0, len(height)-1 # two pointers to left and right
area = 0 # max area
# Repeat until the pointers left and right meet each other
while l < r:
minH = min(height[l], height[r]) # min-height
area = max(area, (r-l) * minH ) # area = distance * min-height
if height[l] < height[r]:
while height[l] <= minH and l < r:
l += 1 # forward left pointer
else:
while height[r] <= minH and l < r:
r -= 1 # backward right pointer
return area
|
container-with-most-water
|
[Python] Beats 99%, Faster Solution using Two Pointers || Documented
|
Buntynara
| 2 | 141 |
container with most water
| 11 | 0.543 |
Medium
| 459 |
https://leetcode.com/problems/container-with-most-water/discuss/1811148/Python-or-O(N)-or-2-pointers-or-with-comments
|
class Solution:
def maxArea(self, height: List[int]) -> int:
# 2 points one from left and one from right
# aim is to
left,right = 0,len(height)-1
mxArea = 0
while left<right:
# area is (distance between 2 heights) x (miminum among 2 heights)
mxArea = max(mxArea, min(height[left],height[right])*(right-left))
#keep moving either left or right till becomes a bigger height.
if height[left]>height[right]:
right-=1
else:
left+=1
return mxArea
# Time Complexity: O(N), Space Complexity: O(1)
|
container-with-most-water
|
Python | O(N) | 2 pointers | with comments
|
vishyarjun1991
| 2 | 237 |
container with most water
| 11 | 0.543 |
Medium
| 460 |
https://leetcode.com/problems/container-with-most-water/discuss/1069627/Python-or-Two-pointers-or-beats-99.7
|
class Solution:
def maxArea(self, height: List[int]) -> int:
l = m = 0
r = len(height)-1
while l<r:
if height[l]>height[r]:
a = height[r]*(r-l)
if a>m:
m = a
r -= 1
else:
a = height[l]*(r-l)
if a>m:
m = a
l += 1
return m
|
container-with-most-water
|
Python | Two pointers | beats 99.7 %
|
SlavaHerasymov
| 2 | 331 |
container with most water
| 11 | 0.543 |
Medium
| 461 |
https://leetcode.com/problems/container-with-most-water/discuss/990214/Two-pointer-python-Solution
|
class Solution:
def maxArea(self, height: List[int]) -> int:
water = []
right = 0
left = len(height) - 1
while (right < left):
water.append(min(height[right], height[left]) * (left - right))
if (height[right] < height[left]):
right += 1
else:
left -= 1
return max(water)
|
container-with-most-water
|
Two pointer python Solution
|
mintukrish
| 2 | 254 |
container with most water
| 11 | 0.543 |
Medium
| 462 |
https://leetcode.com/problems/container-with-most-water/discuss/2826971/Constructive-and-Intuitive-Solution-in-Linear-Time-The-Best
|
class Solution:
def maxArea(self, height: list[int]) -> int:
area_left_higher = self.max_area_when_left_higher(height)
height.reverse()
area_right_higher = self.max_area_when_left_higher(height)
return max(area_left_higher, area_right_higher)
def max_area_when_left_higher(self, height: list[int]) -> int:
max_area = 0
ascending_indexes, ascending_heights = [], []
ascending_height_max = -1
for right_index, right_height in enumerate(height):
if right_height > ascending_height_max:
ascending_height_max = right_height
ascending_indexes.append(right_index)
ascending_heights.append(right_height)
else:
left_index = ascending_indexes[bisect.bisect_left(ascending_heights, right_height)]
max_area = max(max_area, (right_index - left_index) * right_height)
return max_area
|
container-with-most-water
|
Constructive and Intuitive Solution in Linear Time, The Best
|
Triquetra
| 1 | 10 |
container with most water
| 11 | 0.543 |
Medium
| 463 |
https://leetcode.com/problems/container-with-most-water/discuss/2464001/Python3-solution(explained)
|
class Solution:
def maxArea(self, height: List[int]) -> int:
l, r = 0, len(height) - 1
res = 0
while l < r:
res = max(res, min(height[l], height[r]) * (r - l))
if height[l] < height[r]:
l += 1
elif height[r] <= height[l]:
r -= 1
return res
|
container-with-most-water
|
Python3 solution(explained)
|
__Simamina__
| 1 | 121 |
container with most water
| 11 | 0.543 |
Medium
| 464 |
https://leetcode.com/problems/container-with-most-water/discuss/2462266/Simple-python-solution-with-two-pointers
|
class Solution:
def maxArea(self, height: List[int]) -> int:
start = 0
end = len(height) - 1
res = 0
while start < end:
res = max(res, (end-start) * min(height[start], height[end]))
if height[start] <= height[end]:
start += 1
else:
end -= 1
return res
|
container-with-most-water
|
Simple python solution with two pointers
|
Gilbert770
| 1 | 130 |
container with most water
| 11 | 0.543 |
Medium
| 465 |
https://leetcode.com/problems/container-with-most-water/discuss/2436340/python-easy
|
class Solution:
def maxArea(self, height: List[int]) -> int:
l=0
r=len(height)-1
m=0
while l<r:
area=(r-l)*min(height[r],height[l])
m=max(area,m)
if(height[l] < height[r]):
l+=1
else:
r-=1
return m
|
container-with-most-water
|
python easy
|
samudralanithin
| 1 | 121 |
container with most water
| 11 | 0.543 |
Medium
| 466 |
https://leetcode.com/problems/container-with-most-water/discuss/2327827/Python3-Time%3A-O(N)-Space%3A-O(1)-Two-Pointers
|
class Solution:
def maxArea(self, height: List[int]) -> int:
maxArea=0
l=0
r=len(height)-1
while l<r:
area=(r-l)*min(height[r],height[l])
maxArea=max(maxArea,area)
if height[r]>height[l]:
l+=1
else:
r-=1
return maxArea
|
container-with-most-water
|
Python3 Time: O(N) Space: O(1) Two Pointers
|
Simon-Huang-1
| 1 | 80 |
container with most water
| 11 | 0.543 |
Medium
| 467 |
https://leetcode.com/problems/container-with-most-water/discuss/2324493/Python-3-oror-O(n)-Efficient-Solution
|
class Solution:
def maxArea(self, height: List[int]) -> int:
left, right, result = 0, len(height) - 1, 0
while left != right:
result = max(result, min(height[left], height[right]) * (right - left))
if height[left] < height[right]: left += 1
else: right -= 1
return result
|
container-with-most-water
|
Python 3 || O(n) Efficient Solution
|
sagarhasan273
| 1 | 61 |
container with most water
| 11 | 0.543 |
Medium
| 468 |
https://leetcode.com/problems/container-with-most-water/discuss/2288302/Easy-Python-solution
|
class Solution:
def maxArea(self, height: List[int]) -> int:
l=0
r=len(height)-1
max_area = min(height[l],height[r])*(r-l)
while r > l:
if height[l] > height[r]:
r-= 1
else:
l += 1
max_area = max(max_area,min(height[l],height[r])*(r-l) )
return max_area
|
container-with-most-water
|
Easy Python solution
|
sunakshi132
| 1 | 96 |
container with most water
| 11 | 0.543 |
Medium
| 469 |
https://leetcode.com/problems/container-with-most-water/discuss/2230240/Python-Simple-Python-Solution
|
class Solution:
def maxArea(self, height: List[int]) -> int:
i=0
j=len(height)-1
maxheight=0
while i<j:
area = (j-i)*(min(height[i],height[j]))
maxheight = max(maxheight,area)
if height[i]<height[j]:
i+=1
else:
j-=1
return maxheight
|
container-with-most-water
|
[ Python ] ✅ Simple Python Solution ✅✅
|
vaibhav0077
| 1 | 153 |
container with most water
| 11 | 0.543 |
Medium
| 470 |
https://leetcode.com/problems/container-with-most-water/discuss/2142920/Python-easy
|
class Solution:
def maxArea(self, height: List[int]) -> int:
i,j = 0,len(height)-1
final_area = 0
while i<j:
curr_area = (j-i) * min(height[i],height[j])
final_area = curr_area if curr_area>final_area else final_area
if height[i]<height[j]:
i += 1
else:
j -= 1
return final_area
|
container-with-most-water
|
Python easy
|
NiketaM
| 1 | 150 |
container with most water
| 11 | 0.543 |
Medium
| 471 |
https://leetcode.com/problems/container-with-most-water/discuss/1984560/Two-pointer-solution-or-O(n)
|
class Solution:
def maxArea(self, height: List[int]) -> int:
res = 0
l, r = 0, len(height) - 1
while l < r:
area = (r - l) * min(height[r], height[l])
res = max(res, area)
if height[l] < height[r]:
l += 1
else:
r -= 1
return res
|
container-with-most-water
|
Two pointer solution | O(n)
|
nikhitamore
| 1 | 121 |
container with most water
| 11 | 0.543 |
Medium
| 472 |
https://leetcode.com/problems/container-with-most-water/discuss/1913586/Python-Two-Pointer-O(n)
|
class Solution:
def maxArea(self, height: List[int]) -> int:
max_area = 0
left, right = 0, len(height) - 1
while left < right:
current_area = (right - left) * min(height[left], height[right])
max_area = max(current_area, max_area)
if height[left] < height[right]:
left += 1
elif height[left] > height[right]:
right -= 1
else:
left += 1
right -= 1
return max_area
|
container-with-most-water
|
Python Two-Pointer O(n)
|
doubleimpostor
| 1 | 104 |
container with most water
| 11 | 0.543 |
Medium
| 473 |
https://leetcode.com/problems/container-with-most-water/discuss/1861428/Python-or-6-lines
|
class Solution:
def maxArea(self, height: List[int]) -> int:
hi, lo, maxArea = len(height)-1, 0, 0
while lo < hi:
maxArea = max(maxArea, (hi-lo) * min(height[lo], height[hi]))
if height[lo] < height[hi]: lo += 1
else: hi -= 1
return maxArea
|
container-with-most-water
|
✅ Python | 6 lines
|
dhananjay79
| 1 | 149 |
container with most water
| 11 | 0.543 |
Medium
| 474 |
https://leetcode.com/problems/container-with-most-water/discuss/1861428/Python-or-6-lines
|
class Solution:
def maxArea(self, height: List[int]) -> int:
def maxArea(lo,hi,maxi):
if lo >= hi: return maxi
if height[lo] < height[hi]:
return maxArea(lo+1, hi, max(maxi, height[lo] * (hi-lo)))
return maxArea(lo, hi-1, max(maxi, height[hi] * (hi-lo)))
return maxArea(0, len(height)-1, 0)
|
container-with-most-water
|
✅ Python | 6 lines
|
dhananjay79
| 1 | 149 |
container with most water
| 11 | 0.543 |
Medium
| 475 |
https://leetcode.com/problems/container-with-most-water/discuss/1772015/Fast-and-simple-python-solution
|
class Solution:
def maxArea(self, height: List[int]) -> int:
l, r = 0, len(height) - 1
maxarea = 0
while l < r:
height_l, height_r = height[l], height[r]
if height_l <= height_r:
maxarea = max(maxarea, (r - l) * height_l)
while height_l >= height[l] and l < r: l += 1
else:
maxarea = max(maxarea, (r - l) * height_r)
while height_r >= height[r] and l < r: r -= 1
return maxarea
|
container-with-most-water
|
Fast and simple python solution
|
xuauul
| 1 | 134 |
container with most water
| 11 | 0.543 |
Medium
| 476 |
https://leetcode.com/problems/container-with-most-water/discuss/1629497/Python-3-start-and-end-pointer-(my-first-solution)
|
class Solution:
def maxArea(self, height: List[int]) -> int:
retArea = 0
start = 0
end = len(height)-1
while(start != end):
if(height[start] < height[end]):
retArea = max(retArea,height[start] * (end - start))
start +=1
else:
retArea = max(retArea,height[end] * (end - start))
end -=1
return retArea
|
container-with-most-water
|
Python 3, start and end pointer (my first solution)
|
vinija
| 1 | 109 |
container with most water
| 11 | 0.543 |
Medium
| 477 |
https://leetcode.com/problems/container-with-most-water/discuss/1531999/Py3Py-Two-pointer-solution-w-comments
|
class Solution:
def maxArea(self, height: List[int]) -> int:
# Init
area = -inf
i = 0
j = len(height)-1
# Two pointer solution
while i < j:
# Calc breath
breath = j-i
# Keep track of max length
if height[i] < height[j]:
length = height[i]
i += 1
else:
length = height[j]
j -= 1
# Calc area
area = max(area, breath * length)
return area
|
container-with-most-water
|
[Py3/Py] Two pointer solution w/ comments
|
ssshukla26
| 1 | 233 |
container with most water
| 11 | 0.543 |
Medium
| 478 |
https://leetcode.com/problems/container-with-most-water/discuss/1343946/Python-oror-Two-pointer-oror-O(N)
|
class Solution:
def maxArea(self, heights: List[int]) -> int:
gap = len(heights)-1
left = 0; right = len(heights)-1
maxx = 0
while left < right:
maxx = max(maxx, gap*min(heights[left], heights[right]))
if heights[left] <= heights[right]: left += 1
else: right -= 1
gap -= 1
return maxx
|
container-with-most-water
|
Python || Two pointer || O(N)
|
airksh
| 1 | 98 |
container with most water
| 11 | 0.543 |
Medium
| 479 |
https://leetcode.com/problems/container-with-most-water/discuss/1264294/Explained-Python-Attack-Both-Ways
|
class Solution(object):
def maxArea(self, height):
left = 0
right = len(height)-1
max_area = 0
while left<right:
max_area = max(min(height[left],height[right]) * (right-left),max_area)
if height[left]<height[right]:
left+=1
else:
right-=1
return max_area
|
container-with-most-water
|
[Explained] Python — Attack Both Ways
|
akashadhikari
| 1 | 236 |
container with most water
| 11 | 0.543 |
Medium
| 480 |
https://leetcode.com/problems/container-with-most-water/discuss/794967/Python-3-commented
|
class Solution:
def maxArea(self, h: List[int]) -> int:
# Maximum Volume
m = 0
# Left Index
l = 0
# Right Index
r = len(h) - 1
while l != r:
# Volume is height of lowest wall times distance between walls
v = min(h[l], h[r]) * (r - l)
# If volume is bigger than current maximum, save new max
if v > m:
m = v
# Keep highest wall and move the other end towards it
if h[l] > h[r]:
r -= 1
else:
l += 1
return m
|
container-with-most-water
|
Python 3 commented
|
denisrasulev
| 1 | 96 |
container with most water
| 11 | 0.543 |
Medium
| 481 |
https://leetcode.com/problems/container-with-most-water/discuss/506120/Python-Faster-than-95-simple-solution
|
class Solution:
def maxArea(self, height: List[int]) -> int:
i = 0
j = len(height) - 1
mx = 0
while i < j:
area = min(height[i], height[j]) * (j-i)
mx = max(mx, area)
if (height[i] < height[j]):
l = height[i]
while (height[i+1] < l) and (i < j):
i += 1
else:
i += 1
else:
r = height[j]
while (height[j-1] < r) and (i < j):
j -= 1
else:
j -= 1
return mx
|
container-with-most-water
|
Python - Faster than 95% - simple solution
|
frankv55
| 1 | 223 |
container with most water
| 11 | 0.543 |
Medium
| 482 |
https://leetcode.com/problems/container-with-most-water/discuss/407454/Python3-%3A-148-ms-faster-than-52.60
|
class Solution:
def maxArea(self, height: List[int]) -> int:
head_ = 0
tail_ = len(height)-1
area = 0
while( head_ < tail_ ):
area = max(area, ((tail_-head_)*min(height[tail_], height[head_])))
if height[head_] <= height[tail_]:
head_ += 1
else:
tail_ -= 1
return area
|
container-with-most-water
|
Python3 : 148 ms, faster than 52.60%
|
rnnnnn
| 1 | 190 |
container with most water
| 11 | 0.543 |
Medium
| 483 |
https://leetcode.com/problems/container-with-most-water/discuss/2847080/PYTHON-MAD-EASY-100-ON-GOD
|
class Solution:
def maxArea(self, height: List[int]) -> int:
left = 0
right = len(height)-1
res = 0
while right > left:
a = (right-left)*min(height[right],height[left])
res = a if a > res else res
if height[left] > height[right]:
right -= 1
else:
left += 1
return res
|
container-with-most-water
|
[PYTHON] MAD EASY 100% ON GOD
|
omkarxpatel
| 0 | 2 |
container with most water
| 11 | 0.543 |
Medium
| 484 |
https://leetcode.com/problems/container-with-most-water/discuss/2838263/Python-or-Two-Pointer-or-Comments
|
class Solution:
def maxArea(self, height: List[int]) -> int:
left, right = 0, len(height)-1
max_area = 0
while left < right: # < because left can't equal right or else it can't trap water
length = right - left # the length in length * height = area
height_ = min(height[left], height[right]) # we take the minimum because it would overflow above the min
current_area = length * height_
max_area = max(max_area, current_area)
if height[left] > height[right]: # move the lesser pointer because we're trying to find MAX
right -= 1
else: # if right <= left
left += 1
return max_area
|
container-with-most-water
|
🎉Python | Two Pointer | Comments
|
Arellano-Jann
| 0 | 2 |
container with most water
| 11 | 0.543 |
Medium
| 485 |
https://leetcode.com/problems/container-with-most-water/discuss/2836014/EASY-solution-Python
|
class Solution:
def maxArea(self, height: List[int]) -> int:
l, r, area = 0, len(height) - 1, 0
while l<r:
area = max(area, (r-l)*min(height[l],height[r]))
if height[l]<height[r]:
l+=1
else:
r-=1
return area
|
container-with-most-water
|
EASY solution Python
|
atyantjain2
| 0 | 3 |
container with most water
| 11 | 0.543 |
Medium
| 486 |
https://leetcode.com/problems/container-with-most-water/discuss/2834495/Simple-python-solution
|
class Solution:
def maxArea(self, height: List[int]) -> int:
left = 0
right = len(height) -1
curMax = 0
while left < right:
curVal= min(height[left],height[right]) * (right - left)
curMax = max(curVal,curMax)
if(height[left] > height[right]):
right-=1
else:
left+=1
return curMax
|
container-with-most-water
|
Simple python solution
|
btulsi
| 0 | 2 |
container with most water
| 11 | 0.543 |
Medium
| 487 |
https://leetcode.com/problems/container-with-most-water/discuss/2822097/Simple-Python-implementation-using-two-pointers-approach
|
class Solution:
def maxArea(self, height: List[int]) -> int:
start, end = 0, len(height)-1
area = 0
llist = []
maxx = 0
while start < end:
width = abs(start - end )
area = min( height[start], height[end] )*width
maxx = max(area, maxx)
#llist.append(area)
if height[start] > height[end]:
end -= 1
else:
start += 1
return maxx
|
container-with-most-water
|
Simple Python implementation using two pointers approach
|
rahul-tiwari-95
| 0 | 3 |
container with most water
| 11 | 0.543 |
Medium
| 488 |
https://leetcode.com/problems/container-with-most-water/discuss/2820193/Dynamic-programming-beats-99.69-memory-usage
|
class Solution:
def maxArea(self, height: List[int]) -> int:
i = v = 0
j = l = len(height) - 1
while i < j:
if v < l*min(height[i], height[j]):
v = l*min(height[i], height[j])
if height[i] < height[j]:
i += 1
else:
j -= 1
l -= 1
return v
|
container-with-most-water
|
Dynamic programming beats 99.69% memory usage
|
Molot84
| 0 | 4 |
container with most water
| 11 | 0.543 |
Medium
| 489 |
https://leetcode.com/problems/container-with-most-water/discuss/2815851/Easy-Python-Solution-w-intuition
|
class Solution:
def maxArea(self, height: List[int]) -> int:
l, r = 0, len(height)-1
max_area = 0
while l < r:
area = min(height[l], height[r])*(r-l)
if area > max_area:
max_area = area
if height[l] > height[r]:
r -=1
else:
l += 1
return max_area
|
container-with-most-water
|
Easy Python Solution w/ intuition
|
emilyyijack
| 0 | 4 |
container with most water
| 11 | 0.543 |
Medium
| 490 |
https://leetcode.com/problems/container-with-most-water/discuss/2815182/Streamlined-Two-Pointers-Python
|
class Solution:
def maxArea(self, height: List[int]) -> int:
w, L, R = 0, 0, len(height) - 1
while L < R:
w = max(w, (R - L) * min(height[R], height[L]))
L, R = (L + 1, R) if height[L] < height[R] else (L, R - 1)
return w
|
container-with-most-water
|
Streamlined Two Pointers [Python]
|
constantstranger
| 0 | 5 |
container with most water
| 11 | 0.543 |
Medium
| 491 |
https://leetcode.com/problems/container-with-most-water/discuss/2815176/Two-Pointers-Approach%3A-Easy-Explanation-Python
|
class Solution:
def maxArea(self, height: List[int]) -> int:
leftPointer = 0
rightPointer = len(height) - 1
maxArea = (rightPointer - leftPointer)*min(height[leftPointer],height[rightPointer])
while leftPointer < rightPointer:
currHeightL = height[leftPointer]
currHeightR = height[rightPointer]
maxArea = max(maxArea,(rightPointer - leftPointer)*min(currHeightL,currHeightR))
if currHeightL < currHeightR:
leftPointer += 1
else:
rightPointer -= 1
return maxArea
|
container-with-most-water
|
Two Pointers Approach: Easy Explanation Python
|
kenanR
| 0 | 2 |
container with most water
| 11 | 0.543 |
Medium
| 492 |
https://leetcode.com/problems/container-with-most-water/discuss/2808291/SimpleandClearandOrdinary
|
class Solution:
def maxArea(self, height: List[int]) -> int:
firstIndex = 0
lastIndex = len(height)-1
Max = 0
while firstIndex < lastIndex:
first, last = height[firstIndex], height[lastIndex]
temp = (lastIndex - firstIndex)*min(first, last)
if Max < temp:
Max = temp
if last <= first:
lastIndex = lastIndex -1
else:
firstIndex = firstIndex + 1
return Max
|
container-with-most-water
|
Simple&Clear&Ordinary
|
Digger_
| 0 | 3 |
container with most water
| 11 | 0.543 |
Medium
| 493 |
https://leetcode.com/problems/container-with-most-water/discuss/2805709/Python3-two-pointer-O(N)-Solution
|
class Solution:
def maxArea(self, height: List[int]) -> int:
areaMax=0
l,r=0,len(height)-1
while l<r:
area=(r-l) * min(height[l],height[r])
areaMax=max(areaMax,area)
if height[l]<=height[r]:
l+=1
else:
r-=1
return areaMax
|
container-with-most-water
|
Python3 two pointer O(N) Solution
|
nachikethkc
| 0 | 2 |
container with most water
| 11 | 0.543 |
Medium
| 494 |
https://leetcode.com/problems/container-with-most-water/discuss/2803006/Python-3-solution-using-two-pointers
|
class Solution:
def maxArea(self, height: List[int]) -> int:
"""Uses two pointers.
Left pointer starts with 0th index and
Right pointer starts at last index.
Calculate the area and update if greater than
area variable.
If heigh[right] is greater than heigh[left], increment
left, otherwise decrement right.
"""
area = 0
left = 0
right = len(height) -1
while left < right:
side = min(height[left], height[right])
width = right - left
area = max(side * width, area)
if height[right] > height[left]:
left += 1
else:
right -= 1
return area
|
container-with-most-water
|
Python 3 solution using two pointers
|
ankitjaiswal07
| 0 | 4 |
container with most water
| 11 | 0.543 |
Medium
| 495 |
https://leetcode.com/problems/integer-to-roman/discuss/2724200/Python's-Simple-and-Easy-to-Understand-Solution-or-99-Faster
|
class Solution:
def intToRoman(self, num: int) -> str:
# Creating Dictionary for Lookup
num_map = {
1: "I",
5: "V", 4: "IV",
10: "X", 9: "IX",
50: "L", 40: "XL",
100: "C", 90: "XC",
500: "D", 400: "CD",
1000: "M", 900: "CM",
}
# Result Variable
r = ''
for n in [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]:
# If n in list then add the roman value to result variable
while n <= num:
r += num_map[n]
num-=n
return r
|
integer-to-roman
|
✔️ Python's Simple and Easy to Understand Solution | 99% Faster 🔥
|
pniraj657
| 53 | 2,600 |
integer to roman
| 12 | 0.615 |
Medium
| 496 |
https://leetcode.com/problems/integer-to-roman/discuss/2723880/Fastest-Python-solution-using-mapping
|
class Solution:
def intToRoman(self, num: int) -> str:
i=1
dic={1:'I',5:'V',10:'X',50:'L',100:'C',500:'D',1000:'M'}
s=""
while num!=0:
y=num%pow(10,i)//pow(10,i-1)
if y==5:
s=dic[y*pow(10,i-1)]+s
elif y==1:
s=dic[y*pow(10,i-1)]+s
elif y==4:
s=dic[1*pow(10,i-1)]+dic[5*pow(10,i-1)]+s
elif y==9:
s=dic[1*pow(10,i-1)]+dic[1*pow(10,i)]+s
elif y<4:
s=dic[pow(10,i-1)]*y+s
elif y>5 and y<9:
y-=5
s=dic[5*pow(10,i-1)]+dic[pow(10,i-1)]*y+s
num=num//pow(10,i)
num*=pow(10,i)
i+=1
return s
|
integer-to-roman
|
Fastest Python solution using mapping
|
shubham_1307
| 16 | 2,400 |
integer to roman
| 12 | 0.615 |
Medium
| 497 |
https://leetcode.com/problems/integer-to-roman/discuss/1102756/Python-Stack-Solution
|
class Solution:
def intToRoman(self, num: int) -> str:
dct = {1: 'I', 4: 'IV', 5: 'V', 9: 'IX', 10: 'X', 40: 'XL', 50: 'L', 90: 'XC', 100: 'C', 400: 'CD', 500: 'D', 900: 'CM', 1000: 'M'}
stack = [1, 4, 5, 9, 10, 40, 50, 90, 100, 400, 500, 900, 1000]
ans = []
while num > 0:
if stack[-1] > num:
stack.pop()
else:
num -= stack[-1]
ans.append(dct[stack[-1]])
return "".join(map(str, ans))
|
integer-to-roman
|
Python Stack Solution
|
mariandanaila01
| 11 | 1,000 |
integer to roman
| 12 | 0.615 |
Medium
| 498 |
https://leetcode.com/problems/integer-to-roman/discuss/389377/Easy-to-understand-python3
|
class Solution:
def intToRoman(self, num: int) -> str:
mapping = {
1: "I",
4: "IV",
5: "V",
9: "IX",
10: "X",
40: "XL",
50: "L",
90: "XC",
100: "C",
400: "CD",
500: "D",
900: "CM",
1000: "M",
}
arr = [1000,900,500,400,100,90,50,40,10,9,5,4,1]
result = ""
for a in arr:
while num >= a:
num = num - a
result = result + mapping[a]
return result
|
integer-to-roman
|
Easy to understand python3
|
WhiteSeraph
| 8 | 591 |
integer to roman
| 12 | 0.615 |
Medium
| 499 |
Subsets and Splits
Top 2 Solutions by Upvotes
Identifies the top 2 highest upvoted Python solutions for each problem, providing insight into popular approaches.