PHP exercises

<?php
$name = "Ada";
echo "Hello, $name\n";

<?php
$scores = [82, 91, 76];
foreach ($scores as $score) {
    echo "$score\n";
}

<?php
function average(array $values): float {
    return array_sum($values) / count($values);
}

echo average([82, 91, 76, 95]), "\n";
echo round(average([1, 2]), 1), "\n";

<?php
$name = "Programonic";
echo strlen($name), " ", substr($name, 0, 7), " ", strpos($name, "m"), "\n";
echo sprintf("%05.1f|%-8s|%'*8s|%x", 3.14159, "left", "right", 255), "\n";

$parts = explode(",", "a,b,,c");
echo count($parts), " ", implode("-", $parts), "\n";
echo str_contains("haystack", "st") ? "yes" : "no", " ", ucfirst("php"), " ", strrev("abc"), "\n";

if (preg_match('/^(\d{4})-(\d{2})-(\d{2})$/', "2024-03-15", $m)) {
    echo $m[1], "/", $m[2], "/", $m[3], "\n";
}
echo preg_replace('/\s+/', ' ', "too    many   spaces"), "\n";
echo str_pad("7", 3, "0", STR_PAD_LEFT), "\n";

<?php
declare(strict_types=1);

function describe(int|string|null $value): string
{
    return match (true) {
        $value === null => "nothing",
        is_int($value) && $value < 0 => "negative int",
        is_int($value) => "int $value",
        default => "string '$value'",
    };
}

echo describe(5), "\n", describe(-2), "\n", describe("hi"), "\n", describe(null), "\n";

class Address
{
    public function __construct(public ?string $city = null) {}
}

class User
{
    public function __construct(public string $name, public ?Address $address = null) {}
}

$users = [new User("Ada", new Address("London")), new User("Bo")];
foreach ($users as $user) {
    echo $user->name, ": ", $user->address?->city ?? "unknown", "\n";
}

try {
    echo strlen(123);
} catch (TypeError $e) {
    echo "TypeError caught\n";
}

<?php
$numbers = [1, 2, 3, 4, 5, 6];

$squares = array_map(fn($n) => $n * $n, $numbers);
$evens = array_filter($squares, fn($n) => $n % 2 === 0);
$sum = array_reduce($evens, fn($carry, $n) => $carry + $n, 0);
echo implode(",", $squares), " | ", implode(",", $evens), " | ", $sum, "\n";

$rate = 3;
$multiply = function (int $n) use ($rate) {
    return $n * $rate;
};
echo $multiply(5), "\n";

$total = 0;
array_walk($numbers, function ($n) use (&$total) {
    $total += $n;
});
echo $total, "\n";

function fibonacci(): Generator
{
    [$a, $b] = [0, 1];
    while (true) {
        yield $a;
        [$a, $b] = [$b, $a + $b];
    }
}

$first = [];
foreach (fibonacci() as $value) {
    if (count($first) === 10) {
        break;
    }
    $first[] = $value;
}
echo implode(" ", $first), "\n";

<?php
class Counter {
    private int $value = 0;

    public function increment(): void {
        $this->value++;
    }

    public function value(): int {
        return $this->value;
    }
}

$counter = new Counter();
$counter->increment();
$counter->increment();
echo $counter->value(), "\n";

<?php
interface Shape
{
    public function area(): float;
}

trait Describes
{
    public function describe(): string
    {
        return static::class . " with area " . number_format($this->area(), 2);
    }
}

abstract class Base implements Shape
{
    use Describes;
}

final class Circle extends Base
{
    public function __construct(private float $radius) {}

    public function area(): float
    {
        return M_PI * $this->radius ** 2;
    }
}

final class Rect extends Base
{
    public function __construct(private float $width, private float $height) {}

    public function area(): float
    {
        return $this->width * $this->height;
    }
}

foreach ([new Circle(1.5), new Rect(2, 3.5)] as $shape) {
    echo $shape->describe(), "\n";
}
echo (new Circle(1)) instanceof Shape ? "a Circle is a Shape" : "not a Shape", "\n";

<?php
$scores = ["Ada" => 91, "Grace" => 88];
$scores["Linus"] = 79;
foreach ($scores as $name => $score) {
    echo "$name: $score\n";
}
echo count($scores), "\n";

<?php
$numbers = [5, 2, 9, 1, 5, 6];
sort($numbers);
echo implode(" ", $numbers), "\n";
rsort($numbers);
echo implode(" ", $numbers), "\n";

$people = [["Ada", 30], ["Bo", 25], ["Cy", 30], ["Di", 25]];
usort($people, fn($a, $b) => $a[1] <=> $b[1] ?: strcmp($a[0], $b[0]));
echo implode(",", array_column($people, 0)), "\n";

$words = ["pear", "apple", "Fig"];
sort($words);
echo implode(",", $words), "\n";
sort($words, SORT_FLAG_CASE | SORT_STRING);
echo implode(",", $words), "\n";

$scores = ["Ada" => 90, "Bo" => 85, "Cy" => 90];
arsort($scores);
echo implode(",", array_keys($scores)), "\n";

<?php
$stack = new SplStack();
$stack->push("a");
$stack->push("b");
$stack->push("c");
echo $stack->pop(), " ", $stack->top(), " ", count($stack), "\n";

$queue = new SplQueue();
$queue->enqueue(1);
$queue->enqueue(2);
$queue->enqueue(3);
echo $queue->dequeue(), " ", $queue->dequeue(), " ", count($queue), "\n";

$heap = new SplMinHeap();
foreach ([5, 1, 8, 3] as $value) {
    $heap->insert($value);
}
echo $heap->extract(), " ", $heap->top(), "\n";

$tasks = new SplPriorityQueue();
$tasks->insert("low", 1);
$tasks->insert("high", 10);
$tasks->insert("medium", 5);
$order = [];
while (!$tasks->isEmpty()) {
    $order[] = $tasks->extract();
}
echo implode(" > ", $order), "\n";

<?php
class AssertionFailure extends Exception {}

function assertSame(mixed $expected, mixed $actual): void
{
    if ($expected !== $actual) {
        throw new AssertionFailure("expected " . var_export($expected, true) . " but got " . var_export($actual, true));
    }
}

function assertThrows(string $class, callable $code): void
{
    try {
        $code();
    } catch (Throwable $e) {
        if ($e instanceof $class) {
            return;
        }
        throw new AssertionFailure("expected $class but got " . get_class($e));
    }
    throw new AssertionFailure("expected $class but nothing was thrown");
}

function clamp(int $value, int $low, int $high): int
{
    if ($low > $high) {
        throw new InvalidArgumentException("low > high");
    }
    return max($low, min($high, $value));
}

$tests = [
    "inside the range" => fn() => assertSame(5, clamp(5, 0, 10)),
    "below the range" => fn() => assertSame(0, clamp(-3, 0, 10)),
    "above the range" => fn() => assertSame(10, clamp(99, 0, 10)),
    "bad bounds throw" => fn() => assertThrows(InvalidArgumentException::class, fn() => clamp(1, 5, 2)),
    "division by zero" => fn() => assertThrows(DivisionByZeroError::class, fn() => intdiv(1, 0)),
    "a failing check" => fn() => assertSame(6, clamp(7, 0, 5)),
];

$failed = 0;
foreach ($tests as $name => $test) {
    try {
        $test();
        echo "PASS $name\n";
    } catch (AssertionFailure $e) {
        $failed++;
        echo "FAIL $name: ", $e->getMessage(), "\n";
    }
}
echo count($tests) - $failed, " passed, $failed failed\n";

<?php
$hash = password_hash("correct horse", PASSWORD_DEFAULT);
echo "algorithm: ", password_get_info($hash)["algoName"], "\n";
echo "right password: ", password_verify("correct horse", $hash) ? "accepted" : "rejected", "\n";
echo "wrong password: ", password_verify("wrong guess", $hash) ? "accepted" : "rejected", "\n";
echo "hashes differ for equal passwords: ",
    password_hash("correct horse", PASSWORD_DEFAULT) !== $hash ? "yes" : "no", "\n";

$tag = hash_hmac("sha256", "what do ya want for nothing?", "Jefe");
echo $tag, "\n";
$again = hash_hmac("sha256", "what do ya want for nothing?", "Jefe");
echo "valid: ", hash_equals($tag, $again) ? "yes" : "no", "\n";
$forged = hash_hmac("sha256", "what do ya want for something?", "Jefe");
echo "forged valid: ", hash_equals($tag, $forged) ? "yes" : "no", "\n";

<?php
function e(string $text): string
{
    return htmlspecialchars($text, ENT_QUOTES | ENT_SUBSTITUTE, "UTF-8");
}

$comment = '<script>alert("x")</script>';
echo "<p>" . $comment . "</p>", "\n";
echo "<p>" . e($comment) . "</p>", "\n";

$name = "O'Brien & \"Sons\"";
echo '<input value="' . e($name) . '">', "\n";
echo "q=" . urlencode("a b&c=d"), "\n";
echo json_encode(["note" => "</script>"], JSON_HEX_TAG), "\n";