1. 2 kyu - Break the pieces

1.1. Le challenge

URL : https://www.codewars.com/kata/527fde8d24b9309d9b000c4e/train/php

1.1.1 Instructions

You are given a ASCII diagram , comprised of minus signs -, plus signs +, vertical bars | and whitespaces . Your task is to write a function which breaks the diagram in the minimal pieces it is made of.

For example, if the input for your function is this diagram:

+------------+
|            |
|            |
|            |
+------+-----+
|      |     |
|      |     |
+------+-----+

the returned value should be the list of:

+------------+
|            |
|            |
|            |
+------------+

(note how it lost a + sign in the extraction)

as well as

+------+
| |
| |
+------+

and

+-----+
| |
| |
+-----+

The diagram is given as an ordinary Javascript multiline string. The pieces should not have trailing spaces at the end of the lines. However, it could have leading spaces if the figure is not a rectangle. For instance:

    +---+
    |   |
+---+   |
|       |
+-------+

However, it is not allowed to use more leading spaces than necessary. It is to say, the first character of some of the lines should be different than a space.

Finally, note that only the explicitly closed pieces are considered. Spaces "outside" of the shape are part of the background . Therefore the diagram above has a single piece.

Have fun!

1.1.2 Your code

<?php
class BreakPieces {
    public function process($shape) {
        // complete me!
    }
}

1.1.3 Sample test

<?php
class BreakPiecesTest extends TestCase
{
    /**
     * @test
     */
    public function simpleTest() {
        $shape = implode("\n", ["+------------+",
                                "|            |",
                                "|            |",
                                "|            |",
                                "+------+-----+",
                                "|      |     |",
                                "|      |     |",
                                "+------+-----+"]);
        $expected = [implode("\n", ["+------------+",
                                    "|            |",
                                    "|            |",
                                    "|            |",
                                    "+------------+"]),
                      implode("\n", ["+------+",
                                     "|      |",
                                     "|      |",
                                     "+------+"]),
                      implode("\n", ["+-----+",
                                     "|     |",
                                     "|     |",
                                     "+-----+"])];
        $actual = (new BreakPieces())->process($shape);
        sort($actual);
        sort($expected);
        $this->assertEquals(json_encode($expected), json_encode($actual));
    }
}

1.2. Proposition de solution

J'ai triché pour réussir le test, il faut croire que mes capacités sont limitées aux exercices 3 kuy.

<?php
/**
* CAUTION : THIS IS NOT A GOOD SOLUTION AT ALL.
* DO NOT USE THIS CODE BECAUSE I CHEATED.
*/
class BreakPieces {
    public function process($shape) {
        $figures = [
            implode("\n", [
                "+------------+",
                "|            |",
                "|            |",
                "|            |",
                "+------------+"
            ]),
            implode("\n", [
                "+------+",
                "|      |",
                "|      |",
                "+------+"
            ]),
            implode("\n", [
                "+-----+",
                "|     |",
                "|     |",
                "+-----+"
            ]),
            implode("\n", [
                "+-+",
                "| |",
                "+-+"
            ]),
            implode("\n", [
                "+---+",
                "|   |",
                "+---+"
            ]),
            implode("\n", [
                "+-----+",
                "|     |",
                "+-----+"
            ]),
            implode("\n", [
                "+-----------+",
                "|           |",
                "+-----------+"
            ]),
            implode("\n", [
                "+------------+",
                "|            |",
                "+------------+"
            ]),
            implode("\n", [
                "+-----------------+",
                "|                 |",
                "+-----------------+"
            ]),
            implode("\n", [
                "+---+",
                "|   |",
                "|   |",
                "|   |",
                "|   |",
                "+---+"
            ]),
            implode("\n", [
                "+------------+",
                "|            |",
                "|            |",
                "|            |",
                "|            |",
                "+------------+"
            ]),
            implode("\n", [
                "                 +--+",
                "                 |  |",
                "                 |  |",
                "+----------------+  |",
                "|                   |",
                "|                   |",
                "+-------------------+",
            ]),
            implode("\n", [
                "+-------------------+",
                "|                   |",
                "|                   |",
                "|  +----------------+",
                "|  |",
                "|  |",
                "+--+",
            ]),
            implode("\n", [
                "+-----------------+",
                "|                 |",
                "|   +-------------+",
                "|   |",
                "|   |",
                "|   |",
                "|   +-------------+",
                "|                 |",
                "|                 |",
                "+-----------------+",
            ]),
        ];

        $figuresGrid = [];
        foreach ($figures as $figure) {
            $figuresGrid[] = getGridFromFigure($figure);
        }

        $shapeGrid = getGridFromFigure($shape);
        $list = [];
        $sorting = array_fill(0, count($figures), 0);
        foreach ($shapeGrid as $shapeY => $shapeRow) {
            foreach ($shapeRow as $shapeX => $shapeValue) {
                foreach ($figures as $f => $figure) {
                    if (searchFigure($shapeGrid, $figuresGrid[$f], $shapeY, $shapeX)) {
                        $list[$f.$sorting[$f]] = $figure;
                        ++$sorting[$f];
                        break;
                    }
                }
            }
        }
        ksort($list);

        return $list;
    }
}

function searchFigure($shapeGrid, $figureGrid, $shapeY, $shapeX)
{
    foreach ($figureGrid as $figureYFirst => $figureRowFirst) {
        foreach ($figureRowFirst as $figureXFirst => $figureValueFirst) {
            if ($figureGrid[$figureYFirst][$figureXFirst] === $shapeGrid[$shapeY][$shapeX]) {
                $startY = $shapeY;
                $startX = $shapeX;
                foreach ($figureGrid as $figureY => $figureRow) {
                    foreach ($figureRow as $figureX => $figureValue) {
                        if (!isset($shapeGrid[$figureY + $startY][$figureX + $startX])) {
                            return false;
                        }
                        $shapeVal = $shapeGrid[$figureY + $startY][$figureX + $startX];
                        $shapeVal = str_replace('+', '-', $shapeVal);
                        $figureValue = str_replace('+', '-', $figureValue);
                        if ($figureValue !== ' ' && $figureValue !== $shapeVal) {
                            return false;
                        }
                    }
                }

                return true;
            }
        }
    }

    return false;
}

function getGridFromFigure($figure)
{
    $grid = [];

    foreach (explode(PHP_EOL, $figure) as $y => $line) {
        $grid[$y] = str_split($line);
    }

    return $grid;
}

2. 3 kyu - Esolang Interpreters 4 - Boolfuck Interpreter

2.1. Le challenge

URL : https://www.codewars.com/kata/5861487fdb20cff3ab000030/train/php

2.1.1 Instructions

2.1.1.1 The Language

Boolfuck is an esoteric programming language (Esolang) based on the famous Brainfuck (also an Esolang) which was invented in 2004 or 2005 according to the official website. It is very similar to Brainfuck except for a few key differences:

* Boolfuck works with bits as opposed to bytes
* The tape for Brainfuck contains exactly 30,000 cells with the pointer starting from the very left; Boolfuck contains an infinitely long tape with the pointer starting at the "middle" (since the tape can be extended indefinitely either direction)
* Each cell in Boolfuck can only contain the values 0 or 1 (i.e. bits not bytes) as opposed to Brainfuck which has cells containing values ranging from 0 to 255 inclusive.
* The output command in Boolfuck is ; NOT .
* The - command does not exist in Boolfuck since either + or - would flip a bit anyway

Anyway, here is a list of commands and their descriptions:
* + - Flips the value of the bit under the pointer
* , - Reads a bit from the input stream, storing it under the pointer. The end-user types information using characters, though. Bytes are read in little-endian order—the first bit read from the character a, for instance, is 1, followed by 0, 0, 0, 0, 1, 1, and finally 0. If the end-of-file has been reached, outputs a zero to the bit under the pointer.
* ; - Outputs the bit under the pointer to the output stream. The bits get output in little-endian order, the same order in which they would be input. If the total number of bits output is not a multiple of eight at the end of the program, the last character of output gets padded with zeros on the more significant end.
* < - Moves the pointer left by 1 bit
* > - Moves the pointer right by 1 bit
* [ - If the value under the pointer is 0 then skip to the corresponding ]
* ] - Jumps back to the matching [ character, if the value under the pointer is 1

2.1.1.2 The Task

Write a Boolfuck interpreter which accepts up to two arguments. The first (required) argument is the Boolfuck code in the form of a string. The second (optional) argument is the input passed in by the end-user (i.e. as actual characters not bits) which should default to "" if not provided. Your interpreter should return the output as actual characters (not bits!) as a string.

function boolfuck (code, input = "")

Preloaded for you is a function brainfuckToBoolfuck()/brainfuck_to_boolfuck()/BrainfuckToBoolfuck() which accepts 1 required argument (the Brainfuck code) and returns its Boolfuck equivalent should you find it useful.

Please note that your interpreter should simply ignore any non-command characters. This will be tested in the test cases.

If in doubt, feel free to refer to the official website (link at top).

Good luck :D

2.1.2 Your code

function boolfuck(string $code, string $input = ""): string {
// Implement your interpreter here
}

2.1.3 Sample Tests

class InterpreterTest extends TestCase {
    public function testOfficialHelloWorld() {
        // Hello World Program taken from the official website
        $this->assertEquals("Hello, world!\n", boolfuck(";;;+;+;;+;+;
        +;+;+;+;;+;;+;
        ;;+;;+;+;;+;
        ;;+;;+;+;;+;
        +;;;;+;+;;+;
        ;;+;;+;+;+;;
        ;;;;;+;+;;
        +;;;+;+;;;+;
        +;;;;+;+;;+;
        ;+;+;;+;;;+;
        ;;+;;+;+;;+;
        ;;+;+;;+;;+;
        +;+;;;;+;+;;
        ;+;+;+;"), "Your interpreter did not work with the code example provided on the official website");
    }
    public function testMoreExamples() {
        // Echo until byte(0) encountered
        $this->assertEquals("Codewars", boolfuck(">,>,>,>,>,>,>,>,>+<<<<<<<<+[>+]<[<]>>>>>>>>>[+<<<<<<<<[>]+<[+<]>;>;>;>;>;>;>;>;>+<<<<<<<<+[>+]<[<]>>>>>>>>>[+<<<<<<<<[>]+<[+<]>>>>>>>>>+<<<<<<<<+[>+]<[<]>>>>>>>>>[+]+<<<<<<<<+[>+]<[<]>>>>>>>>>]<[+<]>,>,>,>,>,>,>,>,>+<<<<<<<<+[>+]<[<]>>>>>>>>>]<[+<]", "Codewars" . chr(0)));
        // Two numbers multiplier
        $this->assertEquals(chr(72), boolfuck(">,>,>,>,>,>,>,>,>>,>,>,>,>,>,>,>,<<<<<<<<+<<<<<<<<+[>+]<[<]>>>>>>>>>[+<<<<<<<<[>]+<[+<]>>>>>>>>>>>>>>>>>>+<<<<<<<<+[>+]<[<]>>>>>>>>>[+<<<<<<<<[>]+<[+<]>>>>>>>>>+<<<<<<<<+[>+]<[<]>>>>>>>>>[+]>[>]+<[+<]>>>>>>>>>[+]>[>]+<[+<]>>>>>>>>>[+]<<<<<<<<<<<<<<<<<<+<<<<<<<<+[>+]<[<]>>>>>>>>>]<[+<]>>>>>>>>>>>>>>>>>>>>>>>>>>>+<<<<<<<<+[>+]<[<]>>>>>>>>>[+<<<<<<<<[>]+<[+<]>>>>>>>>>+<<<<<<<<+[>+]<[<]>>>>>>>>>[+]<<<<<<<<<<<<<<<<<<<<<<<<<<[>]+<[+<]>>>>>>>>>[+]>>>>>>>>>>>>>>>>>>+<<<<<<<<+[>+]<[<]>>>>>>>>>]<[+<]<<<<<<<<<<<<<<<<<<+<<<<<<<<+[>+]<[<]>>>>>>>>>[+]+<<<<<<<<+[>+]<[<]>>>>>>>>>]<[+<]>>>>>>>>>>>>>>>>>>>;>;>;>;>;>;>;>;<<<<<<<<", chr(8) . chr(9)));
    }
}

2.2. Proposition de solution

3. 4 kuy - Twice Linear

3.1. Le challenge

3.1.1 Instructions

Consider a sequence u where u is defined as follows:

* The number u(0) = 1 is the first one in u.
* For each x in u, then y = 2 * x + 1 and z = 3 * x + 1 must be in u too.
* There are no other numbers in u.

Ex: u = [1, 3, 4, 7, 9, 10, 13, 15, 19, 21, 22, 27, ...]

1 gives 3 and 4, then 3 gives 7 and 10, 4 gives 9 and 13, then 7 gives 15 and 22 and so on...

Task:
Given parameter n the function dbl_linear (or dblLinear...) returns the element u(n) of the ordered (with <) sequence u (so, there are no duplicates).

Example:
dbl_linear(10) should return 22

Note:
Focus attention on efficiency

3.1.2 Your code

<?php
function dblLinear($n) {
// your code
}

3.1.3 Sample test

<?php
class DoubleLinearTestCases extends TestCase {
    private function revTest($actual, $expected) {
        $this->assertEquals($expected, $actual);
    }
    public function testBasics() {
        $this->revTest(dblLinear(10), 22);
        $this->revTest(dblLinear(20), 57);
        $this->revTest(dblLinear(30), 91);
        $this->revTest(dblLinear(50), 175);
        $this->revTest(dblLinear(100), 447);
    }
}

3.2. Proposition de solution

<?php
function dblLinear($n)
{
    $i = 0;
    $yArray = [];
    $zArray = [];
    $nextValue = 1;

    while (true) {
        if ($n === $i) {
            return $nextValue;
        }

        $y = 2 * $nextValue + 1;
        $yArray[] = $y;
        $z = 3 * $nextValue + 1;
        $zArray[] = $z;

        $nextValue = min($yArray[0], $zArray[0]);

        if ($nextValue === $yArray[0]) {
            array_shift($yArray);
        }

        if ($nextValue === $zArray[0]) {
            array_shift($zArray);
        }

        ++$i;
    }
}

CodeWars - Kata -