Inspirado por un políglota en la página de Stack Overflow 404 :

Gol

Su objetivo es simple, crear un políglota que genere el número 404 y luego terminar, en tantos idiomas como sea posible.

Restricciones

Aquí está el giro, hay una restricción para hacerlo más difícil:

Tienes que escribir N programas y elegir N idiomas en un orden particular. el i º programa necesita para imprimir 404en los primeros i lenguas, pero no en cualquier idioma después de la i ª. Esto es para evitar que soluciones muy simples destruyan la competencia.

Tanteo:

• El primer criterio para determinar un ganador es la cantidad de idiomas en los que se ejecuta el programa principal.
• El segundo criterio es el recuento de bytes, donde los programas con más idiomas tienen más importancia para este criterio.
• El tercer y último criterio es el momento de la presentación.

Aclaraciones:

Los códigos fuente de los programas no necesitan tener ninguna relación. Se ejecutan como programas separados. Cualquiera de los programas puede generar espacios en blanco iniciales y / o finales. ¡LOS PROGRAMAS NO TIENEN QUE SER SUBSECUENCIAS DE CADA UNO!

¡Gracias a @MartinEnder por una mejor explicación!

54 idiomas, 1331 bytes

> <> , Gol> <> , Foo , Befunge-93 , Befunge-98 , brainfuck , Brain-Flak , Python 2 , Python 3 , Hexagony , Perl , Ruby , Julia , Cardinal , Brainbash , Turtlèd , Deadfish ~ , Whitespace , Braille , Rail , Fission , ETA , Trigger , Brainfuck auto-modificable , Numberwang , Actually , Emoji , Symbolic Brainfuck , TinCan , Alphuck , Shove , Cood , Wise , Width , Whispers , Thue , Surface , Stones , evil , Set , Prelude , Gaot ++ , Cubix , Cubically , PATH , Commercial , Brian y Chuck, Monos , Nhohnhehr , Viga , AsciiDots , Aluminio , Alice , Giro

Esto se está haciendo muy largo, por lo que, a sugerencia de @ MDXF, estoy trasladando los subprogramas y los comentarios a un punto esencial . El programa aquí es solo el programa final. Gracias a MDXF nuevamente por proporcionar el controlador de prueba TIO.

54. Remolino

##\$"404"#N#S# , ,,#$#?@\404!?@GJlICJlGCC*G^+0%=%=+0%x&fqpqqqiipsoddddoiipsohphhhhyhhhh? 	  ?nnn4$4#!000110000011110000100000100000110000011001100000111100001110011000111000110000
#?\++++:----:++++:H@((((4O0O4O@((((()()()){}){x}x){}x()){}){}()){}){})<[-]>[-]-[<+>-----]<+x%"404"?.⌂----.++++.>11     
#i(N/"404"ooo@ENTHOEONHSSEONTHOEONSETssipceaiiiiiscejiiiijeeeejapmzaeeaeueewzaeeeaeewzaeeaeueewqs??|?)999|997+|++++!999777+++++!999997+++++!   	  
print(404)	
 		
 		
 	
__DATA__=1
# \"404"*CC'[-][ .-$_"404"&]
"""pp
I want 404 of this
How much is it
#  -52, Z, -1                          #
#  -48, Y, -1                          #
#  -52, X, -1                          #
[-][
x::=~404
::=
x
]<<<
> 404
>> Output 1
red up two blue up red up one blue up red up two blue up
baaaaa bleeeeeeeeet bleeeeeeeeet baaaaa bleeeeeeeeet
a now 404 dollar off!
a has been selling out worldwide!
2 LEFT
2 LEFT
2 UP
2 LEFT
2 TEACH
1 LEFT
1 RIGHT
1 BOND
1 BOND
1 TEACH
2 YELL
1 FIGHT
2 YELL
1 TEACH
2 YELL
set ! 52
set ! 48
set ! 52
+------+
|$0011\|
|/000\0|
|0/0@11|
|00  10|
|0\10/0|
|\1100/|
+------+
$'main'
 \-444o000o444omm^

[-][$++++++++++++++++++++++++++++++++++++++++++++++++++++.----.++++.#
<<<<<<```>>>>.>.>.
]
ss"""
#7777777777777777777777777777724091557093543643💬404💬➡77▲▲▲²²▲²²¡▼▼▼▼¡▲▲▲▲¡⠎⡆⡎⡆⢐⠣⠃s&&&&~-<<:<<:<<<:<:>>>>>>>>:^||||G<>

Pruébalo en línea!

Whirl se describe como Turning Tarpit [sic], que usa solo dos instrucciones, 1 y 0. 1 gira la rueda actual de instrucciones (ya sea la rueda matemática o la rueda de operaciones), 0 intercambia la rotación de la rueda y dos ceros ejecuta las instrucciones y cambia las ruedas. Las instrucciones relevantes están en la primera línea:

000110000011110000100000100000110000011001100000111100001110011000111000110000

000110000 Switch to math wheel and execute math.not (math.val = 1)
011110000 Execute math.store, (memval = math.val = 1)
10000     Execute math.add, (math.val = math.val+memval = 1+1 = 2)
010000    Execute math.store (memval = math.val = 2)
0110000   Execute math.multiply, (math.val = math.val*memval = 2*2 = 4)
01100     Execute math.store (memval=math.val) and switch to the ops ring
110000    Execute ops.one (ops.val = 1)
011110000 Executes ops.intio, printing memval (4)
11100     Add one to memory pointer (memval=0)
1100      Execute maths.nop to switch back to ops ring
011100    Execute ops.intio, printing memval (0)
01100     Execute maths.store, (memval=maths.val=4)
00        Execute maths.intio, printing memval (4)

Los 01 iniciales se cancelan entre sí, y los 01 finales provocan una excepción de coma flotante.

Editar: arreglado un montón de cosas rotas

(Los comandos que tener cuidado en el futuro: UDLR%"[.]o473psjw)

Si algún programa funciona para idiomas futuros o no funciona para idiomas actuales o anteriores, comente.

53 idiomas, 2789 bytes

Bash, Foo, Implícito, Carbón, Emoji,> <>, rk, Brain-Flak, C, Set, Cood, Arcyou, TRANSCRIPT, SILOS, Commercial, C ++, Braille, Deadfish ~, Memescript 1.0, ETA, Python 1, Python 3, PARI / GP, Lily, Fission, Decimal, Cubically, Bitwise, TinCan, Whispers, Thue, Emotinomicon, what ??!, Ook !, evil, Lennyfuck, Blablafuck, Stones, TacO, COW, Symbolic Brainfuck, Underload, Rail , Reticular, Gaot ++, PATH, axo, Monkeys, Nhohnhehr, xEec, VTFF, K-on Fuck, Churro y Forked. ¡Pruebe todo en línea en el controlador de prueba!

¡Únete a nosotros en la sala de chat para este desafío!

Esta publicación se hizo demasiado grande, así que aquí hay una esencia que contiene mi progreso. Programa final actual:

Ahorquillado

#undef l" 404"p;((((\)0)0)0)0;(😭4😲⏬😭0😲⏬😭4😲⏬«404»[:5*11-1/1]%&)(404)S^/*NNNNTNNEONHSSEONTHOEONiisoddddoiisohOok! Ook! Ook! Ook? Ook? Ook. Ook. Ook. Ook. Ook? Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook? Ook! Ook? Ook. Ook. Ook. Ook! Ook. Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. ????!?!!?!??!!!???????????????!?!!!?!????!??????????????!!??!??!??!????!⎚404»💬404💬➡ to for the and of to to to to to is the and  a to to to to a and and and and a ;n4n0n4
#11404D301          \4%0%p%&
""""echo 404|| rk:start int x = 404 print: x rk:end R"404"*
exit;
#;
OUT &52 &1
OUT &48 &1
OUT &52 &1 */
#include<stdio.h>
main(){char aA[]={37,100,0};printf(aA,404);}/*<<<<<mzaeeeaeeaaaawuuuuwaaaa what the frick frack backtrack snick snack tic tac snick snack patty wack diddily dack tic tac diddily dack frick frack quarterback frick frack
x::=~404
::=
x #
set ! 52
#;⠎⡆⡎⡆⢐⠣⠃▲▲▲²²▲²²¡▼▼▼▼¡▲▲▲▲¡(♥ ͜ʖ♥)( ͡°((∩ ͡° ͜ʖ ͡°)⊃━☆ﾟ.*( ͡° ͜ʖ ͡°)ᕦ( ͡°ヮ ͡°)ᕥ(♥ ͜ʖ♥)(♥ ͜ʖ♥)(♥ ͜ʖ♥)(♥ ͜ʖ♥)(♥ ͜ʖ♥)) ͡°)(∩ ͡° ͜ʖ ͡°)⊃━☆ﾟ.*( ͡° ͜ʖ ͡°)(> ͜ʖ<)(♥ ͜ʖ♥)(♥ ͜ʖ♥)(♥ ͜ʖ♥)(♥ ͜ʖ♥)(> ͜ʖ<)( ͡° ͜ʖ ͡°)( ͡° ͜ʖ ͡°)( ͡° ͜ʖ ͡°)( ͡° ͜ʖ ͡°)(> ͜ʖ<)うんうんうんうんたんたんたんたんうんうんうんたんうんたんうんうんうんうんうんたんたんうんたんたんうんたんたんうんたんたんうんたんたんたんたんたんうんうんたんうんたんうんたんうんうんうんたんたんうんたんたんうんたんたんうんたんたんたんうんうんうんたんうんうんたんうんうんたんうんうんたんうんたんうんうん {o}===}{======={o}{o}}{======={o}{o}===}{======={o}
> 404
>> Output 1
I want 404 of this.
How much is it?
Ju is here.
>Ju, 404
>X Ju
b = 404
printInt b ;
set ! 48 MoOMoOMoO
set ! 52 MoOOOMmoO
+--------+
|$00110\ |
|/00001/ |
|\11000\ |
|/11000/ |
|\0100 \ |
|        | baaaaa bleeeeeeeeet
|  404p@ |
|        |
+--------+
$'main': OOMmOoOOM ;
 \-444o000o444o-{<$$^- >}+{-----v}+.----.++++.#
#  bleeeeeeeeet baaaaa ^        < bleeeeeeeeet >
2 LEFT
2 LEFT
2 UP
2 LEFT
2 TEACH
1 LEFT
1 RIGHT
1 BOND
1 BOND
1 TEACH
2 YELL
1 FIGHT
2 YELL
1 TEACH
2 YELL
red up two blue up red up one blue up red up two blue up ;
o now 404 dollars off!
o has been selling out worldwide!
#  -52, Z, -1                          #
#  -48, Y, -1                          #
#  -52, X, -1                          #
⡆⡎⡆⢐⠣⠃((((p 404)((()(((()()()){}){}){}){}){}){}){}) h#4 o# h#0 o# h#4 o# """
print(404)#"*/

Pruébalo en línea!

¡Mi nuevo esolang (implementado recientemente)!

34 idiomas, 387 caracteres

Jelly , M , Pyon , Proton, Python 3, Python 2, Python 1, Perl 6, Perl 5, Ruby, bc, Pari / GP, brainfuck, Emoji, Emotin🌗micon, Charcoal, Braingolf, Whitespace, Deadfish ~, Deadfish, Brainfuck auto modificable, Brainfuck simbólico, Numberwang, Cardinal, Actually, Fission, Prelude, Brain-Flak (BrainHack), Alphuck, Deadfish x, TacO, Braille, rk , evil

Esta respuesta se está haciendo muy larga, así que aquí está la respuesta completa. De ahora en adelante solo el último programa se mantendrá aquí.

Si alguien encuentra que uno de los programas está roto para un idioma o un programa funciona para un idioma que no debería, avíseme.

print(404)   	  
+1#<[-]>--[<+>-----]"404".⌂<+.----.++++.💬404💬➡😒😀😒😨😨😨⎚404»___pppissiiiisiiiio▲▲▲²²▲²²¡▼▼▼▼¡▲▲▲▲¡sipceaiiiiiscejiiiijeeeejaxxcxxxcxxxKddddKcxxxx7777777724091557093543643%R"404";77999++++++++!++++++++6+1+!++++++5++++!> @p404 sp7 rk:start print: "404"77szaeeaeueewzaeeeaeewzaeeaeueew
   	  
+1#((a(()a((()(((()()())a{})a{})a{})a{})a{})a{})a{})	
 		
 		
 	


+1#ṛ“Nạç»⠎⡆⡎⡆⢐⠣⠃

Pruébalo en línea!

11 idiomas, 10 bytes

Pyon

print(404

Pyon, Python 2

print 808//2

Pyon, Python 2, Python 1

print None or 404

Pyon, Python 2, Python 1, Python 3

die=0
print(die or 404);

Pyon, Python 2, Python 1, Python 3, Lua

print(None or 404)

Pyon, Python 2, Python 1, Python 3, Lua, Perl 5

print(404 or 0)

Pyon, Python 2, Python 1, Python 3, Lua, Perl 5, Ruby

;print("40"+"4")

Pyon, Python 2, Python 1, Python 3, Lua, Perl 5, Ruby, Swift 4

print("40"+"4")

Pyon, Python 2, Python 1, Python 3, Lua, Perl 5, Ruby, Swift 4, Perl 6

print(404**1)

Pyon, Python 2, Python 1, Python 3, Lua, Perl 5, Ruby, Swift 4, Perl 6, Julia

print(404);

Pyon, Python 2, Python 1, Python 3, Lua, Perl 5, Ruby, Swift 4, Perl 6, Julia, Lily

print(404)

4 idiomas: CJam, Python, Underload,> <>

Lo siguiente funciona en CJam pero no en Python, Underload o> <>:

404

• Para CJam: Esto empuja el literal 404a la pila. El programa finaliza y 404se emite.
• A Python: este programa consta de una sola expresión 404. La expresión se evalúa y el programa termina.
• Para subcargar: 4y0 son comandos no válidos, por lo que el intérprete TIO simplemente los ignora y el programa finaliza.
• Para> <>: 404empuja 4, 0y 4a la pila. La IP se ajusta al principio, y el programa se repite infinitamente.

Lo siguiente funciona en CJam o Underload (aunque produce errores) pero no en Python o> <>:

N(404)S;(\

• Para CJam: Nempuja una cadena (matriz de caracteres) que contiene una nueva línea a la pila. (saca el carácter único (una nueva línea) de la cadena. 404empuja 404a la pila, y luego la )incrementa para dar 405. S;empuja un espacio y luego lo elimina de inmediato. (decrementos de nuevo para obtener 404, y luego \intercambia la nueva línea y el 404.404\nse emite (la matriz vacía se muestra como nada).
• Subcargar: Nse ignora. (404)empuja la cuerda 404a la pila. Slo emite. ;es ignorado (hace que el intérprete intente buscar un cierre) , pero como no se encuentra ninguno, el programa falla.
• Para Python: esta es una sintaxis no válida (la expresión N(404)va seguida de un identificadorS , que tiene un formato incorrecto), por lo que los errores del programa.
• Para> <>: Nes una instrucción no válida, por lo que el programa comete errores.

Lo siguiente funciona en CJam (aunque produce errores), Underload o Python, pero no> <>:

[]
Le=404
+Le#(404)S
(print(404))

• Para CJam: []empuja la matriz vacía a la pila y Lempuja la matriz vacía a la pila. e=cuenta el número de ocurrencias de []in [], giving 0. 404empuja 404a la pila. +suma los dos números juntos, dando 404. Lempuja la matriz vacía a la pila nuevamente y e#crea un comentario que dura hasta el final de la línea. (intenta extraer un elemento de una matriz, pero dado que el elemento de la pila superior es la matriz vacía [], los errores del programa.404todavía se emite.
• Para Python: []es una declaración que consiste en una instrucción no operativa. Le=404define una variable Lepara ser igual a 404. +Letoma el plus unario de la variable Le(una operación bastante inútil) y el resultado se descarta. #(404)SEs un comentario de línea. (print(404))imprime 404.
• Subcargar: la única parte relevante es (404)S, que empuja 404a la pila y la saca. (print(404))empuja print(404)a la pila, pero no se hace nada con él y el programa termina.
• Para> <>: [intenta sacar un número de la pila superior en el metastack, y luego saca muchos elementos de esa pila y los convierte en una nueva pila que luego se empuja al metastack. No hay ningún número en la pila, por lo que los errores del programa.

Lo siguiente funciona en CJam (aunque produce errores), Python, Underload y> <>:

"404nnn;\
"
Le=404
+Le#(404)S
(print(404))

• Para CJam: La mayor parte de lo que dije la última vez se aplica aquí. En lugar de ser [], ahora tenemos una cadena literal, pero el contenido aún no es importante.
• A Python: la mayor parte de lo que dije la última vez se aplica aquí. En lugar de ser [], la primera expresión no utilizada ahora es un literal de cadena, pero el contenido aún no es importante.
• Para descargar: todo lo que dije la última vez se aplica aquí. Todos los comandos aún se ignoran.
• Para> <>: "comienza el modo de cadena y la IP se ajusta alrededor de la primera fila empujando cada código de caracteres que ve a la pila (esto no es importante). La IP se ajusta y "vuelve a golpear , lo que sale del modo de cadena. 404empuja los dígitos 404a la pila y luego nnngenera cada uno de ellos (técnicamente, esto sucede en orden inverso, pero dado que 404 es un palíndromo, esto no importa). ;termina el programa

6 idiomas Brain-Hack, Brain-Flak, Brain-Fuck, Foo, Javascript, Alphuck

¡Más por venir!

Brain-Hack

#(((()((()(((()()()){}){}){}){}){}){}){})

Imprime 404 en Brain-Hack

Brain-Hack, Brain-Flak

(((()((()(((()()()){}){}){}){}){}){}){})

Brain-Hack, Brain-Flak, Brain-Fuck

(((()((()(((()()()){}){}){}){}){}){}){})#-[<+>-----]<+.----.++++.>-.++++.

Utiliza comentarios en Brain-Flak para imprimirlo

Brain-Hack, Brain-Flak, Brain-Fuck, Foo

"404"
(((()((()(((()()()){}){}){}){}){}){}){})#-[<+>-----]<+.----.++++.>-.++++.

Brain-Hack, Brain-Flak, Brain-Fuck, Foo, Javascript

console.log("404")
//(((()((()(((()()()){}){}){}){}){}){}){})#-[<+>-----]<+.----.++++.>-.++++.

Brain-Hack, Brain-Flak, Brain-Fuck, Foo, Javascript, Alphuck

console.log("404")
//(((()((()(((()()()){}){}){}){}){}){}){})#-[<+>-----]<+.----.++++.>-.++++.iaipiiiiiaecsaejiiiijeeeej

5 idiomas (87 bytes)

Pyon

print(404

Pruébalo en línea!

Python 2

print(404)

Pruébalo en línea!

Brain-Flak (BrainHack)

print(404)#(((()((()(((()()()){}){}){}){}){}){}){})

Pruébalo en línea!

cerebro

Tomado de la respuesta de Jo King porque no pude encontrar un código de brainfuck que tuviera los corchetes equilibrados (restricción Brain-Flak).

print(404)#(((()((()(((()()()){}){}){}){}){}){}){})-[<+>-----]<+.----.++++.>

Pruébalo en línea!

05AB1E

Tenga en cuenta que esto también funciona con Ohm.

#404q
print(404)#(((()((()(((()()()){}){}){}){}){}){}){})-[<+>-----]<+.----.++++.>

Pruébalo en línea!

Gracias a Jo King por -6 bytes.

2 idiomas, 24 bytes, Python y Batch

Programa 1: Python 3

print('404')

Programa 2: Python 3 y Batch

print('404')#|echo 404

Después del hash comenta el resto del código en python, y el | es una declaración en bash para hacer esto si el otro comando falla.

2 lenguajes, 53 bytes: C y Python

Comencemos con algo simple.

Programa 1: C

int main(){printf("404");}

Programa 2: C y Python

#define print(X)int main(){printf("404");}
print(404)

Enlaces TIO:

• Programa C 1
• Programa Python 2

Este es solo un ejemplo, y probablemente será golpeado muchas veces.

4 idiomas, 91 bytes

C ++

#ifdef __cplusplus
#include "stdio.h"
int main(){printf("%d",404);}
#endif

C ++, C

#include "stdio.h"
int main(){printf("%d",404);}

Elimina la macro de C ++

C ++, C, Befunge

#define A "404",,,@
#include "stdio.h"
int main(){printf("%d",404);}

Agrega una macro que se ignorará en C ++, pero se leerá como código en Befunge.

C ++, C, Befunge, Python

#define A "404",,,@
#include "stdio.h"//\
print(404);'''
int main(){printf("%d",404);}//'''

Anuncia un fragmento de código que hace que la siguiente línea sea un comentario en C, pero no en Python ( //<backslash>)