Skip to content

Commit 52c93a6

Browse files
blocageblocage
committed
Added solutions
0 parents  commit 52c93a6

File tree

808 files changed

+9864
-0
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

808 files changed

+9864
-0
lines changed

‎1-two-sum/2022-04-24 20.32.16 - Accepted - runtime 7220ms - memory 14.9MB.py

+6
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,6 @@
1+
class Solution:
2+
def twoSum(self, nums: List[int], target: int) -> List[int]:
3+
_len = len(nums)
4+
for i in range(_len):
5+
for j in range(i + 1, _len):
6+
if nums[i] + nums[j] == target: return [i, j]

‎1-two-sum/2022-04-24 20.33.20 - Accepted - runtime 86ms - memory 15.3MB.py

+9
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,9 @@
1+
class Solution:
2+
def twoSum(self, nums: List[int], target: int) -> List[int]:
3+
hashmap = {}
4+
for i in range(len(nums)):
5+
hashmap[nums[i]] = i
6+
for i in range(len(nums)):
7+
complement = target - nums[i]
8+
if complement in hashmap and hashmap[complement] != i:
9+
return [i, hashmap[complement]]

‎1-two-sum/2022-04-24 20.33.33 - Accepted - runtime 69ms - memory 15.2MB.py

+8
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,8 @@
1+
class Solution:
2+
def twoSum(self, nums: List[int], target: int) -> List[int]:
3+
hashmap = {}
4+
for i in range(len(nums)):
5+
complement = target - nums[i]
6+
if complement in hashmap:
7+
return [i, hashmap[complement]]
8+
hashmap[nums[i]] = i

‎1-two-sum/2022-04-24 20.33.39 - Accepted - runtime 66ms - memory 15.1MB.py

+8
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,8 @@
1+
class Solution:
2+
def twoSum(self, nums: List[int], target: int) -> List[int]:
3+
hashmap = {}
4+
for i in range(len(nums)):
5+
complement = target - nums[i]
6+
if complement in hashmap:
7+
return [i, hashmap[complement]]
8+
hashmap[nums[i]] = i

‎1-two-sum/2022-04-24 20.59.59 - Accepted - runtime 107ms - memory 15.4MB.py

+8
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,8 @@
1+
class Solution:
2+
def twoSum(self, nums: List[int], target: int) -> List[int]:
3+
remainders = {}
4+
for i in range(len(nums)):
5+
remainder = target - nums[i]
6+
if remainder in remainders:
7+
return [remainders[remainder], i]
8+
remainders[target - remainder] = i

‎1-two-sum/2022-04-24 21.00.39 - Accepted - runtime 69ms - memory 15.3MB.py

+8
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,8 @@
1+
class Solution:
2+
def twoSum(self, nums: List[int], target: int) -> List[int]:
3+
remainders = {}
4+
for i in range(len(nums)):
5+
remainder = target - nums[i]
6+
if remainder in remainders:
7+
return [remainders[remainder], i]
8+
remainders[nums[i]] = i

‎1-two-sum/2022-06-14 17.49.42 - Accepted - runtime 109ms - memory 15.4MB.py

+8
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,8 @@
1+
class Solution:
2+
def twoSum(self, nums: List[int], target: int) -> List[int]:
3+
d = {}
4+
for ind, i in enumerate(nums):
5+
rem = target - i
6+
if i in d:
7+
return [ind, d[i]]
8+
d[rem] = ind

‎1-two-sum/2022-06-14 17.49.56 - Accepted - runtime 132ms - memory 15.4MB.py

+8
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,8 @@
1+
class Solution:
2+
def twoSum(self, nums: List[int], target: int) -> List[int]:
3+
d = {}
4+
for ind, i in enumerate(nums):
5+
rem = target - i
6+
if i in d:
7+
return [ind, d[i]]
8+
d[rem] = ind

‎1-two-sum/2022-12-30 22.14.34 - Accepted - runtime 56ms - memory 15.4MB.py

+9
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,9 @@
1+
class Solution:
2+
def twoSum(self, nums: List[int], target: int) -> List[int]:
3+
D = {}
4+
for ind, i in enumerate(nums):
5+
if i in D:
6+
return [D[i], ind]
7+
D[target - i] = ind
8+
9+
return [-1]

‎1-two-sum/2024-02-16 13.41.13 - Accepted - runtime 8ms - memory 14.1MB.cpp

+14
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,14 @@
1+
class Solution {
2+
public:
3+
vector<int> twoSum(vector<int>& nums, int target) {
4+
std::unordered_map<int, int> indices;
5+
for (int ind = 0; ind < nums.size(); ++ind) {
6+
int t = target - nums[ind];
7+
if (indices.find(t) != indices.end()) {
8+
return {indices[t], ind};
9+
}
10+
indices[nums[ind]] = ind;
11+
}
12+
return {};
13+
}
14+
};

‎1-two-sum/2024-03-08 19.17.13 - Accepted - runtime 51ms - memory 17.9MB.py

+10
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,10 @@
1+
class Solution:
2+
def twoSum(self, nums: List[int], target: int) -> List[int]:
3+
d = {}
4+
for ind, i in enumerate(nums):
5+
if i in d:
6+
return [d[i], ind]
7+
8+
d[target - i] = ind
9+
10+
return 1

‎10-regular-expression-matching/2024-03-10 18.10.28 - Accepted - runtime 82ms - memory 16.6MB.py

+9
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,9 @@
1+
from re import match, sub
2+
class Solution:
3+
def isMatch(self, s: str, p: str) -> bool:
4+
p = sub(r'\*+', '*', p)
5+
m = match(p, s)
6+
if not m:
7+
return m
8+
9+
return m.group(0) == s

‎100-same-tree/2022-06-24 17.00.11 - Accepted - runtime 62ms - memory 13.8MB.py

+19
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,19 @@
1+
# Definition for a binary tree node.
2+
# class TreeNode:
3+
# def __init__(self, val=0, left=None, right=None):
4+
# self.val = val
5+
# self.left = left
6+
# self.right = right
7+
class Solution:
8+
def check(self, node1: Optional[TreeNode], node2: Optional[TreeNode]) -> bool:
9+
if not node1:
10+
return not node2
11+
if not node2:
12+
return False
13+
if node1.val != node2.val:
14+
return False
15+
return self.check(node1.left, node2.left) and self.check(node1.right, node2.right)
16+
17+
18+
def isSameTree(self, p: Optional[TreeNode], q: Optional[TreeNode]) -> bool:
19+
return self.check(p, q)

‎100-same-tree/2023-01-10 19.53.33 - Accepted - runtime 32ms - memory 14MB.py

+21
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,21 @@
1+
class Solution:
2+
def isSameTree(self, p: Optional[TreeNode], q: Optional[TreeNode]) -> bool:
3+
if not p or not q:
4+
return p == q
5+
6+
p_stack = [p]
7+
q_stack = [q]
8+
9+
while p_stack or q_stack:
10+
p = p_stack.pop()
11+
q = q_stack.pop()
12+
if p and q:
13+
if p.val != q.val:
14+
return False
15+
p_stack.extend([p.left, p.right])
16+
q_stack.extend([q.left, q.right])
17+
18+
else:
19+
if p != q:return False
20+
21+
return True

‎100-same-tree/2024-02-18 16.55.55 - Accepted - runtime 0ms - memory 11.5MB.cpp

+19
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,19 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* struct TreeNode {
4+
* int val;
5+
* TreeNode *left;
6+
* TreeNode *right;
7+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
8+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
9+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
10+
* };
11+
*/
12+
class Solution {
13+
public:
14+
bool isSameTree(TreeNode* p, TreeNode* q) {
15+
if (!p || !q) return p == q;
16+
return p -> val == q -> val &&
17+
isSameTree(p -> left, q -> left) && isSameTree(p -> right, q -> right);
18+
}
19+
};

‎100-same-tree/2024-02-26 15.58.30 - Accepted - runtime 5ms - memory 11.5MB.cpp

+18
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,18 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* struct TreeNode {
4+
* int val;
5+
* TreeNode *left;
6+
* TreeNode *right;
7+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
8+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
9+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
10+
* };
11+
*/
12+
class Solution {
13+
public:
14+
bool isSameTree(TreeNode* p, TreeNode* q) {
15+
if (!p || !q) return p == q;
16+
return p->val == q->val && isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
17+
}
18+
};

‎1005-univalued-binary-tree/2024-01-27 19.51.54 - Accepted - runtime 37ms - memory 16.7MB.py

+18
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,18 @@
1+
# Definition for a binary tree node.
2+
# class TreeNode:
3+
# def __init__(self, val=0, left=None, right=None):
4+
# self.val = val
5+
# self.left = left
6+
# self.right = right
7+
class Solution:
8+
def isUnivalTree(self, root: Optional[TreeNode]) -> bool:
9+
k = set()
10+
s = [root]
11+
while s:
12+
n = s.pop()
13+
k.add(n.val)
14+
for c in (n.left, n.right):
15+
if c:
16+
s.append(c)
17+
18+
return len(k) < 2

‎1005-univalued-binary-tree/2024-02-20 13.15.32 - Accepted - runtime 5ms - memory 11.7MB.cpp

+25
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* struct TreeNode {
4+
* int val;
5+
* TreeNode *left;
6+
* TreeNode *right;
7+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
8+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
9+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
10+
* };
11+
*/
12+
class Solution {
13+
public:
14+
bool isUnivalTree(TreeNode* root) {
15+
stack<TreeNode*> st; st.push(root);
16+
int v = root -> val;
17+
while (!st.empty()){
18+
TreeNode* n = st.top(); st.pop();
19+
if (n -> val != v) return false;
20+
if (n -> left) st.push(n -> left);
21+
if (n -> right) st.push(n -> right);
22+
}
23+
return true;
24+
}
25+
};

‎1005-univalued-binary-tree/2024-02-20 13.16.00 - Accepted - runtime 3ms - memory 11.8MB.cpp

+25
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* struct TreeNode {
4+
* int val;
5+
* TreeNode *left;
6+
* TreeNode *right;
7+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
8+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
9+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
10+
* };
11+
*/
12+
class Solution {
13+
public:
14+
bool isUnivalTree(TreeNode* root) {
15+
stack<TreeNode*> st; st.push(root);
16+
int& v = root -> val;
17+
while (!st.empty()){
18+
TreeNode* n = st.top(); st.pop();
19+
if (n -> val != v) return false;
20+
if (n -> left) st.push(n -> left);
21+
if (n -> right) st.push(n -> right);
22+
}
23+
return true;
24+
}
25+
};

‎101-symmetric-tree/2022-06-24 19.53.57 - Accepted - runtime 73ms - memory 13.7MB.py

+25
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
# Definition for a binary tree node.
2+
# class TreeNode:
3+
# def __init__(self, val=0, left=None, right=None):
4+
# self.val = val
5+
# self.left = left
6+
# self.right = right
7+
class Solution:
8+
def check(self, left: Optional[TreeNode], right: Optional[TreeNode]) -> bool:
9+
if not left:
10+
return not right
11+
if not right:
12+
return False
13+
return left.val == right.val
14+
15+
def traverse(self, left: Optional[TreeNode], right: Optional[TreeNode]) -> bool:
16+
if not self.check(left, right):
17+
return False
18+
19+
if left and right:
20+
return self.traverse(left.left, right.right) and self.traverse(left.right, right.left)
21+
22+
return True
23+
24+
def isSymmetric(self, root: Optional[TreeNode]) -> bool:
25+
return self.traverse(root.left, root.right)

‎101-symmetric-tree/2023-03-13 14.00.04 - Accepted - runtime 31ms - memory 14MB.py

+16
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,16 @@
1+
# Definition for a binary tree node.
2+
# class TreeNode:
3+
# def __init__(self, val=0, left=None, right=None):
4+
# self.val = val
5+
# self.left = left
6+
# self.right = right
7+
class Solution:
8+
def check_nodes(self, left: Optional[TreeNode], right: Optional[TreeNode]) -> bool:
9+
if left is None or right is None:
10+
return left == right
11+
if left.val != right.val:
12+
return False
13+
return self.check_nodes(left.left, right.right) and self.check_nodes(left.right, right.left)
14+
15+
def isSymmetric(self, root: Optional[TreeNode]) -> bool:
16+
return root is None or self.check_nodes(root.left, root.right)

‎101-symmetric-tree/2023-03-13 14.11.32 - Accepted - runtime 35ms - memory 13.8MB.py

+25
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
# Definition for a binary tree node.
2+
# class TreeNode:
3+
# def __init__(self, val=0, left=None, right=None):
4+
# self.val = val
5+
# self.left = left
6+
# self.right = right
7+
class Solution:
8+
def isSymmetric(self, root: Optional[TreeNode]) -> bool:
9+
if root is None:
10+
return True
11+
12+
left, right = [root.left], [root.right]
13+
while left and right:
14+
l, r = left.pop(), right.pop()
15+
if l is None or r is None:
16+
if l != r:
17+
return False
18+
else:
19+
if l.val != r.val:
20+
return False
21+
22+
left.extend([l.left, l.right])
23+
right.extend([r.right, r.left])
24+
25+
return left == right

‎101-symmetric-tree/2024-02-18 17.33.01 - Accepted - runtime 5ms - memory 17.7MB.cpp

+32
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,32 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* struct TreeNode {
4+
* int val;
5+
* TreeNode *left;
6+
* TreeNode *right;
7+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
8+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
9+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
10+
* };
11+
*/
12+
class Solution {
13+
public:
14+
bool isSymmetric(TreeNode* root) {
15+
if (!root) return true;
16+
stack<TreeNode*> left, right;
17+
left.push(root -> left); right.push(root -> right);
18+
while (!left.empty() && !right.empty()){
19+
TreeNode* l = left.top(); left.pop();
20+
TreeNode* r = right.top(); right.pop();
21+
if (!l || !r){
22+
if (l != r) return false;
23+
}
24+
else {
25+
if (l -> val != r -> val) return false;
26+
left.push(l -> left); left.push(l -> right);
27+
right.push(r -> right); right.push(r -> left);
28+
}
29+
}
30+
return left.empty() && right.empty();
31+
}
32+
};

0 commit comments

Comments
 (0)