Solutions of 995, 997, 998, 999

Author: Garvit244

900-1000q/995.py

@@ -0,0 +1,27 @@
+'''
+In an array A containing only 0s and 1s, a K-bit flip consists of choosing a (contiguous) subarray of length K and simultaneously changing every 0 in the subarray to 1, and every 1 in the subarray to 0.
+
+Return the minimum number of K-bit flips required so that there is no 0 in the array.  If it is not possible, return -1.
+
+Input: A = [0,1,0], K = 1
+Output: 2
+Explanation: Flip A[0], then flip A[2]
+'''
+
+class Solution:
+    def minKBitFlips(self, a: 'List[int]', k: 'int') -> 'int':
+        from collections import deque
+        q = deque()
+        res = 0
+        for i in range(len(a)):
+            if len(q) % 2 != 0:
+                if a[i] == 1:
+                    res += 1
+                    q.append(i+k-1)
+            else:
+                if a[i] == 0:
+                    res += 1
+                    q.append(i+k-1)
+            if q and q[0] == i: q.popleft()
+            if q and q[-1] >= len(a): return -1
+        return res    

900-1000q/997.py

@@ -0,0 +1,48 @@
+'''
+In a town, there are N people labelled from 1 to N.  There is a rumor that one of these people is secretly the town judge.
+
+If the town judge exists, then:
+
+The town judge trusts nobody.
+Everybody (except for the town judge) trusts the town judge.
+There is exactly one person that satisfies properties 1 and 2.
+You are given trust, an array of pairs trust[i] = [a, b] representing that the person labelled a trusts the person labelled b.
+
+If the town judge exists and can be identified, return the label of the town judge.  Otherwise, return -1.
+
+ 
+
+Example 1:
+
+Input: N = 2, trust = [[1,2]]
+Output: 2
+Example 2:
+
+Input: N = 3, trust = [[1,3],[2,3]]
+Output: 3
+'''
+
+class Solution(object):
+    def findJudge(self, N, trust):
+        """
+        :type N: int
+        :type trust: List[List[int]]
+        :rtype: int
+        """
+        if not trust:
+            return 1
+        mapping = {}
+        unique = set()
+        for truste_list in trust:
+            unique.add(truste_list[0])
+            if truste_list[1] in mapping:
+                mapping[truste_list[1]] += 1
+            else:
+                mapping[truste_list[1]] = 1
+            
+        unique_set = len(unique)
+        for key, value in mapping.items():
+            if value == unique_set:
+                return key
+        return -1
+        

900-1000q/998.py

@@ -0,0 +1,74 @@
+'''
+We are given the root node of a maximum tree: a tree where every node has a value greater than any other value in its subtree.
+
+Just as in the previous problem, the given tree was constructed from an list A (root = Construct(A)) recursively with the following Construct(A) routine:
+
+If A is empty, return null.
+Otherwise, let A[i] be the largest element of A.  Create a root node with value A[i].
+The left child of root will be Construct([A[0], A[1], ..., A[i-1]])
+The right child of root will be Construct([A[i+1], A[i+2], ..., A[A.length - 1]])
+Return root.
+Note that we were not given A directly, only a root node root = Construct(A).
+
+Suppose B is a copy of A with the value val appended to it.  It is guaranteed that B has unique values.
+
+Return Construct(B).
+
+ 
+
+Example 1:
+
+
+
+Input: root = [4,1,3,null,null,2], val = 5
+Output: [5,4,null,1,3,null,null,2]
+Explanation: A = [1,4,2,3], B = [1,4,2,3,5]
+Example 2:
+
+
+Input: root = [5,2,4,null,1], val = 3
+Output: [5,2,4,null,1,null,3]
+Explanation: A = [2,1,5,4], B = [2,1,5,4,3]
+'''
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+        
+    def insertIntoMaxTree(self, root, val):
+        """
+        :type root: TreeNode
+        :type val: int
+        :rtype: TreeNode
+        """
+        new_node = TreeNode(val)
+        if not root:
+            return new_node
+        
+        if root.val < val:
+            new_node.left = root
+            return new_node
+        
+        nrwwt = root
+        start, prev = root.right, root
+    
+        while start:
+            if(start.val > val):
+                prev = start
+                start = start.right
+            else:
+                break
+            
+
+        prev.right = new_node
+        if not start:
+            new_node.right = start
+        else:
+            new_node.left = start
+        
+        return root
+        

900-1000q/999.py

@@ -0,0 +1,87 @@
+'''
+On an 8 x 8 chessboard, there is one white rook.  There also may be empty squares, white bishops, and black pawns.  These are given as characters 'R', '.', 'B', and 'p' respectively. Uppercase characters represent white pieces, and lowercase characters represent black pieces.
+
+The rook moves as in the rules of Chess: it chooses one of four cardinal directions (north, east, west, and south), then moves in that direction until it chooses to stop, reaches the edge of the board, or captures an opposite colored pawn by moving to the same square it occupies.  Also, rooks cannot move into the same square as other friendly bishops.
+
+Return the number of pawns the rook can capture in one move.
+
+Input: [[".",".",".",".",".",".",".","."],[".",".",".","p",".",".",".","."],[".",".",".","R",".",".",".","p"],[".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".","."],[".",".",".","p",".",".",".","."],[".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".","."]]
+Output: 3
+Explanation: 
+In this example the rook is able to capture all the pawns.
+'''
+
+class Solution(object):
+    def numRookCaptures(self, board):
+        """
+        :type board: List[List[str]]
+        :rtype: int
+        """
+        result = 0
+        rook_index = (0, 0)
+        for row in range(len(board)):
+            for col in range(len(board[0])):
+                if board[row][col] == 'R':
+                    rook_index = (row, col)
+                    break
+               
+        flag = True
+        col = rook_index[1]-1
+        pawn = 0
+        while col >= 0:
+            if board[rook_index[0]][col] == 'B':
+                flag = False
+                break
+            if board[rook_index[0]][col] == 'p':
+                pawn += 1
+                break
+            col -= 1
+        if flag and pawn != 0:
+            result += 1
+            
+        flag = True
+        col = rook_index[1]+1
+        pawn = 0
+        while col < len(board[0]):
+            if board[rook_index[0]][col] == 'B':
+                flag = False
+                break
+            if board[rook_index[0]][col] == 'p':
+                pawn += 1
+                break
+            col += 1
+            
+        if flag and pawn != 0:
+            result += 1
+        
+        flag = True
+        row = rook_index[0]+1
+        pawn = 0
+        while row < len(board):
+            if board[row][rook_index[1]] == 'B':
+                flag = False
+                break
+                
+            if board[row][rook_index[1]] == 'p':
+                pawn += 1
+                break
+            row += 1
+            
+        if flag and pawn != 0:
+            result += 1
+            
+        pawn = 0
+        flag = True
+        row = rook_index[0]-1
+        while row >= 0:
+            if board[row][rook_index[1]] == 'B':
+                flag = False
+                break
+            if board[row][rook_index[1]] == 'p':
+                pawn += 1
+                break
+            row -= 1
+        if flag and pawn != 0:
+            result += 1
+        
+        return result

README.md

@@ -7,6 +7,10 @@ Python solution of problems from [LeetCode](https://leetcode.com/).
 ##### [Problems 900-1000](./900-1000q/)
 | # | Title | Solution | Difficulty |
 |---| ----- | -------- | ---------- |
+|999|[Available Captures for Rook](https://leetcode.com/problems/available-captures-for-rook/)|[Python](./900-1000q/999.py)|Medium|
+|998|[Maximum Binary Tree II](https://leetcode.com/problems/maximum-binary-tree-ii) | [Python](./900-1000q/998.py) | Easy|
+|997|[Find the Town Judge](https://leetcode.com/problems/find-the-town-judge/) | [Python](./900-1000q/997.py) | Easy|
+|995|[Minimum Number of K Consecutive Bit Flips](https://leetcode.com/problems/minimum-number-of-k-consecutive-bit-flips/) | [Python](./900-1000q/995.py) | Hard|
 |994|[Rotting Oranges](https://leetcode.com/problems/rotting-oranges/) | [Python](./900-1000q/994.py)|Easy|
 |993|[Cousins in Binary Tree](https://leetcode.com/problems/cousins-in-binary-tree/) | [Python](./900-1000q/993.py)|Easy|
 |991|[Broken Calculator](https://leetcode.com/problems/broken-calculator/) | [Python](./900-1000q/991.py)|Medium|