Vedi il thread della cop per maggiori informazioni. Ogni risposta a questa domanda dovrebbe dare una risposta lì. Vale a dire, dovrebbe essere il codice per trovare il terzo intero più grande nell'input quando eseguito nell'interprete fornito in quella risposta.

Se pubblichi un crack che risulta non valido, dovresti eliminarlo e non puoi pubblicare un altro tentativo contro la stessa risposta.

punteggio

Il vincitore di questa domanda è il ladro che crea il maggior numero di incrinature riuscite.

Shuffle, di 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!

È stato davvero divertente, grazie Liam! :)

Grazie a Sp3000 per una leggera ma necessaria spinta nella giusta direzione.

Come?

Due parole: Pocket Cube .

Si scopre che le pile corrispondono alle facce di un cubo di Rubik 2x2x2 come segue:

           ____ ____
          |    |    |
          | 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 |
          |____|____|

Dove ULFRBDindicare quale faccia corrisponde a su, a sinistra, davanti, a destra, dietro, verso il basso quando il cubo è piegato correttamente.

Le permutazioni corrispondono alla rotazione di un lato di 90 gradi (dove i nomi corrispondono per fortuna). Si scopre che f, re dsono rotazioni in senso orario (quando si guarda la faccia) e r, leu sono rotazioni in senso antiorario (quando si guarda la faccia).

Ora il cinpushcomando opera in modo tale che esso si applica una delle rotazioni u, do r(a seconda del valore dato) e quindi spinge il valore di ingresso nello stack in posizione 1. (E poi si ripete facendo questo per ogni elemento nell'input.) Ciò significa che possiamo invertire questo processo (per assicurarci di finire con il corretto ordine di stack senza dover risolvere un cubo di Rubik arbitrario) guardando ripetutamente lo stack in posizione 1, annullando la permutazione corrispondente e facendo scattare il valore di quello stack (in modo che la prossima volta che vediamo lo stack, otteniamo il valore sottostante).

Come annullare le rotazioni? Per fortuna, abbiamo entrambi fe ba nostra disposizione. Se li applichiamo entrambi, ruotiamo l'intero cubo di 90 gradi. Questo significa che possiamo spostare il lato colpito ( U, Ro D) per Lsvitare rotazione utilizzando uno o tre ls (a seconda della direzione relativa del le la rotazione eseguita durante l'input), e quindi ruotare la schiena cubo al suo orientamento precedente usando fe bancora.

In particolare, ciascuna delle rotazioni eseguite durante l'immissione può essere annullata come segue:

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

Vedrò se riesco a trovare alcune animazioni per dimostrare che funziona.

Ora questo ci dà un modo per scorrere una volta l'intero input. Ma con 5 registri, questo è tutto ciò di cui abbiamo bisogno:

• Alberto è il valore massimo rilevato finora.
• Gertrude è il 2 ° valore più grande riscontrato finora.
• Hans è il 3 ° valore più grande riscontrato finora.

Quando incontriamo un nuovo valore, lo riempiamo di bolle per quanto necessario, dove possiamo usare ShabbySamcome registro temporaneo per gli swap. Rimane comunque Leopoldciò che possiamo usare per mantenere una condizione quando si effettuano i confronti necessari.

Alla fine del processo, stampiamo semplicemente il contenuto di Hans, che conterrà già il 3 ° valore più grande.

TKDYNS di Sam Cappleman-Lynes

Questo probabilmente non è ottimale, ma penso che faccia il trucco ...

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

Questo può essere una sorpresa, ma non l'ho scritto a mano ... il codice è stato generato dal seguente programma 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"]

In realtà ho scritto tutte quelle safetyCheckrighe a mano. Ma la prima riga di quel codice Mathematica è in realtà lunga circa 28.000 caratteri ed è stata essa stessa generata dal seguente codice 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}/'}

(Che accetta come input i 10 layout hardcoded nell'interprete. È possibile eseguire il codice online. )

Codice-generazione-cezione!

Spiegazione

Per cominciare, dai un'occhiata a questo script di CJam per vedere come appaiono i labirinti.

La mia soluzione si basa su un'osservazione importante: finché raccogliamo elementi lungo una singola colonna, non cambieremo tra layout, indipendentemente dal fatto che le celle siano riempite o meno. In particolare, finché ci spostiamo lungo la colonna più a sinistra rimarremo nel layout 0. Finché ci spostiamo lungo la colonna successiva, rimarremo nel layout 1.

La parte difficile è come garantire che siamo cambiati tra i layout, perché non sappiamo quali celle nella colonna 1hanno degli elementi (se ce ne sono!).

Quindi ecco l'algoritmo (a partire dalla cella 0nel layout 0):

1. Raccogli tutti gli elementi lungo la colonna corrente, finendo nella riga inferiore. Questo servitore non morirà mai.

2. Ora per ogni cella a destra della colonna corrente (provandole nell'ordine principale della colonna), prova a spostarti lì nel layout corrente, prendi un elemento lì, quindi passa alla riga superiore in quella nuova colonna usando il nuovo layout.

   Se la cella tentata conteneva un elemento, il layout sarà cambiato e raggiungeremo con successo la nuova colonna e layout. Poiché la nuova posizione (sicura) si trova nella riga superiore, ma tutti i tentativi di trovare la colonna successiva includono 10 movimenti netti verso l'alto, tutti gli altri tentativi falliranno, quindi possiamo ignorarli.

   Se la cella tentata non conteneva un oggetto, nella maggior parte dei casi, il servitore morirà durante il tentativo di raggiungere la riga superiore usando il layout sbagliato, quindi scartando questo tentativo. Tuttavia, questo non è sempre il caso. Ad esempio, la cella tentata potrebbe essere già nella riga superiore, quindi non sono state effettuate mosse sul nuovo layout. Allo stesso modo, in alcuni casi, il percorso dalla cella tentata alla riga superiore è abbastanza breve da essere valido su entrambi i layout. Ho raccolto tutti i casi in cui questo è un problema a mano e ho determinato una serie di mosse che è valida solo sul nuovo layout (ma che sposta il servitore nella cella di destinazione, quindi è effettivamente un no-op sul nuovo layout). Dopo ogni tentativo in cui questo può essere un problema, eseguo questa serie di mosse per uccidere qualsiasi servitore che non ha

3. Siamo ora passati con successo all'inizio della colonna successiva che contiene almeno un elemento. Torna al passaggio 1.

È possibile notare che la struttura della soluzione è la seguente:

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

Per quanto riguarda il codice Mathematica, le safetyCheckstringhe sono quelle mosse raccolte a mano che assicurano che abbiamo raggiunto il nuovo layout. Il primo parametro per la ricerca è il layout da cui iniziamo e il secondo è la cella che abbiamo tentato. Tutte le combinazioni che non sono menzionate esplicitamente forniscono solo un controllo di sicurezza vuoto (perché non è necessario).

Inoltre, sto semplicemente impostando i 10 labirinti come Graphoggetti, dove ci sono due bordi diretti tra le celle adiacenti (e connesse), dove ogni bordo è annotato con lo spostamento necessario per attraversarlo. Con quello in atto, posso semplicemente trovare i percorsi usando FindShortestPathe quindi estrarre le etichette dei bordi corrispondenti con PropertyValue[..., EdgeLabels].

Il resto del codice ne fa solo uso per implementare l'algoritmo sopra in modo abbastanza diretto.

I dati del grafico reale sono memorizzati layoutse sono stati generati con lo script CJam, che decodifica i numeri come descritto nella posta del poliziotto e li trasforma in un elenco Mathematica, che può essere facilmente trasformato in un grafico.

HPR, di Zgarb

Il codice:

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

Prima di tutto ... il codice è stato generato, non scritto a mano (o digitato).

Fatti sulla lingua:

• Si Non Turing.
• Non è possibile confrontare numeri interi trovati nell'ambiente.
• È possibile confrontare numeri interi negli elenchi con numeri interi nell'ambiente.
• Non è possibile aggiungere elementi agli elenchi o modificare elementi negli elenchi.

Il programma utilizza il seguente 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

L'ambiente contiene quasi sempre solo 1 elenco e 1 intero.

Per risolvere questo problema, ho creato un piccolo motore macro per questa lingua. Permette anche commenti. Ecco il motore macro:

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.

Dopo aver creato il motore macro, ho lentamente creato utili funzioni per questo linguaggio. Ecco il codice che il motore ha elaborato per creare il programma:

//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 di Martin Büttner

Il seguente programma Python 2.7 produce il mio programma Brian & Chuck, traducendo un programma brainfuck in Brian & Chuck (con l'eccezione che .stampa sempre 1, dato che è l'unico carattere che dobbiamo produrre).

Il flusso di controllo funziona per magia facendo in modo che Brian scriva sui comandi del nastro di Chuck per inviare Brian nella posizione corretta nel codice.

Si noti che gli spazi bianchi e []i aggiunti al programma B&C sono solo decorativi.

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, di kirbyfan64sos

Codice funzionante, commentato:

_ 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!

Ciò si basa sull'interprete come attualmente fornito nella risposta del poliziotto, che contraddice leggermente la documentazione riguardante %e! .

La sfida principale qui è stata l'analisi dell'ingresso, dal momento che \consente di trovare il terzo valore in modo abbastanza semplice.

Acc !, di DLosc

Questa lingua ha un supporto di confronto terribile .

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
}

Le count [varname] while 0dichiarazioni all'inizio devono dichiarare la variabile che contiene il numero più grande, il secondo numero più grande, il terzo numero più grande e così via. I confronti si ottengono sottraendo i due numeri e verificando se il risultato è negativo verificando che sia un numero inferiore 10^6.

Zinco, di kirbyfan64sos

Non è stato così difficile, una volta capito come funziona la lingua. La parte difficile era ottenere errori di analisi, ma l'aggiunta di alcune parentesi superflue sembrava risolverlo. Ecco la soluzione:

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

Spiegazione

Nella prima e seconda riga, definisco +l' cutoperazione. Il resto è comprensivo. Prendiamo l'input 101011101100come esempio e iniziamo da quello più interno:

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

Questo prende quegli elementi adal set di input il S = {1,0,1,0,1,1,1,0,1,1,0,0}cui indice non è len(S)-1, quindi tutti tranne l'ultimo. Ho notato che anche questo inverte il set, quindi il risultato è A = {0,1,1,0,1,1,1,0,1,0,1}. Successivamente, la comprensione

{b:A^_}

prende tutti gli elementi Atranne il primo e lo inverte di nuovo, risultando in B = {1,0,1,0,1,1,1,0,1,1}. Quindi, ci dividiamo Bin 0s (questo risulta {1,1,{1,1,1},{1,1}}o il suo rovesciamento, non ho verificato quale) e ordiniamo il risultato per lunghezza. Gli insiemi Singleton sono appiattiti, ma sono tutti 1s quindi la loro lunghezza è ancora 1. Ecco il codice:

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

Il risultato è questo C = {{1,1,1},{1,1},1,1}. Infine, filtriamo tutto tranne l'elemento all'indice 2 di

{d:C^_=2}

Ciò si traduce nel set D = {1}sul nostro caso. In generale, può avere il modulo {{1,1,..,1}}, ma questo non ha importanza poiché 1vengono stampati solo i messaggi di posta elettronica.

Compass Soup, di BMac

È stato divertente.

Modifica: questo programma deve essere anteposto con una nuova riga per poter lavorare sull'interprete di BMac. Non riesco a far apparire la nuova riga nel blocco di codice.

!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
@>
#

Il programma è diviso in 4 sezioni di esecuzione.

Il primo, alla riga 1, aggiunge un #alla fine dell'input trovando 00e sostituendo il secondo 0con #. Cambia anche tutte le 1s in As, dato che volevo averne poche1 s nel codice sorgente possibile.

La seconda sezione, alla riga 5, recupera il secondo numero nell'input e lo mette sotto il primo numero come una stringa di +s. Ad esempio, se l'input è 11011101100, allora si otterrà il seguente:

#AA00000AA0#
#+++

La terza sezione, alla riga 12, combina la stringa di +s con il primo numero: ciascuno 0sopra a +diventa A, Adiventa B, Bdiventa CeC rimane invariato. Successivamente, torniamo alla seconda sezione per recuperare il numero successivo.

Una volta che tutti i numeri sono stati combinati in questo modo, raggiungiamo la sezione finale alla riga 18. Il numero di Cs è l'output desiderato, quindi li cambiamo in 1s, saltando il primo Cperché c'è un singolo 1nel codice sorgente che è stampato lungo con l'uscita.