Escriba un fragmento de código que sea ejecutable en al menos tres idiomas diferentes. El código debe mostrar el número entero 1en el idioma número uno, 2en el idioma número dos, 3en el idioma número tres, etc.

Reglas:

• El resultado debe ser solo el entero, pero las líneas nuevas finales están bien.
• El código no puede recibir información de ningún tipo.
• Las diferentes versiones principales del mismo idioma se consideran únicas. Por lo tanto, su código puede ser ejecutable en Python 2 y Python 3, sin embargo, Python 2.5 y Python 2.7 no se consideran únicos.
• Puede usar un nuevo idioma si y solo si tiene un artículo de esolang / wiki, intérprete disponible y documentación, y ha sido utilizado por al menos dos usuarios en PPCG antes de usarlo en este desafío. También debe cumplir con estas 4 reglas .

El puntaje de su envío es el número de bytes en su código dividido por el número de idiomas que puede ejecutar en cubos. Por lo tanto, una solución de 54 bytes que es ejecutable en 3 idiomas tendrá una puntuación de 2:

54 / 3^3 = 2  

Puntaje más bajo es mejor.

Tabla de clasificación

<style>body { text-align: left !important} #answer-list { padding: 10px; width: 290px; float: left; } #language-list { padding: 10px; width: 290px; float: left; } table thead { font-weight: bold; } table td { padding: 5px; }</style><script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="language-list"> <h2>Shortest Solution by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr> </thead> <tbody id="languages"> </tbody> </table> </div> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr> </thead> <tbody id="answers"> </tbody> </table> </div> <table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table><script>var QUESTION_ID = 65641; var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe"; var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk"; var OVERRIDE_USER = 31516; var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page; function answersUrl(index) { return "https://api.stackexchange.com/2.2/questions/" + QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER; } function commentUrl(index, answers) { return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER; } function getAnswers() { jQuery.ajax({ url: answersUrl(answer_page++), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { answers.push.apply(answers, data.items); answers_hash = []; answer_ids = []; data.items.forEach(function(a) { a.comments = []; var id = +a.share_link.match(/\d+/); answer_ids.push(id); answers_hash[id] = a; }); if (!data.has_more) more_answers = false; comment_page = 1; getComments(); } }); } function getComments() { jQuery.ajax({ url: commentUrl(comment_page++, answer_ids), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { data.items.forEach(function(c) { if (c.owner.user_id === OVERRIDE_USER) answers_hash[c.post_id].comments.push(c); }); if (data.has_more) getComments(); else if (more_answers) getAnswers(); else process(); } }); } getAnswers(); var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d?\.?\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/; var OVERRIDE_REG = /^Override\s*header:\s*/i; function getAuthorName(a) { return a.owner.display_name; } function process() { var valid = []; answers.forEach(function(a) { var body = a.body; a.comments.forEach(function(c) { if(OVERRIDE_REG.test(c.body)) body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>'; }); var match = body.match(SCORE_REG); if (match) valid.push({ user: getAuthorName(a), size: +match[2], language: match[1], link: a.share_link, }); else console.log(body); }); valid.sort(function (a, b) { var aB = a.size, bB = b.size; return aB - bB }); var languages = {}; var place = 1; var lastSize = null; var lastPlace = 1; valid.forEach(function (a) { if (a.size != lastSize) lastPlace = place; lastSize = a.size; ++place; var answer = jQuery("#answer-template").html(); answer = answer.replace("{{PLACE}}", lastPlace + ".") .replace("{{NAME}}", a.user) .replace("{{LANGUAGE}}", a.language) .replace("{{SIZE}}", a.size) .replace("{{LINK}}", a.link); answer = jQuery(answer); jQuery("#answers").append(answer); var lang = a.language; lang = jQuery('<a>'+lang+'</a>').text(); languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang.toLowerCase(), user: a.user, size: a.size, link: a.link}; }); var langs = []; for (var lang in languages) if (languages.hasOwnProperty(lang)) langs.push(languages[lang]); langs.sort(function (a, b) { if (a.lang_raw > b.lang_raw) return 1; if (a.lang_raw < b.lang_raw) return -1; return 0; }); for (var i = 0; i < langs.length; ++i) { var language = jQuery("#language-template").html(); var lang = langs[i]; language = language.replace("{{LANGUAGE}}", lang.lang) .replace("{{NAME}}", lang.user) .replace("{{SIZE}}", lang.size) .replace("{{LINK}}", lang.link); language = jQuery(language); jQuery("#languages").append(language); } }</script>

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

1. VACA

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.

2. CoffeeScript (incluye intérprete)

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

3. Lisp común | ideona

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.

4. Retina | Pruébalo en línea!

^{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.

5. Befunge-93 | Interprete

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.

6. Python 2 | ideona

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.

7. Rail | Pruébalo en línea!

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.

8. ETA | Pruébalo en línea!

^{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.

9. Preludio | Pruébalo en línea!

^{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.

10. Gol> <> | Interprete

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.

11. maldad | Pruébalo en línea!

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

12. Foo | Pruébalo en línea!

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.

13. Ruby | ideona

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.

14. > <> | Pruébalo en línea!

Esta parte es igual que la parte Gol> <>, excepto que @lleva el 14 a la parte superior, que se genera.

15. Brian y Chuck | Pruébalo en línea!

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.

16. Espacio en blanco | Interprete

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.

17. 3var | Pruébalo en línea!

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.

18. Axo | Pruébalo en línea!

^{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.

19. Laberinto | Pruébalo en línea!

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.

20. estrellado | Pruébalo en línea!

^{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.

21. Fisión | Pruébalo en línea!

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.

22. Brainfuck | Pruébalo en línea!

^{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.

23. Julia |Pruébalo en línea!

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.

24. Lily | Interprete

Lily ve:

# comment
#[
multiline comment
]## comment
print (7/6*24)# comment

7/6*24 = 1*24 = 24 está impreso.

25. GolfScript | Pruébalo en línea!

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.

26. Esquema de pollo |ideona

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.

27. jue | Pruébalo en línea!

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.

28. Perl 6 | ideona

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 .

29. Picolisp | ideona

Picolisp ve:

# comment
#{
multiline comment
}#(prin 29)

que imprime 29. La línea posterior provoca un error de sintaxis.

30. TRANSCRIPCIÓN | Pruébalo en línea!

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.

15 idiomas, 68 66 65 bytes / 15 ^ 3 = 0.019 ...

Retina , Starry , Prelude , ETA , Axo , Labyrinth , Hexagony , Foo , Brian & Chuck , Gol> <> , evil , Whitespace , Fission , > <> y GolfScript .

Después de una reescritura masiva, logré encajar en cuatro idiomas más. El código contiene las pocas pestañas para espacios en blanco. Como Stack Exchange los convierte en espacios, los he representado a \tcontinuación:

#I5aeeNTH{\?      \t\t + +3;n@"8"ea9
15}7'`--~!@<"31"LSOe.\t
 \teaww`

Creo que he terminado de agregar idiomas (aunque agregar solo uno podría ahorrar algunos bytes en lo que ya tengo). Sin embargo, me pregunto si es golfable ... 65 bytes para 15 idiomas es un salto de 32 bytes para 11 idiomas, y ahora tengo al menos un carácter inútil para que Foo funcione ...

Impresiones de retina 1

Pruébalo en línea.

Afortunadamente, la primera línea es una expresión regular válida. Sin embargo, esa expresión regular obviamente no coincide con la entrada vacía, por lo que la primera etapa (que consta de las dos primeras líneas) no hace nada.

La tercera línea es independiente, por lo que se trata como una etapa Match que, de forma predeterminada, cuenta el número de coincidencias. Sin embargo, `es un separador que le dice a Retina que la parte que se encuentra frente a él es una cadena de configuración (no conoce ninguna de las opciones que se ofrecen allí) y la parte posterior es la expresión regular. Entonces la expresión regular está vacía y Retina encuentra exactamente una coincidencia.

Impresiones estrelladas 2

Pruébalo en línea.

Starry ignora todo excepto espacios y +*,'`.. Cada comando es uno de esos caracteres junto con los espacios desde el último de esos caracteres. Entonces, eliminemos todo el código extraño:

       + +'`. `

Siete espacios seguidos de +empujes a 2. Un espacio seguido de un +duplicado. 'Es un salto condicional. Aparece en la parte superior de la pila, lo cual es verdadero (positivo), por lo que salta a la etiqueta correspondiente (donde las etiquetas se indican con `y "correspondiente" significa "con el mismo número de espacios iniciales"), que es el primero `. .sin espacios delante, imprime la parte superior de la pila como un número.

Preludio de impresiones 3

Pruébalo en línea.

Esto supone el intérprete de Python que usa salida numérica. Eliminemos todos los no-ops:

# 5        ?         + +3    8   9
15 7  -- !   31

La primera voz hace un montón de cosas, pero nada de eso importa, porque no hay !que imprimir ninguno de los resultados. La segunda voz empuja a 1, luego a 5, luego a 7. Tomamos la diferencia de los dos últimos para obtener -2, y luego restamos eso 1para obtener 3. !lo imprime La tercera voz solo tiene no-ops.

Impresiones de ETA 4

Pruébalo en línea.

ETA ignora todo excepto los caracteres ETAOINSH(en cualquier caso). Entonces, el código visto por ETA es:

IaeeNTHneaSOeea

Iintenta leer la entrada pero no puede, así que empuja -1. aempuja el número de línea actual más 1, que es 2. ees divmod , que reemplaza aquellos con 0y 1(o -1, en realidad no lo sé, pero no importa). El siguiente ereemplaza a ambos con 0.

Ahora la parte interesante. NTHnees un literal de base 7 número. Ny eson solo los delimitadores, y los tres dígitos son THN. Es decir 54(donde Tes dígito 1, Hes 0y nes 5). aempuja 2una vez más. Slo resta, lo que da 52como Oresultado y lo genera como un carácter ( 4). Ahora eintenta divmod nuevamente, pero la pila contiene dos ceros, por lo que el programa termina con un error (pero no contamina STDOUT mientras lo hace).

Impresiones Axo 5

Pruébalo en línea.

Este lenguaje fue prácticamente responsable de la reescritura. No pude tener el }en la primera línea porque bloquearía la entrada en Axo (vea el historial de revisiones de lo que estoy hablando). Para Axo, solo esta parte del código es relevante:

#I5aeeNTH{\

Afortunadamente, Axo también tiene 0s implícitos en la parte inferior de su pila, porque #abre la parte superior de la pila (para verificar si la siguiente instrucción debe omitirse o no). Las letras son todas no-ops. Luego 5empuja un 5, lo {imprime, \finaliza el programa. Muy simple, de verdad.

Impresiones de laberinto 6

Pruébalo en línea.

Estoy truncando el código un poco, porque nunca se alcanza la mitad derecha, y también estoy usando ten lugar de \t, para que las columnas se alineen correctamente:

#I5aeeNTH{\
15}7'`--~!@
 teaww`

Ahora que las letras, los espacios y las pestañas son paredes en Labyrinth, el código accesible se ve así:

# 5      {\
15}7'`--~!@
      `

El puntero de instrucciones seguirá automáticamente ese camino. #empuja la profundidad de la pila principal ( 0) y la 15convierte en a 15. }lo mueve a la pila auxiliar, y ya no lo vamos a usar. Eso convenientemente hace que la parte superior de la pila sea cero, de modo que la IP no gire a la izquierda en la 5. 7convierte el cero en a 7, 'es un no-op. La `negación es unaria, así que lo entendemos -7. Ahora -resta lo -7implícito 0debajo de hacerlo 7. Esta vez, el IP gira a la derecha hacia el `, lo cual es una negación unaria, así que volvemos 7. La IP llega a un callejón sin salida. los- hace lo mismo que antes, por lo que tenemos7una vez más. Como la parte superior de la pila ahora es positiva, la IP gira a la derecha. Hay otro -que da de -7nuevo. Entonces ~es bit a bit NO, lo que da 6e !imprime. Ese es el momento justo para hacerlo, porque ahora la pila está vacía de nuevo, de modo que la IP no gire a la izquierda en el {sino que continúa directamente hacia el @que termina el programa.

Impresiones hexagonales 7

Pruébalo en línea.

El código desplegado se ve así:

     # I 5 a e
    e N T H { \
   ? + + 3 ; n @
  " 8 " e a 9 1 5
 } 7 ' - - ~ ! @ <
  " 3 1 " L S O e
   . e a w w . .
    . . . . . .
     . . . . .

Normalmente, ese sería un programa aterrador de Hexagony, pero los personajes que están en uso no son demasiados. De hecho, son más o menos los mismos que los utilizados por Laberinto y creo que la forma en que diferenciar entre 5y 6es bastante agradable. :)

La fila superior se puede ignorar básicamente. #normalmente cambiaría a una IP diferente, pero el borde de memoria actual es 0, por lo que no lo hace. Las letras solo establecen un valor de memoria fijo, pero no lo vamos a usar. Después del final de la primera fila, el flujo de control continúa en la fila central (comenzando desde la }derecha). Los }movimientos a otro borde de memoria. 7establece esa ventaja en 7. 'regresa a donde venimos. -resta el borde de la memoria que acabamos de establecer 7de un borde de memoria no utilizado ( 0), por lo que obtenemos -7. Lo siguiente no es NO bit a bit sino negación unaria en Hexagony. Entonces esto da en lugar de . , como en Labyrinth, imprime el valor y finaliza el programa.- vuelve a hacer lo mismo, por lo que es un no-op. Hasta ahora, bastante similar a Labyrinth (aparte del diseño de memoria). Pero ahora~76!@

Impresiones foo 8

Pruébalo en línea.

Como todos sabemos, ya que The Programming Language Quiz imprimir cosas es bastante trivial en Foo, incluso si la mayor parte del código es una mezcla aleatoria de caracteres. Ninguno de los caracteres afecta la salida, excepto el "8"que imprime 8. Bueno, está el "31"posterior, pero Foo termina con un error al final de la primera línea. No estoy exactamente seguro de por qué sucede eso, pero requiere eso 3(o cualquier otro dígito) en la fila superior, que no se usa en ningún otro lugar.

Impresiones de Brian y Chuck 9

Pruébalo en línea.

Hagamos esto nuevamente cuando eliminemos la tercera línea (nunca se analiza) y reemplacemos todos los caracteres irrelevantes (es decir, sin operaciones o celdas que no se leen) con espacios:

         { ?         + +         9
  }   --   <        .

Solo como recordatorio, cada línea es un Brainfuck cuya cinta es el código fuente del otro programa. El flujo de control comienza en la primera línea (llamada Brian).

Luego, {mueve el cabezal de la cinta completamente hacia la izquierda (donde ya está), y las ?manos controlan el flujo hacia Chuck (la segunda línea). Allí, }mueve el cabezal de la cinta hacia la derecha hasta que encuentra una celda cero. Eso no sucede hasta el final del programa, por lo que el cabezal de la cinta termina una celda después del 9. -disminuye esa celda, pero eso es irrelevante. <mueve el cabezal de la cinta al 9e .imprime. Chuck se queda sin programa y termina.

Gol> <> impresiones 10

Probado aquí.

#es un espejo, por lo que la IP salta inmediatamente al final de la primera línea (y se va hacia la izquierda). El 9puede ser ignorado. aempuja 10, eempuja 14, "8"empuja el código de caracteres de 8, @gira los tres elementos superiores de la pila (tirando hacia arriba 10), de modo que nimprime 10y ;termina el programa.

Gracias a Sp3000 por sugerir usar en @lugar de !(que guardó un byte).

impresiones malvadas 11

Gracias a Sp3000 por enviarme algunas listas de comandos con fuerza bruta para generar números de un solo dígito.

Pruébalo en línea.

evil ignora todo excepto las letras minúsculas, por lo que el código se ve así:

aeeneaeeaww

Además, nafecta a un estado que no nos importa, así que ignoremos eso también. Ahora aincrementa el registro (que comienza en 0), y ees la operación mágica de "tejido" del mal que permuta los bits de una manera particular. aeeeaeeapasa a producir el valor 49que es el código de caracteres de 1. wwlo imprime dos veces

Impresiones de espacios en blanco 12

Pruébalo en línea.

Bien, sabemos que Whitespace solo lee espacios, pestañas y saltos de línea, así que dejemos de escribir el código como lo ve Whitespace con STL:

SSSSSSTTSSLTLST

Eso son dos comandos:

SSSSSSTTSSL
TLST

El primero empuja el número 12. Específicamente, SScomienza un número literal. El siguiente Ses el bit de signo (positivo). Entonces todo hasta el Les una representación binaria del número. Hay un montón de ceros a la izquierda, que necesitamos para Starry, pero no afectan el número. Entonces la TTSSs está 12en binario. Dato curioso: si agrego un decimosexto idioma, podría guardar un byte aquí, porque Starry podría usar los cuatro Sen la represión binaria de 16. Aunque dudo que lo haga ...

El TLSTsolo imprime la parte superior de la pila como un número. ( TLmarca el comando como un comando de E / S y STestá imprimiendo números).

Impresiones de fisión 13

Pruébalo en línea.

La fisión solo ve esta parte del código:

           <"31"L

Lcomienza el flujo de control con un átomo a la izquierda. "alterna el modo de impresión, de modo que 31solo se imprime 13. Luego, el átomo se captura en la cuña del <, que termina el programa.

> <> impresiones 14

Probado aquí.

Distinguir entre> <> y Gol> <> no es tan fácil como pensaba, porque Gol> <> casi siempre hace lo mismo que> <> para los comandos que existen en ambos, y los comandos que solo existen en Gol> < > causa> <> bloquearse. Sin embargo, @gira al revés en> <>, de modo que empuja hacia abajo en 7lugar de tirar hacia arriba 10y luego 14se imprime en lugar de 10.

Impresiones de GolfScript 15

Pruébalo en línea.

Este es el más simple: #comenta la primera línea. Luego se 15empuja y }es un "super comentario", que ignora todo el resto del programa. Entonces 15se imprime al final del programa.

Python 1.x, 2.xy 3.x, 32 bytes / 3 ^ 3 = 1.1851 ...

import sys
print(sys.version[0])

Imprime el primer número de la versión, que está 1en Python 1.x, 2en Python 2.xy 3Python 3.x.

Cuando lleguemos a Python 9.x, ¡mi puntaje será glorioso 0.04389!

: ~)!

3 idiomas, 2 bytes / 27 = 0.074

1P

Bueno, al menos supera la mitad de las presentaciones: P

1. GolfScript

GolfScript ignora el P, generando solo el 1. Pruébelo en línea .

2. Par

Pes 2 al poder de, entonces 1P = 2^1 = 2. Pruébalo en línea .

3. En serio

Pda la enésima prima, cero indexado. Tenemos 3 ya que ese es el segundo primo. Pruébalo en línea .

Notas

Mi objetivo inicial era encontrar una respuesta válida en 1 byte. Mi primer intento fue \x12con Bubblegum y gs2 , pero el desafío requiere un mínimo de tres idiomas. \x13funcionaría si hay un idioma en el que la salida 1.

Renunciando a una respuesta de 1 byte, me mudé a dos bytes. 3ues una llamada cerrada , que genera 1 en Japt , 3 en GolfScript y 4 en serio, pero fue difícil encontrar un lenguaje que generara 2 para llenar el vacío.

Todo esto me llevó demasiado tiempo: /

6 idiomas: 44 bytes / 6 ^ 3 = 0,204 ...

¡Gracias a SnoringFrog por guardar 10 bytes!

Trabaja en:

• Befunge
• Pyth
• Brainfuck
• Hexagonia
• Espacio en blanco
• AniRad v0.2

2# "1",@"-[----->+<]>.*@@@!4<SSTST
T
ST
 >6=

Nota: Antes de probarlo en línea, asegúrese de reemplazar S con espacios y T con pestañas, o convierta el siguiente hexdump a ASCII

32 23 20 22 31 22 2c 40 22 2d 5b 2d 2d 2d 2d 2d 3e 2b 3c 5d 3e 2e 2a 40 40 40 21 34 3c 20 20 09 20 09 0d 0a 09 0d 0a 20 09 0d 0a 20 3e 36 3d

Voy a tratar de usar más lenguajes de programación :)

Befunge (impresiones 1):

Pruébalo en línea

2# "1",@"-[----->+<]>.*@@@!4<
2                             # This puts 2 onto the stack
 #                            # Skips the next op (the space)
   "1"                        # Sets the ASCII value of 1 onto the stack
      ,                       # Pop the last item (1)
       @                      # Terminate program

Pyth (impresiones 2):

Pruébalo en línea

2# "1",@"-[----->+<]>.*@@@!4<
2                             # Prints 2
 #                            # Infinite while loop until an error occurs
   "1"                        # String
      ,@                      # This gives the error and terminates the program

Brainfuck (impresiones 3):

Pruébalo en línea

2# "1",@"-[----->+<]>.*@@@!4<
2# "1",@"                     # Since these are not brainfuck ops, these will be ignored
         -[----->+<]>         # Puts "3" on the stack
                     .        # Prints the last item (3)     

Hexagonía (impresiones 4):

Pruébalo en línea

2# "1",@"-[----->+<]>.*@@@!4<   

Una versión más legible:

   2 # " 1       # The steps:
  " , @ " -      # 1 (2) - Hexagony starts at the top-left of the hexagon
 [ - - - - -     #       - This immediately puts 2 onto the stack
> + < ] > . *    # 2 (#) - Since the stack is 2, this makes the 2nd pointer the 
 @ @ @ ! 4 <     #       - new current pointer
  > 6 = . .      # 3 (*) - The position of the 2nd pointer is in the left-most
   . . . .       #       - position. This sets the stack to the product
                         - of the two neighbours which is zero
                 # 4 (<) - Changes the pointer direction to west
                 # 5 (4) - Sets the stack to 4
                 # 6 (!) - Outputs the decimal 4
                 # 7 (@) - Terminates the program

Espacio en blanco (impresiones 5):

Pruébalo en línea

Como se ignoran otros caracteres pero espacios en blanco y tabulaciones, nos queda lo siguiente:

SSTST                 # This pushes 5 onto the stack
T                     # 
ST                    # This prints the decimal

AniRad versión 0.2 (impresiones6 ):

De alguna manera, esto funciona para la versión 0.2, pero da un error para la versión 0.4. No tengo ni idea de por qué. Puedes encontrar la versión 0.2 aquí . Para ejecutar esto, puede copiar y pegar el código del intérprete para repl.it y ejecutarlo. Después de eso, solo necesita pegar el programa en STDIN y ejecutarlo.

2# "1",@"-[----->+<]>.*@@@!4<      # (#)  Starts at the hashtag (starting point)
                                   #      Direction is down
                                   # (>)  When the pointer gets to the '>', it changes
 >6=                               #      its direction
                                   # (6) Puts 6 onto the stack 
                                   # (=) Pushes the result and terminates

6 7 idiomas, 32 37 bytes, puntaje 0.148 ... 37/7 ³ ≈ 0.107872 ...

#7+!"@\"6.@;n5
print(4--int(-3/2)#"
)

Brainfuck-ng

+ incrementa la celda actual, ! imprime como entero, @sale. #y "son NOPs.

Python 2

La primera línea es un comentario. Usando la división entera, calcula4 - -int(-3 / 2) = 4 - -int(-2) = 4 - -(-2) = 4 - 2 = 2 e imprime el resultado.

Python 3

Igual que el anterior, pero con división de flotación. 4 - -int(-3 / 2) = 4 - -int(-1.5) = 4 - -(-1) = 4 - 1 = 3.

Lua

--comienza un comentario, y #en la primera línea hay un comentario, así que básicamenteprint(4) .

> <>

#refleja IP, 5empuja 5, nimprime un número y; cierra.

Befunge

#salta sobre +, !niega lógicamente la parte superior de la pila, "@\"empuja la cuerda@\ , 6empuja 6,. imprime un número y se @cierra.

Pyth

#comienza un ciclo infinito, descartando cualquier error. 7imprime 7, luego sigue, lo +!"string")que básicamente causa un error por no tener dos operandos para +finalizar el programa.

JavaC ++ C, 363/27 = 13.4 ....

Java imprime 1, C ++ imprime 2, C imprime 3. Sin romper ningún registro aquí (porque Java), pero realmente me gusta la forma inteligente y abusiva de hacer un políglota en estos lenguajes que descubrí.

//\u000a/*
#include<stdio.h>
#ifdef __cplusplus
#define o "2"
#else
#define o "3"
#endif
int p(int a){printf(o);}
struct{int(*print)(int);}out;
//*/
/*\u002a/
import static java.lang.System.out;
public class P{//*/
/*\u002a/public static void//*/
main(/*\u002a/String[] args//*/
){//\u000a/*
out.print=p;
//\u002a/
out.print(1);}
/*\u002a/}//*/

Esto es un desastre. Aquí hay un desglose de cómo funciona. El compilador de Java expande los literales Unicode ( \u000atambién conocidos como salto de línea y \u002atambién conocidos como *) en sus caracteres reales. Entonces, esto es lo que ve el compilador de Java:

//
/*
#include<stdio.h>
#ifdef __cplusplus
#define o "2"
#else
#define o "3"
#endif
int p(int a){printf(o);}
struct{int(*print)(int);}out;
//*/
/**/
import static java.lang.System.out;
public class P{//*/
/**/public static void//*/
main(/**/String[] args//*/
){//
/*
out.print=p;
//*/
out.print(1);}
/**/}//*/

Todo eso al principio se ignora porque está envuelto en un comentario de varias líneas ( /* ... */). Más adelante, vemos que mezclar comentarios de una sola línea y de varias líneas nos permite controlar exactamente qué partes se comentan en cada idioma. En el método principal, comenzamos un comentario de varias líneas y luego tenemos //*/. Normalmente, este sería un comentario de una sola línea, pero dado que estamos en un comentario de varias líneas, el// no hace nada, lo que permite*/ cerrarlo.

Este es el código Java equivalente, con comentarios eliminados:

import static java.lang.System.out;
public class P{
public static void
main(String[] args
){
out.print(1);}
}

Esto es lo que ve el compilador C / C ++ (he eliminado los literales Unicode, ya que el compilador no los expande y, por lo tanto, no hacen nada):

///*
#include<stdio.h>
#ifdef __cplusplus
#define o "2"
#else
#define o "3"
#endif
int p(int a){printf(o);}
struct{int(*print)(int);}out;
//*/
/*/
import static java.lang.System.out;
public class P{//*/
/*/public static void//*/
main(/*/String[] args//*/
){//\/*
out.print=p;
///
out.print(1);}
/*/}//*/

Aquí, los comentarios de una sola línea anulan los delimitadores de comentarios de varias líneas al principio, por lo que todos los #definesy #includese preprocesan. A continuación, los comentarios de varias líneas se utilizan para comentar el código de la plantilla para Java. Este es el código equivalente, con comentarios eliminados:

#include<stdio.h>
#ifdef __cplusplus
#define o "2"
#else
#define o "3"
#endif
int p(int a){printf(o);}
struct{int(*print)(int);}out;
main(
){
out.print=p;
out.print(1);}

Se #ifdef __cplusplusutiliza un truco políglota C / C ++ estándar (the ) para definir un token ocomo "2"o "3", dependiendo de si es un compilador C ++ o C que está compilando el código. A continuación, definimos una función pque toma un solo intargumento (ignorado) y llamadas printf, utilizando nuestro otoken recién definido . Como de costumbre, el valor de retorno se omite, ya que no estamos en modo estricto. A continuación, definimos a structcon un solo miembro, un puntero de función cuya firma coincide con pla de ellos, y construimos una única instancia llamada out. En el método principal (dejamos de lado intcomo de costumbre), pse asigna la dirección de out.print(por lo que se llaman out.printllamadas p) y se llama.

Si C ++ no se incluyera en los lenguajes, podríamos descartar todo el código del preprocesador y definirlo pcomo int p(int a){puts("2");}. Desafortunadamente, C ++ requiere una #includeE / S para hacer. Si no se incluye C, podríamos descartar la definición py la #ifdefmacro del preprocesador, y definir directamente una función miembro en structlugar de necesitar un puntero de función. Lamentablemente, C no admite funciones miembro.

4 idiomas, 28 bytes / 64 = 0.4375

print((0 and 3^1or 1/2>0)+1)

1. Python 2

0es falso y /es división entera, entonces

(0 and 3^1 or 1/2 > 0) + 1 = (1/2 > 0) + 1 = (0 > 0) + 1 = False + 1 = 1

2. Perl (también Python 3)

0es falso y /es división de flotación, entonces

(0 and 3^1 or 1/2 > 0) + 1 = (1/2 > 0) + 1 = (0.5 > 0) + 1 = 1 + 1 = 2

3. Ruby

0es veraz y es bitor ^xor, entonces

(0 and 3^1 or 1/2 > 0) + 1 = xor(3,1) + 1 = 2 + 1 = 3

4. Lua

0es verdad y ^es exponenciación, entonces

(0 and 3^1 or 1/2 > 0) + 1 = pow(3,1) + 1 = 3 + 1 = 4

Tenga en cuenta que Lua y Ruby no pueden agregar booleanos como si fueran enteros, de ahí la agrupación de ellos. Lamentablemente 0andno funciona en Lua, por lo que no podemos guardar un byte allí.

Versión anterior de 17 bytes que imprime 1 (Lua), 2 (Ruby), 3 (Python / Perl):

print(2^(0 or 1))

-3 bytes gracias a @xnor por esta versión, por lo que es mucho más ordenada :)

BFSRS> <> funge93thon123, 73/343 ≈ 0.212827 ...

Brainfuck, en serio ,> <>, Befunge-93, Python 1, Python 2, Python 3

# 4['.]@kX21z-[>+<-----]>--.<;n3
import sys;print(3+int(sys.version[0]))

Contiene imprimibles, hexdump (reversible con xxd -ps -r):

2320345b272e5d406b5832317a7f2d5b3e2b3c2d2d2d2d2d5d3e2d2d2e3c
3b6e330a696d706f7274207379733b7072696e7428332b696e7428737973
2e76657273696f6e5b305d2929

Agregaré más idiomas (y probablemente bytes) con el tiempo. Los idiomas en el encabezado se enumeran en orden de lo que imprimen. Asume celdas de ajuste de 8 bits y una cinta que no se quejará de ir a la izquierda de la posición inicial (ajuste o infinito) para Brainfuck.

Brainfuck:

[.]   initial value of first cell is 0, so loop is skipped
-[>+<-----]>--  push 49 (ASCII ordinal of 1)
.     print "1"
<     move to blank cell
[0]   skip loop because cell is 0
      everything else is ignored

En serio :

# 4['.]@  does some stuff we don't care about
kX        pop entire stack, push as list, discard (essentially the same as é, but is ASCII so we can use Python)
2         push 2
1z        pop 1 item from stack and print (used instead of . so Brainfuck doesn't print here; same as ü in this scenario, but is ASCII so we can use Python)
0x7f      terminate program
          everything else is ignored

><>:

#    mirror, reverse direction
3n;  push 3, print "3", end (reversed because IP is scanning RTL at this point)
     everything else is ignored

Befunge-93:

#     jump over the space
4['.] push 4, print 4 (brackets and ' do nothing)
@     end program
      everything else is ignored

Python 1 (gracias pez lodo):

# 4['.]@kX21z-[>+<-----]>--.<;n3         comment; ignored
import sys;print(4+int(sys.version[0]))  prints 4+1=5

Python 2 :

# 4['.]@kX21z-[>+<-----]>--.<;n3         comment; ignored
import sys;print(4+int(sys.version[0]))  prints 4+2=6

Python 3 :

# 4['.]@kX21z-[>+<-----]>--.<;n3         comment; ignored
import sys;print(4+int(sys.version[0]))  prints 4+3=7

14 idiomas, 73 bytes, puntaje = (73/14 ^ 3) = 0.02660349854

#Y2(3`5n~thneo e        ;n@0d c
#   -[>+<"9"L-----]>+.
14  
print(int(15/2))+3

Puedo agregar algunas langs más, pero creo que agregaré lo que tengo aquí.

1. Brainbool ;Pruébalo en línea!

El código relevante:

    [>+<         ]>+.

               + 

Esto es realmente justo +.+, lo que produce 1.

2. Jolf ; Pruébalo aquí!

El (personaje deja de interpretar el código fuente, por lo que el código correspondiente es:

#Y2

Esto es equivalente a (en JavaScript)

var Y = []; toHex(Y); alert(2);

Que produce 2.

3. Elemento; Pruébalo en línea!

El código relevante:

    3`

Esto lo captura 3y lo imprime.

4. Brainfuck ; Pruébalo en línea!

El código relevante es:

-[>+<    -----]>+.

  -    -      + 

Cuál es la forma estándar de generar el código char de 4 y generarlo, y algunas otras cosas después de él.

5. Reng; Pruébalo aquí!

~ termina el programa, por lo que el código relevante aquí es:

#Y2(3`5n~

#redefine Yser las condiciones de servicio, en este caso, 0. 2empuja 2; (gira la pila N veces, sacando N de la pila; 3`empuja -3; y finalmente, 5nimpresiones5 .

6. ETA; Pruébalo en línea!

ETA solo lee las letras E, T, A, O, I, N, S, H, por lo que el código que solo se ejecuta es el siguiente:

       n thneo e         n     


  int int          

Código súper relevante:

       n thneo

O, equivalentemente: nthne o. n...ees un literal de base 7 y thnes el número de base 7 para 54.o genera este carácter. El envío presenta errores, pero no sé por qué.

7. Python 3

Lo que ve:

# comment
# comment
14
print(int(15/2))+3

15/2rinde 7,5, como /es la división del flotador. int(...)convierte el número en un int, que luego se imprime. El programa falla cuando+3 produce se encuentra.

8. Julia

Julia ve:

# comment
# comment
14
print(int(15/2))+3

En lugar de truncar 15/2, Julia lo redondea, produciendo 8. Imprime esto, luego se equivoca al encontrar +3.

9. fisión; Pruébalo en línea!

Código relevante:

        <"9"L         

Tengo esta idea de la parte de Martin's Fission (más bien me la robó). Lcomienza una cosa orientada hacia la izquierda, captura 9y termina con <.

10. espacios en blanco; Pruébalo aquí!

El código relevante, traduciendo espacios Sy pestañas en T:

SSSTSTS
T
ST

Empuja 10 a la pila y lo muestra como un número ( T\nST).

11. Python 2

Python 2 ve esto:

# comment
# comment
14
print(int(15/2))+3

(int(15/2))+3 se evalúa como 11 y se imprime.

12. Gol> <>; Pruébalo aquí!

Código relevante:

#                      ;n@0d c

Esto usa el truco usado en la respuesta de Martin que @rota diferentes direcciones en> <> y Gol> <>. #refleja, cempuja 12, dempuja 13, 0empuja 0 y lo @lleva ca la parte superior de la pila, luego sale y se imprime con;n .

13.> <>; Pruébalo en línea!

Código relevante:

#                      ;n@0d c

Nuevamente, el uso de eso @rota diferentes direcciones en> <> y Gol> <>. #refleja, cempuja 12, dempuja 13, 0empuja 0 y @lleva da la parte superior de la pila, luego sale y se imprime con ;n.

14. Golfscript; Pruébalo en línea!

Lo que ve:

# comment
# comment
    14
print(-int(-15/2))+3

Empuja 14, prints it, y errores. Robado inspirado por la respuesta de Sp3000 .

Subskin , Brainfuck y Fob 27 bytes / 3 ^ 3 = 1

0#>&$3#<>$-[----->+<]>-.
31

Subskin

0
31

Establecemos el puntero de instrucción (no importa aquí) en 0y el registro de salida en 31. Si el contenido del registro de salida es >= 0, sacamos el valor contenido como a char. El resto del código se ignora.

Brainfuck

-[----->+<]>-.

Pone 3en el registro, disminuye el valor una vez con -y finalmente sale con. .

Engañar

#>&$3#<>$

Esto es un poco más complicado, ya Brainfuck también lee el <e >instrucciones en Fob. Entramos en modo de ejecución #e incrementamos el puntero de Brainfuck en uno, lo que nos facilita más tarde. Todavía no tenemos nada que ejecutar, por lo que no se ejecuta nada.

Entramos en el modo acumulador con $, lanzamos a 3, ingresamos nuevamente en el modo de ejecución, empujamos el contenido del acumulador a la pila con <y finalmente sacamos el contenido con >.

Para evitar que Brainfuck se joda con el programa, ingresamos nuevamente al modo de acumulación con $.

7 idiomas, 55/7 ^ 3 ≈ 0.16035

Se ejecuta en PowerShell v1, v2, v3, v4 y v5, Foo y Pyth

#7.q"6""
$p=$PSVersionTable;($p.PSVersion.Major,1)[!$p]

Los dígitos 1-5 usan una lógica similar a la respuesta de sweerpotato . La $PSVersionTablevariable especial se introdujo en PowerShell v2 y contiene una lista de compilación completa, revisiones, etc. Aquí hay un ejemplo de salida de la variable:

PS C:\Tools\Scripts> $PSVersionTable

Name                           Value                                                                                                                           
----                           -----                               
PSVersion                      4.0
WSManStackVersion              3.0
SerializationVersion           1.1.0.1
CLRVersion                     4.0.30319.34209
BuildVersion                   6.3.9600.17400
PSCompatibleVersions           {1.0, 2.0, 3.0, 4.0}
PSRemotingProtocolVersion      2.2

En este código, primero lo almacenamos $ppara que la longitud del código sea más corta. Luego, verificamos su existencia aprovechando la variable como un índice en una matriz de dos elementos:

• Si la variable no existe, PowerShell la creará dinámicamente y la asignará $NULL , la !cual es $TRUE, o 1, que corresponde al segundo elemento de la matriz, que genera1 .
• Si la variable existe (como es el caso en v2 +), entonces el ! la variable da como resultado $FALSEo 0, que indexa al primer elemento, que genera el número de versión.

Usando Foo para 6, aprovechamos que #es un comentario en PowerShell, por lo que se ignora al ejecutarlo en un entorno PS. Sin embargo, Foo felizmente escupirá el número.6 y luego continuará con el resto del programa, que no hace nada.

Usando Pyth para 7, volvemos 7, luego inmediatamente salimos con .q, por lo que el ciclo infinito while verdadero que comenzó con #no importa. Como nos queda algo que se imprime implícitamente. Gracias a @ FryAmTheEggman por esta adición.

_{Edit - Golfed un puñado de bytes gracias a Mauris Edit - explicación aclarada de Pyth gracias a Sp3000}

7 idiomas, 287/7 ^ 3 = 0.836

Probablemente el puntaje más bajo que entra, de todos modos me gustan estas 3 versiones de C polyglot.

Se agregó la solución aburrida de Python para al menos calificar para la recompensa de "3 idiomas únicos".

Se agregó Java al abusar de los trigrafos en C para diferentes interpretaciones de comentarios.

Trabaja en:

• Python 1

• Python 2

• Python 3

• C89

• C99

• C ++

• Java

versión de golf:

/*
*??/
/
#include <stdio.h>
#ifndef __cplusplus
#define true 8/*
import sys
print(sys.version[0])
'''
#*??/
/
#endif
int main(){int a=(true>1)?-6:3;printf("%d",(true//*
+a
//**??/
/+2));}
#define a \
'''
/**\u002f
public class p{public static void main(){System.out.println("7");}}
/**/

Sin golf:

/*
*??/
/

#include <stdio.h>

#ifndef __cplusplus
#define true 8/*

import sys
print(sys.version[0])
'''
#*??/
/
#endif 

int main()
{
    int a = (true > 1) ? -6 : 3;
    printf ("%d", (true//*
    +a
    //**??/
/
    +2));
}
#define a \
'''

/**\u002f
public class p
{
    public static void main()
    {
        System.out.println("7");
    }
}
/**/

Ok, esto probablemente se está cansando un poco y espero que mis conocimientos de inglés sean lo suficientemente buenos como para explicarlo ordinariamente.

En primer lugar, explicaré los diferentes tipos de comentarios que utilicé para encapsular las estructuras del lenguaje por separado.

Entonces tomemos el primer bloque:

/*
*??/
/

Para Java, esto es solo el comienzo de un comentario de varias líneas. Pero ... en C99 / 89 / ++ esto se evalúa como

/*
*/

Dado que ??/es un trigrafo durante un \tiempo en C, el \carácter es bastante consistente e incluso consume saltos de línea en su funcionalidad de comando. Esto hace que el resultado de un \nsolo se "muestre" en lugar de ser saltos de línea. eso significa, dada esta matriz de bytes que representa el primer bloque: [ /] [ *] [ \n] [ *] [ ?] [ ?] [ /] [ \n] [ /] sería después de la evaluación de trigraph: [ /] [ *] [ \n] [ *] [ \] [ \n] [ /] Donde la funcionalidad consistente de los \disparadores y "consume", el \nresto y finalmente en los bytes evaluados de C langs son: [ /] [ *] [ \n] [ *] [ /]

Pero sobre todo esto, Java no sabe nada y trata todo lo que sigue como un comentario hasta que este truco se revierta.

(¡continuará!)

4 idiomas (Befunge-93, Microscript II, Microscript y Foo), puntaje 7/64 = 0.109

"4"1.@2

Befunge: Presione 4, presione 1, imprima 1 y termine.

Microscript II: Produzca la cadena "4", deséchela, tome la raíz cuadrada de uno, deséchela y finalmente establezca x en 2. Esto se imprime implícitamente.

Microscript: presione 52 en la pila (que nunca se usará para el resto del programa), incremente el registro (inicialmente cero) en uno, luego incremente el registro en dos. Esto se imprime implícitamente.

Foo: Imprime la cadena "4", luego presiona 2

Python 1 | 2 | 3, 27 bytes / 27 = 1

print(len("\xabc")+(1/2>0))

El uso de los números de versión de @ sweerpotato me hizo preguntarme si era posible distinguir las pitones en menos. Aquí está lo mejor que he encontrado.

Explicación

Para distinguir Python 3 de las versiones anteriores, utilizamos el truco estándar de división de enteros versus división de punto flotante. (1/2>0) == (0>0)devuelve 0 pre-Python 2.3 o Falsedesde Python 2.3 en adelante, y (1/2>0) == (0.5>0)devuelveTrue para Python 3.

Para distinguir Python 1 del resto, tomamos la longitud de la cadena "\xabc", que es la longitud uno en Python 1 y la longitud dos desde Python 2 en adelante. ¿Por qué? Porque

El escape \ x en literales de cadena ahora toma exactamente 2 dígitos hexadecimales. Anteriormente consumiría todos los dígitos hexadecimales después de la 'x' y tomaría los 8 bits más bajos del resultado, por lo que \ x123456 era equivalente a \ x56.

(De lo nuevo en Python 2.0 )

Python 3, Ruby, Perl, C, C ++, Objective-C 202 bytes / 6 ^ 3 = 0.935 ...

Esto fue bastante divertido en realidad, y mucho jugar con booleanos.

Puede todas las versiones del código en el siguiente sitio , copiando y pegando el código en el intérprete.

#include <stdio.h> /*
print ((("0"+"0"==0)and 3) or (0and 2or 1));
__DATA__ = 1
"""""
*/
int main(){putchar(
#ifdef __OBJC__
'6'
#else
#ifdef __cplusplus
'5'
#else
'4'
#endif
#endif
);return 0;}/*
"""
#*/

Python 3, impresiones 1

El truco es el siguiente:

print ((("0"+"0"==0)and 3) or (0and 2or 1));

Esto imprimirá 1

Rubí, estampados 2

El código interpretado para Ruby es:

print ((("0"+"0"==0)and 3) or (0and 2or 1));

Entonces esto imprime 2

Perl, impresiones 3

El código interpretado para Perl es:

print ((("0"+"0"==0)and 3) or (0and 2or 1));
__DATA__ = 1

En primer lugar, el __DATA__token le dice al compilador de Perl que la compilación ha finalizado. Todo después es ignorado.

print ((("0"+"0"==0)and 3) or (0and 2or 1));

E impresiones 3

C, impresiones 4

El código interpretado es bastante diferente de los demás:

#include <stdio.h>
int main(){putchar(
#ifdef __OBJC__
'6'
#else
#ifdef __cplusplus
'5'
#else
'4'
#endif
#endif
);return 0;}

Esto simplemente imprimirá el carácter 4.

C ++, impresiones 5

Lo mismo que el código C

Esto imprimirá el char 5.

Objetivo-C, impresiones 6

Lo mismo que el código C

Esto imprimirá el char 6.

5 idiomas, 18 bytes / 5 ^ 3 = 0.144

Se ejecuta en Brainbool , Mathematica , Foo , > <> y Befunge-93 .

4!<n;+Print@2"3".5

Brainbool

Brainbool es como Brainfuck, pero funciona solo en bits, y su entrada y salida consiste únicamente en 0y 1.

4!<n;+Print@2"3".5
  <                   move the pointer to the left
     +                logic not
                .     print the current cell

Mathematica

En Mathematica, todo es una expresión y tiene un valor. Print@2imprime 2y devuelve el símboloNull . Después de eso, el código hace algunos cálculos simbólicos, pero no imprime nada.

Foo

"3" impresiones 3. No sé lo que hacen las otras partes.

> <>

4!<n;+Print@2"3".5
4                     push 4
 !                    skip the next command
   n                  pop and print it as a number
    ;                 end the program

Befunge

4!<n;+Print@2"3".5
4                     push 4
 !                    logical not
  <                   makes the program counter travel to the right
 !                    logical not
4                     push 4
                 5    push 5
                .     pop and print it as a number
             "3"      push the string "3"
            2         push 2
           @          end the program

Usando el truco del sweerpotato , barato pero poderoso.

Se ejecuta en Brainbool , Mathematica 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 y 10.0 , Foo y > <> .

cn;+"11".Print@Floor@$VersionNumber

6 idiomas, 38/6 ^ 3 = 0.17592̅5̅9̅

Espacio en blanco , Brainfuck, Ruby, Labyrinth , Foo, en serio

Leyenda:

£: pestaña

•: espacio

§: 0x7f

puts•2;#4!@•-[>+<-----]>6.§"5"•£    
£
•£

Esto contiene caracteres no imprimibles, así que aquí está el hexdump:

7075747320323b23342140202d5b3e2b3c2d2d2d2d2d5d3e362e7f22352220090a090a20090a

Explicación:

Espacio en blanco

Pruébalo en línea. (Nota: mi programa omite los tres saltos de línea de cierre para terminar el programa, escribí / probé esto en Whitelips y eso produce la salida correcta allí, pero no en Try It Online, por lo que el programa vinculado tiene esos dos caracteres agregados. Hasta ahora como puedo decir, algunos intérpretes te permiten hacer eso, otros se quedan atrapados en un bucle infinito sin la terminación explícita)

(omitiendo caracteres ignorados)

spacespacespacetabenter: empuja un 1 en la pila

tabenterspacetab: muestra la parte superior de la pila

Rubí

No debería necesitar explicaciones. Imprime 2, trata el resto de esa línea (ergo, el programa brainfuck) como un comentario, trata el resto del archivo como vacío.

Brainfuck

Pruébalo en línea.

Requiere un intérprete que admita el flujo inferior. Desborda la primera celda a 255 y luego la usa para que un contador de bucle genere 51, que es el código ascii para 3.

Laberinto

Pruébalo en línea.

(omitiendo las dos últimas líneas para la legibilidad porque nunca se alcanzan)

puts•2;#4!@ -[>+<-----]>6.§"5"•£
puts•                            skipped
     2                           push 2 onto stack
      ;                          pop 2 from stack
       #                         push current stack depth (0) to stack
        4                        push 4 to stack
         !                       print top of stack as integer
          @                      program terminates

Foo

Pruébalo en línea.

Lo único que afecta la salida es "5", que imprime 5.

Seriamente

Pruébalo en línea.

puts•2;#4!@ -[>+<-----]>6.§"5"•£
puts•2;#4!@ -[>+<-----]>           assorted stack manipulation that doesn't affect this program
                        6          push 6 to the stack
                         .         output top of the stack
                          §        (0x7f) terminate program

5 idiomas, Chaîne , Minkolang , Foo , Brainf ** k-ng y Vitsy , ^ 3 = 0.168

2|<«+!@"3".N+m

5N»

Brainf ** k-ng

2|<«+!@"3".N+m

5N»
  <            go left (should still be ok)
    +!         output 1
      @        halt execution

Chaîne

2|<«+!@"3".N+m

5N»
2              «add 2 to the current string»
 |<            «take off and put on the string (no op)»
   «           «comment»

  »
               «implicit output»

Foo

2|<«+!@"3".N+m

5N»
       "3"     print three

Minkolang

2|<«+!@"3".N+m

5N»
2              C push 2 to the stack [2] C
 |             C mirror C
2              C push 2 to the stack [2,2] C
             m C ignored C
            +  C add top two [4] C
           N   C output C
          .    C terminate program C

Vitsy

2|<«+!@"3".N+m

5N»
2              push 2
 |             mirror
2              push 2
             m pop 2, goto line 2
5              push 5
 N             output 5
  »            ignored

Probablemente pueda agregar> <> o algo así.

Craneflak , Brain-Flak Classic , Rain-Flak , BrainHack , Brain-Flueue , miniflak , miniHack : .1020

(([]()()()<()()()>)()()){}#{}({}())

Pruébalo en línea!

Explicación

Lo primero que sucede aquí es que hay una diferencia en la forma en que se leen los comentarios entre los intérpretes BrainHack, CraneFlak y Rain-Flak. Craneflak no tiene comentarios, en Rain-Flak #comenta el resto de la línea y en BrainHack #{...}comenta el interior.

Entonces, esto es lo que lee cada idioma:

Rain-Flak: (([]()()()<()()()>)()()){}         -> 3
BrainHack: (([]()()()<()()()>)()()){}({}())   -> 4
Craneflak: (([]()()()<()()()>)()()){}{}({}()) -> 1

Lo siguiente es la diferencia entre el cerebro-flaks y los miniflaks. Tanto Rain-Flak como BrainHack admiten miniflak, donde todas las operaciones adicionales simplemente se eliminan. Esto significa que pierden el []y<...>

Rain-Flak: (()()()()()())         -> 6
BrainHack: (()()()()()())({}())   -> 7

A continuación tenemos la diferencia entre Brain-Flak y Brain-Flak Classic. En Classic []es en -1lugar de la altura de la pila, lo que significa que nuestro resultado es 1 menos que en Rain-Flak normal, por lo que es 2.

Por último, tenemos la diferencia entre brain-Flak y brain-flueue. En el conducto cerebral se usa una cola en lugar de una pila. Normalmente, Brain Flak empuja 3 y luego 5 y saca los 5, sin embargo, en el conducto cerebral, el pop elimina los 3 y no los 5.

Vía Láctea 1.0.2 , CJam y STXTRM , 20 bytes / 3 ^ 3 = 0.741

Me imagino que hay al menos otro idioma que podría agregar.

'2"3""1"1<<1>;;"2"3;

Explicación

Vía Láctea ,1

En la Vía Láctea, las cadenas solo se denotan por pares de comillas dobles. Una comilla simple lee la entrada de la línea de comando; si no hay ninguno, empuja una cadena vacía. Los signos mayores y menores que rotarán toda la pila hacia la derecha y hacia la izquierda, respectivamente. Finalmente, un punto y coma intercambia los dos elementos superiores de la pila.

Aquí hay una visualización de la pila (la pila que se muestra es el resultado de la operación listada después de que haya ocurrido):

["", 0]                                             #  default stack

["", 0, ""]                                 #   '   #  read input from command line
["", 0, "", 2]                              #   2   #  push 2 to the stack
["", 0, "", 2, "3"]                         #  "3"  #  push "3" to the stack
["", 0, "", 2, "3", "1"]                    #  "1"  #  push "1" to the stack
["", 0, "", 2, "3", "1", 1]                 #   1   #  push 1 to the stack
[0, "", 2, "3", "1", 1, ""]                 #   <   #  rotate the stack leftwards
["", 2, "3", "1", 1, "", 0]                 #   <   #  rotate the stack leftwards
["", 2, "3", "1", 1, "", 0, 1]              #   1   #  push 1 to the stack
[1, "", 2, "3", "1", 1, "", 0]              #   >   #  rotate the stack rightward
[1, "", 2, "3", "1", 1, 0, ""]              #   ;   #  swap the top two stack elements
[1, "", 2, "3", "1", 1, "", 0]              #   ;   #  swap the top two stack elements
[1, "", 2, "3", "1", 1, "", 0, "", 2]       #  "2"  #  push 2 to the stack
[1, "", 2, "3", "1", 1, "", 0, "", 2, "3"]  #   3   #  push "3" to the stack
[1, "", 2, "3", "1", 1, "", 0, "", "3", 2]  #   ;   #  swap the top two stack elements

CJam ,2

En CJam, las cadenas también se denotan por pares de comillas dobles. Una comilla simple empuja el código de carácter del siguiente carácter. Cuando se emite un código de caracteres, se emite como su carácter correspondiente. Los signos de mayor o menor que actúan como se esperaba, evaluando el orden de los dos elementos superiores de la pila. Finalmente, un punto y coma descarta el elemento de la pila superior. Al finalizar el programa, se muestran los contenidos de la pila.

Aquí hay una visualización de la pila (la pila que se muestra es el resultado de la operación listada después de que haya ocurrido):

[]                         #  default stack

['2]               #  '2   #  push the character code of "2" to the stack
['2, "3"]          #  "3"  #  push "3" to the stack
['2, "3", "1"]     #  "1"  #  push "1" to the stack
['2, "3", "1", 1]  #   1   #  push 1 to the stack
['2, "3", "1"]     #   <   #  leave the greater of the top two stack elements on the stack
['2, 0]            #   <   #  leave the greater of the top two stack elements on the stack
['2, 0, 1]         #   1   #  push 1 to the stack
['2, 1]            #   >   #  leave the lesser of the top two stack elements on the stack
['2]               #   ;   #  pop the top stack value
[]                 #   ;   #  pop the top stack value
['2]               #  "2"  #  push the character code of "2" to the stack
['2, "3"]          #   3   #  push "3" to the stack
['2]               #   ;   #  pop the top stack item

STXTRM ,3

En MSM, cualquier cosa que no sea un operador se empuja a la pila como un personaje. Un punto y coma duplica el elemento de la pila superior. El programa continúa hasta que no haya más operadores o haya un solo elemento en la pila.

El carácter final en la pila es 3, que es duplicado por el operador final. 3es el elemento superior al final del programa, por lo que se emite.

5 idiomas, 18 bytes / 5 ^ 3 = 0.144

Ouroboros , Pip , QBasic, Foo y Pyth

5'"4"()"
1?3'@n()2

1. Ouroboros

Cada línea del programa representa una serpiente que se come la cola.

Serpiente 1

Push 5, 'es un no-op, push 52(código ASCII de "4"). (hace que la serpiente muestre un número y coma tantos caracteres de su cola. Como esto resulta en tragar el puntero de instrucción (y toda la serpiente), la ejecución se detiene.

Serpiente 2

Empujar 1, empujar un número aleatorio ( ?), empujar 3, 'es un no-op. @gira la 1parte superior de la pila y la nmuestra como un número, dejando la 3parte superior de la pila. Luego (come tantos caracteres del final de la serpiente, traga el puntero de instrucción y se detiene.

Puede ejecutar este programa en línea en el intérprete de Stack Snippet aquí .

2. Pip

La mayor parte del programa consta de expresiones que se evalúan y descartan:

• 5
• '" (carácter literal)
• 4
• "()"
• 1?3'@ (expresión ternaria)
• n (variable, = nueva línea)
• () (nulo)

Finalmente, 2se imprime la última expresión ,.

3. QBasic

Todo después 'es un comentario. La primera línea se reduce a 5un número de línea. En la segunda línea, 1hay un número de línea y ?3es un atajo para PRINT 3.

^{(Aparentemente, tener números de línea fuera de servicio no es un problema, aunque sería fácil de solucionar si lo fuera).}

4. Foo

Casi todo es no-ops. "4"impresiones 4. Los paréntesis (x2) son un ciclo que se ejecuta hasta que la celda de la matriz actual es cero, lo cual es cierto de inmediato y el ciclo sale. @, cuando no le sigue un número, toma el valor de la celda de la matriz actual (inicializada en 0) y la empuja a la pila.

No estoy completamente seguro de cómo "se supone que se debe manejar el segundo, sin igual . La versión en línea parece agregar una nueva línea a la salida, lo que permiten las reglas del desafío.

5. Pyth

5es salida Luego se encuentra el programa '"4", que intenta leer desde un archivo llamado 4. Mientras no exista tal archivo, creo que esto debería terminar el programa con un error. (La versión en línea dice: name 'open' is not definedsupongo que abrir archivos no está permitido en línea).

La desviación "al final de la línea 1 asegura que la línea 2 no cause un error de sintaxis antes de la ejecución.

4 idiomas, 24 bytes, 24/4 ^ 3 = 0.375

print(1//0.5--1+1/2*2
);

1. PHP

PHP ejecuta print(1);que es igual a 1

2. Lua

Lua ejecuta lo print(1//0.5);que equivale a 2

3. Python 2

Python 2 se ejecuta, lo print(1//0.5--1+1/2*2);que equivale a 3 (división entera)

4. Python 3

Python 3 se ejecuta, lo print(1//0.5--1+1/2*2);que equivale a 4 (división flotante)

Brainfuck-ng, Foo,> <>, 9 bytes / 3 ^ 3 = 0.333 ...

#+!"2";n3

Brainfuck-ng

Los únicos caracteres que reconoce son +y !:

+ Increment cell by one
! Print as integer

Huellas dactilares 1

Foo

Imprime todo entre comillas.

"2"

Huellas dactilares 2

> <>

#Refleja el punto a la izquierda, 3empuja 3 a la pila, lo nmuestra como un número entero, ;detiene el programa.

#      ;n3

3 idiomas, 82 83/3 ^ 3 = 3.074 ...

Trabaja en ??? , Espacios en blanco y Beatnik . O más bien, debería funcionar en esos idiomas, pero no voy a poder probarlos durante unos días. De todos modos, aquí está el código:

K... Jax... Jy... Jy...   ...
My...    My...
... ...     ......................XO!

1. ???

.................................................!

??? es básicamente una mierda mental, pero usa signos de puntuación comunes como comandos en lugar de los caracteres tradicionales. .incrementa la celda de memoria actual, lo que se hace 49 veces. !toma la celda de memoria actual y la imprime como un carácter, aquí 1.

2. Espacio en blanco

[Space][Space][Space][Tab][Line Feed]
[Tab][Line Feed]
[Space][Tab]

El espacio en blanco es un lenguaje que ignora todos los caracteres que no son espacios en blanco. Aquí lo he convertido a una forma fácil de leer. La primera línea empuja 2hacia la pila, y las segundas dos líneas imprimen la parte superior de la pila como un número, aquí 2.
Tenga en cuenta que en el código combinado, he sustituido las pestañas con cuatro espacios debido a limitaciones técnicas.

3. Beatnik

K Jax
Jy Jy
My My
XO

Beatnik es un idioma en el que cada palabra se convierte a su puntaje de Scrabble, luego esos puntajes se interpretan como comandos. La primera línea empuja 17hacia la pila. La segunda línea duplica la parte superior de la pila de dos veces y la tercera línea añade la parte superior para elementos de la pila juntos dos veces, triplicando efectivamente 17en 51. La última línea imprime el personaje en la parte superior de la pila, aquí 3.
Tenga en cuenta que estoy usando Beatnik en su valor nominal, suponiendo que no haya un error en la especificación original de Beatnik. También tenga en cuenta que estoy usando el sistema de puntuación de Scrabble en inglés de América del Norte.

Si por ahora no está claro, cada uno de estos idiomas solo acepta un cierto tipo de caracteres (puntuación, espacios en blanco y letras, respectivamente), por lo que escribir este políglota fue tan fácil como escribir los programas individuales. El único "truco" real es usar el código de espacios en blanco para separar las palabras de Beatnik. Más allá de eso, los programas individuales no se superponen en absoluto.

5 idiomas, 175/5 ^ 3 = 1.4

Decidí publicar una respuesta diferente ya que la recompensa está cambiando los requisitos de una manera que me hizo sentir insegura con mi primera respuesta (¡pero que todavía me satisface en el camino del desafío general!)

Así que aquí está mi solución que califica para el desafío de recompensas:

Se compila en

• C99
• objC90
• C ++ 0x
• Rubí
• Perl

#if __cplusplus
#define x\
=begin\
=pod
#endif
int a=
#ifndef x
1//**/
+1
#else
3
#endif
;int main(){printf("%d",a);}
#ifdef f
=end
puts 5;
=begin
=cut
print"4";
=end
#endif

3 idiomas, 15 bytes, puntaje 0.555 ...

Voy a agregar más idiomas más tarde.

2//1+1#😅😨

1. Emotinomicon

Emotinomicon prácticamente ignora cualquier texto que no sea una cadena. 😅empuja 1 para apilar y 😨genera los TOS como un número.

2. Javascript

Los comentarios en Javascript comienzan con //, por lo que solo 2se ejecuta la parte.

3. Python 2/3 REPL

Los comentarios en Python comienzan con #, por lo que solo 2//1+1se ejecuta la parte. //es la división entera en Python 3, y es lo mismo que /en Python 2. 2 dividido entre 1 es 2, más 1 es 3.

4 idiomas, 97 bytes, 0.37890625

s="1";s=~-3;2//2;'''/.to_s.ord;"=;print 4;
__DATA__
=1;
";#'''#";print=s=>console.log(3)
print(s)

Rubí

Esto se establece sen "1", compara el uso de =~contra -3en un contexto vacío, intenta dividir 2por y /2;'''/.to_s.ordluego comienza una nueva cadena que contiene =;print 4; __DATA__ =1;, golpea un comentario, luego prints sque aún está1 .

Pitón

Sets sa "1"como por encima, a continuación, establece de nuevo para ~-3que es 2. 2//2Ejecutamos una división entera de , luego hay una cadena de documentos que contiene /.to_s.ord;"=;print 4; __DATA__ =1; ";#, seguida de un comentario, finalmente printing s, que todavía2 .

JavaScript

Establece en sy "1"luego lo establece de nuevo ~-3según lo anterior, luego hay 2en la línea seguida de un comentario. Luego establecemos la variable __DATA__en 1. Hay una cadena corta que contiene ;#'''#seguida de una definición de la funciónprint que codifica la salida para que sea 3, que se llama en la siguiente línea.

Perl

Ejecuta una sustitución equivalente a s/"1";s/~-3;2\/\/2;'''\/.to_s.ord;"/, printsy 4el resto de la cadena está enmascarado detrás del __DATA__identificador.

QBasic, QBIC y> <>, 18 bytes / 3 ^ 3 idiomas = 0.66666 puntos

1:?v+1'-5`
''`>3n;

Descompostura:

1. QBasic ( Obtenga el IDE )

1:          Line number 1
  ?         Print
   v+1      undefined var v = 0 + 1 = 1
'-5`        The rest of theis code is a QBasic comment
''`>3n;     As is this

2. QBIC ( Obtenga el intérprete )

1     inserts a 1 in the code - mostly harmless
:     Reads from the cmd line. Nothing there, creates an empty variable a
?     Print
v+1   v is initialised to 6, +1 = 7
'     Code Literal: everything till the ` is passed to QBasic without processing
 -5`  7-5 = 2

''`>3n; Code literal with the first literal being a ': comment in QBasic

3.> <> ( Pruébelo en línea )

1:  Push a 1 on the stack, duplicate stack
?   Pop top off the stack and skip next instruction if that's a 0
v   Move downwards - rest of the line is ignored

>   move to the right
3   Push 3 onto the stack
n   Print the top of the stack as a number
;   End the program

JavaScript, HTML y PHP, 72 bytes / 3 ^ 3 = 2.67

1<!top?2:2//><!--<?='--'.'><script>document.body.innerHTML=3</script>'?>

En HTML, esto imprimirá el 1 inicial, ignorará la <!window?2:2//>etiqueta, y el resto es un comentario HTML.

En JavaScript, evalúa 1<!window?2:2y genera 2 (esto debe ejecutarse en una consola) y el resto es un comentario.

En PHP, lo siguiente es salida del servidor: 1<!top?2:2//><!----><script>document.body.innerHTML=3</script>que reemplaza HTML 1con 3.