diff --git a/backtracking/sudoku.py b/backtracking/sudoku.py
index 8f5459c76d45..cabeebb90433 100644
--- a/backtracking/sudoku.py
+++ b/backtracking/sudoku.py
@@ -1,7 +1,7 @@
 """
-Given a partially filled 9×9 2D array, the objective is to fill a 9×9
+Given a partially filled 9x9 2D array, the objective is to fill a 9x9
 square grid with digits numbered 1 to 9, so that every row, column, and
-and each of the nine 3×3 sub-grids contains all of the digits.
+and each of the nine 3x3 sub-grids contains all of the digits.
 
 This can be solved using Backtracking and is similar to n-queens.
 We check to see if a cell is safe or not and recursively call the
diff --git a/bit_manipulation/single_bit_manipulation_operations.py b/bit_manipulation/single_bit_manipulation_operations.py
index b43ff07b776f..fcbf033ccb24 100644
--- a/bit_manipulation/single_bit_manipulation_operations.py
+++ b/bit_manipulation/single_bit_manipulation_operations.py
@@ -8,8 +8,8 @@ def set_bit(number: int, position: int) -> int:
     Set the bit at position to 1.
 
     Details: perform bitwise or for given number and X.
-    Where X is a number with all the bits – zeroes and bit on given
-    position – one.
+    Where X is a number with all the bits - zeroes and bit on given
+    position - one.
 
     >>> set_bit(0b1101, 1) # 0b1111
     15
@@ -26,8 +26,8 @@ def clear_bit(number: int, position: int) -> int:
     Set the bit at position to 0.
 
     Details: perform bitwise and for given number and X.
-    Where X is a number with all the bits – ones and bit on given
-    position – zero.
+    Where X is a number with all the bits - ones and bit on given
+    position - zero.
 
     >>> clear_bit(0b10010, 1) # 0b10000
     16
@@ -42,8 +42,8 @@ def flip_bit(number: int, position: int) -> int:
     Flip the bit at position.
 
     Details: perform bitwise xor for given number and X.
-    Where X is a number with all the bits – zeroes and bit on given
-    position – one.
+    Where X is a number with all the bits - zeroes and bit on given
+    position - one.
 
     >>> flip_bit(0b101, 1) # 0b111
     7
@@ -79,7 +79,7 @@ def get_bit(number: int, position: int) -> int:
     Get the bit at the given position
 
     Details: perform bitwise and for the given number and X,
-    Where X is a number with all the bits – zeroes and bit on given position – one.
+    Where X is a number with all the bits - zeroes and bit on given position - one.
     If the result is not equal to 0, then the bit on the given position is 1, else 0.
 
     >>> get_bit(0b1010, 0)
diff --git a/compression/burrows_wheeler.py b/compression/burrows_wheeler.py
index ce493a70c8f9..857d677c904e 100644
--- a/compression/burrows_wheeler.py
+++ b/compression/burrows_wheeler.py
@@ -1,7 +1,7 @@
 """
 https://en.wikipedia.org/wiki/Burrows%E2%80%93Wheeler_transform
 
-The Burrows–Wheeler transform (BWT, also called block-sorting compression)
+The Burrows-Wheeler transform (BWT, also called block-sorting compression)
 rearranges a character string into runs of similar characters. This is useful
 for compression, since it tends to be easy to compress a string that has runs
 of repeated characters by techniques such as move-to-front transform and
diff --git a/compression/lempel_ziv.py b/compression/lempel_ziv.py
index ac3f0c6cfc06..2751a0ebcdb6 100644
--- a/compression/lempel_ziv.py
+++ b/compression/lempel_ziv.py
@@ -1,5 +1,5 @@
 """
-One of the several implementations of Lempel–Ziv–Welch compression algorithm
+One of the several implementations of Lempel-Ziv-Welch compression algorithm
 https://en.wikipedia.org/wiki/Lempel%E2%80%93Ziv%E2%80%93Welch
 """
 
@@ -43,7 +43,7 @@ def add_key_to_lexicon(
 
 def compress_data(data_bits: str) -> str:
     """
-    Compresses given data_bits using Lempel–Ziv–Welch compression algorithm
+    Compresses given data_bits using Lempel-Ziv-Welch compression algorithm
     and returns the result as a string
     """
     lexicon = {"0": "0", "1": "1"}
diff --git a/compression/lempel_ziv_decompress.py b/compression/lempel_ziv_decompress.py
index 0e49c83fb790..225e96236c2c 100644
--- a/compression/lempel_ziv_decompress.py
+++ b/compression/lempel_ziv_decompress.py
@@ -1,5 +1,5 @@
 """
-One of the several implementations of Lempel–Ziv–Welch decompression algorithm
+One of the several implementations of Lempel-Ziv-Welch decompression algorithm
 https://en.wikipedia.org/wiki/Lempel%E2%80%93Ziv%E2%80%93Welch
 """
 
@@ -26,7 +26,7 @@ def read_file_binary(file_path: str) -> str:
 
 def decompress_data(data_bits: str) -> str:
     """
-    Decompresses given data_bits using Lempel–Ziv–Welch compression algorithm
+    Decompresses given data_bits using Lempel-Ziv-Welch compression algorithm
     and returns the result as a string
     """
     lexicon = {"0": "0", "1": "1"}
diff --git a/data_structures/binary_tree/red_black_tree.py b/data_structures/binary_tree/red_black_tree.py
index e68d8d1e3735..a9ecf897c701 100644
--- a/data_structures/binary_tree/red_black_tree.py
+++ b/data_structures/binary_tree/red_black_tree.py
@@ -17,7 +17,7 @@ class RedBlackTree:
     and slower for reading in the average case, though, because they're
     both balanced binary search trees, both will get the same asymptotic
     performance.
-    To read more about them, https://en.wikipedia.org/wiki/Red–black_tree
+    To read more about them, https://en.wikipedia.org/wiki/Red-black_tree
     Unless otherwise specified, all asymptotic runtimes are specified in
     terms of the size of the tree.
     """
diff --git a/digital_image_processing/edge_detection/canny.py b/digital_image_processing/edge_detection/canny.py
index f8cbeedb3874..944161c31cfc 100644
--- a/digital_image_processing/edge_detection/canny.py
+++ b/digital_image_processing/edge_detection/canny.py
@@ -74,9 +74,9 @@ def detect_high_low_threshold(
     image_shape, destination, threshold_low, threshold_high, weak, strong
 ):
     """
-    High-Low threshold detection. If an edge pixel’s gradient value is higher
+    High-Low threshold detection. If an edge pixel's gradient value is higher
     than the high threshold value, it is marked as a strong edge pixel. If an
-    edge pixel’s gradient value is smaller than the high threshold value and
+    edge pixel's gradient value is smaller than the high threshold value and
     larger than the low threshold value, it is marked as a weak edge pixel. If
     an edge pixel's value is smaller than the low threshold value, it will be
     suppressed.
diff --git a/digital_image_processing/index_calculation.py b/digital_image_processing/index_calculation.py
index 67830668b0da..988f8e72b9a8 100644
--- a/digital_image_processing/index_calculation.py
+++ b/digital_image_processing/index_calculation.py
@@ -182,7 +182,7 @@ def arv12(self):
         Atmospherically Resistant Vegetation Index 2
         https://www.indexdatabase.de/db/i-single.php?id=396
         :return: index
-            −0.18+1.17*(self.nir−self.red)/(self.nir+self.red)
+            -0.18+1.17*(self.nir-self.red)/(self.nir+self.red)
         """
         return -0.18 + (1.17 * ((self.nir - self.red) / (self.nir + self.red)))
 
diff --git a/dynamic_programming/combination_sum_iv.py b/dynamic_programming/combination_sum_iv.py
index 4526729b70b7..113c06a27a9e 100644
--- a/dynamic_programming/combination_sum_iv.py
+++ b/dynamic_programming/combination_sum_iv.py
@@ -18,7 +18,7 @@
 The basic idea is to go over recursively to find the way such that the sum
 of chosen elements is “tar”. For every element, we have two choices
     1. Include the element in our set of chosen elements.
-    2. Don’t include the element in our set of chosen elements.
+    2. Don't include the element in our set of chosen elements.
 """
 
 
diff --git a/electronics/coulombs_law.py b/electronics/coulombs_law.py
index 18c1a8179eb6..74bbea5ea8ec 100644
--- a/electronics/coulombs_law.py
+++ b/electronics/coulombs_law.py
@@ -20,8 +20,8 @@ def couloumbs_law(
 
     Reference
     ----------
-    Coulomb (1785) "Premier mémoire sur l’électricité et le magnétisme,"
-    Histoire de l’Académie Royale des Sciences, pp. 569–577.
+    Coulomb (1785) "Premier mémoire sur l'électricité et le magnétisme,"
+    Histoire de l'Académie Royale des Sciences, pp. 569-577.
 
     Parameters
     ----------
diff --git a/hashes/fletcher16.py b/hashes/fletcher16.py
index 7c23c98d72c5..add8e185bc06 100644
--- a/hashes/fletcher16.py
+++ b/hashes/fletcher16.py
@@ -1,6 +1,6 @@
 """
 The Fletcher checksum is an algorithm for computing a position-dependent
-checksum devised by John G. Fletcher (1934–2012) at Lawrence Livermore Labs
+checksum devised by John G. Fletcher (1934-2012) at Lawrence Livermore Labs
 in the late 1970s.[1] The objective of the Fletcher checksum was to
 provide error-detection properties approaching those of a cyclic
 redundancy check but with the lower computational effort associated
diff --git a/linear_algebra/lu_decomposition.py b/linear_algebra/lu_decomposition.py
index 1d364163d9a7..3620674835cd 100644
--- a/linear_algebra/lu_decomposition.py
+++ b/linear_algebra/lu_decomposition.py
@@ -1,5 +1,5 @@
 """
-Lower–upper (LU) decomposition factors a matrix as a product of a lower
+Lower-upper (LU) decomposition factors a matrix as a product of a lower
 triangular matrix and an upper triangular matrix. A square matrix has an LU
 decomposition under the following conditions:
     - If the matrix is invertible, then it has an LU decomposition if and only
diff --git a/linear_algebra/src/schur_complement.py b/linear_algebra/src/schur_complement.py
index 1cc084043856..7c79bb70abfc 100644
--- a/linear_algebra/src/schur_complement.py
+++ b/linear_algebra/src/schur_complement.py
@@ -18,7 +18,7 @@ def schur_complement(
     the pseudo_inv argument.
 
     Link to Wiki: https://en.wikipedia.org/wiki/Schur_complement
-    See also Convex Optimization – Boyd and Vandenberghe, A.5.5
+    See also Convex Optimization - Boyd and Vandenberghe, A.5.5
     >>> import numpy as np
     >>> a = np.array([[1, 2], [2, 1]])
     >>> b = np.array([[0, 3], [3, 0]])
diff --git a/machine_learning/polynomial_regression.py b/machine_learning/polynomial_regression.py
index 5bafea96f41e..19f7dc994017 100644
--- a/machine_learning/polynomial_regression.py
+++ b/machine_learning/polynomial_regression.py
@@ -11,7 +11,7 @@
 
 β = (XᵀX)⁻¹Xᵀy = X⁺y
 
-where X is the design matrix, y is the response vector, and X⁺ denotes the Moore–Penrose
+where X is the design matrix, y is the response vector, and X⁺ denotes the Moore-Penrose
 pseudoinverse of X. In the case of polynomial regression, the design matrix is
 
     |1  x₁  x₁² ⋯ x₁ᵐ|
@@ -106,7 +106,7 @@ def fit(self, x_train: np.ndarray, y_train: np.ndarray) -> None:
 
         β = (XᵀX)⁻¹Xᵀy = X⁺y
 
-        where X⁺ denotes the Moore–Penrose pseudoinverse of the design matrix X. This
+        where X⁺ denotes the Moore-Penrose pseudoinverse of the design matrix X. This
         function computes X⁺ using singular value decomposition (SVD).
 
         References:
diff --git a/maths/chudnovsky_algorithm.py b/maths/chudnovsky_algorithm.py
index aaee7462822e..d122bf0756f7 100644
--- a/maths/chudnovsky_algorithm.py
+++ b/maths/chudnovsky_algorithm.py
@@ -5,7 +5,7 @@
 def pi(precision: int) -> str:
     """
     The Chudnovsky algorithm is a fast method for calculating the digits of PI,
-    based on Ramanujan’s PI formulae.
+    based on Ramanujan's PI formulae.
 
     https://en.wikipedia.org/wiki/Chudnovsky_algorithm
 
diff --git a/maths/entropy.py b/maths/entropy.py
index 39ec67bea038..b816f1d193f7 100644
--- a/maths/entropy.py
+++ b/maths/entropy.py
@@ -21,10 +21,10 @@ def calculate_prob(text: str) -> None:
     :return: Prints
     1) Entropy of information based on 1 alphabet
     2) Entropy of information based on couples of 2 alphabet
-    3) print Entropy of H(X n∣Xn−1)
+    3) print Entropy of H(X n|Xn-1)
 
     Text from random books. Also, random quotes.
-    >>> text = ("Behind Winston’s back the voice "
+    >>> text = ("Behind Winston's back the voice "
     ...         "from the telescreen was still "
     ...         "babbling and the overfulfilment")
     >>> calculate_prob(text)
diff --git a/maths/lucas_lehmer_primality_test.py b/maths/lucas_lehmer_primality_test.py
index 292387414dee..af5c81133044 100644
--- a/maths/lucas_lehmer_primality_test.py
+++ b/maths/lucas_lehmer_primality_test.py
@@ -1,12 +1,12 @@
 """
-In mathematics, the Lucas–Lehmer test (LLT) is a primality test for Mersenne
+In mathematics, the Lucas-Lehmer test (LLT) is a primality test for Mersenne
 numbers.  https://en.wikipedia.org/wiki/Lucas%E2%80%93Lehmer_primality_test
 
 A Mersenne number is a number that is one less than a power of two.
 That is M_p = 2^p - 1
 https://en.wikipedia.org/wiki/Mersenne_prime
 
-The Lucas–Lehmer test is the primality test used by the
+The Lucas-Lehmer test is the primality test used by the
 Great Internet Mersenne Prime Search (GIMPS) to locate large primes.
 """
 
diff --git a/maths/modular_division.py b/maths/modular_division.py
index 260d5683705d..2f8f4479b27d 100644
--- a/maths/modular_division.py
+++ b/maths/modular_division.py
@@ -9,7 +9,7 @@ def modular_division(a: int, b: int, n: int) -> int:
     GCD ( Greatest Common Divisor ) or HCF ( Highest Common Factor )
 
     Given three integers a, b, and n, such that gcd(a,n)=1 and n>1, the algorithm should
-    return an integer x such that 0≤x≤n−1, and  b/a=x(modn) (that is, b=ax(modn)).
+    return an integer x such that 0≤x≤n-1, and  b/a=x(modn) (that is, b=ax(modn)).
 
     Theorem:
     a has a multiplicative inverse modulo n iff gcd(a,n) = 1
diff --git a/maths/numerical_analysis/bisection_2.py b/maths/numerical_analysis/bisection_2.py
index 45f26d8d88e4..68ba6577ce29 100644
--- a/maths/numerical_analysis/bisection_2.py
+++ b/maths/numerical_analysis/bisection_2.py
@@ -1,5 +1,5 @@
 """
-Given a function on floating number f(x) and two floating numbers ‘a’ and ‘b’ such that
+Given a function on floating number f(x) and two floating numbers `a` and `b` such that
 f(a) * f(b) < 0 and f(x) is continuous in [a, b].
 Here f(x) represents algebraic or transcendental equation.
 Find root of function in interval [a, b] (Or find a value of x such that f(x) is 0)
diff --git a/maths/numerical_analysis/nevilles_method.py b/maths/numerical_analysis/nevilles_method.py
index 256b61f5f218..25c93ac6c531 100644
--- a/maths/numerical_analysis/nevilles_method.py
+++ b/maths/numerical_analysis/nevilles_method.py
@@ -1,7 +1,7 @@
 """
 Python program to show how to interpolate and evaluate a polynomial
 using Neville's method.
-Neville’s method evaluates a polynomial that passes through a
+Neville's method evaluates a polynomial that passes through a
 given set of x and y points for a particular x value (x0) using the
 Newton polynomial form.
 Reference:
diff --git a/maths/simultaneous_linear_equation_solver.py b/maths/simultaneous_linear_equation_solver.py
index 1287b2002d00..9685a33e82fe 100644
--- a/maths/simultaneous_linear_equation_solver.py
+++ b/maths/simultaneous_linear_equation_solver.py
@@ -2,10 +2,10 @@
 https://en.wikipedia.org/wiki/Augmented_matrix
 
 This algorithm solves simultaneous linear equations of the form
-λa + λb + λc + λd + ... = γ as [λ, λ, λ, λ, ..., γ]
-Where λ & γ are individual coefficients, the no. of equations = no. of coefficients - 1
+λa + λb + λc + λd + ... = y as [λ, λ, λ, λ, ..., y]
+Where λ & y are individual coefficients, the no. of equations = no. of coefficients - 1
 
-Note in order to work there must exist 1 equation where all instances of λ and γ != 0
+Note in order to work there must exist 1 equation where all instances of λ and y != 0
 """
 
 
diff --git a/matrix/largest_square_area_in_matrix.py b/matrix/largest_square_area_in_matrix.py
index a93369c56bbd..16263fb798f1 100644
--- a/matrix/largest_square_area_in_matrix.py
+++ b/matrix/largest_square_area_in_matrix.py
@@ -31,7 +31,7 @@
 
 Approach:
 We initialize another matrix (dp) with the same dimensions
-as the original one initialized with all 0’s.
+as the original one initialized with all 0's.
 
 dp_array(i,j) represents the side length of the maximum square whose
 bottom right corner is the cell with index (i,j) in the original matrix.
@@ -39,7 +39,7 @@
 Starting from index (0,0), for every 1 found in the original matrix,
 we update the value of the current element as
 
-dp_array(i,j)=dp_array(dp(i−1,j),dp_array(i−1,j−1),dp_array(i,j−1)) + 1.
+dp_array(i,j)=dp_array(dp(i-1,j),dp_array(i-1,j-1),dp_array(i,j-1)) + 1.
 """
 
 
diff --git a/matrix/spiral_print.py b/matrix/spiral_print.py
index c16dde69cb56..88bde1db594d 100644
--- a/matrix/spiral_print.py
+++ b/matrix/spiral_print.py
@@ -89,7 +89,7 @@ def spiral_traversal(matrix: list[list]) -> list[int]:
     Algorithm:
         Step 1. first pop the 0 index list. (which is [1,2,3,4] and concatenate the
                 output of [step 2])
-        Step 2. Now perform matrix’s Transpose operation (Change rows to column
+        Step 2. Now perform matrix's Transpose operation (Change rows to column
                 and vice versa) and reverse the resultant matrix.
         Step 3. Pass the output of [2nd step], to same recursive function till
                 base case hits.
diff --git a/neural_network/back_propagation_neural_network.py b/neural_network/back_propagation_neural_network.py
index 6131a13e945e..182f759c5fc7 100644
--- a/neural_network/back_propagation_neural_network.py
+++ b/neural_network/back_propagation_neural_network.py
@@ -2,10 +2,10 @@
 
 """
 
-A Framework of Back Propagation Neural Network（BP） model
+A Framework of Back Propagation Neural Network (BP) model
 
 Easy to use:
-    * add many layers as you want ！！！
+    * add many layers as you want ! ! !
     * clearly see how the loss decreasing
 Easy to expand:
     * more activation functions
diff --git a/other/davis_putnam_logemann_loveland.py b/other/davis_putnam_logemann_loveland.py
index 3a76f3dfef08..0f3100b1bc2e 100644
--- a/other/davis_putnam_logemann_loveland.py
+++ b/other/davis_putnam_logemann_loveland.py
@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 
 """
-Davis–Putnam–Logemann–Loveland (DPLL) algorithm is a complete, backtracking-based
+Davis-Putnam-Logemann-Loveland (DPLL) algorithm is a complete, backtracking-based
 search algorithm for deciding the satisfiability of propositional logic formulae in
 conjunctive normal form, i.e, for solving the Conjunctive Normal Form SATisfiability
 (CNF-SAT) problem.
diff --git a/other/fischer_yates_shuffle.py b/other/fischer_yates_shuffle.py
index 37e11479a4c9..5e90b10edd89 100644
--- a/other/fischer_yates_shuffle.py
+++ b/other/fischer_yates_shuffle.py
@@ -1,6 +1,6 @@
 #!/usr/bin/python
 """
-The Fisher–Yates shuffle is an algorithm for generating a random permutation of a
+The Fisher-Yates shuffle is an algorithm for generating a random permutation of a
 finite sequence.
 For more details visit
 wikipedia/Fischer-Yates-Shuffle.
diff --git a/physics/archimedes_principle_of_buoyant_force.py b/physics/archimedes_principle_of_buoyant_force.py
index 71043e0e1111..38f1a0a83832 100644
--- a/physics/archimedes_principle_of_buoyant_force.py
+++ b/physics/archimedes_principle_of_buoyant_force.py
@@ -3,7 +3,7 @@
 fluid.  This principle was discovered by the Greek mathematician Archimedes.
 
 Equation for calculating buoyant force:
-Fb = ρ * V * g
+Fb = p * V * g
 
 https://en.wikipedia.org/wiki/Archimedes%27_principle
 """
diff --git a/physics/center_of_mass.py b/physics/center_of_mass.py
index 59c3b807f401..7a20e71be801 100644
--- a/physics/center_of_mass.py
+++ b/physics/center_of_mass.py
@@ -16,8 +16,8 @@
 is the particle equivalent of a given object for the application of Newton's laws of
 motion.
 
-In the case of a system of particles P_i, i = 1, ..., n , each with mass m_i that are
-located in space with coordinates r_i, i = 1, ..., n , the coordinates R of the center
+In the case of a system of particles P_i, i = 1, ..., n , each with mass m_i that are
+located in space with coordinates r_i, i = 1, ..., n , the coordinates R of the center
 of mass corresponds to:
 
 R = (Σ(mi * ri) / Σ(mi))
@@ -36,8 +36,8 @@ def center_of_mass(particles: list[Particle]) -> Coord3D:
     Input Parameters
     ----------------
     particles: list(Particle):
-    A list of particles where each particle is a tuple with it´s (x, y, z) position and
-    it´s mass.
+    A list of particles where each particle is a tuple with it's (x, y, z) position and
+    it's mass.
 
     Returns
     -------
diff --git a/physics/centripetal_force.py b/physics/centripetal_force.py
index 04069d256468..a4c624582475 100644
--- a/physics/centripetal_force.py
+++ b/physics/centripetal_force.py
@@ -6,7 +6,7 @@
 The unit of centripetal force is newton.
 
 The centripetal force is always directed perpendicular to the
-direction of the object’s displacement. Using Newton’s second
+direction of the object's displacement. Using Newton's second
 law of motion, it is found that the centripetal force of an object
 moving in a circular path always acts towards the centre of the circle.
 The Centripetal Force Formula is given as the product of mass (in kg)
diff --git a/physics/lorentz_transformation_four_vector.py b/physics/lorentz_transformation_four_vector.py
index f4fda4dff8cd..3b0fd83d45df 100644
--- a/physics/lorentz_transformation_four_vector.py
+++ b/physics/lorentz_transformation_four_vector.py
@@ -12,13 +12,13 @@
 with respect to X, then the Lorentz transformation from X to X' is X' = BX,
 where
 
-    | γ  -γβ  0  0|
-B = |-γβ  γ   0  0|
+    | y  -γβ  0  0|
+B = |-γβ  y   0  0|
     | 0   0   1  0|
     | 0   0   0  1|
 
 is the matrix describing the Lorentz boost between X and X',
-γ = 1 / √(1 - v²/c²) is the Lorentz factor, and β = v/c is the velocity as
+y = 1 / √(1 - v²/c²) is the Lorentz factor, and β = v/c is the velocity as
 a fraction of c.
 
 Reference: https://en.wikipedia.org/wiki/Lorentz_transformation
@@ -63,7 +63,7 @@ def beta(velocity: float) -> float:
 
 def gamma(velocity: float) -> float:
     """
-    Calculate the Lorentz factor γ = 1 / √(1 - v²/c²) for a given velocity
+    Calculate the Lorentz factor y = 1 / √(1 - v²/c²) for a given velocity
     >>> gamma(4)
     1.0000000000000002
     >>> gamma(1e5)
@@ -90,12 +90,12 @@ def transformation_matrix(velocity: float) -> np.ndarray:
     """
     Calculate the Lorentz transformation matrix for movement in the x direction:
 
-    | γ  -γβ  0  0|
-    |-γβ  γ   0  0|
+    | y  -γβ  0  0|
+    |-γβ  y   0  0|
     | 0   0   1  0|
     | 0   0   0  1|
 
-    where γ is the Lorentz factor and β is the velocity as a fraction of c
+    where y is the Lorentz factor and β is the velocity as a fraction of c
     >>> transformation_matrix(29979245)
     array([[ 1.00503781, -0.10050378,  0.        ,  0.        ],
            [-0.10050378,  1.00503781,  0.        ,  0.        ],
diff --git a/physics/reynolds_number.py b/physics/reynolds_number.py
index dffe690f8822..c24a9e002855 100644
--- a/physics/reynolds_number.py
+++ b/physics/reynolds_number.py
@@ -8,10 +8,10 @@
 viscous forces.
 
 R = Inertial Forces / Viscous Forces
-R = (ρ * V * D)/μ
+R = (p * V * D)/μ
 
 where :
-ρ = Density of fluid (in Kg/m^3)
+p = Density of fluid (in Kg/m^3)
 D = Diameter of pipe through which fluid flows (in m)
 V = Velocity of flow of the fluid (in m/s)
 μ = Viscosity of the fluid (in Ns/m^2)
diff --git a/physics/terminal_velocity.py b/physics/terminal_velocity.py
index cec54162e2b4..16714bd02671 100644
--- a/physics/terminal_velocity.py
+++ b/physics/terminal_velocity.py
@@ -8,13 +8,13 @@
 object. The acceleration of the object is zero as the net force acting on
 the object is zero.
 
-Vt = ((2 * m * g)/(ρ * A * Cd))^0.5
+Vt = ((2 * m * g)/(p * A * Cd))^0.5
 
 where :
 Vt = Terminal velocity (in m/s)
 m = Mass of the falling object (in Kg)
 g = Acceleration due to gravity (value taken : imported from scipy)
-ρ = Density of the fluid through which the object is falling (in Kg/m^3)
+p = Density of the fluid through which the object is falling (in Kg/m^3)
 A = Projected area of the object (in m^2)
 Cd = Drag coefficient (dimensionless)
 
diff --git a/project_euler/problem_004/sol1.py b/project_euler/problem_004/sol1.py
index f237afdd942d..f80a3253e741 100644
--- a/project_euler/problem_004/sol1.py
+++ b/project_euler/problem_004/sol1.py
@@ -4,7 +4,7 @@
 Largest palindrome product
 
 A palindromic number reads the same both ways. The largest palindrome made
-from the product of two 2-digit numbers is 9009 = 91 × 99.
+from the product of two 2-digit numbers is 9009 = 91 x 99.
 
 Find the largest palindrome made from the product of two 3-digit numbers.
 
diff --git a/project_euler/problem_004/sol2.py b/project_euler/problem_004/sol2.py
index abc880966d58..1fa75e7d0c83 100644
--- a/project_euler/problem_004/sol2.py
+++ b/project_euler/problem_004/sol2.py
@@ -4,7 +4,7 @@
 Largest palindrome product
 
 A palindromic number reads the same both ways. The largest palindrome made
-from the product of two 2-digit numbers is 9009 = 91 × 99.
+from the product of two 2-digit numbers is 9009 = 91 x 99.
 
 Find the largest palindrome made from the product of two 3-digit numbers.
 
diff --git a/project_euler/problem_008/sol1.py b/project_euler/problem_008/sol1.py
index 69dd1b4736c1..adbac8d5ad1f 100644
--- a/project_euler/problem_008/sol1.py
+++ b/project_euler/problem_008/sol1.py
@@ -4,7 +4,7 @@
 Largest product in a series
 
 The four adjacent digits in the 1000-digit number that have the greatest
-product are 9 × 9 × 8 × 9 = 5832.
+product are 9 x 9 x 8 x 9 = 5832.
 
     73167176531330624919225119674426574742355349194934
     96983520312774506326239578318016984801869478851843
diff --git a/project_euler/problem_008/sol2.py b/project_euler/problem_008/sol2.py
index f83cb1db30b6..e48231e4023b 100644
--- a/project_euler/problem_008/sol2.py
+++ b/project_euler/problem_008/sol2.py
@@ -4,7 +4,7 @@
 Largest product in a series
 
 The four adjacent digits in the 1000-digit number that have the greatest
-product are 9 × 9 × 8 × 9 = 5832.
+product are 9 x 9 x 8 x 9 = 5832.
 
     73167176531330624919225119674426574742355349194934
     96983520312774506326239578318016984801869478851843
diff --git a/project_euler/problem_008/sol3.py b/project_euler/problem_008/sol3.py
index bf3bcb05b7e9..0d319b9684dd 100644
--- a/project_euler/problem_008/sol3.py
+++ b/project_euler/problem_008/sol3.py
@@ -4,7 +4,7 @@
 Largest product in a series
 
 The four adjacent digits in the 1000-digit number that have the greatest
-product are 9 × 9 × 8 × 9 = 5832.
+product are 9 x 9 x 8 x 9 = 5832.
 
     73167176531330624919225119674426574742355349194934
     96983520312774506326239578318016984801869478851843
diff --git a/project_euler/problem_015/sol1.py b/project_euler/problem_015/sol1.py
index fd9014a406f6..3c9dae1aed77 100644
--- a/project_euler/problem_015/sol1.py
+++ b/project_euler/problem_015/sol1.py
@@ -1,9 +1,9 @@
 """
 Problem 15: https://projecteuler.net/problem=15
 
-Starting in the top left corner of a 2×2 grid, and only being able to move to
+Starting in the top left corner of a 2x2 grid, and only being able to move to
 the right and down, there are exactly 6 routes to the bottom right corner.
-How many such routes are there through a 20×20 grid?
+How many such routes are there through a 20x20 grid?
 """
 
 from math import factorial
diff --git a/project_euler/problem_020/sol1.py b/project_euler/problem_020/sol1.py
index b472024e54c0..1439bdca38e6 100644
--- a/project_euler/problem_020/sol1.py
+++ b/project_euler/problem_020/sol1.py
@@ -1,9 +1,9 @@
 """
 Problem 20: https://projecteuler.net/problem=20
 
-n! means n × (n − 1) × ... × 3 × 2 × 1
+n! means n x (n - 1) x ... x 3 x 2 x 1
 
-For example, 10! = 10 × 9 × ... × 3 × 2 × 1 = 3628800,
+For example, 10! = 10 x 9 x ... x 3 x 2 x 1 = 3628800,
 and the sum of the digits in the number 10! is 3 + 6 + 2 + 8 + 8 + 0 + 0 = 27.
 
 Find the sum of the digits in the number 100!
diff --git a/project_euler/problem_020/sol2.py b/project_euler/problem_020/sol2.py
index a1d56ade7708..61684cd5ef6d 100644
--- a/project_euler/problem_020/sol2.py
+++ b/project_euler/problem_020/sol2.py
@@ -1,9 +1,9 @@
 """
 Problem 20: https://projecteuler.net/problem=20
 
-n! means n × (n − 1) × ... × 3 × 2 × 1
+n! means n x (n - 1) x ... x 3 x 2 x 1
 
-For example, 10! = 10 × 9 × ... × 3 × 2 × 1 = 3628800,
+For example, 10! = 10 x 9 x ... x 3 x 2 x 1 = 3628800,
 and the sum of the digits in the number 10! is 3 + 6 + 2 + 8 + 8 + 0 + 0 = 27.
 
 Find the sum of the digits in the number 100!
diff --git a/project_euler/problem_020/sol3.py b/project_euler/problem_020/sol3.py
index 1886e05463f4..8984def9c34e 100644
--- a/project_euler/problem_020/sol3.py
+++ b/project_euler/problem_020/sol3.py
@@ -1,9 +1,9 @@
 """
 Problem 20: https://projecteuler.net/problem=20
 
-n! means n × (n − 1) × ... × 3 × 2 × 1
+n! means n x (n - 1) x ... x 3 x 2 x 1
 
-For example, 10! = 10 × 9 × ... × 3 × 2 × 1 = 3628800,
+For example, 10! = 10 x 9 x ... x 3 x 2 x 1 = 3628800,
 and the sum of the digits in the number 10! is 3 + 6 + 2 + 8 + 8 + 0 + 0 = 27.
 
 Find the sum of the digits in the number 100!
diff --git a/project_euler/problem_020/sol4.py b/project_euler/problem_020/sol4.py
index b32ce309dfa6..511ac81e176b 100644
--- a/project_euler/problem_020/sol4.py
+++ b/project_euler/problem_020/sol4.py
@@ -1,9 +1,9 @@
 """
 Problem 20: https://projecteuler.net/problem=20
 
-n! means n × (n − 1) × ... × 3 × 2 × 1
+n! means n x (n - 1) x ... x 3 x 2 x 1
 
-For example, 10! = 10 × 9 × ... × 3 × 2 × 1 = 3628800,
+For example, 10! = 10 x 9 x ... x 3 x 2 x 1 = 3628800,
 and the sum of the digits in the number 10! is 3 + 6 + 2 + 8 + 8 + 0 + 0 = 27.
 
 Find the sum of the digits in the number 100!
diff --git a/project_euler/problem_022/sol1.py b/project_euler/problem_022/sol1.py
index b6386186e7df..c4af5dfa81df 100644
--- a/project_euler/problem_022/sol1.py
+++ b/project_euler/problem_022/sol1.py
@@ -10,7 +10,7 @@
 
 For example, when the list is sorted into alphabetical order, COLIN, which is
 worth 3 + 15 + 12 + 9 + 14 = 53, is the 938th name in the list. So, COLIN would
-obtain a score of 938 × 53 = 49714.
+obtain a score of 938 x 53 = 49714.
 
 What is the total of all the name scores in the file?
 """
diff --git a/project_euler/problem_022/sol2.py b/project_euler/problem_022/sol2.py
index f7092ea1cd12..9c22b6bba0cc 100644
--- a/project_euler/problem_022/sol2.py
+++ b/project_euler/problem_022/sol2.py
@@ -10,7 +10,7 @@
 
 For example, when the list is sorted into alphabetical order, COLIN, which is
 worth 3 + 15 + 12 + 9 + 14 = 53, is the 938th name in the list. So, COLIN would
-obtain a score of 938 × 53 = 49714.
+obtain a score of 938 x 53 = 49714.
 
 What is the total of all the name scores in the file?
 """
diff --git a/project_euler/problem_025/sol1.py b/project_euler/problem_025/sol1.py
index 803464b5d786..b3bbb56d20be 100644
--- a/project_euler/problem_025/sol1.py
+++ b/project_euler/problem_025/sol1.py
@@ -1,7 +1,7 @@
 """
 The Fibonacci sequence is defined by the recurrence relation:
 
-    Fn = Fn−1 + Fn−2, where F1 = 1 and F2 = 1.
+    Fn = Fn-1 + Fn-2, where F1 = 1 and F2 = 1.
 
 Hence the first 12 terms will be:
 
diff --git a/project_euler/problem_025/sol2.py b/project_euler/problem_025/sol2.py
index 9e950b355f7a..a0f056023bc9 100644
--- a/project_euler/problem_025/sol2.py
+++ b/project_euler/problem_025/sol2.py
@@ -1,7 +1,7 @@
 """
 The Fibonacci sequence is defined by the recurrence relation:
 
-    Fn = Fn−1 + Fn−2, where F1 = 1 and F2 = 1.
+    Fn = Fn-1 + Fn-2, where F1 = 1 and F2 = 1.
 
 Hence the first 12 terms will be:
 
diff --git a/project_euler/problem_025/sol3.py b/project_euler/problem_025/sol3.py
index 0b9f3a0c84ef..e33b159ac65c 100644
--- a/project_euler/problem_025/sol3.py
+++ b/project_euler/problem_025/sol3.py
@@ -1,7 +1,7 @@
 """
 The Fibonacci sequence is defined by the recurrence relation:
 
-    Fn = Fn−1 + Fn−2, where F1 = 1 and F2 = 1.
+    Fn = Fn-1 + Fn-2, where F1 = 1 and F2 = 1.
 
 Hence the first 12 terms will be:
 
diff --git a/project_euler/problem_027/sol1.py b/project_euler/problem_027/sol1.py
index c93e2b4fa251..48755ec19763 100644
--- a/project_euler/problem_027/sol1.py
+++ b/project_euler/problem_027/sol1.py
@@ -9,12 +9,12 @@
 It turns out that the formula will produce 40 primes for the consecutive values
 n = 0 to 39. However, when n = 40, 402 + 40 + 41 = 40(40 + 1) + 41 is divisible
 by 41, and certainly when n = 41, 412 + 41 + 41 is clearly divisible by 41.
-The incredible formula  n2 − 79n + 1601 was discovered, which produces 80 primes
-for the consecutive values n = 0 to 79. The product of the coefficients, −79 and
-1601, is −126479.
+The incredible formula  n2 - 79n + 1601 was discovered, which produces 80 primes
+for the consecutive values n = 0 to 79. The product of the coefficients, -79 and
+1601, is -126479.
 Considering quadratics of the form:
 n² + an + b, where |a| &lt; 1000 and |b| &lt; 1000
-where |n| is the modulus/absolute value of ne.g. |11| = 11 and |−4| = 4
+where |n| is the modulus/absolute value of ne.g. |11| = 11 and |-4| = 4
 Find the product of the coefficients, a and b, for the quadratic expression that
 produces the maximum number of primes for consecutive values of n, starting with
 n = 0.
diff --git a/project_euler/problem_031/sol1.py b/project_euler/problem_031/sol1.py
index ba40cf383175..4c9c533eecb7 100644
--- a/project_euler/problem_031/sol1.py
+++ b/project_euler/problem_031/sol1.py
@@ -2,14 +2,14 @@
 Coin sums
 Problem 31: https://projecteuler.net/problem=31
 
-In England the currency is made up of pound, £, and pence, p, and there are
+In England the currency is made up of pound, f, and pence, p, and there are
 eight coins in general circulation:
 
-1p, 2p, 5p, 10p, 20p, 50p, £1 (100p) and £2 (200p).
-It is possible to make £2 in the following way:
+1p, 2p, 5p, 10p, 20p, 50p, f1 (100p) and f2 (200p).
+It is possible to make f2 in the following way:
 
-1×£1 + 1×50p + 2×20p + 1×5p + 1×2p + 3×1p
-How many different ways can £2 be made using any number of coins?
+1xf1 + 1x50p + 2x20p + 1x5p + 1x2p + 3x1p
+How many different ways can f2 be made using any number of coins?
 """
 
 
diff --git a/project_euler/problem_031/sol2.py b/project_euler/problem_031/sol2.py
index f9e4dc384bff..574f8d4107a1 100644
--- a/project_euler/problem_031/sol2.py
+++ b/project_euler/problem_031/sol2.py
@@ -3,17 +3,17 @@
 
 Coin sums
 
-In England the currency is made up of pound, £, and pence, p, and there are
+In England the currency is made up of pound, f, and pence, p, and there are
 eight coins in general circulation:
 
-1p, 2p, 5p, 10p, 20p, 50p, £1 (100p) and £2 (200p).
-It is possible to make £2 in the following way:
+1p, 2p, 5p, 10p, 20p, 50p, f1 (100p) and f2 (200p).
+It is possible to make f2 in the following way:
 
-1×£1 + 1×50p + 2×20p + 1×5p + 1×2p + 3×1p
-How many different ways can £2 be made using any number of coins?
+1xf1 + 1x50p + 2x20p + 1x5p + 1x2p + 3x1p
+How many different ways can f2 be made using any number of coins?
 
 Hint:
-    > There are 100 pence in a pound (£1 = 100p)
+    > There are 100 pence in a pound (f1 = 100p)
     > There are coins(in pence) are available: 1, 2, 5, 10, 20, 50, 100 and 200.
     > how many different ways you can combine these values to create 200 pence.
 
diff --git a/project_euler/problem_032/sol32.py b/project_euler/problem_032/sol32.py
index a402b5584061..c0ca2ce10791 100644
--- a/project_euler/problem_032/sol32.py
+++ b/project_euler/problem_032/sol32.py
@@ -3,7 +3,7 @@
 digits 1 to n exactly once; for example, the 5-digit number, 15234, is 1 through
 5 pandigital.
 
-The product 7254 is unusual, as the identity, 39 × 186 = 7254, containing
+The product 7254 is unusual, as the identity, 39 x 186 = 7254, containing
 multiplicand, multiplier, and product is 1 through 9 pandigital.
 
 Find the sum of all products whose multiplicand/multiplier/product identity can
diff --git a/project_euler/problem_038/sol1.py b/project_euler/problem_038/sol1.py
index 5bef273ea2a9..382892723b7d 100644
--- a/project_euler/problem_038/sol1.py
+++ b/project_euler/problem_038/sol1.py
@@ -3,9 +3,9 @@
 
 Take the number 192 and multiply it by each of 1, 2, and 3:
 
-192 × 1 = 192
-192 × 2 = 384
-192 × 3 = 576
+192 x 1 = 192
+192 x 2 = 384
+192 x 3 = 576
 
 By concatenating each product we get the 1 to 9 pandigital, 192384576. We will call
 192384576 the concatenated product of 192 and (1,2,3)
diff --git a/project_euler/problem_040/sol1.py b/project_euler/problem_040/sol1.py
index 69be377723a5..721bd063c28a 100644
--- a/project_euler/problem_040/sol1.py
+++ b/project_euler/problem_040/sol1.py
@@ -11,7 +11,7 @@
 If dn represents the nth digit of the fractional part, find the value of the
 following expression.
 
-d1 × d10 × d100 × d1000 × d10000 × d100000 × d1000000
+d1 x d10 x d100 x d1000 x d10000 x d100000 x d1000000
 """
 
 
diff --git a/project_euler/problem_044/sol1.py b/project_euler/problem_044/sol1.py
index 3b75b6a56a8e..2613563a4bf1 100644
--- a/project_euler/problem_044/sol1.py
+++ b/project_euler/problem_044/sol1.py
@@ -1,14 +1,14 @@
 """
 Problem 44: https://projecteuler.net/problem=44
 
-Pentagonal numbers are generated by the formula, Pn=n(3n−1)/2. The first ten
+Pentagonal numbers are generated by the formula, Pn=n(3n-1)/2. The first ten
 pentagonal numbers are:
 1, 5, 12, 22, 35, 51, 70, 92, 117, 145, ...
 It can be seen that P4 + P7 = 22 + 70 = 92 = P8. However, their difference,
-70 − 22 = 48, is not pentagonal.
+70 - 22 = 48, is not pentagonal.
 
 Find the pair of pentagonal numbers, Pj and Pk, for which their sum and difference
-are pentagonal and D = |Pk − Pj| is minimised; what is the value of D?
+are pentagonal and D = |Pk - Pj| is minimised; what is the value of D?
 """
 
 
diff --git a/project_euler/problem_045/sol1.py b/project_euler/problem_045/sol1.py
index d921b2802c2d..8d016de6e542 100644
--- a/project_euler/problem_045/sol1.py
+++ b/project_euler/problem_045/sol1.py
@@ -3,8 +3,8 @@
 
 Triangle, pentagonal, and hexagonal numbers are generated by the following formulae:
 Triangle	 	T(n) = (n * (n + 1)) / 2	 	1, 3, 6, 10, 15, ...
-Pentagonal	 	P(n) = (n * (3 * n − 1)) / 2	 	1, 5, 12, 22, 35, ...
-Hexagonal	 	H(n) = n * (2 * n − 1)	 	1, 6, 15, 28, 45, ...
+Pentagonal	 	P(n) = (n * (3 * n - 1)) / 2	 	1, 5, 12, 22, 35, ...
+Hexagonal	 	H(n) = n * (2 * n - 1)	 	1, 6, 15, 28, 45, ...
 It can be verified that T(285) = P(165) = H(143) = 40755.
 
 Find the next triangle number that is also pentagonal and hexagonal.
diff --git a/project_euler/problem_046/sol1.py b/project_euler/problem_046/sol1.py
index 07dd9bbf84c8..f27f658e63e5 100644
--- a/project_euler/problem_046/sol1.py
+++ b/project_euler/problem_046/sol1.py
@@ -4,12 +4,12 @@
 It was proposed by Christian Goldbach that every odd composite number can be
 written as the sum of a prime and twice a square.
 
-9 = 7 + 2 × 12
-15 = 7 + 2 × 22
-21 = 3 + 2 × 32
-25 = 7 + 2 × 32
-27 = 19 + 2 × 22
-33 = 31 + 2 × 12
+9 = 7 + 2 x 12
+15 = 7 + 2 x 22
+21 = 3 + 2 x 32
+25 = 7 + 2 x 32
+27 = 19 + 2 x 22
+33 = 31 + 2 x 12
 
 It turns out that the conjecture was false.
 
diff --git a/project_euler/problem_047/sol1.py b/project_euler/problem_047/sol1.py
index 1287e0d9e107..c9c44a9832dd 100644
--- a/project_euler/problem_047/sol1.py
+++ b/project_euler/problem_047/sol1.py
@@ -5,14 +5,14 @@
 
 The first two consecutive numbers to have two distinct prime factors are:
 
-14 = 2 × 7
-15 = 3 × 5
+14 = 2 x 7
+15 = 3 x 5
 
 The first three consecutive numbers to have three distinct prime factors are:
 
-644 = 2² × 7 × 23
-645 = 3 × 5 × 43
-646 = 2 × 17 × 19.
+644 = 2² x 7 x 23
+645 = 3 x 5 x 43
+646 = 2 x 17 x 19.
 
 Find the first four consecutive integers to have four distinct prime factors each.
 What is the first of these numbers?
diff --git a/project_euler/problem_053/sol1.py b/project_euler/problem_053/sol1.py
index a32b73c545d6..192cbf25e50c 100644
--- a/project_euler/problem_053/sol1.py
+++ b/project_euler/problem_053/sol1.py
@@ -10,7 +10,7 @@
 
 In general,
 
-nCr = n!/(r!(n−r)!),where r ≤ n, n! = n×(n−1)×...×3×2×1, and 0! = 1.
+nCr = n!/(r!(n-r)!),where r ≤ n, n! = nx(n-1)x...x3x2x1, and 0! = 1.
 It is not until n = 23, that a value exceeds one-million: 23C10 = 1144066.
 
 How many, not necessarily distinct, values of nCr, for 1 ≤ n ≤ 100, are greater
diff --git a/project_euler/problem_097/sol1.py b/project_euler/problem_097/sol1.py
index 2807e893ded0..a349f3a1dbc9 100644
--- a/project_euler/problem_097/sol1.py
+++ b/project_euler/problem_097/sol1.py
@@ -1,7 +1,7 @@
 """
 The first known prime found to exceed one million digits was discovered in 1999,
-and is a Mersenne prime of the form 2**6972593 − 1; it contains exactly 2,098,960
-digits. Subsequently other Mersenne primes, of the form 2**p − 1, have been found
+and is a Mersenne prime of the form 2**6972593 - 1; it contains exactly 2,098,960
+digits. Subsequently other Mersenne primes, of the form 2**p - 1, have been found
 which contain more digits.
 However, in 2004 there was found a massive non-Mersenne prime which contains
 2,357,207 digits: (28433 * (2 ** 7830457 + 1)).
diff --git a/project_euler/problem_104/sol1.py b/project_euler/problem_104/sol1.py
index d84dbcfc9c65..a0267faa6a38 100644
--- a/project_euler/problem_104/sol1.py
+++ b/project_euler/problem_104/sol1.py
@@ -3,7 +3,7 @@
 
 The Fibonacci sequence is defined by the recurrence relation:
 
-Fn = Fn−1 + Fn−2, where F1 = 1 and F2 = 1.
+Fn = Fn-1 + Fn-2, where F1 = 1 and F2 = 1.
 It turns out that F541, which contains 113 digits, is the first Fibonacci number
 for which the last nine digits are 1-9 pandigital (contain all the digits 1 to 9,
 but not necessarily in order). And F2749, which contains 575 digits, is the first
diff --git a/project_euler/problem_120/sol1.py b/project_euler/problem_120/sol1.py
index 0e6821214560..2f403972502f 100644
--- a/project_euler/problem_120/sol1.py
+++ b/project_euler/problem_120/sol1.py
@@ -3,7 +3,7 @@
 
 Description:
 
-Let r be the remainder when (a−1)^n + (a+1)^n is divided by a^2.
+Let r be the remainder when (a-1)^n + (a+1)^n is divided by a^2.
 For example, if a = 7 and n = 3, then r = 42: 6^3 + 8^3 = 728 ≡ 42 mod 49.
 And as n varies, so too will r, but for a = 7 it turns out that r_max = 42.
 For 3 ≤ a ≤ 1000, find ∑ r_max.
diff --git a/project_euler/problem_123/sol1.py b/project_euler/problem_123/sol1.py
index 7239e13a51e9..3dd31a2e8505 100644
--- a/project_euler/problem_123/sol1.py
+++ b/project_euler/problem_123/sol1.py
@@ -4,7 +4,7 @@
 Name: Prime square remainders
 
 Let pn be the nth prime: 2, 3, 5, 7, 11, ..., and
-let r be the remainder when (pn−1)^n + (pn+1)^n is divided by pn^2.
+let r be the remainder when (pn-1)^n + (pn+1)^n is divided by pn^2.
 
 For example, when n = 3, p3 = 5, and 43 + 63 = 280 ≡ 5 mod 25.
 The least value of n for which the remainder first exceeds 10^9 is 7037.
diff --git a/project_euler/problem_135/sol1.py b/project_euler/problem_135/sol1.py
index ac91fa4e2b9d..d57ace489191 100644
--- a/project_euler/problem_135/sol1.py
+++ b/project_euler/problem_135/sol1.py
@@ -3,9 +3,9 @@
 
 Given the positive integers, x, y, and z, are consecutive terms of an arithmetic
 progression, the least value of the positive integer, n, for which the equation,
-x2 − y2 − z2 = n, has exactly two solutions is n = 27:
+x2 - y2 - z2 = n, has exactly two solutions is n = 27:
 
-342 − 272 − 202 = 122 − 92 − 62 = 27
+342 - 272 - 202 = 122 - 92 - 62 = 27
 
 It turns out that n = 1155 is the least value which has exactly ten solutions.
 
diff --git a/project_euler/problem_144/sol1.py b/project_euler/problem_144/sol1.py
index bc16bf985f41..9070455de79f 100644
--- a/project_euler/problem_144/sol1.py
+++ b/project_euler/problem_144/sol1.py
@@ -6,7 +6,7 @@
 The specific white cell we will be considering is an ellipse with the equation
 4x^2 + y^2 = 100
 
-The section corresponding to −0.01 ≤ x ≤ +0.01 at the top is missing, allowing the
+The section corresponding to -0.01 ≤ x ≤ +0.01 at the top is missing, allowing the
 light to enter and exit through the hole.
 
 The light beam in this problem starts at the point (0.0,10.1) just outside the white
@@ -20,7 +20,7 @@
 the laser beam and the wall of the white cell; the blue line shows the line tangent to
 the ellipse at the point of incidence of the first bounce.
 
-The slope m of the tangent line at any point (x,y) of the given ellipse is: m = −4x/y
+The slope m of the tangent line at any point (x,y) of the given ellipse is: m = -4x/y
 
 The normal line is perpendicular to this tangent line at the point of incidence.
 
diff --git a/project_euler/problem_174/sol1.py b/project_euler/problem_174/sol1.py
index 33c1b158adbb..9a75e8638880 100644
--- a/project_euler/problem_174/sol1.py
+++ b/project_euler/problem_174/sol1.py
@@ -14,7 +14,7 @@
 Let N(n) be the number of t ≤ 1000000 such that t is type L(n); for example,
 N(15) = 832.
 
-What is ∑ N(n) for 1 ≤ n ≤ 10?
+What is sum N(n) for 1 ≤ n ≤ 10?
 """
 
 from collections import defaultdict
diff --git a/pyproject.toml b/pyproject.toml
index 0185f4d7b987..ff22fba81c8a 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -10,6 +10,7 @@ lint.ignore = [    # `ruff rule S101` for a description of that rule
   "PLW2901",  # PLW2901: Redefined loop variable -- FIX ME
   "PT011",    # `pytest.raises(Exception)` is too broad, set the `match` parameter or use a more specific exception
   "PT018",    # Assertion should be broken down into multiple parts
+  "RUF001",   # String contains ambiguous {}. Did you mean {}?
   "RUF002",   # Docstring contains ambiguous {}. Did you mean {}?
   "RUF003",   # Comment contains ambiguous {}. Did you mean {}?
   "S101",     # Use of `assert` detected -- DO NOT FIX
diff --git a/strings/jaro_winkler.py b/strings/jaro_winkler.py
index c18f0d85d9f4..cae2068fabc1 100644
--- a/strings/jaro_winkler.py
+++ b/strings/jaro_winkler.py
@@ -3,7 +3,7 @@
 
 def jaro_winkler(str1: str, str2: str) -> float:
     """
-    Jaro–Winkler distance is a string metric measuring an edit distance between two
+    Jaro-Winkler distance is a string metric measuring an edit distance between two
     sequences.
     Output value is between 0.0 and 1.0.
 
diff --git a/strings/manacher.py b/strings/manacher.py
index fc8b01cd9c1c..af1b10cf81fb 100644
--- a/strings/manacher.py
+++ b/strings/manacher.py
@@ -5,7 +5,7 @@ def palindromic_string(input_string: str) -> str:
     >>> palindromic_string('ababa')
     'ababa'
 
-    Manacher’s algorithm which finds Longest palindromic Substring in linear time.
+    Manacher's algorithm which finds Longest palindromic Substring in linear time.
 
     1. first this convert input_string("xyx") into new_string("x|y|x") where odd
         positions are actual input characters.
diff --git a/strings/prefix_function.py b/strings/prefix_function.py
index 65bbe9100735..04987deef469 100644
--- a/strings/prefix_function.py
+++ b/strings/prefix_function.py
@@ -1,7 +1,7 @@
 """
 https://cp-algorithms.com/string/prefix-function.html
 
-Prefix function Knuth–Morris–Pratt algorithm
+Prefix function Knuth-Morris-Pratt algorithm
 
 Different algorithm than Knuth-Morris-Pratt pattern finding