Adding solutions for Tasks Before Session 4

Author: tachyonlabs

README.md

@@ -137,3 +137,19 @@ And here's a GIF of my InterviewBit Trees, Binary Search, and Heaps and Maps top
 * [GIF of my InterviewBit Trees, Binary Search, and Heaps and Maps topic pages](https://github.com/tachyonlabs/CodePath-Alumni-Professional-Interview-Prep-Course/blob/master/interviewbit-trees-binary-search-and-heaps-and-maps-topics.gif)
 
 When I went to take the HackerRank "CodePath Interview Prep - Unit 3 Test", once again I got a message about how I had already taken this test last summer and "can't login to a test that you have already completed" -- see the "My situation" description at the beginning of this README for an explanation of that -- so as directed by Patricia in Slack, I took the test as tachyon+alt@tachyonlabs.com instead of tachyon@tachyonlabs.com, and you should have the results.
+
+## Tasks Before Session 4
+
+As shown in this GIF, I've already completed most of the Backtracking problems, and all of the Bit Manipulation problems, on InterviewBit (mostly in Python, but I've started doing Java versions of some of them as well):
+
+* GIF of my InterviewBit Backtracking and Bit Manipulation topic pages
+
+#### My InterviewBit Backtracking solutions so far: 
+
+Modular Expression, Reverse Link List Recursion, Subset, Combinations, Combination Sum II, Subsets II, Letter Phone, Generate all Parentheses II, NQueens, Permutations, and Gray Code.
+
+#### My InterviewBit Bit Manipulation solutions so far:
+
+* Java: Min XOR value, Number of 1 Bits, Reverse Bits, Single Number, and Single Number II.
+
+* Python: Min XOR value, Number of 1 Bits, Reverse Bits, Divide Integers, Different Bits Sum Pairwise, Single Number, and Single Number II.

interviewbit-backtracking-combination-sum-ii.py

@@ -0,0 +1,26 @@
+class Solution:
+ # @param A : list of integers
+ # @param B : integer
+ # @return a list of list of integers
+ def combinationSum(self, A, B):
+ """
+ This wss one of those ones where I do a first solution to check for correctness,
+ expecting that InterviewBit will fail it for efficiency, and that after that I
+ will work on optimizing it/coming up with a more efficient approach, but instead
+ it passes just fine.
+ """
+ combo_sums = []
+ combos = [[]]
+ A = sorted([x for x in A if x <= B])
+ for num in A:
+ temp = []
+ for combo in combos:
+ new_combo = combo + [num]
+ total = sum(new_combo)
+ if total == B and new_combo not in combo_sums:
+ combo_sums.append(new_combo)
+ elif total < B:
+ temp.append(new_combo)
+ combos += temp
+
+ return combo_sums

interviewbit-backtracking-combinations.py

@@ -0,0 +1,15 @@
+class Solution:
+ # @param n : integer
+ # @param k : integer
+ # @return a list of list of integers
+ def combine(self, n, k):
+ combos = [[]]
+ for i in range(k):
+ new_combos = []
+ for combo in combos:
+ for num in range(combo[-1] + 1 if combo else 1, n + 1):
+ new_combos.append(combo + [num])
+
+ combos = new_combos[:]
+
+ return combos

interviewbit-backtracking-generate-all-parentheses-ii.py

@@ -0,0 +1,19 @@
+class Solution:
+ # @param A : integer
+ # @return a list of strings
+ def all_parens(self, n, s="", opens=1, closes=0):
+ if len(s) == n * 2:
+ self.parens.append(s)
+ else:
+ if opens < n:
+ self.all_parens(n, s + "(", opens + 1, closes)
+ if closes < opens:
+ self.all_parens(n, s + ")", opens, closes + 1)
+
+ def generateParenthesis(self, A):
+ if A == 0:
+ return []
+
+ self.parens = []
+ self.all_parens(A, "(")
+ return self.parens

interviewbit-backtracking-gray-code.py

@@ -0,0 +1,6 @@
+class Solution:
+ # @param A : integer
+ # @return a list of integers
+ def grayCode(self, A):
+ # maybe this should be in bit manipulation instead
+ return [num ^ (num >> 1) for num in range(2**A)]

interviewbit-backtracking-letter-phone.py

@@ -0,0 +1,15 @@
+class Solution:
+ # @param A : string
+ # @return a list of strings
+ def letterCombinations(self, A):
+ keypad = ["0", "1", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"]
+ letter_combinations = list(keypad[int(str(A)[0])])
+ for digit in str(A)[1:]:
+ temp = []
+ for combo in letter_combinations:
+ for letter in keypad[int(digit)]:
+ temp.append(combo + letter)
+
+ letter_combinations = temp
+
+ return letter_combinations

interviewbit-backtracking-modular-expression.py

@@ -0,0 +1,16 @@
+class Solution:
+ # @param A : integer
+ # @param B : integer
+ # @param C : integer
+ # @return an integer
+ def Mod(self, A, B, C):
+ if not A:
+ return 0
+
+ if B == 0:
+ return 1
+ elif B % 2:
+ return ((A % C) * self.Mod(A, B - 1, C)) % C
+ else:
+ x = self.Mod(A, B / 2, C)
+ return x ** 2 % C

interviewbit-backtracking-nqueens.py

@@ -0,0 +1,29 @@
+class Solution:
+ # @param A : integer
+ # @return a list of list of strings
+ def can_place_queen(self, r, c, queens):
+ for qr, qc in queens:
+ if r == qr or c == qc or r + c == qr + qc or r - c == qr - qc:
+ return False
+
+ return True
+
+ def format_board(self, coords):
+ board = []
+ for r, c in coords:
+ board.append("." * c + "Q" + "." * (len(coords) - c - 1))
+
+ return board
+
+ def find_valid_boards(self, n, row=0, queens=tuple()):
+ for c in range(n):
+ if self.can_place_queen(row, c, queens):
+ if row == n - 1:
+ self.valid.append(queens + ((row, c),))
+ else:
+ self.find_valid_boards(n, row + 1, queens + ((row, c),))
+
+ def solveNQueens(self, A):
+ self.valid = []
+ self.find_valid_boards(A)
+ return [self.format_board(board) for board in self.valid]

interviewbit-backtracking-permutations.py

@@ -0,0 +1,19 @@
+class Solution:
+ # @param A : list of integers
+ # @return a list of list of integers
+ def permute(self, A):
+ # using Heap's algorithm (I had to look at my code from one of the previous times I've used it)
+ def heaps(length, data, permutations):
+ if length == 1:
+ permutations.append(data[:])
+ else:
+ for i in range(length):
+ heaps(length - 1, data, permutations)
+ if length % 2:
+ data[0], data[length - 1] = data[length - 1], data[0]
+ else:
+ data[i], data[length - 1] = data[length - 1], data[i]
+
+ return permutations
+
+ return heaps(len(A), A, [])

interviewbit-backtracking-reverse-link-list-recursion.py

@@ -0,0 +1,28 @@
+# Definition for singly-linked list.
+# class ListNode:
+# def __init__(self, x):
+# self.val = x
+# self.next = None
+
+class Solution:
+ # @param A : head node of linked list
+ # @return the head node in the linked list
+ def __init__(self):
+ self.head = None
+
+ def recursive_reverse(self, node):
+ if not node.next:
+ self.head = node
+ return
+ else:
+ self.recursive_reverse(node.next)
+ temp = node.next
+ temp.next = node
+ node.next = None
+
+ def reverseList(self, A):
+ if not A or not A.next:
+ return A
+
+ self.recursive_reverse(A)
+ return self.head