Não é chato quando você encontra um pedaço de código e não sabe em que idioma ele foi escrito? Este desafio tenta resolver um pouco isso.

Desafio

Você precisará escrever um programa que, quando executado em dois idiomas diferentes, produzirá a string:

This program wasn't written in <language program compiled/interpreted in>, it was built for <other language the program can be run in>!

• Na saída, os nomes de idiomas devem ter letras maiúsculas oficiais. por exemplo: CJam, C ++

• Nenhum dos programas deve receber nenhuma entrada do usuário.

• Quando executado nos dois idiomas, a saída deve ser stdout ou equivalente.

• Não deve haver saída para stderr em nenhum dos programas.

• Você pode usar comentários em qualquer idioma.

• Duas versões diferentes do mesmo idioma contam como idiomas diferentes.

  • Se isso for feito, o programa deverá gerar o número da versão principal e, se estiver executando em duas versões secundárias diferentes, também deverá reportar a versão secundária.

  • Você não deve usar funções de versão pré-construídas (isso inclui variáveis ​​que já foram avaliadas em tempo de execução).

Exemplo de saída:

Perl e Ruby:

• Perl: This program wasn't written in Perl, it was built for Ruby!

• Rubi: This program wasn't written in Ruby, it was built for Perl!

Python e C:

• Pitão: This program wasn't written in Python, it was built for C!

• C: This program wasn't written in C, it was built for Python!

Python 2 e Python 3:

• Python 2: This program wasn't written in Python 2, it was built for Python 3!

• Python 3: This program wasn't written in Python 3, it was built for Python 2!

Python 2.4 e Python 2.7:

• Python 2.4: This program wasn't written in Python 2.4, it was built for Python 2.7!

• Python 2.7: This program wasn't written in Python 2.7, it was built for Python 2.4!

Esse é o código golf, portanto o código mais curto em bytes vence.

Foo / CJam, 70 bytes

"This program wasn't written in ""Foo"", it was built for ""CJam"\@"!"

Em Foo, como muitos descobriram, ele apenas imprime tudo entre aspas duplas e ignora a maioria dos outros caracteres ou faz algo que não afeta a saída na maioria dos casos. Em resumo, \@não faz nada e as seqüências de caracteres são todas impressas como estão.

No CJam, alterna \os dois itens superiores e @move o terceiro item para o topo, que organiza as seqüências na ordem correta. E depois que o programa termina, tudo o que resta na pilha é automaticamente impresso.

C89 / C99, 171 152 136 114 111 107 105 bytes

Obrigado em @Hurkyls, @Qwertiys, @ jimmy23013 e @MD XF por suas dicas.

versão golfed:

c;main(){c=-4.5//**/
-4.5;printf("This program wasn't written in C%d, it was built for C%d!",90-c,98+c);}

versão não destruída:

c;

main()
{
    c = -4.5//**/
    -4.5;
    printf("This program wasn't written in C%d, it was built for C%d!",90-c,98+c);
}

Pouca descrição:

Versões C, C99 anterior, tiveram o comentário multilinha assim:

/*foo*/

com C99, o comentário de linha única foi introduzido. como isso:

//foo

portanto, se você compilar uma linha como esta:

c =-4.5//**/
-4.5;

o código relacionado à compilação do compilador c99 seria:

c = -4.5 -4.5;

enquanto o código relevante para o compilador c89 seria:

(como o primeiro /não faz parte de um comentário e, portanto, o trata como operador)

c = -4.5 / -4.5;

JavaScript / Ruby, 170 bytes

Pode ser apenas o 2.0, não parece funcionar em pelo menos 2.1.5 ... Edit: Atualizações de acordo com o conselho do @Jordan, espero que funcione em mais algumas versões agora!

a='1';c=console=console||eval('def c.log s;$><<s end;c');c.log("This program wasn't written in "+(d=['JavaScript','Ruby'])[b= ~(a=~/1/)]+', it was built for '+d[b+1]+'!')

Abusa o ~operador em que Ruby tratará =~como uma correspondência de regex, retornando a posição da primeira correspondência na string ( 0), mas o JavaScript a tratará como = ~/1/qual é -1(já que /1/é convertida NaNem operações numéricas, que tem 0valor).

Python 2 / Python 3, 92

Usa a verificação de versão "padrão" do Python (divisão de número inteiro vs. divisão flutuante).

print("This program wasn't written in Python %d, it was built for Python %d!"%(3/2*2,4-3/2))

Pesca / > <> 233 217 bytes

v++C-CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC+CCCCCCC-CCCCCCCCCCCCCCCCCCC+CCCCCC
\   "This program wasn't written in ""><>"  ", it was built for Fishing!"
>r!`ol?!;32.                         Fishing                     ><>!`N

A pesca é uma língua baseada em um pescador andando por aí pescando. Para criar um programa nesse idioma, primeiro é necessário definir uma doca na qual ele anda. O encaixe fornece apenas o fluxo de controle para um programa. A doca neste programa é:

v++C-CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC+CCCCCCC-CCCCCCCCCCCCCCCCCCC+CCCCCC

Sempre que o Ccomando é encontrado, o pescador joga sua linha para pegar uma instrução. As instruções +e -diminuem e aumentam o comprimento de sua linha, respectivamente. vmuda sua direção de lançamento para baixo. Os peixes que ele captura neste programa são:

`This program wasn't written in Fishing, it was built for ><>!`N

> <> é uma linguagem baseada em um peixe que se move pela água. O vcomando inicia o peixe se movendo para baixo, onde é refletido à direita com o \comando. Tudo entre aspas é colocado na pilha. Depois que a corda é empurrada para a pilha, o peixe passa para o outro lado, onde é refletido para baixo \. Em seguida, imprime o conteúdo da pilha com:

>r!`ol?!;32.

23 / Malbolge, 5688 bytes

                    bCBA@?>=<;:987
                                                                                        6543210/.-,+*)
                                                                                          ('&%$#"!~}|{zy
                                                                                               xwvutsrqponmlk
                                                                                                  jihgfedcba`_^]
                                                                                     \[ZYXWVUTSRQPO
                                                                                               NMLKJIHGFEDCBA
                                                                                    @?>=<;:9y76543
                                                                210/(L,l*)(!E}
                   |B"!~}|{zyxwvu
                                                                                                     tsrqponmlkjiha
                                                                                                  fed]#a`_^]?zZY
                                                                                         XWVUTSRQ3ONMLK
                   JIHGFEDCBA:^>=
                                                                                                       <;:98705.R21q/
                                                                                               .-,+*#G'&%${"!
                                                                                            x>|{zyxwYutm3k
                                                                                                        ponmlkjihg`&^c
                                                                                     ba`_^]\[ZYXWVO
                   sSRQPONMLEi,HG
                                                                                                      FEDCBA@?>=6Z:9
                                                                                    y76543210/.-,+
                                                                                                          *)('&%$#"y?w|u
                   ;sxwvutm3qSonm
                                                                                                       fkjiha'edcba`_
                                                                                            ^]\[ZYXWVUTSRQ
                   PONM/EiIHGFEDC
                               BA@?>7[;:987w5
                                      432+O/o-,%I)('
                                     &}$#z@~}|{zsxw
                   vutsrqponmlkji
                                                                                                 ha'&dFba`_^]\U
                                                                                            yYXWVUTMRQPONM
                   LKDhH*F?DCBA@?
                                                                                                 8\<;:98765432r
                                                                                        0/.-&J*)('&f$#
                                                                                                       "!~}|{zyxwvuts
                                                                                                       rqj0nmOkjihaf_
                                                                                            %cE[!_^]\[=SwW
                                                                                                     VU7SLpPONMLEJI
                                                                                                          HAeEDC%A@?>=<;
                   :9876543210/.-
                                                                                                       ,+$H('&}${A!xw
                          ={]yxwvutsrk1o
                                                                                                 nmOejib(fedcE"
                                                                                                      `_^]?[ZYRvVUT6
                                                                                     RKo2HMLKJIHAe
                                                                                                           EDCBA@?>=<;:9
                    87w5432+O/.-,
                                                                                                 +*)('&%e#"y?w
                                                                                     |{zs9wvun4rqp
                                                                                                      onmlNjib(fedc
                                                                                           ba`_^]\[ZYXWV
                                                                                                   8TMqKPONMLKDh
                                                                                                      +GFEDCB;_?>=<
                                                                                                    ;:9y7654321*N
                    .-,+*)('&f|{A
                                                                                                       !~}|{]yxwvo5s
                                                                                             rqpinmlkjihg`
                                                                                            &dcbD`_^]\[Tx
                                                                        ;WVUTMRQJnN0F
                                                 KDhH*FEDC<A@?
     >=<5Y92765.R?

Observe que o programa requer um avanço de linha à direita. Nenhuma linha contém espaços em branco à direita; portanto, copiar / colar deve funcionar perfeitamente.

Verificação

Para testar o código Malbolge neste intérprete online , cole-o na área de código Malbolge e clique Load/Resetem Execute.

Para testar o código 23 neste intérprete online , cole-o na área Origem , pressione Enterpara inserir o avanço de linha à direita, digite 23na área Console (para alternar da notação 23.dezsy padrão para a detecção automática) e clique em Run Interpreter!.

Lua / C - 182 164 bytes

#if 0
print"This program wasn't written in Lua, it was built for C!"--[[
#endif
main(){printf("This program wasn't written in C, it was built for Lua!\n");}/*]]--*/

Aproveita o recurso em que Lua trata uma marca de hash na primeira linha como um comentário para permitir shebangs do Unix. Caso contrário, agrupa os comentários do outro idioma em seus próprios comentários.

Para barbear bytes, confio no comportamento implícito que emite apenas avisos no GCC e Clang: declaração implícita de int para a definição principal e implícita de printf.

JavaScript / Haskell, 158 bytes 147 bytes

Ideia geral: esgueirar a sintaxe do comentário de cada um para o outro.

Em uma linha:

u="This program wasn't written in ";v=", it was built for ";j="JavaScript";h="Haskell";{-console.log(u+j+v+h+"!")}//-}main=putStrLn$u++h++v++j++"!"

Como isso se parece com Haskell:

-- some variable definitions
u = "This program wasn't written in "
v = ", it was built for "
j = "JavaScript"
h = "Haskell"

-- a comment
{-console.log(u+j+v+h+"!")}//-}

-- the main method that does the dirty deed
main = putStrLn $ u ++ h ++ v ++ j ++ "!"

Como é o JavaScript:

/* variables can be declared without `var` */
u = "This program wasn't written in ";
v = ", it was built for ";
j = "JavaScript";
h = "Haskell";

/* hey look, an anonymous block! */
{ 
  /* we negate the `undefined` that comes out of console.log */
  -console.log(u+j+v+h+"!")
} 
/* there are two automatic semicolon insertions here:
   one before `}` and one before EOF. */

/* a one-line comment. */
//-}main=putStrLn$u++h++v++j++"!"

Brainfuck / Foo, 769 bytes

-[--->+<]>-.[---->+++++<]>-.+.++++++++++.+[---->+<]>+++.[-->+++++++<]>.++.---.--------.+++++++++++.+++[->+++<]>++.++++++++++++.[->+++++<]>-.--[->++++<]>-.-[->+++<]>-.--[--->+<]>--.-----.[++>---<]>++.[->+++<]>-.[---->+<]>+++.--[->++++<]>-.-----.---------.+++++++++++..+++[->+++<]>.+++++++++.-[->+++++<]>-.-[--->++<]>-.+++++.-[->+++++<]>-.+[->++<]>.---[----->+<]>-.+++[->+++<]>++.++++++++.+++++.--------.-[--->+<]>--.+[->+++<]>+.++++++++.+++[----->++<]>.------------.-[--->++<]>-.+++++++++++.[---->+<]>+++.--[->++++<]>-.-[->+++<]>-.--[--->+<]>--.+[---->+<]>+++.[->+++<]>++.[--->+<]>-.------------.+++.++++++++.[---->+<]>+++.++[->+++<]>.+++++++++.+++.[-->+++++<]>+++.+++[->++<]>.+[--->+<]>++..[--->+<]>----."This program wasn't written in Foo, it was built for Brainfuck!"

Uma resposta extremamente intrincada e complexa ... ou não.

C / Python, 238 caracteres

Isso não imprime 100% exatamente o que é solicitado, mas é bem próximo.
Uma reinicialização do meu cartão de dia dos namorados .

#define def main(){0?
#define print printf(
#define return 0)));}
#define pass 0);

def main():
    print "This program wasn't written in ",
    pass
    print "Python",
    print ", it was built for ",
    print "C",
    return

main();

C / C ++, 136

#include<stdio.h>
int main(){
char*a="++",z=sizeof'c'/2;
printf("This program wasn't written in C%s, it was built for C%s!\n",a+z,a+2-z);
}

Novas linhas adicionadas para formatação. Experimente em C ou C ++ .

Befunge / > <> , 141 138 134 133 130 bytes

3 bytes salvos graças a @Cole .

Para ser exato, estou usando o Befunge-98.

\"!><> rof tliub saw ti ,egnufeB"   >" rof nettirw t'nsaw margorp sih"'T>:#,_@'~~~~~~
>l?v"!egnufeB rof tliub saw ti ,><>"^
?!;>ol

Usando os fatos que:

• \ é um espelho em> <> e troca no Befunge
• 'string'é uma string em> <> e 'cé um caractere no Befunge

PHP / MySQL, 147 bytes

-- $argc;die("This program wasn't written in PHP, it was built for MySQL!");
SELECT("This program wasn't written in MySQL, it was built for PHP!");

Python 3 / > <> , 177 173 172 167 Bytes

Obrigado a @mathmandan por remover 5 bytes de distância!

Bem, essa foi uma experiência e também uma tentativa. Todas as sugestões de golfe são bem-vindas, pois isso é bastante longo. Eu tentei o meu melhor para reutilizar o texto, mas foi bastante difícil.

Tecnicamente, seria o Python 3 que esse programa deveria produzir (e eu poderia mudar isso se não atender às especificações - mas no exemplo a saída do Python / C Pythonfoi listada).

aa=" ni nettirw t'nsaw margorp sihT\"\""
v="><>!"                 #v   "><>"r~/
a=", it was built for "+v#\a
print(aa[-3::-1]+"Pytho" +"n"+a)
#  .4b;!?lor"!nohtyP r"~/

Experimente em um intérprete on - line> <> e um intérprete Python 3 (o intérprete > <> requer que você insira o código manualmente)

Devoluções

This program wasn't written in ><>, it was built for Python!

em> <> e

This program wasn't written in Python, it was built for ><>!

em Python.

Explicação (Python)

Para o lado Python, é bem simples. Aqui está o código com o qual nos preocupamos (basicamente o código sem comentários, que é indicado por um #em Python). Observe que no Python \é um caractere de escape quando usado em strings, portanto, é \"avaliado como "na string.

aa=" ni nettirw t'nsaw margorp sihT\"\""
v="><>!"
a=", it was built for "+v
print(aa[-3::-1]+"Pytho" +"n"+a)

O que mais nos interessa aqui são as operações executadas na variável aa:

aa[-3::-1]: reverses the string and chops off the quotation marks (thanks to @mathmandan)

A declaração de impressão é avaliada como

"This program wasn't written in " + "Pytho" + "n" + ", it was built for ><>!"

Explicação (> <>)

Agora chegamos à parte mais difícil. Mais uma vez, aqui está o código com os bits desnecessários removidos.

aa=" ni nettirw t'nsaw margorp sihT\"\
                          v   "><>"r~/
a=", it was built for "+v \a

   .4b;!?lor"!nohtyP r"~/

Linha 1:

aa=" ni nettirw t'nsaw margorp sihT\"\

aa=         pushes 1 onto the stack (evaluates 10==10, basically)
" ni ... \" pushes the first part plus a \ onto the stack.
\           deflects the pointer downwards

A pilha agora (se impressa): \This program wasn't written in

Linha 2:

Observe que a linha 2 começa com a /posição do ponteiro da linha 1 e se move da direita para a esquerda.

v   "><>"r~/

/     deflects the pointer leftwards
~r    pops the / off the stack and then reverses it
"><>" pushes ><> onto the stack
v     deflects the pointer downwards

A pilha agora: ><> ni nettirw t'nsaw margorp sihT

Linha 3:

Como a linha anterior, esta começa na \, onde é a linha 2 que envia o ponteiro. Observe que, como o ponteiro passa pela linha quando atinge o primeiro, aescreverei minha explicação na ordem em que o ponteiro vai (e, portanto, o que é executado)

a=", it was built for "+v \a

\aa=       deflect and push 1 onto the stack
", i ... " push the string onto the stack
+v         sum the last two values pushed and deflect

A pilha agora ( xé o personagem formado pela adição de "r" e um espaço. - não é o personagem real, apenas um espaço reservado meu):

xof tliub saw ti ,><> ni nettirw t'nsaw margorp sihT

Linha 4:

O ponteiro simplesmente continua para baixo, portanto essa linha não garante mais explicações.

Linha 5:

Começando /e indo para a esquerda.

.4b;!?lor"!nohtyP r"~/

~"r Python!" pops x off and adds back r and a space
r            reverses the stack
o            pops and prints a character
l?!;         pushes the length of the stack and stops if it's 0
b4.          pushes 11 then 4 then moves to that location (where o is)

A pilha agora (a saída invertida):

!nohtyP rof tliub saw ti ,><> ni nettirw t'nsaw margorp sihT

E deve ser isso para a explicação. Deixe-me saber se há alguma inconsistência entre a explicação / código ou se fiz algo errado; Joguei meu código um pouco mais enquanto escrevia a explicação, para que eu pudesse misturar pedaços de código antigo e novo.

Arquivo .BAT em lote / arquivo .CMD em lote, 194 185 Bytes

@ECHO OFF
SET a=BAT
SET b=CMD
CALL :F&&GOTO :C||GOTO :O
:C
SET a=CMD
SET b=BAT
:O
ECHO This program wasn't written for %a% File, it was built for %b% File!
GOTO :EOF
:F
md;2>nul
SET v=1

_{Editar: salvou 9 bytes e corrigiu um erro ausente !graças ao DLosc}

Sim, há diferenças entre os arquivos BAT e CMD. Referência. Essencialmente, o CMD define o comando ERRORLEVELon SET, enquanto o BAT não, o que significa que aqui o ERRORLEVELconjunto do mdcomando malformado é limpo pelo SET v=1em uma versão, mas não na outra. Este script é baseado no exemplo fornecido por "Ritchie" nesse segmento de grupo de notícias.

Observe que o script abreviado acima pressupõe ENABLEEXTENSIONSa configuração ON(por padrão em todas as plataformas). O script expandido abaixo o define explicitamente, para garantir a funcionalidade correta. Sem isso, o SETcomando do CMD não permite todas as extensões e (em alguns sistemas, talvez) pode não definir oERRORLEVEL apropriado.

Expandido e comentado

@ECHO OFF
setlocal ENABLEEXTENSIONS

REM Call the :FUNC subroutine and branch based on the resulting errorlevel
CALL :FUNC&&GOTO :CMD||GOTO :BAT

REM Just in case. If we reach this, though, hoo-boy ...
GOTO :EOF

:BAT
REM We're a BAT file, so set variables and goto output
SET a=BAT
SET b=CMD
GOTO :OUTPUT

:CMD
REM We're a CMD file, so set variables and goto output
SET a=CMD
SET b=BAT
GOTO :OUTPUT

:OUTPUT
REM Print out the result, then go to end of file
ECHO This program wasn't written for %a% File, it was built for %b% File!
GOTO :EOF

:FUNC
REM Simple subroutine to set the ERRORLEVEL appropriately
md;2>nul
REM Right now, ERRORLEVEL on both CMD and BAT is 1
SET v=1
REM Right now, ERRORLEVEL on CMD is 0, but BAT is still 1

Javascript / C, 148 146 143 caracteres

//\
alert/*
main(){puts/**/("This program wasn't written in "//\
+"Javascript"+/*
"C"/**/", it was built for "//\
+"C!")/*
"Javascript!");}/**/

C: http://codepad.org/u8UimGLc http://codepad.org/Y80M5jpc http://codepad.org/m4DB2Ndd
Javascript: basta copiar o código no console do navegador

CJam / GolfScript, 81 78 bytes

"This program wasn't written in "o"GolfScript"", it was built for ""CJam"oo"!"

Versão original de 81 bytes:

"This program wasn't written in "["CJam"", it was built for ""GolfScript"]-1a%"!"

PHP / Perl, 98 96 bytes

$a="HP";$b="erl";
//;$a=$b;$b=HP;
print"This code wasn't written in P$a, it was built for P$b!";

Não sei se isso é trapaça ou não, já que, até onde eu sei, é a única maneira de executar o PHP sem abrir <? tag de é algo parecido php -r $(cat codefile.php). Mas assumindo que isso é legal ... //é um comentário do PHP, mas no Perl é um regex (que, em uma declaração por si só, não faz nada). O resto deve ser bastante auto-explicativo.

Edit: Agora, usando uma palavra de barra na parte somente Perl. Eu queria usá-los em primeiro lugar para os dois idiomas, mas o PHP exibe um aviso quando você faz isso, ao contrário de "Não deve haver saída para o stderr".

Ruby / Python, 105 caracteres

a=["Ruby","Python"];a.sort();print("This program wasn't written in "+a[0]+", it was built for "+a[1]+"!")

JavaScript 1.8 / JavaScript 1.7, 89 bytes

a=![].reduce;`This program wasn't written in JS 1.${8-a}, it was built for JS 1.${7+a}!`

Porque Array.prototype.reduce é novo no 1.8

EDIT: Golfed out 7 bytes inicializando diretamente em avez de usarreverse()

EDIT: JavaScriptpode ser escrito comoJS , economizando 8 bytes

EDIT: Graças Hedi por apontar que eu posso salvar mais 3 bytes se eu não usar a variável bmais

EDIT: Golfed out 6 bytes pela computação 7+ae 8-a, onde a=1se reduzir está definido (JS 1.8) e a=0se não está definido (JS 1.7)

EDIT: Hedi obteve mais 6 bytes, sugerindo o uso da string de modelo

EDIT: ETHproductions obteve 2 bytes, sugerindo em a=!![].reduce;vez dea=[].reduce?1:0;

EDIT: no1xsyzy obteve mais um byte sugerindo reverter a verificação booleana

SWI-Prolog 6 / SWI-Prolog 7, 156 bytes

P='SWI-Prolog ',A=6,B=7,(is_list(""),N=A,M=B;N=B,M=A),atomic_list_concat(['This program wasn\'t written in ',P,N,', it was built for ',P,M,'!'],W),write(W).

Usa o fato de que aspas duplas ""são códigos de string (ou seja, lista de códigos de caracteres) nas versões SWI-Prolog anteriores a 7 e são um tipo de String adequado na versão 7. is_list(""), portanto, serão falsas na versão 7 e verdadeiras nas versões anteriores.

BF / SPL, 5342 bytes

Tenho certeza de que este é o primeiro poliglota da linguagem de programação de Shakespeare neste site.

Provavelmente não vai ganhar nenhum prêmio. Funciona inserindo código BF em títulos de ato / cena / programa. O código SPL usa pontos de exclamação em vez de pontos, exceto em alguns casos. Os programas não devem receber entrada; portanto, as vírgulas nas declarações de caracteres são "comentadas" zerando as células e colocando colchetes entre as vírgulas. O mesmo procedimento se aplica ao ocultar os colchetes ao redor das instruções enter / exeunt.

[-][.
Ford,.
Page,.
Act I:]+++++++++[>+++++++++<-]>+++.
Scene I:>[.
[Enter Ford and Page]
Ford:
You is sum of bad bad bad bad bad bad day and sum of bad bad bad bad day and bad bad day!Speak thy mind!
Scene II:]<<++[>++++++++++<-]>.
Page:
You is sum of bad bad bad bad bad bad day and sum of bad bad bad bad bad day and bad bad bad day!Speak thy mind!
Scene III:+.
Page:
You is sum of thyself and day!Speak thy mind!
Scene IV:++++++++++.
Page:
You is sum of thyself and sum of bad bad bad day and bad day!Speak thy mind!
Scene V:>++++[>++++++++<-]>.
Ford:
You is fat fat fat fat fat cat!Speak thy mind!
Scene VI:[-<+>]<<---.
Page:
You is sum of thyself and sum of big pig and pig!Speak thy mind!
Scene VII:++.
Page:
You is sum of thyself and fat cat!Speak thy mind!
Scene VIII:---.
Page:
You is sum of thyself and sum of big pig and pig!Speak thy mind!
Scene IX:--------.
Page:
You is sum of thyself and big big big pig!Speak thy mind!
Scene X:+++++++++++.
Page:
You is sum of thyself and sum of fat fat fat cat and sum of fat cat and cat!Speak thy mind!
Scene XI:<++++[->----<]>-.
Page:
You is sum of thyself and sum of big big big big pig and pig!Speak thy mind!
Scene XII:++++++++++++.
Page:
You is sum of thyself and sum of fat fat fat fat cat and big big pig!Speak thy mind!
Scene XIII:>.
Ford:
Speak thy mind!
Scene XIV:<++++++++++.
Page:
You is sum of thyself and sum of fat fat fat cat and fat cat!Speak thy mind!
Scene XV:<++++[->-----<]>--.
Page:
You is sum of thyself and sum of big big big big big pig and sum of fat fat fat cat and fat cat!Speak thy mind!
Scene XVI:<++++[>++++<-]>++.
Page:
You is sum of thyself and sum of fat fat fat fat cat and fat cat!Speak thy mind!
Scene XVII:-----.
Page:
You is sum of thyself and sum of big big pig and pig!Speak thy mind!
Scene XVIII:>+++++++.
Ford:
You is sum of thyself and sum of fat fat fat cat and pig!Speak thy mind!
Scene XIX:<++++++.
Page:
You is sum of thyself and sum of fat fat cat and fat cat!Speak thy mind!
Scene XX:>-------.
Ford:
You is sum of thyself and sum of big big big pig and cat!Speak thy mind!
Scene XXI:<+++.
Page:
You is sum of thyself and sum of fat cat and cat!Speak thy mind!
Scene XXII:-----.
Page:
You is sum of thyself and sum of big big pig and pig!Speak thy mind!
Scene XXIII:---------.
Page:
You is sum of thyself and sum of big big big pig and pig!Speak thy mind!
Scene XXIV:+++++++++++.
Page:
You is sum of thyself and sum of cat and sum of fat cat and fat fat fat cat.Speak thy mind!Speak thy mind!
Scene XXV:<+++[>-----<-]>.
Page:
You is sum of thyself and sum of big big big big pig and cat!Speak thy mind!
Scene XXVI:+++++++++.
Page:
You is sum of thyself and sum of fat fat fat cat and cat!Speak thy mind!
Scene XXVII:>.
Ford:
Speak thy mind!
Scene XXVIII:<-----.
Page:
You is sum of thyself and sum of big big pig and pig!Speak thy mind!
Scene XXIX:+++++.
Page:
You is sum of thyself and sum of fat fat cat and cat!Speak thy mind!
Scene XXX:>.
Ford:
Speak thy mind!
Scene XXXI:[->++<]>++.
Page:
You is sum of thyself and sum of big big big big big pig and sum of fat fat cat and cat!Speak thy mind!You is sum of thyself and sum of big pig and pig!Speak thy mind!
Scene XXXII:++++.
Page:
You is sum of thyself and big red hog!Speak thy mind!
Scene XXXIII:<+++++[>-----<-]>-.
Page:
You is sum of thyself and big big big big big pig!Speak thy mind!
Scene XXXIV:[-<+>]<------------.
Ford:
Speak thy mind!
Scene XXXV:<-----.
Page:
You is sum of thyself and sum of fat fat fat fat fat fat cat and sum of big pig and pig!Speak thy mind!
Scene XXXVI:+++++++++++.
Page:
You is sum of thyself and sum of fat fat fat cat and sum of fat cat and cat!Speak thy mind!
Scene XXXVII:>.
Ford:
Speak thy mind!
Scene XXXVIII:<+++.
Page:
You is sum of thyself and sum of fat cat and cat!Speak thy mind!
Scene XXXIX:<++++[->-----<]>--.
Page:
You is sum of thyself and sum of big big big big big pig and sum of fat fat fat cat and fat cat!Speak thy mind!
Scene XL:<++++[>++++<-]>++.
Page:
You is sum of thyself and sum of fat fat fat fat cat and fat cat!Speak thy mind!
Scene XLI:>.
Ford:
Speak thy mind!
Scene XLII:<<++++[>----<-]>-.
Page:
You is sum of thyself and sum of big big big big pig and pig!Speak thy mind!
Scene XLIII:<+++++[>++++<-]>-.
Page:
You is sum of thyself and sum of fat fat fat fat cat and sum of fat cat and cat!Speak thy mind!
Scene XLIV:------------.
Page:
You is sum of thyself and sum of big big big big pig and fat fat cat!Speak thy mind!
Scene XLV:+++.
Page:
You is sum of thyself and sum of fat cat and cat!Speak thy mind!
Scene XLVI:++++++++.
Page:
You is sum of thyself and fat fat fat cat!Speak thy mind!
Scene XLVII:>.
Ford:
Speak thy mind!
Scene XLVIII:<--------------.
Page:
You is sum of thyself and sum of big big big big pig and fat cat!Speak thy mind!
Scene XLIX:+++++++++.
Page:
You is sum of thyself and sum of fat fat fat cat and cat!Speak thy mind!
Scene L:+++.
Page:
You is sum of thyself and sum of fat cat and cat!Speak thy mind!
Scene LI:>.
Ford:
Speak thy mind!
Scene LII:>+++++++[<+++++++>-]<++.
Page:
You is sum of thyself and sum of big big big big big pig and big big big big pig!Speak thy mind!
Scene LIII:---.
Page:
You is sum of thyself and fat fat cat!Speak thy mind!
Scene LIV:----.
Ford:
You is sum of thyself and cat!Speak thy mind!
Scene LV:>+++++++[<------>-]<-.
Ford:
You is cat!
Scene LVI:>[.
[Exeunt]

Teste o BF em https://repl.it/E8Hh/23 .

O código SPL foi testado no compilador encontrado aqui: https://github.com/drsam94/Spl/ .

Ruby 1.8 / Ruby 1.9, 87

puts"This program wasn't written in Ruby 1.#{?9%49}, it was built for Ruby 1.#{?8%47}!"

No Ruby 1.8, ?9é o valor ASCII de "9", que é 8 módulo 49. No Ruby 1.9, é a string "9" e %49é uma operação de formatação que não faz nada, já que "9" não possui nenhuma string de formato em isto.

Python 2.7.9 / Python 2.7.10, 127 bytes

Tivemos algumas postagens que usavam versões menores, mas nenhuma que foi para o próximo nível abaixo ...

import types
n=len(dir(types))
print"This program wasn't written in Python 2.7.%d, it was made for Python 2.7.%d!"%(n%33,-n%52)

Experimente no Ideone (Python 2.7.10) e repl.it (tecnicamente Python 2.7.2, mas deve fornecer o mesmo resultado que o 2.7.9).

Python 2.7.10, de acordo com o changelog :

Adicionado um __all__ao typesmódulo.

Isso passou len(dir(types))de 42 para 43, dando uma diferença numérica que podemos explorar para gerar a saída desejada.

Python / QBasic, 160 142 bytes

Testado com Python 3 e QBasic 1.1 . Não funcionará no Python 2 sem adicionar from __future__ import print_functionà linha 4.

1# DEFSTR A-B
a = "QBasic"
b = "Python"
'';a,b=b,a;PRINT=print
PRINT ("This program wasn't written in " + a + ", it was built for " + b + "!")

• Em Python, 1#é a expressão 1(no-op) seguida por um comentário. No QBasic, é um número de linha (com o sufixo do tipo marcando-o como a DOUBLE). A DEFSTRinstrução informa ao QBasic que todas as variáveis ​​cujos nomes começam com Aou B(sem distinção entre maiúsculas e minúsculas) são variáveis ​​de seqüência de caracteres. Dessa forma, podemos chamar nossas variáveis ae, em bvez de a$e b$(que não funcionaria em Python).
• No QBasic, 'começa um comentário. Em Python, ''é a string vazia (no-op). Em seguida, trocamos os nomes dos idiomas e definimos um alias para a printfunção (pois as palavras-chave QBasic são formatadas automaticamente para maiúsculas).
• Os parênteses na linha final não são necessários no QBasic, mas também não prejudicam nada.

Se eu puder desativar o autoformatter (que é uma opção no QB64 , embora não no QBasic original), eu posso reduzi-lo para 114 bytes usando o Python 2 :

1#DEFSTR A-B
a="QBasic"
b="Python"
'';a,b=b,a
print"This program wasn't written in "+a+", it was built for "+b+"!"

Perl / Ruby, 129 bytes

0&&eval('def sort a,b;[b,a] end');printf"This program wasn't written in %s, it was built for %s!",(@a=sort"Perl","Ruby")[0],@a[1]

Não há abuso de expressão regular neste, apenas aproveitando ao máximo o fato de que 0 é verdade em Ruby para evaluma definição para sort(que realmente reverseé) e printfing. Ruby não gostou de usar a lista para os argumentos, então eu tive que fazer cada um individualmente.

/// e Retina , 95 + 3 = 98 bytes

/
//

This program wasn't written in \/\/\/, it was built for Retina!
/?./....(.*)(R.*)!
$2$1///!

+3 bytes para o -s sinalizador na Retina.

Explicação para ///

A primeira instrução é

/
//

remove todas as novas linhas do restante do código, resultando em

This program wasn't written in \/\/\/, it was built for Retina!/?./....(.*)(R.*)!$2$1///!

Tudo até o !final é apenas um literal e impresso para STDOUT. A próxima instrução é

/?./....(.*)(R.*)!$2$1/

Mas a cadeia de pesquisa ?.não pode ser encontrada, então nada acontece. Então o código restante //!é uma instrução incompleta para que o programa termine, depois de imprimir a sequência correta.

Explicação para Retina

/
//

Isto diz Retina para substituir /com //. Mas a entrada está vazia, então isso não corresponde a nada.

<empty>
This program wasn't written in \/\/\/, it was built for Retina!

Isso substitui a entrada pela string na segunda linha.

/?./....(.*)(R.*)!
$2$1///!

Isso corresponde à string \/\/\/, it was built for Retina!e a substitui por Retina, it was built for ///!para fornecer o resultado correto.

sed / Hexagony 251 bytes

/$/cThis program wasn't written in sed, it was built for Hexagony!
#...>32;p;r;o;g;r;\+/;a;w;23+;m;a<.;.>s;n;+39;t;+32\s/;n;e;;t;i;r;w;<. |.>+32;i;n;+32;H;e\ ;/4+;y;n;o;g;a;x;< i>4;+32;i;t;+32;\;/u;b;23+;s;a;w<h>;i;l;t;+32;f\;/;s;23+;r;o;< T>e;d;+33;@

sed: Experimente online!
Hexagonia: Experimente Online!

No sed, ele imprime a sequência correta se corresponder à sequência vazia no final (sempre). A segunda linha é um comentário. Isso requer uma string no STDIN, mas pode estar vazia ( permitida com base nesse consenso ).

Exemplo:

echo '' | sed -f whatLanguage.sed

No Hexagony, o primeiro /redireciona para o canto inferior esquerdo, segue o lado esquerdo até o início da parte sed e, em seguida, apenas envolve da esquerda para a direita, em uma linha, da direita para a esquerda, em uma linha e assim por diante. O hex expandido é assim:

         / $ / c T h i s p r 
        o g r a m w a s n ' t 
       w r i t t e n i n s e d 
      , i t w a s b u i l t f o 
     r H e x a g o n y ! # . . . 
    > 3 2 ; p ; r ; o ; g ; r ; \
   + / ; a ; w ; 2 3 + ; m ; a < .
  ; . > s ; n ; + 3 9 ; t ; + 3 2 \
 s / ; n ; e ; ; t ; i ; r ; w ; < . 
| . > + 3 2 ; i ; n ; + 3 2 ; H ; e \ 
 ; / 4 + ; y ; n ; o ; g ; a ; x ; < 
  i > 4 ; + 3 2 ; i ; t ; + 3 2 ; \
   ; / u ; b ; 2 3 + ; s ; a ; w <
    h > ; i ; l ; t ; + 3 2 ; f \
     ; / ; s ; 2 3 + ; r ; o ; < 
      T > e ; d ; @ . . . . . .
       . . . . . . . . . . . .
        . . . . . . . . . . .
         . . . . . . . . . .

Python / Retina, 133 120 119 117 115 bytes

Agora que sei mais sobre Retina e regexes, joguei um pouco mais. Na verdade, também funciona agora.

#?.*
print"This program wasn't written in Python, it was built for Retina!"
#?.*t"

#?(\w+)(,.* )(.+)!"
#$3$2$1!
#

Python apenas imprime a declaração. O Retina substitui qualquer coisa pela instrução de impressão Python e remove as printcotações. Então, eu trocar Pythone Retinae retire a #.

Experimente em Python | Experimente na Retina

JavaScript / CoffeeScript, 125 124 bytes

console.log("This program wasn't written in",(a=['Coffee','Java'])[+(b=0=='0')]+"Script, it was built for",a[b^1]+"Script!")

No CoffeeScript, a==bé compilado até a===b, o que torna a condição intermediária falsa. Usei um pouco de mágica para converter o valor booleano em um número inteiro.

Guardado 1 byte graças a @DomHastings!

Versão de 125 bytes:

console.log("This program wasn't written in",(a=['Coffee','Java'])[(b=0=='0')+0]+"Script, it was built for",a[b^1]+"Script!")