diff --git a/Ciphers/CaesarCipher.php b/Ciphers/CaesarCipher.php
index 3af47ffe..18182f3d 100755
--- a/Ciphers/CaesarCipher.php
+++ b/Ciphers/CaesarCipher.php
@@ -3,8 +3,8 @@
 /**
  * Encrypt given text using caesar cipher.
  *
- * @param string text text to be encrypted
- * @param int shift number of shifts to be applied
+ * @param string  $text  text text to be encrypted
+ * @param int  $shift  shift number of shifts to be applied
  * @return string new encrypted text
  */
 function encrypt(string $text, int $shift): string
@@ -27,8 +27,8 @@ function encrypt(string $text, int $shift): string
 
 /**
  * Decrypt given text using caesar cipher.
- * @param string text text to be decrypted
- * @param int shift number of shifts to be applied
+ * @param string  $text  text text to be decrypted
+ * @param int  $shift  shift number of shifts to be applied
  * @return string new decrypted text
  */
 function decrypt(string $text, int $shift): string
diff --git a/Ciphers/MonoAlphabeticCipher.php b/Ciphers/MonoAlphabeticCipher.php
index 0810a4a5..6b362dbe 100644
--- a/Ciphers/MonoAlphabeticCipher.php
+++ b/Ciphers/MonoAlphabeticCipher.php
@@ -1,32 +1,34 @@
-<?php
-// A mono-alphabetic cipher is a simple substitution cipher
-// https://www.101computing.net/mono-alphabetic-substitution-cipher/
-
-function monoAlphabeticCipher($key, $alphabet, $text){
-
-    $cipherText = ''; // the cipher text (can be decrypted and encrypted)
-
-    if ( strlen($key) != strlen($alphabet) ) { return false; } // check if the text length matches
-    $text = preg_replace('/[0-9]+/', '', $text); // remove all the numbers
-    
-    for( $i = 0; $i < strlen($text); $i++ ){
-        $index = strripos( $alphabet, $text[$i] );
-        if( $text[$i] == " " ){ $cipherText .= " "; }
-        else{ $cipherText .= ( ctype_upper($text[$i]) ? strtoupper($key[$index]) : $key[$index] ); }
-    }
-    return $cipherText;
-}
-
-function maEncrypt($key, $alphabet, $text){
-
-    return monoAlphabeticCipher($key, $alphabet, $text);
-
-}
-
-function maDecrypt($key, $alphabet, $text){
-
-    return monoAlphabeticCipher($alphabet, $key, $text);
-
-}
-
-?> 
\ No newline at end of file
+<?php
+
+// A mono-alphabetic cipher is a simple substitution cipher
+// https://www.101computing.net/mono-alphabetic-substitution-cipher/
+
+function monoAlphabeticCipher($key, $alphabet, $text)
+{
+    $cipherText = ''; // the cipher text (can be decrypted and encrypted)
+
+    if (strlen($key) != strlen($alphabet)) {
+        return false;
+    } // check if the text length matches
+    $text = preg_replace('/[0-9]+/', '', $text); // remove all the numbers
+
+    for ($i = 0; $i < strlen($text); $i++) {
+        $index = strripos($alphabet, $text[$i]);
+        if ($text[$i] == " ") {
+            $cipherText .= " ";
+        } else {
+            $cipherText .= ( ctype_upper($text[$i]) ? strtoupper($key[$index]) : $key[$index] );
+        }
+    }
+    return $cipherText;
+}
+
+function maEncrypt($key, $alphabet, $text)
+{
+    return monoAlphabeticCipher($key, $alphabet, $text);
+}
+
+function maDecrypt($key, $alphabet, $text)
+{
+    return monoAlphabeticCipher($alphabet, $key, $text);
+}
diff --git a/Ciphers/MorseCode.php b/Ciphers/MorseCode.php
index 4d1db31a..854e0db1 100644
--- a/Ciphers/MorseCode.php
+++ b/Ciphers/MorseCode.php
@@ -3,8 +3,9 @@
 /**
  * Encode text to Morse Code.
  *
- * @param string text to encode
+ * @param  string  $text  text to encode
  * @return string encoded text
+ * @throws \Exception
  */
 function encode(string $text): string
 {
@@ -57,13 +58,14 @@ function encode(string $text): string
             throw new \Exception("Invalid character: $c");
         }
     }
-    substr_replace($encodedText ,"", -1); // Removes trailing space
+    substr_replace($encodedText, "", -1); // Removes trailing space
     return $encodedText;
 }
 
 /**
  * Decode Morse Code to text.
- * @param string text to decode
+ * @param  string  $text  text to decode
+ * @throws \Exception
  */
 function decode(string $text): string
 {
diff --git a/Ciphers/XORCipher.php b/Ciphers/XORCipher.php
index 4216b5bc..c5583b80 100644
--- a/Ciphers/XORCipher.php
+++ b/Ciphers/XORCipher.php
@@ -7,18 +7,16 @@
  * character with the key.
  * The key is repeated until it is the same length as the input.
  *
- * @param string $input The input string.
+ * @param string $input_string The input string.
  * @param string $key The key to use.
  * @return string The encrypted string.
  */
 function xorCipher(string $input_string, string $key)
 {
-
     $key_len = strlen($key);
     $result = array();
 
-    for ($idx = 0; $idx < strlen($input_string); $idx++)
-    {
+    for ($idx = 0; $idx < strlen($input_string); $idx++) {
         array_push($result, $input_string[$idx] ^ $key[$idx % $key_len]);
     }
 
diff --git a/Conversions/BinaryToDecimal.php b/Conversions/BinaryToDecimal.php
index a8e2c2ea..411c22a3 100644
--- a/Conversions/BinaryToDecimal.php
+++ b/Conversions/BinaryToDecimal.php
@@ -11,8 +11,9 @@
  * (2 + 0) base 10
  * 2 base 10
  *
- * @param string $binaryNumber
+ * @param  string  $binaryNumber
  * @return int
+ * @throws \Exception
  */
 function binaryToDecimal($binaryNumber)
 {
diff --git a/Conversions/DecimalToBinary.php b/Conversions/DecimalToBinary.php
index d8a7573a..89d7accd 100644
--- a/Conversions/DecimalToBinary.php
+++ b/Conversions/DecimalToBinary.php
@@ -5,8 +5,9 @@
  * submitted Decimal Number to
  * Binary Number.
  *
- * @param string $decimalNumber
+ * @param  string  $decimalNumber
  * @return string
+ * @throws \Exception
  */
 function decimalToBinary($decimalNumber)
 {
diff --git a/Conversions/OctalToDecimal.php b/Conversions/OctalToDecimal.php
index 5bc6125e..8172de21 100644
--- a/Conversions/OctalToDecimal.php
+++ b/Conversions/OctalToDecimal.php
@@ -10,8 +10,9 @@
  * (1 * (8 ^ 1) + 0 * (8 ^ 0)) base 10
  * (8 + 0) base 10
  * 9 base 10
- * @param string $octalNumber
+ * @param  string  $octalNumber
  * @return int
+ * @throws \Exception
  */
 function octalToDecimal($octalNumber)
 {
@@ -34,8 +35,9 @@ function octalToDecimal($octalNumber)
  * submitted Decimal Number to
  * Octal Number.
  *
- * @param string $decimalNumber
+ * @param  string  $decimalNumber
  * @return string
+ * @throws \Exception
  */
 function decimalToOctal($decimalNumber)
 {
diff --git a/Conversions/SpeedConversion.php b/Conversions/SpeedConversion.php
index 3d70c98a..1c8fddbe 100644
--- a/Conversions/SpeedConversion.php
+++ b/Conversions/SpeedConversion.php
@@ -14,25 +14,26 @@
  * kn -> 1 knot which is equal to 1 nautical mile (1852 km/h)
  * The conversion is made using kilometers as base
  *
- * @param float $speed
- * @param string $unitFrom
- * @param string $unitTo
- * @return int
+ * @param  float  $speed
+ * @param  string  $unitFrom
+ * @param  string  $unitTo
+ * @return float
+ * @throws \Exception
  */
 function convertSpeed(float $speed, string $unitFrom, string $unitTo)
 {
     $speedUnitsFrom = [
         'mph' => 1.609344,
         'km/h' => 1,
-        'm/s'=> 3.6,
-        'ft/s'=> 1.097,
+        'm/s' => 3.6,
+        'ft/s' => 1.097,
         'kn' => 1.852,
     ];
     $speedUnitsTo = [
         'mph' => 0.6213712,
         'km/h' => 1,
-        'm/s'=> 0.277778,
-        'ft/s'=> 0.911344,
+        'm/s' => 0.277778,
+        'ft/s' => 0.911344,
         'kn' => 0.539957,
     ];
     $availableUnits = array_keys($speedUnitsFrom);
diff --git a/DataStructures/SinglyLinkedList.php b/DataStructures/SinglyLinkedList.php
index 44621d60..7256ed7d 100644
--- a/DataStructures/SinglyLinkedList.php
+++ b/DataStructures/SinglyLinkedList.php
@@ -1,13 +1,12 @@
 <?php
+
 /**
  *  Singly Linked List
  */
-
 class SinglyLinkedList
 {
     public ?SinglyLinkedList $next = null;
     public $data;
-
     public function __construct($data)
     {
         $this->data = $data;
@@ -16,7 +15,6 @@ public function __construct($data)
     public function append($data): void
     {
         $current = $this;
-
         while ($current instanceof SinglyLinkedList && isset($current->next)) {
             $current = $current->next;
         }
@@ -27,7 +25,6 @@ public function append($data): void
     public function delete($data): SinglyLinkedList
     {
         $current = $this;
-
         if ($current->data == $data) {
             return $current->next;
         }
@@ -35,7 +32,6 @@ public function delete($data): SinglyLinkedList
         while ($current instanceof SinglyLinkedList && isset($current->next)) {
             if ($current->next->data === $data) {
                 $current->next = $current->next->next;
-
                 return $this;
             }
 
diff --git a/Graphs/BreadthFirstSearch.php b/Graphs/BreadthFirstSearch.php
index 44110114..68579e10 100644
--- a/Graphs/BreadthFirstSearch.php
+++ b/Graphs/BreadthFirstSearch.php
@@ -3,21 +3,22 @@
 /**
  * Breadth-first search (BFS) is an algorithm for searching a tree data structure for a node that satisfies a given property.
  * (https://en.wikipedia.org/wiki/Breadth-first_search).
- * 
- * This is a non recursive implementation.
- * 
+ *
+ * This is a non-recursive implementation.
+ *
  * References:
  * https://cp-algorithms.com/graph/breadth-first-search.html
- * 
+ *
  * https://the-algorithms.com/algorithm/depth-first-search?lang=python
- * 
+ *
  * @author Aryansh Bhargavan https://github.com/aryanshb
  * @param array $adjList An array representing the grapth as an Adjacent List
  * @param int|string $start The starting vertex
  * @return bool if path between start and end vertex exists
  */
 
-function bfs($adjList, $start, $end, $yes = false){
+function bfs($adjList, $start, $end, $yes = false)
+{
     $visited = [];
     $queue = [$start];
     while (!empty($queue)) {
diff --git a/Graphs/DepthFirstSearch.php b/Graphs/DepthFirstSearch.php
index 936484ce..3a8dea51 100644
--- a/Graphs/DepthFirstSearch.php
+++ b/Graphs/DepthFirstSearch.php
@@ -1,20 +1,20 @@
 <?php
 
 /**
- * The Depth-first Search is an algorithm used for traversing or searching trees or graphs 
+ * The Depth-first Search is an algorithm used for traversing or searching trees or graphs
  * (https://en.wikipedia.org/wiki/Depth-first_search).
- * 
- * This is a non recursive implementation.
- * 
+ *
+ * This is a non-recursive implementation.
+ *
  * References:
  * https://www.geeksforgeeks.org/depth-first-search-or-dfs-for-a-graph/
- * 
+ *
  * https://the-algorithms.com/algorithm/depth-first-search?lang=python
- * 
+ *
  * @author Andre Alves https://github.com/andremralves
  * @param array $adjList An array representing the grapth as an Adjacent List
  * @param int|string $start The starting vertex
- * @return array The visited vertices 
+ * @return array The visited vertices
  */
 function dfs($adjList, $start)
 {
@@ -27,8 +27,9 @@ function dfs($adjList, $start)
 
         // Checks each adjacent vertex of $v and add to the stack if not visited
         foreach (array_reverse($adjList[$v]) as $adj) {
-            if (!array_key_exists($adj, $visited))
+            if (!array_key_exists($adj, $visited)) {
                 array_push($stack, $adj);
+            }
         }
     }
     return array_keys($visited);
diff --git a/Maths/AbsoluteMax.php b/Maths/AbsoluteMax.php
index a15ac03a..b5267316 100644
--- a/Maths/AbsoluteMax.php
+++ b/Maths/AbsoluteMax.php
@@ -1,12 +1,14 @@
 <?php
+
 /**
  * This function calculates
  * Absolute max values from
  * the different numbers
  * provided
  *
- * @param decimal $numbers A variable sized number input
+ * @param  decimal  $numbers  A variable sized number input
  * @return decimal $absoluteMax Absolute max value
+ * @throws \Exception
  */
 function absolute_max(...$numbers)
 {
diff --git a/Maths/AbsoluteMin.php b/Maths/AbsoluteMin.php
index 79bc479a..36398689 100644
--- a/Maths/AbsoluteMin.php
+++ b/Maths/AbsoluteMin.php
@@ -1,12 +1,14 @@
 <?php
+
 /**
  * This function calculates
  * Absolute min values from
  * the different numbers
  * provided.
  *
- * @param decimal $numbers A variable sized number input
+ * @param  decimal  $numbers  A variable sized number input
  * @return decimal $absoluteMin Absolute min value
+ * @throws \Exception
  */
 function absolute_min(...$numbers)
 {
diff --git a/Maths/ArmstrongNumber.php b/Maths/ArmstrongNumber.php
index d19082b5..baa16048 100644
--- a/Maths/ArmstrongNumber.php
+++ b/Maths/ArmstrongNumber.php
@@ -1,4 +1,5 @@
 <?php
+
 /**
  * This function checks if given number is Armstrong
  * e.g. 153
@@ -7,16 +8,14 @@
  */
 function isNumberArmstrong(int $input): bool
 {
-  $arr = array_map('intval', str_split($input));
-  $sumOfCubes = 0;
-  foreach ($arr as $num) {
-    $sumOfCubes += $num * $num * $num;
-  }
-  if ($sumOfCubes == $input) {
-    return true;
-  }
-  else {
-    return false;
-  }
+    $arr = array_map('intval', str_split($input));
+    $sumOfCubes = 0;
+    foreach ($arr as $num) {
+        $sumOfCubes += $num * $num * $num;
+    }
+    if ($sumOfCubes == $input) {
+        return true;
+    } else {
+        return false;
+    }
 }
-?>
diff --git a/Maths/CheckPalindrome.php b/Maths/CheckPalindrome.php
index 574e3407..d76b6da8 100644
--- a/Maths/CheckPalindrome.php
+++ b/Maths/CheckPalindrome.php
@@ -1,4 +1,5 @@
 <?php
+
 /**
  * This function checks if given number is palindromic
  * e.g. 121
@@ -7,14 +8,12 @@
  */
 function isNumberPalindromic(int $input): bool
 {
-  $arr = array_map('intval', str_split($input));
-  $arrRev = array_reverse($arr);
-  $inputRev = (int)implode("", $arrRev);
-  if ($input == $inputRev) {
-    return true;
-  }
-  else {
-    return false;
-  }
+    $arr = array_map('intval', str_split($input));
+    $arrRev = array_reverse($arr);
+    $inputRev = (int)implode("", $arrRev);
+    if ($input == $inputRev) {
+        return true;
+    } else {
+        return false;
+    }
 }
-?>
diff --git a/Maths/CheckPrime.php b/Maths/CheckPrime.php
index 64630435..f9d14522 100644
--- a/Maths/CheckPrime.php
+++ b/Maths/CheckPrime.php
@@ -1,4 +1,5 @@
 <?php
+
 /**
  * This function check whether
  * the provided integer is a prime
diff --git a/Maths/Factorial.php b/Maths/Factorial.php
index 8dc08c94..cce08d68 100644
--- a/Maths/Factorial.php
+++ b/Maths/Factorial.php
@@ -1,30 +1,34 @@
 <?php
+
 /**
  * This function calculates
  * and returns the factorial
  * of provided positive integer
  * number.
  *
- * @param Integer $number Integer input
+ * @param  Integer  $number  Integer input
  * @return Integer Factorial of the input
+ * @throws \Exception
  */
 function factorial(int $number)
 {
-    static $cache = [];//internal caching memory for speed
+    static $cache = [];
+//internal caching memory for speed
 
     if ($number < 0) {
         throw new \Exception("Negative numbers are not allowed for calculating Factorial");
     }
     if ($number === 0) {
-        return 1; // Factorial of 0 is 1
+        return 1;
+// Factorial of 0 is 1
     }
-    
+
     if (isset($cache[$number])) {
         return $cache[$number];
     }
 
-    $fact = ($number * factorial($number - 1)); // Recursion since x! = x * (x-1)!
+    $fact = ($number * factorial($number - 1));
+// Recursion since x! = x * (x-1)!
     $cache[$number] = $fact;
-
     return $fact;
 }
diff --git a/Maths/FastExponentiation.php b/Maths/FastExponentiation.php
index a2043c33..6ddaa4b8 100644
--- a/Maths/FastExponentiation.php
+++ b/Maths/FastExponentiation.php
@@ -1,4 +1,5 @@
 <?php
+
 /**
  * This functions computes an exponent by doing repeated squares
  *
@@ -9,16 +10,16 @@
 function fastExponentiation(int $base, int $exponent)
 {
     if ($exponent == 0) {
-		return 1;
-	}
+        return 1;
+    }
 
-	if ($exponent == 1) {
-		return $base;
-	}
+    if ($exponent == 1) {
+        return $base;
+    }
 
-	if ($exponent % 2 == 0) {
-		return fastExponentiation($base*$base, $exponent/2);
-	} else {
-		return $base * fastExponentiation($base*$base, ($exponent-1)/2);
-	}
+    if ($exponent % 2 == 0) {
+        return fastExponentiation($base * $base, $exponent / 2);
+    } else {
+        return $base * fastExponentiation($base * $base, ($exponent - 1) / 2);
+    }
 }
diff --git a/Maths/Fibonacci.php b/Maths/Fibonacci.php
index 975db26b..bc6b7062 100644
--- a/Maths/Fibonacci.php
+++ b/Maths/Fibonacci.php
@@ -3,8 +3,9 @@
 /**
  * Fibonacci recursive
  *
- * @param int $num
- * @return int
+ * @param  int  $num
+ * @return array
+ * @throws \Exception
  */
 function fibonacciRecursive(int $num)
 {
@@ -20,8 +21,9 @@ function fibonacciRecursive(int $num)
 }
 
 /**
- * @param int $num
+ * @param  int  $num
  * @return int
+ * @throws \Exception
  */
 function recursive(int $num)
 {
@@ -36,6 +38,9 @@ function recursive(int $num)
     }
 }
 
+/**
+ * @throws \Exception
+ */
 function fibonacciWithBinetFormula(int $num)
 {
     /*
@@ -57,7 +62,6 @@ function fibonacciWithBinetFormula(int $num)
             $seriesNumber = (pow($phi_1, $n) - pow($phi_2, $n)) / $sqrt;
             array_push($fib_series, (int)$seriesNumber);
         }
-
     }
 
     return $fib_series;
diff --git a/Maths/Fibonacci2.php b/Maths/Fibonacci2.php
index c7dff110..942ec691 100644
--- a/Maths/Fibonacci2.php
+++ b/Maths/Fibonacci2.php
@@ -10,8 +10,7 @@
   */
 function loop($i, Generator $set)
 {
-    while($i-- > 0 && $set->valid())
-    {
+    while ($i-- > 0 && $set->valid()) {
         yield $set->current();
         $set->next();
     }
@@ -25,8 +24,7 @@ function fib()
     yield $i = 0;
     yield $j = 1;
 
-    while(true)
-    {
+    while (true) {
         yield $k = $i + $j;
         $i = $j;
         $j = $k;
@@ -36,7 +34,6 @@ function fib()
 /*
  * Generate 100 Fibonacci numbers
  */
-foreach(loop(100, fib()) as $item)
-{
-    print($item.',');
-}
\ No newline at end of file
+foreach (loop(100, fib()) as $item) {
+    print($item . ',');
+}
diff --git a/Maths/Mean.php b/Maths/Mean.php
index 52f01202..b24b4e01 100644
--- a/Maths/Mean.php
+++ b/Maths/Mean.php
@@ -1,11 +1,13 @@
 <?php
+
 /**
  * This function calculates
  * The mean value of
  * numbers provided
- * 
- * @param decimal $numbers A variable sized number input
+ *
+ * @param  decimal  $numbers  A variable sized number input
  * @return decimal $mean Mean of provided numbers
+ * @throws \Exception
  */
 function mean(...$numbers)
 {
@@ -14,7 +16,6 @@ function mean(...$numbers)
     }
 
     $total = array_sum($numbers);
-    $mean = $total / count($numbers);
-    
-    return $mean;
-}
\ No newline at end of file
+
+    return $total / count($numbers);
+}
diff --git a/Maths/Median.php b/Maths/Median.php
index 0b637b2d..d8aca9cc 100644
--- a/Maths/Median.php
+++ b/Maths/Median.php
@@ -1,11 +1,13 @@
 <?php
+
 /**
  * This function calculates
  * The median value of
  * numbers provided
- * 
- * @param decimal $numbers A variable sized number input
+ *
+ * @param  decimal  $numbers  A variable sized number input
  * @return decimal $median Median of provided numbers
+ * @throws \Exception
  */
 function median(...$numbers)
 {
@@ -15,11 +17,10 @@ function median(...$numbers)
 
     sort($numbers);
     $length = count($numbers);
-    
     $middle = ceil($length / 2);
-    if($length % 2 == 0) {
+    if ($length % 2 == 0) {
         return ($numbers[$middle] + $numbers[$middle - 1]) / 2;
     }
-    
+
     return $numbers[$middle - 1];
-}
\ No newline at end of file
+}
diff --git a/Maths/Mode.php b/Maths/Mode.php
index 38b6f044..fa5f95be 100644
--- a/Maths/Mode.php
+++ b/Maths/Mode.php
@@ -1,4 +1,5 @@
 <?php
+
 /**
  * This function calculates
  * the mode value(s) of
@@ -16,6 +17,5 @@ function mode(...$numbers)
 
     $values = array_count_values($numbers);
     $maxCount = max($values);
-
     return array_keys($values, $maxCount, true);
-}
\ No newline at end of file
+}
diff --git a/Maths/NeonNumber.php b/Maths/NeonNumber.php
index 1710f7a9..fc4e446c 100644
--- a/Maths/NeonNumber.php
+++ b/Maths/NeonNumber.php
@@ -1,12 +1,12 @@
 <?php
+
 function isNumberNeon($input)
 {
-  $inputSquare = $input * $input;
-  $inputArr = array_map('intval', str_split($inputSquare));
-  $sumOfSquareDigits =0;
-  foreach ($inputArr as $digit) {
-    $sumOfSquareDigits +=$digit;
-  }
-  return $sumOfSquareDigits ==$input;
+    $inputSquare = $input * $input;
+    $inputArr = array_map('intval', str_split($inputSquare));
+    $sumOfSquareDigits = 0;
+    foreach ($inputArr as $digit) {
+        $sumOfSquareDigits += $digit;
+    }
+    return $sumOfSquareDigits == $input;
 }
-?>
diff --git a/Maths/PerfectSquare.php b/Maths/PerfectSquare.php
index 7bca0445..2b6fb747 100644
--- a/Maths/PerfectSquare.php
+++ b/Maths/PerfectSquare.php
@@ -1,4 +1,5 @@
 <?php
+
 /**
  * This function check whether
  * the provided number is a
diff --git a/Maths/ProjectEuler/Problem1.php b/Maths/ProjectEuler/Problem1.php
index 802cb233..e506f1af 100644
--- a/Maths/ProjectEuler/Problem1.php
+++ b/Maths/ProjectEuler/Problem1.php
@@ -26,9 +26,9 @@ function problem1a(): int
 
     $numbers = range(1, $maxNumber);
 
-    return array_reduce($numbers, function($carry, $number) {
+    return array_reduce($numbers, function ($carry, $number) {
         $shouldCarry = $number % 3 == 0 || $number % 5 == 0;
-        return $carry += $shouldCarry ? $number : 0;
+        return $carry + ($shouldCarry ? $number : 0);
     });
 }
 
diff --git a/Maths/ProjectEuler/Problem10.php b/Maths/ProjectEuler/Problem10.php
index e05af975..cdc04458 100644
--- a/Maths/ProjectEuler/Problem10.php
+++ b/Maths/ProjectEuler/Problem10.php
@@ -1,4 +1,5 @@
 <?php
+
 /*
  * This function solves the problem 10 of the Project Euler.
  *
@@ -18,14 +19,15 @@ function problem10(): int
     $n = 2000000;
     $isPrime = [];
 
-    for ($i = 2; $i <= $n; $i++){
+    for ($i = 2; $i <= $n; $i++) {
         $isPrime[$i] = $i;
     }
 
-    for ($i = 2; $i*$i <= $n; $i++){
-        if (isset ($isPrime[$i])){
-            for ( $j = $i; $i*$j <= $n; $j++)
-               unset($isPrime[$i*$j]);
+    for ($i = 2; $i * $i <= $n; $i++) {
+        if (isset($isPrime[$i])) {
+            for ($j = $i; $i * $j <= $n; $j++) {
+                unset($isPrime[$i * $j]);
+            }
         }
     }
 
diff --git a/Maths/ProjectEuler/Problem11.php b/Maths/ProjectEuler/Problem11.php
index b9260be3..208257dc 100644
--- a/Maths/ProjectEuler/Problem11.php
+++ b/Maths/ProjectEuler/Problem11.php
@@ -1,6 +1,5 @@
 <?php
 
-
 /*
  * This function solves the problem 11 of the Project Euler.
  *
@@ -150,4 +149,3 @@ function problem11()
 
     return $maxProduct;
 }
-
diff --git a/Maths/ProjectEuler/Problem4.php b/Maths/ProjectEuler/Problem4.php
index 1227db54..fea52278 100644
--- a/Maths/ProjectEuler/Problem4.php
+++ b/Maths/ProjectEuler/Problem4.php
@@ -13,12 +13,11 @@ function problem4(): int
 {
     $largest  = 0;
 
-    for ($i=100; $i<1000; $i++){
+    for ($i = 100; $i < 1000; $i++) {
+        for ($j = $i; $j < 1000; $j++) {
+            $product = $i * $j;
 
-        for ($j=$i; $j<1000; $j++) {
-            $product = $i*$j;
-
-            if ( strrev((string)$product) == (string)$product && $product > $largest) {
+            if (strrev((string)$product) == (string)$product && $product > $largest) {
                 $largest = $product;
             }
         }
diff --git a/Maths/ProjectEuler/Problem6.php b/Maths/ProjectEuler/Problem6.php
index 15a91ecb..35fd8e5c 100644
--- a/Maths/ProjectEuler/Problem6.php
+++ b/Maths/ProjectEuler/Problem6.php
@@ -5,10 +5,10 @@
  *
  * Problem description:
  * The sum of the squares of the first ten natural numbers is,
- *              1 ** 2 + 2 ** 2 + ... + 10 ** 2 = 385 
+ *              1 ** 2 + 2 ** 2 + ... + 10 ** 2 = 385
  *
  * The square of the sum of the first ten natural numbers is,
- *              (1 + 2 + ... + 10) ** 2 = 3025 
+ *              (1 + 2 + ... + 10) ** 2 = 3025
  *
  * Hence the difference between the sum of the squares of the
  * first ten natural numbers and the square of the sum is .
diff --git a/Maths/ProjectEuler/Problem8.php b/Maths/ProjectEuler/Problem8.php
index 737254f1..aa0a215f 100644
--- a/Maths/ProjectEuler/Problem8.php
+++ b/Maths/ProjectEuler/Problem8.php
@@ -59,11 +59,11 @@ function problem8(): int
     $substringSize = 13;
 
     for ($i = 0; $i < strlen($theNumber) - $substringSize; $i++) {
-        $currentSubstring = substr($theNumber,$i,$substringSize);
+        $currentSubstring = substr($theNumber, $i, $substringSize);
         $currentProduct = 0;
 
-        for ($j = 0; $j < strlen ($currentSubstring); $j++) {
-           $currentProduct = ($currentProduct == 0 ? (int)$currentSubstring[$j] : $currentProduct * (int)$currentSubstring[$j]);
+        for ($j = 0; $j < strlen($currentSubstring); $j++) {
+            $currentProduct = ($currentProduct == 0 ? (int)$currentSubstring[$j] : $currentProduct * (int)$currentSubstring[$j]);
         }
 
         $greatestProduct = ($greatestProduct < $currentProduct ? $currentProduct : $greatestProduct);
diff --git a/Searches/BinarySearch.php b/Searches/BinarySearch.php
index e3b1e310..10789307 100644
--- a/Searches/BinarySearch.php
+++ b/Searches/BinarySearch.php
@@ -21,7 +21,7 @@
 function binarySearchIterative($list, $target)
 {
     $first = 0;
-    $last = count($list)-1;
+    $last = count($list) - 1;
 
 
     while ($first <= $last) {
@@ -70,8 +70,9 @@ function binarySearchByRecursion($list, $target, $start, $end)
         return $list[0] == $target ? 0 : null;
     }
 
-    if ($start > $end)
+    if ($start > $end) {
         return null;
+    }
 
 
     $mid = ($start + $end) >> 1;
@@ -80,9 +81,9 @@ function binarySearchByRecursion($list, $target, $start, $end)
     if ($list[$mid] == $target) {
         return $mid;
     } elseif ($list[$mid] > $target) {
-        return binarySearchByRecursion($list, $target, $start, $mid-1);
+        return binarySearchByRecursion($list, $target, $start, $mid - 1);
     } elseif ($list[$mid] < $target) {
-        return binarySearchByRecursion($list, $target, $mid+1, $end);
+        return binarySearchByRecursion($list, $target, $mid + 1, $end);
     }
 
     return null;
diff --git a/Searches/ExponentialSearch.php b/Searches/ExponentialSearch.php
index 7073053d..f034c1f8 100644
--- a/Searches/ExponentialSearch.php
+++ b/Searches/ExponentialSearch.php
@@ -1,9 +1,10 @@
 <?php
+
 /*
  * Exponential Search Algorithm
  *
  * The algorithm consists of two stages.
- * The first stage determines a range in which the search key would reside 
+ * The first stage determines a range in which the search key would reside
  **** if it were in the list.
  * In the second stage, a binary search is performed on this range.
  */
@@ -14,47 +15,52 @@
   * @param int $ceiling
   * @return int
   **/
-function binarySearch ($arr, $value, $floor, $ceiling) {
+function binarySearch($arr, $value, $floor, $ceiling)
+{
+
   // Get $middle index
-  $mid = floor(($floor + $ceiling) / 2);
-  // Return position if $value is at the $mid position
-  if ($arr[$mid] === $value) {
-    return (int) $mid;
-  }
+    $mid = floor(($floor + $ceiling) / 2);
+// Return position if $value is at the $mid position
+    if ($arr[$mid] === $value) {
+        return (int) $mid;
+    }
   //Return -1 is range is wrong
-  if ($floor > $ceiling) return -1;
+    if ($floor > $ceiling) {
+        return -1;
+    }
   // search the left part of the $array
-  // If the $middle element is great than the $value
-  if ($arr[$mid] > $value) {
-    return binarySearch($arr, $value, $floor, $mid - 1);
-  }
+  // If the $middle element is greater than the $value
+    if ($arr[$mid] > $value) {
+        return binarySearch($arr, $value, $floor, $mid - 1);
+    }
   // search the right part of the $array
   // If the $middle element is lower than the $value
-  else {
-    return binarySearch($arr, $value, $mid + 1, $ceiling);
-  }
+    else {
+        return binarySearch($arr, $value, $mid + 1, $ceiling);
+    }
 }
- /**
-  * @param Array $arr
-  * @param int $length
-  * @param int $value
-  * @return int
-  **/
-function exponentialSearch ($arr, $value) {
+
+/**
+ * @param  Array  $arr
+ * @param  int  $value
+ * @return int
+ */
+function exponentialSearch($arr, $value)
+{
+
   // If $value is the first element of the $array return this position
-  if ($arr[0] === $value) {
-    return 0;
-  }
+    if ($arr[0] === $value) {
+        return 0;
+    }
 
   // Find range for binary search
-  $i = 1;
-  $length = count($arr);
-  while ($i < $length && $arr[$i] <= $value) {
-    $i = $i * 2;
-  }
-  $floor = $i/2;
-  $ceiling = min($i, $length);
-
-  // Call binary search for the range found above
-  return binarySearch($arr, $value, $floor, $ceiling);
-}
\ No newline at end of file
+    $i = 1;
+    $length = count($arr);
+    while ($i < $length && $arr[$i] <= $value) {
+        $i = $i * 2;
+    }
+    $floor = $i / 2;
+    $ceiling = min($i, $length);
+// Call binary search for the range found above
+    return binarySearch($arr, $value, $floor, $ceiling);
+}
diff --git a/Searches/FibonacciSearch.php b/Searches/FibonacciSearch.php
index 7e04a4b9..b103785a 100644
--- a/Searches/FibonacciSearch.php
+++ b/Searches/FibonacciSearch.php
@@ -11,13 +11,16 @@
  */
 function fibonacciPosition(int $n, array &$m = [])
 {
-    if(isset($m[$n])) return $m[$n];
-    if($n < 2) return $n;
+    if (isset($m[$n])) {
+        return $m[$n];
+    }
+    if ($n < 2) {
+        return $n;
+    }
 
     $m[$n] = fibonacciPosition($n - 1, $m) + fibonacciPosition($n - 2, $m);
 
     return $m[$n];
-
 }
 
 print fibonacciPosition(59);
diff --git a/Searches/InterpolationSearch.php b/Searches/InterpolationSearch.php
index 4e27c7dc..bb73d92d 100644
--- a/Searches/InterpolationSearch.php
+++ b/Searches/InterpolationSearch.php
@@ -1,12 +1,13 @@
 <?php
+
 /**
  * Interpolation Search********
- * 
- * 
+ *
+ *
  * Description***********
  * Searches for a key in a sorted array
- * 
- * 
+ *
+ *
  * How************
  * Loop through the array:
  * Determine the index from the low and high indices
@@ -15,36 +16,38 @@
  * if the (value of index in array) is > key decrease the high index
  * repeat the loop
  */
-function interpolationSearch($arr, $key) {
-  $length = count($arr) - 1;
-  $low = 0;
-  $high = $length;
-  $position = -1;
-  //loop, between low & high
-  while ($low <= $high && $key >= $arr[$low] && $key <= $arr[$high]) {
-    //GET INDEX
-    $delta = ($key - $arr[$low]) / ($arr[$high] - $arr[$low]);
-    $index = $low + floor(($high - $low) * $delta);
-    //GET VALUE OF INDEX IN ARRAY...
-    $indexValue = $arr[$index];
-    if ($indexValue === $key) {
-      //index value equals key
-      //FOUND TARGET
-      //return index value
-      $position = $index;
-      return (int) $position;
+function interpolationSearch($arr, $key)
+{
+
+    $length = count($arr) - 1;
+    $low = 0;
+    $high = $length;
+    $position = -1;
+//loop, between low & high
+    while ($low <= $high && $key >= $arr[$low] && $key <= $arr[$high]) {
+//GET INDEX
+        $delta = ($key - $arr[$low]) / ($arr[$high] - $arr[$low]);
+        $index = $low + floor(($high - $low) * $delta);
+//GET VALUE OF INDEX IN ARRAY...
+        $indexValue = $arr[$index];
+        if ($indexValue === $key) {
+        //index value equals key
+                //FOUND TARGET
+                //return index value
+                $position = $index;
+            return (int) $position;
+        }
+        if ($indexValue < $key) {
+  //index value lower than key
+          //increase low index
+            $low = $index + 1;
+        }
+        if ($indexValue > $key) {
+  //index value higher than key
+          //decrease high index
+            $high = $index - 1;
+        }
     }
-    if ($indexValue < $key) {
-      //index value lower than key
-      //increase low index
-      $low = $index + 1;
-    } 
-    if ($indexValue > $key) {
-      //index value higher than key
-      //decrease high index
-      $high = $index - 1;
-    }
-  }
   //when key not found in array or array not sorted
-  return null;
-}
\ No newline at end of file
+    return null;
+}
diff --git a/Searches/JumpSearch.php b/Searches/JumpSearch.php
index adda458b..7be70de6 100644
--- a/Searches/JumpSearch.php
+++ b/Searches/JumpSearch.php
@@ -1,40 +1,38 @@
 <?php
+
 /**
    * Jump Search algorithm in PHP
    * References: https://www.geeksforgeeks.org/jump-search/
    * The list must be sorted in ascending order before performing jumpSearch
    *
-   * @param Array $list refers to a sorted list of integer 
+   * @param Array $list refers to a sorted list of integer
    * @param integer $key refers to the integer target to be searched from the sorted list
-   * @return index of $key if found, otherwise -1 is returned
+   * @return int index of $key if found, otherwise -1 is returned
  */
-   
-function jumpSearch($list,$key)
-{
-	/*number of elements in the sorted array*/
-	$num = count($list);
-	/*block size to be jumped*/
-	$step = (int)sqrt($num);
-	$prev = 0;
-	
-	while ($list[min($step, $num)-1] < $key)
-	{
-		$prev = $step;
-		$step += (int)sqrt($num);
-		if ($prev >= $num)
-			return -1;
-	}
 
-	/*Performing linear search for $key in block*/
-	while ($list[$prev] < $key)
-	{
-		$prev++;
-		if ($prev == min($step, $num))
-			return -1;
-	}
-	
-     return $list[$prev] === $key ? $prev : -1;
-}
+function jumpSearch($list, $key)
+{
+    /*number of elements in the sorted array*/
+    $num = count($list);
+/*block size to be jumped*/
+    $step = (int)sqrt($num);
+    $prev = 0;
 
+    while ($list[min($step, $num) - 1] < $key) {
+        $prev = $step;
+        $step += (int)sqrt($num);
+        if ($prev >= $num) {
+            return -1;
+        }
+    }
 
+    /*Performing linear search for $key in block*/
+    while ($list[$prev] < $key) {
+        $prev++;
+        if ($prev == min($step, $num)) {
+            return -1;
+        }
+    }
 
+     return $list[$prev] === $key ? $prev : -1;
+}
diff --git a/Searches/LinearSearch.php b/Searches/LinearSearch.php
index 4de38be3..2d8ee41e 100644
--- a/Searches/LinearSearch.php
+++ b/Searches/LinearSearch.php
@@ -5,10 +5,6 @@
  *
  * Reference: https://www.geeksforgeeks.org/linear-search/
  *
- * @param Array $list a array of integers to search
- * @param integer $target an integer number to search for in the list
- * @return integer the index where the target is found (or -1 if not found)
- *
  * Examples:
  *  data =  5, 7, 8, 11, 12, 15, 17, 18, 20
  *  x = 15
@@ -17,16 +13,15 @@
  *  x = 1
  *  Element not found
  *
- *  @param Array $list a array of integers to search
+ *  @param Array $list an array of integers to search
  *  @param integer $target an integer number to search for in the list
  *  @return integer the index where the target is found (or -1 if not found)
  */
 function linearSearch($list, $target)
 {
     $n = sizeof($list);
-    for($i = 0; $i < $n; $i++)
-    {
-        if($list[$i] == $target) {
+    for ($i = 0; $i < $n; $i++) {
+        if ($list[$i] == $target) {
             return $i + 1;
         }
     }
diff --git a/Searches/LowerBound.php b/Searches/LowerBound.php
index cf465555..ba4ddbb5 100644
--- a/Searches/LowerBound.php
+++ b/Searches/LowerBound.php
@@ -10,24 +10,25 @@
  * [C++ Lower Bound](http://www.cplusplus.com/reference/algorithm/lower_bound/)
  *
  * It is assumed that an integer array is provided
- * and the second parameter is also a integer
+ * and the second parameter is also an integer
  *
- * @param array of sorted integers
- * @param integer whose lower bound is to be found
+ * @param array  $arr  of sorted integers
+ * @param integer  $elem  whose lower bound is to be found
  *
- * @return the index of lower bound of the given element
+ * @return int the index of lower bound of the given element
  */
-function lowerBound(array $arr, int $elem){
+function lowerBound(array $arr, int $elem)
+{
     isSortedAscendingInts($arr);
     $hi = count($arr);
     $lo = 0;
 
-    while($lo < $hi){
-        $mid = $lo + floor(($hi - $lo)/2);
+    while ($lo < $hi) {
+        $mid = $lo + floor(($hi - $lo) / 2);
 
-        if($arr[$mid] < $elem){
-            $lo = $mid+1;
-        }else{
+        if ($arr[$mid] < $elem) {
+            $lo = $mid + 1;
+        } else {
             $hi = $mid;
         }
     }
diff --git a/Searches/TernarySearch.php b/Searches/TernarySearch.php
index a0e22353..21e4aad0 100644
--- a/Searches/TernarySearch.php
+++ b/Searches/TernarySearch.php
@@ -1,4 +1,5 @@
 <?php
+
 /* Ternary search is similar to binary search
  * It rather divides the sorted array into three parts rather than.two parts by using two middle points, $mid1  $mid2.
  * The value of the $key will first be compared with the two $mid points, the value will be returned if there is a match.
@@ -7,77 +8,77 @@
  * Otherwise, narrow the interval to the $middle part.
  * Repeat the steps until the value is found or the interval is empty (value not found after checking all elements).
  */
+function ternarySearchByRecursion($arr, $key, $low, $high)
+{
 
-function ternarySearchByRecursion ($arr, $key, $low, $high) {
-  
     //Return -1 if high lesser than low, we can't find item in the whole array
     if ($high < $low) {
-      return null;
+        return null;
     }
-    
-    
+
     //get $mid1 and $mid2
     $mid1 = floor($low + ($high - $low) / 3);
     $mid2 = floor($high - ($high - $low) / 3);
-    // check if $key is found at any $mid
+// check if $key is found at any $mid
     if ($arr[$mid1] === $key) {
-      // return index of $key if found
-      return $mid1;
+// return index of $key if found
+        return $mid1;
     }
     if ($arr[$mid2] === $key) {
-      // return index of $key if found
-      return $mid2;
+// return index of $key if found
+        return $mid2;
     }
-    
+
     // since the $key is not found at $mid,
     // check in which region it is present
     // and repeat the Search operation
     // in that region
     if ($key < $arr[$mid1]) {
-      // the $key lies in between $low and $mid1
-      return ternarySearchByRecursion($arr, $key, $low, $mid1 - 1);
-    } else if ($key > $arr[$mid2]) {
-      // the $key lies in between $mid2 and $high
-      return ternarySearchByRecursion($arr, $key, $mid2 + 1, $high);
+// the $key lies in between $low and $mid1
+        return ternarySearchByRecursion($arr, $key, $low, $mid1 - 1);
+    } elseif ($key > $arr[$mid2]) {
+    // the $key lies in between $mid2 and $high
+        return ternarySearchByRecursion($arr, $key, $mid2 + 1, $high);
     } else {
-      // the $key lies in between $mid1 and $mid2
-      return ternarySearchByRecursion($arr, $key, $mid1 + 1, $mid2 - 1);
+    // the $key lies in between $mid1 and $mid2
+        return ternarySearchByRecursion($arr, $key, $mid1 + 1, $mid2 - 1);
     }
 }
 
-function ternarySearchIterative ($arr, $key) {
-  $low = 0; $high = count($arr) - 1;
-  while ($high >= $low) {
+function ternarySearchIterative($arr, $key)
+{
+    $low = 0;
+    $high = count($arr) - 1;
+    while ($high >= $low) {
     // find the $mid1 and $mid2
-    $mid1 = floor($low + ($high - $low) / 3);
-    $mid2 = floor($high - ($high - $low) / 3);
-
+        $mid1 = floor($low + ($high - $low) / 3);
+        $mid2 = floor($high - ($high - $low) / 3);
     // check if $key is found at any $mid
-    if ($arr[$mid1] === $key) {
-      // return index of $key if found
-      return $mid1;
-    }
-    if ($arr[$mid2] === $key) {
-      // return index of $key if found
-      return $mid2;
-    }
+        if ($arr[$mid1] === $key) {
+// return index of $key if found
+            return $mid1;
+        }
+        if ($arr[$mid2] === $key) {
+    // return index of $key if found
+            return $mid2;
+        }
 
-    // since the $key is not found at $mid,
-    // check in which region it is present
-    // and repeat the Search operation
-    // in that region
-    if ($key < $arr[$mid1]) {
-      // the $key lies in between $low and $mid1
-      $high = $mid1 - 1;
-    } else if ($key > $arr[$mid2]) {
-      // the $key lies in between $mid2 and $high
-      $low = $mid2 + 1;
-    } else {
-      // the $key lies in between $mid1 and $mid2
-      $low = $mid1 + 1;
-      $high = $mid2 - 1;
+      // since the $key is not found at $mid,
+      // check in which region it is present
+      // and repeat the Search operation
+      // in that region
+        if ($key < $arr[$mid1]) {
+    // the $key lies in between $low and $mid1
+            $high = $mid1 - 1;
+        } elseif ($key > $arr[$mid2]) {
+        // the $key lies in between $mid2 and $high
+            $low = $mid2 + 1;
+        } else {
+        // the $key lies in between $mid1 and $mid2
+            $low = $mid1 + 1;
+            $high = $mid2 - 1;
+        }
     }
-  }
   // the $key was not found
-  return null;
+    return null;
 }
diff --git a/Searches/UpperBound.php b/Searches/UpperBound.php
index 6cfbffe3..47d62518 100644
--- a/Searches/UpperBound.php
+++ b/Searches/UpperBound.php
@@ -10,24 +10,25 @@
  * [C++ Lower Bound](http://www.cplusplus.com/reference/algorithm/upper_bound/)
  *
  * It is assumed that an integer array is provided
- * and the second parameter is also a integer
+ * and the second parameter is also an integer
  *
- * @param array of sorted integers
- * @param integer whose upper bound is to be found
+ * @param array  $arr  of sorted integers
+ * @param integer  $elem  whose upper bound is to be found
  *
- * @return the index of upper bound of the given element
+ * @return int the index of upper bound of the given element
  */
-function upperBound(array $arr, int $elem){
+function upperBound(array $arr, int $elem)
+{
     isSortedAscendingInts($arr);
     $hi = count($arr);
     $lo = 0;
 
-    while($lo < $hi){
-        $mid = $lo + floor(($hi - $lo)/2);
+    while ($lo < $hi) {
+        $mid = $lo + floor(($hi - $lo) / 2);
 
-        if($arr[$mid] <= $elem){
+        if ($arr[$mid] <= $elem) {
             $lo = $mid + 1;
-        }else{
+        } else {
             $hi = $mid;
         }
     }
diff --git a/Sorting/ArrayKeysSort.php b/Sorting/ArrayKeysSort.php
index 034258ec..4c97830d 100644
--- a/Sorting/ArrayKeysSort.php
+++ b/Sorting/ArrayKeysSort.php
@@ -1,4 +1,5 @@
 <?php
+
 /**
  *  Sort an "Array of objects" or "Array of arrays" by keys
  */
@@ -7,60 +8,52 @@ class ArrayKeysSort
 {
     public const ORDER_ASC = 'ASC';
     public const ORDER_DESC = 'DESC';
-
-    /**
+/**
      * @param $collection
      * @param array $keys
      * @param string $order
      * @param bool $isCaseSensitive
      * @return mixed
      */
-    public static function sort(
-        $collection,
-        array $keys,
-        string $order = self::ORDER_ASC,
-        bool $isCaseSensitive = false
-    ) {
+    public static function sort($collection, array $keys, string $order = self::ORDER_ASC, bool $isCaseSensitive = false)
+    {
         if (!empty($collection) && !empty($keys)) {
             try {
-                usort(
-                    $collection,
-                    function ($a, $b) use ($keys, $order, $isCaseSensitive) {
+                usort($collection, function ($a, $b) use ($keys, $order, $isCaseSensitive) {
+
                         $pos = 0;
-                        do {
+                    do {
                             $key = $keys[$pos];
-                            if (is_array($a)) {
-                                if (!isset($a[$key]) || !isset($b[$key])) {
-                                    $errorMsg = 'The key "' . $key
+                        if (is_array($a)) {
+                            if (!isset($a[$key]) || !isset($b[$key])) {
+                                $errorMsg = 'The key "' . $key
                                         . '" does not exist in the collection';
-                                    throw new Exception($errorMsg);
-                                }
-                                $item1 = !$isCaseSensitive
-                                    ? strtolower($a[$key]) : $a[$key];
-                                $item2 = !$isCaseSensitive
-                                    ? strtolower($b[$key]) : $b[$key];
-                            } else {
-                                if (!isset($a->$key) || !isset($b->$key)) {
-                                    $errorMsg = 'The key "' . $key
-                                        . '" does not exist in the collection';
-                                    throw new Exception($errorMsg);
-                                }
-                                $item1 = !$isCaseSensitive
-                                    ? strtolower($a->$key) : $a->$key;
-                                $item2 = !$isCaseSensitive
-                                    ? strtolower($b->$key) : $b->$key;
+                                throw new Exception($errorMsg);
                             }
-                        } while ($item1 === $item2 && !empty($keys[++$pos]));
-
-                        if ($item1 === $item2) {
-                            return 0;
-                        } elseif ($order === self::ORDER_ASC) {
-                            return ($item1 < $item2) ? -1 : 1;
+                            $item1 = !$isCaseSensitive
+                            ? strtolower($a[$key]) : $a[$key];
+                            $item2 = !$isCaseSensitive
+                            ? strtolower($b[$key]) : $b[$key];
                         } else {
-                            return ($item1 > $item2) ? -1 : 1;
+                            if (!isset($a->$key) || !isset($b->$key)) {
+                                $errorMsg = 'The key "' . $key
+                                        . '" does not exist in the collection';
+                                throw new Exception($errorMsg);
+                            }
+                            $item1 = !$isCaseSensitive
+                            ? strtolower($a->$key) : $a->$key;
+                            $item2 = !$isCaseSensitive
+                            ? strtolower($b->$key) : $b->$key;
                         }
+                    } while ($item1 === $item2 && !empty($keys[++$pos]));
+                    if ($item1 === $item2) {
+                        return 0;
+                    } elseif ($order === self::ORDER_ASC) {
+                        return ($item1 < $item2) ? -1 : 1;
+                    } else {
+                        return ($item1 > $item2) ? -1 : 1;
                     }
-                );
+                });
             } catch (Exception $e) {
                 echo $e->getMessage();
                 die();
diff --git a/Sorting/BubbleSort.php b/Sorting/BubbleSort.php
index b46e7a0b..9bc66795 100644
--- a/Sorting/BubbleSort.php
+++ b/Sorting/BubbleSort.php
@@ -6,13 +6,14 @@
  * @param array $array
  * @return array
  */
-function bubbleSort($array) {
+function bubbleSort($array)
+{
     $length = count($array);
 
     for ($i = $length; $i > 0; $i--) {
         $swapped = true;
 
-        for ($j=0;$j<$i-1;$j++) {
+        for ($j = 0; $j < $i - 1; $j++) {
             if ($array[$j] > $array[$j + 1]) {
                 $temp = $array[$j];
                 $array[$j] = $array[$j + 1];
@@ -21,7 +22,9 @@ function bubbleSort($array) {
             }
         }
 
-        if ($swapped) break;
+        if ($swapped) {
+            break;
+        }
     }
 
     return $array;
diff --git a/Sorting/BubbleSort2.php b/Sorting/BubbleSort2.php
index f29b3394..97d0757f 100644
--- a/Sorting/BubbleSort2.php
+++ b/Sorting/BubbleSort2.php
@@ -1,4 +1,5 @@
 <?php
+
 /*
  * Bubble Sort
  *
@@ -10,25 +11,19 @@
 function bubbleSort2(array $input)
 {
     // Return nothing if input is empty
-    if(!isset($input))
-    {
+    if (!isset($input)) {
         return [];
     }
 
-    do
-    {
+    do {
         $swapped = false;
 
-        for($i = 0, $count = sizeof($input) - 1; $i < $count; $i++)
-        {
-            if($input[$i + 1] < $input[$i])
-            {
+        for ($i = 0, $count = sizeof($input) - 1; $i < $count; $i++) {
+            if ($input[$i + 1] < $input[$i]) {
                 list($input[$i + 1], $input[$i]) = [$input[$i], $input[$i + 1]];
                 $swapped = true;
             }
         }
-    }
-    while($swapped);
-
+    } while ($swapped);
     return $input;
 }
diff --git a/Sorting/CountSort.php b/Sorting/CountSort.php
index 354fbe3e..acec08bc 100644
--- a/Sorting/CountSort.php
+++ b/Sorting/CountSort.php
@@ -1,6 +1,5 @@
 <?php
 
-
 /**
  * @param $array
  * @param $min
@@ -11,20 +10,18 @@ function countSort($array, $min, $max)
 {
     $count = array();
 
-    for($i = $min; $i <= $max; $i++)
-    {
+    for ($i = $min; $i <= $max; $i++) {
         $count[$i] = 0;
     }
 
-    foreach($array as $number)
-    {
+    foreach ($array as $number) {
         $count[$number]++;
     }
 
     $z = 0;
 
-    for($i = $min; $i <= $max; $i++) {
-        while( $count[$i]-- > 0 ) {
+    for ($i = $min; $i <= $max; $i++) {
+        while ($count[$i]-- > 0) {
             $array[$z++] = $i;
         }
     }
diff --git a/Sorting/GnomeSort.php b/Sorting/GnomeSort.php
index 003e0970..a9a88ce8 100644
--- a/Sorting/GnomeSort.php
+++ b/Sorting/GnomeSort.php
@@ -4,26 +4,25 @@
  * Gnome Sort
  * References:
  * https://www.geeksforgeeks.org/gnome-sort-a-stupid-one/
- * 
+ *
  * The Gnome algorithm works by locating the first instance in which two adjoining elements are arranged incorrectly and swaps with each other.
- * 
+ *
  * @param array $array refers to the array to be sorted
  * @return array
  */
-
-function gnomeSort($array){
+function gnomeSort($array)
+{
     $a = 1;
     $b = 2;
 
-    while($a < count($array)){
-
-        if ($array[$a-1] <= $array[$a]){
+    while ($a < count($array)) {
+        if ($array[$a - 1] <= $array[$a]) {
             $a = $b;
             $b++;
-        }else{
-            list($array[$a],$array[$a-1]) = array($array[$a-1],$array[$a]);
+        } else {
+            list($array[$a],$array[$a - 1]) = array($array[$a - 1],$array[$a]);
             $a--;
-            if($a == 0){
+            if ($a == 0) {
                 $a = $b;
                 $b++;
             }
diff --git a/Sorting/HeapSort.php b/Sorting/HeapSort.php
index 308b2201..d999967b 100644
--- a/Sorting/HeapSort.php
+++ b/Sorting/HeapSort.php
@@ -1,4 +1,5 @@
 <?php
+
 /**
  * HeapSort Algorithm
  *
@@ -24,10 +25,9 @@ function heapSort(array $arr): array
 
     // Extract elements from heap one by one
     for ($i = $n - 1; $i >= 0; $i--) {
-        // Swap
+// Swap
         [$arr[0], $arr[$i]] = [$arr[$i], $arr[0]];
-
-        // Heapify the reduced heap
+// Heapify the reduced heap
         heapify($arr, $i, 0);
     }
 
@@ -46,7 +46,6 @@ function heapify(array &$arr, int $n, int $i): void
     $largest = $i;
     $left = 2 * $i + 1;
     $right = 2 * $i + 2;
-
     if ($left < $n && $arr[$left] > $arr[$largest]) {
         $largest = $left;
     }
@@ -59,4 +58,4 @@ function heapify(array &$arr, int $n, int $i): void
         [$arr[$i], $arr[$largest]] = [$arr[$largest], $arr[$i]];
         heapify($arr, $n, $largest);
     }
-}
\ No newline at end of file
+}
diff --git a/Sorting/InsertionSort.php b/Sorting/InsertionSort.php
index b184e545..fcffaa00 100644
--- a/Sorting/InsertionSort.php
+++ b/Sorting/InsertionSort.php
@@ -8,13 +8,11 @@
  */
 function insertionSort(array $array)
 {
-    for ($i = 1; $i < count($array); $i++)
-    {
+    for ($i = 1; $i < count($array); $i++) {
         $currentVal = $array[$i];
 
-        for ($j = $i - 1; $j >= 0 && $array[$j] > $currentVal; $j--)
-        {
-          $array[$j + 1] = $array[$j];
+        for ($j = $i - 1; $j >= 0 && $array[$j] > $currentVal; $j--) {
+            $array[$j + 1] = $array[$j];
         }
 
         $array[$j + 1] = $currentVal;
@@ -22,5 +20,3 @@ function insertionSort(array $array)
 
     return $array;
 }
-
-
diff --git a/Sorting/MergeSort.php b/Sorting/MergeSort.php
index 7923917a..23c64178 100644
--- a/Sorting/MergeSort.php
+++ b/Sorting/MergeSort.php
@@ -9,12 +9,12 @@
 function mergeSort(array $arr)
 {
     if (count($arr) <= 1) {
-      return $arr;
+        return $arr;
     }
 
-    $mid = floor( count($arr) / 2 );
-    $leftArray = mergeSort( array_slice($arr, 0, $mid) );
-    $rightArray = mergeSort( array_slice($arr, $mid) );
+    $mid = floor(count($arr) / 2);
+    $leftArray = mergeSort(array_slice($arr, 0, $mid));
+    $rightArray = mergeSort(array_slice($arr, $mid));
 
     return merge($leftArray, $rightArray);
 }
@@ -52,6 +52,3 @@ function merge(array $leftArray, array $rightArray)
 
     return $result;
 }
-
-
-
diff --git a/Sorting/QuickSort.php b/Sorting/QuickSort.php
index da35617b..0950effa 100644
--- a/Sorting/QuickSort.php
+++ b/Sorting/QuickSort.php
@@ -1,4 +1,5 @@
 <?php
+
 /**
  * Quick Sort
  * Compare number in an array to the next number and sets to new array (greater than or less than)
@@ -9,24 +10,19 @@
 function quickSort(array $input)
 {
     // Return nothing if input is empty
-    if(!empty($input))
-    {
+    if (!empty($input)) {
         return [];
     }
 
     $lt = [];
     $gt = [];
-
-    if(sizeof($input) < 2)
-    {
+    if (sizeof($input) < 2) {
         return $input;
     }
 
     $key = key($input);
     $shift = array_shift($input);
-
-    foreach($input as $value)
-    {
+    foreach ($input as $value) {
         $value <= $shift ? $lt[] = $value : $gt[] = $value;
     }
 
diff --git a/Sorting/RadixSort.php b/Sorting/RadixSort.php
index 15c5c32f..e972af05 100644
--- a/Sorting/RadixSort.php
+++ b/Sorting/RadixSort.php
@@ -3,18 +3,16 @@
 /**
  * Radix Sort
  *
- * @param array $arr
+ * @param $nums
  * @return array
  */
 function radixSort($nums)
 {
     $maxDigitsCount = maxDigits($nums);
-    for ($k=0; $k < $maxDigitsCount; $k++)
-    {
-        $digitBucket = array_fill(0,10,[]);
+    for ($k = 0; $k < $maxDigitsCount; $k++) {
+        $digitBucket = array_fill(0, 10, []);
 
-        for ($i=0; $i < count($nums); $i++)
-        {
+        for ($i = 0; $i < count($nums); $i++) {
             $digitBucket[getDigit($nums[$i], $k)][] = $nums[$i];
         }
 
@@ -34,7 +32,7 @@ function radixSort($nums)
  * Get the digits value by it's place
  *
  * @param $num
- * @param $k
+ * @param $i
  * @return int
  */
 function getDigit($num, $i)
@@ -45,27 +43,28 @@ function getDigit($num, $i)
 /**
  * Get the digits count
  *
- * @param $nums
+ * @param $num
  * @return int
  */
 function digitsCount($num)
 {
-    if ($num == 0) return 1;
+    if ($num == 0) {
+        return 1;
+    }
     return floor(log10(abs($num))) + 1;
 }
 
 /**
  * Get the max digits count
  *
- * @param $nums
+ * @param $arr
  * @return int
  */
 function maxDigits($arr)
 {
     $maxDigits = 0;
 
-    for ($i=0; $i < count($arr); $i++)
-    {
+    for ($i = 0; $i < count($arr); $i++) {
         $maxDigits = max($maxDigits, digitsCount($arr[$i]));
     }
 
@@ -75,18 +74,17 @@ function maxDigits($arr)
 /**
  * Concat the array
  *
- * @param $arr
+ * @param  array  $array
  * @return array
  */
-function concat(array $array) {
-    $newArray=[];
+function concat(array $array)
+{
+    $newArray = [];
 
-    for ($i = 0; $i < count($array); $i++)
-    {
-      for ($j = 0; $j<count($array[$i]); $j++)
-      {
-          $newArray[] = $array[$i][$j];
-      }
+    for ($i = 0; $i < count($array); $i++) {
+        for ($j = 0; $j < count($array[$i]); $j++) {
+            $newArray[] = $array[$i][$j];
+        }
     }
     return $newArray;
 }
diff --git a/Sorting/SelectionSort.php b/Sorting/SelectionSort.php
index 72acda9c..20898edd 100644
--- a/Sorting/SelectionSort.php
+++ b/Sorting/SelectionSort.php
@@ -10,20 +10,16 @@ function selectionSorting(array $array)
 {
     $length = count($array);
 
-    for ($i = 0; $i < $length; $i++)
-    {
+    for ($i = 0; $i < $length; $i++) {
         $lowest = $i;
 
-        for ($j = $i + 1; $j < $length; $j++)
-        {
-            if ($array[$j] < $array[$lowest])
-            {
+        for ($j = $i + 1; $j < $length; $j++) {
+            if ($array[$j] < $array[$lowest]) {
                 $lowest = $j;
             }
         }
 
-        if ($i !==$lowest)
-        {
+        if ($i !== $lowest) {
             $temp = $array[$i];
             $array[$i] = $array[$lowest];
             $array[$lowest] = $temp;
diff --git a/Strings/CheckAnagram.php b/Strings/CheckAnagram.php
index ce4b558c..93ec37d3 100644
--- a/Strings/CheckAnagram.php
+++ b/Strings/CheckAnagram.php
@@ -10,8 +10,7 @@
  */
 function isAnagram(string $originalString, string $testString, bool $caseInsensitive = true)
 {
-    if ($caseInsensitive)
-    {
+    if ($caseInsensitive) {
         $originalString = strtolower($originalString); // Converting string to lowercase for case-insensitive check
         $testString = strtolower($testString);
     }
diff --git a/Strings/CheckPalindrome.php b/Strings/CheckPalindrome.php
index 8fa7e9fc..be2b19c9 100644
--- a/Strings/CheckPalindrome.php
+++ b/Strings/CheckPalindrome.php
@@ -11,22 +11,18 @@ function isPalindrome(string $string, bool $caseInsensitive = true)
 {
     $string = trim($string); // Removing leading and trailing spaces
 
-    if (empty($string))
-    {
+    if (empty($string)) {
         return false; // Returning false for an Empty String
     }
 
-    if ($caseInsensitive)
-    {
+    if ($caseInsensitive) {
         $string = strtolower($string); // Converting string to lowercase for case-insensitive check
     }
 
     $characters = str_split($string);
 
-    for ($i = 0; $i < count($characters); $i++)
-    {
-        if ($characters[$i] !== $characters[count($characters) - ($i + 1)])
-        {
+    for ($i = 0; $i < count($characters); $i++) {
+        if ($characters[$i] !== $characters[count($characters) - ($i + 1)]) {
             return false;
         }
     }
diff --git a/Strings/CheckPalindrome2.php b/Strings/CheckPalindrome2.php
index 56019256..88655999 100644
--- a/Strings/CheckPalindrome2.php
+++ b/Strings/CheckPalindrome2.php
@@ -5,16 +5,17 @@
  * using php strrev() function
  * make it simple
  *
- * @param string $string
- * @param bool $caseInsensitive
+ * @param  string  $string
+ * @param  bool  $caseInsensitive
+ * @return string
+ * @throws \Exception
  */
-function checkPalindromeString(string $string, bool $caseInsensitive = true): String
+function checkPalindromeString(string $string, bool $caseInsensitive = true): string
 {
     //removing spaces
     $string = trim($string);
 
-    if (empty($string))
-    {
+    if (empty($string)) {
         throw new \Exception('You are given empty string. Please give a non-empty string value');
     }
 
@@ -22,13 +23,11 @@ function checkPalindromeString(string $string, bool $caseInsensitive = true): St
      * for case-insensitive
      * lowercase string conversion
      */
-    if ($caseInsensitive)
-    {
+    if ($caseInsensitive) {
         $string = strtolower($string);
     }
 
-    if ($string !== strrev($string))
-    {
+    if ($string !== strrev($string)) {
         return $string . " - not a palindrome string." . PHP_EOL;
     }
 
diff --git a/Strings/CountConsonants.php b/Strings/CountConsonants.php
index d8637926..df53999a 100644
--- a/Strings/CountConsonants.php
+++ b/Strings/CountConsonants.php
@@ -4,10 +4,11 @@
  * Function returns the total number of consonants present in the given
  * string using a linear search through the string
  *
- * @param string $string
+ * @param  string  $string
  * @return int
+ * @throws \Exception
  */
-function countConsonants(string $string): Int
+function countConsonants(string $string): int
 {
     if (empty($string)) {
         throw new \Exception('Please pass a non-empty string value');
@@ -18,11 +19,11 @@ function countConsonants(string $string): Int
 
     $consonantCount = 0;
 
-    for ($i = 0; $i < strlen($string); $i++)
-    {
-      if (!in_array($string[$i], $vowels) &&
-        $string[$i] >= 'a' && $string[$i] <= 'z')
-        {
+    for ($i = 0; $i < strlen($string); $i++) {
+        if (
+            !in_array($string[$i], $vowels) &&
+            $string[$i] >= 'a' && $string[$i] <= 'z'
+        ) {
             $consonantCount++;
         }
     }
diff --git a/Strings/CountVowels.php b/Strings/CountVowels.php
index e3eef0a5..34a78c0f 100644
--- a/Strings/CountVowels.php
+++ b/Strings/CountVowels.php
@@ -1,28 +1,30 @@
 <?php
+
 /**
  * This function returns the total number of vowels present in
  * the given string using a simple method of looping through
  * all the characters present in the string.
  *
- * @param string $string
+ * @param  string  $string
  * @return int   $numberOfVowels
+ * @throws \Exception
  */
 function countVowelsSimple(string $string)
 {
-    if (empty($string))
-    {
+    if (empty($string)) {
         throw new \Exception('Please pass a non-empty string value');
     }
 
     $numberOfVowels = 0;
-    $vowels     = ['a', 'e', 'i', 'o', 'u']; // Vowels Set
-    $string     = strtolower($string); // For case-insensitive checking
-    $characters = str_split($string); // Splitting the string to a Character Array.
+    $vowels     = ['a', 'e', 'i', 'o', 'u'];
+// Vowels Set
+    $string     = strtolower($string);
+// For case-insensitive checking
+    $characters = str_split($string);
+// Splitting the string to a Character Array.
 
-    foreach ($characters as $character)
-    {
-        if (in_array($character, $vowels))
-        {
+    foreach ($characters as $character) {
+        if (in_array($character, $vowels)) {
             $numberOfVowels++;
         }
     }
@@ -34,16 +36,17 @@ function countVowelsSimple(string $string)
  * This function returns the Total number of vowels present in the given
  * string using a regular expression.
  *
- * @param string $string
+ * @param  string  $string
  * @return int
+ * @throws \Exception
  */
 function countVowelsRegex(string $string)
 {
-    if (empty($string))
-    {
+    if (empty($string)) {
         throw new \Exception('Please pass a non-empty string value');
     }
-    $string = strtolower($string); // For case-insensitive checking
+    $string = strtolower($string);
+// For case-insensitive checking
 
     return preg_match_all('/[a,e,i,o,u]/', $string);
 }
diff --git a/Strings/Distance.php b/Strings/Distance.php
index cdd3c421..2d5d293c 100644
--- a/Strings/Distance.php
+++ b/Strings/Distance.php
@@ -1,4 +1,5 @@
 <?php
+
 /**
  * Find distance (Levenshtein distance)
  *
@@ -13,7 +14,6 @@ function findDistance($str1, $str2)
 {
     $lenStr1 = strlen($str1);
     $lenStr2 = strlen($str2);
-
     if ($lenStr1 == 0) {
         return $lenStr2;
     }
@@ -40,14 +40,13 @@ function findDistance($str1, $str2)
         // use formula to fill in the rest of the row
         for ($j = 0; $j < $lenStr1; $j++) {
             $substitutionCost = 0;
-
             if ($str1[$j] == $str2[$i]) {
                 $substitutionCost = $distanceVectorInit[$j];
             } else {
                 $substitutionCost = $distanceVectorInit[$j] + 1;
             }
 
-            $distanceVectorFinal[$j+1] = min($distanceVectorInit[$j+1] + 1, min($distanceVectorFinal[$j] + 1, $substitutionCost));
+            $distanceVectorFinal[$j + 1] = min($distanceVectorInit[$j + 1] + 1, min($distanceVectorFinal[$j] + 1, $substitutionCost));
         }
 
         $distanceVectorInit = $distanceVectorFinal;
diff --git a/Strings/MaxCharacter.php b/Strings/MaxCharacter.php
index 95404910..7c74ed87 100644
--- a/Strings/MaxCharacter.php
+++ b/Strings/MaxCharacter.php
@@ -1,10 +1,12 @@
 <?php
+
 /**
  * This function returns the character which is repeated maximum number of
  * times in the given string.
  *
- * @param string $string
+ * @param  string  $string
  * @return string
+ * @throws \Exception
  */
 function maxCharacter(string $string)
 {
@@ -12,13 +14,15 @@ function maxCharacter(string $string)
         throw new \Exception('Please pass a non-empty string value');
     }
 
-    $characterCountTable = []; // A variable to maintain the character counts
-    $string              = strtolower($string); // For case-insensitive checking
-    $characters          = str_split($string); // Splitting the string to a Character Array.
+    $characterCountTable = [];
+// A variable to maintain the character counts
+    $string              = strtolower($string);
+// For case-insensitive checking
+    $characters          = str_split($string);
+// Splitting the string to a Character Array.
 
     foreach ($characters as $character) {
         $currentCharacterCount = 1;
-
         if (isset($characterCountTable[$character])) {
             $currentCharacterCount = $characterCountTable[$character] + 1;
         }
@@ -27,6 +31,5 @@ function maxCharacter(string $string)
     }
 
     arsort($characterCountTable);
-
     return array_keys($characterCountTable)[0];
 }
diff --git a/Strings/ReverseWords.php b/Strings/ReverseWords.php
index 843e12fc..07296dbe 100644
--- a/Strings/ReverseWords.php
+++ b/Strings/ReverseWords.php
@@ -4,7 +4,7 @@
  * This function returns a given sentence with its words
  * in reverse order
  *
- * @param string $string
+ * @param  string  $text
  * @return string
  */
 function reverseWords(string $text)
@@ -13,8 +13,7 @@ function reverseWords(string $text)
     $words         = explode(' ', $text);
     $reversedWords = [];
 
-    for ($i = (count($words) - 1); $i >= 0; $i--)
-    {
+    for ($i = (count($words) - 1); $i >= 0; $i--) {
         $reversedWords[] = $words[$i];
     }
 
diff --git a/Utils/ArrayHelpers.php b/Utils/ArrayHelpers.php
index 9666aa61..37602e99 100644
--- a/Utils/ArrayHelpers.php
+++ b/Utils/ArrayHelpers.php
@@ -1,24 +1,25 @@
 <?php
 
 /**
- * @param an array of integers
- * @return is array sorted in ascending
+ * @param  array  $arr  array of integers
+ * @return void array sorted in ascending
  */
-function isSortedAscendingInts(array $arr): void{
+function isSortedAscendingInts(array $arr): void
+{
     $len = count($arr);
 
-    if($len == 0){
+    if ($len == 0) {
         return;
     }
 
-    if(!is_int($arr[0])){
+    if (!is_int($arr[0])) {
         throw UnexpectedValueException;
     }
 
-    for($i = 1; $i < $len; $i++){
+    for ($i = 1; $i < $len; $i++) {
         // a sorted array is expected
-        if(!is_int($arr[$i]) && $arr[$i] < $arr[$i-1]){
-           throw UnexpectedValueException;
+        if (!is_int($arr[$i]) && $arr[$i] < $arr[$i - 1]) {
+            throw UnexpectedValueException;
         }
     }
 }
diff --git a/composer.json b/composer.json
index e3ca6e68..8cc0cbd0 100644
--- a/composer.json
+++ b/composer.json
@@ -3,12 +3,12 @@
   "description": "All Algorithms implemented in PHP",
   "config": {
     "platform": {
-      "php": "7.3.0"
+      "php": "7.4.0"
     }
   },
   "license": "MIT",
   "require": {
-    "php": "7.3.0",
+    "php": "7.4",
     "phan/phan": "^2.7"
   },
   "require-dev": {
diff --git a/tests/Ciphers/CiphersTest.php b/tests/Ciphers/CiphersTest.php
index d6204811..241e729b 100755
--- a/tests/Ciphers/CiphersTest.php
+++ b/tests/Ciphers/CiphersTest.php
@@ -1,6 +1,7 @@
 <?php
 
 use function PHPUnit\Framework\assertEquals;
+
 use PHPUnit\Framework\TestCase;
 
 require_once __DIR__ . '/../../vendor/autoload.php';
@@ -22,7 +23,7 @@ public function testXorCipher()
         $input_str = "test@string";
         $key = "test-key";
         $invalid_key = "wrong-key";
-        $this->assertEquals( $input_str, xorCipher( xorCipher( $input_str , $key) , $key));
-        $this->assertNotEquals( $input_str, xorCipher( xorCipher( $input_str , $key) , $invalid_key));
+        $this->assertEquals($input_str, xorCipher(xorCipher($input_str, $key), $key));
+        $this->assertNotEquals($input_str, xorCipher(xorCipher($input_str, $key), $invalid_key));
     }
 }
diff --git a/tests/Ciphers/MonoAlphabeticCipherTest.php b/tests/Ciphers/MonoAlphabeticCipherTest.php
index 4509ab4c..de900967 100644
--- a/tests/Ciphers/MonoAlphabeticCipherTest.php
+++ b/tests/Ciphers/MonoAlphabeticCipherTest.php
@@ -1,23 +1,21 @@
-<?php
-use PHPUnit\Framework\TestCase;
-use function PHPUnit\Framework\assertEquals;
-
-require_once __DIR__ . '/../../vendor/autoload.php';
-require_once __DIR__ . '/../../Ciphers/MonoAlphabeticCipher.php';
-
-class MonoAlphabeticCipherTest extends TestCase
-{
-    public function testMonoAlphabeticCipher(){
-        $alphabet = "abcdefghijklmnopqrstuvwxyz";
-        $key = "yhkqgvxfoluapwmtzecjdbsnri";
-        $text = "I love1234 GitHub";
-        $encryptedText = "O ambg XojFdh";
-
-        assertEquals(maEncrypt($key, $alphabet, $text), $encryptedText);
-
-        assertEquals(maDecrypt($key, $alphabet, $encryptedText), "I love GitHub");
-
-    }
-}
-
-?>
+<?php
+
+use PHPUnit\Framework\TestCase;
+
+use function PHPUnit\Framework\assertEquals;
+
+require_once __DIR__ . '/../../vendor/autoload.php';
+require_once __DIR__ . '/../../Ciphers/MonoAlphabeticCipher.php';
+
+class MonoAlphabeticCipherTest extends TestCase
+{
+    public function testMonoAlphabeticCipher()
+    {
+        $alphabet = "abcdefghijklmnopqrstuvwxyz";
+        $key = "yhkqgvxfoluapwmtzecjdbsnri";
+        $text = "I love1234 GitHub";
+        $encryptedText = "O ambg XojFdh";
+        assertEquals(maEncrypt($key, $alphabet, $text), $encryptedText);
+        assertEquals(maDecrypt($key, $alphabet, $encryptedText), "I love GitHub");
+    }
+}
diff --git a/tests/Ciphers/MorseCodeTest.php b/tests/Ciphers/MorseCodeTest.php
index 7c9b97b7..10bce3b3 100644
--- a/tests/Ciphers/MorseCodeTest.php
+++ b/tests/Ciphers/MorseCodeTest.php
@@ -1,6 +1,7 @@
 <?php
 
 use function PHPUnit\Framework\assertEquals;
+
 use PHPUnit\Framework\TestCase;
 
 require_once __DIR__ . '/../../vendor/autoload.php';
diff --git a/tests/Conversions/ConversionsTest.php b/tests/Conversions/ConversionsTest.php
index 026f94fe..cb8fb511 100644
--- a/tests/Conversions/ConversionsTest.php
+++ b/tests/Conversions/ConversionsTest.php
@@ -1,6 +1,7 @@
 <?php
 
 use function PHPUnit\Framework\assertEquals;
+
 use PHPUnit\Framework\TestCase;
 
 require_once __DIR__ . '/../../vendor/autoload.php';
diff --git a/tests/Graphs/BreadthFirstSearchTest.php b/tests/Graphs/BreadthFirstSearchTest.php
index 7f5fd181..ec68c909 100644
--- a/tests/Graphs/BreadthFirstSearchTest.php
+++ b/tests/Graphs/BreadthFirstSearchTest.php
@@ -46,4 +46,3 @@ public function testBreadthFirstSearch3()
         $this->assertTrue($ans);
     }
 }
-
diff --git a/tests/Maths/MathsTest.php b/tests/Maths/MathsTest.php
index 8684a738..d3bc9b47 100644
--- a/tests/Maths/MathsTest.php
+++ b/tests/Maths/MathsTest.php
@@ -3,6 +3,7 @@
 use function PHPUnit\Framework\assertEquals;
 use function PHPUnit\Framework\assertFalse;
 use function PHPUnit\Framework\assertTrue;
+
 use PHPUnit\Framework\TestCase;
 
 require_once __DIR__ . '/../../vendor/autoload.php';
@@ -107,7 +108,7 @@ public function testNeonNumber()
         assertFalse(isNumberNeon(123));
         assertTrue(isNumberNeon(9));
     }
-    
+
     public function testFibonacciGenerator()
     {
         assertEquals([0, 1, 1, 2, 3], iterator_to_array(loop(5, fib())));
@@ -120,15 +121,15 @@ public function testFibonacciGenerator()
     public function testMean()
     {
         assertEquals(
-            (2 + 4 + 6 + 8 + 20 + 50 + 70) / 7, 
+            (2 + 4 + 6 + 8 + 20 + 50 + 70) / 7,
             mean(2, 4, 6, 8, 20, 50, 70)
         );
 
         assertEquals(
-            (-5 - 7 + 10) / 3, 
+            (-5 - 7 + 10) / 3,
             mean(-5, -7, 10)
         );
-        
+
         assertEquals(-1, mean(-1));
     }
 
@@ -146,5 +147,4 @@ public function testMode()
         $this->assertEquals([1, 2, 3, 4, 5], mode(1, 2, 3, 4, 5));
         $this->assertEquals([2, 3, 4], mode(2, 2, 3, 3, 4, 4));
     }
-
 }
diff --git a/tests/Maths/ProjectEulerTest.php b/tests/Maths/ProjectEulerTest.php
index 3b74f3ed..43b1da47 100644
--- a/tests/Maths/ProjectEulerTest.php
+++ b/tests/Maths/ProjectEulerTest.php
@@ -62,7 +62,7 @@ public function testProblem9(): void
     {
         $this->assertSame(31875000, problem9());
     }
-    
+
     public function testProblem10(): void
     {
         $this->assertSame(142913828922, problem10());
diff --git a/tests/Searches/SearchesTest.php b/tests/Searches/SearchesTest.php
index 08d2f716..3de89db9 100644
--- a/tests/Searches/SearchesTest.php
+++ b/tests/Searches/SearchesTest.php
@@ -3,6 +3,7 @@
 use function PHPUnit\Framework\assertEquals;
 use function PHPUnit\Framework\assertFalse;
 use function PHPUnit\Framework\assertTrue;
+
 use PHPUnit\Framework\TestCase;
 
 require_once __DIR__ . '/../../vendor/autoload.php';
@@ -138,7 +139,7 @@ public function testUpperBound()
         $result = upperBound($list, $target);
         assertEquals(5, $result);
     }
-    
+
     public function testJumpSearch()
     {
         $list = array( 3,5,6,7,9,10,12,20,22,24);
diff --git a/tests/Sorting/ArrayKeysSortTest.php b/tests/Sorting/ArrayKeysSortTest.php
index 2b054987..31c322df 100644
--- a/tests/Sorting/ArrayKeysSortTest.php
+++ b/tests/Sorting/ArrayKeysSortTest.php
@@ -7,7 +7,8 @@
 
 class ArrayKeysSortTest extends TestCase
 {
-    public function testArrayKeysSort() {
+    public function testArrayKeysSort()
+    {
         //test array of arrays
         $array1 = [
             ['fruit' => 'banana', 'color' => 'yellow', 'cant' => 5],
@@ -36,22 +37,22 @@ public function testArrayKeysSort() {
         $this->assertEquals($result2, $test2);
 
         //test array of objects
-        $object1 = new \stdClass;
+        $object1 = new \stdClass();
         $object1->fruit = 'banana';
         $object1->color = 'yellow';
         $object1->cant = 5;
 
-        $object2 = new \stdClass;
+        $object2 = new \stdClass();
         $object2->fruit = 'apple';
         $object2->color = 'red';
         $object2->cant = 2;
 
-        $object3 = new \stdClass;
+        $object3 = new \stdClass();
         $object3->fruit = 'apple';
         $object3->color = 'green';
         $object3->cant = 7;
 
-        $object4 = new \stdClass;
+        $object4 = new \stdClass();
         $object4->fruit = 'grapes';
         $object4->color = 'purple';
         $object4->cant = 4;
diff --git a/tests/Strings/StringsTest.php b/tests/Strings/StringsTest.php
index 3b17907e..41cd170e 100644
--- a/tests/Strings/StringsTest.php
+++ b/tests/Strings/StringsTest.php
@@ -4,6 +4,7 @@
 use function PHPUnit\Framework\assertFalse;
 use function PHPUnit\Framework\assertNotEquals;
 use function PHPUnit\Framework\assertTrue;
+
 use PHPUnit\Framework\TestCase;
 
 require_once __DIR__ . '/../../vendor/autoload.php';