Timing Sorting and Search Algorithms.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Timing Basic Sorting and Search Algorithms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I created this notebook as a project to introduce myself to a few famous algorithms and as an introduction algorithmic complexity. In undergrad, I took an introductory programming class that did not cover algorithms, so I used David Joyner's Introduction to Computing (http://www.davidjoyner.net/b/wp-content/uploads/2017/03/Joyner_IntroductiontoComputing_1stEdition.pdf) to get acquainted with them, as well as other online sources. I thought this project would be a good place to start implementing some of what I learned.\n",
    "\n",
    "In the first section, I create two functions to generate lists of random integers. One allows for repeats and one does not. The one that allows for repeats works well for the sorting algorithms. The one that does not allow repeats is better for timing the search algorithms because if the search term has many repeats it can be found quicker.\n",
    "\n",
    "In the second section, I implement the Bubble Sort, an optimized version of the Bubble Sort, the Insertion Sort, and the Merge Sort.\n",
    "\n",
    "In the third section, I implement a Linear Search and a Binary Search.\n",
    "\n",
    "In the fourth section, I find the average run time of each algorithm at a fixed list length.\n",
    "\n",
    "In the final section, I graph the average run time over different list lenghts.\n",
    "\n",
    "In the bonus section, I determine the algorithmic complexity of my functions to time and plot the sorting and searching algorithms."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## I. Creating the List to be Sorted"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As previously mentioned, this section just creates the functions that create the lists to be searched and sorted."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Imports the random function for generating random numbers\n",
    "from numpy import random\n",
    "\n",
    "# Imports the log2 function for the \n",
    "from numpy import log2\n",
    "\n",
    "# Imports the timeit library to time the performance of sort and search algorithms\n",
    "import timeit\n",
    "\n",
    "# This next block of code defines a function that creates a list of random \n",
    "# integers. The length of the list and bounds of the integers are determined\n",
    "# by the user.\n",
    "\n",
    "def rand_int_list(length, lower_bound, upper_bound):\n",
    "    \n",
    "    # creates an empty list that will be appended with random integers\n",
    "    my_list = []\n",
    "    \n",
    "    # creates a variable that will be incremented up to the length amount\n",
    "    # allowing the while loop to run the number of times as the user\n",
    "    # inputed length\n",
    "    count = 0\n",
    "    \n",
    "    # starts the while loop that will run while count is less than\n",
    "    # the user determined length\n",
    "    while count < length:\n",
    "        \n",
    "        # appends a random integer between the lower and upper bounds determined\n",
    "        # by the user to my_list\n",
    "        my_list.append(random.randint(lower_bound, upper_bound))\n",
    "        \n",
    "        # increments the count by 1 for each iteration of the loop\n",
    "        count += 1\n",
    "        \n",
    "    # returns the list of random integers\n",
    "    return my_list\n",
    "\n",
    "def rand_int_list_no_repeats(length, lower_bound, upper_bound):\n",
    "    \n",
    "    if length < (upper_bound - lower_bound):\n",
    "    \n",
    "        # creates an empty list that will be appended with random integers\n",
    "        my_list = []\n",
    "    \n",
    "        # creates a variable that will be incremented up to the length amount\n",
    "        # allowing the while loop to run the number of times as the user\n",
    "        # inputed length\n",
    "        count = 0\n",
    "    \n",
    "        my_array = list(range(lower_bound, upper_bound))\n",
    "        random.shuffle(my_array)\n",
    "    \n",
    "        # starts the while loop that will run while count is less than\n",
    "        # the user determined length\n",
    "        while count < length:\n",
    "        \n",
    "            # appends a random integer between the lower and upper bounds determined\n",
    "            # by the user to my_list\n",
    "            my_list.append(my_array.pop(random.randint(len(my_array) - 1)))\n",
    "        \n",
    "            # increments the count by 1 for each iteration of the loop\n",
    "            count += 1\n",
    "        \n",
    "        # returns the list of random integers\n",
    "        return my_list\n",
    "    \n",
    "    else:\n",
    "        print('Desired length must be less than the upper bound minus lower bound.') \n",
    "\n",
    "# creates a smaller list to show that the sort algorithms are properly sorting\n",
    "example_list = rand_int_list(10, 0, 10)\n",
    "\n",
    "# creates a copy of the example_sort for each of the sorting algorithms to show that they are\n",
    "# actually functioning\n",
    "(ex_bub_list, ex_opt_bub_list, ex_insert_list, \n",
    " ex_merge_list, ex_linear_list, ex_binary_list) = (example_list.copy(), example_list.copy(), \n",
    "                                                   example_list.copy(), example_list.copy(),\n",
    "                                                   example_list.copy(), example_list.copy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## II. Sorting Algorithms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I chose the sorting algorithms that I did because I had seen them before. Not necessarily the best reason, but there it is. It worked out well though because the Bubble Sort, on average, acts as a slower O(n^2) and the Optimized Bubble Sort demonstrates that you can increase the speed of a O(n^2) algorithm, but it is still O(n^2) and will experience its average run time grow at that rate. The Insertion Sort further demonstrates that fact. The Merge Sort is, on average, a O(n * log(n)) sorting algorithm, so it will be faster than the others and will grow at a slower rate as well.\n",
    "\n",
    "I won't discuss each algorithm in detail, but the comments on the code should illustrate how the algorithm works. I also linked to the wikipedia page for each algorithm."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A. Bubble Sort (https://en.wikipedia.org/wiki/Bubble_sort)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unsorted List:  [1, 1, 8, 3, 8, 1, 3, 1, 0, 0]\n",
      "Sorted List:  [0, 0, 1, 1, 1, 1, 3, 3, 8, 8]\n"
     ]
    }
   ],
   "source": [
    "def Bubble_Sort(my_list):\n",
    "    \n",
    "    # initializes swapped as True so the while loop will execute at least once\n",
    "    swapped = True\n",
    "  \n",
    "    # this loop runs while there was a swap of elements in the previous round\n",
    "    while swapped == True:\n",
    "        \n",
    "        # sets swapped equal to False so if there are no swaps this iteration\n",
    "        # the loop ends\n",
    "        swapped = False\n",
    "        \n",
    "        # looks at the first element in the list to the second to last element of the list\n",
    "        for i in range(len(my_list) - 1):\n",
    "            \n",
    "            # executes the below code it the element on the left is larger than the\n",
    "            # element on the right (ie the pair is unsorted)\n",
    "            if my_list[i] > my_list[i + 1]:\n",
    "                \n",
    "                # if this code is being executed a swap occured and we want to indicate\n",
    "                # that fact so the while loop keeps executing\n",
    "                swapped = True\n",
    "                \n",
    "                # creates a temporary variable that will store the larger value to be\n",
    "                # swapped right\n",
    "                storage = my_list[i]\n",
    "                \n",
    "                # deletes the unsorted larger element\n",
    "                del my_list[i]\n",
    "                \n",
    "                # inserts the larger element to the right of the smaller element\n",
    "                my_list.insert(i + 1, storage)\n",
    "    \n",
    "    # returns the sorted list\n",
    "    return my_list\n",
    "\n",
    "print('Unsorted List: ', example_list)\n",
    "print('Sorted List: ', Bubble_Sort(ex_bub_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### B. Optimized Bubble Sort"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unsorted List:  [1, 1, 8, 3, 8, 1, 3, 1, 0, 0]\n",
      "Sorted List:  [0, 0, 1, 1, 1, 1, 3, 3, 8, 8]\n"
     ]
    }
   ],
   "source": [
    "def Optimized_Bubble_Sort(my_list):\n",
    "    \n",
    "    # initializes swapped as True so the while loop will execute at least once\n",
    "    swapped = True\n",
    "    \n",
    "    # creates a variable that is the max index checked by the swap (second to last\n",
    "    # because of the use of the range function)\n",
    "    max_index = len(my_list) - 1\n",
    "  \n",
    "    # this loop runs while there was a swap of elements in the previous round and\n",
    "    # the max index is 1 or greater (the range function is used for the for loop\n",
    "    # so when it is equal to 1 the for loop still checks the first pair of elements)\n",
    "    while swapped == True and max_index > 0:\n",
    "        \n",
    "        # sets swapped equal to False so if there are no swaps this iteration\n",
    "        # the loop ends\n",
    "        swapped = False\n",
    "        \n",
    "        # because the range function stops at the integer before the input, the\n",
    "        # second to last index is the last element to be compared, which makes\n",
    "        # sense because there is nothing to the right of the last element\n",
    "        for i in range(max_index):\n",
    "            \n",
    "            # executes the below code it the element on the left is larger than the\n",
    "            # element on the right (ie the pair is unsorted)\n",
    "            if my_list[i] > my_list[i + 1]:\n",
    "                \n",
    "                # if this code is being executed a swap occured and we want to indicate\n",
    "                # that fact so the while loop keeps executing\n",
    "                swapped = True\n",
    "                \n",
    "                # creates a temporary variable that will store the larger value to be\n",
    "                # swapped right\n",
    "                storage = my_list[i]\n",
    "                \n",
    "                # deletes the unsorted larger element\n",
    "                del my_list[i]\n",
    "                \n",
    "                # inserts the larger element to the right of the smaller element\n",
    "                my_list.insert(i + 1, storage)\n",
    "        \n",
    "        # because the largest element goes to the end of the list after the first iteration\n",
    "        # the second largest element goes to the second to last postion after the second\n",
    "        # iteration, and so on, time is saved by not rechecking those elements, which is why\n",
    "        # max_index decreases by 1 every iteration\n",
    "        max_index -= 1\n",
    "    \n",
    "    # returns the sorted list\n",
    "    return my_list\n",
    "\n",
    "print('Unsorted List: ', example_list)\n",
    "print('Sorted List: ', Optimized_Bubble_Sort(ex_opt_bub_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### C. Insertion Sort (https://en.wikipedia.org/wiki/Insertion_sort)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unsorted List:  [1, 1, 8, 3, 8, 1, 3, 1, 0, 0]\n",
      "Sorted List:  [0, 0, 1, 1, 1, 1, 3, 3, 8, 8]\n"
     ]
    }
   ],
   "source": [
    "def Insertion_Sort(my_list):\n",
    "    \n",
    "    # creates a copy of the input list so changes to the inputed list don't affect it\n",
    "    # ie. running the function repeatedly on the list don't delete the first entry\n",
    "    # until the list is empty\n",
    "    unsorted_list = my_list.copy()\n",
    "    \n",
    "    # creates a list that will hold the sorted input list initialized with the first\n",
    "    # element of the unsorted list\n",
    "    sorted_list = [unsorted_list[0]]\n",
    "    \n",
    "    # deletes the first element in the unsorted list because it is now in the sorting\n",
    "    # list\n",
    "    del unsorted_list[0]\n",
    "     \n",
    "    # loops through the items in the unsorted list\n",
    "    for i in unsorted_list:    \n",
    "        \n",
    "        # if the item in the unsorted list is greater than or equal to the last item in the sorted\n",
    "        # list, it will be appended to the end of the sorted list\n",
    "        if i >= sorted_list[len(sorted_list) - 1]:\n",
    "            sorted_list.append(i)\n",
    "            \n",
    "        # if the item in the unsorted list is less than the last item in the sorted list...\n",
    "        else:\n",
    "            \n",
    "            # loops throught the indexes in the sorted list\n",
    "            for j in range(len(sorted_list)):\n",
    "                \n",
    "                # if the item in the unsorted list is less than or equal to the element at the\n",
    "                # jth index of the sorted list, it is inserted in its place and the loop is\n",
    "                # cut off\n",
    "                if i <= sorted_list[j]:\n",
    "                    sorted_list.insert(j,  i)\n",
    "                    break\n",
    "    \n",
    "    # returns the sorted list\n",
    "    return sorted_list\n",
    "\n",
    "print('Unsorted List: ', example_list)\n",
    "print('Sorted List: ', Insertion_Sort(ex_bub_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### D. Merge Sort (https://en.wikipedia.org/wiki/Merge_sort)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unsorted List:  [1, 1, 8, 3, 8, 1, 3, 1, 0, 0]\n",
      "Sorted List:  [0, 0, 1, 1, 1, 1, 3, 3, 8, 8]\n"
     ]
    }
   ],
   "source": [
    "def Merge_Sort(my_list):\n",
    "    \n",
    "    # if the list is two or more elements...\n",
    "    if len(my_list) > 1:\n",
    "        \n",
    "        # creates an empty list that will store the sorted list\n",
    "        sorted_list = []\n",
    "        \n",
    "        # creates a variable to hold the middle index by using floor division to divide the list\n",
    "        # in half and round down\n",
    "        mid_index = len(my_list) // 2\n",
    "        \n",
    "        # recursively breaks the input list down until it creates 1 element lists\n",
    "        left_list = Merge_Sort(my_list[:mid_index])\n",
    "        right_list = Merge_Sort(my_list[mid_index:])\n",
    "        \n",
    "        # while the left_list and right_list lists are not empty...\n",
    "        while (len(left_list) > 0) and (len(right_list) > 0):\n",
    "            \n",
    "            # if the first element of the left list is less than the first element in the right list,\n",
    "            # it is added to the sorted list and deleted from the left list\n",
    "            if left_list[0] < right_list[0]:\n",
    "                sorted_list.append(left_list[0])\n",
    "                del left_list[0]\n",
    "            \n",
    "            # if the first element of the right list is equal to or less than the first element in \n",
    "            # the left list, it is added to the sorted list and deleted from the right list\n",
    "            else:\n",
    "                sorted_list.append(right_list[0])\n",
    "                del right_list[0]\n",
    "        \n",
    "        # once one of the lists is empty, the loop exits and the elements in the non-empty list are\n",
    "        # added to the end of the sorted_list\n",
    "        sorted_list.extend(left_list)\n",
    "        sorted_list.extend(right_list)\n",
    "        \n",
    "    # if the list is one element of an empty list, it is returned, which is very important to provide\n",
    "    # an end point for the recursion process\n",
    "    else:\n",
    "        \n",
    "        # returns the list\n",
    "        return my_list\n",
    "    \n",
    "    # returns the sorted list\n",
    "    return sorted_list\n",
    "\n",
    "print('Unsorted List: ', example_list)\n",
    "print('Sorted List: ', Merge_Sort(ex_merge_list))  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## III. Search Algorithms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Linear Search has a linear complexity [O(n)] and is good for searching through unsorted lists.\n",
    "\n",
    "The Binary Search requires a sorted list as an input. On average, it is of O(log(n)) complexity, excluding sorting time. The number of operations it has to perform grows slower than the growth rate of the the input list. When it has to sort the list prior to searching (assuming a O(n * log(n) sorting algorithm), its complexity becomes O(n * log(n)), which is a faster growth rate than O(n).\n",
    "\n",
    "I won't discuss each algorithm in detail, but the comments on the code should illustrate how the algorithm works. I also linked to the wikipedia page for each algorithm."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A. Linear Search (https://en.wikipedia.org/wiki/Linear_search)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Searching for 7 in list [1, 1, 8, 3, 8, 1, 3, 1, 0, 0]\n",
      "\n",
      "Index of Search Term:  Value not found!\n"
     ]
    }
   ],
   "source": [
    "def Linear_Search(my_list, target_value):\n",
    "    \n",
    "    # loops through the indexes in the input list\n",
    "    for i in range(len(my_list)):\n",
    "        \n",
    "        # if the value at the index is equal to our target value, the index is returned\n",
    "        if my_list[i] == target_value:\n",
    "            return i\n",
    "        \n",
    "    # if the loop goes through the end of the list and isn't found then this is returned    \n",
    "    return 'Value not found!'\n",
    "\n",
    "search_term = random.randint(0, 10)\n",
    "\n",
    "print('Searching for ' + str(search_term) + ' in list ' + str(ex_linear_list))\n",
    "print()\n",
    "print('Index of Search Term: ', Linear_Search(ex_linear_list, search_term))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### B. Binary Search (https://en.wikipedia.org/wiki/Binary_search_algorithm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Searching for 7 in list [1, 1, 8, 3, 8, 1, 3, 1, 0, 0]\n",
      "\n",
      "Value not found!\n"
     ]
    }
   ],
   "source": [
    "def Binary_Search(my_list, target_value):\n",
    "    \n",
    "    # binary search requires a sorted list, so this function will call the built-in python\n",
    "    # sort method because it is faster than any sorting algorithm I have implemented\n",
    "    my_list.sort()\n",
    "    \n",
    "    # initializes the minimum index at 0\n",
    "    min_index = 0\n",
    "    \n",
    "    # initializes the maximum index at the maximum index of the list + 1\n",
    "    max_index = len(my_list) \n",
    "    \n",
    "    # sets the maximum number of iterations as the base 2 log of the length of the sorted list\n",
    "    max_iterations = round(log2(len(my_list)))\n",
    "    \n",
    "    # initializes found as False\n",
    "    found = False\n",
    "    \n",
    "    # while the number of max iterations is greater than or equal to zero and the target has not\n",
    "    # been found...\n",
    "    while max_iterations >= 0 and found == False:\n",
    "        \n",
    "        # a variable is created to hold the middle index\n",
    "        mid_index = (max_index + min_index) // 2        \n",
    "        \n",
    "        # if the target value is lower than the element at the middle index of the sorted list, a\n",
    "        # new list is generated holding the elements to the left of that index and the Binary \n",
    "        if target_value < my_list[mid_index]:   \n",
    "            max_index = mid_index\n",
    "\n",
    "        # if the target value is greater than the element at the middle index of the sorted list, a\n",
    "        # new list is generated holding the elements to the right of that index and the Binary    \n",
    "        elif target_value > my_list[mid_index]:\n",
    "            min_index = mid_index\n",
    "\n",
    "        # if the element at the middle index equals the target value, the index within the sorted\n",
    "        # list and the sorted list are returned\n",
    "        else:\n",
    "            found = True\n",
    "            return {'index': mid_index, 'sorted list': my_list}\n",
    "        \n",
    "        max_iterations -= 1\n",
    "        \n",
    "    else:\n",
    "        return 'Value not found!'\n",
    "\n",
    "print('Searching for ' + str(search_term) + ' in list ' + str(ex_binary_list))\n",
    "print()\n",
    "print(Binary_Search(ex_binary_list, search_term))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Searching for 7 in list [0, 0, 1, 1, 1, 1, 3, 3, 8, 8]\n",
      "\n",
      "Index of Search Term : Value not found!\n"
     ]
    }
   ],
   "source": [
    "def Binary_Search_pre_sort(my_list, target_value):\n",
    "    \n",
    "    # initializes the minimum index at 0\n",
    "    min_index = 0\n",
    "    \n",
    "    # initializes the maximum index at the maximum index of the list + 1\n",
    "    max_index = len(my_list) \n",
    "    \n",
    "    # sets the maximum number of iterations as the base 2 log of the length of the sorted list\n",
    "    max_iterations = round(log2(len(my_list)))\n",
    "    \n",
    "    # initializes found as False\n",
    "    found = False\n",
    "    \n",
    "    # while the number of max iterations is greater than or equal to zero and the target has not\n",
    "    # been found...\n",
    "    while max_iterations >= 0 and found == False:\n",
    "        \n",
    "        # a variable is created to hold the middle index\n",
    "        mid_index = (max_index + min_index) // 2        \n",
    "        \n",
    "        # if the target value is lower than the element at the middle index of the sorted list, a\n",
    "        # new list is generated holding the elements to the left of that index and the Binary \n",
    "        if target_value < my_list[mid_index]:   \n",
    "            max_index = mid_index\n",
    "\n",
    "        # if the target value is greater than the element at the middle index of the sorted list, a\n",
    "        # new list is generated holding the elements to the right of that index and the Binary    \n",
    "        elif target_value > my_list[mid_index]:\n",
    "            min_index = mid_index\n",
    "\n",
    "        # if the element at the middle index equals the target value, the index within the sorted\n",
    "        # list and the sorted list are returned\n",
    "        else:\n",
    "            found = True\n",
    "            return mid_index\n",
    "        \n",
    "        max_iterations -= 1\n",
    "        \n",
    "    else:\n",
    "        return 'Value not found!'\n",
    "\n",
    "    \n",
    "ex_binary_list_sorted = example_list.copy()\n",
    "ex_binary_list.sort()\n",
    "print('Searching for ' + str(search_term) + ' in list ' + str(ex_binary_list))\n",
    "print()\n",
    "print('Index of Search Term :', Binary_Search_pre_sort(ex_binary_list_sorted, search_term))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## IV. Timing the Algorithms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The code below produces average run speeds of each algorithm using user specified parameters. As we would expect,\n",
    "Bubble Sort is slower than the Optimized version of itself. Merge Sort and Insertion Sort are the fastest sorting algorithms.\n",
    "\n",
    "The pre-sorting the list doesn't make a difference in run time for the linear search, as expected, but there is a multiple orders of magnitude difference in pre-sorting the lists for binary search. As previously mentioned, using a pre-sorted list vs. having to sort the input list is the difference between O(log(n)) and O(n * log(n)) for binary search.\n",
    "\n",
    "Average run times tells us something about the comparative speed of each algorithm at a fixed list length, but we need to plot the average run speeds over various list lengths to get a better understanding of the complexity of each algorithm."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average Bubble Sort Run Time over 500 iterations on 100 element lists: 0.0013335777541328153 ms\n",
      "\n",
      "Average Optimized Bubble Sort Run Time over 500 iterations on 100 element lists: 0.0010453950592764474 ms\n",
      "\n",
      "Average Insertion Sort Run Time over 500 iterations on 100 element lists: 0.00017052541913384738 ms\n",
      "\n",
      "Average Merge Sort Run Time over 500 iterations on 100 element lists: 0.00030609287436595046 ms\n",
      "\n",
      "Average Linear Search Time over 500 iterations on 1000 element un-sorted lists: 0.035206412232422934 ms\n",
      "\n",
      "Average Binary Search Time over 500 iterations on 1000 element un-sorted lists: 0.2363959435712708 ms\n",
      "\n",
      "Average Linear Search Time over 500 iterations on 1000 element sorted lists: 0.026421611531016964 ms\n",
      "\n",
      "Average Binary Search Time over 500 iterations on 1000 element sorted lists: 0.013520422226234174 ms\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# this code allows the sorting and search functions be passed to the timeit module without\n",
    "# arguments, which is the format timeit requires to run\n",
    "def wrapper(func, *args):\n",
    "    def wrapped():\n",
    "        return func(*args)\n",
    "    return wrapped \n",
    "\n",
    "# this function prints out the average run time of the sorting algorithms over a specified number of \n",
    "# iterations\n",
    "def avg_sort_time(number_of_sorts, length, lower_bound, upper_bound):\n",
    "    \n",
    "    # initializes the runtimes at 0\n",
    "    bubble_time = 0\n",
    "    opt_bubble_time = 0\n",
    "    insert_time = 0\n",
    "    merge_time = 0\n",
    "    \n",
    "    # performs the inputed number of iterations, sorting a new list of random integers each iteration\n",
    "    # and then adds the runtime of that iteration to the associated runtime variable\n",
    "    for i in range(number_of_sorts):\n",
    "        \n",
    "        list_to_sort = rand_int_list(length, lower_bound, upper_bound)\n",
    "        (bub_list, opt_bub_list, insert_list, merge_list) = (list_to_sort.copy(), list_to_sort.copy(), \n",
    "                                                             list_to_sort.copy(), list_to_sort.copy())\n",
    "        bubble_sort = wrapper(Bubble_Sort, bub_list)\n",
    "        bubble_time += timeit.timeit(bubble_sort, number = 1)\n",
    "\n",
    "        optimized_bubble_sort = wrapper(Optimized_Bubble_Sort, opt_bub_list)\n",
    "        opt_bubble_time += timeit.timeit(optimized_bubble_sort, number = 1)\n",
    "\n",
    "        insertion_sort = wrapper(Insertion_Sort, insert_list)\n",
    "        insert_time += timeit.timeit(insertion_sort, number = 1)\n",
    "\n",
    "        merge_sort = wrapper(Merge_Sort, merge_list)\n",
    "        merge_time += timeit.timeit(merge_sort, number = 1)\n",
    "        \n",
    "    # averages the total runtimes by the number of iterations performed    \n",
    "    avg_bubble_time = bubble_time / number_of_sorts\n",
    "    avg_opt_bubble_time = opt_bubble_time / number_of_sorts\n",
    "    avg_insert_time = insert_time / number_of_sorts\n",
    "    avg_merge_time = merge_time / number_of_sorts\n",
    "    \n",
    "    return print('Average Bubble Sort Run Time over ' + str(number_of_sorts) + ' iterations on ' +\n",
    "                 str(length) + ' element lists: ' + str(avg_bubble_time) + ' ms' \n",
    "                 + '\\n' + '\\n' +\n",
    "                 'Average Optimized Bubble Sort Run Time over ' + str(number_of_sorts) + ' iterations on ' \n",
    "                 + str(length) + ' element lists: ' + str(avg_opt_bubble_time) + ' ms' \n",
    "                 + '\\n' + '\\n' +    \n",
    "                 'Average Insertion Sort Run Time over ' + str(number_of_sorts) + ' iterations on ' + \n",
    "                 str(length) + ' element lists: ' + str(avg_insert_time) + ' ms' \n",
    "                 + '\\n' + '\\n' +\n",
    "                 'Average Merge Sort Run Time over ' + str(number_of_sorts) + ' iterations on ' + \n",
    "                 str(length) + ' element lists: ' + str(avg_merge_time) + ' ms' + '\\n')\n",
    "\n",
    "# this function does the same as the above function, but for the search algorithms\n",
    "def avg_search_time(number_of_searches, length, lower_bound, upper_bound, pre_sort):\n",
    "    \n",
    "    linear_time = 0\n",
    "    binary_time = 0\n",
    "    \n",
    "    # a non-exhaustive list of possibilities that will cause the function to not function\n",
    "    if (number_of_searches < 1) or (length >= (upper_bound - lower_bound)) or ((pre_sort != True) and (pre_sort != False)):\n",
    "        print('Error: One or more inputs are invalid!')\n",
    "    \n",
    "    # times the algorithms, including the sorting time for binary search\n",
    "    elif pre_sort == False:\n",
    "    \n",
    "        for i in range(number_of_searches):\n",
    "        \n",
    "            search_list = rand_int_list_no_repeats(length, lower_bound, upper_bound)\n",
    "        \n",
    "            search_value = random.randint(lower_bound, upper_bound)\n",
    "        \n",
    "            linear_search = wrapper(Linear_Search, search_list, search_value)\n",
    "            linear_time += timeit.timeit(linear_search, number = 1)\n",
    "        \n",
    "            binary_search = wrapper(Binary_Search, search_list, search_value)\n",
    "            binary_time += timeit.timeit(binary_search, number = 1)\n",
    "        \n",
    "        avg_linear_time = linear_time / number_of_searches\n",
    "        avg_binary_time = binary_time / number_of_searches\n",
    "    \n",
    "        return print('Average Linear Search Time over ' + str(number_of_searches) + ' iterations on ' + \n",
    "                     str(length) + ' element un-sorted lists: ' + str(1000 * avg_linear_time) + ' ms' + '\\n' \n",
    "                     + '\\n' +\n",
    "                     'Average Binary Search Time over ' + str(number_of_searches) + ' iterations on ' + \n",
    "                     str(length) + ' element un-sorted lists: ' + str(1000 * avg_binary_time) + ' ms' + '\\n')\n",
    "    \n",
    "    # times the search algorithms on pre-sorted lists\n",
    "    elif pre_sort == True:\n",
    "    \n",
    "        for i in range(number_of_searches):\n",
    "        \n",
    "            search_list = list(range(length + 1))\n",
    "        \n",
    "            search_value = random.randint(length)\n",
    "        \n",
    "            linear_search = wrapper(Linear_Search, search_list, search_value)\n",
    "            linear_time += timeit.timeit(linear_search, number = 1)\n",
    "        \n",
    "            binary_search = wrapper(Binary_Search_pre_sort, search_list, search_value)\n",
    "            binary_time += timeit.timeit(binary_search, number = 1)\n",
    "        \n",
    "        avg_linear_time = linear_time / number_of_searches\n",
    "        avg_binary_time = binary_time / number_of_searches\n",
    "    \n",
    "        return print('Average Linear Search Time over ' + str(number_of_searches) + ' iterations on ' + \n",
    "                     str(length) + ' element sorted lists: ' + str(1000 * avg_linear_time) + ' ms' + '\\n' \n",
    "                     + '\\n' +\n",
    "                     'Average Binary Search Time over ' + str(number_of_searches) + ' iterations on ' + \n",
    "                     str(length) + ' element sorted lists: ' + str(1000 * avg_binary_time) + ' ms' + '\\n')\n",
    "\n",
    "# returns the average sort or search times of each algorithm\n",
    "avg_sort_time(500, 100, 0, 101)\n",
    "avg_search_time(500, 1000, 0, 1001, False)\n",
    "avg_search_time(500, 1000, 0, 1001, True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## V. Graphing the Average Algorith Run Times"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I plotted the average run times for a user specified number of iterations at each step because sometimes the lists generated are optimal for the task being performed and the algorithms performs much faster than the average case. Averaging dampens this variability.\n",
    "\n",
    "The graphs are as expected.\n",
    "\n",
    "The bubble sorts (regular and optimized) and the insertion sort are all growing at a quadratic pace. The Merge Sort and Binary Search **with sorting** are growing at the quasilinear pace of n * log(n).\n",
    "\n",
    "The linear search is growing at a linear rate, both with a pre-sorted list and without, as expected.\n",
    "\n",
    "The difference in the graphs of average run time for the Binary Search with pre-sorting and without pre-sorting puts in graphical terms the difference in algorithmic complexity between O(log(n)) and O(n * log(n))."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.rcParams['figure.figsize'] = [15, 4]\n",
    "\n",
    "def plot_sort_time(sort_type, max_trials, step, iterations_for_avg):\n",
    "    \n",
    "    x = []\n",
    "    y = []\n",
    "    \n",
    "    for i in range(1, max_trials + 1, step):\n",
    "        my_time = 0\n",
    "        for j in range(iterations_for_avg + 1):\n",
    "            trial_list = rand_int_list(i, 0, i + 1)\n",
    "            sort = wrapper(sort_type, trial_list)\n",
    "            my_time += timeit.timeit(sort, number = 1)\n",
    "        x.append(i)\n",
    "        y.append(1000 * (my_time / iterations_for_avg))\n",
    "    \n",
    "    plt.scatter(x,y)\n",
    "    plt.plot(x,y)\n",
    "    plt.xlabel('Length of List being Sorted')\n",
    "    plt.ylabel('Run Time in Milliseconds')\n",
    "    plt.title('Run Time of ' + str(sort_type) + ' Sort in Milliseconds')\n",
    "    plt.ylim(bottom = 0)\n",
    "    plt.show()\n",
    "\n",
    "def plot_search_time(search_type, max_trials, step, iterations_for_avg, pre_sort):\n",
    "    \n",
    "    x = []\n",
    "    y = []\n",
    "    \n",
    "    # a non-exhaustive list of possibilities that will cause the function to not function\n",
    "    if (step > max_trials) or (max_trials < 0) or (step < 0) or ((pre_sort != False) and (pre_sort != True)):\n",
    "        print('Error: One or more inputs are invalid!')\n",
    "    \n",
    "    elif pre_sort == False:\n",
    "       \n",
    "        for i in range(1, max_trials + 1, step):\n",
    "            my_time = 0\n",
    "            for j in range(iterations_for_avg):\n",
    "                trial_list = rand_int_list_no_repeats(i, 0, i + 1)\n",
    "                search_value = random.randint(i)\n",
    "                search = wrapper(search_type, trial_list, search_value)\n",
    "                my_time += timeit.timeit(search, number = 1)\n",
    "            x.append(i)\n",
    "            y.append(1000 * (my_time / iterations_for_avg))\n",
    "    \n",
    "        plt.scatter(x,y)\n",
    "        plt.plot(x,y)\n",
    "        plt.xlabel('Length of List being Searched')\n",
    "        plt.ylabel('Run Time in Milliseconds')\n",
    "        plt.title('Run Time of ' + str(search_type) + ' in Milliseconds')\n",
    "        plt.ylim(bottom = 0)\n",
    "        plt.show()\n",
    "    \n",
    "    elif pre_sort == True:\n",
    "    \n",
    "        for i in range(1, max_trials + 1, step):\n",
    "            my_time = 0\n",
    "            for j in range(iterations_for_avg):\n",
    "                trial_list = list(range(i + 1))\n",
    "                search_value = random.randint(i)\n",
    "                search = wrapper(search_type, trial_list, search_value)\n",
    "                my_time += timeit.timeit(search, number = 1)\n",
    "            x.append(i)\n",
    "            y.append(1000 * (my_time / iterations_for_avg))\n",
    "    \n",
    "        plt.scatter(x,y)\n",
    "        plt.plot(x,y)\n",
    "        plt.xlabel('Length of List being Searched')\n",
    "        plt.ylabel('Run Time in Milliseconds')\n",
    "        plt.title('Run Time of ' + str(search_type) + ' on pre-sorted Lists in Milliseconds')\n",
    "        plt.ylim(bottom = 0)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgEAAAEWCAYAAAD/3UTfAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvDW2N/gAAIABJREFUeJzs3XecHWXZ//HPtSXJpi4hPSGEQBIIJYXQERHRICBNpIg0UeRRVIpRsDzATxExioI+gigdpCaETuhVKWkkAdIICWQT0jd1k23X74+5T5icnO3l7Dnn+3699rVn7mnXzJyZuc49M/eYuyMiIiK5Jy/dAYiIiEh6KAkQERHJUUoCREREcpSSABERkRylJEBERCRHKQkQERHJUUoCREREclTGJAFmNtDMNppZfprjMDO7w8zWmtk7TZzWb81slZl91lzx1XO+t5jZr1tznvVhZnea2W9r6e9mtkcN/c4zszdaLjoRaUlm9gUzm9vC89juPGJmr5jZd8Pn7Y4hYbjBLRlPczCzI81sSWPHrzMJMLNFZlYWVshn4UDdubEzrGU+t4R5bDSzcjOriHU/4+6fuHtnd69q7nk30OHAV4AB7n5gYydiZrsAlwPD3b1PcwWXYj47nBzd/SJ3/00LzOvqpO32oZl9o7nn01LMbICZTQiJ2Tozm2Vm5zVheovM7OgmjL/tAFXLMCPNbKqZbQ7/RzZg+peGfXqdmd1uZu1j/QaZ2cthunOSl6MFx/1NWO+VZnZ1DXEfGRLCnyWVfyH23Uv8efw7aGaDzexJM9sQtvMfUkz/lZDkt08qNzO73sxWh78/mJnFltlj811uZn83s8LY+Pea2TIzW29m8+LbNixTdWz8EjO7Jmn+bmabYsOUxvqdFva3DWb2gZmdlGrdNURr7w/u/rq7D2vktM8L6+eGpPKTQvmdYR71Po+E4RY2Jp5MUt+agK+7e2dgJDAKuLK5Awknps5hPr8DHkx0u/vXmnt+TbArsMjdNzV0RDMrMrMusemsdvcVzRpd+j0Y246XAPeaWe90B1VP9wCfEm2bnYFzgOUNnYiZFTRzXDXNpx3wGHAvsBNwF/BYKK9r3LHAFcCXgUHAYCB+0rkfmE60Hn4JPGJmPVth3AXAz4Cnagn/XGBN+L9NOIl0jn3/jgc2As+GebcDngdeAvoAA4jWXXy9DAK+ADhwQtJ8LwROAkYA+4Xpfz9pmOIw732BQ4AfxvpdBwxy965h2r81s/1j/ZfGYj8cuCDFyXxEbBmLQ8z9w3JcBnQFxgH/NrNeoX/3eDLSABm1PwAfAacnze8cYF4rzT8zuXutf8Ai4OhY9x+Ap2LdrwDfjXWfB7wR63bgImA+sBb4P8DqmOfVwL1JZYPCtApi8/0t8B+iHf0Joi/qfcB64F2iHS4x/p5EB4A1wFzgtFrm3w94PAy7APheKL8A2AJUhXleU9f6C+MdDPwjLP8hwNFAGVAdpnMncCSwpKZ1H9bJQ8DdwAbgfWBMbNhdgInASmA18Ddgr6R4S8OwdwK/jY37vbCca8Jy92vM9qthu60ADk313YhNf49YXLeE7bQBeBXYNWnYHwMLgVXAeCCvhu9dvbd3bJyNwMha+p8Q1nsp0fdvr6Rt9XNgJrCV6ERYHbbzRuBnKaa3E/Bk2GZrw+cBod+1YbttCeP/LcX4XwVK4tsD+AQ4BmgHzAB+FMrzgTeB/w3d/wZ+Fxvvy8Bn4fPQsAxdYv1fBy5qyXGTlu1e4OoU5R3Dd+MMoJzYPpBi2DuAO2LdFwKv1/Ed+N+wnm4Ankzq9x/gwlj3BcBbqY5PoewPwK01zGcYsCzxvST1/v8Q8ItU+0rScAcBK5LKVgKHhM+nE528/wTsU9d+kMb9Ybt1EKbx0zCNdcCDQIcaYjkPeIMo4TsulHUHPiM6TtyZajsRO3+R+tyVODYdC3wQvnslwE9jwx1PtK+Vhu/IfrF+OxyXQ3ke8CtgMdEx8m6gW1KM5xLtz6uAX8amWUR0rFwbYhqXtN5+HmLcQHTs+3Kt27keX4RFfH4iGgDMAm6M9d+2EmtZkU8CxcDAsDKOqWOeV1O/JGABsDvQLayMeUQn2IKwUu8Iw3YiymjPD/1GhxW7dw3zfxX4O9CBqPZjZWJFJi9fLcvQl+gXzYdEGepVwG61fOG3606x7q8mOiEcS3RAv47PD0D5wHvAn8OydgAOryleYkkAcFRYF6OB9sBfgdcas/3i2w0w4DiiHaO4lliSk4ANwBEhlhtTfJdeJtq5B4btvcMO3NDtHZv+C0QngDOAgUn9hgKbiC4FFYZtuwBoF9tWM4h2+qLk7VfD/HYGvkF0YusCPAxMqmnfSjH+pcAzSWVPApeHz/sQHSj2IvpF/haQH/q9B5weG69HWL87AycDHyZN92/AX1ty3KRxakoCziY6eeYTJf431bBuEsnCkbGy24l+3T4Tvg+vAPsmjbcA+AGwP1AB9I71WwccFOseA2yo4fjULyzrd5Km/3dgcxh2GtC5huPBEKID+VGp9pWkaeYTHbNOCJ9PApYAnWLD7EN0MlxK9APpB8BObWx/SF4Hi4B3wrrsTnQsvaiGcc8jSgK+RVQbSVjGfxD9WGxqErAM+EL4vBMwOnweTXQSPyis+3ND3O2p/bj8nbC+BgOdiRKFe5Ji/CfRCX8EUSK1V+j/e6LEuntYv7MT640oufyU8EMuTGv32rZzfS8HTDKzDWHiK4hOaA3xe3cvdfdPiA7i9b5uWYc73P0jd19HtGN/5O4vuHsl0QF1VBjueKIq/DvcvdLdpwETgFOTJ2jRtfrDgZ+7+xZ3nwH8i+jgUyeLbjx5kigp2ZOounAPd7/G3T9u2uLyhrs/7dH1rHuIvhwABxLtKOPcfVOIu743yZ0F3O7u09x9K9GlnkNCtWhCQ7bfaeFa5SaiWoXfuXtpLcMne8rdXwux/DLEskus//XuvibE8hfgzBTTqPf2TvJNop3r18DHZjbDzA4I/U4PsT3v7hXAH4l20ENj49/k7p+6e1l9FtTdV7v7BHff7O4biH79f7E+4wadiU5MceuIEgrcfTbRAfBRol9UZ/vn10KTx0187lLXdFtw3Po4l+ggX0VUq3BmDVXd3yA60b8aKxtAdEK7iWh/eYrY5RMzO5yo6vshd59KlLx/KzZ+qtg7J+4LCFaF738J0T7wSDwod/9BWNYvEB34t8Z69zOzUjNbT5Tgvk10YoubFoYpNbObwjSriH70/DtM79/A9z12ydLdZ7v7OKKTxlVEJ9yPzewBM+uaYv1BK+8PNbjJ3Ze6+xqipK+uc8ejwJFm1o3oUsDdTZh3XAUw3My6uvvacEyBqBb1H+7+trtXuftdRNvgYGo/Lp8F3ODuC919I9Fx94ykSxnXuHuZu79HlEwkjvenAdeG4+CnRN/nhCqiBGS4mRW6+yJ3/6i2BatvEnCSu3ch+uLsSZS9N0T87vfNRDtTc4hfnypL0Z2Yz67AQbGdp5RoI6S6Ia8fsCYclBMWA/3rGVMnYG+iTPw9ol9FXs9x65K8HjuEL80uwOKQ/DRUP6LlAyB8IVez/fI2ZPs95O7F7t6RqJbmHDNLvm5am0+TYlkTYtyhf4g73i+hIdt7m7BzX+HuewO9iX7JTAoH+eT1VB1iia+neGx1MrOOZvYPM1scDvyvAcVW/ydgNhJdA47rSvQLOOEuol8DT7v7/FrGTXzeUI/pttS4tQrJ4JeILvlBdD9EB6Iap2TnAncn7XtlRIn0M+5eTnTi2pmopiQxznPuvip0/5vt7ztIFfvGpHn08OhafUeiX9HPJgcWThZvECUl/xPrtTTsO12Jat7KiLZf3OgwTLG7/zisl6OJLj0cSXQZ6IvAvyzFTaIhYZhNdGxaQ1RDkPJ+gdbeH2rQoHNHSDieIqpq7+HubzZDDBAllccCi83sVTM7JJTvClyedKzZhWj91HZc3m79hc8FROs5oaZl78eOx0EA3H0B0b1YVwMrQpKX6hi5TYMeEXT3V4mqbP8YK95E9IVPaLE73ZvgU+DV2M5T7NGNNf+TYtilQPfYDXwQVT2X1GdG7v4hURXPj4mqFOeb2eNmdqol3W2cZLv1GE4EPeszT6LlG1jDDTh1JSBLib7Iifl2Ijow1mt5a+Pui4hqaL4eipKXMdV3ZZdY/85EVV5LU/Un2i7xfgkN2d41xb6K6HueqIpMXk8WYomvp+R1Xde6v5yo+u6gcOA/IjH5eo7/PrBf0i/R/UJ5wt+JLhGMDb904+OOiHWPAJa7++rQb3DSPjAiNt2WGrcuZxMds56w6LHahURJwDnxgUKycCQ7/gqcSQ3r1MyKiH5hfdGiJxc+I7rcMsLMEvGmiv19UggnozuJarJq+tFUQJQopxp/HVES8vVU/ZOMJLqEN8Xdq939XaJahG134ptZ53AH/UtElyH6E12W2ac+676V9ofmcjfRvnVPc03Q3d919xOBXsAkovs1IDrWXJt0rOno7vdT+3F5u/VHdCyrpH43Xi5jx+NgPNZ/u3uiVsuB62ubWGPaCfgL8JVYljkDOCX8qtmD6GaZtuZJYKiZnW1mheHvADPbK3nAUL3yH+A6M+tgZvsRLdN9ycPWxCMvu/s5RBvrMeAnwLIwvVTmEf2yPy5Ub/6KqFqnPt4h+mL83sw6hbgPC/2WAwNquWP838D5Fj1q1p7oyYy3wwm8ScxsANFNaokD5XvA3mFeHYiy1WTHmtnhId7fhFjiWe84M9spHOh/QnSzULJ6b++keK83s33MrCCcxP4HWBAOkg8Bx5nZl8P2uZyo2u8/tUxyOVFCWJMuRL/2Ss2sOzteZqtr/FeIqv9+bGbtzeziUP5SWJ6ziRLR84iS0rvs88d77ya6+3y4me1E9H27E8Dd5xHt11eF79LJRMnFhJYcN8RcGL4beUBBmEaiZuQcoicJRsb+vkG0XXaOrZezgf+kqAa9FzjYzI4O07yE6JLBh0TX0auA4bFp70VUHZ5IMu4GLjOz/uHX1eXx2OPCvnQ20a+51WbWy8zOCCfjfIuekjiTsK1SjN+Z6NJFyiQjybvAFxLHZDMbRXS5YWboPobopHM60TXy/u7+g5As1CgN+0NzeZXoXoW/NsfEzKydmZ1lZt3CpY/1RN8ViK7bX2RmB1mkUziGd6H24/L9wKVmtlvY1okn4upTm/sQcGU4Dg4AfhSLdZiZHRW+f1uIji+1Pw7ptdww4DXczAHcDEzwz2/seY6oOu9NogN7ypsrQvedxO5Mr2GeV1O/GwPjNyRuu/kjdB9N9IVNdA8jqiZK3KX5EjXc+UpUTfckUXXZR8RuRqGeNwbWMN09gD6e4iaY2LSXEd138VN2vDHw3tiwyetjIFGGuprowHZTKG8XlnsNsCrVNiC6+/+jMMy2O9Qbuv1CjBVE1aYbw7LcAnSMDfPLEN+nwLfj02f7pwM2ElWP75YUS+LpgNVEdzvnx9Zd/HtX7+0dG+evRE9BbAzjPcn2dzyfTHSvxzqiA83esX7btlWs7ESiu3tLid1NHOvfj+h7vJEoCfx+0jY9JJSvpeYb4EYBU4l29mnAqNj3YTVwWGzYB4F/xrovIzowrye6k7590vfrlTDduSmWraXGvTOsg/jfeUTXWLcAPVOsg/eBi2Pdc4ALalhfpxDdkLU+xLh3KH8W+FOK4U8jOpEXENXQ/IFoP1kTPlvS/pj47peG78gBoX/P0F0a5j2L8NRR7HhQHRt/NdH3N77vpbwxMPS7OCzXBqL94/JYv92IPfHTgONVa+8PR7LjjYHxJ9OuJum8kHTsTHlcpok3BhIdQ58l2g8TT54dHhvumFBWSnTMe5jwdAw1H5fziJ5E+TSs23sJN2omx5gizo5ECWkpSU8HECXc74TvQeJ4Xuu2T3yBRUREJMdkTLPBIiIi0ryUBEhOMbP3bcemZTea2Vnpjk1EpLXpcoCIiEiOaq02nXNajx49fNCgQekOQ0Qko0ydOnWVu9f3UWlpBCUBrWDQoEFMmTIl3WGIiGQUM1tc91DSFLonQEREJEcpCRAREclRSgJERERylJIAERGRHKUkQEREJEcpCRAREclRekRQRESa3aTpJYyfPJelpWX0Ky5i3NhhnDSqf7rDkiRKAkREpFlNml7ClRNnUVYRvcW2pLSMKyfOAlAi0MbocoCIiDSr8ZPnbksAEsoqqhg/eW6aIpKaKAkQEZFmtbS0rEHlkj5KAkREpFkVdyxMWd6vuKiVI5G65HwSYGa7mNnLZvZheM3sT0J5dzN73szmh/87hXIzs5vMbIGZzTSz0eldAhGRtuODpevZtLWKPNu+vKgwn3Fjh6UnKKlRzicBQCVwubvvBRwM/NDMhgNXAC+6+xDgxdAN8DVgSPi7ELi59UMWEWl71mwq53t3T6F7p3Zc/fW96V9chAH9i4u47pR9dVNgG5TzTwe4+zJgWfi8wcw+BPoDJwJHhsHuAl4Bfh7K73Z3B94ys2Iz6xumIyKSkyqrqvnhfdNYuXErD3//EEbsUsw5hw5Kd1hSB9UExJjZIGAU8DbQO3FiD/97hcH6A5/GRlsSykREcta1T3/Ifxeu5ncn78uIXYrTHY7Uk5KAwMw6AxOAS9x9fW2DpijzFNO70MymmNmUlStXNleYIiJtziNTl3DHm4s4/7BBnLr/gHSHIw2gJAAws0KiBOA+d58YipebWd/Qvy+wIpQvAXaJjT4AWJo8TXe/1d3HuPuYnj17tlzwIiJpNOPTUn7x6CwO3X1nfnnsXukORxoo55MAMzPgNuBDd78h1utx4Nzw+VzgsVj5OeEpgYOBdbofQERy0Yr1W/j+PVPo1aU9f/vWaAryc/6UknFy/sZA4DDgbGCWmc0IZb8Afg88ZGYXAJ8A3wz9ngaOBRYAm4HzWzdcEZH021pZxUX3TmV9WSUT/udQundql+6QpBFyPglw9zdIfZ0f4Msphnfghy0alIhIG+buXPXY+0z7pJS/fWsUw/t1TXdI0kiquxERkQa59+1PeODdT/nBkbtz/H790h2ONIGSABERqbe3F67mmsff50vDenL5V9UCYKZTEiAiIvVSUlrGD+6bxsDuHfnLGaPIT24bWDKOkgAREalTWXkV379nClsrq7n1nP3pVpT6JUGSWXL+xkAREamdu3PFxJm8v3Q9/zx7DHv06pLukKSZqCZARERq9a/XP+axGUu57OihHD28d7rDkWakmgAREdnBpOkljJ88l5LSMgBGDOjGxUftkeaopLmpJkBERLYzaXoJV0yYuS0BAJj72QYem7FDC+mS4VQTICKShRK/5JeWltGvuIhxY4dx0qgdX3jq7qzaWM685Ru2/U2YWkJ5VfV2w22prGb85LkppyGZS0mAiEiWmTS9hCsnzqKsogqIHu27cuIsNm2tZEjvLsxdvoH5yzcw97PopL92c8W2cXfqWLhDApCwNFYzINlBSYCISJYZP3nutgQgoayiil9Omr2tu3P7Aob27swx+/RhSK8uDOvThaG9u9CjczsOv/7l7S4FJPQrLmrx2KV1KQkQEckytf1iv+P8AxjWuwt9u3UgeonqjsaNHbZdTQJAUWE+48aqhcBsoyRARCTL9CsuSvlLvn9xEV8a1qvO8RPX/etzT4FkNiUBIiJZZtzYYVz+8HtUVfu2sob+kj9pVH+d9HOAHhEUEckyx+7bl/YFeRQV5mNENQDXnbKvTuqyA9UEiIhkmZfnrmBzeRV3nH9Avar/JXepJkBEJMtMnLaEHp3b84U9eqQ7FGnjcj4JMLPbzWyFmc2OlT1oZjPC3yIzmxHKB5lZWazfLemLXERkR6Wby3lpzgpOHNmPgvycP8RLHXQ5AO4E/gbcnShw99MTn83sT8C62PAfufvIVotORKQBnpi5jIoq55TRuv4vdcv5JMDdXzOzQan6WfQQ7WnAUa0Zk4hIY02ctoRhvbswvG/XdIciGUB1RbX7ArDc3efHynYzs+lm9qqZfaGmEc3sQjObYmZTVq5c2fKRikjO+3jVJqZ/Usopo/vX2BCQSJySgNqdCdwf614GDHT3UcBlwL/NLGW67e63uvsYdx/Ts2fPVghVRHLdo9OWkGfoUUCpNyUBNTCzAuAU4MFEmbtvdffV4fNU4CNgaHoiFBH5XHW1M3F6CYft0YPeXTukOxzJEEoCanY0MMfdlyQKzKynmeWHz4OBIcDCNMUnIrLNlMVrWbK2TDcESoPkfBJgZvcD/wWGmdkSM7sg9DqD7S8FABwBzDSz94BHgIvcfU3rRSsiktqj05fQsV0+Y/fuk+5QJIPo6QD3M2soPy9F2QRgQkvHJCLSEFsqqnhy5jKO2acPHdvl/GFdGiDnawJERDLdCx8uZ8OWSk4ZNSDdoUiGyZokwMw6mVle+DzUzE4ws8J0xyUi0tIenVZCn64dOGT3ndMdimSYrEkCgNeADmbWH3gROJ+oNUARkay1auNWXpm3kpNG9Sc/T20DSMNkUxJg7r6Z6LG+v7r7ycDwNMckItKinnhvKVXVaiZYGierkgAzOwQ4C3gqlOkOGRHJahOnlbBP/64M7d0l3aFIBsqmJOAS4ErgUXd/PzzH/3KaYxIRaTHzl29gVsk6TtYNgdJIWfNL2d1fBV6NdS8Efpy+iEREWtbE6SXk5xknjOiX7lAkQ2V8EmBmTwBeU393P6EVwxERaRXV1c6k6SUcMaQHPbu0T3c4kqEyPgkA/hj+nwL0Ae4N3WcCi9IRkIhIS3tr4WqWrdvCL47dK92hSAbL+CQgXAbAzH7j7kfEej1hZq+lKSwRkRY1YVoJXdoX8JXhvdMdimSwbLoxsGe4GRAAM9sN0Dt8RSTrbC6v5NnZyzh23750KMxPdziSwTK+JiDmUuAVM0u81W8Q8P30hSMi0jKee385m8qr1DaANFnWJAHu/qyZDQH2DEVz3H1rOmMSEWkJE6YtoX9xEQcM6p7uUCTDZU0SEOxPVANQAIwwM9z97vSGJCLSfJav38KbC1bxwy/tQZ6aCZYmypokwMzuAXYHZgBVodgBJQEikjUem1FCtcPJo3QpQJoua5IAYAww3N1rbDNARCTTTZxWwshdihncs3O6Q5EskE1PB8wmaiegwczsdjNbYWazY2VXm1mJmc0If8fG+l1pZgvMbK6ZjW2G2EVE6vTB0vXM+WwD39ANgdJMsqkmoAfwgZm9A2y7IbCeLQbeCfyNHS8d/Nnd/xgvMLPhwBnA3kA/4AUzG+ruVYiItKCJ05ZQmG8cv5+aCZbmkU1JwNWNHdHdXzOzQfUc/ETggfDkwcdmtgA4EPhvY+cvIlKXyqpqHntvKV8a1oudOrVLdziSJbLmckBoOXAO0CX8fZhoTbAJLjazmeFywU6hrD/waWyYJaFsO2Z2oZlNMbMpK1eubGIYIpLr3liwipUbtqptAGlWWZMEmNlpwDvAN4HTgLfN7NQmTPJmoqcNRgLLgD8lZpVi2B1uRnT3W919jLuP6dlTDReKSNM8Or2EbkWFfGnPXukORbJINl0O+CVwgLuvADCznsALwCONmZi7L098NrN/Ak+GziXALrFBBwBLGzMPEZH62Li1ksnvf8Y3Rg+gfYGaCZbmkzU1AUBeIgEIVtOE5TOzvrHOk4mePgB4HDjDzNqH9xMMIaqBEBFpEc/MWsaWimpOGT0g3aFIlsmmmoBnzWwycH/oPh14pj4jmtn9wJFADzNbAlwFHGlmI4mq+hcR3kPg7u+b2UPAB0Al8EM9GSAiLWnitBIG7dyR0QOL0x2KZJmsSQLcfZyZnQIcTnTd/lZ3f7Se456Zovi2Woa/Fri2UYGKiDRASWkZ/124mkuPHoqZmgmW5pU1SUComn/a3SeG7iIzG+Tui9IbmYhI402aXgKomWBpGVmTBAAPA4fGuqtC2QHpCUdEpPEmTS/hD8/OYem6LbTLz2PaJ2sZuHPHdIclWSabkoACdy9PdLh7uZmpRQ0RyTiTppdw5cRZlFVEtxuVV1Vz5cRZAJykGgFpRtn0dMBKM9vWRLCZnQisSmM8IiKNMn7y3G0JQEJZRRXjJ89NU0SSrbKpJuAi4D4z+z+iO/qXAOekNyQRkYZbWlrWoHKRxsqaJMDdPwIONrPOgLn7hnTHJCLSGP2KiyhJccLvV1yUhmgkm2XN5QAz621mtwEPu/sGMxtuZhekOy4RkYY655BddygrKsxn3NhhaYhGslnWJAFErwOeTPR6X4B5wCVpi0ZEpJGmLl5L+4I8+nTtgAH9i4u47pR9dVOgNLusuRwA9HD3h8zsSgB3rzQzteQnIhll6uI1PPfBcn761aFcfNSQdIcjWS6bagI2mdnOhDf6mdnBwLr0hiQiUn/uznVPz6FXl/Z85/Dd0h2O5IBsqgm4jOjlPrub2ZtAT6AprxIWEWlVL3y4gimL1/K7k/elY7tsOjxLW5U13zJ3n2ZmXwSGEb07YK67V6Q5LBGReqmsqub6Z+cwuGcnThujtwVK68iaywFm9k2gyN3fB04CHjSz0WkOS0SkXiZMW8KCFRv52dg9KcjPmkOztHHZ9E37dXg08HBgLHAXcHOaYxIRqVNZeRU3PD+P0QOLGbt373SHIzkkm5KAxJMAxwE3u/tjgN4dICJt3u1vfszy9Vu54mt76XXB0qqyKQkoMbN/AKcBT5tZe7Jr+UQkC63dVM4tr3zE0Xv14sDduqc7HMkx2XSSPI2osaBj3L0U6A6Mq2skM7vdzFaY2exY2Xgzm2NmM83sUTMrDuWDzKzMzGaEv1taamFEJDf87eUFbCqv5GfH7JnuUCQHZXwSYGZdw8cOwCvAajPrDmwFptRjEncCxySVPQ/s4+77EbU8eGWs30fuPjL8XdSU2EUkt326ZjP3/Hcxp+4/gKG9u6Q7HMlB2fCI4L+B44GpRA0FxS+oOTC4tpHd/TUzG5RU9lys8y3U3oCItIAbnp+HGVz6laHpDkVyVMYnAe5+fPjfUs1rfQd4MNa9m5lNB9YDv3L311ONZGYXAhcCDBw4sIVCE5FM9f7SdUyaUcJFX9ydvt30dkBJj4xPAupqC8DdpzVh2r8EKoH7QtEyYKC7rzaz/YFJZra3u69PMd9bgVsBxowZ442NQUSy0/XPzqVbUSEXfXH3dIciOSzjkwDgT7Xrh/fzAAAgAElEQVT0c+CoxkzUzM4luszwZXd3AHffSnSvAe4+1cw+AoZSv3sPREQAeHPBKl6bt5JfHbcX3YoK0x2O5LCMTwLc/UvNPU0zOwb4OfBFd98cK+8JrHH3KjMbDAwBFjb3/EUke1VXO79/Zg79i4v49sG7pjscyXEZnwSY2Sm19Xf3iXWMfz9wJNDDzJYAVxE9DdAeeD403PFWeBLgCOD/mVklUeNEF7n7miYvhIjkjKdmLWNWyTpuOG0EHQrz0x2O5LiMTwKAr9fSz4FakwB3PzNF8W01DDsBmFD/0EREPldeWc34yXPZs08XThzZP93hiGR+EuDu56c7BhGR+rj/nU/4ZM1m7jz/APLz1DywpF/GJwFm9m13v9fMLkvV391vaO2YRESSbdhSwU0vzueQwTvzxaE90x2OCJAFSQDQKfxXc1si0mb98/WPWb2pnCu+tqdeEiRtRsYnAe7+j/D/mnTHIiKSyooNW/jX6ws5br++jNilON3hiGyT8UmAmd1UW393/3FrxSIiksqNL8ynvLKacV8dlu5QRLaT8UkAcBEwG3gIWMr27w4QEUmrhSs38sC7n3LWQQMZ1KNT3SOItKJsSAL6At8ETidq4vdBYIK7r01rVCKS0yZNL2H85LmUlJZhwJBendMdksgOMv5Vwu6+2t1vCS0HngcUA++b2dnpjUxEctWk6SVcOXEWJaVlQNRgye+ensOk6SXpDUwkScYnAQnhRUKXAN8GniF6tbCISKsbP3kuZRVV25WVVVQxfvLcNEUkklrGXw4ws2uIXvTzIfAAcKW7V6Y3KhHJZYkagGRLaygXSZeMTwKAXxO9xGdE+PtdeAbXAHf3/dIYm4jkGHenY7t8NpdX7dCvX3FRGiISqVk2JAG7pTsAEZGEPz03j83lVRTkGZXVvq28qDCfcWP1iKC0LRmfBLj74nTHICICcM9bi/nbyws488BdOHBQd/743DyWlpbRr7iIcWOHcdIovTRI2paMTwJERNqCZ2d/xv8+Npuj9+rFb07ch4L8PE4ePSDdYYnUKmueDhARSZcpi9bwkwemM3KXYv565mgK8nVolcygb6qISBPMX76BC+6aQv/iIm479wCK2uWnOySResuaJMDMDjOz581snpktNLOPzWxhPce93cxWmNnsWFn3ML354f9OodzM7CYzW2BmM0P7BCKSgz5bt4Vzb3+HdgV53PWdA+neqV26QxJpkKxJAoDbgBuAw4EDgDHhf33cCRyTVHYF8KK7DwFeDN0AXwOGhL8LgZubFLWIZKT1Wyo47453WL+lkjvOO4BdundMd0giDZZNScA6d3/G3VeEpoRXu/vq+ozo7q8Ba5KKTwTuCp/vAk6Kld/tkbeAYjPr2xwLICKZYWtlFRfePYWPVm7klm/vzz79u6U7JJFGyaanA142s/HARGBrotDdpzVyer3dfVmYxjIz6xXK+wOfxoZbEsqWxUc2swuJagoYOHBgI0MQkbamutq57KH3eGvhGv5y+kgOH9Ij3SGJNFo2JQEHhf9jYmUOHNXM80n1qmLfocD9VuBWgDFjxuzQX0Qyj7vz26c+5KmZy7jya3vquX/JeFmTBIS3CDan5WbWN9QC9AVWhPIlwC6x4QYAS5t53iLSBv3r9Y+5/c2POf+wQVx4xOB0hyPSZBmfBJjZt939XjO7LFV/d7+hkZN+HDgX+H34/1is/GIze4Co9mFd4rKBiGSvx2aUcO3TH3Lcfn359XHDCe8oEcloGZ8EAJ3C/y6NnYCZ3Q8cCfQwsyXAVUQn/4fM7ALgE+CbYfCngWOBBcBm4PzGzldEMsObC1bx04ff4+DB3bnhtBHk5SkBkOxg7rpc3dLGjBnjU6ZMSXcYItIAk6aXMH7yXEpKyzCgT7cOPHvJEXQrKkx3aDnDzKa6+5i6h5TGyqZHBEVEmsWk6SVcOXEWJaVlQHTn79pN5bw8Z0XtI4pkGCUBIiJJxk+eS1lF1XZlWyqrGT95bpoiEmkZSgJERJIkagCSLa2hXCRTZU0SYGa9zew2M3smdA8PN/WJiNTb/OUbqOm+v37FRa0bjEgLy5okgKj9/8lAv9A9D7gkbdGISMZ5f+k6Tr/1LTq3L6B9wfaHx6LCfMaNHZamyERaRjYlAT3c/SGgGsDdK4Gq2kcREYlM/2QtZ976Fh0K8njs4sO5/hv70b+4CAP6Fxdx3Sn7qoVAyTrZ0E5AwiYz25nQhK+ZHQysS29IIpIJ3l64mu/c+S47d27Pv793EAN26shuPTrppC9ZL5uSgMuIWvPb3czeBHoCp6Y3JBFp616fv5Lv3T2F/sVF3Pfdg+nTrUO6QxJpNVmTBLj7NDP7IjCM6CU/c929Is1hiUgb9sIHy/nBfdMY3LMT9373IHp0bp/ukERaVdYkAWaWT9Sc7yCi5fqqmTXl3QEiksWenLmUSx6Ywd79unLXdw6kuGO7dIck0uqyJgkAngC2ALMINweKiKTyyNQl/OyR99h/1524/bwD6NJBTQFLbsqmJGCAu++X7iBEpG27963F/GrSbA7bY2f+ec4YOrbLpsOgSMNk0yOCz5jZV9MdhIi0Xf96fSG/mjSbo/bsxW3nHqAEQHJeNu0BbwGPmlkeUEF0c6C7e9f0hiUibcHfXprPH5+bx7H79uEvp4+iXUE2/QYSaZxsSgL+BBwCzHK9H1kk58VfBdy5fQEbt1Zy8qj+jD91PwrylQCIQHYlAfOB2UoARCTxKuDEmwA3bq0k34wvDOmhBEAkJpuSgGXAK+EFQlsThU15RNDMhgEPxooGA/8LFAPfA1aG8l+4+9ONnY+INK9UrwKucudPz83jlNED0hSVSNuTTUnAx+GvXfhrMnefC4yEbe0QlACPAucDf3b3PzbHfESk+WytrNKrgEXqKWuSAHe/poVn8WXgI3dfbFbDe0ZFJG3cnec/WM61T39Y4zB6FbDI9jL+4piZ/SX8f8LMHk/+a8ZZnQHcH+u+2MxmmtntZrZTirguNLMpZjZl5cqVyb1FpBnN+Ww9377tbS68ZyqF+Xl8/4jBFBXmbzeMXgUssiPL9PvozGx/d58a3huwA3d/tRnm0Q5YCuzt7svNrDewiuiNhb8B+rr7d2oaf8yYMT5lypSmhiEiSVZv3MoNz8/j/nc+oUuHQi49eghnHbwrhfl5254OWFpaRr/iIsaNHaa3AmYYM5vq7mPSHUc2y4bLAT8CzmuOk30tvgZMc/flAIn/AGb2T+DJFpy3iCQpr6zm7v8u4sYX57O5vIpzDhnEJUcP2a79/5NG9ddJX6QO2ZAEtEZTwWcSuxRgZn3dfVnoPBmY3QoxiOQ8d+elOSu49qkPWbhqE0cM7cmvj9uLIb27pDs0kYyUDUlARzMbRdRC4A7cfVpTJm5mHYGvAN+PFf/BzEYSXQ5YlNRPRJpBcnX+2QfvypsfreL1+asY3LMTd5x3AEcO64lu1BVpvGy4J2AD8C6pkwB396NaOaQd6J4AkYZJbuwnIXFz39mHRNf9JbvpnoCWlw01AQvawoleRJpPqsZ+ALoVFfKdw3dLQ0Qi2UmptIi0KQtWbKixsZ/l67e0cjQi2S0bagJ+nu4ARKRpqqqdl+es4K7/LuL1+atqHE6N/Yg0r4xPAtz9uXTHICKNs66sgoenfMrd/13MJ2s206drB8aNHUa3DoVc+/SH210SUGM/Is0v45MAEck885dv4K7/LmLitBI2l1dx4KDu/PyYPfnq3r233fDXuUOBGvsRaWFKAkSkRSQ/4nf5V4bStaiQO/+ziDcWrKJdQR4njujHuYcOYp/+3XYYX439iLS8rEkCzGwoMA7Yldhy6ckBkdaX/IhfSWkZlz/8Hg707RZV+Z9xwC7s3Ll9egMVyXFZkwQADwO3AP8Edny2SERaTapH/Bzo3rEdr/3sS3rGX6SNyKYkoNLdb053ECK5zN155+M1NT7it3ZzuRIAkTYkm5KAJ8zsB8CjwNZEobuvSV9IIrmhoqqap2ct47Y3PmbmknXkGVSnaIxUj/iJtC3ZlAScG/6Pi5U5MDgNsYjkhPVbKnjwnU+5482PWbpuC4N7dOLak/ehMC+Pqx5/X4/4ibRxWZMEuLvaEhVpJUvWbuaONxfx4LufsnFrJQcP7s7/O3EfjtqzF3l50Ws82hXk6RE/kTYua5IAMzsnVbm7393asYhkg+RH/MaNHcagHp341+sLeWb2ZwAcv19fvnv4YPYdoEf8RDJR1iQBwAGxzx2ALwPTACUBIg2U6hG/yx6aQbVDlw4FfPfw3Tj30EG6xi+S4bImCXD3H8W7zawbcE+awhHJaKke8at26NahkDevPIrO7bPm0CGS07L5WZ3NwJB0ByGSiZbW8Ijf+i0VSgBEskjW7M1m9gTR0wAQJTfDiRoQaup0FwEbiBogqnT3MWbWHXgQGAQsAk5z97VNnZdIW7Fzp3as2lS+Q7mq/0WyS9YkAcAfY58rgcXuvqSZpv0ld4+/3/QK4EV3/72ZXRG69UpjyQrzlm9gY3klxudZNegRP5FslDWXA9z91djfm8AyMzurhWZ3InBX+HwXcFILzUekVS1fv4Xzbn+Hrh0K+d/jh9O/uAgD+hcXcd0p++puf5Esk/E1AWbWFfgh0B94HHg+dI8DZgD3NXEWDjxnZg78w91vBXq7+zIAd19mZr2aOA+RtNuwpYLz7niXdWUVPHTRIezdrxvnH67mN0SyWcYnAURPAKwF/gt8l+jk3w440d1nNMP0D3P3peFE/7yZzanPSGZ2IXAhwMCBA5shDJGWU1FVzQ/um8b85Ru4/bwD2Lvfjs/9i0j2yYYkYLC77wtgZv8CVgED3X1Dc0zc3ZeG/yvM7FHgQGC5mfUNtQB9gRUpxrsVuBVgzJgxKVpRF2kb3J0rJszi9fmrGH/qfhwxtGe6QxKRVpIN9wRUJD64exXwcXMlAGbWycy6JD4DXwVmE112SLyr4FzgseaYn0g6/Pn5eUyYtoRLjx7KN8fsku5wRKQVZUNNwAgzWx8+G1AUug1wd+/ahGn3Bh41M4jW1b/d/Vkzexd4yMwuAD4BvtmEeYikzQPvfMJNLy3g9DG78OMv75HucESklWV8EuDu+S047YXAiBTlq4maJRbJWC/PXcEvJ83miKE9+e3J+xCSXRHJIdlwOUBEGmjWknX88L5p7NmnC38/azSF+ToUiOQi7fkiOebTNZs5/8532aljO+447wA1AyySw7T3i+SQ0s3lnHvHO5RXVvHAhQfRq2uHdIckImmkJEAkR2ypqOJ7d09hyZoy7v3uQezRq0u6QxKRNFMSIJIDqqudyx96j3cXreWvZ47iwN26pzskEWkDlASIZKlJ00sYP3kuS0vL6NS+gI1bK/nlsXvx9RH90h2aiLQRSgJEstCk6SVcOXEWZRVVAGzcWkl+ntGjc7s0RyYibYmeDhDJQuMnz92WACRUVTt/fG5emiISkbZISYBIFiopLUtZvrSGchHJTbocIJJFtlRUcdsbH0dtZqfo36+4qLVDEpE2TEmASBZwd577YDnXPvUhn6zZzH79uzF3+Qa2VlZvG6aoMJ9xY4elMUoRaWuUBIhkuAUrNnDNEx/w+vxVDOnVmXsvOIjDh/TY7umAfsVFjBs7jJNG9U93uCLShigJEMlQ68oquPGF+dz930UUtcvnqq8P59sH77rtPQAnjeqvk76I1EpJgEiGqap2Hp7yKeMnz2XN5nLOOGAgP/3qUHbu3D7doYlIhlESIJJBpi5ew9WPf8CsknWM2XUn7jrhQPbp3y3dYYlIhlISINJCmnpNPj5+764dGLBTEVMWr6VP1w7ceMZIThjRDzNrwSUQkWynJKAGZrYLcDfQB6gGbnX3G83sauB7wMow6C/c/en0RCltVXKLfSWlZVw5cRZAvRKB5PE/W7+Fz9Zv4St79eYvZ4ykk17/KyLNQEeSmlUCl7v7NDPrAkw1s+dDvz+7+x/TGJu0cala7CurqOKKCTOZNKOEiqpqKiqd8qrq6HNVNRVVTnll9HnVxq1Up3jQ/4Nl65UAiEiz0dGkBu6+DFgWPm8wsw8B3Wot9VJTi31bKqtZu6mcwvw8CvPz6NqukHb5RkFeHoUFeRTmG+3y83jg3U9Tjq8W/0SkOSkJqAczGwSMAt4GDgMuNrNzgClEtQVr0xedtDUvz11BnpHyl3z/4iIeu/jwOqfx+vxVKRMJtfgnIs1J7w6og5l1BiYAl7j7euBmYHdgJFFNwZ9qGO9CM5tiZlNWrlyZahDJMpVV1Vz/7BzOv+Nd+nTtQPuC7XevhrTYN27sMIoK8xs9vohIfSgJqIWZFRIlAPe5+0QAd1/u7lXuXg38Ezgw1bjufqu7j3H3MT179my9oCUtPlu3hTP/+RY3v/IRZx44kJd+eiTXf2M/+hcXYUQ1ANedsm+9nw44aVR/rjtl30aPLyJSH+ae6jUjYtGzV3cBa9z9klh533C/AGZ2KXCQu59R27TGjBnjU6ZMadF4JX1enbeSSx+cwZaKKn53sk7UIs3FzKa6+5h0x5HNdE9AzQ4DzgZmmdmMUPYL4EwzG0n0krZFwPfTE56kW2VVNX9+YR7/9/JH7NmnC/931mh279k53WGJiNSbkoAauPsbQKqWWNQmgLB8/RZ+dP903vl4DWccsAtXfX1vitrl1z2iiEgboiRApIFen7+SSx6YwebyKv58+ghOHjUg3SGJiDSKkgCReqqqdm58YR5/fXkBQ3p15sGzRrNHry7pDktEpNGUBIjUILnt/s4dCliwYiOnjRnANSfso+p/Ecl4SgJEUkjVdj/r4VsHDuR3p+yb5uhERJqH2gkQSeH6Z+fs0PY/RI8DiohkC9UESM5zd5asLWPq4rVMWbyGqYtLWbZuS8ph1Xa/iGQTJQGSteLX9PsVFzFu7DBOGtWf8spqPli2nimL1jDtk7VMWbSWFRu2AtC5fQGjBhbTpUMBG7ZU7jBNtd0vItlESYBkpeRr+iWlZfz04ff460vzWbK2jK2V1QAM2KmIQ3ffmf133Yn9d+3OsD5dyM+zHcYHtd0vItlHSYBkpd89/eEO1/Qrq51P1mzmnEMGhZP+TvTu2iHl+Immf1PVJIiIZAslAZI15i3fwJMzl/H0rGXbqveTVVY5vz5+eL2md9Ko/jrpi0hWUxIgGcvdmbt8A0/PXMbTsz9jwYqNmMGBg7qzsqiQdWUVO4yja/oiIp9TEiBtVqob+04c2Y85n23g6VnLeGrWMhau3ESewUG77cy5hw5i7N696dWlg67pi4jUg14l3Ar0KuGGS3USL8gzdurUjpUbtpJncPDgnTl2376M3bsPPbu0TzkNXdMXyVx6lXDLU02AtCnuzppN5fz2qQ9S3ti3vqyCa0/eh7F796FH5x1P/HG6pi8iUjslAdJiavslvqWiikWrN7Fw5SY+XrWJj1ZuZOHKTSxcuZH1KZ7PTyivrOasg3ZtrUUQEclqSgKkRk2pTp80vYQrJsxkS3gev6S0jMsffo+bX/2ITVsrKSktI34lqk/XDgzu2YkTRvZjtx6d+fvLC1i9qXyH6erGPhGR5qMkIIs19SSe3NjOlRNnAVE1u7tTurmCktIylq3bwtLSMpaWlm3rnvFJKVVJ95tUVTsLV27ka/v05dT9BzC4Z2cG9+jEbj060an99l/FnTu10419IiItTElAI5nZMcCNQD7wL3f/fXPPoyVP4jUpr6xm/ZYKrkvR2E5ZRRU/nzCTv740n6WlW3bo3y4/j77FHejXrWiHBCChssq56cxRdcavxnpERFqekoBGMLN84P+ArwBLgHfN7HF3/6C55pHqJH7FhJmUV1ZzzL59qKisprLaKQ//K6qqw59TWVXNb5/c8ca6sooqfjVpNu8sWsP6sgrWb6lkw5aK7T5vqaiuNa6tldUM7d2FI4f1ol9xEf26dYj+Fxexc6d25OUZAIf9/iVKUrxspyHV+bqxT0SkZSkJaJwDgQXuvhDAzB4ATgSaLQkYP3nuDifxLZXV/GzCTH42YWajp7txayXPvf8ZXTsU0qVDAV2LCunXrWjb564dCujSoZC/vDCPtZt3bGynf3ERN397/zrnM27sMFXni4i0cUoCGqc/8GmsewlwUHwAM7sQuDB0bjSzuQ2ZQbs+e+wPULV5Hfkdu23Xr/yzBVPrGr+w56B9Lb+gXXK5V1WWL165aFZd4+cVde1e0LXnrpjlfT6yV3+6fuViu3L9mvosQ15R1+75nbv3t/yCdl5VWV61cU3Jyb+t37gxPYBVDRwn2+T6OtDy5+7y72pmF7r7rekOJFspCWgcS1G23UXw8KVt8hfXzKZUrluRs41lmNmUXG8sJNfXgZZfy08zHEsltby6B5EUlgC7xLoHAEvTFIuIiEijKAlonHeBIWa2m5m1A84AHk9zTCIiIg2iywGN4O6VZnYxMJnoEcHb3f39FppdrleD5fryg9aBlj+35frytyi9QEhERCRH6XKAiIhIjlISICIikqOUBLRhZnaMmc01swVmdkW642kJZraLmb1sZh+a2ftm9pNQ3t3Mnjez+eH/TqHczOymsE5mmtno9C5B8zCzfDObbmZPhu7dzOztsPwPhhtQMbP2oXtB6D8onXE3BzMrNrNHzGxO+B4ckkvb38wuDd/92WZ2v5l1yObtb2a3m9kKM5sdK2vw9jazc8Pw883s3HQsSzZQEtBGxZom/howHDjTzIanN6oWUQlc7u57AQcDPwzLeQXworsPAV4M3RCtjyHh70Lg5tYPuUX8BPgw1n098Oew/GuBC0L5BcBad98D+HMYLtPdCDzr7nsCI4jWQ05sfzPrD/wYGOPu+xDdaHwG2b397wSOSSpr0PY2s+7AVUSNtB0IXJVIHKRhlAS0XduaJnb3ciDRNHFWcfdl7j4tfN5AdALoT7Ssd4XB7gJOCp9PBO72yFtAsZn1beWwm5WZDQCOA/4Vug04CngkDJK8/In18gjw5TB8RjKzrsARwG0A7l7u7qXk0PYnekqryMwKgI7AMrJ4+7v7a0Byy6EN3d5jgefdfY27rwWeZ8fEQupBSUDblapp4qx+m06o2hwFvA30dvdlECUKQK8wWDaul78APwMSb2/aGSh198rQHV/Gbcsf+q8Lw2eqwcBK4I5wOeRfZtaJHNn+7l4C/BH4hOjkvw6YSu5s/4SGbu+s+h6kk5KAtqvOpomziZl1BiYAl7j7+toGTVGWsevFzI4HVrh7/H0QtS1jVi0/0a/g0cDN7j4K2MTnVcGpZNXyhyrsE4HdgH5AJ6Iq8GTZuv3rUtPy5tp6aDFKAtqunGma2MwKiRKA+9x9YihenqjmDf9XhPJsWy+HASeY2SKiSz5HEdUMFIfqYdh+Gbctf+jfjR2rVjPJEmCJu78duh8hSgpyZfsfDXzs7ivdvQKYCBxK7mz/hIZu72z7HqSNkoC2KyeaJg7XM28DPnT3G2K9HgcSd/yeCzwWKz8n3DV8MLAuUY2Yidz9Sncf4O6DiLbxS+5+FvAycGoYLHn5E+vl1DB8xv4CcvfPgE/NLPGO6S8TvZI7J7Y/0WWAg82sY9gXEsufE9s/pqHbezLwVTPbKdSmfDWUSUO5u/7a6B9wLDAP+Aj4ZbrjaaFlPJyoGm8mMCP8HUt0nfNFYH743z0Mb0RPTXwEzCK6qzrty9FM6+JI4MnweTDwDrAAeBhoH8o7hO4Fof/gdMfdDMs9EpgSvgOTgJ1yafsD1wBzgNnAPUD7bN7+wP1E9z9UEP2iv6Ax2xv4TlgPC4Dz071cmfqnZoNFRERylC4HiIiI5CglASIiIjlKSYCIiEiOUhIgIiKSo5QEiIiI5CglAZKTzGxjC0//PDPrF+teZGY9mjC9+8Nb1C5NKr/azH6aYvj/1DG9X9TSr0HrxswuMrNzGjJOLdM6PjQf/J6ZfWBm32/g+Eea2aGNmG+Tto9IpiqoexARaYTziJ77bnIrZmbWBzjU3Xet7zjuXteJ8BfA75oU2OfzuqU5phNajrwVONDdl5hZe2BQA8YvIGprYSNQaxIkIhHVBIgEZtbTzCaY2bvh77BQfnV4B/orZrbQzH4cG+fXZjYnvAP9fjP7qZmdCowB7jOzGWZWFAb/kZlNM7NZZrZnivl3MLM7Qv/pZval0Os5oFeY1hfquSwbw/++ZvZaGHe2mX3BzH5P9Na6GWZ2Xw3j/ynE+qKZ9Qxlu5vZs2Y21cxeTyxDvDYirKPrzewdM5uXiDe0iPdQqM140MzeNrMxSbPtQvTDZDWAu29197lh/F1DLDPD/4Gh/E4zu8HMXgYeBC4CLk2sq1q26c5m9lxYz/8gdVv0IllPSYDI524keof7AcA3CK/2DfYken1p4t3lheEk9g2iNx+eQnTix90fIWoB7yx3H+nuZWEaq9x9NNE70Xeowgd+GMbfFzgTuMvMOgAnAB+Fab3ewGX6FjDZ3UcCI4AZ7n4FUBamd1aKcToB00KsrxK9tx2iX+k/cvf9Q/x/r2GeBe5+IHBJbNwfAGvdfT/gN8D+ySO5+xqiZmIXh4TqLDNLHKP+RvRK2f2A+4CbYqMOBY52928AtxBtw8S6qmmbXgW84dFLix4HBtawLCJZTZcDRD53NDDcPn89e1cz6xI+P+XuW4GtZrYC6E3U5PFjiZO8mT1Rx/QTL0eaSpQ0JDsc+CuAu88xs8VEJ7ja3qpYl3eB20NV+yR3n1GPcaqJflUD3AtMtOgtj4cCD8fWT/saxo8v56Dw+XCiEzLuPtvMZqYa0d2/a2b7Em2LnwJfIbq0cgifr7N7gD/ERnvY3atqiKWmbXpEYnru/pSZra1hfJGspiRA5HN5wCGxX+4AhBPI1lhRFdG+09Aq5MQ0EuMna/YqaXd/zcyOAI4D7jGz8e5+d0MnQ7RuSkONQl1SLWe9l83dZwGzzOwe4GOiJCBVTAmbaplcbdtUbaZLztPlAJHPPQdcnOgws7pOeDR7B9wAAAGqSURBVG8AXw/X8jsTnWgTNhBd426I14CzwryHElVRz23gNLZjZrsCK9z9n0RvaxwdelWE2oFU8vj8DXbfIqo2Xw98bGbfDNM1MxvRgFDeAE4L4w4H9k0Ra2czOzJWNBJYHD7/h+gtixCtozdqmE/yeq9pm8bX9deIXlokknOUBEiu6mhmS2J/lwE/BsaEm88+ILrJrEbu/i7R9eT3iKrApwDrQu87gVuSbgysy9+BfDObRVQdf164BFGXX8WXJanfkcAMM5tOdE38xlB+KzCzhhsDNwF7m9lU4Cjg/4Xys4ALzOw94H3gxHouV2LZeobLAD8nemPguqRhDPiZmc01sxlEb9c7L/T7MXB+GP9s4Cc1zOcJ4OTYTZQ1bdNrgCPMbBrRa2g/acCyiGQNvUVQpAnMrLO7bzSzjkS/Li9092npjqutMbN8oNDdt5jZ7kSvix3q7uVpDk0kp+meAJGmuTVUb3cA7lICUKOOwMvhEoQB/6MEQCT9VBMgIiKSo3RPgIiISI5SEiAiIpKjlASI/P9260AAAAAAQJC/9SAXRQBTEgAAUxIAAFMBmNHFzDg8sOcAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for sorting_alg in (Bubble_Sort, Optimized_Bubble_Sort, Insertion_Sort, Merge_Sort):\n",
    "    plot_sort_time(sorting_alg, 1000, 50, 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for search_alg in (Linear_Search, Binary_Search):\n",
    "    for boolean in (False, True):\n",
    "        plot_search_time(search_alg, 1000, 50, 5000, boolean)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is the end of the project. I learned a lot while working on it and I hope you learned something too."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}