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.
TKDYNS por Sam Cappleman-Lynes
Provavelmente isso não é o ideal, mas acho que funciona.
Isso pode ser uma surpresa, mas eu não escrevi isso manualmente ... o código foi gerado pelo seguinte programa Mathematica:
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 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 layout1.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 layout0):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
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:
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 usandoFindShortestPathe 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.fonte
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:
O programa usa o seguinte psuedocode:
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:
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:
fonte
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 é impressa1, pois esse é o único caractere que precisamos produzir).O fluxo de controle funciona por
mágicacom 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.fonte
Firetype, por kirbyfan64sos
Código comentado em funcionamento:
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.fonte
Acc !, por DLosc
Este idioma tem um suporte de comparação terrível .
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 isso10^6.fonte
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:
Explicação
Na primeira e na segunda linhas, eu defino
+ser acutoperação. O resto é um conjunto de compreensões. Vamos usar a entrada101011101100como exemplo e começar pela mais interna:Isso pega os elementos
ado conjunto de entradaS = {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ãopega todos os elementos,
Aexceto o primeiro, e o reverte novamente, resultando emB = {1,0,1,0,1,1,1,0,1,1}. Em seguida, dividimosBno0s (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ão1s, portanto seu comprimento ainda é 1. Aqui está o código:O resultado disso é
C = {{1,1,1},{1,1},1,1}. Por fim, filtramos tudo, exceto o elemento no índice 2, porIsso 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 os1s são impressos.fonte
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.
O programa é dividido em 4 seções de execução.
O primeiro, na linha 1, anexa
#a ao final da entrada, localizando00e substituindo o segundo0por#. Ele também muda todos os1sA, já que eu queria ter o mínimo de1s 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 for11011101100, ela resultará no seguinte:A terceira secção, na linha 12, combina a cadeia de
+s com o primeiro número: cada um0acima de um+torna-seA,Atorna-seB,Btorna-seC, eCmanté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 para1s, pulando o primeiroCporque existe um1código no código-fonte que é impresso ao longo com a saída.fonte