Added assessment questions + solutions

Author: das-jishu

.vscode/settings.json

@@ -1,3 +1,4 @@
 {
-    "python.linting.enabled": false
+    "python.linting.enabled": false,
+    "python.languageServer": "None"
 }

Assessments/balance-index.py

@@ -0,0 +1,16 @@
+
+# BALANCE INDEX
+
+# O(N) time and O(1) space, where N -> length of input array
+def balanceIndex(array):
+    # Write your code here.
+    rightSum = sum(array)
+	leftSum = 0
+	
+	for i in range(len(array)):
+		leftSum = leftSum + array[i - 1] if i != 0 else leftSum
+		rightSum -= array[i]
+		if leftSum == rightSum:
+			return i
+		
+	return -1

Assessments/build-failures.py

@@ -0,0 +1,38 @@
+
+# BUILD FAILURES
+
+# O(N*log(S)) time, O(1) space, where N -> length of buildRuns array
+# S -> length of longest buildRun
+def buildFailures(buildRuns):
+    # Write your code here.
+    longestRun = 0
+	currentRun = 1
+	currentHighest = float("-inf")
+	
+	for buildRun in buildRuns:
+		start = 0
+		end = len(buildRun) - 1
+		mid = 0
+		while start <= end:
+			mid = (start + end) // 2
+			if buildRun[mid] == False:
+				if buildRun[mid - 1] == True:
+					break
+				else:
+					end = mid - 1
+			
+			else:
+				start = mid + 1		
+		
+		totalBuilds = len(buildRun)
+		percentage = mid / totalBuilds * 100
+		
+		if percentage >= currentHighest:
+			currentRun = 1
+		else:
+			currentRun += 1
+			
+		currentHighest = percentage	
+		longestRun = max(longestRun, currentRun)
+			
+	return longestRun if longestRun > 1 else -1

Assessments/count-contained-permutations.py

@@ -0,0 +1,51 @@
+
+# COUNT CONTAINED PERMUTATIONS
+
+# O(M * U + N) time and O(U) space, where M -> length of big string,
+# U -> number of unique characters in small string, N -> length
+# of small string.
+# U is actually a constant since it can't be greater than 26. and 
+# M > N, so M will dissolve N
+# So, modified complexities:
+# O(M) time and O(1) space, M -> length of big string
+def countContainedPermutations(bigString, smallString):
+    # Write your code here.
+    smallCount, bigCount = {}, {}
+	for letter in smallString:
+		if letter not in smallCount:
+			smallCount[letter] = 0
+		smallCount[letter] += 1
+		
+	bigSize, smallSize = len(bigString), len(smallString)
+	start, end, totalCount = 0, 0, 0
+	
+	while end < bigSize:
+		letterToAdd = bigString[end]
+		if letterToAdd not in bigCount:
+			bigCount[letterToAdd] = 0
+		bigCount[letterToAdd] += 1
+		
+		if end - start == smallSize:
+			letterToRemove = bigString[start]
+			if bigCount[letterToRemove] == 1:
+				del bigCount[letterToRemove]
+			else:
+				bigCount[letterToRemove] -= 1
+			
+			start += 1
+			
+		if matchCounts(bigCount, smallCount):
+			totalCount += 1
+			
+		end += 1		
+			
+	return totalCount
+
+def matchCounts(bigCount, smallCount):
+	for letter in smallCount:
+		if letter not in bigCount:
+			return False
+		if smallCount[letter] != bigCount[letter]:
+			return False
+		
+	return True

Assessments/degrees-of-separation.py

@@ -0,0 +1,50 @@
+
+# DEGREES OF SEPARATION
+
+# O(V + E) time, O(V) space
+def degreesOfSeparation(friendsLists, personOne, personTwo):
+    # Write your code here.
+    degrees, visited = {}, {}
+	findDegrees(friendsLists, personOne, degrees, visited, 0)
+	getUnconnectedPeople(friendsLists, degrees)
+	countOne = 0
+	for person in degrees:
+		if degrees[person] > 6:
+			countOne += 1
+	
+	print(degrees)
+	degrees, visited = {}, {}
+	findDegrees(friendsLists, personTwo, degrees, visited, 0)
+	getUnconnectedPeople(friendsLists, degrees)
+	countTwo = 0
+	for person in degrees:
+		if degrees[person] > 6:
+			countTwo += 1
+	print(degrees)		
+	if countOne < countTwo:
+		return personOne
+	elif countTwo < countOne:
+		return personTwo
+	else:
+		return ""
+
+def findDegrees(friendsLists, person, degrees, visited, level):
+	degrees[person] = 0
+	queue = [(person, 0)]
+	#visited = {person: True}
+	while queue:
+		current = queue.pop(0)
+		#visited[current[0]] = True
+		level = current[1]
+		for friend in friendsLists[current[0]]:
+			if friend in visited:
+				continue
+			visited[friend] = True
+			degrees[friend] = level + 1
+			queue.append((friend, level + 1))
+
+
+def getUnconnectedPeople(friendsLists, degrees):
+	for friend in friendsLists:
+		if friend not in degrees:
+			degrees[friend] = float("inf")

Assessments/glob-matching.py

@@ -0,0 +1,27 @@
+
+# GLOB MATCHING
+
+# O(n * m) time and space
+def globMatching(fileName, pattern):
+    # Write your code here.
+	match = [[False for _ in range(len(pattern) + 1)] for _ in range(len(fileName) + 1)]
+	match[0][0] = True
+	for i in range(1, len(fileName) + 1):
+		match[i][0] = False
+		
+	for row in range(len(fileName) + 1):
+		for col in range(1, len(pattern) + 1):
+			if row == 0:
+				if pattern[col - 1] == "*":
+					match[row][col] = match[row][col - 1]
+				continue
+			
+			if pattern[col - 1] == "*":
+				match[row][col] = match[row - 1][col - 1] or match[row][col - 1] or match[row - 1][col]
+			elif pattern[col - 1] == "?":
+				match[row][col] = match[row - 1][col - 1]
+			else:
+				match[row][col] = match[row - 1][col - 1] and fileName[row - 1] == pattern[col - 1]
+	print(match)
+	return match[-1][-1]
+	

Assessments/inverted-bisection.py

@@ -0,0 +1,48 @@
+
+# INVERTED BISECTION
+
+# This is an input class. Do not edit.
+class LinkedList:
+    def __init__(self, value):
+        self.value = value
+        self.next = None
+
+# O(N) time and O(1) space
+def invertedBisection(head):
+    # Write your code here.
+	if head is None or head.next is None:
+		return head
+	
+	prev = None
+    slow = head
+	fast = head
+	while fast and fast.next:
+		prev = slow
+		slow = slow.next
+		fast = fast.next.next
+		
+	hasEvenCount = True if fast == None else False
+	prev.next = None
+	if hasEvenCount:
+		firstHalf = reverseLinkedList(head)
+		secondHalf = reverseLinkedList(slow)
+		head.next = secondHalf
+		return firstHalf
+	else:
+		firstHalf = reverseLinkedList(head)
+		secondHalf = reverseLinkedList(slow.next)
+		head.next = slow
+		slow.next = secondHalf
+		return firstHalf
+
+def reverseLinkedList(head):
+	prev = None
+	cur = head
+	while cur is not None:
+		temp = cur.next
+		cur.next = prev
+		prev = cur
+		cur = temp
+		
+	return prev
+		

Assessments/largest-bst-size.py

@@ -0,0 +1,32 @@
+
+# LARGEST BST SIZE
+
+# O(n) time and O(h) space, n -> number of nodes, h -> height of tree
+def largestBstSize(tree):
+    # Write your code here.
+    totalNodes, largestSize, isBST = getLargest(tree)
+	return largestSize
+	
+def getLargest(node):
+	if node == None:
+		return (0, 0, True)
+	
+	left = node.left.value if node.left is not None else float("-inf")
+	right = node.right.value if node.right is not None else float("inf")
+	countLeft, largestLeft, isLeftBST = getLargest(node.left)
+	countRight, largestRight, isRightBST = getLargest(node.right)
+	
+	if left < node.value <= right and isLeftBST and isRightBST:
+		totalCount = countLeft + countRight + 1
+		return (totalCount, totalCount, True)
+	
+	else:
+		return (0, max(largestLeft, largestRight), False)
+
+
+# This is an input class. Do not edit.
+class BinaryTree:
+    def __init__(self, value):
+        self.value = value
+        self.left = None
+        self.right = None

Assessments/longest-increasing-matrix-path.py

@@ -0,0 +1,51 @@
+
+# LONGEST INCREASING MATRIX PATH
+
+# O(M * N) time, O(M * N) space, M -> number of rows in input matrix
+# N -> number of columns in input matrix
+def longestIncreasingMatrixPath(matrix):
+    # Write your code here.
+    maxLength = 0
+	m, n = len(matrix), len(matrix[0])
+	cache = [[None for i in range(n)] for j in range(m)]
+	
+	for i in range(m):
+		for j in range(n):
+			length = findLongest(matrix, i, j, cache)
+			maxLength = max(maxLength, length)
+	
+	return maxLength
+
+def findLongest(matrix, row, col, cache):
+	if cache[row][col] != None:
+		return cache[row][col]
+	
+	num = matrix[row][col]
+	matrix[row][col] = None
+	
+	neighbors = getNeighbors(matrix, row, col)
+	maximum = float("-inf")
+	for i, j in neighbors:
+		if matrix[i][j] == None or matrix[i][j] <= num:
+			continue
+		getMaxLength = findLongest(matrix, i, j, cache)
+		maximum = max(maximum, 1 + getMaxLength)
+		
+	matrix[row][col] = num
+	cache[row][col] = maximum if maximum != float("-inf") else 1
+	
+	return cache[row][col]
+	
+def getNeighbors(matrix, row, col):
+	neighbors = []
+	
+	if row != 0:
+		neighbors.append([row - 1, col])
+	if row != len(matrix) - 1:
+		neighbors.append([row + 1, col])
+	if col != 0:
+		neighbors.append([row, col - 1])
+	if col != len(matrix[0]) - 1:
+		neighbors.append([row, col + 1])
+		
+	return neighbors

Assessments/longest-streak-of-adjacent-ones.py

@@ -0,0 +1,30 @@
+
+# LONGEST STREAK OF ADJACENT ONES
+
+# O(N) time and O(1) space
+def longestStreakOfAdjacentOnes(array):
+    # Write your code here.
+    index = -1
+	maximumOnes = 0
+	
+	for i in range(len(array)):
+		if array[i] == 0:
+			left = 0
+			j = i - 1
+			while j >= 0 and array[j] == 1:
+				j -= 1
+				left += 1
+			
+			j = i + 1
+			right = 0
+			while j < len(array) and array[j] == 1:
+				j += 1
+				right += 1
+				
+			total = left + right + 1
+			if total > maximumOnes:
+				maximumOnes = total
+				index = i
+				
+	return index
+				

Assessments/max-subsequence-dot-product.py

@@ -0,0 +1,23 @@
+
+# MAX SUBSEQUENCE DOT PRODUCT
+
+# O(m * n) time, O(m * n) space; m is the length of arrayOne and 
+# n is the length of arrayTwo
+def maxSubsequenceDotProduct(arrayOne, arrayTwo):
+    # Write your code here.
+	# This solution takes care of a situation where the max dot product is less than zero.
+	# This covers all edges, so this is the correct optimal solution.
+	
+	m, n = len(arrayOne), len(arrayTwo)
+    dp = [[float("-inf") for i in range(m + 1)] for j in range(n + 1)]
+	
+	for i in range(1, n + 1):
+		for j in range(1, m + 1):
+			first = arrayOne[j - 1]
+			second = arrayTwo[i - 1]
+			product = first * second
+			sum = product if dp[i - 1][j - 1] == float("-inf") else dp[i - 1][j - 1] + product
+			dp[i][j] = max(dp[i - 1][j], dp[i][j - 1], sum)
+	
+	return dp[-1][-1]
+