3/2/18

Author: sk-g

C/371. Sum of Two Integers.c

@@ -0,0 +1,11 @@
+/*
+371. Sum of Two Integers
+Calculate the sum of two integers a and b, but you are not allowed to use the operator + and -.
+
+Example:
+Given a = 1 and b = 2, return 3.
+*/
+
+int getSum(int a, int b) {
+    return b==0? a:getSum(a^b, (a&b)<<1);
+}

python/14. Longest Common Prefix.py

@@ -0,0 +1,26 @@
+#14. Longest Common Prefix
+
+"""
+Write a function to find the longest common prefix string amongst an array of strings.
+
+"""
+
+class Solution:
+    def longestCommonPrefix(self, strs):
+        """
+        :type strs: List[str]
+        :rtype: str
+        """
+        if not strs:
+            return ""
+        minLen = len(strs[0])
+        for sx in strs:
+            minLen = min(minLen,len(sx))
+        res = ""
+        for i in range(minLen):
+            c = strs[0][i]
+            for sx in strs:
+                if sx[i] != c:
+                    return res
+            res += c
+        return res

python/2. Add Two Numbers.py

@@ -0,0 +1,64 @@
+#2. Add Two Numbers
+"""
+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.
+
+Pretty straight forward. Only keep in mind the carry.
+
+"""
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution:
+    def addTwoNumbers(self, l1, l2):
+        """
+        :type l1: ListNode
+        :type l2: ListNode
+        :rtype: ListNode
+        """
+        # 212 ms 43.49%
+        # first base cases:
+        # if either of the
+        # list is empty, return
+        # the other one
+        # if both are empty return none
+        if not l1:
+            return l2
+        if not l2:
+            return l1
+        if not l2 and not l1:
+            return none
+        # else init a carry propagator
+        carry = 0
+        # instantiate new linked list
+        root = n = ListNode(1)
+        # while there is something
+        # to be added, ll1 or ll2 
+        # or the carry itself
+        # do:
+        while l1 or l2 or carry:
+            v1 = v2 = 0
+            if l1:# while you can still traverse LL1
+                v1 = l1.val# get current node value
+                l1 = l1.next# get next node
+            if l2:# while you can still traverse LL2
+                v2 = l2.val
+                l2 = l2.next
+            
+            
+            val = v1 + v2 + carry # add numbers + carry if any
+            carry = val//10 # if sum > 10, get the quotient as carry
+            val %= 10# this is the rem or second digit of sum
+            n.next = ListNode(val)# push that into new LL
+            n = n.next# move to next node
+        return root.next#return the head of new LL

python/415. Add Strings.py

@@ -0,0 +1,37 @@
+#415. Add Strings
+"""
+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):
+        """
+        :type num1: str
+        :type num2: str
+        :rtype: str
+        """
+        sums = []
+        i = len(num1)-1
+        j = len(num2)-1
+        carry = 0
+        while i >= 0 or j >= 0:
+            total = carry
+            if i >= 0:
+                total += int(num1[i])
+                i -= 1
+            if j >= 0:
+                total += int(num2[j])
+                j -= 1
+            sums.append(str(total % 10))
+            carry = total / 10
+        if carry:
+            sums.append(str(carry))
+        
+        return "".join(sums[::-1])