python-100 answer

Author: xiaoyi733112

Diff for: 001-unique_chars.py

@@ -0,0 +1,6 @@
+class UniqueChars(object):
+
+    def has_unique_chars(self, string):
+        if string is None:
+            return False
+        return len(set(string)) == len(string)

Diff for: 002-permutation.py

@@ -0,0 +1,6 @@
+class Permutations(object):
+
+    def is_permutation(self, str1, str2):
+        if str1 is None or str2 is None:
+            return False
+        return sorted(str1) == sorted(str2)

Diff for: 003-rotation.py

@@ -0,0 +1,11 @@
+class Rotation(object):
+
+    def is_substring(self, s1, s2):
+        return s1 in s2
+
+    def is_rotation(self, s1, s2):
+        if s1 is None or s2 is None:
+            return False
+        if len(s1) != len(s2):
+            return False
+        return self.is_substring(s1, s2 + s2)

Diff for: 004-compress_str.py

@@ -0,0 +1,20 @@
+class CompressString(object):
+
+    def compress(self, string):
+        if string is None or not string:
+            return string
+        result = ''
+        prev_char = string[0]
+        count = 0
+        for char in string:
+            if char == prev_char:
+                count += 1
+            else:
+                result += self._calc_partial_result(prev_char, count)
+                prev_char = char
+                count = 1
+        result += self._calc_partial_result(prev_char, count)
+        return result if len(result) < len(string) else string
+
+    def _calc_partial_result(self, prev_char, count):
+        return prev_char + (str(count) if count > 1 else '')

Diff for: 005-reverse_chars.py

@@ -0,0 +1,9 @@
+class ReverseString(object):
+
+    def reverse(self, chars):
+        if chars:
+            size = len(chars)
+            for i in range(size // 2):
+                chars[i], chars[size - 1 - i] = \
+                    chars[size - 1 - i], chars[i]
+        return chars

Diff for: 006-diff.py

@@ -0,0 +1,11 @@
+class Solution(object):
+
+    def find_diff(self, str1, str2):
+        if str1 is None or str2 is None:
+            raise TypeError('str1 or str2 cannot be None')
+        result = 0
+        for char in str1:
+            result ^= ord(char)
+        for char in str2:
+            result ^= ord(char)
+        return chr(result)

Diff for: 007-sum.py

@@ -0,0 +1,15 @@
+class Solution(object):
+
+    def two_sum(self, nums, val):
+        if nums is None or val is None:
+            raise TypeError('nums or target cannot be None')
+        if not nums:
+            raise ValueError('nums cannot be empty')
+        cache = {}
+        for index, num in enumerate(nums):
+            cache_val = val - num
+            if num in cache:
+                return [cache[num], index]
+            else:
+                cache[cache_val] = index
+        return None

Diff for: 008-fizzbuzz.py

@@ -0,0 +1,18 @@
+class Solution(object):
+
+    def fizz_buzz(self, num):
+        if num is None:
+            raise TypeError('num cannot be None')
+        if num < 1:
+            raise ValueError('num cannot be less than one')
+        results = []
+        for i in range(1, num + 1):
+            if i % 3 == 0 and i % 5 == 0:
+                results.append('FizzBuzz')
+            elif i % 3 == 0:
+                results.append('Fizz')
+            elif i % 5 == 0:
+                results.append('Buzz')
+            else:
+                results.append(str(i))
+        return results

Diff for: 009-linkedlist.py

@@ -0,0 +1,83 @@
+class Node(object):
+
+    def __init__(self, data, next=None):
+        self.next = next
+        self.data = data
+
+    def __str__(self):
+        return self.data
+
+
+class LinkedList(object):
+
+    def __init__(self, head=None):
+        self.head = head
+
+    def __len__(self):
+        curr = self.head
+        counter = 0
+        while curr is not None:
+            counter += 1
+            curr = curr.next
+        return counter
+
+    def insert_to_front(self, data):
+        if data is None:
+            return None
+        node = Node(data, self.head)
+        self.head = node
+        return node
+
+    def append(self, data):
+        if data is None:
+            return None
+        node = Node(data)
+        if self.head is None:
+            self.head = node
+            return node
+        curr_node = self.head
+        while curr_node.next is not None:
+            curr_node = curr_node.next
+        curr_node.next = node
+        return node
+
+    def find(self, data):
+        if data is None:
+            return None
+        curr_node = self.head
+        while curr_node is not None:
+            if curr_node.data == data:
+                return curr_node
+            curr_node = curr_node.next
+        return None
+
+    def delete(self, data):
+        if data is None:
+            return
+        if self.head is None:
+            return
+        if self.head.data == data:
+            self.head = self.head.next
+            return
+        prev_node = self.head
+        curr_node = self.head.next
+        while curr_node is not None:
+            if curr_node.data == data:
+                prev_node.next = curr_node.next
+                return
+            prev_node = curr_node
+            curr_node = curr_node.next
+
+    def print_list(self):
+        curr_node = self.head
+        while curr_node is not None:
+            print(curr_node.data)
+            curr_node = curr_node.next
+
+    def get_all_data(self):
+        data = []
+        curr_node = self.head
+        while curr_node is not None:
+            data.append(curr_node.data)
+            curr_node = curr_node.next
+        return data

Diff for: 010-removedupes.py

@@ -0,0 +1,18 @@
+from linked_list import LinkedList
+
+
+class MyLinkedList(LinkedList):
+
+    def remove_dupes(self):
+        if self.head is None:
+            return
+        node = self.head
+        seen_data = set()
+        while node is not None:
+            if node.data not in seen_data:
+                seen_data.add(node.data)
+                prev = node
+                node = node.next
+            else:
+                prev.next = node.next
+                node = node.next

Diff for: 011-kth_to_last.py

@@ -0,0 +1,24 @@
+from linked_list import LinkedList
+
+
+class MyLinkedList(LinkedList):
+
+    def kth_to_last_elem(self, k):
+        if self.head is None:
+            return None
+        fast = self.head
+        slow = self.head
+
+        # Give fast a headstart, incrementing it
+        # once for k = 1, twice for k = 2, etc
+        for _ in range(k):
+            fast = fast.next
+            # If k >= num elements, return None
+            if fast is None:
+                return None
+
+        # Increment both pointers until fast reaches the end
+        while fast.next is not None:
+            fast = fast.next
+            slow = slow.next
+        return slow.data

Diff for: 012-del_node.py

@@ -0,0 +1,13 @@
+from linked_list import LinkedList
+
+
+class MyLinkedList(LinkedList):
+
+    def delete_node(self, node):
+        if node is None:
+            return
+        if node.next is None:
+            node.data = None
+        else:
+            node.data = node.next.data
+            node.next = node.next.next

Diff for: 013-partition_data.py

@@ -0,0 +1,30 @@
+from linked_list import LinkedList
+
+
+class MyLinkedList(LinkedList):
+
+    def partition(self, data):
+        if self.head is None:
+            return
+        left = MyLinkedList(None)
+        right = MyLinkedList(None)
+        curr = self.head
+
+        # Build the left and right lists
+        while curr is not None:
+            if curr.data < data:
+                left.append(curr.data)
+            elif curr.data == data:
+                right.insert_to_front(curr.data)
+            else:
+                right.append(curr.data)
+            curr = curr.next
+        curr_left = left.head
+        if curr_left is None:
+            return right
+        else:
+            # Merge the two lists
+            while curr_left.next is not None:
+                curr_left = curr_left.next
+            curr_left.next = right.head
+            return left

Diff for: 014-reverse.py

@@ -0,0 +1,29 @@
+from linked_list import LinkedList,Node
+
+
+class MyLinkedList(LinkedList):
+
+    def add_reverse(self, first_list, second_list):
+        # See constraints
+        if first_list is None or second_list is None:
+            return None
+        head = self._add_reverse(first_list.head, second_list.head, 0)
+        return MyLinkedList(head)
+
+    def _add_reverse(self, first_node, second_node, carry):
+        # Base case
+        if first_node is None and second_node is None and not carry:
+            return None
+
+        # Recursive case
+        value = carry
+        value += first_node.data if first_node is not None else 0
+        value += second_node.data if second_node is not None else 0
+        carry = 1 if value >= 10 else 0
+        value %= 10
+        node = Node(value)
+        node.next = self._add_reverse(
+            first_node.next if first_node is not None else None,
+            second_node.next if first_node is not None else None,
+            carry)
+        return node

Diff for: 015-loop_start.py

@@ -0,0 +1,24 @@
+from linked_list import LinkedList
+
+
+class MyLinkedList(LinkedList):
+
+    def find_loop_start(self):
+        if self.head is None or self.head.next is None:
+            return None
+        slow = self.head
+        fast = self.head
+        while fast.next is not None:
+            slow = slow.next
+            fast = fast.next.next
+            if fast is None:
+                return None
+            if slow == fast:
+                break
+        slow = self.head
+        while slow != fast:
+            slow = slow.next
+            fast = fast.next
+            if fast is None:
+                return None
+        return slow

Diff for: 016-palindrome.py

@@ -0,0 +1,29 @@
+from linked_list import LinkedList
+
+
+class MyLinkedList(LinkedList):
+
+    def is_palindrome(self):
+        if self.head is None or self.head.next is None:
+            return False
+        curr = self.head
+        reversed_list = MyLinkedList()
+        length = 0
+
+        # Reverse the linked list
+        while curr is not None:
+            reversed_list.insert_to_front(curr.data)
+            length += 1
+            curr = curr.next
+
+        # Compare the reversed list with the original list
+        # Only need to compare the first half
+        iterations = length // 2
+        curr = self.head
+        curr_reversed = reversed_list.head
+        for _ in range(iterations):
+            if curr.data != curr_reversed.data:
+                return False
+            curr = curr.next
+            curr_reversed = curr_reversed.next
+        return True