Crie uma linguagem de programação que pareça inutilizável (thread de ladrões)

27

Consulte o tópico da policial para obter mais informações. Cada resposta a essa pergunta deve ter uma resposta lá. Ou seja, deve ser código encontrar o terceiro maior número inteiro na entrada quando executado no interpretador fornecido nessa resposta.

Se você postar um crack que é inválido, exclua-o e não poderá postar outra tentativa contra a mesma resposta.

Pontuação

O vencedor desta pergunta é o ladrão que faz o maior número de rachaduras bem-sucedidas.

popularity-contest  cops-and-robbers 
— feersum
fonte

Respostas:

25

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

Foi realmente muito divertido, obrigado Liam! :)

Agradecemos ao Sp3000 por um pequeno empurrão, mas necessário, na direção certa.

Quão?

Duas palavras: Pocket Cube .

Acontece que as pilhas correspondem às faces de um cubo de Rubik 2x2x2 da seguinte maneira:

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

Onde ULFRBDindicar qual face corresponde a cima, esquerda, frente, direita, costas, baixo quando o cubo é dobrado corretamente.

As permutações correspondem à rotação de qualquer lado em 90 graus (onde os nomes agradecem a correspondência). Acontece que f, re dsão rotações no sentido horário (ao visualizar o rosto) e r, le usão rotações no sentido anti-horário (ao visualizar o rosto).

Agora o cinpushcomando opera de tal forma que se aplica uma das rotações u, dou r(consoante o valor determinado) e em seguida empurra o valor de entrada para a pilha em posição 1. (E depois repete isso para todos os elementos da entrada.) Isso significa que podemos reverter esse processo (para garantir que terminemos com a ordem correta das pilhas sem precisar resolver um cubo arbitrário de Rubik) olhando repetidamente para a pilha em posição 1, desfazendo a permutação correspondente e exibindo o valor dessa pilha (para que da próxima vez que a vejamos, tenhamos o valor abaixo).

Como desfazemos as rotações? Felizmente, temos ambos fe bà nossa disposição. Se aplicarmos os dois, giramos o cubo inteiro em 90 graus. Isto significa que pode mover o lado afectado ( U, Rou D) a L, desfazer a rotação usando um ou três ls (dependendo da direcção em relação de le a rotação efectuada durante a entrada), e em seguida rodar a parte de trás do cubo para a sua orientação anterior utilizando fe bnovamente.

Em particular, cada uma das rotações realizadas durante a entrada pode ser desfeita da seguinte maneira:

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

Vou ver se consigo criar algumas animações para mostrar que isso funciona.

Agora, isso nos dá uma maneira de percorrer toda a entrada uma vez. Mas com 5 registros, é tudo o que precisamos:

  • Alberto é o valor máximo encontrado até o momento.
  • Gertrude é o segundo maior valor encontrado até agora.
  • Hans é o terceiro maior valor encontrado até agora.

Quando encontramos um novo valor, colocamos esses três na medida do necessário, onde podemos usar ShabbySamcomo um registro temporário dos swaps. Ainda resta o Leopoldque podemos usar para manter uma condicional ao fazer as comparações necessárias.

No final do processo, simplesmente imprimimos o conteúdo de Hans, que já conterá o terceiro maior valor.

— Martin Ender
fonte
1
É engraçado que você tenha usado cada um dos cinco registros exatamente da mesma maneira que eu.
— Liam
21

TKDYNS por Sam Cappleman-Lynes

Provavelmente isso não é o ideal, mas acho que funciona.

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

Isso pode ser uma surpresa, mas eu não escrevi isso manualmente ... o código foi gerado pelo seguinte programa 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"]

Na verdade, eu escrevi todas essas safetyChecklinhas à mão. Mas a primeira linha desse código do Mathematica tem, na verdade, cerca de 28.000 caracteres e foi gerada pelo seguinte código 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}/'}

(O que leva como entrada os 10 layouts codificados no intérprete. Você pode executar o código online. )

Cepção de geração de código!

Explicação

Para começar, dê uma olhada neste script CJam para ver como são os labirintos.

Minha solução é baseada em uma observação importante: enquanto coletarmos itens em uma única coluna, não mudaremos entre layouts, independentemente de as células estarem preenchidas ou não. Em particular, enquanto movermos a coluna mais à esquerda, permaneceremos no layout 0. Enquanto avançarmos na próxima coluna, permaneceremos no layout 1.

O mais complicado é como garantir que mudamos entre layouts, porque não sabemos quais células da coluna 1possuem itens (se houver!).

Então, aqui está o algoritmo (começando na célula 0no layout 0):

  1. Colete todos os itens ao longo da coluna atual, terminando na linha inferior. Esse lacaio nunca vai morrer.

  2. Agora, para cada célula à direita da coluna atual (experimentando-as na ordem principal da coluna), tente mover para lá no layout atual, selecione um item e mova para a linha superior dessa nova coluna usando o novo layout.

    Se a célula tentada contiver um item, o layout será alterado e alcançaremos com êxito a nova coluna e layout. Como a nova posição (segura) está na linha superior, mas todas as tentativas de encontrar a próxima coluna incluem 10 movimentos líquidos para cima, todas as outras tentativas falharão, para que possamos ignorá-las.

    Se a célula tentada não contiver um item, na maioria dos casos, o lacaio morrerá durante a tentativa de alcançar a linha superior usando o layout errado, descartando essa tentativa. No entanto, esse nem sempre é o caso. Por exemplo, a célula tentada já pode estar na linha superior, portanto, nenhuma movimentação foi feita no novo layout. Da mesma forma, em alguns casos, o caminho da célula tentada para a linha superior é curto o suficiente para ser válido nos dois layouts. Eu coletei todos os casos em que esse é um problema manualmente e determinei um conjunto de movimentos que são válidos apenas no novo layout (mas que movem o lacaio de volta para a célula de destino, portanto, ele é efetivamente um no-op no novo layout). Depois de cada tentativa em que isso pode ser um problema, eu executo esse conjunto de movimentos para matar qualquer lacaio que não

  3. Agora, passamos para o topo da próxima coluna, que contém pelo menos um item. Volte para a etapa 1.

Você pode perceber que a estrutura da solução é a seguinte:

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

Quanto ao código do Mathematica, as safetyCheckseqüências de caracteres são aqueles movimentos escolhidos a dedo que garantem que alcançamos o novo layout. O primeiro parâmetro para a pesquisa é o layout do qual estamos iniciando e o segundo é a célula que tentamos. Qualquer combinação que não seja mencionada explicitamente fornece apenas uma verificação de segurança vazia (porque nenhuma é necessária).

Além disso, estou simplesmente configurando os 10 labirintos como Graphobjetos, onde existem duas arestas direcionadas entre quaisquer células adjacentes (e conectadas), onde cada aresta é anotada com o movimento necessário para atravessá-la. Com isso, posso simplesmente encontrar os caminhos usando FindShortestPathe depois extrair os rótulos de borda correspondentes comPropertyValue[..., EdgeLabels] .

O restante do código apenas usa isso para implementar o algoritmo acima de maneira bastante direta.

Os dados reais do gráfico são armazenados layoutse foram gerados com o script CJam, que decodifica os números conforme descrito na publicação policial e os transforma em uma lista do Mathematica, que pode ser facilmente transformada em um gráfico.

— Martin Ender
fonte
11
O que
— Alex A.
...
— Sanchises
Obrigado pelo último script CJam - é realmente a primeira vez que vi os labirintos que criei!
— Sam Cappleman-Lynes
Martin assumindo a liderança, entendo.
— seequ
14

HPR, da Zgarb

O código:

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

Primeiro de tudo ... o código foi gerado, não escrito à mão (ou digitado).

Fatos sobre o idioma:

  • É não Turing completa.
  • Você não pode comparar números inteiros encontrados no ambiente.
  • Você pode comparar números inteiros em listas com números inteiros no ambiente.
  • Você não pode adicionar elementos às listas ou alterar elementos nas listas.

O programa usa o seguinte 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

O ambiente quase sempre contém apenas 1 lista e 1 número inteiro.

Para resolver isso, criei um pequeno mecanismo de macro para esse idioma. Também permite comentários. Aqui está o mecanismo de 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.

Depois de criar o mecanismo de macro, criei lentamente funções úteis para esse idioma. Aqui está o código que o mecanismo processou para criar o programa:

//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>
— O número um
fonte
Isso é ótimo, eu gosto do sistema macro!
— Zgarb 31/10/2015
9

Brian & Chuck por Martin Büttner

O programa Python 2.7 a seguir gera o meu programa Brian & Chuck, traduzindo um programa cerebral em Brian & Chuck (com a exceção que .sempre é impressa 1, pois esse é o único caractere que precisamos produzir).

O fluxo de controle funciona por mágica com Brian escrevendo nos comandos de fita de Chuck para enviar Brian para a posição correta no código.

Observe que os espaços em branco []es adicionados ao programa B&C são apenas decorativos.

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('''
-
>,------------------------------------------------[
    ,------------------------------------------------[
        ->+>>>[>+<<<<->>>-]<[>+<<<->>-]<[>+<<->-]>>>[<+>-]<<<<[>+<-]
        >>>>>,------------------------------------------------
    ]
    <+[-<<<<<<+]-
    >,------------------------------------------------
]
>>>>[.>>>>>>].
''')
— caixa de papelão
fonte
Bom trabalho. Obrigado por provar a B&C Turing-complete. ;) (Bem, eu acho que nós precisamos de uma prova formal de correção da sua tradução, mas o programa gerado parece estar funcionando muito bem).
— Martin Ender
8

Firetype, por kirbyfan64sos

Código comentado em funcionamento:

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

Isso depende do intérprete, conforme fornecido atualmente na resposta do policial, o que contradiz levemente a documentação sobre %e! .

O principal desafio aqui foi analisar a entrada, uma vez que a \busca pelo terceiro maior valor é bastante simples.

— Martin Ender
fonte
1
Na verdade, isso é mais curto do que minha solução pretendida!
— kirbyfan64sos
6

Acc !, por DLosc

Este idioma tem um suporte de comparação terrível .

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
}

As count [varname] while 0instruções no início devem declarar a variável que contém o maior número, o segundo maior número, o terceiro maior número e assim por diante. As comparações são realizadas subtraindo os dois números e verificando se o resultado é negativo, verificando se é um número menor que isso 10^6.

— pppery
fonte
Ack! Bom trabalho, embora isso seja muito diferente do que eu estava buscando. Eu temia que alguém pudesse encontrar uma brecha. Voltar para a prancheta para Acc ++ !
— DLosc
Acc !! foi postado;)
— DLosc
5

Zinco, por kirbyfan64sos

Isso não foi tão difícil, uma vez que eu entendi como a linguagem funciona. A parte difícil foi obter os erros do analisador, mas adicionar alguns parênteses supérfluos pareceu consertar isso. Aqui está a solução:

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

Explicação

Na primeira e na segunda linhas, eu defino +ser a cutoperação. O resto é um conjunto de compreensões. Vamos usar a entrada 101011101100como exemplo e começar pela mais interna:

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

Isso pega os elementos ado conjunto de entrada S = {1,0,1,0,1,1,1,0,1,1,0,0}cujo índice não é len(S)-1, então todos, exceto o último. Percebi que isso também reverte o cenário, então o resultado é A = {0,1,1,0,1,1,1,0,1,0,1}. Em seguida, a compreensão

{b:A^_}

pega todos os elementos, Aexceto o primeiro, e o reverte novamente, resultando em B = {1,0,1,0,1,1,1,0,1,1}. Em seguida, dividimos Bno 0s (isso resulta em {1,1,{1,1,1},{1,1}}sua reversão, não verifiquei qual) e classificamos o resultado por comprimento. Conjuntos Singleton são achatados, mas todos são 1s, portanto seu comprimento ainda é 1. Aqui está o código:

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

O resultado disso é C = {{1,1,1},{1,1},1,1}. Por fim, filtramos tudo, exceto o elemento no índice 2, por

{d:C^_=2}

Isso resulta no conjunto D = {1}do nosso caso. Em geral, ele pode ter o formulário {{1,1,..,1}}, mas isso não importa, pois apenas os 1s são impressos.

— Zgarb
fonte
4

Sopa de bússola, de BMac

Isso foi divertido.

Editar: este programa deve ser anexado com uma nova linha para trabalhar com o intérprete do BMac. Não consigo fazer com que a nova linha apareça no bloco de código.

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

O programa é dividido em 4 seções de execução.

O primeiro, na linha 1, anexa #a ao final da entrada, localizando 00e substituindo o segundo 0por #. Ele também muda todos os 1s A, já que eu queria ter o mínimo de1 s no código-fonte possível.

A segunda seção, na linha 5, busca o segundo número na entrada e o coloca abaixo do primeiro número como uma sequência de +s. Por exemplo, se a entrada for 11011101100, ela resultará no seguinte:

#AA00000AA0#
#+++

A terceira secção, na linha 12, combina a cadeia de +s com o primeiro número: cada um 0acima de um +torna-se A, Atorna-se B, Btorna-se C, eC mantém-se inalterada. Depois, voltamos à segunda seção para buscar o próximo número.

Depois que todos os números foram combinados dessa maneira, chegamos à seção final na linha 18. O número de Cs é a saída desejada, então alteramos para 1s, pulando o primeiro Cporque existe um 1código no código-fonte que é impresso ao longo com a saída.

— caixa de papelão
fonte
Estou feliz que foi divertido! Eu esperava que o uso de 1s no código exigisse que você limpe o código antes de terminar, mas acho que você contornou isso usando A em vez disso: D.
— BMac 9/11/2015
1
Minha solução adicionada.
— BMac 11/11
@feersum Esqueci que havia modificado o intérprete. Anexar meu programa com uma nova linha deve corrigi-lo.
— cardboard_box
D'oh, isso é um erro bobo. Vou consertar minha versão do intérprete.
— BMac 12/11/2015
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.