From 64543faa980b526f79d287a073ebb7554749faf9 Mon Sep 17 00:00:00 2001
From: Christian Clauss <cclauss@me.com>
Date: Wed, 1 Mar 2023 17:23:33 +0100
Subject: [PATCH] Make some ruff fixes (#8154)
* Make some ruff fixes
* Undo manual fix
* Undo manual fix
* Updates from ruff=0.0.251
---
audio_filters/iir_filter.py | 2 +-
backtracking/n_queens_math.py | 6 +++---
backtracking/sum_of_subsets.py | 2 +-
ciphers/bifid.py | 2 +-
ciphers/diffie_hellman.py | 16 ++++++++--------
ciphers/polybius.py | 2 +-
ciphers/xor_cipher.py | 18 ++++++++----------
computer_vision/mosaic_augmentation.py | 2 +-
.../binary_tree/binary_search_tree.py | 2 +-
.../binary_tree/binary_tree_traversals.py | 4 ++--
.../binary_tree/inorder_tree_traversal_2022.py | 2 +-
data_structures/binary_tree/red_black_tree.py | 5 ++---
.../hashing/number_theory/prime_numbers.py | 2 +-
data_structures/heap/binomial_heap.py | 4 ++--
.../linked_list/doubly_linked_list_two.py | 2 +-
.../linked_list/singly_linked_list.py | 1 +
data_structures/linked_list/skip_list.py | 5 +----
.../queue/circular_queue_linked_list.py | 2 +-
.../dilation_operation.py | 2 +-
.../erosion_operation.py | 2 +-
dynamic_programming/all_construct.py | 2 +-
dynamic_programming/fizz_buzz.py | 2 +-
.../longest_common_subsequence.py | 10 ++--------
.../longest_increasing_subsequence.py | 2 +-
graphs/basic_graphs.py | 14 ++++++--------
graphs/check_cycle.py | 9 ++++-----
graphs/connected_components.py | 2 +-
graphs/dijkstra_algorithm.py | 2 +-
.../edmonds_karp_multiple_source_and_sink.py | 5 ++---
graphs/frequent_pattern_graph_miner.py | 6 +++---
graphs/minimum_spanning_tree_boruvka.py | 1 +
graphs/minimum_spanning_tree_prims.py | 5 +----
graphs/minimum_spanning_tree_prims2.py | 16 +++++++---------
hashes/hamming_code.py | 5 ++---
linear_algebra/src/lib.py | 7 ++++---
machine_learning/gradient_descent.py | 2 ++
machine_learning/k_means_clust.py | 4 ++--
.../sequential_minimum_optimization.py | 9 ++++-----
maths/abs.py | 6 +++---
maths/binary_exp_mod.py | 2 +-
maths/jaccard_similarity.py | 1 +
maths/largest_of_very_large_numbers.py | 1 +
maths/radix2_fft.py | 5 +----
.../back_propagation_neural_network.py | 1 +
other/graham_scan.py | 7 +++----
other/nested_brackets.py | 9 ++++-----
physics/hubble_parameter.py | 4 ++--
project_euler/problem_005/sol1.py | 1 +
project_euler/problem_009/sol1.py | 5 ++---
project_euler/problem_014/sol2.py | 5 +----
project_euler/problem_018/solution.py | 10 ++--------
project_euler/problem_019/sol1.py | 2 +-
project_euler/problem_033/sol1.py | 8 +++-----
project_euler/problem_064/sol1.py | 5 ++---
project_euler/problem_067/sol1.py | 10 ++--------
project_euler/problem_109/sol1.py | 2 +-
project_euler/problem_203/sol1.py | 4 ++--
scheduling/shortest_job_first.py | 11 +++++------
scripts/build_directory_md.py | 5 ++---
searches/binary_tree_traversal.py | 1 +
sorts/circle_sort.py | 13 ++++++-------
sorts/counting_sort.py | 2 +-
sorts/msd_radix_sort.py | 2 +-
sorts/quick_sort.py | 2 +-
sorts/recursive_quick_sort.py | 10 +++++-----
sorts/tim_sort.py | 4 ++--
strings/autocomplete_using_trie.py | 5 +----
strings/check_anagrams.py | 5 +----
strings/is_palindrome.py | 5 +----
strings/snake_case_to_camel_pascal_case.py | 2 +-
web_programming/convert_number_to_words.py | 6 +++---
web_programming/instagram_crawler.py | 2 +-
web_programming/open_google_results.py | 5 +----
73 files changed, 151 insertions(+), 203 deletions(-)
diff --git a/audio_filters/iir_filter.py b/audio_filters/iir_filter.py
index aae32036..bd448175 100644
--- a/audio_filters/iir_filter.py
+++ b/audio_filters/iir_filter.py
@@ -47,7 +47,7 @@ class IIRFilter:
>>> filt.set_coefficients(a_coeffs, b_coeffs)
"""
if len(a_coeffs) < self.order:
- a_coeffs = [1.0] + a_coeffs
+ a_coeffs = [1.0, *a_coeffs]
if len(a_coeffs) != self.order + 1:
raise ValueError(
diff --git a/backtracking/n_queens_math.py b/backtracking/n_queens_math.py
index 23bd1590..f3b08ab0 100644
--- a/backtracking/n_queens_math.py
+++ b/backtracking/n_queens_math.py
@@ -129,9 +129,9 @@ def depth_first_search(
# If it is False we call dfs function again and we update the inputs
depth_first_search(
- possible_board + [col],
- diagonal_right_collisions + [row - col],
- diagonal_left_collisions + [row + col],
+ [*possible_board, col],
+ [*diagonal_right_collisions, row - col],
+ [*diagonal_left_collisions, row + col],
boards,
n,
)
diff --git a/backtracking/sum_of_subsets.py b/backtracking/sum_of_subsets.py
index 128e2907..c5e23321 100644
--- a/backtracking/sum_of_subsets.py
+++ b/backtracking/sum_of_subsets.py
@@ -44,7 +44,7 @@ def create_state_space_tree(
nums,
max_sum,
index + 1,
- path + [nums[index]],
+ [*path, nums[index]],
result,
remaining_nums_sum - nums[index],
)
diff --git a/ciphers/bifid.py b/ciphers/bifid.py
index c005e051..a15b3816 100644
--- a/ciphers/bifid.py
+++ b/ciphers/bifid.py
@@ -33,7 +33,7 @@ class BifidCipher:
>>> np.array_equal(BifidCipher().letter_to_numbers('u'), [4,5])
True
"""
- index1, index2 = np.where(self.SQUARE == letter)
+ index1, index2 = np.where(letter == self.SQUARE)
indexes = np.concatenate([index1 + 1, index2 + 1])
return indexes
diff --git a/ciphers/diffie_hellman.py b/ciphers/diffie_hellman.py
index 072f4aaa..cd40a6b9 100644
--- a/ciphers/diffie_hellman.py
+++ b/ciphers/diffie_hellman.py
@@ -228,10 +228,10 @@ class DiffieHellman:
def is_valid_public_key(self, key: int) -> bool:
# check if the other public key is valid based on NIST SP800-56
- if 2 <= key and key <= self.prime - 2:
- if pow(key, (self.prime - 1) // 2, self.prime) == 1:
- return True
- return False
+ return (
+ 2 <= key <= self.prime - 2
+ and pow(key, (self.prime - 1) // 2, self.prime) == 1
+ )
def generate_shared_key(self, other_key_str: str) -> str:
other_key = int(other_key_str, base=16)
@@ -243,10 +243,10 @@ class DiffieHellman:
@staticmethod
def is_valid_public_key_static(remote_public_key_str: int, prime: int) -> bool:
# check if the other public key is valid based on NIST SP800-56
- if 2 <= remote_public_key_str and remote_public_key_str <= prime - 2:
- if pow(remote_public_key_str, (prime - 1) // 2, prime) == 1:
- return True
- return False
+ return (
+ 2 <= remote_public_key_str <= prime - 2
+ and pow(remote_public_key_str, (prime - 1) // 2, prime) == 1
+ )
@staticmethod
def generate_shared_key_static(
diff --git a/ciphers/polybius.py b/ciphers/polybius.py
index 3539ab70..d83badf4 100644
--- a/ciphers/polybius.py
+++ b/ciphers/polybius.py
@@ -31,7 +31,7 @@ class PolybiusCipher:
>>> np.array_equal(PolybiusCipher().letter_to_numbers('u'), [4,5])
True
"""
- index1, index2 = np.where(self.SQUARE == letter)
+ index1, index2 = np.where(letter == self.SQUARE)
indexes = np.concatenate([index1 + 1, index2 + 1])
return indexes
diff --git a/ciphers/xor_cipher.py b/ciphers/xor_cipher.py
index 379ef0ef..0f369e38 100644
--- a/ciphers/xor_cipher.py
+++ b/ciphers/xor_cipher.py
@@ -128,11 +128,10 @@ class XORCipher:
assert isinstance(file, str) and isinstance(key, int)
try:
- with open(file) as fin:
- with open("encrypt.out", "w+") as fout:
- # actual encrypt-process
- for line in fin:
- fout.write(self.encrypt_string(line, key))
+ with open(file) as fin, open("encrypt.out", "w+") as fout:
+ # actual encrypt-process
+ for line in fin:
+ fout.write(self.encrypt_string(line, key))
except OSError:
return False
@@ -152,11 +151,10 @@ class XORCipher:
assert isinstance(file, str) and isinstance(key, int)
try:
- with open(file) as fin:
- with open("decrypt.out", "w+") as fout:
- # actual encrypt-process
- for line in fin:
- fout.write(self.decrypt_string(line, key))
+ with open(file) as fin, open("decrypt.out", "w+") as fout:
+ # actual encrypt-process
+ for line in fin:
+ fout.write(self.decrypt_string(line, key))
except OSError:
return False
diff --git a/computer_vision/mosaic_augmentation.py b/computer_vision/mosaic_augmentation.py
index e2953749..c150126d 100644
--- a/computer_vision/mosaic_augmentation.py
+++ b/computer_vision/mosaic_augmentation.py
@@ -159,7 +159,7 @@ def update_image_and_anno(
new_anno.append([bbox[0], xmin, ymin, xmax, ymax])
# Remove bounding box small than scale of filter
- if 0 < filter_scale:
+ if filter_scale > 0:
new_anno = [
anno
for anno in new_anno
diff --git a/data_structures/binary_tree/binary_search_tree.py b/data_structures/binary_tree/binary_search_tree.py
index fc512944..cd88cc10 100644
--- a/data_structures/binary_tree/binary_search_tree.py
+++ b/data_structures/binary_tree/binary_search_tree.py
@@ -60,7 +60,7 @@ class BinarySearchTree:
else: # Tree is not empty
parent_node = self.root # from root
if parent_node is None:
- return None
+ return
while True: # While we don't get to a leaf
if value < parent_node.value: # We go left
if parent_node.left is None:
diff --git a/data_structures/binary_tree/binary_tree_traversals.py b/data_structures/binary_tree/binary_tree_traversals.py
index 24dd1bd8..71a895e7 100644
--- a/data_structures/binary_tree/binary_tree_traversals.py
+++ b/data_structures/binary_tree/binary_tree_traversals.py
@@ -37,7 +37,7 @@ def preorder(root: Node | None) -> list[int]:
>>> preorder(make_tree())
[1, 2, 4, 5, 3]
"""
- return [root.data] + preorder(root.left) + preorder(root.right) if root else []
+ return [root.data, *preorder(root.left), *preorder(root.right)] if root else []
def postorder(root: Node | None) -> list[int]:
@@ -55,7 +55,7 @@ def inorder(root: Node | None) -> list[int]:
>>> inorder(make_tree())
[4, 2, 5, 1, 3]
"""
- return inorder(root.left) + [root.data] + inorder(root.right) if root else []
+ return [*inorder(root.left), root.data, *inorder(root.right)] if root else []
def height(root: Node | None) -> int:
diff --git a/data_structures/binary_tree/inorder_tree_traversal_2022.py b/data_structures/binary_tree/inorder_tree_traversal_2022.py
index e94ba701..1357527d 100644
--- a/data_structures/binary_tree/inorder_tree_traversal_2022.py
+++ b/data_structures/binary_tree/inorder_tree_traversal_2022.py
@@ -50,7 +50,7 @@ def inorder(node: None | BinaryTreeNode) -> list[int]: # if node is None,return
"""
if node:
inorder_array = inorder(node.left_child)
- inorder_array = inorder_array + [node.data]
+ inorder_array = [*inorder_array, node.data]
inorder_array = inorder_array + inorder(node.right_child)
else:
inorder_array = []
diff --git a/data_structures/binary_tree/red_black_tree.py b/data_structures/binary_tree/red_black_tree.py
index a9dbd699..b50d75d3 100644
--- a/data_structures/binary_tree/red_black_tree.py
+++ b/data_structures/binary_tree/red_black_tree.py
@@ -319,9 +319,8 @@ class RedBlackTree:
"""A helper function to recursively check Property 4 of a
Red-Black Tree. See check_color_properties for more info.
"""
- if self.color == 1:
- if color(self.left) == 1 or color(self.right) == 1:
- return False
+ if self.color == 1 and 1 in (color(self.left), color(self.right)):
+ return False
if self.left and not self.left.check_coloring():
return False
if self.right and not self.right.check_coloring():
diff --git a/data_structures/hashing/number_theory/prime_numbers.py b/data_structures/hashing/number_theory/prime_numbers.py
index b88ab76e..0c25896f 100644
--- a/data_structures/hashing/number_theory/prime_numbers.py
+++ b/data_structures/hashing/number_theory/prime_numbers.py
@@ -52,7 +52,7 @@ def next_prime(value, factor=1, **kwargs):
first_value_val = value
while not is_prime(value):
- value += 1 if not ("desc" in kwargs.keys() and kwargs["desc"] is True) else -1
+ value += 1 if not ("desc" in kwargs and kwargs["desc"] is True) else -1
if value == first_value_val:
return next_prime(value + 1, **kwargs)
diff --git a/data_structures/heap/binomial_heap.py b/data_structures/heap/binomial_heap.py
index 2e05c5c8..099bd287 100644
--- a/data_structures/heap/binomial_heap.py
+++ b/data_structures/heap/binomial_heap.py
@@ -136,12 +136,12 @@ class BinomialHeap:
# Empty heaps corner cases
if other.size == 0:
- return
+ return None
if self.size == 0:
self.size = other.size
self.bottom_root = other.bottom_root
self.min_node = other.min_node
- return
+ return None
# Update size
self.size = self.size + other.size
diff --git a/data_structures/linked_list/doubly_linked_list_two.py b/data_structures/linked_list/doubly_linked_list_two.py
index c19309c9..e993cc5a 100644
--- a/data_structures/linked_list/doubly_linked_list_two.py
+++ b/data_structures/linked_list/doubly_linked_list_two.py
@@ -128,7 +128,7 @@ class LinkedList:
while node:
if current_position == position:
self.insert_before_node(node, new_node)
- return None
+ return
current_position += 1
node = node.next
self.insert_after_node(self.tail, new_node)
diff --git a/data_structures/linked_list/singly_linked_list.py b/data_structures/linked_list/singly_linked_list.py
index 3e52c7e4..bdeb5922 100644
--- a/data_structures/linked_list/singly_linked_list.py
+++ b/data_structures/linked_list/singly_linked_list.py
@@ -107,6 +107,7 @@ class LinkedList:
for i, node in enumerate(self):
if i == index:
return node
+ return None
# Used to change the data of a particular node
def __setitem__(self, index: int, data: Any) -> None:
diff --git a/data_structures/linked_list/skip_list.py b/data_structures/linked_list/skip_list.py
index 96b0db7c..4413c53e 100644
--- a/data_structures/linked_list/skip_list.py
+++ b/data_structures/linked_list/skip_list.py
@@ -388,10 +388,7 @@ def test_delete_doesnt_leave_dead_nodes():
def test_iter_always_yields_sorted_values():
def is_sorted(lst):
- for item, next_item in zip(lst, lst[1:]):
- if next_item < item:
- return False
- return True
+ return all(next_item >= item for item, next_item in zip(lst, lst[1:]))
skip_list = SkipList()
for i in range(10):
diff --git a/data_structures/queue/circular_queue_linked_list.py b/data_structures/queue/circular_queue_linked_list.py
index e8c2b8bf..62042c4b 100644
--- a/data_structures/queue/circular_queue_linked_list.py
+++ b/data_structures/queue/circular_queue_linked_list.py
@@ -127,7 +127,7 @@ class CircularQueueLinkedList:
"""
self.check_can_perform_operation()
if self.rear is None or self.front is None:
- return
+ return None
if self.front == self.rear:
data = self.front.data
self.front.data = None
diff --git a/digital_image_processing/morphological_operations/dilation_operation.py b/digital_image_processing/morphological_operations/dilation_operation.py
index 274880b0..c8380737 100644
--- a/digital_image_processing/morphological_operations/dilation_operation.py
+++ b/digital_image_processing/morphological_operations/dilation_operation.py
@@ -32,7 +32,7 @@ def gray2binary(gray: np.array) -> np.array:
[False, True, False],
[False, True, False]])
"""
- return (127 < gray) & (gray <= 255)
+ return (gray > 127) & (gray <= 255)
def dilation(image: np.array, kernel: np.array) -> np.array:
diff --git a/digital_image_processing/morphological_operations/erosion_operation.py b/digital_image_processing/morphological_operations/erosion_operation.py
index 4b0a5eee..c2cde2ea 100644
--- a/digital_image_processing/morphological_operations/erosion_operation.py
+++ b/digital_image_processing/morphological_operations/erosion_operation.py
@@ -32,7 +32,7 @@ def gray2binary(gray: np.array) -> np.array:
[False, True, False],
[False, True, False]])
"""
- return (127 < gray) & (gray <= 255)
+ return (gray > 127) & (gray <= 255)
def erosion(image: np.array, kernel: np.array) -> np.array:
diff --git a/dynamic_programming/all_construct.py b/dynamic_programming/all_construct.py
index 3839d01e..6e53a702 100644
--- a/dynamic_programming/all_construct.py
+++ b/dynamic_programming/all_construct.py
@@ -34,7 +34,7 @@ def all_construct(target: str, word_bank: list[str] | None = None) -> list[list[
# slice condition
if target[i : i + len(word)] == word:
new_combinations: list[list[str]] = [
- [word] + way for way in table[i]
+ [word, *way] for way in table[i]
]
# adds the word to every combination the current position holds
# now,push that combination to the table[i+len(word)]
diff --git a/dynamic_programming/fizz_buzz.py b/dynamic_programming/fizz_buzz.py
index e77ab3de..e2911643 100644
--- a/dynamic_programming/fizz_buzz.py
+++ b/dynamic_programming/fizz_buzz.py
@@ -49,7 +49,7 @@ def fizz_buzz(number: int, iterations: int) -> str:
out += "Fizz"
if number % 5 == 0:
out += "Buzz"
- if not number % 3 == 0 and not number % 5 == 0:
+ if 0 not in (number % 3, number % 5):
out += str(number)
# print(out)
diff --git a/dynamic_programming/longest_common_subsequence.py b/dynamic_programming/longest_common_subsequence.py
index 3468fd87..178b4169 100644
--- a/dynamic_programming/longest_common_subsequence.py
+++ b/dynamic_programming/longest_common_subsequence.py
@@ -42,20 +42,14 @@ def longest_common_subsequence(x: str, y: str):
for i in range(1, m + 1):
for j in range(1, n + 1):
- if x[i - 1] == y[j - 1]:
- match = 1
- else:
- match = 0
+ match = 1 if x[i - 1] == y[j - 1] else 0
l[i][j] = max(l[i - 1][j], l[i][j - 1], l[i - 1][j - 1] + match)
seq = ""
i, j = m, n
while i > 0 and j > 0:
- if x[i - 1] == y[j - 1]:
- match = 1
- else:
- match = 0
+ match = 1 if x[i - 1] == y[j - 1] else 0
if l[i][j] == l[i - 1][j - 1] + match:
if match == 1:
diff --git a/dynamic_programming/longest_increasing_subsequence.py b/dynamic_programming/longest_increasing_subsequence.py
index 6feed235..d8278937 100644
--- a/dynamic_programming/longest_increasing_subsequence.py
+++ b/dynamic_programming/longest_increasing_subsequence.py
@@ -48,7 +48,7 @@ def longest_subsequence(array: list[int]) -> list[int]: # This function is recu
i += 1
temp_array = [element for element in array[1:] if element >= pivot]
- temp_array = [pivot] + longest_subsequence(temp_array)
+ temp_array = [pivot, *longest_subsequence(temp_array)]
if len(temp_array) > len(longest_subseq):
return temp_array
else:
diff --git a/graphs/basic_graphs.py b/graphs/basic_graphs.py
index 298a97bf..065b6185 100644
--- a/graphs/basic_graphs.py
+++ b/graphs/basic_graphs.py
@@ -139,10 +139,9 @@ def dijk(g, s):
u = i
known.add(u)
for v in g[u]:
- if v[0] not in known:
- if dist[u] + v[1] < dist.get(v[0], 100000):
- dist[v[0]] = dist[u] + v[1]
- path[v[0]] = u
+ if v[0] not in known and dist[u] + v[1] < dist.get(v[0], 100000):
+ dist[v[0]] = dist[u] + v[1]
+ path[v[0]] = u
for i in dist:
if i != s:
print(dist[i])
@@ -243,10 +242,9 @@ def prim(g, s):
u = i
known.add(u)
for v in g[u]:
- if v[0] not in known:
- if v[1] < dist.get(v[0], 100000):
- dist[v[0]] = v[1]
- path[v[0]] = u
+ if v[0] not in known and v[1] < dist.get(v[0], 100000):
+ dist[v[0]] = v[1]
+ path[v[0]] = u
return dist
diff --git a/graphs/check_cycle.py b/graphs/check_cycle.py
index dcc86498..9fd1cd80 100644
--- a/graphs/check_cycle.py
+++ b/graphs/check_cycle.py
@@ -15,11 +15,10 @@ def check_cycle(graph: dict) -> bool:
visited: set[int] = set()
# To detect a back edge, keep track of vertices currently in the recursion stack
rec_stk: set[int] = set()
- for node in graph:
- if node not in visited:
- if depth_first_search(graph, node, visited, rec_stk):
- return True
- return False
+ return any(
+ node not in visited and depth_first_search(graph, node, visited, rec_stk)
+ for node in graph
+ )
def depth_first_search(graph: dict, vertex: int, visited: set, rec_stk: set) -> bool:
diff --git a/graphs/connected_components.py b/graphs/connected_components.py
index 4af7803d..15c7633e 100644
--- a/graphs/connected_components.py
+++ b/graphs/connected_components.py
@@ -27,7 +27,7 @@ def dfs(graph: dict, vert: int, visited: list) -> list:
if not visited[neighbour]:
connected_verts += dfs(graph, neighbour, visited)
- return [vert] + connected_verts
+ return [vert, *connected_verts]
def connected_components(graph: dict) -> list:
diff --git a/graphs/dijkstra_algorithm.py b/graphs/dijkstra_algorithm.py
index 1845dad0..452138fe 100644
--- a/graphs/dijkstra_algorithm.py
+++ b/graphs/dijkstra_algorithm.py
@@ -112,7 +112,7 @@ class Graph:
self.dist[src] = 0
q = PriorityQueue()
q.insert((0, src)) # (dist from src, node)
- for u in self.adjList.keys():
+ for u in self.adjList:
if u != src:
self.dist[u] = sys.maxsize # Infinity
self.par[u] = -1
diff --git a/graphs/edmonds_karp_multiple_source_and_sink.py b/graphs/edmonds_karp_multiple_source_and_sink.py
index 070d758e..d0610804 100644
--- a/graphs/edmonds_karp_multiple_source_and_sink.py
+++ b/graphs/edmonds_karp_multiple_source_and_sink.py
@@ -163,9 +163,8 @@ class PushRelabelExecutor(MaximumFlowAlgorithmExecutor):
self.graph[vertex_index][to_index]
- self.preflow[vertex_index][to_index]
> 0
- ):
- if min_height is None or self.heights[to_index] < min_height:
- min_height = self.heights[to_index]
+ ) and (min_height is None or self.heights[to_index] < min_height):
+ min_height = self.heights[to_index]
if min_height is not None:
self.heights[vertex_index] = min_height + 1
diff --git a/graphs/frequent_pattern_graph_miner.py b/graphs/frequent_pattern_graph_miner.py
index 87d5605a..208e57f9 100644
--- a/graphs/frequent_pattern_graph_miner.py
+++ b/graphs/frequent_pattern_graph_miner.py
@@ -130,11 +130,11 @@ def create_edge(nodes, graph, cluster, c1):
"""
create edge between the nodes
"""
- for i in cluster[c1].keys():
+ for i in cluster[c1]:
count = 0
c2 = c1 + 1
while c2 < max(cluster.keys()):
- for j in cluster[c2].keys():
+ for j in cluster[c2]:
"""
creates edge only if the condition satisfies
"""
@@ -185,7 +185,7 @@ def find_freq_subgraph_given_support(s, cluster, graph):
find edges of multiple frequent subgraphs
"""
k = int(s / 100 * (len(cluster) - 1))
- for i in cluster[k].keys():
+ for i in cluster[k]:
my_dfs(graph, tuple(cluster[k][i]), (["Header"],))
diff --git a/graphs/minimum_spanning_tree_boruvka.py b/graphs/minimum_spanning_tree_boruvka.py
index 663d8e26..3c688803 100644
--- a/graphs/minimum_spanning_tree_boruvka.py
+++ b/graphs/minimum_spanning_tree_boruvka.py
@@ -144,6 +144,7 @@ class Graph:
self.rank[root1] += 1
self.parent[root2] = root1
return root1
+ return None
@staticmethod
def boruvka_mst(graph):
diff --git a/graphs/minimum_spanning_tree_prims.py b/graphs/minimum_spanning_tree_prims.py
index f577866f..5a08ec57 100644
--- a/graphs/minimum_spanning_tree_prims.py
+++ b/graphs/minimum_spanning_tree_prims.py
@@ -44,10 +44,7 @@ class Heap:
temp = position[index]
while index != 0:
- if index % 2 == 0:
- parent = int((index - 2) / 2)
- else:
- parent = int((index - 1) / 2)
+ parent = int((index - 2) / 2) if index % 2 == 0 else int((index - 1) / 2)
if val < heap[parent]:
heap[index] = heap[parent]
diff --git a/graphs/minimum_spanning_tree_prims2.py b/graphs/minimum_spanning_tree_prims2.py
index 707be783..81f30ef6 100644
--- a/graphs/minimum_spanning_tree_prims2.py
+++ b/graphs/minimum_spanning_tree_prims2.py
@@ -135,14 +135,14 @@ class MinPriorityQueue(Generic[T]):
# only]
curr_pos = self.position_map[elem]
if curr_pos == 0:
- return
+ return None
parent_position = get_parent_position(curr_pos)
_, weight = self.heap[curr_pos]
_, parent_weight = self.heap[parent_position]
if parent_weight > weight:
self._swap_nodes(parent_position, curr_pos)
return self._bubble_up(elem)
- return
+ return None
def _bubble_down(self, elem: T) -> None:
# Place a node at the proper position (downward movement) [to be used
@@ -154,24 +154,22 @@ class MinPriorityQueue(Generic[T]):
if child_left_position < self.elements and child_right_position < self.elements:
_, child_left_weight = self.heap[child_left_position]
_, child_right_weight = self.heap[child_right_position]
- if child_right_weight < child_left_weight:
- if child_right_weight < weight:
- self._swap_nodes(child_right_position, curr_pos)
- return self._bubble_down(elem)
+ if child_right_weight < child_left_weight and child_right_weight < weight:
+ self._swap_nodes(child_right_position, curr_pos)
+ return self._bubble_down(elem)
if child_left_position < self.elements:
_, child_left_weight = self.heap[child_left_position]
if child_left_weight < weight:
self._swap_nodes(child_left_position, curr_pos)
return self._bubble_down(elem)
else:
- return
+ return None
if child_right_position < self.elements:
_, child_right_weight = self.heap[child_right_position]
if child_right_weight < weight:
self._swap_nodes(child_right_position, curr_pos)
return self._bubble_down(elem)
- else:
- return
+ return None
def _swap_nodes(self, node1_pos: int, node2_pos: int) -> None:
# Swap the nodes at the given positions
diff --git a/hashes/hamming_code.py b/hashes/hamming_code.py
index 481a6750..dc930321 100644
--- a/hashes/hamming_code.py
+++ b/hashes/hamming_code.py
@@ -126,9 +126,8 @@ def emitter_converter(size_par, data):
aux = (bin_pos[cont_loop])[-1 * (bp)]
except IndexError:
aux = "0"
- if aux == "1":
- if x == "1":
- cont_bo += 1
+ if aux == "1" and x == "1":
+ cont_bo += 1
cont_loop += 1
parity.append(cont_bo % 2)
diff --git a/linear_algebra/src/lib.py b/linear_algebra/src/lib.py
index ac0398a3..e3556e74 100644
--- a/linear_algebra/src/lib.py
+++ b/linear_algebra/src/lib.py
@@ -108,7 +108,7 @@ class Vector:
mul implements the scalar multiplication
and the dot-product
"""
- if isinstance(other, float) or isinstance(other, int):
+ if isinstance(other, (float, int)):
ans = [c * other for c in self.__components]
return Vector(ans)
elif isinstance(other, Vector) and len(self) == len(other):
@@ -216,7 +216,7 @@ def axpy(scalar: float, x: Vector, y: Vector) -> Vector:
assert (
isinstance(x, Vector)
and isinstance(y, Vector)
- and (isinstance(scalar, int) or isinstance(scalar, float))
+ and (isinstance(scalar, (int, float)))
)
return x * scalar + y
@@ -337,12 +337,13 @@ class Matrix:
"vector must have the same size as the "
"number of columns of the matrix!"
)
- elif isinstance(other, int) or isinstance(other, float): # matrix-scalar
+ elif isinstance(other, (int, float)): # matrix-scalar
matrix = [
[self.__matrix[i][j] * other for j in range(self.__width)]
for i in range(self.__height)
]
return Matrix(matrix, self.__width, self.__height)
+ return None
def height(self) -> int:
"""
diff --git a/machine_learning/gradient_descent.py b/machine_learning/gradient_descent.py
index 9fa460a0..5b74dad0 100644
--- a/machine_learning/gradient_descent.py
+++ b/machine_learning/gradient_descent.py
@@ -55,6 +55,7 @@ def output(example_no, data_set):
return train_data[example_no][1]
elif data_set == "test":
return test_data[example_no][1]
+ return None
def calculate_hypothesis_value(example_no, data_set):
@@ -68,6 +69,7 @@ def calculate_hypothesis_value(example_no, data_set):
return _hypothesis_value(train_data[example_no][0])
elif data_set == "test":
return _hypothesis_value(test_data[example_no][0])
+ return None
def summation_of_cost_derivative(index, end=m):
diff --git a/machine_learning/k_means_clust.py b/machine_learning/k_means_clust.py
index b6305469..7c8142aa 100644
--- a/machine_learning/k_means_clust.py
+++ b/machine_learning/k_means_clust.py
@@ -229,7 +229,7 @@ def report_generator(
"""
# Fill missing values with given rules
if fill_missing_report:
- df.fillna(value=fill_missing_report, inplace=True)
+ df = df.fillna(value=fill_missing_report)
df["dummy"] = 1
numeric_cols = df.select_dtypes(np.number).columns
report = (
@@ -338,7 +338,7 @@ def report_generator(
)
report.columns.name = ""
report = report.reset_index()
- report.drop(columns=["index"], inplace=True)
+ report = report.drop(columns=["index"])
return report
diff --git a/machine_learning/sequential_minimum_optimization.py b/machine_learning/sequential_minimum_optimization.py
index 9c45c351..37172c8e 100644
--- a/machine_learning/sequential_minimum_optimization.py
+++ b/machine_learning/sequential_minimum_optimization.py
@@ -129,7 +129,7 @@ class SmoSVM:
# error
self._unbound = [i for i in self._all_samples if self._is_unbound(i)]
for s in self.unbound:
- if s == i1 or s == i2:
+ if s in (i1, i2):
continue
self._error[s] += (
y1 * (a1_new - a1) * k(i1, s)
@@ -225,7 +225,7 @@ class SmoSVM:
def _choose_alphas(self):
locis = yield from self._choose_a1()
if not locis:
- return
+ return None
return locis
def _choose_a1(self):
@@ -423,9 +423,8 @@ class Kernel:
return np.exp(-1 * (self.gamma * np.linalg.norm(v1 - v2) ** 2))
def _check(self):
- if self._kernel == self._rbf:
- if self.gamma < 0:
- raise ValueError("gamma value must greater than 0")
+ if self._kernel == self._rbf and self.gamma < 0:
+ raise ValueError("gamma value must greater than 0")
def _get_kernel(self, kernel_name):
maps = {"linear": self._linear, "poly": self._polynomial, "rbf": self._rbf}
diff --git a/maths/abs.py b/maths/abs.py
index cb0ffc8a..b357e98d 100644
--- a/maths/abs.py
+++ b/maths/abs.py
@@ -75,9 +75,9 @@ def test_abs_val():
"""
>>> test_abs_val()
"""
- assert 0 == abs_val(0)
- assert 34 == abs_val(34)
- assert 100000000000 == abs_val(-100000000000)
+ assert abs_val(0) == 0
+ assert abs_val(34) == 34
+ assert abs_val(-100000000000) == 100000000000
a = [-3, -1, 2, -11]
assert abs_max(a) == -11
diff --git a/maths/binary_exp_mod.py b/maths/binary_exp_mod.py
index 67dd1e72..df688892 100644
--- a/maths/binary_exp_mod.py
+++ b/maths/binary_exp_mod.py
@@ -6,7 +6,7 @@ def bin_exp_mod(a, n, b):
7
"""
# mod b
- assert not (b == 0), "This cannot accept modulo that is == 0"
+ assert b != 0, "This cannot accept modulo that is == 0"
if n == 0:
return 1
diff --git a/maths/jaccard_similarity.py b/maths/jaccard_similarity.py
index eab25188..32054414 100644
--- a/maths/jaccard_similarity.py
+++ b/maths/jaccard_similarity.py
@@ -71,6 +71,7 @@ def jaccard_similarity(set_a, set_b, alternative_union=False):
return len(intersection) / len(union)
return len(intersection) / len(union)
+ return None
if __name__ == "__main__":
diff --git a/maths/largest_of_very_large_numbers.py b/maths/largest_of_very_large_numbers.py
index d2dc0af1..7e7fea00 100644
--- a/maths/largest_of_very_large_numbers.py
+++ b/maths/largest_of_very_large_numbers.py
@@ -12,6 +12,7 @@ def res(x, y):
return 0
elif y == 0:
return 1 # any number raised to 0 is 1
+ raise AssertionError("This should never happen")
if __name__ == "__main__": # Main function
diff --git a/maths/radix2_fft.py b/maths/radix2_fft.py
index 1def58e1..af98f24f 100644
--- a/maths/radix2_fft.py
+++ b/maths/radix2_fft.py
@@ -80,10 +80,7 @@ class FFT:
# Discrete fourier transform of A and B
def __dft(self, which):
- if which == "A":
- dft = [[x] for x in self.polyA]
- else:
- dft = [[x] for x in self.polyB]
+ dft = [[x] for x in self.polyA] if which == "A" else [[x] for x in self.polyB]
# Corner case
if len(dft) <= 1:
return dft[0]
diff --git a/neural_network/back_propagation_neural_network.py b/neural_network/back_propagation_neural_network.py
index cb47b829..9dd11211 100644
--- a/neural_network/back_propagation_neural_network.py
+++ b/neural_network/back_propagation_neural_network.py
@@ -153,6 +153,7 @@ class BPNN:
if mse < self.accuracy:
print("----达到精度----")
return mse
+ return None
def cal_loss(self, ydata, ydata_):
self.loss = np.sum(np.power((ydata - ydata_), 2))
diff --git a/other/graham_scan.py b/other/graham_scan.py
index 8e83bfcf..2eadb4e5 100644
--- a/other/graham_scan.py
+++ b/other/graham_scan.py
@@ -125,10 +125,9 @@ def graham_scan(points: list[tuple[int, int]]) -> list[tuple[int, int]]:
miny = y
minx = x
minidx = i
- if y == miny:
- if x < minx:
- minx = x
- minidx = i
+ if y == miny and x < minx:
+ minx = x
+ minidx = i
# remove the lowest and the most left point from points for preparing for sort
points.pop(minidx)
diff --git a/other/nested_brackets.py b/other/nested_brackets.py
index 3f61a4e7..ea48c0a5 100644
--- a/other/nested_brackets.py
+++ b/other/nested_brackets.py
@@ -24,11 +24,10 @@ def is_balanced(s):
if s[i] in open_brackets:
stack.append(s[i])
- elif s[i] in closed_brackets:
- if len(stack) == 0 or (
- len(stack) > 0 and open_to_closed[stack.pop()] != s[i]
- ):
- return False
+ elif s[i] in closed_brackets and (
+ len(stack) == 0 or (len(stack) > 0 and open_to_closed[stack.pop()] != s[i])
+ ):
+ return False
return len(stack) == 0
diff --git a/physics/hubble_parameter.py b/physics/hubble_parameter.py
index 6bc62e71..f7b2d28a 100644
--- a/physics/hubble_parameter.py
+++ b/physics/hubble_parameter.py
@@ -70,10 +70,10 @@ def hubble_parameter(
68.3
"""
parameters = [redshift, radiation_density, matter_density, dark_energy]
- if any(0 > p for p in parameters):
+ if any(p < 0 for p in parameters):
raise ValueError("All input parameters must be positive")
- if any(1 < p for p in parameters[1:4]):
+ if any(p > 1 for p in parameters[1:4]):
raise ValueError("Relative densities cannot be greater than one")
else:
curvature = 1 - (matter_density + radiation_density + dark_energy)
diff --git a/project_euler/problem_005/sol1.py b/project_euler/problem_005/sol1.py
index f272c102..01cbd0e1 100644
--- a/project_euler/problem_005/sol1.py
+++ b/project_euler/problem_005/sol1.py
@@ -63,6 +63,7 @@ def solution(n: int = 20) -> int:
if i == 0:
i = 1
return i
+ return None
if __name__ == "__main__":
diff --git a/project_euler/problem_009/sol1.py b/project_euler/problem_009/sol1.py
index 1d908402..e65c9b85 100644
--- a/project_euler/problem_009/sol1.py
+++ b/project_euler/problem_009/sol1.py
@@ -32,9 +32,8 @@ def solution() -> int:
for a in range(300):
for b in range(a + 1, 400):
for c in range(b + 1, 500):
- if (a + b + c) == 1000:
- if (a**2) + (b**2) == (c**2):
- return a * b * c
+ if (a + b + c) == 1000 and (a**2) + (b**2) == (c**2):
+ return a * b * c
return -1
diff --git a/project_euler/problem_014/sol2.py b/project_euler/problem_014/sol2.py
index d2a1d9f0..2448e652 100644
--- a/project_euler/problem_014/sol2.py
+++ b/project_euler/problem_014/sol2.py
@@ -34,10 +34,7 @@ def collatz_sequence_length(n: int) -> int:
"""Returns the Collatz sequence length for n."""
if n in COLLATZ_SEQUENCE_LENGTHS:
return COLLATZ_SEQUENCE_LENGTHS[n]
- if n % 2 == 0:
- next_n = n // 2
- else:
- next_n = 3 * n + 1
+ next_n = n // 2 if n % 2 == 0 else 3 * n + 1
sequence_length = collatz_sequence_length(next_n) + 1
COLLATZ_SEQUENCE_LENGTHS[n] = sequence_length
return sequence_length
diff --git a/project_euler/problem_018/solution.py b/project_euler/problem_018/solution.py
index 82fc3ce3..70306148 100644
--- a/project_euler/problem_018/solution.py
+++ b/project_euler/problem_018/solution.py
@@ -48,14 +48,8 @@ def solution():
for i in range(1, len(a)):
for j in range(len(a[i])):
- if j != len(a[i - 1]):
- number1 = a[i - 1][j]
- else:
- number1 = 0
- if j > 0:
- number2 = a[i - 1][j - 1]
- else:
- number2 = 0
+ number1 = a[i - 1][j] if j != len(a[i - 1]) else 0
+ number2 = a[i - 1][j - 1] if j > 0 else 0
a[i][j] += max(number1, number2)
return max(a[-1])
diff --git a/project_euler/problem_019/sol1.py b/project_euler/problem_019/sol1.py
index ab593658..0e38137d 100644
--- a/project_euler/problem_019/sol1.py
+++ b/project_euler/problem_019/sol1.py
@@ -39,7 +39,7 @@ def solution():
while year < 2001:
day += 7
- if (year % 4 == 0 and not year % 100 == 0) or (year % 400 == 0):
+ if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
if day > days_per_month[month - 1] and month != 2:
month += 1
day = day - days_per_month[month - 2]
diff --git a/project_euler/problem_033/sol1.py b/project_euler/problem_033/sol1.py
index e0c9a058..32be424b 100644
--- a/project_euler/problem_033/sol1.py
+++ b/project_euler/problem_033/sol1.py
@@ -20,11 +20,9 @@ from fractions import Fraction
def is_digit_cancelling(num: int, den: int) -> bool:
- if num != den:
- if num % 10 == den // 10:
- if (num // 10) / (den % 10) == num / den:
- return True
- return False
+ return (
+ num != den and num % 10 == den // 10 and (num // 10) / (den % 10) == num / den
+ )
def fraction_list(digit_len: int) -> list[str]:
diff --git a/project_euler/problem_064/sol1.py b/project_euler/problem_064/sol1.py
index 81ebcc7b..12769dec 100644
--- a/project_euler/problem_064/sol1.py
+++ b/project_euler/problem_064/sol1.py
@@ -67,9 +67,8 @@ def solution(n: int = 10000) -> int:
count_odd_periods = 0
for i in range(2, n + 1):
sr = sqrt(i)
- if sr - floor(sr) != 0:
- if continuous_fraction_period(i) % 2 == 1:
- count_odd_periods += 1
+ if sr - floor(sr) != 0 and continuous_fraction_period(i) % 2 == 1:
+ count_odd_periods += 1
return count_odd_periods
diff --git a/project_euler/problem_067/sol1.py b/project_euler/problem_067/sol1.py
index f20c206c..2b41fedc 100644
--- a/project_euler/problem_067/sol1.py
+++ b/project_euler/problem_067/sol1.py
@@ -37,14 +37,8 @@ def solution():
for i in range(1, len(a)):
for j in range(len(a[i])):
- if j != len(a[i - 1]):
- number1 = a[i - 1][j]
- else:
- number1 = 0
- if j > 0:
- number2 = a[i - 1][j - 1]
- else:
- number2 = 0
+ number1 = a[i - 1][j] if j != len(a[i - 1]) else 0
+ number2 = a[i - 1][j - 1] if j > 0 else 0
a[i][j] += max(number1, number2)
return max(a[-1])
diff --git a/project_euler/problem_109/sol1.py b/project_euler/problem_109/sol1.py
index 852f001d..ef145dda 100644
--- a/project_euler/problem_109/sol1.py
+++ b/project_euler/problem_109/sol1.py
@@ -65,7 +65,7 @@ def solution(limit: int = 100) -> int:
>>> solution(50)
12577
"""
- singles: list[int] = list(range(1, 21)) + [25]
+ singles: list[int] = [*list(range(1, 21)), 25]
doubles: list[int] = [2 * x for x in range(1, 21)] + [50]
triples: list[int] = [3 * x for x in range(1, 21)]
all_values: list[int] = singles + doubles + triples + [0]
diff --git a/project_euler/problem_203/sol1.py b/project_euler/problem_203/sol1.py
index 713b530b..da943624 100644
--- a/project_euler/problem_203/sol1.py
+++ b/project_euler/problem_203/sol1.py
@@ -50,8 +50,8 @@ def get_pascal_triangle_unique_coefficients(depth: int) -> set[int]:
coefficients = {1}
previous_coefficients = [1]
for _ in range(2, depth + 1):
- coefficients_begins_one = previous_coefficients + [0]
- coefficients_ends_one = [0] + previous_coefficients
+ coefficients_begins_one = [*previous_coefficients, 0]
+ coefficients_ends_one = [0, *previous_coefficients]
previous_coefficients = []
for x, y in zip(coefficients_begins_one, coefficients_ends_one):
coefficients.add(x + y)
diff --git a/scheduling/shortest_job_first.py b/scheduling/shortest_job_first.py
index b3f81bfd..871de820 100644
--- a/scheduling/shortest_job_first.py
+++ b/scheduling/shortest_job_first.py
@@ -36,12 +36,11 @@ def calculate_waitingtime(
# Process until all processes are completed
while complete != no_of_processes:
for j in range(no_of_processes):
- if arrival_time[j] <= increment_time:
- if remaining_time[j] > 0:
- if remaining_time[j] < minm:
- minm = remaining_time[j]
- short = j
- check = True
+ if arrival_time[j] <= increment_time and remaining_time[j] > 0:
+ if remaining_time[j] < minm:
+ minm = remaining_time[j]
+ short = j
+ check = True
if not check:
increment_time += 1
diff --git a/scripts/build_directory_md.py b/scripts/build_directory_md.py
index 7572ce34..b95be9eb 100755
--- a/scripts/build_directory_md.py
+++ b/scripts/build_directory_md.py
@@ -21,9 +21,8 @@ def md_prefix(i):
def print_path(old_path: str, new_path: str) -> str:
old_parts = old_path.split(os.sep)
for i, new_part in enumerate(new_path.split(os.sep)):
- if i + 1 > len(old_parts) or old_parts[i] != new_part:
- if new_part:
- print(f"{md_prefix(i)} {new_part.replace('_', ' ').title()}")
+ if (i + 1 > len(old_parts) or old_parts[i] != new_part) and new_part:
+ print(f"{md_prefix(i)} {new_part.replace('_', ' ').title()}")
return new_path
diff --git a/searches/binary_tree_traversal.py b/searches/binary_tree_traversal.py
index 66814b47..76e80df2 100644
--- a/searches/binary_tree_traversal.py
+++ b/searches/binary_tree_traversal.py
@@ -37,6 +37,7 @@ def build_tree():
right_node = TreeNode(int(check))
node_found.right = right_node
q.put(right_node)
+ return None
def pre_order(node: TreeNode) -> None:
diff --git a/sorts/circle_sort.py b/sorts/circle_sort.py
index da3c5905..271fa1e8 100644
--- a/sorts/circle_sort.py
+++ b/sorts/circle_sort.py
@@ -58,14 +58,13 @@ def circle_sort(collection: list) -> list:
left += 1
right -= 1
- if left == right:
- if collection[left] > collection[right + 1]:
- collection[left], collection[right + 1] = (
- collection[right + 1],
- collection[left],
- )
+ if left == right and collection[left] > collection[right + 1]:
+ collection[left], collection[right + 1] = (
+ collection[right + 1],
+ collection[left],
+ )
- swapped = True
+ swapped = True
mid = low + int((high - low) / 2)
left_swap = circle_sort_util(collection, low, mid)
diff --git a/sorts/counting_sort.py b/sorts/counting_sort.py
index 892ec5d5..18c4b032 100644
--- a/sorts/counting_sort.py
+++ b/sorts/counting_sort.py
@@ -66,7 +66,7 @@ def counting_sort_string(string):
if __name__ == "__main__":
# Test string sort
- assert "eghhiiinrsssttt" == counting_sort_string("thisisthestring")
+ assert counting_sort_string("thisisthestring") == "eghhiiinrsssttt"
user_input = input("Enter numbers separated by a comma:\n").strip()
unsorted = [int(item) for item in user_input.split(",")]
diff --git a/sorts/msd_radix_sort.py b/sorts/msd_radix_sort.py
index 74ce2176..03f84c75 100644
--- a/sorts/msd_radix_sort.py
+++ b/sorts/msd_radix_sort.py
@@ -147,7 +147,7 @@ def _msd_radix_sort_inplace(
list_of_ints[i], list_of_ints[j] = list_of_ints[j], list_of_ints[i]
j -= 1
- if not j == i:
+ if j != i:
i += 1
_msd_radix_sort_inplace(list_of_ints, bit_position, begin_index, i)
diff --git a/sorts/quick_sort.py b/sorts/quick_sort.py
index 70cd19d7..b79d3eac 100644
--- a/sorts/quick_sort.py
+++ b/sorts/quick_sort.py
@@ -39,7 +39,7 @@ def quick_sort(collection: list) -> list:
for element in collection[pivot_index + 1 :]:
(greater if element > pivot else lesser).append(element)
- return quick_sort(lesser) + [pivot] + quick_sort(greater)
+ return [*quick_sort(lesser), pivot, *quick_sort(greater)]
if __name__ == "__main__":
diff --git a/sorts/recursive_quick_sort.py b/sorts/recursive_quick_sort.py
index c28a14e3..c29009ac 100644
--- a/sorts/recursive_quick_sort.py
+++ b/sorts/recursive_quick_sort.py
@@ -9,11 +9,11 @@ def quick_sort(data: list) -> list:
if len(data) <= 1:
return data
else:
- return (
- quick_sort([e for e in data[1:] if e <= data[0]])
- + [data[0]]
- + quick_sort([e for e in data[1:] if e > data[0]])
- )
+ return [
+ *quick_sort([e for e in data[1:] if e <= data[0]]),
+ data[0],
+ *quick_sort([e for e in data[1:] if e > data[0]]),
+ ]
if __name__ == "__main__":
diff --git a/sorts/tim_sort.py b/sorts/tim_sort.py
index c90c7e80..138f11c7 100644
--- a/sorts/tim_sort.py
+++ b/sorts/tim_sort.py
@@ -32,9 +32,9 @@ def merge(left, right):
return left
if left[0] < right[0]:
- return [left[0]] + merge(left[1:], right)
+ return [left[0], *merge(left[1:], right)]
- return [right[0]] + merge(left, right[1:])
+ return [right[0], *merge(left, right[1:])]
def tim_sort(lst):
diff --git a/strings/autocomplete_using_trie.py b/strings/autocomplete_using_trie.py
index 75826029..77a3050a 100644
--- a/strings/autocomplete_using_trie.py
+++ b/strings/autocomplete_using_trie.py
@@ -27,10 +27,7 @@ class Trie:
def _elements(self, d: dict) -> tuple:
result = []
for c, v in d.items():
- if c == END:
- sub_result = [" "]
- else:
- sub_result = [c + s for s in self._elements(v)]
+ sub_result = [" "] if c == END else [(c + s) for s in self._elements(v)]
result.extend(sub_result)
return tuple(result)
diff --git a/strings/check_anagrams.py b/strings/check_anagrams.py
index 0d2f8091..a364b982 100644
--- a/strings/check_anagrams.py
+++ b/strings/check_anagrams.py
@@ -38,10 +38,7 @@ def check_anagrams(first_str: str, second_str: str) -> bool:
count[first_str[i]] += 1
count[second_str[i]] -= 1
- for _count in count.values():
- if _count != 0:
- return False
- return True
+ return all(_count == 0 for _count in count.values())
if __name__ == "__main__":
diff --git a/strings/is_palindrome.py b/strings/is_palindrome.py
index 9bf2abd9..406aa2e8 100644
--- a/strings/is_palindrome.py
+++ b/strings/is_palindrome.py
@@ -30,10 +30,7 @@ def is_palindrome(s: str) -> bool:
# with the help of 1st index (i==n-i-1)
# where n is length of string
- for i in range(end):
- if s[i] != s[n - i - 1]:
- return False
- return True
+ return all(s[i] == s[n - i - 1] for i in range(end))
if __name__ == "__main__":
diff --git a/strings/snake_case_to_camel_pascal_case.py b/strings/snake_case_to_camel_pascal_case.py
index eaabdcb8..28a28b51 100644
--- a/strings/snake_case_to_camel_pascal_case.py
+++ b/strings/snake_case_to_camel_pascal_case.py
@@ -43,7 +43,7 @@ def snake_to_camel_case(input_str: str, use_pascal: bool = False) -> str:
initial_word = "" if use_pascal else words[0]
- return "".join([initial_word] + capitalized_words)
+ return "".join([initial_word, *capitalized_words])
if __name__ == "__main__":
diff --git a/web_programming/convert_number_to_words.py b/web_programming/convert_number_to_words.py
index 50612dec..1e293df9 100644
--- a/web_programming/convert_number_to_words.py
+++ b/web_programming/convert_number_to_words.py
@@ -63,7 +63,7 @@ def convert(number: int) -> str:
current = temp_num % 10
if counter % 2 == 0:
addition = ""
- if counter in placevalue.keys() and current != 0:
+ if counter in placevalue and current != 0:
addition = placevalue[counter]
if counter == 2:
words = singles[current] + addition + words
@@ -84,12 +84,12 @@ def convert(number: int) -> str:
words = teens[number % 10] + words
else:
addition = ""
- if counter in placevalue.keys():
+ if counter in placevalue:
addition = placevalue[counter]
words = doubles[current] + addition + words
else:
addition = ""
- if counter in placevalue.keys():
+ if counter in placevalue:
if current == 0 and ((temp_num % 100) // 10) == 0:
addition = ""
else:
diff --git a/web_programming/instagram_crawler.py b/web_programming/instagram_crawler.py
index 4536257a..0816cd18 100644
--- a/web_programming/instagram_crawler.py
+++ b/web_programming/instagram_crawler.py
@@ -105,7 +105,7 @@ def test_instagram_user(username: str = "github") -> None:
import os
if os.environ.get("CI"):
- return None # test failing on GitHub Actions
+ return # test failing on GitHub Actions
instagram_user = InstagramUser(username)
assert instagram_user.user_data
assert isinstance(instagram_user.user_data, dict)
diff --git a/web_programming/open_google_results.py b/web_programming/open_google_results.py
index 2685bf62..f61e3666 100644
--- a/web_programming/open_google_results.py
+++ b/web_programming/open_google_results.py
@@ -7,10 +7,7 @@ from bs4 import BeautifulSoup
from fake_useragent import UserAgent
if __name__ == "__main__":
- if len(argv) > 1:
- query = "%20".join(argv[1:])
- else:
- query = quote(str(input("Search: ")))
+ query = "%20".join(argv[1:]) if len(argv) > 1 else quote(str(input("Search: ")))
print("Googling.....")