30 idiomas, 248 bytes, 248/30 ^ 3 = 0.009185
#|#?15g,@ kkmNmSaIeoe99+{\#/-;n@0ea
#[9!@>.>.eeaww#-1@*"12" L
#{
###
#`{
25
print(4^2 +7)/2
"""
Jo is here.
$'main'MoO OOM
7
>Jo, 30
>X Jo
f::=~27
::=]##}#(prin 29)
print (7/6*24)###;alert 2#-[>+<-----]>-.|#(write(if(= 1/5 .2)26 3))"""
Editar: Beatnik eliminado ya que las pruebas de primalidad en Beatnik podrían no ser posibles.
El código tiene pestañas (que Stack Exchange destroza) y una nueva línea final, así que aquí está el xxd:
00000000: 237c 233f 3135 672c 4020 2020 0920 2020 #|#?15g,@ .
00000010: 206b 6b6d 4e6d 5361 4965 6f65 3939 2b7b kkmNmSaIeoe99+{
00000020: 5c23 2f2d 3b6e 4030 6561 0a23 5b39 2140 \#/-;n@0ea.#[9!@
00000030: 3e2e 3e2e 6565 6177 7723 2d31 402a 2231 >.>.eeaww#-1@*"1
00000040: 3222 094c 0a23 7b20 090a 2323 230a 2360 2".L.#{ ..###.#`
00000050: 7b0a 3235 0a70 7269 6e74 2834 5e32 202b {.25.print(4^2 +
00000060: 3729 2f32 0a0a 0a22 2222 0a4a 6f20 6973 7)/2...""".Jo is
00000070: 2068 6572 652e 0a24 276d 6169 6e27 4d6f here..$'main'Mo
00000080: 4f20 4f4f 4d0a 2037 0a3e 4a6f 2c20 3330 O OOM. 7.>Jo, 30
00000090: 0a3e 5820 4a6f 0a66 3a3a 3d7e 3237 0a3a .>X Jo.f::=~27.:
000000a0: 3a3d 5d23 237d 2328 7072 696e 2032 3929 :=]##}#(prin 29)
000000b0: 0a70 7269 6e74 2028 372f 362a 3234 2923 .print (7/6*24)#
000000c0: 2323 3b61 6c65 7274 2032 232d 5b3e 2b3c ##;alert 2#-[>+<
000000d0: 2d2d 2d2d 2d5d 3e2d 2e7c 2328 7772 6974 -----]>-.|#(writ
000000e0: 6528 6966 283d 2031 2f35 202e 3229 3236 e(if(= 1/5 .2)26
000000f0: 2033 2929 2222 220a 3))""".
Alternativamente, puede copiar y pegar el código de este "¡Pruébelo en línea!" enlace .
Esto está bastante mal, pero quería jugar con la idea de que, una vez que tienes suficientes idiomas, el conteo de bytes ya no importa tanto. Dicho esto, hay algunos idiomas que aún podría agregar fácilmente (por ejemplo, Objeck) pero actualmente son demasiado largos para ser útiles. Sin embargo, me estoy quedando sin buenos idiomas, así que podría parar aquí por ahora.
Ejecute todos los programas con </dev/null 2>/dev/null(es decir, entrada vacía, STDERR suprimido).
La explicación es bastante larga, así que aquí hay un resumen ejecutivo:
No. Lang. Non-esolang? 2D esolang? BF/BF-deriv?
--------------------------------------------------------------------------
1 COW ✓
2 CoffeeScript ✓
3 Common Lisp ✓
4 Retina
5 Befunge-93 ✓
6 Python 2 ✓
7 Rail ✓
8 ETA
9 Prelude
10 Gol><> ✓
11 evil
12 Foo ✓
13 Ruby ✓
14 ><> ✓
15 Brian & Chuck ✓
16 Whitespace
17 3var
18 Axo ✓
19 Labyrinth ✓
20 Starry
21 Fission ✓
22 Brainfuck ✓
23 Julia ✓
24 Lily ✓
25 GolfScript
26 Chicken Scheme ✓
27 Thue
28 Perl 6 ✓
29 Picolisp ✓
30 TRANSCRIPT
COW es un derivado de Brainfuck con comandos adicionales, uno de los cuales es la salida numérica. Cualquier cosa inválida se ignora, por lo que el programa ejecutado es simplemente
MoO OOM
que incrementa la celda a 1 y luego la imprime como un número.
CoffeeScript ve:
# comments
###
multiline comment
###;alert 2# comment
que simplemente alerta 2.
(Sí, probablemente sería mejor si otro idioma ocupara este lugar, pero soy demasiado vago para reorganizar en este punto: P)
Common Lisp (clisp) ve:
#|
multiline comment
|#(write(if(= 1/5 .2)26 3))"""
1/5es un racional y no igual a 0.2, por lo que se imprime 3. El procedimiento """es un error de sintaxis.
Tenga en cuenta que printparece generar una nueva línea anterior y un espacio final en Common Lisp. Sin embargo, afortunadamente, writefunciona tanto en Common Lisp como en Chicken Scheme.
Restricciones introducidas : cada segunda línea a partir de la primera debe ser una expresión regular válida.
Cada par de líneas forma una etapa de reemplazo, reemplazando instancias de coincidencias de la expresión regular de la primera línea con la segunda línea. En el medio, tenemos el par
"" "
que reemplaza la cadena vacía inicial con """. La última línea vacía, que no forma parte de ningún par, se trata como una etapa de coincidencia, contando el número de coincidencias de la expresión regular. Hay cuatro instancias de cadena vacía """, a saber 1"2"3"4.
Befunge es un lenguaje 2D, y las instrucciones relevantes son
# # 15g,@
en la primera línea, y 5en la 25línea. #omite la siguiente instrucción, 15gobtiene el carácter en la posición (1, 5)en el código (el 5en la 25línea), ,emite el carácter y se @detiene.
Python ve:
# comments
25
print(4^2 +7)/2
"""
multiline string
"""
(4^2+7)/2 = (xor(4,2)+7)/2 = (6+7)/2 = 13/2 = 6, que se printed.
Rail es un lenguaje 2D, y la ejecución comienza desde la $función principal, en dirección sureste. Por lo tanto, la parte relevante del código es
$'main'
7
o
J
con oy Jproveniente de líneas utilizadas por TRANSCRIPT. Después de dar salida a 7, el tren golpea una Jinstrucción no reconocida , que bloquea el programa.
Restricciones introducidas: los caracteres antes del programa ETA no deberían estar incluidos etaoinsh.
ETA solo reconoce las letras etaoinshy sus versiones en mayúscula, lo que significa que el código comienza con
NSaIeoe
n...eempuja un número base 7 basado en lo que está dentro de los delimitadores, que para SaIes 624, o 312 en decimal. oluego sale como char, aparentemente después del módulo 256, dando el char 8(punto de código 56). eluego intenta dividir con una pila vacía, que falla.
Restricciones introducidas: no más de una ()en una columna, ()coincide con la lectura de una columna a la vez, sin bucles infinitos causados por ().
Esto requiere que el intérprete de Python se haya NUMERIC_OUTPUT = Trueconfigurado.
Prelude es un lenguaje donde cada línea se ejecuta por separado. Se ejecutan muchos caracteres, pero la parte importante es el
9!
en la segunda línea, que genera 9. ()en Prelude denota un bucle, pero gracias a la prominencia de #s (que emerge de la pila), las partes superiores de las pilas siempre son 0 cuando se golpea un bucle, por lo que ninguno de ellos se ejecutan. Sin ()embargo, las restricciones del código fuente de Prelude con respecto a la introducción de algunos espacios extraños.
Esta parte (y> <>) funciona como la respuesta de Martin . El código relevante es
# ;n@0ea
Gol> <> es un lenguaje 2D y #refleja la IP, por lo que viaja hacia la izquierda. Se envuelve, empuja 10, 14 y 0 a la pila. @luego gira la pila, colocando 10 en la parte superior, la ngenera y ;detiene el programa.
Esta parte también es similar a la respuesta de Martin.
el mal ignora todo excepto las letras minúsculas. Ignorando algunos caracteres más, la parte relevante es
aeeeaeeaww
donde aincrementa la variable A, ees la función de tejido del mal que baraja los bits Ay las wsalidas A. Por lo tanto, producimos 1dos veces, dando 11.
Pero, ¿qué pasa con el resto de las instrucciones, y especialmente eso wen la última línea? Digamos que a veces es más fácil meterse con el código y rezar para que todavía funcione en todo lo que, aquí, de alguna manera funcionó ...
Foo genera cualquier cosa entre comillas dobles, por lo que la parte relevante es
"12"
en la segunda linea. Sin embargo, dado que necesitamos comillas dobles más adelante, usamos un método similar a la respuesta de Martin para detectar el error de Foo, a saber, el anterior #-1@. No está claro por qué eso funciona en un lenguaje en el que los soldados se enfrentan a la pila vacía y la división por cero errores, pero me alegro de que lo haga.
Al igual que Python, Ruby ve:
# comments
25
print(4^2 +7)/2
"""
multiline string
"""
Sin embargo, vale la pena señalar que la cadena de varias líneas es en realidad tres cadenas separadas ( "", "...", "") concatena juntos. La línea de impresión (4^2+7) = xor(4,2)+7 = 6+7 = 13sale, antes de equivocarse tratando de dividir nilpor 2.
Esta parte es igual que la parte Gol> <>, excepto que @lleva el 14 a la parte superior, que se genera.
Brian & Chuck es un derivado BF con dos cintas, donde el puntero de instrucción de una cinta es el puntero de memoria de la otra cinta. En ausencia de ```, las dos primeras líneas del código fuente se utilizan para inicializar las cintas.
Los caracteres relevantes en las dos primeras líneas son:
?15
# >.>.
La ?cinta de Brian pasa el control a Chuck en la celda a la que apunta (la #) no es cero. Chuck luego se ejecuta >.>., generando los dos caracteres después del signo de interrogación.
Utilizando STLespacio, tabulación y avance de línea respectivamente, el inicio del programa es:
SSSTSSSSL
TL
STL
L
L
La primera línea empuja 16 ( +10000base 2), la anterior lo TLSTimprime como un número. Las siguientes tres nuevas líneas detienen el programa.
Tenga en cuenta, sin embargo, que este programa es específico del intérprete. El resto de los errores de sintaxis del código en la mayoría de los intérpretes, por lo que se requiere un intérprete más indulgente, como el que se vincula anteriormente.
De la primera línea, se ejecutan una serie de instrucciones, pero las relevantes son
kkmmao#/
Debido a la restricción de ETA, usamos kpara disminuir la variable B en lugar de aincrementarla. kkdisminuye B a -2 y los mmcuadrados B dos veces a 16, que se incrementa a 17 con a. Esto se emite con o.
#luego se usa para restablecer B a 0 y /hace que el programa produzca un error a través de la división por 0.
Restricciones introducidas: no hay instrucciones antes del programa Axo que cambien la dirección de la IP
Una vez más, una serie de instrucciones se ejecutan en la primera línea, pero las relevantes son
# # 15 ,@ 9 9 + { \
Axo es un lenguaje 2D como Befunge, y de #manera similar es un puente que omite la siguiente instrucción, pero solo si la parte superior de la pila es cero. 15,empujar a la pila, pero la pila se vacía @. 99+luego empuja 18, {sale y se \detiene.
Labyrinth es otro lenguaje 2D, y las instrucciones ejecutadas son
#|#
[9!@
#empuja la longitud de la pila, que es 0 la primera vez. |es bit a bit O, no cambia nada, ya que la pila solo tiene 0s en este punto, y el segundo #ahora empuja 1 debido al cero solitario. Giramos a la derecha debido al 1, 9convierte este 1 a 1*10+9 = 19, lo !imprime y se @detiene.
Este programa se basa en el hecho de que [actualmente no es una instrucción reconocida y, por lo tanto, se trata como un muro.
Restricciones introducidas: todos los +s deben tener al menos un espacio anterior
Si eliminamos los caracteres no reconocidos, la parte relevante del código es
, +.. +
,es entrada, pero dado que canalizamos desde /dev/nullallí no hay ninguno, empujando 0 a la pila. A +con n >= 5espacios anteriores empuja n-5, por lo que la siguiente instrucción empuja 2. ..luego genera estos dos dígitos en orden inverso.
A continuación tenemos un +con un solo espacio precedente, que se duplica. Sin embargo, la pila está vacía, por lo que nos equivocamos.
La única parte relevante para Fission es
*"12"L
L genera un átomo que se mueve hacia la izquierda, "21" imprime 21 y se *detiene.
Restricciones introducidas: no. antes de la primera[
Esto requiere un intérprete que dé 0 en EOF y tenga celdas de 8 bits. El código relevante es
,+-[>.>.-+.>,>]-[>+<-----]>-..
El inicio -es para compensar el +, y el primero [...]no se ejecuta ya que la celda es 0. Lo siguiente -[>+<-----]>-establece la celda en el código char de2 y la ..genera dos veces.
Julia ve:
# comments
25
print(4^2 +7)/2
Lo que está impreso es 4^2+7 = pow(4,2)+7 = 16+7 = 23 , y el programa comete errores al tratar de dividir nothingentre 2. Tenga en cuenta que a Julia no parece importarle el hecho de que el resto del código causaría un error de sintaxis de todos modos.
Lily ve:
# comment
#[
multiline comment
]## comment
print (7/6*24)# comment
7/6*24 = 1*24 = 24 está impreso.
GolfScript ve:
# comments
25
print(
GolfScript se basa en la pila, por lo que se empuja 25 a la pila, luego se saca e imprime con print.(luego intenta disminuir la cadena vacía implícita en la pila, que falla y produce errores en el programa.
Chicken Scheme tiene la misma #| ... |#sintaxis de comentarios multilínea que Common Lisp. Sin embargo, en
(write(if(= 1/5 .2)26 3))
1/5es un flotador que es igual a 0.2, por lo que se genera 26.
Thue es un lenguaje basado en la reescritura de cadenas. La primera parte relevante es
f::=~27
::=
que define una sustitución f -> 27luego denota el final de las sustituciones con ::=. El solitario fen ifse reemplaza con27 , que es enviada.
Perl 6 tiene una nueva sintaxis de comentarios, #`(some bracket)que es un comentario de varias líneas hasta el paréntesis correspondiente. Por lo tanto, Perl 6 ve:
# comments
#`{
multiline comment
}# comment
print (7/6*24)# comment
que imprime 7/6*24 = 28 .
Picolisp ve:
# comment
#{
multiline comment
}#(prin 29)
que imprime 29. La línea posterior provoca un error de sintaxis.
TRANSCRIPT es un esolang temático modelado a partir de aventuras de texto. Las líneas no reconocidas se ignoran (lo que le permite agregar texto de historia / sabor adicional entre las instrucciones del código real), por lo que las líneas relevantes son:
Jo is here.
>Jo, 30
>X Jo
La primera línea declara una variable de cadena Jo, usando un nombre de dos letras ya que los nombres de una letra parecen fallar. La segunda línea establece esta cadena en "30", que es emitida por X("examinar") en la tercera línea.
2.7.1a2.7.n. (En realidad, sweerpotato hace exactamente eso con las versiones principales)