bubble_sort.py

horners_method_polynomial.py
multiplication_algorithm.py

Author: calvinp0

bubble_sort.py

@@ -0,0 +1,34 @@
+'''
+bubble sorting
+get the size of the array
+set a while loop that checks the array size is larger than zero (for every successful for loop, reduce size by 1
+because after first loop and subsequent loops, the largest numbers will be sorted permanently)
+for loop between 0 and the size of the array-1 (as you cannot check the last array value against nothing)
+    swapping adjacent values if a is larger than b
+original = O(N^2)
+
+improvement:
+if no swapping as occured, break loop
+
+'''
+
+
+def bubble_sorting(array):
+    n = len(array)
+
+    while n > 0:
+        swapped = False
+        for i in range(0, n - 1):
+            if array[i] > array[i + 1]:
+                array[i], array[i + 1] = array[i + 1], array[i]
+                swapped = True
+        if not swapped:
+            print(n)
+            break
+        n -= 1
+    return array
+
+
+array_test = [100, 0, 4, 2, 6, 8, 2, 4, 11, 10]
+
+print(bubble_sorting(array_test))

horners_method_polynomial.py

@@ -0,0 +1,55 @@
+'''
+horner's method
+
+ cnxn + cn-1xn-1 + cn-2xn-2 + … + c1x + c0
+ f(x)=k=0∑n​ak​xk f(x) = sum[a(k) * x^(k)] where k = 0 and nth degree,
+ i.e. deg(f(x)) = n where n represents the highest variable exponent. so if I had the values of a= [4,3,2] and x = 2
+
+f(2) = [4 * 2^0] + [3 * 2^1] + [2 * 2^2]
+f(2) = 18
+
+1. Set k = n
+2. Let bk = ak
+3. Let bk - 1 = ak - 1 + bkx0
+4. Let k = k - 1
+5. If k ≥ 0 then go to step 3
+Else End
+
+another way to look at it
+
+f(x)    = 2x^2 + 3x + 4
+        = (x(2x + 3)) + 4
+
+
+'''
+
+
+def horner(a, x):
+    n = len(a)
+    p = a[0]
+
+    for i in range(1, n):
+        p = p * x + a[i]
+
+    return p
+
+
+a = [2, 3, 4]
+x = 2
+# 2x^2 + 3x + 4
+# x= 2
+# 8 + 6 + 4
+print(horner(a, x))
+
+
+def polynomial_long_division(a, x):
+    result = [a[0]]
+    for i in range(1, len(a)):
+        result.append(a[i] + (x * result[i - 1]))
+    return result, print(f'The remainder is {result[-1]}')
+
+
+# f(x) = 2x**3 - 6x**2 + 2x - 1, x = 3
+# x - 3 = 0
+f = [2, -6, 2, -1]
+print(polynomial_long_division(f, 3))

multiplication_algorithm.py

@@ -0,0 +1,28 @@
+'''
+
+Shift method
+
+c is the base and must be bigger than or equal to 2 - c>= 2
+
+When c is the base of your representation (like decimal), then this is how multiplication can be done "manually".
+It's the "shift and add" method. In c-base cy is a single shift of y to the left (i.e. adding a zero at the right);
+and z/c is a single shift of z to the right: the right most digit is lost. That lost digit is actually z mod c,
+which is multiplied with y separately.
+
+Here is an example with c = 10, where the apostrophe signifies the value of variables in a recursive call. We perform
+the multiplication with y for each separate digit of z (retrieved with z mod c). Each next product found in this way
+is written shifted one more place to the left. Usually the 0 is not padded at the right of this shifted product,
+but it is silently assumed:
+
+'''
+import math
+
+
+def multiply(y, z, c):
+    if z == 0 or y == 0:
+        return 0
+    else:
+        return multiply(c * y, math.floor((z / c)), c) + y * (z % c)
+
+
+print(multiply(10, 20, 2))