├── .github
    └── workflows
    │   ├── ci.yml
    │   ├── code-style.yml
    │   └── directory_workflow.yml
├── .gitignore
├── .gitpod.Dockerfile
├── .gitpod.yml
├── CONTRIBUTING.md
├── Ciphers
    ├── AtbashCipher.php
    ├── CaesarCipher.php
    ├── MonoAlphabeticCipher.php
    ├── MorseCode.php
    ├── RailfenceCipher.php
    ├── VignereCipher.php
    └── XORCipher.php
├── Conversions
    ├── BinaryToDecimal.php
    ├── DecimalToBinary.php
    ├── HexadecimalToDecimal.php
    ├── OctalToDecimal.php
    ├── SpeedConversion.php
    └── TemperatureConversions.php
├── DIRECTORY.md
├── DataStructures
    ├── .keep
    ├── AVLTree
    │   ├── AVLTree.php
    │   ├── AVLTreeNode.php
    │   └── TreeTraversal.php
    ├── BinarySearchTree
    │   ├── BSTNode.php
    │   ├── BSTree.php
    │   ├── BinaryTreeTraversal.php
    │   └── DuplicateKeyException.php
    ├── CompareBinaryTree
    │   ├── BinaryTreeNode.php
    │   └── CompareBinaryTree.php
    ├── DisjointSets
    │   ├── DisjointSet.php
    │   └── DisjointSetNode.php
    ├── DoublyLinkedList.php
    ├── InvertBinaryTree
    │   ├── BinaryTree.php
    │   └── InvertBinaryTree.php
    ├── Node.php
    ├── Queue.php
    ├── ReverseLinkedList
    │   ├── LinkedListItem.php
    │   └── ReverseLinkedList.php
    ├── SegmentTree
    │   ├── SegmentTree.php
    │   └── SegmentTreeNode.php
    ├── SinglyLinkedList.php
    ├── SplayTree
    │   ├── SplayTree.php
    │   ├── SplayTreeNode.php
    │   └── SplayTreeRotations.php
    ├── Stack.php
    └── Trie
    │   ├── Trie.php
    │   └── TrieNode.php
├── Graphs
    ├── BellmanFord.php
    ├── BreadthFirstSearch.php
    ├── DepthFirstSearch.php
    ├── Dijkstras.php
    └── GraphEdge.php
├── LICENSE
├── Maths
    ├── AbsoluteMax.php
    ├── AbsoluteMin.php
    ├── ArmstrongNumber.php
    ├── BaseX.php
    ├── CheckEven.php
    ├── CheckOdd.php
    ├── CheckPalindrome.php
    ├── CheckPrime.php
    ├── EratosthenesSieve.php
    ├── Factorial.php
    ├── FastExponentiation.php
    ├── FastInverseSquareRoot.php
    ├── Fibonacci.php
    ├── Fibonacci2.php
    ├── GreatestCommonDivisor.php
    ├── Mean.php
    ├── Median.php
    ├── Mode.php
    ├── NeonNumber.php
    ├── PerfectNumber.php
    ├── PerfectSquare.php
    └── ProjectEuler
    │   ├── Problem1.php
    │   ├── Problem10.php
    │   ├── Problem11.php
    │   ├── Problem2.php
    │   ├── Problem3.php
    │   ├── Problem4.php
    │   ├── Problem5.php
    │   ├── Problem6.php
    │   ├── Problem7.php
    │   ├── Problem8.php
    │   └── Problem9.php
├── NeuralNetworks
    └── PerceptronClassifier
    │   ├── NeuralNetworkPerceptronClassifier.php
    │   ├── README.md
    │   └── chart
    │       ├── dataset.png
    │       ├── linear-separated.png
    │       └── sigmoid.png
├── README.md
├── Searches
    ├── BinarySearch.php
    ├── ExponentialSearch.php
    ├── FibonacciSearch.php
    ├── InterpolationSearch.php
    ├── JumpSearch.php
    ├── LinearSearch.php
    ├── LowerBound.php
    ├── SentinelSearch.php
    ├── TernarySearch.php
    ├── TwoPointers.php
    └── UpperBound.php
├── Sorting
    ├── ArrayKeysSort.php
    ├── BubbleSort.php
    ├── BubbleSort2.php
    ├── CountSort.php
    ├── GnomeSort.php
    ├── HeapSort.php
    ├── InsertionSort.php
    ├── MergeSort.php
    ├── QuickSort.php
    ├── RadixSort.php
    ├── SelectionSort.php
    └── ShellSort.php
├── Strings
    ├── CheckAnagram.php
    ├── CheckPalindrome.php
    ├── CheckPalindrome2.php
    ├── CountConsonants.php
    ├── CountHomogenous.php
    ├── CountSentences.php
    ├── CountVowels.php
    ├── Distance.php
    ├── MaxCharacter.php
    ├── ReverseString.php
    └── ReverseWords.php
├── Utils
    ├── ArrayHelpers.php
    └── ExecutionTime.php
├── composer.json
├── phpcs.xml.dist
└── tests
    ├── Ciphers
        ├── AtbashCipherTest.php
        ├── CiphersTest.php
        ├── MonoAlphabeticCipherTest.php
        ├── MorseCodeTest.php
        ├── RailfenceCipherTest.php
        └── VignereCipherTest.php
    ├── Conversions
        └── ConversionsTest.php
    ├── DataStructures
        ├── .keep
        ├── AVLTreeTest.php
        ├── BSTreeTest.php
        ├── CompareBinaryTreeTest.php
        ├── DisjointSetTest.php
        ├── DoublyLinkedListTest.php
        ├── InvertBinaryTreeTest.php
        ├── QueueTest.php
        ├── ReverseLinkedListTest.php
        ├── SegmentTreeTest.php
        ├── SinglyLinkedListTest.php
        ├── SplayTreeTest.php
        ├── StackTest.php
        └── TrieTest.php
    ├── Graphs
        ├── BellmanFordTest.php
        ├── BreadthFirstSearchTest.php
        ├── DepthFirstSearchTest.php
        └── DijkstrasTest.php
    ├── Maths
        ├── EratosthenesSieveTest.php
        ├── MathsTest.php
        └── ProjectEulerTest.php
    ├── NeuralNetworks
        └── PerceptronClassifier
        │   └── NeuralNetworkPerceptronClassifierTest.php
    ├── Searches
        └── SearchesTest.php
    ├── Sorting
        ├── ArrayKeysSortTest.php
        ├── GnomeSortTest.php
        ├── ShellSortTest.php
        └── SortingTest.php
    └── Strings
        └── StringsTest.php


/.github/workflows/ci.yml:
--------------------------------------------------------------------------------
 1 | name: PHP Composer
 2 | 
 3 | on:
 4 |   push:
 5 |     branches: [ master ]
 6 |   pull_request:
 7 |     branches: [ master ]
 8 | 
 9 | jobs:
10 |   build:
11 | 
12 |     runs-on: ubuntu-latest
13 | 
14 |     steps:
15 |       - uses: actions/checkout@v4
16 | 
17 |       - name: Setup PHP
18 |         uses: shivammathur/setup-php@v2
19 |         with:
20 |           php-version: '7.4'
21 |           ini-values: xdebug.max_nesting_level=512
22 | 
23 |       - name: Validate composer.json and composer.lock
24 |         run: composer validate
25 | 
26 |       - name: Cache Composer packages
27 |         id: composer-cache
28 |         uses: actions/cache@v3
29 |         with:
30 |           path: vendor
31 |           key: ${{ runner.os }}-php-${{ hashFiles('**/composer.lock') }}
32 |           restore-keys: |
33 |             ${{ runner.os }}-php-
34 | 
35 |       - name: Install dependencies
36 |         if: steps.composer-cache.outputs.cache-hit != 'true'
37 |         run: composer install --prefer-dist --no-progress --no-suggest
38 | 
39 |       - name: Run PHPUnit
40 |         run: composer run-script test


--------------------------------------------------------------------------------
/.github/workflows/code-style.yml:
--------------------------------------------------------------------------------
 1 | name: Code style
 2 | 
 3 | on: [push, pull_request]
 4 | 
 5 | permissions:
 6 |   contents: read
 7 | 
 8 | jobs:
 9 |   phpcs:
10 |     name: PHPCS
11 |     runs-on: ubuntu-latest
12 |     steps:
13 |       - name: Checkout
14 |         uses: actions/checkout@v4
15 | 
16 |       - name: Setup PHP
17 |         uses: shivammathur/setup-php@v2
18 |         with:
19 |           php-version: '7.4'
20 | 
21 |       - name: Install dependencies
22 |         run: composer update --prefer-dist --no-progress --no-suggest
23 | 
24 |       - name: Run script
25 |         run: vendor/bin/phpcs -n


--------------------------------------------------------------------------------
/.github/workflows/directory_workflow.yml:
--------------------------------------------------------------------------------
 1 | name: directory_md
 2 | on:
 3 |   push:
 4 |     branches: [ "master" ]
 5 | 
 6 | jobs:
 7 |   MainSequence:
 8 |     name: DIRECTORY.md
 9 |     runs-on: ubuntu-latest
10 |     steps:
11 |       - uses: actions/checkout@v4
12 |       - uses: actions/setup-python@v5
13 |       - name: Setup Git Specs
14 |         run: |
15 |           git config --global user.name "$GITHUB_ACTOR"
16 |           git config --global user.email "$GITHUB_ACTOR@users.noreply.github.com"
17 |           git remote set-url origin https://x-access-token:${{ secrets.GITHUB_TOKEN }}@github.com/$GITHUB_REPOSITORY
18 |       - name: Update DIRECTORY.md
19 |         shell: python
20 |         run: |
21 |             import os
22 |             from typing import Iterator
23 |             g_output = []
24 |             def good_filepaths(top_dir: str = ".") -> Iterator[str]:
25 |                 fs_exts = tuple(".php".split())
26 |                 for dirpath, dirnames, filenames in os.walk(top_dir):
27 |                     dirnames[:] = [d for d in dirnames if d[0] not in "._"]
28 |                     for filename in filenames:
29 |                         if os.path.splitext(filename)[1].lower() in fs_exts:
30 |                             yield os.path.join(dirpath, filename).lstrip("./")
31 |             def md_prefix(i):
32 |                 return f"{i * '  '}*" if i else "\n##"
33 |             def print_path(old_path: str, new_path: str) -> str:
34 |                 global g_output
35 |                 old_parts = old_path.split(os.sep)
36 |                 for i, new_part in enumerate(new_path.split(os.sep)):
37 |                     if i + 1 > len(old_parts) or old_parts[i] != new_part:
38 |                         if new_part:
39 |                             g_output.append(f"{md_prefix(i)} {new_part.replace('_', ' ').title()}")
40 |                 return new_path
41 |             def build_directory_md(top_dir: str = ".") -> str:
42 |                 global g_output
43 |                 old_path = ""
44 |                 for filepath in sorted(good_filepaths(), key=str.lower):
45 |                     filepath, filename = os.path.split(filepath)
46 |                     if filepath != old_path:
47 |                         old_path = print_path(old_path, filepath)
48 |                     indent = (filepath.count(os.sep) + 1) if filepath else 0
49 |                     url = "/".join((".", filepath, filename)).replace(" ", "%20")
50 |                     filename = os.path.splitext(filename.replace("_", " ").title())[0]
51 |                     g_output.append(f"{md_prefix(indent)} [{filename}]({url})")
52 |                 return "# List of all files\n" + "\n".join(g_output)
53 |             with open("DIRECTORY.md", "w") as out_file:
54 |                 out_file.write(build_directory_md(".") + "\n")
55 |       - name: Commit DIRECTORY.md
56 |         run: |
57 |          git commit -m "updating DIRECTORY.md" DIRECTORY.md ||  true
58 |          git diff DIRECTORY.md
59 |          git push --force origin HEAD:$GITHUB_REF || true
60 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | /vendor/
 2 | .idea
 3 | .vscode
 4 | .phan
 5 | composer.lock
 6 | 
 7 | /.phpcs-cache
 8 | /phpcs.xml
 9 | 
10 | .phpunit.result.cache


--------------------------------------------------------------------------------
/.gitpod.Dockerfile:
--------------------------------------------------------------------------------
1 | FROM gitpod/workspace-full:2022-05-08-14-31-53
2 | 


--------------------------------------------------------------------------------
/.gitpod.yml:
--------------------------------------------------------------------------------
1 | image:
2 |     file: .gitpod.Dockerfile
3 | 
4 | tasks:
5 |   - init: |
6 |       echo "Welcome to TheAlgorithms/PHP"
7 | 


--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
 1 | # Contributing guidelines
 2 | 
 3 | ## Before contributing
 4 | 
 5 | Welcome to [TheAlgorithms/PHP](https://github.com/TheAlgorithms/PHP)! Before sending your pull requests, make sure that you **read the entire guide**. If you have any question about the contributing guide, please feel free to [state it clearly in an issue](https://github.com/TheAlgorithms/PHP/issues/new) or ask the community in [Gitter](https://gitter.im/TheAlgorithms).
 6 | 
 7 | ## Contributing
 8 | 
 9 | ### Contributor
10 | 
11 | We are very happy that you would consider contributing! As a contributor, you agree and confirm that:
12 | 
13 | - You did your work - no plagiarism allowed
14 |   - Any plagiarized work will not be merged
15 | - Your work will be distributed under [MIT License](LICENSE) once your pull request is merged
16 | - Your submitted work follows (or mostly follows) the styles and standards already found in this repo
17 | 
18 | **New implementations** are welcome! For example, new solutions for an existing problem, different representations for a graph data structure or an algorithm design with different complexity.
19 | 
20 | **Improving comments** and **writing proper tests** are also highly welcome.
21 | 
22 | ### Contribution
23 | 
24 | We appreciate any contribution, from fixing a grammar mistake in a comment to implementing complex algorithms. Please read this section if you are contributing your work.
25 | 
26 | Please help us keep our issue list small by adding fixes: #{$ISSUE_NO} to the commit message of pull requests that resolve open issues. GitHub will use this tag to auto close the issue when the PR is merged.
27 | 
28 | #### What is an Algorithm?
29 | 
30 | An Algorithm is one or more functions (or classes) that:
31 | * take one or more inputs,
32 | * perform some internal calculations or data manipulations,
33 | * return one or more outputs,
34 | * have minimal side effects (Ex. print(), plot(), read(), write()).
35 | 
36 | Algorithms should be packaged in a way that would make it easy for readers to put them into larger programs.
37 | 
38 | Algorithms should:
39 | * have intuitive class and function names that make their purpose clear to readers
40 | * use PHP naming conventions and intuitive variable names to ease comprehension
41 | * be flexible to take different input values
42 | * have PHP type hints for their input parameters and return values
43 | * raise PHP exceptions (UnexpectedValueException, etc.) on erroneous input values
44 | * have docstrings with clear explanations and/or URLs to source materials
45 | * contain doctests that test both valid and erroneous input values
46 | * return all calculation results instead of printing or plotting them
47 | 
48 | Algorithms in this repo should not be how-to examples for existing PHP packages.  Instead, they should perform internal calculations or manipulations to convert input values into different output values.  Those calculations or manipulations can use data types, classes, or functions of existing PHP packages but each algorithm in this repo should add unique value.
49 | 
50 | #### Coding Style
51 | 
52 | We want your work to be readable by others; therefore, we encourage you to note the following:
53 | 
54 | - Please write in PHP 7.1+
55 | - Please put thought into naming of functions, classes, and variables.  Help your reader by using __descriptive names__ that can help you to remove redundant comments
56 |   - Single letter variable names are _old school_ so please avoid them unless their life only spans a few lines
57 |   - Please follow the [PHP Basic Coding Standard](https://www.php-fig.org/psr/psr-12/) style guide.  So functionNames should be camelCase, CONSTANTS in UPPER_CASE, Name\Spaces and ClassNames should follow an "autoloading" PSR, etc.
58 | 
59 | - Original code submission require docstrings or comments to describe your work
60 | 
61 | - More on docstrings and comments:
62 | 
63 |   If you used a Wikipedia article or some other source material to create your algorithm, please add the URL in a docstring or comment to help your reader
64 | 
65 | - Write proper unit tests (see examples in [tests](https://github.com/TheAlgorithms/PHP/tree/master/tests) and ensure all unit tests are passing (composer run-script test)
66 | 
67 | - Avoid importing external libraries for basic algorithms. Only use them for complicated algorithms
68 | 
69 | - Ensure code is linted with phpcs, and passing all linting checks (vendor/bin/phpcs -n)
70 | 
71 | #### Other Standard While Submitting Your Work
72 | 
73 | - File extension for code should be `.php` 
74 | - After adding a new File/Directory, please make sure to update the [DIRECTORY.md](DIRECTORY.md) file with the details.
75 | - If possible, follow the standard *within* the folder you are submitting to
76 | - If you have modified/added code work, make sure the code compiles before submitting
77 | - If you have modified/added documentation work, ensure your language is concise and contains no grammar errors
78 | - Add a corresponding explanation to [Algorithms-Explanation](https://github.com/TheAlgorithms/Algorithms-Explanation) (Optional but recommended).
79 | 
80 | - Most importantly,
81 |   - **Be consistent in the use of these guidelines when submitting.**
82 |   - **Join** [Gitter](https://gitter.im/TheAlgorithms) **now!**
83 |   - Happy coding!
84 | 
85 | Writer [@darwinz](https://github.com/darwinz), Aug 2020 (based on [TheAlgorithms/Python](https://github.com/TheAlgorithms/Python/blob/master/CONTRIBUTING.md) by [@poyea](https://github.com/poyea))
86 | 


--------------------------------------------------------------------------------
/Ciphers/AtbashCipher.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Encrypt a message using the Atbash Cipher.
 5 |  * The Atbash Cipher is a simple substitution cipher where each letter in the plaintext is
 6 |  * replaced with its corresponding letter from the end of the alphabet (reverse alphabet).
 7 |  * Non-alphabet characters are not modified.
 8 |  *
 9 |  * @param string $plainText The plaintext to encrypt.
10 |  * @return string The encrypted message.
11 |  */
12 | function atbash_encrypt($plainText)
13 | {
14 |     $result = '';
15 |     $plainText = strtoupper($plainText);
16 |     for ($i = 0; $i < strlen($plainText); $i++) {
17 |         $char = $plainText[$i];
18 |         if (ctype_alpha($char)) {
19 |             $offset = ord('Z') - ord($char);
20 |             $encryptedChar = chr(ord('A') + $offset);
21 |         } else {
22 |             $encryptedChar = $char; // Non-alphabet characters remain unchanged
23 |         }
24 |         $result .= $encryptedChar;
25 |     }
26 |     return $result;
27 | }
28 | 
29 | /**
30 |  * Decrypt a message encrypted using the Atbash Cipher.
31 |  * Since the Atbash Cipher is its own inverse, decryption is the same as encryption.
32 |  *
33 |  * @param string $cipherText The ciphertext to decrypt.
34 |  * @return string The decrypted message.
35 |  */
36 | function atbash_decrypt($cipherText)
37 | {
38 |     return atbash_encrypt($cipherText); // Decryption is the same as encryption
39 | }
40 | 


--------------------------------------------------------------------------------
/Ciphers/CaesarCipher.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Encrypt given text using caesar cipher.
 5 |  *
 6 |  * @param string  $text  text text to be encrypted
 7 |  * @param int  $shift  shift number of shifts to be applied
 8 |  * @return string new encrypted text
 9 |  */
10 | function encrypt(string $text, int $shift): string
11 | {
12 |     $encryptedText = ''; // Empty string to store encrypted text
13 |     foreach (str_split($text) as $c) { // Going through each character
14 |         if (ctype_alpha($c)) {
15 |             $placeValue = ord($c) - ord(ctype_upper($c) ? 'A' : 'a'); // Getting value of character (i.e. 0-25)
16 |             $placeValue = ($placeValue + $shift) % 26; // Applying encryption formula
17 |             $placeValue += ord(ctype_upper($c) ? 'A' : 'a');
18 |             $newChar = chr($placeValue); // Getting new character from new value (i.e. A-Z)
19 |             $encryptedText .= $newChar; // Appending encrypted character
20 |         } else {
21 |             $encryptedText .= $c; // Appending the original character
22 |         }
23 |     }
24 | 
25 |     return $encryptedText; // Returning encrypted text
26 | }
27 | 
28 | /**
29 |  * Decrypt given text using caesar cipher.
30 |  * @param string  $text  text text to be decrypted
31 |  * @param int  $shift  shift number of shifts to be applied
32 |  * @return string new decrypted text
33 |  */
34 | function decrypt(string $text, int $shift): string
35 | {
36 |     $decryptedText = ''; // Empty string to store decrypted text
37 |     foreach (str_split($text) as $c) { // Going through each character
38 |         if (ctype_alpha($c)) {
39 |             $placeValue = ord($c) - ord(ctype_upper($c) ? 'A' : 'a'); // Getting value of character (i.e. 0-25)
40 |             $placeValue = ($placeValue - $shift) % 26; // Applying decryption formula
41 |             if ($placeValue < 0) { // Handling case where remainder is negative
42 |                 $placeValue += 26;
43 |             }
44 |             $placeValue += ord(ctype_upper($c) ? 'A' : 'a');
45 |             $newChar = chr($placeValue); // Getting new character from new value (i.e. A-Z)
46 |             $decryptedText .= $newChar; // Appending decrypted character
47 |         } else {
48 |             $decryptedText .= $c; // Appending the original character
49 |         }
50 |     }
51 | 
52 |     return $decryptedText; // Returning decrypted text
53 | }
54 | 


--------------------------------------------------------------------------------
/Ciphers/MonoAlphabeticCipher.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | // A mono-alphabetic cipher is a simple substitution cipher
 4 | // https://www.101computing.net/mono-alphabetic-substitution-cipher/
 5 | 
 6 | function monoAlphabeticCipher($key, $alphabet, $text)
 7 | {
 8 |     $cipherText = ''; // the cipher text (can be decrypted and encrypted)
 9 | 
10 |     // check if the text length matches
11 |     if (strlen($key) != strlen($alphabet)) {
12 |         return false;
13 |     }
14 | 
15 |     $text = preg_replace('/[0-9]+/', '', $text); // remove all the numbers
16 | 
17 |     for ($i = 0; $i < strlen($text); $i++) {
18 |         $index = strripos($alphabet, $text[$i]);
19 |         if ($text[$i] == " ") {
20 |             $cipherText .= " ";
21 |         } else {
22 |             $cipherText .= ( ctype_upper($text[$i]) ? strtoupper($key[$index]) : $key[$index] );
23 |         }
24 |     }
25 | 
26 |     return $cipherText;
27 | }
28 | 
29 | function maEncrypt($key, $alphabet, $text)
30 | {
31 |     return monoAlphabeticCipher($key, $alphabet, $text);
32 | }
33 | 
34 | function maDecrypt($key, $alphabet, $text)
35 | {
36 |     return monoAlphabeticCipher($alphabet, $key, $text);
37 | }
38 | 


--------------------------------------------------------------------------------
/Ciphers/MorseCode.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /**
  4 |  * Encode text to Morse Code.
  5 |  *
  6 |  * @param  string  $text  text to encode
  7 |  * @return string encoded text
  8 |  * @throws \Exception
  9 |  */
 10 | function encode(string $text): string
 11 | {
 12 |     $text = strtoupper($text); // Makes sure the string is uppercase
 13 |     $MORSE_CODE = array( // Array containing morse code translations
 14 |         "A" => ".-",
 15 |         "B" => "-...",
 16 |         "C" => "-.-.",
 17 |         "D" => "-..",
 18 |         "E" => ".",
 19 |         "F" => "..-.",
 20 |         "G" => "--.",
 21 |         "H" => "....",
 22 |         "I" => "..",
 23 |         "J" => ".---",
 24 |         "K" => "-.-",
 25 |         "L" => ".-..",
 26 |         "M" => "--",
 27 |         "N" => "-.",
 28 |         "O" => "---",
 29 |         "P" => ".--.",
 30 |         "Q" => "--.-",
 31 |         "R" => ".-.",
 32 |         "S" => "...",
 33 |         "T" => "-",
 34 |         "U" => "..-",
 35 |         "V" => "...-",
 36 |         "W" => ".--",
 37 |         "X" => "-..-",
 38 |         "Y" => "-.--",
 39 |         "Z" => "--..",
 40 |         "1" => ".----",
 41 |         "2" => "..---",
 42 |         "3" => "...--",
 43 |         "4" => "....-",
 44 |         "5" => ".....",
 45 |         "6" => "-....",
 46 |         "7" => "--...",
 47 |         "8" => "---..",
 48 |         "9" => "----.",
 49 |         "0" => "-----",
 50 |         " " => "/"
 51 |     );
 52 | 
 53 |     $encodedText = ""; // Stores the encoded text
 54 |     foreach (str_split($text) as $c) { // Going through each character
 55 |         if (array_key_exists($c, $MORSE_CODE)) { // Checks if it is a valid character
 56 |             $encodedText .= $MORSE_CODE[$c] . " "; // Appends the correct character
 57 |         } else {
 58 |             throw new \Exception("Invalid character: $c");
 59 |         }
 60 |     }
 61 |     substr_replace($encodedText, "", -1); // Removes trailing space
 62 |     return $encodedText;
 63 | }
 64 | 
 65 | /**
 66 |  * Decode Morse Code to text.
 67 |  * @param  string  $text  text to decode
 68 |  * @throws \Exception
 69 |  */
 70 | function decode(string $text): string
 71 | {
 72 |     $MORSE_CODE = array( // An array containing morse code to text translations
 73 |         ".-" => "A",
 74 |         "-..." => "B",
 75 |         "-.-." => "C",
 76 |         "-.." => "D",
 77 |         "." => "E",
 78 |         "..-." => "F",
 79 |         "--." => "G",
 80 |         "...." => "H",
 81 |         ".." => "I",
 82 |         ".---" => "J",
 83 |         "-.-" => "K",
 84 |         ".-.." => "L",
 85 |         "--" => "M",
 86 |         "-." => "N",
 87 |         "---" => "O",
 88 |         ".--." => "P",
 89 |         "--.-" => "Q",
 90 |         ".-." => "R",
 91 |         "..." => "S",
 92 |         "-" => "T",
 93 |         "..-" => "U",
 94 |         "...-" => "V",
 95 |         ".--" => "W",
 96 |         "-..-" => "X",
 97 |         "-.--" => "Y",
 98 |         "--.." => "Z",
 99 |         ".----" => "1",
100 |         "..---" => "2",
101 |         "...--" => "3",
102 |         "....-" => "4",
103 |         "....." => "5",
104 |         "-...." => "6",
105 |         "--..." => "7",
106 |         "---.." => "8",
107 |         "----." => "9",
108 |         "-----" => "0",
109 |         "/" => " "
110 |     );
111 | 
112 |     $decodedText = ""; // Stores the decoded text
113 |     foreach (explode(" ", $text) as $c) { // Going through each group
114 |         if (array_key_exists($c, $MORSE_CODE)) { // Checks if it is a valid character
115 |             $decodedText .= $MORSE_CODE[$c]; // Appends the correct character
116 |         } else {
117 |             if ($c) { // Makes sure that the string is not empty to prevent trailing spaces or extra spaces from breaking this
118 |                 throw new \Exception("Invalid character: $c");
119 |             }
120 |         }
121 |     }
122 |     return $decodedText;
123 | }
124 | 


--------------------------------------------------------------------------------
/Ciphers/RailfenceCipher.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Encode a message using the Rail Fence Cipher.
 5 |  * (https://en.wikipedia.org/wiki/Rail_fence_cipher)
 6 |  *
 7 |  * @param string $plainMessage The message to encode.
 8 |  * @param int $rails The number of rails or rows in the rail fence.
 9 |  *
10 |  * @return string The encoded message.
11 |  */
12 | function Railencode($plainMessage, $rails): string
13 | {
14 |     $cipherMessage = [];
15 |     $position = ($rails * 2) - 2;
16 |     // Iterate through the characters of the plain message
17 |     for ($index = 0; $index < strlen($plainMessage); $index++) {
18 |         for ($step = 0; $step < $rails; $step++) {
19 |             if (!isset($cipherMessage[$step])) {
20 |                 $cipherMessage[$step] = '';
21 |             }
22 |             // Check if the character should go in the rail
23 |             if ($index % $position == $step || $index % $position == $position - $step) {
24 |                 $cipherMessage[$step] .= $plainMessage[$index];
25 |             } else {
26 |                 // Add a placeholder for empty spaces
27 |                 $cipherMessage[$step] .= ".";
28 |             }
29 |         }
30 |     }
31 |     // Combine and remove placeholders to form the cipher message
32 |     return implode('', str_replace('.', '', $cipherMessage));
33 | }
34 | 
35 | /**
36 |  * Decode a message encoded using the Rail Fence Cipher.
37 |  *
38 |  * @param string $cipherMessage The encoded message.
39 |  * @param int $rails The number of rails or rows used for encoding.
40 |  *
41 |  * @return string The decoded plain message.
42 |  */
43 | function Raildecode($cipherMessage, $rails): string
44 | {
45 |     $position = ($rails * 2) - 2;
46 |     $textLength = strlen($cipherMessage);
47 |     $minLength = floor($textLength / $position);
48 |     $balance = $textLength % $position;
49 |     $lengths = [];
50 |     $strings = [];
51 |     $totalLengths = 0;
52 |     // Calculate the number of characters in each row
53 |     for ($rowIndex = 0; $rowIndex < $rails; $rowIndex++) {
54 |         $lengths[$rowIndex] = $minLength;
55 |         if ($rowIndex != 0 && $rowIndex != ($rails - 1)) {
56 |             $lengths[$rowIndex] += $minLength;
57 |         }
58 |         if ($balance > $rowIndex) {
59 |             $lengths[$rowIndex]++;
60 |         }
61 |         if ($balance > ($rails + ($rails - $rowIndex) - 2)) {
62 |             $lengths[$rowIndex]++;
63 |         }
64 |         $strings[] = substr($cipherMessage, $totalLengths, $lengths[$rowIndex]);
65 |         $totalLengths += $lengths[$rowIndex];
66 |     }
67 |     // Convert the rows of characters to plain message
68 |     $plainText = '';
69 |     while (strlen($plainText) < $textLength) {
70 |         for ($charIndex = 0; $charIndex < $position; $charIndex++) {
71 |             if (isset($strings[$charIndex])) {
72 |                 $index = $charIndex;
73 |             } else {
74 |                 $index = $position - $charIndex;
75 |             }
76 |             $plainText .= substr($strings[$index], 0, 1);
77 |             $strings[$index] = substr($strings[$index], 1);
78 |         }
79 |     }
80 |     return $plainText;
81 | }
82 | 


--------------------------------------------------------------------------------
/Ciphers/VignereCipher.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Encrypts a plaintext using the Vigenère cipher.
 5 |  * (https://en.wikipedia.org/wiki/Vigen%C3%A8re_cipher)
 6 |  *
 7 |  * @param string $plaintext The plaintext to be encrypted.
 8 |  * @param string $key The encryption key.
 9 |  * @return string The encrypted text.
10 |  */
11 | function vigenere_encrypt($plaintext, $key): string
12 | {
13 |     // Convert the input to uppercase for consistency
14 |     $plaintext = strtoupper($plaintext);
15 |     $key = strtoupper($key);
16 |     $keyLength = strlen($key);
17 |     $encryptedText = "";
18 |     for ($i = 0; $i < strlen($plaintext); $i++) {
19 |         $char = $plaintext[$i];
20 |         if (ctype_alpha($char)) {
21 |             // Calculate the shift based on the key
22 |             $shift = ord($key[$i % $keyLength]) - ord('A');
23 |             // Apply the Vigenère encryption formula
24 |             $encryptedChar = chr(((ord($char) - ord('A') + $shift) % 26) + ord('A'));
25 |             // Append the encrypted character to the result
26 |             $encryptedText .= $encryptedChar;
27 |         } else {
28 |             // If the character is not alphabetic, leave it unchanged
29 |             $encryptedText .= $char;
30 |         }
31 |     }
32 |     return $encryptedText;
33 | }
34 | 
35 | /**
36 |  * Decrypts a ciphertext using the Vigenère cipher.
37 |  *
38 |  * @param string $ciphertext The ciphertext to be decrypted.
39 |  * @param string $key The decryption key.
40 |  * @return string The decrypted text.
41 |  */
42 | function vigenere_decrypt($ciphertext, $key): string
43 | {
44 |     $ciphertext = strtoupper($ciphertext);
45 |     $key = strtoupper($key);
46 |     $keyLength = strlen($key);
47 |     $decryptedText = "";
48 |     for ($i = 0; $i < strlen($ciphertext); $i++) {
49 |         $char = $ciphertext[$i];
50 |         if (ctype_alpha($char)) {
51 |             // Calculate the shift based on the key
52 |             $shift = ord($key[$i % $keyLength]) - ord('A');
53 |             // Apply the Vigenère decryption formula
54 |             $decryptedChar = chr(((ord($char) - ord('A') - $shift + 26) % 26) + ord('A'));
55 |             // Append the decrypted character to the result
56 |             $decryptedText .= $decryptedChar;
57 |         } else {
58 |             // If the character is not alphabetic, leave it unchanged
59 |             $decryptedText .= $char;
60 |         }
61 |     }
62 |     return $decryptedText;
63 | }
64 | 


--------------------------------------------------------------------------------
/Ciphers/XORCipher.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * The XOR cipher is a type of additive cipher.
 5 |  * Each character is bitwise XORed with the key.
 6 |  * We loop through the input string, XORing each
 7 |  * character with the key.
 8 |  * The key is repeated until it is the same length as the input.
 9 |  *
10 |  * @param string $input_string The input string.
11 |  * @param string $key The key to use.
12 |  * @return string The encrypted string.
13 |  */
14 | function xorCipher(string $input_string, string $key)
15 | {
16 |     $key_len = strlen($key);
17 |     $result = array();
18 | 
19 |     for ($idx = 0; $idx < strlen($input_string); $idx++) {
20 |         array_push($result, $input_string[$idx] ^ $key[$idx % $key_len]);
21 |     }
22 | 
23 |     return join("", $result);
24 | }
25 | 


--------------------------------------------------------------------------------
/Conversions/BinaryToDecimal.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This function converts the
 5 |  * submitted Binary Number to
 6 |  * Decimal Number.
 7 |  *
 8 |  * Working of Algorithm
 9 |  * (10) base 2
10 |  * (1 * (2 ^ 1) + 0 * (2 ^ 0)) base 10
11 |  * (2 + 0) base 10
12 |  * 2 base 10
13 |  *
14 |  * @param  string  $binaryNumber
15 |  * @return int
16 |  * @throws \Exception
17 |  */
18 | function binaryToDecimal($binaryNumber)
19 | {
20 |     if (!is_numeric($binaryNumber)) {
21 |         throw new \Exception('Please pass a valid Binary Number for Converting it to a Decimal Number.');
22 |     }
23 | 
24 |     $decimalNumber = 0;
25 |     $binaryDigits  = array_reverse(str_split($binaryNumber));
26 | 
27 |     foreach ($binaryDigits as $index => $digit) {
28 |         $decimalNumber += $digit * pow(2, $index);
29 |     }
30 | 
31 |     return $decimalNumber;
32 | }
33 | 


--------------------------------------------------------------------------------
/Conversions/DecimalToBinary.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This function converts the
 5 |  * submitted Decimal Number to
 6 |  * Binary Number.
 7 |  *
 8 |  * @param  string  $decimalNumber
 9 |  * @return string
10 |  * @throws \Exception
11 |  */
12 | function decimalToBinary($decimalNumber)
13 | {
14 |     if (!is_numeric($decimalNumber)) {
15 |         throw new \Exception('Please pass a valid Decimal Number for Converting it to a Binary Number.');
16 |     }
17 | 
18 |     $binaryNumber = '';
19 | 
20 |     while ($decimalNumber > 0) {
21 |         $binaryNumber = ($decimalNumber % 2) . $binaryNumber;
22 |         $decimalNumber /= 2;
23 |     }
24 | 
25 |     return $binaryNumber;
26 | }
27 | 


--------------------------------------------------------------------------------
/Conversions/HexadecimalToDecimal.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This function converts the
 5 |  * submitted Octal Number to
 6 |  * Decimal Number.
 7 |  *
 8 |  * Working of Algorithm
 9 |  * (AB) base 16
10 |  * (A * (16 ^ 1) + B * (16 ^ 0)) base 10
11 |  * (10 * (16 ^ 1) + 11 * (16 ^ 0)) base 10
12 |  * (160 + 11) base 10
13 |  * 171 base 10
14 |  *
15 |  * @param string $octalNumber
16 |  * @return int
17 |  */
18 | function hexToDecimal($hexNumber)
19 | {
20 |     // Using ctype to check all the digits are valid hex digits or not.
21 |     if (!ctype_xdigit($hexNumber)) {
22 |         throw new \Exception('Please pass a valid Hexadecimal Number for Converting it to a Decimal Number.');
23 |     }
24 | 
25 |     $decimalNumber = 0;
26 | 
27 |     // Mapping for Decimal Digits after 9
28 |     $decimalDigitMappings = [
29 |         'A' => 10,
30 |         'B' => 11,
31 |         'C' => 12,
32 |         'D' => 13,
33 |         'E' => 14,
34 |         'F' => 15,
35 |     ];
36 | 
37 |     $hexDigits = str_split($hexNumber);
38 |     $hexDigits = array_reverse($hexDigits);
39 | 
40 |     foreach ($hexDigits as $power => $digit) {
41 |         $hexDigit = $digit;
42 |         if (!is_numeric($digit)) {
43 |             $hexDigit = $decimalDigitMappings[$digit];
44 |         }
45 |         $decimalNumber += (pow(16, $power) * $hexDigit);
46 |     }
47 |     return $decimalNumber;
48 | }
49 | 
50 | /**
51 |  * This function converts the
52 |  * submitted Decimal Number to
53 |  * Hexadecimal Number.
54 |  *
55 |  * @param string $decimalNumber
56 |  * @return string
57 |  */
58 | function decimalToHex($decimalNumber)
59 | {
60 |     $hexDigits = [];
61 | 
62 |     // Mapping for HexaDecimal Digits after 9
63 |     $hexDigitMappings = [
64 |         10 => 'A',
65 |         11 => 'B',
66 |         12 => 'C',
67 |         13 => 'D',
68 |         14 => 'E',
69 |         15 => 'F',
70 |     ];
71 |     if (!is_numeric($decimalNumber)) {
72 |         throw new \Exception('Please pass a valid Decimal Number for Converting it to a Hexadecimal Number.');
73 |     }
74 | 
75 |     while ($decimalNumber > 0) {
76 |         $remainder = ($decimalNumber % 16);
77 |         $decimalNumber /= 16;
78 |         if (empty($hexDigits) && 0 === $remainder) {
79 |             continue;
80 |         }
81 |         $hexDigits[] = $remainder;
82 |     }
83 | 
84 |     $hexDigits = array_reverse($hexDigits);
85 | 
86 |     foreach ($hexDigits as $index => $digit) {
87 |         if ($digit > 9) {
88 |             $hexDigits[$index] = $hexDigitMappings[$digit];
89 |         }
90 |     }
91 | 
92 |     $hexNumber = ltrim(implode('', $hexDigits), '0'); // Connecting all the digits and removing leading zeroes.
93 | 
94 |     return $hexNumber;
95 | }
96 | 


--------------------------------------------------------------------------------
/Conversions/OctalToDecimal.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This function converts the
 5 |  * submitted Octal Number to
 6 |  * Decimal Number.
 7 |  *
 8 |  * Working of Algorithm
 9 |  * (10) base 8
10 |  * (1 * (8 ^ 1) + 0 * (8 ^ 0)) base 10
11 |  * (8 + 0) base 10
12 |  * 9 base 10
13 |  * @param  string  $octalNumber
14 |  * @return int
15 |  * @throws \Exception
16 |  */
17 | function octalToDecimal($octalNumber)
18 | {
19 |     if (!is_numeric($octalNumber)) {
20 |         throw new \Exception('Please pass a valid Octal Number for Converting it to a Decimal Number.');
21 |     }
22 | 
23 |     $decimalNumber = 0;
24 |     $octalDigits   = array_reverse(str_split($octalNumber));
25 | 
26 |     foreach ($octalDigits as $index => $digit) {
27 |         $decimalNumber += $digit * pow(8, $index);
28 |     }
29 | 
30 |     return $decimalNumber;
31 | }
32 | 
33 | /**
34 |  * This function converts the
35 |  * submitted Decimal Number to
36 |  * Octal Number.
37 |  *
38 |  * @param  string  $decimalNumber
39 |  * @return string
40 |  * @throws \Exception
41 |  */
42 | function decimalToOctal($decimalNumber)
43 | {
44 |     if (!is_numeric($decimalNumber)) {
45 |         throw new \Exception('Please pass a valid Decimal Number for Converting it to an Octal Number.');
46 |     }
47 | 
48 |     $octalNumber = '';
49 | 
50 |     while ($decimalNumber > 0) {
51 |         $octalNumber = ($decimalNumber % 8) . $octalNumber;
52 |         $decimalNumber /= 8;
53 |     }
54 | 
55 |     return $octalNumber;
56 | }
57 | 


--------------------------------------------------------------------------------
/Conversions/SpeedConversion.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This function converts the submitted
 5 |  * speed from one unit to another
 6 |  *
 7 |  * Conversion explanation taken from
 8 |  * https://www.asknumbers.com/SpeedConversion.aspx
 9 |  * Available units for conversion:
10 |  * mph -> miles per hour
11 |  * km/h -> kilometers per hour
12 |  * m/s -> meters per second
13 |  * ft/s -> feet per second
14 |  * kn -> 1 knot which is equal to 1 nautical mile (1852 km/h)
15 |  * The conversion is made using kilometers as base
16 |  *
17 |  * @param  float  $speed
18 |  * @param  string  $unitFrom
19 |  * @param  string  $unitTo
20 |  * @return float
21 |  * @throws \Exception
22 |  */
23 | function convertSpeed(float $speed, string $unitFrom, string $unitTo)
24 | {
25 |     $speedUnitsFrom = [
26 |         'mph' => 1.609344,
27 |         'km/h' => 1,
28 |         'm/s' => 3.6,
29 |         'ft/s' => 1.097,
30 |         'kn' => 1.852,
31 |     ];
32 |     $speedUnitsTo = [
33 |         'mph' => 0.6213712,
34 |         'km/h' => 1,
35 |         'm/s' => 0.277778,
36 |         'ft/s' => 0.911344,
37 |         'kn' => 0.539957,
38 |     ];
39 |     $availableUnits = array_keys($speedUnitsFrom);
40 | 
41 |     if (!is_numeric($speed)) {
42 |         throw new \Exception("Please pass a valid speed number for converting it from one unit to another.");
43 |     }
44 |     if (!in_array($unitFrom, $availableUnits) || !in_array($unitTo, $availableUnits)) {
45 |         throw new \Exception("Please pass a valid speed unit.\n\nAvailable units: " . implode(', ', $availableUnits));
46 |     }
47 | 
48 |     return round($speed * $speedUnitsFrom[$unitFrom] * $speedUnitsTo[$unitTo], 2);
49 | }
50 | 


--------------------------------------------------------------------------------
/Conversions/TemperatureConversions.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /**
  4 | * This function converts the submitted
  5 | * temperature (Celsius) and converts it into
  6 | * Fahrenheit.
  7 | *
  8 | * @author Marco https://github.com/MaarcooC
  9 | * @param float $celsius
 10 | * @throws \Exception
 11 | * @return float
 12 | */
 13 | function CelsiusToFahrenheit($celsius)
 14 | {
 15 |     if (!is_numeric($celsius)) {
 16 |         throw new \Exception("Temperature (Celsius) must be a number");
 17 |     }
 18 | 
 19 |     return round(($celsius * 9 / 5) + 32, 1);
 20 | }
 21 | 
 22 | /**
 23 | * This function converts the submitted
 24 | * temperature (Fahrenheit) and converts it into
 25 | * Celsius.
 26 | *
 27 | * @author Marco https://github.com/MaarcooC
 28 | * @param float $fahrenheit
 29 | * @throws \Exception
 30 | * @return float
 31 | */
 32 | function FahrenheitToCelsius($fahrenheit)
 33 | {
 34 |     if (!is_numeric($fahrenheit)) {
 35 |         throw new \Exception("Temperature (Fahrenheit) must be a number");
 36 |     }
 37 | 
 38 |     return round(($fahrenheit - 32) * 5 / 9, 1);
 39 | }
 40 | 
 41 | /**
 42 | * This function converts the submitted
 43 | * temperature (Celsius) and converts it into
 44 | * Kelvin.
 45 | *
 46 | * @author Marco https://github.com/MaarcooC
 47 | * @param float $celsius
 48 | * @throws \Exception
 49 | * @return float
 50 | */
 51 | function CelsiusToKelvin($celsius)
 52 | {
 53 |     if (!is_numeric($celsius)) {
 54 |         throw new \Exception("Temperature (Celsius) must be a number");
 55 |     }
 56 | 
 57 |     return round(($celsius + 273.15), 2);
 58 | }
 59 | 
 60 | /**
 61 | * This function converts the submitted
 62 | * temperature (Kelvin) and converts it into
 63 | * Celsius.
 64 | *
 65 | * @author Marco https://github.com/MaarcooC
 66 | * @param float $kelvin
 67 | * @throws \Exception
 68 | * @return float
 69 | */
 70 | function KelvinToCelsius($kelvin)
 71 | {
 72 |     if (!is_numeric($kelvin)) {
 73 |         throw new \Exception("Temperature (Kelvin) must be a number");
 74 |     }
 75 | 
 76 |     return round(($kelvin - 273.15), 2);
 77 | }
 78 | 
 79 | /**
 80 | * This function converts the submitted
 81 | * temperature (Kelvin) and converts it into
 82 | * Fahrenheit.
 83 | *
 84 | * @author Marco https://github.com/MaarcooC
 85 | * @param float $kelvin
 86 | * @throws \Exception
 87 | * @return float
 88 | */
 89 | function KelvinToFahrenheit($kelvin)
 90 | {
 91 |     if (!is_numeric($kelvin)) {
 92 |         throw new \Exception("Temperature (Kelvin) must be a number");
 93 |     }
 94 | 
 95 |     return round(($kelvin - 273.15) * 1.8 + 32, 2);
 96 | }
 97 | 
 98 | /**
 99 | * This function converts the submitted
100 | * temperature (Fahrenheit) and converts it into
101 | * kelvin.
102 | *
103 | * @author Marco https://github.com/MaarcooC
104 | * @param float $fahrenheit
105 | * @throws \Exception
106 | * @return float
107 | */
108 | function FahrenheitToKelvin($fahrenheit)
109 | {
110 |     if (!is_numeric($fahrenheit)) {
111 |         throw new \Exception("Temperature (Fahrenheit) must be a number");
112 |     }
113 | 
114 |     return round(($fahrenheit - 32) * 5 / 9 + 273.15, 2);
115 | }
116 | 


--------------------------------------------------------------------------------
/DataStructures/.keep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/TheAlgorithms/PHP/81b5386af390fd2b44fecf162ade3b1a940c8500/DataStructures/.keep


--------------------------------------------------------------------------------
/DataStructures/AVLTree/AVLTreeNode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * Created by: Ramy-Badr-Ahmed (https://github.com/Ramy-Badr-Ahmed) in Pull Request: #163
 5 |  * https://github.com/TheAlgorithms/PHP/pull/163
 6 |  *
 7 |  * Please mention me (@Ramy-Badr-Ahmed) in any issue or pull request addressing bugs/corrections to this file.
 8 |  * Thank you!
 9 |  */
10 | 
11 | namespace DataStructures\AVLTree;
12 | 
13 | class AVLTreeNode
14 | {
15 |     /**
16 |      * @var int|string
17 |      */
18 |     public $key;
19 |     /**
20 |      * @var mixed
21 |      */
22 |     public $value;
23 |     public ?AVLTreeNode $left;
24 |     public ?AVLTreeNode $right;
25 |     public int $height;
26 | 
27 |     public function __construct($key, $value, ?AVLTreeNode $left = null, ?AVLTreeNode $right = null)
28 |     {
29 |         $this->key = $key;
30 |         $this->value = $value;
31 |         $this->left = $left;
32 |         $this->right = $right;
33 |         $this->height = 1; // New node is initially at height 1
34 |     }
35 | 
36 |     public function updateHeight(): void
37 |     {
38 |         $leftHeight = $this->left ? $this->left->height : 0;
39 |         $rightHeight = $this->right ? $this->right->height : 0;
40 |         $this->height = max($leftHeight, $rightHeight) + 1;
41 |     }
42 | 
43 |     public function balanceFactor(): int
44 |     {
45 |         $leftHeight = $this->left ? $this->left->height : 0;
46 |         $rightHeight = $this->right ? $this->right->height : 0;
47 |         return $leftHeight - $rightHeight;
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/DataStructures/AVLTree/TreeTraversal.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * Created by: Ramy-Badr-Ahmed (https://github.com/Ramy-Badr-Ahmed) in Pull Request: #163
 5 |  * https://github.com/TheAlgorithms/PHP/pull/163
 6 |  *
 7 |  * Please mention me (@Ramy-Badr-Ahmed) in any issue or pull request addressing bugs/corrections to this file.
 8 |  * Thank you!
 9 |  */
10 | 
11 | namespace DataStructures\AVLTree;
12 | 
13 | abstract class TreeTraversal
14 | {
15 |     /**
16 |      * Perform an in-order traversal of the subtree.
17 |      * Recursively traverses the subtree rooted at the given node.
18 |      */
19 |     public static function inOrder(?AVLTreeNode $node): array
20 |     {
21 |         $result = [];
22 |         if ($node !== null) {
23 |             $result = array_merge($result, self::inOrder($node->left));
24 |             $result[] = [$node->key => $node->value];
25 |             $result = array_merge($result, self::inOrder($node->right));
26 |         }
27 |         return $result;
28 |     }
29 | 
30 |     /**
31 |      * Perform a pre-order traversal of the subtree.
32 |      * Recursively traverses the subtree rooted at the given node.
33 |      */
34 |     public static function preOrder(?AVLTreeNode $node): array
35 |     {
36 |         $result = [];
37 |         if ($node !== null) {
38 |             $result[] = [$node->key => $node->value];
39 |             $result = array_merge($result, self::preOrder($node->left));
40 |             $result = array_merge($result, self::preOrder($node->right));
41 |         }
42 |         return $result;
43 |     }
44 | 
45 |     /**
46 |      * Perform a post-order traversal of the subtree.
47 |      * Recursively traverses the subtree rooted at the given node.
48 |      */
49 |     public static function postOrder(?AVLTreeNode $node): array
50 |     {
51 |         $result = [];
52 |         if ($node !== null) {
53 |             $result = array_merge($result, self::postOrder($node->left));
54 |             $result = array_merge($result, self::postOrder($node->right));
55 |             $result[] = [$node->key => $node->value];
56 |         }
57 |         return $result;
58 |     }
59 | 
60 |     /**
61 |      * Perform a breadth-first traversal of the AVL Tree.
62 |      */
63 |     public static function breadthFirst(?AVLTreeNode $root): array
64 |     {
65 |         $result = [];
66 |         if ($root === null) {
67 |             return $result;
68 |         }
69 | 
70 |         $queue = [];
71 |         $queue[] = $root;
72 | 
73 |         while (!empty($queue)) {
74 |             $currentNode = array_shift($queue);
75 |             $result[] = [$currentNode->key => $currentNode->value];
76 | 
77 |             if ($currentNode->left !== null) {
78 |                 $queue[] = $currentNode->left;
79 |             }
80 | 
81 |             if ($currentNode->right !== null) {
82 |                 $queue[] = $currentNode->right;
83 |             }
84 |         }
85 | 
86 |         return $result;
87 |     }
88 | }
89 | 


--------------------------------------------------------------------------------
/DataStructures/BinarySearchTree/BSTNode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * Created by: Ramy-Badr-Ahmed (https://github.com/Ramy-Badr-Ahmed) in Pull Request: #174
 5 |  * https://github.com/TheAlgorithms/PHP/pull/174
 6 |  *
 7 |  * Please mention me (@Ramy-Badr-Ahmed) in any issue or pull request addressing bugs/corrections to this file.
 8 |  * Thank you!
 9 |  */
10 | 
11 | namespace DataStructures\BinarySearchTree;
12 | 
13 | class BSTNode
14 | {
15 |     public int $key;
16 |     /**
17 |      * @var mixed
18 |      */
19 |     public $value;
20 |     public ?BSTNode $left;
21 |     public ?BSTNode $right;
22 |     public ?BSTNode $parent;
23 | 
24 |     /**
25 |      * @param int $key The key of the node.
26 |      * @param mixed $value The associated value.
27 |      */
28 |     public function __construct(int $key, $value)
29 |     {
30 |         $this->key = $key;
31 |         $this->value = $value;
32 |         $this->left = null;
33 |         $this->right = null;
34 |         $this->parent = null;
35 |     }
36 | 
37 |     public function isRoot(): bool
38 |     {
39 |         return $this->parent === null;
40 |     }
41 | 
42 |     public function isLeaf(): bool
43 |     {
44 |         return $this->left === null && $this->right === null;
45 |     }
46 | 
47 |     public function getChildren(): array
48 |     {
49 |         if ($this->isLeaf()) {
50 |             return [];
51 |         }
52 | 
53 |         $children = [];
54 |         if ($this->left !== null) {
55 |             $children['left'] = $this->left;
56 |         }
57 |         if ($this->right !== null) {
58 |             $children['right'] = $this->right;
59 |         }
60 |         return $children;
61 |     }
62 |     public function getChildrenCount(): int
63 |     {
64 |         return count($this->getChildren());
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/DataStructures/BinarySearchTree/DuplicateKeyException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace DataStructures\BinarySearchTree;
 4 | 
 5 | use LogicException;
 6 | 
 7 | class DuplicateKeyException extends LogicException
 8 | {
 9 |     public function __construct($key, $code = 0, LogicException $previous = null)
10 |     {
11 |         $message = "Insertion failed. Duplicate key: " . $key;
12 |         parent::__construct($message, $code, $previous);
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/DataStructures/CompareBinaryTree/BinaryTreeNode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace DataStructures\CompareBinaryTree;
 4 | 
 5 | class BinaryTreeNode
 6 | {
 7 |     public function __construct($value, ?BinaryTreeNode $left = null, BinaryTreeNode $right = null)
 8 |     {
 9 |         $this->value = $value;
10 |         $this->left = $left;
11 |         $this->right = $right;
12 |     }
13 | 
14 |     public $value;
15 |     public ?BinaryTreeNode $left;
16 |     public ?BinaryTreeNode $right;
17 | }
18 | 


--------------------------------------------------------------------------------
/DataStructures/CompareBinaryTree/CompareBinaryTree.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace DataStructures\CompareBinaryTree;
 4 | 
 5 | /**
 6 |  * Recurrent comparison of binary trees based on comparison of left and right branches
 7 |  * (https://en.wikipedia.org/wiki/Binary_tree).
 8 |  *
 9 |  * @author Michał Żarnecki https://github.com/rzarno
10 |  */
11 | class CompareBinaryTree
12 | {
13 |     /**
14 |      * compare two binary trees
15 |      * @param BinaryTreeNode|null $a
16 |      * @param BinaryTreeNode|null $b
17 |      * @return bool
18 |      */
19 |     public function areTreesEqual(?BinaryTreeNode $a, ?BinaryTreeNode $b): bool
20 |     {
21 |         if (! $a  &&  $b || $a && ! $b) {
22 |             return false;
23 |         }
24 | 
25 |         if (! $a && ! $b) {
26 |             return true;
27 |         }
28 | 
29 |         if ($a->value !== $b->value) {
30 |             return false;
31 |         }
32 |         return  $this->areTreesEqual($a->left, $b->left)
33 |             &&  $this->areTreesEqual($a->right, $b->right);
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/DataStructures/DisjointSets/DisjointSet.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * Created by: Ramy-Badr-Ahmed (https://github.com/Ramy-Badr-Ahmed) in Pull Request: #160
 5 |  * https://github.com/TheAlgorithms/PHP/pull/160
 6 |  *
 7 |  * Please mention me (@Ramy-Badr-Ahmed) in any issue or pull request addressing bugs/corrections to this file.
 8 |  * Thank you!
 9 |  */
10 | 
11 | namespace DataStructures\DisjointSets;
12 | 
13 | class DisjointSet
14 | {
15 |     /**
16 |      * Finds the representative of the set that contains the node.
17 |      */
18 |     public function findSet(DisjointSetNode $node): DisjointSetNode
19 |     {
20 |         if ($node !== $node->parent) {
21 |             // Path compression: make the parent point directly to the root
22 |             $node->parent = $this->findSet($node->parent);
23 |         }
24 |         return $node->parent;
25 |     }
26 | 
27 |     /**
28 |      * Unites the sets that contain x and y.
29 |      */
30 |     public function unionSet(DisjointSetNode $nodeX, DisjointSetNode $nodeY): void
31 |     {
32 |         $rootX = $this->findSet($nodeX);
33 |         $rootY = $this->findSet($nodeY);
34 | 
35 |         if ($rootX === $rootY) {
36 |             return; // They are already in the same set
37 |         }
38 | 
39 |         // Union by rank: attach the smaller tree under the larger tree
40 |         if ($rootX->rank > $rootY->rank) {
41 |             $rootY->parent = $rootX;
42 |         } else {
43 |             $rootX->parent = $rootY;
44 |             if ($rootX->rank === $rootY->rank) {
45 |                 $rootY->rank += 1;
46 |             }
47 |         }
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/DataStructures/DisjointSets/DisjointSetNode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * Created by: Ramy-Badr-Ahmed (https://github.com/Ramy-Badr-Ahmed) in Pull Request: #160
 5 |  * https://github.com/TheAlgorithms/PHP/pull/160
 6 |  *
 7 |  * Please mention me (@Ramy-Badr-Ahmed) in any issue or pull request addressing bugs/corrections to this file.
 8 |  * Thank you!
 9 |  */
10 | 
11 | namespace DataStructures\DisjointSets;
12 | 
13 | class DisjointSetNode
14 | {
15 |     /**
16 |      * @var int|string|float|null
17 |      */
18 |     // PHP7.4: Defined with annotations
19 |     public $data;       # replace with type hint "mixed" as of PHP 8.0^.
20 |     public int $rank;
21 |     public DisjointSetNode $parent;
22 | 
23 |     public function __construct($data = null)
24 |     {
25 |         $this->data = $data;
26 |         $this->rank = 0;
27 |         $this->parent = $this;  // Initialize parent to itself
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/DataStructures/InvertBinaryTree/BinaryTree.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace DataStructures\InvertBinaryTree;
 4 | 
 5 | class BinaryTree
 6 | {
 7 |     private ?BinaryTree $left = null;
 8 |     private ?BinaryTree $right = null;
 9 |     private $value;
10 | 
11 |     public function setLeft(?BinaryTree $left)
12 |     {
13 |         $this->left = $left;
14 |         return $this;
15 |     }
16 | 
17 |     public function getLeft(): ?BinaryTree
18 |     {
19 |         return $this->left;
20 |     }
21 | 
22 |     public function setRight(?BinaryTree $right)
23 |     {
24 |         $this->right = $right;
25 |         return $this;
26 |     }
27 | 
28 |     public function getRight(): ?BinaryTree
29 |     {
30 |         return $this->right;
31 |     }
32 | 
33 |     public function setValue($value)
34 |     {
35 |         $this->value = $value;
36 |         return $this;
37 |     }
38 | 
39 |     public function getValue()
40 |     {
41 |         return $this->value;
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/DataStructures/InvertBinaryTree/InvertBinaryTree.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace DataStructures\InvertBinaryTree;
 4 | 
 5 | /**
 6 |  * Recurrent algorithm to invert binary tree (mirror)
 7 |  * (https://medium.com/@kvrware/inverting-binary-tree-b0ff3a5cb0df).
 8 |  *
 9 |  * @author Michał Żarnecki https://github.com/rzarno
10 |  */
11 | class InvertBinaryTree
12 | {
13 |     public function invert(?BinaryTree $b): void
14 |     {
15 |         if (! $b) {
16 |             return;
17 |         }
18 |         $tmp = $b->getLeft();
19 |         $b->setLeft($b->getRight());
20 |         $b->setRight($tmp);
21 |         $this->invert($b->getLeft());
22 |         $this->invert($b->getRight());
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/DataStructures/Node.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Linked List Node Class
 5 |  */
 6 | class Node
 7 | {
 8 |     public ?Node $next = null;
 9 |     public ?Node $prev = null;
10 |     public $data;
11 | 
12 |     // Constructor
13 |     public function __construct($data)
14 |     {
15 |         $this->data = $data;
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/DataStructures/Queue.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Queue Data Structure - FIFO (First In, First Out)
 5 |  */
 6 | class Queue
 7 | {
 8 |     private array $elements;
 9 |     private int $count;
10 |     private int $lowestCount;
11 | 
12 |     public function __construct()
13 |     {
14 |         $this->elements = [];
15 |         $this->count = 0;
16 |         $this->lowestCount = 0;
17 |     }
18 | 
19 |     public function enqueue($element): void
20 |     {
21 |         $this->elements[$this->count] = $element;
22 |         $this->count++;
23 |     }
24 | 
25 |     public function dequeue()
26 |     {
27 |         if ($this->isEmpty()) {
28 |             return null;
29 |         }
30 | 
31 |         $element = $this->elements[$this->lowestCount];
32 | 
33 |         unset($this->elements[$this->lowestCount]);
34 | 
35 |         $this->lowestCount++;
36 | 
37 |         return $element;
38 |     }
39 | 
40 |     public function isEmpty(): bool
41 |     {
42 |         return $this->count - $this->lowestCount === 0;
43 |     }
44 | 
45 |     public function size(): int
46 |     {
47 |         return $this->count - $this->lowestCount;
48 |     }
49 | 
50 |     public function peek()
51 |     {
52 |         if ($this->isEmpty()) {
53 |             return null;
54 |         }
55 | 
56 |         return $this->elements[$this->lowestCount];
57 |     }
58 | 
59 |     public function clear(): void
60 |     {
61 |         $this->elements = [];
62 |         $this->count = 0;
63 |         $this->lowestCount = 0;
64 |     }
65 | 
66 |     public function toString(string $delimiter = ''): string
67 |     {
68 |         if ($this->isEmpty()) {
69 |             return '';
70 |         }
71 | 
72 |         $result = "{$this->elements[$this->lowestCount]}";
73 | 
74 |         for ($i = $this->lowestCount + 1; $i < $this->count; $i++) {
75 |             $result .= "{$delimiter}{$this->elements[$i]}";
76 |         }
77 | 
78 |         return $result;
79 |     }
80 | }
81 | 


--------------------------------------------------------------------------------
/DataStructures/ReverseLinkedList/LinkedListItem.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace DataStructures\ReverseLinkedList;
 4 | 
 5 | class LinkedListItem
 6 | {
 7 |     private ?LinkedListItem $next = null;
 8 |     private ?LinkedListItem $prev = null;
 9 |     private $value;
10 | 
11 |     public function setNext(?LinkedListItem $next)
12 |     {
13 |         $this->next = $next;
14 |         return $this;
15 |     }
16 | 
17 |     public function getNext(): ?LinkedListItem
18 |     {
19 |         return $this->next;
20 |     }
21 | 
22 |     public function setPrev(?LinkedListItem $prev)
23 |     {
24 |         $this->prev = $prev;
25 |         return $this;
26 |     }
27 | 
28 |     public function getPrev(): ?LinkedListItem
29 |     {
30 |         return $this->prev;
31 |     }
32 | 
33 |     public function setValue($value)
34 |     {
35 |         $this->value = $value;
36 |         return $this;
37 |     }
38 | 
39 |     public function getValue()
40 |     {
41 |         return $this->value;
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/DataStructures/ReverseLinkedList/ReverseLinkedList.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace DataStructures\ReverseLinkedList;
 4 | 
 5 | /**
 6 |  * Reverse linked list
 7 |  * (https://en.wikipedia.org/wiki/Linked_list).
 8 |  *
 9 |  * @author Michał Żarnecki https://github.com/rzarno
10 |  */
11 | class ReverseLinkedList
12 | {
13 |     public function reverse(LinkedListItem $item): LinkedListItem
14 |     {
15 |         $next = $item->getNext();
16 |         $item->setNext(null);
17 |         while (true) {
18 |             $item->setPrev($next);
19 |             if (! $next) {
20 |                 return $item;
21 |             }
22 |             $nextNext = $next->getNext();
23 |             $next->setNext($item);
24 |             $item = $next;
25 |             $next = $nextNext;
26 |         }
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/DataStructures/SegmentTree/SegmentTreeNode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * Created by: Ramy-Badr-Ahmed (https://github.com/Ramy-Badr-Ahmed) in Pull Request #166
 5 |  * https://github.com/TheAlgorithms/PHP/pull/166
 6 |  *
 7 |  * Please mention me (@Ramy-Badr-Ahmed) in any issue or pull request addressing bugs/corrections to this file.
 8 |  * Thank you!
 9 |  */
10 | 
11 | namespace DataStructures\SegmentTree;
12 | 
13 | class SegmentTreeNode
14 | {
15 |     public int $start;
16 |     public int $end;
17 |     /**
18 |      * @var int|float
19 |      */
20 |     public $value;
21 |     public ?SegmentTreeNode $left;
22 |     public ?SegmentTreeNode $right;
23 | 
24 |     /**
25 |      * @param int $start The starting index of the range.
26 |      * @param int $end The ending index of the range.
27 |      * @param int|float $value The initial aggregated value for this range (e.g. sum, min, or max).
28 |      * calculated using a callback. Defaults to sum.
29 |      */
30 |     public function __construct(int $start, int $end, $value)
31 |     {
32 |         $this->start = $start;
33 |         $this->end = $end;
34 |         $this->value = $value;
35 |         $this->left = null;
36 |         $this->right = null;
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/DataStructures/SinglyLinkedList.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  *  Singly Linked List
 5 |  */
 6 | class SinglyLinkedList
 7 | {
 8 |     public ?SinglyLinkedList $next = null;
 9 |     public $data;
10 | 
11 |     public function __construct($data)
12 |     {
13 |         $this->data = $data;
14 |     }
15 | 
16 |     public function append($data): void
17 |     {
18 |         $current = $this;
19 |         while ($current instanceof SinglyLinkedList && isset($current->next)) {
20 |             $current = $current->next;
21 |         }
22 | 
23 |         $current->next = new SinglyLinkedList($data);
24 |     }
25 | 
26 |     public function delete($data): SinglyLinkedList
27 |     {
28 |         $current = $this;
29 |         if ($current->data == $data) {
30 |             return $current->next;
31 |         }
32 | 
33 |         while ($current instanceof SinglyLinkedList && isset($current->next)) {
34 |             if ($current->next->data === $data) {
35 |                 $current->next = $current->next->next;
36 |                 return $this;
37 |             }
38 | 
39 |             $current = $current->next;
40 |         }
41 | 
42 |         return $this;
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/DataStructures/SplayTree/SplayTreeNode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * Created by: Ramy-Badr-Ahmed (https://github.com/Ramy-Badr-Ahmed) in Pull Request: #168
 5 |  * https://github.com/TheAlgorithms/PHP/pull/168
 6 |  *
 7 |  * Please mention me (@Ramy-Badr-Ahmed) in any issue or pull request addressing bugs/corrections to this file.
 8 |  * Thank you!
 9 |  */
10 | 
11 | namespace DataStructures\SplayTree;
12 | 
13 | class SplayTreeNode
14 | {
15 |     /**
16 |      * @var int|string
17 |      */
18 |     public int $key;
19 |     /**
20 |      * @var mixed
21 |      */
22 |     public $value;
23 |     public ?SplayTreeNode $left;
24 |     public ?SplayTreeNode $right;
25 |     public ?SplayTreeNode $parent;
26 | 
27 |     /**
28 |      * @param int $key The key of the node.
29 |      * @param mixed $value The associated value.
30 |      */
31 |     public function __construct(int $key, $value)
32 |     {
33 |         $this->key = $key;
34 |         $this->value = $value;
35 | 
36 |         // Set all node pointers to null initially
37 |         $this->left = null;
38 |         $this->right = null;
39 |         $this->parent = null;
40 |     }
41 | 
42 |     public function isLeaf(): bool
43 |     {
44 |         return $this->left === null && $this->right === null;
45 |     }
46 | 
47 |     public function isRoot(): bool
48 |     {
49 |         return $this->parent === null;
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/DataStructures/Stack.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Stack Implementation in PHP
 5 |  */
 6 | class Stack
 7 | {
 8 |     private array $stack = [];
 9 | 
10 |     public function __construct(array $array = [])
11 |     {
12 |         $this->stack = $array;
13 |     }
14 | 
15 |     public function __destruct()
16 |     {
17 |         unset($this->stack);
18 |     }
19 | 
20 | 
21 |     public function push($data): void
22 |     {
23 |         array_push($this->stack, $data);
24 |     }
25 | 
26 |     public function pop()
27 |     {
28 |         return array_pop($this->stack);
29 |     }
30 | 
31 |     public function peek()
32 |     {
33 |         return $this->stack[count($this->stack) - 1];
34 |     }
35 | 
36 |     public function isEmpty(): bool
37 |     {
38 |         return empty($this->stack);
39 |     }
40 | 
41 |     public function print(): void
42 |     {
43 |         echo implode(', ', $this->stack);
44 |     }
45 | 
46 |     public function __toString(): string
47 |     {
48 |         return implode(', ', $this->stack);
49 |     }
50 | 
51 |     public function length(): int
52 |     {
53 |         return count($this->stack);
54 |     }
55 | 
56 |     public function clear(): void
57 |     {
58 |         $this->stack = [];
59 |     }
60 | 
61 |     public function search($data): int
62 |     {
63 |         return array_search($data, $this->stack);
64 |     }
65 | 
66 |     public function toArray(): array
67 |     {
68 |         return $this->stack;
69 |     }
70 | 
71 |     public function fromArray(array $array): void
72 |     {
73 |         $this->stack = $array;
74 |     }
75 | 
76 |     public function reverse(): void
77 |     {
78 |         $this->stack = array_reverse($this->stack);
79 |     }
80 | 
81 |     public function sort(): void
82 |     {
83 |         sort($this->stack);
84 |     }
85 | }
86 | 


--------------------------------------------------------------------------------
/DataStructures/Trie/Trie.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /*
  4 |  * Created by: Ramy-Badr-Ahmed (https://github.com/Ramy-Badr-Ahmed) in Pull Request #162 and #172
  5 |  * https://github.com/TheAlgorithms/PHP/pull/162
  6 |  * https://github.com/TheAlgorithms/PHP/pull/172
  7 |  *
  8 |  * Please mention me (@Ramy-Badr-Ahmed) in any issue or pull request addressing bugs/corrections to this file.
  9 |  * Thank you!
 10 |  */
 11 | 
 12 | namespace DataStructures\Trie;
 13 | 
 14 | class Trie
 15 | {
 16 |     private TrieNode $root;
 17 | 
 18 |     public function __construct()
 19 |     {
 20 |         $this->root = new TrieNode();
 21 |     }
 22 | 
 23 |     /**
 24 |      * Get the root node of the Trie.
 25 |      */
 26 |     public function getRoot(): TrieNode
 27 |     {
 28 |         return $this->root;
 29 |     }
 30 | 
 31 |     /**
 32 |      * Insert a word into the Trie.
 33 |      */
 34 |     public function insert(string $word): void
 35 |     {
 36 |         $node = $this->root;
 37 |         for ($i = 0; $i < strlen($word); $i++) {
 38 |             $char = $word[$i];
 39 |             $node = $node->addChild($char);
 40 |         }
 41 |         $node->isEndOfWord = true;
 42 |     }
 43 | 
 44 |     /**
 45 |      * Search for a word in the Trie.
 46 |      */
 47 |     public function search(string $word): bool
 48 |     {
 49 |         $node = $this->root;
 50 |         for ($i = 0; $i < strlen($word); $i++) {
 51 |             $char = $word[$i];
 52 |             if (!$node->hasChild($char)) {
 53 |                 return false;
 54 |             }
 55 |             $node = $node->getChild($char);
 56 |         }
 57 |         return $node->isEndOfWord;
 58 |     }
 59 | 
 60 |     /**
 61 |      * Find all words that start with a given prefix.
 62 |      */
 63 |     public function startsWith(string $prefix): array
 64 |     {
 65 |         $prefix = strtolower($prefix);  // Normalize the prefix to lowercase
 66 |         $node = $this->root;
 67 |         for ($i = 0; $i < strlen($prefix); $i++) {
 68 |             $char = $prefix[$i];
 69 |             if (!$node->hasChild($char)) {
 70 |                 return [];
 71 |             }
 72 |             $node = $node->getChild($char);
 73 |         }
 74 |         return $this->findWordsFromNode($node, $prefix);
 75 |     }
 76 | 
 77 |     /**
 78 |      * Helper function to find all words from a given node.
 79 |      */
 80 |     private function findWordsFromNode(TrieNode $node, string $prefix): array
 81 |     {
 82 |         $words = [];
 83 |         if ($node->isEndOfWord) {
 84 |             $words[] = $prefix;
 85 |         }
 86 | 
 87 |         foreach ($node->children as $char => $childNode) {
 88 |             $words = array_merge($words, $this->findWordsFromNode($childNode, $prefix . $char));
 89 |         }
 90 | 
 91 |         return $words;
 92 |     }
 93 | 
 94 |     /**
 95 |      * Delete a word from the Trie.
 96 |      * Recursively traverses the Trie and removes nodes
 97 |      *
 98 |      * @param string $word The word to delete.
 99 |      * @return bool Returns true if the word was successfully deleted, otherwise false.
100 |      */
101 |     public function delete(string $word): bool
102 |     {
103 |         return $this->deleteHelper($this->root, $word, 0);
104 |     }
105 | 
106 |     /**
107 |      * Helper function for deleting a word.
108 |      * Recursively traverse the Trie and removes nodes.
109 |      *
110 |      * @param TrieNode $node The current node in the Trie.
111 |      * @param string $word The word being deleted.
112 |      * @param int $index The current index in the word.
113 |      * @return bool Returns true if the current node should be deleted, otherwise false.
114 |      */
115 |     private function deleteHelper(TrieNode $node, string &$word, int $index): bool
116 |     {
117 |         if ($index === strlen($word)) {
118 |             if (!$node->isEndOfWord) {
119 |                 return false;
120 |             }
121 |             $node->isEndOfWord = false;
122 |             return empty($node->children);
123 |         }
124 | 
125 |         $char = $word[$index];
126 |         $childNode = $node->getChild($char);
127 |         if ($childNode === null) {
128 |             return false;
129 |         }
130 | 
131 |         // Recursively delete the child node
132 |         $shouldDeleteCurrentNode = $this->deleteHelper($childNode, $word, $index + 1);
133 | 
134 |         if ($shouldDeleteCurrentNode) {
135 |             unset($node->children[$char]);
136 |             return !$node->isEndOfWord;     // true if current node is not the end of another word
137 |         }
138 | 
139 |         return false;
140 |     }
141 | 
142 |     /**
143 |      * Recursively traverses the Trie starting from the given node and collects all words.
144 |      *
145 |      * @param TrieNode $node The starting node for traversal.
146 |      * @param string $prefix The prefix of the current path in the Trie.
147 |      * @return array An array of words found in the Trie starting from the given node.
148 |      */
149 |     public function traverseTrieNode(TrieNode $node, string $prefix = ''): array
150 |     {
151 |         $words = [];
152 | 
153 |         if ($node->isEndOfWord) {
154 |             $words[] = $prefix;
155 |         }
156 | 
157 |         foreach ($node->children as $char => $childNode) {
158 |             $words = array_merge($words, $this->traverseTrieNode($childNode, $prefix . $char));
159 |         }
160 | 
161 |         return $words;
162 |     }
163 | 
164 |     /**
165 |      * Gets all words stored in the Trie.
166 |      *
167 |      * @return array An array of all words in the Trie.
168 |      */
169 |     public function getWords(): array
170 |     {
171 |         return $this->traverseTrieNode($this->root);
172 |     }
173 | }
174 | 


--------------------------------------------------------------------------------
/DataStructures/Trie/TrieNode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * Created by: Ramy-Badr-Ahmed (https://github.com/Ramy-Badr-Ahmed) in Pull Request #162 and #172
 5 |  * https://github.com/TheAlgorithms/PHP/pull/162
 6 |  * https://github.com/TheAlgorithms/PHP/pull/172
 7 |  *
 8 |  * Please mention me (@Ramy-Badr-Ahmed) in any issue or pull request addressing bugs/corrections to this file.
 9 |  * Thank you!
10 |  */
11 | 
12 | namespace DataStructures\Trie;
13 | 
14 | class TrieNode
15 | {
16 |     /** @var array<string, TrieNode> */
17 |     public array $children;
18 |     public bool $isEndOfWord;
19 | 
20 |     public function __construct()
21 |     {
22 |         $this->children = [];  // Associative array where [ char => TrieNode ]
23 |         $this->isEndOfWord = false;
24 |     }
25 | 
26 |     /**
27 |      * Add a child node for a character.
28 |      */
29 |     public function addChild(string $char): TrieNode
30 |     {
31 |         $char = $this->normalizeChar($char);
32 |         if (!isset($this->children[$char])) {
33 |             $this->children[$char] = new TrieNode();
34 |         }
35 |         return $this->children[$char];
36 |     }
37 | 
38 |     /**
39 |      * Check if a character has a child node.
40 |      */
41 |     public function hasChild(string $char): bool
42 |     {
43 |         $char = $this->normalizeChar($char);
44 |         return isset($this->children[$char]);
45 |     }
46 | 
47 |     /**
48 |      * Get the child node corresponding to a character.
49 |      */
50 |     public function getChild(string $char): ?TrieNode
51 |     {
52 |         $char = $this->normalizeChar($char);
53 |         return $this->children[$char] ?? null;
54 |     }
55 | 
56 |     /**
57 |      * Normalize the character to lowercase.
58 |      */
59 |     private function normalizeChar(string $char): string
60 |     {
61 |         return strtolower($char);
62 |     }
63 | }
64 | 


--------------------------------------------------------------------------------
/Graphs/BellmanFord.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * The Bellman–Ford algorithm is an algorithm that computes shortest paths from a single source vertex to all of the
 5 |  * other vertices in a weighted digraph.
 6 |  * (https://en.wikipedia.org/wiki/Bellman%E2%80%93Ford_algorithm).
 7 |  *
 8 |  * @author Michał Żarnecki https://github.com/rzarno
 9 |  * @param array $verticesNames An array of vertices names
10 |  * @param GraphEdge[] $edges An array of edges
11 |  * @param string $start The starting vertex
12 |  * @return array An array of shortest paths from $start to all other vertices
13 |  */
14 | function bellmanFord(array $verticesNames, array $edges, string $start, bool $verbose = false): array
15 | {
16 |     $vertices = array_combine($verticesNames, array_fill(0, count($verticesNames), PHP_INT_MAX));
17 | 
18 |     $change = true;
19 |     $round = 1;
20 |     while ($change) {
21 |         if ($verbose) {
22 |             echo "round $round\n";
23 |         }
24 |         $change = false;
25 |         foreach ($vertices as $vertice => $minWeight) {
26 |             if ($verbose) {
27 |                 echo "checking vertex $vertice\n";
28 |             }
29 |             if ($start === $vertice) {
30 |                 $vertices[$vertice] = 0;
31 |             }
32 | 
33 |             foreach ($edges[$vertice] as $edge) {
34 |                 if ($vertices[$edge->end] > $vertices[$vertice] + $edge->weight) {
35 |                     if ($verbose) {
36 |                         echo "replace $vertice " . $vertices[$edge->end] . " with "
37 |                             . ($vertices[$vertice] + $edge->weight) . "\n ";
38 |                     }
39 |                     $vertices[$edge->end] = $vertices[$vertice] + $edge->weight;
40 |                     $change = true;
41 |                 }
42 |             }
43 |         }
44 |         $round++;
45 |     }
46 |     return $vertices;
47 | }
48 | 


--------------------------------------------------------------------------------
/Graphs/BreadthFirstSearch.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Breadth-first search (BFS) is an algorithm for searching a tree data structure for a node that satisfies
 5 |  * a given property.
 6 |  * (https://en.wikipedia.org/wiki/Breadth-first_search).
 7 |  *
 8 |  * This is a non-recursive implementation.
 9 |  *
10 |  * References:
11 |  * https://cp-algorithms.com/graph/breadth-first-search.html
12 |  *
13 |  * https://the-algorithms.com/algorithm/depth-first-search?lang=python
14 |  *
15 |  * @author Aryansh Bhargavan https://github.com/aryanshb
16 |  * @param array $adjList An array representing the grapth as an Adjacent List
17 |  * @param int|string $start The starting vertex
18 |  * @return bool if path between start and end vertex exists
19 |  */
20 | 
21 | function bfs($adjList, $start, $end, $yes = false)
22 | {
23 |     $visited = [];
24 |     $queue = [$start];
25 |     while (!empty($queue)) {
26 |         $v = array_shift($queue);
27 |         $visited[$v] = 1;
28 |         foreach ($adjList[$v] as $adj) {
29 |             if (!array_key_exists($adj, $visited)) {
30 |                 array_push($queue, $adj);
31 |             }
32 |         }
33 |     }
34 |     // return array_key_exists($end, $visited);
35 |     if (array_key_exists($end, $visited)) {
36 |         $yes = true;
37 |     }
38 |     return $yes;
39 | }
40 | 


--------------------------------------------------------------------------------
/Graphs/DepthFirstSearch.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * The Depth-first Search is an algorithm used for traversing or searching trees or graphs
 5 |  * (https://en.wikipedia.org/wiki/Depth-first_search).
 6 |  *
 7 |  * This is a non-recursive implementation.
 8 |  *
 9 |  * References:
10 |  * https://www.geeksforgeeks.org/depth-first-search-or-dfs-for-a-graph/
11 |  *
12 |  * https://the-algorithms.com/algorithm/depth-first-search?lang=python
13 |  *
14 |  * @author Andre Alves https://github.com/andremralves
15 |  * @param array $adjList An array representing the grapth as an Adjacent List
16 |  * @param int|string $start The starting vertex
17 |  * @return array The visited vertices
18 |  */
19 | function dfs($adjList, $start)
20 | {
21 |     $visited = [];
22 |     $stack = [$start];
23 |     while (!empty($stack)) {
24 |         // Removes the ending element from the stack and mark as visited
25 |         $v = array_pop($stack);
26 |         $visited[$v] = 1;
27 | 
28 |         // Checks each adjacent vertex of $v and add to the stack if not visited
29 |         foreach (array_reverse($adjList[$v]) as $adj) {
30 |             if (!array_key_exists($adj, $visited)) {
31 |                 array_push($stack, $adj);
32 |             }
33 |         }
34 |     }
35 |     return array_keys($visited);
36 | }
37 | 


--------------------------------------------------------------------------------
/Graphs/Dijkstras.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * The Dijkstra's algorithm is an algorithm for finding the shortest paths between nodes in a weighted graph.
 5 |  * (https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm).
 6 |  *
 7 |  * @author Michał Żarnecki https://github.com/rzarno
 8 |  * @param array $verticesNames An array of vertices names
 9 |  * @param GraphEdge[] $edges An array of edges
10 |  * @param string $start The starting vertex
11 |  * @return array An array of shortest paths from $start to all other vertices
12 |  */
13 | function dijkstras(array $verticesNames, array $edges, string $start): array
14 | {
15 |     $vertices = array_combine($verticesNames, array_fill(0, count($verticesNames), PHP_INT_MAX));
16 |     $visitedNodes = [];
17 | 
18 |     $nextVertex = $start;
19 |     $vertices[$start] = 0;
20 |     while (count($visitedNodes) < count($verticesNames)) { //continue until all nodes are visited
21 |         foreach ($edges as $edge) {
22 |             if ($edge->start == $nextVertex) { //consider only nodes connected to current one
23 |                 $vertices[$edge->end] = min($vertices[$edge->end], $vertices[$nextVertex] + $edge->weight);
24 |             }
25 |         }
26 | 
27 |         // find vertex with current lowest value to be starting point in next iteration
28 |         $minVertexName = null;
29 |         $minVertexWeight = PHP_INT_MAX;
30 |         foreach ($vertices as $name => $weight) {
31 |             if (in_array($name, $visitedNodes) || $name == $nextVertex) {
32 |                 continue;
33 |             }
34 |             if ($weight <= $minVertexWeight) {
35 |                 $minVertexName = $name;
36 |                 $minVertexWeight = $weight;
37 |             }
38 |         }
39 |         $visitedNodes[] = $nextVertex;
40 |         $nextVertex = $minVertexName;
41 |     }
42 |     return $vertices;
43 | }
44 | 


--------------------------------------------------------------------------------
/Graphs/GraphEdge.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | class GraphEdge
4 | {
5 |     public string $start;
6 |     public string $end;
7 |     public int $weight;
8 | }
9 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2020 The Algorithms
 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.
22 | 


--------------------------------------------------------------------------------
/Maths/AbsoluteMax.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This function calculates
 5 |  * Absolute max values from
 6 |  * the different numbers
 7 |  * provided
 8 |  *
 9 |  * @param  decimal  $numbers  A variable sized number input
10 |  * @return decimal $absoluteMax Absolute max value
11 |  * @throws \Exception
12 |  */
13 | function absolute_max(...$numbers)
14 | {
15 |     if (empty($numbers)) {
16 |         throw new \Exception('Please pass values to find absolute max value');
17 |     }
18 | 
19 |     $absoluteMax = $numbers[0];
20 |     for ($loopIndex = 0; $loopIndex < count($numbers); $loopIndex++) {
21 |         if ($numbers[$loopIndex] > $absoluteMax) {
22 |             $absoluteMax = $numbers[$loopIndex];
23 |         }
24 |     }
25 | 
26 |     return $absoluteMax;
27 | }
28 | 


--------------------------------------------------------------------------------
/Maths/AbsoluteMin.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This function calculates
 5 |  * Absolute min values from
 6 |  * the different numbers
 7 |  * provided.
 8 |  *
 9 |  * @param  decimal  $numbers  A variable sized number input
10 |  * @return decimal $absoluteMin Absolute min value
11 |  * @throws \Exception
12 |  */
13 | function absolute_min(...$numbers)
14 | {
15 |     if (empty($numbers)) {
16 |         throw new \Exception('Please pass values to find absolute min value');
17 |     }
18 | 
19 |     $absoluteMin = $numbers[0];
20 |     for ($loopIndex = 0; $loopIndex < count($numbers); $loopIndex++) {
21 |         if ($numbers[$loopIndex] < $absoluteMin) {
22 |             $absoluteMin = $numbers[$loopIndex];
23 |         }
24 |     }
25 | 
26 |     return $absoluteMin;
27 | }
28 | 


--------------------------------------------------------------------------------
/Maths/ArmstrongNumber.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This function checks if given number is Armstrong
 5 |  * e.g. 153
 6 |  * @param integer $input
 7 |  * @return boolean
 8 |  */
 9 | function isNumberArmstrong(int $input): bool
10 | {
11 |     $arr = array_map('intval', str_split($input));
12 |     $sumOfCubes = 0;
13 |     foreach ($arr as $num) {
14 |         $sumOfCubes += $num * $num * $num;
15 |     }
16 |     if ($sumOfCubes == $input) {
17 |         return true;
18 |     } else {
19 |         return false;
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/Maths/BaseX.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * This function will calculate the base of any number that is <11.
 5 |  * You can calculate binary, octal quickly with this as well.
 6 |  * For example, to calculate binary of number 4 you can run "echo baseX(4, 2);"
 7 |  * and for octal of number 10 you can run "echo baseX(10, 8);"
 8 |  *
 9 |  * @param int $k The number to convert
10 |  * @param int $x The base to convert to
11 |  * @return string The base-x representation of the given number
12 |  * @author Sevada797 https://github.com/sevada797
13 | 
14 |  */
15 | function baseX($k, $x)
16 | {
17 |     $arr = [];
18 | 
19 |     while (true) {
20 |         array_push($arr, $k % $x);
21 |         $k = ($k - ($k % $x)) / $x;
22 | 
23 |         if ($k == 0) {
24 |             break;
25 |         }
26 |     }
27 | 
28 |     return implode("", array_reverse($arr));
29 | }
30 | 


--------------------------------------------------------------------------------
/Maths/CheckEven.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This function checks whether
 5 |  * the provided integer is even.
 6 |  *
 7 |  * @param int $number An integer input
 8 |  * @return bool whether the number is even or not
 9 |  */
10 | function isEven(int $number): bool
11 | {
12 |     return $number % 2 === 0;
13 | }
14 | 


--------------------------------------------------------------------------------
/Maths/CheckOdd.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This function checks whether
 5 |  * the provided integer is odd.
 6 |  *
 7 |  * @param int $number An integer input
 8 |  * @return bool whether the number is odd or not
 9 |  */
10 | function isOdd(int $number): bool
11 | {
12 |     return $number % 2 !== 0;
13 | }
14 | 


--------------------------------------------------------------------------------
/Maths/CheckPalindrome.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This function checks if given number is palindromic
 5 |  * e.g. 121
 6 |  * @param integer $input
 7 |  * @return boolean
 8 |  */
 9 | function isNumberPalindromic(int $input): bool
10 | {
11 |     $arr = array_map('intval', str_split($input));
12 |     $arrRev = array_reverse($arr);
13 |     $inputRev = (int)implode("", $arrRev);
14 |     if ($input == $inputRev) {
15 |         return true;
16 |     } else {
17 |         return false;
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/Maths/CheckPrime.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This function check whether
 5 |  * the provided integer is a prime
 6 |  * number or not.
 7 |  *
 8 |  * @param Integer $number An integer input
 9 |  * @return boolean whether the number is prime or not
10 |  */
11 | function isPrime(int $number)
12 | {
13 |     if ($number === 2) {
14 |         return true;
15 |     }
16 | 
17 |     if ($number % 2 === 0 or $number < 2) {
18 |         return false;
19 |     }
20 | 
21 |     $i = 3;
22 |     while ($i <= sqrt($number)) {
23 |         if ($number % $i === 0) {
24 |             return false;
25 |         }
26 |         $i += 2;
27 |     }
28 | 
29 |     return true;
30 | }
31 | 


--------------------------------------------------------------------------------
/Maths/EratosthenesSieve.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * The Sieve of Eratosthenes is an algorithm is an ancient algorithm for finding all prime numbers up to any given limit
 5 |  * https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes
 6 |  *
 7 |  * @author Michał Żarnecki https://github.com/rzarno
 8 |  * @param int $number the limit of prime numbers to generate
 9 |  * @return string[] prime numbers up to the given limit
10 |  */
11 | function eratosthenesSieve(int $number): array
12 | {
13 |     $primes = range(1, $number);
14 |     $primes = array_combine($primes, $primes);
15 |     $limit = sqrt($number);
16 |     $current = 2;
17 |     while ($current < $limit) {
18 |         $multiplied = $current;
19 |         $factor = 1;
20 |         while ($multiplied < $number) {
21 |             $factor++;
22 |             $multiplied = $current * $factor;
23 |             if (isset($primes[$multiplied])) {
24 |                 unset($primes[$multiplied]);
25 |             }
26 |         }
27 |         $current += 1;
28 |     }
29 |     return array_values($primes);
30 | }
31 | 


--------------------------------------------------------------------------------
/Maths/Factorial.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This function calculates
 5 |  * and returns the factorial
 6 |  * of provided positive integer
 7 |  * number.
 8 |  *
 9 |  * @param  Integer  $number  Integer input
10 |  * @return Integer Factorial of the input
11 |  * @throws \Exception
12 |  */
13 | function factorial(int $number)
14 | {
15 |     static $cache = []; //internal caching memory for speed
16 | 
17 |     if ($number < 0) {
18 |         throw new \Exception("Negative numbers are not allowed for calculating Factorial");
19 |     }
20 | 
21 |     // Factorial of 0 is 1
22 |     if ($number === 0) {
23 |         return 1;
24 |     }
25 | 
26 |     if (isset($cache[$number])) {
27 |         return $cache[$number];
28 |     }
29 | 
30 |     // Recursion since x! = x * (x-1)!
31 |     $fact = ($number * factorial($number - 1));
32 | 
33 |     $cache[$number] = $fact;
34 | 
35 |     return $fact;
36 | }
37 | 


--------------------------------------------------------------------------------
/Maths/FastExponentiation.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This functions computes an exponent by doing repeated squares
 5 |  *
 6 |  * @param Integer $base the base
 7 |  * @param Integer $exponent the exponent (ie the number of times that the base is multiplied by itself)
 8 |  * @return Integer
 9 |  */
10 | function fastExponentiation(int $base, int $exponent)
11 | {
12 |     if ($exponent == 0) {
13 |         return 1;
14 |     }
15 | 
16 |     if ($exponent == 1) {
17 |         return $base;
18 |     }
19 | 
20 |     if ($exponent % 2 == 0) {
21 |         return fastExponentiation($base * $base, $exponent / 2);
22 |     } else {
23 |         return $base * fastExponentiation($base * $base, ($exponent - 1) / 2);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/Maths/FastInverseSquareRoot.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Calculate the fast inverse square root of a number.
 5 |  *
 6 |  * This function computes the fast inverse square root of a floating-point number
 7 |  * using the famous Quake III algorithm, originally developed by id Software.
 8 |  *
 9 |  * @param float $x The input number for which to calculate the inverse square root.
10 |  * @return float The fast inverse square root of the input number.
11 |  */
12 | function fastInvSqrt($x)
13 | {
14 |     // Convert the input float to an integer
15 |     $i = unpack('l', pack('f', $x))[1];
16 |     // Apply the bit manipulation magic number
17 |     $i = 0x5f3759df - ($i >> 1);
18 |     // Convert the integer back to a float
19 |     $y = unpack('f', pack('l', $i))[1];
20 |     // Perform the final calculation
21 |     return $y * (1.5 - 0.5 * $x * $y * $y);
22 | }
23 | 


--------------------------------------------------------------------------------
/Maths/Fibonacci.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Fibonacci recursive
 5 |  *
 6 |  * @param  int  $num
 7 |  * @return array
 8 |  * @throws \Exception
 9 |  */
10 | function fibonacciRecursive(int $num)
11 | {
12 |     /*
13 |      * Fibonacci series using recursive approach
14 |      */
15 | 
16 |     $fibonacciRecursive = [];
17 |     for ($i = 0; $i < $num; $i++) {
18 |         array_push($fibonacciRecursive, recursive($i));
19 |     }
20 |     return $fibonacciRecursive;
21 | }
22 | 
23 | /**
24 |  * @param  int  $num
25 |  * @return int
26 |  * @throws \Exception
27 |  */
28 | function recursive(int $num)
29 | {
30 |     if ($num < 0) {
31 |         throw new \Exception("Number must be greater than 0.");
32 |     } else {
33 |         if ($num == 0 || $num == 1) {
34 |             return $num;
35 |         } else {
36 |             return recursive($num - 1) + recursive($num - 2);
37 |         }
38 |     }
39 | }
40 | 
41 | /**
42 |  * @throws \Exception
43 |  */
44 | function fibonacciWithBinetFormula(int $num)
45 | {
46 |     /*
47 |      * Fibonacci series using Binet's formula given below
48 |      * binet's formula =  ((1 + sqrt(5) / 2 ) ^ n - (1 - sqrt(5) / 2 ) ^ n ) ) / sqrt(5)
49 |      * More about Binet's formula found at http://www.maths.surrey.ac.uk/hosted-sites/R.Knott/Fibonacci/fibFormula.html#section1
50 |      */
51 | 
52 |     $fib_series = [];
53 | 
54 |     if ($num < 0) {
55 |         throw new \Exception("Number must be greater than 0.");
56 |     } else {
57 |         $sqrt = sqrt(5);
58 |         $phi_1 = (1 + $sqrt) / 2;
59 |         $phi_2 = (1 - $sqrt) / 2;
60 | 
61 |         foreach (range(0, $num - 1) as $n) {
62 |             $seriesNumber = (pow($phi_1, $n) - pow($phi_2, $n)) / $sqrt;
63 |             array_push($fib_series, (int)$seriesNumber);
64 |         }
65 |     }
66 | 
67 |     return $fib_series;
68 | }
69 | 


--------------------------------------------------------------------------------
/Maths/Fibonacci2.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * Print Fibocanni sequence using a generator
 5 |  */
 6 | 
 7 |  /**
 8 |   * @param int $i number of Fibonacci numbers to generate
 9 |   * @param Generator $set Fibonacci calculator
10 |   */
11 | function loop($i, Generator $set)
12 | {
13 |     while ($i-- > 0 && $set->valid()) {
14 |         yield $set->current();
15 |         $set->next();
16 |     }
17 | }
18 | 
19 | /*
20 |  * Fibonacci generator
21 |  */
22 | function fib()
23 | {
24 |     yield $i = 0;
25 |     yield $j = 1;
26 | 
27 |     while (true) {
28 |         yield $k = $i + $j;
29 |         $i = $j;
30 |         $j = $k;
31 |     }
32 | }
33 | 
34 | /*
35 |  * Generate 100 Fibonacci numbers
36 |  */
37 | foreach (loop(100, fib()) as $item) {
38 |     print($item . ',');
39 | }
40 | 


--------------------------------------------------------------------------------
/Maths/GreatestCommonDivisor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This function finds the greatest common division using Euclidean algorithm
 5 |  * example: gcd(30, 24) => 6
 6 |  * @param int $a
 7 |  * @param int $b
 8 |  * @return int
 9 |  */
10 | function gcd(int $a, int $b): int
11 | {
12 |     if ($b == 0) {
13 |         return $a;
14 |     }
15 |     return gcd($b, $a % $b);
16 | }
17 | 


--------------------------------------------------------------------------------
/Maths/Mean.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This function calculates
 5 |  * The mean value of
 6 |  * numbers provided
 7 |  *
 8 |  * @param  decimal  $numbers  A variable sized number input
 9 |  * @return decimal $mean Mean of provided numbers
10 |  * @throws \Exception
11 |  */
12 | function mean(...$numbers)
13 | {
14 |     if (empty($numbers)) {
15 |         throw new \Exception('Please pass values to find mean value');
16 |     }
17 | 
18 |     $total = array_sum($numbers);
19 | 
20 |     return $total / count($numbers);
21 | }
22 | 


--------------------------------------------------------------------------------
/Maths/Median.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This function calculates
 5 |  * The median value of
 6 |  * numbers provided
 7 |  *
 8 |  * @param  decimal  $numbers  A variable sized number input
 9 |  * @return decimal $median Median of provided numbers
10 |  * @throws \Exception
11 |  */
12 | function median(...$numbers)
13 | {
14 |     if (empty($numbers)) {
15 |         throw new \Exception('Please pass values to find mean value');
16 |     }
17 | 
18 |     sort($numbers);
19 |     $length = count($numbers);
20 |     $middle = ceil($length / 2);
21 |     if ($length % 2 == 0) {
22 |         return ($numbers[$middle] + $numbers[$middle - 1]) / 2;
23 |     }
24 | 
25 |     return $numbers[$middle - 1];
26 | }
27 | 


--------------------------------------------------------------------------------
/Maths/Mode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This function calculates
 5 |  * the mode value(s) of
 6 |  * numbers provided
 7 |  *
 8 |  * @param decimal $numbers A variable sized number input
 9 |  * @return array $modes Array of mode(s) of provided numbers
10 |  * @throws \Exception
11 |  */
12 | function mode(...$numbers)
13 | {
14 |     if (empty($numbers)) {
15 |         throw new \Exception('Please pass values to find the mode');
16 |     }
17 | 
18 |     $values = array_count_values($numbers);
19 |     $maxCount = max($values);
20 |     return array_keys($values, $maxCount, true);
21 | }
22 | 


--------------------------------------------------------------------------------
/Maths/NeonNumber.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | function isNumberNeon($input)
 4 | {
 5 |     $inputSquare = $input * $input;
 6 |     $inputArr = array_map('intval', str_split($inputSquare));
 7 |     $sumOfSquareDigits = 0;
 8 |     foreach ($inputArr as $digit) {
 9 |         $sumOfSquareDigits += $digit;
10 |     }
11 |     return $sumOfSquareDigits == $input;
12 | }
13 | 


--------------------------------------------------------------------------------
/Maths/PerfectNumber.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 | This function returns true
 5 | * if the submitted number is perfect,
 6 | * false if it is not.
 7 | *
 8 | * A perfect number is a positive integer that is
 9 | * equal to the sum of its positive proper
10 | * divisors, excluding the number itself.
11 | *
12 | * About perfect numbers: https://en.wikipedia.org/wiki/Perfect_number
13 | *
14 | * @author Marco https://github.com/MaarcooC
15 | * @param int $number
16 | * @return bool
17 | */
18 | function perfect_number($number)
19 | {
20 |     /*Input validation*/
21 |     if (!is_int($number) || $number <= 1) {
22 |         /*Return false for non-integer or non-positive numbers*/
23 |         return false;
24 |     }
25 | 
26 |     $divisorsSum = 1; /*1 is a common divisor for every number*/
27 | 
28 |     /*Check for divisors up to the square root of the number*/
29 |     for ($i = 2; $i * $i <= $number; $i++) {
30 |         if ($number % $i == 0) {
31 |             $divisorsSum += $i; /*add i to the sum of divisors*/
32 |             if ($i != $number / $i) { /*add the complement divisor*/
33 |                 $divisorsSum += $number / $i;
34 |             }
35 |         }
36 |     }
37 | 
38 |     return $divisorsSum == $number;
39 | }
40 | 


--------------------------------------------------------------------------------
/Maths/PerfectSquare.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This function check whether
 5 |  * the provided number is a
 6 |  * perfect square or not.
 7 |  *
 8 |  * @param Decimal $number A decimal input
 9 |  * @return boolean whether the number is perfect square or not
10 |  */
11 | function isPerfectSquare($number)
12 | {
13 |     $root = (int) sqrt($number);
14 |     return (($root * $root) === $number); // If number's square root is an integer then it's a perfect square else not
15 | }
16 | 


--------------------------------------------------------------------------------
/Maths/ProjectEuler/Problem1.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Problem:
 5 |  *
 6 |  * If we list all the natural numbers below 10 that are multiples of 3 or 5,
 7 |  * we get 3, 5, 6 and 9. The sum of these multiples is 23.
 8 |  *
 9 |  * Find the sum of all the multiples of 3 or 5 below 1000.
10 |  *
11 |  *
12 |  * Answer:
13 |  *
14 |  * 233168
15 |  *
16 |  *
17 |  * @link https://projecteuler.net/problem=1
18 |  */
19 | 
20 | /**
21 |  * @return int
22 |  */
23 | function problem1a(): int
24 | {
25 |     $maxNumber = 999; // below 1000
26 | 
27 |     $numbers = range(1, $maxNumber);
28 | 
29 |     return array_reduce($numbers, function ($carry, $number) {
30 |         $shouldCarry = $number % 3 == 0 || $number % 5 == 0;
31 |         return $carry + ($shouldCarry ? $number : 0);
32 |     });
33 | }
34 | 
35 | /**
36 |  * @return int
37 |  */
38 | function problem1b(): int
39 | {
40 |     $maxNumber = 999; // below 1000
41 | 
42 |     $numbersMultByThree = range(3, $maxNumber, 3);
43 |     $numbersMultByFive = range(5, $maxNumber, 5);
44 | 
45 |     $numbers = array_merge($numbersMultByThree, $numbersMultByFive);
46 | 
47 |     return array_sum(array_unique($numbers));
48 | }
49 | 


--------------------------------------------------------------------------------
/Maths/ProjectEuler/Problem10.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * This function solves the problem 10 of the Project Euler.
 5 |  *
 6 |  * Problem description:
 7 |  * The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17.
 8 |  * Find the sum of all the primes below two million.
 9 |  */
10 | 
11 | /**
12 |  * @return int
13 |  */
14 | function problem10(): int
15 | {
16 |     //Using Sieve of Erastothenes
17 |     //@see https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes
18 | 
19 |     $n = 2000000;
20 |     $isPrime = [];
21 | 
22 |     for ($i = 2; $i <= $n; $i++) {
23 |         $isPrime[$i] = $i;
24 |     }
25 | 
26 |     for ($i = 2; $i * $i <= $n; $i++) {
27 |         if (isset($isPrime[$i])) {
28 |             for ($j = $i; $i * $j <= $n; $j++) {
29 |                 unset($isPrime[$i * $j]);
30 |             }
31 |         }
32 |     }
33 | 
34 |     return array_sum($isPrime);
35 | }
36 | 


--------------------------------------------------------------------------------
/Maths/ProjectEuler/Problem2.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Problem:
 5 |  *
 6 |  * Each new term in the Fibonacci sequence is generated by adding the previous
 7 |  * two terms. By starting with 1 and 2, the first 10 terms will be:
 8 |  *
 9 |  * 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...
10 |  *
11 |  * By considering the terms in the Fibonacci sequence whose values do not
12 |  * exceed four million, find the sum of the even-valued terms.
13 |  *
14 |  *
15 |  * Answer:
16 |  *
17 |  * 4613732
18 |  *
19 |  *
20 |  * @link https://projecteuler.net/problem=2
21 |  */
22 | 
23 | /**
24 |  * @return int
25 |  */
26 | function problem2(): int
27 | {
28 |     $maxNumber = 4000000;
29 |     $currNumber = 1;
30 |     $nextNumber = 2;
31 |     $answer = 0;
32 | 
33 |     while ($currNumber <= $maxNumber) {
34 |         $answer += $currNumber % 2 == 0 ? $currNumber : 0;
35 |         [$currNumber, $nextNumber] = [$nextNumber, $currNumber + $nextNumber];
36 |     }
37 | 
38 |     return $answer;
39 | }
40 | 


--------------------------------------------------------------------------------
/Maths/ProjectEuler/Problem3.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Problem:
 5 |  *
 6 |  * The prime factors of 13195 are 5, 7, 13 and 29.
 7 |  *
 8 |  * What is the largest prime factor of the number 600851475143?
 9 |  *
10 |  *
11 |  * Answer:
12 |  *
13 |  * 6857
14 |  *
15 |  *
16 |  * @link https://projecteuler.net/problem=3
17 |  */
18 | 
19 | /**
20 |  * @return int
21 |  */
22 | function problem3(): int
23 | {
24 |     $n = 600851475143;
25 |     $i = 2;
26 |     while ($i * $i < $n) {
27 |         while ($n % $i == 0) {
28 |             $n /= $i;
29 |         }
30 |         $i++;
31 |     }
32 | 
33 |     return $n;
34 | }
35 | 


--------------------------------------------------------------------------------
/Maths/ProjectEuler/Problem4.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Problem:
 5 |  * A palindromic number reads the same both ways. The largest palindrome made from the product of two 2-digit numbers is 9009 = 91 × 99.
 6 |  * Find the largest palindrome made from the product of two 3-digit numbers.
 7 |  */
 8 | 
 9 | /**
10 |  * @return int
11 |  */
12 | function problem4(): int
13 | {
14 |     $largest  = 0;
15 | 
16 |     for ($i = 100; $i < 1000; $i++) {
17 |         for ($j = $i; $j < 1000; $j++) {
18 |             $product = $i * $j;
19 | 
20 |             if (strrev((string)$product) == (string)$product && $product > $largest) {
21 |                 $largest = $product;
22 |             }
23 |         }
24 |     }
25 | 
26 |     return $largest;
27 | }
28 | 


--------------------------------------------------------------------------------
/Maths/ProjectEuler/Problem5.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This function solves the problem 5 of the Project Euler.
 5 |  *
 6 |  * Problem description:
 7 |  * 2520 is the smallest number that can be divided by each of the numbers from 1 to 10 without any remainder.
 8 |  * What is the smallest positive number that is evenly divisible by all of the numbers from 1 to 20?
 9 |  */
10 | 
11 | /**
12 |  * @return int
13 |  */
14 | function problem5(): int
15 | {
16 |     $number = 20;
17 |     while (true) {
18 |         $isSolution = true;
19 |         for ($i = 11; $i <= 20; $i++) {
20 |             if ($number % $i !== 0) {
21 |                 $isSolution = false;
22 |                 break;
23 |             }
24 |         }
25 |         if ($isSolution) {
26 |             return $number;
27 |         }
28 |         $number += 20;
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/Maths/ProjectEuler/Problem6.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This function solves the problem 6 of the Project Euler.
 5 |  *
 6 |  * Problem description:
 7 |  * The sum of the squares of the first ten natural numbers is,
 8 |  *              1 ** 2 + 2 ** 2 + ... + 10 ** 2 = 385
 9 |  *
10 |  * The square of the sum of the first ten natural numbers is,
11 |  *              (1 + 2 + ... + 10) ** 2 = 3025
12 |  *
13 |  * Hence the difference between the sum of the squares of the
14 |  * first ten natural numbers and the square of the sum is .
15 |  *              3025 - 385 = 2640
16 |  *
17 |  * Find the difference between the sum of the squares of the
18 |  * first one hundred natural numbers and the square of the sum.
19 |  *
20 |  * Answer: 25164150
21 |  *
22 |  * @param int $maxNumber Range from 1 to <maxNumber>
23 |  *
24 |  * @return int Difference between the sum of the squares and
25 |  * the square of the sum
26 |  *
27 |  * @link https://projecteuler.net/problem=6
28 |  */
29 | 
30 | /**
31 |  * @param int $maxNumber Range from 1 to <maxNumber>
32 |  *
33 |  * @return int Difference between the sum of the squares and
34 |  * the square of the sum
35 |  */
36 | function problem6(int $maxNumber = 100): int
37 | {
38 |     $sumOfSquares = 0;
39 |     $sums = 0;
40 |     for ($i = 1; $i <= $maxNumber; $i++) {
41 |         $sumOfSquares += $i ** 2; // add squares to the sum of squares
42 |         $sums += $i; // add number to sum to square later
43 |     }
44 |     return ($sums ** 2) - $sumOfSquares; // difference of square of the total sum and sum of squares
45 | }
46 | 


--------------------------------------------------------------------------------
/Maths/ProjectEuler/Problem7.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This function solves the problem 7 of the Project Euler.
 5 |  *
 6 |  * Problem description:
 7 |  * By listing the first six prime numbers: 2, 3, 5, 7, 11, and 13, we can see that the 6th prime is 13.
 8 |  * What is the 10 001st prime number?
 9 |  */
10 | 
11 | /**
12 |  * @return int
13 |  */
14 | function problem7(): int
15 | {
16 |     $numberOfPrimes = 0;
17 |     $number = 0;
18 |     while ($numberOfPrimes < 10001) {
19 |         $number++;
20 |         if (isPrime($number)) {
21 |             $numberOfPrimes++;
22 |         }
23 |     }
24 |     return $number;
25 | }
26 | 


--------------------------------------------------------------------------------
/Maths/ProjectEuler/Problem8.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This function solves the problem 8 of the Project Euler.
 5 |  *
 6 |  * Problem description:
 7 |  *The four adjacent digits in the 1000-digit number that have the greatest product are 9 × 9 × 8 × 9 = 5832.
 8 | 
 9 |  *73167176531330624919225119674426574742355349194934
10 |  96983520312774506326239578318016984801869478851843
11 |  85861560789112949495459501737958331952853208805511
12 |  12540698747158523863050715693290963295227443043557
13 |  66896648950445244523161731856403098711121722383113
14 |  62229893423380308135336276614282806444486645238749
15 |  30358907296290491560440772390713810515859307960866
16 |  70172427121883998797908792274921901699720888093776
17 |  65727333001053367881220235421809751254540594752243
18 |  52584907711670556013604839586446706324415722155397
19 |  53697817977846174064955149290862569321978468622482
20 |  83972241375657056057490261407972968652414535100474
21 |  82166370484403199890008895243450658541227588666881
22 |  16427171479924442928230863465674813919123162824586
23 |  17866458359124566529476545682848912883142607690042
24 |  24219022671055626321111109370544217506941658960408
25 |  07198403850962455444362981230987879927244284909188
26 |  84580156166097919133875499200524063689912560717606
27 |  05886116467109405077541002256983155200055935729725
28 |  71636269561882670428252483600823257530420752963450
29 | 
30 |  *Find the thirteen adjacent digits in the 1000-digit number that have the greatest product. What is the value of this product?
31 |  */
32 | 
33 | /**
34 |  * @return int
35 |  */
36 | function problem8(): int
37 | {
38 |     $theNumber = "73167176531330624919225119674426574742355349194934" .
39 |         "96983520312774506326239578318016984801869478851843" .
40 |         "85861560789112949495459501737958331952853208805511" .
41 |         "12540698747158523863050715693290963295227443043557" .
42 |         "66896648950445244523161731856403098711121722383113" .
43 |         "62229893423380308135336276614282806444486645238749" .
44 |         "30358907296290491560440772390713810515859307960866" .
45 |         "70172427121883998797908792274921901699720888093776" .
46 |         "65727333001053367881220235421809751254540594752243" .
47 |         "52584907711670556013604839586446706324415722155397" .
48 |         "53697817977846174064955149290862569321978468622482" .
49 |         "83972241375657056057490261407972968652414535100474" .
50 |         "82166370484403199890008895243450658541227588666881" .
51 |         "16427171479924442928230863465674813919123162824586" .
52 |         "17866458359124566529476545682848912883142607690042" .
53 |         "24219022671055626321111109370544217506941658960408" .
54 |         "07198403850962455444362981230987879927244284909188" .
55 |         "84580156166097919133875499200524063689912560717606" .
56 |         "05886116467109405077541002256983155200055935729725" .
57 |         "71636269561882670428252483600823257530420752963450";
58 |     $greatestProduct = 0;
59 |     $substringSize = 13;
60 | 
61 |     for ($i = 0; $i < strlen($theNumber) - $substringSize; $i++) {
62 |         $currentSubstring = substr($theNumber, $i, $substringSize);
63 |         $currentProduct = 0;
64 | 
65 |         for ($j = 0; $j < strlen($currentSubstring); $j++) {
66 |             $currentProduct = ($currentProduct == 0 ? (int)$currentSubstring[$j] : $currentProduct * (int)$currentSubstring[$j]);
67 |         }
68 | 
69 |         $greatestProduct = ($greatestProduct < $currentProduct ? $currentProduct : $greatestProduct);
70 |     }
71 | 
72 |     return $greatestProduct;
73 | }
74 | 


--------------------------------------------------------------------------------
/Maths/ProjectEuler/Problem9.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This function solves the problem 9 of the Project Euler.
 5 |  *
 6 |  * Problem description:
 7 |  * A Pythagorean triplet is a set of three natural numbers, a < b < c, for which,
 8 |  *
 9 |  * a^2 + b^2 = c^2
10 |  *
11 |  * For example:
12 |  *
13 |  * 3^2 + 4^2 = 9 + 16 = 25 = 5^2.
14 |  *
15 |  * There exists exactly one Pythagorean triplet for which a + b + c = 1000. Find the product abc.
16 |  */
17 | 
18 | /**
19 |  * @return int
20 |  */
21 | function problem9(): int
22 | {
23 |     for ($i = 0; $i <= 300; $i++) {
24 |         for ($j = 0; $j <= 400; $j++) {
25 |             $k = 1000 - $i - $j;
26 |             if ($i * $i + $j * $j === $k * $k) {
27 |                 return $i * $j * $k;
28 |             }
29 |         }
30 |     }
31 |     return 0;
32 | }
33 | 


--------------------------------------------------------------------------------
/NeuralNetworks/PerceptronClassifier/NeuralNetworkPerceptronClassifier.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace NeuralNetworks\PerceptronClassifier;
  4 | 
  5 | /**
  6 |  * This class implements a simple neural network with one hidden layer and one output neuron.
  7 |  * The network uses the sigmoid activation function and performs binary classification.
  8 |  * (https://cw.fel.cvut.cz/b211/courses/be5b33rpz/labs/07_perceptron/start)
  9 |  *
 10 |  * @author Michał Żarnecki https://github.com/rzarno
 11 |  */
 12 | class NeuralNetworkPerceptronClassifier
 13 | {
 14 |     /**
 15 |      * @param array $X
 16 |      * @param array $Y
 17 |      * @param int $iterations
 18 |      * @param float $learningRate
 19 |      * @return array
 20 |      */
 21 |     public function trainModel(array $X, array $Y, int $iterations, float $learningRate): array
 22 |     {
 23 |         [$W, $b] = $this->initParams(count($X));
 24 | 
 25 |         for ($i = 0; $i < $iterations; $i++) {
 26 |             // Forward propagation
 27 |             $A = $this->forwardPropagation($X, $W, $b);
 28 | 
 29 |             // Compute cost
 30 |             $cost = $this->computeCost($A, $Y);
 31 | 
 32 |             // Backward propagation
 33 |             [$dW, $db] = $this->backwardPropagation($A, $X, $Y);
 34 | 
 35 |             // Update parameters
 36 |             [$W, $b] = $this->updateParams($W, $b, $dW, $db, $learningRate);
 37 | 
 38 |             if ($i % 100 == 0) {
 39 |                 echo "Iteration {$i} - Cost: {$cost}\n";
 40 |             }
 41 |         }
 42 | 
 43 |         return [$W, $b];
 44 |     }
 45 | 
 46 |     /**
 47 |      * @param array $X
 48 |      * @param array $W
 49 |      * @param float $b
 50 |      * @return array
 51 |      */
 52 |     public function predict(array $X, array $W, float $b): array
 53 |     {
 54 |         $A = $this->forwardPropagation($X, $W, $b);
 55 |         return array_map(fn($a) => $a > 0.5 ? 1 : 0, $A);
 56 |     }
 57 | 
 58 |     /**
 59 |      * Stage 1. Prepare dataset
 60 |      * @return array[]
 61 |      */
 62 |     public function generateTrainingSet(): array
 63 |     {
 64 |         $m = 50;
 65 | 
 66 |         // Generate a 2 x m matrix with binary values (0 or 1)
 67 |         $X = [];
 68 |         for ($i = 0; $i < 2; $i++) {
 69 |             for ($j = 0; $j < $m; $j++) {
 70 |                 $X[$i][$j] = rand(0, 1);
 71 |             }
 72 |         }
 73 | 
 74 |         // Compute Y: Logical AND condition (X[0] == 1 and X[1] == 0)
 75 |         $Y = [];
 76 |         for ($j = 0; $j < $m; $j++) {
 77 |             $Y[$j] = ($X[0][$j] == 1 && $X[1][$j] == 0) ? 1 : 0;
 78 |         }
 79 | 
 80 |         return [$X, $Y];
 81 |     }
 82 | 
 83 |      /**
 84 |       * Stage 2. Initialize model parameters
 85 |       * @param int $n Number of features
 86 |       * @return array [$W, $b] Weight and bias arrays
 87 |       */
 88 |     private function initParams(int $n): array
 89 |     {
 90 |         $W = [];
 91 |         for ($i = 0; $i < $n; $i++) {
 92 |             $W[$i] = mt_rand() / mt_getrandmax(); // Small random values
 93 |         }
 94 |         $b = 0.0; // Bias initialized to zero
 95 |         return [$W, $b];
 96 |     }
 97 | 
 98 |     /**
 99 |      * Sigmoid Activation Function
100 |      * @param float $z
101 |      * @return float
102 |      */
103 |     private function sigmoid(float $z): float
104 |     {
105 |         return 1 / (1 + exp(-$z));
106 |     }
107 | 
108 |     /**
109 |      * Stage 3. Forward Propagation
110 |      * @param array $X
111 |      * @param array $W
112 |      * @param float $b
113 |      * @return array
114 |      */
115 |     private function forwardPropagation(array $X, array $W, float $b): array
116 |     {
117 |         $Z = [];
118 |         for ($j = 0; $j < count($X[0]); $j++) {
119 |             $sum = $b;
120 |             for ($i = 0; $i < count($W); $i++) {
121 |                 $sum += $W[$i] * $X[$i][$j];
122 |             }
123 |             $Z[$j] = $this->sigmoid($sum);
124 |         }
125 |         return $Z;
126 |     }
127 | 
128 |     /**
129 |      * Stage 4. Compute Cost Function (Binary Cross-Entropy Loss)
130 |      * @param array $A
131 |      * @param array $Y
132 |      * @return float
133 |      */
134 |     private function computeCost(array $A, array $Y): float
135 |     {
136 |         $m = count($Y);
137 |         $cost = 0.0;
138 |         for ($i = 0; $i < $m; $i++) {
139 |             $cost += -($Y[$i] * log($A[$i]) + (1 - $Y[$i]) * log(1 - $A[$i]));
140 |         }
141 |         return $cost / $m;
142 |     }
143 | 
144 |     /**
145 |      * Stage 5. Backward Propagation
146 |      * @param array $A
147 |      * @param array $X
148 |      * @param array $Y
149 |      * @return array
150 |      */
151 |     private function backwardPropagation(array $A, array $X, array $Y): array
152 |     {
153 |         $m = count($Y);
154 |         $dW = array_fill(0, count($X), 0.0);
155 |         $db = 0.0;
156 | 
157 |         for ($j = 0; $j < $m; $j++) {
158 |             $dZ = $A[$j] - $Y[$j];
159 |             for ($i = 0; $i < count($X); $i++) {
160 |                 $dW[$i] += $dZ * $X[$i][$j];
161 |             }
162 |             $db += $dZ;
163 |         }
164 | 
165 |         // Average gradients
166 |         for ($i = 0; $i < count($dW); $i++) {
167 |             $dW[$i] /= $m;
168 |         }
169 |         $db /= $m;
170 | 
171 |         return [$dW, $db];
172 |     }
173 | 
174 |     /**
175 |      * STage 6. Update Parameters
176 |      * @param array $W
177 |      * @param float $b
178 |      * @param array $dW
179 |      * @param float $db
180 |      * @param float $learningRate
181 |      * @return array
182 |      */
183 |     private function updateParams(array $W, float $b, array $dW, float $db, float $learningRate): array
184 |     {
185 |         for ($i = 0; $i < count($W); $i++) {
186 |             $W[$i] -= $learningRate * $dW[$i];
187 |         }
188 |         $b -= $learningRate * $db;
189 | 
190 |         return [$W, $b];
191 |     }
192 | }
193 | 


--------------------------------------------------------------------------------
/NeuralNetworks/PerceptronClassifier/README.md:
--------------------------------------------------------------------------------
  1 | ## Maths behind the single Perceptron Neural Network with Activation Function
  2 | 
  3 | This work is based on examples from course https://www.coursera.org/learn/machine-learning-calculus prepared by author Luis Serrano.
  4 | 
  5 | Linear separation refers to data points in binary classification problems that can be separated by a linear decision boundary.
  6 | If the data points can be separated by a line, linear function, or flat hyperplane, they are said to be linearly separable.
  7 | 
  8 | If separate points in an n-dimensional space exist, then it is said to be linearly separable
  9 | 
 10 | $$w_1x_1 + w_2x_2 + w_nx_n + b = 0$$
 11 | 
 12 | For two-dimensional input data, if there is a line, whose equation is $$w_1x_1 + w_2x_2 + b = 0$$
 13 | 
 14 | that separates all samples of one class from the other class, then the corresponding observation can be derived from the equation of the separating line.
 15 | Such classification problems are called "linearly separable", i.e. separating by linear combination.
 16 | 
 17 | <img src="chart/linear-separated.png" />
 18 | 
 19 | The input layer contains two nodes $x_1$ and $x_2$. Weight vector $W = \begin{bmatrix} w_1 & w_2\end{bmatrix}$ and bias ($b$) are the parameters to be updated during the model training.
 20 | 
 21 | $$z^{(i)} = w_1x_1^{(i)} + w_2x_2^{(i)} + b = Wx^{(i)} + b.\tag{1}$$
 22 | 
 23 | To be able to perform classification we need nonlinear approach. This can achieved with sigmoid activation function which roughly replace values with nearly 0 or nearly 1 for most cases and some values between for small range near 0.
 24 | 
 25 | $$\hat{y} = \begin{cases} 1 & \mbox{if } a > 0.5 \\ 0 & \mbox{otherwise } \end{cases}\tag{10}$$
 26 | 
 27 | Sigmoid activation function is defined as
 28 | 
 29 | $$a = \sigma\left(z\right) = \frac{1}{1+e^{-z}}.\tag{2}$$
 30 | 
 31 | <img src="chart/sigmoid.png" />
 32 | 
 33 | Threshold value of $0.5$ can be used for predictions: $1$ (red) if  $a > 0.5$ and $0$ (blue) otherwise.
 34 | 
 35 | The single perceptron neural network with sigmoid activation function can be expressed as:
 36 | 
 37 | \begin{align}
 38 | z^{(i)} &=  W x^{(i)} + b,\\
 39 | a^{(i)} &= \sigma\left(z^{(i)}\right).\\\tag{3}
 40 | \end{align}
 41 | 
 42 | 
 43 | With $m$ training examples organised in the columns of ($2 \times m$) matrix $X$, you can apply the activation function element-wise. So the model can be written as:
 44 | 
 45 | 
 46 | \begin {align}
 47 | Z &=  W X + b,\\
 48 | A &= \sigma\left(Z\right),\\\tag{4}
 49 | \end{align}
 50 | 
 51 | When dealing with classification problems, the most commonly used cost function is the **log loss**, which is described by the following equation
 52 | 
 53 | $$\mathcal{L}\left(W, b\right) = \frac{1}{m}\sum_{i=1}^{m} L\left(W, b\right) = \frac{1}{m}\sum_{i=1}^{m}  \large\left(\small -y^{(i)}\log\left(a^{(i)}\right) - (1-y^{(i)})\log\left(1- a^{(i)}\right)  \large  \right) \small,\tag{5}$$
 54 | 
 55 | where $y^{(i)} \in \{0,1\}$ are the original labels and $a^{(i)}$ are the continuous output values of the forward propagation step (elements of array $A$).
 56 | 
 57 | 
 58 | We want to minimize the cost function during the training. To implement gradient descent, calculate partial derivatives using chain rule
 59 | 
 60 | 
 61 | \begin{align}
 62 | \frac{\partial \mathcal{L} }{ \partial w_1 } &=
 63 | \frac{1}{m}\sum_{i=1}^{m} \left(a^{(i)} - y^{(i)}\right)x_1^{(i)},\\
 64 | \frac{\partial \mathcal{L} }{ \partial w_2 } &=
 65 | \frac{1}{m}\sum_{i=1}^{m} \left(a^{(i)} - y^{(i)}\right)x_2^{(i)},\tag{7}\\
 66 | \frac{\partial \mathcal{L} }{ \partial b } &=
 67 | \frac{1}{m}\sum_{i=1}^{m} \left(a^{(i)} - y^{(i)}\right).
 68 | \end{align}
 69 | 
 70 | Equations above can be rewritten in a matrix form
 71 | 
 72 | 
 73 | \begin{align}
 74 | \frac{\partial \mathcal{L} }{ \partial W } &=
 75 | \begin{bmatrix} \frac{\partial \mathcal{L} }{ \partial w_1 } &
 76 | \frac{\partial \mathcal{L} }{ \partial w_2 }\end{bmatrix} = \frac{1}{m}\left(A - Y\right)X^T,\\
 77 | \frac{\partial \mathcal{L} }{ \partial b } &= \frac{1}{m}\left(A - Y\right)\mathbf{1}.
 78 | \tag{8}
 79 | \end{align}
 80 | 
 81 | where $\left(A - Y\right)$ is an array of a shape ($1 \times m$), $X^T$ is an array of a shape ($m \times 2$) and $\mathbf{1}$ is just a ($m \times 1$) vector of ones.
 82 | 
 83 | Then you can update the parameters:
 84 | 
 85 | \begin{align}
 86 | W &= W - \alpha \frac{\partial \mathcal{L} }{ \partial W },\\
 87 | b &= b - \alpha \frac{\partial \mathcal{L} }{ \partial b },
 88 | \tag{9}\end{align}
 89 | 
 90 | where $\alpha$ is the learning rate. Repeat the process in a loop until the cost function stops decreasing.
 91 | 
 92 | in last step apply activation
 93 | $$\hat{y} = \begin{cases} 1 & \mbox{if } a > 0.5 \\ 0 & \mbox{otherwise } \end{cases}\tag{10}$$
 94 | 
 95 | 
 96 | ### Dataset
 97 | 
 98 | As a dataset we will generate $m=50$ data points $(x_1, x_2)$, where $x_1, x_2 \in \{0,1\}$ and save them in the `NumPy` array `X` of a shape $(2 \times m)$. The labels ($0$: blue, $1$: red) will be calculated so that $y = 1$ if $x_1 = 1$ and $x_2 = 0$, in the rest of the cases $y=0$. The labels will be saved in the array `Y` of a shape $(1 \times m)$.
 99 | 
100 | <img src="chart/dataset.png" />
101 | 


--------------------------------------------------------------------------------
/NeuralNetworks/PerceptronClassifier/chart/dataset.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/TheAlgorithms/PHP/81b5386af390fd2b44fecf162ade3b1a940c8500/NeuralNetworks/PerceptronClassifier/chart/dataset.png


--------------------------------------------------------------------------------
/NeuralNetworks/PerceptronClassifier/chart/linear-separated.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/TheAlgorithms/PHP/81b5386af390fd2b44fecf162ade3b1a940c8500/NeuralNetworks/PerceptronClassifier/chart/linear-separated.png


--------------------------------------------------------------------------------
/NeuralNetworks/PerceptronClassifier/chart/sigmoid.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/TheAlgorithms/PHP/81b5386af390fd2b44fecf162ade3b1a940c8500/NeuralNetworks/PerceptronClassifier/chart/sigmoid.png


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # The Algorithms - PHP
 2 | 
 3 | [![Gitpod ready-to-code](https://img.shields.io/badge/Gitpod-ready--to--code-blue?logo=gitpod)](https://gitpod.io/#https://github.com/TheAlgorithms/PHP)
 4 | 
 5 | The Algorithms - PHP, is a library or framework written in the PHP programming language that provides a set of algorithms and data structures for various computational tasks. It aims to simplify the implementation of common algorithms and data structures in PHP, making it easier for developers to leverage these powerful tools in their projects.
 6 | 
 7 | ### All algorithms implemented in PHP - for education
 8 | 
 9 | The Implementations in this repo are examples and may be less efficient than the implementations in the PHP standard Library.
10 | 
11 | 
12 | ## Contribution Guidelines:
13 | 
14 | To Contribute to this repo please take your time to read our
15 | [Contribution Guidelines](CONTRIBUTING.md) before you contribute.
16 | 
17 | ## Community Channels
18 | 
19 | We're on [Discord](https://discord.gg/c7MnfGFGa6) and [Gitter](https://gitter.im/TheAlgorithms)! Community channels are great for you to ask questions and get help. Please join us!
20 | 
21 | ## List of Algorithms
22 | 
23 | See the [directory](DIRECTORY.md) for easier navigation and to view the current list of algorithms.
24 | 
25 | Thanks for contributing!!
26 | 


--------------------------------------------------------------------------------
/Searches/BinarySearch.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Binary search algorithm iterative approach
 5 |  *
 6 |  * Be careful collection must be ascending sorted, otherwise result will be unpredictable
 7 |  *
 8 |  * Examples:
 9 |  * binarySearchIterative([0, 5, 7, 10, 15], 0);
10 |  * 0
11 |  * binarySearchIterative([0, 5, 7, 10, 15], 15);
12 |  * 4
13 |  * binarySearchIterative([0, 5, 7, 10, 15], 5);
14 |  * 1
15 |  * binarySearchIterative([0, 5, 7, 10, 15], 6);
16 |  *
17 |  * @param array $list
18 |  * @param int $target
19 |  * @return int
20 |  */
21 | function binarySearchIterative($list, $target)
22 | {
23 |     $first = 0;
24 |     $last = count($list) - 1;
25 | 
26 | 
27 |     while ($first <= $last) {
28 |         $mid = ($first + $last) >> 1;
29 | 
30 | 
31 |         if ($list[$mid] == $target) {
32 |             return $mid;
33 |         } elseif ($list[$mid] > $target) {
34 |             $last = $mid - 1;
35 |         } elseif ($list[$mid] < $target) {
36 |             $first = $mid + 1;
37 |         }
38 |     }
39 | 
40 |     return null;
41 | }
42 | 
43 | /**
44 |  * Binary search algorithm in PHP by recursion
45 |  *
46 |  * Be careful collection must be ascending sorted, otherwise result will be unpredictable
47 |  *
48 |  * Examples:
49 |  * binarySearchByRecursion([0, 5, 7, 10, 15], 0, 0, 4);
50 |  * 0
51 |  * binarySearchByRecursion([0, 5, 7, 10, 15], 15, 0, 4);
52 |  * 4
53 |  * binarySearchByRecursion([0, 5, 7, 10, 15], 5, 0, 4);
54 |  * 1
55 |  * binarySearchByRecursion([0, 5, 7, 10, 15], 6, 0, 4);
56 |  *
57 |  * @param Array $list a sorted array list of integers to search
58 |  * @param integer $target an integer number to search for in the list
59 |  * @param integer $start an integer number where to start searching in the list
60 |  * @param integer $end an integer number where to end searching in the list
61 |  * @return integer the index where the target is found (or null if not found)
62 |  */
63 | function binarySearchByRecursion($list, $target, $start, $end)
64 | {
65 |     if (count($list) == 0) {
66 |         return null;
67 |     }
68 | 
69 |     if (count($list) < 2) {
70 |         return $list[0] == $target ? 0 : null;
71 |     }
72 | 
73 |     if ($start > $end) {
74 |         return null;
75 |     }
76 | 
77 | 
78 |     $mid = ($start + $end) >> 1;
79 | 
80 | 
81 |     if ($list[$mid] == $target) {
82 |         return $mid;
83 |     } elseif ($list[$mid] > $target) {
84 |         return binarySearchByRecursion($list, $target, $start, $mid - 1);
85 |     } elseif ($list[$mid] < $target) {
86 |         return binarySearchByRecursion($list, $target, $mid + 1, $end);
87 |     }
88 | 
89 |     return null;
90 | }
91 | 


--------------------------------------------------------------------------------
/Searches/ExponentialSearch.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * Exponential Search Algorithm
 5 |  *
 6 |  * The algorithm consists of two stages.
 7 |  * The first stage determines a range in which the search key would reside
 8 |  **** if it were in the list.
 9 |  * In the second stage, a binary search is performed on this range.
10 |  */
11 | 
12 | /**
13 |  * @param  Array  $arr
14 |  * @param  int  $value
15 |  * @param  int  $floor
16 |  * @param  int  $ceiling
17 |  * @return int
18 |  **/
19 | function binarySearch($arr, $value, $floor, $ceiling)
20 | {
21 |     // Get $middle index
22 |     $mid = floor(($floor + $ceiling) / 2);
23 | 
24 |     // Return position if $value is at the $mid position
25 |     if ($arr[$mid] === $value) {
26 |         return (int) $mid;
27 |     }
28 | 
29 |     //Return -1 is range is wrong
30 |     if ($floor > $ceiling) {
31 |         return -1;
32 |     }
33 | 
34 |     // search the left part of the $array
35 |     // If the $middle element is greater than the $value
36 |     if ($arr[$mid] > $value) {
37 |         return binarySearch($arr, $value, $floor, $mid - 1);
38 |     } else {     // search the right part of the $array If the $middle element is lower than the $value
39 |         return binarySearch($arr, $value, $mid + 1, $ceiling);
40 |     }
41 | }
42 | 
43 | /**
44 |  * @param  Array  $arr
45 |  * @param  int  $value
46 |  * @return int
47 |  */
48 | function exponentialSearch($arr, $value)
49 | {
50 |     // If $value is the first element of the $array return this position
51 |     if ($arr[0] === $value) {
52 |         return 0;
53 |     }
54 | 
55 |     // Find range for binary search
56 |     $i = 1;
57 |     $length = count($arr);
58 |     while ($i < $length && $arr[$i] <= $value) {
59 |         $i = $i * 2;
60 |     }
61 |     $floor = $i / 2;
62 |     $ceiling = min($i, $length);
63 | 
64 |     // Call binary search for the range found above
65 |     return binarySearch($arr, $value, $floor, $ceiling);
66 | }
67 | 


--------------------------------------------------------------------------------
/Searches/FibonacciSearch.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * Function to find nth number in Fibonacci sequence.
 5 |  * Uses a version of memoization and runs very fast!
 6 |  */
 7 | 
 8 | /**
 9 |  * @param int $n position to check
10 |  * @param array $m array to store solved trees
11 |  */
12 | function fibonacciPosition(int $n, array &$m = [])
13 | {
14 |     if (isset($m[$n])) {
15 |         return $m[$n];
16 |     }
17 |     if ($n < 2) {
18 |         return $n;
19 |     }
20 | 
21 |     $m[$n] = fibonacciPosition($n - 1, $m) + fibonacciPosition($n - 2, $m);
22 | 
23 |     return $m[$n];
24 | }
25 | 
26 | print fibonacciPosition(59);
27 | 


--------------------------------------------------------------------------------
/Searches/InterpolationSearch.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Interpolation Search********
 5 |  *
 6 |  *
 7 |  * Description***********
 8 |  * Searches for a key in a sorted array
 9 |  *
10 |  *
11 |  * How************
12 |  * Loop through the array:
13 |  * Determine the index from the low and high indices
14 |  * if the (value of index in array) is = key return the "POSITION", end loop
15 |  * if the (value of index in array) is < key increase the low index
16 |  * if the (value of index in array) is > key decrease the high index
17 |  * repeat the loop
18 |  */
19 | function interpolationSearch($arr, $key)
20 | {
21 |     $length = count($arr) - 1;
22 |     $low = 0;
23 |     $high = $length;
24 |     $position = -1;
25 |     //loop, between low & high
26 |     while ($low <= $high && $key >= $arr[$low] && $key <= $arr[$high]) {
27 |         //GET INDEX
28 |         $delta = ($key - $arr[$low]) / ($arr[$high] - $arr[$low]);
29 |         $index = $low + floor(($high - $low) * $delta);
30 | 
31 |         //GET VALUE OF INDEX IN ARRAY...
32 |         $indexValue = $arr[$index];
33 | 
34 |         if ($indexValue === $key) {
35 |             //index value equals key
36 |             //FOUND TARGET
37 |             //return index value
38 |             $position = $index;
39 |             return (int) $position;
40 |         } elseif ($indexValue < $key) {
41 |             //index value lower than key
42 |             //increase low index
43 |             $low = $index + 1;
44 |         } elseif ($indexValue > $key) {
45 |             //index value higher than key
46 |             //decrease high index
47 |             $high = $index - 1;
48 |         }
49 |     }
50 | 
51 |     //when key not found in array or array not sorted
52 |     return null;
53 | }
54 | 


--------------------------------------------------------------------------------
/Searches/JumpSearch.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |    * Jump Search algorithm in PHP
 5 |    * References: https://www.geeksforgeeks.org/jump-search/
 6 |    * The list must be sorted in ascending order before performing jumpSearch
 7 |    *
 8 |    * @param Array $list refers to a sorted list of integer
 9 |    * @param integer $key refers to the integer target to be searched from the sorted list
10 |    * @return int index of $key if found, otherwise -1 is returned
11 |  */
12 | 
13 | function jumpSearch($list, $key)
14 | {
15 |     /*number of elements in the sorted array*/
16 |     $num = count($list);
17 | 
18 |     /*block size to be jumped*/
19 |     $step = (int)sqrt($num);
20 |     $prev = 0;
21 | 
22 |     while ($list[min($step, $num) - 1] < $key) {
23 |         $prev = $step;
24 |         $step += (int)sqrt($num);
25 |         if ($prev >= $num) {
26 |             return -1;
27 |         }
28 |     }
29 | 
30 |     /*Performing linear search for $key in block*/
31 |     while ($list[$prev] < $key) {
32 |         $prev++;
33 |         if ($prev == min($step, $num)) {
34 |             return -1;
35 |         }
36 |     }
37 | 
38 |      return $list[$prev] === $key ? $prev : -1;
39 | }
40 | 


--------------------------------------------------------------------------------
/Searches/LinearSearch.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Linear search in PHP
 5 |  *
 6 |  * Reference: https://www.geeksforgeeks.org/linear-search/
 7 |  *
 8 |  * Examples:
 9 |  *  data =  5, 7, 8, 11, 12, 15, 17, 18, 20
10 |  *  x = 15
11 |  *  Element found at position 6
12 |  *
13 |  *  x = 1
14 |  *  Element not found
15 |  *
16 |  *  @param Array $list an array of integers to search
17 |  *  @param integer $target an integer number to search for in the list
18 |  *  @return integer the index where the target is found (or -1 if not found)
19 |  */
20 | function linearSearch($list, $target)
21 | {
22 |     $n = sizeof($list);
23 |     for ($i = 0; $i < $n; $i++) {
24 |         if ($list[$i] == $target) {
25 |             return $i + 1;
26 |         }
27 |     }
28 | 
29 |     return -1;
30 | }
31 | 


--------------------------------------------------------------------------------
/Searches/LowerBound.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | require_once __DIR__ . '/../vendor/autoload.php';
 4 | require_once __DIR__ . '/../Utils/ArrayHelpers.php';
 5 | 
 6 | /**
 7 |  * Lower Bound of an element is minimum index that an element would be placed
 8 |  * if it is added into that sorted array
 9 |  *
10 |  * [C++ Lower Bound](http://www.cplusplus.com/reference/algorithm/lower_bound/)
11 |  *
12 |  * It is assumed that an integer array is provided
13 |  * and the second parameter is also an integer
14 |  *
15 |  * @param array  $arr  of sorted integers
16 |  * @param integer  $elem  whose lower bound is to be found
17 |  *
18 |  * @return int the index of lower bound of the given element
19 |  */
20 | function lowerBound(array $arr, int $elem)
21 | {
22 |     isSortedAscendingInts($arr);
23 |     $hi = count($arr);
24 |     $lo = 0;
25 | 
26 |     while ($lo < $hi) {
27 |         $mid = $lo + floor(($hi - $lo) / 2);
28 | 
29 |         if ($arr[$mid] < $elem) {
30 |             $lo = $mid + 1;
31 |         } else {
32 |             $hi = $mid;
33 |         }
34 |     }
35 | 
36 |     return $lo;
37 | }
38 | 


--------------------------------------------------------------------------------
/Searches/SentinelSearch.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /* SentinelSearch
 4 |     Input : -
 5 |     parameter 1: Array
 6 |     parameter 2: Target element
 7 | 
 8 |     Output : -
 9 |     Returns index of element if found, else -1
10 | */
11 | function SentinelSearch($list, $target)
12 | {
13 |     //Length of array
14 |     $len = sizeof($list);
15 | 
16 |     //Store last element of array
17 |     $lastElement = $list[$len - 1];
18 | 
19 |     //Put target at the last position of array known as 'Sentinel'
20 |     if ($lastElement == $target) {
21 |         return ($len - 1);
22 |     }
23 |     //Put target at last index of array
24 |     $list[$len - 1] = $target;
25 | 
26 |     //Initialize variable to traverse through array
27 |     $i = 0;
28 | 
29 |     //Traverse through array to search target
30 |     while ($list[$i] != $target) {
31 |         $i++;
32 |     }
33 |     //Put last element at it's position
34 |     $list[$len - 1] = $lastElement;
35 | 
36 |     //If i in less than length, It means element is present in array
37 |     if ($i < ($len - 1)) {
38 |         return $i;
39 |     } else {
40 |         return -1;
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/Searches/TernarySearch.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /* Ternary search is similar to binary search
 4 |  * It rather divides the sorted array into three parts rather than.two parts by using two middle points, $mid1  $mid2.
 5 |  * The value of the $key will first be compared with the two $mid points, the value will be returned if there is a match.
 6 |  * Then, if the value of the $key is less than $mid1, narrow the interval to the first part.
 7 |  * Else, if the value of the $key is greater than $mid2, narrow the interval to the third part.
 8 |  * Otherwise, narrow the interval to the $middle part.
 9 |  * Repeat the steps until the value is found or the interval is empty (value not found after checking all elements).
10 |  */
11 | function ternarySearchByRecursion($arr, $key, $low, $high)
12 | {
13 |     // Return null if high is less than low (base case: key not found).
14 |     if ($high < $low) {
15 |         return null;
16 |     }
17 | 
18 |     // Calculate the indices of the first and second midpoints.
19 |     $mid1 = floor($low + ($high - $low) / 3);
20 |     $mid2 = floor($high - ($high - $low) / 3);
21 | 
22 |     // Check if key is located at either midpoint.
23 |     if ($arr[$mid1] === $key) {
24 |         return $mid1;
25 |     }
26 | 
27 |     if ($arr[$mid2] === $key) {
28 |         return $mid2;
29 |     }
30 | 
31 |     // Determine which section to continue searching in.
32 |     if ($key < $arr[$mid1]) {
33 |         // Key is in the left section, between $low and $mid1.
34 |         return ternarySearchByRecursion($arr, $key, $low, $mid1 - 1);
35 |     } elseif ($key > $arr[$mid2]) {
36 |         // Key is in the right section, between $mid2 and $high.
37 |         return ternarySearchByRecursion($arr, $key, $mid2 + 1, $high);
38 |     } else {
39 |         // Key is in the middle section, between $mid1 and $mid2.
40 |         return ternarySearchByRecursion($arr, $key, $mid1 + 1, $mid2 - 1);
41 |     }
42 | }
43 | 
44 | function ternarySearchIterative($arr, $key)
45 | {
46 |     // Initialize low and high pointers.
47 |     $low = 0;
48 |     $high = count($arr) - 1;
49 | 
50 |     // Continue searching while the high pointer is greater than or equal to the low pointer.
51 |     while ($high >= $low) {
52 |         // Calculate the first and second midpoints.
53 |         $mid1 = floor($low + ($high - $low) / 3);
54 |         $mid2 = floor($high - ($high - $low) / 3);
55 | 
56 |         // Check if the key is found at either midpoint.
57 |         if ($arr[$mid1] === $key) {
58 |             return $mid1;
59 |         }
60 | 
61 |         if ($arr[$mid2] === $key) {
62 |             return $mid2;
63 |         }
64 | 
65 |         // Determine the section to continue the search in.
66 |         if ($key < $arr[$mid1]) {
67 |             // Key is in the left section, update the high pointer.
68 |             $high = $mid1 - 1;
69 |         } elseif ($key > $arr[$mid2]) {
70 |             // Key is in the right section, update the low pointer.
71 |             $low = $mid2 + 1;
72 |         } else {
73 |             // Key is in the middle section, update both pointers.
74 |             $low = $mid1 + 1;
75 |             $high = $mid2 - 1;
76 |         }
77 |     }
78 | 
79 |     // Key was not found.
80 |     return null;
81 | }
82 | 


--------------------------------------------------------------------------------
/Searches/TwoPointers.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Two Pointers Approach
 5 |  * This method is designed to improve the efficiency of algorithms by processing two elements per
 6 |  * loop instead of just one, thereby reducing both time and space complexity
 7 |  * The technique involves using two pointers, which can start from the beginning and the end of the array
 8 |  * or list, or one pointer moving at a slower pace while the other moves at a faster pace.
 9 |  */
10 | 
11 | /**
12 |  * To understand the technique let's solve a simple problem,
13 |  * Problem Statement:
14 |  *     There is an array of distinct integers "$list" and a target integer "$target". We have to find how many pairs
15 |  *     of elements of $list sum up to $target.
16 |  *     For example: $list = [2,4,3,8,6,9,10], $target = 12
17 |  *     in this array 2+10 = 12, 4+8 = 12, 3+9 = 12, therefore, there are 3 pairs which sum up to 12.
18 |  *
19 |  * If we solve this problem using two nested loops, the time complexity would be O(n^2),
20 |         for($i=0; $i<sizeof($list); ++$i){
21 |             for($j=$i+1; $j<sizeof($list); ++$j){
22 |                 if($list[$i] + $list[$j] == $target)
23 |                     $ans++;
24 |             }
25 |         }
26 |  * To reduce the time complexity to O(n), we need Two Pointers technique.
27 |  */
28 | 
29 | // Two Pointers step by step solution to that problem is given below:
30 | function twoPointers($list, $target)
31 | {
32 |     // First we need to sort the array so that we can take advantage of the order
33 |     sort($list);
34 |     // Now we are having two pointers "$left" and "$right"
35 |     // $left at the start and $right at the end of the array
36 |     $n = sizeof($list);
37 |     $left = 0;
38 |     $right = $n - 1;
39 | 
40 |     $ans = 0; # we will store the number of pairs in $ans
41 | 
42 |     // Now we will scan the array until $left and $right meet
43 |     while ($left < $right) {
44 |         # Now carefully understand how we move one of our pointers
45 |         if ($list[$left] + $list[$right] < $target) {
46 |             // it means the sum is less than $target and we need to increase our sum
47 |             // to increase the sum we will move $left pointer to the right
48 |             $left++;
49 |         } else if ($list[$left] + $list[$right] > $target) {
50 |             // the sum is greater than the target, so we need to decrease the sum
51 |             // to decrease the sum we will move our $right pointer to the left
52 |             $right--;
53 |         } else if ($list[$left] + $list[$right] == $target) {
54 |             // if it's true, we have found a pair
55 |             $ans++;
56 |             // now we will move one of our pointers, otherwise it'll run forever
57 |             $left++; # doesn't matter which one we move
58 |         }
59 |         // The loop will go until the pointers point to the same element
60 |     }
61 |     return $ans; # returning the number of pairs
62 | }
63 | 


--------------------------------------------------------------------------------
/Searches/UpperBound.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | require_once __DIR__ . '/../vendor/autoload.php';
 4 | require_once __DIR__ . '/../Utils/ArrayHelpers.php';
 5 | 
 6 | /**
 7 |  * Upper Bound of an element is maximum index that an element would be placed
 8 |  * if it is added into that sorted array
 9 |  *
10 |  * [C++ Lower Bound](http://www.cplusplus.com/reference/algorithm/upper_bound/)
11 |  *
12 |  * It is assumed that an integer array is provided
13 |  * and the second parameter is also an integer
14 |  *
15 |  * @param array  $arr  of sorted integers
16 |  * @param integer  $elem  whose upper bound is to be found
17 |  *
18 |  * @return int the index of upper bound of the given element
19 |  */
20 | function upperBound(array $arr, int $elem)
21 | {
22 |     isSortedAscendingInts($arr);
23 |     $hi = count($arr);
24 |     $lo = 0;
25 | 
26 |     while ($lo < $hi) {
27 |         $mid = $lo + floor(($hi - $lo) / 2);
28 | 
29 |         if ($arr[$mid] <= $elem) {
30 |             $lo = $mid + 1;
31 |         } else {
32 |             $hi = $mid;
33 |         }
34 |     }
35 | 
36 |     return $lo;
37 | }
38 | 


--------------------------------------------------------------------------------
/Sorting/ArrayKeysSort.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  *  Sort an "Array of objects" or "Array of arrays" by keys
 5 |  */
 6 | 
 7 | class ArrayKeysSort
 8 | {
 9 |     public const ORDER_ASC = 'ASC';
10 |     public const ORDER_DESC = 'DESC';
11 | /**
12 |      * @param $collection
13 |      * @param array $keys
14 |      * @param string $order
15 |      * @param bool $isCaseSensitive
16 |      * @return mixed
17 |      */
18 |     public static function sort($collection, array $keys, string $order = self::ORDER_ASC, bool $isCaseSensitive = false)
19 |     {
20 |         if (!empty($collection) && !empty($keys)) {
21 |             try {
22 |                 usort($collection, function ($a, $b) use ($keys, $order, $isCaseSensitive) {
23 | 
24 |                         $pos = 0;
25 |                     do {
26 |                             $key = $keys[$pos];
27 |                         if (is_array($a)) {
28 |                             if (!isset($a[$key]) || !isset($b[$key])) {
29 |                                 $errorMsg = 'The key "' . $key
30 |                                         . '" does not exist in the collection';
31 |                                 throw new Exception($errorMsg);
32 |                             }
33 |                             $item1 = !$isCaseSensitive
34 |                             ? strtolower($a[$key]) : $a[$key];
35 |                             $item2 = !$isCaseSensitive
36 |                             ? strtolower($b[$key]) : $b[$key];
37 |                         } else {
38 |                             if (!isset($a->$key) || !isset($b->$key)) {
39 |                                 $errorMsg = 'The key "' . $key
40 |                                         . '" does not exist in the collection';
41 |                                 throw new Exception($errorMsg);
42 |                             }
43 |                             $item1 = !$isCaseSensitive
44 |                             ? strtolower($a->$key) : $a->$key;
45 |                             $item2 = !$isCaseSensitive
46 |                             ? strtolower($b->$key) : $b->$key;
47 |                         }
48 |                     } while ($item1 === $item2 && !empty($keys[++$pos]));
49 |                     if ($item1 === $item2) {
50 |                         return 0;
51 |                     } elseif ($order === self::ORDER_ASC) {
52 |                         return ($item1 < $item2) ? -1 : 1;
53 |                     } else {
54 |                         return ($item1 > $item2) ? -1 : 1;
55 |                     }
56 |                 });
57 |             } catch (Exception $e) {
58 |                 echo $e->getMessage();
59 |                 die();
60 |             }
61 |         }
62 | 
63 |         return $collection;
64 |     }
65 | }
66 | 


--------------------------------------------------------------------------------
/Sorting/BubbleSort.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Bubble Sort
 5 |  *
 6 |  * @param array $array
 7 |  * @return array
 8 |  */
 9 | function bubbleSort($array)
10 | {
11 |     $length = count($array);
12 | 
13 |     for ($i = $length; $i > 0; $i--) {
14 |         $swapped = true;
15 | 
16 |         for ($j = 0; $j < $i - 1; $j++) {
17 |             if ($array[$j] > $array[$j + 1]) {
18 |                 $temp = $array[$j];
19 |                 $array[$j] = $array[$j + 1];
20 |                 $array[$j + 1] = $temp;
21 |                 $swapped = false;
22 |             }
23 |         }
24 | 
25 |         if ($swapped) {
26 |             break;
27 |         }
28 |     }
29 | 
30 |     return $array;
31 | }
32 | 


--------------------------------------------------------------------------------
/Sorting/BubbleSort2.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * Bubble Sort
 5 |  *
 6 |  * Compare numbers in an array 2 at a time and switch them if the second number is smaller
 7 |  *
 8 |  * @param array $input array of random numbers
 9 |  * @return array sorted array of numbers
10 |  */
11 | function bubbleSort2(array $input)
12 | {
13 |     // Return nothing if input is empty
14 |     if (!isset($input)) {
15 |         return [];
16 |     }
17 | 
18 |     do {
19 |         $swapped = false;
20 | 
21 |         for ($i = 0, $count = sizeof($input) - 1; $i < $count; $i++) {
22 |             if ($input[$i + 1] < $input[$i]) {
23 |                 list($input[$i + 1], $input[$i]) = [$input[$i], $input[$i + 1]];
24 |                 $swapped = true;
25 |             }
26 |         }
27 |     } while ($swapped);
28 |     return $input;
29 | }
30 | 


--------------------------------------------------------------------------------
/Sorting/CountSort.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * @param $array
 5 |  * @return mixed
 6 |  */
 7 | function countSort($array)
 8 | {
 9 |     $count = array();
10 |     $min = min($array);
11 |     $max = max($array);
12 | 
13 |     for ($i = $min; $i <= $max; $i++) {
14 |         $count[$i] = 0;
15 |     }
16 | 
17 |     foreach ($array as $number) {
18 |         $count[$number]++;
19 |     }
20 | 
21 |     $z = 0;
22 | 
23 |     for ($i = $min; $i <= $max; $i++) {
24 |         while ($count[$i]-- > 0) {
25 |             $array[$z++] = $i;
26 |         }
27 |     }
28 | 
29 |     return $array;
30 | }
31 | 


--------------------------------------------------------------------------------
/Sorting/GnomeSort.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Gnome Sort
 5 |  * References:
 6 |  * https://www.geeksforgeeks.org/gnome-sort-a-stupid-one/
 7 |  *
 8 |  * The Gnome algorithm works by locating the first instance in which two adjoining elements are arranged incorrectly and swaps with each other.
 9 |  *
10 |  * @param array $array refers to the array to be sorted
11 |  * @return array
12 |  */
13 | function gnomeSort($array)
14 | {
15 |     $a = 1;
16 |     $b = 2;
17 | 
18 |     while ($a < count($array)) {
19 |         if ($array[$a - 1] <= $array[$a]) {
20 |             $a = $b;
21 |             $b++;
22 |         } else {
23 |             list($array[$a],$array[$a - 1]) = array($array[$a - 1],$array[$a]);
24 |             $a--;
25 |             if ($a == 0) {
26 |                 $a = $b;
27 |                 $b++;
28 |             }
29 |         }
30 |     }
31 | 
32 |     return $array;
33 | }
34 | 


--------------------------------------------------------------------------------
/Sorting/HeapSort.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * HeapSort Algorithm
 5 |  *
 6 |  * The HeapSort algorithm sorts an array by first transforming the array into a max heap and then
 7 |  * iteratively swapping the maximum element from the heap with the last unsorted element
 8 |  * and "heapifying" the heap again.
 9 |  *
10 |  * @param array $arr
11 |  * @return array
12 |  * @throws \UnexpectedValueException
13 |  */
14 | function heapSort(array $arr): array
15 | {
16 |     // Get the number of elements in the array.
17 |     $n = count($arr);
18 | 
19 |     // Throw an exception if the array has no elements.
20 |     if ($n <= 0) {
21 |         throw new \UnexpectedValueException('Input array must have at least one element.');
22 |     }
23 | 
24 |     // Build a max heap from the array.
25 |     for ($i = floor($n / 2) - 1; $i >= 0; $i--) {
26 |         heapify($arr, $n, $i);
27 |     }
28 | 
29 |     // Extract elements from the max heap and build the sorted array.
30 |     for ($i = $n - 1; $i >= 0; $i--) {
31 |         // Swap the root(maximum value) of the heap with the last element of the heap.
32 |         [$arr[0], $arr[$i]] = [$arr[$i], $arr[0]];
33 | 
34 |         // Heapify the reduced heap.
35 |         heapify($arr, $i, 0);
36 |     }
37 | 
38 |     // Return the sorted array.
39 |     return $arr;
40 | }
41 | 
42 | /**
43 |  * Ensures that the array satisfies the heap property
44 |  *
45 |  * @param array $arr
46 |  * @param int $n
47 |  * @param int $i
48 |  */
49 | function heapify(array &$arr, int $n, int $i): void
50 | {
51 |     $largest = $i;
52 |     $left = 2 * $i + 1;
53 |     $right = 2 * $i + 2;
54 |     if ($left < $n && $arr[$left] > $arr[$largest]) {
55 |         $largest = $left;
56 |     }
57 | 
58 |     if ($right < $n && $arr[$right] > $arr[$largest]) {
59 |         $largest = $right;
60 |     }
61 | 
62 |     if ($largest !== $i) {
63 |         [$arr[$i], $arr[$largest]] = [$arr[$largest], $arr[$i]];
64 |         heapify($arr, $n, $largest);
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/Sorting/InsertionSort.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Insertion Sort
 5 |  *
 6 |  * @param array $array
 7 |  * @return array
 8 |  */
 9 | function insertionSort(array $array)
10 | {
11 |     for ($i = 1; $i < count($array); $i++) {
12 |         $currentVal = $array[$i];
13 | 
14 |         for ($j = $i - 1; $j >= 0 && $array[$j] > $currentVal; $j--) {
15 |             $array[$j + 1] = $array[$j];
16 |         }
17 | 
18 |         $array[$j + 1] = $currentVal;
19 |     }
20 | 
21 |     return $array;
22 | }
23 | 


--------------------------------------------------------------------------------
/Sorting/MergeSort.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Merge Sort
 5 |  *
 6 |  * @param array $arr
 7 |  * @return array
 8 |  */
 9 | function mergeSort(array $arr)
10 | {
11 |     if (count($arr) <= 1) {
12 |         return $arr;
13 |     }
14 | 
15 |     $mid = floor(count($arr) / 2);
16 |     $leftArray = mergeSort(array_slice($arr, 0, $mid));
17 |     $rightArray = mergeSort(array_slice($arr, $mid));
18 | 
19 |     return merge($leftArray, $rightArray);
20 | }
21 | 
22 | /**
23 |  * @param array $leftArray
24 |  * @param array $rightArray
25 |  * @return array
26 |  */
27 | function merge(array $leftArray, array $rightArray)
28 | {
29 |     $result = [];
30 |     $i = 0;
31 |     $j = 0;
32 | 
33 |     while ($i < count($leftArray) && $j < count($rightArray)) {
34 |         if ($rightArray[$j] > $leftArray[$i]) {
35 |             $result[] = $leftArray[$i];
36 |             $i++;
37 |         } else {
38 |             $result[] = $rightArray[$j];
39 |             $j++;
40 |         }
41 |     }
42 | 
43 |     while ($i < count($leftArray)) {
44 |         $result[] = $leftArray[$i];
45 |         $i++;
46 |     }
47 | 
48 |     while ($j < count($rightArray)) {
49 |         $result[] = $rightArray[$j];
50 |         $j++;
51 |     }
52 | 
53 |     return $result;
54 | }
55 | 


--------------------------------------------------------------------------------
/Sorting/QuickSort.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Quick Sort
 5 |  * Compare number in an array to the next number and sets to new array (greater than or less than)
 6 |  *
 7 |  * @param array $input array of random numbers
 8 |  * @return array sorted array of numbers
 9 |  */
10 | function quickSort(array $input)
11 | {
12 |     // Return nothing if input is empty
13 |     if (empty($input)) {
14 |         return [];
15 |     }
16 | 
17 |     $lt = [];
18 |     $gt = [];
19 |     if (sizeof($input) < 2) {
20 |         return $input;
21 |     }
22 | 
23 |     $key = key($input);
24 |     $shift = array_shift($input);
25 |     foreach ($input as $value) {
26 |         $value <= $shift ? $lt[] = $value : $gt[] = $value;
27 |     }
28 | 
29 |     return array_merge(quickSort($lt), [$key => $shift], quickSort($gt));
30 | }
31 | 


--------------------------------------------------------------------------------
/Sorting/RadixSort.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Radix Sort
 5 |  *
 6 |  * @param $nums
 7 |  * @return array
 8 |  */
 9 | function radixSort($nums)
10 | {
11 |     $maxDigitsCount = maxDigits($nums);
12 |     for ($k = 0; $k < $maxDigitsCount; $k++) {
13 |         $digitBucket = array_fill(0, 10, []);
14 | 
15 |         for ($i = 0; $i < count($nums); $i++) {
16 |             $digitBucket[getDigit($nums[$i], $k)][] = $nums[$i];
17 |         }
18 | 
19 |         $nums = concat($digitBucket);
20 |     }
21 | 
22 |     return $nums;
23 | }
24 | 
25 | 
26 | /*
27 |  * Helper functions
28 |  */
29 | 
30 | 
31 | /**
32 |  * Get the digits value by it's place
33 |  *
34 |  * @param $num
35 |  * @param $i
36 |  * @return int
37 |  */
38 | function getDigit($num, $i)
39 | {
40 |     return floor(abs($num) / pow(10, $i)) % 10;
41 | }
42 | 
43 | /**
44 |  * Get the digits count
45 |  *
46 |  * @param $num
47 |  * @return int
48 |  */
49 | function digitsCount($num)
50 | {
51 |     if ($num == 0) {
52 |         return 1;
53 |     }
54 |     return floor(log10(abs($num))) + 1;
55 | }
56 | 
57 | /**
58 |  * Get the max digits count
59 |  *
60 |  * @param $arr
61 |  * @return int
62 |  */
63 | function maxDigits($arr)
64 | {
65 |     $maxDigits = 0;
66 | 
67 |     for ($i = 0; $i < count($arr); $i++) {
68 |         $maxDigits = max($maxDigits, digitsCount($arr[$i]));
69 |     }
70 | 
71 |     return $maxDigits;
72 | }
73 | 
74 | /**
75 |  * Concat the array
76 |  *
77 |  * @param  array  $array
78 |  * @return array
79 |  */
80 | function concat(array $array)
81 | {
82 |     $newArray = [];
83 | 
84 |     for ($i = 0; $i < count($array); $i++) {
85 |         for ($j = 0; $j < count($array[$i]); $j++) {
86 |             $newArray[] = $array[$i][$j];
87 |         }
88 |     }
89 |     return $newArray;
90 | }
91 | 


--------------------------------------------------------------------------------
/Sorting/SelectionSort.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Selection Sort
 5 |  *
 6 |  * @param array $array
 7 |  * @return array
 8 |  */
 9 | function selectionSort(array $array)
10 | {
11 |     $length = count($array);
12 | 
13 |     for ($i = 0; $i < $length; $i++) {
14 |         $lowest = $i;
15 | 
16 |         for ($j = $i + 1; $j < $length; $j++) {
17 |             if ($array[$j] < $array[$lowest]) {
18 |                 $lowest = $j;
19 |             }
20 |         }
21 | 
22 |         if ($i !== $lowest) {
23 |             $temp = $array[$i];
24 |             $array[$i] = $array[$lowest];
25 |             $array[$lowest] = $temp;
26 |         }
27 |     }
28 | 
29 |     return $array;
30 | }
31 | 


--------------------------------------------------------------------------------
/Sorting/ShellSort.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Shell Sort
 5 |  * This function sorts an array in ascending order using the Shell Sort algorithm.
 6 |  * Time complexity of the Shell Sort algorithm depends on the gap sequence used.
 7 |  * With Knuth's sequence, the time complexity is O(n^(3/2)).
 8 |  *
 9 |  *
10 |  * @param array $array
11 |  * @return array
12 |  */
13 | 
14 | function shellSort(array $array): array
15 | {
16 |     $length = count($array);
17 |     $series = calculateKnuthSeries($length);
18 | 
19 |     foreach ($series as $gap) {
20 |         for ($i = $gap; $i < $length; $i++) {
21 |             $temp = $array[$i];
22 |             $j = $i;
23 | 
24 |             while ($j >= $gap && $array[$j - $gap] > $temp) {
25 |                 $array[$j] = $array[$j - $gap];
26 |                 $j -= $gap;
27 |             }
28 | 
29 |             $array[$j] = $temp;
30 |         }
31 |     }
32 | 
33 |     return $array;
34 | }
35 | 
36 | /**
37 |  * Calculate Knuth's series
38 |  *
39 |  * @param int $n Size of the array
40 |  * @return array
41 |  */
42 | function calculateKnuthSeries(int $n): array
43 | {
44 |     $h = 1;
45 |     $series = [];
46 | 
47 |     while ($h < $n) {
48 |         array_unshift($series, $h);
49 |         $h = 3 * $h + 1;
50 |     }
51 | 
52 |     return $series;
53 | }
54 | 


--------------------------------------------------------------------------------
/Strings/CheckAnagram.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Checks if two strings are anagrams of each other.
 5 |  *
 6 |  * @param string $originalString
 7 |  * @param string $testString
 8 |  * @param bool $caseInsensitive
 9 |  * @return bool
10 |  */
11 | function isAnagram(string $originalString, string $testString, bool $caseInsensitive = true)
12 | {
13 |     if ($caseInsensitive) {
14 |         $originalString = strtolower($originalString); // Converting string to lowercase for case-insensitive check
15 |         $testString = strtolower($testString);
16 |     }
17 | 
18 |     // count_chars(string, mode = 1) returns key-value pairs with character as key, frequency as value
19 |     // We can directly compare the arrays in this case
20 |     return count_chars($originalString, 1) === count_chars($testString, 1);
21 | }
22 | 


--------------------------------------------------------------------------------
/Strings/CheckPalindrome.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Checks if a string is a palindrome
 5 |  *
 6 |  * @param string $string
 7 |  * @param bool $caseInsensitive
 8 |  * @return bool
 9 |  */
10 | function isPalindrome(string $string, bool $caseInsensitive = true)
11 | {
12 |     $string = trim($string); // Removing leading and trailing spaces
13 | 
14 |     if (empty($string)) {
15 |         return false; // Returning false for an Empty String
16 |     }
17 | 
18 |     if ($caseInsensitive) {
19 |         $string = strtolower($string); // Converting string to lowercase for case-insensitive check
20 |     }
21 | 
22 |     $characters = str_split($string);
23 | 
24 |     for ($i = 0; $i < count($characters); $i++) {
25 |         if ($characters[$i] !== $characters[count($characters) - ($i + 1)]) {
26 |             return false;
27 |         }
28 |     }
29 | 
30 |     return true;
31 | }
32 | 


--------------------------------------------------------------------------------
/Strings/CheckPalindrome2.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This is a simple way to check palindrome string
 5 |  * using php strrev() function
 6 |  * make it simple
 7 |  *
 8 |  * @param  string  $string
 9 |  * @param  bool  $caseInsensitive
10 |  * @return string
11 |  * @throws \Exception
12 |  */
13 | function checkPalindromeString(string $string, bool $caseInsensitive = true): string
14 | {
15 |     //removing spaces
16 |     $string = trim($string);
17 | 
18 |     if (empty($string)) {
19 |         throw new \Exception('You are given empty string. Please give a non-empty string value');
20 |     }
21 | 
22 |     /**
23 |      * for case-insensitive
24 |      * lowercase string conversion
25 |      */
26 |     if ($caseInsensitive) {
27 |         $string = strtolower($string);
28 |     }
29 | 
30 |     if ($string !== strrev($string)) {
31 |         return $string . " - not a palindrome string." . PHP_EOL;
32 |     }
33 | 
34 |     return $string . " - a palindrome string." . PHP_EOL;
35 | }
36 | 


--------------------------------------------------------------------------------
/Strings/CountConsonants.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Function returns the total number of consonants present in the given
 5 |  * string using a linear search through the string
 6 |  *
 7 |  * @param  string  $string
 8 |  * @return int
 9 |  * @throws \Exception
10 |  */
11 | function countConsonants(string $string): int
12 | {
13 |     if (empty($string)) {
14 |         throw new \Exception('Please pass a non-empty string value');
15 |     }
16 | 
17 |     $vowels     = ['a', 'e', 'i', 'o', 'u']; // Vowels Set
18 |     $string     = strtolower($string); // For case-insensitive checking
19 | 
20 |     $consonantCount = 0;
21 | 
22 |     for ($i = 0; $i < strlen($string); $i++) {
23 |         if (
24 |             !in_array($string[$i], $vowels) &&
25 |             $string[$i] >= 'a' && $string[$i] <= 'z'
26 |         ) {
27 |             $consonantCount++;
28 |         }
29 |     }
30 | 
31 |     return $consonantCount;
32 | }
33 | 


--------------------------------------------------------------------------------
/Strings/CountHomogenous.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Count homogenous substrings
 5 |  * @param String $s
 6 |  * @return Integer
 7 |  */
 8 | function countHomogenous($s)
 9 | {
10 |     // Initialize the count of homogeneous substrings
11 |     $count = 0;
12 | 
13 |     // Length of the string
14 |     $length = strlen($s);
15 | 
16 |     if ($length == 0) {
17 |         return 0; // If the string is empty, return 0
18 |     }
19 | 
20 |     // Initialize the count of homogeneous substrings
21 |     $count = 1; // Start with 1 since the first character itself starts a substring
22 | 
23 |     // Loop through each character in the string, starting from the second character
24 |     for ($i = 1; $i < $length; $i++) {
25 |         // Check if current character is not the same as the previous one
26 |         if ($s[$i] != $s[$i - 1]) {
27 |             $count++; // A new substring starts, increment the count
28 |         }
29 |     }
30 | 
31 |     return $count;
32 | }
33 | 


--------------------------------------------------------------------------------
/Strings/CountSentences.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This is a simple way to count sentence
 5 |  * using php preg_match_all() function
 6 |  *
 7 |  * @param string $sentence
 8 |  * @return int
 9 |  */
10 | function countSentences(string $sentence): int
11 | {
12 |     $sentence = trim($sentence);
13 | 
14 |     return preg_match_all('/[^\s|^\...](\.|\!|\?)(?!\w)/', $sentence);
15 | }
16 | 


--------------------------------------------------------------------------------
/Strings/CountVowels.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This function returns the total number of vowels present in
 5 |  * the given string using a simple method of looping through
 6 |  * all the characters present in the string.
 7 |  *
 8 |  * @param  string  $string
 9 |  * @return int   $numberOfVowels
10 |  * @throws \Exception
11 |  */
12 | function countVowelsSimple(string $string): int
13 | {
14 |     // Check for an empty string and throw an exception if so.
15 |     if (empty($string)) {
16 |         throw new \Exception('Please pass a non-empty string value.');
17 |     }
18 | 
19 |     // Initialize variables.
20 |     $numberOfVowels = 0;
21 |     $vowels = ['a', 'e', 'i', 'o', 'u']; // Set of vowels for comparison.
22 | 
23 |     // Convert the string to lowercase for case-insensitive comparison.
24 |     $string = strtolower($string);
25 | 
26 |     // Split the string into an array of characters.
27 |     $characters = str_split($string);
28 | 
29 |     // Loop through each character to count the vowels.
30 |     foreach ($characters as $character) {
31 |         if (in_array($character, $vowels)) {
32 |             $numberOfVowels++;
33 |         }
34 |     }
35 | 
36 |     // Return the total number of vowels found.
37 |     return $numberOfVowels;
38 | }
39 | 
40 | /**
41 |  * This function returns the Total number of vowels present in the given
42 |  * string using a regular expression.
43 |  *
44 |  * @param  string  $string
45 |  * @return int
46 |  * @throws \Exception
47 |  */
48 | function countVowelsRegex(string $string)
49 | {
50 |     if (empty($string)) {
51 |         throw new \Exception('Please pass a non-empty string value');
52 |     }
53 | 
54 |     $string = strtolower($string); // For case-insensitive checking
55 | 
56 |     return preg_match_all('/[a,e,i,o,u]/', $string);
57 | }
58 | 


--------------------------------------------------------------------------------
/Strings/Distance.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Find distance (Levenshtein distance)
 5 |  *
 6 |  * Compute the difference between two sequences, ie, the minimum number of changes
 7 |  * to get to $str2 from $str1
 8 |  *
 9 |  * @param string $str1
10 |  * @param string $str2
11 |  * @return int the minimum number of changes to transform one string into another
12 |  */
13 | function findDistance($str1, $str2)
14 | {
15 |     $lenStr1 = strlen($str1);
16 |     $lenStr2 = strlen($str2);
17 |     if ($lenStr1 == 0) {
18 |         return $lenStr2;
19 |     }
20 | 
21 |     if ($lenStr2 == 0) {
22 |         return $lenStr1;
23 |     }
24 | 
25 |     $distanceVectorInit = [];
26 |     $distanceVectorFinal = [];
27 | 
28 |     for ($i = 0; $i < $lenStr1 + 1; $i++) {
29 |         $distanceVectorInit[] = 0;
30 |         $distanceVectorFinal[] = 0;
31 |     }
32 | 
33 |     for ($i = 0; $i < $lenStr1 + 1; $i++) {
34 |         $distanceVectorInit[$i] = $i;
35 |     }
36 | 
37 |     for ($i = 0; $i < $lenStr2; $i++) {
38 |         $distanceVectorFinal[0] = $i + 1;
39 | 
40 |         // use formula to fill in the rest of the row
41 |         for ($j = 0; $j < $lenStr1; $j++) {
42 |             $substitutionCost = 0;
43 |             if ($str1[$j] == $str2[$i]) {
44 |                 $substitutionCost = $distanceVectorInit[$j];
45 |             } else {
46 |                 $substitutionCost = $distanceVectorInit[$j] + 1;
47 |             }
48 | 
49 |             $distanceVectorFinal[$j + 1] = min($distanceVectorInit[$j + 1] + 1, min($distanceVectorFinal[$j] + 1, $substitutionCost));
50 |         }
51 | 
52 |         $distanceVectorInit = $distanceVectorFinal;
53 |     }
54 | 
55 | 
56 |     return $distanceVectorFinal[$lenStr1];
57 | }
58 | 


--------------------------------------------------------------------------------
/Strings/MaxCharacter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This function returns the character which is repeated maximum number of
 5 |  * times in the given string.
 6 |  *
 7 |  * @param  string  $string
 8 |  * @return string
 9 |  * @throws \Exception
10 |  */
11 | function maxCharacter(string $string): string
12 | {
13 |     // Throw an exception if the string is empty.
14 |     if (empty($string)) {
15 |         throw new \Exception('Please pass a non-empty string value.');
16 |     }
17 | 
18 |     // Initialize an associative array to hold character counts.
19 |     $characterCountTable = [];
20 | 
21 |     // Convert the string to lowercase for case-insensitive analysis.
22 |     $string = strtolower($string);
23 | 
24 |     // Convert the string into an array of characters.
25 |     $characters = str_split($string);
26 | 
27 |     // Loop through the characters to populate the count table.
28 |     foreach ($characters as $character) {
29 |         // Initialize or update the count of the current character.
30 |         $currentCharacterCount = isset($characterCountTable[$character]) ? $characterCountTable[$character] + 1 : 1;
31 | 
32 |         // Update the count in the table.
33 |         $characterCountTable[$character] = $currentCharacterCount;
34 |     }
35 | 
36 |     // Sort the count table in descending order.
37 |     arsort($characterCountTable);
38 | 
39 |     // Return the character that appears most frequently.
40 |     return array_keys($characterCountTable)[0];
41 | }
42 | 


--------------------------------------------------------------------------------
/Strings/ReverseString.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This function returns a given string in reverse order
 5 |  *
 6 |  * @param string $string
 7 |  * @return string
 8 |  */
 9 | function reverseString(string $string)
10 | {
11 |     $string = trim($string); // Removing leading and trailing spaces
12 | 
13 |     $characters = str_split($string);
14 | 
15 |     $reversedCharacters = [];
16 | 
17 |     for ($i = (count($characters) - 1); $i >= 0; $i--) {
18 |         $reversedCharacters[] = $characters[$i];
19 |     }
20 | 
21 |     return implode('', $reversedCharacters);
22 | }
23 | 


--------------------------------------------------------------------------------
/Strings/ReverseWords.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This function returns a given sentence with its words
 5 |  * in reverse order
 6 |  *
 7 |  * @param  string  $text
 8 |  * @return string
 9 |  */
10 | function reverseWords(string $text)
11 | {
12 |     $text          = trim($text);
13 |     $words         = explode(' ', $text);
14 |     $reversedWords = [];
15 | 
16 |     for ($i = (count($words) - 1); $i >= 0; $i--) {
17 |         $reversedWords[] = $words[$i];
18 |     }
19 | 
20 |     return implode(' ', $reversedWords);
21 | }
22 | 


--------------------------------------------------------------------------------
/Utils/ArrayHelpers.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * @param  array  $arr  array of integers
 5 |  * @return void array sorted in ascending
 6 |  */
 7 | function isSortedAscendingInts(array $arr): void
 8 | {
 9 |     $len = count($arr);
10 | 
11 |     if ($len == 0) {
12 |         return;
13 |     }
14 | 
15 |     if (!is_int($arr[0])) {
16 |         throw UnexpectedValueException;
17 |     }
18 | 
19 |     for ($i = 1; $i < $len; $i++) {
20 |         // a sorted array is expected
21 |         if (!is_int($arr[$i]) && $arr[$i] < $arr[$i - 1]) {
22 |             throw UnexpectedValueException;
23 |         }
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/Utils/ExecutionTime.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * Run script and test execution time with following script
 5 |         $executionTime = New ExecutionTime();
 6 |         print_r(fibonacciRecursive(10));
 7 |  */
 8 | class ExecutionTime
 9 | {
10 |     private $start_time = 0;
11 |     private $end_time = 0;
12 |     private $execution_time = 0;
13 | 
14 |     public function __construct()
15 |     {
16 |         $this->start_time = microtime(true);
17 |     }
18 | 
19 |     public function __destruct()
20 |     {
21 |         $this->end_time = microtime(true);
22 |         $this->execution_time = $this->end_time - $this->start_time;
23 |         echo "Executed in $this->execution_time seconds\n";
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "thealgorithms/php",
 3 |   "description": "All Algorithms implemented in PHP",
 4 |   "config": {
 5 |     "platform": {
 6 |       "php": "7.4.0"
 7 |     }
 8 |   },
 9 |   "license": "MIT",
10 |   "require": {
11 |     "php": "7.4",
12 |     "phan/phan": "^2.7",
13 |     "ext-json": "*"
14 |   },
15 |   "require-dev": {
16 |     "phpunit/phpunit": "^9",
17 |     "squizlabs/php_codesniffer": "^3.7"
18 |   },
19 |   "scripts": {
20 |     "test": "vendor/bin/phpunit tests"
21 |   }
22 | }
23 | 
24 | 


--------------------------------------------------------------------------------
/phpcs.xml.dist:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <ruleset xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 3 |          xsi:noNamespaceSchemaLocation="vendor/squizlabs/php_codesniffer/phpcs.xsd">
 4 | 
 5 |     <arg name="extensions" value="php"/>
 6 |     <rule ref="PSR12"/>
 7 | 
 8 |     <file>.</file>
 9 | 
10 |     <exclude-pattern>vendor</exclude-pattern>
11 | 
12 |     <rule ref="PSR1.Classes.ClassDeclaration.MissingNamespace">
13 |         <severity>0</severity>
14 |     </rule>
15 | </ruleset>
16 | 


--------------------------------------------------------------------------------
/tests/Ciphers/AtbashCipherTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use PHPUnit\Framework\TestCase;
 4 | 
 5 | require_once __DIR__ . '/../../vendor/autoload.php';
 6 | require_once __DIR__ . '/../../Ciphers/AtbashCipher.php';
 7 | 
 8 | class AtbashCipherTest extends TestCase
 9 | {
10 |     public function testEncryptionAndDecryption()
11 |     {
12 |         $plainText = "HELLO";
13 |         $encryptedText = atbash_encrypt($plainText);
14 |         $decryptedText = atbash_decrypt($encryptedText);
15 |         $this->assertEquals($plainText, $decryptedText);
16 |     }
17 | 
18 |     public function testWithNonAlphabetCharacters()
19 |     {
20 |         $plainText = "HELLO, WORLD!";
21 |         $encryptedText = atbash_encrypt($plainText);
22 |         $decryptedText = atbash_decrypt($encryptedText);
23 |         $this->assertEquals($plainText, $decryptedText);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/tests/Ciphers/CiphersTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use PHPUnit\Framework\TestCase;
 4 | 
 5 | require_once __DIR__ . '/../../vendor/autoload.php';
 6 | require_once __DIR__ . '/../../Ciphers/CaesarCipher.php';
 7 | require_once __DIR__ . '/../../Ciphers/XORCipher.php';
 8 | 
 9 | class CiphersTest extends TestCase
10 | {
11 |     public function testCaesarCipher()
12 |     {
13 |         $this->assertEquals('Aopz pz h alza.', encrypt('This is a test.', 7));
14 |         $this->assertEquals('Aopz pz h alza.', encrypt('This is a test.', 7 + 26));
15 |         $this->assertEquals('This is a test.', decrypt('Aopz pz h alza.', 7));
16 |         $this->assertEquals('This is a test.', decrypt('Aopz pz h alza.', 7 + 26));
17 |     }
18 | 
19 |     public function testXorCipher()
20 |     {
21 |         $input_str = "test@string";
22 |         $key = "test-key";
23 |         $invalid_key = "wrong-key";
24 |         $this->assertEquals($input_str, xorCipher(xorCipher($input_str, $key), $key));
25 |         $this->assertNotEquals($input_str, xorCipher(xorCipher($input_str, $key), $invalid_key));
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/tests/Ciphers/MonoAlphabeticCipherTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use PHPUnit\Framework\TestCase;
 4 | 
 5 | require_once __DIR__ . '/../../vendor/autoload.php';
 6 | require_once __DIR__ . '/../../Ciphers/MonoAlphabeticCipher.php';
 7 | 
 8 | class MonoAlphabeticCipherTest extends TestCase
 9 | {
10 |     public function testMonoAlphabeticCipher()
11 |     {
12 |         $alphabet = "abcdefghijklmnopqrstuvwxyz";
13 |         $key = "yhkqgvxfoluapwmtzecjdbsnri";
14 |         $text = "I love1234 GitHub";
15 |         $encryptedText = "O ambg XojFdh";
16 |         $this->assertEquals(maEncrypt($key, $alphabet, $text), $encryptedText);
17 |         $this->assertEquals(maDecrypt($key, $alphabet, $encryptedText), "I love GitHub");
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/tests/Ciphers/MorseCodeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use PHPUnit\Framework\TestCase;
 4 | 
 5 | require_once __DIR__ . '/../../vendor/autoload.php';
 6 | require_once __DIR__ . '/../../Ciphers/MorseCode.php';
 7 | 
 8 | class MorseCodeTest extends TestCase
 9 | {
10 |     public function testMorseCodeCipher()
11 |     {
12 |         $this->assertEquals('TEST 123', decode(encode('TEST 123')));
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/tests/Ciphers/RailfenceCipherTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use PHPUnit\Framework\TestCase;
 4 | 
 5 | require_once __DIR__ . '/../../vendor/autoload.php'; // Adjust the path as needed
 6 | require_once __DIR__ . '/../../Ciphers/RailfenceCipher.php'; // Adjust the path as needed
 7 | 
 8 | class RailfenceCipherTest extends TestCase
 9 | {
10 |     public function testRailfenceCipherCase1()
11 |     {
12 |         $plainMessage = "ABCDEF";
13 |         $rails = 3;
14 |         $cipherMessage = Railencode($plainMessage, $rails);
15 |         $decodedMessage = Raildecode($cipherMessage, $rails);
16 |         $this->assertEquals($plainMessage, $decodedMessage);
17 |     }
18 |     public function testRailfenceCipherCase2()
19 |     {
20 |         $plainMessage = "THIS IS RAILFENCE";
21 |         $rails = 3;
22 |         $cipherMessage = Railencode($plainMessage, $rails);
23 |         $decodedMessage = Raildecode($cipherMessage, $rails);
24 |         $this->assertEquals($plainMessage, $decodedMessage);
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/tests/Ciphers/VignereCipherTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use PHPUnit\Framework\TestCase;
 4 | 
 5 | require_once __DIR__ . '/../../vendor/autoload.php';
 6 | require_once __DIR__ . '/../../Ciphers/VignereCipher.php';
 7 | 
 8 | class VignereCipherTest extends TestCase
 9 | {
10 |     public function testVignereCipher()
11 |     {
12 |         $plaintext = "HELLO";
13 |         $key = "KEY";
14 |         $encryptedText = vigenere_encrypt($plaintext, $key);
15 |         $decryptedText = vigenere_decrypt($encryptedText, $key);
16 | 
17 |         $this->assertEquals($plaintext, $decryptedText);
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/tests/DataStructures/.keep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/TheAlgorithms/PHP/81b5386af390fd2b44fecf162ade3b1a940c8500/tests/DataStructures/.keep


--------------------------------------------------------------------------------
/tests/DataStructures/CompareBinaryTreeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace DataStructures;
 4 | 
 5 | require_once __DIR__ . '/../../vendor/autoload.php';
 6 | require_once __DIR__ . '/../../DataStructures/CompareBinaryTree/BinaryTreeNode.php';
 7 | require_once __DIR__ . '/../../DataStructures/CompareBinaryTree/CompareBinaryTree.php';
 8 | 
 9 | use DataStructures\CompareBinaryTree\BinaryTreeNode;
10 | use DataStructures\CompareBinaryTree\CompareBinaryTree;
11 | use PHPUnit\Framework\TestCase;
12 | 
13 | class CompareBinaryTreeTest extends TestCase
14 | {
15 |     public function testBinaryTreesAreEqualWhenAreEqualInReality()
16 |     {
17 |         $tree1 = new BinaryTreeNode(
18 |             'A',
19 |             new BinaryTreeNode(
20 |                 'B',
21 |                 new BinaryTreeNode(
22 |                     'D'
23 |                 ),
24 |                 new BinaryTreeNode(
25 |                     'E',
26 |                     null,
27 |                     new BinaryTreeNode(
28 |                         'F'
29 |                     )
30 |                 )
31 |             ),
32 |             new BinaryTreeNode(
33 |                 'C',
34 |                 new BinaryTreeNode('G')
35 |             )
36 |         );
37 | 
38 |         $tree2 = clone $tree1;
39 | 
40 |         $sut = new CompareBinaryTree();
41 |         $this->assertTrue($sut->areTreesEqual($tree1, $tree2));
42 |     }
43 | 
44 |     public function testBinaryTreesAreNotEqualWhenAreNotEqualInReality()
45 |     {
46 | 
47 |         $tree1 = new BinaryTreeNode(
48 |             'A',
49 |             new BinaryTreeNode(
50 |                 'B',
51 |                 new BinaryTreeNode(
52 |                     'F'
53 |                 ),
54 |                 new BinaryTreeNode(
55 |                     'E',
56 |                     null,
57 |                     new BinaryTreeNode(
58 |                         'D'
59 |                     )
60 |                 )
61 |             ),
62 |             new BinaryTreeNode(
63 |                 'C',
64 |                 new BinaryTreeNode('G')
65 |             )
66 |         );
67 | 
68 |         $tree2 = new BinaryTreeNode(
69 |             'A',
70 |             new BinaryTreeNode(
71 |                 'B',
72 |                 new BinaryTreeNode(
73 |                     'F'
74 |                 ),
75 |                 new BinaryTreeNode(
76 |                     'E',
77 |                     null,
78 |                     new BinaryTreeNode(
79 |                         'D'
80 |                     )
81 |                 )
82 |             ),
83 |             new BinaryTreeNode(
84 |                 'C'
85 |             )
86 |         );
87 | 
88 |         $sut = new CompareBinaryTree();
89 |         $this->assertFalse($sut->areTreesEqual($tree1, $tree2));
90 |     }
91 | }
92 | 


--------------------------------------------------------------------------------
/tests/DataStructures/DisjointSetTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * Created by: Ramy-Badr-Ahmed (https://github.com/Ramy-Badr-Ahmed) in Pull Request: #160
 5 |  * https://github.com/TheAlgorithms/PHP/pull/160
 6 |  *
 7 |  * Please mention me (@Ramy-Badr-Ahmed) in any issue or pull request addressing bugs/corrections to this file.
 8 |  * Thank you!
 9 |  */
10 | 
11 | namespace DataStructures;
12 | 
13 | require_once __DIR__ . '/../../DataStructures/DisjointSets/DisjointSet.php';
14 | require_once __DIR__ . '/../../DataStructures/DisjointSets/DisjointSetNode.php';
15 | 
16 | use DataStructures\DisjointSets\DisjointSet;
17 | use DataStructures\DisjointSets\DisjointSetNode;
18 | use PHPUnit\Framework\TestCase;
19 | 
20 | class DisjointSetTest extends TestCase
21 | {
22 |     private DisjointSet $ds;
23 |     private array $nodes;
24 | 
25 |     protected function setUp(): void
26 |     {
27 |         $this->ds = new DisjointSet();
28 |         $this->nodes = [];
29 | 
30 |         // Create 20 nodes
31 |         for ($i = 0; $i < 20; $i++) {
32 |             $this->nodes[$i] = new DisjointSetNode($i);
33 |         }
34 | 
35 |         // Perform union operations to form several disjoint sets
36 |         $this->ds->unionSet($this->nodes[0], $this->nodes[1]);
37 |         $this->ds->unionSet($this->nodes[1], $this->nodes[2]);
38 | 
39 |         $this->ds->unionSet($this->nodes[3], $this->nodes[4]);
40 |         $this->ds->unionSet($this->nodes[4], $this->nodes[5]);
41 | 
42 |         $this->ds->unionSet($this->nodes[6], $this->nodes[7]);
43 |         $this->ds->unionSet($this->nodes[7], $this->nodes[8]);
44 | 
45 |         $this->ds->unionSet($this->nodes[9], $this->nodes[10]);
46 |         $this->ds->unionSet($this->nodes[10], $this->nodes[11]);
47 | 
48 |         $this->ds->unionSet($this->nodes[12], $this->nodes[13]);
49 |         $this->ds->unionSet($this->nodes[13], $this->nodes[14]);
50 | 
51 |         $this->ds->unionSet($this->nodes[15], $this->nodes[16]);
52 |         $this->ds->unionSet($this->nodes[16], $this->nodes[17]);
53 | 
54 |         $this->ds->unionSet($this->nodes[18], $this->nodes[19]);
55 |     }
56 | 
57 |     public function testFindSet(): void
58 |     {
59 |         // Nodes in the same sets should have the same root
60 |         for ($i = 0; $i < 6; $i++) {
61 |             for ($j = 0; $j < 6; $j++) {
62 |                 $setI = $this->ds->findSet($this->nodes[$i]);
63 |                 $setJ = $this->ds->findSet($this->nodes[$j]);
64 | 
65 |                 if ($this->inSameSet($i, $j)) {
66 |                     $this->assertSame($setI, $setJ, "Nodes $i and $j should be in the same set");
67 |                 } else {
68 |                     $this->assertNotSame($setI, $setJ, "Nodes $i and $j should be in different sets");
69 |                 }
70 |             }
71 |         }
72 |     }
73 | 
74 |     private function inSameSet(int $i, int $j): bool
75 |     {
76 |         // Define which nodes should be in the same set based on union operations
77 |         $sets = [
78 |             [0, 1, 2],      // Set A
79 |             [3, 4, 5],      // Set B
80 |             [6, 7, 8],      // Set C
81 |             [9, 10, 11],    // Set D
82 |             [12, 13, 14],   // Set E
83 |             [15, 16, 17],   // Set F
84 |             [18, 19]        // Set G
85 |         ];
86 | 
87 |         foreach ($sets as $set) {
88 |             if (in_array($i, $set) && in_array($j, $set)) {
89 |                 return true;
90 |             }
91 |         }
92 | 
93 |         return false;
94 |     }
95 | }
96 | 


--------------------------------------------------------------------------------
/tests/DataStructures/DoublyLinkedListTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | use PHPUnit\Framework\TestCase;
  4 | 
  5 | require_once __DIR__ . '/../../vendor/autoload.php';
  6 | require_once __DIR__ . '/../../DataStructures/DoublyLinkedList.php';
  7 | 
  8 | /**
  9 |  * Tests for the Doubly Linked Lists class
 10 |  */
 11 | 
 12 | class DoublyLinkedListTest extends TestCase
 13 | {
 14 |     /**
 15 |      * Constructor test
 16 |      */
 17 |     public function testConstructor()
 18 |     {
 19 |         $list = new DoublyLinkedList();
 20 |         $this->assertEquals(0, $list->length());
 21 |     }
 22 | 
 23 |     /**
 24 |      * Test for the append method
 25 |      */
 26 |     public function testAppend()
 27 |     {
 28 |         $list = new DoublyLinkedList();
 29 |         $list->append(1);
 30 |         $list->append(2);
 31 |         $list->append(3);
 32 |         $this->assertEquals(3, $list->length());
 33 |     }
 34 | 
 35 |     /**
 36 |      * Test for the insert method
 37 |      */
 38 |     public function testInsert()
 39 |     {
 40 |         $list = new DoublyLinkedList();
 41 |         $list->append(1);
 42 |         $list->append(2);
 43 |         $list->append(3);
 44 |         $list->insert(1, 4);
 45 |         $this->assertEquals(4, $list->length());
 46 |     }
 47 | 
 48 |     /**
 49 |      * Test for the delete method
 50 |      */
 51 |     public function testDelete()
 52 |     {
 53 |         $list = new DoublyLinkedList();
 54 |         $list->append(1);
 55 |         $list->append(2);
 56 |         $list->append(3);
 57 |         $list->delete(1);
 58 |         $this->assertEquals(2, $list->length());
 59 |     }
 60 | 
 61 |     /**
 62 |      * Test for the deleteAt method
 63 |      */
 64 |     public function testDeleteAt()
 65 |     {
 66 |         $list = new DoublyLinkedList();
 67 |         $list->append(1);
 68 |         $list->append(2);
 69 |         $list->append(3);
 70 |         $list->deleteAt(1);
 71 |         $this->assertEquals(2, $list->length());
 72 |     }
 73 | 
 74 |     /**
 75 |      * Test for printList method
 76 |      */
 77 |     public function testPrintList()
 78 |     {
 79 |         $list = new DoublyLinkedList();
 80 |         $list->append(1);
 81 |         $list->append(2);
 82 |         $list->append(3);
 83 |         $this->expectOutputString("1\n2\n3\n");
 84 |         $list->printList();
 85 |     }
 86 | 
 87 |     /**
 88 |      * Test for the printListReverse method
 89 |      */
 90 |     public function testPrintListReverse()
 91 |     {
 92 |         $list = new DoublyLinkedList();
 93 |         $list->append(1);
 94 |         $list->append(2);
 95 |         $list->append(3);
 96 |         $this->expectOutputString("3\n2\n1\n");
 97 |         $list->printListReverse();
 98 |     }
 99 | 
100 |     /**
101 |      * Test for the reverse method
102 |      */
103 |     public function testReverse()
104 |     {
105 |         $list = new DoublyLinkedList();
106 |         $list->append(1);
107 |         $list->append(2);
108 |         $list->append(3);
109 |         $list->reverse();
110 |         $this->expectOutputString("3\n2\n1\n");
111 |         $list->printList();
112 |     }
113 | 
114 |     /**
115 |      * Test for the length method
116 |      */
117 |     public function testLength()
118 |     {
119 |         $list = new DoublyLinkedList();
120 |         $list->append(1);
121 |         $list->append(2);
122 |         $list->append(3);
123 |         $this->assertEquals(3, $list->length());
124 |     }
125 |     /**
126 |      * Test for the Search method
127 |      */
128 |     public function testSearch()
129 |     {
130 |         $list = new DoublyLinkedList();
131 |         $list->append(1);
132 |         $list->append(2);
133 |         $list->append(3);
134 |         $searchItem = $list->search(2);
135 |         $this->assertEquals(2, $searchItem->data);
136 |     }
137 | 
138 |     /**
139 |      * Test for the isEmpty method
140 |      */
141 |     public function testIsEmpty()
142 |     {
143 |         $list = new DoublyLinkedList();
144 |         $this->assertEquals(true, $list->isEmpty());
145 |     }
146 | 
147 |     /**
148 |      * Test for __toString method
149 |      */
150 |     public function testToString()
151 |     {
152 |         $list = new DoublyLinkedList();
153 |         $list->append(1);
154 |         $list->append(2);
155 |         $list->append(3);
156 |         $this->expectOutputString("1, 2, 3");
157 |         echo $list;
158 |     }
159 | 
160 |     /**
161 |      * Test for the toArray method
162 |      */
163 |     public function testToArray()
164 |     {
165 |         $list = new DoublyLinkedList();
166 |         $list->append(1);
167 |         $list->append(2);
168 |         $list->append(3);
169 |         $this->assertEquals([1,2,3], $list->toArray());
170 |     }
171 | }
172 | 


--------------------------------------------------------------------------------
/tests/DataStructures/InvertBinaryTreeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace DataStructures;
 4 | 
 5 | require_once __DIR__ . '/../../vendor/autoload.php';
 6 | require_once __DIR__ . '/../../DataStructures/InvertBinaryTree/BinaryTree.php';
 7 | require_once __DIR__ . '/../../DataStructures/InvertBinaryTree/InvertBinaryTree.php';
 8 | 
 9 | use DataStructures\InvertBinaryTree\BinaryTree;
10 | use DataStructures\InvertBinaryTree\InvertBinaryTree;
11 | use PHPUnit\Framework\TestCase;
12 | 
13 | class InvertBinaryTreeTest extends TestCase
14 | {
15 |     public function testInvertBinaryTree()
16 |     {
17 |         $b = (new BinaryTree())->setValue(1);
18 |         $bl = (new BinaryTree())->setValue(3);
19 |         $b->setLeft($bl);
20 |         $br = (new BinaryTree())->setValue(2);
21 |         $b->setRight($br);
22 |         $br->setLeft((new BinaryTree())->setValue(4));
23 |         $br->setRight((new BinaryTree())->setValue(5));
24 | 
25 |         $expected = (new BinaryTree())->setValue(1);
26 |         $expectedBr = (new BinaryTree())->setValue(3);
27 |         $expected->setRight($expectedBr);
28 |         $expectedBl = (new BinaryTree())->setValue(2);
29 |         $expected->setLeft($expectedBl);
30 |         $expectedBl->setRight((new BinaryTree())->setValue(4));
31 |         $expectedBl->setLeft((new BinaryTree())->setValue(5));
32 | 
33 |         (new InvertBinaryTree())->invert($b);
34 | 
35 |         $this->assertEquals($expected, $b);
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/tests/DataStructures/QueueTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | use PHPUnit\Framework\TestCase;
  4 | 
  5 | require_once __DIR__ . '/../../vendor/autoload.php';
  6 | require_once __DIR__ . "/../../DataStructures/Queue.php";
  7 | 
  8 | class QueueTest extends TestCase
  9 | {
 10 |     /**
 11 |      * @test
 12 |      */
 13 |     public function shouldAddElementToQueue(): void
 14 |     {
 15 |         $queue = new Queue();
 16 |         $queue->enqueue(1);
 17 |         $queue->enqueue(2);
 18 |         $queue->enqueue(3);
 19 | 
 20 |         $this->assertEquals(3, $queue->size());
 21 |         $this->assertEquals(1, $queue->peek());
 22 |     }
 23 | 
 24 |     /**
 25 |      * @test
 26 |      */
 27 |     public function shouldRemoveElementFromQueue(): void
 28 |     {
 29 |         $queue = new Queue();
 30 |         $queue->enqueue(1);
 31 |         $queue->enqueue(2);
 32 |         $queue->enqueue(3);
 33 | 
 34 |         $this->assertEquals(1, $queue->dequeue());
 35 |         $this->assertEquals(2, $queue->peek());
 36 |         $this->assertEquals(2, $queue->size());
 37 |     }
 38 | 
 39 |     /**
 40 |      * @test
 41 |      */
 42 |     public function shouldReturnCorrectValueWhenDequeue(): void
 43 |     {
 44 |         $queue = new Queue();
 45 |         $queue->enqueue(1);
 46 |         $queue->enqueue(2);
 47 |         $queue->enqueue(3);
 48 | 
 49 |         $this->assertEquals(1, $queue->dequeue());
 50 |         $this->assertEquals(2, $queue->dequeue());
 51 |         $this->assertEquals(3, $queue->dequeue());
 52 |     }
 53 | 
 54 |     /**
 55 |      * @test
 56 |      */
 57 |     public function shouldReturnNullWhenDequeueEmptyQueue(): void
 58 |     {
 59 |         $queue = new Queue();
 60 | 
 61 |         $this->assertNull($queue->dequeue());
 62 |     }
 63 | 
 64 |     /**
 65 |      * @test
 66 |      */
 67 |     public function shouldReturnTrueIfQueueIsEmpty(): void
 68 |     {
 69 |         $queue = new Queue();
 70 | 
 71 |         $this->assertTrue($queue->isEmpty());
 72 |     }
 73 | 
 74 |     /**
 75 |      * @test
 76 |      */
 77 |     public function shouldReturnFalseIfQueueIsNotEmpty(): void
 78 |     {
 79 |         $queue = new Queue();
 80 |         $queue->enqueue(1);
 81 | 
 82 |         $this->assertFalse($queue->isEmpty());
 83 |     }
 84 | 
 85 |     /**
 86 |      * @test
 87 |      */
 88 |     public function shouldReturnQueueSize(): void
 89 |     {
 90 |         $queue = new Queue();
 91 |         $queue->enqueue(1);
 92 |         $queue->enqueue(2);
 93 |         $queue->enqueue(3);
 94 | 
 95 |         $this->assertEquals(3, $queue->size());
 96 |         $this->assertEquals(1, $queue->peek());
 97 |     }
 98 | 
 99 |     /**
100 |      * @test
101 |      */
102 |     public function shouldReturnFrontElement(): void
103 |     {
104 |         $queue = new Queue();
105 |         $queue->enqueue(1);
106 |         $queue->enqueue(2);
107 |         $queue->enqueue(3);
108 | 
109 |         $this->assertEquals(1, $queue->peek());
110 |         $this->assertEquals(3, $queue->size());
111 |     }
112 | 
113 |     /**
114 |      * @test
115 |      */
116 |     public function shouldReturnNullWhenPeekEmptyQueue(): void
117 |     {
118 |         $queue = new Queue();
119 | 
120 |         $this->assertNull($queue->peek());
121 |     }
122 | 
123 |     /**
124 |      * @test
125 |      */
126 |     public function shouldClearQueue(): void
127 |     {
128 |         $queue = new Queue();
129 |         $queue->enqueue(1);
130 |         $queue->enqueue(2);
131 |         $queue->enqueue(3);
132 | 
133 |         $queue->clear();
134 | 
135 |         $this->assertTrue($queue->isEmpty());
136 |         $this->assertEquals(0, $queue->size());
137 |         $this->assertNull($queue->peek());
138 |     }
139 | 
140 |     /**
141 |      * @test
142 |      */
143 |     public function shouldReturnStringRepresentation(): void
144 |     {
145 |         $queue = new Queue();
146 |         $queue->enqueue(1);
147 |         $queue->enqueue(2);
148 |         $queue->enqueue(3);
149 | 
150 |         $this->assertIsString($queue->toString());
151 |         $this->assertEquals("1, 2, 3", $queue->toString(', '));
152 |     }
153 | }
154 | 


--------------------------------------------------------------------------------
/tests/DataStructures/ReverseLinkedListTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace DataStructures;
 4 | 
 5 | require_once __DIR__ . '/../../vendor/autoload.php';
 6 | require_once __DIR__ . '/../../DataStructures/ReverseLinkedList/LinkedListItem.php';
 7 | require_once __DIR__ . '/../../DataStructures/ReverseLinkedList/ReverseLinkedList.php';
 8 | 
 9 | 
10 | use DataStructures\ReverseLinkedList\LinkedListItem;
11 | use DataStructures\ReverseLinkedList\ReverseLinkedList;
12 | use PHPUnit\Framework\TestCase;
13 | 
14 | class ReverseLinkedListTest extends TestCase
15 | {
16 |     public function testReverseLinkedList()
17 |     {
18 |         $list = [1,2,3,4,5];
19 | 
20 |         $firstItem = (new LinkedListItem())->setValue(0);
21 | 
22 |         $prevItem = $firstItem;
23 | 
24 |         foreach ($list as $value) {
25 |             $item = new LinkedListItem();
26 |             $item->setValue($value);
27 |             $item->setPrev($prevItem);
28 |             $prevItem->setNext($item);
29 |             $prevItem = $item;
30 |         }
31 | 
32 |         $newFirstItem = (new ReverseLinkedList())->reverse($firstItem);
33 |         do {
34 |             $this->assertEquals($newFirstItem->getValue(), array_pop($list));
35 |         } while ($newFirstItem = $newFirstItem->getNext());
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/tests/DataStructures/SinglyLinkedListTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | use PHPUnit\Framework\TestCase;
  4 | 
  5 | require_once __DIR__ . '/../../vendor/autoload.php';
  6 | require_once __DIR__ . '/../../DataStructures/SinglyLinkedList.php';
  7 | 
  8 | /**
  9 |  * Tests for the Singly Linked Lists class
 10 |  */
 11 | class SinglyLinkedListTest extends TestCase
 12 | {
 13 |     /**
 14 |      * Create a SinglyLinkedList node
 15 |      */
 16 |     private function createNode(string $string): SinglyLinkedList
 17 |     {
 18 |         $node = new SinglyLinkedList($string[0]);
 19 | 
 20 |         for ($i = 1; $i < strlen($string); $i++) {
 21 |             $node->append($string[$i]);
 22 |         }
 23 | 
 24 |         return $node;
 25 |     }
 26 | 
 27 |     /**
 28 |      * Provider of SinglyLinkedList nodes
 29 |      */
 30 |     public function provideNodes()
 31 |     {
 32 |         return [
 33 |             'IsPalindrome' => [
 34 |                 'node' => $this->createNode('hannah'),
 35 |                 'expected' => true
 36 |             ],
 37 |             'IsPalindrome2' => [
 38 |                 'node' => $this->createNode('hanah'),
 39 |                 'expected' => true
 40 |             ],
 41 |             'IsNotPalindrome' => [
 42 |                 'node' => $this->createNode('hanbah'),
 43 |                 'expected' => false
 44 |             ],
 45 |             'IsNotPalindrome2' => [
 46 |                 'node' => $this->createNode('han1h'),
 47 |                 'expected' => false
 48 |             ],
 49 |         ];
 50 |     }
 51 | 
 52 |     /**
 53 |      * Test the if a SinglyLinkedList is a palindrome
 54 |      *
 55 |      * @dataProvider provideNodes
 56 |      */
 57 |     public function testIsPalindrome($node, $expected): void
 58 |     {
 59 |         $this->assertEquals($expected, $this->isPalindrome($node));
 60 |     }
 61 | 
 62 |     /**
 63 |      * Supporting method for testing if a linked list is palindrome
 64 |      */
 65 |     private function isPalindrome(SinglyLinkedList $node): bool
 66 |     {
 67 |         $length = $this->length($node);
 68 |         $pairs = 0;
 69 |         $curr = $node;
 70 | 
 71 |         while ($curr instanceof SinglyLinkedList) {
 72 |             if ($this->hasPair($curr->next, $curr->data)) {
 73 |                 $pairs++;
 74 |             }
 75 | 
 76 |             $curr = $curr->next;
 77 |         }
 78 | 
 79 |         return $pairs == floor($length / 2);
 80 |     }
 81 | 
 82 |     /**
 83 |      * Supporting method for testing if a linked list is palindrome
 84 |      */
 85 |     private function hasPair($node, string $data): bool
 86 |     {
 87 |         if (! $node instanceof SinglyLinkedList) {
 88 |             return false;
 89 |         }
 90 | 
 91 |         $curr = $node;
 92 | 
 93 |         while ($curr instanceof SinglyLinkedList) {
 94 |             if ($curr->data == $data) {
 95 |                 return true;
 96 |             }
 97 | 
 98 |             $curr = $curr->next;
 99 |         }
100 | 
101 |         return false;
102 |     }
103 | 
104 |     /**
105 |      * Supporting method for testing if a linked list is palindrome
106 |      */
107 |     private function length(SinglyLinkedList $node): int
108 |     {
109 |         $curr = $node;
110 |         $counter = 0;
111 | 
112 |         while ($curr instanceof SinglyLinkedList) {
113 |             $counter++;
114 |             $curr = $curr->next;
115 |         }
116 | 
117 |         return $counter;
118 |     }
119 | 
120 |     /**
121 |      * Test SinglyLinkedList's delete functionality
122 |      */
123 |     public function testDelete(): void
124 |     {
125 |         $this->assertEquals(
126 |             $this->createNode('hanah'), // expected node
127 |             $this->createNode('hannah')->delete('n'), // actual node
128 |         );
129 | 
130 |         $this->assertNotEquals(
131 |             $this->createNode('hanah'), // expected node
132 |             $this->createNode('hannah')->delete('h'), // actual node
133 |         );
134 |     }
135 | }
136 | 


--------------------------------------------------------------------------------
/tests/DataStructures/StackTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | use PHPUnit\Framework\TestCase;
  4 | 
  5 | require_once __DIR__ . '/../../vendor/autoload.php';
  6 | require_once __DIR__ . '/../../DataStructures/Stack.php';
  7 | 
  8 | class StackTest extends TestCase
  9 | {
 10 |     public function testConstruct()
 11 |     {
 12 |         $stack = new Stack([1, 2, 3]);
 13 |         $this->assertEquals([1, 2, 3], $stack->toArray());
 14 |     }
 15 | 
 16 |     public function testDestruct()
 17 |     {
 18 |         $stack = new Stack([1, 2, 3]);
 19 |         unset($stack);
 20 |         $this->expectNotToPerformAssertions();
 21 |     }
 22 | 
 23 |     public function testPush()
 24 |     {
 25 |         $stack = new Stack();
 26 |         $stack->push(1);
 27 |         $stack->push(2);
 28 |         $stack->push(3);
 29 |         $this->assertEquals([1, 2, 3], $stack->toArray());
 30 |     }
 31 | 
 32 |     public function testPop()
 33 |     {
 34 |         $stack = new Stack([1, 2, 3]);
 35 |         $this->assertEquals(3, $stack->pop());
 36 |         $this->assertEquals([1, 2], $stack->toArray());
 37 |     }
 38 | 
 39 |     public function testPeek()
 40 |     {
 41 |         $stack = new Stack([1, 2, 3]);
 42 |         $this->assertEquals(3, $stack->peek());
 43 |     }
 44 | 
 45 |     public function testIsEmpty()
 46 |     {
 47 |         $stack = new Stack();
 48 |         $this->assertTrue($stack->isEmpty());
 49 |     }
 50 | 
 51 |     public function testPrint()
 52 |     {
 53 |         $stack = new Stack([1, 2, 3]);
 54 |         $this->expectOutputString("1, 2, 3");
 55 |         $stack->print();
 56 |     }
 57 | 
 58 |     public function testToString()
 59 |     {
 60 |         $stack = new Stack([1, 2, 3]);
 61 |         $this->expectOutputString("1, 2, 3");
 62 |         echo $stack;
 63 |     }
 64 | 
 65 |     public function testLength()
 66 |     {
 67 |         $stack = new Stack([1, 2, 3]);
 68 |         $this->assertEquals(3, $stack->length());
 69 |     }
 70 | 
 71 |     public function testClear()
 72 |     {
 73 |         $stack = new Stack([1, 2, 3]);
 74 |         $stack->clear();
 75 |         $this->assertEquals([], $stack->toArray());
 76 |     }
 77 | 
 78 |     public function testSearch()
 79 |     {
 80 |         $stack = new Stack([1, 2, 3]);
 81 |         $this->assertEquals(2, $stack->search(3));
 82 |     }
 83 | 
 84 |     public function testToArray()
 85 |     {
 86 |         $stack = new Stack([1, 2, 3]);
 87 |         $this->assertEquals([1, 2, 3], $stack->toArray());
 88 |     }
 89 | 
 90 |     public function testFromArray()
 91 |     {
 92 |         $stack = new Stack();
 93 |         $stack->fromArray([1, 2, 3]);
 94 |         $this->assertEquals([1, 2, 3], $stack->toArray());
 95 |     }
 96 | 
 97 |     public function testReverse()
 98 |     {
 99 |         $stack = new Stack([1, 2, 3]);
100 |         $stack->reverse();
101 |         $this->assertEquals([3, 2, 1], $stack->toArray());
102 |     }
103 | 
104 |     public function testSort()
105 |     {
106 |         $stack = new Stack([3, 2, 1]);
107 |         $stack->sort();
108 |         $this->assertEquals([1, 2, 3], $stack->toArray());
109 |     }
110 | }
111 | 


--------------------------------------------------------------------------------
/tests/Graphs/BellmanFordTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | require_once __DIR__ . '/../../vendor/autoload.php';
 4 | require_once __DIR__ . '/../../Graphs/GraphEdge.php';
 5 | require_once __DIR__ . '/../../Graphs/BellmanFord.php';
 6 | 
 7 | use PHPUnit\Framework\TestCase;
 8 | 
 9 | class BellmanFordTest extends TestCase
10 | {
11 |     public function testBellmanFord()
12 |     {
13 |         $edgesRaw = [
14 |             ['S', 8, 'E'],
15 |             ['E', 1, 'D'],
16 |             ['D', -1, 'C'],
17 |             ['S', 10, 'A'],
18 |             ['D', -4, 'A'],
19 |             ['A', 2, 'C'],
20 |             ['C', -2, 'B'],
21 |             ['B', 1, 'A'],
22 |         ];
23 |         $vertices = ['S', 'A', 'B', 'C', 'D', 'E',];
24 | 
25 |         #prepare array of edges listed by edge start to simplify Bellman-Ford updating weights of other edges
26 |         $edges = [];
27 |         foreach ($edgesRaw as $edgeRaw) {
28 |             $edge = new GraphEdge();
29 |             $edge->start = $edgeRaw[0];
30 |             $edge->end = $edgeRaw[2];
31 |             $edge->weight = $edgeRaw[1];
32 |             if (!isset($edges[$edgeRaw[0]])) {
33 |                 $edges[$edgeRaw[0]] = [];
34 |             }
35 |             $edges[$edgeRaw[0]][] = $edge;
36 |         }
37 | 
38 |         $result = bellmanFord($vertices, $edges, 'S');
39 | 
40 |         $this->assertEquals(
41 |             [
42 |                 'S' => 0,
43 |                 'A' => 5,
44 |                 'B' => 5,
45 |                 'C' => 7,
46 |                 'D' => 9,
47 |                 'E' => 8
48 |             ],
49 |             $result
50 |         );
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/tests/Graphs/BreadthFirstSearchTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | require_once __DIR__ . '/../../vendor/autoload.php';
 4 | require_once __DIR__ . '/../../Graphs/BreadthFirstSearch.php';
 5 | 
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class BreadthFirstSearchTest extends TestCase
 9 | {
10 |     public function testBreadthFirstSearch()
11 |     {
12 |         $graph = array(
13 |             "A" => ["B", "C", "D"],
14 |             "B" => ["A", "D", "E"],
15 |             "C" => ["A", "F"],
16 |             "D" => ["B", "D"],
17 |             "E" => ["B", "F"],
18 |             "F" => ["C", "E", "G"],
19 |             "G" => ["F"],
20 |         );
21 |         $ans = bfs($graph, "A", "F");
22 |         $this->assertTrue($ans);
23 |     }
24 |     public function testBreadthFirstSearch2()
25 |     {
26 |         $graph = array(
27 |             [1, 2],
28 |             [2],
29 |             [0, 3],
30 |             [3],
31 |         );
32 | 
33 |         $ans2 = bfs($graph, 3, 0);
34 |         $this->assertFalse($ans2);
35 |     }
36 |     public function testBreadthFirstSearch3()
37 |     {
38 |         $graph = array(
39 |             [2, 3, 1],
40 |             [0],
41 |             [0, 4],
42 |             [0],
43 |             [2],
44 |         );
45 |         $ans = bfs($graph, 0, 3);
46 |         $this->assertTrue($ans);
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/tests/Graphs/DepthFirstSearchTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | require_once __DIR__ . '/../../vendor/autoload.php';
 4 | require_once __DIR__ . '/../../Graphs/DepthFirstSearch.php';
 5 | 
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class DepthFirstSearchTest extends TestCase
 9 | {
10 |     public function testDepthFirstSearch()
11 |     {
12 |         $graph = array(
13 |             "A" => ["B", "C", "D"],
14 |             "B" => ["A", "D", "E"],
15 |             "C" => ["A", "F"],
16 |             "D" => ["B", "D"],
17 |             "E" => ["B", "F"],
18 |             "F" => ["C", "E", "G"],
19 |             "G" => ["F"],
20 |         );
21 |         $visited = dfs($graph, "A");
22 |         $this->assertEquals(["A", "B", "D", "E", "F", "C", "G"], $visited);
23 |     }
24 |     public function testDepthFirstSearch2()
25 |     {
26 |         $graph = array(
27 |             [1, 2],
28 |             [2],
29 |             [0, 3],
30 |             [3],
31 |         );
32 | 
33 |         $visited = dfs($graph, 2);
34 |         $this->assertEquals([2, 0, 1, 3], $visited);
35 |     }
36 |     public function testDepthFirstSearch3()
37 |     {
38 |         $graph = array(
39 |             [2, 3, 1],
40 |             [0],
41 |             [0, 4],
42 |             [0],
43 |             [2],
44 |         );
45 |         $visited = dfs($graph, 0);
46 |         $this->assertEquals([0, 2, 4, 3, 1], $visited);
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/tests/Graphs/DijkstrasTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Graphs;
 4 | 
 5 | require_once __DIR__ . '/../../vendor/autoload.php';
 6 | require_once __DIR__ . '/../../Graphs/GraphEdge.php';
 7 | require_once __DIR__ . '/../../Graphs/Dijkstras.php';
 8 | 
 9 | use GraphEdge;
10 | use PHPUnit\Framework\TestCase;
11 | 
12 | class DijkstrasTest extends TestCase
13 | {
14 |     public function testDijkstras()
15 |     {
16 |         $edgesRaw = [
17 |             ['S', 8, 'E'],
18 |             ['E', 1, 'D'],
19 |             ['D', -1, 'C'],
20 |             ['S', 10, 'A'],
21 |             ['D', -4, 'A'],
22 |             ['A', 2, 'C'],
23 |             ['C', -2, 'B'],
24 |             ['B', 1, 'A'],
25 |         ];
26 |         $vertices = ['S', 'A', 'B', 'C', 'D', 'E',];
27 | 
28 |         #prepare array of edges listed by edge start to simplify Dijkstra's updating weights of other edges
29 |         $edges = [];
30 |         foreach ($edgesRaw as $edgeRaw) {
31 |             $edge = new GraphEdge();
32 |             $edge->start = $edgeRaw[0];
33 |             $edge->end = $edgeRaw[2];
34 |             $edge->weight = $edgeRaw[1];
35 |             $edges[] = $edge;
36 |         }
37 | 
38 |         $result = dijkstras($vertices, $edges, 'S');
39 | 
40 |         $this->assertEquals(
41 |             [
42 |                 'S' => 0,
43 |                 'A' => 5,
44 |                 'B' => 5,
45 |                 'C' => 7,
46 |                 'D' => 9,
47 |                 'E' => 8
48 |             ],
49 |             $result
50 |         );
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/tests/Maths/EratosthenesSieveTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | require_once __DIR__ . '/../../vendor/autoload.php';
 4 | require_once __DIR__ . '/../../Maths/EratosthenesSieve.php';
 5 | 
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class EratosthenesSieveTest extends TestCase
 9 | {
10 |     public function testEratosthenesSieve()
11 |     {
12 |         $result = eratosthenesSieve(30);
13 | 
14 |         $this->assertEquals($result, [1, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29]);
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/tests/Maths/ProjectEulerTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use PHPUnit\Framework\TestCase;
 4 | 
 5 | require_once __DIR__ . '/../../vendor/autoload.php';
 6 | require_once __DIR__ . '/../../Maths/ProjectEuler/Problem1.php';
 7 | require_once __DIR__ . '/../../Maths/ProjectEuler/Problem2.php';
 8 | require_once __DIR__ . '/../../Maths/ProjectEuler/Problem3.php';
 9 | require_once __DIR__ . '/../../Maths/ProjectEuler/Problem4.php';
10 | require_once __DIR__ . '/../../Maths/ProjectEuler/Problem5.php';
11 | require_once __DIR__ . '/../../Maths/ProjectEuler/Problem6.php';
12 | require_once __DIR__ . '/../../Maths/ProjectEuler/Problem7.php';
13 | require_once __DIR__ . '/../../Maths/ProjectEuler/Problem8.php';
14 | require_once __DIR__ . '/../../Maths/ProjectEuler/Problem9.php';
15 | require_once __DIR__ . '/../../Maths/ProjectEuler/Problem10.php';
16 | require_once __DIR__ . '/../../Maths/ProjectEuler/Problem11.php';
17 | 
18 | class ProjectEulerTest extends TestCase
19 | {
20 |     public function testProblem1(): void
21 |     {
22 |         $this->assertSame(233168, problem1a());
23 |         $this->assertSame(233168, problem1b());
24 |     }
25 | 
26 |     public function testProblem2(): void
27 |     {
28 |         $this->assertSame(4613732, problem2());
29 |     }
30 | 
31 |     public function testProblem3(): void
32 |     {
33 |         $this->assertSame(6857, problem3());
34 |     }
35 | 
36 |     public function testProblem4(): void
37 |     {
38 |         $this->assertSame(906609, problem4());
39 |     }
40 | 
41 |     public function testProblem5(): void
42 |     {
43 |         $this->assertSame(232792560, problem5());
44 |     }
45 | 
46 |     public function testProblem6(): void
47 |     {
48 |         $this->assertSame(25164150, problem6());
49 |     }
50 | 
51 |     public function testProblem7(): void
52 |     {
53 |         $this->assertSame(104743, problem7());
54 |     }
55 | 
56 |     public function testProblem8(): void
57 |     {
58 |         $this->assertSame(23514624000, problem8());
59 |     }
60 | 
61 |     public function testProblem9(): void
62 |     {
63 |         $this->assertSame(31875000, problem9());
64 |     }
65 | 
66 |     public function testProblem10(): void
67 |     {
68 |         $this->assertSame(142913828922, problem10());
69 |     }
70 | 
71 |     public function testProblem11(): void
72 |     {
73 |         $this->assertSame(70600674, problem11());
74 |     }
75 | }
76 | 


--------------------------------------------------------------------------------
/tests/NeuralNetworks/PerceptronClassifier/NeuralNetworkPerceptronClassifierTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace NeuralNetworks\PerceptronClassifier;
 4 | 
 5 | require_once __DIR__ . '/../../../vendor/autoload.php';
 6 | require_once __DIR__ . '/../../../NeuralNetworks/PerceptronClassifier/NeuralNetworkPerceptronClassifier.php';
 7 | 
 8 | use PHPUnit\Framework\TestCase;
 9 | 
10 | class NeuralNetworkPerceptronClassifierTest extends TestCase
11 | {
12 |     public function testNeuralNetworkPerceptronClassification()
13 |     {
14 |         $nnClassifier = new NeuralNetworkPerceptronClassifier();
15 |         [$X, $Y] = $nnClassifier->generateTrainingSet();
16 |         // Train the model
17 |         [$W, $b] = $nnClassifier->trainModel($X, $Y, 1000, 0.1);
18 | 
19 |         // Make predictions
20 |         $predictions = $nnClassifier->predict([[0, 0, 1, 1], [0, 1, 1, 0]], $W, $b);
21 |         $this->assertEquals([0, 0, 0, 1], $predictions);
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/tests/Sorting/ArrayKeysSortTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | require_once __DIR__ . '/../../vendor/autoload.php';
 4 | require_once __DIR__ . '/../../Sorting/ArrayKeysSort.php';
 5 | 
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class ArrayKeysSortTest extends TestCase
 9 | {
10 |     public function testArrayKeysSort()
11 |     {
12 |         //test array of arrays
13 |         $array1 = [
14 |             ['fruit' => 'banana', 'color' => 'yellow', 'cant' => 5],
15 |             ['fruit' => 'apple', 'color' => 'red', 'cant' => 2],
16 |             ['fruit' => 'apple', 'color' => 'green', 'cant' => 7],
17 |             ['fruit' => 'grapes', 'color' => 'purple', 'cant' => 4],
18 |         ];
19 | 
20 |         $result1 = [
21 |             ['fruit' => 'apple', 'color' => 'red', 'cant' => 2],
22 |             ['fruit' => 'grapes', 'color' => 'purple', 'cant' => 4],
23 |             ['fruit' => 'banana', 'color' => 'yellow', 'cant' => 5],
24 |             ['fruit' => 'apple', 'color' => 'green', 'cant' => 7],
25 |         ];
26 |         $result2 = [
27 |             ['fruit' => 'apple', 'color' => 'green', 'cant' => 7],
28 |             ['fruit' => 'apple', 'color' => 'red', 'cant' => 2],
29 |             ['fruit' => 'banana', 'color' => 'yellow', 'cant' => 5],
30 |             ['fruit' => 'grapes', 'color' => 'purple', 'cant' => 4],
31 |         ];
32 | 
33 |         $test1 = arrayKeysSort::sort($array1, ['cant']);
34 |         $test2 = arrayKeysSort::sort($array1, ['fruit', 'color']);
35 | 
36 |         $this->assertEquals($result1, $test1);
37 |         $this->assertEquals($result2, $test2);
38 | 
39 |         //test array of objects
40 |         $object1 = new \stdClass();
41 |         $object1->fruit = 'banana';
42 |         $object1->color = 'yellow';
43 |         $object1->cant = 5;
44 | 
45 |         $object2 = new \stdClass();
46 |         $object2->fruit = 'apple';
47 |         $object2->color = 'red';
48 |         $object2->cant = 2;
49 | 
50 |         $object3 = new \stdClass();
51 |         $object3->fruit = 'apple';
52 |         $object3->color = 'green';
53 |         $object3->cant = 7;
54 | 
55 |         $object4 = new \stdClass();
56 |         $object4->fruit = 'grapes';
57 |         $object4->color = 'purple';
58 |         $object4->cant = 4;
59 | 
60 |         $array2 = [$object1, $object2, $object3, $object4];
61 | 
62 |         $result3 = [$object2, $object4, $object1, $object3];
63 |         $result4 = [$object3, $object2, $object1, $object4];
64 | 
65 |         $test3 = arrayKeysSort::sort($array2, ['cant']);
66 |         $test4 = arrayKeysSort::sort($array2, ['fruit', 'color']);
67 | 
68 |         $this->assertEquals($result3, $test3);
69 |         $this->assertEquals($result4, $test4);
70 |     }
71 | }
72 | 


--------------------------------------------------------------------------------
/tests/Sorting/GnomeSortTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | require_once __DIR__ . '/../../vendor/autoload.php';
 4 | require_once __DIR__ . '/../../Sorting/GnomeSort.php';
 5 | 
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class GnomeSortTest extends TestCase
 9 | {
10 |     public function testGnomeSort()
11 |     {
12 |         $array = array(3, 0, 2, 5, -1, 4, 1);
13 |         $sorted = gnomeSort($array);
14 |         $this->assertEquals([-1, 0, 1, 2, 3, 4, 5], $sorted);
15 |     }
16 | 
17 |     public function testGnomeSort2()
18 |     {
19 |         $array = array(8, -50, 1, 90, 35, 47, 69, -5);
20 |         $sorted = gnomeSort($array);
21 |         $this->assertEquals([-50, -5, 1, 8, 35, 47, 69, 90], $sorted);
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/tests/Sorting/ShellSortTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Sorting;
 4 | 
 5 | use PHPUnit\Framework\TestCase;
 6 | 
 7 | require_once __DIR__ . '/../../vendor/autoload.php';
 8 | require_once __DIR__ . '/../../Sorting/ShellSort.php';
 9 | 
10 | class ShellSortTest extends TestCase
11 | {
12 |     public function testShellSort()
13 |     {
14 |         $array = [
15 |             51158, 1856, 8459, 67957, 59748, 58213, 90876, 39621, 66570, 64204, 79935, 27892, 47615, 94706, 34201,
16 |             74474, 63968, 4337, 43688, 42685, 31577, 5239, 25385, 56301, 94083, 23232, 67025, 44044, 74813, 34671,
17 |             90235, 65764, 49709, 12440, 21165, 20620, 38265, 12973, 25236, 93144, 13720, 4204, 77026, 42348, 19756,
18 |             97222, 78828, 73437, 48208, 69858, 19713, 29411, 49809, 66174, 5257, 43340, 40565, 9592, 52328, 16677,
19 |             38386, 55416, 99519, 13732, 84076, 52905, 47662, 31805, 46184, 2811, 35374, 50800, 53635, 51886, 49052,
20 |             75197, 3720, 75045, 28309, 63771, 71526, 16122, 36625, 44654, 86814, 98845, 44637, 54955, 24714, 81960,
21 |             78095, 49048, 99711, 272, 45755, 31919, 8181, 1392, 15352, 82656, 27760, 18362, 43780, 50209, 51433, 2847,
22 |             62310, 87450, 22874, 40789, 56841, 52928, 5523, 76474, 8935, 63245, 16387, 21746, 47596, 84402, 49168,
23 |             58223, 26993, 55908, 92837, 64208, 86309, 30819, 83638, 9508, 44628, 10786, 68125, 14123, 70474, 50596,
24 |             44518, 74872, 61968, 36828, 17860, 4605, 68756, 86070, 52068, 51830, 56992, 45799, 42422, 68514, 92559,
25 |             40206, 31263, 71774, 14202, 94807, 25774, 15003, 54211, 18708, 32074, 43836, 48964, 40742, 26281, 67338,
26 |             75786, 34925, 34649, 45519, 72472, 80188, 40858, 83246, 92215, 66178, 67452, 86198, 82300, 45894, 97156,
27 |             73907, 31159, 7018, 55549, 35245, 68975, 88246, 14098, 59973, 7762, 40459, 86358, 63178, 47489, 55515,
28 |             79488, 46528, 99272, 10867, 75190, 56963, 5520, 56494, 42310, 40171, 78105, 29724, 30110, 28493, 36141,
29 |             22479, 85799, 70466, 92106, 16868, 57402, 4813, 47432, 24689, 78533, 97577, 32178, 30258, 82785, 56063,
30 |             76277, 96407, 77849, 1807, 45344, 30298, 18158, 49935, 90728, 22192, 36852, 33982, 66206, 30948, 40372,
31 |             33446, 99156, 28651, 61591, 79028, 1689, 94257, 32158, 11122, 81097, 57981, 26277, 7515, 7873, 8350, 28229,
32 |             24105, 76818, 86897, 18456, 29373, 7853, 24932, 93070, 4696, 63015, 9358, 28302, 3938, 11754, 33679, 18492,
33 |             91503, 63395, 12029, 23954, 27230, 58336, 16544, 23606, 61349, 37348, 78629, 96145, 57954, 32392, 76201,
34 |             54616, 59992, 5676, 97799, 47910, 98758, 75043, 72849, 6466, 68831, 2246, 69091, 22296, 6506, 93729, 86968,
35 |             39583, 46186, 96782, 19074, 46574, 46704, 99211, 55295, 33963, 77977, 86805, 72686
36 |         ];
37 |         $sorted = shellSort($array);
38 |         $this->assertEquals([
39 |             272, 1392, 1689, 1807, 1856, 2246, 2811, 2847, 3720, 3938, 4204, 4337, 4605, 4696, 4813, 5239, 5257, 5520,
40 |             5523, 5676, 6466, 6506, 7018, 7515, 7762, 7853, 7873, 8181, 8350, 8459, 8935, 9358, 9508, 9592, 10786,
41 |             10867, 11122, 11754, 12029, 12440, 12973, 13720, 13732, 14098, 14123, 14202, 15003, 15352, 16122, 16387,
42 |             16544, 16677, 16868, 17860, 18158, 18362, 18456, 18492, 18708, 19074, 19713, 19756, 20620, 21165, 21746,
43 |             22192, 22296, 22479, 22874, 23232, 23606, 23954, 24105, 24689, 24714, 24932, 25236, 25385, 25774, 26277,
44 |             26281, 26993, 27230, 27760, 27892, 28229, 28302, 28309, 28493, 28651, 29373, 29411, 29724, 30110, 30258,
45 |             30298, 30819, 30948, 31159, 31263, 31577, 31805, 31919, 32074, 32158, 32178, 32392, 33446, 33679, 33963,
46 |             33982, 34201, 34649, 34671, 34925, 35245, 35374, 36141, 36625, 36828, 36852, 37348, 38265, 38386, 39583,
47 |             39621, 40171, 40206, 40372, 40459, 40565, 40742, 40789, 40858, 42310, 42348, 42422, 42685, 43340, 43688,
48 |             43780, 43836, 44044, 44518, 44628, 44637, 44654, 45344, 45519, 45755, 45799, 45894, 46184, 46186, 46528,
49 |             46574, 46704, 47432, 47489, 47596, 47615, 47662, 47910, 48208, 48964, 49048, 49052, 49168, 49709, 49809,
50 |             49935, 50209, 50596, 50800, 51158, 51433, 51830, 51886, 52068, 52328, 52905, 52928, 53635, 54211, 54616,
51 |             54955, 55295, 55416, 55515, 55549, 55908, 56063, 56301, 56494, 56841, 56963, 56992, 57402, 57954, 57981,
52 |             58213, 58223, 58336, 59748, 59973, 59992, 61349, 61591, 61968, 62310, 63015, 63178, 63245, 63395, 63771,
53 |             63968, 64204, 64208, 65764, 66174, 66178, 66206, 66570, 67025, 67338, 67452, 67957, 68125, 68514, 68756,
54 |             68831, 68975, 69091, 69858, 70466, 70474, 71526, 71774, 72472, 72686, 72849, 73437, 73907, 74474, 74813,
55 |             74872, 75043, 75045, 75190, 75197, 75786, 76201, 76277, 76474, 76818, 77026, 77849, 77977, 78095, 78105,
56 |             78533, 78629, 78828, 79028, 79488, 79935, 80188, 81097, 81960, 82300, 82656, 82785, 83246, 83638, 84076,
57 |             84402, 85799, 86070, 86198, 86309, 86358, 86805, 86814, 86897, 86968, 87450, 88246, 90235, 90728, 90876,
58 |             91503, 92106, 92215, 92559, 92837, 93070, 93144, 93729, 94083, 94257, 94706, 94807, 96145, 96407, 96782,
59 |             97156, 97222, 97577, 97799, 98758, 98845, 99156, 99211, 99272, 99519, 99711
60 |         ], $sorted);
61 |     }
62 | 
63 |     public function testShellSortWithEmptyInput()
64 |     {
65 |         $array = [];
66 |         $sorted = shellSort($array);
67 |         $this->assertEmpty($sorted);
68 |     }
69 | 
70 |     public function testShellSortPerformance()
71 |     {
72 |         $array = range(1, 10000);
73 |         $n = count($array);
74 |         shuffle($array);  // Randomize the order
75 |         $start = microtime(true);
76 |         shellSort($array);
77 |         $end = microtime(true);
78 |         $this->assertLessThan(pow($n, 3 / 2), $end - $start);
79 |     }
80 | }
81 | 


--------------------------------------------------------------------------------
/tests/Strings/StringsTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use PHPUnit\Framework\TestCase;
 4 | 
 5 | require_once __DIR__ . '/../../vendor/autoload.php';
 6 | 
 7 | require_once __DIR__ . '/../../Strings/CheckAnagram.php';
 8 | require_once __DIR__ . '/../../Strings/CheckPalindrome.php';
 9 | require_once __DIR__ . '/../../Strings/CheckPalindrome2.php';
10 | require_once __DIR__ . '/../../Strings/CountConsonants.php';
11 | require_once __DIR__ . '/../../Strings/CountHomogenous.php';
12 | require_once __DIR__ . '/../../Strings/CountSentences.php';
13 | require_once __DIR__ . '/../../Strings/CountVowels.php';
14 | require_once __DIR__ . '/../../Strings/Distance.php';
15 | require_once __DIR__ . '/../../Strings/MaxCharacter.php';
16 | require_once __DIR__ . '/../../Strings/ReverseString.php';
17 | require_once __DIR__ . '/../../Strings/ReverseWords.php';
18 | 
19 | class StringsTest extends TestCase
20 | {
21 |     public function testIsPalindrome()
22 |     {
23 |         $this->assertTrue(isPalindrome('MaDam')); // true
24 |         $this->assertFalse(isPalindrome('ThisIsTest')); // false
25 |         $this->assertFalse(isPalindrome('')); // false
26 |         $this->assertTrue(isPalindrome('Sator Arepo Tenet Opera Rotas')); // true
27 |         $this->assertFalse(isPalindrome('Sator Arepo Tenet Opera Rotas', false)); // false since we are doing
28 |         // case-sensitive check
29 |     }
30 | 
31 |     public function testCountSentences()
32 |     {
33 |         $this->assertEquals(2, countSentences('Hi! Hello world.'));
34 |         $this->assertEquals(2, countSentences('i am testing. test....'));
35 |         $this->assertEquals(1, countSentences('How are you?'));
36 |     }
37 | 
38 |     public function testReverseString()
39 |     {
40 |         $this->assertEquals('txet emos si sihT', reverseString('This is some text'));
41 |         $this->assertEquals('mADaM', reverseString('MaDAm'));
42 |         $this->assertNotEquals('MaDAm', reverseString('MaDAm'));
43 |     }
44 | 
45 |     public function testReverseWords()
46 |     {
47 |         $this->assertEquals('Fun is Coding PHP', reverseWords('PHP Coding is Fun'));
48 |         $this->assertEquals('OneWord', reverseWords('OneWord'));
49 |         $this->assertEquals('Text different some is This', reverseWords('This is some different Text'));
50 |     }
51 | 
52 |     public function testIsAnagram()
53 |     {
54 |         $this->assertTrue(isAnagram("php", "PHP")); // By default it's case-insensitive
55 |         $this->assertFalse(isAnagram("php", "PHP", false)); // Make case-sensitive check
56 |         $this->assertTrue(isAnagram("php is fun", "pin hpf us"));
57 |         $this->assertFalse(isAnagram("Hello", " Hello")); //Extra space character
58 |         $this->assertTrue(isAnagram("ScRamble", "SRlmcaeb", false)); // Check with a mixture of upper and lower case
59 |     }
60 | 
61 |     public function testMaxCharacter()
62 |     {
63 |         $this->assertEquals('t', maxCharacter("this is test for max character repetition"));
64 |         $this->assertEquals('t', maxCharacter("This is Test for max characTer repetition"));
65 |         $this->assertEquals(' ', maxCharacter("           "));
66 |     }
67 | 
68 |     public function testCountVowels()
69 |     {
70 |         $this->assertEquals(7, countVowelsSimple("This is a string with 7 vowels"));
71 |         $this->assertEquals(3, countVowelsSimple("hello world"));
72 |         $this->assertEquals(16, countVowelsRegex("Just A list of somE aaaaaaaaaa"));
73 | 
74 |         $this->assertEquals(7, countVowelsRegex("This is a string with 7 vowels"));
75 |         $this->assertEquals(3, countVowelsRegex("hello world"));
76 |         $this->assertEquals(16, countVowelsRegex("Just A list of somE aaaaaaaaaa"));
77 |     }
78 | 
79 |     public function testCountConsonants()
80 |     {
81 |         $this->assertEquals(19, countConsonants("This is a string with 19 consonants"));
82 |         $this->assertEquals(7, countConsonants("hello world"));
83 |         $this->assertEquals(9, countConsonants("Just A list of somE aaaaaaaaaa"));
84 |     }
85 |     public function testCountHomogenous()
86 |     {
87 |         $this->assertEquals(4, countHomogenous("abbcccaa"));
88 |         $this->assertEquals(2, countHomogenous("xy"));
89 |     }
90 | 
91 |     public function testFindDistance()
92 |     {
93 |         $this->assertEquals(1, findDistance("hello", "hallo"));
94 |         $this->assertEquals(1, findDistance("hallo", "hello"));
95 |         $this->assertEquals(0, findDistance("sunday", "sunday"));
96 |         $this->assertEquals(3, findDistance("saturday", "sunday"));
97 |     }
98 | }
99 | 


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