¿Cuáles son los cinco caracteres más poderosos en tu idioma?

101

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.

Pasatiempos de Calvin
fuente
21
¡Quiero hacer este desafío pero parece IMPOSIBLE en clenguajes similares!
Mukul Kumar
3
@MukulKumar Creo que también hay REPL en lenguaje similar a C (por ejemplo, gdb puede usarse, hasta cierto punto, como REPL para C), de modo que el enfoque demostrado para Python todavía sería una opción.
Martin Ender
1
Relacionados (enlace fijo).
Fatalize
3
@ETH No a lo verdadero. Eso es como permitir otra base.
Aficiones de Calvin
3
@ OldBunny2800 Las salidas válidas deben ser deterministas e invariables en el tiempo.
Dennis

Respuestas:

41

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
Yytsi
fuente
2
¿No obtendrías mejores resultados en Python 2, donde /está la división de enteros?
Neil
@Kade Me también. Lo más grande que probé fue algo en las líneas de "0123456789 * - + & |% ^ 0123456789"
Yytsi
Hay 2 alternativas más para esto, resultando el mismo número de valores: 5679%y5789%
Gábor Fekete
FYI: esto (o los 5679%y 5789%unos) probablemente también sean óptimos para PowerShell.
AdmBorkBork
Obtuve esta respuesta (junto con 5679%y 5798%) también a través de una búsqueda exhaustiva en todas las combinaciones de 0123456789+-*/&|^#%con reemplazo. Estoy de acuerdo en que estos son probablemente óptimos.
JaredL
34

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.

Emigna
fuente
¿No lo he probado, pero usaría en -lugar de +producir una variedad más amplia de resultados en función de su propiedad no conmutativa?
Osable
@Osable: también lo he probado -, pero nunca obtuve más de 30 números únicos. Un problema es que también obtienes valores negativos que están fuera del rango. Quizás con algunos otros operadores reemplazados podría ser mejor, pero no he encontrado una mejora hasta ahora.
Emigna
Correcto, salté la parte (aunque en negrita) diciendo que la salida debe estar dentro del rango [1,120]. Mi mal
Osable
Lo intenté por un tiempo y terminé como ~ 35 en todo lo demás.
Urna de pulpo mágico
32

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.

León
fuente
25
@ TùxCräftîñg En realidad no lo es, un conjunto es una colección desordenada.
Leo
2
@ TùxCräftîñg https://repl.it/El9V/0, por supuesto, los conjuntos utilizan una clasificación interna para realizar un seguimiento de los elementos, el punto es que no puede confiar en esta clasificación, ya que los elementos no están necesariamente ordenados en el orden en que lo haría esperar que lo sean
Leo
1
@ TuukkaX Veo que este es un comportamiento inesperado y causa más problemas de los que resuelve, así que lo edité. Disculpe las molestias :)
Leo
1
@ hBy2Py Si no realiza ninguna otra operación en el conjunto entre las dos iteraciones, creo que puede suponer que las dos iteraciones seguirán el mismo orden. Sin embargo, en el caso general, la regla es que los conjuntos son colecciones desordenadas, por lo que nunca debe confiar en que tengan ningún tipo de orden.
Leo
3
@Leo Entendido: los conjuntos son de nitroglicerina. Razonablemente estable a menos que los golpee.
hBy2Py
23

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!

Xanderhall
fuente
2
¿Java tiene un REPL? Tal vez puedas usar más símbolos de esta manera
Arturo Torres Sánchez
No tengo idea. Me inclino a decir que no. Además, mi respuesta se convertiría básicamente en una copia de las otras respuestas de REPL: P
Xanderhall
3
¡Java 9 tendrá un REPL de vainilla ! Pero por ahora estamos atrapados con cosas de terceros .
NonlinearFruit
17
Creo que puedes hacerlo mejor n->12. Esto le da cuatro respuestas distintas que son todo dentro de la gama: n->12, n->21, n1->2, n2->1.
2
Java 9 y su REPL están disponibles en una versión de acceso temprano hoy. De hecho, he enviado respuestas a otras preguntas aquí usándolo.
David Conrad
18

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


fuente
@TuukkaX lo hace, implementé tanto la monádica Œ¿como la diádica œ¿(ver cerca de la parte inferior de la página de átomos de Wiki ), pero ambas son díadas de 2 bytes, lo que reducirá las permutaciones de código que hacen lo que quieres, además necesitarías todas sus entradas para ser listas ( 12no es una lista).
Jonathan Allan
16

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
Arnauld
fuente
¿usaría bitwise no ~ayuda? Es una operación unaria que puede ser útil.
JollyJoker
1
@JollyJoker Bueno, lo mejor que puedo encontrar hasta ahora ~es 257&~que produce 11 valores distintos.
Arnauld
Estoy un poco sorprendido, pero supongo que mi intuición no es muy buena aquí.
JollyJoker
15

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

Fatalizar
fuente
1
Buena respuesta e Idk cualquier cosa sobre el golf, pero en el lado de las matemáticas puedes obtener cualquier número hasta 121 simplemente sumando o sustituyendo las primeras cinco potencias de 3. 1,3,9,27 y 81. Espero que ayude.
shyos
11

Vim, 16 números

i1234

impresión

1, 2, 3, 4, 12, 13, 14, 21, 23, 24, 31, 32, 34, 41, 42, 43
Sefa
fuente
1
@ymbirtt ¿Dónde fue el 3y el 4ir? Necesita todas las permutaciones de longitud 5.
Kade
i1234imprime "1234", ¿se trata de algún tipo de secuencia de comandos o pulsaciones de teclas? Si se presiona una tecla, no funciona.
Capitán Man
Ampliando el punto de @Captain Man, la forma obvia de ejecutar las permutaciones como un script sería con: norma. Sin embargo, eso no imprime ningún número en el rango 1-120. ¿Tenías otro método en mente?
Simon
Puede ponerlos en el intérprete en línea para V, que es más o menos compatible con Vim
nmjcman101
44
@ nmjcman101 En este caso, cae en el agujero de "en su mayoría" ya que 12i34 en V da como resultado 12 ocurrencias de 34 donde, como si lo escribes en vim, solo te da 34 (supongo que V asume una esc final)
Sefa
11

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.

anatolyg
fuente
10

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

Jonathan Allan
fuente
10

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.

Riley
fuente
Una característica mal documentada: el @ijindicador de depuración detiene el programa y permite al usuario ingresar el código de brain-flak para que se ejecute donde @ijapareció el indicador en el código. Bastante potente, pero desafortunadamente requiere la intervención del usuario, por lo que no es útil aquí.
0 '
Corrección leve: (){}[]obtendría 0. Olvidó la regla de permutaciones;)
CalculatorFeline
8

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.

Martin Ender
fuente
Iba a publicar una respuesta de Labyrinth también, pero el mismo conjunto de soluciones parece ser óptimo allí también (con la misma semántica efectiva).
Martin Ender
7

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;
}
ThisSuitIsBlackNot
fuente
Perl en realidad tiene algo muy parecido a un REPL incorporado. Intenta correr un perl -de 1poco de tiempo. Esto técnicamente abre el depurador en un programa vacío, pero el depurador tiene un REPL-like incorporado. Desafortunadamente, necesita escribir p al comienzo de cada línea para que realmente imprima el resultado.
@ ais523 Por eso no lo mencioné; no puede simplemente escribir la cadena en sí y obtener la salida, que es uno de los requisitos.
ThisSuitIsBlackNot
7

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)
      }
)
rturnbull
fuente
Dices que es un código feo ... ¡Creo que es hermoso! ¡Los múltiples usos de apply nunca dejan de sorprenderme!
Sumner18
6

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
falla
fuente
5

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
Stewie Griffin
fuente
Según mis pruebas, la elección óptima de 0123456789+-*.%por octava es 139-%, que produce una matriz de 18: 1 2 3 4 6 8 9 13 16 19 22 31 38 39 88 91 92 93. Para que pueda obtener otros 3 números :)
2
fuerza bruta muy cruda que usé para obtener la solución de 18 números: pastebin.com/umckG0VS
2
También encontré esa solución, pero eso fue después de ver el envío de Python y es esencialmente lo mismo. Buen trabajo molesto para hacer un guión de fuerza bruta. 😊
Stewie Griffin
4

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
usuario59178
fuente
3
Sin embargo, eso realmente no imprime esos números. 12\r30imprime 12\r30, el terminal simplemente sobrescribe los dos primeros caracteres.
Dennis
@Dennis Eso es como decir que en cualquier desafío que requiera la técnica de caracteres de control para sobrescribir el texto, la salida no es lo que se ve al final, sino la suma de los bytes escritos. Como \rno es imprimible, la salida de 12\r30es 30.
gato
3
@cat De hecho, hemos discutido esto en meta ; el uso de caracteres de control solo está permitido si el desafío está relacionado con el arte ASCII.
Dennis
4

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

ETHproducciones
fuente
3

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

Emigna
fuente
He estado tratando de resolver esto, pero ¿esto no solo produce 4 números? como el rango es 1-120 no 0-120?
Teal pelican
@ Tealpelican: Correcto. Me di cuenta de esto en el camino a casa desde el trabajo y estaba a punto de arreglarlo.
Emigna
He echado un vistazo a algunos programas más de peces como quines y hello world, etc. y tuve una idea. Algo usando los personajes como este; 1n; + "generaría 6+ a partir de un cálculo rápido (utilizando nuestra función de bucle y cadenas para nuestra ventaja) - podría valer la pena verificar con diferentes valores para 1 y operaciones.
Teal pelican
@ Tealpelican: Esa es una buena idea.
Emigna
3

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();​
Urna de pulpo mágico
fuente
Supongo que la misma respuesta también funcionaría para Java.
Paŭlo Ebermann
3

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
Cedric Reichenbach
fuente
3

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]'
Bolce Bussiere
fuente
3

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
Lanudo
fuente
2

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
James Holderness
fuente
2

Python, 16 números

1234#

Utiliza # para comentar todos los números innecesarios.

OldBunny2800
fuente
2

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

Toby Speight
fuente
2

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.

aka.nice
fuente
1

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
Martin Ender
fuente
¿Por qué no; 6789?
David G. Stork
1

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
Draco18s
fuente
1

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,dieciséis,26,30,36,45,47,48,51,56,74

Tau
fuente