Complexity analysis and Proof of correctness using assertions

Author: rusty-sj

hw1 - prime factorization & complexity analysis/hw1-report.pdf

@@ -0,0 +1,52 @@
+from time import time
+
+
+def factors(number):
+    start_time = time()
+    output = []  # output array to store factors
+
+    if number == 1:
+        return output  # 1 is not a prime
+
+    # Reduce the number until it can be divided by 2
+    while number % 2 == 0:  # worst case runs log_2(N) times,  O (log_2 N)
+        output.append(2)
+        number = number // 2
+
+    # For each number from 3 to sqrt n, keep dividing number whenever possible and add to factors
+    # since even numbers are already taken care of by previous loop, increment by 2
+    for i in range(3, int(number ** (1 / 2)) + 1):  # worst case runs sqrt N times, O (sqrt N)
+        while number % i == 0:  # worst case runs log_3 N times, otherwise log_i N
+            output.append(i)
+            number = number // i
+        i += 2
+
+    if number > 2:  # number hasn't been divided by anything, it's prime
+        output.append(number)
+
+    time_taken = time() - start_time
+    times.append(time_taken)
+    return output
+
+
+def verify(number, factors_list):
+    product = 1
+    for factor in factors_list:
+        product *= factor
+    return number == product
+
+
+if __name__ == '__main__':
+    times = []
+    numbers = [6, 60, 840, 7560, 83160, 720720, 8648640, 73513440, 735134400, 6983776800, 97772875200, 963761198400,
+               9316358251200, 97821761637600, 866421317361600, 8086598962041600, 74801040398884800, 897612484786617600]
+    # numbers = [170141183460469231731687303715884105727]
+    for num in numbers:
+        factors_list = factors(number=num)
+        # print(verify(number=num, factors_list=factors_list))
+
+    for i in range(0, len(numbers)):
+        print('{} \t {}'.format(numbers[i], times[i] * 1000))
+
+    # factors_list = factors(number=1)
+    # print(verify(number=1, factors_list=factors_list))

hw1 - prime factorization & complexity analysis/hw1.pdf

@@ -0,0 +1,23 @@
+def bubble_sort(a):
+    swap, j = 1, len(a)
+    # Assertion 0: a[0], ..., a[n - 1] is an array of integers with at least 1 element
+    while swap == 1:
+        # Assertion 1: swap = 1 && a'[j] <= ... <= a'[n - 1] && {a’[j], ...,a’[n - 1]} = {a[j], ..., a[n - 1]}
+        swap = 0
+        j = j - 1
+        for i in range(j):
+            # Assertion 2: a[i] is pointing to max a[0]...a[i]
+            print(i, j)
+            print(a)
+            if a[i] > a[i + 1]:
+                a[i], a[i + 1], swap = a[i + 1], a[i], 1
+    # Assertion 3: a’[0] <= ...<= a’[n - 1] & {a’[0], ..., a’[n - 1]} = {a[0], ..., a[n - 1]}
+
+
+if __name__ == '__main__':
+    input = [3, 5, 2, 9, 1]
+    # input = [9, 6, 3, 1, 0]
+    # input = [1, 2, 3, 4, 5]
+    # input = [5, 4, 3, 2, 1]
+    bubble_sort(input)
+    print(input)

hw1 - prime factorization & complexity analysis/hw1.py

@@ -0,0 +1,85 @@
+import random
+from time import time
+
+
+# Time Complexity: O(n log n)
+# Space Complexity: O(log n) stack space for recursion + O(n) array after merge
+def merge_sort_recursive(numbers, low, high):
+    if low < high:
+        middle = (low + high) // 2
+        merge_sort_recursive(numbers, low, middle)
+        merge_sort_recursive(numbers, middle + 1, high)
+        merge(numbers, low, middle, high)
+
+
+def merge(numbers, low, mid, high):
+    i = low
+    j = mid + 1
+    sorted_nums = []
+    while i <= mid and j <= high:
+        if numbers[i] < numbers[j]:
+            sorted_nums.append(numbers[i])
+            i += 1
+        else:
+            sorted_nums.append(numbers[j])
+            j += 1
+
+    while i <= mid:
+        sorted_nums.append(numbers[i])
+        i += 1
+    while j <= high:
+        sorted_nums.append(numbers[j])
+        j += 1
+    numbers[low:high + 1] = sorted_nums[:]
+
+
+# Time Complexity: O(n log n); worst case O(n^2) when list is already sorted
+# Space Complexity: O(log n) stack space for recursion; O(n) stack in worst case
+def quick_sort_recursive(numbers, low, high):
+    if low >= high:
+        return
+    partition_index = partition(numbers, low, high)
+    quick_sort_recursive(numbers, low, partition_index - 1)
+    quick_sort_recursive(numbers, partition_index, high)
+
+
+def partition(numbers, low, high):
+    pivot = numbers[(low + high) // 2]  # Take middle element as pivot
+    while low <= high:
+        while numbers[low] < pivot:
+            low += 1
+        while numbers[high] > pivot:
+            high -= 1
+        if low <= high:
+            numbers[low], numbers[high] = numbers[high], numbers[low]
+            # swap(numbers, low, high)
+            low += 1
+            high -= 1
+    return low  # new partition position, every left is smaller than pivot, every right is bigger than pivot
+
+
+if __name__ == '__main__':
+    merge_time = []
+    quick_time = []
+    for x in range(100, 10100, 100):
+        nums = random.sample(range(1, 10100), x)
+        nums_copy = nums[:]
+        # print("before merge sort:", nums_copy)
+
+        # merge_sort_recursive(nums, 0, len(nums) - 1)
+        start_time = time()
+        merge_sort_recursive(nums, 0, len(nums) - 1)
+        time_taken = time() - start_time
+        merge_time.append(time_taken * 1000)
+        # print("after merge sort:", nums)
+
+        # print("before quick sort:", nums_copy)
+        # quick_sort_recursive(nums_copy, 0, len(nums_copy) - 1)
+        start_time = time()
+        quick_sort_recursive(nums_copy, 0, len(nums_copy) - 1)
+        time_taken = time() - start_time
+        quick_time.append(time_taken * 1000)
+        # print("after quick sort:", nums_copy)
+
+    for y in range(len(merge_time)):
+        print(merge_time[y], quick_time[y])

hw2 - sorting techniques and proof of assertions/bubble_sort.py

@@ -0,0 +1,23 @@
+def bubble_sort(a):
+    swap, j = 1, len(a)
+    # Assertion 0: a[0], ..., a[n - 1] is an array of integers with at least 1 element
+    while swap == 1:
+        # Assertion 1: swap = 1 && a'[j] <= ... <= a'[n - 1] && {a’[j], ...,a’[n - 1]} = {a[j], ..., a[n - 1]}
+        swap = 0
+        j = j - 1
+        for i in range(j):
+            # Assertion 2: a[i] is pointing to max a[0]...a[i]
+            print(i, j)
+            print(a)
+            if a[i] > a[i + 1]:
+                a[i], a[i + 1], swap = a[i + 1], a[i], 1
+    # Assertion 3: a’[0] <= ...<= a’[n - 1] & {a’[0], ..., a’[n - 1]} = {a[0], ..., a[n - 1]}
+
+
+if __name__ == '__main__':
+    input = [3, 5, 2, 9, 1]
+    # input = [9, 6, 3, 1, 0]
+    # input = [1, 2, 3, 4, 5]
+    # input = [5, 4, 3, 2, 1]
+    bubble_sort(input)
+    print(input)

hw2 - sorting techniques and proof of assertions/hw2-report.pdf

@@ -0,0 +1,85 @@
+import random
+from time import time
+
+
+# Time Complexity: O(n log n)
+# Space Complexity: O(log n) stack space for recursion + O(n) array after merge
+def merge_sort_recursive(numbers, low, high):
+    if low < high:
+        middle = (low + high) // 2
+        merge_sort_recursive(numbers, low, middle)
+        merge_sort_recursive(numbers, middle + 1, high)
+        merge(numbers, low, middle, high)
+
+
+def merge(numbers, low, mid, high):
+    i = low
+    j = mid + 1
+    sorted_nums = []
+    while i <= mid and j <= high:
+        if numbers[i] < numbers[j]:
+            sorted_nums.append(numbers[i])
+            i += 1
+        else:
+            sorted_nums.append(numbers[j])
+            j += 1
+
+    while i <= mid:
+        sorted_nums.append(numbers[i])
+        i += 1
+    while j <= high:
+        sorted_nums.append(numbers[j])
+        j += 1
+    numbers[low:high + 1] = sorted_nums[:]
+
+
+# Time Complexity: O(n log n); worst case O(n^2) when list is already sorted
+# Space Complexity: O(log n) stack space for recursion; O(n) stack in worst case
+def quick_sort_recursive(numbers, low, high):
+    if low >= high:
+        return
+    partition_index = partition(numbers, low, high)
+    quick_sort_recursive(numbers, low, partition_index - 1)
+    quick_sort_recursive(numbers, partition_index, high)
+
+
+def partition(numbers, low, high):
+    pivot = numbers[(low + high) // 2]  # Take middle element as pivot
+    while low <= high:
+        while numbers[low] < pivot:
+            low += 1
+        while numbers[high] > pivot:
+            high -= 1
+        if low <= high:
+            numbers[low], numbers[high] = numbers[high], numbers[low]
+            # swap(numbers, low, high)
+            low += 1
+            high -= 1
+    return low  # new partition position, every left is smaller than pivot, every right is bigger than pivot
+
+
+if __name__ == '__main__':
+    merge_time = []
+    quick_time = []
+    for x in range(100, 10100, 100):
+        nums = random.sample(range(1, 10100), x)
+        nums_copy = nums[:]
+        # print("before merge sort:", nums_copy)
+
+        # merge_sort_recursive(nums, 0, len(nums) - 1)
+        start_time = time()
+        merge_sort_recursive(nums, 0, len(nums) - 1)
+        time_taken = time() - start_time
+        merge_time.append(time_taken * 1000)
+        # print("after merge sort:", nums)
+
+        # print("before quick sort:", nums_copy)
+        # quick_sort_recursive(nums_copy, 0, len(nums_copy) - 1)
+        start_time = time()
+        quick_sort_recursive(nums_copy, 0, len(nums_copy) - 1)
+        time_taken = time() - start_time
+        quick_time.append(time_taken * 1000)
+        # print("after quick sort:", nums_copy)
+
+    for y in range(len(merge_time)):
+        print(merge_time[y], quick_time[y])