30 PHP Coding Challenges for Junior and Senior Developers

The traditional first program to verify a working setup.

<?php
echo "Hello, World!";
?>

A basic test of loops and array manipulation.

<?php
function sum(array $numbers): int {
    $total = 0;
    foreach ($numbers as $number) {
        $total += $number;
    }
    return $total;
}
?>

A simple test of string manipulation.

<?php
function reverse(string $str): string {
    return strrev($str);
}
?>

A fundamental algorithm using a simple loop.

<?php
function largest(array $numbers): int {
    $largest = $numbers[0];
    foreach ($numbers as $number) {
        if ($number > $largest) {
            $largest = $number;
        }
    }
    return $largest;
}
?>

Tests string manipulation and comparison logic.

<?php
function isPalindrome(string $str): bool {
    return $str === strrev($str);
}
?>

The classic test of basic conditional logic and loops.

<?php
function fizzbuzz(int $n): void {
    for ($i = 1; $i <= $n; $i++) {
        if ($i % 15 === 0) {
            echo "FizzBuzz\n";
        } elseif ($i % 3 === 0) {
            echo "Fizz\n";
        } elseif ($i % 5 === 0) {
            echo "Buzz\n";
        } else {
            echo "$i\n";
        }
    }
}
?>

Introduces custom types and data organization.

<?php
class Person {
    public string $name;
    public int $age;

    public function __construct(string $name, int $age) {
        $this->name = $name;
        $this->age = $age;
    }
}
?>

A simple function to demonstrate associative array creation.

<?php
function getPerson(): array {
    return [
        "name" => "John Doe",
        "age" => 30,
    ];
}
?>

A basic loop to demonstrate syntax.

<?php
for ($i = 1; $i <= 10; $i++) {
    echo "$i\n";
}
?>

Tests basic conditional logic.

<?php
function checkNumber(int $n): void {
    if ($n > 0) {
        echo "Positive\n";
    } elseif ($n < 0) {
        echo "Negative\n";
    } else {
        echo "Zero\n";
    }
}
?>

Use an associative array to count the frequency of words in a text.

<?php
function wordCount(string $str): array {
    $words = str_word_count(strtolower($str), 1);
    return array_count_values($words);
}
?>

A simple interface for a `Shape` with an `area` method.

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

class Circle implements Shape {
    private float $radius;

    public function __construct(float $radius) {
        $this->radius = $radius;
    }

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

Convert PHP objects to and from JSON using `json_encode` and `json_decode`.

<?php
class User {
    public string $name;
    public int $age;
}

$user = new User();
$user->name = "John Doe";
$user->age = 30;

$json = json_encode($user);
$user2 = json_decode($json, false, 512, JSON_THROW_ON_ERROR);
?>

A common interview question that can be solved with an associative array.

<?php
function firstNonRepeatingCharacter(string $str): ?string {
    $counts = count_chars($str, 1);
    foreach (str_split($str) as $char) {
        if ($counts[ord($char)] === 1) {
            return $char;
        }
    }
    return null;
}
?>

A simple trait for a `Logger`.

<?php
trait Logger {
    public function log(string $message): void {
        echo $message;
    }
}

class MyClass {
    use Logger;
}
?>

A simple example of error handling with `try`/`catch`.

<?php
function doSomething(bool $fail): void {
    if ($fail) {
        throw new Exception("Something went wrong");
    }
}

try {
    doSomething(true);
} catch (Exception $e) {
    echo $e->getMessage();
}
?>

A simple example of an anonymous function.

<?php
$addOne = function (int $n): int {
    return $n + 1;
};

echo $addOne(1);
?>

A simple command-line argument parser.

<?php
global $argv;

foreach ($argv as $arg) {
    echo "$arg\n";
}
?>

A simple example of reading and writing to a file.

<?php
file_put_contents("foo.txt", "Hello, world!");
$contents = file_get_contents("foo.txt");
echo $contents;
?>

A simple implementation of a PSR-4 autoloader.

<?php
spl_autoload_register(function (string $className): void {
    $file = str_replace('\\', DIRECTORY_SEPARATOR, $className) . '.php';
    if (file_exists($file)) {
        require $file;
    }
});
?>

A simple dependency injection container.

<?php
class Container {
    private array $services = [];

    public function set(string $name, callable $callable): void {
        $this->services[$name] = $callable;
    }

    public function get(string $name) {
        return $this->services[$name]($this);
    }
}
?>

A simple web server with a router.

<?php
// Run with `php -S localhost:8000 router.php`
$uri = $_SERVER['REQUEST_URI'];

switch ($uri) {
    case '/':
        echo "Hello, world!";
        break;
    default:
        http_response_code(404);
        echo "404 Not Found";
}
?>

A simple middleware pattern.

<?php
interface Middleware {
    public function handle(callable $next);
}

class MyMiddleware implements Middleware {
    public function handle(callable $next) {
        echo "Before\n";
        $next();
        echo "After\n";
    }
}
?>

A simple Composer package.

// In composer.json
{
    "name": "my-vendor/my-package",
    "description": "My awesome package",
    "authors": [
        {
            "name": "My Name",
            "email": "[email protected]"
        }
    ],
    "require": {}
}

A simple event dispatcher.

<?php
class EventDispatcher {
    private array $listeners = [];

    public function addListener(string $eventName, callable $listener): void {
        $this->listeners[$eventName][] = $listener;
    }

    public function dispatch(string $eventName, $event): void {
        foreach ($this->listeners[$eventName] as $listener) {
            $listener($event);
        }
    }
}
?>

A simple example of using reflection to inspect a class.

<?php
$reflectionClass = new ReflectionClass(MyClass::class);
$methods = $reflectionClass->getMethods();
foreach ($methods as $method) {
    echo $method->getName() . "\n";
}
?>

A simple concurrent queue with `pthreads` or `Swoole`.

// This is a complex task that would require a lot of code.
// A full implementation would be too long for this format.

A simple key-value store with caching.

<?php
class KvStore {
    private array $data = [];
    private array $cache = [];

    public function set(string $key, $value): void {
        $this->data[$key] = $value;
        unset($this->cache[$key]);
    }

    public function get(string $key) {
        if (isset($this->cache[$key])) {
            return $this->cache[$key];
        }

        if (isset($this->data[$key])) {
            $this->cache[$key] = $this->data[$key];
            return $this->data[$key];
        }

        return null;
    }
}
?>

A simple state machine.

<?php
interface State {
    public function handle(Context $context): void;
}

class Context {
    private State $state;

    public function __construct(State $state) {
        $this->state = $state;
    }

    public function setState(State $state): void {
        $this->state = $state;
    }

    public function request(): void {
        $this->state->handle($this);
    }
}
?>

A simple build script for a project with Phing.

<?xml version="1.0" encoding="UTF-8"?>
<project name="MyProject" default="build">
    <target name="build">
        <echo msg="Building..." />
    </target>
</project>