diff --git a/src/Algorithms/s0001_two_sum/Solution.php b/src/Algorithms/s0001_two_sum/Solution.php
index f368863..7ef39e1 100644
--- a/src/Algorithms/s0001_two_sum/Solution.php
+++ b/src/Algorithms/s0001_two_sum/Solution.php
@@ -1,3 +1,9 @@
+<?php
+
+// #Easy #Top_100_Liked_Questions #Top_Interview_Questions #Array #Hash_Table
+// #Data_Structure_I_Day_2_Array #Level_1_Day_13_Hashmap #Udemy_Arrays #Big_O_Time_O(n)_Space_O(n)
+// #2024_01_16_Time_15_ms_(85.61%)_Space_20_MB_(40.39%)
+
 class Solution {
 
     /**
@@ -13,9 +19,9 @@ function twoSum($nums, $target) {
         for ($i = 0; $i < count($nums); $i++) {
             $complement = $target - $nums[$i];
             if (array_key_exists($complement, $map) && $map[$complement] != $i) {
-                return [$i, $map[$complement] ];
+                return [$i, $map[$complement]];
             }
         }
-        throw new IllegalArgumentException("No two sum solution");      
+        throw new IllegalArgumentException("No two sum solution");
     }
 }
diff --git a/src/Algorithms/s0002_add_two_numbers/Solution.php b/src/Algorithms/s0002_add_two_numbers/Solution.php
index 4b6a4a2..c61db82 100644
--- a/src/Algorithms/s0002_add_two_numbers/Solution.php
+++ b/src/Algorithms/s0002_add_two_numbers/Solution.php
@@ -1,3 +1,9 @@
+<?php
+
+// #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Math #Linked_List #Recursion
+// #Data_Structure_II_Day_10_Linked_List #Programming_Skills_II_Day_15
+// #Big_O_Time_O(max(N,M))_Space_O(max(N,M)) #2024_01_16_Time_14_ms_(73.15%)_Space_19.6_MB_(25.98%)
+
 /**
  * Definition for a singly-linked list.
  * class ListNode {
@@ -15,7 +21,9 @@ class Solution {
      */
     function addTwoNumbers($l1, $l2) {
         $dummyHead = new ListNode(0);
-        $p = $l1; $q = $l2; $curr = $dummyHead;
+        $p = $l1;
+        $q = $l2;
+        $curr = $dummyHead;
         $carry = 0;
         while ($p != null || $q != null) {
             $x = ($p != null) ? $p->val : 0;
diff --git a/src/Algorithms/s0003_longest_substring_without_repeating_characters/Solution.php b/src/Algorithms/s0003_longest_substring_without_repeating_characters/Solution.php
index f131766..6322784 100644
--- a/src/Algorithms/s0003_longest_substring_without_repeating_characters/Solution.php
+++ b/src/Algorithms/s0003_longest_substring_without_repeating_characters/Solution.php
@@ -1,3 +1,9 @@
+<?php
+
+// #Medium #Top_100_Liked_Questions #Top_Interview_Questions #String #Hash_Table #Sliding_Window
+// #Algorithm_I_Day_6_Sliding_Window #Level_2_Day_14_Sliding_Window/Two_Pointer #Udemy_Strings
+// #Big_O_Time_O(n)_Space_O(1) #2024_01_16_Time_14_ms_(75.32%)_Space_19.8_MB_(36.83%)
+
 class Solution {
 
     /**
@@ -5,11 +11,11 @@ class Solution {
      * @return Integer
      */
     function lengthOfLongestSubstring($s) {
-        if (strlen($s)==0) return 0;
+        if (strlen($s) == 0) return 0;
         $map = [];
         $max = 0;
-        for ($i=0, $j=0; $i < strlen($s); ++$i) {
-            if (array_key_exists($s[$i], $map)){
+        for ($i = 0, $j = 0; $i < strlen($s); ++$i) {
+            if (array_key_exists($s[$i], $map)) {
                 $j = max($j, $map[$s[$i]] + 1);
             }
             $map[$s[$i]] = $i;
@@ -17,4 +23,4 @@ function lengthOfLongestSubstring($s) {
         }
         return $max;
     }
-}
\ No newline at end of file
+}
diff --git a/src/Algorithms/s0004_median_of_two_sorted_arrays/Solution.php b/src/Algorithms/s0004_median_of_two_sorted_arrays/Solution.php
index bfd5153..06435c8 100644
--- a/src/Algorithms/s0004_median_of_two_sorted_arrays/Solution.php
+++ b/src/Algorithms/s0004_median_of_two_sorted_arrays/Solution.php
@@ -1,3 +1,8 @@
+<?php
+
+// #Hard #Top_100_Liked_Questions #Top_Interview_Questions #Array #Binary_Search #Divide_and_Conquer
+// #Big_O_Time_O(log(min(N,M)))_Space_O(1) #2024_01_16_Time_28_ms_(75.00%)_Space_19.6_MB_(54.49%)
+
 class Solution {
 
     /**
@@ -7,30 +12,23 @@ class Solution {
      */
     function findMedianSortedArrays($nums1, $nums2) {
         $array = range(0, count($nums1) + count($nums2) - 1);
-        $p=0; $q=0;
+        $p = 0;
+        $q = 0;
 
 
-        for($i =0;$i< count($array);$i++)
-        {
-            if(($p<count($nums1) && $q< count($nums2) && $nums1[$p]<=$nums2[$q]) || $q==count($nums2))
-            {
-                $array[$i]=$nums1[$p];
+        for ($i = 0; $i < count($array); $i++) {
+            if (($p < count($nums1) && $q < count($nums2) && $nums1[$p] <= $nums2[$q]) || $q == count($nums2)) {
+                $array[$i] = $nums1[$p];
                 $p++;
-            }
-
-            else if(($p<count($nums1) && $q< count($nums2) && $nums1[$p]>$nums2[$q]) || $p==count($nums1))
-            {
-                $array[$i]=$nums2[$q];
+            } else if (($p < count($nums1) && $q < count($nums2) && $nums1[$p] > $nums2[$q]) || $p == count($nums1)) {
+                $array[$i] = $nums2[$q];
                 $q++;
             }
         }
 
-        if (intval(count($array) % 2)==0)
-        {
-            return doubleval($array[count($array) / 2] + $array[(count($array) / 2) - 1])/2;
-        }
-        else
-        {
+        if (intval(count($array) % 2) == 0) {
+            return doubleval($array[count($array) / 2] + $array[(count($array) / 2) - 1]) / 2;
+        } else {
             return doubleval($array[count($array) / 2]);
         }
     }
diff --git a/src/Algorithms/s0005_longest_palindromic_substring/Solution.php b/src/Algorithms/s0005_longest_palindromic_substring/Solution.php
index ca2d331..cc904be 100644
--- a/src/Algorithms/s0005_longest_palindromic_substring/Solution.php
+++ b/src/Algorithms/s0005_longest_palindromic_substring/Solution.php
@@ -1,3 +1,10 @@
+<?php
+
+// #Medium #Top_100_Liked_Questions #Top_Interview_Questions #String #Dynamic_Programming
+// #Data_Structure_II_Day_9_String #Algorithm_II_Day_14_Dynamic_Programming
+// #Dynamic_Programming_I_Day_17 #Udemy_Strings #Big_O_Time_O(n)_Space_O(n)
+// #2024_01_16_Time_1146_ms_(40.69%)_Space_37.4_MB_(6.37%)
+
 class Solution {
 
     /**
@@ -5,16 +12,17 @@ class Solution {
      * @return String
      */
     function longestPalindrome($s) {
-       if(strlen($s) == 0) {
+        if (strlen($s) == 0) {
             return $s;
-       }
-       $dp = array_fill(0, strlen($s), array_fill(0, strlen($s), false));
-       $longestPalindromeStart = 0; $longestPalindromeLength = 1;
-        for($i=strlen($s)-1;$i>=0;$i--){
+        }
+        $dp = array_fill(0, strlen($s), array_fill(0, strlen($s), false));
+        $longestPalindromeStart = 0;
+        $longestPalindromeLength = 1;
+        for ($i = strlen($s) - 1; $i >= 0; $i--) {
             $dp[$i][$i] = true;  //single character is a palindrome so making it true
-            for($j=$i+1;$j<strlen($s);$j++){
-                if(($s[$i]==$s[$j] && $dp[$i+1][$j-1])|| ($i+1==$j&&$s[$i]==$s[$j] )){ //checking for two edge cases 1.if characters are equal check for diagonal lower left one if true make it true 2. or if both equal and its the first elelment in the loop make it as true
-                        $dp[$i][$j] = true;
+            for ($j = $i + 1; $j < strlen($s); $j++) {
+                if (($s[$i] == $s[$j] && $dp[$i + 1][$j - 1]) || ($i + 1 == $j && $s[$i] == $s[$j])) { //checking for two edge cases 1.if characters are equal check for diagonal lower left one if true make it true 2. or if both equal and its the first elelment in the loop make it as true
+                    $dp[$i][$j] = true;
                     if ($j - $i + 1 > $longestPalindromeLength) { // update the length if greater than previous
                         $longestPalindromeLength = $j - $i + 1;
                         $longestPalindromeStart = $i;
@@ -23,6 +31,6 @@ function longestPalindrome($s) {
             }
         }
         // return the substring using starting and ending index
-        return substr($s, $longestPalindromeStart,$longestPalindromeLength);        
+        return substr($s, $longestPalindromeStart, $longestPalindromeLength);
     }
-}
\ No newline at end of file
+}
diff --git a/src/Algorithms/s0006_zigzag_conversion/Solution.php b/src/Algorithms/s0006_zigzag_conversion/Solution.php
index 6a3e81a..cd2db02 100644
--- a/src/Algorithms/s0006_zigzag_conversion/Solution.php
+++ b/src/Algorithms/s0006_zigzag_conversion/Solution.php
@@ -1,3 +1,7 @@
+<?php
+
+// #Medium #String #2024_01_16_Time_10_ms_(90.40%)_Space_19.5_MB_(58.08%)
+
 class Solution {
 
     /**
@@ -21,4 +25,4 @@ function convert($s, $numRows) {
         }
         return $ret;
     }
-}
\ No newline at end of file
+}
diff --git a/src/Algorithms/s0007_reverse_integer/Solution.php b/src/Algorithms/s0007_reverse_integer/Solution.php
index 1427a0e..d885818 100644
--- a/src/Algorithms/s0007_reverse_integer/Solution.php
+++ b/src/Algorithms/s0007_reverse_integer/Solution.php
@@ -1,3 +1,8 @@
+<?php
+
+// #Medium #Top_Interview_Questions #Math #Udemy_Integers
+// #2024_01_16_Time_7_ms_(67.94%)_Space_19.5_MB_(33.82%)
+
 class Solution {
 
     /**
@@ -5,12 +10,12 @@ class Solution {
      * @return Integer
      */
     function reverse($x) {
-        $rev = 0; 
+        $rev = 0;
         while ($x != 0) {
             $rev = ($rev * 10) + ($x % 10);
             $x = intval($x / 10);
         }
-        if (intval($rev) > 2147483647  || intval($rev) < -2147483647 ) return 0;
-        return intval($rev);   
+        if (intval($rev) > 2147483647 || intval($rev) < -2147483647) return 0;
+        return intval($rev);
     }
 }
diff --git a/src/Algorithms/s0008_string_to_integer_atoi/Solution.php b/src/Algorithms/s0008_string_to_integer_atoi/Solution.php
index 85d34c6..baa73a7 100644
--- a/src/Algorithms/s0008_string_to_integer_atoi/Solution.php
+++ b/src/Algorithms/s0008_string_to_integer_atoi/Solution.php
@@ -1,3 +1,7 @@
+<?php
+
+// #Medium #Top_Interview_Questions #String #2024_01_16_Time_4_ms_(85.00%)_Space_19.8_MB_(8.00%)
+
 class Solution {
 
     /**
@@ -5,22 +9,25 @@ class Solution {
      * @return Integer
      */
     function myAtoi($str) {
-	if (trim($str) == '')
-		return 0;
-	$str = trim($str);
-	$i = 0; $ans = 0; $sign = 1; $len = strlen($str);
-	if ($str[$i] == '-' || $str[$i] == '+')
-		$sign = $str[$i++] == '+' ? 1 : -1;
-	for (; $i < $len; ++$i) {
-		$tmp = ord($str[$i]) - ord('0');
-		if ($tmp < 0 || $tmp > 9)
-			break;
-		if ($ans > intval(2147483647 / 10)
-				|| ($ans == intval(2147483647 / 10) && (2147483647 % 10) < $tmp)) {
-			return $sign == 1 ? 2147483647 : -2147483648;
-                } else
-			$ans = $ans * 10 + $tmp;
-       	}
-	return $sign * $ans;
+        if (trim($str) == '')
+            return 0;
+        $str = trim($str);
+        $i = 0;
+        $ans = 0;
+        $sign = 1;
+        $len = strlen($str);
+        if ($str[$i] == '-' || $str[$i] == '+')
+            $sign = $str[$i++] == '+' ? 1 : -1;
+        for (; $i < $len; ++$i) {
+            $tmp = ord($str[$i]) - ord('0');
+            if ($tmp < 0 || $tmp > 9)
+                break;
+            if ($ans > intval(2147483647 / 10)
+                || ($ans == intval(2147483647 / 10) && (2147483647 % 10) < $tmp)) {
+                return $sign == 1 ? 2147483647 : -2147483648;
+            } else
+                $ans = $ans * 10 + $tmp;
+        }
+        return $sign * $ans;
     }
 }
diff --git a/src/Algorithms/s0009_palindrome_number/Solution.php b/src/Algorithms/s0009_palindrome_number/Solution.php
index 545b004..ca6ad22 100644
--- a/src/Algorithms/s0009_palindrome_number/Solution.php
+++ b/src/Algorithms/s0009_palindrome_number/Solution.php
@@ -1,3 +1,7 @@
+<?php
+
+// #Easy #Math #Udemy_Integers #2024_01_16_Time_25_ms_(72.15%)_Space_19.6_MB_(10.33%)
+
 class Solution {
 
     /**
@@ -5,12 +9,14 @@ class Solution {
      * @return Boolean
      */
     function isPalindrome($x) {
-        if($x<0) return false;
-        $i = 0; $rev = 0; $ori = $x;
-        for($i=10; $x>0; $x= intval($x / 10)){
+        if ($x < 0) return false;
+        $i = 0;
+        $rev = 0;
+        $ori = $x;
+        for ($i = 10; $x > 0; $x = intval($x / 10)) {
             $rev *= 10;
             $rev += $x % $i;
         }
-        return $rev==$ori;   
+        return $rev == $ori;
     }
-}
\ No newline at end of file
+}
diff --git a/src/Algorithms/s0010_regular_expression_matching/Solution.php b/src/Algorithms/s0010_regular_expression_matching/Solution.php
index 8f6322f..b643927 100644
--- a/src/Algorithms/s0010_regular_expression_matching/Solution.php
+++ b/src/Algorithms/s0010_regular_expression_matching/Solution.php
@@ -1,3 +1,9 @@
+<?php
+
+// #Hard #Top_100_Liked_Questions #Top_Interview_Questions #String #Dynamic_Programming #Recursion
+// #Udemy_Dynamic_Programming #Big_O_Time_O(m*n)_Space_O(m*n)
+// #2024_01_16_Time_16_ms_(25.58%)_Space_19.3_MB_(79.07%)
+
 class Solution {
 
     /**
@@ -9,18 +15,18 @@ function isMatch($s, $p) {
         $dp = array_fill(0, strlen($s) + 1, array_fill(0, strlen($p) + 1, false));
         $dp[strlen($s)][strlen($p)] = true;
 
-        for ($i = strlen($s); $i >= 0; $i--){
-            for ($j = strlen($p) - 1; $j >= 0; $j--){
+        for ($i = strlen($s); $i >= 0; $i--) {
+            for ($j = strlen($p) - 1; $j >= 0; $j--) {
                 $first_match = ($i < strlen($s) &&
-                                       ($p[$j] == $s[$i] ||
-                                        $p[$j] == '.'));
-                if ($j + 1 < strlen($p) && $p[$j+1] == '*'){
-                    $dp[$i][$j] = $dp[$i][$j+2] || $first_match && $dp[$i+1][$j];
+                    ($p[$j] == $s[$i] ||
+                        $p[$j] == '.'));
+                if ($j + 1 < strlen($p) && $p[$j + 1] == '*') {
+                    $dp[$i][$j] = $dp[$i][$j + 2] || $first_match && $dp[$i + 1][$j];
                 } else {
-                    $dp[$i][$j] = $first_match && $dp[$i+1][$j+1];
+                    $dp[$i][$j] = $first_match && $dp[$i + 1][$j + 1];
                 }
             }
         }
         return $dp[0][0];
     }
-}
\ No newline at end of file
+}
diff --git a/src/Algorithms/s0011_container_with_most_water/Solution.php b/src/Algorithms/s0011_container_with_most_water/Solution.php
index 35b310c..9442426 100644
--- a/src/Algorithms/s0011_container_with_most_water/Solution.php
+++ b/src/Algorithms/s0011_container_with_most_water/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -5,7 +7,9 @@ class Solution {
      * @return Integer
      */
     function maxArea($height) {
-        $maxarea = 0; $l = 0; $r = count($height) - 1;
+        $maxarea = 0;
+        $l = 0;
+        $r = count($height) - 1;
         while ($l < $r) {
             $maxarea = max($maxarea, min($height[$l], $height[$r]) * ($r - $l));
             if ($height[$l] < $height[$r])
diff --git a/src/Algorithms/s0012_integer_to_roman/Solution.php b/src/Algorithms/s0012_integer_to_roman/Solution.php
index af4f8ea..bce80ba 100644
--- a/src/Algorithms/s0012_integer_to_roman/Solution.php
+++ b/src/Algorithms/s0012_integer_to_roman/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -9,15 +11,15 @@ function intToRoman($num) {
         $values = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1];
         $roman = ["M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"];
         $i = 0;
-        
-        while($num > 0){
-            $repeats = intval($num/$values[$i]);
-            if($repeats >= 1){
-                while($repeats != 0){
+
+        while ($num > 0) {
+            $repeats = intval($num / $values[$i]);
+            if ($repeats >= 1) {
+                while ($repeats != 0) {
                     $sb .= $roman[$i];
                     $repeats--;
                 }
-                $num = $num - intval($num/$values[$i])*$values[$i];
+                $num = $num - intval($num / $values[$i]) * $values[$i];
             }
             $i++;
         }
diff --git a/src/Algorithms/s0013_roman_to_integer/Solution.php b/src/Algorithms/s0013_roman_to_integer/Solution.php
index 0acda30..94e1136 100644
--- a/src/Algorithms/s0013_roman_to_integer/Solution.php
+++ b/src/Algorithms/s0013_roman_to_integer/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -6,31 +8,29 @@ class Solution {
      */
     function romanToInt($s) {
         $map = [
-        'I' => 1,
-        'V' => 5,
-        'X' => 10,
-        'L' => 50,
-        'C' => 100,
-        'D' => 500,
-        'M' =>  1000];
-        
+            'I' => 1,
+            'V' => 5,
+            'X' => 10,
+            'L' => 50,
+            'C' => 100,
+            'D' => 500,
+            'M' => 1000];
+
         $result = 0;
-        for($i = 0; $i < strlen($s); $i++) {
+        for ($i = 0; $i < strlen($s); $i++) {
             $first = $map[$s[$i]];
-            if($i <= strlen($s) - 2) {
+            if ($i <= strlen($s) - 2) {
                 $second = $map[$s[$i + 1]];
-                if($second > $first) {
+                if ($second > $first) {
                     $result += $second - $first;
                     $i++;
-                }
-                else {
+                } else {
                     $result += $first;
                 }
-            }
-            else
+            } else
                 $result += $first;
         }
-        
+
         return $result;
     }
 }
\ No newline at end of file
diff --git a/src/Algorithms/s0014_longest_common_prefix/Solution.php b/src/Algorithms/s0014_longest_common_prefix/Solution.php
index 9779c7f..90010ed 100644
--- a/src/Algorithms/s0014_longest_common_prefix/Solution.php
+++ b/src/Algorithms/s0014_longest_common_prefix/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -23,7 +25,7 @@ function longestCommonPrefix($strs) {
         return substr($strs[0], 0, intval(($low + $high) / 2));
     }
 
-    function isCommonPrefix($strs, $len){
+    function isCommonPrefix($strs, $len) {
         $str1 = substr($strs[0], 0, $len);
         for ($i = 1; $i < count($strs); $i++) {
             if (!self::startsWith($strs[$i], $str1)) {
@@ -32,7 +34,7 @@ function isCommonPrefix($strs, $len){
         }
         return true;
     }
-    
+
     function startsWith($haystack, $needle) {
         return strncmp($haystack, $needle, strlen($needle)) === 0;
     }
diff --git a/src/Algorithms/s0015_3sum/Solution.php b/src/Algorithms/s0015_3sum/Solution.php
index 2214033..f593b23 100644
--- a/src/Algorithms/s0015_3sum/Solution.php
+++ b/src/Algorithms/s0015_3sum/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -7,7 +9,10 @@ class Solution {
     function threeSum($nums) {
         $res = [];
         sort($nums);
-        $i = 0; $j = 0; $n = count($nums); $k = $n - 1;
+        $i = 0;
+        $j = 0;
+        $n = count($nums);
+        $k = $n - 1;
         if ($k < 2 || $nums[$k] < 0) {
             return $res;
         }
@@ -24,15 +29,15 @@ function threeSum($nums) {
                 }
                 if ($nums[$j] + $nums[$k] == $target) {
                     $res[] = [$nums[$i], $nums[$j], $nums[$k]];
-                    while($j < $k && $nums[$j] == $nums[++$j]);
-                    while($j < $k && $nums[$k] == $nums[--$k]);
+                    while ($j < $k && $nums[$j] == $nums[++$j]) ;
+                    while ($j < $k && $nums[$k] == $nums[--$k]) ;
                 } else if ($nums[$j] + $nums[$k] > $target) {
                     $k--;
                 } else {
                     $j++;
                 }
             }
-            while ($i < $n - 2 && $nums[$i] == $nums[++$i]);
+            while ($i < $n - 2 && $nums[$i] == $nums[++$i]) ;
         }
         return $res;
     }
diff --git a/src/Algorithms/s0016_3sum_closest/Solution.php b/src/Algorithms/s0016_3sum_closest/Solution.php
index d7c8856..b0fa7f5 100644
--- a/src/Algorithms/s0016_3sum_closest/Solution.php
+++ b/src/Algorithms/s0016_3sum_closest/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -9,23 +11,23 @@ function threeSumClosest($nums, $target) {
         sort($nums);
         $min = 2147483647;
         $res = 0;
-        for($i=2;$i<count($nums);$i++){
-            $l=0;$r=$i-1;
+        for ($i = 2; $i < count($nums); $i++) {
+            $l = 0;
+            $r = $i - 1;
 
-            while($l<$r){
-                $sum = $nums[$l]+$nums[$r]+$nums[$i];
-                if($sum == $target){
+            while ($l < $r) {
+                $sum = $nums[$l] + $nums[$r] + $nums[$i];
+                if ($sum == $target) {
                     return $target;
                 }
-                $diff= abs($target-$sum);
-                if($diff<$min){
+                $diff = abs($target - $sum);
+                if ($diff < $min) {
                     $min = $diff;
                     $res = $sum;
                 }
-                if($sum<$target){
+                if ($sum < $target) {
                     $l++;
-                }
-                else{
+                } else {
                     $r--;
                 }
             }
diff --git a/src/Algorithms/s0017_letter_combinations_of_a_phone_number/Solution.php b/src/Algorithms/s0017_letter_combinations_of_a_phone_number/Solution.php
index 1e65df9..ca7363b 100644
--- a/src/Algorithms/s0017_letter_combinations_of_a_phone_number/Solution.php
+++ b/src/Algorithms/s0017_letter_combinations_of_a_phone_number/Solution.php
@@ -1,45 +1,47 @@
-class Solution {
-  public function __construct() {
-      $this->phone = [
-        "2" => "abc",
-        "3" => "def",
-        "4" => "ghi",
-        "5" => "jkl",
-        "6" => "mno",
-        "7" => "pqrs",
-        "8" => "tuv",
-        "9" => "wxyz"
-      ];
-      $this->output = [];
-  }
+<?php
 
-  function backtrack($combination, $next_digits) {
-    // if there is no more digits to check
-    if (strlen($next_digits) == 0) {
-      // the combination is done
-      array_push($this->output, $combination);
+class Solution {
+    public function __construct() {
+        $this->phone = [
+            "2" => "abc",
+            "3" => "def",
+            "4" => "ghi",
+            "5" => "jkl",
+            "6" => "mno",
+            "7" => "pqrs",
+            "8" => "tuv",
+            "9" => "wxyz"
+        ];
+        $this->output = [];
     }
-    // if there are still digits to check
-    else {
-      // iterate over all letters which map 
-      // the next available digit
-      $digit = substr($next_digits, 0, 1);
-      $letters = $this->phone[$digit];
-      for ($i = 0; $i < strlen($letters); $i++) {
-        $letter = substr($this->phone[$digit], $i, 1);
-        // append the current letter to the combination
-        // and proceed to the next digits
-        self::backtrack($combination . $letter, substr($next_digits, 1));
-      }
+
+    function backtrack($combination, $next_digits) {
+        // if there is no more digits to check
+        if (strlen($next_digits) == 0) {
+            // the combination is done
+            array_push($this->output, $combination);
+        } // if there are still digits to check
+        else {
+            // iterate over all letters which map
+            // the next available digit
+            $digit = substr($next_digits, 0, 1);
+            $letters = $this->phone[$digit];
+            for ($i = 0; $i < strlen($letters); $i++) {
+                $letter = substr($this->phone[$digit], $i, 1);
+                // append the current letter to the combination
+                // and proceed to the next digits
+                self::backtrack($combination . $letter, substr($next_digits, 1));
+            }
+        }
     }
-  }
+
     /**
      * @param String $digits
      * @return String[]
      */
     function letterCombinations($digits) {
         if (strlen($digits) != 0)
-          self::backtrack("", $digits);
-        return $this->output;       
+            self::backtrack("", $digits);
+        return $this->output;
     }
 }
diff --git a/src/Algorithms/s0018_4sum/Solution.php b/src/Algorithms/s0018_4sum/Solution.php
index 791a357..eee4189 100644
--- a/src/Algorithms/s0018_4sum/Solution.php
+++ b/src/Algorithms/s0018_4sum/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -8,48 +10,46 @@ class Solution {
     function fourSum($nums, $target) {
         $result = [];
         sort($nums);
-        $sum  = 0;
-        
-        for($i=0;$i<count($nums);$i++){
-            if($i!=0 && $nums[$i-1]==$nums[$i]) // avoid duplicates
+        $sum = 0;
+
+        for ($i = 0; $i < count($nums); $i++) {
+            if ($i != 0 && $nums[$i - 1] == $nums[$i]) // avoid duplicates
                 continue;
-            
-            for($j=$i+1;$j<count($nums);$j++){
-                
-                if($nums[$j-1]==$nums[$j] && $i!=$j-1) // // avoid duplicates
+
+            for ($j = $i + 1; $j < count($nums); $j++) {
+
+                if ($nums[$j - 1] == $nums[$j] && $i != $j - 1) // // avoid duplicates
                     continue;
-                
-                $k = $j+1;
-                $l = count($nums)-1;
-                
-                while($k<$l){
-                    
+
+                $k = $j + 1;
+                $l = count($nums) - 1;
+
+                while ($k < $l) {
+
                     $output = [];
-                    if($nums[$i]+$nums[$j]+$nums[$k]+$nums[$l]==$target){
+                    if ($nums[$i] + $nums[$j] + $nums[$k] + $nums[$l] == $target) {
                         $output[] = $nums[$i];
                         $output[] = $nums[$j];
                         $output[] = $nums[$k];
                         $output[] = $nums[$l];
                         $result[] = $output;
-                        
+
                         $k++;
-                        while($k<$l && $nums[$k-1]==$nums[$k]) // avoid duplicates
+                        while ($k < $l && $nums[$k - 1] == $nums[$k]) // avoid duplicates
                             $k++;
-                        
+
                         $l--;
-                        while($k<$l && $nums[$l+1]==$nums[$l])  // avoid duplicates
+                        while ($k < $l && $nums[$l + 1] == $nums[$l])  // avoid duplicates
                             $l--;
-                    }
-                    else if($nums[$i]+$nums[$j]+$nums[$k]+$nums[$l]>$target){
+                    } else if ($nums[$i] + $nums[$j] + $nums[$k] + $nums[$l] > $target) {
                         $l--;
-                    }
-                    else 
+                    } else
                         $k++;
                 }
             }
         }
-        
-        
+
+
         return $result;
     }
 }
diff --git a/src/Algorithms/s0019_remove_nth_node_from_end_of_list/Solution.php b/src/Algorithms/s0019_remove_nth_node_from_end_of_list/Solution.php
index 688eb18..aa20461 100644
--- a/src/Algorithms/s0019_remove_nth_node_from_end_of_list/Solution.php
+++ b/src/Algorithms/s0019_remove_nth_node_from_end_of_list/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /**
  * Definition for a singly-linked list.
  * class ListNode {
@@ -17,31 +19,31 @@ function removeNthFromEnd($head, $n) {
         $list = [];
         $size = 1;
         $a = $head;
-        
-        while($a->next != null){
+
+        while ($a->next != null) {
             $list[] = $a;
-            $a=$a->next;
+            $a = $a->next;
             $size++;
         }
         $list[] = $a;
-        
+
         $c = null;
-        
-        if($size==1){            
+
+        if ($size == 1) {
             return $c;
         }
-        if($size==$n){
-            $head=$head->next;
+        if ($size == $n) {
+            $head = $head->next;
             return $head;
         }
-        
-        $b=$list[$size-$n-1];
-        
-        if($b->next->next == null)
-            $b->next=null;
+
+        $b = $list[$size - $n - 1];
+
+        if ($b->next->next == null)
+            $b->next = null;
         else
-            $b->next=$b->next->next;
-        
+            $b->next = $b->next->next;
+
         return $head;
     }
 }
\ No newline at end of file
diff --git a/src/Algorithms/s0020_valid_parentheses/Solution.php b/src/Algorithms/s0020_valid_parentheses/Solution.php
index 58ef5b5..1f95cf8 100644
--- a/src/Algorithms/s0020_valid_parentheses/Solution.php
+++ b/src/Algorithms/s0020_valid_parentheses/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -5,32 +7,32 @@ class Solution {
      * @return Boolean
      */
     function isValid($s) {
-        $toClose=array_fill(0, strlen($s)>>1);
-        $open=0;
-        try{
-            for($i=0; $i<strlen($s); ++$i){
-                $c=$s[$i];
-                $t=0;
-                switch($c){
+        $toClose = array_fill(0, strlen($s) >> 1);
+        $open = 0;
+        try {
+            for ($i = 0; $i < strlen($s); ++$i) {
+                $c = $s[$i];
+                $t = 0;
+                switch ($c) {
                     case '(':
                         ++$t;
                     case '[':
                         ++$t;
                     case '{':
-                        $toClose[$open++]=$t;
+                        $toClose[$open++] = $t;
                         break;
                     case ')':
                         ++$t;
                     case ']':
                         ++$t;
                     case '}':
-                        if($toClose[--$open]!=$t) 
+                        if ($toClose[--$open] != $t)
                             return false;
                 }
             }
-            return $open==0;
-        } catch(OutOfBoundsException $x){
+            return $open == 0;
+        } catch (OutOfBoundsException $x) {
             return false;
-        }    
+        }
     }
 }
diff --git a/src/Algorithms/s0021_merge_two_sorted_lists/Solution.php b/src/Algorithms/s0021_merge_two_sorted_lists/Solution.php
index a5f7def..c75d367 100644
--- a/src/Algorithms/s0021_merge_two_sorted_lists/Solution.php
+++ b/src/Algorithms/s0021_merge_two_sorted_lists/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /**
  * Definition for a singly-linked list.
  * class ListNode {
@@ -34,7 +36,7 @@ function mergeTwoLists($l1, $l2) {
             }
             $cur = $cur->next;
         }
-        
+
         return $res->next;
     }
 }
diff --git a/src/Algorithms/s0022_generate_parentheses/Solution.php b/src/Algorithms/s0022_generate_parentheses/Solution.php
index 04cb18a..e3f1d5e 100644
--- a/src/Algorithms/s0022_generate_parentheses/Solution.php
+++ b/src/Algorithms/s0022_generate_parentheses/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     var $list = [];
@@ -22,6 +24,6 @@ function internal($s, $remainLeft, $remainRight) {
      */
     function generateParenthesis($n) {
         self::internal("", $n, $n);
-        return $this->list;        
+        return $this->list;
     }
 }
diff --git a/src/Algorithms/s0023_merge_k_sorted_lists/Solution.php b/src/Algorithms/s0023_merge_k_sorted_lists/Solution.php
index e9c0dd7..b3010e7 100644
--- a/src/Algorithms/s0023_merge_k_sorted_lists/Solution.php
+++ b/src/Algorithms/s0023_merge_k_sorted_lists/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /**
  * Definition for a singly-linked list.
  * class ListNode {
@@ -13,29 +15,30 @@ class Solution {
      * @return ListNode
      */
     function mergeKLists($lists) {
-        if(count($lists) == 0) {
+        if (count($lists) == 0) {
             return null;
         }
         $l = null;
-        for($i = 0; $i < count($lists); ++$i) {
+        for ($i = 0; $i < count($lists); ++$i) {
             $l = self::mergeTwoLists($l, $lists[$i]);
-        } 
+        }
         return $l;
     }
+
     // AC in LeetCode-23 Merge Two Sorted Lists
-    function  mergeTwoLists($l1, $l2) {
-        if($l1 == null) {
+    function mergeTwoLists($l1, $l2) {
+        if ($l1 == null) {
             return $l2;
-        } else if($l2 == null) {
+        } else if ($l2 == null) {
             return $l1;
         }
 
         $head = new ListNode(-1);
         $cur = $head;
-        while($l1 != null && $l2 != null) {
+        while ($l1 != null && $l2 != null) {
             $cur->next = $l1->val <= $l2->val ? $l1 : $l2;
             $cur = $cur->next;
-            if($cur->val == $l1->val) {
+            if ($cur->val == $l1->val) {
                 $l1 = $l1->next;
             } else {
                 $l2 = $l2->next;
diff --git a/src/Algorithms/s0024_swap_nodes_in_pairs/Solution.php b/src/Algorithms/s0024_swap_nodes_in_pairs/Solution.php
index 96672b7..14c5ec8 100644
--- a/src/Algorithms/s0024_swap_nodes_in_pairs/Solution.php
+++ b/src/Algorithms/s0024_swap_nodes_in_pairs/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /**
  * Definition for a singly-linked list.
  * class ListNode {
@@ -14,8 +16,8 @@ class Solution {
      */
     function swapPairs($head) {
         $cur = $head;
-        while ($cur != null && $cur->next != null){
-           
+        while ($cur != null && $cur->next != null) {
+
             $temp = $cur->val;
             $cur->val = $cur->next->val;
             $cur->next->val = $temp;
diff --git a/src/Algorithms/s0025_reverse_nodes_in_k_group/Solution.php b/src/Algorithms/s0025_reverse_nodes_in_k_group/Solution.php
index 78a08d3..e0241da 100644
--- a/src/Algorithms/s0025_reverse_nodes_in_k_group/Solution.php
+++ b/src/Algorithms/s0025_reverse_nodes_in_k_group/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /**
  * Definition for a singly-linked list.
  * class ListNode {
@@ -14,7 +16,7 @@ class Solution {
      * @return ListNode
      */
     function reverseKGroup($head, $k) {
-        if($head==null || $k<2){
+        if ($head == null || $k < 2) {
             return $head;
         }
 
@@ -22,17 +24,17 @@ function reverseKGroup($head, $k) {
         $curr = $head;
         $prev = null;
         $count = 0;
-        
-        while($count<$k && $curr!=null){
+
+        while ($count < $k && $curr != null) {
             $temp = $curr->next;
             $curr->next = $prev;
             $prev = $curr;
             $curr = $temp;
             $count++;
         }
-        
-        if($count<$k){
-            while($count!=0){
+
+        if ($count < $k) {
+            while ($count != 0) {
                 $temp = $prev->next;
                 $prev->next = $curr;
                 $curr = $prev;
@@ -41,9 +43,9 @@ function reverseKGroup($head, $k) {
             }
             return $curr;
         }
-        
-        $head->next = self::reverseKGroup($curr,$k);
-        
+
+        $head->next = self::reverseKGroup($curr, $k);
+
         return $prev;
     }
 }
diff --git a/src/Algorithms/s0026_remove_duplicates_from_sorted_array/Solution.php b/src/Algorithms/s0026_remove_duplicates_from_sorted_array/Solution.php
index 33d8698..a311a28 100644
--- a/src/Algorithms/s0026_remove_duplicates_from_sorted_array/Solution.php
+++ b/src/Algorithms/s0026_remove_duplicates_from_sorted_array/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
diff --git a/src/Algorithms/s0027_remove_element/Solution.php b/src/Algorithms/s0027_remove_element/Solution.php
index e8d04b1..b055384 100644
--- a/src/Algorithms/s0027_remove_element/Solution.php
+++ b/src/Algorithms/s0027_remove_element/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -7,8 +9,8 @@ class Solution {
      */
     function removeElement(&$nums, $val) {
         $start = 0;
-        for($i = 0; $i < count($nums); $i++){
-            if($nums[$i] != $val){
+        for ($i = 0; $i < count($nums); $i++) {
+            if ($nums[$i] != $val) {
                 $nums[$start] = $nums[$i];
                 $start++;
             }
diff --git a/src/Algorithms/s0028_find_the_index_of_the_first_occurrence_in_a_string/Solution.php b/src/Algorithms/s0028_find_the_index_of_the_first_occurrence_in_a_string/Solution.php
index ca51bc3..b3982f7 100644
--- a/src/Algorithms/s0028_find_the_index_of_the_first_occurrence_in_a_string/Solution.php
+++ b/src/Algorithms/s0028_find_the_index_of_the_first_occurrence_in_a_string/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -6,19 +8,19 @@ class Solution {
      * @return Integer
      */
     function strStr($haystack, $needle) {
-        if(strlen($needle) == 0) return 0;
-        if(strlen($haystack) == 0) return -1;
-        if(strlen($haystack) == 1 && strlen($needle) == 1){
-            if($haystack[0] == $needle[0]){
+        if (strlen($needle) == 0) return 0;
+        if (strlen($haystack) == 0) return -1;
+        if (strlen($haystack) == 1 && strlen($needle) == 1) {
+            if ($haystack[0] == $needle[0]) {
                 return 0;
             }
         }
-        
-        for($i = 0; $i < strlen($haystack) - strlen($needle) + 1; $i++){
-            if($needle === substr($haystack, $i, strlen($needle))){
+
+        for ($i = 0; $i < strlen($haystack) - strlen($needle) + 1; $i++) {
+            if ($needle === substr($haystack, $i, strlen($needle))) {
                 return $i;
             }
         }
-        return -1; 
+        return -1;
     }
 }
diff --git a/src/Algorithms/s0029_divide_two_integers/Solution.php b/src/Algorithms/s0029_divide_two_integers/Solution.php
index fa27581..5f294ea 100644
--- a/src/Algorithms/s0029_divide_two_integers/Solution.php
+++ b/src/Algorithms/s0029_divide_two_integers/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -11,18 +13,20 @@ function divide($dividend, $divisor) {
             if ($divisor > 0) return $dividend;
             else return -$dividend;
         }
-        $l1 = abs($dividend); $l2 = abs($divisor);
+        $l1 = abs($dividend);
+        $l2 = abs($divisor);
         $sol = 0;
-        while($l1 >= $l2){
-            $x = $l2; $y = 1;
-            while($l1 >= $x){
-                $l1-=$x;
-                $sol+=$y;
-                $y+=$y;
-                $x+=$x;
+        while ($l1 >= $l2) {
+            $x = $l2;
+            $y = 1;
+            while ($l1 >= $x) {
+                $l1 -= $x;
+                $sol += $y;
+                $y += $y;
+                $x += $x;
             }
         }
-        if ($dividend > 0 && $divisor < 0 || $dividend<0 && $divisor>0) $sol = -$sol;
+        if ($dividend > 0 && $divisor < 0 || $dividend < 0 && $divisor > 0) $sol = -$sol;
         return $sol;
     }
 }
diff --git a/src/Algorithms/s0030_substring_with_concatenation_of_all_words/Solution.php b/src/Algorithms/s0030_substring_with_concatenation_of_all_words/Solution.php
index 7f07b9f..5b5d9e0 100644
--- a/src/Algorithms/s0030_substring_with_concatenation_of_all_words/Solution.php
+++ b/src/Algorithms/s0030_substring_with_concatenation_of_all_words/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -8,23 +10,28 @@ class Solution {
     function findSubstring($s, $words) {
         $sol = [];
         if (count($words) == 0 || strlen($words[0]) == 0) return $sol;
-        $wordLen = strlen($words[0]); $listLen = count($words); $strLen = strlen($s);
-        $maxIdx = $strLen-$wordLen*$listLen;
+        $wordLen = strlen($words[0]);
+        $listLen = count($words);
+        $strLen = strlen($s);
+        $maxIdx = $strLen - $wordLen * $listLen;
         if ($maxIdx < 0) return $sol;
         $map = [];
         foreach ($words as $ss)
             $map[$ss] = ($map[$ss] == null ? 0 : $map[$ss]) + 1;
         $temp = [];
-        for ($i = 0; $i < $wordLen; $i++){
-            for ($j = $i; $j <= $maxIdx; $j+=$wordLen){
-                for ($k = $listLen-1; $k >= 0; $k--){
-                    $str = substr($s, $k*$wordLen+$j, $wordLen);
+        for ($i = 0; $i < $wordLen; $i++) {
+            for ($j = $i; $j <= $maxIdx; $j += $wordLen) {
+                for ($k = $listLen - 1; $k >= 0; $k--) {
+                    $str = substr($s, $k * $wordLen + $j, $wordLen);
                     $num = ($temp[$str] == null ? 0 : $temp[$str]) + 1;
-                    if ($num > ($map[$str] == null ? 0 : $map[$str])){
-                        $j+=$k*$wordLen;
+                    if ($num > ($map[$str] == null ? 0 : $map[$str])) {
+                        $j += $k * $wordLen;
                         break;
-                    }else if ($k == 0) {$sol[] = $j;}
-                    else {$temp[$str] = $num;}
+                    } else if ($k == 0) {
+                        $sol[] = $j;
+                    } else {
+                        $temp[$str] = $num;
+                    }
                 }
                 $temp = [];
             }
diff --git a/src/Algorithms/s0031_next_permutation/Solution.php b/src/Algorithms/s0031_next_permutation/Solution.php
index 2fbe9e4..4ac1402 100644
--- a/src/Algorithms/s0031_next_permutation/Solution.php
+++ b/src/Algorithms/s0031_next_permutation/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -5,11 +7,11 @@ class Solution {
      * @return NULL
      */
     function nextPermutation(&$nums) {
-        if(count($nums) == 0) return;
-        for($i = count($nums) - 2; $i >= 0; $i--){
-            if($nums[$i] < $nums[$i + 1]){
+        if (count($nums) == 0) return;
+        for ($i = count($nums) - 2; $i >= 0; $i--) {
+            if ($nums[$i] < $nums[$i + 1]) {
                 $j = $i + 1;
-                while($j < count($nums) && $nums[$j] > $nums[$i]) $j++;
+                while ($j < count($nums) && $nums[$j] > $nums[$i]) $j++;
                 self::swap($nums, $i, $j - 1);
                 self::reverse($nums, $i + 1, count($nums) - 1);
                 return;
@@ -17,10 +19,12 @@ function nextPermutation(&$nums) {
         }
         self::reverse($nums, 0, count($nums) - 1);
     }
-    function reverse(&$nums, $i, $j){
-        while($i < $j) self::swap($nums, $i++, $j--);
+
+    function reverse(&$nums, $i, $j) {
+        while ($i < $j) self::swap($nums, $i++, $j--);
     }
-    function swap(&$nums, $a, $b){
+
+    function swap(&$nums, $a, $b) {
         $temp = $nums[$a];
         $nums[$a] = $nums[$b];
         $nums[$b] = $temp;
diff --git a/src/Algorithms/s0032_longest_valid_parentheses/Solution.php b/src/Algorithms/s0032_longest_valid_parentheses/Solution.php
index ec51417..cc886c5 100644
--- a/src/Algorithms/s0032_longest_valid_parentheses/Solution.php
+++ b/src/Algorithms/s0032_longest_valid_parentheses/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -13,13 +15,13 @@ function longestValidParentheses($s) {
         $dp = array_fill(0, $len + 1, 0);
         $dp[0] = 0;
         $res = 0;
-        for($i = 1; $i <= $len; $i++) {
+        for ($i = 1; $i <= $len; $i++) {
             $c = $s[$i - 1];
-            if($c != '(' && $c != '[' && $c != '{') {
-                if($dp[$i - 1] > 0 && $i - 2 - $dp[$i - 1] >= 0 &&
-                   ($map[$s[$i - 2 - $dp[$i - 1]]] == null ? '?' : $map[$s[$i - 2 - $dp[$i - 1]]]) == $c) 
-                        $dp[$i] = $dp[$i - 1] + $dp[$i - 2 - $dp[$i - 1]] + 2;
-                else if($i > 1 && ($map[$s[$i - 2]] == null ? '?' : $map[$s[$i - 2]]) == $c) {
+            if ($c != '(' && $c != '[' && $c != '{') {
+                if ($dp[$i - 1] > 0 && $i - 2 - $dp[$i - 1] >= 0 &&
+                    ($map[$s[$i - 2 - $dp[$i - 1]]] == null ? '?' : $map[$s[$i - 2 - $dp[$i - 1]]]) == $c)
+                    $dp[$i] = $dp[$i - 1] + $dp[$i - 2 - $dp[$i - 1]] + 2;
+                else if ($i > 1 && ($map[$s[$i - 2]] == null ? '?' : $map[$s[$i - 2]]) == $c) {
                     $dp[$i] = $dp[$i - 2] + 2;
                 }
             }
diff --git a/src/Algorithms/s0033_search_in_rotated_sorted_array/Solution.php b/src/Algorithms/s0033_search_in_rotated_sorted_array/Solution.php
index b89936c..373cfb9 100644
--- a/src/Algorithms/s0033_search_in_rotated_sorted_array/Solution.php
+++ b/src/Algorithms/s0033_search_in_rotated_sorted_array/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -6,7 +8,8 @@ class Solution {
      * @return Integer
      */
     function search($nums, $target) {
-        $low = 0; $high = count($nums) - 1;
+        $low = 0;
+        $high = count($nums) - 1;
         while ($low <= $high) {
             $m = intval(($low + $high) / 2);
             if ($nums[$m] == $target) {
diff --git a/src/Algorithms/s0034_find_first_and_last_position_of_element_in_sorted_array/Solution.php b/src/Algorithms/s0034_find_first_and_last_position_of_element_in_sorted_array/Solution.php
index 85336a3..ca13f88 100644
--- a/src/Algorithms/s0034_find_first_and_last_position_of_element_in_sorted_array/Solution.php
+++ b/src/Algorithms/s0034_find_first_and_last_position_of_element_in_sorted_array/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -9,9 +11,9 @@ function searchRange($nums, $target) {
         $n = count($nums);
         $res = array_fill(0, 2, 0);
         $beg = 0;
-        $end = $n-1;
+        $end = $n - 1;
         while ($beg <= $end) {
-            $mid = $beg + intval(($end-$beg)/2);
+            $mid = $beg + intval(($end - $beg) / 2);
             if ($nums[$mid] < $target) {
                 $beg = $mid + 1;
             } else {
@@ -19,11 +21,11 @@ function searchRange($nums, $target) {
             }
         }
         $res[0] = ($beg >= $n || $nums[$beg] != $target) ? -1 : $beg;
-        
+
         $beg = 0;
-        $end = $n-1;
+        $end = $n - 1;
         while ($beg <= $end) {
-            $mid = $beg + intval(($end-$beg)/2);
+            $mid = $beg + intval(($end - $beg) / 2);
             if ($nums[$mid] <= $target) {
                 $beg = $mid + 1;
             } else {
diff --git a/src/Algorithms/s0035_search_insert_position/Solution.php b/src/Algorithms/s0035_search_insert_position/Solution.php
index cfbef88..8bbdcdd 100644
--- a/src/Algorithms/s0035_search_insert_position/Solution.php
+++ b/src/Algorithms/s0035_search_insert_position/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -6,7 +8,7 @@ class Solution {
      * @return Integer
      */
     function searchInsert($nums, $target) {
-        for($i = 0; $i < count($nums) && $nums[$i] <= $target; $i++) {
+        for ($i = 0; $i < count($nums) && $nums[$i] <= $target; $i++) {
             if ($nums[$i] == $target) {
                 return $i;
             }
diff --git a/src/Algorithms/s0036_valid_sudoku/Solution.php b/src/Algorithms/s0036_valid_sudoku/Solution.php
index 3880150..96179c9 100644
--- a/src/Algorithms/s0036_valid_sudoku/Solution.php
+++ b/src/Algorithms/s0036_valid_sudoku/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -6,8 +8,8 @@ class Solution {
      */
     function isValidSudoku($board) {
         $list = [];
-        for ($i = 0; $i < 9; $i++){
-            for ($j = 0; $j < 9; $j++){
+        for ($i = 0; $i < 9; $i++) {
+            for ($j = 0; $j < 9; $j++) {
                 $c = $board[$i][$j];
                 if ($c == '.') continue;
                 if (in_array($c, $list)) return false;
@@ -15,8 +17,8 @@ function isValidSudoku($board) {
             }
             $list = [];
         }
-        for ($i = 0; $i < 9; $i++){
-            for ($j = 0; $j < 9; $j++){
+        for ($i = 0; $i < 9; $i++) {
+            for ($j = 0; $j < 9; $j++) {
                 $c = $board[$j][$i];
                 if ($c == '.') continue;
                 if (in_array($c, $list)) return false;
@@ -24,10 +26,10 @@ function isValidSudoku($board) {
             }
             $list = [];
         }
-        for ($i = 0; $i < 3; $i++){
-            for ($j = 0; $j < 3; $j++){
-                for ($x = 3*$i; $x < 3+3*$i; $x++){
-                    for ($y = 3*$j; $y < 3+3*$j; $y++){
+        for ($i = 0; $i < 3; $i++) {
+            for ($j = 0; $j < 3; $j++) {
+                for ($x = 3 * $i; $x < 3 + 3 * $i; $x++) {
+                    for ($y = 3 * $j; $y < 3 + 3 * $j; $y++) {
                         $c = $board[$x][$y];
                         if ($c == '.') continue;
                         if (in_array($c, $list)) return false;
@@ -37,6 +39,6 @@ function isValidSudoku($board) {
                 $list = [];
             }
         }
-        return true;    
+        return true;
     }
 }
diff --git a/src/Algorithms/s0037_sudoku_solver/Solution.php b/src/Algorithms/s0037_sudoku_solver/Solution.php
index aacc0e2..2fbd246 100644
--- a/src/Algorithms/s0037_sudoku_solver/Solution.php
+++ b/src/Algorithms/s0037_sudoku_solver/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
     public function __construct() {
         $this->row = array_fill(0, 9, array_fill(0, 9, false));
@@ -23,14 +25,16 @@ function solveSudoku(&$board) {
         self::place(0, $board);
         return;
     }
+
     function place($n, &$board) {
         if ($n == 81) {
             // board = g;
             $this->found = true;
             return;
         }
-        
-        $i = intval($n / 9); $j = $n % 9;
+
+        $i = intval($n / 9);
+        $j = $n % 9;
         $index = intval(($i / 3)) * 3 + intval(($j / 3)) % 3;
         if ($board[$i][$j] == '.') {
             for ($c = 0; $c < 9; ++$c) {
@@ -39,21 +43,20 @@ function place($n, &$board) {
                     $this->col[$j][$c] = true;
                     $this->grid[$index][$c] = true;
                     $board[$i][$j] = chr($c + ord('1'));
-                    
+
                     self::place($n + 1, $board);
-                    
+
                     if ($this->found)
                         return;
-                    
+
                     $board[$i][$j] = '.';
                     $this->row[$i][$c] = false;
                     $this->col[$j][$c] = false;
                     $this->grid[$index][$c] = false;
-                    
+
                 }
             }
-        }
-        else 
+        } else
             self::place($n + 1, $board);
         return;
     }
diff --git a/src/Algorithms/s0038_count_and_say/Solution.php b/src/Algorithms/s0038_count_and_say/Solution.php
index 9a3209f..5a7e0c1 100644
--- a/src/Algorithms/s0038_count_and_say/Solution.php
+++ b/src/Algorithms/s0038_count_and_say/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -6,25 +8,27 @@ class Solution {
      */
     function countAndSay($n) {
         $s = "1";
-        while($n>1){
+        while ($n > 1) {
             $sub = "";
-            $i=0; $num=0;
-            $ch = ''; $pre=' ';
-            while($i<=strlen($s)){
-                $ch = ($i==strlen($s) ? ' ': $s[$i]);
-                if(($pre!=' '&&$ch!=$pre)|| $ch==' '){
-                    $sub .= ($num==0? 1:$num)."".$pre;
+            $i = 0;
+            $num = 0;
+            $ch = '';
+            $pre = ' ';
+            while ($i <= strlen($s)) {
+                $ch = ($i == strlen($s) ? ' ' : $s[$i]);
+                if (($pre != ' ' && $ch != $pre) || $ch == ' ') {
+                    $sub .= ($num == 0 ? 1 : $num) . "" . $pre;
                     $pre = $ch;
                     $num = 1;
-                }else{
+                } else {
                     $num++;
-                    $pre=$ch;
+                    $pre = $ch;
                 }
                 $i++;
             }
             $s = $sub;
             $n--;
         }
-        return $s; 
+        return $s;
     }
 }
diff --git a/src/Algorithms/s0039_combination_sum/Solution.php b/src/Algorithms/s0039_combination_sum/Solution.php
index 6d89521..df0e140 100644
--- a/src/Algorithms/s0039_combination_sum/Solution.php
+++ b/src/Algorithms/s0039_combination_sum/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     public function __construct() {
@@ -17,13 +19,13 @@ function combinationSum($candidates, $target) {
         self::search($target, $temp, 0);
         return $this->sol;
     }
-    
-    function search($target, $list, $start){
+
+    function search($target, $list, $start) {
         if ($target == 0) {
-			array_push($this->sol, $list);
-			return;
-		}
-        for ($i = $start; $i < count($this->nums); $i++){
+            array_push($this->sol, $list);
+            return;
+        }
+        for ($i = $start; $i < count($this->nums); $i++) {
             if ($this->nums[$i] > $target) break;
             else {
                 array_push($list, $this->nums[$i]);
diff --git a/src/Algorithms/s0040_combination_sum_ii/Solution.php b/src/Algorithms/s0040_combination_sum_ii/Solution.php
index e9790ff..9776728 100644
--- a/src/Algorithms/s0040_combination_sum_ii/Solution.php
+++ b/src/Algorithms/s0040_combination_sum_ii/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -12,16 +14,17 @@ function combinationSum2($cand, $target) {
         self::dfs_com($cand, 0, $target, $path, $res);
         return $res;
     }
+
     function dfs_com($cand, $cur, $target, $path, &$res) {
         if ($target == 0) {
             array_push($res, $path);
             return;
         }
         if ($target < 0) return;
-        for ($i = $cur; $i < count($cand); $i++){
-            if ($i > $cur && $cand[$i] == $cand[$i-1]) continue;
+        for ($i = $cur; $i < count($cand); $i++) {
+            if ($i > $cur && $cand[$i] == $cand[$i - 1]) continue;
             array_push($path, $cand[$i]);
-            self::dfs_com($cand, $i+1, $target - $cand[$i], $path, $res);
+            self::dfs_com($cand, $i + 1, $target - $cand[$i], $path, $res);
             array_pop($path);
         }
     }
diff --git a/src/Algorithms/s0041_first_missing_positive/Solution.php b/src/Algorithms/s0041_first_missing_positive/Solution.php
index 27a8a13..3b0b7e6 100644
--- a/src/Algorithms/s0041_first_missing_positive/Solution.php
+++ b/src/Algorithms/s0041_first_missing_positive/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -5,16 +7,16 @@ class Solution {
      * @return Integer
      */
     function firstMissingPositive($nums) {
-        if(count($nums) == 0) return 1;
-        for($i =  0;$i < count($nums);$i++) {
-            while(($nums[$i] != $i + 1) && $nums[$i] >= 1 && $nums[$i] <= count($nums) && $nums[$nums[$i] - 1] != $nums[$i]) {
+        if (count($nums) == 0) return 1;
+        for ($i = 0; $i < count($nums); $i++) {
+            while (($nums[$i] != $i + 1) && $nums[$i] >= 1 && $nums[$i] <= count($nums) && $nums[$nums[$i] - 1] != $nums[$i]) {
                 $tmp = $nums[$i] - 1;
                 $nums[$i] = $nums[$tmp];
-                $nums[$tmp] = $tmp + 1;                    
+                $nums[$tmp] = $tmp + 1;
             }
         }
-        for($i = 0;$i < count($nums);$i++) {
-            if($nums[$i] != $i + 1) return $i + 1;
+        for ($i = 0; $i < count($nums); $i++) {
+            if ($nums[$i] != $i + 1) return $i + 1;
         }
         return count($nums) + 1;
     }
diff --git a/src/Algorithms/s0042_trapping_rain_water/Solution.php b/src/Algorithms/s0042_trapping_rain_water/Solution.php
index e644fa9..8f25a98 100644
--- a/src/Algorithms/s0042_trapping_rain_water/Solution.php
+++ b/src/Algorithms/s0042_trapping_rain_water/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -5,26 +7,26 @@ class Solution {
      * @return Integer
      */
     function trap($height) {
-        if($height == null || count($height) == 0) return 0;
-        
+        if ($height == null || count($height) == 0) return 0;
+
         $max = 0;
         $memo = array_fill(0, count($height), 0);
-        for($i = 0; $i < count($height); $i++){
+        for ($i = 0; $i < count($height); $i++) {
             $max = max($max, $height[$i]);
             $memo[$i] = $max;
         }
-        
+
         $max = 0;
-        for($i = count($height) - 1; $i >= 0; $i--){
+        for ($i = count($height) - 1; $i >= 0; $i--) {
             $max = max($max, $height[$i]);
             $memo[$i] = min($memo[$i], $max);
         }
-        
+
         $volume = 0;
-        for($i = 0; $i < count($height); $i++){
+        for ($i = 0; $i < count($height); $i++) {
             $volume += $memo[$i] - $height[$i];
         }
-        
+
         return $volume;
     }
 }
diff --git a/src/Algorithms/s0043_multiply_strings/Solution.php b/src/Algorithms/s0043_multiply_strings/Solution.php
index 31eff98..e1e9c3b 100644
--- a/src/Algorithms/s0043_multiply_strings/Solution.php
+++ b/src/Algorithms/s0043_multiply_strings/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -13,18 +15,18 @@ function multiply($num1, $num2) {
             $b = 0;
             for ($j = strlen($num1) - 1; $j >= 0; $j--) {
                 $prod = (ord($num1[$j]) - ord('0')) * (ord($num2[$i]) - ord('0'));
-                $prod += $res[$a+$b];
-                $carry = intval($prod/10);
-                $digit = $prod%10;
-                $res[$a+$b] = $digit;
-                $res[$a+$b+1] += $carry;
+                $prod += $res[$a + $b];
+                $carry = intval($prod / 10);
+                $digit = $prod % 10;
+                $res[$a + $b] = $digit;
+                $res[$a + $b + 1] += $carry;
                 $b++;
             }
             $a++;
         }
         $sb = "";
         for ($i = count($res) - 1; $i >= 0; $i--) {
-            if ($i == count($res) -1 && $res[count($res) - 1] == 0) continue;
+            if ($i == count($res) - 1 && $res[count($res) - 1] == 0) continue;
             $sb .= chr($res[$i] + ord('0'));
         }
         return $sb;
diff --git a/src/Algorithms/s0044_wildcard_matching/Solution.php b/src/Algorithms/s0044_wildcard_matching/Solution.php
index 2c9d562..5e9b637 100644
--- a/src/Algorithms/s0044_wildcard_matching/Solution.php
+++ b/src/Algorithms/s0044_wildcard_matching/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
diff --git a/src/Algorithms/s0045_jump_game_ii/Solution.php b/src/Algorithms/s0045_jump_game_ii/Solution.php
index 21c2767..7b30ce0 100644
--- a/src/Algorithms/s0045_jump_game_ii/Solution.php
+++ b/src/Algorithms/s0045_jump_game_ii/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
diff --git a/src/Algorithms/s0046_permutations/Solution.php b/src/Algorithms/s0046_permutations/Solution.php
index 1a4869a..5b062f6 100644
--- a/src/Algorithms/s0046_permutations/Solution.php
+++ b/src/Algorithms/s0046_permutations/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -9,33 +11,29 @@ function permute($nums) {
         if ($nums == null || count($nums) == 0) return $res;
         $currentX = [];
         $used = array_fill(0, count($nums), false);
-        for($j=0; $j<count($used);$j++)
-        {
+        for ($j = 0; $j < count($used); $j++) {
             $used[$j] = false;
         }
         self::bt($currentX, $nums, $used, $res);
         return $res;
     }
 
-        function bt($currentX, &$nums, $used, &$res)
-        {
-            if (count($currentX) == count($nums))
-            {
-                array_push($res, $currentX);
-                return;
-            }
+    function bt($currentX, &$nums, $used, &$res) {
+        if (count($currentX) == count($nums)) {
+            array_push($res, $currentX);
+            return;
+        }
 
-            for ($i = 0; $i < count($nums); $i++)
-            {
+        for ($i = 0; $i < count($nums); $i++) {
 
-                if ($used[$i] == true) continue;
-                array_push($currentX, $nums[$i]);
-                $used[$i] = true;
+            if ($used[$i] == true) continue;
+            array_push($currentX, $nums[$i]);
+            $used[$i] = true;
 
-                self::bt($currentX, $nums, $used, $res);
+            self::bt($currentX, $nums, $used, $res);
 
-                array_pop($currentX);
-                $used[$i] = false;
-            }
+            array_pop($currentX);
+            $used[$i] = false;
         }
+    }
 }
diff --git a/src/Algorithms/s0047_permutations_ii/Solution.php b/src/Algorithms/s0047_permutations_ii/Solution.php
index 668f6de..eb0ed55 100644
--- a/src/Algorithms/s0047_permutations_ii/Solution.php
+++ b/src/Algorithms/s0047_permutations_ii/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -8,25 +10,25 @@ function permuteUnique($nums) {
         return self::helper($nums, 0);
     }
 
-    function helper($nums, $index){
+    function helper($nums, $index) {
         $result = [];
-        if($index==count($nums)-1){
+        if ($index == count($nums) - 1) {
             $temp = [];
             array_push($temp, $nums[$index]);
             array_push($result, $temp);
             return $result;
         }
-        foreach (self::helper($nums, $index+1) as $temp){
-            for($i=0;$i<=count($temp);$i++){
-                if($i==0 || $temp[$i-1]!=$nums[$index]){
+        foreach (self::helper($nums, $index + 1) as $temp) {
+            for ($i = 0; $i <= count($temp); $i++) {
+                if ($i == 0 || $temp[$i - 1] != $nums[$index]) {
                     $temp2 = $temp;
                     array_splice($temp2, $i, 0, $nums[$index]);
                     array_push($result, $temp2);
-                }else{
+                } else {
                     break;
                 }
             }
         }
-        return $result;   
+        return $result;
     }
 }
diff --git a/src/Algorithms/s0048_rotate_image/Solution.php b/src/Algorithms/s0048_rotate_image/Solution.php
index 82aa857..918c189 100644
--- a/src/Algorithms/s0048_rotate_image/Solution.php
+++ b/src/Algorithms/s0048_rotate_image/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -14,7 +16,7 @@ function rotate(&$matrix) {
             }
         }
         for ($i = 0; $i < count($matrix); $i++) {
-            $start  = 0;
+            $start = 0;
             $end = count($matrix[$i]) - 1;
             while ($start < $end) {
                 $temp = $matrix[$i][$start];
@@ -23,6 +25,6 @@ function rotate(&$matrix) {
                 $start++;
                 $end--;
             }
-        } 
+        }
     }
 }
diff --git a/src/Algorithms/s0049_group_anagrams/Solution.php b/src/Algorithms/s0049_group_anagrams/Solution.php
index b14926b..ba53d7c 100644
--- a/src/Algorithms/s0049_group_anagrams/Solution.php
+++ b/src/Algorithms/s0049_group_anagrams/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -6,12 +8,12 @@ class Solution {
      */
     function groupAnagrams($strs) {
         $map = [];
-        for($i = 0; $i < count($strs); $i++) {
+        for ($i = 0; $i < count($strs); $i++) {
             $s = $strs[$i];
             $temp = str_split($s);
             sort($temp);
             $sorted = implode($temp);
-            if($map[$sorted] == null) {
+            if ($map[$sorted] == null) {
                 $map[$sorted] = [];
             }
             array_push($map[$sorted], $strs[$i]);
diff --git a/src/Algorithms/s0050_powx_n/Solution.php b/src/Algorithms/s0050_powx_n/Solution.php
index 5ad2bb3..7861339 100644
--- a/src/Algorithms/s0050_powx_n/Solution.php
+++ b/src/Algorithms/s0050_powx_n/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -6,22 +8,22 @@ class Solution {
      * @return Float
      */
     function myPow($x, $n) {
-        if($x == 1) {
+        if ($x == 1) {
             return $x;
         }
-        if($x == -1) {
+        if ($x == -1) {
             return $n % 2 == 0 ? 1 : -1;
         }
-        if($n == 0) {
+        if ($n == 0) {
             return 1;
         }
-        if($n < 0) {
-            $x = 1/$x;
+        if ($n < 0) {
+            $x = 1 / $x;
             $n = abs($n);
         }
         return self::helper($x, $n);
     }
-    
+
     function helper($x, $n) {
         if ($x == 0) {
             return 0;
@@ -32,12 +34,12 @@ function helper($x, $n) {
         if ($n == 0) {
             return 1;
         }
-        
-        $output = self::helper($x, $n/2);
-        
-        if($n % 2 == 0) {
+
+        $output = self::helper($x, $n / 2);
+
+        if ($n % 2 == 0) {
             return $output * $output;
-        }else {
+        } else {
             return $output * $output * $x;
         }
     }
diff --git a/src/Algorithms/s0051_n_queens/Solution.php b/src/Algorithms/s0051_n_queens/Solution.php
index 2641399..3adc63c 100644
--- a/src/Algorithms/s0051_n_queens/Solution.php
+++ b/src/Algorithms/s0051_n_queens/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -13,22 +15,22 @@ function solveNQueens($n) {
         self::helper(0, $chars, $ans, $colUsed, $diagonals45Used, $diagonals135Used);
         return $ans;
     }
-    
-    function helper($row, &$chars, &$ans, &$colUsed, &$diagonals45Used, &$diagonals135Used){
+
+    function helper($row, &$chars, &$ans, &$colUsed, &$diagonals45Used, &$diagonals135Used) {
         $N = count($chars);
         if ($row == $N) {
             $temp = [];
             for ($i = 0; $i < $N; $i++)
                 array_push($temp, implode($chars[$i]));
             array_push($ans, $temp);
-        }else{
-            for ($i = 0; $i < $N; $i++){
-                if ($colUsed[$i] || $diagonals45Used[$i+$row] || $diagonals135Used[$N-1-$row+$i]) continue;
+        } else {
+            for ($i = 0; $i < $N; $i++) {
+                if ($colUsed[$i] || $diagonals45Used[$i + $row] || $diagonals135Used[$N - 1 - $row + $i]) continue;
                 $chars[$row][$i] = 'Q';
-                $colUsed[$i] = $diagonals45Used[$i+$row] = $diagonals135Used[$N-1-$row+$i] = true;
-                self::helper($row+1, $chars, $ans, $colUsed, $diagonals45Used, $diagonals135Used);
+                $colUsed[$i] = $diagonals45Used[$i + $row] = $diagonals135Used[$N - 1 - $row + $i] = true;
+                self::helper($row + 1, $chars, $ans, $colUsed, $diagonals45Used, $diagonals135Used);
                 $chars[$row][$i] = '.';
-                $colUsed[$i] = $diagonals45Used[$i+$row] = $diagonals135Used[$N-1-$row+$i] = false;
+                $colUsed[$i] = $diagonals45Used[$i + $row] = $diagonals135Used[$N - 1 - $row + $i] = false;
             }
         }
     }
diff --git a/src/Algorithms/s0052_n_queens_ii/Solution.php b/src/Algorithms/s0052_n_queens_ii/Solution.php
index 37ac26d..e865109 100644
--- a/src/Algorithms/s0052_n_queens_ii/Solution.php
+++ b/src/Algorithms/s0052_n_queens_ii/Solution.php
@@ -1,6 +1,9 @@
+<?php
+
 class Solution {
 
     var $tot = 0;
+
     /**
      * @param Integer $n
      * @return Integer
@@ -8,23 +11,23 @@ class Solution {
     function totalNQueens($n) {
         $col = array_fill(0, $n, 0);
         $cur = 0;
-        return self::totalQueens($n,$cur,$col);
+        return self::totalQueens($n, $cur, $col);
     }
-    
-    function totalQueens($n,$cur,&$col){
-        if($cur == $n) $this->tot++;
-        else{
-            for($i = 0; $i < $n; $i++){
+
+    function totalQueens($n, $cur, &$col) {
+        if ($cur == $n) $this->tot++;
+        else {
+            for ($i = 0; $i < $n; $i++) {
                 $ok = true;
                 $col[$cur] = $i;
-                for($j = 0; $j < $cur; $j++){
-                    if($col[$cur] == $col[$j] || $cur+$col[$cur] == $j + $col[$j] || $cur-$col[$cur] == $j - $col[$j]){
+                for ($j = 0; $j < $cur; $j++) {
+                    if ($col[$cur] == $col[$j] || $cur + $col[$cur] == $j + $col[$j] || $cur - $col[$cur] == $j - $col[$j]) {
                         $ok = false;
                         break;
                     }
                 }
-                if($ok){
-                    self::totalQueens($n,$cur+1,$col);
+                if ($ok) {
+                    self::totalQueens($n, $cur + 1, $col);
                 }
             }
         }
diff --git a/src/Algorithms/s0053_maximum_subarray/Solution.php b/src/Algorithms/s0053_maximum_subarray/Solution.php
index 3689c52..090e419 100644
--- a/src/Algorithms/s0053_maximum_subarray/Solution.php
+++ b/src/Algorithms/s0053_maximum_subarray/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -5,12 +7,12 @@ class Solution {
      * @return Integer
      */
     function maxSubArray($nums) {
-        $sum =$nums[0];
+        $sum = $nums[0];
         $n = count($nums);
-        $max=$sum;
-        for($i=1;$i<$n;$i++){
-            $sum = $nums[$i]>$nums[$i]+$sum?$nums[$i]:$nums[$i]+$sum;
-            $max = $max > $sum? $max : $sum;
+        $max = $sum;
+        for ($i = 1; $i < $n; $i++) {
+            $sum = $nums[$i] > $nums[$i] + $sum ? $nums[$i] : $nums[$i] + $sum;
+            $max = $max > $sum ? $max : $sum;
         }
         return $max;
     }
diff --git a/src/Algorithms/s0054_spiral_matrix/Solution.php b/src/Algorithms/s0054_spiral_matrix/Solution.php
index e8c5187..283b03a 100644
--- a/src/Algorithms/s0054_spiral_matrix/Solution.php
+++ b/src/Algorithms/s0054_spiral_matrix/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -5,45 +7,45 @@ class Solution {
      * @return Integer[]
      */
     function spiralOrder($matrix) {
-	if (count($matrix) == 0)
-		return [];
-	$count = count($matrix) * count($matrix[0]);
-	$res = [];
-	$i = 0; $j = 0; $row = count($matrix); $col = count($matrix[0]); $start1 = 0; $start2 = 1;
-	array_push($res, $matrix[0][0]);
-	while ($count > 1)
-	{
-		while ($j < $col - 1)
-		{
-			$j++;
-			array_push($res, $matrix[$i][$j]);
-			$count--;
-		}
-		while ($i < $row - 1)
-		{
-			$i++;
-			array_push($res, $matrix[$i][$j]);
-			$count--;
-		}
-		$row--;
-		$col--;
-		if ($count == 1)
-			break;
-		while ($j > $start1)
-		{
-			$j--;
-			array_push($res, $matrix[$i][$j]);
-			$count--;
-		}
-		while ($i > $start2)
-		{
-			$i--;
-			array_push($res, $matrix[$i][$j]);
-			$count--;
-		}
-		$start1++;
-		$start2++;
-	}
-	return $res;
+        if (count($matrix) == 0)
+            return [];
+        $count = count($matrix) * count($matrix[0]);
+        $res = [];
+        $i = 0;
+        $j = 0;
+        $row = count($matrix);
+        $col = count($matrix[0]);
+        $start1 = 0;
+        $start2 = 1;
+        array_push($res, $matrix[0][0]);
+        while ($count > 1) {
+            while ($j < $col - 1) {
+                $j++;
+                array_push($res, $matrix[$i][$j]);
+                $count--;
+            }
+            while ($i < $row - 1) {
+                $i++;
+                array_push($res, $matrix[$i][$j]);
+                $count--;
+            }
+            $row--;
+            $col--;
+            if ($count == 1)
+                break;
+            while ($j > $start1) {
+                $j--;
+                array_push($res, $matrix[$i][$j]);
+                $count--;
+            }
+            while ($i > $start2) {
+                $i--;
+                array_push($res, $matrix[$i][$j]);
+                $count--;
+            }
+            $start1++;
+            $start2++;
+        }
+        return $res;
     }
 }
diff --git a/src/Algorithms/s0055_jump_game/Solution.php b/src/Algorithms/s0055_jump_game/Solution.php
index 238f1c3..d4b713e 100644
--- a/src/Algorithms/s0055_jump_game/Solution.php
+++ b/src/Algorithms/s0055_jump_game/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
diff --git a/src/Algorithms/s0056_merge_intervals/Solution.php b/src/Algorithms/s0056_merge_intervals/Solution.php
index b518a3c..cb8dc1c 100644
--- a/src/Algorithms/s0056_merge_intervals/Solution.php
+++ b/src/Algorithms/s0056_merge_intervals/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /**
  * Definition for an interval.
  * class Interval {
@@ -25,12 +27,12 @@ function cmp($a, $b) {
     function merge($intervals) {
         usort($intervals, 'self::cmp');
         $mergedIntervals = [];
-        
+
         for ($i = 0; $i < count($intervals);) {
             $interval = $intervals[$i];
             $start = $interval->start;
             $end = $interval->end;
-            
+
             while (++$i < count($intervals) && $intervals[$i]->start <= $end) {
                 if ($end < $intervals[$i]->end) {
                     $end = $intervals[$i]->end;
@@ -38,7 +40,7 @@ function merge($intervals) {
             }
             array_push($mergedIntervals, new Interval($start, $end));
         }
-        
+
         return $mergedIntervals;
     }
 }
diff --git a/src/Algorithms/s0057_insert_interval/Solution.php b/src/Algorithms/s0057_insert_interval/Solution.php
index bb0cad1..2fc86ad 100644
--- a/src/Algorithms/s0057_insert_interval/Solution.php
+++ b/src/Algorithms/s0057_insert_interval/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /**
  * Definition for an interval.
  * class Interval {
@@ -18,27 +20,26 @@ class Solution {
      */
     function insert($intervals, $newInterval) {
         $res = [];
-        
+
         $s = $newInterval->start;
         $e = $newInterval->end;
-        
-        foreach($intervals as $i) {
-            if($i->start > $e) {
-                array_push($res, new Interval($s,$e));
+
+        foreach ($intervals as $i) {
+            if ($i->start > $e) {
+                array_push($res, new Interval($s, $e));
                 $s = $i->start;
                 $e = $i->end;
             }
-            
-            if($s <= $i->end) {
+
+            if ($s <= $i->end) {
                 $s = min($s, $i->start);
                 $e = max($e, $i->end);
-            }
-            else {
+            } else {
                 array_push($res, $i);
             }
         }
-        
-        array_push($res, new Interval($s,$e));
-        return $res; 
+
+        array_push($res, new Interval($s, $e));
+        return $res;
     }
 }
diff --git a/src/Algorithms/s0058_length_of_last_word/Solution.php b/src/Algorithms/s0058_length_of_last_word/Solution.php
index 5a810cc..d449764 100644
--- a/src/Algorithms/s0058_length_of_last_word/Solution.php
+++ b/src/Algorithms/s0058_length_of_last_word/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
diff --git a/src/Algorithms/s0059_spiral_matrix_ii/Solution.php b/src/Algorithms/s0059_spiral_matrix_ii/Solution.php
index f113001..6241adf 100644
--- a/src/Algorithms/s0059_spiral_matrix_ii/Solution.php
+++ b/src/Algorithms/s0059_spiral_matrix_ii/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -5,14 +7,14 @@ class Solution {
      * @return Integer[][]
      */
     function generateMatrix($n) {
-        $res=array_fill(0, $n, array_fill(0, $n, 0));
-        $next=1;
-        for($k=0;$k<intval($n/2)+$n%2;$k++){
-            $i=$k; 
-            for($j=$i;$j<$n-$k;$j++)$res[$i][$j]=$next++;
-            for(--$j,++$i;$i<$n-$k;$i++)$res[$i][$j]=$next++;
-            for(--$j,--$i;$j>=$k;$j--)$res[$i][$j]=$next++;
-            for(++$j,--$i;$i>$k;$i--)$res[$i][$j]=$next++;
+        $res = array_fill(0, $n, array_fill(0, $n, 0));
+        $next = 1;
+        for ($k = 0; $k < intval($n / 2) + $n % 2; $k++) {
+            $i = $k;
+            for ($j = $i; $j < $n - $k; $j++) $res[$i][$j] = $next++;
+            for (--$j, ++$i; $i < $n - $k; $i++) $res[$i][$j] = $next++;
+            for (--$j, --$i; $j >= $k; $j--) $res[$i][$j] = $next++;
+            for (++$j, --$i; $i > $k; $i--) $res[$i][$j] = $next++;
         }
         return $res;
     }
diff --git a/src/Algorithms/s0060_permutation_sequence/Solution.php b/src/Algorithms/s0060_permutation_sequence/Solution.php
index d489c9b..3342d46 100644
--- a/src/Algorithms/s0060_permutation_sequence/Solution.php
+++ b/src/Algorithms/s0060_permutation_sequence/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -15,8 +17,8 @@ function getPermutation($n, $k) {
         }
         $sb = "";
         for ($i = 1; $i <= $n; ++$i) {
-            $mod = intval($mod / ($n-$i+1));
-            $idx = intval($k/$mod);
+            $mod = intval($mod / ($n - $i + 1));
+            $idx = intval($k / $mod);
             $sb .= array_splice($list, $idx, 1)[0];
             $k = $k % $mod;
         }
diff --git a/src/Algorithms/s0061_rotate_list/Solution.php b/src/Algorithms/s0061_rotate_list/Solution.php
index bdb37a4..ee93af1 100644
--- a/src/Algorithms/s0061_rotate_list/Solution.php
+++ b/src/Algorithms/s0061_rotate_list/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /**
  * Definition for a singly-linked list.
  * class ListNode {
@@ -14,11 +16,11 @@ class Solution {
      * @return ListNode
      */
     function rotateRight($head, $k) {
-        if($head == null){
+        if ($head == null) {
             return $head;
         }
         $k = ($k == 0) ? 0 : $k % self::getLen($head);
-        if($k == 0){
+        if ($k == 0) {
             return $head;
         }
         $head1 = self::reverse(null, $head);
@@ -26,7 +28,7 @@ function rotateRight($head, $k) {
         $dummyHead->next = $head1;
         $cur = $dummyHead->next;
         $pre = $dummyHead;
-        while($k > 0){
+        while ($k > 0) {
             $pre = $cur;
             $cur = $cur->next;
             $k--;
@@ -35,18 +37,20 @@ function rotateRight($head, $k) {
         $head2 = self::reverse(null, $cur);
         return self::reverse($head2, $head1);
     }
-    function getLen($head){
+
+    function getLen($head) {
         $cnt = 0;
-        while($head != null){
+        while ($head != null) {
             $cnt++;
             $head = $head->next;
         }
         return $cnt;
     }
-    function reverse($pre,$head) {
+
+    function reverse($pre, $head) {
         $tmp;
         $cur = $head;
-        while($cur != null) {
+        while ($cur != null) {
             $tmp = $cur->next;
             $cur->next = $pre;
             $pre = $cur;
diff --git a/src/Algorithms/s0062_unique_paths/Solution.php b/src/Algorithms/s0062_unique_paths/Solution.php
index 7c94e9f..0d9edfd 100644
--- a/src/Algorithms/s0062_unique_paths/Solution.php
+++ b/src/Algorithms/s0062_unique_paths/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -6,17 +8,17 @@ class Solution {
      * @return Integer
      */
     function uniquePaths($m, $n) {
-        $dp=array_fill(0, $m, array_fill(0, $n, 0));
-        
+        $dp = array_fill(0, $m, array_fill(0, $n, 0));
+
         $dp[0] = array_fill(0, $n, 1);
-        
-        for($r=0;$r<$m;$r++) $dp[$r][0]=1;
-        
-        for($r=1;$r<$m;$r++){
-            for($c=1;$c<$n;$c++){
-                $dp[$r][$c]=$dp[$r-1][$c]+$dp[$r][$c-1];
+
+        for ($r = 0; $r < $m; $r++) $dp[$r][0] = 1;
+
+        for ($r = 1; $r < $m; $r++) {
+            for ($c = 1; $c < $n; $c++) {
+                $dp[$r][$c] = $dp[$r - 1][$c] + $dp[$r][$c - 1];
             }
         }
-        return $dp[$m-1][$n-1]; 
+        return $dp[$m - 1][$n - 1];
     }
 }
diff --git a/src/Algorithms/s0063_unique_paths_ii/Solution.php b/src/Algorithms/s0063_unique_paths_ii/Solution.php
index 32ef0e0..ad815e1 100644
--- a/src/Algorithms/s0063_unique_paths_ii/Solution.php
+++ b/src/Algorithms/s0063_unique_paths_ii/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -5,28 +7,28 @@ class Solution {
      * @return Integer
      */
     function uniquePathsWithObstacles($obstacleGrid) {
-     $rows = count($obstacleGrid);
-     $cols = count($obstacleGrid[0]);
-     $temp=array_fill(0, $rows, array_fill(0, $cols, 0));
+        $rows = count($obstacleGrid);
+        $cols = count($obstacleGrid[0]);
+        $temp = array_fill(0, $rows, array_fill(0, $cols, 0));
         // If starting point is Obstacle, no way to reach end.
-        if($obstacleGrid[0][0]==1)
+        if ($obstacleGrid[0][0] == 1)
             return 0;
         // Starting point.
-        $temp[0][0]=1;
-        for($row=0;$row<$rows;$row++){
-            for ($col=0;$col<$cols;$col++){
-                if($col==0 && $row==0)
+        $temp[0][0] = 1;
+        for ($row = 0; $row < $rows; $row++) {
+            for ($col = 0; $col < $cols; $col++) {
+                if ($col == 0 && $row == 0)
                     continue;
-                if($obstacleGrid[$row][$col]!=1){
-                    $upVal=($row-1)<0?0: $temp[$row-1][$col];
-                    $leftVal=($col-1)<0?0: $temp[$row][$col-1];
+                if ($obstacleGrid[$row][$col] != 1) {
+                    $upVal = ($row - 1) < 0 ? 0 : $temp[$row - 1][$col];
+                    $leftVal = ($col - 1) < 0 ? 0 : $temp[$row][$col - 1];
                     // Number of ways to reach current cell. 
                     // No. of ways to reach uppper cell + No.of ways to reach left cell.
-                    $temp[$row][$col]=$upVal+$leftVal;
+                    $temp[$row][$col] = $upVal + $leftVal;
                 }
-               
+
             }
         }
-      return $temp[$rows-1][$cols-1];
+        return $temp[$rows - 1][$cols - 1];
     }
 }
diff --git a/src/Algorithms/s0064_minimum_path_sum/Solution.php b/src/Algorithms/s0064_minimum_path_sum/Solution.php
index c6be698..0728e8a 100644
--- a/src/Algorithms/s0064_minimum_path_sum/Solution.php
+++ b/src/Algorithms/s0064_minimum_path_sum/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -5,17 +7,18 @@ class Solution {
      * @return Integer
      */
     function minPathSum($grid) {
-        $m = count($grid); $n = count($grid[0]);
+        $m = count($grid);
+        $n = count($grid[0]);
         $dp = array_fill(0, $m, array_fill(0, $n, 0));
         $dp[0][0] = $grid[0][0];
-        for($i = 1; $i < $m; $i++) $dp[$i][0] = $dp[$i-1][0] + $grid[$i][0];  
-        for($i = 1; $i < $n; $i++) $dp[0][$i] = $dp[0][$i-1] + $grid[0][$i];
-        
-        for($j = 1; $j < $n; $j++){
-            for($i = 1; $i < $m; $i++){
-                $dp[$i][$j] = $grid[$i][$j] + min($dp[$i-1][$j],$dp[$i][$j-1]);
+        for ($i = 1; $i < $m; $i++) $dp[$i][0] = $dp[$i - 1][0] + $grid[$i][0];
+        for ($i = 1; $i < $n; $i++) $dp[0][$i] = $dp[0][$i - 1] + $grid[0][$i];
+
+        for ($j = 1; $j < $n; $j++) {
+            for ($i = 1; $i < $m; $i++) {
+                $dp[$i][$j] = $grid[$i][$j] + min($dp[$i - 1][$j], $dp[$i][$j - 1]);
             }
         }
-        return $dp[$m-1][$n-1];
+        return $dp[$m - 1][$n - 1];
     }
 }
diff --git a/src/Algorithms/s0065_valid_number/Solution.php b/src/Algorithms/s0065_valid_number/Solution.php
index b65b8fc..08d3c3e 100644
--- a/src/Algorithms/s0065_valid_number/Solution.php
+++ b/src/Algorithms/s0065_valid_number/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -9,46 +11,46 @@ function isNumber($s) {
         $isPoint = false;
         $lastChar = -1;
         $llastChar = -1;
-        if(strlen($s)==1 && !(ord($s[0])>=48 && ord($s[0])<=57)){
+        if (strlen($s) == 1 && !(ord($s[0]) >= 48 && ord($s[0]) <= 57)) {
             return false;
         }
-        $s=trim($s);
-        for($i=0;$i<strlen($s);$i++){
+        $s = trim($s);
+        for ($i = 0; $i < strlen($s); $i++) {
             $t = ord($s[$i]);
-            if($i==0 && $t==101){
+            if ($i == 0 && $t == 101) {
                 return false;
             }
-            if(!(($t>=48 && $t<=57) || $t==101 || $t== 43 || $t==45 || $t==46)){
+            if (!(($t >= 48 && $t <= 57) || $t == 101 || $t == 43 || $t == 45 || $t == 46)) {
                 return false;
             }
-            if($t == 101){
-                if($isE){
+            if ($t == 101) {
+                if ($isE) {
                     return false;
                 }
-                if($i == strlen($s)-1){
+                if ($i == strlen($s) - 1) {
                     return false;
                 }
-                if($lastChar==43 || $lastChar==45 || $lastChar==46){
-                    if($llastChar == -1){
+                if ($lastChar == 43 || $lastChar == 45 || $lastChar == 46) {
+                    if ($llastChar == -1) {
                         return false;
                     }
                 }
                 $isE = true;
             }
-            if($t == 46 ){
-                if($isE){
+            if ($t == 46) {
+                if ($isE) {
                     return false;
                 }
-                if($i == strlen($s)-1 && !($lastChar>=48 && $lastChar<=57)){
+                if ($i == strlen($s) - 1 && !($lastChar >= 48 && $lastChar <= 57)) {
                     return false;
                 }
-                if($isPoint){
+                if ($isPoint) {
                     return false;
                 }
-                $isPoint  = true;
+                $isPoint = true;
             }
-            if(($t==43 || $t==45)&& $i!=0 && ($lastChar!=101 ||($lastChar==101 && $i == strlen($s)-1))){
-                    return false;
+            if (($t == 43 || $t == 45) && $i != 0 && ($lastChar != 101 || ($lastChar == 101 && $i == strlen($s) - 1))) {
+                return false;
             }
             $llastChar = $lastChar;
             $lastChar = $t;
diff --git a/src/Algorithms/s0066_plus_one/Solution.php b/src/Algorithms/s0066_plus_one/Solution.php
index 9e51d6c..ffa07ec 100644
--- a/src/Algorithms/s0066_plus_one/Solution.php
+++ b/src/Algorithms/s0066_plus_one/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -5,18 +7,18 @@ class Solution {
      * @return Integer[]
      */
     function plusOne($digits) {
-        $carry=1;
-        for($i=count($digits)-1;$i>=0;$i--){
-            $temp=($digits[$i]+$carry)%10;
-            $carry=intval(($digits[$i]+$carry)/10);
-            $digits[$i]=$temp;
+        $carry = 1;
+        for ($i = count($digits) - 1; $i >= 0; $i--) {
+            $temp = ($digits[$i] + $carry) % 10;
+            $carry = intval(($digits[$i] + $carry) / 10);
+            $digits[$i] = $temp;
         }
-        if($carry==0)return $digits;
-        else{
-            $res=array_fill(0, count($digits) + 1, 0);
-            $res[0]=$carry;
-            for($i=0;$i<count($digits);$i++){
-                $res[$i+1]=$digits[$i];
+        if ($carry == 0) return $digits;
+        else {
+            $res = array_fill(0, count($digits) + 1, 0);
+            $res[0] = $carry;
+            for ($i = 0; $i < count($digits); $i++) {
+                $res[$i + 1] = $digits[$i];
             }
             return $res;
         }
diff --git a/src/Algorithms/s0067_add_binary/Solution.php b/src/Algorithms/s0067_add_binary/Solution.php
index 2e88553..b5e1343 100644
--- a/src/Algorithms/s0067_add_binary/Solution.php
+++ b/src/Algorithms/s0067_add_binary/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -7,15 +9,14 @@ class Solution {
      */
     function addBinary($a, $b) {
         $sb = "";
-		$i = strlen($a) - 1;
+        $i = strlen($a) - 1;
         $j = strlen($b) - 1;
         $carry = 0;
-        
-        while($i >= 0 || $j >= 0 || $carry > 0)
-        {
+
+        while ($i >= 0 || $j >= 0 || $carry > 0) {
             $sum = $carry;
-            if($i >= 0) $sum += ord($a[$i--]) - ord('0');
-            if($j >= 0) $sum += ord($b[$j--]) - ord('0');
+            if ($i >= 0) $sum += ord($a[$i--]) - ord('0');
+            if ($j >= 0) $sum += ord($b[$j--]) - ord('0');
             $sb .= chr($sum % 2 + ord('0'));
             $carry = intval($sum / 2);
         }
diff --git a/src/Algorithms/s0068_text_justification/Solution.php b/src/Algorithms/s0068_text_justification/Solution.php
index 0941b9e..9f03d12 100644
--- a/src/Algorithms/s0068_text_justification/Solution.php
+++ b/src/Algorithms/s0068_text_justification/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -10,28 +12,28 @@ function fullJustify($words, $maxWidth) {
         $beg = 0;
         $res = [];
         while ($beg < $n) {
-            $end = $beg; 
+            $end = $beg;
             $used = 0;
-            while ($end < $n && strlen($words[$end])+$used <= $maxWidth) {
-                $used += strlen($words[$end++])+1;
+            while ($end < $n && strlen($words[$end]) + $used <= $maxWidth) {
+                $used += strlen($words[$end++]) + 1;
             }
             $sb = "";
             if ($end == $n) {
                 for ($i = $beg; $i < $end; ++$i) {
                     $sb .= $words[$i];
-                    if ($i < $end-1) $sb .= ' ';
+                    if ($i < $end - 1) $sb .= ' ';
                 }
             } else {
-                $c = $maxWidth - $used + ($end-$beg);
+                $c = $maxWidth - $used + ($end - $beg);
                 $slots = $end - $beg - 1;
-                for ($i = 0; $i < $end-$beg-1; ++$i) {
-                    $sb .= $words[$i+$beg];
-                    for ($j = 0; $j < intval($c/$slots); ++$j) {
+                for ($i = 0; $i < $end - $beg - 1; ++$i) {
+                    $sb .= $words[$i + $beg];
+                    for ($j = 0; $j < intval($c / $slots); ++$j) {
                         $sb .= ' ';
                     }
-                    if ($i < $c%$slots) $sb .= ' ';
+                    if ($i < $c % $slots) $sb .= ' ';
                 }
-                $sb .= $words[$end-1];
+                $sb .= $words[$end - 1];
             }
             $c = $maxWidth - strlen($sb);
             while ($c-- > 0) $sb .= ' ';
diff --git a/src/Algorithms/s0069_sqrtx/Solution.php b/src/Algorithms/s0069_sqrtx/Solution.php
index 6a51464..d990bb9 100644
--- a/src/Algorithms/s0069_sqrtx/Solution.php
+++ b/src/Algorithms/s0069_sqrtx/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
diff --git a/src/Algorithms/s0070_climbing_stairs/Solution.php b/src/Algorithms/s0070_climbing_stairs/Solution.php
index d4efde6..a6782d4 100644
--- a/src/Algorithms/s0070_climbing_stairs/Solution.php
+++ b/src/Algorithms/s0070_climbing_stairs/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -5,19 +7,18 @@ class Solution {
      * @return Integer
      */
     function climbStairs($n) {
-		if ($n == 2)
-			return 2;
-		else if ($n == 1)
-			return 1;
-		$a = 0;
-		$b = 1;
-		$c = 0;
-		for ($i = 0; $i < $n; $i++)
-		{
-			$c = $a + $b;
-			$a = $b;
-			$b = $c;
-		}
-		return $c;
+        if ($n == 2)
+            return 2;
+        else if ($n == 1)
+            return 1;
+        $a = 0;
+        $b = 1;
+        $c = 0;
+        for ($i = 0; $i < $n; $i++) {
+            $c = $a + $b;
+            $a = $b;
+            $b = $c;
+        }
+        return $c;
     }
 }
diff --git a/src/Algorithms/s0071_simplify_path/Solution.php b/src/Algorithms/s0071_simplify_path/Solution.php
index d6fa851..547a89f 100644
--- a/src/Algorithms/s0071_simplify_path/Solution.php
+++ b/src/Algorithms/s0071_simplify_path/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -5,16 +7,17 @@ class Solution {
      * @return String
      */
     function simplifyPath($path) {
-        if(null == $path || empty($path)) return "";
+        if (null == $path || empty($path)) return "";
         $stack = new SplQueue();
-        foreach(explode("/", $path) as $cur) {
-            if($cur == "..") {if (!$stack->isEmpty()) $stack->pop();}
-            else if($cur != "" && $cur != ".") $stack->push($cur);
+        foreach (explode("/", $path) as $cur) {
+            if ($cur == "..") {
+                if (!$stack->isEmpty()) $stack->pop();
+            } else if ($cur != "" && $cur != ".") $stack->push($cur);
         }
-        
-        if($stack->isEmpty()) return "/";
+
+        if ($stack->isEmpty()) return "/";
         $sb = "";
-        while(!$stack->isEmpty()) $sb .= "/" . $stack->shift();
+        while (!$stack->isEmpty()) $sb .= "/" . $stack->shift();
         return $sb;
     }
 }
diff --git a/src/Algorithms/s0072_edit_distance/Solution.php b/src/Algorithms/s0072_edit_distance/Solution.php
index c1acd94..fd7dc91 100644
--- a/src/Algorithms/s0072_edit_distance/Solution.php
+++ b/src/Algorithms/s0072_edit_distance/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -6,10 +8,11 @@ class Solution {
      * @return Integer
      */
     function minDistance($word1, $word2) {
-        $n1 = strlen($word1); $n2 = strlen($word2);
+        $n1 = strlen($word1);
+        $n2 = strlen($word2);
         if ($n2 > $n1)
             return self::minDistance($word2, $word1);
-        $dp = array_fill(0, $n2+1, 0);
+        $dp = array_fill(0, $n2 + 1, 0);
         for ($j = 0; $j <= $n2; $j++)
             $dp[$j] = $j;
         for ($i = 1; $i <= $n1; $i++) {
@@ -17,8 +20,8 @@ function minDistance($word1, $word2) {
             $dp[0] = $i;
             for ($j = 1; $j <= $n2; $j++) {
                 $tmp = $dp[$j];
-                $dp[$j] = $word1[$i-1] != $word2[$j-1] 
-                    ? 1 + min($pre, min($dp[$j], $dp[$j-1]))
+                $dp[$j] = $word1[$i - 1] != $word2[$j - 1]
+                    ? 1 + min($pre, min($dp[$j], $dp[$j - 1]))
                     : $pre;
                 $pre = $tmp;
             }
diff --git a/src/Algorithms/s0073_set_matrix_zeroes/Solution.php b/src/Algorithms/s0073_set_matrix_zeroes/Solution.php
index 2716852..dbedc6e 100644
--- a/src/Algorithms/s0073_set_matrix_zeroes/Solution.php
+++ b/src/Algorithms/s0073_set_matrix_zeroes/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -5,31 +7,31 @@ class Solution {
      * @return NULL
      */
     function setZeroes(&$matrix) {
-        if(count($matrix)==0 || count($matrix[0])==0) return ;
+        if (count($matrix) == 0 || count($matrix[0]) == 0) return;
         // check whether the first row has zero;
         $firstRowZero = false;
-        for($j=0; $j<count($matrix[0]); $j++)
-            if($matrix[0][$j]==0){
+        for ($j = 0; $j < count($matrix[0]); $j++)
+            if ($matrix[0][$j] == 0) {
                 $firstRowZero = true;
                 break;
             }
         // Set all rows that have zero to zeros, and mark the zero column in the first row
-        for($i=1; $i<count($matrix); $i++){
+        for ($i = 1; $i < count($matrix); $i++) {
             $rowZero = false;
-            for($j=0; $j<count($matrix[0]); $j++){
-                if($matrix[$i][$j]==0){
+            for ($j = 0; $j < count($matrix[0]); $j++) {
+                if ($matrix[$i][$j] == 0) {
                     $rowZero = true;
                     $matrix[0][$j] = 0;
                 }
             }
-            if($rowZero) $matrix[$i] = array_fill(0, count($matrix[$i]), 0);
+            if ($rowZero) $matrix[$i] = array_fill(0, count($matrix[$i]), 0);
         }
         // Set all the zero columns to zeros
-        for($j=0; $j<count($matrix[0]); $j++)
-            if($matrix[0][$j]==0)
-                for($i=1; $i<count($matrix); $i++)
+        for ($j = 0; $j < count($matrix[0]); $j++)
+            if ($matrix[0][$j] == 0)
+                for ($i = 1; $i < count($matrix); $i++)
                     $matrix[$i][$j] = 0;
         // deal with the first row
-        if($firstRowZero) $matrix[0] = array_fill(0, count($matrix[0]), 0);
+        if ($firstRowZero) $matrix[0] = array_fill(0, count($matrix[0]), 0);
     }
 }
diff --git a/src/Algorithms/s0074_search_a_2d_matrix/Solution.php b/src/Algorithms/s0074_search_a_2d_matrix/Solution.php
index 93b8829..d8ab65a 100644
--- a/src/Algorithms/s0074_search_a_2d_matrix/Solution.php
+++ b/src/Algorithms/s0074_search_a_2d_matrix/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -9,7 +11,7 @@ function searchMatrix($matrix, $target) {
         if ($matrix == null || count($matrix) == 0 || $matrix[0] == null || count($matrix[0]) == 0) return false;
         $col = count($matrix[0]) - 1;
         $row = 0;
-		// start from the up left corner, if smaller than target, then go down, if larger then go left
+        // start from the up left corner, if smaller than target, then go down, if larger then go left
         while ($row < count($matrix) && $col >= 0) {
             if ($matrix[$row][$col] == $target) return true;
             if ($matrix[$row][$col] < $target) $row++;
diff --git a/src/Algorithms/s0075_sort_colors/Solution.php b/src/Algorithms/s0075_sort_colors/Solution.php
index e16107f..7c9aacb 100644
--- a/src/Algorithms/s0075_sort_colors/Solution.php
+++ b/src/Algorithms/s0075_sort_colors/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -5,27 +7,28 @@ class Solution {
      * @return NULL
      */
     function sortColors(&$nums) {
-		$red = 0; $white;
-		$temp = 0;
-		for($i = 0; $i < count($nums); $i++) {
-				if($nums[$i] == 0) {            
-					self::swap($nums, $red,$i);
-					$red++;
-				}
-		}
-		$white = $red;
+        $red = 0;
+        $white;
+        $temp = 0;
+        for ($i = 0; $i < count($nums); $i++) {
+            if ($nums[$i] == 0) {
+                self::swap($nums, $red, $i);
+                $red++;
+            }
+        }
+        $white = $red;
 
-		for($i = 0; $i < count($nums); $i++) {
-			if($nums[$i] == 1) {
-				self::swap($nums, $white,$i);
-				$white++;
-			}
-		}
+        for ($i = 0; $i < count($nums); $i++) {
+            if ($nums[$i] == 1) {
+                self::swap($nums, $white, $i);
+                $white++;
+            }
+        }
     }
-    
+
     function swap(&$array, $i, $j) {
         $temp = $array[$i];
         $array[$i] = $array[$j];
         $array[$j] = $temp;
-    } 
+    }
 }
diff --git a/src/Algorithms/s0076_minimum_window_substring/Solution.php b/src/Algorithms/s0076_minimum_window_substring/Solution.php
index 316a372..42878a9 100644
--- a/src/Algorithms/s0076_minimum_window_substring/Solution.php
+++ b/src/Algorithms/s0076_minimum_window_substring/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -8,37 +10,37 @@ class Solution {
     function minWindow($s, $t) {
         $alphabetSize = 256;
         $T = strlen($t); //The number of characters in t
-        $S = strlen($s); 
-        
+        $S = strlen($s);
+
         if ($S < $T) return "";
         $tCount = array_fill(0, $alphabetSize, 0);
         //Create  frequency table for the string t
-        foreach(str_split($t) as $c){
+        foreach (str_split($t) as $c) {
             $tCount[ord($c)]++;
         }
-        
-       
+
+
         $left = 0;
         $right = 0;
-        
+
         $N = strlen($s);
         $min = 2147483647;
         $res = [-1, -1];
-        
-        while ($right < $N){
-            while($right < $N && $T > 0){
+
+        while ($right < $N) {
+            while ($right < $N && $T > 0) {
                 if (--$tCount[ord($s[$right++])] >= 0) $T--;
             }
             //At this point we are either at the end or we have a substring in S that covers all of T.
-            while ($left < $right && $T == 0){
-                if ($right-$left < $min){
+            while ($left < $right && $T == 0) {
+                if ($right - $left < $min) {
                     $min = $right - $left;
                     $res = [$left, $right];
                 }
                 if (++$tCount[ord($s[$left++])] > 0) $T++;
             }
         }
-        
+
         return $min == 2147483647 ? "" : substr($s, $res[0], $res[1] - $res[0]);
     }
 }
diff --git a/src/Algorithms/s0077_combinations/Solution.php b/src/Algorithms/s0077_combinations/Solution.php
index 979a73d..b06064f 100644
--- a/src/Algorithms/s0077_combinations/Solution.php
+++ b/src/Algorithms/s0077_combinations/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -7,14 +9,14 @@ class Solution {
      */
     function combine($n, $k) {
         $list = [];
-        self::backtrack($list, [], $n, 1,$k);
+        self::backtrack($list, [], $n, 1, $k);
         return $list;
     }
 
-    function backtrack(&$list, $tempList, $n, $start,$k)   {
-        if(count($tempList) <= $k) {
-            if(count($tempList) == $k)  array_push($list, $tempList);
-            for($i = $start; $i <= $n; $i++) {
+    function backtrack(&$list, $tempList, $n, $start, $k) {
+        if (count($tempList) <= $k) {
+            if (count($tempList) == $k) array_push($list, $tempList);
+            for ($i = $start; $i <= $n; $i++) {
                 array_push($tempList, $i);
                 self::backtrack($list, $tempList, $n, $i + 1, $k);
                 array_pop($tempList);
diff --git a/src/Algorithms/s0078_subsets/Solution.php b/src/Algorithms/s0078_subsets/Solution.php
index 4be7e2f..9d50638 100644
--- a/src/Algorithms/s0078_subsets/Solution.php
+++ b/src/Algorithms/s0078_subsets/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -5,7 +7,7 @@ class Solution {
      * @return Integer[][]
      */
     function subsets($nums) {
-        $count = intval(pow(2,count($nums)));
+        $count = intval(pow(2, count($nums)));
         $result = [];
         for ($i = 0; $i < $count; $i++) {
             $list = [];
diff --git a/src/Algorithms/s0079_word_search/Solution.php b/src/Algorithms/s0079_word_search/Solution.php
index 840c4b0..0de0950 100644
--- a/src/Algorithms/s0079_word_search/Solution.php
+++ b/src/Algorithms/s0079_word_search/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -7,24 +9,25 @@ class Solution {
      */
     function exist($board, $word) {
         if (count($board) == 0) return false;
-        $n = count($board); $m = count($board[0]);
-        if (strlen($word) > $m*$n) return false;
+        $n = count($board);
+        $m = count($board[0]);
+        if (strlen($word) > $m * $n) return false;
         $visited = array_fill(0, $n, array_fill(0, $m, false));
-        for ($i = 0; $i < $n; $i++) for ($j = 0; $j < $m; $j++) 
+        for ($i = 0; $i < $n; $i++) for ($j = 0; $j < $m; $j++)
             if (self::help($i, $j, 0, $board, $word, $visited)) return true;
         return false;
     }
-    
-    function help($i, $j, $k, $board, $word, $visited){
+
+    function help($i, $j, $k, $board, $word, $visited) {
         if ($k == strlen($word)) return true;
         if ($i >= count($board) || $i < 0 || $j >= count($board[0]) || $j < 0)
             return false;
         if ($visited[$i][$j] || $board[$i][$j] != $word[$k]) return false;
         $visited[$i][$j] = true;
-        $b = self::help($i+1, $j, $k+1, $board, $word, $visited) || 
-                    self::help($i-1, $j, $k+1, $board, $word, $visited) || 
-                    self::help($i, $j-1, $k+1, $board, $word, $visited) ||
-                    self::help($i, $j+1, $k+1, $board, $word, $visited);
+        $b = self::help($i + 1, $j, $k + 1, $board, $word, $visited) ||
+            self::help($i - 1, $j, $k + 1, $board, $word, $visited) ||
+            self::help($i, $j - 1, $k + 1, $board, $word, $visited) ||
+            self::help($i, $j + 1, $k + 1, $board, $word, $visited);
         $visited[$i][$j] = false;
         return $b;
     }
diff --git a/src/Algorithms/s0080_remove_duplicates_from_sorted_array_ii/Solution.php b/src/Algorithms/s0080_remove_duplicates_from_sorted_array_ii/Solution.php
index f4badd5..0a1ae0d 100644
--- a/src/Algorithms/s0080_remove_duplicates_from_sorted_array_ii/Solution.php
+++ b/src/Algorithms/s0080_remove_duplicates_from_sorted_array_ii/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -5,7 +7,8 @@ class Solution {
      * @return Integer
      */
     function removeDuplicates(&$nums) {
-        $j = 0; $c = 0;
+        $j = 0;
+        $c = 0;
         for ($i = 1; $i < count($nums); $i++) {
             if ($nums[$i] == $nums[$j]) {
                 $c++;
@@ -21,6 +24,6 @@ function removeDuplicates(&$nums) {
             $nums[$i] = $nums[$j];
             $nums[$j] = $tmp;
         }
-        return $j+1;
+        return $j + 1;
     }
 }
diff --git a/src/Algorithms/s0081_search_in_rotated_sorted_array_ii/Solution.php b/src/Algorithms/s0081_search_in_rotated_sorted_array_ii/Solution.php
index 8e7c2ed..3c2d972 100644
--- a/src/Algorithms/s0081_search_in_rotated_sorted_array_ii/Solution.php
+++ b/src/Algorithms/s0081_search_in_rotated_sorted_array_ii/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -7,11 +9,11 @@ class Solution {
      */
     function search($nums, $target) {
         $n = count($nums);
-        $m = intval($n/2);
-        for($i=0; $i<$m; $i++)
-          if($nums[$i] == $target) return true;
-        for($i=$m; $i<$n; $i++)
-          if($nums[$i] == $target) return true;
+        $m = intval($n / 2);
+        for ($i = 0; $i < $m; $i++)
+            if ($nums[$i] == $target) return true;
+        for ($i = $m; $i < $n; $i++)
+            if ($nums[$i] == $target) return true;
         return false;
     }
 }
diff --git a/src/Algorithms/s0082_remove_duplicates_from_sorted_list_ii/Solution.php b/src/Algorithms/s0082_remove_duplicates_from_sorted_list_ii/Solution.php
index c6b5e69..96548a9 100644
--- a/src/Algorithms/s0082_remove_duplicates_from_sorted_list_ii/Solution.php
+++ b/src/Algorithms/s0082_remove_duplicates_from_sorted_list_ii/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /**
  * Definition for a singly-linked list.
  * class ListNode {
@@ -13,15 +15,15 @@ class Solution {
      * @return ListNode
      */
     function deleteDuplicates($head) {
-        if($head == null || $head->next == null) return $head;
+        if ($head == null || $head->next == null) return $head;
         $dummy = new ListNode(-1);
         $dummy->next = $head;
-        $prev=$dummy;
-        $slow=$dummy->next;
-        $fast=$slow->next;
-        while($slow != null && $fast != null) {
-            if($slow->val == $fast->val) {
-                while($fast != null && $slow->val == $fast->val) {
+        $prev = $dummy;
+        $slow = $dummy->next;
+        $fast = $slow->next;
+        while ($slow != null && $fast != null) {
+            if ($slow->val == $fast->val) {
+                while ($fast != null && $slow->val == $fast->val) {
                     $fast = $fast->next;
                 }
                 $prev->next = $fast;
diff --git a/src/Algorithms/s0083_remove_duplicates_from_sorted_list/Solution.php b/src/Algorithms/s0083_remove_duplicates_from_sorted_list/Solution.php
index ebdf938..6b494cc 100644
--- a/src/Algorithms/s0083_remove_duplicates_from_sorted_list/Solution.php
+++ b/src/Algorithms/s0083_remove_duplicates_from_sorted_list/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /**
  * Definition for a singly-linked list.
  * class ListNode {
@@ -13,14 +15,14 @@ class Solution {
      * @return ListNode
      */
     function deleteDuplicates($head) {
-        if($head==null || $head->next == null) return $head;
+        if ($head == null || $head->next == null) return $head;
         $prev = $head;
         $node = $head->next;
-        while( $node!= null){
-            if($node->val != $prev->val){
+        while ($node != null) {
+            if ($node->val != $prev->val) {
                 $prev = $node;
                 $node = $node->next;
-            }else{
+            } else {
                 $prev->next = $node->next;
                 $node = $node->next;
             }
diff --git a/src/Algorithms/s0084_largest_rectangle_in_histogram/Solution.php b/src/Algorithms/s0084_largest_rectangle_in_histogram/Solution.php
index b2d206a..f66725e 100644
--- a/src/Algorithms/s0084_largest_rectangle_in_histogram/Solution.php
+++ b/src/Algorithms/s0084_largest_rectangle_in_histogram/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -5,10 +7,11 @@ class Solution {
      * @return Integer
      */
     function largestRectangleArea($heights) {
-        $max = 0; $i = 0;
+        $max = 0;
+        $i = 0;
         $stack = [];
-        while($i < count($heights) || count($stack) != 0)
-            if($i < count($heights) && (count($stack) == 0  || $heights[$i] >= $heights[end($stack)])) array_push($stack, $i++);
+        while ($i < count($heights) || count($stack) != 0)
+            if ($i < count($heights) && (count($stack) == 0 || $heights[$i] >= $heights[end($stack)])) array_push($stack, $i++);
             else $max = max($max, $heights[array_pop($stack)] * (count($stack) == 0 ? $i : $i - end($stack) - 1));
         return $max;
     }
diff --git a/src/Algorithms/s0085_maximal_rectangle/Solution.php b/src/Algorithms/s0085_maximal_rectangle/Solution.php
index d92b403..fc2c2bb 100644
--- a/src/Algorithms/s0085_maximal_rectangle/Solution.php
+++ b/src/Algorithms/s0085_maximal_rectangle/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -13,26 +15,29 @@ function maximalRectangle($matrix) {
                 }
             }
         }
-        
+
         return $maxSize;
     }
-    
+
     function rectangleSize(&$matrix, $row, $col) {
-        $maxSize; $rowSize; $size;
-        $i = $row + 1; $j = $col + 1; 
+        $maxSize;
+        $rowSize;
+        $size;
+        $i = $row + 1;
+        $j = $col + 1;
         $maxSize = $rowSize = $size = 1;
-        
+
         while ($i < count($matrix) && $matrix[$i++][$col] == '1') {
             $rowSize++;
         }
 
         $maxSize = $size = $rowSize;
-        
+
         while ($j < count($matrix[0])) {
-            if ($matrix[$row][$j] == '0' ) {
+            if ($matrix[$row][$j] == '0') {
                 break;
             }
-            
+
             for ($k = $row; $k < $row + $rowSize; $k++) {
                 if ($matrix[$k][$j] == '0') { //if a '0' is found, reshape the rectangle
                     $oldrowSize = $rowSize;
@@ -40,12 +45,12 @@ function rectangleSize(&$matrix, $row, $col) {
                     $size -= ($j - $col) * ($oldrowSize - $rowSize);
                 }
             }
-            
+
             $size += $rowSize;
             $maxSize = max($maxSize, $size);
             $j++;
         }
-        
+
         return $maxSize;
     }
 }
diff --git a/src/Algorithms/s0086_partition_list/Solution.php b/src/Algorithms/s0086_partition_list/Solution.php
index 16268fc..56aeb6a 100644
--- a/src/Algorithms/s0086_partition_list/Solution.php
+++ b/src/Algorithms/s0086_partition_list/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /**
  * Definition for a singly-linked list.
  * class ListNode {
@@ -14,30 +16,30 @@ class Solution {
      * @return ListNode
      */
     function partition($head, $x) {
-        if($head == null || $head->next == null) return $head;
-		//split the answer into two part and then combine them, use prevPart and restPart as dummy heads;
+        if ($head == null || $head->next == null) return $head;
+        //split the answer into two part and then combine them, use prevPart and restPart as dummy heads;
         $prevPart = new ListNode(-1);
         $restPart = new ListNode(-1);
         $prev = $prevPart;
         $rest = $restPart;
-        while($head != null){
-            if($head->val < $x){
+        while ($head != null) {
+            if ($head->val < $x) {
                 $prev->next = new ListNode($head->val);
                 $prev = $prev->next;
-            }else{
+            } else {
                 $rest->next = new ListNode($head->val);
                 $rest = $rest->next;
             }
             $head = $head->next;
         }
         $tail = self::getTail($prevPart);
-		//put `>= val` numbers at tail of `< val` numbers
+        //put `>= val` numbers at tail of `< val` numbers
         $tail->next = $restPart->next;
         return $prevPart->next;
     }
-    
-    function getTail($head){
-        while($head->next != null){
+
+    function getTail($head) {
+        while ($head->next != null) {
             $head = $head->next;
         }
         return $head;
diff --git a/src/Algorithms/s0087_scramble_string/Solution.php b/src/Algorithms/s0087_scramble_string/Solution.php
index 2ff3134..1501ca2 100644
--- a/src/Algorithms/s0087_scramble_string/Solution.php
+++ b/src/Algorithms/s0087_scramble_string/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -10,7 +12,7 @@ function isScramble($s1, $s2) {
         if (strlen($s1) != strlen($s2)) return false;
         return self::helper($s1, $s2, 0, 0, strlen($s1));
     }
-    
+
     function helper($cs1, $cs2, $s1, $s2, $len) {
         if ($len == 0) return true;
         $same = true;
diff --git a/src/Algorithms/s0088_merge_sorted_array/Solution.php b/src/Algorithms/s0088_merge_sorted_array/Solution.php
index f04f5f1..5566c9e 100644
--- a/src/Algorithms/s0088_merge_sorted_array/Solution.php
+++ b/src/Algorithms/s0088_merge_sorted_array/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -8,15 +10,17 @@ class Solution {
      * @return NULL
      */
     function merge(&$nums1, $m, $nums2, $n) {
-        $i = $m-1; $j = $n-1; $x = count($nums1);
-        for($c = count($nums1) - 1; $c >= 0; $c--) {
-            if ($i>=0 && $j>=0 && $nums1[$i] >= $nums2[$j]) {
+        $i = $m - 1;
+        $j = $n - 1;
+        $x = count($nums1);
+        for ($c = count($nums1) - 1; $c >= 0; $c--) {
+            if ($i >= 0 && $j >= 0 && $nums1[$i] >= $nums2[$j]) {
                 $nums1[$c] = $nums1[$i];
                 --$i;
-            } else if ($i>=0 && $j>=0 && $nums2[$j] > $nums1[$i]) {
+            } else if ($i >= 0 && $j >= 0 && $nums2[$j] > $nums1[$i]) {
                 $nums1[$c] = $nums2[$j];
                 --$j;
-            } else if($i<0 && $j>=0) {
+            } else if ($i < 0 && $j >= 0) {
                 $nums1[$c] = $nums2[$j];
                 --$j;
             } else {
diff --git a/src/Algorithms/s0089_gray_code/Solution.php b/src/Algorithms/s0089_gray_code/Solution.php
index 2ec94b9..7d951d7 100644
--- a/src/Algorithms/s0089_gray_code/Solution.php
+++ b/src/Algorithms/s0089_gray_code/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -9,7 +11,7 @@ function grayCode($n) {
         self::subGray($n, $ans);
         return $ans;
     }
-    
+
     function subGray($n, &$ans) {
         if ($n == 0) {
             array_push($ans, 0);
diff --git a/src/Algorithms/s0090_subsets_ii/Solution.php b/src/Algorithms/s0090_subsets_ii/Solution.php
index c8c9abb..3ec8306 100644
--- a/src/Algorithms/s0090_subsets_ii/Solution.php
+++ b/src/Algorithms/s0090_subsets_ii/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -6,25 +8,25 @@ class Solution {
      */
     function subsetsWithDup($nums) {
         $result = [];
-        if($nums == null || count($nums) == 0) return $result; 
+        if ($nums == null || count($nums) == 0) return $result;
         sort($nums);
         array_push($result, []);
         self::dfs($nums, [], $result, 0);
         return $result;
     }
-    
+
     function dfs($nums, $list, &$result, $index) {
-        
-        if($index == count($nums)) {
+
+        if ($index == count($nums)) {
             return;
         }
-        for($i=$index; $i<count($nums); $i++) {
-            if($i > $index && $nums[$i-1] == $nums[$i]) {
+        for ($i = $index; $i < count($nums); $i++) {
+            if ($i > $index && $nums[$i - 1] == $nums[$i]) {
                 continue;
             }
             array_push($list, $nums[$i]);
             array_push($result, $list);
-            self::dfs($nums, $list, $result, $i+1);
+            self::dfs($nums, $list, $result, $i + 1);
             array_pop($list);
         }
     }
diff --git a/src/Algorithms/s0091_decode_ways/Solution.php b/src/Algorithms/s0091_decode_ways/Solution.php
index a54fd4c..5282aec 100644
--- a/src/Algorithms/s0091_decode_ways/Solution.php
+++ b/src/Algorithms/s0091_decode_ways/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -5,26 +7,26 @@ class Solution {
      * @return Integer
      */
     function numDecodings($s) {
-        if(strlen($s) == 0)
-			return 0;
-		
-		$prev = 26;
-		$result = 0;
-		$first = 1; $second = 1;
-		
-		for($i = strlen($s) - 1; $i >= 0; $i--)
-		{
-			$digit = ord($s[$i]) - ord('0');
-			
-			if($digit == 0)
-				$result = 0;
-			else 
-				$result = $first + ($digit * 10 + $prev <= 26 ? $second : 0);
-			
-			$second = $first;
-			$first = $result; 
-			$prev = $digit;
-		}
-		return $result;
+        if (strlen($s) == 0)
+            return 0;
+
+        $prev = 26;
+        $result = 0;
+        $first = 1;
+        $second = 1;
+
+        for ($i = strlen($s) - 1; $i >= 0; $i--) {
+            $digit = ord($s[$i]) - ord('0');
+
+            if ($digit == 0)
+                $result = 0;
+            else
+                $result = $first + ($digit * 10 + $prev <= 26 ? $second : 0);
+
+            $second = $first;
+            $first = $result;
+            $prev = $digit;
+        }
+        return $result;
     }
 }
diff --git a/src/Algorithms/s0092_reverse_linked_list_ii/Solution.php b/src/Algorithms/s0092_reverse_linked_list_ii/Solution.php
index cf07893..8ffb459 100644
--- a/src/Algorithms/s0092_reverse_linked_list_ii/Solution.php
+++ b/src/Algorithms/s0092_reverse_linked_list_ii/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /**
  * Definition for a singly-linked list.
  * class ListNode {
@@ -16,30 +18,32 @@ class Solution {
      */
     function reverseBetween($head, $m, $n) {
         $dummy = new ListNode(-1);
-        $pre; $cur;
-        $connection; $tail; // tail points to the last node of the reversed sub-list
+        $pre;
+        $cur;
+        $connection;
+        $tail; // tail points to the last node of the reversed sub-list
         $pre = $dummy;
         $dummy->next = $head;
-        
+
         // this loop aims to find the connection node and the first node to be reversed.
-        for($i=0; $i<$m-1; $i++) {
+        for ($i = 0; $i < $m - 1; $i++) {
             $pre = $pre->next;
-        }  
+        }
         $connection = $pre;
         $tail = $cur = $pre->next;
-        
-        $temp; 
+
+        $temp;
         // this loop is just like the similar problem(https://leetcode.com/problems/reverse-linked-list/)
-        for($i=$m; $i<=$n; $i++) {
+        for ($i = $m; $i <= $n; $i++) {
             $temp = $cur->next;
             $cur->next = $pre;
             $pre = $cur;
             $cur = $temp;
         }
-        
+
         // adjust the connection points
         $tail->next = $cur;
         $connection->next = $pre;
-        return $dummy->next;        
+        return $dummy->next;
     }
 }
diff --git a/src/Algorithms/s0093_restore_ip_addresses/Solution.php b/src/Algorithms/s0093_restore_ip_addresses/Solution.php
index 6e47e1e..4ec305d 100644
--- a/src/Algorithms/s0093_restore_ip_addresses/Solution.php
+++ b/src/Algorithms/s0093_restore_ip_addresses/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     var $s;
@@ -30,7 +32,7 @@ function helper($num, $nextIdx, $partIdx) {
         }
         $nextDigit = ord($this->s[$nextIdx]) - ord('0');
         $possibleNum = $num == -1 ? $nextDigit : $num * 10 + $nextDigit;
-        if ($possibleNum <= 255 ) {
+        if ($possibleNum <= 255) {
             //trying increase this position next (if it's not 0)
             if ($possibleNum > 0 || ($possibleNum == 0 && $nextIdx == strlen($this->s) - 1))
                 self::helper($possibleNum, $nextIdx + 1, $partIdx);
@@ -40,11 +42,12 @@ function helper($num, $nextIdx, $partIdx) {
             $this->parts[$partIdx] = -1;
         }
     }
+
     function parseIp() {
         $sb = "";
         for ($i = 0; $i < count($this->parts); $i++) {
             $sb .= $this->parts[$i];
-            if ( $i < count($this->parts) - 1)
+            if ($i < count($this->parts) - 1)
                 $sb .= '.';
         }
         array_push($this->res, $sb);
diff --git a/src/Algorithms/s0094_binary_tree_inorder_traversal/Solution.php b/src/Algorithms/s0094_binary_tree_inorder_traversal/Solution.php
index fe0df35..9bb656f 100644
--- a/src/Algorithms/s0094_binary_tree_inorder_traversal/Solution.php
+++ b/src/Algorithms/s0094_binary_tree_inorder_traversal/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /**
  * Definition for a binary tree node.
  * class TreeNode {
diff --git a/src/Algorithms/s0095_unique_binary_search_trees_ii/Solution.php b/src/Algorithms/s0095_unique_binary_search_trees_ii/Solution.php
index 2d4fdc0..9d23d8b 100644
--- a/src/Algorithms/s0095_unique_binary_search_trees_ii/Solution.php
+++ b/src/Algorithms/s0095_unique_binary_search_trees_ii/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /**
  * Definition for a binary tree node.
  * class TreeNode {
@@ -14,7 +16,7 @@ class Solution {
      * @return TreeNode[]
      */
     function generateTrees($n) {
-       if ($n == 0) {
+        if ($n == 0) {
             return [];
         }
         $results = self::helper(1, $n);
diff --git a/src/Algorithms/s0096_unique_binary_search_trees/Solution.php b/src/Algorithms/s0096_unique_binary_search_trees/Solution.php
index be7d56b..dde1293 100644
--- a/src/Algorithms/s0096_unique_binary_search_trees/Solution.php
+++ b/src/Algorithms/s0096_unique_binary_search_trees/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -8,9 +10,9 @@ function numTrees($n) {
         $dp = array_fill(0, $n + 1, 0);;
         $dp[0] = $dp[1] = 1; // null is also a BST;
 
-        for($i = 2 ; $i <= $n; $i++){
+        for ($i = 2; $i <= $n; $i++) {
             $dp[$i] = 0;
-            for($j = 0 ; $j < $i ; $j++){
+            for ($j = 0; $j < $i; $j++) {
                 $dp[$i] += $dp[$j] * $dp[$i - $j - 1];
             }
         }
diff --git a/src/Algorithms/s0097_interleaving_string/Solution.php b/src/Algorithms/s0097_interleaving_string/Solution.php
index 4d0a077..a4336e3 100644
--- a/src/Algorithms/s0097_interleaving_string/Solution.php
+++ b/src/Algorithms/s0097_interleaving_string/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -7,7 +9,9 @@ class Solution {
      * @return Boolean
      */
     function isInterleave($s1, $s2, $s3) {
-        $l1 = strlen($s1); $l2 = strlen($s2); $l3 = strlen($s3);
+        $l1 = strlen($s1);
+        $l2 = strlen($s2);
+        $l3 = strlen($s3);
         if ($l1 + $l2 != $l3) return false;
         $dp = array_fill(0, $l1 + 1, array_fill(0, $l2 + 1, false));
         $dp[0][0] = true;
@@ -22,10 +26,10 @@ function isInterleave($s1, $s2, $s3) {
         }
         for ($i = 1; $i <= $l1; $i++) {
             for ($j = 1; $j <= $l2; $j++) {
-                    $dp[$i][$j] = ($dp[$i - 1][$j] && $s1[$i - 1] == $s3[$i + $j - 1]) 
-					|| ($dp[$i][$j - 1] && $s2[$j - 1] == $s3[$i + $j - 1]);
+                $dp[$i][$j] = ($dp[$i - 1][$j] && $s1[$i - 1] == $s3[$i + $j - 1])
+                    || ($dp[$i][$j - 1] && $s2[$j - 1] == $s3[$i + $j - 1]);
             }
         }
-        return $dp[$l1][$l2];   
+        return $dp[$l1][$l2];
     }
 }
diff --git a/src/Algorithms/s0098_validate_binary_search_tree/Solution.php b/src/Algorithms/s0098_validate_binary_search_tree/Solution.php
index f1dac96..73e55c1 100644
--- a/src/Algorithms/s0098_validate_binary_search_tree/Solution.php
+++ b/src/Algorithms/s0098_validate_binary_search_tree/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /**
  * Definition for a binary tree node.
  * class TreeNode {
@@ -16,7 +18,7 @@ class Solution {
     function isValidBST($root) {
         return self::helper($root, null, null);
     }
-    
+
     function helper($node, $min, $max) {
         if ($node == null) return true;
         if (($min != null && $node->val <= $min->val) || ($max != null && $node->val >= $max->val)) return false;
diff --git a/src/Algorithms/s0099_recover_binary_search_tree/Solution.php b/src/Algorithms/s0099_recover_binary_search_tree/Solution.php
index 5ae502f..9a5b2f1 100644
--- a/src/Algorithms/s0099_recover_binary_search_tree/Solution.php
+++ b/src/Algorithms/s0099_recover_binary_search_tree/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /**
  * Definition for a binary tree node.
  * class TreeNode {
@@ -15,7 +17,10 @@ class Solution {
      */
     function recoverTree($root) {
         $stack = [];
-        $current = $root; $prev = null; $first = null; $second = null;
+        $current = $root;
+        $prev = null;
+        $first = null;
+        $second = null;
         while ($current != null || count($stack) != 0) {
             while ($current != null) {
                 array_push($stack, $current);
@@ -25,10 +30,13 @@ function recoverTree($root) {
             if ($prev != null && $current->val < $prev->val) {
                 if ($first == null) $first = $prev;
                 $second = $current;
-            } 
-            $prev = $current; $current = $current->right;
+            }
+            $prev = $current;
+            $current = $current->right;
         }
         // swap
-        $temp = $first->val; $first->val = $second->val; $second->val = $temp;        
+        $temp = $first->val;
+        $first->val = $second->val;
+        $second->val = $temp;
     }
 }
diff --git a/src/Algorithms/s0100_same_tree/Solution.php b/src/Algorithms/s0100_same_tree/Solution.php
index f2ac9fb..046e4a1 100644
--- a/src/Algorithms/s0100_same_tree/Solution.php
+++ b/src/Algorithms/s0100_same_tree/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /**
  * Definition for a binary tree node.
  * class TreeNode {
@@ -15,12 +17,12 @@ class Solution {
      * @return Boolean
      */
     function isSameTree($p, $q) {
-        if($p == null && $q == null)
+        if ($p == null && $q == null)
             return true;
-        
-        if($p == null || $q == null)
+
+        if ($p == null || $q == null)
             return false;
-        
-        return ($p->val == $q->val) && self::isSameTree($p->left, $q->left) && self::isSameTree($p->right,$q->right);   
+
+        return ($p->val == $q->val) && self::isSameTree($p->left, $q->left) && self::isSameTree($p->right, $q->right);
     }
 }
diff --git a/src/Algorithms/s0101_symmetric_tree/Solution.php b/src/Algorithms/s0101_symmetric_tree/Solution.php
index 590e147..cbf4652 100644
--- a/src/Algorithms/s0101_symmetric_tree/Solution.php
+++ b/src/Algorithms/s0101_symmetric_tree/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /**
  * Definition for a binary tree node.
  * class TreeNode {
@@ -15,18 +17,18 @@ class Solution {
      */
     function isSymmetric($root) {
         //1. Top empty, return symmetric!
-        if($root == null) return true;
-        
+        if ($root == null) return true;
+
         //2. Recursion method: Single null always symm, so just put kids in.
         return self::helper($root->left, $root->right);
     }
-    
-    function helper($left, $right){
+
+    function helper($left, $right) {
         //3. Both must be null, or false
-        if($left==null || $right==null)
-            return $left==$right;
-        
+        if ($left == null || $right == null)
+            return $left == $right;
+
         //4. Check values and next level of children
-        return $left->val==$right->val && self::helper($left->left, $right->right) && self::helper($left->right, $right->left);
+        return $left->val == $right->val && self::helper($left->left, $right->right) && self::helper($left->right, $right->left);
     }
 }
diff --git a/src/Algorithms/s0102_binary_tree_level_order_traversal/Solution.php b/src/Algorithms/s0102_binary_tree_level_order_traversal/Solution.php
index cf24342..5bf6059 100644
--- a/src/Algorithms/s0102_binary_tree_level_order_traversal/Solution.php
+++ b/src/Algorithms/s0102_binary_tree_level_order_traversal/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /**
  * Definition for a binary tree node.
  * class TreeNode {
@@ -14,23 +16,23 @@ class Solution {
      * @return Integer[][]
      */
     function levelOrder($root) {
-      $lists=[];
-      self::levelOrderTraverse($root,0,$lists);
-      return $lists;
+        $lists = [];
+        self::levelOrderTraverse($root, 0, $lists);
+        return $lists;
     }
 
-    function levelOrderTraverse($root,$depth,&$lists) {
-        if($root==null){
-            return ;
+    function levelOrderTraverse($root, $depth, &$lists) {
+        if ($root == null) {
+            return;
         }
-        if(count($lists)<=$depth){
+        if (count($lists) <= $depth) {
             array_push($lists, []);
             array_push($lists[$depth], $root->val);
-        }else{
+        } else {
             array_push($lists[$depth], $root->val);
         }
 
-        self::levelOrderTraverse($root->left,$depth+1,$lists);
-        self::levelOrderTraverse($root->right,$depth+1,$lists);
+        self::levelOrderTraverse($root->left, $depth + 1, $lists);
+        self::levelOrderTraverse($root->right, $depth + 1, $lists);
     }
 }
diff --git a/src/Algorithms/s0103_binary_tree_zigzag_level_order_traversal/Solution.php b/src/Algorithms/s0103_binary_tree_zigzag_level_order_traversal/Solution.php
index 9b227a4..a7fa16e 100644
--- a/src/Algorithms/s0103_binary_tree_zigzag_level_order_traversal/Solution.php
+++ b/src/Algorithms/s0103_binary_tree_zigzag_level_order_traversal/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /**
  * Definition for a binary tree node.
  * class TreeNode {
@@ -18,12 +20,12 @@ function zigzagLevelOrder($root) {
         $result = [];
         $queue = [];
         if ($root != null) array_push($queue, $root);
-        while (count($queue)  > 0){
+        while (count($queue) > 0) {
             $size = count($queue);
             $list = [];
-            for ($i = 0; $i < $size; $i++){
+            for ($i = 0; $i < $size; $i++) {
                 $node = array_shift($queue);
-                if ($leftRight){
+                if ($leftRight) {
                     array_push($list, $node->val);
                 } else {
                     array_splice($list, 0, 0, $node->val);
@@ -34,7 +36,7 @@ function zigzagLevelOrder($root) {
             array_push($result, $list);
             $leftRight = !$leftRight;
         }
-        
-        return $result; 
+
+        return $result;
     }
 }
diff --git a/src/Algorithms/s0104_maximum_depth_of_binary_tree/Solution.php b/src/Algorithms/s0104_maximum_depth_of_binary_tree/Solution.php
index d469cc1..804eafc 100644
--- a/src/Algorithms/s0104_maximum_depth_of_binary_tree/Solution.php
+++ b/src/Algorithms/s0104_maximum_depth_of_binary_tree/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /**
  * Definition for a binary tree node.
  * class TreeNode {
@@ -14,7 +16,7 @@ class Solution {
      * @return Integer
      */
     function maxDepth($root) {
-        if($root == null) return 0;
-        return 1 + max(self::maxDepth($root->left), self::maxDepth($root->right) );   
+        if ($root == null) return 0;
+        return 1 + max(self::maxDepth($root->left), self::maxDepth($root->right));
     }
 }
diff --git a/src/Algorithms/s0105_construct_binary_tree_from_preorder_and_inorder_traversal/Solution.php b/src/Algorithms/s0105_construct_binary_tree_from_preorder_and_inorder_traversal/Solution.php
index 93852ca..2a27a2f 100644
--- a/src/Algorithms/s0105_construct_binary_tree_from_preorder_and_inorder_traversal/Solution.php
+++ b/src/Algorithms/s0105_construct_binary_tree_from_preorder_and_inorder_traversal/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /**
  * Definition for a binary tree node.
  * class TreeNode {
@@ -21,6 +23,7 @@ function buildTree($preorder, $inorder) {
         }
         return self::helper($preorder, $inorder, $map, 0, 0, count($inorder) - 1);
     }
+
     function helper($preorder, $inorder, $map, $index, $start, $end) {
         if ($index >= count($preorder) || $start > $end) {
             return null;
diff --git a/src/Algorithms/s0106_construct_binary_tree_from_inorder_and_postorder_traversal/Solution.php b/src/Algorithms/s0106_construct_binary_tree_from_inorder_and_postorder_traversal/Solution.php
index c09facc..ede1bd1 100644
--- a/src/Algorithms/s0106_construct_binary_tree_from_inorder_and_postorder_traversal/Solution.php
+++ b/src/Algorithms/s0106_construct_binary_tree_from_inorder_and_postorder_traversal/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /**
  * Definition for a binary tree node.
  * class TreeNode {
@@ -15,20 +17,20 @@ class Solution {
      * @return TreeNode
      */
     function buildTree($inorder, $postorder) {
-        if($inorder==null || count($inorder)==0 || $postorder==null || count($postorder)==0) return null;
-        return self::recursive($inorder, 0, count($inorder)-1, $postorder, count($postorder)-1);
+        if ($inorder == null || count($inorder) == 0 || $postorder == null || count($postorder) == 0) return null;
+        return self::recursive($inorder, 0, count($inorder) - 1, $postorder, count($postorder) - 1);
     }
-    
+
     function recursive($inorder, $inStart, $inEnd, $postorder, $postEnd) {
-        if($inStart>$inEnd || $postEnd<0) return null;
-        $root=new TreeNode($postorder[$postEnd]);
+        if ($inStart > $inEnd || $postEnd < 0) return null;
+        $root = new TreeNode($postorder[$postEnd]);
         /**
-			manually check the index of postorder[postEnd] in inorder arr
-		**/
-        $index=0;
-        while($inorder[$index]!=$root->val) $index++;
-        $root->left=self::recursive($inorder, $inStart, $index-1, $postorder, $postEnd-1-($inEnd-$index));
-        $root->right=self::recursive($inorder, $index+1, $inEnd, $postorder, $postEnd-1);
+         * manually check the index of postorder[postEnd] in inorder arr
+         **/
+        $index = 0;
+        while ($inorder[$index] != $root->val) $index++;
+        $root->left = self::recursive($inorder, $inStart, $index - 1, $postorder, $postEnd - 1 - ($inEnd - $index));
+        $root->right = self::recursive($inorder, $index + 1, $inEnd, $postorder, $postEnd - 1);
         return $root;
     }
 }
diff --git a/src/Algorithms/s0107_binary_tree_level_order_traversal_ii/Solution.php b/src/Algorithms/s0107_binary_tree_level_order_traversal_ii/Solution.php
index 3d500b7..7ba0b54 100644
--- a/src/Algorithms/s0107_binary_tree_level_order_traversal_ii/Solution.php
+++ b/src/Algorithms/s0107_binary_tree_level_order_traversal_ii/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /**
  * Definition for a binary tree node.
  * class TreeNode {
@@ -15,17 +17,17 @@ class Solution {
      */
     function levelOrderBottom($root) {
         $result = [];
-		// Hit the end, return an empty list directly
+        // Hit the end, return an empty list directly
         if ($root == null) {
             return $result;
         }
-        
+
         $self = [];
         array_push($self, $root->val);
-        
+
         $left = self::levelOrderBottom($root->left);
         $right = self::levelOrderBottom($root->right);
-        
+
         // Return directly on leaf will cause the depth of left/right tree are not the same
         // need to merge the lists based on different index.
         $startIdx = abs(count($left) - count($right));
diff --git a/src/Algorithms/s0108_convert_sorted_array_to_binary_search_tree/Solution.php b/src/Algorithms/s0108_convert_sorted_array_to_binary_search_tree/Solution.php
index 8f46af3..6516b08 100644
--- a/src/Algorithms/s0108_convert_sorted_array_to_binary_search_tree/Solution.php
+++ b/src/Algorithms/s0108_convert_sorted_array_to_binary_search_tree/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /**
  * Definition for a binary tree node.
  * class TreeNode {
@@ -15,21 +17,21 @@ class Solution {
      */
     function sortedArrayToBST($num) {
         /*1. Set up recursion*/
-        return self::makeTree($num, 0, count($num)-1);
+        return self::makeTree($num, 0, count($num) - 1);
     }
-    
-    function makeTree($num, $left, $right){
+
+    function makeTree($num, $left, $right) {
         /*2. left as lowest# can't be greater than right*/
-        if($left>$right) return null;
-        
+        if ($left > $right) return null;
+
         /*3. Set median# as node*/
-        $mid = intval(($left+$right)/2);
+        $mid = intval(($left + $right) / 2);
         $midNode = new TreeNode($num[$mid]);
-        
+
         /*4. Set mid node's kids*/
-        $midNode->left = self::makeTree($num, $left, $mid-1);
-        $midNode->right = self::makeTree($num, $mid+1, $right);
-        
+        $midNode->left = self::makeTree($num, $left, $mid - 1);
+        $midNode->right = self::makeTree($num, $mid + 1, $right);
+
         /*5. Sends node back || Goes back to prev node*/
         return $midNode;
     }
diff --git a/src/Algorithms/s0109_convert_sorted_list_to_binary_search_tree/Solution.php b/src/Algorithms/s0109_convert_sorted_list_to_binary_search_tree/Solution.php
index 310c855..a36ec63 100644
--- a/src/Algorithms/s0109_convert_sorted_list_to_binary_search_tree/Solution.php
+++ b/src/Algorithms/s0109_convert_sorted_list_to_binary_search_tree/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /**
  * Definition for a singly-linked list.
  * class ListNode {
@@ -6,6 +8,7 @@
  *     function __construct($val) { $this->val = $val; }
  * }
  */
+
 /**
  * Definition for a binary tree node.
  * class TreeNode {
@@ -30,7 +33,7 @@ function sortedListToBST($head) {
 
         return self::helper($lst, 0, count($lst) - 1);
     }
-    
+
     function helper($lst, $start, $end) {
         if ($start > $end) {
             return null;
diff --git a/src/Algorithms/s0110_balanced_binary_tree/Solution.php b/src/Algorithms/s0110_balanced_binary_tree/Solution.php
index 3e8abb4..88d5ba1 100644
--- a/src/Algorithms/s0110_balanced_binary_tree/Solution.php
+++ b/src/Algorithms/s0110_balanced_binary_tree/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /**
  * Definition for a binary tree node.
  * class TreeNode {
@@ -14,17 +16,17 @@ class Solution {
      * @return Boolean
      */
     function isBalanced($root) {
-        return $root == null || self::checkDepth($root) != -1;      
+        return $root == null || self::checkDepth($root) != -1;
     }
 
-	function checkDepth($root) {
+    function checkDepth($root) {
         $lh = $root->left == null ? 0 : self::checkDepth($root->left);
         $rh = $root->right == null ? 0 : self::checkDepth($root->right);
-		// Left subtree or right subtree is unbalanced
+        // Left subtree or right subtree is unbalanced
         if ($lh == -1 || $rh == -1) return -1;
-		// This tree is unbalanced
+        // This tree is unbalanced
         if ($lh - $rh > 1 || $lh - $rh < -1) return -1;
-		// Return depth of this tree
+        // Return depth of this tree
         return max($lh, $rh) + 1;
     }
 }
diff --git a/src/Algorithms/s0111_minimum_depth_of_binary_tree/Solution.php b/src/Algorithms/s0111_minimum_depth_of_binary_tree/Solution.php
index ca4d56b..cf205b2 100644
--- a/src/Algorithms/s0111_minimum_depth_of_binary_tree/Solution.php
+++ b/src/Algorithms/s0111_minimum_depth_of_binary_tree/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /**
  * Definition for a binary tree node.
  * class TreeNode {
@@ -14,11 +16,11 @@ class Solution {
      * @return Integer
      */
     function minDepth($root) {
-        if($root == null)
+        if ($root == null)
             return 0;
-        else if($root->left == null)
+        else if ($root->left == null)
             return self::minDepth($root->right) + 1;
-        else if($root->right == null)
+        else if ($root->right == null)
             return self::minDepth($root->left) + 1;
         else
             return min(self::minDepth($root->left) + 1, self::minDepth($root->right) + 1);
diff --git a/src/Algorithms/s0112_path_sum/Solution.php b/src/Algorithms/s0112_path_sum/Solution.php
index ffe5f40..f7f1845 100644
--- a/src/Algorithms/s0112_path_sum/Solution.php
+++ b/src/Algorithms/s0112_path_sum/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /**
  * Definition for a binary tree node.
  * class TreeNode {
@@ -15,16 +17,14 @@ class Solution {
      * @return Boolean
      */
     function hasPathSum($root, $sum) {
-        $s=0;
-        return self::hasPathSumUtil($root,$sum,$s);
+        $s = 0;
+        return self::hasPathSumUtil($root, $sum, $s);
     }
 
-    function hasPathSumUtil($root, $sum, $s)
-    {
-        if($root == null)
+    function hasPathSumUtil($root, $sum, $s) {
+        if ($root == null)
             return false;
-        if($root->left==null && $root->right==null)
-        {
+        if ($root->left == null && $root->right == null) {
             $s = $s + $root->val;
             if ($s == $sum)
                 return true;
@@ -34,7 +34,7 @@ function hasPathSumUtil($root, $sum, $s)
         $left = self::hasPathSumUtil($root->left, $sum, $s);
         $right = self::hasPathSumUtil($root->right, $sum, $s);
 
-        if($left || $right)
+        if ($left || $right)
             return true;
 
         return false;
diff --git a/src/Algorithms/s0113_path_sum_ii/Solution.php b/src/Algorithms/s0113_path_sum_ii/Solution.php
index e36acba..fe4e164 100644
--- a/src/Algorithms/s0113_path_sum_ii/Solution.php
+++ b/src/Algorithms/s0113_path_sum_ii/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /**
  * Definition for a binary tree node.
  * class TreeNode {
@@ -19,23 +21,20 @@ function pathSum($root, $sum) {
         $temp = [];
 
         $curSum = 0;
-        self::pathSumUtil($root, $sum, $curSum, $res,$temp);
+        self::pathSumUtil($root, $sum, $curSum, $res, $temp);
 
         return $res;
     }
 
-    function pathSumUtil($root, $sum, $curSum, &$res, &$temp)
-    {
+    function pathSumUtil($root, $sum, $curSum, &$res, &$temp) {
 
-        if($root==null)
+        if ($root == null)
             return;
         array_push($temp, $root->val);
-        if($root->left==null && $root->right==null)
-        {
+        if ($root->left == null && $root->right == null) {
             $curSum = $curSum + $root->val;
 
-            if($sum==$curSum)
-            {   
+            if ($sum == $curSum) {
                 array_push($res, $temp);
             }
         }
diff --git a/src/Algorithms/s0114_flatten_binary_tree_to_linked_list/Solution.php b/src/Algorithms/s0114_flatten_binary_tree_to_linked_list/Solution.php
index 4924d1d..f95faa1 100644
--- a/src/Algorithms/s0114_flatten_binary_tree_to_linked_list/Solution.php
+++ b/src/Algorithms/s0114_flatten_binary_tree_to_linked_list/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /**
  * Definition for a binary tree node.
  * class TreeNode {
@@ -14,17 +16,17 @@ class Solution {
      * @return NULL
      */
     function flatten($root) {
-        if($root==null){
+        if ($root == null) {
             return;
         }
         self::flatten($root->left);
         self::flatten($root->right);
-        $left=$root->left;
-        $right=$root->right;
+        $left = $root->left;
+        $right = $root->right;
         $root->left = null;
         $root->right = $left;
-        $temp=$root;
-        while($temp->right != null){
+        $temp = $root;
+        while ($temp->right != null) {
             $temp = $temp->right;
         }
         $temp->right = $right;
diff --git a/src/Algorithms/s0115_distinct_subsequences/Solution.php b/src/Algorithms/s0115_distinct_subsequences/Solution.php
index 64738fc..c255700 100644
--- a/src/Algorithms/s0115_distinct_subsequences/Solution.php
+++ b/src/Algorithms/s0115_distinct_subsequences/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -6,16 +8,16 @@ class Solution {
      * @return Integer
      */
     function numDistinct($s, $t) {
-      $tLength = strlen($t);
-      $match = array_fill(0, $tLength + 1, 0);
-      $match[0] = 1;
-      for ($i = 0 ; $i < strlen($s); $i++){
-          for ($j = $tLength; $j > 0; $j--){
-              if ($s[$i] == $t[$j-1]){
-                  $match[$j] += $match[$j-1];
-              }
-          }
-      }
-      return $match[$tLength];   
+        $tLength = strlen($t);
+        $match = array_fill(0, $tLength + 1, 0);
+        $match[0] = 1;
+        for ($i = 0; $i < strlen($s); $i++) {
+            for ($j = $tLength; $j > 0; $j--) {
+                if ($s[$i] == $t[$j - 1]) {
+                    $match[$j] += $match[$j - 1];
+                }
+            }
+        }
+        return $match[$tLength];
     }
 }
diff --git a/src/Algorithms/s0116_populating_next_right_pointers_in_each_node/Solution.php b/src/Algorithms/s0116_populating_next_right_pointers_in_each_node/Solution.php
index 36abfaa..47ec7c4 100644
--- a/src/Algorithms/s0116_populating_next_right_pointers_in_each_node/Solution.php
+++ b/src/Algorithms/s0116_populating_next_right_pointers_in_each_node/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /*
 // Definition for a Node.
 class Node {
@@ -18,6 +20,7 @@ function __construct($val, $left, $right, $next) {
     }
 }
 */
+
 class Solution {
 
     /**
@@ -25,18 +28,18 @@ class Solution {
      * @return Node
      */
     function connect($root) {
-        if($root==null){
+        if ($root == null) {
             return null;
-        }     
-        
-        if($root->left!=null && $root->right!=null){
+        }
+
+        if ($root->left != null && $root->right != null) {
             $root->left->next = $root->right;
         }
-        
-        if($root->next!=null && $root->right!=null){
-            $root->right->next=$root->next->left;
+
+        if ($root->next != null && $root->right != null) {
+            $root->right->next = $root->next->left;
         }
-        
+
         self::connect($root->left);
         self::connect($root->right);
         return $root;
diff --git a/src/Algorithms/s0117_populating_next_right_pointers_in_each_node_ii/Solution.php b/src/Algorithms/s0117_populating_next_right_pointers_in_each_node_ii/Solution.php
index 4c3cc40..5dd97d0 100644
--- a/src/Algorithms/s0117_populating_next_right_pointers_in_each_node_ii/Solution.php
+++ b/src/Algorithms/s0117_populating_next_right_pointers_in_each_node_ii/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /*
 // Definition for a Node.
 class Node {
@@ -18,6 +20,7 @@ function __construct($val, $left, $right, $next) {
     }
 }
 */
+
 class Solution {
 
     /**
@@ -25,42 +28,36 @@ class Solution {
      * @return Node
      */
     function connect($root) {
-            if ($root == null)
-            {
-                return null;
-            }
-
-            $start = $root;
+        if ($root == null) {
+            return null;
+        }
 
-            while ($start != null)
-            {
-                $temp = $start;
-                $prev = new Node(-1, null, null, null);
-                $start = null;
+        $start = $root;
 
-                while ($temp != null)
-                {
-                    if ($start == null)
-                    {
-                        $start = $temp->left == null ? $temp->right : $temp->left;
-                    }
+        while ($start != null) {
+            $temp = $start;
+            $prev = new Node(-1, null, null, null);
+            $start = null;
 
-                    if ($temp->left != null)
-                    {
-                        $prev->next = $temp->left;
-                        $prev = $temp->left;
-                    }
+            while ($temp != null) {
+                if ($start == null) {
+                    $start = $temp->left == null ? $temp->right : $temp->left;
+                }
 
-                    if ($temp->right != null)
-                    {
-                        $prev->next = $temp->right;
-                        $prev = $temp->right;
-                    }
+                if ($temp->left != null) {
+                    $prev->next = $temp->left;
+                    $prev = $temp->left;
+                }
 
-                    $temp = $temp->next;
+                if ($temp->right != null) {
+                    $prev->next = $temp->right;
+                    $prev = $temp->right;
                 }
+
+                $temp = $temp->next;
             }
+        }
 
-            return $root;
+        return $root;
     }
 }
diff --git a/src/Algorithms/s0118_pascals_triangle/Solution.php b/src/Algorithms/s0118_pascals_triangle/Solution.php
index 16fb754..260514c 100644
--- a/src/Algorithms/s0118_pascals_triangle/Solution.php
+++ b/src/Algorithms/s0118_pascals_triangle/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -5,24 +7,24 @@ class Solution {
      * @return Integer[][]
      */
     function generate($numRows) {
-        $ans=[];
-        if($numRows==0)
-        	return $ans;
-        $t1=[];
-        
+        $ans = [];
+        if ($numRows == 0)
+            return $ans;
+        $t1 = [];
+
         array_push($t1, 1);
-        $count=0;
-        while($count!=$numRows) {
-        	array_push($ans, $t1);
-        	$t2=[];
-        	array_push($t2, 1);
-        	for($i=1;$i<count($t1);$i++) 
-        		array_push($t2, $t1[$i-1]+$t1[$i]);
-        	array_push($t2, 1);
-        	
-        	$t1=$t2;
-        	$count++;
+        $count = 0;
+        while ($count != $numRows) {
+            array_push($ans, $t1);
+            $t2 = [];
+            array_push($t2, 1);
+            for ($i = 1; $i < count($t1); $i++)
+                array_push($t2, $t1[$i - 1] + $t1[$i]);
+            array_push($t2, 1);
+
+            $t1 = $t2;
+            $count++;
         }
-        return $ans; 
+        return $ans;
     }
 }
diff --git a/src/Algorithms/s0119_pascals_triangle_ii/Solution.php b/src/Algorithms/s0119_pascals_triangle_ii/Solution.php
index 7ee35ad..41c6f50 100644
--- a/src/Algorithms/s0119_pascals_triangle_ii/Solution.php
+++ b/src/Algorithms/s0119_pascals_triangle_ii/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -9,25 +11,25 @@ function getRow($rowIndex) {
         self::getRowHelper($lvl, 0, $rowIndex);
         return $lvl;
     }
-    
+
     function getRowHelper(&$lvl, $row, $rowIndex) {
         // base case when the recursion should stop
-        if ($row>$rowIndex)
+        if ($row > $rowIndex)
             return;
-			
+
         $numElem = $row + 1;
         $prev = 0;
-        for ($i=0; $i<$numElem; $i++) {
-            if ($i==$numElem-1)
+        for ($i = 0; $i < $numElem; $i++) {
+            if ($i == $numElem - 1)
                 array_push($lvl, 1);
             else {
                 // in-place replacement using temporary `prev`
                 $curr = $lvl[$i];
-                $lvl[$i] = $curr+$prev;
+                $lvl[$i] = $curr + $prev;
                 $prev = $curr;  // update prev for next iteration
             }
         }
         // recurse
-        self::getRowHelper($lvl, $row+1, $rowIndex);
+        self::getRowHelper($lvl, $row + 1, $rowIndex);
     }
 }
diff --git a/src/Algorithms/s0120_triangle/Solution.php b/src/Algorithms/s0120_triangle/Solution.php
index 32c2a27..a2faa7c 100644
--- a/src/Algorithms/s0120_triangle/Solution.php
+++ b/src/Algorithms/s0120_triangle/Solution.php
@@ -1,16 +1,18 @@
+<?php
+
 class Solution {
 
     function minimumTotalOfLayer(
         $triangle, &$cache, $layer, $totalLayerSize) {
         $currentLayer = $triangle[$layer];
         if ($layer == $totalLayerSize - 1) {
-          for ($i = 0; $i < $totalLayerSize; $i++) $cache[$i] = $currentLayer[$i];
-          return;
+            for ($i = 0; $i < $totalLayerSize; $i++) $cache[$i] = $currentLayer[$i];
+            return;
         }
         self::minimumTotalOfLayer($triangle, $cache, $layer + 1, $totalLayerSize);
         $currentLayerSize = count($currentLayer);
         for ($i = 0; $i < $currentLayerSize; $i++) {
-          $cache[$i] = min($cache[$i], $cache[$i + 1]) + $currentLayer[$i];
+            $cache[$i] = min($cache[$i], $cache[$i + 1]) + $currentLayer[$i];
         }
     }
 
diff --git a/src/Algorithms/s0121_best_time_to_buy_and_sell_stock/Solution.php b/src/Algorithms/s0121_best_time_to_buy_and_sell_stock/Solution.php
index d233957..9d6959c 100644
--- a/src/Algorithms/s0121_best_time_to_buy_and_sell_stock/Solution.php
+++ b/src/Algorithms/s0121_best_time_to_buy_and_sell_stock/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -5,25 +7,24 @@ class Solution {
      * @return Integer
      */
     function maxProfit($prices) {
-        $max_profit=0;
-        $cur_profit=0;
-        $cur_min=0;
-        $cur_max= 0;
-        for($i = 0; $i < count($prices); $i++){
-            if($i==0) {
+        $max_profit = 0;
+        $cur_profit = 0;
+        $cur_min = 0;
+        $cur_max = 0;
+        for ($i = 0; $i < count($prices); $i++) {
+            if ($i == 0) {
                 $cur_min = $prices[$i];
                 $cur_max = $prices[$i];
                 continue;
             }
-            if ($prices[$i]< $cur_min){
+            if ($prices[$i] < $cur_min) {
                 $cur_min = $prices[$i];
-                $cur_max = $prices[$i];              
-            }
-            else if($prices[$i] > $cur_max){
+                $cur_max = $prices[$i];
+            } else if ($prices[$i] > $cur_max) {
                 $cur_max = $prices[$i];
             }
             $cur_profit = $cur_max - $cur_min;
-            if($cur_profit > $max_profit) $max_profit = $cur_profit;
+            if ($cur_profit > $max_profit) $max_profit = $cur_profit;
         }
         return $max_profit;
     }
diff --git a/src/Algorithms/s0122_best_time_to_buy_and_sell_stock_ii/Solution.php b/src/Algorithms/s0122_best_time_to_buy_and_sell_stock_ii/Solution.php
index 0aed8a0..f4b476f 100644
--- a/src/Algorithms/s0122_best_time_to_buy_and_sell_stock_ii/Solution.php
+++ b/src/Algorithms/s0122_best_time_to_buy_and_sell_stock_ii/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -5,10 +7,10 @@ class Solution {
      * @return Integer
      */
     function maxProfit($prices) {
-        $res=0;
+        $res = 0;
 
-        for($i=0;$i<count($prices)-1;$i++){
-            if($prices[$i]<$prices[$i+1]) $res+=($prices[$i+1]-$prices[$i]);
+        for ($i = 0; $i < count($prices) - 1; $i++) {
+            if ($prices[$i] < $prices[$i + 1]) $res += ($prices[$i + 1] - $prices[$i]);
         }
         return $res;
     }
diff --git a/src/Algorithms/s0123_best_time_to_buy_and_sell_stock_iii/Solution.php b/src/Algorithms/s0123_best_time_to_buy_and_sell_stock_iii/Solution.php
index f3ef0cf..70321e1 100644
--- a/src/Algorithms/s0123_best_time_to_buy_and_sell_stock_iii/Solution.php
+++ b/src/Algorithms/s0123_best_time_to_buy_and_sell_stock_iii/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -5,13 +7,15 @@ class Solution {
      * @return Integer
      */
     function maxProfit($prices) {
-        $hold1 = -2147483647; $hold2 = -2147483647;
-        $release1 = 0; $release2 = 0;
-        foreach($prices as $i){                              // Assume we only have 0 money at first
-            $release2 = max($release2, $hold2+$i);     // The maximum if we've just sold 2nd stock so far.
-            $hold2    = max($hold2,    $release1-$i);  // The maximum if we've just buy  2nd stock so far.
-            $release1 = max($release1, $hold1+$i);     // The maximum if we've just sold 1nd stock so far.
-            $hold1    = max($hold1,    -$i);          // The maximum if we've just buy  1st stock so far. 
+        $hold1 = -2147483647;
+        $hold2 = -2147483647;
+        $release1 = 0;
+        $release2 = 0;
+        foreach ($prices as $i) {                              // Assume we only have 0 money at first
+            $release2 = max($release2, $hold2 + $i);     // The maximum if we've just sold 2nd stock so far.
+            $hold2 = max($hold2, $release1 - $i);  // The maximum if we've just buy  2nd stock so far.
+            $release1 = max($release1, $hold1 + $i);     // The maximum if we've just sold 1nd stock so far.
+            $hold1 = max($hold1, -$i);          // The maximum if we've just buy  1st stock so far.
         }
         return $release2; ///Since release1 is initiated as 0, so release2 will always higher than release1.
     }
diff --git a/src/Algorithms/s0124_binary_tree_maximum_path_sum/Solution.php b/src/Algorithms/s0124_binary_tree_maximum_path_sum/Solution.php
index bbf9c86..854c2ed 100644
--- a/src/Algorithms/s0124_binary_tree_maximum_path_sum/Solution.php
+++ b/src/Algorithms/s0124_binary_tree_maximum_path_sum/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /**
  * Definition for a binary tree node.
  * class TreeNode {
@@ -10,6 +12,7 @@
 class Solution {
 
     var $maxSum = -2147483647;
+
     /**
      * @param TreeNode $root
      * @return Integer
@@ -18,17 +21,17 @@ function maxPathSum($root) {
         self::helper($root);
         return $this->maxSum;
     }
-    
+
     function helper($root) {
-        if($root == null) return 0;
+        if ($root == null) return 0;
         $left = self::helper($root->left);
         $right = self::helper($root->right);
         $rootLeft = $left + $root->val;
         $rootRight = $right + $root->val;
         $ret = max(max($rootLeft, $rootRight), $root->val);
         $compSum = $root->val;
-        if($left > 0) $compSum += $left;
-        if($right > 0) $compSum += $right;
+        if ($left > 0) $compSum += $left;
+        if ($right > 0) $compSum += $right;
         $this->maxSum = max($this->maxSum, $compSum);
         return $ret;
     }
diff --git a/src/Algorithms/s0125_valid_palindrome/Solution.php b/src/Algorithms/s0125_valid_palindrome/Solution.php
index 6c63ac0..dea1076 100644
--- a/src/Algorithms/s0125_valid_palindrome/Solution.php
+++ b/src/Algorithms/s0125_valid_palindrome/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -6,17 +8,17 @@ class Solution {
      */
     function isPalindrome($s) {
         if ($s == null || strlen($s) < 2) return true;
-        
-        for ($i = 0, $j = strlen($s) -1; $i < $j; ) {
+
+        for ($i = 0, $j = strlen($s) - 1; $i < $j;) {
             if (self::normalizeChar($s[$i]) == ' ') $i++;
             else if (self::normalizeChar($s[$j]) == ' ') $j--;
             else if (self::normalizeChar($s[$i++]) != self::normalizeChar($s[$j--]))
                 return false;
         }
-        
+
         return true;
     }
-    
+
     function normalizeChar($c) {
         if (ord($c) > 96 && ord($c) < 123 || ord($c) > 47 && ord($c) < 58) return $c;
         if (ord($c) > 64 && ord($c) < 91) return chr(ord($c) + 32);
diff --git a/src/Algorithms/s0128_longest_consecutive_sequence/Solution.php b/src/Algorithms/s0128_longest_consecutive_sequence/Solution.php
index 54d20da..0af2aed 100644
--- a/src/Algorithms/s0128_longest_consecutive_sequence/Solution.php
+++ b/src/Algorithms/s0128_longest_consecutive_sequence/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -8,26 +10,26 @@ function longestConsecutive($nums) {
         if ($nums == null || count($nums) == 0) {
             return 0;
         }
-        
+
         $map = [];
         $result = 1;
-        
+
         for ($i = 0; $i < count($nums); $i++) {
             $num = $nums[$i];
             if (array_key_exists($num, $map)) {
                 continue;
             }
-            
+
             $left = array_key_exists($num - 1, $map) ? $map[$num - 1] : 0;
             $right = array_key_exists($num + 1, $map) ? $map[$num + 1] : 0;
             $length = $left + $right + 1;
             $result = max($result, $length);
-            
+
             $map[$num] = $length;
             $map[$num - $left] = $length;
             $map[$num + $right] = $length;
         }
-        
+
         return $result;
     }
 }
diff --git a/src/Algorithms/s0129_sum_root_to_leaf_numbers/Solution.php b/src/Algorithms/s0129_sum_root_to_leaf_numbers/Solution.php
index a7c3bbe..9927225 100644
--- a/src/Algorithms/s0129_sum_root_to_leaf_numbers/Solution.php
+++ b/src/Algorithms/s0129_sum_root_to_leaf_numbers/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /**
  * Definition for a binary tree node.
  * class TreeNode {
@@ -14,21 +16,21 @@ class Solution {
      * @return Integer
      */
     function sumNumbers($root) {
-        return self::getSum($root,0);
-        
+        return self::getSum($root, 0);
+
     }
-    
-    function getSum($root, $sum){
-        
-        if($root == null)
+
+    function getSum($root, $sum) {
+
+        if ($root == null)
             return 0;
-        
+
         $sum = $sum * 10 + $root->val;
-        
-        if($root->left == null && $root->right == null)
+
+        if ($root->left == null && $root->right == null)
             return $sum;
-        
-        return self::getSum($root->left,$sum) + self::getSum($root->right,$sum);
-        
+
+        return self::getSum($root->left, $sum) + self::getSum($root->right, $sum);
+
     }
 }
diff --git a/src/Algorithms/s0130_surrounded_regions/Solution.php b/src/Algorithms/s0130_surrounded_regions/Solution.php
index 50cefb6..bad7fcb 100644
--- a/src/Algorithms/s0130_surrounded_regions/Solution.php
+++ b/src/Algorithms/s0130_surrounded_regions/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -5,52 +7,52 @@ class Solution {
      * @return NULL
      */
     function solve(&$board) {
-		if(($board==null)||count($board)==0||count($board[0])==0)
-			return;
-		for ($row = 0; $row < count($board); $row++) {
-			for ($col = 0; $col < count($board[0]); $col++) {
-				if (($row == 0) || ($row == count($board) - 1) || ($col == 0) || ($col == count($board[0]) - 1)) {
-					if ($board[$row][$col] == 'O') {
-						self::color($board, $row, $col);
-					}
-				}
-			}
-		}
+        if (($board == null) || count($board) == 0 || count($board[0]) == 0)
+            return;
+        for ($row = 0; $row < count($board); $row++) {
+            for ($col = 0; $col < count($board[0]); $col++) {
+                if (($row == 0) || ($row == count($board) - 1) || ($col == 0) || ($col == count($board[0]) - 1)) {
+                    if ($board[$row][$col] == 'O') {
+                        self::color($board, $row, $col);
+                    }
+                }
+            }
+        }
 
-		for ($row = 0; $row < count($board); $row++) {
-			for ($col = 0; $col < count($board[0]); $col++) {
+        for ($row = 0; $row < count($board); $row++) {
+            for ($col = 0; $col < count($board[0]); $col++) {
 
-				if ($board[$row][$col] == 'O') {
-					$board[$row][$col] = 'X';
-				}
-				if ($board[$row][$col] == 'V') {
-					$board[$row][$col] = 'O';
-				}
-			}
-		}
-	}
+                if ($board[$row][$col] == 'O') {
+                    $board[$row][$col] = 'X';
+                }
+                if ($board[$row][$col] == 'V') {
+                    $board[$row][$col] = 'O';
+                }
+            }
+        }
+    }
 
-	function color(&$board, $row, $col) {
-		$board[$row][$col] = 'V';
-		if ($row + 1 < count($board)) {
-			if ($board[$row + 1][$col] == 'O') {
-				self::color($board, $row + 1, $col);
-			}
-		}
-		if ($row - 1 >= 0) {
-			if ($board[$row - 1][$col] == 'O') {
-				self::color($board, $row - 1, $col);
-			}
-		}
-		if ($col + 1 < count($board[0])) {
-			if ($board[$row][$col + 1] == 'O') {
-				self::color($board, $row, $col + 1);
-			}
-		}
-		if ($col - 1 >= 0) {
-			if ($board[$row][$col - 1] == 'O') {
-				self::color($board, $row, $col - 1);
-			}
-		}
-	}
+    function color(&$board, $row, $col) {
+        $board[$row][$col] = 'V';
+        if ($row + 1 < count($board)) {
+            if ($board[$row + 1][$col] == 'O') {
+                self::color($board, $row + 1, $col);
+            }
+        }
+        if ($row - 1 >= 0) {
+            if ($board[$row - 1][$col] == 'O') {
+                self::color($board, $row - 1, $col);
+            }
+        }
+        if ($col + 1 < count($board[0])) {
+            if ($board[$row][$col + 1] == 'O') {
+                self::color($board, $row, $col + 1);
+            }
+        }
+        if ($col - 1 >= 0) {
+            if ($board[$row][$col - 1] == 'O') {
+                self::color($board, $row, $col - 1);
+            }
+        }
+    }
 }
diff --git a/src/Algorithms/s0131_palindrome_partitioning/Solution.php b/src/Algorithms/s0131_palindrome_partitioning/Solution.php
index f2e8865..9fd0bf3 100644
--- a/src/Algorithms/s0131_palindrome_partitioning/Solution.php
+++ b/src/Algorithms/s0131_palindrome_partitioning/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -6,29 +8,29 @@ class Solution {
      */
     function partition($s) {
         $res = [];
-        self::helper($s,0,$res,[],array_fill(0, strlen($s), array_fill(0, strlen($s), false)));
-        return $res;        
+        self::helper($s, 0, $res, [], array_fill(0, strlen($s), array_fill(0, strlen($s), false)));
+        return $res;
     }
-    
+
     function helper($s, $cur, &$res, $temp, &$dp) {
-        if($cur == strlen($s)){
+        if ($cur == strlen($s)) {
             array_push($res, $temp);
             return;
         }
-        
-        for($i=$cur;$i<strlen($s);$i++){
-            if(self::isPlaindrome($cur,$i,$dp,$s)){
+
+        for ($i = $cur; $i < strlen($s); $i++) {
+            if (self::isPlaindrome($cur, $i, $dp, $s)) {
                 $dp[$cur][$i] = true;
-                array_push($temp, substr($s, $cur,$i+1-$cur));
-                self::helper($s,$i+1,$res,$temp,$dp);
+                array_push($temp, substr($s, $cur, $i + 1 - $cur));
+                self::helper($s, $i + 1, $res, $temp, $dp);
                 array_pop($temp);
             }
         }
     }
-    
-    function isPlaindrome($i,$j, $dp, $s){
-        if($s[$i] == $s[$j]){
-            if($i == $j || $j == $i+1 || $dp[$i+1][$j-1]) return true;
+
+    function isPlaindrome($i, $j, $dp, $s) {
+        if ($s[$i] == $s[$j]) {
+            if ($i == $j || $j == $i + 1 || $dp[$i + 1][$j - 1]) return true;
         }
         return false;
     }
diff --git a/src/Algorithms/s0132_palindrome_partitioning_ii/Solution.php b/src/Algorithms/s0132_palindrome_partitioning_ii/Solution.php
index 264f753..e54f23c 100644
--- a/src/Algorithms/s0132_palindrome_partitioning_ii/Solution.php
+++ b/src/Algorithms/s0132_palindrome_partitioning_ii/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -8,19 +10,19 @@ function minCut($s) {
         $n = strlen($s);
         $dp = array_fill(0, $n, array_fill(0, $n, false));
         $cut = array_fill(0, $n, $n - 1);
-        
-        for($j = 0; $j < $n; $j++) {
-            for($i = 0; $i <= $j; $i++) {
-                if($s[$i] == $s[$j] && ($j - $i <= 1 || $dp[$i + 1][$j - 1])) {
+
+        for ($j = 0; $j < $n; $j++) {
+            for ($i = 0; $i <= $j; $i++) {
+                if ($s[$i] == $s[$j] && ($j - $i <= 1 || $dp[$i + 1][$j - 1])) {
                     $dp[$i][$j] = true;
-                    if($i == 0)
+                    if ($i == 0)
                         $cut[$j] = 0; //no cut needed
                     else
                         $cut[$j] = min($cut[$j], $cut[$i - 1] + 1);
                 }
             }
         }
-        
+
         return $cut[$n - 1];
     }
 }
diff --git a/src/Algorithms/s0133_clone_graph/Solution.php b/src/Algorithms/s0133_clone_graph/Solution.php
index 494e31f..0f145b0 100644
--- a/src/Algorithms/s0133_clone_graph/Solution.php
+++ b/src/Algorithms/s0133_clone_graph/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /*
 // Definition for a Node.
 class Node {
@@ -12,6 +14,7 @@ function __construct($val, $neighbors) {
     }
 }
 */
+
 class Solution {
 
     /**
@@ -22,7 +25,7 @@ function cloneGraph($node) {
         $seen = [];
         return self::cloneHelper($node, $seen);
     }
-        
+
     function cloneHelper(&$origNode, &$seen) {
         if ($origNode == null)
             return null;
diff --git a/src/Algorithms/s0134_gas_station/Solution.php b/src/Algorithms/s0134_gas_station/Solution.php
index 4bee582..264dc0f 100644
--- a/src/Algorithms/s0134_gas_station/Solution.php
+++ b/src/Algorithms/s0134_gas_station/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -9,14 +11,14 @@ function canCompleteCircuit($gas, $cost) {
         $sum = 0;
         $min = 2147483647;
         $minIndex = 0;
-        for($i=0; $i<count($gas); $i++){
-            $sum += $gas[$i]-$cost[$i];
-            if($sum<$min){
+        for ($i = 0; $i < count($gas); $i++) {
+            $sum += $gas[$i] - $cost[$i];
+            if ($sum < $min) {
                 $min = $sum;
                 $minIndex = $i;
             }
         }
-        if($sum<0) return -1;
-        return $minIndex==count($gas)-1 ?  0 : $minIndex + 1;
+        if ($sum < 0) return -1;
+        return $minIndex == count($gas) - 1 ? 0 : $minIndex + 1;
     }
 }
diff --git a/src/Algorithms/s0135_candy/Solution.php b/src/Algorithms/s0135_candy/Solution.php
index 324b5b7..5893322 100644
--- a/src/Algorithms/s0135_candy/Solution.php
+++ b/src/Algorithms/s0135_candy/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -5,29 +7,25 @@ class Solution {
      * @return Integer
      */
     function candy($ratings) {
-		$n = count($ratings);
-		$sum = 0;
-		$candies = array_fill(0, $n, 1);
+        $n = count($ratings);
+        $sum = 0;
+        $candies = array_fill(0, $n, 1);
 
-		for($i = 1; $i < $n; $i++)
-		{
-			if($ratings[$i] > $ratings[$i - 1])
-            {
+        for ($i = 1; $i < $n; $i++) {
+            if ($ratings[$i] > $ratings[$i - 1]) {
                 $candies[$i] = $candies[$i - 1] + 1;
             }
-		}
+        }
 
-		for($i = $n - 1; $i > 0; $i--)
-		{
-			if($ratings[$i - 1] > $ratings[$i] && $candies[$i - 1] <= $candies[$i])
-            {
+        for ($i = $n - 1; $i > 0; $i--) {
+            if ($ratings[$i - 1] > $ratings[$i] && $candies[$i - 1] <= $candies[$i]) {
                 $candies[$i - 1] = $candies[$i] + 1;
             }
-		}
+        }
 
-		foreach($candies as $candy)
-			$sum += $candy;
+        foreach ($candies as $candy)
+            $sum += $candy;
 
-		return $sum;
+        return $sum;
     }
 }
diff --git a/src/Algorithms/s0136_single_number/Solution.php b/src/Algorithms/s0136_single_number/Solution.php
index ee9989d..6592fd7 100644
--- a/src/Algorithms/s0136_single_number/Solution.php
+++ b/src/Algorithms/s0136_single_number/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
diff --git a/src/Algorithms/s0137_single_number_ii/Solution.php b/src/Algorithms/s0137_single_number_ii/Solution.php
index 3a3fba3..f5bd4ae 100644
--- a/src/Algorithms/s0137_single_number_ii/Solution.php
+++ b/src/Algorithms/s0137_single_number_ii/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -5,32 +7,31 @@ class Solution {
      * @return Integer
      */
     function singleNumber($nums) {
-        sort($nums); 
-        
-        $result = -1; 
-        $found = false; 
-        $i = 0; 
-        
-        while($found == false){
+        sort($nums);
+
+        $result = -1;
+        $found = false;
+        $i = 0;
+
+        while ($found == false) {
             $found = false;
-			
-            if($i == count($nums) - 1){
-                $result = $nums[$i]; 
-                $found = true; 
+
+            if ($i == count($nums) - 1) {
+                $result = $nums[$i];
+                $found = true;
                 break;
             }
-			//if its next one, then we know three more of same number exist
-            if($nums[$i] == $nums[$i+1]){
-                $i+=3; 
-                continue; 
-            }
-            else{
-			//if not equal to the one next to it, we've found it. 
-                $result = $nums[$i]; 
-                $found = true; 
+            //if its next one, then we know three more of same number exist
+            if ($nums[$i] == $nums[$i + 1]) {
+                $i += 3;
+                continue;
+            } else {
+                //if not equal to the one next to it, we've found it.
+                $result = $nums[$i];
+                $found = true;
                 break;
             }
         }
-        return $result; 
+        return $result;
     }
 }
diff --git a/src/Algorithms/s0138_copy_list_with_random_pointer/Solution.php b/src/Algorithms/s0138_copy_list_with_random_pointer/Solution.php
index 15b46a8..04415a1 100644
--- a/src/Algorithms/s0138_copy_list_with_random_pointer/Solution.php
+++ b/src/Algorithms/s0138_copy_list_with_random_pointer/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /*
 // Definition for a Node.
 class Node {
@@ -15,6 +17,7 @@ function __construct($val, $next, $random) {
     }
 }
 */
+
 class Solution {
 
     /**
@@ -22,50 +25,50 @@ class Solution {
      * @return Node
      */
     function copyRandomList($head) {
-      $iter = $head;
-      $next;
+        $iter = $head;
+        $next;
 
-      // First round: make copy of each node,
-      // and link them together side-by-side in a single list.
-      while ($iter != null) {
-        $next = $iter->next;
+        // First round: make copy of each node,
+        // and link them together side-by-side in a single list.
+        while ($iter != null) {
+            $next = $iter->next;
 
-        $copy = new Node($iter->val, null, null);
-        $iter->next = $copy;
-        $copy->next = $next;
+            $copy = new Node($iter->val, null, null);
+            $iter->next = $copy;
+            $copy->next = $next;
 
-        $iter = $next;
-      }
+            $iter = $next;
+        }
 
-      // Second round: assign random pointers for the copy nodes.
-      $iter = $head;
-      while ($iter != null) {
-        if ($iter->random != null) {
-          $iter->next->random = $iter->random->next;
+        // Second round: assign random pointers for the copy nodes.
+        $iter = $head;
+        while ($iter != null) {
+            if ($iter->random != null) {
+                $iter->next->random = $iter->random->next;
+            }
+            $iter = $iter->next->next;
         }
-        $iter = $iter->next->next;
-      }
 
-      // Third round: restore the original list, and extract the copy list.
-      $iter = $head;
-      $pseudoHead = new Node(0, null, null);
-      $copy;
-      $copyIter = $pseudoHead;
+        // Third round: restore the original list, and extract the copy list.
+        $iter = $head;
+        $pseudoHead = new Node(0, null, null);
+        $copy;
+        $copyIter = $pseudoHead;
 
-      while ($iter != null) {
-        $next = $iter->next->next;
+        while ($iter != null) {
+            $next = $iter->next->next;
 
-        // extract the copy
-        $copy = $iter->next;
-        $copyIter->next = $copy;
-        $copyIter = $copy;
+            // extract the copy
+            $copy = $iter->next;
+            $copyIter->next = $copy;
+            $copyIter = $copy;
 
-        // restore the original list
-        $iter->next = $next;
+            // restore the original list
+            $iter->next = $next;
 
-        $iter = $next;
-      }
+            $iter = $next;
+        }
 
-      return $pseudoHead->next;
+        return $pseudoHead->next;
     }
 }
diff --git a/src/Algorithms/s0139_word_break/Solution.php b/src/Algorithms/s0139_word_break/Solution.php
index 4cf332f..327888d 100644
--- a/src/Algorithms/s0139_word_break/Solution.php
+++ b/src/Algorithms/s0139_word_break/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
diff --git a/src/Algorithms/s0140_word_break_ii/Solution.php b/src/Algorithms/s0140_word_break_ii/Solution.php
index 1280098..b6b5352 100644
--- a/src/Algorithms/s0140_word_break_ii/Solution.php
+++ b/src/Algorithms/s0140_word_break_ii/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -10,14 +12,14 @@ function wordBreak($s, $wordDict) {
         self::wordBreakHelper($s, $wordDict, $map);
         return $map[$s];
     }
-    
+
     function wordBreakHelper($s, $dict, &$map) {
         if (array_key_exists($s, $map)) {
-            return $map[$s];   
+            return $map[$s];
         }
-        
+
         $list = [];
-        
+
         if ($s == "") {
             array_push($list, "");
             return $list;
@@ -28,16 +30,16 @@ function wordBreakHelper($s, $dict, &$map) {
                 $tempList = self::wordBreakHelper(substr($s, strlen($currStr)), $dict, $map);
                 if (!empty($tempList)) {
                     foreach ($tempList as $tempStr) {
-                       array_push($list, $currStr . ($tempStr == "" ? "" : " ") . $tempStr);
+                        array_push($list, $currStr . ($tempStr == "" ? "" : " ") . $tempStr);
                     }
                 }
             }
         }
-        
+
         $map[$s] = $list;
         return $list;
     }
-    
+
     function startsWith($haystack, $needle) {
         return strncmp($haystack, $needle, strlen($needle)) === 0;
     }
diff --git a/src/Algorithms/s0143_reorder_list/Solution.php b/src/Algorithms/s0143_reorder_list/Solution.php
index 77cd8cf..c019d97 100644
--- a/src/Algorithms/s0143_reorder_list/Solution.php
+++ b/src/Algorithms/s0143_reorder_list/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /**
  * Definition for a singly-linked list.
  * class ListNode {
@@ -13,27 +15,27 @@ class Solution {
      * @return NULL
      */
     function reorderList($head) {
-        if($head == null) return;
+        if ($head == null) return;
         $slow = $head;
         $fast = $head;
 
-        while($fast != null && $fast->next != null){
+        while ($fast != null && $fast->next != null) {
             $fast = $fast->next->next;
             $slow = $slow->next;
         }
-        
+
         $next = null;
         $curr = $slow;
         $prev = null;
-        while($curr != null){
+        while ($curr != null) {
             $next = $curr->next;
             $curr->next = $prev;
             $prev = $curr;
             $curr = $next;
         }
-        
+
         $temp;
-        while($prev != null && $head->next != null){
+        while ($prev != null && $head->next != null) {
             $temp = $head->next;
             $head->next = $prev;
             $head = $temp;
diff --git a/src/Algorithms/s0144_binary_tree_preorder_traversal/Solution.php b/src/Algorithms/s0144_binary_tree_preorder_traversal/Solution.php
index 66dcdeb..356da74 100644
--- a/src/Algorithms/s0144_binary_tree_preorder_traversal/Solution.php
+++ b/src/Algorithms/s0144_binary_tree_preorder_traversal/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /**
  * Definition for a binary tree node.
  * class TreeNode {
@@ -17,13 +19,13 @@ function preorderTraversal($root) {
         $list = [];
         $stack = [];
         array_push($stack, $root);
-        while(!empty($stack)){
+        while (!empty($stack)) {
             $node = array_pop($stack);
-            while($node != null){
+            while ($node != null) {
                 array_push($list, $node->val);
                 array_push($stack, $node->right);
                 $node = $node->left;
-            }            
+            }
         }
         return $list;
     }
diff --git a/src/Algorithms/s0145_binary_tree_postorder_traversal/Solution.php b/src/Algorithms/s0145_binary_tree_postorder_traversal/Solution.php
index 5cd8369..bdbb314 100644
--- a/src/Algorithms/s0145_binary_tree_postorder_traversal/Solution.php
+++ b/src/Algorithms/s0145_binary_tree_postorder_traversal/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /**
  * Definition for a binary tree node.
  * class TreeNode {
diff --git a/src/Algorithms/s0146_lru_cache/LRUCache.php b/src/Algorithms/s0146_lru_cache/LRUCache.php
index 7603ed6..f40cddf 100644
--- a/src/Algorithms/s0146_lru_cache/LRUCache.php
+++ b/src/Algorithms/s0146_lru_cache/LRUCache.php
@@ -1,8 +1,11 @@
-class Node{
+<?php
+
+class Node {
     var $key;
     var $val;
     var $prev;
     var $next;
+
     function __construct($key, $val) {
         $this->key = $key;
         $this->val = $val;
@@ -24,7 +27,7 @@ function __construct($capacity) {
         $this->tail->prev = $this->head;
         $this->map = [];
     }
-  
+
     /**
      * @param Integer $key
      * @return Integer
@@ -38,7 +41,7 @@ function get($key) {
         }
         return -1;
     }
-  
+
     /**
      * @param Integer $key
      * @param Integer $value
@@ -64,12 +67,12 @@ function put($key, $value) {
             $this->currentCapacity++;
         }
     }
-    
+
     function removeNode($node) {
         $node->prev->next = $node->next;
         $node->next->prev = $node->prev;
     }
-    
+
     function addToTail($node) {
         $this->tail->prev->next = $node;
         $node->prev = $this->tail->prev;
diff --git a/src/Algorithms/s0147_insertion_sort_list/Solution.php b/src/Algorithms/s0147_insertion_sort_list/Solution.php
index 0f6e42d..2004cf8 100644
--- a/src/Algorithms/s0147_insertion_sort_list/Solution.php
+++ b/src/Algorithms/s0147_insertion_sort_list/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /**
  * Definition for a singly-linked list.
  * class ListNode {
@@ -13,9 +15,10 @@ class Solution {
      * @return ListNode
      */
     function insertionSortList($head) {
-        if ($head == null || $head->next == null ) return $head;
+        if ($head == null || $head->next == null) return $head;
         $tmp;
-        $k; $z;
+        $k;
+        $z;
         for ($start = $head; $start->next != null; $start = $start->next) {
             $tmp = $start->next;
             $k = $tmp->val;
diff --git a/src/Algorithms/s0148_sort_list/Solution.php b/src/Algorithms/s0148_sort_list/Solution.php
index 928212b..914f3c6 100644
--- a/src/Algorithms/s0148_sort_list/Solution.php
+++ b/src/Algorithms/s0148_sort_list/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /**
  * Definition for a singly-linked list.
  * class ListNode {
@@ -18,7 +20,7 @@ function sortList($head) {
         $slow = $head;
         $fast = $head;
         $pre = $slow;
-        while($fast != null && $fast->next != null) {
+        while ($fast != null && $fast->next != null) {
             $pre = $slow;
             $slow = $slow->next;
             $fast = $fast->next->next;
@@ -30,7 +32,7 @@ function sortList($head) {
         $cur = $res;
         while ($first != null || $second != null) {
             if ($first == null) {
-                $cur->next= $second;
+                $cur->next = $second;
                 break;
             } else if ($second == null) {
                 $cur->next = $first;
diff --git a/src/Algorithms/s0149_max_points_on_a_line/Solution.php b/src/Algorithms/s0149_max_points_on_a_line/Solution.php
index 2ae412d..33fa181 100644
--- a/src/Algorithms/s0149_max_points_on_a_line/Solution.php
+++ b/src/Algorithms/s0149_max_points_on_a_line/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 /**
  * Definition for a point.
  * class Point(
@@ -22,77 +24,77 @@ function maxPoints($points) {
         if ($points == null || count($points) == 0) {
             return 0;
         } else if (count($points) == 1) {
-            return 1;  
+            return 1;
         } else if (count($points) == 2) {
             return 2;
         } else {
-            for ($i=0;$i<count($points);$i++) {
-		//key is a string = y + "/" + x to prevent from division/float/double/BigDecimal
-		//value is amount of points on the same line -1
-            	$amount = [];
-		//j=i+1 to prevent from backwarding loop
-                for ($j=$i+1;$j<count($points);$j++) {
+            for ($i = 0; $i < count($points); $i++) {
+                //key is a string = y + "/" + x to prevent from division/float/double/BigDecimal
+                //value is amount of points on the same line -1
+                $amount = [];
+                //j=i+1 to prevent from backwarding loop
+                for ($j = $i + 1; $j < count($points); $j++) {
                     $y = $points[$j]->y - $points[$i]->y;
                     $x = $points[$j]->x - $points[$i]->x;
-                	
+
                     if ($x == 0 && $y == 0) {
-                	$duplicated++;
-                	if ($isMaxChanged == true) {
-                	    $max++;
-                	} else if ($max < $duplicated) {
-                	    $max = $duplicated;
-                	}
-                		
+                        $duplicated++;
+                        if ($isMaxChanged == true) {
+                            $max++;
+                        } else if ($max < $duplicated) {
+                            $max = $duplicated;
+                        }
+
                     } else {
-                	$gcd = self::getGCD($y,$x);
-                	if ($gcd != 0) {
-                 	    $y = intval($y / $gcd);
-	              	    $x = intval($x / $gcd);
-	               	    $k = $y."/".$x;
-	                    if (array_key_exists($k, $amount)) {
-	                	$n = $amount[$k];
-	                	$amount[$k] = $n+1;
-	                	if ($max < $n+1+$duplicated) {
-	                	    $max = $n+1+$duplicated;
-	                	    $isMaxChanged = true;
-	                	}
-	                    } else {
-	                	$amount[$k] = 1;
-	                	if ($max < 1+$duplicated) {
-	                	    $max = 1+$duplicated;
-	                	    $isMaxChanged = true;
-	                	}
-	                    }
-	                }
+                        $gcd = self::getGCD($y, $x);
+                        if ($gcd != 0) {
+                            $y = intval($y / $gcd);
+                            $x = intval($x / $gcd);
+                            $k = $y . "/" . $x;
+                            if (array_key_exists($k, $amount)) {
+                                $n = $amount[$k];
+                                $amount[$k] = $n + 1;
+                                if ($max < $n + 1 + $duplicated) {
+                                    $max = $n + 1 + $duplicated;
+                                    $isMaxChanged = true;
+                                }
+                            } else {
+                                $amount[$k] = 1;
+                                if ($max < 1 + $duplicated) {
+                                    $max = 1 + $duplicated;
+                                    $isMaxChanged = true;
+                                }
+                            }
+                        }
                     }
                 }
 
                 $duplicated = 0;
                 $isMaxChanged = false;
-                
+
             }
-            return $max+1;
+            return $max + 1;
         }
     }
-    
+
     //horizontal lines make x=0 & y=1
     //vertical lines make x=1 & y=0
     //same position points should not invoke this function whick make x=0 & y=0
     //other points return the gcd
     function getGCD($y, $x) {
-    	if ($x == 0) {
-    	    if ($y == 0) {
-    		return 0;//same point
-    	    } else {
-    		return $y;//horizontal lines
-    	    }
-    	} else {
-	    //normal case and the vertical lines
-	    if ($y%$x != 0) {
-	    	return self::getGCD($x,$y%$x);
-	    } else {
-	    	return $x;
-	    }
-    	}
+        if ($x == 0) {
+            if ($y == 0) {
+                return 0;//same point
+            } else {
+                return $y;//horizontal lines
+            }
+        } else {
+            //normal case and the vertical lines
+            if ($y % $x != 0) {
+                return self::getGCD($x, $y % $x);
+            } else {
+                return $x;
+            }
+        }
     }
 }
diff --git a/src/Algorithms/s0150_evaluate_reverse_polish_notation/Solution.php b/src/Algorithms/s0150_evaluate_reverse_polish_notation/Solution.php
index 859a42f..053e1ed 100644
--- a/src/Algorithms/s0150_evaluate_reverse_polish_notation/Solution.php
+++ b/src/Algorithms/s0150_evaluate_reverse_polish_notation/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -6,37 +8,40 @@ class Solution {
      */
     function evalRPN($tokens) {
         $stack = [];
-        $conVal=0;
-        $res=0;
-        
-        if(count($tokens)<2)return intval($tokens[0]);
-        foreach($tokens as $s){
-            if(($s == "+") || ($s == "-") || ($s == "*") || ($s == "/")){
-                switch($s){
-                    case "+" : $res=array_pop($stack)+array_pop($stack);
-                               array_push($stack, $res);
-                               break;
-                    case "-" : $x = array_pop($stack);
-                               $y = array_pop($stack);
-                               $res=$y-$x;
-                               array_push($stack, $res);
-                               break;
-                    case "*" : $res=array_pop($stack)*array_pop($stack);
-                               array_push($stack, $res);
-                               break;
-                    case "/" : $a = array_pop($stack);
-                               $b = array_pop($stack);
-                               if($b==0)$res=0;
-                               else $res=intval($b/$a);
-                               array_push($stack, $res);
-                               break;
-                 }
-            }
-          else{
+        $conVal = 0;
+        $res = 0;
+
+        if (count($tokens) < 2) return intval($tokens[0]);
+        foreach ($tokens as $s) {
+            if (($s == "+") || ($s == "-") || ($s == "*") || ($s == "/")) {
+                switch ($s) {
+                    case "+" :
+                        $res = array_pop($stack) + array_pop($stack);
+                        array_push($stack, $res);
+                        break;
+                    case "-" :
+                        $x = array_pop($stack);
+                        $y = array_pop($stack);
+                        $res = $y - $x;
+                        array_push($stack, $res);
+                        break;
+                    case "*" :
+                        $res = array_pop($stack) * array_pop($stack);
+                        array_push($stack, $res);
+                        break;
+                    case "/" :
+                        $a = array_pop($stack);
+                        $b = array_pop($stack);
+                        if ($b == 0) $res = 0;
+                        else $res = intval($b / $a);
+                        array_push($stack, $res);
+                        break;
+                }
+            } else {
                 $conVal = intval($s);
                 array_push($stack, $conVal);
             }
         }
-      return $res;
+        return $res;
     }
 }
diff --git a/src/Algorithms/s0151_reverse_words_in_a_string/Solution.php b/src/Algorithms/s0151_reverse_words_in_a_string/Solution.php
index fb1002c..47ecda8 100644
--- a/src/Algorithms/s0151_reverse_words_in_a_string/Solution.php
+++ b/src/Algorithms/s0151_reverse_words_in_a_string/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -7,9 +9,9 @@ class Solution {
     function reverseWords($s) {
         $words = explode(" ", $s);
         $sb = "";
-        
-        for ($i = count($words)-1; $i>= 0; $i--){
-            if(strlen(trim($words[$i])) != 0){
+
+        for ($i = count($words) - 1; $i >= 0; $i--) {
+            if (strlen(trim($words[$i])) != 0) {
                 $sb .= trim($words[$i]);
                 $sb .= " ";
             }
diff --git a/src/Algorithms/s0152_maximum_product_subarray/Solution.php b/src/Algorithms/s0152_maximum_product_subarray/Solution.php
index 74e65d4..56b1283 100644
--- a/src/Algorithms/s0152_maximum_product_subarray/Solution.php
+++ b/src/Algorithms/s0152_maximum_product_subarray/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
diff --git a/src/Algorithms/s0153_find_minimum_in_rotated_sorted_array/Solution.php b/src/Algorithms/s0153_find_minimum_in_rotated_sorted_array/Solution.php
index 9af26a7..497ced2 100644
--- a/src/Algorithms/s0153_find_minimum_in_rotated_sorted_array/Solution.php
+++ b/src/Algorithms/s0153_find_minimum_in_rotated_sorted_array/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -5,8 +7,8 @@ class Solution {
      * @return Integer
      */
     function findMin($nums) {
-        for($i=1;$i<count($nums);$i++){
-            if($nums[$i]<$nums[$i-1])
+        for ($i = 1; $i < count($nums); $i++) {
+            if ($nums[$i] < $nums[$i - 1])
                 return $nums[$i];
         }
         return $nums[0];
diff --git a/src/Algorithms/s0154_find_minimum_in_rotated_sorted_array_ii/Solution.php b/src/Algorithms/s0154_find_minimum_in_rotated_sorted_array_ii/Solution.php
index a12599d..c6941d9 100644
--- a/src/Algorithms/s0154_find_minimum_in_rotated_sorted_array_ii/Solution.php
+++ b/src/Algorithms/s0154_find_minimum_in_rotated_sorted_array_ii/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -5,21 +7,21 @@ class Solution {
      * @return Integer
      */
     function findMin($nums) {
-        $r=count($nums)-1;
-        $l=0;
-        if($r<0) return -1;
-        $first=$nums[0];
-        if($first==$nums[$r]){//move util the start is not equal to the end any more;
-            while($l<$r && $nums[$l]==$first) $l++;
-            while($l<$r && $nums[$r]==$first) $r--;
+        $r = count($nums) - 1;
+        $l = 0;
+        if ($r < 0) return -1;
+        $first = $nums[0];
+        if ($first == $nums[$r]) {//move util the start is not equal to the end any more;
+            while ($l < $r && $nums[$l] == $first) $l++;
+            while ($l < $r && $nums[$r] == $first) $r--;
         }
-        if($nums[$l]<=$nums[$r]){ //deal with the ascending condition.
-            return $nums[$l]<$first?$nums[$l]:$first;
+        if ($nums[$l] <= $nums[$r]) { //deal with the ascending condition.
+            return $nums[$l] < $first ? $nums[$l] : $first;
         }
-        while($l<$r-1){//now we are bold to handle it as there must be a steep and the minimum is the right one. 
-            $m=intval($l+($r-$l)/2);
-            if($nums[$m]>=$nums[$l]) $l=$m;
-            else $r=$m;
+        while ($l < $r - 1) {//now we are bold to handle it as there must be a steep and the minimum is the right one.
+            $m = intval($l + ($r - $l) / 2);
+            if ($nums[$m] >= $nums[$l]) $l = $m;
+            else $r = $m;
         }
         return $nums[$r];
     }
diff --git a/src/Algorithms/s0162_find_peak_element/Solution.php b/src/Algorithms/s0162_find_peak_element/Solution.php
index 62a9dbf..489eea8 100644
--- a/src/Algorithms/s0162_find_peak_element/Solution.php
+++ b/src/Algorithms/s0162_find_peak_element/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -5,16 +7,16 @@ class Solution {
      * @return Integer
      */
     function findPeakElement($nums) {
-        if($nums==null||count($nums)<=1)return 0;
-        
-        if(count($nums)>=2){
-            if($nums[count($nums)-1]>$nums[count($nums)-2])return count($nums)-1;
+        if ($nums == null || count($nums) <= 1) return 0;
+
+        if (count($nums) >= 2) {
+            if ($nums[count($nums) - 1] > $nums[count($nums) - 2]) return count($nums) - 1;
         }
-        
-        for($i=1;$i<count($nums)-1;$i++){
-            if($nums[$i]>$nums[$i-1]&&$nums[$i]>$nums[$i+1])return $i;
+
+        for ($i = 1; $i < count($nums) - 1; $i++) {
+            if ($nums[$i] > $nums[$i - 1] && $nums[$i] > $nums[$i + 1]) return $i;
         }
-        
+
         return 0;
     }
 }
diff --git a/src/Algorithms/s0164_maximum_gap/Solution.php b/src/Algorithms/s0164_maximum_gap/Solution.php
index 5a7bb82..2639b37 100644
--- a/src/Algorithms/s0164_maximum_gap/Solution.php
+++ b/src/Algorithms/s0164_maximum_gap/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Bucket {
     var $leftClose;
     var $rightOpen;
@@ -17,7 +19,7 @@ class Solution {
      * @return Integer
      */
     function maximumGap($nums) {
-        if ($nums==null || count($nums)<2) {
+        if ($nums == null || count($nums) < 2) {
             return 0;
         }
 
@@ -25,16 +27,16 @@ function maximumGap($nums) {
         $max = $nums[0];
         $min = $nums[0];
         foreach ($nums as $num) {
-            $max = $max<$num ? $num : $max;
-            $min = $min>$num ? $num : $min;
+            $max = $max < $num ? $num : $max;
+            $min = $min > $num ? $num : $min;
         }
 
         // the size of bucket must > 1
         $bucketSize = intval(max(1, ($max - $min) / (count($nums) - 1)));
-        $bucketNum = intval(($max-$min) / $bucketSize + 1);
+        $bucketNum = intval(($max - $min) / $bucketSize + 1);
 
         $buckets = array_fill(0, $bucketNum, null);
-        for ($i=0; $i<count($buckets); $i++) {
+        for ($i = 0; $i < count($buckets); $i++) {
             $buckets[$i] = new Bucket();
         }
 
@@ -54,11 +56,11 @@ function maximumGap($nums) {
 
         $maxGap = 0;
         $preRightOpen = $buckets[0]->rightOpen;
-        for ($i=1; $i<count($buckets); $i++) {
+        for ($i = 1; $i < count($buckets); $i++) {
             if ($buckets[$i]->usedFlag == false) {
                 continue;
             }
-            $maxGap = max($maxGap, $buckets[$i]->leftClose-$preRightOpen);
+            $maxGap = max($maxGap, $buckets[$i]->leftClose - $preRightOpen);
             $preRightOpen = $buckets[$i]->rightOpen;
         }
 
diff --git a/src/Algorithms/s0165_compare_version_numbers/Solution.php b/src/Algorithms/s0165_compare_version_numbers/Solution.php
index 5937ef3..5fcf5f3 100644
--- a/src/Algorithms/s0165_compare_version_numbers/Solution.php
+++ b/src/Algorithms/s0165_compare_version_numbers/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -6,7 +8,10 @@ class Solution {
      * @return Integer
      */
     function compareVersion($v1, $v2) {
-        $i1 = 0; $i2 = 0; $n1 = 0; $n2 = 0;
+        $i1 = 0;
+        $i2 = 0;
+        $n1 = 0;
+        $n2 = 0;
         while ($i1 < strlen($v1) || $i2 < strlen($v2)) {
             while ($i1 < strlen($v1) && $v1[$i1] != '.') {
                 $n1 = $n1 * 10 + ord($v1[$i1++]) - ord('0');
@@ -17,7 +22,8 @@ function compareVersion($v1, $v2) {
             if ($n1 > $n2) return 1;
             if ($n1 < $n2) return -1;
             $n1 = $n2 = 0;
-            $i1++; $i2++;
+            $i1++;
+            $i2++;
         }
         return 0;
     }
diff --git a/src/Algorithms/s0166_fraction_to_recurring_decimal/Solution.php b/src/Algorithms/s0166_fraction_to_recurring_decimal/Solution.php
index 77427f6..544772e 100644
--- a/src/Algorithms/s0166_fraction_to_recurring_decimal/Solution.php
+++ b/src/Algorithms/s0166_fraction_to_recurring_decimal/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -7,52 +9,52 @@ class Solution {
      */
     function fractionToDecimal($num1, $deno1) {
         $neg = $num1 > 0 && $deno1 < 0 || $num1 < 0 && $deno1 > 0;
-        $ret = $neg ? "-":"";
+        $ret = $neg ? "-" : "";
         $num = abs($num1);
         $deno = abs($deno1);
-        
-        
-        $p1 = intval($num/$deno);
-        $remain = $num%$deno;
-        if($remain == 0) return $ret . $p1;
-        
+
+
+        $p1 = intval($num / $deno);
+        $remain = $num % $deno;
+        if ($remain == 0) return $ret . $p1;
+
         $map = [];
         $sb = "";
-        
+
         $start = -1;
         $end = -1;
-        $map[$remain] =  0;
+        $map[$remain] = 0;
         echo($sb);
-        while($remain != 0) {
+        while ($remain != 0) {
             $remain *= 10;
-            while($remain < $deno) {
+            while ($remain < $deno) {
                 $sb .= '0';
                 $map[$remain] = strlen($sb);
                 $remain *= 10;
             }
-            
-            $res = intval($remain/$deno);
+
+            $res = intval($remain / $deno);
             $sb = $sb . chr($res + ord('0'));
-            
+
             $remain %= $deno;
-            if($remain == 0) break;
-            
+            if ($remain == 0) break;
+
             $len = strlen($sb);
-            if(array_key_exists($remain, $map)) {
+            if (array_key_exists($remain, $map)) {
                 $start = $map[$remain];
                 break;
             } else {
                 $map[$remain] = $len;
             }
         }
-        
+
         $ret = $ret . $p1 . ".";
-        if($start == -1) {
+        if ($start == -1) {
             $ret .= $sb;
         } else {
             $ret = $ret . substr($sb, 0, $start) . "(" . substr($sb, $start) . ")";
         }
-        
+
         return $ret;
     }
 }
diff --git a/src/Algorithms/s0167_two_sum_ii_input_array_is_sorted/Solution.php b/src/Algorithms/s0167_two_sum_ii_input_array_is_sorted/Solution.php
index 5828702..46508aa 100644
--- a/src/Algorithms/s0167_two_sum_ii_input_array_is_sorted/Solution.php
+++ b/src/Algorithms/s0167_two_sum_ii_input_array_is_sorted/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -6,14 +8,14 @@ class Solution {
      * @return Integer[]
      */
     function twoSum($numbers, $target) {
-        $res=array_fill(0, 2, 0);
-        for ($i=0,$j=count($numbers)-1;$i<$j;){
-            $sum = $numbers[$i]+$numbers[$j];
-            if ($sum==$target){
-                $res[0]=$i+1; $res[1]=$j+1;
+        $res = array_fill(0, 2, 0);
+        for ($i = 0, $j = count($numbers) - 1; $i < $j;) {
+            $sum = $numbers[$i] + $numbers[$j];
+            if ($sum == $target) {
+                $res[0] = $i + 1;
+                $res[1] = $j + 1;
                 return $res;
-            }
-            else if ($sum<$target)$i++;
+            } else if ($sum < $target) $i++;
             else $j--;
         }
         return $res;
diff --git a/src/Algorithms/s0168_excel_sheet_column_title/Solution.php b/src/Algorithms/s0168_excel_sheet_column_title/Solution.php
index 6cc274b..09ab6f7 100644
--- a/src/Algorithms/s0168_excel_sheet_column_title/Solution.php
+++ b/src/Algorithms/s0168_excel_sheet_column_title/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -5,9 +7,9 @@ class Solution {
      * @return String
      */
     function convertToTitle($n) {
-        $mapping = ['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'];
+        $mapping = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'];
         $sb = "";
-        while($n > 0) {
+        while ($n > 0) {
             $sb .= $mapping [--$n % 26]; //Since for a base 26 the numbers would be from 0 to 25. Deducting 1
             $n = intval($n / 26);
         }
diff --git a/src/Algorithms/s0169_majority_element/Solution.php b/src/Algorithms/s0169_majority_element/Solution.php
index 3ea48be..ca7e4d1 100644
--- a/src/Algorithms/s0169_majority_element/Solution.php
+++ b/src/Algorithms/s0169_majority_element/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -6,6 +8,6 @@ class Solution {
      */
     function majorityElement($nums) {
         sort($nums);
-        return $nums[intval(count($nums)/2)];
+        return $nums[intval(count($nums) / 2)];
     }
 }
diff --git a/src/Algorithms/s0171_excel_sheet_column_number/Solution.php b/src/Algorithms/s0171_excel_sheet_column_number/Solution.php
index dba97dc..d9390f4 100644
--- a/src/Algorithms/s0171_excel_sheet_column_number/Solution.php
+++ b/src/Algorithms/s0171_excel_sheet_column_number/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -5,14 +7,13 @@ class Solution {
      * @return Integer
      */
     function titleToNumber($s) {
-        $len=strlen($s);
-        $jinzhi=1;
-        $sum=0;
-        for($i=$len-1;$i>=0;$i--)
-        {
-            
-            $sum=$sum+(ord($s[$i])-64)*$jinzhi;
-            $jinzhi=$jinzhi*26;
+        $len = strlen($s);
+        $jinzhi = 1;
+        $sum = 0;
+        for ($i = $len - 1; $i >= 0; $i--) {
+
+            $sum = $sum + (ord($s[$i]) - 64) * $jinzhi;
+            $jinzhi = $jinzhi * 26;
         }
         return $sum;
     }
diff --git a/src/Algorithms/s0172_factorial_trailing_zeroes/Solution.php b/src/Algorithms/s0172_factorial_trailing_zeroes/Solution.php
index a760e87..e6f22b7 100644
--- a/src/Algorithms/s0172_factorial_trailing_zeroes/Solution.php
+++ b/src/Algorithms/s0172_factorial_trailing_zeroes/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -6,7 +8,7 @@ class Solution {
      */
     function trailingZeroes($n) {
         $res = 0;
-        while($n >= 5){
+        while ($n >= 5) {
             $n = intval($n / 5);
             $res += $n;
         }
diff --git a/src/Algorithms/s0174_dungeon_game/Solution.php b/src/Algorithms/s0174_dungeon_game/Solution.php
index 41a495c..efaee94 100644
--- a/src/Algorithms/s0174_dungeon_game/Solution.php
+++ b/src/Algorithms/s0174_dungeon_game/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     private $dp;
@@ -11,23 +13,23 @@ function calculateMinimumHP(&$dungeon) {
         $dp = array_fill(0, count($dungeon), array_fill(0, count($dungeon[0]), 0));
         $visited = array_fill(0, count($dungeon), array_fill(0, count($dungeon[0]), false));
         $val = self::solve($dungeon, 0, 0);
-        return $val >= 1 ? 1 : 1-$val;
+        return $val >= 1 ? 1 : 1 - $val;
     }
-    
+
     function solve(&$dungeon, $i, $j) {
-        if($i == count($dungeon)-1 && $j == count($dungeon[0])-1) return $dungeon[$i][$j];
-        if($i == count($dungeon)) return -2147483647;
-        if($j == count($dungeon[0])) return -2147483647;
-        
-        if($visited[$i][$j]) {
+        if ($i == count($dungeon) - 1 && $j == count($dungeon[0]) - 1) return $dungeon[$i][$j];
+        if ($i == count($dungeon)) return -2147483647;
+        if ($j == count($dungeon[0])) return -2147483647;
+
+        if ($visited[$i][$j]) {
             return $dp[$i][$j];
         }
-        
-        $val = min($dungeon[$i][$j] + max(self::solve($dungeon, $i+1, $j), self::solve($dungeon, $i, $j+1)), $dungeon[$i][$j]);
-        
+
+        $val = min($dungeon[$i][$j] + max(self::solve($dungeon, $i + 1, $j), self::solve($dungeon, $i, $j + 1)), $dungeon[$i][$j]);
+
         $dp[$i][$j] = $val;
         $visited[$i][$j] = true;
-        
+
         return $val;
     }
 }
diff --git a/src/Algorithms/s0179_largest_number/Solution.php b/src/Algorithms/s0179_largest_number/Solution.php
index 13efc70..036894c 100644
--- a/src/Algorithms/s0179_largest_number/Solution.php
+++ b/src/Algorithms/s0179_largest_number/Solution.php
@@ -1,32 +1,34 @@
+<?php
+
 class Solution {
 
     function cmp($str1, $str2) {
-         $s1 = $str1 . $str2;
-         $s2 = $str2 . $str1;
-         return strcmp($s2, $s1);       
+        $s1 = $str1 . $str2;
+        $s2 = $str2 . $str1;
+        return strcmp($s2, $s1);
     }
-    
+
     /**
      * @param Integer[] $nums
      * @return String
      */
     function largestNumber($nums) {
         $strs = array_fill(0, count($nums), "");
-         for ($i=0; $i<count($nums); $i++) {
-             $strs[$i] = "" . $nums[$i];
-         }
+        for ($i = 0; $i < count($nums); $i++) {
+            $strs[$i] = "" . $nums[$i];
+        }
 
-         usort($strs, 'self::cmp');
+        usort($strs, 'self::cmp');
 
-         if ($strs[0] == "0") {
-             return "0";
-         }
+        if ($strs[0] == "0") {
+            return "0";
+        }
 
-         $sb = "";
-         foreach ($strs as $str) {
-             $sb .= $str;
-         }
+        $sb = "";
+        foreach ($strs as $str) {
+            $sb .= $str;
+        }
 
-         return $sb;
+        return $sb;
     }
 }
diff --git a/src/Algorithms/s0771_jewels_and_stones/Solution.php b/src/Algorithms/s0771_jewels_and_stones/Solution.php
index 6f274cf..418c5e2 100644
--- a/src/Algorithms/s0771_jewels_and_stones/Solution.php
+++ b/src/Algorithms/s0771_jewels_and_stones/Solution.php
@@ -1,13 +1,15 @@
+<?php
+
 class Solution {
 
     /**
-    * @param String $jewels
-    * @param String $stones
-    * @return Integer
-    */
+     * @param String $jewels
+     * @param String $stones
+     * @return Integer
+     */
     function numJewelsInStones($jewels, $stones) {
         $jewelsArr = str_split($jewels);
-        foreach($jewelsArr as $jewel) {
+        foreach ($jewelsArr as $jewel) {
             $b += substr_count($stones, $jewel);
         }
         return $b;
diff --git a/src/Algorithms/s0864_shortest_path_to_get_all_keys/Solution.php b/src/Algorithms/s0864_shortest_path_to_get_all_keys/Solution.php
index cb39330..c5ace22 100644
--- a/src/Algorithms/s0864_shortest_path_to_get_all_keys/Solution.php
+++ b/src/Algorithms/s0864_shortest_path_to_get_all_keys/Solution.php
@@ -1,7 +1,10 @@
+<?php
+
 class Status {
     var $key;
     var $i;
     var $j;
+
     function __construct($key, $i, $j) {
         $this->key = $key;
         $this->i = $i;
@@ -27,7 +30,7 @@ function shortestPathAllKeys($grid) {
                 if ($c >= 'A' && $c <= 'F') {
                     $success |= 1 << (ord($c) - ord('A'));
                 }
-                
+
                 if ($c == '@') {
                     $startI = $i;
                     $startJ = $j;
@@ -57,11 +60,11 @@ function shortestPathAllKeys($grid) {
                         if ($c >= 'a' && $c <= 'f') {
                             $nextKey = $key | (1 << (ord($c) - ord('a')));
                         }
-                        
+
                         if ($c >= 'A' && $c <= 'F') {
                             if (($nextKey & (1 << (ord($c) - ord('A')))) == 0) continue;
                         }
-                        
+
                         if ($path + 1 < $dist[$nextKey][$xx][$yy]) {
                             $dist[$nextKey][$xx][$yy] = $path + 1;
                             array_unshift($queue, new Status($nextKey, $xx, $yy));
diff --git a/src/Algorithms/s0973_k_closest_points_to_origin/Solution.php b/src/Algorithms/s0973_k_closest_points_to_origin/Solution.php
index 695fc82..a1bad58 100644
--- a/src/Algorithms/s0973_k_closest_points_to_origin/Solution.php
+++ b/src/Algorithms/s0973_k_closest_points_to_origin/Solution.php
@@ -1,3 +1,5 @@
+<?php
+
 class Solution {
 
     /**
@@ -6,56 +8,55 @@ class Solution {
      * @return Integer[][]
      */
     function kClosest($points, $K) {
-    if ($points == null || count($points) == 0 || $K == 0) {
-      throw new Exception("Input should not be empty");
+        if ($points == null || count($points) == 0 || $K == 0) {
+            throw new Exception("Input should not be empty");
+        }
+        self::quickSelect($points, $K, 0, count($points) - 1);
+        return array_slice($points, 0, $K);
     }
-    self::quickSelect($points, $K, 0, count($points) - 1);
-    return array_slice($points, 0, $K);
-  }
 
-  function quickSelect(&$points, $K, $low, $high) {
-    $partition = self::partition($points, $low, $high);
-    if ($partition == $K || $partition == $K - 1) {
-      // If the location is K after partition, the points before it can be used;
-      // If the location is K-1, the points before it plus itself can be used.
-      return;
-    } else if ($partition < $K - 1) {
-      self::quickSelect($points, $K,$partition + 1, $high);
-    }
-    else {
-      self::quickSelect($points, $K, $low, $partition - 1);
+    function quickSelect(&$points, $K, $low, $high) {
+        $partition = self::partition($points, $low, $high);
+        if ($partition == $K || $partition == $K - 1) {
+            // If the location is K after partition, the points before it can be used;
+            // If the location is K-1, the points before it plus itself can be used.
+            return;
+        } else if ($partition < $K - 1) {
+            self::quickSelect($points, $K, $partition + 1, $high);
+        } else {
+            self::quickSelect($points, $K, $low, $partition - 1);
+        }
     }
-  }
 
-  /**
-   * The low is smaller
-   * @param points
-   * @param low
-   * @param high
-   * @@return The index that points are closer before it, and points are further after it.
-   */
-  function partition(&$points, $low, $high) {
-    $pivotPoint = $points[$high];
-    $partitionIndex = $low;
+    /**
+     * The low is smaller
+     * @param points
+     * @param low
+     * @param high
+     * @@return The index that points are closer before it, and points are further after it.
+     */
+    function partition(&$points, $low, $high) {
+        $pivotPoint = $points[$high];
+        $partitionIndex = $low;
 
-    for ($i = $low; $i < $high; $i++) {
-      if (self::compare($points[$i], $pivotPoint) <= 0) {
-        self::swap($points, $i, $partitionIndex);
-        $partitionIndex++;
-      }
+        for ($i = $low; $i < $high; $i++) {
+            if (self::compare($points[$i], $pivotPoint) <= 0) {
+                self::swap($points, $i, $partitionIndex);
+                $partitionIndex++;
+            }
+        }
+        self::swap($points, $partitionIndex, $high);
+        return $partitionIndex;
     }
-    self::swap($points, $partitionIndex, $high);
-    return $partitionIndex;
-  }
 
-  function compare($point1, $point2) {
-    return $point1[0] * $point1[0] + $point1[1] * $point1[1] -
-        $point2[0] * $point2[0] - $point2[1] * $point2[1];
-  }
+    function compare($point1, $point2) {
+        return $point1[0] * $point1[0] + $point1[1] * $point1[1] -
+            $point2[0] * $point2[0] - $point2[1] * $point2[1];
+    }
 
-  function swap(&$points, $location1, $location2) {
-    $tempPoint = $points[$location1];
-    $points[$location1] = $points[$location2];
-    $points[$location2] = $tempPoint;
-  }
+    function swap(&$points, $location1, $location2) {
+        $tempPoint = $points[$location1];
+        $points[$location1] = $points[$location2];
+        $points[$location2] = $tempPoint;
+    }
 }