Skip to content

Commit 2987da0

Browse files
Garvit244Garvit244
committedApr 14, 2019
Solution for latest problems
1 parent 3bed800 commit 2987da0

File tree

6 files changed

+277
-0
lines changed

6 files changed

+277
-0
lines changed
 

‎1000-1100q/1020.py

+61
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,61 @@
1+
'''
2+
Given a 2D array A, each cell is 0 (representing sea) or 1 (representing land)
3+
4+
A move consists of walking from one land square 4-directionally to another land square, or off the boundary of the grid.
5+
6+
Return the number of land squares in the grid for which we cannot walk off the boundary of the grid in any number of moves.
7+
8+
9+
10+
Example 1:
11+
12+
Input: [[0,0,0,0],[1,0,1,0],[0,1,1,0],[0,0,0,0]]
13+
Output: 3
14+
Explanation:
15+
There are three 1s that are enclosed by 0s, and one 1 that isn't enclosed because its on the boundary.
16+
Example 2:
17+
18+
Input: [[0,1,1,0],[0,0,1,0],[0,0,1,0],[0,0,0,0]]
19+
Output: 0
20+
Explanation:
21+
All 1s are either on the boundary or can reach the boundary.
22+
23+
24+
Note:
25+
26+
1 <= A.length <= 500
27+
1 <= A[i].length <= 500
28+
0 <= A[i][j] <= 1
29+
All rows have the same size.
30+
'''
31+
32+
class Solution(object):
33+
def numEnclaves(self, A):
34+
"""
35+
:type A: List[List[int]]
36+
:rtype: int
37+
"""
38+
result = 0
39+
queue = []
40+
for row in range(len(A)):
41+
for col in range(len(A[0])):
42+
result += A[row][col]
43+
if (row*col == 0 or row == len(A)-1 or col == len(A[0])-1) and A[row][col] == 1:
44+
queue.append((row, col))
45+
46+
x_move = [-1, 0, 1, 0]
47+
y_move = [0, 1, 0, -1]
48+
49+
while queue:
50+
x, y = queue.pop(0)
51+
A[x][y] = 0
52+
result -= 1
53+
54+
for xm, ym in zip(x_move, y_move):
55+
nx = x + xm
56+
ny = y + ym
57+
58+
if 0<= nx <len(A) and 0 <= ny < len(A[0]) and A[nx][ny] == 1 and (nx, ny) not in queue:
59+
queue.append((nx, ny))
60+
61+
return result

‎1000-1100q/1025.py

+50
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,50 @@
1+
'''
2+
Alice and Bob take turns playing a game, with Alice starting first.
3+
4+
Initially, there is a number N on the chalkboard. On each player's turn, that player makes a move consisting of:
5+
6+
Choosing any x with 0 < x < N and N % x == 0.
7+
Replacing the number N on the chalkboard with N - x.
8+
Also, if a player cannot make a move, they lose the game.
9+
10+
Return True if and only if Alice wins the game, assuming both players play optimally.
11+
12+
13+
14+
Example 1:
15+
16+
Input: 2
17+
Output: true
18+
Explanation: Alice chooses 1, and Bob has no more moves.
19+
Example 2:
20+
21+
Input: 3
22+
Output: false
23+
Explanation: Alice chooses 1, Bob chooses 1, and Alice has no more moves.
24+
25+
26+
Note:
27+
28+
1 <= N <= 1000
29+
'''
30+
31+
class Solution(object):
32+
def divisorGame(self, N):
33+
"""
34+
:type N: int
35+
:rtype: bool
36+
"""
37+
if N == 0:
38+
return False
39+
40+
move = 0
41+
while N > 1:
42+
for num in range(1, N):
43+
if N%num == 0:
44+
N -= num
45+
move += 1
46+
break
47+
# print move
48+
if move%2:
49+
return True
50+
return False

‎1000-1100q/1026.py

+62
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,62 @@
1+
'''
2+
Given the root of a binary tree, find the maximum value V for which there exists different nodes A and B where V = |A.val - B.val| and A is an ancestor of B.
3+
(A node A is an ancestor of B if either: any child of A is equal to B, or any child of A is an ancestor of B.)
4+
5+
6+
Example 1:
7+
8
8+
/ \
9+
3 10
10+
/ \ \
11+
1 6 14
12+
/ \ /
13+
4 7 13
14+
15+
Input: [8,3,10,1,6,null,14,null,null,4,7,13]
16+
Output: 7
17+
Explanation:
18+
We have various ancestor-node differences, some of which are given below :
19+
|8 - 3| = 5
20+
|3 - 7| = 4
21+
|8 - 1| = 7
22+
|10 - 13| = 3
23+
Among all possible differences, the maximum value of 7 is obtained by |8 - 1| = 7.
24+
25+
26+
Note:
27+
28+
The number of nodes in the tree is between 2 and 5000.
29+
Each node will have value between 0 and 100000.
30+
'''
31+
32+
# Definition for a binary tree node.
33+
# class TreeNode(object):
34+
# def __init__(self, x):
35+
# self.val = x
36+
# self.left = None
37+
# self.right = None
38+
39+
class Solution(object):
40+
41+
def maxAncestorDiff(self, root):
42+
"""
43+
:type root: TreeNode
44+
:rtype: int
45+
"""
46+
47+
def utility_fun(root, res):
48+
if not root:
49+
return 2147483648, -2147483648, res
50+
if not root.left and not root.right:
51+
return root.val, root.val, res
52+
left_t, lmax_t, res = utility_fun(root.left, res)
53+
right_t, rmax_t, res = utility_fun(root.right, res)
54+
m_val = min(left_t, right_t)
55+
max_val = max(lmax_t, rmax_t)
56+
57+
res = max(res, max(abs(root.val-m_val), abs(root.val-max_val)))
58+
# print res
59+
return min(m_val, root.val), max(max_val, root.val), res
60+
61+
x, x2, res = utility_fun(root, -2147483648)
62+
return abs(res)

‎1000-1100q/1027.py

+37
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,37 @@
1+
'''
2+
Given an array A of integers, return the length of the longest arithmetic subsequence in A.
3+
4+
Recall that a subsequence of A is a list A[i_1], A[i_2], ..., A[i_k] with 0 <= i_1 < i_2 < ... < i_k <= A.length - 1, and that a sequence B is arithmetic if B[i+1] - B[i] are all the same value (for 0 <= i < B.length - 1).
5+
6+
7+
8+
Example 1:
9+
10+
Input: [3,6,9,12]
11+
Output: 4
12+
Explanation:
13+
The whole array is an arithmetic sequence with steps of length = 3.
14+
Example 2:
15+
16+
Input: [9,4,7,2,10]
17+
Output: 3
18+
Explanation:
19+
The longest arithmetic subsequence is [4,7,10].
20+
'''
21+
22+
class Solution(object):
23+
def longestArithSeqLength(self, A):
24+
"""
25+
:type A: List[int]
26+
:rtype: int
27+
"""
28+
from collections import defaultdict
29+
30+
dp = defaultdict(int)
31+
# print dp
32+
for index_i in range(len(A)):
33+
for index_j in range(index_i):
34+
diff = A[index_i] - A[index_j]
35+
dp[(index_i, diff)] = max(dp[(index_i, diff)], dp[(index_j, diff)]+1)
36+
# print dp
37+
return max(dp.itervalues())+1

‎1000-1100q/1028.py

+62
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,62 @@
1+
'''
2+
We run a preorder depth first search on the root of a binary tree.
3+
4+
At each node in this traversal, we output D dashes (where D is the depth of this node), then we output the value of this node. (If the depth of a node is D, the depth of its immediate child is D+1. The depth of the root node is 0.)
5+
6+
If a node has only one child, that child is guaranteed to be the left child.
7+
8+
Given the output S of this traversal, recover the tree and return its root
9+
Example 1:
10+
1
11+
/ \
12+
2 5
13+
/ \ / \
14+
3 4 6 7
15+
16+
17+
18+
Input: "1-2--3--4-5--6--7"
19+
Output: [1,2,5,3,4,6,7]
20+
Example 2:
21+
1
22+
/ \
23+
2 5
24+
/ /
25+
3 6
26+
/ /
27+
4 7
28+
29+
Input: "1-2--3---4-5--6---7"
30+
Output: [1,2,5,3,null,6,null,4,null,7]
31+
32+
33+
Example 3:
34+
35+
36+
37+
Input: "1-401--349---90--88"
38+
Output: [1,401,null,349,88,90]
39+
40+
41+
Note:
42+
43+
The number of nodes in the original tree is between 1 and 1000.
44+
Each node will have a value between 1 and 10^9.
45+
'''
46+
47+
class Solution(object):
48+
def longestArithSeqLength(self, A):
49+
"""
50+
:type A: List[int]
51+
:rtype: int
52+
"""
53+
from collections import defaultdict
54+
55+
dp = defaultdict(int)
56+
# print dp
57+
for index_i in range(len(A)):
58+
for index_j in range(index_i):
59+
diff = A[index_i] - A[index_j]
60+
dp[(index_i, diff)] = max(dp[(index_i, diff)], dp[(index_j, diff)]+1)
61+
# print dp
62+
return max(dp.itervalues())+1

‎README.md

+5
Original file line numberDiff line numberDiff line change
@@ -7,9 +7,14 @@ Python solution of problems from [LeetCode](https://leetcode.com/).
77
##### [Problems 1000-1100](./1000-1100q/)
88
| # | Title | Solution | Difficulty |
99
|---| ----- | -------- | ---------- |
10+
|1028|[Recover a Tree From Preorder Traversal](https://leetcode.com/problems/recover-a-tree-from-preorder-traversal)|[Python](./1000-1100q/1028.py)|Hard|
11+
|1027|[Longest Arithmetic Sequence](https://leetcode.com/problems/longest-arithmetic-sequence)|[Python](./1000-1100q/1027.py)|Medium|
12+
|1026|[Maximum Difference Between Node and Ancestor](https://leetcode.com/problems/maximum-difference-between-node-and-ancestor)|[Python](./1000-1100q/1026.py)|Medium|
13+
|1025|[Divisor Game](https://leetcode.com/problems/divisor-game/)|[Python](./1000-1100q/1025.py)|Easy|
1014
|1023|[Camelcase Matching](https://leetcode.com/problems/camelcase-matching)|[Python](./1000-1100q/1023.py)|Medium|
1115
|1022|[Sum of Root To Leaf Binary Numbers](https://leetcode.com/problems/sum-of-root-to-leaf-binary-numbers)|[Python](./1000-1100q/1022.py)|Easy|
1216
|1021|[Remove Outermost Parentheses](https://leetcode.com/problems/remove-outermost-parentheses)|[Python](./1000-1100q/1021.py)|Easy|
17+
|1020|[Number of Enclaves](https://leetcode.com/problems/number-of-enclaves)|[Python](./1000-1100q/1020.py)|Medium|
1318
|1019|[Next Greater Node In Linked List](https://leetcode.com/problems/next-greater-node-in-linked-list)|[Python](./1000-1100q/1019.py)|Medium|
1419
|1018|[Binary Prefix Divisible By 5](https://leetcode.com/problems/binary-prefix-divisible-by-5)|[Python](./1000-1100q/1018.py)|Easy|
1520
|1017|[Convert to Base -2](https://leetcode.com/problems/convert-to-base-2)|[Python](./1000-1100q/1017.py)|Medium|

0 commit comments

Comments
 (0)
Please sign in to comment.