├── .github
    └── workflows
    │   └── php.yml
├── .gitignore
├── ArrayProblems
    ├── MergeIntervals.php
    ├── MergeSortedArray.php
    ├── MoveZeroes.php
    ├── RemoveElement.php
    ├── ThreeSum.php
    └── TwoSum.php
├── Heap
    ├── KthLargestElementInAStream.php
    ├── KthLargestElementInAnArray.php
    ├── MedianStream.php
    └── TopKFrequentElements.php
├── LICENSE.md
├── LinkedList
    ├── ListNode.php
    ├── MergedToSortedList.php
    ├── ReOrderList.php
    ├── RemoveNthNodeFromEndOfList.php
    ├── ReverseLinkedList.php
    └── ReverseLinkedListII.php
├── README.md
├── SqlProblems
    ├── CustomersWhoNeverOrder.sql
    ├── DepartmentTopThreeSalaries.sql
    ├── FriendRequestsOverallAcceptanceRate.sql
    ├── FriendRequestsWhoHasTheMostFriends.sql
    ├── NthHighestSalary.sql
    └── SecondHighestSalary.sql
├── String
    ├── FindAllAnagramsInAString.php
    ├── GroupAnagrams.php
    ├── LongestSubstringWithAtMostKDistinctCharacters.php
    ├── LongestSubstringWithAtMostTwoDistinctCharacters.php
    ├── LongestSubstringWithoutRepeatingCharacters.php
    ├── RemoveAllAdjacentDuplicatesInString.php
    ├── RemoveAllAdjacentDuplicatesInStringII.php
    ├── RomanToInteger.php
    ├── StringToInteger.php
    ├── ValidPalindrome.php
    └── ValidPalindromeII.php
├── Tests
    ├── ArrayProblems
    │   ├── IntegerToEnglishWordsTest.php
    │   ├── MergeIntervalsTest.php
    │   ├── MergeSortedArrayTest.php
    │   ├── MoveZeroesTest.php
    │   ├── RemoveElementTest.php
    │   ├── ThreeSumTest.php
    │   └── TwoSumTest.php
    ├── Heap
    │   ├── KthLargestElementInAStreamTest.php
    │   ├── KthLargestElementInAnArrayTest.php
    │   ├── MedianStreamTest.php
    │   └── TopKFrequentElementsTest.php
    ├── Helper
    │   ├── InputFiles
    │   │   ├── BinaryTreeLevelOrderTraversalTest.json
    │   │   ├── BinaryTreePathsTest.json
    │   │   ├── BinaryTreePostorderTraversalTest.json
    │   │   ├── BinaryTreePreorderTraversalTest.json
    │   │   ├── BinaryTreeRightSideViewTest.json
    │   │   ├── BinaryTreeVerticalOrderTraversalTest.json
    │   │   ├── ConstructBinaryTreeFromInorderAndPostorderTraversalTest.json
    │   │   ├── ConstructBinaryTreeFromInorderAndPreorderTraversalTest.json
    │   │   ├── ConvertSortedArrayToBinarySearchTreeTest.json
    │   │   ├── CountUniValueSubtreesTest.json
    │   │   ├── DiameterOfBinaryTreeTest.json
    │   │   ├── FindAllAnagramsInAStringTest.json
    │   │   ├── FlattenBinaryTreeToLinkedListTest.json
    │   │   ├── GroupAnagramsTest.json
    │   │   ├── IntegerToEnglishWordsTest.json
    │   │   ├── KthLargestElementInAStreamTest.json
    │   │   ├── KthLargestElementInAnArrayTest.json
    │   │   ├── LongestSubstringWithAtMostKDistinctCharactersTest.json
    │   │   ├── LongestSubstringWithAtMostTwoDistinctCharactersTest.json
    │   │   ├── LongestSubstringWithoutRepeatingCharactersTest.json
    │   │   ├── MaximumDepthOfBinaryTreeTest.json
    │   │   ├── MedianStreamTest.json
    │   │   ├── MergeIntervalsTest.json
    │   │   ├── MergeSortedArrayTest.json
    │   │   ├── MergedToSortedListTest.json
    │   │   ├── MoveZeroesTest.json
    │   │   ├── PathSumTest.json
    │   │   ├── ReOrderListTest.json
    │   │   ├── RemoveAllAdjacentDuplicatesInStringIITest.json
    │   │   ├── RemoveAllAdjacentDuplicatesInStringTest.json
    │   │   ├── RemoveElementTest.json
    │   │   ├── RemoveNthNodeFromEndOfListTest.json
    │   │   ├── ReverseLinkedListIITest.json
    │   │   ├── ReverseLinkedListTest.json
    │   │   ├── RomanToIntTest.json
    │   │   ├── SameTreeTest.json
    │   │   ├── StringToIntegerTest.json
    │   │   ├── SymmetricTreeTest.json
    │   │   ├── ThreeSumTest.json
    │   │   ├── TopKFrequentElementsTest.json
    │   │   ├── TwoSumTest.json
    │   │   ├── ValidPalindromeIITest.json
    │   │   ├── ValidPalindromeTest.json
    │   │   └── ValidateBinarySearchTreeTest.json
    │   ├── LinkedListHelperTrait.php
    │   ├── MainTest.php
    │   └── TreeHelperTrait.php
    ├── LinkedList
    │   ├── ListNodeTest.php
    │   ├── MergedToSortedListTest.php
    │   ├── ReOrderListTest.php
    │   ├── RemoveNthNodeFromEndOfListTest.php
    │   ├── ReverseLinkedListIITest.php
    │   └── ReverseLinkedListTest.php
    ├── String
    │   ├── FindAllAnagramsInAStringTest.php
    │   ├── GroupAnagramsTest.php
    │   ├── LongestSubstringWithAtMostKDistinctCharactersTest.php
    │   ├── LongestSubstringWithAtMostTwoDistinctCharactersTest.php
    │   ├── LongestSubstringWithoutRepeatingCharactersTest.php
    │   ├── RemoveAllAdjacentDuplicatesInStringTest.php
    │   ├── RomanToIntTest.php
    │   ├── StringToIntegerTest.php
    │   ├── ValidPalindromeIITest.php
    │   └── ValidPalindromeTest.php
    └── Tree
    │   ├── BinaryTreeLevelOrderTraversalTest.php
    │   ├── BinaryTreePathsTest.php
    │   ├── BinaryTreePostorderTraversalTest.php
    │   ├── BinaryTreePreorderTraversalTest.php
    │   ├── BinaryTreeRightSideViewTest.php
    │   ├── BinaryTreeVerticalOrderTraversalTest.php
    │   ├── ConvertSortedArrayToBinarySearchTreeTest.php
    │   ├── CountUniValueSubtreesTest.php
    │   ├── DiameterOfBinaryTreeTest.php
    │   ├── FlattenBinaryTreeToLinkedListTest.php
    │   ├── MaximumDepthOfBinaryTreeTest.php
    │   ├── PathSumTest.php
    │   ├── SameTreeTest.php
    │   ├── SymmetricTreeTest.php
    │   ├── TreeNodeTest.php
    │   └── ValidateBinarySearchTreeTest.php
├── Tree
    ├── BinaryTreeLevelOrderTraversal.php
    ├── BinaryTreePaths.php
    ├── BinaryTreePostorderTraversal.php
    ├── BinaryTreePreorderTraversal.php
    ├── BinaryTreeRightSideView.php
    ├── BinaryTreeVerticalOrderTraversal.php
    ├── ConvertBinarySearchTreeToSortedDoublyLinkedList.php
    ├── ConvertSortedArrayToBinarySearchTree.php
    ├── CountUniValueSubtrees.php
    ├── DiameterOfBinaryTree.php
    ├── FlattenBinaryTreeToLinkedList.php
    ├── IntegerToEnglishWords.php
    ├── MaximumDepthOfBinaryTree.php
    ├── PathSum.php
    ├── SameTree.php
    ├── SymmetricTree.php
    ├── TreeNode.php
    └── ValidateBinarySearchTree.php
├── clover.xml
├── composer.json
├── composer.lock
└── phpunit.xml


/.github/workflows/php.yml:
--------------------------------------------------------------------------------
 1 | name: Build
 2 | 
 3 | on:
 4 |   push:
 5 |     branches: [ main ]
 6 |   pull_request:
 7 |     branches: [ main ]
 8 | 
 9 | jobs:
10 |   build:
11 | 
12 |     runs-on: ubuntu-latest
13 | 
14 |     steps:
15 |       - uses: actions/checkout@v2
16 | 
17 |       - name: Validate composer.json and composer.lock
18 |         run: composer validate --strict
19 | 
20 |       - name: Cache Composer packages
21 |         id: composer-cache
22 |         uses: actions/cache@v2
23 |         with:
24 |           path: vendor
25 |           key: ${{ runner.os }}-php-${{ hashFiles('**/composer.lock') }}
26 |           restore-keys: |
27 |             ${{ runner.os }}-php-
28 | 
29 |       - name: Install dependencies
30 |         run: composer install --prefer-dist --no-progress
31 | 
32 |       - name: Run test suite
33 |         run: vendor/bin/phpunit
34 | 
35 |       - name: phpunit-coverage-badge
36 |         uses: timkrase/phpunit-coverage-badge@v1.2.0
37 | 
38 | 
39 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | /vendor/
2 | .idea
3 | .phpunit.result.cache
4 | 


--------------------------------------------------------------------------------
/ArrayProblems/MergeIntervals.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\ArrayProblems;
 4 | 
 5 | /**
 6 |  * LeetCode Problem Link : https://leetcode.com/problems/merge-intervals
 7 |  */
 8 | class MergeIntervals
 9 | {
10 |     /**
11 |      * @param Integer[][] $intervals
12 |      * @return Integer[][]
13 |      */
14 |     public function merge(array $intervals): array
15 |     {
16 |         usort($intervals,function($i,$j){
17 |             if($i[0] === $j[0])
18 |             {
19 |                 return 0;
20 |             }
21 |             return $i[0]<$j[0]? -1:1;
22 |         });
23 |         $list = [];
24 |         foreach($intervals as $interval)
25 |         {
26 |             if(count($list) === 0|| end($list)[1]<$interval[0])
27 |             {
28 |                 $list [] = $interval;
29 |             }
30 |             else {
31 |                 $newInterval = array_pop($list);
32 |                 $newInterval[1] =  max($newInterval[1],$interval[1]);
33 |                 $list [] = $newInterval;
34 |             }
35 |         }
36 |         return $list;
37 |     }
38 | }


--------------------------------------------------------------------------------
/ArrayProblems/MergeSortedArray.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\ArrayProblems;
 4 | 
 5 | use SplMinHeap;
 6 | 
 7 | /**
 8 |  * LeetCode Problem Link : https://leetcode.com/problems/merge-sorted-array
 9 |  */
10 | class MergeSortedArray
11 | {
12 |     /**
13 |      * @param Integer[] $nums1
14 |      * @param Integer $m
15 |      * @param Integer[] $nums2
16 |      * @param Integer $n
17 |      * @return void
18 |      */
19 | 
20 |     public function mergeByHeap(array &$nums1, int $m, array $nums2, int $n): void
21 |     {
22 |         $minHeap = new SplMinHeap();
23 |         for ($index = 0; $index < $m + $n; $index++) {
24 |             if ($index <= $m - 1) {
25 |                 $value = $nums1[$index];
26 |             } else {
27 |                 $value = array_shift($nums2);
28 |             }
29 |             $minHeap->insert($value);
30 |         }
31 |         for ($index = 0; $index < $m + $n; $index++) {
32 |             $nums1[$index] = $minHeap->extract();
33 |         }
34 |     }
35 | 
36 |     public function mergeByPointers(&$nums1, $m, $nums2, $n): void
37 |     {
38 |         for ($i = 0; $i < $m; $i++) {
39 |             $nums1Copy[$i] = $nums1[$i];
40 |         }
41 |         $p1 = 0;
42 |         $p2 = 0;
43 |         for ($p = 0; $p < $m + $n; $p++) {
44 |             if (($p1 < $m && $nums1Copy[$p1] <= $nums2[$p2]) || $p2 >= $n) {
45 |                 $nums1[$p] = $nums1Copy[$p1++];
46 |             } else {
47 |                 $nums1[$p] = $nums2[$p2++];
48 |             }
49 |         }
50 |     }
51 | }


--------------------------------------------------------------------------------
/ArrayProblems/MoveZeroes.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\ArrayProblems;
 4 | 
 5 | /**
 6 |  * LeetCode Problem Link : https://leetcode.com/problems/move-zeroes
 7 |  */
 8 | class MoveZeroes
 9 | {
10 |     /**
11 |      * @param Integer[] $nums
12 |      * @return void
13 |      */
14 |     public function moveZeroes(array &$nums): void
15 |     {
16 |         foreach ($nums as $i => $iValue) {
17 |             if ($iValue === 0) {
18 |                 unset($nums[$i]);
19 |                 $nums[] = 0;
20 |             }
21 |         }
22 |     }
23 | }


--------------------------------------------------------------------------------
/ArrayProblems/RemoveElement.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\ArrayProblems;
 4 | 
 5 | /**
 6 |  * LeetCode Problem Link : https://leetcode.com/problems/remove-element
 7 |  */
 8 | class RemoveElement
 9 | {
10 |     /**
11 |      * @param Integer[] $nums
12 |      * @param Integer $val
13 |      * @return Integer
14 |      */
15 |     public function removeElement(array &$nums, int $val): int
16 |     {
17 |         $count = count($nums);
18 |         for($index = 0; $index<$count;$index ++)
19 |         {
20 |             if ($nums[$index] === $val) {
21 |                 $nums[$index--] = $nums[--$count];
22 |             }
23 |         }
24 |         return $count;
25 |     }
26 | }


--------------------------------------------------------------------------------
/ArrayProblems/ThreeSum.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\ArrayProblems;
 4 | 
 5 | /**
 6 |  * LeetCode Problem Link: https://leetcode.com/problems/3sum
 7 |  */
 8 | class ThreeSum
 9 | {
10 |     /**
11 |      * @param Integer[] $nums
12 |      * @return Integer[][]
13 |      */
14 |     public function threeSum(array $nums): array
15 |     {
16 |         sort($nums);
17 |         $count = count($nums);
18 |         $listOf3Sum = [];
19 |         for ($index = 0; $index < $count; $index++) {
20 |             $number = $nums[$index];
21 |             if ($index > 0 && $number === $nums[$index - 1]) {
22 |                 continue;
23 |             }
24 |             $leftPointer = $index + 1;
25 |             $rightPointer = count($nums) - 1;
26 |             while ($leftPointer < $rightPointer) {
27 |                 $threeSum = $number + $nums[$leftPointer] + $nums[$rightPointer];
28 |                 if ($threeSum > 0) {
29 |                     --$rightPointer;
30 |                 } elseif ($threeSum < 0) {
31 |                     ++$leftPointer;
32 |                 } else {
33 |                     $listOf3Sum [] = [$number, $nums[$leftPointer], $nums[$rightPointer]];
34 |                     ++$leftPointer;
35 |                     while (isset($nums[$leftPointer], $nums[$leftPointer - 1]) && $nums[$leftPointer] === $nums[$leftPointer - 1]) {
36 |                         ++$leftPointer;
37 |                     }
38 |                 }
39 |             }
40 |         }
41 |         return $listOf3Sum;
42 |     }
43 | }


--------------------------------------------------------------------------------
/ArrayProblems/TwoSum.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\ArrayProblems;
 4 | 
 5 | /**
 6 |  * LeetCode Problem Link: https://leetcode.com/problems/two-sum
 7 |  */
 8 | class TwoSum
 9 | {
10 |     /**
11 |      * @param Integer[] $nums
12 |      * @param Integer $target
13 |      * @return Integer[]
14 |      */
15 |     public function twoSum(array $nums, int $target): array
16 |     {
17 |        $hashList = [];
18 |        foreach ($nums as $key => $num)
19 |        {
20 |            if(isset($hashList[$target-$num]) && $hashList[$target-$num] !== $key)
21 |            {
22 |                return [$key,$hashList[$target-$num]];
23 |            }
24 |                $hashList[$num] =$key;
25 |        }
26 |        return  [];
27 |     }
28 | }


--------------------------------------------------------------------------------
/Heap/KthLargestElementInAStream.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Heap;
 4 | 
 5 | use SplMinHeap;
 6 | 
 7 | class KthLargestElementInAStream
 8 | {
 9 |     /**
10 |      * @param Integer $k
11 |      * @param Integer[] $nums
12 |      */
13 |     private SplMinHeap $minHeap;
14 |     private int $kTh;
15 | 
16 |     public function __construct($k, $nums)
17 |     {
18 |         $this->kTh = $k;
19 |         $this->minHeap = new SplMinHeap();
20 |         if ($k < count($nums)) {
21 | 
22 |             for ($index = 0; $index < $k; $index++) {
23 |                 $this->minHeap->insert($nums[$index]);
24 |             }
25 |             for ($index = $k, $indexMax = count($nums); $index < $indexMax; $index++) {
26 |                 $this->add($nums[$index]);
27 |             }
28 |         } else {
29 |             for ($index = 0, $indexMax = count($nums); $index < $indexMax; $index++) {
30 |                 $this->add($nums[$index]);
31 |             }
32 |         }
33 | 
34 |     }
35 | 
36 |     /**
37 |      * @param Integer $val
38 |      * @return Integer
39 |      */
40 |     public function add(int $val): int
41 |     {
42 |         if ($this->minHeap->count() < $this->kTh) {
43 |             $this->minHeap->insert($val);
44 |         } elseif ($val > $this->minHeap->top()) {
45 |             $this->minHeap->extract();
46 |             $this->minHeap->insert($val);
47 |         }
48 |         return $this->minHeap->top();
49 |     }
50 | }


--------------------------------------------------------------------------------
/Heap/KthLargestElementInAnArray.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Heap;
 4 | 
 5 | use SplMinHeap;
 6 | 
 7 | class KthLargestElementInAnArray
 8 | {
 9 | 
10 |     public function findKthLargest($nums, $k)
11 |     {
12 |         $minHeap = new SplMinHeap();
13 |         for ($index = 0; $index < $k; $index++) {
14 |             $minHeap->insert($nums[$index]);
15 |         }
16 | 
17 |         for ($index = $k, $indexMax = count($nums); $index < $indexMax; $index++) {
18 |             if ($nums[$index] <= $minHeap->top()) {
19 |                 continue;
20 |             }
21 |             $minHeap->extract();
22 |             $minHeap->insert($nums[$index]);
23 |         }
24 |         return $minHeap->top();
25 |     }
26 | }


--------------------------------------------------------------------------------
/Heap/MedianStream.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Heap;
 4 | 
 5 | use SplMinHeap;
 6 | 
 7 | class MedianStream
 8 | {
 9 |     public function findMedian($arr): array
10 |     {
11 |         for ($key = 1, $keyMax = count($arr); $key <= $keyMax; $key++) {
12 |             $minHeap = new SplMinHeap();
13 | 
14 |             for ($index = 0; $index < $key; $index++) {
15 | 
16 |                 $minHeap->insert($arr[$index]);
17 |             }
18 | 
19 |             if ($key === 1) {
20 |                 $temp = $minHeap->extract();
21 |                 $maiden [] = $temp;
22 |                 continue;
23 |             }
24 | 
25 |             if ($key === 2) {
26 |                 $temp = floor(($minHeap->extract() + $minHeap->extract()) / 2);
27 |                 $maiden [] = $temp;
28 |                 continue;
29 |             }
30 | 
31 |             if ($key % 2 === 0) {
32 |                 for ($i = 0; $i < ($key / 2) - 1; $i++) {
33 |                     $minHeap->extract();
34 |                 }
35 |                 $temp = floor(($minHeap->extract() + $minHeap->extract()) / 2);
36 |             } else {
37 | 
38 |                 for ($i = 0; $i < floor($key / 2); $i++) {
39 |                     $minHeap->extract();
40 |                 }
41 | 
42 |                 $temp = $minHeap->extract();
43 | 
44 |             }
45 | 
46 |             $maiden [] = $temp;
47 | 
48 |         }
49 |         return $maiden;
50 |     }
51 | }


--------------------------------------------------------------------------------
/Heap/TopKFrequentElements.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Heap;
 4 | 
 5 | use SplPriorityQueue;
 6 | 
 7 | class TopKFrequentElements
 8 | {
 9 |     /**
10 |      * @param Integer[] $nums
11 |      * @param Integer $k
12 |      * @return Integer[]
13 |      */
14 |     function topKFrequent($nums, $k)
15 |     {
16 | 
17 |         $hashMap = [];
18 |         $heap = new PQ();
19 |         foreach ($nums as $num) {
20 |             if(isset($hashMap[$num]))
21 |             {
22 |                 ++$hashMap[$num];
23 |             }
24 |             else {
25 |                 $hashMap[$num]= 1;
26 |             }
27 |         }
28 |         foreach ($hashMap as $key => $value) {
29 |             $heap->insert($key, $value);
30 |             if ($heap->count() > $k) {
31 |             }
32 |         }
33 | 
34 |         while (!$heap->isEmpty()) {
35 |             $list [] = $heap->extract();
36 |         }
37 | 
38 |         return $list;
39 |     }
40 | }
41 | 
42 | class PQ extends SplPriorityQueue
43 | {
44 |     public function compare($priority1, $priority2): int
45 |     {
46 |           if($priority1 === $priority2) {
47 |               return 0;
48 |           }
49 |         return $priority1 < $priority2 ? 1 : -1;
50 |     }
51 | }


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2022 Ramy Hakam
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.


--------------------------------------------------------------------------------
/LinkedList/ListNode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\LinkedList;
 4 | 
 5 | /**
 6 |  * @covers \Hakam\LeetCodePhp\LinkedList\ListNode
 7 |  * @codeCoverageIgnore
 8 |  */
 9 | class ListNode
10 | {
11 |     public int $val = 0;
12 |     public ?ListNode $next = null;
13 | 
14 |     /**
15 |      * @param int $val
16 |      * @param null $next
17 | 
18 |      */
19 |     public function __construct($val = 0, $next = null)
20 |     {
21 |         $this->val = $val;
22 |         $this->next = $next;
23 |     }
24 | }


--------------------------------------------------------------------------------
/LinkedList/MergedToSortedList.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\LinkedList;
 4 | 
 5 | class MergedToSortedList
 6 | {
 7 | 
 8 |     /**
 9 |      * @param ListNode|null $l1
10 |      * @param ListNode|null $l2
11 |      * @return ListNode|null
12 |      */
13 |     function mergeTwoLists(?ListNode $l1, ?ListNode $l2): ?ListNode
14 |     {
15 |         if ($l1 === null) {
16 |             return $l2;
17 |         }
18 |         if ($l2 === null) {
19 |             return $l1;
20 |         }
21 | 
22 |         if ($l1->val < $l2->val) {
23 |             $l1->next = $this->mergeTwoLists($l1->next, $l2);
24 |             return $l1;
25 |         }
26 | 
27 |         $l2->next = $this->mergeTwoLists($l2->next, $l1);
28 |         return $l2;
29 |     }
30 | }


--------------------------------------------------------------------------------
/LinkedList/ReOrderList.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\LinkedList;
 4 | 
 5 | /**
 6 |  * LeetCode Problem Link: https://leetcode.com/problems/reorder-list
 7 |  */
 8 | class ReOrderList
 9 | {
10 |     /**
11 |      * @param ListNode $head
12 |      * @return NULL
13 |      */
14 |     public function reorderList(ListNode $head)
15 |     {
16 |         $arrayList = [];
17 |         $copyHead = $head;
18 |         while ($copyHead !== null) {
19 |             $arrayList [] = $copyHead;
20 |             $copyHead = $copyHead->next;
21 |         }
22 |         $head = new ListNode();
23 |         $order = $head;
24 |         while (!empty($arrayList)) {
25 |             $temp = array_shift($arrayList);
26 |             $tempNext = array_pop($arrayList);
27 |             if ($tempNext !== null) {
28 |                 $tempNext->next = null;
29 |             }
30 |             $temp->next = $tempNext;
31 |             $head->next = $temp;
32 |             $head = $head->next->next;
33 |         }
34 |         return $order->next;
35 |     }
36 | }


--------------------------------------------------------------------------------
/LinkedList/RemoveNthNodeFromEndOfList.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\LinkedList;
 4 | 
 5 | class RemoveNthNodeFromEndOfList
 6 | {
 7 |     /**
 8 |      * @param ListNode $head
 9 |      * @param Integer $n
10 |      * @return ListNode
11 |      */
12 |   public  function removeNthFromEnd(ListNode $head, int $n) : ?ListNode
13 |     {
14 |         $dummy = new ListNode(0);
15 |         $dummy->next = $head;
16 |         $copyHead = $head;
17 |         $length = 0;
18 |         while ($copyHead !== null) {
19 |             $copyHead = $copyHead->next;
20 |             ++$length;
21 |         }
22 |         $length -= $n;
23 |         $copyHead = $dummy;
24 |         while ($length > 0) {
25 |             $length--;
26 |             $copyHead = $copyHead->next;
27 |         }
28 | 
29 |         $copyHead->next = $copyHead->next->next;
30 | 
31 |         return $dummy->next;
32 |     }
33 | }


--------------------------------------------------------------------------------
/LinkedList/ReverseLinkedList.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\LinkedList;
 4 | 
 5 | /**
 6 |  * LeetCode Problem Link : https://leetcode.com/problems/reverse-linked-list
 7 |  */
 8 | class ReverseLinkedList
 9 | {
10 |     public function reverseList(ListNode $node): ?ListNode
11 |     {
12 |         $current = $node;
13 |         $prev = null;
14 |         while ($current !== null) {
15 |             $tempNode = $current->next;
16 |             $current->next = $prev;
17 |             $prev = $current;
18 |             $current = $tempNode;
19 |         }
20 |         return $prev;
21 |     }
22 | }


--------------------------------------------------------------------------------
/LinkedList/ReverseLinkedListII.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\LinkedList;
 4 | /**
 5 |  * LeetCode Problem Link : https://leetcode.com/problems/reverse-linked-list-ii
 6 |  */
 7 | class ReverseLinkedListII
 8 | {
 9 |     /**
10 |      * @param ListNode $head
11 |      * @param Integer $left
12 |      * @param Integer $right
13 |      * @return ListNode
14 |      */
15 |   public  function reverseBetween(ListNode $head, int $left, int $right): ListNode
16 |     {
17 |         $sentinel = new ListNode(0, $head);
18 |         $p1 = $sentinel;
19 | 
20 |         for ($i = 0; $i < $left - 1; $i++) {
21 |             $p1 = $p1->next;
22 |         }
23 | 
24 |         $p2 = $p1->next;
25 |         $p3 = $p2;
26 |         $reverted = null;
27 | 
28 |         for ($i = 0; $i <= ($right - $left); $i++) {
29 |             $tmp = $p2->next;
30 |             $p2->next = $reverted;
31 |             $reverted = $p2;
32 |             $p2 = $tmp;
33 |         }
34 | 
35 |         $p1->next = $reverted;
36 |         $p3->next = $p2;
37 |         return $sentinel->next;
38 |     }
39 | }


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # LeetCode in PHP 😊🤓
 2 | ##  My Solutions with Many different Test Cases Fully in PHP 😍
 3 | 
 4 | ![](https://github.com/RamyHakam/leet-code-php/workflows/Build/badge.svg)
 5 | 
 6 | In this repository you can find my solutions for too many different leet code problems, I will frequently update it to add more solutions and test cases. 👌🚀
 7 | ## Acknowledgment ✋
 8 | 
 9 | Many of these solutions are inspired by some other's solutions and ideas, But fully implemented and tested By me ,So thanks to all Developers Who shares their ideas and solutions with others   🤝🙏🏻
10 | 
11 | ## How To Use This List
12 | - Each problem has Three files `Solution, Test, and Input.json` Sorted by Category. 📂📂📂
13 | - Check The solution and Validate it per Category.☑️✅
14 | - Check The input File for That Problem in `Tests\Helper\InputFiles`.🧪🔦
15 | - Run the test file for that problem in `Tests\{Category}` Folder.⌛️🤔
16 | - Add more Test Cases data into The input File following the Same existing format `JSON` 🥸😉
17 | - Run The Test again to check the solution against your new test cases automatically ☑️✅🙏🏻
18 | 
19 | ## Contribute!!
20 | 
21 | You are very welcomed if You want to Contribute 🥳 on that, And this is How :
22 | 
23 | - Fork The Repo.📂
24 | - Create Your new Solution in a Class with The existing Name + your Name. 🚀
25 | - Create a Test Class for Your Solution.☑️✅
26 | - Extend `MainTest` Class to load the data from your input file 👌👌
27 | - Add/Copy a new Input file in `Tests\Helper\InputFiles` Exactly With Your Test Class Name Follow The same Format for Other files!. 👨
28 | - Validate Your Solution From Time and Space Complexity.⌛️🧪
29 | - Create a PR against The Repo 🥳
30 | - Let us discuss about your solution in your PR 🥊🥊🥊
31 | - Done !! You are a Contributor now 🍻
32 | 
33 | ## License
34 | MIT
35 | 
36 | **Free Software, Hell Yeah!**
37 | 
38 | [//]: # (These are reference links used in the body of this note and get stripped out when the markdown processor does its job. There is no need to format nicely because it shouldn't be seen. Thanks SO - http://stackoverflow.com/questions/4823468/store-comments-in-markdown-syntax)
39 | 
40 | [dill]: <https://github.com/joemccann/dillinger>
41 | [git-repo-url]: <https://github.com/joemccann/dillinger.git>
42 | [john gruber]: <http://daringfireball.net>
43 | [df1]: <http://daringfireball.net/projects/markdown/>
44 | [markdown-it]: <https://github.com/markdown-it/markdown-it>
45 | [Ace Editor]: <http://ace.ajax.org>
46 | [node.js]: <http://nodejs.org>
47 | [Twitter Bootstrap]: <http://twitter.github.com/bootstrap/>
48 | [jQuery]: <http://jquery.com>
49 | [@tjholowaychuk]: <http://twitter.com/tjholowaychuk>
50 | [express]: <http://expressjs.com>
51 | [AngularJS]: <http://angularjs.org>
52 | [Gulp]: <http://gulpjs.com>
53 | 
54 | [PlDb]: <https://github.com/joemccann/dillinger/tree/master/plugins/dropbox/README.md>
55 | [PlGh]: <https://github.com/joemccann/dillinger/tree/master/plugins/github/README.md>
56 | [PlGd]: <https://github.com/joemccann/dillinger/tree/master/plugins/googledrive/README.md>
57 | [PlOd]: <https://github.com/joemccann/dillinger/tree/master/plugins/onedrive/README.md>
58 | [PlMe]: <https://github.com/joemccann/dillinger/tree/master/plugins/medium/README.md>
59 | [PlGa]: <https://github.com/RahulHP/dillinger/blob/master/plugins/googleanalytics/README.md>
60 | 


--------------------------------------------------------------------------------
/SqlProblems/CustomersWhoNeverOrder.sql:
--------------------------------------------------------------------------------
1 | SELECT c.name  as Customers FROM customers as c where c.id not in (SELECT o.customerId from orders as o);


--------------------------------------------------------------------------------
/SqlProblems/DepartmentTopThreeSalaries.sql:
--------------------------------------------------------------------------------
 1 | WITH CTE as (
 2 |     SELECT d.name as Department,
 3 |            e.name as Employee,
 4 |            e.salary as salary,
 5 |            DENSE_RANK over(
 6 |            PARTTION BY d.name
 7 |            ORDER BY salary DESC
 8 |            ) rnk
 9 |     FROM Employee as e LEFT JOIN Department as d on d.id = e.departmentId
10 | )
11 | 
12 | SELECT Department,Employee,salary
13 | FROM CTE
14 | WHERE rnk <= 3;


--------------------------------------------------------------------------------
/SqlProblems/FriendRequestsOverallAcceptanceRate.sql:
--------------------------------------------------------------------------------
1 | 
2 | SELECT ROUND(
3 |  IFNULL(
4 | SELECT (*) FROM (SELECT DISTINCT requester_id,accepter_id FROM  RequestAccepted ) as A
5 |            /
6 | SELECT (*) FROM (SELECT DISTINCT sender_id,send_to_id FROM  FriendRequest ) as S
7 | ,0),2) as accept_rate


--------------------------------------------------------------------------------
/SqlProblems/FriendRequestsWhoHasTheMostFriends.sql:
--------------------------------------------------------------------------------
 1 | WITH CTE as (
 2 |     SELECT t1.requester_id as id ,count(DISTINCT t1.accepter_id) + count(DISTINCT t2.requester_id) as num
 3 |     FROM RequestAccepted t1  LEFT JOIN
 4 |          RequestAccepted t2 on t2.accepter_id =  t1.requester_id
 5 |     GROUP BY t1.requester_id
 6 | )
 7 | 
 8 | SELECT id,num
 9 | FROM CTE
10 | ORDER BY num DESC
11 | LIMIT 1;


--------------------------------------------------------------------------------
/SqlProblems/NthHighestSalary.sql:
--------------------------------------------------------------------------------
1 | CREATE FUNCTION getNthHighestSalary(N INT) RETURNS INT
2 | BEGIN
3 | DECLARE M INT;
4 | SET M = N-1;
5 | RETURN (
6 |     SELECT IFNULL((SELECT DISTINCT salary FROM Employee ORDER BY salary DESC LIMIT 1 OFFSET M),NULL));
7 | END


--------------------------------------------------------------------------------
/SqlProblems/SecondHighestSalary.sql:
--------------------------------------------------------------------------------
1 | SELECT IFNULL((SELECT DISTINCT SALARY FROM Employee ORDER BY salary DESC LIMIT 1 OFFSET 1),NULL) as SecondHighestSalary;
2 | 


--------------------------------------------------------------------------------
/String/FindAllAnagramsInAString.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\String;
 4 | 
 5 | /**
 6 |  * LeetCode Problem Link : https://leetcode.com/problems/find-all-anagrams-in-a-string
 7 |  */
 8 | class FindAllAnagramsInAString
 9 | {
10 | 
11 |     /**
12 |      * @param String $s
13 |      * @param String $p
14 |      * @return Integer[]
15 |      */
16 |     private $list = [];
17 | 
18 |     function findAnagrams($s, $p)
19 |     {
20 | 
21 |         if (strlen($p) > strlen($s)) {
22 |             return [];
23 |         }
24 |         $phash = [];
25 |         $sHash = [];
26 |         for ($index = 0, $indexMax = strlen($p); $index < $indexMax; $index++) {
27 |             $phash[$p[$index]] = isset($phash[$p[$index]]) ? ++$phash[$p[$index]] : 1;
28 |         }
29 | 
30 |         for ($index = 0, $indexMax = strlen($s); $index < $indexMax; $index++) {
31 |             $subString = substr($s, $index, strlen($p));
32 |             if(strlen($subString)<strlen($p))
33 |             {
34 |                 return $this->list;
35 |             }
36 | 
37 |             if (count($sHash) > 0) {
38 |                 if(isset($sHash[$s[$index-1]]) && $sHash[$s[$index-1]]>1)
39 |                 {
40 |                     --$sHash[$s[$index-1]];
41 |                 }
42 |                 else {
43 |                    unset($sHash[$s[$index-1]]);
44 |                 }
45 | 
46 |                 if (isset($sHash[$subString[strlen($p) - 1]])) {
47 |                     ++$sHash[$subString[strlen($p) - 1]];
48 |                 } else {
49 |                     $sHash[$subString[strlen($p) - 1]] = 1;
50 |                 }
51 | 
52 |             } else {
53 |                 for ($i = 0, $iMax = strlen($p); $i < $iMax; $i++) {
54 |                     $sHash[$subString[$i]] = isset($sHash[$subString[$i]]) ? ++$sHash[$subString[$i]] : 1;
55 |                 }
56 |             }
57 | 
58 |             if ($sHash == $phash) {
59 |                 $this->list [] = $index;
60 |             }
61 |         }
62 |         return $this->list;
63 |     }
64 | }


--------------------------------------------------------------------------------
/String/GroupAnagrams.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\String;
 4 | 
 5 | class GroupAnagrams
 6 | {
 7 |     /**
 8 |      * @param String[] $strs
 9 |      * @return String[][]
10 |      */
11 |     private array $hashList = [];
12 | 
13 |     public function groupAnagrams(array $stringsList): array
14 |     {
15 |         foreach ($stringsList as $str) {
16 |             $strList = str_split($str);
17 |             sort($strList);
18 |             $sorted = implode($strList);
19 |             if (isset($this->hashList[$sorted])) {
20 |                 $this->hashList[$sorted][] = $str;
21 |             } else {
22 |                 $this->hashList [$sorted] = [$str];
23 |             }
24 |         }
25 |         return array_values($this->hashList);
26 |     }
27 | }


--------------------------------------------------------------------------------
/String/LongestSubstringWithAtMostKDistinctCharacters.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\String;
 4 | 
 5 | class LongestSubstringWithAtMostKDistinctCharacters
 6 | {
 7 |     /**
 8 |      * @param String $s
 9 |      * @param Integer $k
10 |      * @return Integer
11 |      */
12 |     public function lengthOfLongestSubstringKDistinct($s, $k)
13 |     {
14 |         if ($k === 0) {
15 |             return 0;
16 |         }
17 | 
18 |         $hashList = [];
19 |         $left = 0;
20 |         $right = 0;
21 |         $maxLength = 0;
22 |         while($right < strlen($s))
23 |         {
24 |             $hashList[$s[$right]] = $right++;
25 |             if(count($hashList) >$k)
26 |             {
27 |                 $del_index = min(array_values($hashList));
28 |                 unset($hashList[$s[$del_index]]);
29 |                 $left = $del_index+1;
30 |             }
31 |             $maxLength = max ($maxLength,$right-$left);
32 |         }
33 |         return $maxLength;
34 |     }
35 | }


--------------------------------------------------------------------------------
/String/LongestSubstringWithAtMostTwoDistinctCharacters.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\String;
 4 | 
 5 | class LongestSubstringWithAtMostTwoDistinctCharacters
 6 | {
 7 |     /**
 8 |      * @param String $s
 9 |      * @return Integer
10 |      */
11 |     public function lengthOfLongestSubstringTwoDistinct( string $s): int
12 |     {
13 |         if (strlen($s) <= 2) {
14 |             return strlen($s);
15 |         }
16 | 
17 |         $hashList = [];
18 |         $left = 0;
19 |         $right = 0;
20 |         $maxLength = 0;
21 | 
22 |         while ($right < strlen($s)) {
23 |             $hashList [$s[$right]] = $right;
24 |             $right++;
25 |             if (count($hashList) === 3) {
26 |                 $del_index = min(array_values($hashList));
27 |                 unset($hashList[$s[$del_index]]);
28 |                 $left = $del_index + 1;
29 |             }
30 |             $maxLength = max($maxLength, $right - $left);
31 |         }
32 |         return $maxLength;
33 |     }
34 | }


--------------------------------------------------------------------------------
/String/LongestSubstringWithoutRepeatingCharacters.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\String;
 4 | 
 5 | class LongestSubstringWithoutRepeatingCharacters
 6 | {
 7 |     public function lengthOfLongestSubstring(string $s)
 8 |     {
 9 |         if (strlen($s) === 1) {
10 |             return 1;
11 |         }
12 |         $result = 0;
13 |         $longestSubStringList = [];
14 |         for ($index = 0, $indexMax = strlen($s); $index < $indexMax; $index++) {
15 |             foreach ($longestSubStringList as $value) {
16 |                 if (isset($longestSubStringList[$s[$index]])) {
17 |                     array_shift($longestSubStringList);
18 |                 }
19 |             }
20 |             $longestSubStringList[$s[$index]] = $s[$index];
21 |             $result = max($result, count($longestSubStringList));
22 |         }
23 |         return $result;
24 |     }
25 | }


--------------------------------------------------------------------------------
/String/RemoveAllAdjacentDuplicatesInString.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\String;
 4 | 
 5 | /**
 6 |  * LeetCode Problem Link: https://leetcode.com/problems/remove-all-adjacent-duplicates-in-string
 7 |  */
 8 | class RemoveAllAdjacentDuplicatesInString
 9 | {
10 | 
11 |     /**
12 |      * @param String $s
13 |      * @return String
14 |      */
15 |     function removeDuplicates($s)
16 |     {
17 |         $stack = [null];
18 |         for ($index = 0, $indexMax = strlen($s); $index < $indexMax; $index++) {
19 | 
20 |             if (end($stack) === $s[$index]) {
21 |                 array_pop($stack);
22 |             } else {
23 |                 $stack [] = $s[$index];
24 |             }
25 |         }
26 |         return implode('', $stack);
27 |     }
28 | }


--------------------------------------------------------------------------------
/String/RemoveAllAdjacentDuplicatesInStringII.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\String;
 4 | 
 5 | class RemoveAllAdjacentDuplicatesInStringII
 6 | {
 7 |     /**
 8 |      * @param String $s
 9 |      * @param Integer $k
10 |      * @return String
11 |      */
12 |     private $dublicateCount;
13 | 
14 |     function removeDuplicates($s, $k)
15 |     {
16 | 
17 |         for ($index = 0; $index < strlen($s); $index++) {
18 |             if (isset($s[$index - 1]) && $s[$index] === $s[$index - 1]) {
19 |                 if (isset($this->dublicateCount[$s[$index]])) {
20 |                     $this->dublicateCount[$s[$index]] .= $s[$index];
21 |                 }else {
22 |                     $this->dublicateCount[$s[$index]] = $s[$index];
23 |                 }
24 |             } else {
25 |                 $this->dublicateCount[$s[$index]] = $s[$index];
26 |             }
27 |             if (
28 |                 isset($this->dublicateCount[$s[$index]]) &&
29 |                 strlen($this->dublicateCount[$s[$index]]) >= $k) {
30 |                 $stringToDelete = $this->dublicateCount[$s[$index]];
31 |                 unset($this->dublicateCount[$s[$index]]);
32 |                 $s = str_replace($stringToDelete, '', $s);
33 |                 $index -= $k;
34 |             }
35 |         }
36 |         return $s;
37 |     }
38 | }


--------------------------------------------------------------------------------
/String/RomanToInteger.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\String;
 4 | 
 5 | class RomanToInteger
 6 | {
 7 |     /**
 8 |      * @param String $s
 9 |      * @return Integer
10 |      */
11 |     function romanToInt($s) {
12 |         $romanValues = [ 'I' =>1,'V' => 5,'X' =>10 ,'L'=>50 ,'C' => 100 ,'D' => 500,'M'=>1000];
13 |         $intValue = 0;
14 |         for($index = strlen($s)-1;$index>=0;$index--)
15 |         {
16 |             $valueMines = 0;
17 |             $valueAdded = $s[$index];
18 |             if(($s[$index] === 'V' || $s[$index] === 'X') && $s[$index-1] === 'I' & $index > 0 )
19 |             {
20 |                 $valueMines = $romanValues['I'];
21 |                 $index--;
22 |             }
23 | 
24 |             elseif(($s[$index] === 'L' || $s[$index] === 'C') && $s[$index-1] === 'X' && $index > 0 )
25 |             {
26 |                 $valueMines = $romanValues['X'];
27 |                 $index--;
28 |             }
29 | 
30 |             elseif(($s[$index] === 'D' || $s[$index] === 'M') && $s[$index-1] === 'C' && $index > 0 )
31 |             {
32 |                 $valueMines = $romanValues['C'];
33 |                 $index--;
34 |             }
35 | 
36 |             $intValue += $romanValues[$valueAdded] - $valueMines;
37 |         }
38 |         return $intValue;
39 |     }
40 | }


--------------------------------------------------------------------------------
/String/StringToInteger.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\String;
 4 | 
 5 | class StringToInteger
 6 | {
 7 | 
 8 |     /**
 9 |      * @param String $s
10 |      * @return Integer
11 |      */
12 |     function myAtoi($s)
13 |     {
14 |         $s = trim($s);
15 |         $min_rang = -2147483648;
16 |         $max_rang = 2147483647;
17 |         $sign = "+";
18 |         if ($s[0] === '-' || $s[0] === '+') {
19 |             $sign = $s[0];
20 |             $s = substr($s, 1);
21 |         }
22 |         $number = $sign;
23 |         for ($i = 0, $iMax = strlen($s); $i < $iMax; $i++) {
24 |             if (!is_numeric($s[$i])) {
25 |                 return (int)$number;
26 |             }
27 |             $number .= $s[$i];
28 | 
29 |             if (max($min_rang, min($max_rang, $number)) !== $number) {
30 |                 return $number;
31 |             }
32 |         }
33 |         return (int)$number;
34 |     }
35 | 
36 | }


--------------------------------------------------------------------------------
/String/ValidPalindrome.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\String;
 4 | 
 5 | class ValidPalindrome
 6 | {
 7 |     /**
 8 |      * @param String $s
 9 |      * @return Boolean
10 |      */
11 |     function isPalindromeByIteration( string $s) {
12 |         $s = preg_replace("/[^A-Za-z0-9 ]/", '', $s);
13 |         $s = str_replace(" ","",$s);
14 |         $s = strtolower($s);
15 |         if($s === ""){
16 |             return true;
17 |         }
18 | 
19 |         $right = strlen($s)-1;
20 | 
21 |         for($left = 0, $leftMax = strlen($s); $left< $leftMax; $left ++){
22 |                 if($s[$right] !== $s[$left] && $left <=$right){
23 |                     return false;
24 |                 }
25 |                 if($left === $right)
26 |                 {
27 |                     return true;
28 |                 }
29 |                 --$right;
30 |         }
31 |         return  true;
32 |     }
33 | }


--------------------------------------------------------------------------------
/String/ValidPalindromeII.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\String;
 4 | 
 5 | class ValidPalindromeII
 6 | {
 7 |     /**
 8 |      * @param String $s
 9 |      * @return Boolean
10 |      */
11 | 
12 |     public function validPalindrome($s): bool
13 |     {
14 |         $right = strlen($s) - 1;
15 |         $left = 0;
16 |         while ($left < $right) {
17 |             if ($s[$left] !== $s[$right]) {
18 |                 return $this->isPalindrome($s, $left + 1, $right) || $this->isPalindrome($s, $left, $right - 1);
19 |             }
20 |             $left++;
21 |             $right--;
22 |         }
23 |         return true;
24 |     }
25 | 
26 |     private function isPalindrome($s, $i, $j): bool
27 |     {
28 |         while ($i < $j) {
29 |             if ($s[$i++] !== $s[$j--]) {
30 |                 return false;
31 |             }
32 |         }
33 |         return true;
34 |     }
35 | }


--------------------------------------------------------------------------------
/Tests/ArrayProblems/IntegerToEnglishWordsTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArrayProblems;
 4 | 
 5 | use Hakam\LeetCodePhp\Tests\Helper\MainTest;
 6 | use Hakam\LeetCodePhp\Tree\IntegerToEnglishWords;
 7 | 
 8 | /**
 9 |  * @covers \Hakam\LeetCodePhp\Tree\IntegerToEnglishWords
10 |  */
11 | class IntegerToEnglishWordsTest extends MainTest
12 | {
13 |     /**
14 |      * @dataProvider provideData
15 |      */
16 |     public function testWithDataList($expectedResult, $inputData): void
17 |     {
18 |         $integerToEnglish = new IntegerToEnglishWords();
19 |         $word = $integerToEnglish->numberToWords($inputData);
20 |         self::assertEquals($expectedResult, $word);
21 |     }
22 | }


--------------------------------------------------------------------------------
/Tests/ArrayProblems/MergeIntervalsTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArrayProblems;
 4 | 
 5 | use Hakam\LeetCodePhp\ArrayProblems\MergeIntervals;
 6 | use Hakam\LeetCodePhp\Tests\Helper\MainTest;
 7 | 
 8 | /**
 9 |  * @covers \Hakam\LeetCodePhp\ArrayProblems\MergeIntervals
10 |  */
11 | class MergeIntervalsTest extends MainTest
12 | {
13 |     /**
14 |      * @dataProvider provideData
15 |      *
16 |      */
17 |     public function testWithDataList($expectedResult, $inputData): void
18 |     {
19 |        $merge = new MergeIntervals();
20 |        $result = $merge->merge($inputData);
21 |        $index = 0;
22 |        foreach ($result as $item)
23 |        {
24 |            self::assertEmpty(array_diff($expectedResult[$index++],$item));
25 |        }
26 |     }
27 | }


--------------------------------------------------------------------------------
/Tests/ArrayProblems/MergeSortedArrayTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArrayProblems;
 4 | 
 5 | use Hakam\LeetCodePhp\ArrayProblems\MergeSortedArray;
 6 | use Hakam\LeetCodePhp\Tests\Helper\MainTest;
 7 | 
 8 | /**
 9 |  * @covers \Hakam\LeetCodePhp\ArrayProblems\MergeSortedArray
10 |  */
11 | class MergeSortedArrayTest extends MainTest
12 | {
13 |     /**
14 |      * @dataProvider provideData
15 |      */
16 |     public function testWithDataList($expectedResult, $inputData): void
17 |     {
18 |         $merge = new MergeSortedArray();
19 |         $merge->mergeByHeap(...$inputData);
20 |         self::assertEmpty(array_diff($expectedResult,$inputData[0]));
21 |     }
22 | 
23 |     /**
24 |      * @dataProvider provideData
25 |      */
26 |     public function testWithDataListByPointers($expectedResult, $inputData): void
27 |     {
28 |         $merge = new MergeSortedArray();
29 |         $merge->mergeByPointers(...$inputData);
30 |         self::assertEmpty(array_diff($expectedResult,$inputData[0]));
31 |     }
32 | }


--------------------------------------------------------------------------------
/Tests/ArrayProblems/MoveZeroesTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArrayProblems;
 4 | 
 5 | use Hakam\LeetCodePhp\ArrayProblems\MoveZeroes;
 6 | use Hakam\LeetCodePhp\Tests\Helper\MainTest;
 7 | 
 8 | /**
 9 |  * @covers \Hakam\LeetCodePhp\ArrayProblems\MoveZeroes
10 |  */
11 | class MoveZeroesTest extends MainTest
12 | {
13 |     /**
14 |      * @dataProvider provideData
15 |      */
16 |     public function testWithDataList($expectedResult, $inputData): void
17 |     {
18 |         $moveZeroes = new MoveZeroes();
19 |         $moveZeroes->moveZeroes($inputData);
20 |         self::assertEmpty(array_diff($expectedResult,$inputData));
21 |     }
22 | }


--------------------------------------------------------------------------------
/Tests/ArrayProblems/RemoveElementTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArrayProblems;
 4 | 
 5 | use Hakam\LeetCodePhp\ArrayProblems\RemoveElement;
 6 | use Hakam\LeetCodePhp\Tests\Helper\MainTest;
 7 | 
 8 | /**
 9 |  * @covers \Hakam\LeetCodePhp\ArrayProblems\RemoveElement
10 |  */
11 | class RemoveElementTest extends MainTest
12 | {
13 |     /**
14 |      * @dataProvider provideData
15 |      */
16 |     public function testWithDataList($expectedResult, $inputData): void
17 |     {
18 |        $removeElement = new RemoveElement();
19 |        $arrayOfNumbers = $inputData[0];
20 |        $count = $removeElement->removeElement($arrayOfNumbers,$inputData[1]);
21 |        self::assertEmpty(array_diff($expectedResult,array_slice($arrayOfNumbers,0,$count-1)));
22 |     }
23 | }


--------------------------------------------------------------------------------
/Tests/ArrayProblems/ThreeSumTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tests\ArrayProblems;
 4 | 
 5 | use Hakam\LeetCodePhp\ArrayProblems\ThreeSum;
 6 | use Hakam\LeetCodePhp\Tests\Helper\MainTest;
 7 | 
 8 | /**
 9 |  * @covers \Hakam\LeetCodePhp\ArrayProblems\ThreeSum
10 |  */
11 | class ThreeSumTest extends MainTest
12 | {
13 | 
14 |     /**
15 |      * @dataProvider provideData
16 |      */
17 |     public function testWithDataList($expectedResult, $inputData): void
18 |     {
19 |         $threeSum = new ThreeSum();
20 |         $list = $threeSum->threeSum($inputData);
21 |         self::assertSameSize($expectedResult, $list);
22 |         $expectedResult = array_merge(...$expectedResult);
23 |         asort($expectedResult);
24 |         $list = array_merge(...$list);
25 |         asort($list);
26 |         self::assertEmpty(array_diff($expectedResult, $list));
27 |     }
28 | }


--------------------------------------------------------------------------------
/Tests/ArrayProblems/TwoSumTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tests\ArrayProblems;
 4 | 
 5 | use Hakam\LeetCodePhp\ArrayProblems\TwoSum;
 6 | use Hakam\LeetCodePhp\Tests\Helper\MainTest;
 7 | 
 8 | /**
 9 |  * @covers \Hakam\LeetCodePhp\ArrayProblems\TwoSum
10 |  */
11 | class TwoSumTest extends MainTest
12 | {
13 | 
14 |     /**
15 |      * @dataProvider provideData
16 |      */
17 |     public function testWithDataList($expectedResult, $inputData): void
18 |     {
19 |         $twoSum = new TwoSum();
20 |         $result = $twoSum->twoSum($inputData['nums'],$inputData['target']);
21 |         self::assertEmpty(array_diff($expectedResult,$result));
22 |     }
23 | }


--------------------------------------------------------------------------------
/Tests/Heap/KthLargestElementInAStreamTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tests\Heap;
 4 | 
 5 | use Hakam\LeetCodePhp\Heap\KthLargestElementInAStream;
 6 | use Hakam\LeetCodePhp\Tests\Helper\MainTest;
 7 | 
 8 | /**
 9 |  * @covers \Hakam\LeetCodePhp\Heap\KthLargestElementInAStream
10 |  */
11 | class KthLargestElementInAStreamTest extends MainTest
12 | {
13 | 
14 |     /**
15 |      * @dataProvider provideData
16 |      */
17 |     public function testWithDataList($expectedResult, $inputData): void
18 |     {
19 |         $kthLargestElement = new KthLargestElementInAStream($inputData[0][0], $inputData[0][1]);
20 |         array_shift($inputData);
21 |         foreach ($inputData as $datum) {
22 |             $result[] = $kthLargestElement->add($datum[0]);
23 |         }
24 |         self::assertEmpty(array_diff($expectedResult, $result));
25 |     }
26 | }


--------------------------------------------------------------------------------
/Tests/Heap/KthLargestElementInAnArrayTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tests\Heap;
 4 | 
 5 | use Hakam\LeetCodePhp\Heap\KthLargestElementInAnArray;
 6 | use Hakam\LeetCodePhp\Tests\Helper\MainTest;
 7 | 
 8 | /**
 9 |  * @covers \Hakam\LeetCodePhp\Heap\KthLargestElementInAnArray
10 |  */
11 | class KthLargestElementInAnArrayTest extends MainTest
12 | {
13 |     /**
14 |      * @dataProvider provideData
15 |      */
16 |     public function testWithDataList($expectedResult, $inputData): void
17 |     {
18 |         $kthLargestElement = new KthLargestElementInAnArray();
19 |         self::assertEquals($expectedResult,$kthLargestElement->findKthLargest($inputData[0],$inputData[1]));
20 |     }
21 | }


--------------------------------------------------------------------------------
/Tests/Heap/MedianStreamTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tests\Heap;
 4 | 
 5 | use Hakam\LeetCodePhp\Heap\MedianStream;
 6 | use Hakam\LeetCodePhp\Tests\Helper\MainTest;
 7 | 
 8 | /**
 9 |  * @covers \Hakam\LeetCodePhp\Heap\MedianStream
10 |  */
11 | class MedianStreamTest extends MainTest
12 | {
13 |     /**
14 |      * @dataProvider provideData
15 |      */
16 |     public function testWithDataList($expectedResult, $inputData): void
17 |     {
18 |        $medianStream = new MedianStream();
19 |        self::assertEmpty(array_diff($expectedResult,$medianStream->findMedian($inputData)));
20 |     }
21 | }


--------------------------------------------------------------------------------
/Tests/Heap/TopKFrequentElementsTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tests\Heap;
 4 | 
 5 | use Hakam\LeetCodePhp\Heap\TopKFrequentElements;
 6 | use Hakam\LeetCodePhp\Tests\Helper\MainTest;
 7 | 
 8 | /**
 9 |  * @covers \Hakam\LeetCodePhp\Heap\TopKFrequentElements
10 |  * @covers \Hakam\LeetCodePhp\Heap\PQ
11 |  */
12 | class TopKFrequentElementsTest extends MainTest
13 | {
14 |     /**
15 |      * @dataProvider provideData
16 |      */
17 |     public function testWithDataList($expectedResult, $inputData): void
18 |     {
19 |         $topFrequentElement = new TopKFrequentElements();
20 |         self::assertEmpty(array_diff($expectedResult,$topFrequentElement->topKFrequent($inputData[0],$inputData[1])));
21 |     }
22 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/BinaryTreeLevelOrderTraversalTest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "testCase1": {
 3 |     "expectedResult": [[3],[9,20],[15,7]],
 4 |     "input": {
 5 |       "tree": {
 6 |         "nodes": [
 7 |           {"id": "1", "left": "2", "right": "3", "value": 3},
 8 |           {"id": "2", "left": null, "right": null, "value": 9},
 9 |           {"id": "3", "left": "4", "right": "5", "value": 20},
10 |           {"id": "4", "left": null, "right": null, "value": 15},
11 |           {"id": "5", "left": null, "right": null, "value": 7}
12 |         ],
13 |         "root": "1"
14 |       }
15 |     }
16 |   },
17 |   "testCase2": {
18 |     "expectedResult": [[1],[2,3],[4,5]],
19 |     "input": {
20 |       "tree": {
21 |         "nodes": [
22 |           {"id": "1", "left": "2", "right": "3", "value": 1},
23 |           {"id": "2", "left": "4", "right": null, "value": 2},
24 |           {"id": "3", "left": null, "right": "5", "value": 3},
25 |           {"id": "4", "left": null, "right": null, "value": 4},
26 |           {"id": "5", "left": null, "right": null, "value": 5}
27 |         ],
28 |         "root": "1"
29 |       }
30 |     }
31 |   }
32 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/BinaryTreePathsTest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "testCase1": {
 3 |     "expectedResult": ["1->2->4","1->3"],
 4 |     "input": {
 5 |       "tree": {
 6 |         "nodes": [
 7 |           {"id": "1", "left": "2", "right": "3", "value": 1},
 8 |           {"id": "2", "left": null, "right": "4", "value": 2},
 9 |           {"id": "3", "left": null, "right": null, "value": 3},
10 |           {"id": "4", "left": null, "right": null, "value": 4}
11 |           ],
12 |         "root": "1"
13 |       }
14 |     }
15 |   },
16 |   "testCase2": {
17 |     "expectedResult": [1],
18 |     "input": {
19 |       "tree": {
20 |         "nodes": [
21 |           {"id": "1", "left": null, "right": null, "value": 1}
22 |         ],
23 |         "root": "1"
24 |       }
25 |     }
26 |   }
27 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/BinaryTreePostorderTraversalTest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "testCase1": {
 3 |     "expectedResult": [3,2,1],
 4 |     "input": {
 5 |       "tree": {
 6 |         "nodes": [
 7 |           {"id": "1", "left": null, "right": "2", "value": 1},
 8 |           {"id": "2", "left": "3", "right": null, "value": 2},
 9 |           {"id": "3", "left": null, "right": null, "value": 3}
10 |         ],
11 |         "root": "1"
12 |       }
13 |     }
14 |   },
15 |   "testCase2": {
16 |     "expectedResult": [1],
17 |     "input": {
18 |       "tree": {
19 |         "nodes": [
20 |           {"id": "1", "left": null, "right": null, "value": 1}
21 |         ],
22 |         "root": "1"
23 |       }
24 |     }
25 |   }
26 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/BinaryTreePreorderTraversalTest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "testCase1": {
 3 |     "expectedResult": [1,2,3],
 4 |     "input": {
 5 |       "tree": {
 6 |         "nodes": [
 7 |           {"id": "1", "left": null, "right": "2", "value": 1},
 8 |           {"id": "2", "left": "3", "right": null, "value": 2},
 9 |           {"id": "3", "left": null, "right": null, "value": 3}
10 |         ],
11 |         "root": "1"
12 |       }
13 |     }
14 |   },
15 |   "testCase2": {
16 |     "expectedResult": [1],
17 |     "input": {
18 |       "tree": {
19 |         "nodes": [
20 |           {"id": "1", "left": null, "right": null, "value": 1}
21 |         ],
22 |         "root": "1"
23 |       }
24 |     }
25 |   }
26 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/BinaryTreeRightSideViewTest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "testCase1": {
 3 |     "expectedResult": [1,3,4],
 4 |     "input": {
 5 |       "tree": {
 6 |         "nodes": [
 7 |           {"id": "1", "left": "2", "right": "3", "value": 1},
 8 |           {"id": "2", "left": null, "right": "5", "value": 2},
 9 |           {"id": "3", "left": null, "right": "4", "value": 3},
10 |           {"id": "4", "left": null, "right": null, "value": 4},
11 |           {"id": "5", "left": null, "right": null, "value": 5}
12 | 
13 |         ],
14 |         "root": "1"
15 |       }
16 |     }
17 |   },
18 |   "testCase2": {
19 |     "expectedResult": [1,2],
20 |     "input": {
21 |       "tree": {
22 |         "nodes": [
23 |           {"id": "1", "left": null, "right": "2", "value": 1},
24 |           {"id": "2", "left": null, "right": null, "value": 2}
25 | 
26 |         ],
27 |         "root": "1"
28 |       }
29 |     }
30 |   },
31 |   "testCase3": {
32 |     "expectedResult": [1,3,4],
33 |     "input": {
34 |       "tree": {
35 |         "nodes": [
36 |           {"id": "1", "left": "2", "right": "3", "value": 1},
37 |           {"id": "2", "left": "4", "right": null, "value": 2},
38 |           {"id": "3", "left": null, "right": null, "value": 3},
39 |           {"id": "4", "left": null, "right": null, "value": 4}
40 | 
41 | 
42 |         ],
43 |         "root": "1"
44 |       }
45 |     }
46 |   }
47 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/BinaryTreeVerticalOrderTraversalTest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "testCase1": {
 3 |     "expectedResult": [[9],[3,15],[20],[7]],
 4 |     "input": {
 5 |       "tree": {
 6 |         "nodes": [
 7 |           {"id": "1", "left": "2", "right": "3", "value": 3},
 8 |           {"id": "2", "left": null, "right": null, "value": 9},
 9 |           {"id": "3", "left": "4", "right": "5", "value": 20},
10 |           {"id": "4", "left": null, "right": null, "value": 15},
11 |           {"id": "5", "left": null, "right": null, "value": 7}
12 |         ],
13 |         "root": "1"
14 |       }
15 |     }
16 |   },
17 |   "testCase2": {
18 |     "expectedResult": [[4],[9],[3,0,1],[8],[7]],
19 |     "input": {
20 |       "tree": {
21 |         "nodes": [
22 |           {"id": "1", "left": "2", "right": "3", "value": 3},
23 |           {"id": "2", "left": "4", "right": "5", "value": 9},
24 |           {"id": "3", "left": "6", "right": "7", "value": 8},
25 |           {"id": "4", "left": null, "right": null, "value": 4},
26 |           {"id": "5", "left": null, "right": null, "value": 0},
27 |           {"id": "6", "left": null, "right": null, "value": 1},
28 |           {"id": "7", "left": null, "right": null, "value": 7}
29 |         ],
30 |         "root": "1"
31 |       }
32 |     }
33 |   },
34 |   "testCase3": {
35 |     "expectedResult": [[4],[2,7,8],[1,5,6,10,11,10],[3,9]],
36 |     "input": {
37 |       "tree": {
38 |         "nodes": [
39 |           {"id": "1", "left": "2", "right": "3", "value": 1},
40 |           {"id": "2", "left": "4", "right": "5", "value": 2},
41 |           {"id": "3", "left": "6", "right": null, "value": 3},
42 |           {"id": "4", "left": null, "right": "7", "value": 4},
43 |           {"id": "5", "left": "8", "right": null, "value": 5},
44 |           {"id": "6", "left": null, "right": "9", "value": 6},
45 |           {"id": "7", "left": null, "right": "10", "value": 7},
46 |           {"id": "8", "left": null, "right": "11", "value": 8},
47 |           {"id": "9", "left": "12", "right": null, "value": 9},
48 |           {"id": "10", "left": null, "right": null, "value": 10},
49 |           {"id": "11", "left": null, "right": null, "value": 11},
50 |           {"id": "12", "left": null, "right": null, "value": 10}
51 |         ],
52 |         "root": "1"
53 |       }
54 |     }
55 |   }
56 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/ConstructBinaryTreeFromInorderAndPostorderTraversalTest.json:
--------------------------------------------------------------------------------
1 | {
2 |   "testCase1": {
3 |     "expectedResult": [3,9,20,null,null,15,7],
4 |     "input": [[9,3,15,20,7],[9,15,7,20,3]]
5 |   }
6 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/ConstructBinaryTreeFromInorderAndPreorderTraversalTest.json:
--------------------------------------------------------------------------------
1 | {
2 |   "testCase1": {
3 |     "expectedResult": [3,9,20,null,null,15,7],
4 |     "input": [[3,9,20,15,7],[9,3,15,20,7]]
5 |   }
6 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/ConvertSortedArrayToBinarySearchTreeTest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "testCase1": {
 3 |     "expectedResult": true,
 4 |     "input": [-10,-3,0,5,9]
 5 |   },
 6 |   "testCase2": {
 7 |     "expectedResult": true,
 8 |     "input": [1,3]
 9 |   }
10 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/CountUniValueSubtreesTest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "testCase1": {
 3 |     "expectedResult": 4,
 4 |     "input": {
 5 |       "tree": {
 6 |         "nodes": [
 7 |           {
 8 |             "id": "1",
 9 |             "left": "2",
10 |             "right": "3",
11 |             "value": 5
12 |           },
13 |           {
14 |             "id": "2",
15 |             "left": "4",
16 |             "right": "5",
17 |             "value": 1
18 |           },
19 |           {
20 |             "id": "3",
21 |             "left": null,
22 |             "right": "6",
23 |             "value": 5
24 |           },
25 |           {
26 |             "id": "4",
27 |             "left": null,
28 |             "right": null,
29 |             "value": 5
30 |           },
31 |           {
32 |             "id": "5",
33 |             "left": null,
34 |             "right": null,
35 |             "value": 5
36 |           },
37 |           {
38 |             "id": "6",
39 |             "left": null,
40 |             "right": null,
41 |             "value": 5
42 |           }
43 |         ],
44 |         "root": "1"
45 |       }
46 |     }
47 |   },
48 |   "testCase2": {
49 |     "expectedResult": 6,
50 |     "input": {
51 |       "tree": {
52 |         "nodes": [
53 |           {
54 |             "id": "1",
55 |             "left": "2",
56 |             "right": "3",
57 |             "value": 5
58 |           },
59 |           {
60 |             "id": "2",
61 |             "left": "4",
62 |             "right": "5",
63 |             "value": 5
64 |           },
65 |           {
66 |             "id": "3",
67 |             "left": null,
68 |             "right": "6",
69 |             "value": 5
70 |           },
71 |           {
72 |             "id": "4",
73 |             "left": null,
74 |             "right": null,
75 |             "value": 5
76 |           },
77 |           {
78 |             "id": "5",
79 |             "left": null,
80 |             "right": null,
81 |             "value": 5
82 |           },
83 |           {
84 |             "id": "6",
85 |             "left": null,
86 |             "right": null,
87 |             "value": 5
88 |           }
89 |         ],
90 |         "root": "1"
91 |       }
92 |     }
93 |   }
94 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/DiameterOfBinaryTreeTest.json:
--------------------------------------------------------------------------------
 1 | {"testCase1": {
 2 |   "expectedResult": 3,
 3 |   "input": {
 4 |     "tree": {
 5 |       "nodes": [
 6 |         {"id": "1", "left": "2", "right": "3", "value": 1},
 7 |         {"id": "2", "left": "4", "right": "5", "value": 2},
 8 |         {"id": "3", "left": null, "right": null, "value": 3},
 9 |         {"id": "4", "left": null, "right": null, "value": 4},
10 |         {"id": "5", "left": null, "right": null, "value": 5}
11 | 
12 |       ],
13 |       "root": "1"
14 |     }
15 |   }
16 | },
17 |   "testCase2": {
18 |     "expectedResult": 0,
19 |     "input": {
20 |       "tree": {
21 |         "nodes": [
22 |           {"id": "1", "left": null, "right": null, "value": 1}
23 |         ],
24 |         "root": "1"
25 |       }
26 |     }
27 |   }}


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/FindAllAnagramsInAStringTest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "testCase1": {
 3 |     "expectedResult": [0,1,2],
 4 |     "input": ["abab","ab"]
 5 |   },
 6 |   "testCase2": {
 7 |     "expectedResult": [0,6],
 8 |     "input": ["cbaebabacd","abc"]
 9 |   },
10 |   "testCase3": {
11 |     "expectedResult": [1,2,3,5],
12 |     "input": ["abacbabc","abc"]
13 |   }
14 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/FlattenBinaryTreeToLinkedListTest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "testCase1": {
 3 |     "expectedResult": [1,null,2,null,3,null,4,null,5,null,6],
 4 |     "input": {
 5 |       "tree": {
 6 |         "nodes": [
 7 |           {"id": "1", "left": "2", "right": "5", "value": 1},
 8 |           {"id": "2", "left": "3", "right": "4", "value": 2},
 9 |           {"id": "3", "left": null, "right": null, "value": 3},
10 |           {"id": "4", "left": null, "right": null, "value": 4},
11 |           {"id": "5", "left": null, "right": "6", "value": 5},
12 |           {"id": "6", "left": null, "right": null, "value": 6}
13 |         ],
14 |         "root": "1"
15 |       }
16 |     }
17 |   }
18 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/GroupAnagramsTest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "testCase1": {
 3 |     "expectedResult": [["eat","tea","ate"],["tan","nat"],["bat"]],
 4 |     "input": ["eat","tea","tan","ate","nat","bat"]
 5 |   },
 6 |   "testCase2": {
 7 |     "expectedResult": [["a"]],
 8 |     "input": ["a"]
 9 |   }
10 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/IntegerToEnglishWordsTest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "testCase1": {
 3 |     "expectedResult": "One Hundred Twenty Three",
 4 |     "input": 123
 5 |   },
 6 |   "testCase2": {
 7 |     "expectedResult": "Twelve Thousand Three Hundred Forty Five",
 8 |     "input": 12345
 9 |   },
10 | 
11 |   "testCase3": {
12 |     "expectedResult": "One Hundred Twenty Three Million Four Hundred Twelve Thousand Three Hundred Forty Five",
13 |     "input": 123412345
14 |   },
15 |   "testCase4": {
16 |     "expectedResult": "Twenty",
17 |     "input": 20
18 |   }
19 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/KthLargestElementInAStreamTest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "testCase1": {
 3 |     "expectedResult": [-1,0,0,0,1],
 4 |     "input": [[2,[0]],[-1],[1],[-2],[-4],[3]]
 5 |   },
 6 |   "testCase2": {
 7 |     "expectedResult": [4,5,5,8,8],
 8 |     "input": [[3,[4,5,8,2]],[3],[5],[10],[9],[4]]
 9 |   }
10 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/KthLargestElementInAnArrayTest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "testCase1": {
 3 |     "expectedResult": 5,
 4 |     "input": [[3,2,1,5,6,4],2]
 5 |   },
 6 |   "testCase2": {
 7 |     "expectedResult": 3,
 8 |     "input": [[3,1,5,8,2,0,10,9,4],6]
 9 |   }
10 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/LongestSubstringWithAtMostKDistinctCharactersTest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "testCase1": {
 3 |     "expectedResult": 3,
 4 |     "input": ["eceba",2]
 5 |   },
 6 |   "testCase2": {
 7 |     "expectedResult": 4,
 8 |     "input": ["abaccc",2]
 9 |   },
10 |   "testCase3": {
11 |     "expectedResult": 2,
12 |     "input": ["aa",1]
13 |   },
14 |   "testCase4": {
15 |     "expectedResult": 5,
16 |     "input": ["ccaabbb",2]
17 |   },
18 |   "testCase5": {
19 |     "expectedResult": 2,
20 |     "input": ["abee",1]
21 |   }
22 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/LongestSubstringWithAtMostTwoDistinctCharactersTest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "testCase1": {
 3 |     "expectedResult": 3,
 4 |     "input": ["eceba"]
 5 |   },
 6 |   "testCase2": {
 7 |     "expectedResult": 4,
 8 |     "input": ["abaccc"]
 9 |   },
10 |   "testCase3": {
11 |     "expectedResult": 2,
12 |     "input": ["aa"]
13 |   },
14 |   "testCase4": {
15 |     "expectedResult": 5,
16 |     "input": ["ccaabbb"]
17 |   },
18 |   "testCase5": {
19 |     "expectedResult": 3,
20 |     "input": ["abee"]
21 |   }
22 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/LongestSubstringWithoutRepeatingCharactersTest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "testCase1": {
 3 |     "expectedResult": 2,
 4 |     "input": "au"
 5 |   },
 6 |   "testCase2": {
 7 |     "expectedResult": 3,
 8 |     "input": "abcabcbb"
 9 |   },
10 |   "testCase3": {
11 |     "expectedResult": 1,
12 |     "input": "bbbbb"
13 |   },
14 |   "testCase4": {
15 |     "expectedResult": 3,
16 |     "input": "pwwkew"
17 |   },
18 |   "testCase5": {
19 |     "expectedResult": 0,
20 |     "input": ""
21 |   },
22 |   "testCase6": {
23 |     "expectedResult": 3,
24 |     "input": "aabaab!bb"
25 |   },
26 |   "testCase7": {
27 |     "expectedResult": 95,
28 |     "input": "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCD"
29 |   }
30 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/MaximumDepthOfBinaryTreeTest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "testCase1": {
 3 |     "expectedResult": 3,
 4 |     "input": {
 5 |       "tree": {
 6 |         "nodes": [
 7 |           {"id": "1", "left": null, "right": "2", "value": 1},
 8 |           {"id": "2", "left": "3", "right": null, "value": 2},
 9 |           {"id": "3", "left": null, "right": null, "value": 3}
10 |         ],
11 |         "root": "1"
12 |       }
13 |     }
14 |   },
15 |   "testCase2": {
16 |     "expectedResult": 1,
17 |     "input": {
18 |       "tree": {
19 |         "nodes": [
20 |           {"id": "1", "left": null, "right": null, "value": 1}
21 |         ],
22 |         "root": "1"
23 |       }
24 |     }
25 |   }
26 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/MedianStreamTest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "testCase1": {
 3 |     "expectedResult": [5, 10, 5, 4],
 4 |     "input":  [5, 15, 1, 3]
 5 |   },
 6 |   "testCase2": {
 7 |     "expectedResult": [1,1],
 8 |     "input": [1,2]
 9 |   }
10 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/MergeIntervalsTest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "testCase1": {
 3 |     "expectedResult": [[1,6],[8,10],[15,18]],
 4 |     "input":[[1,3],[2,6],[8,10],[15,18]]
 5 |   },
 6 |   "testCase2": {
 7 |     "expectedResult": [[1,5]],
 8 |     "input": [[1,4],[4,5]]
 9 |   }
10 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/MergeSortedArrayTest.json:
--------------------------------------------------------------------------------
1 | {
2 |   "testCase1": {
3 |     "expectedResult":[1,2,2,3,5,6],
4 |     "input": [[1,2,3,0,0,0],3,[2,5,6],3]
5 |   }
6 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/MergedToSortedListTest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "testCase1": {
 3 |     "expectedResult": [1,1,2,3,4,4],
 4 |     "input": [[1,2,4],[1,3,4]]
 5 |   },
 6 |   "testCase2": {
 7 |     "expectedResult": [],
 8 |     "input": []
 9 |   },
10 |   "testCase3": {
11 |     "expectedResult": [-4,-1,3,5,9,12,16,20],
12 |     "input": [[-1,5,20],[-4,3,5,9,12,16]]
13 |   }
14 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/MoveZeroesTest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "testCase1": {
 3 |     "expectedResult": [1,3,12,0,0],
 4 |     "input": [0,1,0,3,12]
 5 |   },
 6 |   "testCase2": {
 7 |     "expectedResult": [5,9,12,3,40,0,0],
 8 |     "input": [5,9,0,12,3,0,40,0]
 9 |   }
10 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/PathSumTest.json:
--------------------------------------------------------------------------------
 1 | {"testCase1": {
 2 |   "expectedResult": true,
 3 |   "input": {
 4 |     "tree": {
 5 |       "nodes": [
 6 |         {"id": "1", "left": "2", "right": "3", "value": 1},
 7 |         {"id": "2", "left": "4", "right": null, "value": 4},
 8 |         {"id": "3", "left": "5", "right": "6", "value": 8},
 9 |         {"id": "4", "left": "7", "right": "8", "value": 11},
10 |         {"id": "5", "left": null, "right": null, "value": 13},
11 |         {"id": "6", "left": null, "right": "9", "value": 4},
12 |         {"id": "7", "left": null, "right": null, "value": 7},
13 |         {"id": "8", "left": null, "right": null, "value": 2},
14 |         {"id": "9", "left": null, "right": null, "value": 1}
15 |       ],
16 |       "root": "1"
17 |     },
18 |     "sum" : 22
19 |   }
20 | },
21 |   "testCase2": {
22 |     "expectedResult": 0,
23 |     "input": {
24 |       "tree": {
25 |         "nodes": [
26 |           {"id": "1", "left": "2", "right": "3", "value": 1},
27 |           {"id": "2", "left": null, "right": null, "value": 2},
28 |           {"id": "3", "left": null, "right": null, "value": 3}
29 |         ],
30 |         "root": "1"
31 |       },
32 |       "sum": 5
33 |     }
34 |   }}


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/ReOrderListTest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "testCase1": {
 3 |     "expectedResult":[1,4,2,3],
 4 |     "input": [1,2,3,4]
 5 |   },
 6 |   "testCase2": {
 7 |     "expectedResult":[1,5,2,4,3],
 8 |     "input": [1,2,3,4,5]
 9 |   }
10 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/RemoveAllAdjacentDuplicatesInStringIITest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "testCase1": {
 3 |     "expectedResult": "aa",
 4 |     "input": ["deeedbbcccbdaa",3]
 5 |   },
 6 |   "testCase2": {
 7 |     "expectedResult": "abcd",
 8 |     "input": ["abcd",2]
 9 |   }
10 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/RemoveAllAdjacentDuplicatesInStringTest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "testCase1": {
 3 |     "expectedResult": "ca",
 4 |     "input": "abbaca"
 5 |   },
 6 |   "testCase2": {
 7 |     "expectedResult": "ay",
 8 |     "input": "azxxzy"
 9 |   }
10 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/RemoveElementTest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "testCase1": {
 3 |     "expectedResult": [2,2],
 4 |     "input": [[3,2,2,3],3]
 5 |   },
 6 |   "testCase2": {
 7 |     "expectedResult": [],
 8 |     "input": [[],3]
 9 |   }
10 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/RemoveNthNodeFromEndOfListTest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "testCase1": {
 3 |     "expectedResult":[2],
 4 |     "input": [[1,2],2]
 5 |   },
 6 |   "testCase2": {
 7 |     "expectedResult":[1,2,3,5],
 8 |     "input": [[1,2,3,4,5],2]
 9 |   },
10 |   "testCase3": {
11 |     "expectedResult":[],
12 |     "input": [[1],1]
13 |   }
14 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/ReverseLinkedListIITest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "testCase1": {
 3 |     "expectedResult":[1,4,3,2,5],
 4 |     "input": [[1,2,3,4,5],2,4]
 5 |   },
 6 |   "testCase2": {
 7 |     "expectedResult":[5],
 8 |     "input": [[5],1,1]
 9 |   }
10 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/ReverseLinkedListTest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "testCase1": {
 3 |     "expectedResult":[4,3,2,1],
 4 |     "input": [1,2,3,4]
 5 |   },
 6 |   "testCase2": {
 7 |     "expectedResult":[8,5,1,3,2,4],
 8 |     "input": [4,2,3,1,5,8]
 9 |   }
10 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/RomanToIntTest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "testCase1": {
 3 |     "expectedResult": 1994,
 4 |     "input": "MCMXCIV"
 5 |   },
 6 |   "testCase2": {
 7 |     "expectedResult": 3490,
 8 |     "input": "MMMCDXC"
 9 |   }
10 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/SameTreeTest.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "testCase1": {
  3 |     "expectedResult": true,
  4 |     "input": {
  5 |       "tree1": {
  6 |         "tree": {
  7 |           "nodes": [
  8 |             {
  9 |               "id": "1",
 10 |               "left": "2",
 11 |               "right": "3",
 12 |               "value": 1
 13 |             },
 14 |             {
 15 |               "id": "2",
 16 |               "left": null,
 17 |               "right": null,
 18 |               "value": 2
 19 |             },
 20 |             {
 21 |               "id": "3",
 22 |               "left": null,
 23 |               "right": null,
 24 |               "value": 3
 25 |             }
 26 |           ],
 27 |           "root": "1"
 28 |         }
 29 |       },
 30 |       "tree2": {
 31 |         "tree": {
 32 |           "nodes": [
 33 |             {
 34 |               "id": "1",
 35 |               "left": "2",
 36 |               "right": "3",
 37 |               "value": 1
 38 |             },
 39 |             {
 40 |               "id": "2",
 41 |               "left": null,
 42 |               "right": null,
 43 |               "value": 2
 44 |             },
 45 |             {
 46 |               "id": "3",
 47 |               "left": null,
 48 |               "right": null,
 49 |               "value": 3
 50 |             }
 51 |           ],
 52 |           "root": "1"
 53 |         }
 54 |       }
 55 |     }
 56 |   },
 57 |   "testCase2": {
 58 |     "expectedResult": false,
 59 |     "input": {
 60 |       "tree1": {
 61 |         "tree": {
 62 |           "nodes": [
 63 |             {
 64 |               "id": "1",
 65 |               "left": "2",
 66 |               "right": null,
 67 |               "value": 1
 68 |             },
 69 |             {
 70 |               "id": "2",
 71 |               "left": null,
 72 |               "right": null,
 73 |               "value": 2
 74 |             }
 75 |           ],
 76 |           "root": "1"
 77 |         }
 78 |       },
 79 |       "tree2": {
 80 |         "tree": {
 81 |           "nodes": [
 82 |             {
 83 |               "id": "1",
 84 |               "left": null,
 85 |               "right": "2",
 86 |               "value": 1
 87 |             },
 88 |             {
 89 |               "id": "2",
 90 |               "left": null,
 91 |               "right": null,
 92 |               "value": 2
 93 |             }
 94 |           ],
 95 |           "root": "1"
 96 |         }
 97 |       }
 98 |     }
 99 |   }
100 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/StringToIntegerTest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "testCase1": {
 3 |     "expectedResult": 42,
 4 |     "input": "42"
 5 |   },
 6 |   "testCase2": {
 7 |     "expectedResult": -42,
 8 |     "input": "-42"
 9 |   },
10 |   "testCase3": {
11 |     "expectedResult": 0,
12 |     "input": "   +0 123"
13 |   },
14 |   "testCase4": {
15 |     "expectedResult": 0,
16 |     "input": "++1"
17 |   }
18 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/SymmetricTreeTest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "testCase1": {
 3 |     "expectedResult": true,
 4 |     "input": {
 5 |       "tree": {
 6 |         "nodes": [
 7 |           {"id": "1", "left": "2", "right": "5", "value": 1},
 8 |           {"id": "2", "left": "3", "right": "4", "value": 2},
 9 |           {"id": "3", "left": null, "right": null, "value": 3},
10 |           {"id": "4", "left": null, "right": null, "value": 4},
11 |           {"id": "5", "left": "6", "right": "7", "value": 2},
12 |           {"id": "6", "left": null, "right": null, "value": 4},
13 |           {"id": "7", "left": null, "right": null, "value": 3}
14 |         ],
15 |         "root": "1"
16 |       }
17 |     }
18 |   },
19 |   "testCase2": {
20 |     "expectedResult": false,
21 |     "input": {
22 |       "tree": {
23 |         "nodes": [
24 |           {"id": "1", "left": "2", "right": "4", "value": 1},
25 |           {"id": "2", "left": null, "right": "3", "value": 3},
26 |           {"id": "3", "left": null, "right": null, "value": 3},
27 |           {"id": "4", "left": null, "right": 5, "value": 2},
28 |           {"id": "5", "left": null, "right": null, "value": 3}
29 |           ],
30 |         "root": "1"
31 |       }
32 |     }
33 |   }
34 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/ThreeSumTest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "testCase1": {
 3 |     "expectedResult": [[-1,-1,2],[-1,0,1]],
 4 |     "input": [-1,0,1,2,-1,-4]
 5 |   },
 6 |   "testCase2": {
 7 |     "expectedResult": [],
 8 |     "input": []
 9 |   },
10 |   "testCase3": {
11 |     "expectedResult": [],
12 |     "input": [0]
13 |   },
14 |   "testCase4": {
15 |     "expectedResult": [[0,0,0]],
16 |     "input": [0,0,0]
17 |   },
18 |   "testCase5": {
19 |     "expectedResult": [[-5,1,4],[-4,0,4],[-4,1,3],[-2,-2,4],[-2,1,1],[0,0,0]],
20 |     "input": [-4,-2,1,-5,-4,-4,4,-2,0,4,0,-2,3,1,-5,0]
21 |   },
22 |   "testCase6": {
23 |     "expectedResult": [{"2":-15,"0":1,"1":14},{"2":-15,"0":2,"1":13},{"2":-15,"0":3,"1":12},{"2":-15,"0":4,"1":11},{"2":-15,"0":5,"1":10},{"2":-15,"0":6,"1":9},{"2":-15,"0":7,"1":8},{"2":-14,"0":0,"1":14},{"2":-14,"0":1,"1":13},{"2":-14,"0":2,"1":12},{"2":-14,"0":3,"1":11},{"2":-14,"0":4,"1":10},{"2":-14,"0":5,"1":9},{"2":-14,"0":6,"1":8},{"2":-14,"0":7,"1":7},{"2":-13,"0":-1,"1":14},{"2":-13,"0":0,"1":13},{"2":-13,"0":1,"1":12},{"2":-13,"0":2,"1":11},{"2":-13,"0":3,"1":10},{"2":-13,"0":4,"1":9},{"2":-13,"0":5,"1":8},{"2":-13,"0":6,"1":7},{"2":-12,"0":-2,"1":14},{"2":-12,"0":-1,"1":13},{"2":-12,"0":0,"1":12},{"2":-12,"0":1,"1":11},{"2":-12,"0":2,"1":10},{"2":-12,"0":3,"1":9},{"2":-12,"0":4,"1":8},{"2":-12,"0":5,"1":7},{"2":-12,"0":6,"1":6},{"2":-11,"0":-3,"1":14},{"2":-11,"0":-2,"1":13},{"2":-11,"0":-1,"1":12},{"2":-11,"0":0,"1":11},{"2":-11,"0":1,"1":10},{"2":-11,"0":2,"1":9},{"2":-11,"0":3,"1":8},{"2":-11,"0":4,"1":7},{"2":-11,"0":5,"1":6},{"2":-10,"0":-4,"1":14},{"2":-10,"0":-3,"1":13},{"2":-10,"0":-2,"1":12},{"2":-10,"0":-1,"1":11},{"2":-10,"0":0,"1":10},{"2":-10,"0":1,"1":9},{"2":-10,"0":2,"1":8},{"2":-10,"0":3,"1":7},{"2":-10,"0":4,"1":6},{"2":-10,"0":5,"1":5},{"2":-9,"0":-5,"1":14},{"2":-9,"0":-4,"1":13},{"2":-9,"0":-3,"1":12},{"2":-9,"0":-2,"1":11},{"2":-9,"0":-1,"1":10},{"2":-9,"0":0,"1":9},{"2":-9,"0":1,"1":8},{"2":-9,"0":2,"1":7},{"2":-9,"0":3,"1":6},{"2":-9,"0":4,"1":5},{"2":-8,"0":-6,"1":14},{"2":-8,"0":-5,"1":13},{"2":-8,"0":-4,"1":12},{"2":-8,"0":-3,"1":11},{"2":-8,"0":-2,"1":10},{"2":-8,"0":-1,"1":9},{"2":-8,"0":0,"1":8},{"2":-8,"0":1,"1":7},{"2":-8,"0":2,"1":6},{"2":-8,"0":3,"1":5},{"2":-8,"0":4,"1":4},{"0":-7,"2":-7,"1":14},{"2":-7,"0":-6,"1":13},{"2":-7,"0":-5,"1":12},{"2":-7,"0":-4,"1":11},{"2":-7,"0":-3,"1":10},{"2":-7,"0":-2,"1":9},{"2":-7,"0":-1,"1":8},{"2":-7,"0":0,"1":7},{"2":-7,"0":1,"1":6},{"2":-7,"0":2,"1":5},{"2":-7,"0":3,"1":4},{"0":-6,"2":-6,"1":12},{"2":-6,"0":-5,"1":11},{"2":-6,"0":-4,"1":10},{"2":-6,"0":-3,"1":9},{"2":-6,"0":-2,"1":8},{"2":-6,"0":-1,"1":7},{"2":-6,"0":0,"1":6},{"2":-6,"0":1,"1":5},{"2":-6,"0":2,"1":4},{"2":-6,"0":3,"1":3},{"0":-5,"2":-5,"1":10},{"2":-5,"0":-4,"1":9},{"2":-5,"0":-3,"1":8},{"2":-5,"0":-2,"1":7},{"2":-5,"0":-1,"1":6},{"2":-5,"0":0,"1":5},{"2":-5,"0":1,"1":4},{"2":-5,"0":2,"1":3},{"2":-4,"0":-3,"1":7},{"2":-4,"0":-2,"1":6},{"2":-4,"0":-1,"1":5},{"2":-4,"0":0,"1":4},{"2":-4,"0":1,"1":3},{"2":-4,"0":2,"1":2},{"0":-3,"2":-3,"1":6},{"2":-3,"0":-2,"1":5},{"2":-3,"0":-1,"1":4},{"2":-3,"0":0,"1":3},{"2":-3,"0":1,"1":2},{"2":-2,"0":-1,"1":3},{"2":-2,"0":0,"1":2},{"2":-2,"0":1,"1":1},{"2":-1,"0":0,"1":1},[0,0,0]],
24 |     "input": [-5,1,-10,2,-7,-13,-3,-8,2,-15,9,-3,-15,13,-6,-10,5,6,11,1,13,-12,14,6,11,4,13,-14,0,11,1,10,-11,6,-11,-10,8,2,-3,-13,-6,-9,-9,-6,11,-8,-9,1,13,9,9,3,13,0,-6,1,-10,-15,3,5,3,11,-8,0,2,-11,5,-13,6,9,-11,7,8,-13,8,4,-6,14,13,-15,1,7,-5,-1,-7,5,7,-2,-3,-13,10,7,13,9,-8,-8,13,12,-6,4,7,-10,-12,-8,-8,11,11,-6,3,9,-14,-11,2,-4,-5,10,8,-13,-7,12,-10,10]
25 |   },
26 |   "testCase7": {
27 |     "expectedResult": [[-1,0,1]],
28 |     "input": [-1,0,1,0]
29 |   }
30 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/TopKFrequentElementsTest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "testCase1": {
 3 |     "expectedResult": [1,2],
 4 |     "input": [[1,1,1,2,2,3],2]
 5 |   },
 6 |   "testCase2": {
 7 |     "expectedResult": [1],
 8 |     "input": [[1],1]
 9 |   }
10 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/TwoSumTest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "testCase1": {
 3 |     "expectedResult":[1,2] ,
 4 |     "input": {"nums" :[3,2,4],"target" : 6}
 5 |   },
 6 |   "testCase2": {
 7 |     "expectedResult": [0,1] ,
 8 |     "input": {"nums" :[2,7,11,15],"target" : 9}
 9 |   },
10 |   "testCase3": {
11 |     "expectedResult":[0,1] ,
12 |     "input": {"nums" :[3,3],"target" : 6}
13 |   }
14 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/ValidPalindromeIITest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "testCase1": {
 3 |     "expectedResult": false ,
 4 |     "input": "abcbaebg"
 5 |   },
 6 |   "testCase2": {
 7 |     "expectedResult": true ,
 8 |     "input": "abca"
 9 |   },
10 |   "testCase3": {
11 |     "expectedResult": true ,
12 |     "input": " "
13 |   },
14 |   "testCase4": {
15 |     "expectedResult": false ,
16 |     "input": "abc"
17 |   },
18 |   "testCase5": {
19 |     "expectedResult": true ,
20 |     "input": "aba"
21 |   }
22 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/ValidPalindromeTest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "testCase1": {
 3 |     "expectedResult": true ,
 4 |     "input": "A man, a plan, a canal: Panama"
 5 |   },
 6 |   "testCase2": {
 7 |     "expectedResult": false ,
 8 |     "input": "race a car"
 9 |   },
10 |   "testCase3": {
11 |     "expectedResult": true ,
12 |     "input": " "
13 |   },
14 |   "testCase4": {
15 |     "expectedResult": true ,
16 |     "input": "aa"
17 |   },
18 |   "testCase5": {
19 |     "expectedResult": false ,
20 |     "input": "ab"
21 |   },
22 |   "testCase6": {
23 |     "expectedResult": true ,
24 |     "input": "abba"
25 |   }
26 | }


--------------------------------------------------------------------------------
/Tests/Helper/InputFiles/ValidateBinarySearchTreeTest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "testCase1": {
 3 |     "expectedResult": true,
 4 |     "input": {
 5 |       "tree": {
 6 |         "nodes": [
 7 |           {"id": "10", "left": "5", "right": "15", "value": 10},
 8 |           {"id": "15", "left": "13", "right": "22", "value": 15},
 9 |           {"id": "22", "left": null, "right": null, "value": 22},
10 |           {"id": "13", "left": null, "right": "14", "value": 13},
11 |           {"id": "14", "left": null, "right": null, "value": 14},
12 |           {"id": "5", "left": "2", "right": "3", "value": 5},
13 |           {"id": "3", "left": null, "right": null, "value": 5},
14 |           {"id": "2", "left": "1", "right": null, "value": 2},
15 |           {"id": "1", "left": null, "right": null, "value": 1}
16 |         ],
17 |         "root": "10"
18 |       }
19 |     }
20 |   },
21 |   "testCase2": {
22 |     "expectedResult": true,
23 |     "input": {
24 |       "tree": {
25 |         "nodes": [
26 |           {"id": "10", "left": "5", "right": "15", "value": 10},
27 |           {"id": "15", "left": null, "right": "22", "value": 15},
28 |           {"id": "22", "left": null, "right": null, "value": 22},
29 |           {"id": "5", "left": "2", "right": "6", "value": 5},
30 |           {"id": "6", "left": null, "right": null, "value": 5},
31 |           {"id": "2", "left": "1", "right": null, "value": 2},
32 |           {"id": "1", "left": "-5", "right": null, "value": 1},
33 |           {"id": "-5", "left": "-15", "right": "3", "value": -5},
34 |           {"id": "3", "left": null, "right": "-2", "value": -5},
35 |           {"id": "-2", "left": null, "right": "-1", "value": -2},
36 |           {"id": "-1", "left": null, "right": null, "value": -1},
37 |           {"id": "-15", "left": "-22", "right": null, "value": -15},
38 |           {"id": "-22", "left": null, "right": null, "value": -22}
39 |         ],
40 |         "root": "10"
41 |       }
42 |     }
43 |   },
44 |   "testCase3": {
45 |     "expectedResult": false,
46 |     "input": {
47 |       "tree": {
48 |         "nodes": [
49 |           {"id": "100", "left": "5", "right": "502", "value": 100},
50 |           {"id": "502", "left": "204", "right": "55000", "value": 502},
51 |           {"id": "55000", "left": null, "right": null, "value": 55000},
52 |           {"id": "204", "left": "203", "right": "205", "value": 204},
53 |           {"id": "205", "left": "300", "right": "207", "value": 205},
54 |           {"id": "207", "left": "206", "right": "208", "value": 207},
55 |           {"id": "208", "left": null, "right": null, "value": 208},
56 |           {"id": "206", "left": null, "right": null, "value": 206},
57 |           {"id": "300", "left": null, "right": null, "value": 300},
58 |           {"id": "203", "left": null, "right": null, "value": 203},
59 |           {"id": "5", "left": "2", "right": "15", "value": 5},
60 |           {"id": "15", "left": "50", "right": "22", "value": 15},
61 |           {"id": "22", "left": null, "right": null, "value": 22},
62 |           {"id": "50", "left": null, "right": null, "value": 5},
63 |           {"id": "2", "left": "1", "right": "3", "value": 2},
64 |           {"id": "3", "left": null, "right": null, "value": 3},
65 |           {"id": "1", "left": null, "right": "6", "value": 1},
66 |           {"id": "6", "left": null, "right": "7", "value": 1},
67 |           {"id": "7", "left": null, "right": "8", "value": 1},
68 |           {"id": "8", "left": null, "right": "9", "value": 1},
69 |           {"id": "9", "left": null, "right": null, "value": 1}
70 |         ],
71 |         "root": "100"
72 |       }
73 |     }
74 |   }
75 | }


--------------------------------------------------------------------------------
/Tests/Helper/LinkedListHelperTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tests\Helper;
 4 | 
 5 | use Hakam\LeetCodePhp\LinkedList\ListNode;
 6 | 
 7 | /**
 8 |  * @codeCoverageIgnore
 9 |  */
10 | trait LinkedListHelperTrait
11 | {
12 |     protected function convertToArray(?ListNode $node): ?array
13 |     {
14 |         $list = [];
15 |         while ($node !== null) {
16 |             $list[] = $node->val;
17 |             $node = $node->next;
18 |         }
19 |         return $list;
20 |     }
21 | 
22 |     protected function convertFromArray(array $arrayList): ?ListNode
23 |     {
24 |         $list = new ListNode();
25 |         $head = $list;
26 |         foreach ($arrayList as $nodeValue) {
27 |             $list->next = new ListNode($nodeValue);
28 |             $list = $list->next;
29 |         }
30 |         return $head->next;
31 |     }
32 | }


--------------------------------------------------------------------------------
/Tests/Helper/MainTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tests\Helper;
 4 | 
 5 | use JsonException;
 6 | use PHPUnit\Framework\TestCase;
 7 | use ReflectionClass;
 8 | 
 9 | /**
10 |  * @codeCoverageIgnore
11 |  */
12 | abstract class MainTest extends TestCase
13 | {
14 |     /**
15 |      * @dataProvider provideData
16 |      */
17 |     abstract public function testWithDataList($expectedResult, $inputData) :void;
18 | 
19 |     /**
20 |      * @throws JsonException
21 |      */
22 |     public function provideData(): array
23 |     {
24 |         $inputFile = file_get_contents( __DIR__ . "/InputFiles/" . (new ReflectionClass(static::class))->getShortName() . ".json");
25 |         return json_decode($inputFile, true, 512, JSON_THROW_ON_ERROR);
26 |     }
27 | }


--------------------------------------------------------------------------------
/Tests/Helper/TreeHelperTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tests\Helper;
 4 | 
 5 | use Hakam\LeetCodePhp\Tree\TreeNode;
 6 | 
 7 | /**
 8 |  * @codeCoverageIgnore
 9 |  */
10 | trait TreeHelperTrait
11 | {
12 |     private  $list = [];
13 | 
14 |     /**
15 |      * @param array|null $treeList
16 |      * @return TreeNode
17 |      * @codeCoverageIgnore
18 |      */
19 |     protected function createBinaryTree(?array $treeList)
20 |     {
21 |         $this->list = $treeList['tree']['nodes'];
22 |         return $this->createTreeNode($this->findNodeById($treeList['tree']['root']));
23 |     }
24 | 
25 |     /**
26 |      * @param array $nodeData
27 |      * @return TreeNode
28 |      * @codeCoverageIgnore
29 |      */
30 | 
31 |     private function createTreeNode(array $nodeData)
32 |     {
33 |         $nodeRoot = new TreeNode($nodeData['value']);
34 |         if ($nodeData['left'] !== null) {
35 |             $nodeRoot->left = $this->createTreeNode(
36 |                 $this->findNodeById($nodeData['left']));
37 |         }
38 |         if ($nodeData['right'] !== null) {
39 |             $nodeRoot->right = $this->createTreeNode(
40 |                 $this->findNodeById($nodeData['right']));
41 |         }
42 |         return $nodeRoot;
43 |     }
44 | 
45 | 
46 |     private function findNodeById( string $id)
47 |     {
48 |       $node =  array_filter($this->list, static function ($nodeData) use ($id) {
49 |             if($id === $nodeData['id'])
50 |             {
51 |                 return $nodeData;
52 |             }
53 |         });
54 | 
55 |       return array_shift($node);
56 |     }
57 | }


--------------------------------------------------------------------------------
/Tests/LinkedList/ListNodeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tests\LinkedList;
 4 | 
 5 | use Hakam\LeetCodePhp\LinkedList\ListNode;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | /**
 9 |  * @covers \Hakam\LeetCodePhp\LinkedList\ListNode
10 |  */
11 | class ListNodeTest extends TestCase
12 | {
13 |     public function testCanCreateALinkedList()
14 |     {
15 |         $list = new ListNode(0);
16 |         $list->next = new ListNode(1);
17 |         $list->next->next = new ListNode(3);
18 |         self::assertInstanceOf(ListNode::class,$list);
19 |         self::assertInstanceOf(ListNode::class,$list->next);
20 |         self::assertInstanceOf(ListNode::class,$list->next->next);
21 |     }
22 | 
23 | }


--------------------------------------------------------------------------------
/Tests/LinkedList/MergedToSortedListTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tests\LinkedList;
 4 | 
 5 | use Hakam\LeetCodePhp\LinkedList\MergedToSortedList;
 6 | use Hakam\LeetCodePhp\Tests\Helper\LinkedListHelperTrait;
 7 | use Hakam\LeetCodePhp\Tests\Helper\MainTest;
 8 | 
 9 | /**
10 |  * @covers \Hakam\LeetCodePhp\LinkedList\MergedToSortedList
11 |  */
12 | class MergedToSortedListTest extends MainTest
13 | {
14 |     use LinkedListHelperTrait;
15 | 
16 |     /**
17 |      * @dataProvider provideData
18 |      */
19 |     public function testWithDataList($expectedResult, $inputData): void
20 |     {
21 |         $inputData = array_values($inputData);
22 |         $this->addToAssertionCount(1);
23 |         $mergeTwoSortedList = new MergedToSortedList();
24 |         $mergedList = $mergeTwoSortedList->mergeTwoLists(
25 |             $this->convertFromArray($inputData[0] ?? []),
26 |             $this->convertFromArray($inputData[1] ?? []));
27 | 
28 |         self::assertEmpty(array_diff($expectedResult, $this->convertToArray($mergedList)));
29 |     }
30 | }


--------------------------------------------------------------------------------
/Tests/LinkedList/ReOrderListTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tests\LinkedList;
 4 | 
 5 | use Hakam\LeetCodePhp\LinkedList\ListNode;
 6 | use Hakam\LeetCodePhp\LinkedList\ReOrderList;
 7 | use Hakam\LeetCodePhp\Tests\Helper\LinkedListHelperTrait;
 8 | use Hakam\LeetCodePhp\Tests\Helper\MainTest;
 9 | 
10 | /**
11 |  * @covers \Hakam\LeetCodePhp\LinkedList\ReOrderList
12 |  */
13 | class ReOrderListTest extends MainTest
14 | {
15 |     use LinkedListHelperTrait;
16 |     /**
17 |      * @dataProvider provideData
18 |      */
19 |     public function testWithDataList($expectedResult, $inputData): void
20 |     {
21 |         $orderList = new ReOrderList();
22 | 
23 |         self::assertEmpty(array_diff(
24 |             $expectedResult,
25 |             $this->convertToArray(
26 |                 $orderList->reorderList($this->createLinkedListFromInput($inputData))))
27 |         );
28 |     }
29 | 
30 |     private function createLinkedListFromInput(array $input): ListNode
31 |     {
32 |         $head = new ListNode(array_shift($input));
33 |         $list = $head;
34 |         foreach ($input as $value)
35 |         {
36 |             $node = new ListNode($value);
37 |             $head->next = $node;
38 |             $head = $head->next;
39 |         }
40 |         return $list;
41 |     }
42 | }


--------------------------------------------------------------------------------
/Tests/LinkedList/RemoveNthNodeFromEndOfListTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tests\LinkedList;
 4 | 
 5 | 
 6 | use Hakam\LeetCodePhp\LinkedList\RemoveNthNodeFromEndOfList;
 7 | use Hakam\LeetCodePhp\Tests\Helper\LinkedListHelperTrait;
 8 | use Hakam\LeetCodePhp\Tests\Helper\MainTest;
 9 | 
10 | /**
11 |  * @covers \Hakam\LeetCodePhp\LinkedList\RemoveNthNodeFromEndOfList
12 |  */
13 | class RemoveNthNodeFromEndOfListTest extends MainTest
14 | {
15 |     use LinkedListHelperTrait;
16 | 
17 |     /**
18 |      * @dataProvider provideData
19 |      */
20 |     public function testWithDataList($expectedResult, $inputData): void
21 |     {
22 |         $list = $this->convertFromArray($inputData[0]);
23 |         $remover = new RemoveNthNodeFromEndOfList();
24 |         self::assertEmpty(array_diff($expectedResult,
25 |             $this->convertToArray(
26 |                 $remover->removeNthFromEnd($list,$inputData[1]))
27 |         ));
28 |     }
29 | }


--------------------------------------------------------------------------------
/Tests/LinkedList/ReverseLinkedListIITest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tests\LinkedList;
 4 | 
 5 | use Hakam\LeetCodePhp\LinkedList\ReverseLinkedListII;
 6 | use Hakam\LeetCodePhp\Tests\Helper\LinkedListHelperTrait;
 7 | use Hakam\LeetCodePhp\Tests\Helper\MainTest;
 8 | 
 9 | /**
10 |  * @covers \Hakam\LeetCodePhp\LinkedList\ReverseLinkedListII
11 |  */
12 | class ReverseLinkedListIITest extends MainTest
13 | {
14 |     use LinkedListHelperTrait;
15 | 
16 |     /**
17 |      * @dataProvider provideData
18 |      */
19 |     public function testWithDataList($expectedResult, $inputData): void
20 |     {
21 |         $reversList = new ReverseLinkedListII();
22 |         $list = $this->convertFromArray($inputData[0]);
23 |         self::assertEmpty(array_diff($expectedResult,
24 |             $this->convertToArray($reversList->reverseBetween($list,$inputData[1],$inputData[2]))));
25 |     }
26 | }


--------------------------------------------------------------------------------
/Tests/LinkedList/ReverseLinkedListTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tests\LinkedList;
 4 | 
 5 | use Hakam\LeetCodePhp\LinkedList\ReverseLinkedList;
 6 | use Hakam\LeetCodePhp\Tests\Helper\LinkedListHelperTrait;
 7 | use Hakam\LeetCodePhp\Tests\Helper\MainTest;
 8 | 
 9 | /**
10 |  * @covers \Hakam\LeetCodePhp\LinkedList\ReverseLinkedList
11 |  */
12 | class ReverseLinkedListTest extends MainTest
13 | {
14 |     use LinkedListHelperTrait;
15 |     /**
16 |      * @dataProvider provideData
17 |      */
18 |     public function testWithDataList($expectedResult, $inputData): void
19 |     {
20 |         $reversList = new ReverseLinkedList();
21 |         $list = $this->convertFromArray($inputData);
22 |         self::assertEmpty(array_diff($expectedResult,
23 |             $this->convertToArray($reversList->reverseList($list))));
24 |     }
25 | }


--------------------------------------------------------------------------------
/Tests/String/FindAllAnagramsInAStringTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tests\String;
 4 | 
 5 | use Hakam\LeetCodePhp\String\FindAllAnagramsInAString;
 6 | use Hakam\LeetCodePhp\Tests\Helper\MainTest;
 7 | 
 8 | /**
 9 |  * @covers \Hakam\LeetCodePhp\String\FindAllAnagramsInAString
10 |  */
11 | class FindAllAnagramsInAStringTest extends MainTest
12 | {
13 |     /**
14 |      * @dataProvider provideData
15 |      */
16 |     public function testWithDataList($expectedResult, $inputData): void
17 |     {
18 |         $findAllAnagrams = new FindAllAnagramsInAString();
19 |         self::assertEmpty(array_diff($expectedResult,$findAllAnagrams->findAnagrams(...$inputData)));
20 |     }
21 | }


--------------------------------------------------------------------------------
/Tests/String/GroupAnagramsTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tests\String;
 4 | 
 5 | use Hakam\LeetCodePhp\String\GroupAnagrams;
 6 | use Hakam\LeetCodePhp\Tests\Helper\MainTest;
 7 | 
 8 | /**
 9 |  * @covers \Hakam\LeetCodePhp\String\GroupAnagrams
10 |  */
11 | class GroupAnagramsTest extends MainTest
12 | {
13 |     /**
14 |      * @dataProvider provideData
15 |      */
16 |     public function testWithDataList($expectedResult, $inputData): void
17 |     {
18 |         $groupAnagrams = new GroupAnagrams();
19 |         $result = $groupAnagrams->groupAnagrams($inputData);
20 |         foreach ($result as $item) {
21 |             self::assertContains($item, $expectedResult);
22 |         }
23 |     }
24 | }


--------------------------------------------------------------------------------
/Tests/String/LongestSubstringWithAtMostKDistinctCharactersTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tests\String;
 4 | 
 5 | use Hakam\LeetCodePhp\String\LongestSubstringWithAtMostKDistinctCharacters;
 6 | use Hakam\LeetCodePhp\Tests\Helper\MainTest;
 7 | 
 8 | /**
 9 |  * @covers \Hakam\LeetCodePhp\String\LongestSubstringWithAtMostKDistinctCharacters
10 |  */
11 | class LongestSubstringWithAtMostKDistinctCharactersTest extends MainTest
12 | {
13 | 
14 |     /**
15 |      * @dataProvider provideData
16 |      */
17 |     public function testWithDataList($expectedResult, $inputData): void
18 |     {
19 |         $findLongestSubString = new LongestSubstringWithAtMostKDistinctCharacters();
20 |         self::assertEquals($expectedResult,$findLongestSubString->lengthOfLongestSubstringKDistinct(...$inputData));
21 |     }
22 | }


--------------------------------------------------------------------------------
/Tests/String/LongestSubstringWithAtMostTwoDistinctCharactersTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tests\String;
 4 | 
 5 | use Hakam\LeetCodePhp\String\LongestSubstringWithAtMostTwoDistinctCharacters;
 6 | use Hakam\LeetCodePhp\Tests\Helper\MainTest;
 7 | 
 8 | /**
 9 |  * @covers \Hakam\LeetCodePhp\String\LongestSubstringWithAtMostTwoDistinctCharacters
10 |  */
11 | class LongestSubstringWithAtMostTwoDistinctCharactersTest extends MainTest
12 | {
13 |     /**
14 |      * @dataProvider provideData
15 |      */
16 |     public function testWithDataList($expectedResult, $inputData): void
17 |     {
18 |         $findLongestSubString = new LongestSubstringWithAtMostTwoDistinctCharacters();
19 |         self::assertEquals($expectedResult,$findLongestSubString->lengthOfLongestSubstringTwoDistinct($inputData[0]));
20 |     }
21 | }


--------------------------------------------------------------------------------
/Tests/String/LongestSubstringWithoutRepeatingCharactersTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tests\String;
 4 | 
 5 | use Hakam\LeetCodePhp\String\LongestSubstringWithoutRepeatingCharacters;
 6 | use Hakam\LeetCodePhp\Tests\Helper\MainTest;
 7 | 
 8 | /**
 9 |  * @covers \Hakam\LeetCodePhp\String\LongestSubstringWithoutRepeatingCharacters
10 |  */
11 | class LongestSubstringWithoutRepeatingCharactersTest extends MainTest
12 | {
13 |     /**
14 |      * @dataProvider provideData
15 |      */
16 |     public function testWithDataList($expectedResult, $inputData): void
17 |     {
18 |         $longestSubString = new LongestSubstringWithoutRepeatingCharacters();
19 |         self::assertEquals($expectedResult,$longestSubString->lengthOfLongestSubstring($inputData));
20 |     }
21 | }


--------------------------------------------------------------------------------
/Tests/String/RemoveAllAdjacentDuplicatesInStringTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tests\String;
 4 | 
 5 | use Hakam\LeetCodePhp\String\RemoveAllAdjacentDuplicatesInString;
 6 | use Hakam\LeetCodePhp\Tests\Helper\MainTest;
 7 | 
 8 | /**
 9 |  * @covers \Hakam\LeetCodePhp\String\RemoveAllAdjacentDuplicatesInString
10 |  */
11 | class RemoveAllAdjacentDuplicatesInStringTest extends MainTest
12 | {
13 |     /**
14 |      * @dataProvider provideData
15 |      */
16 |     public function testWithDataList($expectedResult, $inputData): void
17 |     {
18 |         $remover = new RemoveAllAdjacentDuplicatesInString();
19 |         $value =$remover->removeDuplicates($inputData);
20 |         self::assertEquals($expectedResult,$value);
21 |     }
22 | 
23 | }


--------------------------------------------------------------------------------
/Tests/String/RomanToIntTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tests\String;
 4 | 
 5 | use Hakam\LeetCodePhp\String\RomanToInteger;
 6 | use Hakam\LeetCodePhp\Tests\Helper\MainTest;
 7 | 
 8 | /**
 9 |  * @covers \Hakam\LeetCodePhp\String\RomanToInteger
10 |  */
11 | class RomanToIntTest extends MainTest
12 | {
13 |     /**
14 |      * @dataProvider provideData
15 |      */
16 |     public function testWithDataList($expectedResult, $inputData): void
17 |     {
18 |         $romanToInt = new RomanToInteger();
19 |         self::assertEquals($expectedResult,$romanToInt->romanToInt($inputData));
20 |     }
21 | }


--------------------------------------------------------------------------------
/Tests/String/StringToIntegerTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tests\String;
 4 | 
 5 | use Hakam\LeetCodePhp\String\StringToInteger;
 6 | use Hakam\LeetCodePhp\Tests\Helper\MainTest;
 7 | 
 8 | /**
 9 |  * @covers \Hakam\LeetCodePhp\String\StringToInteger
10 |  */
11 | class StringToIntegerTest extends MainTest
12 | {
13 |     /**
14 |      * @dataProvider provideData
15 |      */
16 |     public function testWithDataList($expectedResult, $inputData): void
17 |     {
18 |         $stringToInteger = new StringToInteger();
19 |         self::assertEquals($expectedResult,$stringToInteger->myAtoi($inputData));
20 |     }
21 | }


--------------------------------------------------------------------------------
/Tests/String/ValidPalindromeIITest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tests\String;
 4 | 
 5 | use Hakam\LeetCodePhp\String\ValidPalindromeII;
 6 | use Hakam\LeetCodePhp\Tests\Helper\MainTest;
 7 | 
 8 | /**
 9 |  * @covers \Hakam\LeetCodePhp\String\ValidPalindromeII
10 |  */
11 | class ValidPalindromeIITest extends MainTest
12 | {
13 |     /**
14 |      * @dataProvider provideData
15 |      */
16 |     public function testWithDataList($expectedResult, $inputData): void
17 |     {
18 |         $validatePalindrome = new ValidPalindromeII();
19 |         self::assertEquals($expectedResult,$validatePalindrome->validPalindrome($inputData));
20 |     }
21 | }


--------------------------------------------------------------------------------
/Tests/String/ValidPalindromeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tests\String;
 4 | 
 5 | use Hakam\LeetCodePhp\String\ValidPalindrome;
 6 | use Hakam\LeetCodePhp\Tests\Helper\MainTest;
 7 | 
 8 | /**
 9 |  * @covers \Hakam\LeetCodePhp\String\ValidPalindrome
10 |  */
11 | class ValidPalindromeTest extends MainTest
12 | {
13 | 
14 |     /**
15 |      * @dataProvider provideData
16 |      */
17 |     public function testWithDataList($expectedResult, $inputData): void
18 |     {
19 |         $validatePalindrome = new ValidPalindrome();
20 |         self::assertEquals($expectedResult,$validatePalindrome->isPalindromeByIteration($inputData));
21 |     }
22 | }


--------------------------------------------------------------------------------
/Tests/Tree/BinaryTreeLevelOrderTraversalTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tests\Tree;
 4 | 
 5 | use Hakam\LeetCodePhp\Tests\Helper\MainTest;
 6 | use Hakam\LeetCodePhp\Tests\Helper\TreeHelperTrait;
 7 | use Hakam\LeetCodePhp\Tree\BinaryTreeLevelOrderTraversal;
 8 | 
 9 | /**
10 |  * @covers \Hakam\LeetCodePhp\Tree\BinaryTreeLevelOrderTraversal
11 |  */
12 | class BinaryTreeLevelOrderTraversalTest extends MainTest
13 | {
14 |    use TreeHelperTrait;
15 | 
16 |     /**
17 |      * @dataProvider provideData
18 |      */
19 |     public function testWithDataList($expectedResult, $inputData): void
20 |     {
21 |         $tree = $this->createBinaryTree($inputData);
22 |         $binaryTreeLevelOrder = new BinaryTreeLevelOrderTraversal();
23 |         $result = $binaryTreeLevelOrder->levelOrder($tree);
24 |         self::assertEmpty(array_diff(array_merge(...$expectedResult),array_merge(...$result)));
25 |     }
26 | }


--------------------------------------------------------------------------------
/Tests/Tree/BinaryTreePathsTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tests\Tree;
 4 | 
 5 | use Hakam\LeetCodePhp\Tests\Helper\MainTest;
 6 | use Hakam\LeetCodePhp\Tests\Helper\TreeHelperTrait;
 7 | use Hakam\LeetCodePhp\Tree\BinaryTreePaths;
 8 | 
 9 | /**
10 |  * @covers \Hakam\LeetCodePhp\Tree\BinaryTreePaths
11 |  */
12 | class BinaryTreePathsTest extends MainTest
13 | {
14 |     use TreeHelperTrait;
15 |     /**
16 |      * @dataProvider provideData
17 |      */
18 |     public function testWithDataList($expectedResult, $inputData): void
19 |     {
20 |        $tree = $this->createBinaryTree($inputData);
21 |        $binaryPaths = new BinaryTreePaths();
22 |        self::assertEmpty(array_diff($expectedResult,$binaryPaths->binaryTreePaths($tree)));
23 |     }
24 | }


--------------------------------------------------------------------------------
/Tests/Tree/BinaryTreePostorderTraversalTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tests\Tree;
 4 | 
 5 | use Hakam\LeetCodePhp\Tests\Helper\MainTest;
 6 | use Hakam\LeetCodePhp\Tests\Helper\TreeHelperTrait;
 7 | use Hakam\LeetCodePhp\Tree\BinaryTreePostorderTraversal;
 8 | 
 9 | /**
10 |  * @covers \Hakam\LeetCodePhp\Tree\BinaryTreePostorderTraversal
11 |  */
12 | class BinaryTreePostorderTraversalTest extends MainTest
13 | {
14 |     use TreeHelperTrait;
15 | 
16 |     /**
17 |      * @dataProvider provideData
18 |      */
19 |     public function testWithDataList($expectedResult, $inputData): void
20 |     {
21 |         $tree = $this->createBinaryTree($inputData);
22 |         $postorderTraversal = new BinaryTreePostorderTraversal();
23 |         $result = $postorderTraversal->postorderTraversalBYRecursion($tree);
24 |         self::assertEmpty(array_diff($result, $expectedResult));
25 |     }
26 | 
27 | 
28 |     /**
29 |      * @dataProvider provideData
30 |      */
31 |     public function testWithDataListByIteration($expectedResult, $inputData): void
32 |     {
33 |         $tree = $this->createBinaryTree($inputData);
34 |         $preorderTraversal = new BinaryTreePostorderTraversal();
35 |         $result = $preorderTraversal->postorderTraversalBYIneration($tree);
36 |         self::assertEmpty(array_diff($result, $expectedResult));
37 |     }
38 | 
39 | }


--------------------------------------------------------------------------------
/Tests/Tree/BinaryTreePreorderTraversalTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tests\Tree;
 4 | 
 5 | use Hakam\LeetCodePhp\Tests\Helper\MainTest;
 6 | use Hakam\LeetCodePhp\Tests\Helper\TreeHelperTrait;
 7 | use Hakam\LeetCodePhp\Tree\BinaryTreePreorderTraversal;
 8 | 
 9 | /**
10 |  * @covers \Hakam\LeetCodePhp\Tree\BinaryTreePreorderTraversal
11 |  */
12 | class BinaryTreePreorderTraversalTest extends MainTest
13 | {
14 |     use TreeHelperTrait;
15 |     /**
16 |      * @dataProvider provideData
17 |      */
18 |     public function testWithDataList($expectedResult, $inputData): void
19 |     {
20 |         $tree=$this->createBinaryTree($inputData);
21 |         $preorderTraversal = new BinaryTreePreorderTraversal();
22 |         $result = $preorderTraversal->preorderTraversalBYRecursion($tree);
23 |         self::assertEmpty(array_diff($result,$expectedResult));
24 |     }
25 | 
26 | 
27 |     /**
28 |      * @dataProvider provideData
29 |      */
30 |     public function testWithDataListByIteration($expectedResult, $inputData): void
31 |     {
32 |         $tree=$this->createBinaryTree($inputData);
33 |         $preorderTraversal = new BinaryTreePreorderTraversal();
34 |         $result = $preorderTraversal->preorderTraversalBYIneration($tree);
35 |         self::assertEmpty(array_diff($result,$expectedResult));
36 |     }
37 | }


--------------------------------------------------------------------------------
/Tests/Tree/BinaryTreeRightSideViewTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tests\Tree;
 4 | 
 5 | use Hakam\LeetCodePhp\Tests\Helper\MainTest;
 6 | use Hakam\LeetCodePhp\Tests\Helper\TreeHelperTrait;
 7 | use Hakam\LeetCodePhp\Tree\BinaryTreeRightSideView;
 8 | 
 9 | /**
10 |  * @covers \Hakam\LeetCodePhp\Tree\BinaryTreeRightSideView
11 |  */
12 | class BinaryTreeRightSideViewTest extends MainTest
13 | {
14 |     use TreeHelperTrait;
15 |     /**
16 |      * @dataProvider provideData
17 |      */
18 |     public function testWithDataList($expectedResult, $inputData): void
19 |     {
20 |         $tree = $this->createBinaryTree($inputData);
21 |         $rightSideView = new BinaryTreeRightSideView();
22 |        self::assertEmpty(array_diff($expectedResult,$rightSideView->rightSideView($tree)));
23 |     }
24 | 
25 | 
26 | }


--------------------------------------------------------------------------------
/Tests/Tree/BinaryTreeVerticalOrderTraversalTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tests\Tree;
 4 | 
 5 | use Hakam\LeetCodePhp\Tests\Helper\MainTest;
 6 | use Hakam\LeetCodePhp\Tests\Helper\TreeHelperTrait;
 7 | use Hakam\LeetCodePhp\Tree\BinaryTreeVerticalOrderTraversal;
 8 | 
 9 | /**
10 |  * @covers \Hakam\LeetCodePhp\Tree\BinaryTreeVerticalOrderTraversal
11 |  */
12 | class BinaryTreeVerticalOrderTraversalTest extends MainTest
13 | {
14 |     use TreeHelperTrait;
15 |     /**
16 |      * @dataProvider provideData
17 |      */
18 |     public function testWithDataList($expectedResult, $inputData): void
19 |     {
20 |       $tree =  $this->createBinaryTree($inputData);
21 |       $verticalOrder = new BinaryTreeVerticalOrderTraversal();
22 |       $result = $verticalOrder->verticalOrder($tree);
23 |       while (count($expectedResult) !== 0 )
24 |       {
25 |           $value = array_diff(array_shift($expectedResult),array_shift($result));
26 |           self::assertEmpty($value);
27 |       }
28 |     }
29 | }


--------------------------------------------------------------------------------
/Tests/Tree/ConvertSortedArrayToBinarySearchTreeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tests\Tree;
 4 | 
 5 | use Hakam\LeetCodePhp\Tests\Helper\MainTest;
 6 | use Hakam\LeetCodePhp\Tree\ConvertSortedArrayToBinarySearchTree;
 7 | use Hakam\LeetCodePhp\Tree\TreeNode;
 8 | use Hakam\LeetCodePhp\Tree\ValidateBinarySearchTree;
 9 | 
10 | /**
11 |  * @covers \Hakam\LeetCodePhp\Tree\ConvertSortedArrayToBinarySearchTree
12 |  */
13 | class ConvertSortedArrayToBinarySearchTreeTest extends MainTest
14 | {
15 | 
16 |     /**
17 |      * @dataProvider provideData
18 |      * @covers \Hakam\LeetCodePhp\Tree\ConvertSortedArrayToBinarySearchTree::sortedArrayToBST
19 |      * @covers \Hakam\LeetCodePhp\Tree\ConvertSortedArrayToBinarySearchTree::createTreeNode
20 |      * @covers   \Hakam\LeetCodePhp\Tree\ValidateBinarySearchTree::validate()
21 |      * @covers   \Hakam\LeetCodePhp\Tree\ValidateBinarySearchTree::isValidBST()
22 |      * @covers   \Hakam\LeetCodePhp\Tree\ValidateBinarySearchTree
23 |      */
24 |     public function testWithDataList($expectedResult, $inputData): void
25 |     {
26 |        $convertSortedArrayToBST = new ConvertSortedArrayToBinarySearchTree();
27 |        $result = $convertSortedArrayToBST->sortedArrayToBST($inputData);
28 |        self::assertEquals($expectedResult,$this->validatedBSTFromBSTSolution($result));
29 |     }
30 | 
31 |     /**
32 |      * @param TreeNode $treeNode
33 |      * @return bool
34 |      */
35 |     private function validatedBSTFromBSTSolution(TreeNode $treeNode): bool
36 |     {
37 |         $treeValidator = new ValidateBinarySearchTree();
38 |         return $treeValidator->isValidBST($treeNode);
39 | 
40 |     }
41 | }


--------------------------------------------------------------------------------
/Tests/Tree/CountUniValueSubtreesTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tests\Tree;
 4 | 
 5 | use Hakam\LeetCodePhp\Tests\Helper\MainTest;
 6 | use Hakam\LeetCodePhp\Tests\Helper\TreeHelperTrait;
 7 | use Hakam\LeetCodePhp\Tree\CountUniValueSubtrees;
 8 | 
 9 | /**
10 |  * @covers \Hakam\LeetCodePhp\Tree\CountUniValueSubtrees
11 |  */
12 | class CountUniValueSubtreesTest extends MainTest
13 | {
14 |     use TreeHelperTrait;
15 |     /**
16 |      * @dataProvider provideData
17 |      * @covers \Hakam\LeetCodePhp\Tree\CountUniValueSubtrees::countUnivalSubtrees
18 |      */
19 |     public function testWithDataList($expectedResult, $inputData): void
20 |     {
21 |         $tree = $this->createBinaryTree($inputData);
22 |         $countUniValue = new CountUniValueSubtrees();
23 |         self::assertEquals($expectedResult,$countUniValue->countUnivalSubtrees($tree));
24 |     }
25 | }


--------------------------------------------------------------------------------
/Tests/Tree/DiameterOfBinaryTreeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tests\Tree;
 4 | 
 5 | use Hakam\LeetCodePhp\Tests\Helper\MainTest;
 6 | use Hakam\LeetCodePhp\Tests\Helper\TreeHelperTrait;
 7 | use Hakam\LeetCodePhp\Tree\DiameterOfBinaryTree;
 8 | 
 9 | /**
10 |  * @covers \Hakam\LeetCodePhp\Tree\DiameterOfBinaryTree
11 |  */
12 | class DiameterOfBinaryTreeTest extends MainTest
13 | {
14 |     use TreeHelperTrait;
15 |     /**
16 |      * @dataProvider provideData
17 |      */
18 |     public function testWithDataList($expectedResult, $inputData): void
19 |     {
20 |         $tree = $this->createBinaryTree($inputData);
21 |         $diameter = new DiameterOfBinaryTree();
22 |         self::assertEquals($expectedResult,$diameter->diameterOfBinaryTree($tree));
23 |     }
24 | }


--------------------------------------------------------------------------------
/Tests/Tree/FlattenBinaryTreeToLinkedListTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tests\Tree;
 4 | 
 5 | use Hakam\LeetCodePhp\Tests\Helper\MainTest;
 6 | use Hakam\LeetCodePhp\Tests\Helper\TreeHelperTrait;
 7 | use Hakam\LeetCodePhp\Tree\FlattenBinaryTreeToLinkedList;
 8 | use Hakam\LeetCodePhp\Tree\TreeNode;
 9 | 
10 | /**
11 |  * @covers \Hakam\LeetCodePhp\Tree\FlattenBinaryTreeToLinkedList
12 |  */
13 | class FlattenBinaryTreeToLinkedListTest extends MainTest
14 | {
15 |     use TreeHelperTrait;
16 |     /**
17 |      * @dataProvider provideData
18 |      */
19 |     public function testWithDataList($expectedResult, $inputData): void
20 |     {
21 |         $tree = $this->createBinaryTree($inputData);
22 |         $flattenBinary = new FlattenBinaryTreeToLinkedList();
23 |         $flattenBinary->flatten($tree);
24 |         $list = $this->getArrayFromTreeNode($tree);
25 |         self::assertEmpty(array_diff(array_filter($expectedResult),$list));
26 |     }
27 | 
28 |     private function getArrayFromTreeNode(TreeNode $treeNode)
29 |     {
30 |         $list = [];
31 |         while ($treeNode !== null)
32 |         {
33 |             $list [] = $treeNode->val;
34 |             $treeNode = $treeNode->right;
35 |         }
36 |         return $list;
37 |     }
38 | }


--------------------------------------------------------------------------------
/Tests/Tree/MaximumDepthOfBinaryTreeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tests\Tree;
 4 | 
 5 | use Hakam\LeetCodePhp\Tests\Helper\MainTest;
 6 | use Hakam\LeetCodePhp\Tests\Helper\TreeHelperTrait;
 7 | use Hakam\LeetCodePhp\Tree\MaximumDepthOfBinaryTree;
 8 | 
 9 | /**
10 |  * @covers \Hakam\LeetCodePhp\Tree\MaximumDepthOfBinaryTree
11 |  */
12 | class MaximumDepthOfBinaryTreeTest extends MainTest
13 | {
14 |     use TreeHelperTrait;
15 |     /**
16 |      * @dataProvider provideData
17 |      */
18 |     public function testWithDataList($expectedResult, $inputData): void
19 |     {
20 |         $tree = $this->createBinaryTree($inputData);
21 |         $maxDepth = new MaximumDepthOfBinaryTree();
22 | 
23 |         self::assertEquals($expectedResult, $maxDepth->maxDepth($tree));
24 |     }
25 | 
26 | }


--------------------------------------------------------------------------------
/Tests/Tree/PathSumTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tests\Tree;
 4 | 
 5 | use Hakam\LeetCodePhp\Tests\Helper\MainTest;
 6 | use Hakam\LeetCodePhp\Tests\Helper\TreeHelperTrait;
 7 | use Hakam\LeetCodePhp\Tree\PathSum;
 8 | 
 9 | /**
10 |  * @covers \Hakam\LeetCodePhp\Tree\PathSum
11 |  */
12 | class PathSumTest extends MainTest
13 | {
14 |     use TreeHelperTrait;
15 |     /**
16 |      * @dataProvider provideData
17 |      */
18 |     public function testWithDataList($expectedResult, $inputData): void
19 |     {
20 |         $tree = $this->createBinaryTree($inputData);
21 |         $pathSum = new PathSum();
22 |         self::assertEquals($expectedResult,$pathSum->hasPathSum($tree,$inputData['sum']));
23 |     }
24 | }


--------------------------------------------------------------------------------
/Tests/Tree/SameTreeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tests\Tree;
 4 | 
 5 | use Hakam\LeetCodePhp\Tests\Helper\MainTest;
 6 | use Hakam\LeetCodePhp\Tests\Helper\TreeHelperTrait;
 7 | use Hakam\LeetCodePhp\Tree\SameTree;
 8 | 
 9 | /**
10 |  * @covers \Hakam\LeetCodePhp\Tree\SameTree
11 |  */
12 | class SameTreeTest extends MainTest
13 | {
14 |     use TreeHelperTrait;
15 |     /**
16 |      * @dataProvider provideData
17 |      */
18 |     public function testWithDataList($expectedResult, $inputData): void
19 |     {
20 |         $tree1 = $this->createBinaryTree($inputData['tree1']);
21 |         $tree2 = $this->createBinaryTree($inputData['tree2']);
22 |         $sameTree = new SameTree();
23 |         self::assertEquals($expectedResult,$sameTree->isSameTree($tree1,$tree2));
24 |     }
25 | }


--------------------------------------------------------------------------------
/Tests/Tree/SymmetricTreeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tests\Tree;
 4 | 
 5 | use Hakam\LeetCodePhp\Tests\Helper\MainTest;
 6 | use Hakam\LeetCodePhp\Tests\Helper\TreeHelperTrait;
 7 | use Hakam\LeetCodePhp\Tree\SymmetricTree;
 8 | 
 9 | /**
10 |  * @covers \Hakam\LeetCodePhp\Tree\SymmetricTree
11 |  */
12 | class SymmetricTreeTest extends MainTest
13 | {
14 |     use TreeHelperTrait;
15 |     /**
16 |      * @dataProvider provideData
17 |      * @covers \Hakam\LeetCodePhp\Tree\SymmetricTree::isSymmetric
18 |      * @covers \Hakam\LeetCodePhp\Tree\SymmetricTree::helper
19 |      */
20 |     public function testWithDataList($expectedResult, $inputData): void
21 |     {
22 |         $tree = $this->createBinaryTree($inputData);
23 |         $symmetric = new SymmetricTree();
24 |         self::assertEquals($expectedResult,$symmetric->isSymmetric($tree));
25 |     }
26 | }


--------------------------------------------------------------------------------
/Tests/Tree/TreeNodeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tests\Tree;
 4 | 
 5 | use Hakam\LeetCodePhp\Tree\TreeNode;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | /**
 9 |  * @covers \Hakam\LeetCodePhp\Tree\TreeNode
10 |  */
11 | class TreeNodeTest extends TestCase
12 | {
13 |     public function testCanCreateaTree()
14 |     {
15 |         $tree = new TreeNode(10,new TreeNode(7),new TreeNode(3));
16 |         self::assertInstanceOf(TreeNode::class,$tree);
17 |         self::assertInstanceOf(TreeNode::class,$tree->left);
18 |         self::assertInstanceOf(TreeNode::class,$tree->right);
19 |     }
20 | }


--------------------------------------------------------------------------------
/Tests/Tree/ValidateBinarySearchTreeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tests\Tree;
 4 | 
 5 | use Hakam\LeetCodePhp\Tests\Helper\MainTest;
 6 | use Hakam\LeetCodePhp\Tests\Helper\TreeHelperTrait;
 7 | use Hakam\LeetCodePhp\Tree\ValidateBinarySearchTree;
 8 | 
 9 | /**
10 |  * @covers \Hakam\LeetCodePhp\Tree\ValidateBinarySearchTree
11 |  */
12 | class ValidateBinarySearchTreeTest extends MainTest
13 | {
14 |     use TreeHelperTrait;
15 | 
16 |     /**
17 |      * @dataProvider provideData
18 |      * @covers \Hakam\LeetCodePhp\Tree\ValidateBinarySearchTree::isValidBST
19 |      * @covers \Hakam\LeetCodePhp\Tree\ValidateBinarySearchTree::validate
20 |      */
21 |     public function testWithDataList($expectedResult, $inputData): void
22 |     {
23 |        $tree=$this->createBinaryTree($inputData);
24 |        $validateBT = new ValidateBinarySearchTree();
25 |        self::assertEquals($expectedResult,$validateBT->isValidBST($tree));
26 |     }
27 | }


--------------------------------------------------------------------------------
/Tree/BinaryTreeLevelOrderTraversal.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tree;
 4 | 
 5 | /**
 6 |  * LeetCode Problem Link : https://leetcode.com/problems/binary-tree-level-order-traversal
 7 |  */
 8 | class BinaryTreeLevelOrderTraversal
 9 | {
10 |     /**
11 |      * @param TreeNode|null $root
12 |      * @return Integer[][]
13 |      */
14 | 
15 |     public function levelOrder(?TreeNode $root): array
16 |     {
17 |         if($root === null)
18 |         {
19 |             return [];
20 |         }
21 |         $bFT = [];
22 |         $tQ = [];
23 |         $tQ [] = [$root,0];
24 | 
25 |         while(count($tQ) !== 0)
26 |         {
27 |             [$node,$nodeLevel] = array_shift($tQ); //level 0
28 |             $bFT[$nodeLevel][] = $node->val;
29 |             if($node->left !== null) {$tQ[] = [$node->left,$nodeLevel+1];}
30 |             if($node->right !== null) {$tQ[] = [$node->right,$nodeLevel+1];}
31 |         }
32 |         return $bFT;
33 |     }
34 | }


--------------------------------------------------------------------------------
/Tree/BinaryTreePaths.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tree;
 4 | 
 5 | class BinaryTreePaths
 6 | {
 7 |     private array $leafPaths = [];
 8 | 
 9 |     /**
10 |      * @param TreeNode $root
11 |      * @return String[]
12 |      */
13 |     function binaryTreePaths($root): array
14 |     {
15 |         $this->findLeafPath($root,'');
16 |         return $this->leafPaths;
17 |     }
18 | 
19 |     public function findLeafPath($node, $path)
20 |     {
21 |         if($node === null) {
22 |             return;
23 |         }
24 |         if($node->left === null && $node->right === null)
25 |         {
26 |             $path .= $node->val;
27 |             $this->leafPaths [] = $path;
28 |             return;
29 |         }
30 |         $path .= $node->val."->";
31 | 
32 |         if($node->left !== null)
33 |         {
34 |             $this->findLeafPath($node->left,$path);
35 |         }
36 |         if($node->right !== null)
37 |         {
38 |             $this->findLeafPath($node->right,$path);
39 |         }
40 |     }
41 | }


--------------------------------------------------------------------------------
/Tree/BinaryTreePostorderTraversal.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tree;
 4 | 
 5 | class BinaryTreePostorderTraversal
 6 | {
 7 |     /**
 8 |      * @param TreeNode|null $root
 9 |      * @return Integer[]
10 |      */
11 |     function postorderTraversalBYRecursion(?TreeNode $root): array
12 |     {
13 |         if ($root === null) {
14 |             return [];
15 |         }
16 | 
17 |         if ($root->left !== null) {
18 | 
19 |             $list [] = $this->postorderTraversalBYRecursion($root->left);
20 |         }
21 |         if ($root->right !== null) {
22 |             $list [] =  $this->postorderTraversalBYRecursion($root->right);
23 |         }
24 |         $list [] = [$root->val];
25 | 
26 |         return array_merge(...$list);
27 |     }
28 | 
29 | 
30 |     public function postorderTraversalBYIneration(?TreeNode $treeNode)
31 |     {
32 |         if ($treeNode === null) {
33 |             return [];
34 |         }
35 |         $stack [] = $treeNode;
36 |         $list = [];
37 |         while (count($stack) !== 0) {
38 |             $currentNode = array_pop($stack);
39 | 
40 |             if ($currentNode->left !== null) {
41 |                 $stack [] = $currentNode->left;
42 |             }
43 | 
44 |             if ($currentNode->left !== null) {
45 |                 $stack [] = $currentNode->right;
46 |             }
47 |             $list [] = $currentNode->val;
48 |         }
49 |         return $list;
50 |     }
51 | 
52 | }


--------------------------------------------------------------------------------
/Tree/BinaryTreePreorderTraversal.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tree;
 4 | 
 5 | class BinaryTreePreorderTraversal
 6 | {
 7 |     /**
 8 |      * @param TreeNode|null $root
 9 |      * @return Integer[]
10 |      */
11 |     function preorderTraversalBYRecursion(?TreeNode $root): array
12 |     {
13 |         if ($root === null) {
14 |             return [];
15 |         }
16 | 
17 |         $list [] = $root->val;
18 |         if ($root->left !== null) {
19 |             $list = array_merge($list, $this->preorderTraversalBYRecursion($root->left));
20 |         }
21 |         if ($root->right !== null) {
22 |             $list = array_merge($list, $this->preorderTraversalBYRecursion($root->right));
23 |         }
24 |         return $list;
25 |     }
26 | 
27 | 
28 |     public function preorderTraversalBYIneration(?TreeNode $treeNode)
29 |     {
30 |         if ($treeNode === null) {
31 |             return [];
32 |         }
33 |         $stack [] = $treeNode;
34 |         $list = [];
35 |         while (count($stack) !== 0) {
36 |             $currentNode = array_pop($stack);
37 |             $list [] = $currentNode->val;
38 |             if ($currentNode->left !== null) {
39 |                 $stack [] = $currentNode->left;
40 |             }
41 | 
42 |             if ($currentNode->left !== null) {
43 |                 $stack [] = $currentNode->right;
44 |             }
45 |         }
46 |         return $list;
47 |     }
48 | }


--------------------------------------------------------------------------------
/Tree/BinaryTreeRightSideView.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tree;
 4 | 
 5 | class BinaryTreeRightSideView
 6 | {
 7 |     private $rightSide = [];
 8 | 
 9 |     /**
10 |      * @param TreeNode $root
11 |      * @return Integer[]
12 |      */
13 |     function rightSideView($root): array
14 |     {
15 | 
16 |         $this->getViewNode($root, 0);
17 |         return $this->rightSide;
18 |     }
19 | 
20 |     function getViewNode($node, $level)
21 |     {
22 |         if ($node === null) {
23 |             return [];
24 |         }
25 |         if ($level === count($this->rightSide)) {
26 |             $this->rightSide [] = $node->val;
27 |         }
28 | 
29 |         if ($node->right !== null) {
30 |             $this->getViewNode($node->right, $level + 1);
31 |         }
32 |         if ($node->left !== null) {
33 |             $this->getViewNode($node->left, $level + 1);
34 |         }
35 |     }
36 | }


--------------------------------------------------------------------------------
/Tree/BinaryTreeVerticalOrderTraversal.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tree;
 4 | 
 5 | class BinaryTreeVerticalOrderTraversal
 6 | {
 7 |     /**
 8 |      * @param TreeNode $root
 9 |      * @return Integer[][]
10 |      */
11 |     private array $order = [];
12 |     private array $queue = [];
13 | 
14 |     public function verticalOrder($root): array
15 |     {
16 |         if ($root === null) {
17 |             return [];
18 |         }
19 | 
20 |         $this->queue [] = [$root, 0];
21 | 
22 |         while (count($this->queue) !== 0) {
23 |             [$node, $index] = array_shift($this->queue);
24 |             $this->order[$index][] = $node->val;
25 |             if ($node->left !== null) {
26 |                 $this->queue [] = [$node->left, $index - 1];
27 |             }
28 | 
29 |             if ($node->right !== null) {
30 |                 $this->queue [] = [$node->right, $index + 1];
31 | 
32 |             }
33 |         }
34 |         ksort($this->order);
35 |         return $this->order;
36 |     }
37 | }


--------------------------------------------------------------------------------
/Tree/ConvertBinarySearchTreeToSortedDoublyLinkedList.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tree;
 4 | 
 5 | class ConvertBinarySearchTreeToSortedDoublyLinkedList
 6 | {
 7 |     private $head;
 8 |     private $preNode;
 9 | 
10 |     function treeToDoublyList($root)
11 |     {
12 |         if ($root == null) {
13 |             return null;
14 |         }
15 |         $this->helper($root);
16 |         $this->preNode->right = $this->head;
17 |         $this->head->left = $this->preNode;
18 |         return $this->head;
19 |     }
20 | 
21 |     private function helper($node)
22 |     {
23 |         if ($node !== null) {
24 |             $this->helper($node->left);
25 |             if ($this->preNode != null) {
26 |                 $this->preNode->right = $node;
27 |                 $node->left = $this->preNode;
28 |             } else {
29 |                 $this->head = $node;
30 |             }
31 |             $this->preNode = $node;
32 |             $this->helper($node->right);
33 |         }
34 |     }
35 | }


--------------------------------------------------------------------------------
/Tree/ConvertSortedArrayToBinarySearchTree.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tree;
 4 | 
 5 | class ConvertSortedArrayToBinarySearchTree
 6 | {
 7 |     private array $nums;
 8 | 
 9 |     /**
10 |      * @param Integer[] $nums
11 |      * @return TreeNode
12 |      */
13 |     function sortedArrayToBST($nums)
14 |     {
15 | 
16 |         $this->nums = $nums;
17 |         return $this->createTreeNode(0, count($nums) - 1);
18 | 
19 |     }
20 | 
21 |     function createTreeNode($left, $right)
22 |     {
23 |         if ($left > $right) {
24 |             return null;
25 |         }
26 | 
27 |         $rootIndex = (int)(($left + $right) / 2);
28 |         //PreOrders
29 |         $rootNode = new TreeNode($this->nums[$rootIndex]);
30 |         $rootNode->left = $this->createTreeNode($left, $rootIndex - 1);
31 |         $rootNode->right = $this->createTreeNode($rootIndex + 1, $right);
32 | 
33 |         return $rootNode;
34 |     }
35 | }


--------------------------------------------------------------------------------
/Tree/CountUniValueSubtrees.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tree;
 4 | 
 5 | class CountUniValueSubtrees
 6 | {
 7 |     /**
 8 |      * @param TreeNode $root
 9 |      * @return Integer
10 |      */
11 |     private int $count = 0;
12 | 
13 |     public function countUnivalSubtrees($root): int
14 |     {
15 |         if ($root === null) {
16 |             return 0;
17 |         }
18 |         $this->getUni($root);
19 |         return $this->count;
20 |     }
21 | 
22 |     private function getUni($root): bool
23 |     {
24 |         if ($root->left === null && $root->right === null) {
25 |             ++$this->count;
26 |             return true;
27 |         }
28 | 
29 |         $leftUni = true;
30 |         $rightUni = true;
31 |         if ($root->left !== null) {
32 |             $leftUni = $this->getUni($root->left) && $root->left->val == $root->val;
33 |         }
34 | 
35 |         if ($root->right !== null) {
36 |             $rightUni = $this->getUni($root->right) && $root->right->val == $root->val;
37 |         }
38 | 
39 |         if (!($leftUni && $rightUni)) {
40 |             return false;
41 |         }
42 |         ++$this->count;
43 |         return true;
44 |     }
45 | }


--------------------------------------------------------------------------------
/Tree/DiameterOfBinaryTree.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tree;
 4 | 
 5 | class DiameterOfBinaryTree
 6 | {
 7 |     private int $diameter = 0;
 8 | 
 9 |     function diameterOfBinaryTree(TreeNode $root): int
10 |     {
11 |         $this->getMaxPathLength($root);
12 |         return $this->diameter;
13 |     }
14 | 
15 |     private function getMaxPathLength(?TreeNode $node)
16 |     {
17 |         if ($node === null) {
18 |             return 0;
19 |         }
20 | 
21 |         $leftPathLength = $this->getMaxPathLength($node->left);
22 |         $rightPathLength = $this->getMaxPathLength($node->right);
23 | 
24 |         $this->diameter = max($this->diameter, $leftPathLength + $rightPathLength);
25 |         return 1+ max($rightPathLength, $leftPathLength);
26 |     }
27 | }


--------------------------------------------------------------------------------
/Tree/FlattenBinaryTreeToLinkedList.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tree;
 4 | 
 5 | class FlattenBinaryTreeToLinkedList
 6 | {
 7 |     /**
 8 |      * @param TreeNode $root
 9 |      * @return void
10 |      */
11 |     public function flatten(TreeNode $root): void
12 |     {
13 |         $this->getPreOrderLinkedList($root);
14 |     }
15 | 
16 |     private function getPreOrderLinkedList( ?TreeNode $node): ?TreeNode
17 |     {
18 |         if($node === null)
19 |         {
20 |            return null;
21 |         }
22 |         if ($node->right === null && $node->left === null) {
23 |             return $node;
24 |         }
25 | 
26 |         $leftTail = $this->getPreOrderLinkedList($node->left);
27 |         $rightTail = $this->getPreOrderLinkedList($node->right);
28 | 
29 |         if ($leftTail !== null) {
30 |             $leftTail->right = $node->right;
31 |             $node->right = $node->left;
32 |             $node->left = null;
33 |         }
34 |         return $rightTail ?? $leftTail;
35 |     }
36 | }


--------------------------------------------------------------------------------
/Tree/IntegerToEnglishWords.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Hakam\LeetCodePhp\Tree;
  4 | 
  5 | class IntegerToEnglishWords
  6 | {
  7 |     /**
  8 |      * @param Integer $num
  9 |      * @return String
 10 |      */
 11 |   public  function numberToWords($num)
 12 |     {
 13 |         $b = (int)($num / 1000000000);
 14 |         $m = (int)(($num - $b * 1000000000) / 1000000);
 15 |         $t = (int)(($num - $b * 1000000000 - $m * 1000000) / 1000);
 16 |         $rest = (int)($num - $b * 1000000000 - $m * 1000000 - $t * 1000);
 17 |         $numToWord = '';
 18 |         if ($b !== 0) {
 19 |             $numToWord .= $this->ThreeToWord($b) . " Billion ";
 20 |         }
 21 |         if ($m !== 0) {
 22 |             $numToWord .= $this->ThreeToWord($m) . " Million ";
 23 |         }
 24 |         if ($t !== 0) {
 25 |             $numToWord .= $this->ThreeToWord($t) . " Thousand ";
 26 |         }
 27 |         if ($rest !== 0) {
 28 |             $numToWord .= $this->ThreeToWord($rest);
 29 |         }
 30 |         return trim($numToWord);
 31 |     }
 32 | 
 33 |   private  function ThreeToWord($num)
 34 |     {
 35 |         $hundred = (int)($num / 100);
 36 |         $rest = $num - $hundred * 100;
 37 |         $result = '';
 38 |         if ($rest != 0 && $hundred != 0) {
 39 |             $result = $this->convertOnes($hundred) . " Hundred " . $this->TwoToWord($rest);
 40 |         }
 41 | 
 42 |         if ($hundred === 0 && $rest !== 0) {
 43 |             $result = $this->TwoToWord($rest);
 44 |         }
 45 | 
 46 |         if ($hundred !== 0 && $rest === 0) {
 47 |             $result = $this->convertOnes($hundred) . " Hundred";
 48 |         }
 49 | 
 50 |         return $result;
 51 |     }
 52 | 
 53 |   private function convertOnes($num)
 54 |     {
 55 |         switch ($num) {
 56 |             case 1:
 57 |                 return 'One';
 58 |                 break;
 59 |             case 2:
 60 |                 return 'Two';
 61 |                 break;
 62 |             case 3:
 63 |                 return 'Three';
 64 |                 break;
 65 |             case 4:
 66 |                 return 'Four';
 67 |                 break;
 68 |             case 5:
 69 |                 return 'Five';
 70 |                 break;
 71 |             case 6:
 72 |                 return 'Six';
 73 |                 break;
 74 |             case 7:
 75 |                 return 'Seven';
 76 |                 break;
 77 |             case 8:
 78 |                 return 'Eight';
 79 |                 break;
 80 |             case 9:
 81 |                 return 'Nine';
 82 |                 break;
 83 |             default:
 84 |                 return '';
 85 |         }
 86 |     }
 87 | 
 88 |    private function TwoToWord($num)
 89 |     {
 90 |         if ($num == 0) {
 91 |             return '';
 92 |         }
 93 |         if ($num < 10) {
 94 |             return $this->convertOnes($num);
 95 |         }
 96 |         if ($num < 20) {
 97 |             return $this->convertLessThan20($num);
 98 |         }
 99 |         $tens = (int)($num / 10);
100 |         $rest = $num - $tens * 10;
101 |         if ($rest != 0) {
102 |             return $this->convertTens($tens) . " " . $this->convertOnes($rest);
103 |         }
104 |         return $this->convertTens($tens);
105 |     }
106 | 
107 |    private function convertLessThan20($num)
108 |     {
109 |         switch ($num) {
110 |             case 10:
111 |                 return 'Ten';
112 |                 break;
113 |             case 11:
114 |                 return 'Eleven';
115 |                 break;
116 |             case 12:
117 |                 return 'Twelve';
118 |                 break;
119 |             case 13:
120 |                 return 'Thirteen';
121 |                 break;
122 |             case 14:
123 |                 return 'Fourteen';
124 |                 break;
125 |             case 15:
126 |                 return 'Fifteen';
127 |                 break;
128 |             case 16:
129 |                 return 'Sixteen';
130 |                 break;
131 |             case 17:
132 |                 return 'Seventeen';
133 |                 break;
134 |             case 18:
135 |                 return 'Eighteen';
136 |                 break;
137 |             case 19:
138 |                 return 'Nineteen';
139 |                 break;
140 |         }
141 |         return '';
142 |     }
143 | 
144 |    private function convertTens($num)
145 |     {
146 |         switch ($num) {
147 |             case 2:
148 |                 return 'Twenty';
149 |                 break;
150 |             case 3:
151 |                 return 'Thirty';
152 |                 break;
153 |             case 4:
154 |                 return 'Forty';
155 |                 break;
156 |             case 5:
157 |                 return 'Fifty';
158 |                 break;
159 |             case 6:
160 |                 return 'Sixty';
161 |                 break;
162 |             case 7:
163 |                 return 'Seventy';
164 |                 break;
165 |             case 8:
166 |                 return 'Eighty';
167 |                 break;
168 |             case 9:
169 |                 return 'Ninety';
170 |                 break;
171 |         }
172 |     }
173 | }


--------------------------------------------------------------------------------
/Tree/MaximumDepthOfBinaryTree.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tree;
 4 | 
 5 | class MaximumDepthOfBinaryTree
 6 | {
 7 |     /**
 8 |      * @param TreeNode $root
 9 |      * @return Integer
10 |      */
11 |     function maxDepth($root): int
12 |     {
13 |         if($root === null)
14 |         {
15 |             return 0;
16 |         }
17 |         return max($this->maxDepth($root->left)+1,$this->maxDepth($root->right)+1);
18 |     }
19 | }


--------------------------------------------------------------------------------
/Tree/PathSum.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tree;
 4 | 
 5 | class PathSum
 6 | {
 7 |     /**
 8 |      * @param TreeNode $root
 9 |      * @param Integer $targetSum
10 |      * @return Boolean
11 |      */
12 |     function hasPathSum($root, $targetSum): bool
13 |     {
14 |         if($root === null) {return false;}
15 |         if($root->left === null && $root->right === null && $root->val ==$targetSum){return true;}
16 |         $leftSum = $this->hasPathSum($root->left,$targetSum-$root->val);
17 |         $rightSum = $this->hasPathSum($root->right,$targetSum-$root->val);
18 |         return  $leftSum || $rightSum ;
19 |     }
20 | }


--------------------------------------------------------------------------------
/Tree/SameTree.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tree;
 4 | 
 5 | class SameTree
 6 | {
 7 |     /**
 8 |      * @param TreeNode $p
 9 |      * @param TreeNode $q
10 |      * @return Boolean
11 |      */
12 |     function isSameTree($p, $q): bool
13 |     {
14 | 
15 |         if (($p !== null && $q === null) || ($p === null && $q !== null)) {
16 |             return false;
17 |         }
18 | 
19 |         if ($p === null && $q === null) {
20 |             return true;
21 |         }
22 | 
23 |         if ($p->val === $q->val) {
24 |             return $this->isSameTree($p->left, $q->left) &&
25 |                 $this->isSameTree($p->right, $q->right);
26 |         }
27 |     }
28 | }


--------------------------------------------------------------------------------
/Tree/SymmetricTree.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tree;
 4 | 
 5 | class SymmetricTree
 6 | {
 7 |     /**
 8 |      * @param TreeNode|null $root
 9 |      * @return Boolean
10 |      */
11 |     public function isSymmetric(?TreeNode $root): bool
12 |     {
13 |         if ($root === null) {
14 |             return true;
15 |         }
16 |         return $this->helper($root->left, $root->right);
17 |     }
18 | 
19 |     private function helper(?TreeNode $tree1, ?TreeNode $tree2): bool
20 |     {
21 | 
22 |         if ($tree1 === null && $tree2 === null) {
23 |             return true;
24 |         }
25 | 
26 |         if (($tree1 === null && $tree2 !== null) || ($tree1 !== null && $tree2 === null)) {
27 |             return false;
28 |         }
29 | 
30 |         if ($tree1->val === $tree2->val) {
31 |             return
32 |                 $this->helper($tree1->left, $tree2->right) &&
33 |                 $this->helper($tree1->right, $tree2->left);
34 |         }
35 |         return false;
36 |     }
37 | }


--------------------------------------------------------------------------------
/Tree/TreeNode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tree;
 4 | 
 5 | /**
 6 |  * * @codeCoverageIgnore
 7 |  */
 8 | class TreeNode
 9 | {
10 |     public $val = null;
11 |     public $left = null;
12 |     public $right = null;
13 | 
14 |     /**
15 |      * @param int $val
16 |      * @param null $left
17 |      * @param null $right
18 |      * @codeCoverageIgnore
19 |      */
20 |     public function __construct($val = 0, $left = null, $right = null)
21 |     {
22 |         $this->val = $val;
23 |         $this->left = $left;
24 |         $this->right = $right;
25 |     }
26 | }


--------------------------------------------------------------------------------
/Tree/ValidateBinarySearchTree.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hakam\LeetCodePhp\Tree;
 4 | 
 5 | class ValidateBinarySearchTree
 6 | {
 7 |     public function isValidBST(TreeNode $treeNode): bool
 8 |     {
 9 |        return $this->validate($treeNode,PHP_INT_MIN,PHP_INT_MAX);
10 |     }
11 | 
12 |     private function validate(?TreeNode $node, ?int $min, ?int $max): bool
13 |     {
14 |         if ($node === null) {
15 |             return true;
16 |         }
17 |         if ($node->val < $min || $node->val >= $max) {
18 |             return false;
19 |         }
20 |         return $this->validate($node->left, $min, $node->val) && $this->validate($node->right, $node->val, $max);
21 |     }
22 | }


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "hakam/leet_code_php",
 3 |   "description": "PHP solutions for leet code problems",
 4 | 
 5 |   "require": {
 6 |     "phpunit/phpunit": "^9.5"
 7 |   },
 8 |   "license": "MIT",
 9 |   "autoload": {
10 |     "psr-4": {
11 |       "Hakam\\LeetCodePhp\\": ""
12 |     }
13 |   },
14 |   "authors": [
15 |     {
16 |       "name": "Ramy hakam",
17 |       "email": "pencilsoft1@gmail.com"
18 |     }
19 |   ]
20 | }
21 | 


--------------------------------------------------------------------------------
/phpunit.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 3 |          xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/9.5/phpunit.xsd"
 4 |          bootstrap="vendor/autoload.php"
 5 |          cacheResultFile=".phpunit.cache/test-results"
 6 |          executionOrder="depends,defects"
 7 |          forceCoversAnnotation="true"
 8 |          beStrictAboutCoversAnnotation="true"
 9 |          beStrictAboutOutputDuringTests="true"
10 |          beStrictAboutTodoAnnotatedTests="true"
11 |          convertDeprecationsToExceptions="true"
12 |          failOnRisky="true"
13 |          failOnWarning="true"
14 |          verbose="true">
15 |     <testsuites>
16 |         <testsuite name="default">
17 |             <directory>Tests</directory>
18 |         </testsuite>
19 |     </testsuites>
20 | 
21 |     <coverage cacheDirectory=".phpunit.cache/code-coverage"
22 |               processUncoveredFiles="true">
23 |         <include>
24 |             <directory suffix=".php">./</directory>
25 |         </include>
26 | 
27 |         <exclude>
28 |             <directory suffix=".php">vendor/</directory>
29 |             <directory suffix=".php">Tests/</directory>
30 |         </exclude>
31 |         <report>
32 |             <clover outputFile="clover.xml" />
33 |         </report>
34 |     </coverage>
35 | </phpunit>
36 | 


--------------------------------------------------------------------------------