Adding solutions of 70, 71, 73, 74 problems

Author: Garvit244

70.py

@@ -0,0 +1,34 @@
+'''
+	You are climbing a stair case. It takes n steps to reach to the top.
+
+	Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?
+
+	Note: Given n will be a positive integer.
+
+	Example 1:
+
+	Input: 2
+	Output: 2
+	Explanation: There are two ways to climb to the top.
+	1. 1 step + 1 step
+	2. 2 steps
+'''
+
+class Solution(object):
+    def climbStairs(self, n):
+        """
+        :type n: int
+        :rtype: int
+        """
+        if n == 0:
+        	return 0
+
+        dp = [0]*n
+        dp[0], dp[1] = 1, 2
+
+        for index in range(2, n):
+        	dp[index] = dp[index-1] + dp[index-2]
+        return dp[n-1]
+
+# Time: O(N)
+# Space: O(N)

71.py

@@ -0,0 +1,51 @@
+'''
+	Given an absolute path for a file (Unix-style), simplify it.
+
+	For example,
+	path = "/home/", => "/home"
+	path = "/a/./b/../../c/", => "/c"
+'''
+
+class Solution(object):
+    def simplifyPath(self, path):
+        """
+        :type path: str
+        :rtype: str
+        """
+
+        result = "/"
+        stack = []
+
+        index = 0
+        while index < len(path):
+        	if path[index] == '/':
+        		index += 1
+        		continue
+
+
+        	curr_str = ""
+        	while index < len(path) and path[index] != '/':
+        		curr_str += path[index]
+        		index += 1
+
+        	if curr_str == '.' or curr_str == "":
+        		index += 1
+        		continue
+        	elif curr_str == "..":
+        		if stack:
+	        		stack.pop()
+        		index += 1
+        	else:
+        		stack.append(curr_str)
+        		index += 1
+
+        for index in range(len(stack)):
+        	if index != len(stack) -1:
+        		result += stack[index] + '/'
+        	else:
+        		result += stack[index]
+
+        return result
+
+# Time: O(N)
+# Space: O(N)

73.py

@@ -0,0 +1,21 @@
+class Solution(object):
+    def setZeroes(self, matrix):
+        """
+        :type matrix: List[List[int]]
+        :rtype: void Do not return anything, modify matrix in-place instead.
+        """
+        col0 = 1
+        for row in range(len(matrix)):
+        	if matrix[row][0] == 0:
+        		col0 = 0
+        	for col in range(1, len(matrix[0])):
+        		if matrix[row][col] == 0:
+        			matrix[row][0] = 0
+        			matrix[0][col] = 0
+        for row in range(len(matrix)-1, -1, -1):
+        	for col in range(len(matrix[0])-1, 0, -1):
+        		if matrix[row][0] == 0 or matrix[0][col] == 0:
+        			matrix[row][col] = 0
+        	if col0 == 0:
+        		matrix[row][0] = 0
+

74.py

@@ -0,0 +1,36 @@
+'''
+	Write an efficient algorithm that searches for a value in an m x n matrix. This matrix has the following properties:
+
+	Integers in each row are sorted from left to right.
+	The first integer of each row is greater than the last integer of the previous row.
+	Example 1:
+
+	Input:
+	matrix = [
+	  [1,   3,  5,  7],
+	  [10, 11, 16, 20],
+	  [23, 30, 34, 50]
+	]
+	target = 3
+	Output: true
+'''
+class Solution(object):
+    def searchMatrix(self, matrix, target):
+        """
+        :type matrix: List[List[int]]
+        :type target: int
+        :rtype: bool
+        """
+
+        if not matrix:
+        	return 0
+        left, right = 0, len(matrix[0])-1
+
+        while left < len(matrix) and right >= 0:
+        	if matrix[left][right] == target:
+        		return True 
+        	elif matrix[left][right] < target:
+        		left += 1
+        	else:
+        		right -= 1
+        return False