Zobacz wątek gliniarza, aby uzyskać więcej informacji. Każda odpowiedź na to pytanie powinna tam znaleźć odpowiedź. Oznacza to, że kodem powinno być znalezienie trzeciej co do wielkości liczby całkowitej na wejściu, gdy zostanie uruchomiony w interpreter podany w tej odpowiedzi.

Jeśli opublikujesz crack, który okaże się nieprawidłowy, powinieneś go usunąć i nie możesz zaksięgować kolejnej próby przeciwko tej samej odpowiedzi.

Punktacja

Zwycięzcą tego pytania jest rabuś, który wykonuje największą liczbę udanych pęknięć.

Shuffle, autor: Liam Noronha

cinpush

main:
    gte Hans 1s Leopold
    jnz Leopold done

    mov 1s Hans

    gte Gertrude Hans Leopold
    jnz Leopold done

    mov Gertrude ShabbySam
    mov Hans Gertrude
    mov ShabbySam Hans

    gte Alberto Gertrude Leopold
    jnz Leopold done

    mov Alberto ShabbySam
    mov Gertrude Alberto
    mov ShabbySam Gertrude

    done:

    mov 10 ShabbySam

    gte 1s ShabbySam Leopold
    jz Leopold undo_u

    mov 30 ShabbySam
    gte 1s ShabbySam Leopold
    jz Leopold undo_d

    undo_r:

        POP!! 1

        "shuffle" f
        "shuffle" f
        "shuffle" b
        "shuffle" b
        "shuffle" l
        "shuffle" f
        "shuffle" f
        "shuffle" b
        "shuffle" b

        jmp end

    undo_u:

        POP!! 1

        "shuffle" f
        "shuffle" f
        "shuffle" f
        "shuffle" b
        "shuffle" b
        "shuffle" b
        "shuffle" l
        "shuffle" l
        "shuffle" l
        "shuffle" f
        "shuffle" b

        jmp end

    undo_d:

        POP!! 1

        "shuffle" f
        "shuffle" b
        "shuffle" l
        "shuffle" f
        "shuffle" f
        "shuffle" f
        "shuffle" b
        "shuffle" b
        "shuffle" b

    end:
    jnz 1s main

print Hans
done!

To była naprawdę świetna zabawa, dziękuję Liam! :)

Dzięki Sp3000 za delikatny, ale konieczny ruch we właściwym kierunku.

W jaki sposób?

Dwa słowa: Pocket Cube .

Okazuje się, że stosy odpowiadają powierzchniom sześcianu Rubika 2x2x2 w następujący sposób:

           ____ ____
          |    |    |
          | 19 | 17 |
          |____U____|
          |    |    |
          | 20 | 18 |
 _________|____|____|____ ____ ____ ____
|    |    |    |    |    |    |    |    |
| 13 | 14 |  1 |  2 |  9 | 10 |  6 |  5 |
|____L____|____F____|____R____|____B____|
|    |    |    |    |    |    |    |    |
| 15 | 16 |  3 |  4 | 11 | 12 |  8 |  7 |
|____|____|____|____|____|____|____|____|
          |    |    |
          | 22 | 24 |
          |____D____|
          |    |    |
          | 21 | 23 |
          |____|____|

Gdzie ULFRBDwskazać, która twarz odpowiada w górę, w lewo, z przodu, z prawej, z tyłu, w dół, gdy sześcian jest prawidłowo złożony.

Permutacje odpowiadają obróceniu dowolnej strony o 90 stopni (gdzie nazwy na szczęście się pokrywają). Okazuje się, że f, ri dsą prawoskrętne obrotów (podczas oglądania twarzy) i r, li uto w lewo o obroty (podczas oglądania twarzy).

Teraz cinpushkomenda działa w taki sposób, że dotyczy on jednej z obrotów u, dlub r(w zależności od danej wartości), a następnie wypycha wartość wejściową na stosie w pozycji 1. (A potem powtarza to, robiąc to dla każdego elementu na wejściu.) Oznacza to, że możemy odwrócić ten proces (aby upewnić się, że otrzymamy prawidłową kolejność stosów bez konieczności rozwiązywania dowolnej kostki Rubika) poprzez wielokrotne przeglądanie stosu w pozycję 1, cofając odpowiednią permutację i wstawiając wartość tego stosu (aby następnym razem, gdy zobaczymy stos, otrzymamy wartość poniżej).

Jak cofamy rotacje? Na szczęście mamy zarówno do dyspozycji, jak fi bdo naszej dyspozycji. Jeśli zastosujemy oba z nich, obrócimy cały sześcian o 90 stopni. W ten sposób można się przesuwać chorym ( U, Ri D), aby Lpoluzować obrotów z jednego lub trzy ls (w zależności od względnego kierunku l, a ruch obrotowy wykonywany podczas wprowadzania), a następnie obraca się w tył kostka poprzedniej orientacji użyciu fi bjeszcze raz.

W szczególności każde z obrotów wykonanych podczas wprowadzania można cofnąć w następujący sposób:

u --> fffbbblllfb
r --> ffbblffbb
d --> fblfffbbb

Zobaczę, czy mogę wymyślić jakieś animacje, aby pokazać, że to działa.

Teraz daje nam to sposób na jednorazowe powtórzenie całego wejścia. Ale przy 5 rejestrach wystarczy nam:

• Alberto to maksymalna napotkana do tej pory wartość.
• Gertrude jest drugą co do wielkości wartością napotkaną do tej pory.
• Hans to 3. największa jak dotąd napotkana wartość.

Kiedy napotykamy nową wartość, zwiększamy ją w razie potrzeby o trzy, gdzie możemy użyć jej ShabbySamjako tymczasowego rejestru dla swapów. To wciąż pozostawia warunki, Leopoldktóre możemy zastosować, aby spełnić warunek, dokonując niezbędnych porównań.

Pod koniec procesu po prostu drukujemy zawartość Hans, która będzie już zawierać 3. największą wartość.

TKDYNS autorstwa Sama Capplemana-Lynesa

Prawdopodobnie nie jest to optymalne, ale myślę, że to działa ...

cvcvc>v>^>>^^>>v>vvvvvvvv<<<^<<^<<^^>^<^cvc>v<cvcvcvc^>>vv<<c
>>^>>v>>>^^^^^^^^<^<<vv<<v<^<^^>cv<>^
>>^>>v>>>^^^^^^^^<^<<vv<<v<^<^^>vc^v<>^
>>^>>v>>>^^^^^^^^<^<<vv<<v<^c<^>^
>>^>>v>>>^^^^^^^^<^<<vv<<v<c^<^>^
>>^^<<^^>^c^^<^>^
>>^^<<^^>c<^>^^<^>^
>>^^<^c^<^>^^<^>^
>>^^<c<^^^>^^<^>^
>^cv>^>^<<<^^^>^^<^>^
>c>^>^<<<^^^>^^<^>^
>>^>>v>>>^^^^^^^^<^<<vv<<v<^<^^>>cv^
>>^>>v>>>^^^^^^^^<^<<<v<c^
>>^>>v>>>^^^^^^^^<^<<vv<<c^^
>>^>>v>>>^^^^^^^^<^<<vv<<vcv>>>^<^<<^^
>>^^<<^^>>^c>>>^<^<<^^
>>^^<<^^>>c<^>>>>^<^<<^^
>>^>>v>>^<^^<<<c^<^>>>>^<^<<^^
>>^^c>vv>^^^<<^<^>>>>^<^<<^^
>>^c^>vv>^^^<<^<^>>>>^<^<<^^
>>c^^>vv>^^^<<^<^>>>>^<^<<^^
>>^>>v>>>^^^^^^^^<^<<<c<>
>>^>>v>>>^^^^^^^^<^<<<vc^<>
>>^>>v>>>^^^^^^^^<^<<vv<c^^
>>^>>v>>>^^^^^^^^<^<<vv<vc^^^
>>^^<<^^>>>^c^^^^
>>^^<<^^>>>c^^^^^
>>^>>v>>^<^^<<c^^^^^^
>>^>^c<^^<^>^^^>^
>>^>c^<^^<^>^^^>^
>>>c^^<^^<^>^^^>^
>>^>>v>>>^^^^^^^^<^<<c<<>>
>>^>>v>>>^^^^^^^^<^<<vc<^>
>>^>>v>>>^^^^^^^^<^<<vvc>^<<^>
>>^>>v>>>^^^^^^^^<^<<vv<v>c>^^<<^>
>>^>>v>>>^^^^^^^^<^<<vv<v>>v<c^>^^<<^>
>>^^<<^^>>>>cv<^<^^>^>>^<<^>
>>^>>v>>^<^^<c<^<^^>^>>^<<^>
>>^>>v>>^<^^<vc>^^<v<^<^^>^>>^<<^>
>>^>>c>^^^<v<^<^^>^>>^<<^>
>>^>>vc<<^^>^^<^^>^>>^<<^>
>>^>>v>>>^^^^^^^^<^<cv^
>>^>>v>>>^^^^^^^^<<c^
>>^>>v>>>^^^^^^^^<^<<vv>c<^>^
>>^>>v>>>^^^^^^^^<^<<vv<v>>c<^^>^
>>^>>v>>>^^^^^^^^<^<<vv<v>>vc^<^^>^
>>^>>v>>^<^^^c^^<^^>^
>>^>>v>>^<^^c>v>>^>^<^^^<^<<^
>>^>>v>>^<^c^>v>>^>^<^^^<^<<^
>>^>>v>>^<c^^>v>>^>^<^^^<^<<^
>>^>>v>c^^^>v>>^>^<^^^<^<<^
>>^>>v>>>^^^^^^^^<^c<v^>
>>^>>v>>>^^^^^^^^<c<^>
>>^>>v>>>^^^^^^^^<^<<vv<v>>>^c<vv<<v<^^<^<^^>>>>>>
>>^>>v>>>^^^^^^^^<^<<vv<v>>>c>^<<vv<<v<^^<^<^^>>>>>>
>>^>>v>>>^^^^^^^^<^<<vv<v>>v>c^>^<<vv<<v<^^<^<^^>>>>>>
>>^>>v>>>^^^^<c^^>^<<vv<<v<^^<^<^^>>>>>>
>>^>>v>>^<^^>c<v<v>>v>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
>>^>>v>>^<^^>vc^<v<v>>v>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
>>^>>v>>^cv>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
>>^>>v>>c>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
>>^>>v>>>^^^^^^^^<^>c><
>>^>>v>>>^^^^^^^^c>^<
>>^>>v>>>^^^^^^^c^>^<
>>^>>v>>>^^^^^^c>^<^>^<
>>^>>v>>>^^^^^c^>^<^>^<
>>^>>v>>>^^^^c^^>^<^>^<
>>^>>v>>>^^^c>^^<^>^<^>^<
>>^>>v>>>^^c^>^^<^>^<^>^<
>>^>>v>>>^cv>^^<^>^^<^>^<^>^<
>>^>>v>>>c>^^<^>^^<^>^<^>^<
>>^>>v>>>^^^^^^^^>^c<>
>>^>>v>>>^^^^^^^^>c^<>
>>^>>v>>>^^^^^^^>cv<vvv>v<<^^^^^^>>^
>>^>>v>>>^^^^^^^>vc<vvv>v<<^^^^^^>>^
>>^>>v>>>^^^>^^c^<vvv>v<<^^^^^^>>^
>>^>>v>>>^^^>^c^^<vvv>v<<^^^^^^>>^
>>^>>v>>>^^^>cv<<^^^^^^>>^
>>^>>v>>>^^^>vc<<^^^^^^>>^
>>^>>v>>>^>cv<<<^<<<^>>>>^^^^^^>>^
>>^>>v>>>^>vc<<<^<<<^>>>>^^^^^^>>^
>>^>>v>>>^^^^^^^^>^>cv^
>>^>>v>>>^^^^^^^>>^c^
>>^>>v>>>^^^^^^^>>c^^
>>^>>v>>>^^^>^^>^c^^^
>>^>>v>>>^^^>^^>cvv<^^^^^^>
>>^>>v>>>^^^>^^>vcv<^^^^^^>
>>^>>v>>>^^^>>c<^^^^^^>
>>^>>v>>>^>v>^^cvv<<^<^^>^>^^^^^>
>>^>>v>>>^>v>^cv<<^<^^>^>^^^^^>
>>^>>v>>>^>v>c<<^<^^>^>^^^^^>
cvc<v>cvcvc<v>cvc^<vv>c>>v<v<^cvc
>^>^<<<^^^>^>^>^^<cv^
>^>^<<<^^^>^>^^c^
>^>^<<<^^^>^>^c^^
>^>^<<<^^^>^>cv>>>^<^<<^^
>^>^<^^^c>>>^<^<<^^
>^>^<^^c<^>>>>^<^<<^^
>^>^<^c^<^>>>>^<^<<^^
>^>^<c>vv>^^^<<^<^>>>>^<^<<^^
>^c^>vv>^^^<<^<^>>>>^<^<<^^
>c^^>vv>^^^<<^<^>>>>^<^<<^^
>^>^<<<^^^>^>^>^^c<<>>
>^>^<<<^^^>^>^>^c^<<>>
>^>^<<<^^^>^>^>c^^<<>>
>^>^<<<^^^>^>>c^^^
>^>^<^^^>c^^^^
>^>^<^^>c^^^^^
>^>^<^>c^^^^^^
>^>^c<^^<^>^^^>^
>^>c^<^^<^>^^^>^
>^>>v<c^^<^^<^>^^^>^
>^>^<<<^^^>^>^>^^>c<v<>^>
>^>^<<<^^^>^>^>^^>vc<^>
>^>^<<<^^^>^>^>^^>>>>v<vv<<^c>^<<^>
>^>^<<<^^^>^>^>^^>>>>v<vv<<c>^^<<^>
>^>^<^^^>>c^>^^<<^>
>^>^<^>>^cv<^<^^>^>>^<<^>
>^>^<^>>c<^<^^>^>>^<<^>
>^>^<^>>vc>^^<v<^<^^>^>>^<<^>
>^>>c>^^^<v<^<^^>^>>^<<^>
>^>>vc<<^^>^^<^^>^>>^<<^>
>^>^<<<^^^>^>^>^^>>cv^
>^>^<<<^^^>^>^>^^>>>>v<<c^
>^>^<<<^^^>^>^>^^>>>>v<v<c<^>^
>^>^<<<^^^>^>^>^^>>>>v<vv<c<^^>^
>^>^<<<^^^>^>^>^^>>>>v<v>>v<v<<c^<^^>^
>^>^<<<^^^>^>^>^^>>>>v<v>>v<v<<vc^^<^^>^
>^>^<^>>v>^c>v>>^>^<^^^<^<<^
>^>^<^>>v>c^>v>>^>^<^^^<^<<^
>^>^<^>>v>vc^^>v>>^>^<^^^<^<<^
>^>^<^>>v>vvc^^^>v>>^>^<^^^<^<<^
>^>^<<<^^^>^>^>^^>>>c<v^>
>^>^<<<^^^>^>^>^^>>>>v<c<^>
>^>^<<<^^^>^>^>^^>>>>v<vc<vv<<v<^^<^<^^>>>>>>
>^>^<<<^^^>^>^>^^>>>>v<vvc>^<<vv<<v<^^<^<^^>>>>>>
>^>^<<<^^^>^>^>^^>>>>v<v>>v<v<c^>^<<vv<<v<^^<^<^^>>>>>>
>^>^<^>>v>>>>^<<^c^^>^<<vv<<v<^^<^<^^>>>>>>
>^>^<^>>v>>>>^<<c<v<v>>v>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
>^>^<^>>v>>c^<v<v>>v>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
>^>^<^>>v>>vcv>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
>^>^<^>>v>vv>c>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
>^>^<<<^^^>^>^>^^>>>>c<v^>
>^>^<<<^^^>^>^>^^>>>>vc>^<
>^>^<<<^^^>^>^>^^>>>>v<v>c^>^<
>^>^<<<^^^>^>^>^^>>>>v<v>>v<c>^<^>^<
>^>^<<<^^^>^>^>^^>>>>v<v>>v<vc^>^<^>^<
>^>^<<<^^^>^>^>^^>>>>v<v>>vvv<c^^>^<^>^<
>^>^<^>>v>>>>^<c>^^<^>^<^>^<
>^>^<^>>v>>>c^>^^<^>^<^>^<
>^>^<^>>v>>>vcv>^^<^>^^<^>^<^>^<
>^>^<^>>v>vv>>c>^^<^>^^<^>^<^>^<
>^>^<<<^^^>^>^>^^>>>>>cv^
>^>^<<<^^^>^>^>^^>>>>v>c^
>^>^<<<^^^>^>^>^^>>>>v<v>>cv<vvv>v<<^^^^^^>>^
>^>^<<<^^^>^>^>^^>>>>v<v>>vc<vvv>v<<^^^^^^>>^
>^>^<<<^^^>^>^>^^>>>>v<v>>vvc^<vvv>v<<^^^^^^>>^
>^>^<<<^^^>^>^>^^>>>>v<v>>vvvc^^<vvv>v<<^^^^^^>>^
>^>^<^>>v>>>>^cv<<^^^^^^>>^
>^>^<^>>v>>>>c<<^^^^^^>>^
>^>^<^>>v>>>v>cv<<<^<<<^>>>>^^^^^^>>^
>^>^<^>>v>>>v>>v<c<<<^<<<^>>>>^^^^^^>>^
>^>^<<<^^^>^>^>^^>>>>>>c<v^>
>^>^<<<^^^>^>^>^^>>>>>>vc^<v^>
>^>^<<<^^^>^>^>^^>>>>v<v>>v>^c^^
>^>^<<<^^^>^>^>^^>>>>v<v>>v>c^^^
>^>^<<<^^^>^>^>^^>>>>v<v>>vvv>^cvv<^^^^^^>
>^>^<<<^^^>^>^>^^>>>>v<v>>vvv>cv<^^^^^^>
>^>^<<<^^^>^>^>^^>>>>v<v>>vvv>vc<^^^^^^>
>^>^<<<^^^>^>^>^^>>>>v<v>>vvv>vvcvv<<^<^^>^>^^^^^>
>^>^<^>>v>>>v>>cv<<^<^^>^>^^^^^>
>^>^<^>>v>>>v>>vc<<^<^^>^>^^^^^>
cvcvc>>v>v<<<^cvc<v>cvc>>vvv<^^<cvcvc
^^>vv>>^^^^>^>^>^<^<<^<<c<>
^^>vv>>^^^^>^>^>^<^<<^<<vc^<>
^^>vv>^^^<<^<^>>>>^<^<c^^
^^>vv>^^^<<^<^>>>>^<^<vc^^^
^^>vv>^^^<<^<^>>c^^^^
^^>vv>^^^<^c^^^^^
^^>vv>^^^<c^^^^^^
^^>c<^^<^>^^^>^
^^>vc^<^^<^>^^^>^
^^>vvc^^<^^<^>^^^>^
^^>vv>>^^^^>^>^>^<^<<^<c<<>>
^^>vv>^^^<<^<^>>>>^<^^c<^>
^^>vv>^^^<<^<^>>>>^<^c>^<<^>
^^>vv>^^^<<^<^>>>>^<c>^^<<^>
^^>vv>^^^<<^<^>>>c^>^^<<^>
^^>vv>^^^<<^<^>>>vcv<^<^^>^>>^<<^>
^^>vv>^^^c<^<^^>^>>^<<^>
^^>vv>^^c>^^<v<^<^^>^>>^<<^>
^^>vv>^c>^^^<v<^<^^>^>>^<<^>
^^>vv>c<<^^>^^<^^>^>>^<<^>
^^>vv>>^^^^>^>^>^<^<<^cv<>^
^^>vv>>^^^^>^>^>^<^<<c^v<>^
^^>vv>^^^<<^<^>>>>^>^<c<^>^
^^>vv>^^^<<^<^>>>>^c<^^>^
^^>vv>^^^<<^<^>>>>c^<^^>^
^^>vv>>^^^^c^^<^^>^
^^>vv>>^^^c>v>>^>^<^^^<^<<^
^^>vv>>^^c^>v>>^>^<^^^<^<<^
^^>vv>>^c^^>v>>^>^<^^^<^<<^
^^>vv>>c^^^>v>>^>^<^^^<^<<^
^^>vv>>^^^^>^>^>^<^<<^>c<<<<>>>>
^^>vv>>^^^^>^>^>^<^<c<^><<<<>>>>
^^>vv>^^^<<^<^>>>>^>^c<vv<<v<^^<^<^^>>>>>>
^^>vv>^^^<<^<^>>>>^>c>^<<vv<<v<^^<^<^^>>>>>>
^^>vv>>^^^^>^c^>^<<vv<<v<^^<^<^^>>>>>>
^^>vv>>^^^^>c^^>^<<vv<<v<^^<^<^^>>>>>>
^^>vv>>^^^^>>>v<<c<v<v>>v>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
^^>vv>>>>^<^c^<v<v>>v>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
^^>vv>>>>^<cv>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
^^>vv>>>c>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
^^>vv>>^^^^>^>^>^<^<<^>>c><
^^>vv>>^^^^>^>^>^<^c>^<
^^>vv>>^^^^>^>^>^<c^>^<
^^>vv>>^^^^>^>^c>^<^>^<
^^>vv>>^^^^>^>c^>^<^>^<
^^>vv>>^^^^>>c^^>^<^>^<
^^>vv>>^^^^>>>v<c>^^<^>^<^>^<
^^>vv>>>>^<^>c^>^^<^>^<^>^<
^^>vv>>>>^cv>^^<^>^^<^>^<^>^<
^^>vv>>>>c>^^<^>^^<^>^<^>^<
^^>vv>>^^^^>^>^>^^^c<>
^^>vv>>^^^^>^>^>^^c^<>
^^>vv>>^^^^>^>^>^cv<vvv>v<<^^^^^^>>^
^^>vv>>^^^^>^>^>c<vvv>v<<^^^^^^>>^
^^>vv>>^^^^>>>>^<c^<vvv>v<<^^^^^^>>^
^^>vv>>^^^^>>>c^^<vvv>v<<^^^^^^>>^
^^>vv>>^^^^>>>vcv<<^^^^^^>>^
^^>vv>>>>^<^>>c<<^^^^^^>>^
^^>vv>>>>>>^<cv<<<^<<<^>>>>^^^^^^>>^
^^>vv>>>>>c<<<^<<<^>>>>^^^^^^>>^
^^>vv>>^^^^>^>^>^^>^c<>
^^>vv>>^^^^>^>^>^^>c^<>
^^>vv>>^^^^>^>^>^^>vc^^<>
^^>vv>>^^^^>^>^>>c^^^
^^>vv>>^^^^>>>>^cvv<^^^^^^>
^^>vv>>^^^^>>>>cv<^^^^^^>
^^>vv>>^^^^>>>>vc<^^^^^^>
^^>vv>>>>>>^^cvv<<^<^^>^>^^^^^>
^^>vv>>>>>>^cv<<^<^^>^>^^^^^>
^^>vv>>>>>>c<<^<^^>^>^^^^^>
cvcvcvcvcvcvc^^^^^<vvv<v>vv>cvcvc
^^<^^<^>^^^>>^c<>
^^<^^<^>^^^>>c<^>
^^<^^<^>^^^>v>c>^<<^>
^^<^^<^>^^^>vv>c>^^<<^>
^^<^^<^>^^^>vv>vc^>^^<<^>
^^<^^<^>^^^>vvvvv>^cv<^<^^>^>>^<<^>
^^<^^<^>^^^>vvvvv>c<^<^^>^>>^<<^>
^^<^^<^>^^^>vvvvv>vc>^^<v<^<^^>^>>^<<^>
^^<^^<^>^^^>vvvvv>v>v<c>^^^<v<^<^^>^>>^<<^>
^^<^^<^>^^^>vvvvv>v>vv<c<<^^>^^<^^>^>>^<<^>
^^<^^<^>^^^>>^>cv^
^^<^^<^>^^^>>>c^
^^<^^<^>^^^>v>>c<^>^
^^<^^<^>^^^>vv>>c<^^>^
^^<^^<^>^^^>vv>v>c^<^^>^
^^<^^<^>^^^>vvvvv>^>c^^<^^>^
^^<^^<^>^^^>vvvvv>>c>v>>^>^<^^^<^<<^
^^<^^<^>^^^>vvvvv>v>c^>v>>^>^<^^^<^<<^
^^<^^<^>^^^>vvvvv>v>vc^^>v>>^>^<^^^<^<<^
^^<^^<^>^^^>vvvvv>v>vvc^^^>v>>^>^<^^^<^<<^
^^<^^<^>^^^>>>>>>^<<c>><<
^^<^^<^>^^^>>>>c<^>
^^<^^<^>^^^>vv>>>^c<vv<<v<^^<^<^^>>>>>>
^^<^^<^>^^^>vv>>>c>^<<vv<<v<^^<^<^^>>>>>>
^^<^^<^>^^^>vv>>>vc^>^<<vv<<v<^^<^<^^>>>>>>
^^<^^<^>^^^>vvvvv>v>v>>>^^<^<c^^>^<<vv<<v<^^<^<^^>>>>>>
^^<^^<^>^^^>vvvvv>v>v>>>^^<<c<v<v>>v>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
^^<^^<^>^^^>vvvvv>v>>c^<v<v>>v>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
^^<^^<^>^^^>vvvvv>v>v>cv>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
^^<^^<^>^^^>vvvvv>v>vv>c>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
^^<^^<^>^^^>>>>>>^<c<<>>
^^<^^<^>^^^>>>>>c>^<<<>>
^^<^^<^>^^^>vv>>>^>c^>^<
^^<^^<^>^^^>vv>>>>c>^<^>^<
^^<^^<^>^^^>vvvvv>v>v>>>^^<^^c^>^<^>^<
^^<^^<^>^^^>vvvvv>v>v>>>^^<^c^^>^<^>^<
^^<^^<^>^^^>vvvvv>v>v>>>^^<c>^^<^>^<^>^<
^^<^^<^>^^^>vvvvv>v>v>>^c^>^^<^>^<^>^<
^^<^^<^>^^^>vvvvv>v>v>>cv>^^<^>^^<^>^<^>^<
^^<^^<^>^^^>vvvvv>v>v>>vc>^^<^>^^<^>^<^>^<
^^<^^<^>^^^>>>>>>^cv><^
^^<^^<^>^^^>>>>>>c^v><^
^^<^^<^>^^^>>>>>>^>vv<cv<vvv>v<<^^^^^^>>^
^^<^^<^>^^^>vv>>>>>c<vvv>v<<^^^^^^>>^
^^<^^<^>^^^>vvvvv>v>v>>>^^^^c^<vvv>v<<^^^^^^>>^
^^<^^<^>^^^>vvvvv>v>v>>>^^^c^^<vvv>v<<^^^^^^>>^
^^<^^<^>^^^>vvvvv>v>v>>>^^cv<<^^^^^^>>^
^^<^^<^>^^^>vvvvv>v>v>>>^c<<^^^^^^>>^
^^<^^<^>^^^>vvvvv>v>v>>>cv<<<^<<<^>>>>^^^^^^>>^
^^<^^<^>^^^>vvvvv>v>v>>>vc<<<^<<<^>>>>^^^^^^>>^
^^<^^<^>^^^>>>>>>^>cvvv^^^
^^<^^<^>^^^>>>>>>^>vc^vvv^^^
^^<^^<^>^^^>>>>>>^>vvc^^vvv^^^
^^<^^<^>^^^>vvvvv>v>v>>>^^^^>^c^^^
^^<^^<^>^^^>vvvvv>v>v>>>^^^^>cvv<^^^^^^>
^^<^^<^>^^^>vvvvv>v>v>>>^>^^cv<^^^^^^>
^^<^^<^>^^^>vvvvv>v>v>>>^>^c<^^^^^^>
^^<^^<^>^^^>vvvvv>v>v>>>^>cvv<<^<^^>^>^^^^^>
^^<^^<^>^^^>vvvvv>v>v>>>v>^cv<<^<^^>^>^^^^^>
^^<^^<^>^^^>vvvvv>v>v>>>v>c<<^<^^>^>^^^^^>
c<v>c>v<c>v<cvc^>^<<v<vv>v>^cvc^>vv<c>v<c>^^^<v<v<vv>>c
<<^^>^^<^^>^>>^^c<>
<<^^>^^<^^>^>>^c^<>
<<^^>^^<^^>^>>c<^>^
<<^^>^^<^^>^>>vc<^^>^
<<^^>^^<^^>^>>vvc^<^^>^
<<^^>^>^>c^^<^^>^
<<^^>^>^>vc>v>>^>^<^^^<^<<^
<<^^>^>^>vvc^>v>>^>^<^^^<^<<^
<<^^>^>^>vvvc^^>v>>^>^<^^^<^<<^
<<^^>^>^>vvvvc^^^>v>>^>^<^^^<^<<^
<<^^>^^<^^>^>>^^>c<<>>
<<^^>^^<^^>^>>^>c<^><<>>
<<^^>^^<^^>^>>>c<vv<<v<^^<^<^^>>>>>>
<<^^>^^<^^>^>>vv>^c>^<<vv<<v<^^<^<^^>>>>>>
<<^^>^^<^^>^>>vv>c^>^<<vv<<v<^^<^<^^>>>>>>
<<^^>^^<^^>^>>vv>vc^^>^<<vv<<v<^^<^<^^>>>>>>
<<^^>^>^>vv>^c<v<v>>v>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
<<^^>^>^>vv>c^<v<v>>v>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
<<^^>^>^>vv>vcv>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
<<^^>^>^>vv>v>v<c>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
<<^^>^^<^^>^>>^^>>c>v^<
<<^^>^^<^^>^>>>>^c>^<
<<^^>^^<^^>^>>>>c^>^<
<<^^>^>^>vv>^>^>^^<c>^<^>^<
<<^^>^>^>vv>^>^>^^<vc^>^<^>^<
<<^^>^>^>vv>^>^c^^>^<^>^<
<<^^>^>^>vv>^>c>^^<^>^<^>^<
<<^^>^>^>vv>>c^>^^<^>^<^>^<
<<^^>^>^>vv>v>cv>^^<^>^^<^>^<^>^<
<<^^>^>^>vv>v>vc>^^<^>^^<^>^<^>^<
<<^^>^^<^^>^>>^^>>>cv^
<<^^>^>^>vv>^>^>^^^^c^
<<^^>^>^>vv>^>^>^^^cv<vvv>v<<^^^^^^>>^
<<^^>^>^>vv>^>^>^^c<vvv>v<<^^^^^^>>^
<<^^>^>^>vv>^>^>^c^<vvv>v<<^^^^^^>>^
<<^^>^>^>vv>^>^>c^^<vvv>v<<^^^^^^>>^
<<^^>^>^>vv>^>^>vcv<<^^^^^^>>^
<<^^>^>^>vv>^>^>vvc<<^^^^^^>>^
<<^^>^>^>vv>^>^>vvvcv<<<^<<<^>>>>^^^^^^>>^
<<^^>^>^>vv>v>v>c<<<^<<<^>>>>^^^^^^>>^
<<^^>^>^>vv>^>^>^^^>^^c<>
<<^^>^>^>vv>^>^>^^^>^c^<>
<<^^>^>^>vv>^>^>^^^>c^^<>
<<^^>^>^>vv>^>^>^^>c^^^
<<^^>^>^>vv>^>^>>^cvv<^^^^^^>
<<^^>^>^>vv>^>^>>cv<^^^^^^>
<<^^>^>^>vv>^>^>>vc<^^^^^^>
<<^^>^>^>vv>^>^>>vvcvv<<^<^^>^>^^^^^>
<<^^>^>^>vv>^>^>vvv>cv<<^<^^>^>^^^^^>
<<^^>^>^>vv>v>v>>c<<^<^^>^>^^^^^>
cvc<v>c<v>cvcvc^^<^^>>>v>vvv>v<v<<^<cvcvcvc
^^^>v>>^>^<^^^<^<^c<>
^^^>v>>^>^<^^^<^<c<^>
^^^>v>>^>^<^^^<<c<vv<<v<^^<^<^^>>>>>>
^^^>v>>^>^<^^^<v<c>^<<vv<<v<^^<^<^^>>>>>>
^^^>v>>^>^<^^^<vv<c^>^<<vv<<v<^^<^<^^>>>>>>
^^^>v>>^>^<^^^<^<<<vv>vv>c^^>^<<vv<<v<^^<^<^^>>>>>>
^^^>c<v<v>>v>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
^^^>vc^<v<v>>v>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
^>cv>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
>c>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
^^^>v>>^>^<^^^<^<^>c><
^^^>v>>^>^<^^^<^c>^<
^^^>v>>^>^<^^^<c^>^<
^^^>v>>^>^<^^^<vc>^<^>^<
^^^>v>>^>^<^^^<vvc^>^<^>^<
^^^>v>>^>^<^^^<^<<<vv>vv>>c^^>^<^>^<
^^^>v>>^<c>^^<^>^<^>^<
^^^>v>c^>^^<^>^<^>^<
^>>cv>^^<^>^^<^>^<^>^<
^^^>v>>>vv<<c>^^<^>^^<^>^<^>^<
^^^>v>>^>^<^^^<^>>^<c<>
^^^>v>>^>^<^^^<^>c^
^^^>v>>^>^<^^^cv<vvv>v<<^^^^^^>>^
^^^>v>>^>^<^^c<vvv>v<<^^^^^^>>^
^^^>v>>^>^<^c^<vvv>v<<^^^^^^>>^
^^^>v>>^>^<c^^<vvv>v<<^^^^^^>>^
^^^>v>>^cv<<^^^^^^>>^
^^^>v>>c<<^^^^^^>>^
^^^>v>>vcv<<<^<<<^>>>>^^^^^^>>^
^^^>v>>>vv<c<<<^<<<^>>>>^^^^^^>>^
^^^>v>>^>^<^^^<^>>^c<<>>
^^^>v>>^>^<^^^<^>>c^<<>>
^^^>v>>^>^<^^^>c^^
^^^>v>>^>^<^^>c^^^
^^^>v>>^>^<^>cvv<^^^^^^>
^^^>v>>^>^cv<^^^^^^>
^^^>v>>^>c<^^^^^^>
^^^>v>>>cvv<<^<^^>^>^^^^^>
^^^>v>>>vcv<<^<^^>^>^^^^^>
^^^>v>>>vvc<<^<^^>^>^^^^^>
c<v>c<^<<<<<vv>v>vv>^>>^^>c>v<cvcvc^^>>vvvv>vv<^<v<^<<^>^>cvc^<v<v>>cvc
>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>>c><
>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>v>>c>^<
>^>v>^^<^^^^<^c^>^<
>^>v>^^<^^^^<c>^<^>^<
>^>v>^^<^^^<c^>^<^>^<
>^>v>^^<^^<c^^>^<^>^<
^<<^>^>>c>^^<^>^<^>^<
^<<^>^>>vc^>^^<^>^<^>^<
>^cv>^^<^>^^<^>^<^>^<
>c>^^<^>^^<^>^<^>^<
>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>v>>>^c<>
>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>v>>>c^<>
>^>v>^^<^^^^^cv<vvv>v<<^^^^^^>>^
>^>v>^^<^^^^c<vvv>v<<^^^^^^>>^
>^>v>^^<^^^c^<vvv>v<<^^^^^^>>^
>^>v>^^<^^c^^<vvv>v<<^^^^^^>>^
>^>v>^^<^cv<<^^^^^^>>^
>^>v>^^<c<<^^^^^^>>^
>^>cv<<<^<<<^>>>>^^^^^^>>^
>^>vc<<<^<<<^>>>>^^^^^^>>^
>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>v>>>^>cv^
>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>v>>>>c^
>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>v>>>>vc^^
>^>v>^^<^^^^>c^^^
>^>v>^^<^^>^cvv<^^^^^^>
>^>v>^^<^^>cv<^^^^^^>
>^>v>^^<^^>vc<^^^^^^>
>^>v>^^cvv<<^<^^>^>^^^^^>
>^>v>^cv<<^<^^>^>^^^^^>
>^>v>c<<^<^^>^>^^^^^>
c>v<cvc>v<cvcvc^>vv<cvc>vv<^cvc
>^^<^>^^<^>^<^>^cv><^
>^^<^>^^<^>^<^>c^v><^
>^^<^>^^<^>^cv<vvv>v<<^^^^^^>>^
>^^<^>^^<^>c<vvv>v<<^^^^^^>>^
>^^<^>^^c^<vvv>v<<^^^^^^>>^
>^^<^>^c^^<vvv>v<<^^^^^^>>^
>^^<^>cv<<^^^^^^>>^
>^^c<<^^^^^^>>^
>^cv<<<^<<<^>>>>^^^^^^>>^
>c<<<^<<<^>>>>^^^^^^>>^
>^^<^>^^<^>^>^^c<>
>^^<^>^^<^>^>^c^<>
>^^<^>^^<^>^>c^^<>
>^^<^>^^<^>>c^^^
>^^<^>^^>cvv<^^^^^^>
>^>^^^cv<^^^^^^>
>^>^^c<^^^^^^>
>^>^cvv<<^<^^>^>^^^^^>
>^>cv<<^<^^>^>^^^^^>
>^>vc<<^<^^>^>^^^^^>
cvc<<vvvvvv>>^<^^^>^cvcvcvc^^<vvv>cvc<<<<<<v>>>v>>>^cvc
<<<^<<<^>>>>^^^^^^>>>^c<>
<<<^<<<^>>>>^^^^^^>>>c^<>
<<<^<<<^>>>>^^^^^^>>>vc^^<>
<<<^<<<^>>>>>>^<^^^>v>^c^^^
<<<^<<<^>>>>>>^<^^^>v>cvv<^^^^^^>
<<<^<<<^>>>>>>^>^cv<^^^^^^>
<<<^<<<^>>>>>>^>c<^^^^^^>
<<<^<<<^>>>>>>^>vcvv<<^<^^>^>^^^^^>
^>cv<<^<^^>^>^^^^^>
>c<<^<^^>^>^^^^^>
cvcvcvc^^^<vvvvvv>^^cvcvc<^<v<vv>v>>^^cvcvc

Może to być zaskoczeniem, ale nie napisałem tego ręcznie ... kod został wygenerowany przez następujący program Mathematica:

layouts = Graph /@ {Labeled[DirectedEdge[#, #2], #3] & @@@ {{0, 1, ">"}, ... };
path[layout_, a_, b_] := 
 StringJoin[
  PropertyValue[{layouts[[layout + 1]], #}, EdgeLabels] & /@ 
   DirectedEdge @@@ 
    Partition[FindShortestPath[layouts[[layout + 1]], a, b], 2, 1]]
safetyCheck[layout_, target_] = "";
safetyCheck[0, 1] = safetyCheck[0, 11] = "v<>^";
safetyCheck[0, 2] = "v^";
safetyCheck[0, 3] = safetyCheck[0, 13] = "<>";
safetyCheck[0, 4] = "<<>>";
safetyCheck[0, 5] = "v^";
safetyCheck[0, 6] = "<v^>";
safetyCheck[0, 7] = "><";
safetyCheck[0, 8] = safetyCheck[0, 18] = "<>";
safetyCheck[0, 9] = "v^";
safetyCheck[1, 2] = "v^";
safetyCheck[1, 3] = safetyCheck[1, 13] = safetyCheck[1, 23] = "<<>>";
safetyCheck[1, 4] = "<v<>^>";
safetyCheck[1, 5] = "v^";
safetyCheck[1, 6] = "<v^>";
safetyCheck[1, 7] = "<v^>";
safetyCheck[1, 8] = "v^";
safetyCheck[1, 9] = safetyCheck[1, 19] = "<v^>";
safetyCheck[2, 3] = safetyCheck[2, 13] = "<>";
safetyCheck[2, 4] = "<<>>";
safetyCheck[2, 5] = safetyCheck[2, 15] = "v<>^";
safetyCheck[2, 6] = safetyCheck[2, 16] = "<<<<>>>>";
safetyCheck[2, 7] = "><";
safetyCheck[2, 8] = safetyCheck[2, 18] = "<>";
safetyCheck[2, 9] = safetyCheck[2, 19] = safetyCheck[2, 29] = "<>";
safetyCheck[3, 4] = "<>";
safetyCheck[3, 5] = "v^";
safetyCheck[3, 6] = ">><<";
safetyCheck[3, 7] = safetyCheck[3, 17] = "<<>>";
safetyCheck[3, 8] = safetyCheck[3, 18] = "v><^";
safetyCheck[3, 9] = safetyCheck[3, 19] = safetyCheck[3, 29] = "vvv^^^";
safetyCheck[4, 5] = safetyCheck[4, 15] = "<>";
safetyCheck[4, 6] = safetyCheck[4, 16] = "<<>>";
safetyCheck[4, 7] = ">v^<";
safetyCheck[4, 8] = "v^";
safetyCheck[4, 9] = safetyCheck[4, 19] = safetyCheck[4, 29] = "<>";
safetyCheck[5, 6] = "<>";
safetyCheck[5, 7] = "><";
safetyCheck[5, 8] = "<>";
safetyCheck[5, 9] = safetyCheck[5, 19] = "<<>>";
safetyCheck[6, 7] = "><";
safetyCheck[6, 8] = safetyCheck[6, 18] = "<>";
safetyCheck[6, 9] = "v^";
safetyCheck[7, 8] = safetyCheck[7, 18] = "v><^";
safetyCheck[7, 9] = safetyCheck[7, 19] = safetyCheck[7, 29] = "<>";
safetyCheck[8, 9] = safetyCheck[8, 19] = safetyCheck[8, 29] = "<>";

minions = {};
For[i = 0, i < 10, ++i,
  collector = "c";
  For[j = i, j < 90, j += 10,
   collector = collector <> path[i, j, j + 10] <> "c"
   ];
  AppendTo[minions, collector];
  For[newI = i + 1, newI < 10, ++newI,
   For[k = 0, k < 10, ++k,
    AppendTo[minions, 
     path[i, j, 10 k + newI] <> "c" <> path[newI, 10 k + newI, newI] <>
       safetyCheck[i, 10 k + newI]]
    ]
   ]
  ];
StringRiffle[minions, "\n"]

Wszystkie te safetyCheckwiersze napisałem ręcznie. Ale pierwszy wiersz tego kodu Mathematica ma w rzeczywistości około 28 000 znaków i sam został wygenerowany przez następujący kod CJam:

'{o
q~]{-1:W;
2b200Te[W%2/{W):W;~\{
  "{"W+","W)++",\">\"}"+
  "{"W)+","W++",\"<\"}"+
  @
}*{
  "{"W+","WA+++",\"v\"}"+
  "{"WA++","W++",\"^\"}"+
}*}%", "*"Labeled[DirectedEdge[#,#2],#3]&@@@{ }"S/\*

]o',oNoNo}/'}

(Który przyjmuje jako dane wejściowe 10 układów zakodowanych na stałe w interpretatorze. Możesz uruchomić kod online. )

Recepcja generowania kodu!

Wyjaśnienie

Na początek spójrz na ten skrypt CJam, aby zobaczyć, jak wyglądają labirynty.

Moje rozwiązanie opiera się na jednej ważnej obserwacji: dopóki podnosimy przedmioty wzdłuż jednej kolumny, nie będziemy zmieniać między układami, niezależnie od tego, czy komórki są wypełnione, czy nie. W szczególności, dopóki będziemy poruszać się wzdłuż lewej kolumny, pozostaniemy w układzie 0. Dopóki przejdziemy do następnej kolumny, będziemy zachowywać układ 1.

Problem polega na tym, jak zapewnić zmianę między układami, ponieważ nie wiemy, które komórki w kolumnie 1mają na sobie elementy (jeśli w ogóle!).

Oto algorytm (zaczynający się na komórce 0w układzie 0):

1. Zbierz wszystkie przedmioty wzdłuż bieżącej kolumny, kończąc na dolnym rzędzie. Ten stronnik nigdy nie umrze.

2. Teraz dla każdej komórki po prawej stronie bieżącej kolumny (wypróbuj je w kolejności według kolumny), spróbuj przenieść się tam w bieżącym układzie, podnieś element, a następnie przejdź do górnego rzędu w tej nowej kolumnie, używając nowego układu.

   Jeśli próbowana komórka zawierała element, układ ulegnie zmianie i pomyślnie przejdziemy do nowej kolumny i układu. Ponieważ nowa (bezpieczna) pozycja znajduje się w górnym rzędzie, ale wszystkie próby znalezienia następnej kolumny obejmują 10 ruchów w górę netto, wszystkie inne próby zakończą się niepowodzeniem, więc możemy je zignorować.

   Jeśli próbowana komórka nie zawierała przedmiotu, w większości przypadków stwór umrze podczas próby dotarcia do górnego rzędu przy użyciu złego układu, dlatego odrzuca tę próbę. Jednak nie zawsze tak jest. Na przykład próbowana komórka może już znajdować się w górnym rzędzie, więc w nowym układzie nie wykonano żadnych ruchów. Podobnie, w niektórych przypadkach ścieżka od próbowanej komórki do górnego rzędu jest wystarczająco krótka, aby była poprawna w obu układach. Zebrałem wszystkie przypadki, w których jest to problem ręcznie, i określiłem zestaw ruchów, który jest poprawny tylko w nowym układzie (ale który przenosi stwora z powrotem do komórki docelowej, więc w rzeczywistości jest to brak możliwości Nowy układ). Po każdej próbie, w której może to stanowić problem, wykonuję ten zestaw ruchów, aby zabić stwory, które nie „

3. Teraz pomyślnie przeszliśmy na górę następnej kolumny, która zawiera co najmniej jeden element. Wróć do kroku 1.

Możesz zauważyć, że struktura rozwiązania jest następująca:

Line with 10 "c"s
90 lines with 1 "c"
Line with 10 "c"s
80 lines with 1 "c"
Line with 10 "c"s
70 lines with 1 "c"
Line with 10 "c"s
60 lines with 1 "c"
...
Line with 10 "c"s
10 lines with 1 "c"
Line with 10 "c"s

Jeśli chodzi o kod Mathematica, safetyCheckciągi to te ręcznie wybierane ruchy, które zapewniają, że osiągnęliśmy nowy układ. Pierwszy parametr wyszukiwania to układ, od którego zaczynamy, a drugi to komórka, którą próbowaliśmy. Wszelkie kombinacje, które nie zostały wyraźnie wymienione, dają jedynie pustą kontrolę bezpieczeństwa (ponieważ żadna nie jest konieczna).

Oprócz tego po prostu ustawiam 10 labiryntów jako Graphobiekty, w których są dwie skierowane krawędzie między dowolnymi sąsiednimi (i połączonymi) komórkami, gdzie każda krawędź jest opatrzona adnotacjami o ruchu wymaganym do przejścia przez krawędź. Dzięki temu mogę po prostu znaleźć ścieżki za pomocą, FindShortestPatha następnie wyodrębnić odpowiednie etykiety krawędzi PropertyValue[..., EdgeLabels].

Reszta kodu korzysta z tego, aby zaimplementować powyższy algorytm dość bezpośrednio.

Rzeczywiste dane wykresu są przechowywane layoutsi zostały wygenerowane za pomocą skryptu CJam, który dekoduje liczby zgodnie z opisem w poście gliniarza i przekształca je w listę Mathematica, którą można łatwo przekształcić w wykres.

HPR, autor: Zgarb

Kod:

#(*#(!(-)(#(-)()))()!(-)(-)#(!(-)(#(-)()))())(!(-)(#(-)()))#(!(#(!(#(!(-)(#(-)())*#(!(-)(#(-)()))())(!(-)(#(-)()))#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(-)(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(#(*)()#(!(-)(#(-)()))()))))#(!(-)(#(-)()))())#(!(-)(#(-)()))())))!(-)(#(-)()))#(!(-)(#(-)()))())(!(#(!(-)(#(-)())*#(!(-)(#(-)()))())(!(-)(#(-)()))!(-)(#(-)()))(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(-)(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(#(*)()#(!(-)(#(-)()))()))))#(!(-)(#(-)()))())#(!(-)(#(-)()))())))#(!(-)(#(-)()))())!(-)(#(-)()))#(#(!(-)(#(-)()))())(*!(-)(#(-)())))(#(*)())#(!(-)(#(-)()))())(!(-)(#(-)()))!($)(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(#(*)()#(!(-)(#(-)()))())))#(#(!(-)(#(-)()))())(*!(-)(#(-)()))#(*#(!(-)(#(-)()))()!(-)(-)#(!(-)(#(-)()))())(!(-)(#(-)()))#(!(#(!(#(!(-)(#(-)())*#(!(-)(#(-)()))())(!(-)(#(-)()))#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(-)(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(#(*)()#(!(-)(#(-)()))()))))#(!(-)(#(-)()))())#(!(-)(#(-)()))())))!(-)(#(-)()))#(!(-)(#(-)()))())(!(#(!(-)(#(-)())*#(!(-)(#(-)()))())(!(-)(#(-)()))!(-)(#(-)()))(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(-)(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(#(*)()#(!(-)(#(-)()))()))))#(!(-)(#(-)()))())#(!(-)(#(-)()))())))#(!(-)(#(-)()))())!(-)(#(-)()))#(#(!(-)(#(-)()))())(*!(-)(#(-)())))(#(*)())#(!(-)(#(-)()))())(!(-)(#(-)()))!($)(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(#(*)()#(!(-)(#(-)()))())))#(#(!(-)(#(-)()))())(*!(-)(#(-)()))#(*#(!(-)(#(-)()))()!(-)(-)#(!(-)(#(-)()))())(!(-)(#(-)()))#(!(#(!(#(!(-)(#(-)())*#(!(-)(#(-)()))())(!(-)(#(-)()))#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(-)(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(#(*)()#(!(-)(#(-)()))()))))#(!(-)(#(-)()))())#(!(-)(#(-)()))())))!(-)(#(-)()))#(!(-)(#(-)()))())(!(#(!(-)(#(-)())*#(!(-)(#(-)()))())(!(-)(#(-)()))!(-)(#(-)()))(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(-)(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(#(*)()#(!(-)(#(-)()))()))))#(!(-)(#(-)()))())#(!(-)(#(-)()))())))#(!(-)(#(-)()))())!(-)(#(-)()))#(#(!(-)(#(-)()))())(*!(-)(#(-)())))(#(*)())#(!(-)(#(-)()))())(!(-)(#(-)()))!($)(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(#(*)()#(!(-)(#(-)()))())))!(#(*#(!(-)(#(-)()))())(!(-)(#(-)()))-)(#(#(*#(!(-)(#(-)()))())(!(-)(#(-)()))-)())#(!(-)(#(-)()))()

Przede wszystkim ... kod został wygenerowany, a nie ręcznie pisany (lub wpisywany).

Fakty o języku:

• To nie jest ukończenie Turinga.
• Nie można porównywać liczb całkowitych znalezionych w środowisku.
• Możesz porównać liczby całkowite na listach z liczbami całkowitymi w środowisku.
• Nie można dodawać elementów do list ani zmieniać elementów na listach.

Program wykorzystuje następujący kod psuedocode:

global item
global list = input()

biggest()
remove()
biggest()
remove()
biggest()
print()

def remove():
    while item != list[0]:
        rotate_list
    list.remove(0)
def print():
    rotate_list until item == list[0]
    do until no change:
        list.pop()
        subtract
    removeList()
def biggest():
    item = 0
    while hasListWithElements():
        if item < list1[0]:
            item = list1[0]
        list.remove(0)
    restore list

Środowisko prawie zawsze zawiera tylko 1 listę i 1 liczbę całkowitą.

Aby rozwiązać ten problem, stworzyłem mały silnik makr dla tego języka. Pozwala także na komentarze. Oto silnik makr:

import sys

code = {}


filename = sys.argv[1]
f = open(filename, 'r')
prog = f.read()
f.close()

def c(prog):
    for n in prog.splitlines():
        if n.startswith('def'):
            parts = n[4:].split(' ', 2)
            code[parts[0]] = int(parts[1]) ,parts[2]
            prog = prog.replace(n, '', 1)
        elif n.strip().startswith('//'):
            prog = prog.replace(n, '', 1)
    return compile(prog)

def compile(prog):
    ret = ''
    while prog:
        n = prog[0]
        if n == '<':
            name = prog[1:prog.find('>')]
            args_count, formatter = code[name]
            if args_count == 0:
                prog = prog[prog.find('>') + 1:]
                ret += compile(formatter)[0]
                continue;
            prog = prog[prog.find('>') + 2:]
            args = []
            for n in range(args_count):
                arg, prog = compile(prog)
                if n == args_count - 1:
                    arg = arg[:-1]
                args.append(arg)
            ret += compile(formatter.format(*args))[0]
        elif n == ')':
            return ret + ')', prog[1:]
        elif n == ',':
            return ret, prog[1:]
        elif n == '(':
            c, prog = compile(prog[1:])
            ret += '(' + c
        else:
            ret += n
            prog = prog[1:]
    return ret.replace('\n','').replace(' ',''), prog

print(c(prog)[0]) #Use pipes to put into file.

Po zbudowaniu silnika makr powoli budowałem przydatne funkcje dla tego języka. Oto kod przetworzony przez silnik w celu utworzenia programu:

//While loop
def w 2 !({1})({0})

//Detects changes
def c 1 #({0})()

//Do while it changes:
def wc 1 <w>(<c>({0}), {0})

//Remove all items:
def rint 0 <wc>(-)

//Contains list:
def clist 0 <rint>

//Remove all lists:
def rlist 0 #(<rint>)()

//Contains item:
def cint 0 <rlist>

//False (empty environment):
def false 0 <rint><rlist>

//Not:
def not 1 !(<false>)({0})

//Bool (if expression does not evaluate to an empty environment,
// restore the environment to its previous state.
def bool 1 <not>(<not>({0}))

//And
def and 2 <bool>({0}){1}

//Or
def or 2 <not>(<and>(<not>({0}), <not>({1})))

//Combine parts (takes the integer parts of first argument and 
//combines them with the list parts of second argument):
def p 2 #({0}<rlist>)({1}<rint>)

//If, executes an expression if condition evalutates to true. Only works in standard environment.
def if 2 <p>(!({1}<rlist>)(<and>({0}, <rint>)),!({1}<rint>)(<and>({0}, <rlist>)))

//equal (compares item to list[0]) for equality:
def eq 0 <not>(#(*)()<rlist>)

//list.remove(0), does not change item:
def listr 0 <p>(, *)

//remove, removes item from list, goes into infinite loop if list does not contain item.
def remove 0 <w>(<not>(<eq>), $)<listr>

//Greater than or equal, item >= list[0]: 
def ge 0 <w>(<and>(<not>(<eq>), <rlist>), -)<rlist>

//Less than, item < list[0]:
def lt 0 <not>(<ge>)

//Zero, sets item to zero:
def zero 0 <p>(*<rlist>!(-)(-), )

//Biggest, puts biggest item in the list into item:
def biggest 0 <zero><p>(<w>(<c>(*), <if>(<lt>, <p>(<rint>*, ))<listr>), )

//print item, item must be somewhere on list.
def print 0 <w>(<not>(<eq>), $)<wc>(<p>(*, )-)<rlist>

//The actual program!!!!
<biggest>
<remove>
<biggest>
<remove>
<biggest>
<print>

Brian & Chuck autorstwa Martina Büttnera

Poniższy program Python 2.7 generuje mój program Brian & Chuck, tłumacząc program pieprzenia mózgu na Brian & Chuck (z wyjątkiem, że .zawsze drukuje 1, ponieważ jest to jedyny znak, który musimy wypisać).

Kontrola przepływu działa magicznie, gdy Brian wypisuje polecenia Chucka na taśmie, aby wysłać Briana do właściwej pozycji w kodzie.

Zwróć uwagę, że białe znaki []dodane do programu B&C mają jedynie charakter dekoracyjny.

def brainfuck_to_brianchuck(code):
    # find biggest jump needed
    biggest_jump = 0
    idx = 0
    while idx < len(code):
        if code[idx] == '[':
            end = matching_bracket(code,idx)
            jump = sum(c == '[' for c in code[idx:end])
            if jump > biggest_jump:
                biggest_jump = jump
            idx = end
        idx += 1
    block_size = biggest_jump*4 + 4

    fragments = []
    depth = 0
    for idx,c in enumerate(code):
        if c in '<>':
            fragments.append(block_size*c)
        elif c == '[':
            end = matching_bracket(code,idx)
            jump = sum(c == '[' for c in code[idx:end])
            fragments.append('\n' + '  '*depth)
            fragments.append('[ ' + open_while(jump))
            depth += 1
            fragments.append('\n' + '  '*depth)
        elif c == ']':
            start = matching_bracket(code,idx)
            jump = sum(c == '[' for c in code[start:idx])
            depth -= 1
            fragments.append('\n' + '  '*depth)
            fragments.append('] ' + close_while(jump))
            fragments.append('\n' + '  '*depth)
        elif c == '.':
            fragments.append('>' + write('0>.?',True) + '<<<?1<<<' + write('0>.?',False) + '<<<<')
        elif c in ',+-':
            fragments.append(c)
    return ''.join(fragments) + '\n```'


def open_while(jump):
    fragments = []

    right = '0' + '}>}>'*jump + '?'
    fragments.append('>' + write(right,True))
    r = len(right)-1
    fragments.append('<'*r + '?' + '_0')

    left = '{<{<'*jump + '>>?'
    l = len(left)-1
    fragments.append('<'*l)
    fragments.append(write(left,False))
    fragments.append('<'*l + '<')

    return ''.join(fragments)

def close_while(jump):
    fragments = []

    right = '0' + '}>}>'*jump + '?'
    fragments.append('>' + write(right,True))
    r = len(right)-1
    fragments.append('_0' + '<'*r)
    fragments.append(write(right,False))
    fragments.append('<'*r)

    left = '{<{<'*jump + '>>?'
    l = len(left)-1
    fragments.append(write(left,True))
    fragments.append('<'*l + '<' + '?>')
    fragments.append(write(left,False))
    fragments.append('<'*l + '<')

    return ''.join(fragments)

# returns the code to write s, or erase it if increment is False
def write(s,increment):
    c = '+' if increment else '-'
    return '>'.join(c*ord(a) for a in s)

def matching_bracket(code, idx):
    bracket = code[idx]
    other_bracket = ']' if bracket == '[' else '['
    direction = 1 if bracket == '[' else -1
    idx += direction
    while code[idx] != other_bracket:
        if code[idx] == bracket:
            idx = matching_bracket(code, idx)
        idx += direction
    return idx

print brainfuck_to_brianchuck('''
-
>,------------------------------------------------[
    ,------------------------------------------------[
        ->+>>>[>+<<<<->>>-]<[>+<<<->>-]<[>+<<->-]>>>[<+>-]<<<<[>+<-]
        >>>>>,------------------------------------------------
    ]
    <+[-<<<<<<+]-
    >,------------------------------------------------
]
>>>>[.>>>>>>].
''')

Firetype, autor: kirbyfan64sos

Działający, skomentowany kod:

_ Beginning of the loop where one iteration reads one unary number.
- Decrement to cancel the next +, which is part of the loop.
+ Increment... this is executed once for each 1 we read.
, Read a character.
^ "eval"
# Negate.
* Double three times to get -8 if we read a 1 and 0 otherwise.
*
*
% If we read a 1, jump back to the +. Otherwise, continue.
# Negate the resulting number to reverse the sort order later.
` Duplicate...
~ Logical NOT twice, to turn non-zero results into 1 (zeroes remain zeroes).
~
* Double, double, square, double, negate, to get -32 if the last number
* we read was non-zero. The double-0 at the end of the input leads to a
| zero being read as a unary number, which we use as the termination
* condition. When this is the case, the current cell will be 0 instead  
# of -32. The next lines are padding to get the jump right...












% So... if the unary number was not 0, jump back to the _.
\ Sort the list... the sort is descending, but we negated all the values...
< That means the largest value next to the pointer now, just with a minus
< sign. We move to the left three times to find the place where the third
< largest value is.
# Negate to get its positive value again.
` Duplicate to ensure we've got a cell to the left of the result.
< Move left to the other copy.
~ Logical NOT twice, to turn it into a 1.
~
> Move right to the result.
! This moves the pointer to the left (onto the 1) and executes "." (print)
. "result" times, printing the result in unary. Yay!

Zależy to od tłumacza, jak podano obecnie w odpowiedzi policjanta, co jest nieco sprzeczne z dokumentacją dotyczącą %i !.

Głównym wyzwaniem było tutaj przeanalizowanie danych wejściowych, ponieważ \znalezienie trzeciej trzeciej wartości jest dość proste.

Acc !, DLosc

Ten język ma straszne wsparcie porównania.

Count b while 0 {
}
Count c while 0 {
}
Count a while N-48 {
    Count q while N-48 {
    }
    Count a while _ {
        _ - 1
    }
    a - (q + 1)
    Count z while (z-(10^6+1)) * (_ - z) {
    }
    Count x while (_ - z) {
       b
       Count c while _ {
           _ - 1
       }
       a
       Count b while _ {
           _ - 1
       }
       q
       Count a while _ {
           _ - 1
       }
       z
    }
    z-((10^6)+1)
    Count x while _ {
        b - (q + 1)
        Count f while (f-(10^6+1)) * (_ - f) {
        }
        Count x while (_ - f) {
            b
            Count c while _ {
                _ - 1
            }
            q
            Count b while _ {
                _ - 1
            }
            f
        }
        f-((10^6)+1)
        Count x while _ {
            c - (q + 1)
            Count k while (k-(10^6+1)) * (_ - k) {
            }
            Count x while (_ - k) {
                q
                Count c while _ {
                    _ - 1
                }
                k
            }
            0
        }
        0
    }
    0
    Count j while (a - _) {
        _ + 1
    }
}
c
Write 49
Count h while _ {
    Write 49
    _ - 1
}

W count [varname] while 0wypowiedzi na początku mają zadeklarować zmienną posiadających największą liczbę, drugi największy numer, trzecią co do wielkości liczbę, i tak dalej. Porównania dokonuje się odejmując dwie liczby, a następnie sprawdzając, czy wynik jest ujemny, sprawdzając, czy liczba jest mniejsza 10^6.

Cynk, autor: kirbyfan64sos

To nie było takie trudne, kiedy zrozumiałem, jak działa ten język. Trudną częścią było wyłapanie błędów parsera, ale wydawało się, że dodanie zbędnych nawiasów to rozwiązało. Oto rozwiązanie:

let
+=cut
in {d:{c:({b:{a:S^((#S)-_)-1}^_})+0$#c}^_=2}

Wyjaśnienie

W pierwszym i drugim rzędzie określam, +że jest to cutoperacja. Reszta to zrozumienie. Weźmy dane wejściowe 101011101100jako przykład i zacznijmy od najbardziej wewnętrznego:

{a:S^((#S)-_)-1}

Pobiera te elementy az zestawu danych wejściowych, S = {1,0,1,0,1,1,1,0,1,1,0,0}których indeks nie jest len(S)-1, więc wszystkie oprócz ostatniego. Zauważyłem, że to również odwraca zestaw, więc wynik jest taki A = {0,1,1,0,1,1,1,0,1,0,1}. Następnie zrozumienie

{b:A^_}

wykonuje wszystkie elementy Az wyjątkiem pierwszego i odwraca go ponownie, w wyniku B = {1,0,1,0,1,1,1,0,1,1}. Następnie dzielimy się Bna 0s (powoduje to {1,1,{1,1,1},{1,1}}lub jego odwrócenie, nie sprawdziłem, który z nich) i sortujemy wynik według długości. Zestawy singletonów są spłaszczone, ale wszystkie są 1s, więc ich długość wynosi wciąż 1. Oto kod:

{c:(B)+0$#c}

Wynikiem tego jest C = {{1,1,1},{1,1},1,1}. Na koniec odfiltrowujemy wszystko oprócz elementu o indeksie 2 według

{d:C^_=2}

To skutkuje zestawem D = {1}w naszym przypadku. Ogólnie może mieć formę {{1,1,..,1}}, ale nie ma to znaczenia, ponieważ 1drukowane są tylko litery s.

Zupa Kompasowa, BMac

To było fajne.

Edycja: ten program musi być poprzedzony nową linią, aby pracować z interpreterem BMac. Nie mogę sprawić, by nowa linia pojawiła się w bloku kodu.

!p#eXj0sXj0sp#exj#ss
   n Apw   w  n   w
s                  w
     s    w s         w   s    w         s    w           e s
eXj0seXj0sn ep0Yp+yXj0nYp#exj+sneXp exj#seXj+snep+eXj#sxj+nseXp exj#ss
n   w    ej#ns                e n   n   w    e n  n   w         n   w
                          n                                w         
s                                                                    w
             e          s
    y
s                     Yw
eXj+np yjCs       C    n
          ejBs    B pC n
                e A pB n
             ej0n 0 pA n
s                       w
              e s
exj#s X   eXj#nsejCsp1s
n   w     n        w  w
               w
@>
#

Program podzielony jest na 4 sekcje wykonawcze.

Pierwszy z nich, w wierszu 1, dołącza do niego #do końca wejściowego poprzez znalezienie 00i zastępując 2-gi 0z #. Zmienia również wszystkie 1s na As, ponieważ chciałem mieć jak najmniej 1s kodu źródłowego.

Druga sekcja, w wierszu 5, pobiera drugą liczbę na wejściu i umieszcza ją poniżej pierwszej liczby jako ciąg +s. Na przykład, jeśli dane wejściowe są 11011101100, to spowoduje to:

#AA00000AA0#
#+++

Trzecia sekcja, w wierszu 12, łączy ciąg +s z pierwszą liczbą: każda 0powyżej a +staje się A, Astaje się B, Bstaje się Ci Cpozostaje niezmieniona. Następnie wracamy do drugiej sekcji, aby pobrać następny numer.

Po połączeniu wszystkich liczb w ten sposób, dochodzimy do ostatniej sekcji w linii 18. Liczba Cs jest naszym pożądanym wyjściem, więc zmieniamy je na 1s, pomijając pierwszą, Cponieważ 1w kodzie źródłowym znajduje się pojedynczy, który jest drukowany wzdłuż z wyjściem.