From 9d1da353275a1ac2455190e87de24b67c1b7cf55 Mon Sep 17 00:00:00 2001 From: matkosoric Date: Tue, 3 Mar 2020 14:00:00 +0100 Subject: [PATCH 01/15] spelling corrections --- machine_learning/linear_regression.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/machine_learning/linear_regression.py b/machine_learning/linear_regression.py index b666feddccc7..fcb18fcedce2 100644 --- a/machine_learning/linear_regression.py +++ b/machine_learning/linear_regression.py @@ -1,10 +1,10 @@ """ Linear regression is the most basic type of regression commonly used for -predictive analysis. The idea is pretty simple, we have a dataset and we have -a feature's associated with it. The Features should be choose very cautiously -as they determine, how much our model will be able to make future predictions. -We try to set these Feature weights, over many iterations, so that they best -fits our dataset. In this particular code, i had used a CSGO dataset (ADR vs +predictive analysis. The idea is pretty simple: we have a dataset and we have +features associated with it. Features should be chosen very cautiously +as they determine how much our model will be able to make future predictions. +We try to set these features weights, over many iterations, so that they best +fit our dataset. In this particular code, I had used a CSGO dataset (ADR vs Rating). We try to best fit a line through dataset and estimate the parameters. """ import requests From b0595afb561c4c324decd2082cc9e03caa73cc82 Mon Sep 17 00:00:00 2001 From: matkosoric Date: Tue, 3 Mar 2020 14:15:21 +0100 Subject: [PATCH 02/15] review --- machine_learning/linear_regression.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/machine_learning/linear_regression.py b/machine_learning/linear_regression.py index fcb18fcedce2..29bb7c48589e 100644 --- a/machine_learning/linear_regression.py +++ b/machine_learning/linear_regression.py @@ -3,7 +3,7 @@ predictive analysis. The idea is pretty simple: we have a dataset and we have features associated with it. Features should be chosen very cautiously as they determine how much our model will be able to make future predictions. -We try to set these features weights, over many iterations, so that they best +We try to set the weight of these features, over many iterations, so that they best fit our dataset. In this particular code, I had used a CSGO dataset (ADR vs Rating). We try to best fit a line through dataset and estimate the parameters. """ From c9f921ee3ca611896a39414dd446a660a77f01f1 Mon Sep 17 00:00:00 2001 From: matkosoric Date: Tue, 3 Mar 2020 20:23:24 +0100 Subject: [PATCH 03/15] improved documentation, removed redundant variables, added testing --- sorts/comb_sort.py | 46 +++++++++++++++++++++++++++------------------- 1 file changed, 27 insertions(+), 19 deletions(-) diff --git a/sorts/comb_sort.py b/sorts/comb_sort.py index 3c4c57483e3f..54a25ca3015c 100644 --- a/sorts/comb_sort.py +++ b/sorts/comb_sort.py @@ -1,8 +1,13 @@ """ +This is pure python implementation of comb sort algorithm. Comb sort is a relatively simple sorting algorithm originally designed by Wlodzimierz Dobosiewicz in 1980. -Later it was rediscovered by Stephen Lacey and Richard Box in 1991. Comb sort improves on bubble sort. +It was rediscovered by Stephen Lacey and Richard Box in 1991. Comb sort improves on bubble sort algorithm. +In bubble sort, distance (or gap) between two compared elements is always one. +Comb sort improvement is that gap can be much more than 1, in order to prevent slowing down by small values +at the end of a list. + +More info on: https://en.wikipedia.org/wiki/Comb_sort -This is pure python implementation of comb sort algorithm For doctests run following command: python -m doctest -v comb_sort.py or @@ -15,40 +20,43 @@ def comb_sort(data): """Pure implementation of comb sort algorithm in Python - :param collection: some mutable ordered collection with heterogeneous - comparable items inside - :return: the same collection ordered by ascending + :param data: mutable collection with comparable items + :return: the same collection in ascending order Examples: >>> comb_sort([0, 5, 3, 2, 2]) [0, 2, 2, 3, 5] >>> comb_sort([]) [] - >>> comb_sort([-2, -5, -45]) - [-45, -5, -2] + >>> comb_sort([99,45,-7,8,2,0,-15,3]) + [-15, -7, 0, 2, 3, 8, 45, 99] """ shrink_factor = 1.3 gap = len(data) - swapped = True - i = 0 + completed = False - while gap > 1 or swapped: - # Update the gap value for a next comb - gap = int(float(gap) / shrink_factor) + while not completed: - swapped = False - i = 0 + # Update the gap value for a next comb + gap = int(gap / shrink_factor) + if gap <= 1: + completed = True - while gap + i < len(data): - if data[i] > data[i + gap]: + index = 0 + while index + gap < len(data): + if data[index] > data[index + gap]: # Swap values - data[i], data[i + gap] = data[i + gap], data[i] - swapped = True - i += 1 + data[index], data[index + gap] = data[index + gap], data[index] + completed = False + index += 1 return data if __name__ == "__main__": + + import doctest + doctest.testmod() + user_input = input("Enter numbers separated by a comma:\n").strip() unsorted = [int(item) for item in user_input.split(",")] print(comb_sort(unsorted)) From 8f0e9f8c0a7918db590393d5c3ba5b76353c883e Mon Sep 17 00:00:00 2001 From: matkosoric Date: Tue, 3 Mar 2020 20:31:50 +0100 Subject: [PATCH 04/15] added type hint --- sorts/comb_sort.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sorts/comb_sort.py b/sorts/comb_sort.py index 54a25ca3015c..0d6d0404f86b 100644 --- a/sorts/comb_sort.py +++ b/sorts/comb_sort.py @@ -18,7 +18,7 @@ """ -def comb_sort(data): +def comb_sort(data: list) -> list: """Pure implementation of comb sort algorithm in Python :param data: mutable collection with comparable items :return: the same collection in ascending order From bde5d29d68a9775748b25929a4bd62bb8499b31f Mon Sep 17 00:00:00 2001 From: matkosoric Date: Tue, 3 Mar 2020 20:41:05 +0100 Subject: [PATCH 05/15] camel case to snake case --- ciphers/hill_cipher.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/ciphers/hill_cipher.py b/ciphers/hill_cipher.py index ffc1d9793bf2..47910e4ebdaa 100644 --- a/ciphers/hill_cipher.py +++ b/ciphers/hill_cipher.py @@ -65,11 +65,11 @@ def __init__(self, encrypt_key): encrypt_key is an NxN numpy matrix """ self.encrypt_key = self.modulus(encrypt_key) # mod36 calc's on the encrypt key - self.checkDeterminant() # validate the determinant of the encryption key + self.check_determinant() # validate the determinant of the encryption key self.decrypt_key = None self.break_key = encrypt_key.shape[0] - def checkDeterminant(self): + def check_determinant(self): det = round(numpy.linalg.det(self.encrypt_key)) if det < 0: @@ -83,7 +83,7 @@ def checkDeterminant(self): ) ) - def processText(self, text): + def process_text(self, text): text = list(text.upper()) text = [char for char in text if char in self.key_string] @@ -94,7 +94,7 @@ def processText(self, text): return "".join(text) def encrypt(self, text): - text = self.processText(text.upper()) + text = self.process_text(text.upper()) encrypted = "" for i in range(0, len(text) - self.break_key + 1, self.break_key): @@ -109,7 +109,7 @@ def encrypt(self, text): return encrypted - def makeDecryptKey(self): + def make_decrypt_key(self): det = round(numpy.linalg.det(self.encrypt_key)) if det < 0: @@ -129,8 +129,8 @@ def makeDecryptKey(self): return self.toInt(self.modulus(inv_key)) def decrypt(self, text): - self.decrypt_key = self.makeDecryptKey() - text = self.processText(text.upper()) + self.decrypt_key = self.make_decrypt_key() + text = self.process_text(text.upper()) decrypted = "" for i in range(0, len(text) - self.break_key + 1, self.break_key): From cbac92002922a3a2fbc95ea391272668adeaa048 Mon Sep 17 00:00:00 2001 From: matkosoric Date: Tue, 3 Mar 2020 22:03:56 +0100 Subject: [PATCH 06/15] spelling fix --- searches/simulated_annealing.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/searches/simulated_annealing.py b/searches/simulated_annealing.py index d3542b00af45..994f139dfcb6 100644 --- a/searches/simulated_annealing.py +++ b/searches/simulated_annealing.py @@ -74,7 +74,7 @@ def simulated_annealing( current_temp = current_temp - (current_temp * rate_of_decrease) if current_temp < threshold_temp or next_state is None: - # temperature below threshold, or could not find a suitaable neighbor + # temperature below threshold, or could not find a suitable neighbor search_end = True else: current_state = next_state From 297472020fad8485f9bdfdacc0fdcd2c11d3052d Mon Sep 17 00:00:00 2001 From: matkosoric Date: Tue, 3 Mar 2020 22:07:26 +0100 Subject: [PATCH 07/15] review --- sorts/comb_sort.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/sorts/comb_sort.py b/sorts/comb_sort.py index 0d6d0404f86b..11c31a55f277 100644 --- a/sorts/comb_sort.py +++ b/sorts/comb_sort.py @@ -1,5 +1,5 @@ """ -This is pure python implementation of comb sort algorithm. +This is pure Python implementation of comb sort algorithm. Comb sort is a relatively simple sorting algorithm originally designed by Wlodzimierz Dobosiewicz in 1980. It was rediscovered by Stephen Lacey and Richard Box in 1991. Comb sort improves on bubble sort algorithm. In bubble sort, distance (or gap) between two compared elements is always one. @@ -37,7 +37,7 @@ def comb_sort(data: list) -> list: while not completed: # Update the gap value for a next comb - gap = int(gap / shrink_factor) + gap //= shrink_factor if gap <= 1: completed = True From 82ffd1e2aac1d80526ee5b1d4dabcbc29b6a25c9 Mon Sep 17 00:00:00 2001 From: matkosoric Date: Tue, 3 Mar 2020 22:15:54 +0100 Subject: [PATCH 08/15] python --> Python # it is a brand name, not a snake --- .gitignore | 2 +- data_structures/queue/queue_on_list.py | 2 +- digital_image_processing/change_contrast.py | 2 +- dynamic_programming/bitmask.py | 2 +- fuzzy_logic/fuzzy_operations.py | 2 +- other/magicdiamondpattern.py | 2 +- other/primelib.py | 2 +- searches/binary_search.py | 2 +- searches/interpolation_search.py | 2 +- searches/linear_search.py | 2 +- searches/sentinel_linear_search.py | 2 +- searches/tabu_search.py | 2 +- sorts/bogo_sort.py | 2 +- sorts/counting_sort.py | 2 +- sorts/heap_sort.py | 2 +- sorts/insertion_sort.py | 2 +- sorts/merge_sort.py | 2 +- sorts/pancake_sort.py | 2 +- sorts/quick_sort.py | 2 +- sorts/selection_sort.py | 2 +- sorts/shell_sort.py | 2 +- sorts/unknown_sort.py | 2 +- traversals/binary_tree_traversals.py | 2 +- 23 files changed, 23 insertions(+), 23 deletions(-) diff --git a/.gitignore b/.gitignore index b840d4ed0490..574cdf312836 100644 --- a/.gitignore +++ b/.gitignore @@ -26,7 +26,7 @@ wheels/ MANIFEST # PyInstaller -# Usually these files are written by a python script from a template +# 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 diff --git a/data_structures/queue/queue_on_list.py b/data_structures/queue/queue_on_list.py index bb44e08ad6c5..4d69461af66a 100644 --- a/data_structures/queue/queue_on_list.py +++ b/data_structures/queue/queue_on_list.py @@ -1,4 +1,4 @@ -"""Queue represented by a python list""" +"""Queue represented by a Python list""" class Queue: diff --git a/digital_image_processing/change_contrast.py b/digital_image_processing/change_contrast.py index 76f1a3e1fcd8..c7da52298ae2 100644 --- a/digital_image_processing/change_contrast.py +++ b/digital_image_processing/change_contrast.py @@ -2,7 +2,7 @@ Changing contrast with PIL This algorithm is used in -https://noivce.pythonanywhere.com/ python web app. +https://noivce.pythonanywhere.com/ Python web app. python/black: True flake8 : True diff --git a/dynamic_programming/bitmask.py b/dynamic_programming/bitmask.py index 1841f1747557..e0e3f74489e4 100644 --- a/dynamic_programming/bitmask.py +++ b/dynamic_programming/bitmask.py @@ -1,6 +1,6 @@ """ -This is a python implementation for questions involving task assignments between people. +This is a Python implementation for questions involving task assignments between people. Here Bitmasking and DP are used for solving this. Question :- diff --git a/fuzzy_logic/fuzzy_operations.py b/fuzzy_logic/fuzzy_operations.py index cb870e8d9e3b..34dd9c029be7 100644 --- a/fuzzy_logic/fuzzy_operations.py +++ b/fuzzy_logic/fuzzy_operations.py @@ -11,7 +11,7 @@ if __name__ == "__main__": - # Create universe of discourse in python using linspace () + # Create universe of discourse in Python using linspace () X = np.linspace(start=0, stop=75, num=75, endpoint=True, retstep=False) # Create two fuzzy sets by defining any membership function (trapmf(), gbellmf(),gaussmf(), etc). diff --git a/other/magicdiamondpattern.py b/other/magicdiamondpattern.py index 6de5046c9f18..4ca698d80c28 100644 --- a/other/magicdiamondpattern.py +++ b/other/magicdiamondpattern.py @@ -1,4 +1,4 @@ -# Python program for generating diamond pattern in python 3.7+ +# Python program for generating diamond pattern in Python 3.7+ # Function to print upper half of diamond (pyramid) def floyd(n): diff --git a/other/primelib.py b/other/primelib.py index 1b99819ce62a..a6d1d7dfb324 100644 --- a/other/primelib.py +++ b/other/primelib.py @@ -3,7 +3,7 @@ @author: Christian Bender -This python library contains some useful functions to deal with +This Python library contains some useful functions to deal with prime numbers and whole numbers. Overview: diff --git a/searches/binary_search.py b/searches/binary_search.py index fe22e423a7d4..8edf63136f9a 100644 --- a/searches/binary_search.py +++ b/searches/binary_search.py @@ -1,5 +1,5 @@ """ -This is pure python implementation of binary search algorithms +This is pure Python implementation of binary search algorithms For doctests run following command: python -m doctest -v binary_search.py diff --git a/searches/interpolation_search.py b/searches/interpolation_search.py index 419ec52c0f4e..f4fa8e1203df 100644 --- a/searches/interpolation_search.py +++ b/searches/interpolation_search.py @@ -1,5 +1,5 @@ """ -This is pure python implementation of interpolation search algorithm +This is pure Python implementation of interpolation search algorithm """ diff --git a/searches/linear_search.py b/searches/linear_search.py index b6f52ca4857f..76683dc6a6a8 100644 --- a/searches/linear_search.py +++ b/searches/linear_search.py @@ -1,5 +1,5 @@ """ -This is pure python implementation of linear search algorithm +This is pure Python implementation of linear search algorithm For doctests run following command: python -m doctest -v linear_search.py diff --git a/searches/sentinel_linear_search.py b/searches/sentinel_linear_search.py index 5650151b1d2f..69c1cf9f351a 100644 --- a/searches/sentinel_linear_search.py +++ b/searches/sentinel_linear_search.py @@ -1,5 +1,5 @@ """ -This is pure python implementation of sentinel linear search algorithm +This is pure Python implementation of sentinel linear search algorithm For doctests run following command: python -m doctest -v sentinel_linear_search.py diff --git a/searches/tabu_search.py b/searches/tabu_search.py index 2847dca7acd7..9ddc5e8dee7f 100644 --- a/searches/tabu_search.py +++ b/searches/tabu_search.py @@ -1,5 +1,5 @@ """ -This is pure python implementation of Tabu search algorithm for a Travelling Salesman Problem, that the distances +This is pure Python implementation of Tabu search algorithm for a Travelling Salesman Problem, that the distances between the cities are symmetric (the distance between city 'a' and city 'b' is the same between city 'b' and city 'a'). The TSP can be represented into a graph. The cities are represented by nodes and the distance between them is represented by the weight of the ark between the nodes. diff --git a/sorts/bogo_sort.py b/sorts/bogo_sort.py index 0afa444e5b8e..798ff619a6d7 100644 --- a/sorts/bogo_sort.py +++ b/sorts/bogo_sort.py @@ -1,5 +1,5 @@ """ -This is a pure python implementation of the bogosort algorithm +This is a pure Python implementation of the bogosort algorithm For doctests run following command: python -m doctest -v bogo_sort.py or diff --git a/sorts/counting_sort.py b/sorts/counting_sort.py index b672d4af47cb..892ec5d5f344 100644 --- a/sorts/counting_sort.py +++ b/sorts/counting_sort.py @@ -1,5 +1,5 @@ """ -This is pure python implementation of counting sort algorithm +This is pure Python implementation of counting sort algorithm For doctests run following command: python -m doctest -v counting_sort.py or diff --git a/sorts/heap_sort.py b/sorts/heap_sort.py index a39ae2b88da2..4dca879bd89c 100644 --- a/sorts/heap_sort.py +++ b/sorts/heap_sort.py @@ -1,5 +1,5 @@ """ -This is a pure python implementation of the heap sort algorithm. +This is a pure Python implementation of the heap sort algorithm. For doctests run following command: python -m doctest -v heap_sort.py diff --git a/sorts/insertion_sort.py b/sorts/insertion_sort.py index b767018c3d57..ca678381b431 100644 --- a/sorts/insertion_sort.py +++ b/sorts/insertion_sort.py @@ -1,5 +1,5 @@ """ -This is a pure python implementation of the insertion sort algorithm +This is a pure Python implementation of the insertion sort algorithm For doctests run following command: python -m doctest -v insertion_sort.py diff --git a/sorts/merge_sort.py b/sorts/merge_sort.py index 13f1144d4ad3..e8031a1cb97c 100644 --- a/sorts/merge_sort.py +++ b/sorts/merge_sort.py @@ -1,5 +1,5 @@ """ -This is a pure python implementation of the merge sort algorithm +This is a pure Python implementation of the merge sort algorithm For doctests run following command: python -m doctest -v merge_sort.py diff --git a/sorts/pancake_sort.py b/sorts/pancake_sort.py index ee54e57f9e0f..e5d600738435 100644 --- a/sorts/pancake_sort.py +++ b/sorts/pancake_sort.py @@ -1,5 +1,5 @@ """ -This is a pure python implementation of the pancake sort algorithm +This is a pure Python implementation of the pancake sort algorithm For doctests run following command: python3 -m doctest -v pancake_sort.py or diff --git a/sorts/quick_sort.py b/sorts/quick_sort.py index 29e10206f720..f2a55c58b437 100644 --- a/sorts/quick_sort.py +++ b/sorts/quick_sort.py @@ -1,5 +1,5 @@ """ -This is a pure python implementation of the quick sort algorithm +This is a pure Python implementation of the quick sort algorithm For doctests run following command: python -m doctest -v quick_sort.py diff --git a/sorts/selection_sort.py b/sorts/selection_sort.py index 6a9c063d3364..f3beb31b7070 100644 --- a/sorts/selection_sort.py +++ b/sorts/selection_sort.py @@ -1,5 +1,5 @@ """ -This is a pure python implementation of the selection sort algorithm +This is a pure Python implementation of the selection sort algorithm For doctests run following command: python -m doctest -v selection_sort.py diff --git a/sorts/shell_sort.py b/sorts/shell_sort.py index ff9c2785b218..80d95870f95b 100644 --- a/sorts/shell_sort.py +++ b/sorts/shell_sort.py @@ -1,5 +1,5 @@ """ -This is a pure python implementation of the shell sort algorithm +This is a pure Python implementation of the shell sort algorithm For doctests run following command: python -m doctest -v shell_sort.py diff --git a/sorts/unknown_sort.py b/sorts/unknown_sort.py index 087533b4a575..5ecc55e9cf69 100644 --- a/sorts/unknown_sort.py +++ b/sorts/unknown_sort.py @@ -1,7 +1,7 @@ """ Python implementation of a sort algorithm. Best Case Scenario : O(n) -Worst Case Scenario : O(n^2) because native python functions:min, max and remove are already O(n) +Worst Case Scenario : O(n^2) because native Python functions:min, max and remove are already O(n) """ diff --git a/traversals/binary_tree_traversals.py b/traversals/binary_tree_traversals.py index 31a73ae0c6a4..c522ecebc0ff 100644 --- a/traversals/binary_tree_traversals.py +++ b/traversals/binary_tree_traversals.py @@ -1,5 +1,5 @@ """ -This is pure python implementation of tree traversal algorithms +This is pure Python implementation of tree traversal algorithms """ import queue from typing import List From 5e8e686c606b97e39486172d8bf0abe78bcc90af Mon Sep 17 00:00:00 2001 From: matkosoric Date: Tue, 3 Mar 2020 22:35:30 +0100 Subject: [PATCH 09/15] explicit cast to int --- sorts/comb_sort.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sorts/comb_sort.py b/sorts/comb_sort.py index 11c31a55f277..ef4377cb9be2 100644 --- a/sorts/comb_sort.py +++ b/sorts/comb_sort.py @@ -37,7 +37,7 @@ def comb_sort(data: list) -> list: while not completed: # Update the gap value for a next comb - gap //= shrink_factor + gap = int(gap / shrink_factor) if gap <= 1: completed = True From 1562b40c97101a0428e1b1f611e05a07fea983c3 Mon Sep 17 00:00:00 2001 From: matkosoric Date: Wed, 4 Mar 2020 11:39:06 +0100 Subject: [PATCH 10/15] spaces in int list --- sorts/comb_sort.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sorts/comb_sort.py b/sorts/comb_sort.py index ef4377cb9be2..83c299994508 100644 --- a/sorts/comb_sort.py +++ b/sorts/comb_sort.py @@ -27,7 +27,7 @@ def comb_sort(data: list) -> list: [0, 2, 2, 3, 5] >>> comb_sort([]) [] - >>> comb_sort([99,45,-7,8,2,0,-15,3]) + >>> comb_sort([99, 45, -7, 8, 2, 0, -15, 3]) [-15, -7, 0, 2, 3, 8, 45, 99] """ shrink_factor = 1.3 From 4961b7cfbf6f12f5543424a0fb5d3d02502d13b7 Mon Sep 17 00:00:00 2001 From: matkosoric Date: Wed, 4 Mar 2020 11:42:14 +0100 Subject: [PATCH 11/15] "!= None" to "is not None" --- data_structures/linked_list/deque_doubly.py | 2 +- data_structures/linked_list/doubly_linked_list.py | 2 +- dynamic_programming/fibonacci.py | 2 +- hashes/hamming_code.py | 4 ++-- project_euler/problem_551/sol1.py | 4 ++-- sorts/odd_even_transposition_parallel.py | 4 ++-- 6 files changed, 9 insertions(+), 9 deletions(-) diff --git a/data_structures/linked_list/deque_doubly.py b/data_structures/linked_list/deque_doubly.py index 0898db679802..b2e73a8f789b 100644 --- a/data_structures/linked_list/deque_doubly.py +++ b/data_structures/linked_list/deque_doubly.py @@ -21,7 +21,7 @@ def __init__(self, link_p, element, link_n): def has_next_and_prev(self): return " Prev -> {0}, Next -> {1}".format( - self._prev != None, self._next != None + self._prev is not None, self._next is not None ) def __init__(self): diff --git a/data_structures/linked_list/doubly_linked_list.py b/data_structures/linked_list/doubly_linked_list.py index 27b04ed39ad2..f8f652be6d32 100644 --- a/data_structures/linked_list/doubly_linked_list.py +++ b/data_structures/linked_list/doubly_linked_list.py @@ -62,7 +62,7 @@ def isEmpty(self): # Will return True if the list is empty def display(self): # Prints contents of the list current = self.head - while current != None: + while current is not None: current.displayLink() current = current.next print() diff --git a/dynamic_programming/fibonacci.py b/dynamic_programming/fibonacci.py index 923560b54d30..45319269f5d4 100644 --- a/dynamic_programming/fibonacci.py +++ b/dynamic_programming/fibonacci.py @@ -28,7 +28,7 @@ def get(self, sequence_no=None): [0, 1, 1, 2, 3, 5] [] """ - if sequence_no != None: + if sequence_no is not None: if sequence_no < len(self.fib_array): return print(self.fib_array[: sequence_no + 1]) else: diff --git a/hashes/hamming_code.py b/hashes/hamming_code.py index 756ba7c6670f..c1ed7fe1d727 100644 --- a/hashes/hamming_code.py +++ b/hashes/hamming_code.py @@ -121,7 +121,7 @@ def emitterConverter(sizePar, data): # counter to control the loop reading contLoop = 0 for x in dataOrd: - if x != None: + if x is not None: try: aux = (binPos[contLoop])[-1 * (bp)] except IndexError: @@ -224,7 +224,7 @@ def receptorConverter(sizePar, data): # Counter to control loop reading contLoop = 0 for x in dataOrd: - if x != None: + if x is not None: try: aux = (binPos[contLoop])[-1 * (bp)] except IndexError: diff --git a/project_euler/problem_551/sol1.py b/project_euler/problem_551/sol1.py index 4775800693bc..873e520cc9b4 100644 --- a/project_euler/problem_551/sol1.py +++ b/project_euler/problem_551/sol1.py @@ -52,10 +52,10 @@ def next_term(a_i, k, i, n): sub_memo = memo.get(ds_b) - if sub_memo != None: + if sub_memo is not None: jumps = sub_memo.get(c) - if jumps != None and len(jumps) > 0: + if jumps is not None and len(jumps) > 0: # find and make the largest jump without going over max_jump = -1 for _k in range(len(jumps) - 1, -1, -1): diff --git a/sorts/odd_even_transposition_parallel.py b/sorts/odd_even_transposition_parallel.py index 080c86af5a8c..33ebb9ea67e7 100644 --- a/sorts/odd_even_transposition_parallel.py +++ b/sorts/odd_even_transposition_parallel.py @@ -35,7 +35,7 @@ def oeProcess(position, value, LSend, RSend, LRcv, RRcv, resultPipe): # find out we are sorted as it does to sort the list with this algorithm for i in range(0, 10): - if (i + position) % 2 == 0 and RSend != None: + if (i + position) % 2 == 0 and RSend is not None: # send your value to your right neighbor processLock.acquire() RSend[1].send(value) @@ -48,7 +48,7 @@ def oeProcess(position, value, LSend, RSend, LRcv, RRcv, resultPipe): # take the lower value since you are on the left value = min(value, temp) - elif (i + position) % 2 != 0 and LSend != None: + elif (i + position) % 2 != 0 and LSend is not None: # send your value to your left neighbor processLock.acquire() LSend[1].send(value) From 37227296f51c358c8a2c0cfca4c3652bc1e89b05 Mon Sep 17 00:00:00 2001 From: John Law Date: Wed, 4 Mar 2020 12:18:35 +0100 Subject: [PATCH 12/15] Update comb_sort.py --- sorts/comb_sort.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/sorts/comb_sort.py b/sorts/comb_sort.py index ef4377cb9be2..c36bb8e63748 100644 --- a/sorts/comb_sort.py +++ b/sorts/comb_sort.py @@ -27,7 +27,7 @@ def comb_sort(data: list) -> list: [0, 2, 2, 3, 5] >>> comb_sort([]) [] - >>> comb_sort([99,45,-7,8,2,0,-15,3]) + >>> comb_sort([99, 45, -7, 8, 2, 0, -15, 3]) [-15, -7, 0, 2, 3, 8, 45, 99] """ shrink_factor = 1.3 @@ -53,7 +53,6 @@ def comb_sort(data: list) -> list: if __name__ == "__main__": - import doctest doctest.testmod() From 1c370608df8d82cd85aa498926a29b876d0ecbf6 Mon Sep 17 00:00:00 2001 From: matkosoric Date: Wed, 4 Mar 2020 12:46:03 +0100 Subject: [PATCH 13/15] various spelling corrections in documentation & several variables naming conventions fix --- backtracking/n_queens.py | 4 +-- ciphers/onepad_cipher.py | 4 +-- .../binary_tree/binary_search_tree.py | 36 +++++++++---------- .../number_of_possible_binary_trees.py | 2 +- divide_and_conquer/convex_hull.py | 12 +++---- dynamic_programming/bitmask.py | 26 +++++++------- graphs/bellman_ford.py | 2 +- ...irected_and_undirected_(weighted)_graph.py | 2 +- graphs/minimum_spanning_tree_prims.py | 32 ++++++++--------- graphs/multi_heuristic_astar.py | 36 +++++++------------ maths/3n+1.py | 2 +- maths/average_mode.py | 2 +- maths/basic_maths.py | 2 +- maths/explicit_euler.py | 8 ++--- maths/factorial_iterative.py | 2 +- other/anagrams.py | 4 +-- other/autocomplete_using_trie.py | 6 ++-- other/fischer_yates_shuffle.py | 12 +++---- project_euler/problem_04/sol2.py | 2 +- project_euler/problem_07/sol1.py | 6 ++-- scripts/build_directory_md.py | 10 +++--- searches/simulated_annealing.py | 4 +-- sorts/bitonic_sort.py | 22 ++++++------ sorts/bogo_sort.py | 11 ++++-- sorts/odd_even_transposition_parallel.py | 2 +- web_programming/emails_from_url.py | 2 -- 26 files changed, 123 insertions(+), 130 deletions(-) diff --git a/backtracking/n_queens.py b/backtracking/n_queens.py index c0db41496aee..58d9c4279a35 100644 --- a/backtracking/n_queens.py +++ b/backtracking/n_queens.py @@ -42,7 +42,7 @@ def solve(board, row): """ It creates a state space tree and calls the safe function until it receives a False Boolean and terminates that branch and backtracks to the next - poosible solution branch. + possible solution branch. """ if row >= len(board): """ @@ -56,7 +56,7 @@ def solve(board, row): return for i in range(len(board)): """ - For every row it iterates through each column to check if it is feesible to place a + For every row it iterates through each column to check if it is feasible to place a queen there. If all the combinations for that particular branch are successful the board is reinitialized for the next possible combination. diff --git a/ciphers/onepad_cipher.py b/ciphers/onepad_cipher.py index 5a410bfa638a..fe07908afff5 100644 --- a/ciphers/onepad_cipher.py +++ b/ciphers/onepad_cipher.py @@ -3,7 +3,7 @@ class Onepad: def encrypt(self, text): - """Function to encrypt text using psedo-random numbers""" + """Function to encrypt text using pseudo-random numbers""" plain = [ord(i) for i in text] key = [] cipher = [] @@ -15,7 +15,7 @@ def encrypt(self, text): return cipher, key def decrypt(self, cipher, key): - """Function to decrypt text using psedo-random numbers.""" + """Function to decrypt text using pseudo-random numbers.""" plain = [] for i in range(len(key)): p = int((cipher[i] - (key[i]) ** 2) / key[i]) diff --git a/data_structures/binary_tree/binary_search_tree.py b/data_structures/binary_tree/binary_search_tree.py index 86dcd6489bd5..40546875216b 100644 --- a/data_structures/binary_tree/binary_search_tree.py +++ b/data_structures/binary_tree/binary_search_tree.py @@ -28,16 +28,16 @@ def __str__(self): """ return str(self.root) - def __reassign_nodes(self, node, newChildren): - if newChildren is not None: # reset its kids - newChildren.parent = node.parent + def __reassign_nodes(self, node, new_children): + if new_children is not None: # reset its kids + new_children.parent = node.parent if node.parent is not None: # reset its parent if self.is_right(node): # If it is the right children - node.parent.right = newChildren + node.parent.right = new_children else: - node.parent.left = newChildren + node.parent.left = new_children else: - self.root = newChildren + self.root = new_children def is_right(self, node): return node == node.parent.right @@ -117,39 +117,39 @@ def remove(self, value): elif node.right is None: # Has only left children self.__reassign_nodes(node, node.left) else: - tmpNode = self.get_max( + tmp_node = self.get_max( node.left - ) # Gets the max value of the left branch - self.remove(tmpNode.value) + ) # Gets the max value of the left branch + self.remove(tmp_node.value) node.value = ( - tmpNode.value - ) # Assigns the value to the node to delete and keesp tree structure + tmp_node.value + ) # Assigns the value to the node to delete and keep tree structure def preorder_traverse(self, node): if node is not None: - yield node # Preorder Traversal + yield node # Preorder Traversal yield from self.preorder_traverse(node.left) yield from self.preorder_traverse(node.right) - def traversal_tree(self, traversalFunction=None): + def traversal_tree(self, traversal_function=None): """ This function traversal the tree. You can pass a function to traversal the tree as needed by client code """ - if traversalFunction is None: + if traversal_function is None: return self.preorder_traverse(self.root) else: - return traversalFunction(self.root) + return traversal_function(self.root) def postorder(curr_node): """ postOrder (left, right, self) """ - nodeList = list() + node_list = list() if curr_node is not None: - nodeList = postorder(curr_node.left) + postorder(curr_node.right) + [curr_node] - return nodeList + node_list = postorder(curr_node.left) + postorder(curr_node.right) + [curr_node] + return node_list def binary_search_tree(): diff --git a/data_structures/binary_tree/number_of_possible_binary_trees.py b/data_structures/binary_tree/number_of_possible_binary_trees.py index d053ba31171f..1ad8f2ed4287 100644 --- a/data_structures/binary_tree/number_of_possible_binary_trees.py +++ b/data_structures/binary_tree/number_of_possible_binary_trees.py @@ -82,7 +82,7 @@ def binary_tree_count(node_count: int) -> int: """ Return the number of possible of binary trees. :param n: number of nodes - :return: Number of possilble binary trees + :return: Number of possible binary trees >>> binary_tree_count(5) 5040 diff --git a/divide_and_conquer/convex_hull.py b/divide_and_conquer/convex_hull.py index 76184524e266..11b16975c8b4 100644 --- a/divide_and_conquer/convex_hull.py +++ b/divide_and_conquer/convex_hull.py @@ -344,19 +344,19 @@ def convex_hull_recursive(points): right_most_point = points[n - 1] convex_set = {left_most_point, right_most_point} - upperhull = [] - lowerhull = [] + upper_hull = [] + lower_hull = [] for i in range(1, n - 1): det = _det(left_most_point, right_most_point, points[i]) if det > 0: - upperhull.append(points[i]) + upper_hull.append(points[i]) elif det < 0: - lowerhull.append(points[i]) + lower_hull.append(points[i]) - _construct_hull(upperhull, left_most_point, right_most_point, convex_set) - _construct_hull(lowerhull, right_most_point, left_most_point, convex_set) + _construct_hull(upper_hull, left_most_point, right_most_point, convex_set) + _construct_hull(lower_hull, right_most_point, left_most_point, convex_set) return sorted(convex_set) diff --git a/dynamic_programming/bitmask.py b/dynamic_programming/bitmask.py index e0e3f74489e4..625a0809c4b9 100644 --- a/dynamic_programming/bitmask.py +++ b/dynamic_programming/bitmask.py @@ -25,41 +25,41 @@ def __init__(self, task_performed, total): self.task = defaultdict(list) # stores the list of persons for each task - # finalmask is used to check if all persons are included by setting all bits to 1 - self.finalmask = (1 << len(task_performed)) - 1 + # final_mask is used to check if all persons are included by setting all bits to 1 + self.final_mask = (1 << len(task_performed)) - 1 - def CountWaysUtil(self, mask, taskno): + def CountWaysUtil(self, mask, task_no): # if mask == self.finalmask all persons are distributed tasks, return 1 - if mask == self.finalmask: + if mask == self.final_mask: return 1 # if not everyone gets the task and no more tasks are available, return 0 - if taskno > self.total_tasks: + if task_no > self.total_tasks: return 0 # if case already considered - if self.dp[mask][taskno] != -1: - return self.dp[mask][taskno] + if self.dp[mask][task_no] != -1: + return self.dp[mask][task_no] # Number of ways when we don't this task in the arrangement - total_ways_util = self.CountWaysUtil(mask, taskno + 1) + total_ways_util = self.CountWaysUtil(mask, task_no + 1) # now assign the tasks one by one to all possible persons and recursively assign for the remaining tasks. - if taskno in self.task: - for p in self.task[taskno]: + if task_no in self.task: + for p in self.task[task_no]: # if p is already given a task if mask & (1 << p): continue # assign this task to p and change the mask value. And recursively assign tasks with the new mask value. - total_ways_util += self.CountWaysUtil(mask | (1 << p), taskno + 1) + total_ways_util += self.CountWaysUtil(mask | (1 << p), task_no + 1) # save the value. - self.dp[mask][taskno] = total_ways_util + self.dp[mask][task_no] = total_ways_util - return self.dp[mask][taskno] + return self.dp[mask][task_no] def countNoOfWays(self, task_performed): diff --git a/graphs/bellman_ford.py b/graphs/bellman_ford.py index 6b5e8b735c43..807e0b0fcdb9 100644 --- a/graphs/bellman_ford.py +++ b/graphs/bellman_ford.py @@ -8,7 +8,7 @@ def printDist(dist, V): def BellmanFord(graph: List[Dict[str, int]], V: int, E: int, src: int) -> int: - r""" + """ Returns shortest paths from a vertex src to all other vertices. """ diff --git a/graphs/directed_and_undirected_(weighted)_graph.py b/graphs/directed_and_undirected_(weighted)_graph.py index 15e2ce663594..26c87cd8f4b2 100644 --- a/graphs/directed_and_undirected_(weighted)_graph.py +++ b/graphs/directed_and_undirected_(weighted)_graph.py @@ -3,7 +3,7 @@ import math as math import time -# the dfault weight is 1 if not assigned but all the implementation is weighted +# the default weight is 1 if not assigned but all the implementation is weighted class DirectedGraph: diff --git a/graphs/minimum_spanning_tree_prims.py b/graphs/minimum_spanning_tree_prims.py index 216d6a3f56de..6255b6af64ad 100644 --- a/graphs/minimum_spanning_tree_prims.py +++ b/graphs/minimum_spanning_tree_prims.py @@ -6,13 +6,13 @@ def PrimsAlgorithm(l): nodePosition = [] - def getPosition(vertex): + def get_position(vertex): return nodePosition[vertex] - def setPosition(vertex, pos): + def set_position(vertex, pos): nodePosition[vertex] = pos - def topToBottom(heap, start, size, positions): + def top_to_bottom(heap, start, size, positions): if start > size // 2 - 1: return else: @@ -28,14 +28,14 @@ def topToBottom(heap, start, size, positions): heap[m], positions[m] = heap[start], positions[start] heap[start], positions[start] = temp, temp1 - temp = getPosition(positions[m]) - setPosition(positions[m], getPosition(positions[start])) - setPosition(positions[start], temp) + temp = get_position(positions[m]) + set_position(positions[m], get_position(positions[start])) + set_position(positions[start], temp) - topToBottom(heap, m, size, positions) + top_to_bottom(heap, m, size, positions) # Update function if value of any node in min-heap decreases - def bottomToTop(val, index, heap, position): + def bottom_to_top(val, index, heap, position): temp = position[index] while index != 0: @@ -47,27 +47,27 @@ def bottomToTop(val, index, heap, position): if val < heap[parent]: heap[index] = heap[parent] position[index] = position[parent] - setPosition(position[parent], index) + set_position(position[parent], index) else: heap[index] = val position[index] = temp - setPosition(temp, index) + set_position(temp, index) break index = parent else: heap[0] = val position[0] = temp - setPosition(temp, 0) + set_position(temp, 0) def heapify(heap, positions): start = len(heap) // 2 - 1 for i in range(start, -1, -1): - topToBottom(heap, i, len(heap), positions) + top_to_bottom(heap, i, len(heap), positions) def deleteMinimum(heap, positions): temp = positions[0] heap[0] = sys.maxsize - topToBottom(heap, 0, len(heap), positions) + top_to_bottom(heap, 0, len(heap), positions) return temp visited = [0 for i in range(len(l))] @@ -96,9 +96,9 @@ def deleteMinimum(heap, positions): TreeEdges.append((Nbr_TV[vertex], vertex)) visited[vertex] = 1 for v in l[vertex]: - if visited[v[0]] == 0 and v[1] < Distance_TV[getPosition(v[0])]: - Distance_TV[getPosition(v[0])] = v[1] - bottomToTop(v[1], getPosition(v[0]), Distance_TV, Positions) + if visited[v[0]] == 0 and v[1] < Distance_TV[get_position(v[0])]: + Distance_TV[get_position(v[0])] = v[1] + bottom_to_top(v[1], get_position(v[0]), Distance_TV, Positions) Nbr_TV[v[0]] = vertex return TreeEdges diff --git a/graphs/multi_heuristic_astar.py b/graphs/multi_heuristic_astar.py index 56cfc727d338..386aab695bb0 100644 --- a/graphs/multi_heuristic_astar.py +++ b/graphs/multi_heuristic_astar.py @@ -52,25 +52,25 @@ def get(self): return (priority, item) -def consistent_hueristic(P, goal): +def consistent_heuristic(P, goal): # euclidean distance a = np.array(P) b = np.array(goal) return np.linalg.norm(a - b) -def hueristic_2(P, goal): +def heuristic_2(P, goal): # integer division by time variable - return consistent_hueristic(P, goal) // t + return consistent_heuristic(P, goal) // t -def hueristic_1(P, goal): +def heuristic_1(P, goal): # manhattan distance return abs(P[0] - goal[0]) + abs(P[1] - goal[1]) def key(start, i, goal, g_function): - ans = g_function[start] + W1 * hueristics[i](start, goal) + ans = g_function[start] + W1 * heuristics[i](start, goal) return ans @@ -134,7 +134,7 @@ def expand_state( open_list, back_pointer, ): - for itera in range(n_hueristic): + for itera in range(n_heuristic): open_list[itera].remove_element(s) # print("s", s) # print("j", j) @@ -158,30 +158,24 @@ def expand_state( if neighbours not in close_list_anchor: open_list[0].put(neighbours, key(neighbours, 0, goal, g_function)) if neighbours not in close_list_inad: - for var in range(1, n_hueristic): + for var in range(1, n_heuristic): if key(neighbours, var, goal, g_function) <= W2 * key( neighbours, 0, goal, g_function ): - # print("why not plssssssssss") open_list[j].put( neighbours, key(neighbours, var, goal, g_function) ) - # print - def make_common_ground(): some_list = [] - # block 1 for x in range(1, 5): for y in range(1, 6): some_list.append((x, y)) - # line for x in range(15, 20): some_list.append((x, 17)) - # block 2 big for x in range(10, 19): for y in range(1, 15): some_list.append((x, y)) @@ -196,7 +190,7 @@ def make_common_ground(): return some_list -hueristics = {0: consistent_hueristic, 1: hueristic_1, 2: hueristic_2} +heuristics = {0: consistent_heuristic, 1: heuristic_1, 2: heuristic_2} blocks_blk = [ (0, 1), @@ -229,7 +223,7 @@ def make_common_ground(): W1 = 1 W2 = 1 n = 20 -n_hueristic = 3 # one consistent and two other inconsistent +n_heuristic = 3 # one consistent and two other inconsistent # start and end destination start = (0, 0) @@ -238,26 +232,24 @@ def make_common_ground(): t = 1 -def multi_a_star(start, goal, n_hueristic): +def multi_a_star(start, goal, n_heuristic): g_function = {start: 0, goal: float("inf")} back_pointer = {start: -1, goal: -1} open_list = [] visited = set() - for i in range(n_hueristic): + for i in range(n_heuristic): open_list.append(PriorityQueue()) open_list[i].put(start, key(start, i, goal, g_function)) close_list_anchor = [] close_list_inad = [] while open_list[0].minkey() < float("inf"): - for i in range(1, n_hueristic): - # print("i", i) + for i in range(1, n_heuristic): # print(open_list[0].minkey(), open_list[i].minkey()) if open_list[i].minkey() <= W2 * open_list[0].minkey(): global t t += 1 - # print("less prio") if g_function[goal] <= open_list[i].minkey(): if g_function[goal] < float("inf"): do_something(back_pointer, goal, start) @@ -276,12 +268,10 @@ def multi_a_star(start, goal, n_hueristic): ) close_list_inad.append(get_s) else: - # print("more prio") if g_function[goal] <= open_list[0].minkey(): if g_function[goal] < float("inf"): do_something(back_pointer, goal, start) else: - # print("hoolla") get_s = open_list[0].top_show() visited.add(get_s) expand_state( @@ -319,4 +309,4 @@ def multi_a_star(start, goal, n_hueristic): if __name__ == "__main__": - multi_a_star(start, goal, n_hueristic) + multi_a_star(start, goal, n_heuristic) diff --git a/maths/3n+1.py b/maths/3n+1.py index 64ff34fd2039..7e5a431326bc 100644 --- a/maths/3n+1.py +++ b/maths/3n+1.py @@ -3,7 +3,7 @@ def n31(a: int) -> Tuple[List[int], int]: """ - Returns the Collatz sequence and its length of any postiver integer. + Returns the Collatz sequence and its length of any postive integer. >>> n31(4) ([4, 2, 1], 3) """ diff --git a/maths/average_mode.py b/maths/average_mode.py index c1a4b3521448..d472dc04d4bf 100644 --- a/maths/average_mode.py +++ b/maths/average_mode.py @@ -14,7 +14,7 @@ def mode(input_list): # Defining function "mode." >>> mode(input_list) == statistics.mode(input_list) True """ - # Copying inputlist to check with the index number later. + # Copying input_list to check with the index number later. check_list = input_list.copy() result = list() # Empty list to store the counts of elements in input_list for x in input_list: diff --git a/maths/basic_maths.py b/maths/basic_maths.py index 5dbfd250d308..07ee3b3df296 100644 --- a/maths/basic_maths.py +++ b/maths/basic_maths.py @@ -63,7 +63,7 @@ def sum_of_divisors(n: int) -> int: def euler_phi(n: int) -> int: - """Calculte Euler's Phi Function. + """Calculate Euler's Phi Function. >>> euler_phi(100) 40 """ diff --git a/maths/explicit_euler.py b/maths/explicit_euler.py index 8a43d71fb432..7c780198602b 100644 --- a/maths/explicit_euler.py +++ b/maths/explicit_euler.py @@ -1,7 +1,7 @@ import numpy as np -def explicit_euler(ode_func, y0, x0, stepsize, x_end): +def explicit_euler(ode_func, y0, x0, step_size, x_end): """ Calculate numeric solution at each step to an ODE using Euler's Method @@ -22,14 +22,14 @@ def explicit_euler(ode_func, y0, x0, stepsize, x_end): >>> y[-1] 144.77277243257308 """ - N = int(np.ceil((x_end - x0) / stepsize)) + N = int(np.ceil((x_end - x0) / step_size)) y = np.zeros((N + 1,)) y[0] = y0 x = x0 for k in range(N): - y[k + 1] = y[k] + stepsize * ode_func(x, y[k]) - x += stepsize + y[k + 1] = y[k] + step_size * ode_func(x, y[k]) + x += step_size return y diff --git a/maths/factorial_iterative.py b/maths/factorial_iterative.py index 249408cb5b4e..64314790c11c 100644 --- a/maths/factorial_iterative.py +++ b/maths/factorial_iterative.py @@ -26,5 +26,5 @@ def factorial(n: int) -> int: if __name__ == "__main__": - n = int(input("Enter a positivve integer: ").strip() or 0) + n = int(input("Enter a positive integer: ").strip() or 0) print(f"factorial{n} is {factorial(n)}") diff --git a/other/anagrams.py b/other/anagrams.py index 6e6806e92a0f..471413194498 100644 --- a/other/anagrams.py +++ b/other/anagrams.py @@ -16,8 +16,8 @@ def signature(word): word_bysig[signature(word)].append(word) -def anagram(myword): - return word_bysig[signature(myword)] +def anagram(my_word): + return word_bysig[signature(my_word)] print("finding anagrams...") diff --git a/other/autocomplete_using_trie.py b/other/autocomplete_using_trie.py index eb906f8efa9a..8aa0dc223680 100644 --- a/other/autocomplete_using_trie.py +++ b/other/autocomplete_using_trie.py @@ -26,10 +26,10 @@ def _elements(self, d): result = [] for c, v in d.items(): if c == END: - subresult = [" "] + sub_result = [" "] else: - subresult = [c + s for s in self._elements(v)] - result.extend(subresult) + sub_result = [c + s for s in self._elements(v)] + result.extend(sub_result) return tuple(result) diff --git a/other/fischer_yates_shuffle.py b/other/fischer_yates_shuffle.py index 4217cb0bef67..99121ba632c7 100644 --- a/other/fischer_yates_shuffle.py +++ b/other/fischer_yates_shuffle.py @@ -7,12 +7,12 @@ import random -def FYshuffle(LIST): - for i in range(len(LIST)): - a = random.randint(0, len(LIST) - 1) - b = random.randint(0, len(LIST) - 1) - LIST[a], LIST[b] = LIST[b], LIST[a] - return LIST +def FYshuffle(list): + for i in range(len(list)): + a = random.randint(0, len(list) - 1) + b = random.randint(0, len(list) - 1) + list[a], list[b] = list[b], list[a] + return list if __name__ == "__main__": diff --git a/project_euler/problem_04/sol2.py b/project_euler/problem_04/sol2.py index ecc503912c34..0f185f1216ab 100644 --- a/project_euler/problem_04/sol2.py +++ b/project_euler/problem_04/sol2.py @@ -20,7 +20,7 @@ def solution(n): 39893 """ answer = 0 - for i in range(999, 99, -1): # 3 digit nimbers range from 999 down to 100 + for i in range(999, 99, -1): # 3 digit numbers range from 999 down to 100 for j in range(999, 99, -1): t = str(i * j) if t == t[::-1] and i * j < n: diff --git a/project_euler/problem_07/sol1.py b/project_euler/problem_07/sol1.py index f6b2584d9cdc..373915f886e1 100644 --- a/project_euler/problem_07/sol1.py +++ b/project_euler/problem_07/sol1.py @@ -8,7 +8,7 @@ from math import sqrt -def isprime(n): +def is_prime(n): if n == 2: return True elif n % 2 == 0: @@ -41,11 +41,11 @@ def solution(n): j = 1 while i != n and j < 3: j += 1 - if isprime(j): + if is_prime(j): i += 1 while i != n: j += 2 - if isprime(j): + if is_prime(j): i += 1 return j diff --git a/scripts/build_directory_md.py b/scripts/build_directory_md.py index 1043e6ccb696..9e26ee81a323 100755 --- a/scripts/build_directory_md.py +++ b/scripts/build_directory_md.py @@ -6,14 +6,14 @@ URL_BASE = "https://github.com/TheAlgorithms/Python/blob/master" -def good_filepaths(top_dir: str = ".") -> Iterator[str]: - for dirpath, dirnames, filenames in os.walk(top_dir): - dirnames[:] = [d for d in dirnames if d != "scripts" and d[0] not in "._"] +def good_file_paths(top_dir: str = ".") -> Iterator[str]: + for dir_path, dir_names, filenames in os.walk(top_dir): + dir_names[:] = [d for d in dir_names if d != "scripts" and d[0] not in "._"] for filename in filenames: if filename == "__init__.py": continue if os.path.splitext(filename)[1] in (".py", ".ipynb"): - yield os.path.join(dirpath, filename).lstrip("./") + yield os.path.join(dir_path, filename).lstrip("./") def md_prefix(i): @@ -31,7 +31,7 @@ def print_path(old_path: str, new_path: str) -> str: def print_directory_md(top_dir: str = ".") -> None: old_path = "" - for filepath in sorted(good_filepaths()): + for filepath in sorted(good_file_paths()): filepath, filename = os.path.split(filepath) if filepath != old_path: old_path = print_path(old_path, filepath) diff --git a/searches/simulated_annealing.py b/searches/simulated_annealing.py index 994f139dfcb6..c24adc1ddb41 100644 --- a/searches/simulated_annealing.py +++ b/searches/simulated_annealing.py @@ -66,10 +66,10 @@ def simulated_annealing( if change > 0: # improves the solution next_state = picked_neighbor else: - probabililty = (math.e) ** ( + probability = (math.e) ** ( change / current_temp ) # probability generation function - if random.random() < probabililty: # random number within probability + if random.random() < probability: # random number within probability next_state = picked_neighbor current_temp = current_temp - (current_temp * rate_of_decrease) diff --git a/sorts/bitonic_sort.py b/sorts/bitonic_sort.py index 131f97291fbb..ce80c6028729 100644 --- a/sorts/bitonic_sort.py +++ b/sorts/bitonic_sort.py @@ -14,36 +14,36 @@ def compAndSwap(a, i, j, dire): # if dir = 1, and in descending order otherwise (means dir=0). # The sequence to be sorted starts at index position low, # the parameter cnt is the number of elements to be sorted. -def bitonicMerge(a, low, cnt, dire): +def bitonic_merge(a, low, cnt, dire): if cnt > 1: k = int(cnt / 2) for i in range(low, low + k): compAndSwap(a, i, i + k, dire) - bitonicMerge(a, low, k, dire) - bitonicMerge(a, low + k, k, dire) + bitonic_merge(a, low, k, dire) + bitonic_merge(a, low + k, k, dire) # This function first produces a bitonic sequence by recursively # sorting its two halves in opposite sorting orders, and then -# calls bitonicMerge to make them in the same order -def bitonicSort(a, low, cnt, dire): +# calls bitonic_merge to make them in the same order +def bitonic_sort(a, low, cnt, dire): if cnt > 1: k = int(cnt / 2) - bitonicSort(a, low, k, 1) - bitonicSort(a, low + k, k, 0) - bitonicMerge(a, low, cnt, dire) + bitonic_sort(a, low, k, 1) + bitonic_sort(a, low + k, k, 0) + bitonic_merge(a, low, cnt, dire) - # Caller of bitonicSort for sorting the entire array of length N + # Caller of bitonic_sort for sorting the entire array of length N # in ASCENDING order def sort(a, N, up): - bitonicSort(a, 0, N, up) + bitonic_sort(a, 0, N, up) if __name__ == "__main__": - # Driver code to test above + a = [] n = int(input().strip()) diff --git a/sorts/bogo_sort.py b/sorts/bogo_sort.py index 798ff619a6d7..b72f2089f3d2 100644 --- a/sorts/bogo_sort.py +++ b/sorts/bogo_sort.py @@ -1,5 +1,10 @@ """ -This is a pure Python implementation of the bogosort algorithm +This is a pure Python implementation of the bogosort algorithm, +also known as permutation sort, stupid sort, slowsort, shotgun sort, or monkey sort. +Bogosort generates random permutations until it guesses the correct one. + +More info on: https://en.wikipedia.org/wiki/Bogosort + For doctests run following command: python -m doctest -v bogo_sort.py or @@ -25,7 +30,7 @@ def bogo_sort(collection): [-45, -5, -2] """ - def isSorted(collection): + def is_sorted(collection): if len(collection) < 2: return True for i in range(len(collection) - 1): @@ -33,7 +38,7 @@ def isSorted(collection): return False return True - while not isSorted(collection): + while not is_sorted(collection): random.shuffle(collection) return collection diff --git a/sorts/odd_even_transposition_parallel.py b/sorts/odd_even_transposition_parallel.py index 33ebb9ea67e7..5de7a016c628 100644 --- a/sorts/odd_even_transposition_parallel.py +++ b/sorts/odd_even_transposition_parallel.py @@ -18,7 +18,7 @@ """ The function run by the processes that sorts the list -position = the position in the list the prcoess represents, used to know which +position = the position in the list the process represents, used to know which neighbor we pass our value to value = the initial value at list[position] LSend, RSend = the pipes we use to send to our left and right neighbors diff --git a/web_programming/emails_from_url.py b/web_programming/emails_from_url.py index fba9f769bace..01dee274f015 100644 --- a/web_programming/emails_from_url.py +++ b/web_programming/emails_from_url.py @@ -51,8 +51,6 @@ def get_domain_name(url: str) -> str: # Get sub domain name (sub.example.com) def get_sub_domain_name(url: str) -> str: """ - This function get sub domin name - >>> get_sub_domain_name("https://a.b.c.d/e/f?g=h,i=j#k") 'a.b.c.d' >>> get_sub_domain_name("Not a URL!") From 88668314d4b7822c36083f386abda3e750a367a3 Mon Sep 17 00:00:00 2001 From: matkosoric Date: Wed, 4 Mar 2020 12:59:38 +0100 Subject: [PATCH 14/15] + char in file name --- DIRECTORY.md | 2 +- maths/{3n+1.py => 3n_plus_1.py} | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) rename maths/{3n+1.py => 3n_plus_1.py} (97%) diff --git a/DIRECTORY.md b/DIRECTORY.md index 91a5ab7f6a99..48c1dde9ab67 100644 --- a/DIRECTORY.md +++ b/DIRECTORY.md @@ -263,7 +263,7 @@ * [Support Vector Machines](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/support_vector_machines.py) ## Maths - * [3N+1](https://github.com/TheAlgorithms/Python/blob/master/maths/3n+1.py) + * [3N+1](https://github.com/TheAlgorithms/Python/blob/master/maths/3n_plus_1.py) * [Abs](https://github.com/TheAlgorithms/Python/blob/master/maths/abs.py) * [Abs Max](https://github.com/TheAlgorithms/Python/blob/master/maths/abs_max.py) * [Abs Min](https://github.com/TheAlgorithms/Python/blob/master/maths/abs_min.py) diff --git a/maths/3n+1.py b/maths/3n_plus_1.py similarity index 97% rename from maths/3n+1.py rename to maths/3n_plus_1.py index 7e5a431326bc..d3684561827f 100644 --- a/maths/3n+1.py +++ b/maths/3n_plus_1.py @@ -3,7 +3,7 @@ def n31(a: int) -> Tuple[List[int], int]: """ - Returns the Collatz sequence and its length of any postive integer. + Returns the Collatz sequence and its length of any positive integer. >>> n31(4) ([4, 2, 1], 3) """ From 3e840390bc771df7a7746f257ce5e04174718b7e Mon Sep 17 00:00:00 2001 From: matkosoric Date: Wed, 4 Mar 2020 13:11:03 +0100 Subject: [PATCH 15/15] import dependency - bug fix --- scripts/validate_filenames.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/scripts/validate_filenames.py b/scripts/validate_filenames.py index 51dd6a40cb41..f22fda4149f3 100755 --- a/scripts/validate_filenames.py +++ b/scripts/validate_filenames.py @@ -1,10 +1,10 @@ #!/usr/bin/env python3 import os -from build_directory_md import good_filepaths +from build_directory_md import good_file_paths -filepaths = list(good_filepaths()) -assert filepaths, "good_filepaths() failed!" +filepaths = list(good_file_paths()) +assert filepaths, "good_file_paths() failed!" upper_files = [file for file in filepaths if file != file.lower()]