mirror of
https://github.com/TheAlgorithms/PHP.git
synced 2025-07-10 11:36:21 +02:00
Merge pull request #122 from salehhashemi1992/ci/setup-code-style-check
Implement PSR-12 Coding Standards and Add CS Check to CI Flow
This commit is contained in:
Brandon Johnson
GitHub
25
.github/workflows/code-style.yml
vendored
Normal file
25
.github/workflows/code-style.yml
vendored
Normal file
@ -0,0 +1,25 @@
|
||||
name: Code style
|
||||
|
||||
on: [push, pull_request]
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
|
||||
jobs:
|
||||
phpcs:
|
||||
name: PHPCS
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- name: Checkout
|
||||
uses: actions/checkout@v3
|
||||
|
||||
- name: Setup PHP
|
||||
uses: shivammathur/setup-php@v2
|
||||
with:
|
||||
php-version: '7.4'
|
||||
|
||||
- name: Install dependencies
|
||||
run: composer update --prefer-dist --no-progress --no-suggest
|
||||
|
||||
- name: Run script
|
||||
run: vendor/bin/phpcs -n
|
||||
3
.gitignore
vendored
3
.gitignore
vendored
@ -4,4 +4,7 @@
|
||||
.phan
|
||||
composer.lock
|
||||
|
||||
/.phpcs-cache
|
||||
/phpcs.xml
|
||||
|
||||
.phpunit.result.cache
|
||||
@ -3,8 +3,8 @@
|
||||
/**
|
||||
* Encrypt given text using caesar cipher.
|
||||
*
|
||||
* @param string text text to be encrypted
|
||||
* @param int shift number of shifts to be applied
|
||||
* @param string $text text text to be encrypted
|
||||
* @param int $shift shift number of shifts to be applied
|
||||
* @return string new encrypted text
|
||||
*/
|
||||
function encrypt(string $text, int $shift): string
|
||||
@ -27,8 +27,8 @@ function encrypt(string $text, int $shift): string
|
||||
|
||||
/**
|
||||
* Decrypt given text using caesar cipher.
|
||||
* @param string text text to be decrypted
|
||||
* @param int shift number of shifts to be applied
|
||||
* @param string $text text text to be decrypted
|
||||
* @param int $shift shift number of shifts to be applied
|
||||
* @return string new decrypted text
|
||||
*/
|
||||
function decrypt(string $text, int $shift): string
|
||||
|
||||
@ -1,32 +1,37 @@
|
||||
<?php
|
||||
|
||||
// A mono-alphabetic cipher is a simple substitution cipher
|
||||
// https://www.101computing.net/mono-alphabetic-substitution-cipher/
|
||||
|
||||
function monoAlphabeticCipher($key, $alphabet, $text){
|
||||
|
||||
function monoAlphabeticCipher($key, $alphabet, $text)
|
||||
{
|
||||
$cipherText = ''; // the cipher text (can be decrypted and encrypted)
|
||||
|
||||
if ( strlen($key) != strlen($alphabet) ) { return false; } // check if the text length matches
|
||||
// check if the text length matches
|
||||
if (strlen($key) != strlen($alphabet)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
$text = preg_replace('/[0-9]+/', '', $text); // remove all the numbers
|
||||
|
||||
for ($i = 0; $i < strlen($text); $i++) {
|
||||
$index = strripos($alphabet, $text[$i]);
|
||||
if( $text[$i] == " " ){ $cipherText .= " "; }
|
||||
else{ $cipherText .= ( ctype_upper($text[$i]) ? strtoupper($key[$index]) : $key[$index] ); }
|
||||
if ($text[$i] == " ") {
|
||||
$cipherText .= " ";
|
||||
} else {
|
||||
$cipherText .= ( ctype_upper($text[$i]) ? strtoupper($key[$index]) : $key[$index] );
|
||||
}
|
||||
}
|
||||
|
||||
return $cipherText;
|
||||
}
|
||||
|
||||
function maEncrypt($key, $alphabet, $text){
|
||||
|
||||
function maEncrypt($key, $alphabet, $text)
|
||||
{
|
||||
return monoAlphabeticCipher($key, $alphabet, $text);
|
||||
|
||||
}
|
||||
|
||||
function maDecrypt($key, $alphabet, $text){
|
||||
|
||||
function maDecrypt($key, $alphabet, $text)
|
||||
{
|
||||
return monoAlphabeticCipher($alphabet, $key, $text);
|
||||
|
||||
}
|
||||
|
||||
?>
|
||||
@ -3,8 +3,9 @@
|
||||
/**
|
||||
* Encode text to Morse Code.
|
||||
*
|
||||
* @param string text to encode
|
||||
* @param string $text text to encode
|
||||
* @return string encoded text
|
||||
* @throws \Exception
|
||||
*/
|
||||
function encode(string $text): string
|
||||
{
|
||||
@ -63,7 +64,8 @@ function encode(string $text): string
|
||||
|
||||
/**
|
||||
* Decode Morse Code to text.
|
||||
* @param string text to decode
|
||||
* @param string $text text to decode
|
||||
* @throws \Exception
|
||||
*/
|
||||
function decode(string $text): string
|
||||
{
|
||||
|
||||
@ -7,18 +7,16 @@
|
||||
* character with the key.
|
||||
* The key is repeated until it is the same length as the input.
|
||||
*
|
||||
* @param string $input The input string.
|
||||
* @param string $input_string The input string.
|
||||
* @param string $key The key to use.
|
||||
* @return string The encrypted string.
|
||||
*/
|
||||
function xorCipher(string $input_string, string $key)
|
||||
{
|
||||
|
||||
$key_len = strlen($key);
|
||||
$result = array();
|
||||
|
||||
for ($idx = 0; $idx < strlen($input_string); $idx++)
|
||||
{
|
||||
for ($idx = 0; $idx < strlen($input_string); $idx++) {
|
||||
array_push($result, $input_string[$idx] ^ $key[$idx % $key_len]);
|
||||
}
|
||||
|
||||
|
||||
@ -13,6 +13,7 @@
|
||||
*
|
||||
* @param string $binaryNumber
|
||||
* @return int
|
||||
* @throws \Exception
|
||||
*/
|
||||
function binaryToDecimal($binaryNumber)
|
||||
{
|
||||
|
||||
@ -7,6 +7,7 @@
|
||||
*
|
||||
* @param string $decimalNumber
|
||||
* @return string
|
||||
* @throws \Exception
|
||||
*/
|
||||
function decimalToBinary($decimalNumber)
|
||||
{
|
||||
|
||||
@ -12,6 +12,7 @@
|
||||
* 9 base 10
|
||||
* @param string $octalNumber
|
||||
* @return int
|
||||
* @throws \Exception
|
||||
*/
|
||||
function octalToDecimal($octalNumber)
|
||||
{
|
||||
@ -36,6 +37,7 @@ function octalToDecimal($octalNumber)
|
||||
*
|
||||
* @param string $decimalNumber
|
||||
* @return string
|
||||
* @throws \Exception
|
||||
*/
|
||||
function decimalToOctal($decimalNumber)
|
||||
{
|
||||
|
||||
@ -17,7 +17,8 @@
|
||||
* @param float $speed
|
||||
* @param string $unitFrom
|
||||
* @param string $unitTo
|
||||
* @return int
|
||||
* @return float
|
||||
* @throws \Exception
|
||||
*/
|
||||
function convertSpeed(float $speed, string $unitFrom, string $unitTo)
|
||||
{
|
||||
|
||||
@ -1,8 +1,8 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* Singly Linked List
|
||||
*/
|
||||
|
||||
class SinglyLinkedList
|
||||
{
|
||||
public ?SinglyLinkedList $next = null;
|
||||
@ -16,7 +16,6 @@ class SinglyLinkedList
|
||||
public function append($data): void
|
||||
{
|
||||
$current = $this;
|
||||
|
||||
while ($current instanceof SinglyLinkedList && isset($current->next)) {
|
||||
$current = $current->next;
|
||||
}
|
||||
@ -27,7 +26,6 @@ class SinglyLinkedList
|
||||
public function delete($data): SinglyLinkedList
|
||||
{
|
||||
$current = $this;
|
||||
|
||||
if ($current->data == $data) {
|
||||
return $current->next;
|
||||
}
|
||||
@ -35,7 +33,6 @@ class SinglyLinkedList
|
||||
while ($current instanceof SinglyLinkedList && isset($current->next)) {
|
||||
if ($current->next->data === $data) {
|
||||
$current->next = $current->next->next;
|
||||
|
||||
return $this;
|
||||
}
|
||||
|
||||
|
||||
@ -1,10 +1,11 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* Breadth-first search (BFS) is an algorithm for searching a tree data structure for a node that satisfies a given property.
|
||||
* Breadth-first search (BFS) is an algorithm for searching a tree data structure for a node that satisfies
|
||||
* a given property.
|
||||
* (https://en.wikipedia.org/wiki/Breadth-first_search).
|
||||
*
|
||||
* This is a non recursive implementation.
|
||||
* This is a non-recursive implementation.
|
||||
*
|
||||
* References:
|
||||
* https://cp-algorithms.com/graph/breadth-first-search.html
|
||||
@ -17,7 +18,8 @@
|
||||
* @return bool if path between start and end vertex exists
|
||||
*/
|
||||
|
||||
function bfs($adjList, $start, $end, $yes = false){
|
||||
function bfs($adjList, $start, $end, $yes = false)
|
||||
{
|
||||
$visited = [];
|
||||
$queue = [$start];
|
||||
while (!empty($queue)) {
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
* The Depth-first Search is an algorithm used for traversing or searching trees or graphs
|
||||
* (https://en.wikipedia.org/wiki/Depth-first_search).
|
||||
*
|
||||
* This is a non recursive implementation.
|
||||
* This is a non-recursive implementation.
|
||||
*
|
||||
* References:
|
||||
* https://www.geeksforgeeks.org/depth-first-search-or-dfs-for-a-graph/
|
||||
@ -27,9 +27,10 @@ function dfs($adjList, $start)
|
||||
|
||||
// Checks each adjacent vertex of $v and add to the stack if not visited
|
||||
foreach (array_reverse($adjList[$v]) as $adj) {
|
||||
if (!array_key_exists($adj, $visited))
|
||||
if (!array_key_exists($adj, $visited)) {
|
||||
array_push($stack, $adj);
|
||||
}
|
||||
}
|
||||
}
|
||||
return array_keys($visited);
|
||||
}
|
||||
|
||||
@ -1,4 +1,5 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* This function calculates
|
||||
* Absolute max values from
|
||||
@ -7,6 +8,7 @@
|
||||
*
|
||||
* @param decimal $numbers A variable sized number input
|
||||
* @return decimal $absoluteMax Absolute max value
|
||||
* @throws \Exception
|
||||
*/
|
||||
function absolute_max(...$numbers)
|
||||
{
|
||||
|
||||
@ -1,4 +1,5 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* This function calculates
|
||||
* Absolute min values from
|
||||
@ -7,6 +8,7 @@
|
||||
*
|
||||
* @param decimal $numbers A variable sized number input
|
||||
* @return decimal $absoluteMin Absolute min value
|
||||
* @throws \Exception
|
||||
*/
|
||||
function absolute_min(...$numbers)
|
||||
{
|
||||
|
||||
@ -1,4 +1,5 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* This function checks if given number is Armstrong
|
||||
* e.g. 153
|
||||
@ -14,9 +15,7 @@ function isNumberArmstrong(int $input): bool
|
||||
}
|
||||
if ($sumOfCubes == $input) {
|
||||
return true;
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
?>
|
||||
|
||||
@ -1,4 +1,5 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* This function checks if given number is palindromic
|
||||
* e.g. 121
|
||||
@ -12,9 +13,7 @@ function isNumberPalindromic(int $input): bool
|
||||
$inputRev = (int)implode("", $arrRev);
|
||||
if ($input == $inputRev) {
|
||||
return true;
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
?>
|
||||
|
||||
@ -1,4 +1,5 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* This function check whether
|
||||
* the provided integer is a prime
|
||||
|
||||
@ -1,4 +1,5 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* This function calculates
|
||||
* and returns the factorial
|
||||
@ -7,6 +8,7 @@
|
||||
*
|
||||
* @param Integer $number Integer input
|
||||
* @return Integer Factorial of the input
|
||||
* @throws \Exception
|
||||
*/
|
||||
function factorial(int $number)
|
||||
{
|
||||
@ -15,15 +17,19 @@ function factorial(int $number)
|
||||
if ($number < 0) {
|
||||
throw new \Exception("Negative numbers are not allowed for calculating Factorial");
|
||||
}
|
||||
|
||||
// Factorial of 0 is 1
|
||||
if ($number === 0) {
|
||||
return 1; // Factorial of 0 is 1
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (isset($cache[$number])) {
|
||||
return $cache[$number];
|
||||
}
|
||||
|
||||
$fact = ($number * factorial($number - 1)); // Recursion since x! = x * (x-1)!
|
||||
// Recursion since x! = x * (x-1)!
|
||||
$fact = ($number * factorial($number - 1));
|
||||
|
||||
$cache[$number] = $fact;
|
||||
|
||||
return $fact;
|
||||
|
||||
@ -1,4 +1,5 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* This functions computes an exponent by doing repeated squares
|
||||
*
|
||||
|
||||
@ -4,7 +4,8 @@
|
||||
* Fibonacci recursive
|
||||
*
|
||||
* @param int $num
|
||||
* @return int
|
||||
* @return array
|
||||
* @throws \Exception
|
||||
*/
|
||||
function fibonacciRecursive(int $num)
|
||||
{
|
||||
@ -22,6 +23,7 @@ function fibonacciRecursive(int $num)
|
||||
/**
|
||||
* @param int $num
|
||||
* @return int
|
||||
* @throws \Exception
|
||||
*/
|
||||
function recursive(int $num)
|
||||
{
|
||||
@ -36,6 +38,9 @@ function recursive(int $num)
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @throws \Exception
|
||||
*/
|
||||
function fibonacciWithBinetFormula(int $num)
|
||||
{
|
||||
/*
|
||||
@ -57,7 +62,6 @@ function fibonacciWithBinetFormula(int $num)
|
||||
$seriesNumber = (pow($phi_1, $n) - pow($phi_2, $n)) / $sqrt;
|
||||
array_push($fib_series, (int)$seriesNumber);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
return $fib_series;
|
||||
|
||||
@ -10,8 +10,7 @@
|
||||
*/
|
||||
function loop($i, Generator $set)
|
||||
{
|
||||
while($i-- > 0 && $set->valid())
|
||||
{
|
||||
while ($i-- > 0 && $set->valid()) {
|
||||
yield $set->current();
|
||||
$set->next();
|
||||
}
|
||||
@ -25,8 +24,7 @@ function fib()
|
||||
yield $i = 0;
|
||||
yield $j = 1;
|
||||
|
||||
while(true)
|
||||
{
|
||||
while (true) {
|
||||
yield $k = $i + $j;
|
||||
$i = $j;
|
||||
$j = $k;
|
||||
@ -36,7 +34,6 @@ function fib()
|
||||
/*
|
||||
* Generate 100 Fibonacci numbers
|
||||
*/
|
||||
foreach(loop(100, fib()) as $item)
|
||||
{
|
||||
foreach (loop(100, fib()) as $item) {
|
||||
print($item . ',');
|
||||
}
|
||||
@ -1,4 +1,5 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* This function calculates
|
||||
* The mean value of
|
||||
@ -6,6 +7,7 @@
|
||||
*
|
||||
* @param decimal $numbers A variable sized number input
|
||||
* @return decimal $mean Mean of provided numbers
|
||||
* @throws \Exception
|
||||
*/
|
||||
function mean(...$numbers)
|
||||
{
|
||||
@ -14,7 +16,6 @@ function mean(...$numbers)
|
||||
}
|
||||
|
||||
$total = array_sum($numbers);
|
||||
$mean = $total / count($numbers);
|
||||
|
||||
return $mean;
|
||||
return $total / count($numbers);
|
||||
}
|
||||
@ -1,4 +1,5 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* This function calculates
|
||||
* The median value of
|
||||
@ -6,6 +7,7 @@
|
||||
*
|
||||
* @param decimal $numbers A variable sized number input
|
||||
* @return decimal $median Median of provided numbers
|
||||
* @throws \Exception
|
||||
*/
|
||||
function median(...$numbers)
|
||||
{
|
||||
@ -15,7 +17,6 @@ function median(...$numbers)
|
||||
|
||||
sort($numbers);
|
||||
$length = count($numbers);
|
||||
|
||||
$middle = ceil($length / 2);
|
||||
if ($length % 2 == 0) {
|
||||
return ($numbers[$middle] + $numbers[$middle - 1]) / 2;
|
||||
|
||||
@ -1,4 +1,5 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* This function calculates
|
||||
* the mode value(s) of
|
||||
@ -16,6 +17,5 @@ function mode(...$numbers)
|
||||
|
||||
$values = array_count_values($numbers);
|
||||
$maxCount = max($values);
|
||||
|
||||
return array_keys($values, $maxCount, true);
|
||||
}
|
||||
@ -1,4 +1,5 @@
|
||||
<?php
|
||||
|
||||
function isNumberNeon($input)
|
||||
{
|
||||
$inputSquare = $input * $input;
|
||||
@ -9,4 +10,3 @@ function isNumberNeon($input)
|
||||
}
|
||||
return $sumOfSquareDigits == $input;
|
||||
}
|
||||
?>
|
||||
|
||||
@ -1,4 +1,5 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* This function check whether
|
||||
* the provided number is a
|
||||
|
||||
@ -28,7 +28,7 @@ function problem1a(): int
|
||||
|
||||
return array_reduce($numbers, function ($carry, $number) {
|
||||
$shouldCarry = $number % 3 == 0 || $number % 5 == 0;
|
||||
return $carry += $shouldCarry ? $number : 0;
|
||||
return $carry + ($shouldCarry ? $number : 0);
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
@ -1,4 +1,5 @@
|
||||
<?php
|
||||
|
||||
/*
|
||||
* This function solves the problem 10 of the Project Euler.
|
||||
*
|
||||
@ -24,10 +25,11 @@ function problem10(): int
|
||||
|
||||
for ($i = 2; $i * $i <= $n; $i++) {
|
||||
if (isset($isPrime[$i])) {
|
||||
for ( $j = $i; $i*$j <= $n; $j++)
|
||||
for ($j = $i; $i * $j <= $n; $j++) {
|
||||
unset($isPrime[$i * $j]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return array_sum($isPrime);
|
||||
}
|
||||
|
||||
@ -1,6 +1,5 @@
|
||||
<?php
|
||||
|
||||
|
||||
/*
|
||||
* This function solves the problem 11 of the Project Euler.
|
||||
*
|
||||
@ -150,4 +149,3 @@ function problem11()
|
||||
|
||||
return $maxProduct;
|
||||
}
|
||||
|
||||
|
||||
@ -14,7 +14,6 @@ function problem4(): int
|
||||
$largest = 0;
|
||||
|
||||
for ($i = 100; $i < 1000; $i++) {
|
||||
|
||||
for ($j = $i; $j < 1000; $j++) {
|
||||
$product = $i * $j;
|
||||
|
||||
|
||||
@ -70,8 +70,9 @@ function binarySearchByRecursion($list, $target, $start, $end)
|
||||
return $list[0] == $target ? 0 : null;
|
||||
}
|
||||
|
||||
if ($start > $end)
|
||||
if ($start > $end) {
|
||||
return null;
|
||||
}
|
||||
|
||||
|
||||
$mid = ($start + $end) >> 1;
|
||||
|
||||
@ -1,4 +1,5 @@
|
||||
<?php
|
||||
|
||||
/*
|
||||
* Exponential Search Algorithm
|
||||
*
|
||||
@ -7,6 +8,7 @@
|
||||
**** if it were in the list.
|
||||
* In the second stage, a binary search is performed on this range.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @param Array $arr
|
||||
* @param int $value
|
||||
@ -14,33 +16,37 @@
|
||||
* @param int $ceiling
|
||||
* @return int
|
||||
**/
|
||||
function binarySearch ($arr, $value, $floor, $ceiling) {
|
||||
function binarySearch($arr, $value, $floor, $ceiling)
|
||||
{
|
||||
// Get $middle index
|
||||
$mid = floor(($floor + $ceiling) / 2);
|
||||
|
||||
// Return position if $value is at the $mid position
|
||||
if ($arr[$mid] === $value) {
|
||||
return (int) $mid;
|
||||
}
|
||||
|
||||
//Return -1 is range is wrong
|
||||
if ($floor > $ceiling) return -1;
|
||||
if ($floor > $ceiling) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
// search the left part of the $array
|
||||
// If the $middle element is great than the $value
|
||||
// If the $middle element is greater than the $value
|
||||
if ($arr[$mid] > $value) {
|
||||
return binarySearch($arr, $value, $floor, $mid - 1);
|
||||
}
|
||||
// search the right part of the $array
|
||||
// If the $middle element is lower than the $value
|
||||
else {
|
||||
} else { // search the right part of the $array If the $middle element is lower than the $value
|
||||
return binarySearch($arr, $value, $mid + 1, $ceiling);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @param Array $arr
|
||||
* @param int $length
|
||||
* @param int $value
|
||||
* @return int
|
||||
**/
|
||||
function exponentialSearch ($arr, $value) {
|
||||
*/
|
||||
function exponentialSearch($arr, $value)
|
||||
{
|
||||
// If $value is the first element of the $array return this position
|
||||
if ($arr[0] === $value) {
|
||||
return 0;
|
||||
|
||||
@ -11,13 +11,16 @@
|
||||
*/
|
||||
function fibonacciPosition(int $n, array &$m = [])
|
||||
{
|
||||
if(isset($m[$n])) return $m[$n];
|
||||
if($n < 2) return $n;
|
||||
if (isset($m[$n])) {
|
||||
return $m[$n];
|
||||
}
|
||||
if ($n < 2) {
|
||||
return $n;
|
||||
}
|
||||
|
||||
$m[$n] = fibonacciPosition($n - 1, $m) + fibonacciPosition($n - 2, $m);
|
||||
|
||||
return $m[$n];
|
||||
|
||||
}
|
||||
|
||||
print fibonacciPosition(59);
|
||||
|
||||
@ -1,4 +1,5 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* Interpolation Search********
|
||||
*
|
||||
@ -15,7 +16,8 @@
|
||||
* if the (value of index in array) is > key decrease the high index
|
||||
* repeat the loop
|
||||
*/
|
||||
function interpolationSearch($arr, $key) {
|
||||
function interpolationSearch($arr, $key)
|
||||
{
|
||||
$length = count($arr) - 1;
|
||||
$low = 0;
|
||||
$high = $length;
|
||||
@ -25,26 +27,27 @@ function interpolationSearch($arr, $key) {
|
||||
//GET INDEX
|
||||
$delta = ($key - $arr[$low]) / ($arr[$high] - $arr[$low]);
|
||||
$index = $low + floor(($high - $low) * $delta);
|
||||
|
||||
//GET VALUE OF INDEX IN ARRAY...
|
||||
$indexValue = $arr[$index];
|
||||
|
||||
if ($indexValue === $key) {
|
||||
//index value equals key
|
||||
//FOUND TARGET
|
||||
//return index value
|
||||
$position = $index;
|
||||
return (int) $position;
|
||||
}
|
||||
if ($indexValue < $key) {
|
||||
} elseif ($indexValue < $key) {
|
||||
//index value lower than key
|
||||
//increase low index
|
||||
$low = $index + 1;
|
||||
}
|
||||
if ($indexValue > $key) {
|
||||
} elseif ($indexValue > $key) {
|
||||
//index value higher than key
|
||||
//decrease high index
|
||||
$high = $index - 1;
|
||||
}
|
||||
}
|
||||
|
||||
//when key not found in array or array not sorted
|
||||
return null;
|
||||
}
|
||||
@ -1,4 +1,5 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* Jump Search algorithm in PHP
|
||||
* References: https://www.geeksforgeeks.org/jump-search/
|
||||
@ -6,35 +7,33 @@
|
||||
*
|
||||
* @param Array $list refers to a sorted list of integer
|
||||
* @param integer $key refers to the integer target to be searched from the sorted list
|
||||
* @return index of $key if found, otherwise -1 is returned
|
||||
* @return int index of $key if found, otherwise -1 is returned
|
||||
*/
|
||||
|
||||
function jumpSearch($list, $key)
|
||||
{
|
||||
/*number of elements in the sorted array*/
|
||||
$num = count($list);
|
||||
|
||||
/*block size to be jumped*/
|
||||
$step = (int)sqrt($num);
|
||||
$prev = 0;
|
||||
|
||||
while ($list[min($step, $num)-1] < $key)
|
||||
{
|
||||
while ($list[min($step, $num) - 1] < $key) {
|
||||
$prev = $step;
|
||||
$step += (int)sqrt($num);
|
||||
if ($prev >= $num)
|
||||
if ($prev >= $num) {
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
/*Performing linear search for $key in block*/
|
||||
while ($list[$prev] < $key)
|
||||
{
|
||||
while ($list[$prev] < $key) {
|
||||
$prev++;
|
||||
if ($prev == min($step, $num))
|
||||
if ($prev == min($step, $num)) {
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
return $list[$prev] === $key ? $prev : -1;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
@ -5,10 +5,6 @@
|
||||
*
|
||||
* Reference: https://www.geeksforgeeks.org/linear-search/
|
||||
*
|
||||
* @param Array $list a array of integers to search
|
||||
* @param integer $target an integer number to search for in the list
|
||||
* @return integer the index where the target is found (or -1 if not found)
|
||||
*
|
||||
* Examples:
|
||||
* data = 5, 7, 8, 11, 12, 15, 17, 18, 20
|
||||
* x = 15
|
||||
@ -17,15 +13,14 @@
|
||||
* x = 1
|
||||
* Element not found
|
||||
*
|
||||
* @param Array $list a array of integers to search
|
||||
* @param Array $list an array of integers to search
|
||||
* @param integer $target an integer number to search for in the list
|
||||
* @return integer the index where the target is found (or -1 if not found)
|
||||
*/
|
||||
function linearSearch($list, $target)
|
||||
{
|
||||
$n = sizeof($list);
|
||||
for($i = 0; $i < $n; $i++)
|
||||
{
|
||||
for ($i = 0; $i < $n; $i++) {
|
||||
if ($list[$i] == $target) {
|
||||
return $i + 1;
|
||||
}
|
||||
|
||||
@ -10,14 +10,15 @@ require_once __DIR__ . '/../Utils/ArrayHelpers.php';
|
||||
* [C++ Lower Bound](http://www.cplusplus.com/reference/algorithm/lower_bound/)
|
||||
*
|
||||
* It is assumed that an integer array is provided
|
||||
* and the second parameter is also a integer
|
||||
* and the second parameter is also an integer
|
||||
*
|
||||
* @param array of sorted integers
|
||||
* @param integer whose lower bound is to be found
|
||||
* @param array $arr of sorted integers
|
||||
* @param integer $elem whose lower bound is to be found
|
||||
*
|
||||
* @return the index of lower bound of the given element
|
||||
* @return int the index of lower bound of the given element
|
||||
*/
|
||||
function lowerBound(array $arr, int $elem){
|
||||
function lowerBound(array $arr, int $elem)
|
||||
{
|
||||
isSortedAscendingInts($arr);
|
||||
$hi = count($arr);
|
||||
$lo = 0;
|
||||
|
||||
@ -1,4 +1,5 @@
|
||||
<?php
|
||||
|
||||
/* Ternary search is similar to binary search
|
||||
* It rather divides the sorted array into three parts rather than.two parts by using two middle points, $mid1 $mid2.
|
||||
* The value of the $key will first be compared with the two $mid points, the value will be returned if there is a match.
|
||||
@ -7,77 +8,74 @@
|
||||
* Otherwise, narrow the interval to the $middle part.
|
||||
* Repeat the steps until the value is found or the interval is empty (value not found after checking all elements).
|
||||
*/
|
||||
|
||||
function ternarySearchByRecursion ($arr, $key, $low, $high) {
|
||||
|
||||
//Return -1 if high lesser than low, we can't find item in the whole array
|
||||
function ternarySearchByRecursion($arr, $key, $low, $high)
|
||||
{
|
||||
// Return null if high is less than low (base case: key not found).
|
||||
if ($high < $low) {
|
||||
return null;
|
||||
}
|
||||
|
||||
|
||||
//get $mid1 and $mid2
|
||||
// Calculate the indices of the first and second midpoints.
|
||||
$mid1 = floor($low + ($high - $low) / 3);
|
||||
$mid2 = floor($high - ($high - $low) / 3);
|
||||
// check if $key is found at any $mid
|
||||
|
||||
// Check if key is located at either midpoint.
|
||||
if ($arr[$mid1] === $key) {
|
||||
// return index of $key if found
|
||||
return $mid1;
|
||||
}
|
||||
|
||||
if ($arr[$mid2] === $key) {
|
||||
// return index of $key if found
|
||||
return $mid2;
|
||||
}
|
||||
|
||||
// since the $key is not found at $mid,
|
||||
// check in which region it is present
|
||||
// and repeat the Search operation
|
||||
// in that region
|
||||
// Determine which section to continue searching in.
|
||||
if ($key < $arr[$mid1]) {
|
||||
// the $key lies in between $low and $mid1
|
||||
// Key is in the left section, between $low and $mid1.
|
||||
return ternarySearchByRecursion($arr, $key, $low, $mid1 - 1);
|
||||
} elseif ($key > $arr[$mid2]) {
|
||||
// the $key lies in between $mid2 and $high
|
||||
// Key is in the right section, between $mid2 and $high.
|
||||
return ternarySearchByRecursion($arr, $key, $mid2 + 1, $high);
|
||||
} else {
|
||||
// the $key lies in between $mid1 and $mid2
|
||||
// Key is in the middle section, between $mid1 and $mid2.
|
||||
return ternarySearchByRecursion($arr, $key, $mid1 + 1, $mid2 - 1);
|
||||
}
|
||||
}
|
||||
|
||||
function ternarySearchIterative ($arr, $key) {
|
||||
$low = 0; $high = count($arr) - 1;
|
||||
function ternarySearchIterative($arr, $key)
|
||||
{
|
||||
// Initialize low and high pointers.
|
||||
$low = 0;
|
||||
$high = count($arr) - 1;
|
||||
|
||||
// Continue searching while the high pointer is greater than or equal to the low pointer.
|
||||
while ($high >= $low) {
|
||||
// find the $mid1 and $mid2
|
||||
// Calculate the first and second midpoints.
|
||||
$mid1 = floor($low + ($high - $low) / 3);
|
||||
$mid2 = floor($high - ($high - $low) / 3);
|
||||
|
||||
// check if $key is found at any $mid
|
||||
// Check if the key is found at either midpoint.
|
||||
if ($arr[$mid1] === $key) {
|
||||
// return index of $key if found
|
||||
return $mid1;
|
||||
}
|
||||
|
||||
if ($arr[$mid2] === $key) {
|
||||
// return index of $key if found
|
||||
return $mid2;
|
||||
}
|
||||
|
||||
// since the $key is not found at $mid,
|
||||
// check in which region it is present
|
||||
// and repeat the Search operation
|
||||
// in that region
|
||||
// Determine the section to continue the search in.
|
||||
if ($key < $arr[$mid1]) {
|
||||
// the $key lies in between $low and $mid1
|
||||
// Key is in the left section, update the high pointer.
|
||||
$high = $mid1 - 1;
|
||||
} elseif ($key > $arr[$mid2]) {
|
||||
// the $key lies in between $mid2 and $high
|
||||
// Key is in the right section, update the low pointer.
|
||||
$low = $mid2 + 1;
|
||||
} else {
|
||||
// the $key lies in between $mid1 and $mid2
|
||||
// Key is in the middle section, update both pointers.
|
||||
$low = $mid1 + 1;
|
||||
$high = $mid2 - 1;
|
||||
}
|
||||
}
|
||||
// the $key was not found
|
||||
|
||||
// Key was not found.
|
||||
return null;
|
||||
}
|
||||
|
||||
@ -10,14 +10,15 @@ require_once __DIR__ . '/../Utils/ArrayHelpers.php';
|
||||
* [C++ Lower Bound](http://www.cplusplus.com/reference/algorithm/upper_bound/)
|
||||
*
|
||||
* It is assumed that an integer array is provided
|
||||
* and the second parameter is also a integer
|
||||
* and the second parameter is also an integer
|
||||
*
|
||||
* @param array of sorted integers
|
||||
* @param integer whose upper bound is to be found
|
||||
* @param array $arr of sorted integers
|
||||
* @param integer $elem whose upper bound is to be found
|
||||
*
|
||||
* @return the index of upper bound of the given element
|
||||
* @return int the index of upper bound of the given element
|
||||
*/
|
||||
function upperBound(array $arr, int $elem){
|
||||
function upperBound(array $arr, int $elem)
|
||||
{
|
||||
isSortedAscendingInts($arr);
|
||||
$hi = count($arr);
|
||||
$lo = 0;
|
||||
|
||||
@ -1,4 +1,5 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* Sort an "Array of objects" or "Array of arrays" by keys
|
||||
*/
|
||||
@ -7,7 +8,6 @@ class ArrayKeysSort
|
||||
{
|
||||
public const ORDER_ASC = 'ASC';
|
||||
public const ORDER_DESC = 'DESC';
|
||||
|
||||
/**
|
||||
* @param $collection
|
||||
* @param array $keys
|
||||
@ -15,17 +15,12 @@ class ArrayKeysSort
|
||||
* @param bool $isCaseSensitive
|
||||
* @return mixed
|
||||
*/
|
||||
public static function sort(
|
||||
$collection,
|
||||
array $keys,
|
||||
string $order = self::ORDER_ASC,
|
||||
bool $isCaseSensitive = false
|
||||
) {
|
||||
public static function sort($collection, array $keys, string $order = self::ORDER_ASC, bool $isCaseSensitive = false)
|
||||
{
|
||||
if (!empty($collection) && !empty($keys)) {
|
||||
try {
|
||||
usort(
|
||||
$collection,
|
||||
function ($a, $b) use ($keys, $order, $isCaseSensitive) {
|
||||
usort($collection, function ($a, $b) use ($keys, $order, $isCaseSensitive) {
|
||||
|
||||
$pos = 0;
|
||||
do {
|
||||
$key = $keys[$pos];
|
||||
@ -51,7 +46,6 @@ class ArrayKeysSort
|
||||
? strtolower($b->$key) : $b->$key;
|
||||
}
|
||||
} while ($item1 === $item2 && !empty($keys[++$pos]));
|
||||
|
||||
if ($item1 === $item2) {
|
||||
return 0;
|
||||
} elseif ($order === self::ORDER_ASC) {
|
||||
@ -59,8 +53,7 @@ class ArrayKeysSort
|
||||
} else {
|
||||
return ($item1 > $item2) ? -1 : 1;
|
||||
}
|
||||
}
|
||||
);
|
||||
});
|
||||
} catch (Exception $e) {
|
||||
echo $e->getMessage();
|
||||
die();
|
||||
|
||||
@ -6,7 +6,8 @@
|
||||
* @param array $array
|
||||
* @return array
|
||||
*/
|
||||
function bubbleSort($array) {
|
||||
function bubbleSort($array)
|
||||
{
|
||||
$length = count($array);
|
||||
|
||||
for ($i = $length; $i > 0; $i--) {
|
||||
@ -21,7 +22,9 @@ function bubbleSort($array) {
|
||||
}
|
||||
}
|
||||
|
||||
if ($swapped) break;
|
||||
if ($swapped) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return $array;
|
||||
|
||||
@ -1,4 +1,5 @@
|
||||
<?php
|
||||
|
||||
/*
|
||||
* Bubble Sort
|
||||
*
|
||||
@ -10,25 +11,19 @@
|
||||
function bubbleSort2(array $input)
|
||||
{
|
||||
// Return nothing if input is empty
|
||||
if(!isset($input))
|
||||
{
|
||||
if (!isset($input)) {
|
||||
return [];
|
||||
}
|
||||
|
||||
do
|
||||
{
|
||||
do {
|
||||
$swapped = false;
|
||||
|
||||
for($i = 0, $count = sizeof($input) - 1; $i < $count; $i++)
|
||||
{
|
||||
if($input[$i + 1] < $input[$i])
|
||||
{
|
||||
for ($i = 0, $count = sizeof($input) - 1; $i < $count; $i++) {
|
||||
if ($input[$i + 1] < $input[$i]) {
|
||||
list($input[$i + 1], $input[$i]) = [$input[$i], $input[$i + 1]];
|
||||
$swapped = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
while($swapped);
|
||||
|
||||
} while ($swapped);
|
||||
return $input;
|
||||
}
|
||||
|
||||
@ -1,6 +1,5 @@
|
||||
<?php
|
||||
|
||||
|
||||
/**
|
||||
* @param $array
|
||||
* @param $min
|
||||
@ -11,13 +10,11 @@ function countSort($array, $min, $max)
|
||||
{
|
||||
$count = array();
|
||||
|
||||
for($i = $min; $i <= $max; $i++)
|
||||
{
|
||||
for ($i = $min; $i <= $max; $i++) {
|
||||
$count[$i] = 0;
|
||||
}
|
||||
|
||||
foreach($array as $number)
|
||||
{
|
||||
foreach ($array as $number) {
|
||||
$count[$number]++;
|
||||
}
|
||||
|
||||
|
||||
@ -10,13 +10,12 @@
|
||||
* @param array $array refers to the array to be sorted
|
||||
* @return array
|
||||
*/
|
||||
|
||||
function gnomeSort($array){
|
||||
function gnomeSort($array)
|
||||
{
|
||||
$a = 1;
|
||||
$b = 2;
|
||||
|
||||
while ($a < count($array)) {
|
||||
|
||||
if ($array[$a - 1] <= $array[$a]) {
|
||||
$a = $b;
|
||||
$b++;
|
||||
|
||||
@ -1,4 +1,5 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* HeapSort Algorithm
|
||||
*
|
||||
@ -12,25 +13,29 @@
|
||||
*/
|
||||
function heapSort(array $arr): array
|
||||
{
|
||||
// Get the number of elements in the array.
|
||||
$n = count($arr);
|
||||
|
||||
// Throw an exception if the array has no elements.
|
||||
if ($n <= 0) {
|
||||
throw new \UnexpectedValueException('Input array must have at least one element.');
|
||||
}
|
||||
|
||||
// Build heap
|
||||
for ($i = $n / 2 - 1; $i >= 0; $i--) {
|
||||
// Build a max heap from the array.
|
||||
for ($i = floor($n / 2) - 1; $i >= 0; $i--) {
|
||||
heapify($arr, $n, $i);
|
||||
}
|
||||
|
||||
// Extract elements from heap one by one
|
||||
// Extract elements from the max heap and build the sorted array.
|
||||
for ($i = $n - 1; $i >= 0; $i--) {
|
||||
// Swap
|
||||
// Swap the root(maximum value) of the heap with the last element of the heap.
|
||||
[$arr[0], $arr[$i]] = [$arr[$i], $arr[0]];
|
||||
|
||||
// Heapify the reduced heap
|
||||
// Heapify the reduced heap.
|
||||
heapify($arr, $i, 0);
|
||||
}
|
||||
|
||||
// Return the sorted array.
|
||||
return $arr;
|
||||
}
|
||||
|
||||
@ -46,7 +51,6 @@ function heapify(array &$arr, int $n, int $i): void
|
||||
$largest = $i;
|
||||
$left = 2 * $i + 1;
|
||||
$right = 2 * $i + 2;
|
||||
|
||||
if ($left < $n && $arr[$left] > $arr[$largest]) {
|
||||
$largest = $left;
|
||||
}
|
||||
|
||||
@ -8,12 +8,10 @@
|
||||
*/
|
||||
function insertionSort(array $array)
|
||||
{
|
||||
for ($i = 1; $i < count($array); $i++)
|
||||
{
|
||||
for ($i = 1; $i < count($array); $i++) {
|
||||
$currentVal = $array[$i];
|
||||
|
||||
for ($j = $i - 1; $j >= 0 && $array[$j] > $currentVal; $j--)
|
||||
{
|
||||
for ($j = $i - 1; $j >= 0 && $array[$j] > $currentVal; $j--) {
|
||||
$array[$j + 1] = $array[$j];
|
||||
}
|
||||
|
||||
@ -22,5 +20,3 @@ function insertionSort(array $array)
|
||||
|
||||
return $array;
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -52,6 +52,3 @@ function merge(array $leftArray, array $rightArray)
|
||||
|
||||
return $result;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
@ -1,4 +1,5 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* Quick Sort
|
||||
* Compare number in an array to the next number and sets to new array (greater than or less than)
|
||||
@ -9,24 +10,19 @@
|
||||
function quickSort(array $input)
|
||||
{
|
||||
// Return nothing if input is empty
|
||||
if(!empty($input))
|
||||
{
|
||||
if (!empty($input)) {
|
||||
return [];
|
||||
}
|
||||
|
||||
$lt = [];
|
||||
$gt = [];
|
||||
|
||||
if(sizeof($input) < 2)
|
||||
{
|
||||
if (sizeof($input) < 2) {
|
||||
return $input;
|
||||
}
|
||||
|
||||
$key = key($input);
|
||||
$shift = array_shift($input);
|
||||
|
||||
foreach($input as $value)
|
||||
{
|
||||
foreach ($input as $value) {
|
||||
$value <= $shift ? $lt[] = $value : $gt[] = $value;
|
||||
}
|
||||
|
||||
|
||||
@ -3,18 +3,16 @@
|
||||
/**
|
||||
* Radix Sort
|
||||
*
|
||||
* @param array $arr
|
||||
* @param $nums
|
||||
* @return array
|
||||
*/
|
||||
function radixSort($nums)
|
||||
{
|
||||
$maxDigitsCount = maxDigits($nums);
|
||||
for ($k=0; $k < $maxDigitsCount; $k++)
|
||||
{
|
||||
for ($k = 0; $k < $maxDigitsCount; $k++) {
|
||||
$digitBucket = array_fill(0, 10, []);
|
||||
|
||||
for ($i=0; $i < count($nums); $i++)
|
||||
{
|
||||
for ($i = 0; $i < count($nums); $i++) {
|
||||
$digitBucket[getDigit($nums[$i], $k)][] = $nums[$i];
|
||||
}
|
||||
|
||||
@ -34,7 +32,7 @@ function radixSort($nums)
|
||||
* Get the digits value by it's place
|
||||
*
|
||||
* @param $num
|
||||
* @param $k
|
||||
* @param $i
|
||||
* @return int
|
||||
*/
|
||||
function getDigit($num, $i)
|
||||
@ -45,27 +43,28 @@ function getDigit($num, $i)
|
||||
/**
|
||||
* Get the digits count
|
||||
*
|
||||
* @param $nums
|
||||
* @param $num
|
||||
* @return int
|
||||
*/
|
||||
function digitsCount($num)
|
||||
{
|
||||
if ($num == 0) return 1;
|
||||
if ($num == 0) {
|
||||
return 1;
|
||||
}
|
||||
return floor(log10(abs($num))) + 1;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the max digits count
|
||||
*
|
||||
* @param $nums
|
||||
* @param $arr
|
||||
* @return int
|
||||
*/
|
||||
function maxDigits($arr)
|
||||
{
|
||||
$maxDigits = 0;
|
||||
|
||||
for ($i=0; $i < count($arr); $i++)
|
||||
{
|
||||
for ($i = 0; $i < count($arr); $i++) {
|
||||
$maxDigits = max($maxDigits, digitsCount($arr[$i]));
|
||||
}
|
||||
|
||||
@ -75,16 +74,15 @@ function maxDigits($arr)
|
||||
/**
|
||||
* Concat the array
|
||||
*
|
||||
* @param $arr
|
||||
* @param array $array
|
||||
* @return array
|
||||
*/
|
||||
function concat(array $array) {
|
||||
function concat(array $array)
|
||||
{
|
||||
$newArray = [];
|
||||
|
||||
for ($i = 0; $i < count($array); $i++)
|
||||
{
|
||||
for ($j = 0; $j<count($array[$i]); $j++)
|
||||
{
|
||||
for ($i = 0; $i < count($array); $i++) {
|
||||
for ($j = 0; $j < count($array[$i]); $j++) {
|
||||
$newArray[] = $array[$i][$j];
|
||||
}
|
||||
}
|
||||
|
||||
@ -10,20 +10,16 @@ function selectionSorting(array $array)
|
||||
{
|
||||
$length = count($array);
|
||||
|
||||
for ($i = 0; $i < $length; $i++)
|
||||
{
|
||||
for ($i = 0; $i < $length; $i++) {
|
||||
$lowest = $i;
|
||||
|
||||
for ($j = $i + 1; $j < $length; $j++)
|
||||
{
|
||||
if ($array[$j] < $array[$lowest])
|
||||
{
|
||||
for ($j = $i + 1; $j < $length; $j++) {
|
||||
if ($array[$j] < $array[$lowest]) {
|
||||
$lowest = $j;
|
||||
}
|
||||
}
|
||||
|
||||
if ($i !==$lowest)
|
||||
{
|
||||
if ($i !== $lowest) {
|
||||
$temp = $array[$i];
|
||||
$array[$i] = $array[$lowest];
|
||||
$array[$lowest] = $temp;
|
||||
|
||||
@ -10,8 +10,7 @@
|
||||
*/
|
||||
function isAnagram(string $originalString, string $testString, bool $caseInsensitive = true)
|
||||
{
|
||||
if ($caseInsensitive)
|
||||
{
|
||||
if ($caseInsensitive) {
|
||||
$originalString = strtolower($originalString); // Converting string to lowercase for case-insensitive check
|
||||
$testString = strtolower($testString);
|
||||
}
|
||||
|
||||
@ -11,22 +11,18 @@ function isPalindrome(string $string, bool $caseInsensitive = true)
|
||||
{
|
||||
$string = trim($string); // Removing leading and trailing spaces
|
||||
|
||||
if (empty($string))
|
||||
{
|
||||
if (empty($string)) {
|
||||
return false; // Returning false for an Empty String
|
||||
}
|
||||
|
||||
if ($caseInsensitive)
|
||||
{
|
||||
if ($caseInsensitive) {
|
||||
$string = strtolower($string); // Converting string to lowercase for case-insensitive check
|
||||
}
|
||||
|
||||
$characters = str_split($string);
|
||||
|
||||
for ($i = 0; $i < count($characters); $i++)
|
||||
{
|
||||
if ($characters[$i] !== $characters[count($characters) - ($i + 1)])
|
||||
{
|
||||
for ($i = 0; $i < count($characters); $i++) {
|
||||
if ($characters[$i] !== $characters[count($characters) - ($i + 1)]) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
@ -7,14 +7,15 @@
|
||||
*
|
||||
* @param string $string
|
||||
* @param bool $caseInsensitive
|
||||
* @return string
|
||||
* @throws \Exception
|
||||
*/
|
||||
function checkPalindromeString(string $string, bool $caseInsensitive = true): String
|
||||
function checkPalindromeString(string $string, bool $caseInsensitive = true): string
|
||||
{
|
||||
//removing spaces
|
||||
$string = trim($string);
|
||||
|
||||
if (empty($string))
|
||||
{
|
||||
if (empty($string)) {
|
||||
throw new \Exception('You are given empty string. Please give a non-empty string value');
|
||||
}
|
||||
|
||||
@ -22,13 +23,11 @@ function checkPalindromeString(string $string, bool $caseInsensitive = true): St
|
||||
* for case-insensitive
|
||||
* lowercase string conversion
|
||||
*/
|
||||
if ($caseInsensitive)
|
||||
{
|
||||
if ($caseInsensitive) {
|
||||
$string = strtolower($string);
|
||||
}
|
||||
|
||||
if ($string !== strrev($string))
|
||||
{
|
||||
if ($string !== strrev($string)) {
|
||||
return $string . " - not a palindrome string." . PHP_EOL;
|
||||
}
|
||||
|
||||
|
||||
@ -6,8 +6,9 @@
|
||||
*
|
||||
* @param string $string
|
||||
* @return int
|
||||
* @throws \Exception
|
||||
*/
|
||||
function countConsonants(string $string): Int
|
||||
function countConsonants(string $string): int
|
||||
{
|
||||
if (empty($string)) {
|
||||
throw new \Exception('Please pass a non-empty string value');
|
||||
@ -18,11 +19,11 @@ function countConsonants(string $string): Int
|
||||
|
||||
$consonantCount = 0;
|
||||
|
||||
for ($i = 0; $i < strlen($string); $i++)
|
||||
{
|
||||
if (!in_array($string[$i], $vowels) &&
|
||||
$string[$i] >= 'a' && $string[$i] <= 'z')
|
||||
{
|
||||
for ($i = 0; $i < strlen($string); $i++) {
|
||||
if (
|
||||
!in_array($string[$i], $vowels) &&
|
||||
$string[$i] >= 'a' && $string[$i] <= 'z'
|
||||
) {
|
||||
$consonantCount++;
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,4 +1,5 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* This function returns the total number of vowels present in
|
||||
* the given string using a simple method of looping through
|
||||
@ -6,27 +7,33 @@
|
||||
*
|
||||
* @param string $string
|
||||
* @return int $numberOfVowels
|
||||
* @throws \Exception
|
||||
*/
|
||||
function countVowelsSimple(string $string)
|
||||
function countVowelsSimple(string $string): int
|
||||
{
|
||||
if (empty($string))
|
||||
{
|
||||
throw new \Exception('Please pass a non-empty string value');
|
||||
// Check for an empty string and throw an exception if so.
|
||||
if (empty($string)) {
|
||||
throw new \Exception('Please pass a non-empty string value.');
|
||||
}
|
||||
|
||||
// Initialize variables.
|
||||
$numberOfVowels = 0;
|
||||
$vowels = ['a', 'e', 'i', 'o', 'u']; // Vowels Set
|
||||
$string = strtolower($string); // For case-insensitive checking
|
||||
$characters = str_split($string); // Splitting the string to a Character Array.
|
||||
$vowels = ['a', 'e', 'i', 'o', 'u']; // Set of vowels for comparison.
|
||||
|
||||
foreach ($characters as $character)
|
||||
{
|
||||
if (in_array($character, $vowels))
|
||||
{
|
||||
// Convert the string to lowercase for case-insensitive comparison.
|
||||
$string = strtolower($string);
|
||||
|
||||
// Split the string into an array of characters.
|
||||
$characters = str_split($string);
|
||||
|
||||
// Loop through each character to count the vowels.
|
||||
foreach ($characters as $character) {
|
||||
if (in_array($character, $vowels)) {
|
||||
$numberOfVowels++;
|
||||
}
|
||||
}
|
||||
|
||||
// Return the total number of vowels found.
|
||||
return $numberOfVowels;
|
||||
}
|
||||
|
||||
@ -36,13 +43,14 @@ function countVowelsSimple(string $string)
|
||||
*
|
||||
* @param string $string
|
||||
* @return int
|
||||
* @throws \Exception
|
||||
*/
|
||||
function countVowelsRegex(string $string)
|
||||
{
|
||||
if (empty($string))
|
||||
{
|
||||
if (empty($string)) {
|
||||
throw new \Exception('Please pass a non-empty string value');
|
||||
}
|
||||
|
||||
$string = strtolower($string); // For case-insensitive checking
|
||||
|
||||
return preg_match_all('/[a,e,i,o,u]/', $string);
|
||||
|
||||
@ -1,4 +1,5 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* Find distance (Levenshtein distance)
|
||||
*
|
||||
@ -13,7 +14,6 @@ function findDistance($str1, $str2)
|
||||
{
|
||||
$lenStr1 = strlen($str1);
|
||||
$lenStr2 = strlen($str2);
|
||||
|
||||
if ($lenStr1 == 0) {
|
||||
return $lenStr2;
|
||||
}
|
||||
@ -40,7 +40,6 @@ function findDistance($str1, $str2)
|
||||
// use formula to fill in the rest of the row
|
||||
for ($j = 0; $j < $lenStr1; $j++) {
|
||||
$substitutionCost = 0;
|
||||
|
||||
if ($str1[$j] == $str2[$i]) {
|
||||
$substitutionCost = $distanceVectorInit[$j];
|
||||
} else {
|
||||
|
||||
@ -1,32 +1,41 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* This function returns the character which is repeated maximum number of
|
||||
* times in the given string.
|
||||
*
|
||||
* @param string $string
|
||||
* @return string
|
||||
* @throws \Exception
|
||||
*/
|
||||
function maxCharacter(string $string)
|
||||
function maxCharacter(string $string): string
|
||||
{
|
||||
// Throw an exception if the string is empty.
|
||||
if (empty($string)) {
|
||||
throw new \Exception('Please pass a non-empty string value');
|
||||
throw new \Exception('Please pass a non-empty string value.');
|
||||
}
|
||||
|
||||
$characterCountTable = []; // A variable to maintain the character counts
|
||||
$string = strtolower($string); // For case-insensitive checking
|
||||
$characters = str_split($string); // Splitting the string to a Character Array.
|
||||
// Initialize an associative array to hold character counts.
|
||||
$characterCountTable = [];
|
||||
|
||||
// Convert the string to lowercase for case-insensitive analysis.
|
||||
$string = strtolower($string);
|
||||
|
||||
// Convert the string into an array of characters.
|
||||
$characters = str_split($string);
|
||||
|
||||
// Loop through the characters to populate the count table.
|
||||
foreach ($characters as $character) {
|
||||
$currentCharacterCount = 1;
|
||||
|
||||
if (isset($characterCountTable[$character])) {
|
||||
$currentCharacterCount = $characterCountTable[$character] + 1;
|
||||
}
|
||||
// Initialize or update the count of the current character.
|
||||
$currentCharacterCount = isset($characterCountTable[$character]) ? $characterCountTable[$character] + 1 : 1;
|
||||
|
||||
// Update the count in the table.
|
||||
$characterCountTable[$character] = $currentCharacterCount;
|
||||
}
|
||||
|
||||
// Sort the count table in descending order.
|
||||
arsort($characterCountTable);
|
||||
|
||||
// Return the character that appears most frequently.
|
||||
return array_keys($characterCountTable)[0];
|
||||
}
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
* This function returns a given sentence with its words
|
||||
* in reverse order
|
||||
*
|
||||
* @param string $string
|
||||
* @param string $text
|
||||
* @return string
|
||||
*/
|
||||
function reverseWords(string $text)
|
||||
@ -13,8 +13,7 @@ function reverseWords(string $text)
|
||||
$words = explode(' ', $text);
|
||||
$reversedWords = [];
|
||||
|
||||
for ($i = (count($words) - 1); $i >= 0; $i--)
|
||||
{
|
||||
for ($i = (count($words) - 1); $i >= 0; $i--) {
|
||||
$reversedWords[] = $words[$i];
|
||||
}
|
||||
|
||||
|
||||
@ -1,10 +1,11 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* @param an array of integers
|
||||
* @return is array sorted in ascending
|
||||
* @param array $arr array of integers
|
||||
* @return void array sorted in ascending
|
||||
*/
|
||||
function isSortedAscendingInts(array $arr): void{
|
||||
function isSortedAscendingInts(array $arr): void
|
||||
{
|
||||
$len = count($arr);
|
||||
|
||||
if ($len == 0) {
|
||||
|
||||
@ -3,16 +3,17 @@
|
||||
"description": "All Algorithms implemented in PHP",
|
||||
"config": {
|
||||
"platform": {
|
||||
"php": "7.3.0"
|
||||
"php": "7.4.0"
|
||||
}
|
||||
},
|
||||
"license": "MIT",
|
||||
"require": {
|
||||
"php": "7.3.0",
|
||||
"php": "7.4",
|
||||
"phan/phan": "^2.7"
|
||||
},
|
||||
"require-dev": {
|
||||
"phpunit/phpunit": "^9"
|
||||
"phpunit/phpunit": "^9",
|
||||
"squizlabs/php_codesniffer": "^3.7"
|
||||
},
|
||||
"scripts": {
|
||||
"test": "vendor/bin/phpunit tests"
|
||||
|
||||
15
phpcs.xml.dist
Normal file
15
phpcs.xml.dist
Normal file
@ -0,0 +1,15 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<ruleset xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
|
||||
xsi:noNamespaceSchemaLocation="vendor/squizlabs/php_codesniffer/phpcs.xsd">
|
||||
|
||||
<arg name="extensions" value="php"/>
|
||||
<rule ref="PSR12"/>
|
||||
|
||||
<file>.</file>
|
||||
|
||||
<exclude-pattern>vendor</exclude-pattern>
|
||||
|
||||
<rule ref="PSR1.Classes.ClassDeclaration.MissingNamespace">
|
||||
<severity>0</severity>
|
||||
</rule>
|
||||
</ruleset>
|
||||
@ -1,6 +1,5 @@
|
||||
<?php
|
||||
|
||||
use function PHPUnit\Framework\assertEquals;
|
||||
use PHPUnit\Framework\TestCase;
|
||||
|
||||
require_once __DIR__ . '/../../vendor/autoload.php';
|
||||
|
||||
@ -1,23 +1,19 @@
|
||||
<?php
|
||||
|
||||
use PHPUnit\Framework\TestCase;
|
||||
use function PHPUnit\Framework\assertEquals;
|
||||
|
||||
require_once __DIR__ . '/../../vendor/autoload.php';
|
||||
require_once __DIR__ . '/../../Ciphers/MonoAlphabeticCipher.php';
|
||||
|
||||
class MonoAlphabeticCipherTest extends TestCase
|
||||
{
|
||||
public function testMonoAlphabeticCipher(){
|
||||
public function testMonoAlphabeticCipher()
|
||||
{
|
||||
$alphabet = "abcdefghijklmnopqrstuvwxyz";
|
||||
$key = "yhkqgvxfoluapwmtzecjdbsnri";
|
||||
$text = "I love1234 GitHub";
|
||||
$encryptedText = "O ambg XojFdh";
|
||||
|
||||
assertEquals(maEncrypt($key, $alphabet, $text), $encryptedText);
|
||||
|
||||
assertEquals(maDecrypt($key, $alphabet, $encryptedText), "I love GitHub");
|
||||
|
||||
$this->assertEquals(maEncrypt($key, $alphabet, $text), $encryptedText);
|
||||
$this->assertEquals(maDecrypt($key, $alphabet, $encryptedText), "I love GitHub");
|
||||
}
|
||||
}
|
||||
|
||||
?>
|
||||
|
||||
@ -1,6 +1,5 @@
|
||||
<?php
|
||||
|
||||
use function PHPUnit\Framework\assertEquals;
|
||||
use PHPUnit\Framework\TestCase;
|
||||
|
||||
require_once __DIR__ . '/../../vendor/autoload.php';
|
||||
@ -10,6 +9,6 @@ class MorseCodeTest extends TestCase
|
||||
{
|
||||
public function testMorseCodeCipher()
|
||||
{
|
||||
assertEquals('TEST 123', decode(encode('TEST 123')));
|
||||
$this->assertEquals('TEST 123', decode(encode('TEST 123')));
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,6 +1,5 @@
|
||||
<?php
|
||||
|
||||
use function PHPUnit\Framework\assertEquals;
|
||||
use PHPUnit\Framework\TestCase;
|
||||
|
||||
require_once __DIR__ . '/../../vendor/autoload.php';
|
||||
@ -15,8 +14,8 @@ class ConversionsTest extends TestCase
|
||||
{
|
||||
public function testBinaryToDecimal()
|
||||
{
|
||||
assertEquals(binaryToDecimal(111), 7);
|
||||
assertEquals(binaryToDecimal(101), 5);
|
||||
$this->assertEquals(7, binaryToDecimal(111));
|
||||
$this->assertEquals(5, binaryToDecimal(101));
|
||||
$this->expectException(\Exception::class);
|
||||
$this->expectExceptionMessage('Please pass a valid Binary Number for Converting it to a Decimal Number.');
|
||||
binaryToDecimal("this is a string");
|
||||
@ -24,8 +23,8 @@ class ConversionsTest extends TestCase
|
||||
|
||||
public function testDecimalToBinary()
|
||||
{
|
||||
assertEquals(decimalToBinary(7), 111);
|
||||
assertEquals(decimalToBinary(5), 101);
|
||||
$this->assertEquals(111, decimalToBinary(7));
|
||||
$this->assertEquals(101, decimalToBinary(5));
|
||||
$this->expectException(\Exception::class);
|
||||
$this->expectExceptionMessage('Please pass a valid Decimal Number for Converting it to a Binary Number.');
|
||||
decimalToBinary("this is a string");
|
||||
@ -33,9 +32,9 @@ class ConversionsTest extends TestCase
|
||||
|
||||
public function testOctalToDecimal()
|
||||
{
|
||||
assertEquals(octalToDecimal(10), 8);
|
||||
assertEquals(octalToDecimal(11), 9);
|
||||
assertEquals(octalToDecimal(1115), 589);
|
||||
$this->assertEquals(8, octalToDecimal(10));
|
||||
$this->assertEquals(9, octalToDecimal(11));
|
||||
$this->assertEquals(589, octalToDecimal(1115));
|
||||
$this->expectException(\Exception::class);
|
||||
$this->expectExceptionMessage('Please pass a valid Octal Number for Converting it to a Decimal Number.');
|
||||
octalToDecimal("this is a string");
|
||||
@ -43,9 +42,9 @@ class ConversionsTest extends TestCase
|
||||
|
||||
public function testDecimalToOctal()
|
||||
{
|
||||
assertEquals(decimalToOctal(8), 10);
|
||||
assertEquals(decimalToOctal(9), 11);
|
||||
assertEquals(decimalToOctal(589), 1115);
|
||||
$this->assertEquals(10, decimalToOctal(8));
|
||||
$this->assertEquals(11, decimalToOctal(9));
|
||||
$this->assertEquals(1115, decimalToOctal(589));
|
||||
$this->expectException(\Exception::class);
|
||||
$this->expectExceptionMessage('Please pass a valid Decimal Number for Converting it to an Octal Number.');
|
||||
decimalToOctal("this is a string");
|
||||
@ -53,9 +52,9 @@ class ConversionsTest extends TestCase
|
||||
|
||||
public function testDecimalToHex()
|
||||
{
|
||||
assertEquals(decimalToHex(10), 'A');
|
||||
assertEquals(decimalToHex(489201875), '1D28A0D3');
|
||||
assertEquals(decimalToHex(171), 'AB');
|
||||
$this->assertEquals('A', decimalToHex(10));
|
||||
$this->assertEquals('1D28A0D3', decimalToHex(489201875));
|
||||
$this->assertEquals('AB', decimalToHex(171));
|
||||
$this->expectException(\Exception::class);
|
||||
$this->expectExceptionMessage('Please pass a valid Decimal Number for Converting it to a Hexadecimal Number.');
|
||||
decimalToHex("this is a string");
|
||||
@ -63,9 +62,9 @@ class ConversionsTest extends TestCase
|
||||
|
||||
public function testHexToDecimal()
|
||||
{
|
||||
assertEquals(hexToDecimal('A'), 10);
|
||||
assertEquals(hexToDecimal('1D28A0D3'), 489201875);
|
||||
assertEquals(hexToDecimal('AB'), 171);
|
||||
$this->assertEquals(10, hexToDecimal('A'));
|
||||
$this->assertEquals(489201875, hexToDecimal('1D28A0D3'));
|
||||
$this->assertEquals(171, hexToDecimal('AB'));
|
||||
$this->expectException(\Exception::class);
|
||||
$this->expectExceptionMessage('Please pass a valid Hexadecimal Number for Converting it to a Decimal Number.');
|
||||
hexToDecimal("this is a string");
|
||||
@ -73,12 +72,12 @@ class ConversionsTest extends TestCase
|
||||
|
||||
public function testSpeedConversion()
|
||||
{
|
||||
assertEquals(convertSpeed(5, 'm/s', 'mph'), 11.18);
|
||||
assertEquals(convertSpeed(5, 'ft/s', 'km/h'), 5.49);
|
||||
assertEquals(convertSpeed(3, 'km/h', 'km/h'), 3);
|
||||
assertEquals(convertSpeed(7, 'kn', 'km/h'), 12.96);
|
||||
assertEquals(convertSpeed(12, 'mph', 'km/h'), 19.31);
|
||||
assertEquals(convertSpeed(0.514, 'm/s', 'kn'), 1);
|
||||
$this->assertEquals(11.18, convertSpeed(5, 'm/s', 'mph'));
|
||||
$this->assertEquals(5.49, convertSpeed(5, 'ft/s', 'km/h'));
|
||||
$this->assertEquals(3, convertSpeed(3, 'km/h', 'km/h'));
|
||||
$this->assertEquals(12.96, convertSpeed(7, 'kn', 'km/h'));
|
||||
$this->assertEquals(19.31, convertSpeed(12, 'mph', 'km/h'));
|
||||
$this->assertEquals(1, convertSpeed(0.514, 'm/s', 'kn'));
|
||||
|
||||
$this->expectException(\Exception::class);
|
||||
convertSpeed('1', 'km/h', 'mph');
|
||||
|
||||
@ -46,4 +46,3 @@ class BreadthFirstSearchTest extends TestCase
|
||||
$this->assertTrue($ans);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -1,8 +1,5 @@
|
||||
<?php
|
||||
|
||||
use function PHPUnit\Framework\assertEquals;
|
||||
use function PHPUnit\Framework\assertFalse;
|
||||
use function PHPUnit\Framework\assertTrue;
|
||||
use PHPUnit\Framework\TestCase;
|
||||
|
||||
require_once __DIR__ . '/../../vendor/autoload.php';
|
||||
@ -25,118 +22,118 @@ class MathsTest extends TestCase
|
||||
{
|
||||
public function testFactorial()
|
||||
{
|
||||
assertEquals(1, factorial(1));
|
||||
assertEquals(120, factorial(5));
|
||||
assertEquals(1, factorial(0));
|
||||
$this->assertEquals(1, factorial(1));
|
||||
$this->assertEquals(120, factorial(5));
|
||||
$this->assertEquals(1, factorial(0));
|
||||
$this->expectException(\Exception::class);
|
||||
factorial(-25);
|
||||
}
|
||||
|
||||
public function testIsNumberArmstrong()
|
||||
{
|
||||
assertTrue(isNumberArmstrong(153));
|
||||
assertFalse(isNumberArmstrong(123));
|
||||
assertTrue(isNumberArmstrong(370));
|
||||
assertFalse(isNumberArmstrong(2468));
|
||||
$this->assertTrue(isNumberArmstrong(153));
|
||||
$this->assertFalse(isNumberArmstrong(123));
|
||||
$this->assertTrue(isNumberArmstrong(370));
|
||||
$this->assertFalse(isNumberArmstrong(2468));
|
||||
}
|
||||
|
||||
public function testIsNumberPalindromic()
|
||||
{
|
||||
assertTrue(isNumberPalindromic(121));
|
||||
assertFalse(isNumberPalindromic(123));
|
||||
assertTrue(isNumberPalindromic(123321));
|
||||
assertFalse(isNumberPalindromic(2468));
|
||||
$this->assertTrue(isNumberPalindromic(121));
|
||||
$this->assertFalse(isNumberPalindromic(123));
|
||||
$this->assertTrue(isNumberPalindromic(123321));
|
||||
$this->assertFalse(isNumberPalindromic(2468));
|
||||
}
|
||||
|
||||
public function testIsPrime()
|
||||
{
|
||||
assertTrue(isPrime(73));
|
||||
assertFalse(isPrime(21));
|
||||
assertFalse(isPrime(1));
|
||||
assertTrue(isPrime(997));
|
||||
$this->assertTrue(isPrime(73));
|
||||
$this->assertFalse(isPrime(21));
|
||||
$this->assertFalse(isPrime(1));
|
||||
$this->assertTrue(isPrime(997));
|
||||
}
|
||||
|
||||
public function testAbsoluteMax()
|
||||
{
|
||||
assertEquals(50, absolute_max(12, 20, 35, 50, 50, 23));
|
||||
assertEquals(13, absolute_max(13));
|
||||
assertEquals(54, absolute_max(12, 13, 54, 22));
|
||||
$this->assertEquals(50, absolute_max(12, 20, 35, 50, 50, 23));
|
||||
$this->assertEquals(13, absolute_max(13));
|
||||
$this->assertEquals(54, absolute_max(12, 13, 54, 22));
|
||||
$this->expectException(\Exception::class);
|
||||
absolute_max();
|
||||
}
|
||||
|
||||
public function testAbsoluteMin()
|
||||
{
|
||||
assertEquals(12, absolute_min(12, 20, 35, 50, 50, 23));
|
||||
assertEquals(13, absolute_min(13));
|
||||
assertEquals(12, absolute_min(12, 13, 54, 22));
|
||||
$this->assertEquals(12, absolute_min(12, 20, 35, 50, 50, 23));
|
||||
$this->assertEquals(13, absolute_min(13));
|
||||
$this->assertEquals(12, absolute_min(12, 13, 54, 22));
|
||||
$this->expectException(\Exception::class);
|
||||
absolute_min();
|
||||
}
|
||||
|
||||
public function testPerfectSquare()
|
||||
{
|
||||
assertTrue(isPerfectSquare(25));
|
||||
assertFalse(isPerfectSquare(43));
|
||||
assertFalse(isPerfectSquare(2));
|
||||
assertTrue(isPerfectSquare(225));
|
||||
$this->assertTrue(isPerfectSquare(25));
|
||||
$this->assertFalse(isPerfectSquare(43));
|
||||
$this->assertFalse(isPerfectSquare(2));
|
||||
$this->assertTrue(isPerfectSquare(225));
|
||||
}
|
||||
|
||||
public function testFastExponentiation()
|
||||
{
|
||||
assertEquals(fastExponentiation(10, 0), 1);
|
||||
assertEquals(fastExponentiation(10, 1), 10);
|
||||
assertEquals(fastExponentiation(10, 2), 100);
|
||||
assertEquals(fastExponentiation(10, 3), 1000);
|
||||
assertEquals(fastExponentiation(20, 5), 3200000);
|
||||
$this->assertEquals(1, fastExponentiation(10, 0));
|
||||
$this->assertEquals(10, fastExponentiation(10, 1));
|
||||
$this->assertEquals(100, fastExponentiation(10, 2));
|
||||
$this->assertEquals(1000, fastExponentiation(10, 3));
|
||||
$this->assertEquals(3200000, fastExponentiation(20, 5));
|
||||
}
|
||||
|
||||
public function testFibonacciSeries()
|
||||
{
|
||||
assertEquals([0, 1, 1, 2, 3], fibonacciRecursive(5));
|
||||
assertEquals([0, 1, 1, 2, 3, 5, 8, 13, 21, 34], fibonacciRecursive(10));
|
||||
$this->assertEquals([0, 1, 1, 2, 3], fibonacciRecursive(5));
|
||||
$this->assertEquals([0, 1, 1, 2, 3, 5, 8, 13, 21, 34], fibonacciRecursive(10));
|
||||
|
||||
assertEquals([0, 1, 1, 2, 3], fibonacciWithBinetFormula(5));
|
||||
assertEquals([0, 1, 1, 2, 3, 5, 8, 13, 21, 34], fibonacciWithBinetFormula(10));
|
||||
$this->assertEquals([0, 1, 1, 2, 3], fibonacciWithBinetFormula(5));
|
||||
$this->assertEquals([0, 1, 1, 2, 3, 5, 8, 13, 21, 34], fibonacciWithBinetFormula(10));
|
||||
}
|
||||
|
||||
public function testNeonNumber()
|
||||
{
|
||||
assertTrue(isNumberNeon(1));
|
||||
assertFalse(isNumberNeon(43));
|
||||
assertFalse(isNumberNeon(123));
|
||||
assertTrue(isNumberNeon(9));
|
||||
$this->assertTrue(isNumberNeon(1));
|
||||
$this->assertFalse(isNumberNeon(43));
|
||||
$this->assertFalse(isNumberNeon(123));
|
||||
$this->assertTrue(isNumberNeon(9));
|
||||
}
|
||||
|
||||
public function testFibonacciGenerator()
|
||||
{
|
||||
assertEquals([0, 1, 1, 2, 3], iterator_to_array(loop(5, fib())));
|
||||
assertEquals([0, 1, 1, 2, 3, 5, 8, 13, 21, 34], iterator_to_array(loop(10, fib())));
|
||||
$this->assertEquals([0, 1, 1, 2, 3], iterator_to_array(loop(5, fib())));
|
||||
$this->assertEquals([0, 1, 1, 2, 3, 5, 8, 13, 21, 34], iterator_to_array(loop(10, fib())));
|
||||
|
||||
assertEquals([0, 1, 1, 2, 3], iterator_to_array(loop(5, fib())));
|
||||
assertEquals([0, 1, 1, 2, 3, 5, 8, 13, 21, 34], iterator_to_array(loop(10, fib())));
|
||||
$this->assertEquals([0, 1, 1, 2, 3], iterator_to_array(loop(5, fib())));
|
||||
$this->assertEquals([0, 1, 1, 2, 3, 5, 8, 13, 21, 34], iterator_to_array(loop(10, fib())));
|
||||
}
|
||||
|
||||
public function testMean()
|
||||
{
|
||||
assertEquals(
|
||||
$this->assertEquals(
|
||||
(2 + 4 + 6 + 8 + 20 + 50 + 70) / 7,
|
||||
mean(2, 4, 6, 8, 20, 50, 70)
|
||||
);
|
||||
|
||||
assertEquals(
|
||||
$this->assertEquals(
|
||||
(-5 - 7 + 10) / 3,
|
||||
mean(-5, -7, 10)
|
||||
);
|
||||
|
||||
assertEquals(-1, mean(-1));
|
||||
$this->assertEquals(-1, mean(-1));
|
||||
}
|
||||
|
||||
public function testMedian()
|
||||
{
|
||||
assertEquals(3, median(1, 2, 3, 4, 5));
|
||||
assertEquals(4.5, median(1, 2, 3, 4, 5, 6, 7, 8));
|
||||
assertEquals(3, median(5, 3, 1, 2, 4));
|
||||
$this->assertEquals(3, median(1, 2, 3, 4, 5));
|
||||
$this->assertEquals(4.5, median(1, 2, 3, 4, 5, 6, 7, 8));
|
||||
$this->assertEquals(3, median(5, 3, 1, 2, 4));
|
||||
}
|
||||
|
||||
public function testMode()
|
||||
@ -146,5 +143,4 @@ class MathsTest extends TestCase
|
||||
$this->assertEquals([1, 2, 3, 4, 5], mode(1, 2, 3, 4, 5));
|
||||
$this->assertEquals([2, 3, 4], mode(2, 2, 3, 3, 4, 4));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -1,8 +1,5 @@
|
||||
<?php
|
||||
|
||||
use function PHPUnit\Framework\assertEquals;
|
||||
use function PHPUnit\Framework\assertFalse;
|
||||
use function PHPUnit\Framework\assertTrue;
|
||||
use PHPUnit\Framework\TestCase;
|
||||
|
||||
require_once __DIR__ . '/../../vendor/autoload.php';
|
||||
@ -24,16 +21,16 @@ class SearchesTest extends TestCase
|
||||
$list = [0, 5, 7, 10, 15];
|
||||
$target = 0;
|
||||
$result = binarySearchIterative($list, $target);
|
||||
assertEquals(0, $result);
|
||||
$this->assertEquals(0, $result);
|
||||
$target = 15;
|
||||
$result = binarySearchIterative($list, $target);
|
||||
assertEquals(4, $result);
|
||||
$this->assertEquals(4, $result);
|
||||
$target = 5;
|
||||
$result = binarySearchIterative($list, $target);
|
||||
assertEquals(1, $result);
|
||||
$this->assertEquals(1, $result);
|
||||
$target = 6;
|
||||
$result = binarySearchIterative($list, $target);
|
||||
assertEquals(null, $result);
|
||||
$this->assertEquals(null, $result);
|
||||
}
|
||||
|
||||
public function testBinarySearchByRecursion()
|
||||
@ -41,16 +38,16 @@ class SearchesTest extends TestCase
|
||||
$list = [0, 5, 7, 10, 15];
|
||||
$target = 0;
|
||||
$result = binarySearchByRecursion($list, $target, 0, 4);
|
||||
assertEquals(0, $result);
|
||||
$this->assertEquals(0, $result);
|
||||
$target = 15;
|
||||
$result = binarySearchByRecursion($list, $target, 0, 4);
|
||||
assertEquals(4, $result);
|
||||
$this->assertEquals(4, $result);
|
||||
$target = 5;
|
||||
$result = binarySearchByRecursion($list, $target, 0, 4);
|
||||
assertEquals(1, $result);
|
||||
$this->assertEquals(1, $result);
|
||||
$target = 6;
|
||||
$result = binarySearchByRecursion($list, $target, 0, 4);
|
||||
assertEquals(null, $result);
|
||||
$this->assertEquals(null, $result);
|
||||
}
|
||||
|
||||
public function testBinarySearchByRecursionWithEmptyList()
|
||||
@ -58,7 +55,7 @@ class SearchesTest extends TestCase
|
||||
$list = [];
|
||||
$target = 0;
|
||||
$result = binarySearchByRecursion($list, $target, 0, 0);
|
||||
assertEquals(null, $result);
|
||||
$this->assertEquals(null, $result);
|
||||
}
|
||||
|
||||
public function testBinarySearchByRecursionWithOneElementList()
|
||||
@ -66,10 +63,10 @@ class SearchesTest extends TestCase
|
||||
$list = [0];
|
||||
$target = 0;
|
||||
$result = binarySearchByRecursion($list, $target, 0, 0);
|
||||
assertEquals(0, $result);
|
||||
$this->assertEquals(0, $result);
|
||||
$target = 1;
|
||||
$result = binarySearchByRecursion($list, $target, 0, 0);
|
||||
assertEquals(null, $result);
|
||||
$this->assertEquals(null, $result);
|
||||
}
|
||||
|
||||
public function testBinarySearchByRecursionWithTwoElementList()
|
||||
@ -77,13 +74,13 @@ class SearchesTest extends TestCase
|
||||
$list = [0, 1];
|
||||
$target = 0;
|
||||
$result = binarySearchByRecursion($list, $target, 0, 1);
|
||||
assertEquals(0, $result);
|
||||
$this->assertEquals(0, $result);
|
||||
$target = 1;
|
||||
$result = binarySearchByRecursion($list, $target, 0, 1);
|
||||
assertEquals(1, $result);
|
||||
$this->assertEquals(1, $result);
|
||||
$target = 2;
|
||||
$result = binarySearchByRecursion($list, $target, 0, 1);
|
||||
assertEquals(null, $result);
|
||||
$this->assertEquals(null, $result);
|
||||
}
|
||||
|
||||
public function testBinarySearchByRecursionWithThreeElementList()
|
||||
@ -91,28 +88,28 @@ class SearchesTest extends TestCase
|
||||
$list = [0, 1, 2];
|
||||
$target = 0;
|
||||
$result = binarySearchByRecursion($list, $target, 0, 2);
|
||||
assertEquals(0, $result);
|
||||
$this->assertEquals(0, $result);
|
||||
$target = 1;
|
||||
$result = binarySearchByRecursion($list, $target, 0, 2);
|
||||
assertEquals(1, $result);
|
||||
$this->assertEquals(1, $result);
|
||||
$target = 2;
|
||||
$result = binarySearchByRecursion($list, $target, 0, 2);
|
||||
assertEquals(2, $result);
|
||||
$this->assertEquals(2, $result);
|
||||
$target = 3;
|
||||
$result = binarySearchByRecursion($list, $target, 0, 2);
|
||||
assertEquals(null, $result);
|
||||
$this->assertEquals(null, $result);
|
||||
}
|
||||
|
||||
public function testFibonacciSearch()
|
||||
{
|
||||
$test1 = fibonacciPosition(6);
|
||||
assertEquals(8, $test1);
|
||||
$this->assertEquals(8, $test1);
|
||||
|
||||
$test2 = fibonacciPosition(9);
|
||||
assertEquals(34, $test2);
|
||||
$this->assertEquals(34, $test2);
|
||||
|
||||
$test3 = fibonacciPosition(60);
|
||||
assertEquals(1548008755920, $test3);
|
||||
$this->assertEquals(1548008755920, $test3);
|
||||
}
|
||||
|
||||
public function testLinearSearch()
|
||||
@ -120,7 +117,7 @@ class SearchesTest extends TestCase
|
||||
$list = [5, 7, 8, 11, 12, 15, 17, 18, 20];
|
||||
$target = 15;
|
||||
$result = linearSearch($list, $target);
|
||||
assertEquals(6, $result);
|
||||
$this->assertEquals(6, $result);
|
||||
}
|
||||
|
||||
public function testLowerBound()
|
||||
@ -128,7 +125,7 @@ class SearchesTest extends TestCase
|
||||
$list = [1, 2, 3, 3, 3, 4, 5, 9];
|
||||
$target = 3;
|
||||
$result = lowerBound($list, $target);
|
||||
assertEquals(2, $result);
|
||||
$this->assertEquals(2, $result);
|
||||
}
|
||||
|
||||
public function testUpperBound()
|
||||
@ -136,7 +133,7 @@ class SearchesTest extends TestCase
|
||||
$list = [1, 2, 3, 3, 3, 4, 5, 9];
|
||||
$target = 3;
|
||||
$result = upperBound($list, $target);
|
||||
assertEquals(5, $result);
|
||||
$this->assertEquals(5, $result);
|
||||
}
|
||||
|
||||
public function testJumpSearch()
|
||||
@ -144,7 +141,7 @@ class SearchesTest extends TestCase
|
||||
$list = array( 3,5,6,7,9,10,12,20,22,24);
|
||||
$target = 12;
|
||||
$result = jumpSearch($list, $target);
|
||||
assertEquals(6, $result);
|
||||
$this->assertEquals(6, $result);
|
||||
}
|
||||
|
||||
public function testExponentialSearch()
|
||||
@ -152,7 +149,7 @@ class SearchesTest extends TestCase
|
||||
$list = array(2,3,4,7,28,35,63,98);
|
||||
$target = 35;
|
||||
$result = exponentialSearch($list, $target);
|
||||
assertEquals(5, $result);
|
||||
$this->assertEquals(5, $result);
|
||||
}
|
||||
|
||||
public function testTernarySearchIterative()
|
||||
@ -160,16 +157,16 @@ class SearchesTest extends TestCase
|
||||
$list = [0, 5, 7, 10, 15];
|
||||
$target = 0;
|
||||
$result = ternarySearchIterative($list, $target);
|
||||
assertEquals(0, $result);
|
||||
$this->assertEquals(0, $result);
|
||||
$target = 15;
|
||||
$result = ternarySearchIterative($list, $target);
|
||||
assertEquals(4, $result);
|
||||
$this->assertEquals(4, $result);
|
||||
$target = 5;
|
||||
$result = ternarySearchIterative($list, $target);
|
||||
assertEquals(1, $result);
|
||||
$this->assertEquals(1, $result);
|
||||
$target = 6;
|
||||
$result = ternarySearchIterative($list, $target);
|
||||
assertEquals(null, $result);
|
||||
$this->assertEquals(null, $result);
|
||||
}
|
||||
|
||||
public function testTernarySearchByRecursion()
|
||||
@ -177,16 +174,16 @@ class SearchesTest extends TestCase
|
||||
$list = [0, 5, 7, 10, 15];
|
||||
$target = 0;
|
||||
$result = ternarySearchByRecursion($list, $target, 0, 4);
|
||||
assertEquals(0, $result);
|
||||
$this->assertEquals(0, $result);
|
||||
$target = 15;
|
||||
$result = ternarySearchByRecursion($list, $target, 0, 4);
|
||||
assertEquals(4, $result);
|
||||
$this->assertEquals(4, $result);
|
||||
$target = 5;
|
||||
$result = ternarySearchByRecursion($list, $target, 0, 4);
|
||||
assertEquals(1, $result);
|
||||
$this->assertEquals(1, $result);
|
||||
$target = 6;
|
||||
$result = ternarySearchByRecursion($list, $target, 0, 4);
|
||||
assertEquals(null, $result);
|
||||
$this->assertEquals(null, $result);
|
||||
}
|
||||
|
||||
public function testInterpolationSearch()
|
||||
@ -194,15 +191,15 @@ class SearchesTest extends TestCase
|
||||
$list = [2, 6, 8, 10, 12, 14, 16, 18, 20, 22, 26, 34, 39];
|
||||
$target = 20;
|
||||
$result = interpolationSearch($list, $target);
|
||||
assertEquals(8, $result);
|
||||
$this->assertEquals(8, $result);
|
||||
$target = 12;
|
||||
$result = interpolationSearch($list, $target);
|
||||
assertEquals(4, $result);
|
||||
$this->assertEquals(4, $result);
|
||||
$target = 1000;
|
||||
$result = interpolationSearch($list, $target);
|
||||
assertEquals(null, $result);
|
||||
$this->assertEquals(null, $result);
|
||||
$target = 39;
|
||||
$result = interpolationSearch($list, $target);
|
||||
assertEquals(12, $result);
|
||||
$this->assertEquals(12, $result);
|
||||
}
|
||||
}
|
||||
|
||||
@ -7,7 +7,8 @@ use PHPUnit\Framework\TestCase;
|
||||
|
||||
class ArrayKeysSortTest extends TestCase
|
||||
{
|
||||
public function testArrayKeysSort() {
|
||||
public function testArrayKeysSort()
|
||||
{
|
||||
//test array of arrays
|
||||
$array1 = [
|
||||
['fruit' => 'banana', 'color' => 'yellow', 'cant' => 5],
|
||||
@ -36,22 +37,22 @@ class ArrayKeysSortTest extends TestCase
|
||||
$this->assertEquals($result2, $test2);
|
||||
|
||||
//test array of objects
|
||||
$object1 = new \stdClass;
|
||||
$object1 = new \stdClass();
|
||||
$object1->fruit = 'banana';
|
||||
$object1->color = 'yellow';
|
||||
$object1->cant = 5;
|
||||
|
||||
$object2 = new \stdClass;
|
||||
$object2 = new \stdClass();
|
||||
$object2->fruit = 'apple';
|
||||
$object2->color = 'red';
|
||||
$object2->cant = 2;
|
||||
|
||||
$object3 = new \stdClass;
|
||||
$object3 = new \stdClass();
|
||||
$object3->fruit = 'apple';
|
||||
$object3->color = 'green';
|
||||
$object3->cant = 7;
|
||||
|
||||
$object4 = new \stdClass;
|
||||
$object4 = new \stdClass();
|
||||
$object4->fruit = 'grapes';
|
||||
$object4->color = 'purple';
|
||||
$object4->cant = 4;
|
||||
|
||||
@ -24,9 +24,53 @@ class SortingTests extends TestCase
|
||||
|
||||
public function testBubbleSort2()
|
||||
{
|
||||
$array = [51158,1856,8459,67957,59748,58213,90876,39621,66570,64204,79935,27892,47615,94706,34201,74474,63968,4337,43688,42685,31577,5239,25385,56301,94083,23232,67025,44044,74813,34671,90235,65764,49709,12440,21165,20620,38265,12973,25236,93144,13720,4204,77026,42348,19756,97222,78828,73437,48208,69858,19713,29411,49809,66174,5257,43340,40565,9592,52328,16677,38386,55416,99519,13732,84076,52905,47662,31805,46184,2811,35374,50800,53635,51886,49052,75197,3720,75045,28309,63771,71526,16122,36625,44654,86814,98845,44637,54955,24714,81960,78095,49048,99711,272,45755,31919,8181,1392,15352,82656,27760,18362,43780,50209,51433,2847,62310,87450,22874,40789,56841,52928,5523,76474,8935,63245,16387,21746,47596,84402,49168,58223,26993,55908,92837,64208,86309,30819,83638,9508,44628,10786,68125,14123,70474,50596,44518,74872,61968,36828,17860,4605,68756,86070,52068,51830,56992,45799,42422,68514,92559,40206,31263,71774,14202,94807,25774,15003,54211,18708,32074,43836,48964,40742,26281,67338,75786,34925,34649,45519,72472,80188,40858,83246,92215,66178,67452,86198,82300,45894,97156,73907,31159,7018,55549,35245,68975,88246,14098,59973,7762,40459,86358,63178,47489,55515,79488,46528,99272,10867,75190,56963,5520,56494,42310,40171,78105,29724,30110,28493,36141,22479,85799,70466,92106,16868,57402,4813,47432,24689,78533,97577,32178,30258,82785,56063,76277,96407,77849,1807,45344,30298,18158,49935,90728,22192,36852,33982,66206,30948,40372,33446,99156,28651,61591,79028,1689,94257,32158,11122,81097,57981,26277,7515,7873,8350,28229,24105,76818,86897,18456,29373,7853,24932,93070,4696,63015,9358,28302,3938,11754,33679,18492,91503,63395,12029,23954,27230,58336,16544,23606,61349,37348,78629,96145,57954,32392,76201,54616,59992,5676,97799,47910,98758,75043,72849,6466,68831,2246,69091,22296,6506,93729,86968,39583,46186,96782,19074,46574,46704,99211,55295,33963,77977,86805,72686];
|
||||
$array = [
|
||||
51158, 1856, 8459, 67957, 59748, 58213, 90876, 39621, 66570, 64204, 79935, 27892, 47615, 94706, 34201,
|
||||
74474, 63968, 4337, 43688, 42685, 31577, 5239, 25385, 56301, 94083, 23232, 67025, 44044, 74813, 34671,
|
||||
90235, 65764, 49709, 12440, 21165, 20620, 38265, 12973, 25236, 93144, 13720, 4204, 77026, 42348, 19756,
|
||||
97222, 78828, 73437, 48208, 69858, 19713, 29411, 49809, 66174, 5257, 43340, 40565, 9592, 52328, 16677,
|
||||
38386, 55416, 99519, 13732, 84076, 52905, 47662, 31805, 46184, 2811, 35374, 50800, 53635, 51886, 49052,
|
||||
75197, 3720, 75045, 28309, 63771, 71526, 16122, 36625, 44654, 86814, 98845, 44637, 54955, 24714, 81960,
|
||||
78095, 49048, 99711, 272, 45755, 31919, 8181, 1392, 15352, 82656, 27760, 18362, 43780, 50209, 51433, 2847,
|
||||
62310, 87450, 22874, 40789, 56841, 52928, 5523, 76474, 8935, 63245, 16387, 21746, 47596, 84402, 49168,
|
||||
58223, 26993, 55908, 92837, 64208, 86309, 30819, 83638, 9508, 44628, 10786, 68125, 14123, 70474, 50596,
|
||||
44518, 74872, 61968, 36828, 17860, 4605, 68756, 86070, 52068, 51830, 56992, 45799, 42422, 68514, 92559,
|
||||
40206, 31263, 71774, 14202, 94807, 25774, 15003, 54211, 18708, 32074, 43836, 48964, 40742, 26281, 67338,
|
||||
75786, 34925, 34649, 45519, 72472, 80188, 40858, 83246, 92215, 66178, 67452, 86198, 82300, 45894, 97156,
|
||||
73907, 31159, 7018, 55549, 35245, 68975, 88246, 14098, 59973, 7762, 40459, 86358, 63178, 47489, 55515,
|
||||
79488, 46528, 99272, 10867, 75190, 56963, 5520, 56494, 42310, 40171, 78105, 29724, 30110, 28493, 36141,
|
||||
22479, 85799, 70466, 92106, 16868, 57402, 4813, 47432, 24689, 78533, 97577, 32178, 30258, 82785, 56063,
|
||||
76277, 96407, 77849, 1807, 45344, 30298, 18158, 49935, 90728, 22192, 36852, 33982, 66206, 30948, 40372,
|
||||
33446, 99156, 28651, 61591, 79028, 1689, 94257, 32158, 11122, 81097, 57981, 26277, 7515, 7873, 8350, 28229,
|
||||
24105, 76818, 86897, 18456, 29373, 7853, 24932, 93070, 4696, 63015, 9358, 28302, 3938, 11754, 33679, 18492,
|
||||
91503, 63395, 12029, 23954, 27230, 58336, 16544, 23606, 61349, 37348, 78629, 96145, 57954, 32392, 76201,
|
||||
54616, 59992, 5676, 97799, 47910, 98758, 75043, 72849, 6466, 68831, 2246, 69091, 22296, 6506, 93729, 86968,
|
||||
39583, 46186, 96782, 19074, 46574, 46704, 99211, 55295, 33963, 77977, 86805, 72686
|
||||
];
|
||||
$sorted = bubbleSort2($array);
|
||||
$this->assertEquals([272, 1392, 1689, 1807, 1856, 2246, 2811, 2847, 3720, 3938, 4204, 4337, 4605, 4696, 4813, 5239, 5257, 5520, 5523, 5676, 6466, 6506, 7018, 7515, 7762, 7853, 7873, 8181, 8350, 8459, 8935, 9358, 9508, 9592, 10786, 10867, 11122, 11754, 12029, 12440, 12973, 13720, 13732, 14098, 14123, 14202, 15003, 15352, 16122, 16387, 16544, 16677, 16868, 17860, 18158, 18362, 18456, 18492, 18708, 19074, 19713, 19756, 20620, 21165, 21746, 22192, 22296, 22479, 22874, 23232, 23606, 23954, 24105, 24689, 24714, 24932, 25236, 25385, 25774, 26277, 26281, 26993, 27230, 27760, 27892, 28229, 28302, 28309, 28493, 28651, 29373, 29411, 29724, 30110, 30258, 30298, 30819, 30948, 31159, 31263, 31577, 31805, 31919, 32074, 32158, 32178, 32392, 33446, 33679, 33963, 33982, 34201, 34649, 34671, 34925, 35245, 35374, 36141, 36625, 36828, 36852, 37348, 38265, 38386, 39583, 39621, 40171, 40206, 40372, 40459, 40565, 40742, 40789, 40858, 42310, 42348, 42422, 42685, 43340, 43688, 43780, 43836, 44044, 44518, 44628, 44637, 44654, 45344, 45519, 45755, 45799, 45894, 46184, 46186, 46528, 46574, 46704, 47432, 47489, 47596, 47615, 47662, 47910, 48208, 48964, 49048, 49052, 49168, 49709, 49809, 49935, 50209, 50596, 50800, 51158, 51433, 51830, 51886, 52068, 52328, 52905, 52928, 53635, 54211, 54616, 54955, 55295, 55416, 55515, 55549, 55908, 56063, 56301, 56494, 56841, 56963, 56992, 57402, 57954, 57981, 58213, 58223, 58336, 59748, 59973, 59992, 61349, 61591, 61968, 62310, 63015, 63178, 63245, 63395, 63771, 63968, 64204, 64208, 65764, 66174, 66178, 66206, 66570, 67025, 67338, 67452, 67957, 68125, 68514, 68756, 68831, 68975, 69091, 69858, 70466, 70474, 71526, 71774, 72472, 72686, 72849, 73437, 73907, 74474, 74813, 74872, 75043, 75045, 75190, 75197, 75786, 76201, 76277, 76474, 76818, 77026, 77849, 77977, 78095, 78105, 78533, 78629, 78828, 79028, 79488, 79935, 80188, 81097, 81960, 82300, 82656, 82785, 83246, 83638, 84076, 84402, 85799, 86070, 86198, 86309, 86358, 86805, 86814, 86897, 86968, 87450, 88246, 90235, 90728, 90876, 91503, 92106, 92215, 92559, 92837, 93070, 93144, 93729, 94083, 94257, 94706, 94807, 96145, 96407, 96782, 97156, 97222, 97577, 97799, 98758, 98845, 99156, 99211, 99272, 99519, 99711], $sorted);
|
||||
$this->assertEquals([
|
||||
272, 1392, 1689, 1807, 1856, 2246, 2811, 2847, 3720, 3938, 4204, 4337, 4605, 4696, 4813, 5239, 5257, 5520,
|
||||
5523, 5676, 6466, 6506, 7018, 7515, 7762, 7853, 7873, 8181, 8350, 8459, 8935, 9358, 9508, 9592, 10786,
|
||||
10867, 11122, 11754, 12029, 12440, 12973, 13720, 13732, 14098, 14123, 14202, 15003, 15352, 16122, 16387,
|
||||
16544, 16677, 16868, 17860, 18158, 18362, 18456, 18492, 18708, 19074, 19713, 19756, 20620, 21165, 21746,
|
||||
22192, 22296, 22479, 22874, 23232, 23606, 23954, 24105, 24689, 24714, 24932, 25236, 25385, 25774, 26277,
|
||||
26281, 26993, 27230, 27760, 27892, 28229, 28302, 28309, 28493, 28651, 29373, 29411, 29724, 30110, 30258,
|
||||
30298, 30819, 30948, 31159, 31263, 31577, 31805, 31919, 32074, 32158, 32178, 32392, 33446, 33679, 33963,
|
||||
33982, 34201, 34649, 34671, 34925, 35245, 35374, 36141, 36625, 36828, 36852, 37348, 38265, 38386, 39583,
|
||||
39621, 40171, 40206, 40372, 40459, 40565, 40742, 40789, 40858, 42310, 42348, 42422, 42685, 43340, 43688,
|
||||
43780, 43836, 44044, 44518, 44628, 44637, 44654, 45344, 45519, 45755, 45799, 45894, 46184, 46186, 46528,
|
||||
46574, 46704, 47432, 47489, 47596, 47615, 47662, 47910, 48208, 48964, 49048, 49052, 49168, 49709, 49809,
|
||||
49935, 50209, 50596, 50800, 51158, 51433, 51830, 51886, 52068, 52328, 52905, 52928, 53635, 54211, 54616,
|
||||
54955, 55295, 55416, 55515, 55549, 55908, 56063, 56301, 56494, 56841, 56963, 56992, 57402, 57954, 57981,
|
||||
58213, 58223, 58336, 59748, 59973, 59992, 61349, 61591, 61968, 62310, 63015, 63178, 63245, 63395, 63771,
|
||||
63968, 64204, 64208, 65764, 66174, 66178, 66206, 66570, 67025, 67338, 67452, 67957, 68125, 68514, 68756,
|
||||
68831, 68975, 69091, 69858, 70466, 70474, 71526, 71774, 72472, 72686, 72849, 73437, 73907, 74474, 74813,
|
||||
74872, 75043, 75045, 75190, 75197, 75786, 76201, 76277, 76474, 76818, 77026, 77849, 77977, 78095, 78105,
|
||||
78533, 78629, 78828, 79028, 79488, 79935, 80188, 81097, 81960, 82300, 82656, 82785, 83246, 83638, 84076,
|
||||
84402, 85799, 86070, 86198, 86309, 86358, 86805, 86814, 86897, 86968, 87450, 88246, 90235, 90728, 90876,
|
||||
91503, 92106, 92215, 92559, 92837, 93070, 93144, 93729, 94083, 94257, 94706, 94807, 96145, 96407, 96782,
|
||||
97156, 97222, 97577, 97799, 98758, 98845, 99156, 99211, 99272, 99519, 99711
|
||||
], $sorted);
|
||||
}
|
||||
|
||||
public function testCountSort()
|
||||
@ -54,9 +98,53 @@ class SortingTests extends TestCase
|
||||
|
||||
public function testQuickSort()
|
||||
{
|
||||
$array = [51158,1856,8459,67957,59748,58213,90876,39621,66570,64204,79935,27892,47615,94706,34201,74474,63968,4337,43688,42685,31577,5239,25385,56301,94083,23232,67025,44044,74813,34671,90235,65764,49709,12440,21165,20620,38265,12973,25236,93144,13720,4204,77026,42348,19756,97222,78828,73437,48208,69858,19713,29411,49809,66174,5257,43340,40565,9592,52328,16677,38386,55416,99519,13732,84076,52905,47662,31805,46184,2811,35374,50800,53635,51886,49052,75197,3720,75045,28309,63771,71526,16122,36625,44654,86814,98845,44637,54955,24714,81960,78095,49048,99711,272,45755,31919,8181,1392,15352,82656,27760,18362,43780,50209,51433,2847,62310,87450,22874,40789,56841,52928,5523,76474,8935,63245,16387,21746,47596,84402,49168,58223,26993,55908,92837,64208,86309,30819,83638,9508,44628,10786,68125,14123,70474,50596,44518,74872,61968,36828,17860,4605,68756,86070,52068,51830,56992,45799,42422,68514,92559,40206,31263,71774,14202,94807,25774,15003,54211,18708,32074,43836,48964,40742,26281,67338,75786,34925,34649,45519,72472,80188,40858,83246,92215,66178,67452,86198,82300,45894,97156,73907,31159,7018,55549,35245,68975,88246,14098,59973,7762,40459,86358,63178,47489,55515,79488,46528,99272,10867,75190,56963,5520,56494,42310,40171,78105,29724,30110,28493,36141,22479,85799,70466,92106,16868,57402,4813,47432,24689,78533,97577,32178,30258,82785,56063,76277,96407,77849,1807,45344,30298,18158,49935,90728,22192,36852,33982,66206,30948,40372,33446,99156,28651,61591,79028,1689,94257,32158,11122,81097,57981,26277,7515,7873,8350,28229,24105,76818,86897,18456,29373,7853,24932,93070,4696,63015,9358,28302,3938,11754,33679,18492,91503,63395,12029,23954,27230,58336,16544,23606,61349,37348,78629,96145,57954,32392,76201,54616,59992,5676,97799,47910,98758,75043,72849,6466,68831,2246,69091,22296,6506,93729,86968,39583,46186,96782,19074,46574,46704,99211,55295,33963,77977,86805,72686];
|
||||
$array = [
|
||||
51158, 1856, 8459, 67957, 59748, 58213, 90876, 39621, 66570, 64204, 79935, 27892, 47615, 94706, 34201,
|
||||
74474, 63968, 4337, 43688, 42685, 31577, 5239, 25385, 56301, 94083, 23232, 67025, 44044, 74813, 34671,
|
||||
90235, 65764, 49709, 12440, 21165, 20620, 38265, 12973, 25236, 93144, 13720, 4204, 77026, 42348, 19756,
|
||||
97222, 78828, 73437, 48208, 69858, 19713, 29411, 49809, 66174, 5257, 43340, 40565, 9592, 52328, 16677,
|
||||
38386, 55416, 99519, 13732, 84076, 52905, 47662, 31805, 46184, 2811, 35374, 50800, 53635, 51886, 49052,
|
||||
75197, 3720, 75045, 28309, 63771, 71526, 16122, 36625, 44654, 86814, 98845, 44637, 54955, 24714, 81960,
|
||||
78095, 49048, 99711, 272, 45755, 31919, 8181, 1392, 15352, 82656, 27760, 18362, 43780, 50209, 51433, 2847,
|
||||
62310, 87450, 22874, 40789, 56841, 52928, 5523, 76474, 8935, 63245, 16387, 21746, 47596, 84402, 49168,
|
||||
58223, 26993, 55908, 92837, 64208, 86309, 30819, 83638, 9508, 44628, 10786, 68125, 14123, 70474, 50596,
|
||||
44518, 74872, 61968, 36828, 17860, 4605, 68756, 86070, 52068, 51830, 56992, 45799, 42422, 68514, 92559,
|
||||
40206, 31263, 71774, 14202, 94807, 25774, 15003, 54211, 18708, 32074, 43836, 48964, 40742, 26281, 67338,
|
||||
75786, 34925, 34649, 45519, 72472, 80188, 40858, 83246, 92215, 66178, 67452, 86198, 82300, 45894, 97156,
|
||||
73907, 31159, 7018, 55549, 35245, 68975, 88246, 14098, 59973, 7762, 40459, 86358, 63178, 47489, 55515,
|
||||
79488, 46528, 99272, 10867, 75190, 56963, 5520, 56494, 42310, 40171, 78105, 29724, 30110, 28493, 36141,
|
||||
22479, 85799, 70466, 92106, 16868, 57402, 4813, 47432, 24689, 78533, 97577, 32178, 30258, 82785, 56063,
|
||||
76277, 96407, 77849, 1807, 45344, 30298, 18158, 49935, 90728, 22192, 36852, 33982, 66206, 30948, 40372,
|
||||
33446, 99156, 28651, 61591, 79028, 1689, 94257, 32158, 11122, 81097, 57981, 26277, 7515, 7873, 8350, 28229,
|
||||
24105, 76818, 86897, 18456, 29373, 7853, 24932, 93070, 4696, 63015, 9358, 28302, 3938, 11754, 33679, 18492,
|
||||
91503, 63395, 12029, 23954, 27230, 58336, 16544, 23606, 61349, 37348, 78629, 96145, 57954, 32392, 76201,
|
||||
54616, 59992, 5676, 97799, 47910, 98758, 75043, 72849, 6466, 68831, 2246, 69091, 22296, 6506, 93729, 86968,
|
||||
39583, 46186, 96782, 19074, 46574, 46704, 99211, 55295, 33963, 77977, 86805, 72686
|
||||
];
|
||||
$sorted = quickSort($array);
|
||||
$this->assertEquals([272, 1392, 1689, 1807, 1856, 2246, 2811, 2847, 3720, 3938, 4204, 4337, 4605, 4696, 4813, 5239, 5257, 5520, 5523, 5676, 6466, 6506, 7018, 7515, 7762, 7853, 7873, 8181, 8350, 8459, 8935, 9358, 9508, 9592, 10786, 10867, 11122, 11754, 12029, 12440, 12973, 13720, 13732, 14098, 14123, 14202, 15003, 15352, 16122, 16387, 16544, 16677, 16868, 17860, 18158, 18362, 18456, 18492, 18708, 19074, 19713, 19756, 20620, 21165, 21746, 22192, 22296, 22479, 22874, 23232, 23606, 23954, 24105, 24689, 24714, 24932, 25236, 25385, 25774, 26277, 26281, 26993, 27230, 27760, 27892, 28229, 28302, 28309, 28493, 28651, 29373, 29411, 29724, 30110, 30258, 30298, 30819, 30948, 31159, 31263, 31577, 31805, 31919, 32074, 32158, 32178, 32392, 33446, 33679, 33963, 33982, 34201, 34649, 34671, 34925, 35245, 35374, 36141, 36625, 36828, 36852, 37348, 38265, 38386, 39583, 39621, 40171, 40206, 40372, 40459, 40565, 40742, 40789, 40858, 42310, 42348, 42422, 42685, 43340, 43688, 43780, 43836, 44044, 44518, 44628, 44637, 44654, 45344, 45519, 45755, 45799, 45894, 46184, 46186, 46528, 46574, 46704, 47432, 47489, 47596, 47615, 47662, 47910, 48208, 48964, 49048, 49052, 49168, 49709, 49809, 49935, 50209, 50596, 50800, 51158, 51433, 51830, 51886, 52068, 52328, 52905, 52928, 53635, 54211, 54616, 54955, 55295, 55416, 55515, 55549, 55908, 56063, 56301, 56494, 56841, 56963, 56992, 57402, 57954, 57981, 58213, 58223, 58336, 59748, 59973, 59992, 61349, 61591, 61968, 62310, 63015, 63178, 63245, 63395, 63771, 63968, 64204, 64208, 65764, 66174, 66178, 66206, 66570, 67025, 67338, 67452, 67957, 68125, 68514, 68756, 68831, 68975, 69091, 69858, 70466, 70474, 71526, 71774, 72472, 72686, 72849, 73437, 73907, 74474, 74813, 74872, 75043, 75045, 75190, 75197, 75786, 76201, 76277, 76474, 76818, 77026, 77849, 77977, 78095, 78105, 78533, 78629, 78828, 79028, 79488, 79935, 80188, 81097, 81960, 82300, 82656, 82785, 83246, 83638, 84076, 84402, 85799, 86070, 86198, 86309, 86358, 86805, 86814, 86897, 86968, 87450, 88246, 90235, 90728, 90876, 91503, 92106, 92215, 92559, 92837, 93070, 93144, 93729, 94083, 94257, 94706, 94807, 96145, 96407, 96782, 97156, 97222, 97577, 97799, 98758, 98845, 99156, 99211, 99272, 99519, 99711], $sorted);
|
||||
$this->assertEquals([
|
||||
272, 1392, 1689, 1807, 1856, 2246, 2811, 2847, 3720, 3938, 4204, 4337, 4605, 4696, 4813, 5239, 5257, 5520,
|
||||
5523, 5676, 6466, 6506, 7018, 7515, 7762, 7853, 7873, 8181, 8350, 8459, 8935, 9358, 9508, 9592, 10786,
|
||||
10867, 11122, 11754, 12029, 12440, 12973, 13720, 13732, 14098, 14123, 14202, 15003, 15352, 16122, 16387,
|
||||
16544, 16677, 16868, 17860, 18158, 18362, 18456, 18492, 18708, 19074, 19713, 19756, 20620, 21165, 21746,
|
||||
22192, 22296, 22479, 22874, 23232, 23606, 23954, 24105, 24689, 24714, 24932, 25236, 25385, 25774, 26277,
|
||||
26281, 26993, 27230, 27760, 27892, 28229, 28302, 28309, 28493, 28651, 29373, 29411, 29724, 30110, 30258,
|
||||
30298, 30819, 30948, 31159, 31263, 31577, 31805, 31919, 32074, 32158, 32178, 32392, 33446, 33679, 33963,
|
||||
33982, 34201, 34649, 34671, 34925, 35245, 35374, 36141, 36625, 36828, 36852, 37348, 38265, 38386, 39583,
|
||||
39621, 40171, 40206, 40372, 40459, 40565, 40742, 40789, 40858, 42310, 42348, 42422, 42685, 43340, 43688,
|
||||
43780, 43836, 44044, 44518, 44628, 44637, 44654, 45344, 45519, 45755, 45799, 45894, 46184, 46186, 46528,
|
||||
46574, 46704, 47432, 47489, 47596, 47615, 47662, 47910, 48208, 48964, 49048, 49052, 49168, 49709, 49809,
|
||||
49935, 50209, 50596, 50800, 51158, 51433, 51830, 51886, 52068, 52328, 52905, 52928, 53635, 54211, 54616,
|
||||
54955, 55295, 55416, 55515, 55549, 55908, 56063, 56301, 56494, 56841, 56963, 56992, 57402, 57954, 57981,
|
||||
58213, 58223, 58336, 59748, 59973, 59992, 61349, 61591, 61968, 62310, 63015, 63178, 63245, 63395, 63771,
|
||||
63968, 64204, 64208, 65764, 66174, 66178, 66206, 66570, 67025, 67338, 67452, 67957, 68125, 68514, 68756,
|
||||
68831, 68975, 69091, 69858, 70466, 70474, 71526, 71774, 72472, 72686, 72849, 73437, 73907, 74474, 74813,
|
||||
74872, 75043, 75045, 75190, 75197, 75786, 76201, 76277, 76474, 76818, 77026, 77849, 77977, 78095, 78105,
|
||||
78533, 78629, 78828, 79028, 79488, 79935, 80188, 81097, 81960, 82300, 82656, 82785, 83246, 83638, 84076,
|
||||
84402, 85799, 86070, 86198, 86309, 86358, 86805, 86814, 86897, 86968, 87450, 88246, 90235, 90728, 90876,
|
||||
91503, 92106, 92215, 92559, 92837, 93070, 93144, 93729, 94083, 94257, 94706, 94807, 96145, 96407, 96782,
|
||||
97156, 97222, 97577, 97799, 98758, 98845, 99156, 99211, 99272, 99519, 99711
|
||||
], $sorted);
|
||||
}
|
||||
|
||||
public function testQuickSortWithEmptyInput()
|
||||
|
||||
@ -1,9 +1,5 @@
|
||||
<?php
|
||||
|
||||
use function PHPUnit\Framework\assertEquals;
|
||||
use function PHPUnit\Framework\assertFalse;
|
||||
use function PHPUnit\Framework\assertNotEquals;
|
||||
use function PHPUnit\Framework\assertTrue;
|
||||
use PHPUnit\Framework\TestCase;
|
||||
|
||||
require_once __DIR__ . '/../../vendor/autoload.php';
|
||||
@ -23,73 +19,74 @@ class StringsTest extends TestCase
|
||||
{
|
||||
public function testIsPalindrome()
|
||||
{
|
||||
assertTrue(isPalindrome('MaDam')); // true
|
||||
assertFalse(isPalindrome('ThisIsTest')); // false
|
||||
assertFalse(isPalindrome('')); // false
|
||||
assertTrue(isPalindrome('Sator Arepo Tenet Opera Rotas')); // true
|
||||
assertFalse(isPalindrome('Sator Arepo Tenet Opera Rotas', false)); // false since we are doing case-sensitive check
|
||||
$this->assertTrue(isPalindrome('MaDam')); // true
|
||||
$this->assertFalse(isPalindrome('ThisIsTest')); // false
|
||||
$this->assertFalse(isPalindrome('')); // false
|
||||
$this->assertTrue(isPalindrome('Sator Arepo Tenet Opera Rotas')); // true
|
||||
$this->assertFalse(isPalindrome('Sator Arepo Tenet Opera Rotas', false)); // false since we are doing
|
||||
// case-sensitive check
|
||||
}
|
||||
|
||||
public function testCountSentences()
|
||||
{
|
||||
assertEquals(countSentences('Hi! Hello world.'), 2);
|
||||
assertEquals(countSentences('i am testing. test....'), 2);
|
||||
assertEquals(countSentences('How are you?'), 1);
|
||||
$this->assertEquals(2, countSentences('Hi! Hello world.'));
|
||||
$this->assertEquals(2, countSentences('i am testing. test....'));
|
||||
$this->assertEquals(1, countSentences('How are you?'));
|
||||
}
|
||||
|
||||
public function testReverseString()
|
||||
{
|
||||
assertEquals('txet emos si sihT', reverseString('This is some text'));
|
||||
assertEquals('mADaM', reverseString('MaDAm'));
|
||||
assertNotEquals('MaDAm', reverseString('MaDAm'));
|
||||
$this->assertEquals('txet emos si sihT', reverseString('This is some text'));
|
||||
$this->assertEquals('mADaM', reverseString('MaDAm'));
|
||||
$this->assertNotEquals('MaDAm', reverseString('MaDAm'));
|
||||
}
|
||||
|
||||
public function testReverseWords()
|
||||
{
|
||||
assertEquals('Fun is Coding PHP', reverseWords('PHP Coding is Fun'));
|
||||
assertEquals('OneWord', reverseWords('OneWord'));
|
||||
assertEquals('Text different some is This', reverseWords('This is some different Text'));
|
||||
$this->assertEquals('Fun is Coding PHP', reverseWords('PHP Coding is Fun'));
|
||||
$this->assertEquals('OneWord', reverseWords('OneWord'));
|
||||
$this->assertEquals('Text different some is This', reverseWords('This is some different Text'));
|
||||
}
|
||||
|
||||
public function testIsAnagram()
|
||||
{
|
||||
assertTrue(isAnagram("php", "PHP")); // By default it's case-insensitive
|
||||
assertFalse(isAnagram("php", "PHP", false)); // Make case-sensitive check
|
||||
assertTrue(isAnagram("php is fun", "pin hpf us"));
|
||||
assertFalse(isAnagram("Hello", " Hello")); //Extra space character
|
||||
assertTrue(isAnagram("ScRamble", "SRlmcaeb", false)); // Check with a mixture of upper and lower case
|
||||
$this->assertTrue(isAnagram("php", "PHP")); // By default it's case-insensitive
|
||||
$this->assertFalse(isAnagram("php", "PHP", false)); // Make case-sensitive check
|
||||
$this->assertTrue(isAnagram("php is fun", "pin hpf us"));
|
||||
$this->assertFalse(isAnagram("Hello", " Hello")); //Extra space character
|
||||
$this->assertTrue(isAnagram("ScRamble", "SRlmcaeb", false)); // Check with a mixture of upper and lower case
|
||||
}
|
||||
|
||||
public function testMaxCharacter()
|
||||
{
|
||||
assertEquals(maxCharacter("this is test for max character repetition"), 't');
|
||||
assertEquals(maxCharacter("This is Test for max characTer repetition"), 't');
|
||||
assertEquals(maxCharacter(" "), ' ');
|
||||
$this->assertEquals('t', maxCharacter("this is test for max character repetition"));
|
||||
$this->assertEquals('t', maxCharacter("This is Test for max characTer repetition"));
|
||||
$this->assertEquals(' ', maxCharacter(" "));
|
||||
}
|
||||
|
||||
public function testCountVowels()
|
||||
{
|
||||
assertEquals(countVowelsSimple("This is a string with 7 vowels"), 7);
|
||||
assertEquals(countVowelsSimple("hello world"), 3);
|
||||
assertEquals(countVowelsRegex("Just A list of somE aaaaaaaaaa"), 16);
|
||||
$this->assertEquals(7, countVowelsSimple("This is a string with 7 vowels"));
|
||||
$this->assertEquals(3, countVowelsSimple("hello world"));
|
||||
$this->assertEquals(16, countVowelsRegex("Just A list of somE aaaaaaaaaa"));
|
||||
|
||||
assertEquals(countVowelsRegex("This is a string with 7 vowels"), 7);
|
||||
assertEquals(countVowelsRegex("hello world"), 3);
|
||||
assertEquals(countVowelsRegex("Just A list of somE aaaaaaaaaa"), 16);
|
||||
$this->assertEquals(7, countVowelsRegex("This is a string with 7 vowels"));
|
||||
$this->assertEquals(3, countVowelsRegex("hello world"));
|
||||
$this->assertEquals(16, countVowelsRegex("Just A list of somE aaaaaaaaaa"));
|
||||
}
|
||||
|
||||
public function testCountConsonants()
|
||||
{
|
||||
assertEquals(countConsonants("This is a string with 19 consonants"), 19);
|
||||
assertEquals(countConsonants("hello world"), 7);
|
||||
assertEquals(countConsonants("Just A list of somE aaaaaaaaaa"), 9);
|
||||
$this->assertEquals(19, countConsonants("This is a string with 19 consonants"));
|
||||
$this->assertEquals(7, countConsonants("hello world"));
|
||||
$this->assertEquals(9, countConsonants("Just A list of somE aaaaaaaaaa"));
|
||||
}
|
||||
|
||||
public function testFindDistance()
|
||||
{
|
||||
assertEquals(findDistance("hello", "hallo"), 1);
|
||||
assertEquals(findDistance("hallo", "hello"), 1);
|
||||
assertEquals(findDistance("sunday", "sunday"), 0);
|
||||
assertEquals(findDistance("saturday", "sunday"), 3);
|
||||
$this->assertEquals(1, findDistance("hello", "hallo"));
|
||||
$this->assertEquals(1, findDistance("hallo", "hello"));
|
||||
$this->assertEquals(0, findDistance("sunday", "sunday"));
|
||||
$this->assertEquals(3, findDistance("saturday", "sunday"));
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user