Spring naar hoofdtekst

Binaire puzzels oplossen in PHP

Geplaatst op door ,
Laatste aanpassing op .

Inleiding

Afgelopen feestdagen kreeg ik een puzzelboekje cadeau met binaire puzzels. Al jaren maakte ik soortgelijke, maar kleinere, puzzels in de wekelijkse tv-gids. Nu kon ik zeker een aantal maanden vooruit!

Toen mijn helpende hand en ik eenmaal de vier mogelijke strategiën onder de knie hadden, waren de meeste puzzels binnen een kwartier compleet. Maar soms zagen we simpelweg niet waar de volgende stap zou zijn. De puzzel bleef dan voor alsnog onopgelost.

Voor dát geval wilde ik een stuk code schrijven dat mij een hint zou geven met welke strategie en in welke cel zich de volgende stap zou kunnen afspelen. Hieronder zal ik het proces van de totstandkoming bespreken, gevolgd door een korte analyse van de code zelf. Het eindresultaat is op FWieP.nl te bewonderen.

Aanpak

Aangezien ik thuis ben in PHP besloot ik er een webapplicatie van te maken. Eerst de logica en daarna de formulier(en) voor in de browser. Met die eerste stap was ik een behoorlijk tijdje zoet, en liep uiteindelijk tegen een beperking aan: ik kon bij één van de strategiën de vertaalslag van een procedure in mijn hoofd naar code niet maken. Ik zag niet hoe ik de handelingen die ik moeiteloos op papier uitvoerde, moest omzetten naar instructies voor mijn programma.

Gelukkig kwam er hulp uit onverwachte hoek. Karin Schaap, een bevriende programmeur, bood aan om mee te kijken en haar steen bij te dragen aan dit stukje software. Ondanks het feit dat ze nog nooit met PHP had gewerkt, bracht de samenwerking tussen ons een code-dialoog op gang. Afgewisseld door korte trial-error-trial-succes momenten leidde dit tot een werkende oplosser!

Uitbreiding

Natuurlijk ging ik direct op zoek naar puzzels om mijn code te testen. Ik vond, onder meer op binarypuzzle.com, een groot aantal puzzels die mijn code glansvol en zonder problemen oplostte. Tot ik ook de 'zeer moeilijke' (very hard) puzzels probeerde; mijn code was niet slim genoeg! Er moest nog minimaal één strategie zijn die ik niet kende…

De uitleg die ik als basis had genomen voor mijn code reikte tot en met vier strategiën. De vijfde werd kort aangehaald op een andere pagina, maar dat soort wiskunde gaat ver boven mijn pet. Gelukkig was er ook een beschrijving die ik wél snapte. Ik ging aan de slag en bouwde de ontbrekende schakel in mijn ketting om de code te kraken.

Code

In deze webapplicatie wordt een HTML-textarea gebruikt om de puzzel in te voeren. In de constructor van de klasse Puzzle wordt de rauwe tekst eerst opgeschoond en gecontroleerd op juistheid. Tot slot wordt de puzzel opgesplitst in losse cellen ($this->_cells).

<?php
class Puzzle
{
    public function __construct(string $in) 
    {
        // Clean up input
        $in = str_replace(array("\r","\n"), '', $in);
        $in = preg_replace('/[^01.]/', '', $in);

        // Catch too big input, max 16x16 cells
        if (strlen($in) > 256) {
            return false;
        }

        // Ensure the input represents a square
        $side = sqrt(strlen($in));
        if ($side != (int)$side) {
            return false;
        }

        // Ensure the square's side is even
        if ($side % 2 != 0) {
            return false;
        }

        $this->_unsolved = $in;
        $this->_size = $side;
        $this->_amountMax = intdiv($side, 2);
        $this->_cells = str_split($in);
    }
    // ...
}

Oplossen

De hoofdfunctie van de oplosser is solve(). Ze bestaat uit een while(true)-loop die met beleid wordt onderbroken of opnieuw gestart. Eerst worden alle vijf strategiën losgelaten op de rijen, daarna op de kolommen van de puzzel. Als er na het uitvoeren van zo'n stap iets is veranderd (een lege cel is ingevuld), dan wordt het hele proces opnieuw gestart. De code werkt dus met zo eenvoudig mogelijke middelen, totdat het niet anders kan.

private function _isSolved() : bool 
{
    return strpos(implode('', $this->_cells), '.') === false;
}

public const STRATEGY_1 = 1;
public const STRATEGY_2 = 2;
public const STRATEGY_3 = 4;
public const STRATEGY_4 = 8;
public const STRATEGY_5 = 16;

public function solve(int $strategies) : bool 
{
    $doStrategy1 = ($strategies & self::STRATEGY_1) > 0;
    // same goes for strategy 2, 3, 4 and 5

    while (true) {
        if ($this->_isSolved()) {
            return true;
        }
        $oldCells = implode('', $this->_cells);

        $items = $this->_getRows();
        foreach ($items as $ix => $item) {
            if ($doStrategy1
                && self::_executeStrategy($item, 1, self::PUZLLE_ROW, $ix)
            ) {
                continue 2;
            }
            // same goes for strategy 2, 3, 4 and 5
        }

        $items = $this->_getColumns();
        foreach ($items as $ix => $item) {
            if ($doStrategy1
                && self::_executeStrategy($item, 1, self::PUZLLE_COL, $ix)
            ) {
                continue 2;
            }
            // same goes for strategy 2, 3, 4 and 5
        }

        // If all this work didn't bring any change, break the loop.
        if (strcmp($oldCells, implode('', $this->_cells)) === 0) {
            return false;
        }
    }
    return false;
}

Strategiën

In een binaire puzzel moet een rij of kolom aan een aantal voorwaarden voldoen. De rij of kolom mag niet leeg zijn, niet groter of kleiner dan de rest van de puzzel, mag geen drie nullen of enen naast elkaar hebben, of méér dan het maximaal aantal toegestane nullen en enen.

private function _isValidRow(string $row) : bool 
{
    if (strcmp($row, '') === 0) {
        return false; // is this row empty?
    }
    if (strlen($row) != $this->_size) {
        return false; // is this row the wrong size?
    }
    if (stripos($row, '000') !== false) {
        return false; // are there three consecutive zeroes?
    }
    if (stripos($row, '111') !== false) {
        return false; // are there three consecutive ones?
    }

    $amount0 = substr_count($row, '0');
    $amount1 = substr_count($row, '1');

    if ($amount0 > $this->_amountMax) {
        return false; // are there more zeroes than allowed?
    }
    if ($amount1 > $this->_amountMax) {
        return false; // are there more ones than allowed?
    }

    // the row is valid!
    return true;
}

De functie die alle strategiën aanroept moet controleren of het resultaat van zo'n aanroep geldig is. Zo ja, wordt de nieuwe rij of kolom teruggeplaatst in de puzzel en kan het oplossen weer van voren af aan beginnen.

private function _executeStrategy(
    string $oldItem, int $strategy, int $rowcol, int $ix
) : bool {
    $newItem = $oldItem;

    switch ($strategy) {
    case 1: $newItem = self::_strat1($oldItem); break;
    case 2: $newItem = self::_strat2($oldItem); break;
    case 3: $newItem = self::_strat3($oldItem); break;
    case 4: $newItem = self::_strat4($oldItem, $rowcol); break;
    case 5: $newItem = self::_strat5($oldItem, $rowcol); break;
    }

    if (!self::_isValidRow($newItem)) {
        return false;
    }

    if (strcmp($newItem, $oldItem) !== 0) {
        switch ($rowcol) {
            case self::PUZLLE_ROW: $this->_setRow($newItem, $ix); break;
            case self::PUZLLE_COL: $this->_setColumn($newItem, $ix); break;
        }
        return true;
    }
    return false;
}

1: Duo's en trio's

Tussen twee nullen staat altijd een één: 0.0 wordt 010. Tussen twee enen staat altijd een nul: 1.1 wordt 101. Naast twee nullen staat altijd een één: 00. wordt 001, .00 wordt 100. Naast twee enen staat altijd een nul: 11. wordt 110, .11 wordt 011.

private static function _strat1(string $str) : string 
{
    $replaceCount = 0;

    $str = preg_replace('/00\./', '001', $str, 1, $replaceCount);
    if ($replaceCount > 0) {
        return $str;
    }

    $str = preg_replace('/\.00/', '100', $str, 1, $replaceCount);
    if ($replaceCount > 0) {
        return $str;
    }

    $str = preg_replace('/11\./', '110', $str, 1, $replaceCount);
    if ($replaceCount > 0) {
        return $str;
    }

    $str = preg_replace('/\.11/', '011', $str, 1, $replaceCount);
    if ($replaceCount > 0) {
        return $str;
    }

    $str = preg_replace('/0\.0/', '010', $str, 1, $replaceCount);
    if ($replaceCount > 0) {
        return $str;
    }

    $str = preg_replace('/1\.1/', '101', $str, 1, $replaceCount);
    if ($replaceCount > 0) {
        return $str;
    }
    return $str; 
}

Een snellere en zeker efficiëntere methode van deze strategie zou gebruik maken van str_replace, maar daarmee kun je niet elke vervanging (puzzelstap) afzonderlijk vastleggen. En laat dát nou juist het doel zijn van deze oplosser :-)

2: Maximaal aantal 0's en 1's

Een rij (kolom) bevat altijd evenveel nullen als enen. Als de nullen 'op zijn', moeten de resterende cellen met enen worden gevuld; en vice versa.

private function _strat2(string $str) : string 
{
    $amount0 = substr_count($str, '0');
    $amount1 = substr_count($str, '1');
    $amountXX = substr_count($str, 'xx');
    $amountEmp = substr_count($str, '.');

    $amount0 += $amountXX;
    $amount1 += $amountXX;

    if ($amountEmp == 1) {
        $toInsert = $amount0 < $amount1 ? '0' : '1';
        $str = str_replace('.', $toInsert, $str);
        return $str;
    }
    if ($amount0 == $this->_amountMax) {
        $str = str_replace('.', '1', $str);
        return $str;
    }
    if ($amount1 == $this->_amountMax) {
        $str = str_replace('.', '0', $str);
        return $str;
    }

    if ($amount0 == $this->_amountMax - 1) {
        $options = array();

        for ($i = 0; $i < $this->_size; $i++) {
            if (substr($str, $i, 1) != '.') {
                continue;
            }
            $tmpOption = substr_replace($str, '0', $i, 1);
            $tmpOption = str_replace('.', '1', $tmpOption);
            if (self::_isValidRow($tmpOption)) {
                $options[] = $tmpOption;
            } else {
                $tmpOption = substr_replace($str, '1', $i, 1);
                return $tmpOption;
            }
        }

        if (count($options) == 1) {
            $str = reset($options);
            return $str;
        }
    }

    if ($amount1 == $this->_amountMax - 1) {
        $options = array();

        for ($i = 0; $i < $this->_size; $i++) {
            if (substr($str, $i, 1) != '.') {
                continue;
            }
            $tmpOption = substr_replace($str, '1', $i, 1);
            $tmpOption = str_replace('.', '0', $tmpOption);
            if (self::_isValidRow($tmpOption)) {
                $options[] = $tmpOption;
            } else {
                $tmpOption = substr_replace($str, '0', $i, 1);
                return $tmpOption;
            }
        }

        if (count($options) == 1) {
            $str = reset($options);
            return $str;
        }
    }
    return $str;
}

3: 0..1 en 1..0 uitsluiten

Tussen een nul en één met twee cellen tussenruimte, staan altijd een nul en een één. Bijvoorbeeld: 0..1 of 1..0. Dit gegeven kan worden gebruikt om met strategie 2 deze twee lege cellen uit te sluiten.

private function _strat3(string $str) : string 
{
    $option = '';

    if (strpos($str, '0..1') !== false) {
        $option = preg_replace('/0\.\.1/', '0xx1', $str);
    }
    if (strpos($str, '1..0') !== false) {
        $option = preg_replace('/1\.\.0/', '1xx0', $str);
    }
    if (!$option) {
        return $str;
    }

    $newItem = self::_strat2($option);
    $newItem = str_replace('xx', '..', $newItem);

    return $newItem;
}

4: Unieke rijen vergelijken

Elke rij (kolom) is uniek. Als een rij (kolom) nog maar twee open cellen heeft, en er is een volledige rij (kolom) die verder identiek is, moeten de lege cellen 'andersom' worden ingevuld.

private function _strat4(string $str, int $rowcol) : string 
{
    if (substr_count($str, '.') != 2) {
        return $str;
    }

    $optionA = $str;
    $optionA = preg_replace('/\./', '1', $optionA, 1);
    $optionA = preg_replace('/\./', '0', $optionA, 1);

    $optionB = $str;
    $optionB = preg_replace('/\./', '0', $optionB, 1);
    $optionB = preg_replace('/\./', '1', $optionB, 1);

    switch ($rowcol) {
    case self::PUZLLE_ROW: $items = $this->_getRows(); 
        break;
    case self::PUZLLE_COL: $items = $this->_getColumns(); 
        break;
    default: $items = array(); 
        break;
    }

    foreach ($items as $ix2 => $item2) {

        if ($item2 == $optionA) {
            $newItem = $optionB;
        } else if ($item2 == $optionB) {
            $newItem = $optionA;
        } else {
            $newItem = '';
        }

        if ($this->_isValidRow($newItem)) {
            return $newItem;
        } else {
            continue;
        }
    }
    return $str;
}

5: Alle mogelijkheden filteren

Maak een lijst van alle mogelijkheden voor het invullen van een rij (kolom) met lege cellen. Komen één of meer cellen daarvan overeen in alle mogelijkheden, dan is de inhoud van die cel zeker.

private function _strat5(string $str, int $rowcol) : string 
{
    if (!$this->_allPossibles) {

        // Create the maximum binary number based on the puzzle's size
        $size = $this->_size;
        $maxBinary = str_repeat('1', $size);

        // Get all possible numbers represented by the puzzle's rows (columns)
        $all = range(0, bindec($maxBinary));
        $all = array_map(
            function ($x) use ($size) {
                // Pad them with zeroes to the correct length
                return sprintf("%0${size}b", $x);
            }, $all
        );

        // Reduce to only valid rows (columns)
        $all = array_filter($all, array(__CLASS__, '_isValidRow'));

        // Cache for later usage
        $this->_allPossibles = $all;
        unset($all);
    }

    $possibles = array_filter(
        $this->_allPossibles,
        function ($x) use ($str) {
            $xChars = str_split($x);
            $strChars = str_split($str);
            $charsCount = count($xChars);

            // Find possible candidates for row (column) $str
            for ($i = 0; $i < $charsCount; $i++) {
                if ($strChars[$i] == '.') {
                    continue; // ... by skipping empty cells...
                }
                if ($strChars[$i] != $xChars[$i]) {
                    return false; // ... not including non-matching...
                }
            }
            return true; // ... and keeping all others
        }
    );

    switch ($rowcol) {
    case self::PUZLLE_ROW: $items = $this->_getRows(); 
        break;
    case self::PUZLLE_COL: $items = $this->_getColumns(); 
        break;
    default: $items = array(); 
        break;
    }

    // Exclude existing rows (columns)
    $possibles = array_filter(
        $possibles,
        function ($x) use ($items) {
            return array_search($x, $items) === false;
        }
    );

    // Loop through $str by character
    for ($i = 0; $i < $this->_size; $i++) {
        if (substr($str, $i, 1) != '.') {
            continue; // Skip empty cells
        }

        // Create a concatenated string of all possible values for this cell
        $valuesOnIndexI = array_reduce(
            $possibles,
            function ($a, $b) use ($i) {
                return $a.substr($b, $i, 1);
            }, ''
        );

        // If the options only contain zeroes, then this cell MUST be 0        
        if (strpos($valuesOnIndexI, '0') !== false
            && strpos($valuesOnIndexI, '1') === false
        ) {
            $str = substr_replace($str, '0', $i, 1);
            return $str;
        }

        // If the options only contain ones, then this cell MUST be 1
        if (strpos($valuesOnIndexI, '1') !== false
            && strpos($valuesOnIndexI, '0') === false
        ) {
            $str = substr_replace($str, '1', $i, 1);
            return $str;
        }
    }
    return $str;
}

Inhoudsopgave

Atom-feed Atom-feed van FWiePs weblog

Artikelen


Doorzoek de onderstaande categorieën om de lijst met artikelen te filteren.