Elija cualquiera de los cinco caracteres que admite su idioma. Hay 5! = 5 × 4 × 3 × 2 × 1 = 120 formas en que se pueden organizar en una cadena de 5 caracteres que contiene cada carácter una vez; 120 permutaciones .

Elija sus caracteres de modo que, cuando cada una de las 120 cadenas se ejecute en su idioma, las 120 salidas producidas sean tantos enteros únicos del 1 al 120 (inclusive) como sea posible.

Es decir, para cada una de las 120 permutaciones de sus 5 caracteres que producen código ejecutable que genera un solo número, desea que el conjunto de todos esos números coincida lo más cerca posible del conjunto de enteros del 1 al 120.

Entonces, idealmente, su primera permutación saldría 1, la siguiente 2, la siguiente 3, hasta el final 120. Pero ese ideal es probablemente imposible para la mayoría de los idiomas y caracteres.

Las cadenas de 5 caracteres se pueden ejecutar como:

• un programa sin entrada
• una función sin argumentos
• un comando REPL

Se pueden ejecutar diferentes cadenas de diferentes maneras si se desea

Para que la salida cuente, debe ser una única salida entera de una manera normal , como:

• ser impreso en stdout
• devuelto por la función
• El resultado de la expresión REPL

El código debe terminar normalmente (lo que puede implicar un error siempre que el número se haya enviado primero). El código que no se ejecuta está bien, solo la salida (inexistente) no cuenta. La salida de los números debe estar en decimal a menos que una base diferente sea la norma para su idioma.

La presentación que genera los números más distintos del 1 al 120 gana. La presentación anterior gana en caso de empate.

Notas

• No es necesario que todos sus 5 caracteres sean diferentes, pero, por supuesto, tener caracteres duplicados reduce el número efectivo de permutaciones.
• Salidas flotantes, como 32.0recuento y sin formato 32. (Pero 32.01no lo haría)
• Ceros a la izquierda, como el 032recuento y el simple 32.
• Las salidas válidas deben ser deterministas e invariantes en el tiempo.
• Estamos tratando con caracteres , no con bytes.

Ejemplo

Los personajes 123+*son una primera opción razonable para REPL de Python (o muchos idiomas). Las 120 permutaciones y salidas resultantes son:

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

Se generan 36 números, todos afortunadamente entre 1 y 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

Sin embargo, solo 8 de ellos son únicos:

36, 26, 7, 5, 23, 32, 63, 62

Por lo tanto, tal presentación solo obtendría 8 de un máximo de 120.

Python3, 21 27 valores

Caracteres: 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 se solicitó, aquí están las permutaciones que cayeron en el rango [1, 120] . Pruébalo en línea!

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

Genera los números únicos:

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

Utiliza la constante de 4las operaciones +1, +2, *2y ^2.

Python, 18 números

237#-

Produce como resultados válidos:

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

EDITAR: puedo dar fe de que la solución de TuukkaX es óptima para Python. Ejecuté el siguiente código que aplica todas las combinaciones posibles de 5 caracteres ASCII imprimibles:

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

Los resultados (después de correr durante casi 7 horas) mostraron que la solución óptima es de hecho 27 números diferentes, producidos por tres soluciones diferentes, todas utilizando cuatro números y MOD ( %): %3479, %5679y %5789.

Java 8, 2 4 números

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

No esperabas una respuesta de Java, ¿verdad?

Esta es una lambda que solo se puede organizar de dos maneras (¡y con dos dígitos diferentes!) Para un total de dos números únicos. Todo lo demás no es una lambda válida.

En realidad mejoró la respuesta, gracias a la ayuda de los comentarios! No vi que 0 no era válido, y olvidé que las variables podrían, ya sabes, tener más de un carácter. ¡Tenemos 4!

Una solución aún peor

()->1

Pero, por el lado positivo, ¡dos respuestas únicas en Java!

Gelatina, 26 30 32 números

‘’3²Ḥ

Esto (y sus anagramas) son programas completos, que no toman entrada y producen salida en salida estándar.

Los resultados de los 120 programas son, en el orden en que Jelly los genera si le pide que genere permutaciones del 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

Si solo toma las salidas únicas en orden numérico, obtendrá:

-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

Muchos de estos son demasiado pequeños, y 135 es demasiado grande, pero todavía hay 32 que están dentro del rango.

La idea básica es utilizar principalmente instrucciones monádicas (en un programa con solo mónadas y nilas, cada una de ellas solo transforma la salida anterior) y otras que permiten que el valor diverja rápidamente. La excepción es con 3, que es un nilad (el valor constante 3). Si aparece al comienzo del programa, todas las operaciones se realizarán desde 3. Si aparece en el medio, divide el programa en dos mitades, cada una de las cuales genera un número entero (y cada una imprime a la salida estándar, los resultados terminan siendo concatenados, lo que nos da "concatenar" como una operación adicional para generar números).

Las operaciones que tenemos aquí, en el contexto en el que las genera el programa, son: incremento; decremento; constante 3; cuadrado; y doble Lamentablemente, el aumento y la disminución son opuestos, y la disminución tiene una desafortunada tendencia a producir un -1 o -2 en la primera sección (lo que lleva a un número negativo en general), pero esto aún dio una mayor difusión de resultados que las otras cosas que probé . En particular, obtenemos una distribución bastante buena tanto de la primera como de la segunda mitad del número (tenga en cuenta que la primera mitad puede ser la cadena nula, si 3es el primer carácter del programa).

JavaScript, 27 números

Muy similar a la respuesta de TuukkaX , con otro conjunto de dígitos.

5789%

Los 27 valores distintos son:

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

Brachylog , 26 números

3+*^-

Esto genera los siguientes 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]

Explicación

• 3 es el entero 3, obviamente.
• + es incremento
• * es doble
• ^ es cuadrado
• - es decremento

Hay muchas situaciones en las que el programa simplemente comete errores: por ejemplo, *+^3-errores porque pregunta "Tome 0, duplíquelo, incremente, cuadrado, el resultado de ese cuadrado es 3, decremento", lo cual obviamente es incorrecto.

Cualquier programa que termine con 3saldrá 3o no funcionará.

Cualquier programa que comience con *3un bucle infinito debido a un error (Brachylog está intentando encontrar una lista de sublistas cuyo producto da como resultado 3 que no es posible).

Vim, 16 números

i1234

impresión

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

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

Valores de bytes hexadecimales:

2c 40 48 b0 c3

El código se ejecuta como una función que devuelve el valor en al.

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

Hice una búsqueda de fuerza bruta, con las siguientes restricciones:

• El primer byte es b0- para inicializar el alregistro
• El último byte es c3- return; los siguientes bytes se descartan
• Los bytes de código de operación posibles son:
  • 0x04 - add
  • 0x0c - or
  • 0x24 - and
  • 0x2c - sub
  • 0x34 - xor
  • 0xd4 - aad
  • 0x40 - inc
  • 0x48 - dec

Esto deja solo 3 bytes modificables con un máximo de 15 resultados posibles. De estos, un máximo de 9 puede ser distinto (de hecho, ¡esto sucede solo para un conjunto de bytes!). Uno de los valores está fuera de rango, por lo que deja 8 valores. Hay otro conjunto de bytes

34 40 48 b0 c3

que también proporciona 8 valores distintos: los programas son los mismos, excepto que se subreemplazan por xor, lo que hace que dos de las salidas posibles sean idénticas.

Todos los demás conjuntos de bytes dan 7 o menos resultados posibles.

Gelatina , 33 números

Ḥ23+c

Ḥdoble (izquierda);
2literal 2;
3literal 3;
+agregar (izquierda, derecha); y
celija (izquierda, derecha), es decir, varias formas de elegir los objetos correctos de una colección de objetos izquierdos.

Números producidos con un programa de ejemplo:

 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

Traté de elegir los que son fáciles de analizar, pero algunos son raros y un poco extraños, por ejemplo 23es:

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

... y 72y 13utilizar la impresión 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)

Tenga en cuenta que Ḥ34+ctambién produce 33valores únicos en [1,120].

Brain-Flak 1

(())#

Brain-Flak requiere llaves equilibradas, por lo que un programa de 5 caracteres solo es válido si uno de los personajes comienza un comentario. Eso nos deja con 4 personajes para trabajar. De esos, 2 tienen que serlo (y de lo )contrario nada se empujaría a la pila. Esos tienen que ir primero y cuarto con el último comentario ( (..)#). Ahora podemos poner (), {}, <>, o []en el interior. {},, <>y []cada uno evalúa a 0, pero ()es 1. Eso significa que (())#es la única cadena de 5 caracteres que produce un programa Brain-Flak válido.

Pruébalo en línea!

Si la pregunta fuera "cuáles son los 6 personajes más poderosos", la respuesta sería (){}[]que Brain-Flak se está completando usando solo este subconjunto.

Hexagonía , 13 números.

)24!@

Estos son los 13 números imprimibles con un posible programa para cada uno de ellos:

)!@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

Los programas deberían explicarse bastante por sí mismos. @finaliza el programa, !imprime el valor actual, lo )incrementa 2y se 4agrega al valor actual (donde está el valor inicial 0). El diseño hexagonal real del código fuente es irrelevante aquí, los programas simplemente se pueden leer de izquierda a derecha.

Esto debería ser óptimo, aunque en lugar de 2y 4puede elegir cualquier par de dígitos xy ytal 2 ≤ x ≤ y-2.

La solución anterior fue encontrada por la fuerza bruta (casi exhaustiva), requiriendo una !(de lo contrario no imprimiría nada), una @(de lo contrario, el programa no terminará) y llenando los tres caracteres restantes con cualquier combinación (repetida) del siguiente conjunto de caracteres:

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

No puedo ver cómo cualquiera de los otros comandos podría generar más variedad.

Perl, 27 números

3479%

Perl no tiene un REPL incorporado, por lo que puede usarlo re.pldesde 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

Brute-force usando el siguiente 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

No es un gran número, pero puede ser lo mejor que se puede hacer con R. Busqué en todas las combinaciones de dígitos 0..9, operadores + - * / ^y el comentario de caracteres #, y los siguientes ocho arrojaron 18 enteros únicos entre 1 y 120.

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

Como ejemplo, tomemos -#146. Aquí están los 18 enteros que podemos obtener:

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

Si tiene curiosidad sobre el código (feo) utilizado para probar todas las combinaciones posibles, aquí está. Produce el número de enteros únicos entre 1 y 120 para cada combinación de caracteres de longitud 5 en un archivo llamado "archivo de datos" en el directorio de trabajo actual.

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

Octava, 18

Esto se encontró usando una búsqueda de fuerza bruta en los símbolos *+-/0123456789:;<\^|~%. Pero tomó demasiado tiempo calcular ...

-139%

Salidas posibles:

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

Octava, 15 números

No hay mucho de qué jactarse, pero esto es lo mejor que puedo obtener en Octave:

124+%

Da los números:

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

También obtuve 16, pero parece que es idéntico a la respuesta de Sefa ...

1234%

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

PHP, 15 números

1230\r

Utiliza el hecho de que php imprime cualquier cosa fuera de sus etiquetas textualmente (sin usar esto, puede hacer exactamente 1 número con algo así <?=1;). También usa un carácter de retorno de carro real en lugar de\r .

Crea (ordenó, eliminó los ceros iniciales):

 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

de los cuales los números únicos válidos son:

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

Cubix , 7 números

"2)@O

Salidas estos números:

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

Cualquier programa Cubix válido para este desafío debe tener un Oresultado para un entero y un@ final del programa (Cubix nunca ha oído hablar de "errores"). Esto nos da 3 caracteres para jugar y generar la mayor cantidad de resultados. Además, debido a la forma en que Cubix organiza el código en un cubo, el primer carácter será inútil a menos que uno de los otros sea un carácter direccional.

La forma más eficiente que he encontrado para generar múltiples números es usar "para empujar una cadena de códigos de caracteres a la pila. Con un reordenamiento cuidadoso, podemos colocar varios caracteres en el último lugar y simplemente generar sus códigos de caracteres. Mediante el uso) para incrementar el elemento superior, podemos crear salidas adicionales a partir de varios de estos arreglos.

Hay dos tipos de programas básicos en uso aquí. El primero es este:

"2)O@

que se expande a

  "
2 ) O @
  .

El programa resultante empuja 2a la pila, lo incrementa con ), emite Oy termina con @.

El segundo es este:

2")O@

que se expande a

  2
" ) O @
  .

El programa resultante empuja los códigos de caracteres de ), Oy @, incrementa el último con ), emite con O, y termina con @.

> <> , 6 números

Obtuvo 2 números gracias a Teal Pelican

1ln";

Produce los números únicos. [1, 4, 5, 49, 59, 108]

Necesitamos nimprimir un número.
Necesitamos ;terminar.

Eso nos deja solo 3 caracteres para trabajar.

Algunas combinaciones diferentes de value& operatorjunto con "confirmado para producir 6 valores únicos, pero no he encontrado nada mejor que eso.

Groovy, 10 números

Las soluciones de Man JVM son MALAS para esto ... ¿Quién sabía?

1200+

Resultados en:

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

¿Esperar lo? ¿Cómo demonios hace 17 preguntas?

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.

Secreto comercial, en Groovy / Java, los enteros precedidos por un 0 son octales. Código que usé para probar las respuestas de Groovy en caso de que alguien quiera vencerme:

("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%

% es el operador de comentarios, por lo que "cortará" en todos los lugares posibles una vez, lo que ayudará a crear todas las combinaciones posibles de los dígitos y subconjuntos dados:

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

J, 16 números

1234]

Nada lujoso, solo probado 1234con todos los verbos de 1 carácter que eran razonables. ]selecciona su argumento correcto.

Los números únicos producidos son

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

de los cuales 16:

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

Están en el rango [1.120].

Probado con

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

Japt , 41 números

Prácticamente solo prueba y error, por lo que puede haber una mejor solución. Utiliza números enteros 3& 4y los accesos directos Japt para elevar al cuadrado, la adición 1y la multiplicación por 2. Los 120 programas generan un número entero, >0pero solo 78 son <=120y solo 41 de ellos son únicos.

34²ÄÑ

Genera los 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

Ver la lista de números o la colección de programas válidos.

Explicación

Algunas cosas a tener en cuenta sobre Japt que son relevantes aquí son:

1. Si un programa no comienza con (en este caso) uno de los dígitos, la primera variable de entrada U, que por defecto 0es, se inserta automáticamente al principio,
2. Si uno o ambos dígitos siguen inmediatamente uno de los accesos directos para una operación matemática, entonces se agregan a él (por ejemplo 3Ä4 = 3+14 = 17, y, de manera similar 4Ѳ = 4*2**2 = 16), y,
3. Si uno de los dígitos sigue inmediatamente al, ²entonces el ²y todo lo anterior se ignora esencialmente.

Las explicaciones de algunos de los programas (que producen 1, 3, 37y 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

Befunge es un poco limitado porque solo admite literales de un solo dígito. Así que lo mejor que pude encontrar fue 11 números, suponiendo que el cálculo nos deje con un solo número en la pila.

Mejores personajes: 358*%

Números generados: (solo un ejemplo de cada uno)

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#

Utiliza # para comentar todos los números innecesarios.

dc, 19 números

*3zO+

La salida está en la parte superior de la pila y se ignoran los errores (incluido el flujo inferior de la pila) Las permutaciones válidas son:

+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

Aquí está el programa Python que solía mostrar esos 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))

Otras dos cadenas que dan el mismo puntaje de 19 son 32d+*y *4zO+.

Smalltalk, 26 números

1235r

Explicación: 12r35 es una notación para usar radix 12, y por lo tanto es 3 * 12 + 5.
Esto se puede verificar en 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

da:

#(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)

Si reemplazamos la última línea con:

    sorted: #value ascending)

entonces obtenemos las expresiones:

'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

Quería hacer trampa y definir un método r en Integer como

Integer>>r
    ^self \\ 120 + 1

Desafortunadamente, el compilador se corta en 1235r porque reconoce un número inacabado con radix en lugar de un mensaje r enviado a 1235 ...
También podría cambiar fácilmente el compilador, pero es demasiado engañoso para mi gusto.

Mathematica, 16 números

;1234

No es muy interesante, pero parece que no puedo encontrar nada mejor usando aritmética. Lo único que podría funcionar es usar !factorial o factorial doble, pero esto es tan propenso a generar números masivos que es imposible la fuerza bruta.

Los 16 números (en rango) que se pueden generar a partir de los 5 caracteres anteriores son:

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

Encantamientos rúnicos, 19 números

234p@

Esencialmente 3 literales, el operador pow y un comando "imprimir la pila completa y terminar". 234p@imprime 812 (3 ^ 4 concatenado con un 2). Lista de permutación completa , tenga en cuenta que @se ha reemplazado por ak@para generar una nueva línea entre cada resultado y >se ha agregado una para asegurar que cada línea se ejecute de forma independiente. Tenga en cuenta también que las salidas no están en el mismo orden que los programas que las generaron (ya que algunos programas pueden terminar más rápidamente).

Muchas permutaciones no imprimen nada (p. Ej. @234pO p234@), pero 19 dan como resultado una salida dentro del rango permitido.

Números posibles (y un posible programa que resulta en él; .indica que esas posiciones pueden ser cualquiera de los caracteres restantes ya que no se ejecuta):

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!

Lo más probable es que haya una mejor combinación, pero no pude encontrarla.

Todas $24$ Las permutaciones válidas son las siguientes:

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

De los cuales hay $12$ valores únicos:

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