leetcode

Author: bgoonz

leetcode/Add_Binary.py

@@ -0,0 +1,32 @@
+# Given two binary strings, return their sum (also a binary string).
+#
+# The input strings are both non-empty and contains only characters 1 or 0.
+#
+# Example 1:
+#
+# Input: a = "11", b = "1"
+# Output: "100"
+
+
+# Example 2:
+#
+# Input: a = "1010", b = "1011"
+# Output: "10101"
+
+
+class Solution:
+    def addBinary(self, a, b):
+        x, y = int(a, 2), int(b, 2)
+
+        while y:
+            answer = x ^ y
+            carry = (x & y) << 1
+            x, y = answer, carry
+
+        return bin(x)
+
+
+if __name__ == "__main__":
+    a = "1010"
+    b = "1011"
+    print(Solution().addBinary(a, b))

leetcode/Add_Strings.py

@@ -0,0 +1,42 @@
+# Given two non-negative integers num1 and num2 represented as string, return the sum of num1 and num2.
+#
+# Note:
+#
+# The length of both num1 and num2 is < 5100.
+# Both num1 and num2 contains only digits 0-9.
+# Both num1 and num2 does not contain any leading zero.
+# You must not use any built-in BigInteger library or convert the inputs to integer directly.
+
+
+class Solution:
+    def addStrings(self, num1, num2):
+
+        if len(num1) < len(num2):
+            return self.sumNums(num1, num2)
+        else:
+            return self.sumNums(num2, num1)
+
+    def sumNums(self, low, high):
+        dict = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
+
+        i = len(low) - 1
+        j = len(high) - 1
+        res = []
+        carry = 0
+        while j >= 0:
+
+            while i >= 0:
+                add = dict[low[i]] + dict[high[j]] + carry
+                res = [str(add % 10)] + res
+                carry = add // 10
+                i -= 1
+                j -= 1
+            if j >= 0:
+                add = dict[high[j]] + carry
+                carry = add // 10
+                res = [str(add % 10)] + res
+                j -= 1
+        if carry > 0:
+            res = [str(carry)] + res
+
+        return "".join(res)

leetcode/Add_Two_LinkedList_without_reverse.py

@@ -0,0 +1,63 @@
+# You are given two non-empty linked lists representing two non-negative integers.
+# The most significant digit comes first and each of their nodes contain a single digit.
+# Add the two numbers and return it as a linked list.
+#
+# You may assume the two numbers do not contain any leading zero, except the number 0 itself.
+#
+# Follow up:
+# What if you cannot modify the input lists? In other words, reversing the lists is not allowed.
+#
+# Example:
+#
+# Input: (7 -> 2 -> 4 -> 3) + (5 -> 6 -> 4)
+# Output: 7 -> 8 -> 0 -> 7
+
+# Definition for singly-linked list.
+
+
+class ListNode:
+    def __init__(self, x):
+        self.val = x
+        self.next = None
+
+
+class Solution:
+
+    def addTwoNumbers(self, l1, l2):
+
+        def ll_to_l(l):
+            num = ""
+            while l:
+                num += str(l.val)
+                l = l.next
+            return int(num)
+
+        n1 = ll_to_l(l1)
+        n2 = ll_to_l(l2)
+        n = n1 + n2
+        n = str(n)
+        head = ListNode(int(n[0]))
+        newnode = head
+
+        for i in range(1, len(n)):
+            new = ListNode(int(n[i]))
+            newnode.next = new
+            newnode = newnode.next
+        return head
+
+
+if __name__ == "__main__":
+    l1 = ListNode(7)
+    l1.next = ListNode(2)
+    l1.next.next = ListNode(4)
+    l1.next.next.next = ListNode(3)
+
+    l2 = ListNode(5)
+    l2.next = ListNode(6)
+    l2.next.next = ListNode(4)
+    # Input: (7 -> 2 -> 4 -> 3) + (5 -> 6 -> 4)
+    # Output: 7 -> 8 -> 0 -> 7
+    ans = Solution().addTwoNumbers(l1, l2)
+    while ans:
+        print(ans.val)
+        ans = ans.next

leetcode/Add_Two_Linked_List_Reverse.py

@@ -0,0 +1,72 @@
+# You are given two non-empty linked lists representing two non-negative integers.
+# The digits are stored in reverse order and each of their nodes contain a single digit.
+# Add the two numbers and return it as a linked list.
+#
+# You may assume the two numbers do not contain any leading zero, except the number 0 itself.
+#
+# Example:
+#
+# Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)
+# Output: 7 -> 0 -> 8
+# Explanation: 342 + 465 = 807.
+
+
+class ListNode(object):
+    def __init__(self, x):
+        self.val = x
+        self.next = None
+
+
+class Solution(object):
+    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
+
+        list1 = l1
+        list2 = l2
+        res = []
+        carry = 0
+
+        while list1 is not None and list2 is not None:
+            currSum = list1.val + list2.val + carry
+            res.append(currSum % 10)
+            carry = currSum // 10
+
+            list1 = list1.next
+            list2 = list2.next
+
+        while list1 is not None:
+            currSum = list1.val + carry
+            res.append(currSum % 10)
+            carry = currSum // 10
+            list1 = list1.next
+
+        while list2 is not None:
+            currSum = list2.val + carry
+            res.append(currSum % 10)
+            carry = currSum // 10
+            list2 = list2.next
+
+        if carry:
+            res.append(carry)
+
+        newnode = ListNode(0)
+        node = newnode
+        for num in res:
+            node.next = ListNode(num)
+            node = node.next
+
+        return newnode.next
+
+
+if __name__ == "__main__":
+    l1 = ListNode(2)
+    l1.next = ListNode(4)
+    l1.next.next = ListNode(3)
+
+    l2 = ListNode(5)
+    l2.next = ListNode(6)
+    l2.next.next = ListNode(4)
+
+    ans = Solution().addTwoNumbers(l1, l2)
+    print(ans.next.next.val)
+    print(ans.next.val)
+    print(ans.val)

leetcode/Backspace_String_compare.py

@@ -0,0 +1,74 @@
+# Given two strings S and T, return if they are equal when both are typed
+# into empty text editors. '#' means a backspace character.
+#
+# Example 1:
+#
+# Input: S = "ab#c", T = "ad#c"
+# Output: true
+# Explanation: Both S and T become "ac".
+# Example 2:
+#
+# Input: S = "ab##", T = "c#d#"
+# Output: true
+# Explanation: Both S and T become "".
+# Example 3:
+#
+# Input: S = "a##c", T = "#a#c"
+# Output: true
+# Explanation: Both S and T become "c".
+# Example 4:
+#
+# Input: S = "a#c", T = "b"
+# Output: false
+# Explanation: S becomes "c" while T becomes "b".
+# Note:
+#
+# 1 <= S.length <= 200
+# 1 <= T.length <= 200
+# S and T only contain lowercase letters and '#' characters.
+# Follow up:
+#
+# Can you solve it in O(N) time and O(1) space?
+
+
+class Solution:
+    def backspaceCompare(self, S, T):
+        p1 = len(S) - 1
+        p2 = len(S) - 1
+        skip1 = 0
+        skip2 = 0
+
+        while p1 >= 0 or p2 >= 0:
+
+            while p1 >= 0:
+                if S[p1] == '#':
+                    skip1 += 1
+                    p1 -= 1
+                elif skip1 > 0:
+                    p1 -= 1
+                    skip1 -= 1
+                else:
+                    break
+            while p2 >= 0:
+                if T[p2] == '#':
+                    skip2 += 1
+                    p2 -= 1
+                elif skip2 > 0:
+                    skip2 -= 1
+                    p2 -= 1
+                else:
+                    break
+            if (p1 >= 0) != (p2 >= 0):
+                return False
+            if S[p1] != T[p2]:
+                return False
+            p1 -= 1
+            p2 -= 1
+        return True
+
+
+if __name__ == "__main__":
+    S = "a##c"
+    T = "#a#c"
+    # Time Complexity is O(n) and space is O(1)
+    print(Solution().backspaceCompare(S, T))

leetcode/Balanced_Binary_Tree.py

@@ -0,0 +1,61 @@
+# Given a binary tree, determine if it is height-balanced.
+#
+# For this problem, a height-balanced binary tree is defined as:
+#
+# a binary tree in which the left and right subtrees of every node differ in height by no more than 1.
+#
+# Example 1:
+#
+# Given the following tree [3,9,20,null,null,15,7]:
+#
+#     3
+#    / \
+#   9  20
+#     /  \
+#    15   7
+# Return true.
+#
+# Example 2:
+#
+# Given the following tree [1,2,2,3,3,null,null,4,4]:
+#
+#        1
+#       / \
+#      2   2
+#     / \
+#    3   3
+#   / \
+#  4   4
+# Return false.
+
+
+class TreeNode:
+    def __init__(self, val):
+        self.val = val
+        self.left = None
+        self.right = None
+
+
+class Solution:
+    def isBalanced(self, root):
+        def helper(root):
+            if not root:
+                return (True, 0)
+
+            leftB, leftH = helper(root.left)
+            rightB, rightH = helper(root.right)
+
+            return (leftB and rightB and abs(leftH - rightH) <= 1, max(leftH, rightH) + 1)
+
+        return helper(root)[0]
+
+
+if __name__ == "__main__":
+    root = TreeNode(1)
+    root.left = TreeNode(2)
+    root.right = TreeNode(2)
+    root.left.left = TreeNode(3)
+    root.right.right = TreeNode(3)
+    root.left.left.left = TreeNode(4)
+    root.right.right.right = TreeNode(4)
+    print(Solution().isBalanced(root))

leetcode/Best_Time_to_Buy_and_Sell_Stock.py

@@ -0,0 +1,33 @@
+# Say you have an array for which the ith element is the price of a given stock on day i.
+#
+# If you were only permitted to complete at most one transaction (i.e., buy one and sell
+# one share of the stock), design an algorithm to find the maximum profit.
+#
+# Note that you cannot sell a stock before you buy one.
+#
+# Example 1:
+#
+# Input: [7,1,5,3,6,4]
+# Output: 5
+# Explanation: Buy on day 2 (price = 1) and sell on day 5 (price = 6), profit = 6-1 = 5.
+#              Not 7-1 = 6, as selling price needs to be larger than buying price.
+# Example 2:
+#
+# Input: [7,6,4,3,1]
+# Output: 0
+# Explanation: In this case, no transaction is done, i.e. max profit = 0.
+
+
+class Solution:
+    def maxProfit(self, prices):
+        if not prices:
+            return 0
+        Min = prices[0]
+        res = 0
+
+        for price in prices:
+            if Min > price:
+                Min = min(Min, price)
+            res = max(price - Min, res)
+
+        return res