python-100 answer

Author: xiaoyi733112

Diff for: 070-primes.py

@@ -0,0 +1,29 @@
+import math
+
+
+class PrimeGenerator(object):
+
+    def generate_primes(self, max_num):
+        if max_num is None:
+            raise TypeError('max_num cannot be None')
+        array = [True] * max_num
+        array[0] = False
+        array[1] = False
+        prime = 2
+        while prime <= math.sqrt(max_num):
+            self._cross_off(array, prime)
+            prime = self._next_prime(array, prime)
+        return array
+
+    def _cross_off(self, array, prime):
+        for index in range(prime*prime, len(array), prime):
+            # Start with prime*prime because if we have a k*prime
+            # where k < prime, this value would have already been
+            # previously crossed off
+            array[index] = False
+
+    def _next_prime(self, array, prime):
+        next = prime + 1
+        while next < len(array) and not array[next]:
+            next += 1
+        return next

Diff for: 071-digits.py

@@ -0,0 +1,16 @@
+class Solution(object):
+
+    def add_digits(self, val):
+        if val is None:
+            raise TypeError('num cannot be None')
+        if val < 0:
+            raise ValueError('num cannot be negative')
+        digits = []
+        while val != 0:
+            digits.append(val % 10)
+            val //= 10
+        digits_sum = sum(digits)
+        if digits_sum >= 10:
+            return self.add_digits(digits_sum)
+        else:
+            return digits_sum

Diff for: 072-math_ops.py

@@ -0,0 +1,30 @@
+class Solution(object):
+
+    def __init__(self, upper_limit=100):
+        self.max = None
+        self.min = None
+        # Mean
+        self.num_items = 0
+        self.running_sum = 0
+        self.mean = None
+        # Mode
+        self.array = [0] * (upper_limit + 1)
+        self.mode_occurrences = 0
+        self.mode = None
+
+    def insert(self, val):
+        if val is None:
+            raise TypeError('val cannot be None')
+        if self.max is None or val > self.max:
+            self.max = val
+        if self.min is None or val < self.min:
+            self.min = val
+        # Calculate the mean
+        self.num_items += 1
+        self.running_sum += val
+        self.mean = self.running_sum / self.num_items
+        # Calculate the mode
+        self.array[val] += 1
+        if self.array[val] > self.mode_occurrences:
+            self.mode_occurrences = self.array[val]
+            self.mode = val

Diff for: 073-power_of_two.py

@@ -0,0 +1,8 @@
+class Solution(object):
+
+    def is_power_of_two(self, val):
+        if val is None:
+            raise TypeError('n cannot be None')
+        if val <= 0:
+            return False
+        return (val & (val - 1)) == 0

Diff for: 074-sum.py

@@ -0,0 +1,10 @@
+class Solution(object):
+
+    def sum_two(self, a, b):
+        if a is None or b is None:
+            raise TypeError('a or b cannot be None')
+        result = a ^ b;
+        carry = (a&b) << 1
+        if carry != 0:
+            return self.sum_two(result, carry)
+        return result

Diff for: 075-sub.py

@@ -0,0 +1,10 @@
+class Solution(object):
+
+    def sub_two(self, a, b):
+        if a is None or b is None:
+            raise TypeError('a or b cannot be None')
+        result = a ^ b
+        borrow = (~a & b) << 1
+        if borrow != 0:
+            return self.sub_two(result, borrow)
+        return result