Usando uma linguagem de programação, escreva 5 programas de linha única, cada um com uma linha diferente do primeiro verso da música " Coconut ", de Harry Nilsson, em 1972, quando executada individualmente:

O irmão comprou um coco, ele comprou por um centavo
A irmã dele teve outro, ela pagou por um limão
Ela colocou o limão no coco, ela bebeu os dois
Ela colocou o limão no coco, ela bebeu os dois
Ela coloque o limão no coco, ela bebeu os dois

( letra completa )

As últimas 3 linhas têm a mesma letra, então seus últimos 3 programas também podem ser.

Existem 5 fatores ou 120 maneiras pelas quais esses 5 programas de linha única podem ser organizados um por linha em um único programa de 5 linhas. Você deve otimizar seus programas de linha única para que, para o maior número possível de 120 combinações, o programa de 5 linhas produza o verso inteiro na ordem correta , exatamente como aparece acima.

Exemplo

A resposta mais simples teria 5 declarações de impressão de linha única, as 3 últimas idênticas:

print('Brother bought a coconut, he bought it for a dime')

print('His sister had another one, she paid it for a lime')

print('She put the lime in the coconut, she drank them both up')

print('She put the lime in the coconut, she drank them both up')

print('She put the lime in the coconut, she drank them both up')

A saída para os programas de 5 linhas será o verso em sua ordem correta, desde que os dois primeiros liners individuais estejam em seus lugares corretos. Somente 6 dos 120 arranjos possíveis conseguem isso.

Pontuação

A finalização com os casos mais úteis de todas as 120 vitórias. O desempatador vai para o conjunto de programas com a menor contagem cumulativa de bytes (novas linhas não contadas). O exemplo tem 309 bytes.

Detalhes

• Seus programas podem não ler seu próprio código-fonte. Nem devem ler outros arquivos externos ou exigir uma conexão de rede.

• Saída para stdout ou alternativa mais próxima. Você também pode enviar para um arquivo com o nome de sua escolha.

• "Programas de linha única" são cadeias que contêm caracteres, exceto terminadores de linha (você provavelmente precisará se preocupar com novas linhas).

• Ao compor os liners únicos nos 5 liners, você deve adicionar exatamente 4 novas linhas, uma entre cada par adjacente. Opcionalmente, você pode adicionar uma nova linha à direita.

CJam, 120 permutações válidas, 334 299 290 bytes

"She put the lime in the coconut, she drank them both up"N+
"Brother bought a coconut, he bought it for a dime"N+]$~
"She put the lime in the coconut, she drank them both up"N+
"His sister had another one, she paid it for a lime"N+]$~
"She put the lime in the coconut, she drank them both up"N+

Lógica bastante simples:

• Coloque cada linha da música em cada um dos 5 programas
• Agrupe tudo na pilha em uma matriz
• Classificar a matriz
• Desembrulhe a matriz para que o próximo programa possa usar a mesma lógica
• Em cada etapa, temos as letras parciais em uma matriz. Felizmente, classificar a matriz fornece a ordem correta das letras.

ATUALIZAÇÃO : Acontece que você não precisa do ciclo de empacotamento / desempacotamento após os três similares e que aparecem nas linhas finais da música. Eu posso explicar por que, se não é tão aparente :)

Prelúdio , 120 permutações, 2045 2035 bytes

9-9-9-9-9-9-9-9-9-5-97+993++09-9-9-9-9-9-9-1-8992++96+209-9-9-9-9-9-9-1-94+58992++09-9-9-9-9-9-9-1-92+95+199+409-9-9-9-9-9-9-1-58991++09-9-9-9-9-9-9-1-09-9-9-9-9-7-992++993++95+96+396+309-9-9-9-9-9-9-1-58992++09-9-9-9-9-9-9-1-95+909-9-9-9-9-9-9-1-594+993+09-9-9-9-9-9-9-1-58992++09-9-9-9-9-9-9-1-992++993++97+09-9-9-9-9-9-9-1-5809-4-                                                                          (9+9+9+9+9+9+9+9+9+9+6+!)
9-9-9-9-9-9-9-9-9-5-594+9409-9-9-9-9-9-9-1-109-9-9-9-9-9-9-1-99+96+609-9-9-9-9-9-9-1-992++909-9-9-9-9-9-9-1-992++87993++96+209-9-9-9-9-9-9-1-5809-9-9-9-9-9-9-1-09-9-9-9-9-7-992++993++95+96+396+309-9-9-9-9-9-9-1-109-9-9-9-9-9-9-1-992++87993++96+209-9-9-9-9-9-9-1-99+58992++96+99+09-9-9-3-                                             (9+9+9+9+9+9+9+9+9+9+6+!)
9-9-9-9-9-9-9-9-9-5-97+993++09-9-9-9-9-9-9-1-8992++96+209-9-9-9-9-9-9-1-94+58992++09-9-9-9-9-9-9-1-92+95+199+409-9-9-9-9-9-9-1-58991++09-9-9-9-9-9-9-1-09-9-9-9-9-7-992++993++95+96+396+309-9-9-9-9-9-9-1-58992++09-9-9-9-9-9-9-1-95+909-9-9-9-9-9-9-1-594+993+09-9-9-9-9-9-9-1-58992++09-9-9-9-9-9-9-1-992++993++97+09-9-9-9-9-9-9-1-5809-4-                                                 (9+9+9+9+9+9+9+9+9+9+6+!)
9-9-9-9-9-9-9-9-9-5-594+993+09-9-9-9-9-9-9-1-109-9-9-9-9-9-9-1-99+96+609-9-9-9-9-9-9-1-992++909-9-9-9-9-9-9-1-49197+09-9-9-9-9-9-9-1-58991++09-9-9-9-9-9-9-1-09-9-9-9-9-7-595+96+09-9-9-9-9-9-9-1-99+58992++96+95+109-9-9-9-9-9-9-1-41809-9-9-9-9-9-9-1-99+5992++991++9991++09-9-9-9-9-9-9-1-991++909-9-6-                                                           (9+9+9+9+9+9+9+9+9+9+6+!)
9-9-9-9-9-9-9-9-9-5-97+993++09-9-9-9-9-9-9-1-8992++96+209-9-9-9-9-9-9-1-94+58992++09-9-9-9-9-9-9-1-92+95+199+409-9-9-9-9-9-9-1-58991++09-9-9-9-9-9-9-1-09-9-9-9-9-7-992++993++95+96+396+309-9-9-9-9-9-9-1-58992++09-9-9-9-9-9-9-1-95+909-9-9-9-9-9-9-1-594+993+09-9-9-9-9-9-9-1-58992++09-9-9-9-9-9-9-1-992++993++97+09-9-9-9-9-9-9-1-5809-4-                                                                                                   (9+9+9+9+9+9+9+9+9+9+6+!)

Isso finalmente me convenceu de que Prelude e CJam precisam de um filho. Se não fosse o conjunto de instruções muito limitado do Prelude, essa submissão seria realmente muito competitiva, se não vencesse o CJam.

A ideia básica é a seguinte

"push line 4"               print
"push line 1"print
"push line 3"          print
"push line 2"     print
"push line 5"                    print

No prelúdio, cada linha é sua própria "voz" com sua própria pilha, e essas vozes são executadas em paralelo. Ou seja, no programa completo, cada linha construirá a string individualmente e a imprimirá no final. Porém, devido aos desvios das instruções de impressão, a ordem das linhas não importa de maneira alguma para a ordem da saída, pois a execução é da esquerda para a direita, não de cima para baixo.

Agora, por que as linhas são tão longas? O prelúdio armazena apenas números em sua pilha. Além disso, ele só pode pressionar um número de um dígito de cada vez; portanto, números maiores precisam ser construídos a partir de adição e subtração (não há multiplicação nem aritmética). Portanto, a maior parte do código é simplesmente calcular e enviar os códigos de caracteres certos. Para encurtar um pouco, eu os compenso 96. No final, para imprimir, faço um loop até a pilha ficar vazia (ou seja, a 0é encontrada), adiciono 96 a cada número e imprimo.

Observe que as strings são pressionadas ao contrário, pois são impressas do último ao primeiro caractere.

Isso pressupõe o interpretador Python com NUMERIC_OUTPUT = False(que é como a especificação define E / S).

Eu usei o seguinte código CJam para gerar a construção da string:

"Brother bought a coconut, he bought it for a dime
"W%{i96-_0<{zLa*9/:,'-*'-+0\+}{La*9/:,_,'+*W<}?}%

Por fim, apenas por diversão, por que acho que isso seria muito curto se o Prelude tivesse um conceito de strings:

"pu htob meht knard ehs ,tunococ eht ni emil eht tup ehS"N+!
"emid a rof ti thguob eh ,tunococ a thguob rehtorB"N+!
"pu htob meht knard ehs ,tunococ eht ni emil eht tup ehS"N+!
"emil a rof ti diap ehs ,eno rehtona dah retsis siH"N+!
"pu htob meht knard ehs ,tunococ eht ni emil eht tup ehS"N+!

Agora, as instruções de impressão !já estão na ordem certa, então nem preciso compensá-las. Acho que vou começar a implementar isso algum tempo.

Ruby, 120 permutações válidas, 430 bytes

$*[1]='His sister had another one, she paid it for a lime';a||=at_exit{puts($*-[p])}
$*[0]='Brother bought a coconut, he bought it for a dime';a||=at_exit{puts($*)}
$*[2]='She put the lime in the coconut, she drank them both up';a||=at_exit{puts($*-[p])}
$*[3]='She put the lime in the coconut, she drank them both up';a||=at_exit{puts($*-[p])}
$*[4]='She put the lime in the coconut, she drank them both up';a||=at_exit{puts($*-[p])}

Funciona em qualquer ordem ou individualmente. Cada linha modifica o estado global e define um gancho para ser executado no final do programa, a menos que o gancho já tenha sido definido.

> <> , 120 permutações, 703 bytes

<    /a"emid a rof ti thguob eh ,tunococ a thguob rehtorB"0a.#.!50padpacpabpaapa9pa8pa7p97p87p77p67p57p95p84p73p62p51"/////\\\\\>l0=?;o"
<   / a"emil a rof ti diap ehs ,eno rehtona dah retsis siH"09.#.!50padpacpabpaapa9pa8pa7p97p87p77p67p57p95p84p73p62p51"/////\\\\\>l0=?;o"
<  /  a"pu htob meht knard ehs ,tunococ eht ni emil eht tup ehS"08.#.!50padpacpabpaapa9pa8pa7p97p87p77p67p57p95p84p73p62p51"/////\\\\\>l0=?;o"
< /   a"pu htob meht knard ehs ,tunococ eht ni emil eht tup ehS"07.#.!50padpacpabpaapa9pa8pa7p97p87p77p67p57p95p84p73p62p51"/////\\\\\>l0=?;o"
</    a"pu htob meht knard ehs ,tunococ eht ni emil eht tup ehS"06.#.!50padpacpabpaapa9pa8pa7p97p87p77p67p57p95p84p73p62p51"/////\\\\\>l0=?;o"

A restrição de uma linha era bastante difícil para uma linguagem 2D, então eu tive que encontrar uma maneira de aproveitar ao máximo as .instruções de teleporte.

A inicial <faz o programa fluir para a esquerda, contornando e executando

"o;?=0l>\\\\\\/////"15p26p37p48p59p75p76p77p78p79p7ap8ap9apaapbapcapdap

Esta é uma série de pinstruções (colocadas) que coloca caracteres até que o quadro fique assim:

<    /<lyrics1>0a.#.!50<blah>
<   / <lyrics2>09.#.!50<blah>
<  /  <lyrics3>08.#.!50<blah>
< /   <lyrics4>07.#.!50<blah>
</    <lyrics5>06.#.!50<blah>
 /     \
  /    \
   /   \
    /  \
     / \
       >l0=?;o

O #.!50programa então vira o fluxo de volta para a direita novamente, antes de pular para a linha 5. O que se segue é o seguinte:

• Seguindo o /espelho na linha 5, encontra a letra 5, que é empurrada para a pilha. Em seguida, teleportamos para a linha 6.
• Seguindo o /espelho na linha 6, encontra a letra 4, que é empurrada para a pilha. Em seguida, teleportamos para a linha 7.
• Seguindo o /espelho na linha 7 encontra a letra 3 ...

Isso acontece até pressionarmos a letra 1, quando teletransportamos para a linha 10. Este é um loop para imprimir a pilha inteira até que ela esteja vazia.

Se apenas uma linha do programa estiver presente, os \espelhos farão o mesmo trabalho que os teleports em cada linha de letra.

Se o programa for embaralhado, a explicação acima ainda se aplica, portanto o programa funciona para todas as permutações!