Adding files

Adding solutions to problems already completed.

Author: setu4993

001_two-sum.py

@@ -0,0 +1,18 @@
+class Solution:
+
+    def twoSum(self, nums, target):
+        """
+        :type nums: List[int]
+        :type target: int
+        :rtype: List[int]
+        """
+        differences = {}
+        for i, n in enumerate(nums):
+            if n in differences:
+                return differences[nums[i]], i
+            else:
+                differences[target - n] = i
+        return -1, -1
+
+
+print(Solution().twoSum([2, 7, 11, 15], 9))

002_add-two-numbers.py

@@ -0,0 +1,46 @@
+# Definition for singly-linked list.
+class ListNode(object):
+    def __init__(self, x):
+        self.val = x
+        self.next = None
+
+
+class Solution(object):
+    def addTwoNumbers(self, l1, l2):
+        """
+        :type l1: ListNode
+        :type l2: ListNode
+        :rtype: ListNode
+        """
+        carry = 0
+        head = current = ListNode(0)
+        while l1 or l2 or carry:
+            if l1:
+                val1 = l1.val
+                l1 = l1.next
+            else:
+                val1 = 0
+            if l2:
+                val2 = l2.val
+                l2 = l2.next
+            else:
+                val2 = 0
+            carry, step_val = divmod(val1 + val2 + carry, 10)
+            current.next = ListNode(step_val)
+            current = current.next
+
+        return head.next
+
+
+def CreateList(num_list):
+    head = n = ListNode(0)
+    for l in num_list:
+        n.next = ListNode(l)
+        n = n.next
+    return head.next
+
+l1 = CreateList([2, 4, 3])
+
+l2 = CreateList([5, 6, 4])
+
+Solution().addTwoNumbers(l1, l2)

003_longest-subsequence-without-repeating-characters.py

@@ -0,0 +1,20 @@
+class Solution(object):
+
+    def lengthOfLongestSubstring(self, s):
+        """
+        :type s: str
+        :rtype: int
+        """
+        substring_list = []
+        substring = []
+        for char in s:
+            if char not in substring:
+                substring.append(char)
+            else:
+                substring_list.append("".join(substring))
+                substring = substring[substring.index(char) + 1:len(substring)]
+                substring.append(char)
+        substring_list.append("".join(substring))
+        return len(max(substring_list, key=len))
+
+print(Solution().lengthOfLongestSubstring("bpfbhmipx"))

005_longest-palindromic-substring.py

@@ -0,0 +1,31 @@
+class Solution(object):
+
+    def longestPalindrome(self, s):
+        """
+        :type s: str
+        :rtype: str
+        """
+
+        for i in range(len(s) - 1, 0, -1):
+            for j in range(0, len(s) - i):
+                substring = s[j:j + i + 1]
+                if substring == substring[::-1]:
+                    return substring
+        '''
+        # attempt 1 : brute force O(n^2)
+        for i in range(len(s)):
+            for j in range(i + 1, len(s)):
+                substring = s[i:j + 1]
+                if substring == substring[::-1]:
+                    substring_list.append(substring)
+        try:
+            return max(substring_list, key=len)
+        except ValueError:
+            return s[0]
+
+        '''
+
+print(Solution().longestPalindrome("ababad"))
+print(Solution().longestPalindrome("mwwfjysbkebpdjyabcfkgprtxpwvhglddhmvaprcvrnuxifcrjpdgnktvmggmguiiquibmtviwjsqwtchkqgxqwljouunurcdtoeygdqmijdympcamawnlzsxucbpqtuwkjfqnzvvvigifyvymfhtppqamlgjozvebygkxawcbwtouaankxsjrteeijpuzbsfsjwxejtfrancoekxgfyangvzjkdskhssdjvkvdskjtiybqgsmpxmghvvicmjxqtxdowkjhmlnfcpbtwvtmjhnzntxyfxyinmqzivxkwigkondghzmbioelmepgfttczskvqfejfiibxjcuyevvpawybcvvxtxycrfbcnpvkzryrqujqaqhoagdmofgdcbhvlwgwmsmhomknbanvntspvvhvccedzzngdywuccxrnzbtchisdwsrfdqpcwknwqvalczznilujdrlevncdsyuhnpmheukottewtkuzhookcsvctsqwwdvfjxifpfsqxpmpwospndozcdbfhselfdltmpujlnhfzjcgnbgprvopxklmlgrlbldzpnkhvhkybpgtzipzotrgzkdrqntnuaqyaplcybqyvidwcfcuxinchretgvfaepmgilbrtxgqoddzyjmmupkjqcypdpfhpkhitfegickfszermqhkwmffdizeoprmnlzbjcwfnqyvmhtdekmfhqwaftlyydirjnojbrieutjhymfpflsfemkqsoewbojwluqdckmzixwxufrdpqnwvwpbavosnvjqxqbosctttxvsbmqpnolfmapywtpfaotzmyjwnd"))
+
+print(Solution().longestPalindrome("esbtzjaaijqkgmtaajpsdfiqtvxsgfvijpxrvxgfumsuprzlyvhclgkhccmcnquukivlpnjlfteljvykbddtrpmxzcrdqinsnlsteonhcegtkoszzonkwjevlasgjlcquzuhdmmkhfniozhuphcfkeobturbuoefhmtgcvhlsezvkpgfebbdbhiuwdcftenihseorykdguoqotqyscwymtjejpdzqepjkadtftzwebxwyuqwyeegwxhroaaymusddwnjkvsvrwwsmolmidoybsotaqufhepinkkxicvzrgbgsarmizugbvtzfxghkhthzpuetufqvigmyhmlsgfaaqmmlblxbqxpluhaawqkdluwfirfngbhdkjjyfsxglsnakskcbsyafqpwmwmoxjwlhjduayqyzmpkmrjhbqyhongfdxmuwaqgjkcpatgbrqdllbzodnrifvhcfvgbixbwywanivsdjnbrgskyifgvksadvgzzzuogzcukskjxbohofdimkmyqypyuexypwnjlrfpbtkqyngvxjcwvngmilgwbpcsseoywetatfjijsbcekaixvqreelnlmdonknmxerjjhvmqiztsgjkijjtcyetuygqgsikxctvpxrqtuhxreidhwcklkkjayvqdzqqapgdqaapefzjfngdvjsiiivnkfimqkkucltgavwlakcfyhnpgmqxgfyjziliyqhugphhjtlllgtlcsibfdktzhcfuallqlonbsgyyvvyarvaxmchtyrtkgekkmhejwvsuumhcfcyncgeqtltfmhtlsfswaqpmwpjwgvksvazhwyrzwhyjjdbphhjcmurdcgtbvpkhbkpirhysrpcrntetacyfvgjivhaxgpqhbjahruuejdmaghoaquhiafjqaionbrjbjksxaezosxqmncejjptcksnoq"))

006_zigzag-conversion.py

@@ -0,0 +1,49 @@
+class Solution(object):
+    def convert(self, s, numRows):
+        """
+        :type s: str
+        :type numRows: int
+        :rtype: str
+        """
+        converted = [''] * numRows
+        row = 0
+        i = 0
+        down = True
+        if numRows > 1:
+            while i < len(s):
+                converted[row] += s[i]
+                if down and row != (numRows - 1):
+                    row += 1
+                elif down and row == (numRows - 1):
+                    down = not down
+                    row -= 1
+                elif not down and row == 0:
+                    down = not down
+                    row += 1
+                elif not down:
+                    row -= 1
+                i += 1
+        else:
+            return s
+        '''
+        col = 0
+        while row < numRows:
+            row_text = []
+            while col < len(s):
+                row_text.append(s[col])
+                print(row, col, s[col])
+                col += 2 * (numRows - 1)
+            row += 1
+            col = row
+            converted = converted + ''.join(row_text)
+
+        
+        for i in range(len(s)):
+            location = i % len(s)
+            converted.append(s[i])
+        return ''.join(converted)
+        '''
+        return ''.join(converted)
+
+
+print(Solution().convert("PAYPALISHIRING", 4))

007_reverse-integer.py

@@ -0,0 +1,32 @@
+import sys
+sys.maxint = 32
+
+class Solution(object):
+
+    def reverse(self, x):
+        """
+        :type x: int
+        :rtype: int
+        """
+        rev = 0
+        negative = False
+        if x < 0:
+            x = 0 - x
+            negative = True
+
+        while x != 0:
+            x, quotient = divmod(x, 10)
+            try:
+                rev = rev * 10 + quotient
+            except OverflowError:
+                return 0
+            pass
+        if negative:
+            rev = 0 - rev
+        if rev > 2147483647 or rev <-2147483648:
+            rev = 0
+        return int(rev)
+
+print(Solution().reverse(123))
+print(Solution().reverse(-123))
+print(Solution().reverse(2147483651))

008_string-to-integer-(atoi).py

@@ -0,0 +1,39 @@
+class Solution(object):
+    def myAtoi(self, str):
+        """
+        :type str: str
+        :rtype: int
+        """
+        str = str.strip()
+        num_dict = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
+        value = 0
+        try:
+            if str[0] == '-':
+                neg = True
+                str = str[1:]
+            elif str[0] == '+':
+                neg = False
+                str = str[1:]
+            else:
+                neg = False
+        except IndexError:
+            return value
+        for s in str:
+            if s in num_dict:
+                value = value * 10 + num_dict[s]
+            else:
+                break
+
+        if neg:
+            value = 0 - value
+
+        if value > 2147483647:
+            return 2147483647
+
+        if value < -2147483648:
+            return -2147483648
+
+        return value
+
+v = Solution().myAtoi('   -124a2324')
+print(v, type(v))

009_palindrome-number.py

@@ -0,0 +1,22 @@
+class Solution(object):
+    def isPalindrome(self, x):
+        """
+        :type x: int
+        :rtype: bool
+        """
+        if x >= 0 and x < 2147483647:
+            num_range = 1
+            while x > num_range:
+                num_range *= 10
+            while x >= 10 or num_range > 10:
+                l, x = divmod(x, num_range / 10)
+                x, r = divmod(x, 10)
+                print(num_range, r, l, x)
+                if l != r:
+                    return False
+                num_range /= 100
+            return True
+
+        return False
+
+print(Solution().isPalindrome(1000021))

011_container-with-most-water.py

@@ -0,0 +1,19 @@
+class Solution(object):
+    def maxArea(self, height):
+        """
+        :type height: List[int]
+        :rtype: int
+        """
+        i = 0
+        j = len(height) - 1
+        area = 0
+        while i < j:
+            area = max(area, (min(height[i], height[j]) * (j - i)))
+            if height[i] < height[j]:
+                i += 1
+            else:
+                j -= 1
+
+        return area
+
+print(Solution().maxArea([2, 3, 5, 12, 4, 2, 4, 1]))

012_integer-to-roman.py

@@ -0,0 +1,28 @@
+class Solution(object):
+    def intToRoman(self, num):
+        """
+        :type num: int
+        :rtype: str
+        """
+        roman_num = ""
+        roman_dict = {1: 'I', 5: 'V', 10: 'X', 50: 'L', 100: 'C', 500: 'D', 1000: 'M'}
+        dec_roman_list = [1000, 500, 100, 50, 10, 5, 1]
+        roman_index = 0
+        max_roman = dec_roman_list[roman_index]
+
+        while num:
+            if num >= max_roman:
+                roman_num += roman_dict[max_roman]
+                num = num - max_roman
+            else:
+                roman_index += 1
+                max_roman = dec_roman_list[roman_index]
+        roman_num = roman_num.replace("DCCCC", "CM") # 900
+        roman_num = roman_num.replace("CCCC", "CD") # 400
+        roman_num = roman_num.replace("LXXXX", "XC") # 90
+        roman_num = roman_num.replace("XXXX", "XL") # 40
+        roman_num = roman_num.replace("VIIII", "IX") # 9
+        roman_num = roman_num.replace("IIII", "IV") # 4
+        return roman_num
+
+print(Solution().intToRoman(149))

013_roman-to-integer.py

@@ -0,0 +1,35 @@
+class Solution(object):
+    def romanToInt(self, s):
+        """
+        :type s: str
+        :rtype: int
+        """
+        roman_dict = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}
+        value = 0
+        i = 0
+        while i < len(s):
+
+            try:
+                val_i = roman_dict[s[i]]
+            except IndexError:
+                val_i = 0
+            except KeyError:
+                val_i = 0
+
+            try:
+                val_plus = roman_dict[s[i + 1]]
+            except IndexError:
+                val_plus = 0
+            except KeyError:
+                val_plus = 0
+
+            if val_i >= val_plus:
+                value = value + val_i
+                i += 1
+            else:
+                value = value + val_plus - val_i
+                i += 2
+        return value
+
+
+print(Solution().romanToInt("CVI"))

014_longest-common-prefix.py

@@ -0,0 +1,19 @@
+class Solution(object):
+    def longestCommonPrefix(self, strs):
+        """
+        :type strs: List[str]
+        :rtype: str
+        """
+        common = []
+        if strs:
+            shortest = min(strs, key=len)
+            for i in range(len(shortest)):
+                for s in strs:
+                    if s[i] == strs[0][i]:
+                        pass
+                    else:
+                        return "".join(common)
+                common.append(strs[0][i])
+        return "".join(common)
+
+print(Solution().longestCommonPrefix(["aaa", "aaaaa", "aaaaaaa"]))