Quais são os cinco personagens mais poderosos do seu idioma?

101

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.0contagem e planície 32. (Mas 32.01não faria.)
  • Zeros à esquerda, como 032contagem e simples 32.
  • 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.

Passatempos de Calvin
fonte
21
Eu quero fazer esse desafio, mas parece impossível em cidiomas semelhantes !!!
Mukul Kumar
3
@MukulKumar Eu acredito que também existem REPLs na linguagem C (por exemplo, o gdb pode ser usado - até certo ponto - como um REPL para C), para que a abordagem demonstrada para o Python ainda seja uma opção.
Martin Ender
1
Relacionado (link fixo).
Fatalize
3
@ETH Não à coisa verdadeira. É como permitir outra base.
Calvin's Hobbies
3
@ OldBunny2800 As saídas válidas devem ser determinísticas e invariantes no tempo.
Dennis

Respostas:

41

Python3, 21 27 valores

Personagens: 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!

347%9   5
349%7   6
34%79   34
34%97   34
374%9   5
379%4   3
37%49   37
37%94   37
394%7   2
397%4   1
39%47   39
39%74   39
3%479   3
3%497   3
3%749   3
3%794   3
3%947   3
3%974   3
437%9   5
439%7   5
43%79   43
43%97   43
473%9   5
479%3   2
47%39   8
47%93   47
493%7   3
497%3   2
49%37   12
49%73   49
4%379   4
4%397   4
4%739   4
4%793   4
4%937   4
4%973   4
734%9   5
739%4   3
73%49   24
73%94   73
743%9   5
749%3   2
74%39   35
74%93   74
793%4   1
794%3   2
79%34   11
79%43   36
7%349   7
7%394   7
7%439   7
7%493   7
7%934   7
7%943   7
934%7   3
937%4   1
93%47   46
93%74   19
943%7   5
947%3   2
94%37   20
94%73   21
973%4   1
974%3   2
97%34   29
97%43   11
9%347   9
9%374   9
9%437   9
9%473   9
9%734   9
9%743   9
Yytsi
fonte
2
Você não obteria melhores resultados no Python 2, onde /está a divisão inteira?
Neil
@ Kade Me também. O maior que eu tentei foi algo nas linhas de "0123456789 * - + & |% ^ 0123456789"
Yytsi
Há mais duas alternativas para isso, resultando o mesmo número de valores: 5679%e5789%
Gábor Fekete
FYI - Este (ou os 5679%e 5789%) provavelmente também é o ideal para o PowerShell.
AdmBorkBork
Eu recebi esta resposta (junto com 5679%e 5798%) também através de uma pesquisa exaustiva em todas as combinações de 0123456789+-*/&|^#%substituição. Concordo que estes são provavelmente ótimos.
precisa saber é o seguinte
34

05AB1E , 27 38 41 números

4·>Ìn

Gera 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 4com as operações +1, +2, *2e ^2.

Emigna
fonte
Não foram testados, mas o uso ao -invés de +produzir uma variedade mais ampla de resultados com base em sua propriedade não comutativa?
Osable
@ Osable: Também testei com -, 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.
Emigna
Certo, pulei a parte (embora em estilo negrito) dizendo que a saída deve estar no intervalo [1.120]. Meu mal
Osable
Tentei por um tempo e terminei com ~ 35 em todo o resto.
Magic Octopus Urn
32

Python, 18 números

237#-

Produz como resultados válidos:

1, 2, 3, 4, 5, 7, 16, 23, 24, 25, 27, 32, 35, 37, 69, 71, 72, 73

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:

from itertools import permutations,combinations_with_replacement

def perms(chars):
  result=set()
  for permut in permutations(chars):
    try:
      current=eval(''.join(permut))
      assert str(int(current))==str(current)
      result.add(int(current))
    except:
      pass
  return sum([1 for x in result if 1<=x<=120])

best=1
for c in combinations_with_replacement(' !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~',5):
    string=''.join(c)
    r=perms(string)
    if r>=best:
        best=r
        print(r,string,end='\n')

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, %5679e %5789.

Leo
fonte
25
@ TùxCräftîñg Na verdade, não é, um conjunto é uma coleção não ordenada.
Leo
2
@ TùxCräftîñg https://repl.it/El9V/0 Os conjuntos de cursos usam uma classificação interna para acompanhar os elementos, o ponto é que você não pode confiar nessa classificação, pois os itens não são necessariamente classificados na ordem em que você faria espere que eles sejam #
Leo #:
1
@TuukkaX Vejo que esse é um comportamento inesperado e causa mais problemas do que resolve, então editei. Desculpem o transtorno :) #
Leo
1
@ hBy2Py Se você não fizer nenhuma outra operação no conjunto entre as duas iterações, acho que pode assumir que as duas iterações seguirão a mesma ordem. No entanto, no caso geral, a regra é que os conjuntos são coleções não ordenadas, portanto, você nunca deve confiar neles para ter qualquer tipo de ordem.
Leo
3
@ Leo Entendi: conjuntos são nitroglicerina. Razoavelmente estável, a menos que você os esbarre.
Hby2Py
23

Números Java 8, 2 4

n->12  // returns 12
n->21  // returns 21
n1->2  // returns 2
n2->1  // returns 1

Você 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!

Xanderhall
fonte
2
O Java tem um REPL? Talvez você possa usar mais símbolos desta forma
Arturo Torres Sánchez
Eu não faço ideia. Estou inclinado a dizer não. Além disso, a minha resposta seria basicamente se tornar um copypaste do outro REPL responde então: P
Xanderhall
3
Java 9 terá um REPL de baunilha !! Mas, por enquanto, estamos presos a coisas de terceiros .
NonlinearFruit
17
Eu acho que você pode fazer melhor com n->12. Isto dá-lhe quatro respostas distintas que estão todos dentro do intervalo: n->12, n->21, n1->2, n2->1.
2
O Java 9 e seu REPL estão disponíveis hoje em uma versão de acesso antecipado . De fato, enviei respostas para outras perguntas aqui usando-o.
David Conrad
18

Geleia, 26 30 32 números

‘’3²Ḥ

Este (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:

018 036 06 03 09 03 18 116 116 117 125 135 06 03 14 15 13 22 19 13 24
28 33 42 018 036 06 03 09 03 -132 -164 -120 -119 -149 -137 26 43 18 17 
33 24 -19 13 -216 -210 53 44 18 36 30 31 49 63 18 36 10 9 25 17 18 19
18 17 18 18 36 48 36 26 36 36 06 03 14 15 13 22 06 03 -18 -17 -13 -24
06 07 06 05 06 06 03 12 03 -14 03 03 09 03 14 18 03 12 09 03 -116 -110 
23 14 09 015 09 05 09 09 03 12 03 -14 03 03

Se você apenas obtiver as saídas exclusivas em ordem numérica, obterá:

-216 -210 -164 -149 -137 -132 -120 -119 -116 -110 -24 -19 -18 -17 -14 -13
03 05 06 07 09 10 12 13 14 15 17 018 19 22 23 24 25 26 28 30 31 33 036 42
43 44 48 49 53 63 116 117 125 135

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
@TuukkaX, implementei tanto o monádico Œ¿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 ( 12não é uma lista).
Jonathan Allan
16

JavaScript, 27 números

Muito semelhante à resposta de TuukkaX , com outro conjunto de dígitos.

5789%

Os 27 valores distintos são:

589 %   7 -> 1
987 %   5 -> 2
978 %   5 -> 3
879 %   5 -> 4
985 %   7 -> 5
958 %   7 -> 6
975 %   8 -> 7
 95 %  87 -> 8
  9 % 875 -> 9
 97 %  85 -> 12
 89 %  75 -> 14
 95 %  78 -> 17
 78 %  59 -> 19
 79 %  58 -> 21
 98 %  75 -> 23
 87 %  59 -> 28
 89 %  57 -> 32
 97 %  58 -> 39
 98 %  57 -> 41
 57 %  98 -> 57
 58 %  97 -> 58
 59 %  87 -> 59
 75 %  98 -> 75
 78 %  95 -> 78
 79 %  85 -> 79
 85 %  97 -> 85
 87 %  95 -> 87
Arnauld
fonte
usando bit a bit não ~, ajuda em tudo? É uma operação unária que pode ser útil.
precisa saber é o seguinte
1
@JollyJoker Bem, o melhor que posso encontrar até agora ~é o 257&~que produz 11 valores distintos.
Arnauld
Estou um pouco surpreso, mas acho que minha intuição não é muito boa aqui.
JollyJoker #
15

Braquilog , 26 números

3+*^-

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éscimo

Existem 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 3produzirá 3ou não funcionará.

Qualquer programa iniciado com *3um 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).

Fatalizar
fonte
1
Boa resposta e idk qualquer coisa sobre o golfe, mas no lado da matemática, você pode obter qualquer número até 121 adicionando ou substituindo as cinco primeiras potências de 3. 1,3,9,27 e 81. Espero que ajude.
shyos
11

Vim, 16 números

i1234

impressão

1, 2, 3, 4, 12, 13, 14, 21, 23, 24, 31, 32, 34, 41, 42, 43
Sefa
fonte
1
@ymbirtt Para onde foi 3e como 4foi? Você precisa de todas as permutações de comprimento-5.
Kade
i1234imprime "1234", isso é algum tipo de script ou pressionamento de tecla? Se pressionar as teclas, não funciona.
Captain Man
Expandindo o argumento do @Captain Man, a maneira óbvia de executar as permutações como um script seria com: norm. Porém, isso não imprime nenhum número na faixa de 1-120. Você tinha outro método em mente?
Simon
Você pode colocá-los no intérprete on-line para V que é mais ou menos compatível com Vim
nmjcman101
4
@ nmjcman101 Neste caso, ele cai no buraco de "principalmente", pois 12i34 em V resulta em 12 ocorrências de 34, onde, como se você digitasse no vim, apenas 34 (acho que V assume uma esc final)
Sefa
11

Código da máquina IA-32, 8 números

Valores de bytes hexadecimais:

2c 40 48 b0 c3

O código é executado como uma função que retorna o valor em al.

Permutações válidas:

b0 2c c3 xx xx => 2c (mov al, 2c)

b0 40 c3 xx xx => 40 (mov al, 40)

b0 48 c3 xx xx => 48 (mov al, 48)

b0 2c 40 c3 48 => 2d (mov al, 2c; inc eax)

b0 2c 48 c3 40 => 2b (mov al, 2c; dec eax)

b0 40 48 c3 2c => 3f (mov al, 40; dec eax)

b0 48 40 c3 2c => 49 (mov al, 48; inc eax)

b0 48 2c 40 c3 => 8 (mov al, 48; sub al, 40)

Fiz uma pesquisa de força bruta, com as seguintes restrições:

  • O primeiro byte é b0- para inicializar o alregistro
  • O último byte é c3- return; os seguintes bytes são descartados
  • Os bytes possíveis do código de operação são:
    • 0x04 - add
    • 0x0c - or
    • 0x24 - and
    • 0x2c - sub
    • 0x34 - xor
    • 0xd4 - aad
    • 0x40 - inc
    • 0x48 - 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

34 40 48 b0 c3

que também fornece 8 valores distintos - os programas são os mesmos, exceto subsubstituídos por xor, o que torna idênticas duas das saídas possíveis.

Todos os outros conjuntos de bytes fornecem 7 ou menos resultados possíveis.

anatolyg
fonte
10

Gelatina , 33 números

Ḥ23+c

duplo (esquerda);
2literal 2;
3literal 3;
+adicionar (esquerda, direita); e
cescolha (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:

 1 +32Ḥc   18 3Ḥc2+    45 2+3Ḥc
 2 c3Ḥ+2   20 2+Ḥc3    47 23c+Ḥ
 3 c2Ḥ+3   21 2Ḥ+3c    48 c+23Ḥ
 4 +2Ḥc3   22 3Ḥc+2    53 2c+Ḥ3
 5 2+3cḤ   23 23cḤ+    56 3Ḥ+2c
 6 3c+2Ḥ   24 cḤ+23    63 c+2Ḥ3
 8 2c+3Ḥ   30 3+c2Ḥ    65 32c+Ḥ
 9 3c2+Ḥ   32 32cḤ+    66 c+32Ḥ
12 +3cḤ2   33 cḤ+32    72 3c+Ḥ2
13 +2cḤ3   36 3+Ḥc2    82 c+3Ḥ2
15 +3Ḥc2   42 cḤ3+2   120 3+2Ḥc

Tentei escolher os fáceis de analisar, mas alguns são raros e um pouco estranhos, por exemplo 23:

23cḤ+: (23 c (2 * 23)) + 23 = (23 c 46) + 23 = 0 + 23 = 23

... e 72e 13usar a impressão implícita:

3c+Ḥ2: z = (3 c 0) + (3 * 2); print(z); z = 2; print(z)
       z =    1    +    6   ; print(z); z = 2; print(z)

+2cḤ3: z = (0 + 2) c (2 * 0); print(z); z = 3; print(z)
       z =    2    c    0   ; print(z); z = 3; print(z)
       z =         1        ; print(z); z = 3; print(z)

Observe que Ḥ34+ctambém produz 33valores exclusivos em [1,120].

Jonathan Allan
fonte
10

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.

Riley
fonte
Um recurso mal documentado: o @ijsinalizador de depuração interrompe o programa e permite que o usuário insira o código de falha cerebral a ser executado onde o @ijsinalizador apareceu no código. Bastante poderoso, mas infelizmente requer a entrada do usuário e, portanto, não é útil aqui.
0
Correção ligeira: (){}[]marcaria 0. Você esqueceu a regra permutações;)
CalculatorFeline
8

Hexagonia , 13 números

)24!@

Estes são os 13 números imprimíveis com um programa possível para cada um deles:

)!@24 1
2!@)4 2
2)!@4 3
4!@)2 4
4)!@2 5
)2!@4 12
)4!@2 14
24!@) 24
24)!@ 25
2)4!@ 34
42!@) 42
42)!@ 43
4)2!@ 52

Os programas devem ser bastante auto-explicativos. @finaliza o programa, !imprime o valor atual, )incrementa-o 2e 4acrescenta-se ao valor atual (onde está o valor inicial 0). 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 2e 4você possa escolher qualquer dígito de par xe yassim por diante 2 ≤ 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:

#[]\/_|<>)!0123456789$

Não vejo como nenhum dos outros comandos poderia gerar mais variedade.

Martin Ender
fonte
Eu também publicaria uma resposta do labirinto, mas o mesmo conjunto de soluções exatamente parece ótimo também (com efetivamente a mesma semântica também).
Martin Ender
7

Perl, 27 números

3479%

O Perl não possui um REPL interno, portanto você pode usar a re.plpartir de Devel :: REPL .

Resultados:

%9743 -> N/A
9%743 -> 9
97%43 -> 11
974%3 -> 2
9743% -> N/A
%7943 -> N/A
7%943 -> 7
79%43 -> 36
794%3 -> 2
7943% -> N/A
%7493 -> N/A
7%493 -> 7
74%93 -> 74
749%3 -> 2
7493% -> N/A
%7439 -> N/A
7%439 -> 7
74%39 -> 35
743%9 -> 5
7439% -> N/A
%9473 -> N/A
9%473 -> 9
94%73 -> 21
947%3 -> 2
9473% -> N/A
%4973 -> N/A
4%973 -> 4
49%73 -> 49
497%3 -> 2
4973% -> N/A
%4793 -> N/A
4%793 -> 4
47%93 -> 47
479%3 -> 2
4793% -> N/A
%4739 -> N/A
4%739 -> 4
47%39 -> 8
473%9 -> 5
4739% -> N/A
%9437 -> N/A
9%437 -> 9
94%37 -> 20
943%7 -> 5
9437% -> N/A
%4937 -> N/A
4%937 -> 4
49%37 -> 12
493%7 -> 3
4937% -> N/A
%4397 -> N/A
4%397 -> 4
43%97 -> 43
439%7 -> 5
4397% -> N/A
%4379 -> N/A
4%379 -> 4
43%79 -> 43
437%9 -> 5
4379% -> N/A
%9734 -> N/A
9%734 -> 9
97%34 -> 29
973%4 -> 1
9734% -> N/A
%7934 -> N/A
7%934 -> 7
79%34 -> 11
793%4 -> 1
7934% -> N/A
%7394 -> N/A
7%394 -> 7
73%94 -> 73
739%4 -> 3
7394% -> N/A
%7349 -> N/A
7%349 -> 7
73%49 -> 24
734%9 -> 5
7349% -> N/A
%9374 -> N/A
9%374 -> 9
93%74 -> 19
937%4 -> 1
9374% -> N/A
%3974 -> N/A
3%974 -> 3
39%74 -> 39
397%4 -> 1
3974% -> N/A
%3794 -> N/A
3%794 -> 3
37%94 -> 37
379%4 -> 3
3794% -> N/A
%3749 -> N/A
3%749 -> 3
37%49 -> 37
374%9 -> 5
3749% -> N/A
%9347 -> N/A
9%347 -> 9
93%47 -> 46
934%7 -> 3
9347% -> N/A
%3947 -> N/A
3%947 -> 3
39%47 -> 39
394%7 -> 2
3947% -> N/A
%3497 -> N/A
3%497 -> 3
34%97 -> 34
349%7 -> 6
3497% -> N/A
%3479 -> N/A
3%479 -> 3
34%79 -> 34
347%9 -> 5
3479% -> N/A

Forçado bruto usando o seguinte programa:

use strict;
use warnings 'all';
use 5.010;

use Algorithm::Combinatorics qw(combinations);
use Algorithm::Permute;
use Scalar::Util::Numeric qw(isint);

my @chars = ( 0..9, qw(+ - * / . ; ' " \ @ $ # ! % ^ & ( ) { } =) );
my $iter  = combinations(\@chars, 5);
my $max   = 0;
my @best;

while (my $combo = $iter->next) {
    my $count = count_valid([@$combo]);

    if ($count > $max) {
        $max  = $count;
        @best = @$combo;
    }
}

say "$max -> @best";

sub count_valid {
    my ($chars) = @_;

    my $iter = Algorithm::Permute->new($chars);
    my %results;

    while (my @perm = $iter->next) {
        no warnings;
        my $val = eval join '', @perm;
        use warnings 'all';

        $results{$val} = 1 if isint($val) && $val > 0 && $val <= 120;
    }

    return scalar keys %results;
}
ThisSuitIsBlackNot
fonte
Perl realmente tem algo muito próximo a um REPL embutido. Tente executar perl -de 1algum tempo. Tecnicamente, isso abre o depurador em um programa vazio, mas o depurador possui um REPL semelhante. Infelizmente, você precisa escrever p no início de cada linha para que ele realmente imprima o resultado.
@ ais523 É por isso que não mencionei; você não pode simplesmente digitar a sequência e obter a saída, que é um dos requisitos.
ThisSuitIsBlackNot
7

R, 15 18 números

Nã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.

-#146
-#157
-#237
-#238
-#256
-#267
-#278
-#378
-#467
-#568

Como exemplo, vamos dar -#146. Aqui estão os 18 números inteiros que podemos obter:

1#-46      = 1
6-4#1      = 2
4-1#6      = 3
4#-16      = 4
6-1#4      = 5
6#-14      = 6
14-6#      = 8
16-4#      = 12
14#-6      = 14
16#-4      = 16
41-6#      = 35
41#-6      = 41
46-1#      = 45
46#-1      = 46
61-4#      = 57
61#-4      = 61
64-1#      = 63
64#-1      = 64

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.

allchars = c("1","2","3","4","5","6","7","8","9","0","+","-","*","/","^")
apply(gtools::combinations(n=15, r=5, v=allchars, repeats.allowed=TRUE),
      1,
      function(chars) {
        x = apply(apply(e1071::permutations(length(chars)), 
                        1,
                        function(i) chars[i]
                        ),
                  2,
                  paste, collapse=""
            )
        u = unique(x)
        o = as.numeric(unlist(sapply(u, function(i) eval(try(parse(t=i),TRUE)))))

        f = factor(unique(o[o<=120 & o>=1 & o%%1==0]))
        write(paste(nlevels(f), paste(chars, collapse="")), "datafile", append=TRUE)
      }
)
rturnbull
fonte
Você diz que é um código feio ... eu acho lindo! Os muitos usos de aplicar nunca deixam de me surpreender!
Sumner18
6

Oitava, 18

Isso foi encontrado usando uma pesquisa bruteforce nos símbolos *+-/0123456789:;<\^|~%. Mas demorou muito para calcular ...

-139%

Saídas possíveis:

1, 2, 3, 4, 6, 8, 9,13,16,19,22,31,38,39,88,91,92,93
flawr
fonte
5

Oitava, 15 números

Não há muito para me gabar, mas é o melhor que posso obter no Oitava:

124+%

Dá os números:

1    2    3    4    5    6   12   14   16   21   24   25   41   42   43

Também tenho 16, mas parece que é idêntico à resposta da Sefa ...

1234%

1    2    3    4   12   13   14   21   23   24   31   32   34   41   42   43
Stewie Griffin
fonte
De acordo com os testes, a escolha óptima a partir 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 :)
2
de força bruta muito bruto que eu usei para obter a solução de 18 number: pastebin.com/umckG0VS
2
Encontrei essa solução também, mas isso foi depois de ver o envio do python e é essencialmente a mesma coisa. Bom trabalho se preocupando em fazer um script de força bruta. Ste
Stewie Griffin
4

PHP, 15 números

1230\r

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):

 1 1 2 2 3 3 10 10 12 12 12 12 13 13 13 13 20 20 21 21 21 21 23 23 23 23 30 30 31 31 31 31 32 32 32 32 102 102 103 103 120 120 123 123 123  123  130  130  132  132  132  132  201  201  203  203  210  210  213  213  213  213  230  230  231  231  231  231  301  301  302  302  310  310  312  312  312  312  320  320  321  321  321  321  1023  1023  1032  1032  1203  1203  1230  1230  1302  1302  1320  1320  2013  2013  2031  2031  2103  2103  2130  2130  2301  2301  2310  2310  3012  3012  3021  3021  3102  3102  3120  3120  3201  3201  3210  3210

dos quais os números únicos válidos são:

1 2 3 10 12 13 20 21 23 30 31 32 102 103 120
user59178
fonte
3
Isso realmente não imprime esses números. 12\r30imprime 12\r30, o terminal substitui apenas os dois primeiros caracteres.
Dennis
@ Dennis É como dizer que, em qualquer desafio que exija a técnica de caracteres de controle para substituir o texto, a saída não é o que se vê no final, mas a soma dos bytes escritos. Como \rnão é imprimível, a saída de 12\r30é 30.
gato
3
@cat Na verdade, discutimos isso na meta ; o uso de caracteres de controle é permitido apenas se o desafio estiver relacionado à arte ASCII.
Dennis
4

Cubix , 7 números

"2)@O

Produz estes números:

")O2@ ->  1
")2O@ ->  2
"2)O@ ->  3
2"O@) -> 41
)"O@2 -> 50
2"O)@ -> 64
2")O@ -> 65

Qualquer programa válido do Cubix para esse desafio precisa ter um para gerar um Onú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:

"2)O@

que se expande para

  "
2 ) O @
  .

O programa resultante é enviado 2para a pilha, incrementa-o com ), sai com Oe termina com @.

O segundo é o seguinte:

2")O@

que se expande para

  2
" ) O @
  .

O programa resultante empurra os Char-códigos de ), Oe @, incrementa o último com ), saídas com O, e termina com @.

ETHproductions
fonte
3

> <> , 6 números

Ganhou 2 números graças ao Teal Pelican

1ln";

Produz os números únicos [1, 4, 5, 49, 59, 108]

Precisamos nimprimir um número.
Precisamos ;terminar.

Isso nos deixa com apenas 3 caracteres para trabalhar.

Algumas combinações diferentes de value& operatorjuntamente com "confirmaram para produzir 6 valores únicos, mas não encontrei nada melhor que isso.

Emigna
fonte
Eu tenho tentado resolver isso, mas isso não produz apenas 4 números? como o intervalo é 1-120 e não 0-120?
Teal pelican
@Tealpelican: Correto. Eu percebi isso no caminho de casa para o trabalho e estava prestes a corrigi-lo.
Emigna
Eu já dei uma olhada em mais alguns programas de peixes, como o quines e oi mundo, etc., e tive uma idéia. Algo usando personagens como este; 1n; + "geraria 6+ a partir de um cálculo rápido (usando o recurso de loop e seqüências de caracteres para nossa vantagem) - pode valer a pena verificar com valores diferentes para 1 e operações.
Teal pelican
@Tealpelican: Essa é uma boa ideia.
Emigna
3

Groovy, 10 números

As soluções JVM da Man são ruins para isso ... Quem sabia?

1200+

Resulta em:

[3, 10, 12, 17, 21, 30, 66, 80, 102, 120]

Espere o que? Como diabos faz 17 você pergunta?

20+10 is 30.
0120+ is invalid.
2+001 is 3.
201+0 is 201.
2+100 is 102.
0+012 is 10.
21+00 is 21.
02+01 is 3.
0210+ is invalid.
10+20 is 30.
200+1 is 201.
0+210 is 210.
1200+ is invalid.
0201+ is invalid.
+0021 is 17.
1+002 is 3.
210+0 is 210.
100+2 is 102.
010+2 is 10.
00+12 is 12.
20+01 is 21.
01+20 is 21.
0+120 is 120.
+0120 is 80.
0+021 is 17.
+1020 is 1020.
0012+ is invalid.
02+10 is 12.
102+0 is 102.
012+0 is 10.
+2100 is 2100.
12+00 is 12.
00+21 is 21.
+2001 is 2001.
+0210 is 136.
+1200 is 1200.
1020+ is invalid.
0102+ is invalid.
2001+ is invalid.
001+2 is 3.
+0012 is 10.
2+010 is 10.
0021+ is invalid.
10+02 is 12.
2100+ is invalid.
+0201 is 129.
2010+ is invalid.
020+1 is 17.
1002+ is invalid.
+2010 is 2010.
1+020 is 17.
1+200 is 201.
01+02 is 3.
+1002 is 1002.
120+0 is 120.
0+102 is 102.
+0102 is 66.
002+1 is 3.
0+201 is 201.
021+0 is 17.

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:

("1200+" as List).permutations().collect{
    it.join()
}.collect {
    print "$it is "
    x=-1;
    try {
        x=Eval.me(it);
        println "$x."
    } catch(Exception e) {
        println "invalid."
    }
    x<=120?x:-1;
}.unique().sort();​
Urna de polvo mágico
fonte
Eu acho que a mesma resposta também funcionaria para Java.
Paŭlo Ebermann
3

MATL, 15 números

0123%

% é 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:

1
2
3
10
12
13
20
21
23
30
31
32
102
103
120
Cedric Reichenbach
fonte
3

J, 16 números

1234]

Nada extravagante, apenas testado 1234com todos os verbos de 1 caractere que eram razoáveis. ]seleciona seu argumento correto.

Os números únicos produzidos são

0 4 3 34 43 2 24 42 23 32 234 243 324 342 423 432 1 14 41 13 31 134 143 314 341 413 431 12 21 124 142 214 241 412 421 123 132 213 231 312 321 1234 1243 1324 1342 1423 1432 2134 2143 2314 2341 2413 2431 3124 3142 3214 3241 3412 3421 4123 4132 4213 4231 4312 4321

dos quais 16:

4 3 34 43 2 24 42 23 32 1 14 41 13 31 12 21

Estão no intervalo [1.120].

Testado com

# (#~e.&(>:i.120)) ~. (". :: 0:)"1 (A.~ i.@!@#) '1234]'
Bolce Bussiere
fonte
3

Japt , 41 números

Praticamente apenas tentativa e erro, para que possa haver uma solução melhor. Usa inteiros 3e 4e os atalhos Japt para quadratura, acrescentando 1& multiplicando por 2. Todos os 120 programas produzem um número inteiro, >0mas apenas 78 são <=120e apenas 41 deles são únicos.

34²ÄÑ

Gera os números:

1,3,4,5,6,7,8,9,13,14,17,20,21,26,27,29,30,31,32,33,34,35,36,37,38,39,42,43,44,45,47,56,59,68,69,72,73,86,87,92,93

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:

  1. Se um programa não iniciar com (neste caso) um dos dígitos, a primeira variável de entrada U, cujo padrão 0é, será automaticamente inserida no início,
  2. Se um ou ambos os dígitos seguirem imediatamente um dos atalhos para uma operação matemática, eles serão anexados a ele (por exemplo 3Ä4 = 3+14 = 17, e, da mesma forma 4Ѳ = 4*2**2 = 16) e,
  3. Se um dos dígitos seguir imediatamente ²o ²e tudo antes dele, essencialmente, será ignorado.

As explicações para alguns dos programas (que produzem 1, 3, 37e 93, respectivamente):

²Ñ34Ä  :Square 0, multiply by 234 and add 1
4ÄѲ3  :Add 1 multiplied by 2 squared to 4, ignore that and return the 3
3²Ä4Ñ  :Square 3 and add 14 multiplied by 2
4Ñ3IJ  :Multiply 4 by 23 and add 1 squared
Shaggy
fonte
2

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)

58*3% => 1
358*% => 3
38*5% => 4
538*% => 5
35*8% => 7
835*% => 8
385%* => 9
583%* => 10
358%* => 15
53%8* => 16
35%8* => 24
James Holderness
fonte
2

Python, 16 números

1234#

Usa # para comentar todos os números desnecessários.

OldBunny2800
fonte
2

dc, 19 números

*3zO+

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:

+O3*z:   1
+O*3z:   2
+Oz3*:   3
O*z3+:   4
O*3z+:   5
+O3z*:   6
+z3*O:  10
3*zO+:  11
3*Oz+:  12
Oz3*+:  13
O3z*+:  16
+3Oz*:  20
3Oz*+:  23
+zO3*:  30
O3*z+:  31
Oz+3*:  33
3Oz+*:  36
Oz3+*:  40
O3z+*:  50
TOTAL COUNT = 19 numbers

Aqui está o programa Python que usei para mostrar esses resultados:

#!/usr/bin/python

import sys
import itertools
import subprocess

if len(sys.argv[1]) != 5:
    print("Invalid input")
    sys.exit(1)

devnull = open("/dev/null", 'w');

r = dict()
for s in itertools.permutations(sys.argv[1]):
    p = "".join(s)
    try:
        e = (subprocess.check_output(['dc', '-e', p, '-e', 'p'], stderr=devnull))
        e = int(e)
        if 0 < e <= 120:
            r[e] = p
    except e:
        pass

for i in sorted(r):
    print("%5s: %3d" % (r[i], i))

print("TOTAL COUNT = %d numbers" % len(r))

Duas outras strings que dão a mesma pontuação de 19 são 32d+*e *4zO+.

Toby Speight
fonte
2

Smalltalk, 26 números

1235r

Explicação: 12r35 é uma notação para o uso da raiz 12 e, portanto, é 3 * 12 + 5.
Isso pode ser verificado no Squeak:

((Array streamContents: [:s |
    '1235r'  permutationsDo: [:each | 
        | eval |
        eval := [Compiler evaluate: each] ifError: [nil].
        (eval isInteger and: [eval >=1 and: [eval <= 120]]) ifTrue: [s nextPut: each copy -> eval]]])
  collect: #value as: Set) sorted

dá:

#(1 2 3 5 28 31 33 37 38 41 42 47 55 58 63 66 67 68 71 76 82 86 105 107 108 116)

Se substituirmos a última linha por:

    sorted: #value ascending)

então obtemos as expressões:

'235r1' -> 1
'253r1' -> 1
'325r1' -> 1
'352r1' -> 1
'523r1' -> 1
'532r1' -> 1
'135r2' -> 2
'153r2' -> 2
'315r2' -> 2
'351r2' -> 2
'531r2' -> 2
'513r2' -> 2
'125r3' -> 3
'152r3' -> 3
'215r3' -> 3
'251r3' -> 3
'521r3' -> 3
'512r3' -> 3
'123r5' -> 5
'132r5' -> 5
'213r5' -> 5
'231r5' -> 5
'321r5' -> 5
'312r5' -> 5
'23r15' -> 28
'25r13' -> 28
'13r25' -> 31
'15r23' -> 33
'32r15' -> 37
'35r12' -> 37
'5r123' -> 38
'12r35' -> 41
'5r132' -> 42
'15r32' -> 47
'52r13' -> 55
'53r12' -> 55
'5r213' -> 58
'12r53' -> 63
'5r231' -> 66
'13r52' -> 67
'31r25' -> 67
'21r35' -> 68
'35r21' -> 71
'25r31' -> 76
'5r312' -> 82
'5r321' -> 86
'51r23' -> 105
'53r21' -> 107
'21r53' -> 108
'23r51' -> 116

Eu queria trapacear e definir um método r em Inteiro como

Integer>>r
    ^self \\ 120 + 1

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.

aka.nice
fonte
1

Mathematica, 16 números

;1234

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:

1, 2, 3, 4, 12, 13, 14, 21, 23, 24, 31, 32, 34, 41, 42, 43
Martin Ender
fonte
Por que não; 6789?
David G. Stork
1

Encantos Rúnicos, 19 números

234p@

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 por ak@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, @234pou p234@), 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):

2@...        2
3@...        3
4@...        4
23p@.        8
32p@.        9
42p@.       16
32@..       23
42@..       24
23@..       32
43@..       34
24@..       42
34@..       43
23p4@       48
32p4@       49
43p@.       64
34p@.       81
423p@       84
432p@       94
Draco18s
fonte
1

TI-BASIC, 12 números

23+4!

Provavelmente existe uma combinação melhor, mas não consegui encontrá-la.

24

23+4!   -> 47
24+3!   -> 30
2+4!3   -> 74
2+3!4   -> 26
2!4+3   -> 11
2!+43   -> 45
2!+34   -> 36
2!3+4   -> 10
32+4!   -> 56
34+2!   -> 36
3+4!2   -> 51
3+2!4   -> 11
3!4+2   -> 26
3!+42   -> 48
3!+24   -> 30
3!2+4   -> 16
43+2!   -> 45
42+3!   -> 48
4+2!3   -> 10
4+3!2   -> 16
4!2+3   -> 51
4!+23   -> 47
4!+32   -> 56
4!3+2   -> 74

12

10,11,16,26,30,36.,45,47,48.,51,56.,74

Tau
fonte