diff --git a/.gitignore b/.gitignore new file mode 100644 index 000000000..4f6813f97 --- /dev/null +++ b/.gitignore @@ -0,0 +1,90 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +env/ +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +*.egg-info/ +.installed.cfg +*.egg + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*,cover +.hypothesis/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +target/ + +# IPython Notebook +.ipynb_checkpoints + +# pyenv +.python-version + +# celery beat schedule file +celerybeat-schedule + +# dotenv +.env + +# virtualenv +venv/ +ENV/ + +# Spyder project settings +.spyderproject + +# Rope project settings +.ropeproject +.idea diff --git a/BubbleSort.py b/BubbleSort.py deleted file mode 100644 index 9f3579617..000000000 --- a/BubbleSort.py +++ /dev/null @@ -1,39 +0,0 @@ -import sys - - -def simple_bubble_sort(int_list): - count = len(int_list) - swapped = True - while (swapped): - swapped = False - for j in range(count - 1): - if (int_list[j] > int_list[j + 1]): - int_list[j], int_list[j + 1] = int_list[j + 1], int_list[j] - swapped = True - return int_list - - -def main(): - # Python 2's `raw_input` has been renamed to `input` in Python 3 - if sys.version_info.major < 3: - input_function = raw_input - else: - input_function = input - - try: - print("Enter numbers separated by spaces:") - s = input_function() - inputs = list(map(int, s.split(' '))) - if len(inputs) < 2: - print('No Enough values to sort!') - raise Exception - - except Exception as e: - print(e) - else: - sorted_input = simple_bubble_sort(inputs) - print('\nSorted list (min to max): {}'.format(sorted_input)) - -if __name__ == '__main__': - print('==== Bubble Sort ====\n') - main() diff --git a/InsertionSort.py b/InsertionSort.py deleted file mode 100644 index a577c4a81..000000000 --- a/InsertionSort.py +++ /dev/null @@ -1,40 +0,0 @@ -import sys - - -def simple_insertion_sort(int_list): - count = len(int_list) - for i in range(1, count): - temp = int_list[i] - j = i - 1 - while(j >= 0 and temp < int_list[j]): - int_list[j + 1] = int_list[j] - j -= 1 - int_list[j + 1] = temp - - return int_list - - -def main(): - # Python 2's `raw_input` has been renamed to `input` in Python 3 - if sys.version_info.major < 3: - input_function = raw_input - else: - input_function = input - - try: - print("Enter numbers separated by spaces:") - s = input_function() - inputs = list(map(int, s.split(' '))) - if len(inputs) < 2: - print('No Enough values to sort!') - raise Exception - - except Exception as e: - print(e) - else: - sorted_input = simple_insertion_sort(inputs) - print('\nSorted list (min to max): {}'.format(sorted_input)) - -if __name__ == '__main__': - print('==== Insertion Sort ====\n') - main() diff --git a/LinearSearch.py b/LinearSearch.py deleted file mode 100644 index 82595eded..000000000 --- a/LinearSearch.py +++ /dev/null @@ -1,32 +0,0 @@ -import sys - - -def sequential_search(alist, target): - for index, item in enumerate(alist): - if item == target: - print("Found target {} at index {}".format(target, index)) - break - else: - print("Not found") - - -def main(): - # Python 2's `raw_input` has been renamed to `input` in Python 3 - if sys.version_info.major < 3: - input_function = raw_input - else: - input_function = input - - try: - print("Enter numbers separated by spaces") - s = input_function() - inputs = list(map(int, s.split(' '))) - target = int(input_function('\nEnter a number to be found in list: ')) - except Exception as e: - print(e) - else: - sequential_search(inputs, target) - -if __name__ == '__main__': - print('==== Linear Search ====\n') - main() diff --git a/MergeSort.py b/MergeSort.py deleted file mode 100644 index ff3a31c70..000000000 --- a/MergeSort.py +++ /dev/null @@ -1,59 +0,0 @@ -import sys - - -def merge_sort(alist): - print("Splitting ", alist) - if len(alist) > 1: - mid = len(alist) // 2 - left_half = alist[:mid] - right_half = alist[mid:] - merge_sort(left_half) - merge_sort(right_half) - i = j = k = 0 - - while i < len(left_half) and j < len(right_half): - if left_half[i] < right_half[j]: - alist[k] = left_half[i] - i += 1 - else: - alist[k] = right_half[j] - j += 1 - k += 1 - - while i < len(left_half): - alist[k] = left_half[i] - i += 1 - k += 1 - - while j < len(right_half): - alist[k] = right_half[j] - j += 1 - k += 1 - print("Merging ", alist) - return alist - - -def main(): - # Python 2's `raw_input` has been renamed to `input` in Python 3 - if sys.version_info.major < 3: - input_function = raw_input - else: - input_function = input - - try: - print("Enter numbers separated by spaces:") - s = input_function() - inputs = list(map(int, s.split(' '))) - if len(inputs) < 2: - print('No Enough values to sort!') - raise Exception - - except Exception as e: - print(e) - else: - sorted_input = merge_sort(inputs) - print('\nSorted list (min to max): {}'.format(sorted_input)) - -if __name__ == '__main__': - print('==== Merge Sort ====\n') - main() diff --git a/QuickSort.py b/QuickSort.py deleted file mode 100644 index 2d922a3de..000000000 --- a/QuickSort.py +++ /dev/null @@ -1,41 +0,0 @@ -import sys - - -def quick_sort(A, p, r): - if p < r: - q = partition(A, p, r) - quick_sort(A, p, q - 1) - quick_sort(A, q + 1, r) - return A - - -def partition(A, p, r): - i = p - 1 - for j in range(p, r): - if A[j] <= A[r]: - i += 1 - A[i], A[j] = A[j], A[i] - A[i + 1], A[r] = A[r], A[i + 1] - return i + 1 - - -def main(): - # Python 2's `raw_input` has been renamed to `input` in Python 3 - if sys.version_info.major < 3: - input_function = raw_input - else: - input_function = input - - try: - print("Enter numbers separated by spaces") - s = input_function() - inputs = list(map(int, s.split(' '))) - except Exception as e: - print(e) - else: - sorted_input = quick_sort(inputs, 0, len(inputs) - 1) - print('\nSorted list (min to max): {}'.format(sorted_input)) - -if __name__ == '__main__': - print('==== Quick Sort ====\n') - main() diff --git a/binary_seach.py b/binary_seach.py index a48762863..f9e27d3ff 100644 --- a/binary_seach.py +++ b/binary_seach.py @@ -2,9 +2,9 @@ This is pure python implementation of binary search algorithm For doctests run following command: -python -m doctest -v selection_sort.py +python -m doctest -v binary_search.py or -python3 -m doctest -v selection_sort.py +python3 -m doctest -v binary_search.py For manual testing run: python binary_search.py @@ -13,30 +13,12 @@ from __future__ import print_function import bisect -def assert_sorted(collection): - """Check if collection is sorted. If not raises :py:class:`ValueError` - - :param collection: collection - :return: True if collection is sorted - :raise: :py:class:`ValueError` if collection is not sorted - - Examples: - >>> assert_sorted([0, 1, 2, 4]) - True - - >>> assert_sorted([10, -1, 5]) - Traceback (most recent call last): - ... - ValueError: Collection must be sorted - """ - if collection != sorted(collection): - raise ValueError('Collection must be sorted') - return True - - def binary_search(sorted_collection, item): """Pure implementation of binary search algorithm in Python + Be careful collection must be sorted, otherwise result will be + unpredictable + :param sorted_collection: some sorted collection with comparable items :param item: item value to search :return: index of found item or None if item is not found @@ -53,12 +35,7 @@ def binary_search(sorted_collection, item): >>> binary_search([0, 5, 7, 10, 15], 6) - >>> binary_search([5, 2, 1, 5], 2) - Traceback (most recent call last): - ... - ValueError: Collection must be sorted """ - assert_sorted(sorted_collection) left = 0 right = len(sorted_collection) - 1 @@ -78,6 +55,9 @@ def binary_search(sorted_collection, item): def binary_search_std_lib(sorted_collection, item): """Pure implementation of binary search algorithm in Python using stdlib + Be careful collection must be sorted, otherwise result will be + unpredictable + :param sorted_collection: some sorted collection with comparable items :param item: item value to search :return: index of found item or None if item is not found @@ -94,18 +74,34 @@ def binary_search_std_lib(sorted_collection, item): >>> binary_search_std_lib([0, 5, 7, 10, 15], 6) - >>> binary_search_std_lib([5, 2, 1, 5], 2) - Traceback (most recent call last): - ... - ValueError: Collection must be sorted """ - assert_sorted(sorted_collection) index = bisect.bisect_left(sorted_collection, item) if index != len(sorted_collection) and sorted_collection[index] == item: return index return None +def __assert_sorted(collection): + """Check if collection is sorted, if not - raises :py:class:`ValueError` + + :param collection: collection + :return: True if collection is sorted + :raise: :py:class:`ValueError` if collection is not sorted + + Examples: + >>> __assert_sorted([0, 1, 2, 4]) + True + + >>> __assert_sorted([10, -1, 5]) + Traceback (most recent call last): + ... + ValueError: Collection must be sorted + """ + if collection != sorted(collection): + raise ValueError('Collection must be sorted') + return True + + if __name__ == '__main__': import sys # For python 2.x and 3.x compatibility: 3.x has not raw_input builtin @@ -117,6 +113,10 @@ if __name__ == '__main__': user_input = input_function('Enter numbers separated by coma:\n') collection = [int(item) for item in user_input.split(',')] + try: + __assert_sorted(collection) + except ValueError: + sys.exit('Sequence must be sorted to apply binary search') target_input = input_function( 'Enter a single number to be found in the list:\n' diff --git a/bubble_sort.py b/bubble_sort.py new file mode 100644 index 000000000..2baaff9ae --- /dev/null +++ b/bubble_sort.py @@ -0,0 +1,52 @@ +""" +This is pure python implementation of bubble sort algorithm + +For doctests run following command: +python -m doctest -v bubble_sort.py +or +python3 -m doctest -v bubble_sort.py + +For manual testing run: +python bubble_sort.py +""" +from __future__ import print_function + + +def bubble_sort(collection): + """Pure implementation of bubble sort algorithm in Python + + :param collection: some mutable ordered collection with heterogeneous + comparable items inside + :return: the same collection ordered by ascending + + Examples: + >>> bubble_sort([0, 5, 3, 2, 2]) + [0, 2, 2, 3, 5] + + >>> bubble_sort([]) + [] + + >>> bubble_sort([-2, -5, -45]) + [-45, -5, -2] + """ + length = len(collection) + for i in range(length): + for j in range(length-1): + if collection[j] > collection[j+1]: + collection[j], collection[j+1] = collection[j+1], collection[j] + + return collection + + +if __name__ == '__main__': + import sys + # For python 2.x and 3.x compatibility: 3.x has not raw_input builtin + # otherwise 2.x's input builtin function is too "smart" + if sys.version_info.major < 3: + input_function = raw_input + else: + input_function = input + + user_input = input_function('Enter numbers separated by coma:\n') + unsorted = [int(item) for item in user_input.split(',')] + print(bubble_sort(unsorted)) diff --git a/insertion_sort.py b/insertion_sort.py new file mode 100644 index 000000000..501655e92 --- /dev/null +++ b/insertion_sort.py @@ -0,0 +1,56 @@ +""" +This is pure python implementation of insertion sort algorithm + +For doctests run following command: +python -m doctest -v insertion_sort.py +or +python3 -m doctest -v insertion_sort.py + +For manual testing run: +python insertion_sort.py +""" +from __future__ import print_function + + +def insertion_sort(collection): + """Pure implementation of insertion sort algorithm in Python + + :param collection: some mutable ordered collection with heterogeneous + comparable items inside + :return: the same collection ordered by ascending + + Examples: + >>> insertion_sort([0, 5, 3, 2, 2]) + [0, 2, 2, 3, 5] + + >>> insertion_sort([]) + [] + + >>> insertion_sort([-2, -5, -45]) + [-45, -5, -2] + """ + length = len(collection) + for i in range(length): + current_item = collection[i] + j = i - 1 + while j >= 0 and current_item < collection[j]: + collection[j+1] = collection[j] + j -= 1 + collection[j+1] = current_item + + return collection + + +if __name__ == '__main__': + import sys + + # For python 2.x and 3.x compatibility: 3.x has not raw_input builtin + # otherwise 2.x's input builtin function is too "smart" + if sys.version_info.major < 3: + input_function = raw_input + else: + input_function = input + + user_input = input_function('Enter numbers separated by coma:\n') + unsorted = [int(item) for item in user_input.split(',')] + print(insertion_sort(unsorted)) diff --git a/linear_search.py b/linear_search.py new file mode 100644 index 000000000..f42810092 --- /dev/null +++ b/linear_search.py @@ -0,0 +1,62 @@ +""" +This is pure python implementation of linear search algorithm + +For doctests run following command: +python -m doctest -v linear_search.py +or +python3 -m doctest -v linear_search.py + +For manual testing run: +python linear_search.py +""" +from __future__ import print_function + + +def linear_search(sequence, target): + """Pure implementation of binary search algorithm in Python + + :param sequence: some sorted collection with comparable items + :param target: item value to search + :return: index of found item or None if item is not found + + Examples: + >>> linear_search([0, 5, 7, 10, 15], 0) + 0 + + >>> linear_search([0, 5, 7, 10, 15], 15) + 4 + + >>> linear_search([0, 5, 7, 10, 15], 5) + 1 + + >>> linear_search([0, 5, 7, 10, 15], 6) + + """ + for index, item in enumerate(sequence): + if item == target: + return index + return None + + +if __name__ == '__main__': + import sys + + # For python 2.x and 3.x compatibility: 3.x has not raw_input builtin + # otherwise 2.x's input builtin function is too "smart" + if sys.version_info.major < 3: + input_function = raw_input + else: + input_function = input + + user_input = input_function('Enter numbers separated by coma:\n') + sequence = [int(item) for item in user_input.split(',')] + + target_input = input_function( + 'Enter a single number to be found in the list:\n' + ) + target = int(target_input) + result = linear_search(sequence, target) + if result is not None: + print('{} found at positions: {}'.format(target, result)) + else: + print('Not found') diff --git a/merge_sort.py b/merge_sort.py new file mode 100644 index 000000000..c34c395af --- /dev/null +++ b/merge_sort.py @@ -0,0 +1,76 @@ +""" +This is pure python implementation of merge sort algorithm + +For doctests run following command: +python -m doctest -v merge_sort.py +or +python3 -m doctest -v merge_sort.py + +For manual testing run: +python merge_sort.py +""" +from __future__ import print_function + + +def merge_sort(collection): + """Pure implementation of merge sort algorithm in Python + + :param collection: some mutable ordered collection with heterogeneous + comparable items inside + :return: the same collection ordered by ascending + + Examples: + >>> merge_sort([0, 5, 3, 2, 2]) + [0, 2, 2, 3, 5] + + >>> merge_sort([]) + [] + + >>> merge_sort([-2, -5, -45]) + [-45, -5, -2] + """ + length = len(collection) + if length > 1: + midpoint = length // 2 + left_half = merge_sort(collection[:midpoint]) + right_half = merge_sort(collection[midpoint:]) + i = 0 + j = 0 + k = 0 + left_length = len(left_half) + right_length = len(right_half) + while i < left_length and j < right_length: + if left_half[i] < right_half[j]: + collection[k] = left_half[i] + i += 1 + else: + collection[k] = right_half[j] + j += 1 + k += 1 + + while i < left_length: + collection[k] = left_half[i] + i += 1 + k += 1 + + while j < right_length: + collection[k] = right_half[j] + j += 1 + k += 1 + + return collection + + +if __name__ == '__main__': + import sys + + # For python 2.x and 3.x compatibility: 3.x has not raw_input builtin + # otherwise 2.x's input builtin function is too "smart" + if sys.version_info.major < 3: + input_function = raw_input + else: + input_function = input + + user_input = input_function('Enter numbers separated by coma:\n') + unsorted = [int(item) for item in user_input.split(',')] + print(merge_sort(unsorted)) diff --git a/quick_sort.py b/quick_sort.py new file mode 100644 index 000000000..fa6597041 --- /dev/null +++ b/quick_sort.py @@ -0,0 +1,61 @@ +""" +This is pure python implementation of quick sort algorithm + +For doctests run following command: +python -m doctest -v quick_sort.py +or +python3 -m doctest -v quick_sort.py + +For manual testing run: +python quick_sort.py +""" +from __future__ import print_function + + +def quick_sort(collection): + """Pure implementation of quick sort algorithm in Python + + :param collection: some mutable ordered collection with heterogeneous + comparable items inside + :return: the same collection ordered by ascending + + Examples: + >>> quick_sort([0, 5, 3, 2, 2]) + [0, 2, 2, 3, 5] + + >>> quick_sort([]) + [] + + >>> quick_sort([-2, -5, -45]) + [-45, -5, -2] + """ + less = [] + equal = [] + greater = [] + if len(collection) > 1: + pivot = collection[0] + for x in collection: + if x < pivot: + less.append(x) + if x == pivot: + equal.append(x) + if x > pivot: + greater.append(x) + return quick_sort(less) + equal + quick_sort(greater) + else: + return collection + + +if __name__ == '__main__': + import sys + + # For python 2.x and 3.x compatibility: 3.x has not raw_input builtin + # otherwise 2.x's input builtin function is too "smart" + if sys.version_info.major < 3: + input_function = raw_input + else: + input_function = input + + user_input = input_function('Enter numbers separated by coma:\n') + unsorted = [int(item) for item in user_input.split(',')] + print(quick_sort(unsorted)) diff --git a/selection_sort.py b/selection_sort.py index 4de19d230..fbb94226d 100644 --- a/selection_sort.py +++ b/selection_sort.py @@ -5,10 +5,14 @@ For doctests run following command: python -m doctest -v selection_sort.py or python3 -m doctest -v selection_sort.py + +For manual testing run: +python selection_sort.py """ from __future__ import print_function -def selection_sort(sortable): + +def selection_sort(collection): """Pure implementation of selection sort algorithm in Python Examples: @@ -21,20 +25,20 @@ def selection_sort(sortable): >>> selection_sort([-2, -5, -45]) [-45, -5, -2] - :param sortable: some mutable ordered collection with heterogeneous + :param collection: some mutable ordered collection with heterogeneous comparable items inside :return: the same collection ordered by ascending """ - length = len(sortable) + length = len(collection) for i in range(length): least = i for k in range(i + 1, length): - if sortable[k] < sortable[least]: + if collection[k] < collection[least]: least = k - sortable[least], sortable[i] = ( - sortable[i], sortable[least] + collection[least], collection[i] = ( + collection[i], collection[least] ) - return sortable + return collection if __name__ == '__main__':