problem_title stringlengths 3 77 | python_solutions stringlengths 81 8.45k | post_href stringlengths 64 213 | upvotes int64 0 1.2k | question stringlengths 0 3.6k | post_title stringlengths 2 100 | views int64 1 60.9k | slug stringlengths 3 77 | acceptance float64 0.14 0.91 | user stringlengths 3 26 | difficulty stringclasses 3
values | __index_level_0__ int64 0 34k | number int64 1 2.48k |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
longest palindromic subsequence | class Solution:
def longestPalindromeSubseq(self, s: str) -> int:
return self.get_longest_subseq(0, len(s)-1, s)
def get_longest_subseq(self, start, end, s):
"""
method used to find the longest palindrome subsequence in a string
start: start index of the string
... | https://leetcode.com/problems/longest-palindromic-subsequence/discuss/1968323/Python-3-Approaches-(Recursion-%2B-Memoization-%2B-DP) | 6 | Given a string s, find the longest palindromic subsequence's length in s.
A subsequence is a sequence that can be derived from another sequence by deleting some or no elements without changing the order of the remaining elements.
Example 1:
Input: s = "bbbab"
Output: 4
Explanation: One possible longest palindromic su... | Python - 3 Approaches (Recursion + Memoization + DP) | 225 | longest-palindromic-subsequence | 0.607 | superGloria | Medium | 9,070 | 516 |
super washing machines | class Solution:
def findMinMoves(self, machines: List[int]) -> int:
total = sum(machines)
if total % len(machines): return -1 # impossible
avg = total // len(machines)
ans = prefix = 0
for i, x in enumerate(machines):
ans = max(ans, abs(prefix), x - avg... | https://leetcode.com/problems/super-washing-machines/discuss/1494245/Python3-greedy | 1 | You have n super washing machines on a line. Initially, each washing machine has some dresses or is empty.
For each move, you could choose any m (1 <= m <= n) washing machines, and pass one dress of each washing machine to one of its adjacent washing machines at the same time.
Given an integer array machines representi... | [Python3] greedy | 138 | super-washing-machines | 0.401 | ye15 | Hard | 9,099 | 517 |
coin change ii | class Solution:
def change(self, amount: int, coins: List[int]) -> int:
dp = [[1]+[0]*amount for _ in range(len(coins)+1)]
for i in range(1, len(coins)+1):
for j in range(1, amount+1):
if coins[i-1] <= j:
dp[i][j] = dp[i-1][j] + dp[i][j-coins[i-1]]
... | https://leetcode.com/problems/coin-change-ii/discuss/675186/Python3-DP-Solution-O(mn)-Time-and-Space | 9 | You are given an integer array coins representing coins of different denominations and an integer amount representing a total amount of money.
Return the number of combinations that make up that amount. If that amount of money cannot be made up by any combination of the coins, return 0.
You may assume that you have an ... | Python3 DP Solution - O(mn) Time and Space | 1,200 | coin-change-ii | 0.599 | schedutron | Medium | 9,100 | 518 |
random flip matrix | class Solution:
def __init__(self, m: int, n: int):
self.nums = m * n - 1
self.cols = n
self.flipped = set()
def flip(self) -> List[int]:
rc = random.randint(0, self.nums)
while rc in self.flipped:
rc = random.randint(0, self.nums)
... | https://leetcode.com/problems/random-flip-matrix/discuss/2108517/Python3Three-solutions-with-detailed-explanation. | 0 | There is an m x n binary grid matrix with all the values set 0 initially. Design an algorithm to randomly pick an index (i, j) where matrix[i][j] == 0 and flips it to 1. All the indices (i, j) where matrix[i][j] == 0 should be equally likely to be returned.
Optimize your algorithm to minimize the number of calls made t... | [Python3]Three solutions with detailed explanation. | 55 | random-flip-matrix | 0.399 | AlainWong | Medium | 9,144 | 519 |
detect capital | class Solution:
def detectCapitalUse(self, word: str) -> bool:
return word in [word.upper(), word.lower(), word.title()]
- Python 3
- Junaid Mansuri | https://leetcode.com/problems/detect-capital/discuss/336441/Solution-in-Python-3-(one-line) | 6 | We define the usage of capitals in a word to be right when one of the following cases holds:
All letters in this word are capitals, like "USA".
All letters in this word are not capitals, like "leetcode".
Only the first letter in this word is capital, like "Google".
Given a string word, return true if the usage of capit... | Solution in Python 3 (one line) | 541 | detect-capital | 0.555 | junaidmansuri | Easy | 9,147 | 520 |
longest uncommon subsequence i | class Solution:
def findLUSlength(self, a: str, b: str) -> int:
if a==b:return -1
else:return max(len(a),len(b)) | https://leetcode.com/problems/longest-uncommon-subsequence-i/discuss/1277607/python-two-lines-or-easy | 4 | Given two strings a and b, return the length of the longest uncommon subsequence between a and b. If no such uncommon subsequence exists, return -1.
An uncommon subsequence between two strings is a string that is a
subsequence
of exactly one of them.
Example 1:
Input: a = "aba", b = "cdc"
Output: 3
Explanation: One l... | python two lines | easy | 314 | longest-uncommon-subsequence-i | 0.603 | chikushen99 | Easy | 9,194 | 521 |
longest uncommon subsequence ii | class Solution:
def findLUSlength(self, S: List[str]) -> int:
C = collections.Counter(S)
S = sorted(C.keys(), key = len, reverse = True)
for i,s in enumerate(S):
if C[s] != 1: continue
b = True
for j in range(i):
I, c = -1, True
for i in s:
I = S[j].find(i,I+1)... | https://leetcode.com/problems/longest-uncommon-subsequence-ii/discuss/380412/Solution-in-Python-3-(beats-~100) | 2 | Given an array of strings strs, return the length of the longest uncommon subsequence between them. If the longest uncommon subsequence does not exist, return -1.
An uncommon subsequence between an array of strings is a string that is a subsequence of one string but not the others.
A subsequence of a string s is a stri... | Solution in Python 3 (beats ~100%) | 648 | longest-uncommon-subsequence-ii | 0.404 | junaidmansuri | Medium | 9,209 | 522 |
continuous subarray sum | class Solution:
def checkSubarraySum(self, nums: List[int], k: int) -> bool:
# Brute Force: O(𝑛^2) - TLE
count = 0
for i in range(len(nums)):
sum = 0
for j in range(i, len(nums)):
sum += nums[j]
if sum % k == 0:
return True
return False
class Solution:
def checkSubarraySum(self, nums: L... | https://leetcode.com/problems/continuous-subarray-sum/discuss/1582670/Python-Easy-Solution-or-Brute-Force-and-Optimal-Approach | 5 | Given an integer array nums and an integer k, return true if nums has a good subarray or false otherwise.
A good subarray is a subarray where:
its length is at least two, and
the sum of the elements of the subarray is a multiple of k.
Note that:
A subarray is a contiguous part of the array.
An integer x is a multiple o... | Python Easy Solution | Brute Force and Optimal Approach | 603 | continuous-subarray-sum | 0.285 | leet_satyam | Medium | 9,213 | 523 |
longest word in dictionary through deleting | class Solution:
def findLongestWord(self, s: str, d: List[str]) -> str:
def is_subseq(main: str, sub: str) -> bool:
i, j, m, n = 0, 0, len(main), len(sub)
while i < m and j < n and n - j >= m - i:
if main[i] == sub[j]:
i += 1
j += 1... | https://leetcode.com/problems/longest-word-in-dictionary-through-deleting/discuss/1077760/Python.-very-clear-and-simplistic-solution. | 6 | Given a string s and a string array dictionary, return the longest string in the dictionary that can be formed by deleting some of the given string characters. If there is more than one possible result, return the longest word with the smallest lexicographical order. If there is no possible result, return the empty str... | Python. very clear and simplistic solution. | 879 | longest-word-in-dictionary-through-deleting | 0.512 | m-d-f | Medium | 9,254 | 524 |
contiguous array | class Solution:
def findMaxLength(self, nums: List[int]) -> int:
partial_sum = 0
# table is a dictionary
# key : partial sum value
# value : the left-most index who has the partial sum value
table = { 0: -1}
max_length = 0
for idx, number in enume... | https://leetcode.com/problems/contiguous-array/discuss/577489/Python-O(n)-by-partial-sum-and-dictionary.-90%2B-w-Visualization | 12 | Given a binary array nums, return the maximum length of a contiguous subarray with an equal number of 0 and 1.
Example 1:
Input: nums = [0,1]
Output: 2
Explanation: [0, 1] is the longest contiguous subarray with an equal number of 0 and 1.
Example 2:
Input: nums = [0,1,0]
Output: 2
Explanation: [0, 1] (or [1, 0]) is ... | Python O(n) by partial sum and dictionary. 90%+ [w/ Visualization] | 1,700 | contiguous-array | 0.468 | brianchiang_tw | Medium | 9,274 | 525 |
beautiful arrangement | class Solution:
def countArrangement(self, n: int) -> int:
self.count = 0
self.backtrack(n, 1, [])
return self.count
def backtrack(self, N, idx, temp):
if len(temp) == N:
self.count += 1
return
for i in range(1, N+1):
... | https://leetcode.com/problems/beautiful-arrangement/discuss/1094146/Python-Backtracking-the-more-intuitive-way | 8 | Suppose you have n integers labeled 1 through n. A permutation of those n integers perm (1-indexed) is considered a beautiful arrangement if for every i (1 <= i <= n), either of the following is true:
perm[i] is divisible by i.
i is divisible by perm[i].
Given an integer n, return the number of the beautiful arrangemen... | Python Backtracking, the more intuitive way | 872 | beautiful-arrangement | 0.646 | IamCookie | Medium | 9,297 | 526 |
random pick with weight | class Solution:
def __init__(self, w: List[int]):
self.li = []
ma = sum(w)
for i, weight in enumerate(w):
ratio = ceil(weight / ma * 100)
self.li += ([i] * ratio)
def pickIndex(self) -> int:
return random.choice(self.li) | https://leetcode.com/problems/random-pick-with-weight/discuss/1535699/Better-than-96.5 | 8 | You are given a 0-indexed array of positive integers w where w[i] describes the weight of the ith index.
You need to implement the function pickIndex(), which randomly picks an index in the range [0, w.length - 1] (inclusive) and returns it. The probability of picking an index i is w[i] / sum(w).
For example, if w = [1... | Better than 96.5% | 815 | random-pick-with-weight | 0.461 | josephp27 | Medium | 9,315 | 528 |
minesweeper | class Solution:
def updateBoard(self, board: List[List[str]], click: List[int]) -> List[List[str]]:
m, n = len(board), len(board[0])
def dfs(x, y):
if board[x][y] == 'M': board[x][y] = 'X'
elif board[x][y] == 'E':
cnt, nei = 0, []
for i, j in m... | https://leetcode.com/problems/minesweeper/discuss/875335/Python-3-or-Ad-hoc-DFS-or-Explanation | 5 | Let's play the minesweeper game (Wikipedia, online game)!
You are given an m x n char matrix board representing the game board where:
'M' represents an unrevealed mine,
'E' represents an unrevealed empty square,
'B' represents a revealed blank square that has no adjacent mines (i.e., above, below, left, right, and all ... | Python 3 | Ad-hoc DFS | Explanation | 743 | minesweeper | 0.655 | idontknoooo | Medium | 9,331 | 529 |
minimum absolute difference in bst | class Solution:
def getMinimumDifference(self, root: Optional[TreeNode]) -> int:
d = float('inf')
s = []
if root == None:
return
d = self.traverse(root,d,s)
return d
def traverse(self,root,d,s):
if root.left != None:
d = self.traverse(root... | https://leetcode.com/problems/minimum-absolute-difference-in-bst/discuss/1414654/Faster-than-99.61-of-Python3-with-logical-explanation | 4 | Given the root of a Binary Search Tree (BST), return the minimum absolute difference between the values of any two different nodes in the tree.
Example 1:
Input: root = [4,2,6,1,3]
Output: 1
Example 2:
Input: root = [1,0,48,null,null,12,49]
Output: 1
Constraints:
The number of nodes in the tree is in the range [2, ... | Faster than 99.61% of Python3 with logical explanation | 786 | minimum-absolute-difference-in-bst | 0.568 | iron_man_365 | Easy | 9,349 | 530 |
k diff pairs in an array | class Solution:
def findPairs(self, nums: List[int], k: int) -> int:
cnt=0
c=Counter(nums)
if k==0:
for key,v in c.items():
if v>1:
cnt+=1
else:
for key,v in c.items():
if key+k in c:
... | https://leetcode.com/problems/k-diff-pairs-in-an-array/discuss/1757434/Python-O(n)-Solution-or-98-Faster-or-Easy-Solution-or-K-diff-Pairs-in-an-Array | 34 | Given an array of integers nums and an integer k, return the number of unique k-diff pairs in the array.
A k-diff pair is an integer pair (nums[i], nums[j]), where the following are true:
0 <= i, j < nums.length
i != j
|nums[i] - nums[j]| == k
Notice that |val| denotes the absolute value of val.
Example 1:
Input: num... | ✔️ Python O(n) Solution | 98% Faster | Easy Solution | K-diff Pairs in an Array | 2,200 | k-diff-pairs-in-an-array | 0.408 | pniraj657 | Medium | 9,362 | 532 |
complex number multiplication | class Solution:
def complexNumberMultiply(self, num1: str, num2: str) -> str:
a1,b1 = num1.split('+')
a1 = int(a1)
b1 = int(b1[:-1])
a2,b2 = num2.split('+')
a2 = int(a2)
b2 = int(b2[:-1])
return str(a1*a2 + b1*b2*(-1)) + '+' + str(a1*b2 + a2*b1) + 'i' | https://leetcode.com/problems/complex-number-multiplication/discuss/1187864/Python3-simple-solution | 7 | A complex number can be represented as a string on the form "real+imaginaryi" where:
real is the real part and is an integer in the range [-100, 100].
imaginary is the imaginary part and is an integer in the range [-100, 100].
i2 == -1.
Given two complex numbers num1 and num2 as strings, return a string of the complex ... | Python3 simple solution | 113 | complex-number-multiplication | 0.714 | EklavyaJoshi | Medium | 9,384 | 537 |
convert bst to greater tree | class Solution:
def convertBST(self, root: TreeNode) -> TreeNode:
sum = 0
def sol(root: TreeNode) -> TreeNode:
nonlocal sum
if root:
sol(root.right)
root.val += sum
sum = root.val
sol(root.left)
return root
return sol(root) | https://leetcode.com/problems/convert-bst-to-greater-tree/discuss/1057429/Python.-faster-than-100.00.-Explained-clear-and-Easy-understanding-solution.-O(n).-Recursive | 13 | Given the root of a Binary Search Tree (BST), convert it to a Greater Tree such that every key of the original BST is changed to the original key plus the sum of all keys greater than the original key in BST.
As a reminder, a binary search tree is a tree that satisfies these constraints:
The left subtree of a node cont... | Python. faster than 100.00%. Explained, clear & Easy-understanding solution. O(n). Recursive | 912 | convert-bst-to-greater-tree | 0.674 | m-d-f | Medium | 9,404 | 538 |
minimum time difference | class Solution:
def findMinDifference(self, timePoints: List[str]) -> int:
M = 1440
times = [False] * M
for time in timePoints:
minute = self.minute(time)
if times[minute]:
return 0
times[minute] = True
minutes = [i for i i... | https://leetcode.com/problems/minimum-time-difference/discuss/1829297/python-3-bucket-sort-O(n)-time-O(1)-space | 9 | Given a list of 24-hour clock time points in "HH:MM" format, return the minimum minutes difference between any two time-points in the list.
Example 1:
Input: timePoints = ["23:59","00:00"]
Output: 1
Example 2:
Input: timePoints = ["00:00","23:59","00:00"]
Output: 0
Constraints:
2 <= timePoints.length <= 2 * 104
tim... | [python 3] bucket sort, O(n) time, O(1) space | 595 | minimum-time-difference | 0.563 | dereky4 | Medium | 9,431 | 539 |
single element in a sorted array | class Solution:
def singleNonDuplicate(self, nums: List[int]) -> int:
counts = defaultdict(int)
for num in nums:
counts[num] += 1
for num, count in counts.items():
if count == 1:
return num
return -1 # this will never be reached
# return Cou... | https://leetcode.com/problems/single-element-in-a-sorted-array/discuss/1587293/Python-3-Simple-Approaches-with-Explanation | 54 | You are given a sorted array consisting of only integers where every element appears exactly twice, except for one element which appears exactly once.
Return the single element that appears only once.
Your solution must run in O(log n) time and O(1) space.
Example 1:
Input: nums = [1,1,2,3,3,4,4,8,8]
Output: 2
Exampl... | [Python] 3 Simple Approaches with Explanation | 2,800 | single-element-in-a-sorted-array | 0.585 | zayne-siew | Medium | 9,449 | 540 |
reverse string ii | class Solution:
def reverseStr(self, s: str, k: int) -> str:
if len(s)<(k):return s[::-1]
if len(s)<(2*k):return (s[:k][::-1]+s[k:])
return s[:k][::-1]+s[k:2*k]+self.reverseStr(s[2*k:],k) | https://leetcode.com/problems/reverse-string-ii/discuss/343424/Python-3-solution-using-recursion-(efficient)-3-liner-with-explanation | 22 | Given a string s and an integer k, reverse the first k characters for every 2k characters counting from the start of the string.
If there are fewer than k characters left, reverse all of them. If there are less than 2k but greater than or equal to k characters, then reverse the first k characters and leave the other as... | Python 3 solution using recursion (efficient) 3-liner with explanation | 1,700 | reverse-string-ii | 0.505 | ketan35 | Easy | 9,496 | 541 |
01 matrix | class Solution:
def updateMatrix(self, mat: List[List[int]]) -> List[List[int]]:
row, col = len(mat), len(mat[0])
queue = deque([])
for x in range(row):
for y in range(col):
if mat[x][y] == 0:
queue.append((x, y, 1))
return self.bfs(row, col, queue, mat)
def bfs(self, row, col, queue, grid):
... | https://leetcode.com/problems/01-matrix/discuss/1556018/WEEB-DOES-PYTHON-BFS | 7 | Given an m x n binary matrix mat, return the distance of the nearest 0 for each cell.
The distance between two adjacent cells is 1.
Example 1:
Input: mat = [[0,0,0],[0,1,0],[0,0,0]]
Output: [[0,0,0],[0,1,0],[0,0,0]]
Example 2:
Input: mat = [[0,0,0],[0,1,0],[1,1,1]]
Output: [[0,0,0],[0,1,0],[1,2,1]]
Constraints:
m =... | WEEB DOES PYTHON BFS | 414 | 01-matrix | 0.442 | Skywalker5423 | Medium | 9,542 | 542 |
diameter of binary tree | class Solution:
def __init__(self):
self.diameter = 0 # stores the maximum diameter calculated
def depth(self, node: Optional[TreeNode]) -> int:
"""
This function needs to do the following:
1. Calculate the maximum depth of the left and right sides of the given node
... | https://leetcode.com/problems/diameter-of-binary-tree/discuss/1515564/Python-Easy-to-understand-solution-w-Explanation | 56 | Given the root of a binary tree, return the length of the diameter of the tree.
The diameter of a binary tree is the length of the longest path between any two nodes in a tree. This path may or may not pass through the root.
The length of a path between two nodes is represented by the number of edges between them.
Ex... | Python Easy-to-understand solution w Explanation | 3,100 | diameter-of-binary-tree | 0.561 | zayne-siew | Easy | 9,572 | 543 |
remove boxes | class Solution:
def removeBoxes(self, boxes: List[int]) -> int:
@cache
def fn(lo, hi, k):
"""Return max score of removing boxes from lo to hi with k to the left."""
if lo == hi: return 0
while lo+1 < hi and boxes[lo] == boxes[lo+1]: lo, k = lo+1, k+1
... | https://leetcode.com/problems/remove-boxes/discuss/1379392/Python3-dp | 2 | You are given several boxes with different colors represented by different positive numbers.
You may experience several rounds to remove boxes until there is no box left. Each time you can choose some continuous boxes with the same color (i.e., composed of k boxes, k >= 1), remove them and get k * k points.
Return the ... | [Python3] dp | 293 | remove-boxes | 0.479 | ye15 | Hard | 9,595 | 546 |
number of provinces | class Solution(object):
def findCircleNum(self, M):
"""
:type M: List[List[int]]
:rtype: int
"""
n = len(M) #1
visited = [False]*n #2
count = 0 #3
if not M: #4
return 0 #5
def dfs(u): #6
for v in ... | https://leetcode.com/problems/number-of-provinces/discuss/727759/Python3-solution-with-detailed-explanation | 17 | There are n cities. Some of them are connected, while some are not. If city a is connected directly with city b, and city b is connected directly with city c, then city a is connected indirectly with city c.
A province is a group of directly or indirectly connected cities and no other cities outside of the group.
You a... | Python3 solution with detailed explanation | 1,600 | number-of-provinces | 0.634 | peyman_np | Medium | 9,597 | 547 |
student attendance record i | class Solution:
def checkRecord(self, s: str) -> bool:
return (s.count('A') < 2) and ('LLL' not in s)
- Junaid Mansuri
(LeetCode ID)@hotmail.com | https://leetcode.com/problems/student-attendance-record-i/discuss/356636/Solution-in-Python-3-(one-line) | 16 | You are given a string s representing an attendance record for a student where each character signifies whether the student was absent, late, or present on that day. The record only contains the following three characters:
'A': Absent.
'L': Late.
'P': Present.
The student is eligible for an attendance award if they mee... | Solution in Python 3 (one line) | 940 | student-attendance-record-i | 0.481 | junaidmansuri | Easy | 9,644 | 551 |
student attendance record ii | class Solution:
def checkRecord(self, n: int) -> int:
C, m = [1,1,0,1,0,0], 10**9 + 7
for i in range(n-1):
a, b = sum(C[:3]) % m, sum(C[3:]) % m
C = [a, C[0], C[1], a + b, C[3], C[4]]
return (sum(C) % m) | https://leetcode.com/problems/student-attendance-record-ii/discuss/356750/Solution-in-Python-3-(five-lines)-(with-explanation) | 12 | An attendance record for a student can be represented as a string where each character signifies whether the student was absent, late, or present on that day. The record only contains the following three characters:
'A': Absent.
'L': Late.
'P': Present.
Any student is eligible for an attendance award if they meet both ... | Solution in Python 3 (five lines) (with explanation) | 1,900 | student-attendance-record-ii | 0.412 | junaidmansuri | Hard | 9,674 | 552 |
optimal division | class Solution:
def optimalDivision(self, nums: List[int]) -> str:
if len(nums) <= 2: return "/".join(map(str, nums))
return f'{nums[0]}/({"/".join(map(str, nums[1:]))})' | https://leetcode.com/problems/optimal-division/discuss/1265206/Python3-string-concatenation | 3 | You are given an integer array nums. The adjacent integers in nums will perform the float division.
For example, for nums = [2,3,4], we will evaluate the expression "2/3/4".
However, you can add any number of parenthesis at any position to change the priority of operations. You want to add these parentheses such the va... | [Python3] string concatenation | 86 | optimal-division | 0.597 | ye15 | Medium | 9,687 | 553 |
brick wall | class Solution:
def leastBricks(self, wall: List[List[int]]) -> int:
count = defaultdict(int)
tot = len(wall)
if tot == 1 and len(wall[0]) > 1:
return 0
elif tot == 1 and len(wall[0]) == 1:
return 1
for w in wall:
s = 0
... | https://leetcode.com/problems/brick-wall/discuss/1736767/python-easy-hashmap-solution | 1 | There is a rectangular brick wall in front of you with n rows of bricks. The ith row has some number of bricks each of the same height (i.e., one unit) but they can be of different widths. The total width of each row is the same.
Draw a vertical line from the top to the bottom and cross the least bricks. If your line g... | python easy hashmap solution | 62 | brick-wall | 0.532 | byuns9334 | Medium | 9,696 | 554 |
next greater element iii | class Solution:
def nextGreaterElement(self, n: int) -> int:
m=list(str(n)) ## n = 257761
l = len(m) ## l = 6
d = {}
res = str(n)
## reading character backwards: 1->6->7->7->5 break
for i,c in enumerate(m[::-1])... | https://leetcode.com/problems/next-greater-element-iii/discuss/983461/Simple-Python-Solution-easy-to-understand-reading-backwards-from-the-end | 7 | Given a positive integer n, find the smallest integer which has exactly the same digits existing in the integer n and is greater in value than n. If no such positive integer exists, return -1.
Note that the returned integer should fit in 32-bit integer, if there is a valid answer but it does not fit in 32-bit integer, ... | Simple Python Solution, easy to understand, reading backwards from the end | 935 | next-greater-element-iii | 0.341 | KevinZzz666 | Medium | 9,708 | 556 |
reverse words in a string iii | class Solution:
def reverseWords(self, s: str) -> str:
s = s.split()
for i in range(len(s)): s[i] = s[i][::-1]
return " ".join(s)
- Junaid Mansuri
(LeetCode ID)@hotmail.com | https://leetcode.com/problems/reverse-words-in-a-string-iii/discuss/332138/Simple-Python-3-Solution-(beats-~98)-(three-lines) | 8 | Given a string s, reverse the order of characters in each word within a sentence while still preserving whitespace and initial word order.
Example 1:
Input: s = "Let's take LeetCode contest"
Output: "s'teL ekat edoCteeL tsetnoc"
Example 2:
Input: s = "Mr Ding"
Output: "rM gniD"
Constraints:
1 <= s.length <= 5 * 104... | Simple Python 3 Solution (beats ~98%) (three lines) | 2,000 | reverse-words-in-a-string-iii | 0.816 | junaidmansuri | Easy | 9,725 | 557 |
logical or of two binary grids represented as quad trees | class Solution:
def intersect(self, quadTree1: 'Node', quadTree2: 'Node') -> 'Node':
if quadTree1.isLeaf: return quadTree1 if quadTree1.val else quadTree2 # boundary condition
if quadTree2.isLeaf: return quadTree2 if quadTree2.val else quadTree1 # boundary condition
tl = self.intersect(qua... | https://leetcode.com/problems/logical-or-of-two-binary-grids-represented-as-quad-trees/discuss/884082/Python3-9-line-recursive-(64ms-93.33) | 2 | A Binary Matrix is a matrix in which all the elements are either 0 or 1.
Given quadTree1 and quadTree2. quadTree1 represents a n * n binary matrix and quadTree2 represents another n * n binary matrix.
Return a Quad-Tree representing the n * n binary matrix which is the result of logical bitwise OR of the two binary mat... | [Python3] 9-line recursive (64ms 93.33%) | 151 | logical-or-of-two-binary-grids-represented-as-quad-trees | 0.483 | ye15 | Medium | 9,780 | 558 |
maximum depth of n ary tree | class Solution:
def maxDepth(self, root: 'Node') -> int:
if root is None:
# empty node or empty tree
return 0
else:
# DFS to choose the longest path
if root.children:
# current node has subtrees
... | https://leetcode.com/problems/maximum-depth-of-n-ary-tree/discuss/629671/Python-O(n)-by-DFS-90%2B-w-Comment | 4 | Given a n-ary tree, find its maximum depth.
The maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.
Nary-Tree input serialization is represented in their level order traversal, each group of children is separated by the null value (See examples).
Example 1:
I... | Python O(n) by DFS 90%+ [w/ Comment] | 438 | maximum-depth-of-n-ary-tree | 0.716 | brianchiang_tw | Easy | 9,782 | 559 |
subarray sum equals k | class Solution:
def subarraySum(self, nums: List[int], k: int) -> int:
ans=0
prefsum=0
d={0:1}
for num in nums:
prefsum = prefsum + num
if prefsum-k in d:
ans = ans + d[prefsum-k]
if prefsum not in d:
d[prefsum] = 1
else:
d[prefsum] = d[prefsum]+1
return ans | https://leetcode.com/problems/subarray-sum-equals-k/discuss/1759711/Python-Simple-Python-Solution-Using-PrefixSum-and-Dictionary | 192 | Given an array of integers nums and an integer k, return the total number of subarrays whose sum equals to k.
A subarray is a contiguous non-empty sequence of elements within an array.
Example 1:
Input: nums = [1,1,1], k = 2
Output: 2
Example 2:
Input: nums = [1,2,3], k = 3
Output: 2
Constraints:
1 <= nums.length <... | [ Python ] ✅✅ Simple Python Solution Using PrefixSum and Dictionary 🔥✌ | 26,200 | subarray-sum-equals-k | 0.44 | ASHOK_KUMAR_MEGHVANSHI | Medium | 9,800 | 560 |
array partition | class Solution:
def arrayPairSum(self, nums: List[int]) -> int:
nums.sort()
sum_ = 0
for i in range(0,len(nums),2):
sum_ += nums[i]
return sum_
# Time : 356 ms
# Memory : 16.7 M | https://leetcode.com/problems/array-partition/discuss/390198/Algorithm-and-solution-in-python3 | 47 | Given an integer array nums of 2n integers, group these integers into n pairs (a1, b1), (a2, b2), ..., (an, bn) such that the sum of min(ai, bi) for all i is maximized. Return the maximized sum.
Example 1:
Input: nums = [1,4,3,2]
Output: 4
Explanation: All possible pairings (ignoring the ordering of elements) are:
1.... | Algorithm and solution in python3 | 3,200 | array-partition | 0.767 | ramanaditya | Easy | 9,846 | 561 |
binary tree tilt | class Solution:
def findTilt(self, root: Optional[TreeNode]) -> int:
def rec(node):
nonlocal res
if not node:
return 0
left_sum = rec(node.left)
right_sum = rec(node.right)
res += abs(left_sum - right_sum)
r... | https://leetcode.com/problems/binary-tree-tilt/discuss/1617385/Recursive-solution-Python | 3 | Given the root of a binary tree, return the sum of every tree node's tilt.
The tilt of a tree node is the absolute difference between the sum of all left subtree node values and all right subtree node values. If a node does not have a left child, then the sum of the left subtree node values is treated as 0. The rule is... | Recursive solution Python | 192 | binary-tree-tilt | 0.595 | kryuki | Easy | 9,877 | 563 |
find the closest palindrome | class Solution:
def find_next_palindrome(self, n, additive):
l = len(n)
if l == 0:
return 0
first_half = str(int(n[:l // 2 + l % 2]) + additive)
return int(first_half + first_half[(-1 - l%2)::-1])
def nearestPalindromic(self, n: str) -> str:
m = i... | https://leetcode.com/problems/find-the-closest-palindrome/discuss/2581120/Only-5-Cases-to-Consider%3A-Concise-implementation-in-Python-with-Full-Explanation | 3 | Given a string n representing an integer, return the closest integer (not including itself), which is a palindrome. If there is a tie, return the smaller one.
The closest is defined as the absolute difference minimized between two integers.
Example 1:
Input: n = "123"
Output: "121"
Example 2:
Input: n = "1"
Output: "... | Only 5 Cases to Consider: Concise implementation in Python with Full Explanation | 269 | find-the-closest-palindrome | 0.22 | metaphysicalist | Hard | 9,890 | 564 |
array nesting | class Solution:
def arrayNesting(self, nums: List[int]) -> int:
res, l = 0, len(nums)
globalSet = set()
for k in range(l):
if k not in globalSet:
currLength, currSet, val = 0, set(), k
while True:
if nums[val] in currSet: break
... | https://leetcode.com/problems/array-nesting/discuss/1438213/CLEAN-and-SHORT-PYTHON-O(N)-TIME-O(N)-SPACE | 6 | You are given an integer array nums of length n where nums is a permutation of the numbers in the range [0, n - 1].
You should build a set s[k] = {nums[k], nums[nums[k]], nums[nums[nums[k]]], ... } subjected to the following rule:
The first element in s[k] starts with the selection of the element nums[k] of index = k.
... | CLEAN & SHORT PYTHON, O(N) TIME, O(N) SPACE | 442 | array-nesting | 0.565 | kushagrabainsla | Medium | 9,894 | 565 |
reshape the matrix | class Solution:
def matrixReshape(self, mat: List[List[int]], r: int, c: int) -> List[List[int]]:
flatten = []
new_mat = []
for row in mat:
for num in row:
flatten.append(num)
if r * c != len(flatten): # when given parameters is NOT poss... | https://leetcode.com/problems/reshape-the-matrix/discuss/2046840/Python-Intuitive-%2B-Direct-for-Beginners-with-Illustrations | 45 | In MATLAB, there is a handy function called reshape which can reshape an m x n matrix into a new one with a different size r x c keeping its original data.
You are given an m x n matrix mat and two integers r and c representing the number of rows and the number of columns of the wanted reshaped matrix.
The reshaped mat... | [Python] Intuitive + Direct for Beginners with Illustrations | 1,100 | reshape-the-matrix | 0.627 | ziaiz-zythoniz | Easy | 9,912 | 566 |
permutation in string | class Solution:
def checkInclusion(self, s1: str, s2: str) -> bool:
window = len(s1)
s1_c = Counter(s1)
for i in range(len(s2)-window+1):
s2_c = Counter(s2[i:i+window])
if s2_c == s1_c:
return True
return False | https://leetcode.com/problems/permutation-in-string/discuss/1476884/Python-Sliding-Window-and-Dictionary.-Easy-to-understand | 29 | Given two strings s1 and s2, return true if s2 contains a permutation of s1, or false otherwise.
In other words, return true if one of s1's permutations is the substring of s2.
Example 1:
Input: s1 = "ab", s2 = "eidbaooo"
Output: true
Explanation: s2 contains one permutation of s1 ("ba").
Example 2:
Input: s1 = "ab",... | Python Sliding Window and Dictionary. Easy to understand | 3,000 | permutation-in-string | 0.437 | ParthitPatel | Medium | 9,964 | 567 |
subtree of another tree | class Solution:
def isSubtree(self, s: TreeNode, t: TreeNode) -> bool:
if not s:
return False
if self.isSameTree(s, t):
return True
return self.isSubtree(s.left, t) or self.isSubtree(s.right, t)
def isSameTree(self, p: TreeNode, q: TreeNode) -> bool:
if... | https://leetcode.com/problems/subtree-of-another-tree/discuss/265239/Python-Easy-to-Understand | 83 | Given the roots of two binary trees root and subRoot, return true if there is a subtree of root with the same structure and node values of subRoot and false otherwise.
A subtree of a binary tree tree is a tree that consists of a node in tree and all of this node's descendants. The tree tree could also be considered as ... | Python Easy to Understand | 13,100 | subtree-of-another-tree | 0.46 | ccparamecium | Easy | 10,009 | 572 |
distribute candies | class Solution:
def distributeCandies(self, candyType: List[int]) -> int:
return min(len(candyType) //2, len(set(candyType))) | https://leetcode.com/problems/distribute-candies/discuss/1088016/Python.-One-liner-Easy-understanding-solution. | 2 | Alice has n candies, where the ith candy is of type candyType[i]. Alice noticed that she started to gain weight, so she visited a doctor.
The doctor advised Alice to only eat n / 2 of the candies she has (n is always even). Alice likes her candies very much, and she wants to eat the maximum number of different types of... | Python. One-liner Easy-understanding solution. | 224 | distribute-candies | 0.661 | m-d-f | Easy | 10,043 | 575 |
out of boundary paths | class Solution: # The plan is to accrete the number of paths from the starting cell, which
# is the sum of (a) the number of adjacent positions that are off the grid
# and (b) the number of paths from the adjacent cells in the grid within
... | https://leetcode.com/problems/out-of-boundary-paths/discuss/2288190/Python3-oror-recursion-one-grid-w-explanation-oror-TM%3A-8949 | 5 | There is an m x n grid with a ball. The ball is initially at the position [startRow, startColumn]. You are allowed to move the ball to one of the four adjacent cells in the grid (possibly out of the grid crossing the grid boundary). You can apply at most maxMove moves to the ball.
Given the five integers m, n, maxMove,... | Python3 || recursion , one grid w/ explanation || T/M: 89%/49% | 371 | out-of-boundary-paths | 0.443 | warrenruud | Medium | 10,073 | 576 |
shortest unsorted continuous subarray | class Solution:
def findUnsortedSubarray(self, nums: List[int]) -> int:
sorted_nums = sorted(nums)
l, u = len(nums) - 1,0
for i in range(len(nums)):
if nums[i]!=sorted_nums[i]:
l=min(l, i)
u=max(u, i)
return 0 if ... | https://leetcode.com/problems/shortest-unsorted-continuous-subarray/discuss/2002965/Python-Simple-Two-Approaches | 11 | Given an integer array nums, you need to find one continuous subarray such that if you only sort this subarray in non-decreasing order, then the whole array will be sorted in non-decreasing order.
Return the shortest such subarray and output its length.
Example 1:
Input: nums = [2,6,4,8,10,9,15]
Output: 5
Explanation... | Python Simple Two Approaches | 828 | shortest-unsorted-continuous-subarray | 0.363 | constantine786 | Medium | 10,093 | 581 |
delete operation for two strings | class Solution:
def minDistance(self, word1: str, word2: str) -> int:
m,n=len(word1),len(word2)
@cache
def lcs(i, j): # find longest common subsequence
if i==m or j==n:
return 0
return 1 + lcs(i+1, j+1) if word1[i]==word2[j] else max(lcs(i... | https://leetcode.com/problems/delete-operation-for-two-strings/discuss/2148966/Python-DP-2-approaches-using-LCS | 49 | Given two strings word1 and word2, return the minimum number of steps required to make word1 and word2 the same.
In one step, you can delete exactly one character in either string.
Example 1:
Input: word1 = "sea", word2 = "eat"
Output: 2
Explanation: You need one step to make "sea" to "ea" and another step to make "e... | Python DP 2 approaches using LCS ✅ | 3,000 | delete-operation-for-two-strings | 0.594 | constantine786 | Medium | 10,142 | 583 |
erect the fence | class Solution:
def outerTrees(self, points: List[List[int]]) -> List[List[int]]:
"""
Use Monotone Chain algorithm.
"""
def is_clockwise(
p0: List[int], p1: List[int], p2: List[int]) -> bool:
"""
Determine the orientation the slope p0p2 is on t... | https://leetcode.com/problems/erect-the-fence/discuss/864619/Python-Solution-with-Monotone-Chain-Algorithm | 4 | You are given an array trees where trees[i] = [xi, yi] represents the location of a tree in the garden.
Fence the entire garden using the minimum length of rope, as it is expensive. The garden is well-fenced only if all the trees are enclosed.
Return the coordinates of trees that are exactly located on the fence perime... | Python Solution with Monotone Chain Algorithm | 542 | erect-the-fence | 0.523 | eroneko | Hard | 10,180 | 587 |
n ary tree preorder traversal | class Solution(object):
def preorder(self, root):
# To store the output result...
output = []
self.traverse(root, output)
return output
def traverse(self, root, output):
# Base case: If root is none...
if root is None: return
# Append the value of the root... | https://leetcode.com/problems/n-ary-tree-preorder-traversal/discuss/2496970/Very-Easy-oror-100-oror-Fully-Explained-oror-Java-C%2B%2B-Python-Python3-oror-Iterative-and-Recursive(DFS) | 28 | Given the root of an n-ary tree, return the preorder traversal of its nodes' values.
Nary-Tree input serialization is represented in their level order traversal. Each group of children is separated by the null value (See examples)
Example 1:
Input: root = [1,null,3,2,4,null,5,6]
Output: [1,3,5,6,2,4]
Example 2:
Input... | Very Easy || 100% || Fully Explained || Java, C++, Python, Python3 || Iterative & Recursive(DFS) | 1,600 | n-ary-tree-preorder-traversal | 0.762 | PratikSen07 | Easy | 10,201 | 589 |
n ary tree postorder traversal | class Solution:
def postorder(self, root: 'Node') -> List[int]:
def dfs(node):
"""Populate ans via post-order traversal."""
if not node: return
for child in node.children: dfs(child)
ans.append(node.val)
ans = []
dfs(root... | https://leetcode.com/problems/n-ary-tree-postorder-traversal/discuss/355782/Python3-recursive-and-iterative-implementation | 2 | Given the root of an n-ary tree, return the postorder traversal of its nodes' values.
Nary-Tree input serialization is represented in their level order traversal. Each group of children is separated by the null value (See examples)
Example 1:
Input: root = [1,null,3,2,4,null,5,6]
Output: [5,6,3,2,4,1]
Example 2:
Inpu... | [Python3] recursive & iterative implementation | 129 | n-ary-tree-postorder-traversal | 0.772 | ye15 | Easy | 10,232 | 590 |
tag validator | class Solution:
def isValid(self, code: str) -> bool:
if code[0] != '<' or code[-1] != '>': return False
i, n = 0, len(code)
stk = []
while i < n:
if code[i] == '<':
if i != 0 and code[i: i + 9] == '<![CDATA[':
if not stk: return False
... | https://leetcode.com/problems/tag-validator/discuss/449403/Two-Python-Solution%3A(1)-linear-paring-with-stack(2)BNF-parsing-with-pyparsing | 1 | Given a string representing a code snippet, implement a tag validator to parse the code and return whether it is valid.
A code snippet is valid if all the following rules hold:
The code must be wrapped in a valid closed tag. Otherwise, the code is invalid.
A closed tag (not necessarily valid) has exactly the following ... | Two Python Solution:(1) linear paring with stack;(2)BNF parsing with pyparsing | 402 | tag-validator | 0.371 | cava | Hard | 10,250 | 591 |
fraction addition and subtraction | class Solution:
def fractionAddition(self, exp: str) -> str:
if not exp:
return "0/1"
if exp[0] != '-':
exp = '+' + exp
# Parse the expression to get the numerator and denominator of each fraction
num = []
den = []
po... | https://leetcode.com/problems/fraction-addition-and-subtraction/discuss/1128722/Python-Simple-Parsing-with-example | 6 | Given a string expression representing an expression of fraction addition and subtraction, return the calculation result in string format.
The final result should be an irreducible fraction. If your final result is an integer, change it to the format of a fraction that has a denominator 1. So in this case, 2 should be ... | [Python] Simple Parsing - with example | 918 | fraction-addition-and-subtraction | 0.521 | rowe1227 | Medium | 10,252 | 592 |
valid square | class Solution:
def validSquare(self, p1: List[int], p2: List[int], p3: List[int], p4: List[int]) -> bool:
def dist(point1,point2):
return (point1[0]-point2[0])**2+(point1[1]-point2[1])**2
D=[
dist(p1,p2),
dist(p1,p3),
dist(p1,p4),
dist(p2,p3)... | https://leetcode.com/problems/valid-square/discuss/931866/python-easy-to-understand-3-lines-code-beats-95 | 17 | Given the coordinates of four points in 2D space p1, p2, p3 and p4, return true if the four points construct a square.
The coordinate of a point pi is represented as [xi, yi]. The input is not given in any order.
A valid square has four equal sides with positive length and four equal angles (90-degree angles).
Exampl... | python easy to understand 3 lines code beats 95% | 966 | valid-square | 0.44 | Mahesh_N_V | Medium | 10,260 | 593 |
longest harmonious subsequence | class Solution:
def findLHS(self, nums: List[int]) -> int:
tmp = Counter(nums)
keys = tmp.keys()
max = 0
for num in keys:
if num - 1 in keys:
if tmp[num - 1] + tmp[num] > max:
max = tmp[num - 1] + tmp[num]
return max | https://leetcode.com/problems/longest-harmonious-subsequence/discuss/1049126/Python.-O(n)-Cool-easy-and-clear-solution. | 6 | We define a harmonious array as an array where the difference between its maximum value and its minimum value is exactly 1.
Given an integer array nums, return the length of its longest harmonious subsequence among all its possible subsequences.
A subsequence of array is a sequence that can be derived from the array by... | Python. O(n), Cool, easy & clear solution. | 494 | longest-harmonious-subsequence | 0.532 | m-d-f | Easy | 10,275 | 594 |
range addition ii | class Solution:
def maxCount(self, m: int, n: int, ops: List[List[int]]) -> int:
min_row = m
min_col = n
for i in range(len(ops)):
min_row=min(min_row, ops[i][0])
min_col=min(min_col, ops[i][1])
return min_row*min_col | https://leetcode.com/problems/range-addition-ii/discuss/1434604/C-or-C%2B%2B-or-Python-or-Java-or-C-or-JavaScript-or-Go-Same-Simple-Solution | 23 | You are given an m x n matrix M initialized with all 0's and an array of operations ops, where ops[i] = [ai, bi] means M[x][y] should be incremented by one for all 0 <= x < ai and 0 <= y < bi.
Count and return the number of maximum integers in the matrix after performing all the operations.
Example 1:
Input: m = 3, n... | [ C | C++ | Python | Java | C# | JavaScript | Go ] Same Simple Solution | 2,000 | range-addition-ii | 0.551 | HadaEn | Easy | 10,293 | 598 |
minimum index sum of two lists | class Solution:
def findRestaurant(self, list1: List[str], list2: List[str]) -> List[str]:
d = {}
d2 = {}
min_ = 5000
ret = []
for i in range(len(list1)):
d[list1[i]] = i+1
for i in range(len(list2)):
a = d.get(list2[i], 0)
if a:
... | https://leetcode.com/problems/minimum-index-sum-of-two-lists/discuss/1382036/Easy-Python-Solution-(Memory-Usage-less-than-97) | 3 | Given two arrays of strings list1 and list2, find the common strings with the least index sum.
A common string is a string that appeared in both list1 and list2.
A common string with the least index sum is a common string such that if it appeared at list1[i] and list2[j] then i + j should be the minimum value among all... | Easy Python Solution (Memory Usage less than 97%) | 454 | minimum-index-sum-of-two-lists | 0.529 | the_sky_high | Easy | 10,308 | 599 |
non negative integers without consecutive ones | class Solution:
def findIntegers(self, n: int) -> int:
# f stores the fibonacci numbers
f = [1, 2]
for i in range(2, 30):
f.append(f[-1]+f[-2])
# last_seen tells us if there was a one right before.
# If that is the case, we are done then and there!
... | https://leetcode.com/problems/non-negative-integers-without-consecutive-ones/discuss/1361794/Python3-Official-Solution-Explained-Simply-with-Diagrams | 100 | Given a positive integer n, return the number of the integers in the range [0, n] whose binary representations do not contain consecutive ones.
Example 1:
Input: n = 5
Output: 5
Explanation:
Here are the non-negative integers <= 5 with their corresponding binary representations:
0 : 0
1 : 1
2 : 10
3 : 11
4 : 100
5 : ... | [Python3] Official Solution Explained Simply with Diagrams | 2,500 | non-negative-integers-without-consecutive-ones | 0.39 | chaudhary1337 | Hard | 10,337 | 600 |
can place flowers | class Solution:
def canPlaceFlowers(self, f: List[int], n: int) -> bool:
L, i, c, f = len(f)-2, -2, 0, f + [0]
while i < L:
i += 2
if f[i] == 1: continue
if f[i+1] == 0: c += 1
else: i += 1
return n <= c
class Solution:
def canPlaceFlowers(... | https://leetcode.com/problems/can-place-flowers/discuss/380474/Three-Solutions-in-Python-3-(beats-~100) | 7 | You have a long flowerbed in which some of the plots are planted, and some are not. However, flowers cannot be planted in adjacent plots.
Given an integer array flowerbed containing 0's and 1's, where 0 means empty and 1 means not empty, and an integer n, return true if n new flowers can be planted in the flowerbed wit... | Three Solutions in Python 3 (beats ~100%) | 1,800 | can-place-flowers | 0.329 | junaidmansuri | Easy | 10,341 | 605 |
construct string from binary tree | class Solution:
def tree2str(self, t: TreeNode) -> str:
sb = [] # init string builder
# helper function to create result
def helper(node: TreeNode) -> None:
if not node:
return
sb.append(str(node.val))
if... | https://leetcode.com/problems/construct-string-from-binary-tree/discuss/1112030/Python-recursive-solution-with-string-builder | 15 | Given the root node of a binary tree, your task is to create a string representation of the tree following a specific set of formatting rules. The representation should be based on a preorder traversal of the binary tree and must adhere to the following guidelines:
Node Representation: Each node in the tree should be r... | Python recursive solution with string builder | 1,200 | construct-string-from-binary-tree | 0.636 | ignat-s | Easy | 10,378 | 606 |
find duplicate file in system | class Solution:
def findDuplicate(self, paths: List[str]) -> List[List[str]]:
m = defaultdict(list)
for p in paths:
# 1. split the string by ' '
path = p.split()
# the first string is the directory path
# the rest of them are just file names with conte... | https://leetcode.com/problems/find-duplicate-file-in-system/discuss/2595019/LeetCode-The-Hard-Way-Explained-Line-By-Line | 28 | Given a list paths of directory info, including the directory path, and all the files with contents in this directory, return all the duplicate files in the file system in terms of their paths. You may return the answer in any order.
A group of duplicate files consists of at least two files that have the same content.
... | 🔥 [LeetCode The Hard Way] 🔥 Explained Line By Line | 1,200 | find-duplicate-file-in-system | 0.678 | wingkwong | Medium | 10,417 | 609 |
valid triangle number | class Solution:
def triangleNumber(self, nums: List[int]) -> int:
nums.sort()
ans = 0
for i in range(len(nums)):
lo, hi = 0, i-1
while lo < hi:
if nums[lo] + nums[hi] > nums[i]:
ans += hi - lo
hi -= 1
... | https://leetcode.com/problems/valid-triangle-number/discuss/884373/Python3-O(N2)-time-solution | 3 | Given an integer array nums, return the number of triplets chosen from the array that can make triangles if we take them as side lengths of a triangle.
Example 1:
Input: nums = [2,2,3,4]
Output: 3
Explanation: Valid combinations are:
2,3,4 (using the first 2)
2,3,4 (using the second 2)
2,2,3
Example 2:
Input: nums =... | [Python3] O(N^2) time solution | 222 | valid-triangle-number | 0.504 | ye15 | Medium | 10,449 | 611 |
merge two binary trees | class Solution:
def mergeTrees(self, root1: TreeNode, root2: TreeNode) -> TreeNode:
if not root1: return root2
if not root2: return root1
queue = deque([(root1, root2)])
while queue:
current_root1, current_root2 = queue.pop()
if current_root1.left and current_... | https://leetcode.com/problems/merge-two-binary-trees/discuss/1342175/Elegant-Python-Iterative-and-Recursive-solutions | 9 | You are given two binary trees root1 and root2.
Imagine that when you put one of them to cover the other, some nodes of the two trees are overlapped while the others are not. You need to merge the two trees into a new binary tree. The merge rule is that if two nodes overlap, then sum node values up as the new value of ... | Elegant Python Iterative & Recursive solutions | 453 | merge-two-binary-trees | 0.786 | soma28 | Easy | 10,460 | 617 |
task scheduler | class Solution:
def leastInterval(self, tasks: List[str], n: int) -> int:
cnt = [0] * 26
for i in tasks: cnt[ord(i) - ord('A')] += 1
mx, mxcnt = max(cnt), 0
for i in cnt:
if i == mx: mxcnt += 1
return max((mx - 1) * (n + 1) + mxcnt, len(tasks)) | https://leetcode.com/problems/task-scheduler/discuss/2667200/Python-O(n)-time-count-it-directly | 10 | You are given an array of CPU tasks, each represented by letters A to Z, and a cooling time, n. Each cycle or interval allows the completion of one task. Tasks can be completed in any order, but there's a constraint: identical tasks must be separated by at least n intervals due to cooling time.
Return the minimum numbe... | Python O(n) time, count it directly | 1,100 | task-scheduler | 0.558 | alex391a | Medium | 10,490 | 621 |
add one row to tree | class Solution:
def addOneRow(self, root: TreeNode, v: int, d: int, side = "left") -> TreeNode:
if d == 1:
res = TreeNode(v)
setattr(res, side, root)
return res
if root:
root.left = self.addOneRow(root.left, v, d - 1)
root.right = self.addO... | https://leetcode.com/problems/add-one-row-to-tree/discuss/1101104/Python.-Recursive.-Easy-understanding-solution | 13 | Given the root of a binary tree and two integers val and depth, add a row of nodes with value val at the given depth depth.
Note that the root node is at depth 1.
The adding rule is:
Given the integer depth, for each not null tree node cur at the depth depth - 1, create two tree nodes with value val as cur's left subtr... | Python. Recursive. Easy understanding solution | 772 | add-one-row-to-tree | 0.595 | m-d-f | Medium | 10,507 | 623 |
maximum product of three numbers | class Solution:
def maximumProduct(self, nums: List[int]) -> int:
max1 = max2 = max3 = float("-inf")
min1 = min2 = float("inf")
for num in nums:
if num > max1:
max1, max2, max3 = num, max1, max2
elif num > max2:
max2, max3 = n... | https://leetcode.com/problems/maximum-product-of-three-numbers/discuss/356715/Python3-O(N)-and-O(NlogN)-solutions | 7 | Given an integer array nums, find three numbers whose product is maximum and return the maximum product.
Example 1:
Input: nums = [1,2,3]
Output: 6
Example 2:
Input: nums = [1,2,3,4]
Output: 24
Example 3:
Input: nums = [-1,-2,-3]
Output: -6
Constraints:
3 <= nums.length <= 104
-1000 <= nums[i] <= 1000 | [Python3] O(N) and O(NlogN) solutions | 677 | maximum-product-of-three-numbers | 0.463 | ye15 | Easy | 10,533 | 628 |
k inverse pairs array | class Solution:
# A very good description of the dp solution is at
# https://leetcode.com/problems/k-inverse-pairs-array/solution/
# The code below uses two 1D arrays--dp and tmp--instead if a
# 2D array. tmp replaces dp a... | https://leetcode.com/problems/k-inverse-pairs-array/discuss/2293304/Python3-oror-dp1D-array-10-lines-w-explanation-oror-TM%3A-9586 | 8 | For an integer array nums, an inverse pair is a pair of integers [i, j] where 0 <= i < j < nums.length and nums[i] > nums[j].
Given two integers n and k, return the number of different arrays consisting of numbers from 1 to n such that there are exactly k inverse pairs. Since the answer can be huge, return it modulo 10... | Python3 || dp,1D array, 10 lines, w/ explanation || T/M: 95%/86% | 657 | k-inverse-pairs-array | 0.429 | warrenruud | Hard | 10,562 | 629 |
course schedule iii | class Solution:
def scheduleCourse(self, courses: List[List[int]]) -> int:
courses.sort(key=lambda c: c[1])
A, curr = [], 0
for dur, ld in courses:
heapq.heappush(A,-dur)
curr += dur
if curr > ld: curr += heapq.heappop(A)
return len(A) | https://leetcode.com/problems/course-schedule-iii/discuss/2185553/Python3-oror-Heapq-oror-Faster-Solution-with-explanation | 28 | There are n different online courses numbered from 1 to n. You are given an array courses where courses[i] = [durationi, lastDayi] indicate that the ith course should be taken continuously for durationi days and must be finished before or on lastDayi.
You will start on the 1st day and you cannot take two or more course... | Python3 || Heapq || Faster Solution with explanation | 1,000 | course-schedule-iii | 0.402 | bvian | Hard | 10,570 | 630 |
smallest range covering elements from k lists | class Solution:
def smallestRange(self, nums: List[List[int]]) -> List[int]:
k=len(nums)
maxx=-float('inf')
ans=[0,float('inf')]
heap=[]
for i in range(k):
heap.append((nums[i][0],i,0))
if nums[i][0]>maxx:maxx=nums[i][0]
heapq.heapify(heap)
... | https://leetcode.com/problems/smallest-range-covering-elements-from-k-lists/discuss/1495460/PYTHON-SOLUTION-FASTER-THAN-88.58-OF-PYTHON-SUBMISSIONS | 1 | You have k lists of sorted integers in non-decreasing order. Find the smallest range that includes at least one number from each of the k lists.
We define the range [a, b] is smaller than range [c, d] if b - a < d - c or a < c if b - a == d - c.
Example 1:
Input: nums = [[4,10,15,24,26],[0,9,12,20],[5,18,22,30]]
Outp... | PYTHON SOLUTION FASTER THAN 88.58% OF PYTHON SUBMISSIONS | 113 | smallest-range-covering-elements-from-k-lists | 0.606 | reaper_27 | Hard | 10,585 | 632 |
sum of square numbers | class Solution:
def judgeSquareSum(self, c: int) -> bool:
low = 0
high = int(sqrt(c))
if high**2 == c:
return True
while low<=high:
x = low **2 + high **2
if x == c:
return True
if x > c:
... | https://leetcode.com/problems/sum-of-square-numbers/discuss/2203194/Python3-solution-using-two-pointers | 6 | Given a non-negative integer c, decide whether there're two integers a and b such that a2 + b2 = c.
Example 1:
Input: c = 5
Output: true
Explanation: 1 * 1 + 2 * 2 = 5
Example 2:
Input: c = 3
Output: false
Constraints:
0 <= c <= 231 - 1 | 📌 Python3 solution using two pointers | 89 | sum-of-square-numbers | 0.346 | Dark_wolf_jss | Medium | 10,592 | 633 |
exclusive time of functions | class Solution:
def exclusiveTime(self, n: int, logs: List[str]) -> List[int]:
helper = lambda log: (int(log[0]), log[1], int(log[2])) # to covert id and time to integer
logs = [helper(log.split(':')) for log in logs] # convert [string] to [(,,)]
ans, s = [0] * n, [] ... | https://leetcode.com/problems/exclusive-time-of-functions/discuss/863039/Python-3-or-Clean-Simple-Stack-or-Explanation | 15 | On a single-threaded CPU, we execute a program containing n functions. Each function has a unique ID between 0 and n-1.
Function calls are stored in a call stack: when a function call starts, its ID is pushed onto the stack, and when a function call ends, its ID is popped off the stack. The function whose ID is at the ... | Python 3 | Clean, Simple Stack | Explanation | 1,100 | exclusive-time-of-functions | 0.611 | idontknoooo | Medium | 10,614 | 636 |
average of levels in binary tree | class Solution:
def averageOfLevels(self, root: TreeNode) -> List[float]:
if not root:
# Quick response for empty tree
return []
traversal_q = [root]
average = []
while traversal_q:
# co... | https://leetcode.com/problems/average-of-levels-in-binary-tree/discuss/492462/PythonGo-O(n)-by-level-order-traversal.-w-Explanation | 10 | Given the root of a binary tree, return the average value of the nodes on each level in the form of an array. Answers within 10-5 of the actual answer will be accepted.
Example 1:
Input: root = [3,9,20,null,null,15,7]
Output: [3.00000,14.50000,11.00000]
Explanation: The average value of nodes on level 0 is 3, on leve... | Python/Go O(n) by level-order-traversal. [ w/ Explanation ] | 1,300 | average-of-levels-in-binary-tree | 0.717 | brianchiang_tw | Easy | 10,629 | 637 |
shopping offers | class Solution:
def shoppingOffers(self, price: List[int], special: List[List[int]], needs: List[int]) -> int:
n = len(price)
@lru_cache(maxsize=None)
def dfs(needs):
ans = sum([i*j for i, j in zip(price, needs)])
cur = sys.maxsize
for s in special:
... | https://leetcode.com/problems/shopping-offers/discuss/783072/Python-3-DFS-%2B-Memoization-(lru_cache) | 2 | In LeetCode Store, there are n items to sell. Each item has a price. However, there are some special offers, and a special offer consists of one or more different kinds of items with a sale price.
You are given an integer array price where price[i] is the price of the ith item, and an integer array needs where needs[i]... | Python 3 DFS + Memoization (lru_cache) | 292 | shopping-offers | 0.541 | idontknoooo | Medium | 10,657 | 638 |
decode ways ii | class Solution:
def numDecodings(self, s: str) -> int:
non_zero = ['1', '2', '3', '4', '5', '6', '7', '8', '9']
first_incl, second_incl = 1, 0
first_excl, second_excl = 0, 0
if s[0] in non_zero:
second_incl = 1
if s[0] == '*':
second_incl = 9
... | https://leetcode.com/problems/decode-ways-ii/discuss/2509952/Best-Python3-implementation-(Top-93.7)-oror-Clean-code | 0 | A message containing letters from A-Z can be encoded into numbers using the following mapping:
'A' -> "1"
'B' -> "2"
...
'Z' -> "26"
To decode an encoded message, all the digits must be grouped then mapped back into letters using the reverse of the mapping above (there may be multiple ways). For example, "11106" can be... | ✔️ Best Python3 implementation (Top 93.7%) || Clean code | 25 | decode-ways-ii | 0.304 | UpperNoot | Hard | 10,662 | 639 |
solve the equation | class Solution:
def solveEquation(self, equation: str) -> str:
def helper(l,r): # left inclusive and right exclusive
constant = unknown = 0
sign,val = 1,''
while l < r:
if equation[l].isnumeric():
val += equation[l]
elif... | https://leetcode.com/problems/solve-the-equation/discuss/837106/Python-or-No-Regex-or-Simple-Logic-or-Probably-better-for-interviews-or-Commented | 6 | Solve a given equation and return the value of 'x' in the form of a string "x=#value". The equation contains only '+', '-' operation, the variable 'x' and its coefficient. You should return "No solution" if there is no solution for the equation, or "Infinite solutions" if there are infinite solutions for the equation.
... | Python | No Regex | Simple Logic | Probably better for interviews | Commented | 299 | solve-the-equation | 0.434 | since2020 | Medium | 10,664 | 640 |
maximum average subarray i | class Solution:
def findMaxAverage(self, nums: List[int], k: int) -> float:
M = d = 0
for i in range(len(nums)-k):
d += nums[i+k] - nums[i]
if d > M: M = d
return (sum(nums[:k])+M)/k
- Python 3
- Junaid Mansuri | https://leetcode.com/problems/maximum-average-subarray-i/discuss/336428/Solution-in-Python-3-(beats-100) | 11 | You are given an integer array nums consisting of n elements, and an integer k.
Find a contiguous subarray whose length is equal to k that has the maximum average value and return this value. Any answer with a calculation error less than 10-5 will be accepted.
Example 1:
Input: nums = [1,12,-5,-6,50,3], k = 4
Output:... | Solution in Python 3 (beats 100%) | 2,100 | maximum-average-subarray-i | 0.438 | junaidmansuri | Easy | 10,672 | 643 |
set mismatch | class Solution:
def findErrorNums(self, nums: List[int]) -> List[int]:
c=Counter(nums)
l=[0,0]
for i in range(1,len(nums)+1):
if c[i]==2:
l[0]=i
if c[i]==0:
l[1]=i
return l | https://leetcode.com/problems/set-mismatch/discuss/2733971/Easy-Python-Solution | 14 | You have a set of integers s, which originally contains all the numbers from 1 to n. Unfortunately, due to some error, one of the numbers in s got duplicated to another number in the set, which results in repetition of one number and loss of another number.
You are given an integer array nums representing the data stat... | Easy Python Solution | 966 | set-mismatch | 0.43 | Vistrit | Easy | 10,705 | 645 |
maximum length of pair chain | class Solution:
def findLongestChain(self, pairs: List[List[int]]) -> int:
pairs.sort()
rt = 1
l = pairs[0]
for r in range(1,len(pairs)):
if l[1] < pairs[r][0]:
rt += 1
l = pairs[r]
elif pairs[r][1]<l[1]:
l = pa... | https://leetcode.com/problems/maximum-length-of-pair-chain/discuss/1564508/Fast-O(NlogN)-and-simple-Python-3-solution | 2 | You are given an array of n pairs pairs where pairs[i] = [lefti, righti] and lefti < righti.
A pair p2 = [c, d] follows a pair p1 = [a, b] if b < c. A chain of pairs can be formed in this fashion.
Return the length longest chain which can be formed.
You do not need to use up all the given intervals. You can select pair... | Fast O(NlogN) and simple Python 3 solution | 156 | maximum-length-of-pair-chain | 0.564 | cyrille-k | Medium | 10,764 | 646 |
palindromic substrings | class Solution:
def countSubstrings(self, s: str) -> int:
L, r = len(s), 0
for i in range(L):
for a,b in [(i,i),(i,i+1)]:
while a >= 0 and b < L and s[a] == s[b]: a -= 1; b += 1
r += (b-a)//2
return r
- Junaid Mansuri
(LeetCode ID)@hotmail.com | https://leetcode.com/problems/palindromic-substrings/discuss/392119/Solution-in-Python-3-(beats-~94)-(six-lines)-(With-Detaiiled-Explanation) | 67 | Given a string s, return the number of palindromic substrings in it.
A string is a palindrome when it reads the same backward as forward.
A substring is a contiguous sequence of characters within the string.
Example 1:
Input: s = "abc"
Output: 3
Explanation: Three palindromic strings: "a", "b", "c".
Example 2:
Input:... | Solution in Python 3 (beats ~94%) (six lines) (With Detaiiled Explanation) | 8,100 | palindromic-substrings | 0.664 | junaidmansuri | Medium | 10,781 | 647 |
replace words | class Solution:
def replaceWords(self, dictionary: List[str], sentence: str) -> str:
d = {w:len(w) for w in dictionary}
mini, maxi = min(d.values()), max(d.values())
wd = sentence.split()
rt = []
for s in wd:
c = s
for k in range(mini,min(maxi,len(s))... | https://leetcode.com/problems/replace-words/discuss/1576514/Fast-solution-beats-97-submissions | 3 | In English, we have a concept called root, which can be followed by some other word to form another longer word - let's call this word successor. For example, when the root "help" is followed by the successor word "ful", we can form a new word "helpful".
Given a dictionary consisting of many roots and a sentence consis... | Fast solution beats 97% submissions | 118 | replace-words | 0.627 | cyrille-k | Medium | 10,832 | 648 |
dota2 senate | class Solution:
def predictPartyVictory(self, senate: str) -> str:
n = len(senate)
s, banned = set(), [False] * n
ban_d = ban_r = 0
while len(s) != 1:
s = set()
for i, p in enumerate(senate):
if banned[i]: continue
if p == 'R':
... | https://leetcode.com/problems/dota2-senate/discuss/845912/Python-3-or-Greedy-Simulation-or-Explanantion | 8 | In the world of Dota2, there are two parties: the Radiant and the Dire.
The Dota2 senate consists of senators coming from two parties. Now the Senate wants to decide on a change in the Dota2 game. The voting for this change is a round-based procedure. In each round, each senator can exercise one of the two rights:
Ban ... | Python 3 | Greedy, Simulation | Explanantion | 690 | dota2-senate | 0.404 | idontknoooo | Medium | 10,852 | 649 |
2 keys keyboard | class Solution:
def minSteps(self, n: int) -> int:
dp = [float('inf')] * (n+1)
## Intialize a dp array to store the solutions of sub problems i.e. number of steps needed
dp[1] = 0
## Intially first element of dp array with 0 as 'A' is already present and we haven't consumed any steps... | https://leetcode.com/problems/2-keys-keyboard/discuss/727856/Python3-Dynamic-Programming-Beginners | 12 | There is only one character 'A' on the screen of a notepad. You can perform one of two operations on this notepad for each step:
Copy All: You can copy all the characters present on the screen (a partial copy is not allowed).
Paste: You can paste the characters which are copied last time.
Given an integer n, return the... | Python3 Dynamic Programming - Beginners | 1,000 | 2-keys-keyboard | 0.532 | ayushjain94 | Medium | 10,857 | 650 |
find duplicate subtrees | class Solution:
def findDuplicateSubtrees(self, root: TreeNode) -> List[TreeNode]:
seen = collections.defaultdict(int)
res = []
def helper(node):
if not node:
return
sub = tuple([helper(node.left), node.val, helper(node.right)])
... | https://leetcode.com/problems/find-duplicate-subtrees/discuss/1178526/Easy-%2B-Clean-%2B-Straightforward-Python-Recursive | 15 | Given the root of a binary tree, return all duplicate subtrees.
For each kind of duplicate subtrees, you only need to return the root node of any one of them.
Two trees are duplicate if they have the same structure with the same node values.
Example 1:
Input: root = [1,2,3,4,null,2,4,null,null,4]
Output: [[2,4],[4]]
... | Easy + Clean + Straightforward Python Recursive | 1,100 | find-duplicate-subtrees | 0.565 | Pythagoras_the_3rd | Medium | 10,880 | 652 |
two sum iv input is a bst | class Solution:
def findTarget(self, root: TreeNode, k: int) -> bool:
queue = [root]
unique_set = set()
while len(queue) > 0:
current = queue.pop()
if k - current.val in unique_set: return True
unique_set.add(current.val)
if current.le... | https://leetcode.com/problems/two-sum-iv-input-is-a-bst/discuss/1011974/BFS-two-pointers-and-recursive | 2 | Given the root of a binary search tree and an integer k, return true if there exist two elements in the BST such that their sum is equal to k, or false otherwise.
Example 1:
Input: root = [5,3,6,2,4,null,7], k = 9
Output: true
Example 2:
Input: root = [5,3,6,2,4,null,7], k = 28
Output: false
Constraints:
The number... | BFS, two pointers and recursive | 213 | two-sum-iv-input-is-a-bst | 0.61 | borodayev | Easy | 10,886 | 653 |
maximum binary tree | class Solution:
def constructMaximumBinaryTree(self, nums: List[int]) -> TreeNode:
# base case
if not nums:
return None
max_val = max(nums)
max_idx = nums.index(max_val)
root = TreeNode(max_val)
root.left = self.constructMaximumB... | https://leetcode.com/problems/maximum-binary-tree/discuss/944324/simple-python3-solution-with-recursion | 2 | You are given an integer array nums with no duplicates. A maximum binary tree can be built recursively from nums using the following algorithm:
Create a root node whose value is the maximum value in nums.
Recursively build the left subtree on the subarray prefix to the left of the maximum value.
Recursively build the r... | simple python3 solution with recursion | 100 | maximum-binary-tree | 0.845 | Gushen88 | Medium | 10,922 | 654 |
print binary tree | class Solution:
def printTree(self, root: TreeNode) -> List[List[str]]:
height = 0
def dfs(node, h): # Find height
nonlocal height
height = max(height, h)
if node.left:
dfs(node.left, h+1)
if node.right: ... | https://leetcode.com/problems/print-binary-tree/discuss/1384379/Python-3-or-DFS-%2B-BFS-(Level-order-traversal)-or-Explanation | 2 | Given the root of a binary tree, construct a 0-indexed m x n string matrix res that represents a formatted layout of the tree. The formatted layout matrix should be constructed using the following rules:
The height of the tree is height and the number of rows m should be equal to height + 1.
The number of columns n sho... | Python 3 | DFS + BFS (Level-order-traversal) | Explanation | 256 | print-binary-tree | 0.614 | idontknoooo | Medium | 10,937 | 655 |
robot return to origin | class Solution:
def judgeCircle(self, moves: str) -> bool:
return moves.count('L') == moves.count('R') and moves.count('U') == moves.count('D')
- Python 3
- Junaid Mansuri | https://leetcode.com/problems/robot-return-to-origin/discuss/342078/Solution-in-Python-3-(~beats-99)-(-one-line-) | 11 | There is a robot starting at the position (0, 0), the origin, on a 2D plane. Given a sequence of its moves, judge if this robot ends up at (0, 0) after it completes its moves.
You are given a string moves that represents the move sequence of the robot where moves[i] represents its ith move. Valid moves are 'R' (right),... | Solution in Python 3 (~beats 99%) ( one line ) | 1,600 | robot-return-to-origin | 0.753 | junaidmansuri | Easy | 10,943 | 657 |
find k closest elements | class Solution:
def findClosestElements(self, arr: List[int], k: int, x: int) -> List[int]:
# first binary search where the value 'x' should be in the sorted array
n = len(arr)
low, high = 0, n - 1
while low <= high:
mid = low + (high - low) // 2
if arr[mid] == x:
... | https://leetcode.com/problems/find-k-closest-elements/discuss/1310805/Python-Solution | 13 | Given a sorted integer array arr, two integers k and x, return the k closest integers to x in the array. The result should also be sorted in ascending order.
An integer a is closer to x than an integer b if:
|a - x| < |b - x|, or
|a - x| == |b - x| and a < b
Example 1:
Input: arr = [1,2,3,4,5], k = 4, x = 3
Output: [... | Python Solution | 1,000 | find-k-closest-elements | 0.468 | mariandanaila01 | Medium | 10,973 | 658 |
split array into consecutive subsequences | class Solution:
def isPossible(self, nums: List[int]) -> bool:
len1 = len2 = absorber = 0
prev_num = nums[0] - 1
for streak_len, streak_num in Solution.get_streaks(nums):
if streak_num == prev_num + 1:
spillage = streak_len - len1 - len2
if spillage < 0:
return False
absorber = min(a... | https://leetcode.com/problems/split-array-into-consecutive-subsequences/discuss/2446738/Python-524ms-98.3-Faster-Multiple-solutions-94-memory-efficient | 44 | You are given an integer array nums that is sorted in non-decreasing order.
Determine if it is possible to split nums into one or more subsequences such that both of the following conditions are true:
Each subsequence is a consecutive increasing sequence (i.e. each integer is exactly one more than the previous integer)... | Python 524ms 98.3% Faster Multiple solutions 94% memory efficient | 2,900 | split-array-into-consecutive-subsequences | 0.506 | anuvabtest | Medium | 11,024 | 659 |
image smoother | class Solution:
def imageSmoother(self, M: List[List[int]]) -> List[List[int]]:
row, col = len(M), len(M[0])
res = [[0]*col for i in range(row)]
dirs = [[0,0],[0,1],[0,-1],[1,0],[-1,0],[1,1],[-1,-1],[-1,1],[1,-1]]
for i in range(row):
for j in range(col):
... | https://leetcode.com/problems/image-smoother/discuss/454951/Python3-simple-solution | 12 | An image smoother is a filter of the size 3 x 3 that can be applied to each cell of an image by rounding down the average of the cell and the eight surrounding cells (i.e., the average of the nine cells in the blue smoother). If one or more of the surrounding cells of a cell is not present, we do not consider it in the... | Python3 simple solution | 807 | image-smoother | 0.551 | jb07 | Easy | 11,038 | 661 |
maximum width of binary tree | class Solution:
def widthOfBinaryTree(self, root: TreeNode) -> int:
Q = collections.deque()
Q.append((root,0))
ans = 0
while Q:
length = len(Q)
_, start = Q[0]
for i in range(length):
node, index = Q.popleft()
if nod... | https://leetcode.com/problems/maximum-width-of-binary-tree/discuss/688259/Python-solution-O(N)-BFS-traversal | 4 | Given the root of a binary tree, return the maximum width of the given tree.
The maximum width of a tree is the maximum width among all levels.
The width of one level is defined as the length between the end-nodes (the leftmost and rightmost non-null nodes), where the null nodes between the end-nodes that would be pres... | Python solution - O(N) BFS traversal | 489 | maximum-width-of-binary-tree | 0.407 | realslimshady | Medium | 11,045 | 662 |
strange printer | class Solution:
def strangePrinter(self, s: str) -> int:
s = "".join(ch for i, ch in enumerate(s) if i == 0 or s[i-1] != ch)
@cache
def fn(lo, hi):
"""Return min ops to print s[lo:hi]."""
if lo == hi: return 0
ans = 1 + fn(lo+1, hi)
f... | https://leetcode.com/problems/strange-printer/discuss/1492420/Python3-dp | 3 | There is a strange printer with the following two special properties:
The printer can only print a sequence of the same character each time.
At each turn, the printer can print new characters starting from and ending at any place and will cover the original existing characters.
Given a string s, return the minimum numb... | [Python3] dp | 378 | strange-printer | 0.468 | ye15 | Hard | 11,066 | 664 |
non decreasing array | class Solution:
def checkPossibility(self, nums: List[int]) -> bool:
cnt_violations=0
for i in range(1, len(nums)):
if nums[i]<nums[i-1]:
if cnt_violations==1:
return False
cnt_violations+=1
... | https://leetcode.com/problems/non-decreasing-array/discuss/2193030/Python-Easy-Greedy-w-explanation-O(1)-space | 52 | Given an array nums with n integers, your task is to check if it could become non-decreasing by modifying at most one element.
We define an array is non-decreasing if nums[i] <= nums[i + 1] holds for every i (0-based) such that (0 <= i <= n - 2).
Example 1:
Input: nums = [4,2,3]
Output: true
Explanation: You could mo... | Python Easy Greedy w/ explanation - O(1) space | 2,800 | non-decreasing-array | 0.242 | constantine786 | Medium | 11,067 | 665 |
beautiful arrangement ii | class Solution:
def constructArray(self, n: int, k: int) -> List[int]:
lo, hi = 1, n
ans = []
while lo <= hi:
if k&1:
ans.append(lo)
lo += 1
else:
ans.append(hi)
hi -= 1
if k > 1: k -=... | https://leetcode.com/problems/beautiful-arrangement-ii/discuss/1158414/Python3-greedy | 1 | Given two integers n and k, construct a list answer that contains n different positive integers ranging from 1 to n and obeys the following requirement:
Suppose this list is answer = [a1, a2, a3, ... , an], then the list [|a1 - a2|, |a2 - a3|, |a3 - a4|, ... , |an-1 - an|] has exactly k distinct integers.
Return the li... | [Python3] greedy | 57 | beautiful-arrangement-ii | 0.597 | ye15 | Medium | 11,096 | 667 |
kth smallest number in multiplication table | class Solution:
def findKthNumber(self, m: int, n: int, k: int) -> int:
# special cases: k == 1, k == m * n
if k == 1:
return 1
if k == m * n:
return m * n
# make the matrix a tall one - height >= width
# because later I will loop along the width. This will reduce t... | https://leetcode.com/problems/kth-smallest-number-in-multiplication-table/discuss/1581461/Binary-Search-Solution-with-detailed-explanation-beating-98-in-time-and-86-in-space | 1 | Nearly everyone has used the Multiplication Table. The multiplication table of size m x n is an integer matrix mat where mat[i][j] == i * j (1-indexed).
Given three integers m, n, and k, return the kth smallest element in the m x n multiplication table.
Example 1:
Input: m = 3, n = 3, k = 5
Output: 3
Explanation: The... | Binary Search Solution with detailed explanation, beating 98% in time and 86% in space | 83 | kth-smallest-number-in-multiplication-table | 0.515 | leonine9 | Hard | 11,104 | 668 |
trim a binary search tree | class Solution:
def trimBST(self, root: TreeNode, low: int, high: int) -> TreeNode:
if not root: return root
if root.val < low: return self.trimBST(root.right, low, high)
if root.val > high: return self.trimBST(root.left, low, high)
root.left = self.trimBST(root.left, low, high)
root.right = self.trimBST(roo... | https://leetcode.com/problems/trim-a-binary-search-tree/discuss/1046286/Python.-faster-than-98.05.-recursive.-6-lines.-DFS. | 24 | Given the root of a binary search tree and the lowest and highest boundaries as low and high, trim the tree so that all its elements lies in [low, high]. Trimming the tree should not change the relative structure of the elements that will remain in the tree (i.e., any node's descendant should remain a descendant). It c... | Python. faster than 98.05%. recursive. 6 lines. DFS. | 1,000 | trim-a-binary-search-tree | 0.663 | m-d-f | Medium | 11,107 | 669 |
maximum swap | class Solution:
def maximumSwap(self, num: int) -> int:
s = list(str(num))
n = len(s)
for i in range(n-1): # find index where s[i] < s[i+1], meaning a chance to flip
if s[i] < s[i+1]: break
else: return num ... | https://leetcode.com/problems/maximum-swap/discuss/846837/Python-3-or-Greedy-Math-or-Explanations | 43 | You are given an integer num. You can swap two digits at most once to get the maximum valued number.
Return the maximum valued number you can get.
Example 1:
Input: num = 2736
Output: 7236
Explanation: Swap the number 2 and the number 7.
Example 2:
Input: num = 9973
Output: 9973
Explanation: No swap.
Constraints:
0... | Python 3 | Greedy, Math | Explanations | 3,600 | maximum-swap | 0.479 | idontknoooo | Medium | 11,137 | 670 |
second minimum node in a binary tree | class Solution:
def findSecondMinimumValue(self, root: TreeNode) -> int:
def inorderTraversal(root):
if not root:
return []
else:
return inorderTraversal(root.left) + [root.val] + inorderTraversal(root.right)
r = set(inorderTraversal(root))
if len(r)>=2:
return sorted(list(r))[1]
else:
retu... | https://leetcode.com/problems/second-minimum-node-in-a-binary-tree/discuss/405721/Beats-100-Python-Solution | 2 | Given a non-empty special binary tree consisting of nodes with the non-negative value, where each node in this tree has exactly two or zero sub-node. If the node has two sub-nodes, then this node's value is the smaller value among its two sub-nodes. More formally, the property root.val = min(root.left.val, root.right.v... | Beats 100% Python Solution | 424 | second-minimum-node-in-a-binary-tree | 0.44 | saffi | Easy | 11,162 | 671 |
bulb switcher ii | class Solution:
def flipLights(self, n: int, m: int) -> int:
def fn(n, m):
"""Return number of different status."""
if m * n == 0: return 1
return fn(n-1, m-1) + fn(n-1, m)
return fn(min(n, 3), min(m, 3)) | https://leetcode.com/problems/bulb-switcher-ii/discuss/897976/Python3-O(1) | 4 | There is a room with n bulbs labeled from 1 to n that all are turned on initially, and four buttons on the wall. Each of the four buttons has a different functionality where:
Button 1: Flips the status of all the bulbs.
Button 2: Flips the status of all the bulbs with even labels (i.e., 2, 4, ...).
Button 3: Flips the ... | [Python3] O(1) | 462 | bulb-switcher-ii | 0.51 | ye15 | Medium | 11,168 | 672 |
number of longest increasing subsequence | class Solution:
def findNumberOfLIS(self, nums: List[int]) -> int:
dp = [1] * len(nums)
ct = [1] * len(nums)
maxLen, maxCt = 0, 0
# same as the LIS code, iterate
# over all the elements once and then
# from 0 -> i again to compute LISs
for i in range(... | https://leetcode.com/problems/number-of-longest-increasing-subsequence/discuss/1881188/Python-DP-solution-explained | 2 | Given an integer array nums, return the number of longest increasing subsequences.
Notice that the sequence has to be strictly increasing.
Example 1:
Input: nums = [1,3,5,4,7]
Output: 2
Explanation: The two longest increasing subsequences are [1, 3, 4, 7] and [1, 3, 5, 7].
Example 2:
Input: nums = [2,2,2,2,2]
Output:... | [Python] DP solution explained | 182 | number-of-longest-increasing-subsequence | 0.423 | buccatini | Medium | 11,171 | 673 |
longest continuous increasing subsequence | class Solution:
def findLengthOfLCIS(self, nums: List[int]) -> int:
counter=1
temp=1
for i in range(0,len(nums)-1):
if nums[i]<nums[i+1]:
temp+=1
if temp>counter:
counter=temp
else:
temp=1
ret... | https://leetcode.com/problems/longest-continuous-increasing-subsequence/discuss/2445685/Two-python-solutions-using-dp-and-a-straightforward-soln | 3 | Given an unsorted array of integers nums, return the length of the longest continuous increasing subsequence (i.e. subarray). The subsequence must be strictly increasing.
A continuous increasing subsequence is defined by two indices l and r (l < r) such that it is [nums[l], nums[l + 1], ..., nums[r - 1], nums[r]] and f... | Two python solutions using dp and a straightforward soln | 182 | longest-continuous-increasing-subsequence | 0.491 | guneet100 | Easy | 11,178 | 674 |
cut off trees for golf event | class Solution:
def cutOffTree(self, forest: List[List[int]]) -> int:
forest.append([0] * len(forest[0]))
for row in forest: row.append(0)
def bfs(end, start):
if end == start: return 0
visited, queue = set(), {start}
visited.add(start)
step = ... | https://leetcode.com/problems/cut-off-trees-for-golf-event/discuss/1204000/Python-normal-and-priority-BFS-faster-than-99-and-faster-than-77 | 4 | You are asked to cut off all the trees in a forest for a golf event. The forest is represented as an m x n matrix. In this matrix:
0 means the cell cannot be walked through.
1 represents an empty cell that can be walked through.
A number greater than 1 represents a tree in a cell that can be walked through, and this nu... | Python, normal and priority BFS, faster than 99% and faster than 77% | 681 | cut-off-trees-for-golf-event | 0.342 | dustlihy | Hard | 11,200 | 675 |
valid parenthesis string | class Solution:
def checkValidString(self, s: str) -> bool:
# store the indices of '('
stk = []
# store the indices of '*'
star = []
for idx, char in enumerate(s):
if char == '(':
stk.append( idx )
... | https://leetcode.com/problems/valid-parenthesis-string/discuss/584655/Python-O(n)-by-stack.-85%2B-w-Comment | 23 | Given a string s containing only three types of characters: '(', ')' and '*', return true if s is valid.
The following rules define a valid string:
Any left parenthesis '(' must have a corresponding right parenthesis ')'.
Any right parenthesis ')' must have a corresponding left parenthesis '('.
Left parenthesis '(' mus... | Python O(n) by stack. 85%+ [w/ Comment] | 813 | valid-parenthesis-string | 0.339 | brianchiang_tw | Medium | 11,206 | 678 |
valid palindrome ii | class Solution:
def validPalindrome(self, s: str) -> bool:
p1=0
p2=len(s)-1
while p1<=p2:
if s[p1]!=s[p2]:
string1=s[:p1]+s[p1+1:]
string2=s[:p2]+s[p2+1:]
return string1==string1[::-1] or string2==string2... | https://leetcode.com/problems/valid-palindrome-ii/discuss/1409641/Python-3-oror-Two-Pointer-Approach-oror-Self-Understandable | 85 | Given a string s, return true if the s can be palindrome after deleting at most one character from it.
Example 1:
Input: s = "aba"
Output: true
Example 2:
Input: s = "abca"
Output: true
Explanation: You could delete the character 'c'.
Example 3:
Input: s = "abc"
Output: false
Constraints:
1 <= s.length <= 105
s con... | Python 3 || Two Pointer Approach || Self-Understandable | 5,500 | valid-palindrome-ii | 0.393 | bug_buster | Easy | 11,223 | 680 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.