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.

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

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.

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.

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!

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

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

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

Vim, 16 números

i1234

impressão

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

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.

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].

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.

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.

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;
}

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

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

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

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

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 @.

> <> , 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.

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();​

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

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]'

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

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

Python, 16 números

1234#

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

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+.

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.

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

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

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$