Corrected a few C'isms and also added the solutions to four more problems

problem_2.py

@@ -1,6 +1,6 @@
 
-prev_two = 1;
+prev_two = 1
-prev_one = 0;
+prev_one = 0
 fib_num = 0
 sum = 0
 

problem_21.py

@@ -1,5 +1,44 @@
 import math
 
+# Let d(n) be defined as the sum of proper divisors of n (numbers less than n which divide evenly into n).
+# If d(a) = b and d(b) = a, where a ≠ b, then a and b are an amicable pair and each of a and b are called amicable numbers.
 
+# For example, the proper divisors of 220 are 1, 2, 4, 5, 10, 11, 20, 22, 44, 55 and 110; therefore d(220) = 284.
+# The proper divisors of 284 are 1, 2, 4, 71 and 142; so d(284) = 220.
+
+# Evaluate the sum of all the amicable numbers under 10000.
+
+def get_divisor_sum(input):
+
+    divisor_sum = 0
+    cutoff = math.ceil(input / 2)
+
+    for idx, val in enumerate(range(cutoff), 1):
+        if input % idx == 0:
+            divisor_sum += idx
+
+    return divisor_sum
+
+
+def get_amicable():
+
+    sums = []
+
+    for i in range(10000):
+        sums.append(get_divisor_sum(i))
+
+    amicable_sum = 0
+
+    for idx, val in enumerate(sums):
+        if val < 10000:
+            if sums[val] == idx and idx != val:
+                amicable_sum += val + sums[val]
+                print("VAL1_IDX: ", val)
+                #print("VAL1_VAL: ", val)
+                print("VAL2_VAL: ", sums[val])
+                print("")
+
+    return amicable_sum/2
+
+print(get_amicable())
 
-count_array

problem_22.py

@@ -0,0 +1,20 @@
+import ast
+
+# read in the file, convert to a list
+f = open('assets/problem_21_names.txt', 'r')  # We need to re-open the file
+data = ast.literal_eval(f.read())
+f.close()
+
+data.sort()
+
+sum = 0
+
+for idx, name in enumerate(data):
+
+    word_sum = 0
+    for letter in name:
+        word_sum += ord(letter) - 65 + 1
+
+    sum += word_sum * (idx+1)
+
+print(sum)

problem_23.py

@@ -0,0 +1,89 @@
+# A perfect number is a number for which the sum of its proper
+# divisors is exactly equal to the number. For example, the sum
+# of the proper divisors of 28 would be 1 + 2 + 4 + 7 + 14 = 28,
+# which means that 28 is a perfect number.
+#
+# A number n is called deficient if the sum of its proper divisors
+# is less than n and it is called abundant if this sum exceeds n.
+#
+# As 12 is the smallest abundant number, 1 + 2 + 3 + 4 + 6 = 16,
+# the smallest number that can be written as the sum of two abundant
+# numbers is 24. By mathematical analysis, it can be shown that all
+# integers greater than 28123 can be written as the sum of two
+# abundant numbers. However, this upper limit cannot be reduced any
+# further by analysis even though it is known that the greatest
+# number that cannot be expressed as the sum of two abundant numbers
+# is less than this limit.
+#
+# Find the sum of all the positive integers which cannot be written
+# as the sum of two abundant numbers.
+
+
+# This program is essentially n^3 in the search and n^2 for the divisor count,
+# so it runs reaalllyy slowly
+
+import math
+import pickle
+
+def get_divisor_sum(input):
+
+    divisor_sum = 0
+    cutoff = math.ceil(input / 2)
+
+    for idx, val in enumerate(range(cutoff), 1):
+        if input % idx == 0:
+            divisor_sum += idx
+
+    return divisor_sum
+
+def get_abundants():
+
+    list = []
+
+    for i in range(28123):
+        sum = get_divisor_sum(i)
+        if sum > i:
+            list.append(i)
+
+    with open('assets/outfile', 'wb') as fp:
+        pickle.dump(list, fp)
+
+    return list
+
+
+# uncomment on any subsiquent runs to retrieve the cached data
+# with open('assets/outfile', 'rb') as fp:
+#     abundant_list = pickle.load(fp)
+
+# comment this line out after the first run
+abundant_list = get_abundants()
+abundant_list.sort()
+
+seen = {}
+abundant_list = [seen.setdefault(x, x) for x in abundant_list if x not in seen]
+
+summation = 0
+
+for i in range(28123):
+
+    found = False
+    for first_number in abundant_list:
+
+        if first_number > i:
+            break
+
+        search = i - first_number
+        if search in abundant_list:
+            found = True
+            break
+
+    if not found:
+        summation += i
+
+
+
+print(summation)
+print(abundant_list)
+
+
+

problem_24.py

@@ -0,0 +1,26 @@
+
+# A permutation is an ordered arrangement of objects.
+# For example, 3124 is one possible permutation of the
+# digits 1, 2, 3 and 4. If all of the permutations are
+# listed numerically or alphabetically, we call it
+# lexicographic order. The lexicographic permutations of 0, 1 and 2 are:
+#
+# 012   021   102   120   201   210
+#
+# What is the millionth lexicographic permutation of the digits
+# 0, 1, 2, 3, 4, 5, 6, 7, 8 and 9?
+
+# learned about itertools from problem 23. Python is wonderful
+
+import itertools
+
+list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+uniquelist = set(list)
+
+iter = 0
+for n in itertools.permutations(uniquelist, 10):
+    iter += 1
+    if iter == 1000000:
+        print(n)
+        break

problem_6.py

@@ -1,14 +1,14 @@
 #Difference between the sum of squares and the square of the sum of the first 100 numbers
 
 #find the sum of the squares
-sum_of_squares = 0;
+sum_of_squares = 0
 for i in range (1, 101):
     sum_of_squares += i * i
 
 #find the square of the sum
 square_of_sums = 0
 for i in range(1, 101):
-    square_of_sums += i;
+    square_of_sums += i
 
 square_of_sums *= square_of_sums
 

problem_7.py

@@ -13,7 +13,7 @@ def isPrime(number):
 
     return prime
 
-i = 1;
+i = 1
 primeCount = 1
 while (primeCount != 10001):
     if isPrime(i):

problem_8.py

@@ -28,7 +28,7 @@ queue = collections.deque()
 for i in range(0, 13):
     queue.append(number[i])
 
-max_product = 0;
+max_product = 0
 for i in range(13, 1000):
     product = 1
     for q in queue: