Inspirado por uma poliglota na página Stack Overflow 404 :

Objetivo

Seu objetivo é simples: criar um poliglota que emita o número 404 e depois terminar, no maior número possível de idiomas.

Restrições

Aqui está a reviravolta, há uma restrição para dificultar:

Você precisa escrever N programas e escolher N idiomas em uma ordem específica. o i- ésimo programa precisa ser impresso 404nos primeiros i idiomas, mas não em nenhum idioma após o i - i . Isso evita que soluções muito simples destruam a concorrência

Pontuação:

• O primeiro critério para determinar um vencedor é o número de idiomas em que o programa principal é executado.
• O segundo critério é a contagem de bytes, onde os programas com mais idiomas têm mais importância para esse critério.
• O terceiro e último critério é o momento da submissão

Esclarecimentos:

Os códigos-fonte dos programas não precisam ter nenhuma relação. Eles são executados como programas separados. Qualquer um dos programas pode gerar espaços em branco à esquerda e à esquerda. OS PROGRAMAS NÃO DEVEM SER SUBSEQUÊNCIAS DE CADA OUTRO!

Obrigado a @MartinEnder para uma explicação melhor!

54 idiomas, 1331 bytes

> <> , Gol> <> , Foo , Befunge-93 , Befunge-98 , brainfuck , Brain-Flak , Python 2 , Python 3 , Hexagony , Perl , Ruby , Julia , Cardeal , Brainbash , Turtlèd , Deadfish ~ , Espaço em branco , Braille , trilho , fissão , ETA , gatilho , Brainfuck auto-modificável , Numberwang , Na verdade , Emoji , Brainfuck simbólico , TinCan , Alphuck , Shove , Cood , Wise , Width , Whispers , Thue , Surface , Stones , evil , Set , Prelude , Gaot ++ , Cubix , Cubically , PATH , Commercial , Brian & Chuck, Macacos , Nhohnhehr , Feixe , AsciiDots , Alumin , Alice , Giro

Isso está ficando muito longo, então, por sugestão do @ MDXF, estou movendo os subprogramas e comentários para uma essência . O programa aqui é apenas o programa final. Agradecemos novamente ao MDXF por fornecer o driver de teste TIO.

54. Giro

##\$"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<>

Experimente online!

Whirl é descrito como um Turning Tarpit [sic], que usa apenas duas instruções, 1 e 0. 1 gira a roda de instruções atual (a roda matemática ou a roda de operações), 0 troca a rotação da roda e dois 0s executa a instrução e troca as rodas. As instruções relevantes estão na primeira linha:

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)

Os 01s iniciais se cancelam e os 01s finais causam uma exceção de ponto flutuante.

Edit: corrigido um monte de coisas quebradas

(Comandos para ter cuidado no futuro UDLR%"[.]o473psjw:)

Se algum programa funcionar para idiomas futuros ou não para idiomas atuais ou anteriores, comente.

53 idiomas, 2789 bytes

Bash, Foo, Implícito, Carvão Vegetal, Emoji,> <>, rk, Brain-Flak, C, Conjunto, Cood, Arcyou, TRANSCRIPT, SILOS, Comercial, C ++, Braille, Deadfish ~, Memescript 1.0, ETA, Python 1, Python 3, PARI / GP, Lily, Fissão, Decimal, Cubicamente, Bitwise, TinCan, Whispers, Thue, Emotinomicon, what ??!, Ook !, evil, Lennyfuck, Blablafuck, Stones, TacO, COW, Brainfuck simbólico, Underload, Rail , Reticular, Gaot ++, PATH, axo, Macacos, Nhohnhehr, xEec, VTFF, Foda K-on, Churro e Forked. Experimente tudo online no driver de teste!

Junte-se a nós na sala de bate - papo para este desafio!

Este post ficou muito grande, então aqui está uma essência contendo meu progresso. Programa final atual:

Bifurcado

#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)#"*/

Experimente online!

Meu novo (implementado) esolang!

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, Carvão vegetal, Braingolf, Espaço em branco, Deadfish ~, Deadfish, Brainfuck auto-modificável, Brainfuck simbólico, Numberwang, Cardeal, Na verdade, Fissão, Prelúdio, Flacidez cerebral (BrainHack), Alphuck, Peixe morto x, TacO, Braille, rk , mal

Esta resposta está ficando muito longa, então aqui está a resposta completa. A partir de agora, apenas o último programa será mantido aqui.

Se alguém achar que um dos programas está quebrado para um idioma ou que um programa funciona para um idioma que não deveria, informe-me.

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ạç»⠎⡆⡎⡆⢐⠣⠃

Experimente online!

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, Lírio

print(404)

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

O seguinte funciona em CJam, mas não em Python, Underload ou> <>:

404

• Para CJam: Isso envia o literal 404para a pilha. O programa termina e 404é emitido.
• Para Python: Este programa consiste em uma única expressão 404. A expressão é avaliada e o programa termina.
• Para carregar abaixo: 4e 0são comandos inválidos, o intérprete TIO simplesmente os ignora e o programa termina.
• Para> <>: 404empurrões 4, 0e 4para a pilha. O IP envolve o início e o programa se repete infinitamente.

O seguinte funciona em CJam ou Underload (embora erros), mas não em Python ou> <>:

N(404)S;(\

• Para CJam: Nenvia uma string (matriz de caracteres) contendo uma nova linha para a pilha. (exibe o caractere único (uma nova linha) da string. 404empurra 404para a pilha e a )incrementa para dar 405. S;empurra um espaço e exclui-o imediatamente. (decrementa novamente para obter 404e \troca a nova linha e o 404. 404\né emitido (a matriz vazia é exibida como nada).
• Para Subcarga: Né ignorado. (404)empurra a corda 404para a pilha. Sgera isso. ;é ignorado. (faz com que o intérprete tente procurar um fechamento ), mas, como nenhum é encontrado, o programa é segmentado.
• Para Python: esta é uma sintaxe inválida (a expressão N(404)é seguida por um identificador S, que está malformado), portanto, o erro do programa.
• Para> <>: Né uma instrução inválida, portanto, o programa erros.

O seguinte funciona em CJam (embora com erros), Underload ou Python, mas não> <>:

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

• Para CJam: []empurra a matriz vazia para a pilha e Lempurra a matriz vazia para a pilha. e=conta o número de ocorrências de []in [], giving 0. 404empurra 404para a pilha. +adiciona os dois números juntos, dando 404. Lenvia a matriz vazia para a pilha novamente e e#cria um comentário que dura até o final da linha. (tenta remover um elemento de uma matriz, mas como o elemento superior da pilha é a matriz vazia [], os erros do programa. 404ainda é emitido.
• Para Python: []é uma declaração que consiste em uma instrução no-op. Le=404define uma variável Lepara ser igual a 404. +Lepega o mais unário da variável Le(uma operação bastante inútil) e o resultado é descartado. #(404)Sé um comentário de linha. (print(404))imprime 404.
• Para carregar abaixo: A única parte relevante é (404)S, que empurra 404para a pilha e a produz. (print(404))empurra print(404)para a pilha, mas nada é feito com ela e o programa termina.
• Para> <>: [tenta exibir um número da pilha superior na pilha de metastacks e, em seguida, retira muitos elementos dessa pilha e os transforma em uma nova pilha, que é enviada para a metastack. Como não há número na pilha, os erros do programa.

O seguinte funciona em CJam (embora com erros), Python, Underload e> <>:

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

• Para CJam: A maior parte do que eu disse da última vez se aplica aqui. Em vez de ser [], agora temos uma string literal, mas o conteúdo ainda não é importante.
• Para Python: A maior parte do que eu disse da última vez se aplica aqui. Em vez de ser [], a primeira expressão não usada agora é uma string literal, mas o conteúdo ainda não é importante.
• To Underload: Tudo o que eu disse da última vez se aplica aqui. Todos os comandos ainda são ignorados.
• Para> <>: "inicia o modo de sequência e o IP envolve a primeira linha, empurrando todos os códigos de caracteres que vê para a pilha (isso não é importante). O IP envolve e acerta "novamente, o que sai do modo de seqüência de caracteres. 404envia os dígitos 404para a pilha e nnngera cada um deles (tecnicamente, isso acontece na ordem inversa, mas como 404 é um palíndromo, isso não importa). ;finaliza o programa.

Hack de cérebro em 6 idiomas, Flak cerebral, Foda cerebral, Foo, Javascript, Alphuck

Mais por vir!

Brain-Hack

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

Impressões 404 em Brain-Hack

Corte cerebral, ataque cerebral

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

Corte cerebral, ataque cerebral, foda cerebral

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

Usa comentários no Brain-Flak para imprimi-lo

Corte Cerebral, Invasão Cerebral, Foda Cerebral, Foo

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

Hack de Cérebro, Teste de Cérebro, Foda de Cérebro, Foo, Javascript

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

Corte Cerebral, Invasão Cerebral, Foda Cerebral, Foo, Javascript, Alphuck

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

5 idiomas (87 bytes)

Pyon

print(404

Experimente online!

Python 2

print(404)

Experimente online!

Flacidez Cerebral (BrainHack)

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

Experimente online!

cérebro

Retirado da resposta de Jo King, porque eu não era capaz de criar um código que tivesse os colchetes equilibrados (restrição de quebra de cérebro).

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

Experimente online!

05AB1E

Observe que isso também funciona com Ohm.

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

Experimente online!

Agradecimentos a Jo King por -6 bytes.

2 idiomas, 24 bytes, Python e lote

Programa 1: Python 3

print('404')

Programa 2: Python 3 e Lote

print('404')#|echo 404

Após o hash comentar o restante do código em python, e o | é uma instrução no bash para fazer isso se o outro comando falhar.

2 idiomas, 53 bytes: C e Python

Vamos começar com algo simples.

Programa 1: C

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

Programa 2: C e Python

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

Links TIO:

• Programa C 1
• Programa Python 2

Este é apenas um exemplo e provavelmente será derrotado muitas vezes.

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

Remove a macro C ++

C ++, C, Befunge

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

Adiciona uma macro que será ignorada em C ++, mas lida como código no Befunge.

C ++, C, Melhor, Python

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

Anúncios um pedaço de código que faz com que a próxima linha seja um comentário em C, mas não em Python ( //<backslash>)