Escolha cinco caracteres que seu idioma suporta. Existem 5! = 5 × 4 × 3 × 2 × 1 = 120 maneiras pelas quais elas podem ser organizadas em uma sequência de 5 caracteres que contém cada caractere uma vez; 120 permutações .
Escolha seus caracteres para que, quando cada uma das 120 strings for executada no seu idioma, as 120 saídas produzidas tenham o número inteiro inteiro único de 1 a 120 (inclusive) possível.
Ou seja, para cada uma das 120 permutações dos seus 5 caracteres que produzem código executável que gera um único número, você deseja que o conjunto de todos esses números seja o mais próximo possível do conjunto de números inteiros de 1 a 120.
Então, idealmente, sua primeira permutação produziria 1
, a próxima 2
, a próxima 3
, até o fim 120
. Mas esse ideal é provavelmente impossível para a maioria dos idiomas e caracteres.
As seqüências de cinco caracteres podem ser executadas como:
- um programa sem entrada
- uma função sem argumentos
- um comando REPL
Seqüências diferentes podem ser executadas de maneiras diferentes, se desejado
Para que a saída conte, ela deve ser uma única saída inteira de maneira normal , como:
- sendo impresso em stdout
- retornado pela função
- o resultado da expressão REPL
O código deve terminar normalmente (o que pode envolver erros, desde que o número tenha sido gerado primeiro). O código que não é executado é bom, apenas a saída (inexistente) não conta. A saída dos números deve ser decimal, a menos que uma base diferente seja a norma para o seu idioma.
O envio que gera os números mais distintos de 1 a 120 vence. A finalização anterior vence em caso de empate.
Notas
- Nem todos os seus 5 caracteres precisam ser diferentes, mas é claro que ter caracteres duplicados reduz o número efetivo de permutações.
- Saídas flutuantes, como
32.0
contagem e planície32
. (Mas32.01
não faria.) - Zeros à esquerda, como
032
contagem e simples32
. - Saídas válidas devem ser determinísticas e invariantes no tempo.
- Estamos lidando com caracteres , não bytes.
Exemplo
Os caracteres 123+*
são uma primeira escolha razoável para o REPL do Python (ou de muitas línguas). As 120 permutações e saídas resultantes são:
123+* n/a
123*+ n/a
12+3* n/a
12+*3 n/a
12*3+ n/a
12*+3 36
132+* n/a
132*+ n/a
13+2* n/a
13+*2 n/a
13*2+ n/a
13*+2 26
1+23* n/a
1+2*3 7
1+32* n/a
1+3*2 7
1+*23 n/a
1+*32 n/a
1*23+ n/a
1*2+3 5
1*32+ n/a
1*3+2 5
1*+23 23
1*+32 32
213+* n/a
213*+ n/a
21+3* n/a
21+*3 n/a
21*3+ n/a
21*+3 63
231+* n/a
231*+ n/a
23+1* n/a
23+*1 n/a
23*1+ n/a
23*+1 23
2+13* n/a
2+1*3 5
2+31* n/a
2+3*1 5
2+*13 n/a
2+*31 n/a
2*13+ n/a
2*1+3 5
2*31+ n/a
2*3+1 7
2*+13 26
2*+31 62
312+* n/a
312*+ n/a
31+2* n/a
31+*2 n/a
31*2+ n/a
31*+2 62
321+* n/a
321*+ n/a
32+1* n/a
32+*1 n/a
32*1+ n/a
32*+1 32
3+12* n/a
3+1*2 5
3+21* n/a
3+2*1 5
3+*12 n/a
3+*21 n/a
3*12+ n/a
3*1+2 5
3*21+ n/a
3*2+1 7
3*+12 36
3*+21 63
+123* n/a
+12*3 36
+132* n/a
+13*2 26
+1*23 23
+1*32 32
+213* n/a
+21*3 63
+231* n/a
+23*1 23
+2*13 26
+2*31 62
+312* n/a
+31*2 62
+321* n/a
+32*1 32
+3*12 36
+3*21 63
+*123 n/a
+*132 n/a
+*213 n/a
+*231 n/a
+*312 n/a
+*321 n/a
*123+ n/a
*12+3 n/a
*132+ n/a
*13+2 n/a
*1+23 n/a
*1+32 n/a
*213+ n/a
*21+3 n/a
*231+ n/a
*23+1 n/a
*2+13 n/a
*2+31 n/a
*312+ n/a
*31+2 n/a
*321+ n/a
*32+1 n/a
*3+12 n/a
*3+21 n/a
*+123 n/a
*+132 n/a
*+213 n/a
*+231 n/a
*+312 n/a
*+321 n/a
Existem 36 números gerados, todos por sorte de 1 a 120:
36, 26, 7, 7, 5, 5, 23, 32, 63, 23, 5, 5, 5, 7, 26, 62, 62, 32, 5, 5, 5, 7, 36, 63, 36, 26, 23, 32, 63, 23, 26, 62, 62, 32, 36, 63
No entanto, apenas 8 deles são únicos:
36, 26, 7, 5, 23, 32, 63, 62
Portanto, esse envio pontuaria apenas 8 de um máximo de 120.
fonte
c
idiomas semelhantes !!!Respostas:
Python3,
2127 valoresPersonagens:
3479%
Números únicos:
[1,2,3,4,5,6,7,8,9,11,12,19,20,21,24,29,34,35,36,37,39,43,46,47,49,73,74]
Como foi solicitado, aqui estão as permutações que caíram no intervalo [1, 120] . Experimente online!
fonte
/
está a divisão inteira?5679%
e5789%
5679%
e5789%
) provavelmente também é o ideal para o PowerShell.5679%
e5798%
) também através de uma pesquisa exaustiva em todas as combinações de0123456789+-*/&|^#%
substituição. Concordo que estes são provavelmente ótimos.05AB1E ,
273841 númerosGera os números exclusivos:
[4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 18, 19, 25, 27, 32, 33, 34, 35, 36, 37, 38, 49, 50, 52, 54, 64, 65, 66, 67, 72, 73, 74, 81, 83, 98, 100, 101, 102]
Usa a constante
4
com as operações+1
,+2
,*2
e^2
.fonte
-
invés de+
produzir uma variedade mais ampla de resultados com base em sua propriedade não comutativa?-
, mas nunca obtive mais de 30 números únicos. Uma questão é que você também obtém valores negativos que ficam fora do intervalo. Talvez com alguns outros operadores substituídos possa ser melhor, mas ainda não encontrei uma melhoria.Python, 18 números
Produz como resultados válidos:
EDIT: Posso atestar que a solução do TuukkaX é ideal para Python. Executei o seguinte código bruteforcing todas as combinações possíveis de 5 caracteres ASCII imprimíveis:
Os resultados (após a execução de cerca de 7 horas) mostrou que a solução óptima é de facto 27 números diferentes, produzidos por três soluções diferentes, todos utilizando quatro números e mod (
%
):%3479
,%5679
e%5789
.fonte
Números Java 8,
24Você não esperava uma resposta Java, estava?
Este é um lambda que só pode ser organizado de duas maneiras (e com dois dígitos diferentes!) Para um total de dois números exclusivos. Tudo o resto não é um lambda válido.
Melhorou realmente a resposta, graças a alguma ajuda de comentários! Não viu que 0 não era válido e esqueceu que as variáveis poderiam, sabe, ter mais de um caractere. Temos 4!
Uma solução ainda pior
()->1
Mas, pelo lado positivo, duas respostas únicas em Java!
fonte
n->12
. Isto dá-lhe quatro respostas distintas que estão todos dentro do intervalo:n->12
,n->21
,n1->2
,n2->1
.Geleia,
263032 númerosEste (e seus anagramas) são programas completos, que não recebem entrada e produzem saída na saída padrão.
As saídas dos 120 programas são, na ordem em que o Jelly as gera, se você pedir para gerar permutações do programa:
Se você apenas obtiver as saídas exclusivas em ordem numérica, obterá:
Muitos deles são muito pequenos e 135 são muito grandes, mas ainda existem 32 que estão ao alcance.
A idéia básica é usar principalmente instruções monádicas (em um programa apenas com mônadas e nilads, cada uma delas transforma a saída anterior) e aquelas que permitem que o valor diverja rapidamente. A exceção é with
3
, que é um nilad (o valor constante 3). Se aparecer no início do programa, todas as operações serão realizadas a partir de 3. Se aparecer no meio, o programa será dividido em duas metades, cada uma com um número inteiro (e cada uma imprimindo na saída padrão, os resultados acabam sendo concatenados, dando-nos "concatenados" como uma operação adicional para gerar números).As operações que temos aqui, no contexto em que o programa as gera, são: incremento; decremento; constante 3; quadrado; e duplo. Infelizmente, incremento e decréscimo são opostos, e o decréscimo tem uma tendência infeliz de produzir um -1 ou -2 na primeira seção (levando a um número negativo geral), mas isso ainda deu uma maior dispersão de resultados do que as outras coisas que tentei . Em particular, temos uma boa dispersão da primeira e da segunda metade do número (observe que a primeira metade pode ser a sequência nula, se
3
é o primeiro caractere do programa).fonte
Œ¿
quanto o diádicoœ¿
(veja na parte inferior da página de átomos do Wiki ), mas são dois diodos de 2 bytes que reduzirão as permutações de código que você deseja, além de que você precisaria todas as suas entradas sejam listas (12
não é uma lista).JavaScript, 27 números
Muito semelhante à resposta de TuukkaX , com outro conjunto de dígitos.
Os 27 valores distintos são:
fonte
~
, ajuda em tudo? É uma operação unária que pode ser útil.~
é o257&~
que produz 11 valores distintos.Braquilog , 26 números
Isso gera os seguintes números:
[2,3,4,5,6,7,8,9,10,16,17,18,19,20,25,26,30,31,32,35,36,37,48,49,63,64]
Explicação
3
é o número inteiro 3, obviamente.+
é incremento*
é o dobro^
é quadrado-
é decréscimoExistem muitas situações em que o programa simplesmente erra: por exemplo,
*+^3-
erros, porque ele pede "Pegue 0, dobre, incremente, quadrado, o resultado desse quadrado é 3, decremento", o que está obviamente errado.Qualquer programa que termine com
3
produzirá3
ou não funcionará.Qualquer programa iniciado com
*3
um loop infinito por causa de um erro (o Brachylog está tentando encontrar uma lista de sublistas cujo produto resulta em 3, o que não é possível).fonte
Vim, 16 números
impressão
fonte
3
e como4
foi? Você precisa de todas as permutações de comprimento-5.i1234
imprime "1234", isso é algum tipo de script ou pressionamento de tecla? Se pressionar as teclas, não funciona.Código da máquina IA-32, 8 números
Valores de bytes hexadecimais:
O código é executado como uma função que retorna o valor em
al
.Permutações válidas:
Fiz uma pesquisa de força bruta, com as seguintes restrições:
b0
- para inicializar oal
registroc3
- return; os seguintes bytes são descartadosadd
or
and
sub
xor
aad
inc
dec
Isso deixa apenas 3 bytes alteráveis, com no máximo 15 resultados possíveis. Destas, no máximo 9 podem ser distintas (na verdade, isso ocorre apenas para um conjunto de bytes!). Um dos valores está fora da faixa, portanto, isso deixa 8 valores. Há outro conjunto de bytes
que também fornece 8 valores distintos - os programas são os mesmos, exceto
sub
substituídos porxor
, o que torna idênticas duas das saídas possíveis.Todos os outros conjuntos de bytes fornecem 7 ou menos resultados possíveis.
fonte
Gelatina , 33 números
Ḥ
duplo (esquerda);2
literal 2;3
literal 3;+
adicionar (esquerda, direita); ec
escolha (esquerda, direita), ou seja, várias maneiras de escolher objetos certos de uma coleção de objetos esquerdos.Números produzidos com um exemplo de programa:
Tentei escolher os fáceis de analisar, mas alguns são raros e um pouco estranhos, por exemplo
23
:... e
72
e13
usar a impressão implícita:Observe que
Ḥ34+c
também produz33
valores exclusivos em[1,120]
.fonte
Brain-Flak 1
O Brain-Flak requer chaves equilibradas; portanto, um programa de 5 caracteres só é válido se um dos caracteres iniciar um comentário. Isso nos deixa com 4 caracteres para trabalhar. Desses, 2 têm que ser
(
e,)
caso contrário, nada seria empurrado para a pilha. Aqueles têm que ir primeiro e quarto com o último comentário ((..)#
). Agora podemos colocar()
,{}
,<>
, ou[]
no interior.{}
,<>
E[]
cada um avaliar a 0, mas()
é 1. Isso significa que(())#
é a corda só 5 caráter que produz um programa Brain-Flak válido.Experimente Online!
Se a pergunta fosse "quais são os 6 personagens mais poderosos", a resposta seria
(){}[]
quando o Brain-Flak estiver completo usando apenas esse subconjunto.fonte
@ij
sinalizador de depuração interrompe o programa e permite que o usuário insira o código de falha cerebral a ser executado onde o@ij
sinalizador apareceu no código. Bastante poderoso, mas infelizmente requer a entrada do usuário e, portanto, não é útil aqui.(){}[]
marcaria 0. Você esqueceu a regra permutações;)Hexagonia , 13 números
Estes são os 13 números imprimíveis com um programa possível para cada um deles:
Os programas devem ser bastante auto-explicativos.
@
finaliza o programa,!
imprime o valor atual,)
incrementa-o2
e4
acrescenta-se ao valor atual (onde está o valor inicial0
). O layout hexagonal real do código fonte é irrelevante aqui, os programas podem ser lidos da esquerda para a direita.Isso deve ser ideal, embora em vez de
2
e4
você possa escolher qualquer dígito de parx
ey
assim por diante2 ≤ x ≤ y-2
.A solução acima foi encontrada por força bruta (quase exaustiva), exigindo uma
!
(caso contrário, não imprimiria nada), uma@
(caso contrário, o programa não será finalizado) e preenchendo os três caracteres restantes com qualquer combinação (repetida) do seguinte conjunto de caracteres:Não vejo como nenhum dos outros comandos poderia gerar mais variedade.
fonte
Perl, 27 números
3479%
O Perl não possui um REPL interno, portanto você pode usar a
re.pl
partir de Devel :: REPL .Resultados:
Forçado bruto usando o seguinte programa:
fonte
perl -de 1
algum tempo. Tecnicamente, isso abre o depurador em um programa vazio, mas o depurador possui um REPL semelhante. Infelizmente, você precisa escreverp
no início de cada linha para que ele realmente imprima o resultado.R,
1518 númerosNão é um número grande, mas pode ser o melhor que pode ser feito com R. Pesquisei todas as combinações de dígitos
0..9
, operadores+ - * / ^
e o caractere de comentário#
, e os oito a seguir geram 18 números inteiros únicos entre 1 e 120.Como exemplo, vamos dar
-#146
. Aqui estão os 18 números inteiros que podemos obter:Se você está curioso sobre o código (feio) usado para testar todas as combinações possíveis, aqui está ele. Ele gera o número de números inteiros exclusivos entre 1 e 120 para cada combinação de caracteres de comprimento 5 em um arquivo chamado "datafile" no diretório de trabalho atual.
fonte
Oitava, 18
Isso foi encontrado usando uma pesquisa bruteforce nos símbolos
*+-/0123456789:;<\^|~%
. Mas demorou muito para calcular ...Saídas possíveis:
fonte
Oitava, 15 números
Não há muito para me gabar, mas é o melhor que posso obter no Oitava:
Dá os números:
Também tenho 16, mas parece que é idêntico à resposta da Sefa ...
fonte
0123456789+-*.%
de oitava é139-%
, que produz uma matriz de 18:1 2 3 4 6 8 9 13 16 19 22 31 38 39 88 91 92 93
. Assim, você pode ganhar mais 3 números :)PHP, 15 números
Usa o fato de que o php imprime qualquer coisa fora de suas tags literalmente (sem usar isso, você pode fazer exatamente 1 número com algo parecido
<?=1;
). Também usa um caractere de retorno de carro real em vez de\r
.Cria (ordenados, 0s iniciais removidos):
dos quais os números únicos válidos são:
fonte
12\r30
imprime12\r30
, o terminal substitui apenas os dois primeiros caracteres.\r
não é imprimível, a saída de12\r30
é30
.Cubix , 7 números
Produz estes números:
Qualquer programa válido do Cubix para esse desafio precisa ter um para gerar um
O
número inteiro e um@
para finalizar o programa (o Cubix nunca ouviu falar de "erros"). Isso nos dá três caracteres para brincar e gerar o máximo de resultados. Além disso, devido à maneira como o Cubix organiza o código em um cubo, o primeiro caractere será inútil, a menos que um dos outros seja um caractere direcional.A maneira mais eficiente que encontrei para gerar vários números é usar
"
para enviar uma sequência de códigos de caracteres para a pilha. Com um rearranjo cuidadoso, podemos ajustar vários caracteres no último ponto e simplesmente emitir seus códigos de caracteres. Usando)
para incrementar o item principal, podemos criar saídas extras a partir de vários desses arranjos.Existem dois tipos de programas básicos em uso aqui. O primeiro é o seguinte:
que se expande para
O programa resultante é enviado
2
para a pilha, incrementa-o com)
, sai comO
e termina com@
.O segundo é o seguinte:
que se expande para
O programa resultante empurra os Char-códigos de
)
,O
e@
, incrementa o último com)
, saídas comO
, e termina com@
.fonte
> <> , 6 números
Ganhou 2 números graças ao Teal Pelican
Produz os números únicos
[1, 4, 5, 49, 59, 108]
Precisamos
n
imprimir um número.Precisamos
;
terminar.Isso nos deixa com apenas 3 caracteres para trabalhar.
Algumas combinações diferentes de
value
&operator
juntamente com"
confirmaram para produzir 6 valores únicos, mas não encontrei nada melhor que isso.fonte
Groovy, 10 números
As soluções JVM da Man são ruins para isso ... Quem sabia?
Resulta em:
Espere o que? Como diabos faz 17 você pergunta?
Segredo comercial, em números inteiros Groovy / Java precedidos por 0 são octais. O código que eu usei para testar as respostas do Groovy, caso alguém queira me derrotar:
fonte
MATL, 15 números
%
é o operador de comentário, portanto, ele "recorta" em todos os locais possíveis uma vez, ajudando a criar todas as combinações possíveis dos dígitos e subconjuntos fornecidos:fonte
J, 16 números
Nada extravagante, apenas testado
1234
com todos os verbos de 1 caractere que eram razoáveis.]
seleciona seu argumento correto.Os números únicos produzidos são
dos quais 16:
Estão no intervalo [1.120].
Testado com
fonte
Japt , 41 números
Praticamente apenas tentativa e erro, para que possa haver uma solução melhor. Usa inteiros
3
e4
e os atalhos Japt para quadratura, acrescentando1
& multiplicando por2
. Todos os 120 programas produzem um número inteiro,>0
mas apenas 78 são<=120
e apenas 41 deles são únicos.Gera os números:
Veja a lista de números ou a coleção de programas válidos
Explicação
Algumas coisas a serem observadas sobre o Japt que são relevantes aqui são:
U
, cujo padrão0
é, será automaticamente inserida no início,3Ä4 = 3+14 = 17
, e, da mesma forma4Ѳ = 4*2**2 = 16
) e,²
o²
e tudo antes dele, essencialmente, será ignorado.As explicações para alguns dos programas (que produzem
1
,3
,37
e93
, respectivamente):fonte
Befunge, 11 números
O Befunge é um pouco limitado porque suporta apenas literais de um dígito. Portanto, o melhor que pude apresentar foram 11 números, assumindo que o cálculo deve nos deixar com um e apenas um número na pilha.
Melhores personagens:
358*%
Números gerados: (apenas um exemplo de cada)
fonte
Python, 16 números
Usa # para comentar todos os números desnecessários.
fonte
dc, 19 números
A saída está no topo da pilha e os erros (incluindo o estouro da pilha) são ignorados. As permutações válidas são:
Aqui está o programa Python que usei para mostrar esses resultados:
Duas outras strings que dão a mesma pontuação de 19 são
32d+*
e*4zO+
.fonte
Smalltalk, 26 números
Explicação: 12r35 é uma notação para o uso da raiz 12 e, portanto, é 3 * 12 + 5.
Isso pode ser verificado no Squeak:
dá:
Se substituirmos a última linha por:
então obtemos as expressões:
Eu queria trapacear e definir um método r em Inteiro como
Infelizmente, o compilador seleciona o 1235r porque reconhece um número inacabado com raiz em vez de uma mensagem enviada para 1235 ...
Eu também poderia facilmente mudar o compilador, mas é um truque demais para o meu gosto.
fonte
Mathematica, 16 números
Não é muito interessante, mas não consigo encontrar nada melhor usando aritmética. A única coisa que pode funcionar é usar
!
fatorial ou fatorial duplo, mas isso é tão propenso a gerar números maciços que é impossível usar força bruta.Os 16 números (no intervalo) que podem ser gerados a partir dos 5 caracteres acima são:
fonte
Encantos Rúnicos, 19 números
Essencialmente 3 literais, o operador pow e um comando "imprima a pilha inteira e finalize".
234p@
imprime 812 (3 ^ 4 conxatenado com um 2). Lista de permutação completa , observe que@
foi substituída porak@
para gerar uma nova linha entre cada resultado e a>
foi adicionada para garantir que cada linha seja executada independentemente. Observe também que as saídas não estão na mesma ordem que os programas que as geraram (pois alguns programas podem terminar mais rapidamente).Muitas permutações não imprimem nada (por exemplo,
@234p
oup234@
), mas 19 resultam em saída dentro da faixa permitida.Números possíveis (e um programa possível que resulta nele;
.
indica que essas posições podem ser qualquer um dos caracteres restantes, pois não é executado):fonte
TI-BASIC, 12 números
Provavelmente existe uma combinação melhor, mas não consegui encontrá-la.
fonte