¿No es molesto cuando encuentras un código y no sabes en qué idioma está escrito? Este desafío intenta resolver esto de alguna manera.

Desafío

Tendrá que escribir un programa que, cuando se ejecute en dos idiomas diferentes, genere la cadena:

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

• En la salida, los nombres de los idiomas deben tener mayúsculas oficiales. por ejemplo: CJam, C ++

• Ninguno de los programas debe recibir ninguna entrada del usuario.

• Cuando se ejecuta en ambos idiomas, la salida debe ser stdout o equivalente.

• No debería haber salida para stderr en ninguno de los programas.

• Puede usar comentarios en cualquier idioma.

• Dos versiones diferentes del mismo idioma cuentan como idiomas diferentes.

  • Si se hace esto, el programa debería generar el número de versión principal y, si se ejecuta en dos versiones menores diferentes, también debería informar la versión menor.

  • No debe usar funciones de versión preconstruidas (esto incluye variables que ya se han evaluado en tiempo de ejecución).

Salida de ejemplo:

Perl y Ruby:

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

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

Python y C:

• Pitón: 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 y 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 y 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!

Este es el código de golf, por lo que gana el código más corto en bytes.

Foo / CJam, 70 bytes

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

En Foo, como muchos han descubierto, simplemente imprime todo entre comillas dobles e ignora la mayoría de los otros caracteres o hace algo que no afecta la salida en la mayoría de los casos. En resumen, \@no hace nada y las cadenas se imprimen tal cual.

En CJam, \intercambia los dos elementos superiores y @mueve el tercer elemento a la parte superior, que organiza las cadenas en el orden correcto. Y una vez que finaliza el programa, todo lo que queda en la pila se imprime automáticamente.

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

Gracias a @Hurkyls, @Qwertiys, @ jimmy23013 y @MD XF por sus sugerencias.

versión de golf:

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

versión sin golf:

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

Pequeña descripción:

Las versiones C anteriores a C99 solo tenían el comentario de varias líneas como este:

/*foo*/

con C99 se introdujo el comentario de una sola línea. Me gusta esto:

//foo

así que si compilas una línea como esta:

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

el código relacionado con la compilación del compilador c99 sería:

c = -4.5 -4.5;

mientras que el código relevante para un compilador c89 sería:

(ya que el primero /no es parte de un comentario y por lo tanto se trata como operador)

c = -4.5 / -4.5;

JavaScript / Ruby, 170 bytes

Podría ser solo 2.0, no parece funcionar en al menos 2.1.5 ... Editar: Actualizaciones según el consejo de @Jordan, ¡ espero que funcione en algunas versiones más ahora!

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 del ~operador porque Ruby tratará =~como una coincidencia de expresiones regulares que devuelve la posición de la primera coincidencia en la cadena ( 0), pero JavaScript lo tratará como lo = ~/1/que es -1(ya que /1/se convierte NaNpara operaciones numéricas, que tiene 0valor).

Python 2 / Python 3, 92

Utiliza la verificación de versión de Python "estándar" (división de enteros vs.

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

La pesca es un lenguaje basado en un pescador que anda pescando . Para hacer un programa en este idioma, primero tiene que definir un muelle en el que camina. El dock solo proporciona flujo de control a un programa. El muelle en este programa es:

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

Cada vez que Cse encuentra el comando, el pescador lanza su línea para atrapar una instrucción. Las instrucciones +y -disminuyen y aumentan la longitud de su línea respectivamente. vcambia su dirección de lanzamiento hacia abajo. Los peces que atrapa en este programa son:

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

> <> es un lenguaje basado en un pez que se mueve a través del agua. El vcomando comienza a mover el pez hacia abajo, donde luego se refleja a la derecha con el \comando. Todo entre comillas se empuja a la pila. Después de que la cuerda se empuja hacia la pila, el pez se enrolla hacia el otro lado donde se refleja hacia abajo \. Luego imprime el contenido de la pila con:

>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?

Tenga en cuenta que el programa requiere un salto de línea final. Ninguna línea contiene espacios en blanco al final, por lo que copiar / pegar debería funcionar bien.

Verificación

Para probar el código de Malbolge en este intérprete en línea , péguelo en el área de código de Malbolge y haga clic en Load/Reset, luego Execute.

Para probar el código 23 en este intérprete en línea , péguelo en el área Fuente , presione Enterpara insertar el salto de línea final, escriba 23en el área Consola (para cambiar de la notación 23.dezsy predeterminada a la detección automática) y haga clic 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");}/*]]--*/

Aprovecha la función donde Lua trata una marca de hash en la primera línea como un comentario para permitir shebangs de Unix. De lo contrario, envuelve los comentarios del otro idioma en sus propios comentarios.

Para reducir bytes, confío en el comportamiento implícito que solo emite advertencias en GCC y Clang: declaración implícita de int para la definición principal e implícita de printf.

JavaScript / Haskell, 158 bytes 147 bytes

Idea general: introducir la sintaxis de comentarios de cada uno en el otro.

En una linea:

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++"!"

Cómo se ve esto para 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 ++ "!"

Cómo se ve esto en 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!"

Una respuesta extremadamente compleja y compleja ... o no.

C / Python, 238 caracteres

Esto no imprime 100% exactamente lo que se solicita, pero está bastante cerca.
Un reinicio de mi tarjeta de San Valentín .

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

Nuevas líneas agregadas para formatear. Pruébalo en C o C ++ .

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

3 bytes guardados gracias a @Cole .

Para ser exactos, estoy usando Befunge-98.

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

Usando los hechos que:

• \ es un espejo en> <> e intercambia en Befunge
• 'string'es una cadena en> <> y 'ces un carácter en 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

¡Gracias a @mathmandan por eliminar 5 bytes!

Bueno, esta fue una experiencia, y también una prueba. Cualquier sugerencia de golf es bienvenida, ya que esto es bastante largo. Hice todo lo posible para reutilizar el texto, pero fue bastante difícil.

Técnicamente, sería Python 3 el que debería generar este programa (y podría cambiarlo si no cumpliera con las especificaciones, pero en el ejemplo Pythonse enumeró la salida de Python / C ).

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"~/

Pruébelo en un intérprete en línea> <> y en un intérprete de Python 3 (el intérprete > <> requiere que ingrese el código manualmente)

Devoluciones

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

en> <> y

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

en Python

Explicación (Python)

Para el lado de Python, es bastante simple. Aquí está el código que nos interesa (básicamente el código sin comentarios, que se denota con un #en Python). Tenga en cuenta que en Python \es un carácter de escape cuando se usa en cadenas, por lo que se \"evalúa "en la cadena.

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

Lo que más nos importa aquí son las operaciones realizadas en la variable aa:

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

La declaración impresa se evalúa así

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

Explicación (> <>)

Ahora llegamos a la parte más difícil. Una vez más, aquí está el código con los bits innecesarios eliminados.

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

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

Línea 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

La pila en este momento (si está impresa): \This program wasn't written in

Línea 2:

Tenga en cuenta que la línea 2 comienza en la /posición del puntero desde la línea 1 y se mueve de derecha a izquierda.

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

La pila en este momento: ><> ni nettirw t'nsaw margorp sihT

Línea 3:

Al igual que la línea anterior, esta comienza en \, que es donde la línea 2 envía el puntero. Tenga en cuenta que debido a que el puntero se ajusta alrededor de la línea cuando llega al primero a, escribiré mi explicación en orden de dónde va el puntero (y, por lo tanto, qué se ejecuta)

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

La pila en este momento ( xes el personaje formado por la adición de "r" y un espacio. No es el personaje real, solo un marcador de posición de mi parte):

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

Línea 4:

El puntero simplemente continúa hacia abajo, por lo que esta línea no garantiza más explicaciones.

Línea 5:

Comenzando en /y yendo hacia la izquierda.

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

La pila en este momento (la salida se invirtió):

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

Y eso debería ser todo por la explicación. Avíseme si hay alguna inconsistencia entre la explicación / código o si hice algo mal; Aprendí un poco más mi código mientras estaba escribiendo la explicación para poder mezclar fragmentos de código antiguo y nuevo.

Batch .BAT File / Batch .CMD File, 194185 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: se guardaron 9 bytes y se corrigió la falta !gracias a DLosc}

Sí, hay diferencias entre los archivos BAT y CMD. Referencia. Esencialmente, CMD establece el comando ERRORLEVELen un SETcomando, mientras que BAT no lo hace, lo que significa que aquí el ERRORLEVELconjunto del mdcomando con formato incorrecto se borra SET v=1en una versión pero no en la otra. Este script se basa en el ejemplo proporcionado por "Ritchie" en ese hilo del grupo de noticias.

Tenga en cuenta que la secuencia de comandos abreviada de arriba se supone ENABLEEXTENSIONSque se establece ON(de forma predeterminada en todas las plataformas). El script expandido a continuación lo establece explícitamente para garantizar la funcionalidad correcta. Sin eso, el SETcomando para CMD no permite todas las extensiones, y (en algunos sistemas, tal vez) podría no establecerlo ERRORLEVELadecuadamente.

Ampliado y remarcado

@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: simplemente copie el código a la consola del navegador

CJam / GolfScript, 81 78 bytes

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

Versión 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!";

No sé si esto es trampa o no, ya que, por lo que puedo decir, la única forma de ejecutar PHP sin una <?etiqueta de apertura es algo así php -r $(cat codefile.php). Pero suponiendo que sea legal ... //es un comentario de PHP, pero en Perl es una expresión regular (que, en una declaración en sí misma, no hace nada). El resto debería explicarse por sí mismo.

Editar: ahora usando una palabra desnuda en la parte de solo Perl. En primer lugar, quería usarlos para ambos idiomas, pero PHP muestra una advertencia cuando lo hace, contrario a "No debería haber salida para 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 es nuevo en 1.8

EDITAR: Golfed 7 bytes inicializando directamente en alugar de usarreverse()

EDITAR: JavaScriptse puede escribir comoJS , ahorrando 8 bytes

EDIT: Gracias por Hedi señalando que puedo ahorrar 3 bytes más si yo no uso la variable bmás

EDITAR: Golfed 6 bytes calculando 7+ay 8-a, donde a=1si se define la reducción (JS 1.8) y a=0si no está definido (JS 1.7)

EDITAR: Hedi jugó 6 bytes más, lo que sugiere el uso de una cadena de plantilla

EDITAR: ETHproductions arrojó 2 bytes sugiriendo en a=!![].reduce;lugar dea=[].reduce?1:0;

EDITAR: no1xsyzy jugó un byte más sugiriendo revertir el cheque booleano

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

Utiliza el hecho de que las comillas dobles ""son códigos de cadena (es decir, una lista de códigos de caracteres) en las versiones SWI-Prolog anteriores a 7, y son un tipo de cadena adecuado en la versión 7. is_list(""), por lo tanto, será falso en la versión 7 y verdadero en las versiones anteriores.

BF / SPL, 5342 bytes

Estoy bastante seguro de que este es el primer políglota del lenguaje de programación de Shakespeare en este sitio.

Probablemente no gane ningún premio. Funciona infiltrando el código BF en los títulos de acto / escena / programa. El código SPL usa puntos de exclamación en lugar de puntos, excepto en algunos casos. Se supone que los programas no deben ingresar datos, por lo que las comas en las declaraciones de caracteres se "comentan" al poner a cero las celdas y poner corchetes alrededor de las comas. El mismo procedimiento se aplica al ocultar los corchetes alrededor de las instrucciones 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]

Pruebe BF en https://repl.it/E8Hh/23 .

El código SPL se probó en el compilador que se encuentra aquí: 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}!"

En Ruby 1.8, ?9es el valor ASCII de "9", que es 8 módulo 49. En Ruby 1.9, es la cadena "9", y %49es una operación de formateo que no hace nada ya que "9" no tiene cadenas de formato en eso.

Python 2.7.9 / Python 2.7.10, 127 bytes

Hemos tenido un par de publicaciones que utilizan versiones menores, pero ninguna que haya pasado al siguiente nivel ...

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)

Pruébelo en Ideone (Python 2.7.10) y repl.it (técnicamente Python 2.7.2, pero debería dar el mismo resultado que 2.7.9).

Python 2.7.10, de acuerdo con el registro de cambios :

Se agregó una __all__al typesmódulo.

Esto pasó len(dir(types))de 42 a 43, dando una diferencia numérica que podemos explotar para generar la salida deseada.

Python / QBasic, 160 142 bytes

Probado con Python 3 y QBasic 1.1 . No funcionará en Python 2 sin agregar from __future__ import print_functiona la línea 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 + "!")

• En Python, 1#es la expresión 1(no-op) seguida de un comentario. En QBasic, es un número de línea (con el sufijo de tipo que lo marca como a DOUBLE). La DEFSTRdeclaración le dice a QBasic que todas las variables cuyos nombres comienzan con Ao B(sin distinción entre mayúsculas y minúsculas) son variables de cadena. De esa manera, podemos llamar a nuestras variables ay en blugar de a$y b$(que no funcionaría en Python).
• En QBasic, 'comienza un comentario. En Python, ''es la cadena vacía (no-op). Luego intercambiamos los nombres de los idiomas y definimos un alias paraprint función (dado que las palabras clave QBasic se formatean automáticamente en mayúsculas).
• Los paréntesis en la línea final no son necesarios en QBasic, pero tampoco hacen daño a nada.

Si se me permite apagar el autoformatter (que es una opción en QB64 , aunque no en el QBasic original), puedo bajarlo a 114 bytes usando 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]

No hay abuso de expresiones regulares en este, solo aprovechando el hecho de que 0 es verdadero en Ruby para evaluna definición de sort(que realmente reversees) e printfing. A Ruby no le gustaba usar la lista para los argumentos, así que tuve que hacer cada uno individualmente.

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

/
//

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

+3 bytes para el -s bandera en Retina.

Explicación para ///

La primera instrucción es

/
//

elimina todas las nuevas líneas del resto del código, lo que resulta en

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

Todo hasta el !es simplemente un literal e impreso en STDOUT. La siguiente instrucción es

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

Pero la cadena de búsqueda ?.no se puede encontrar, por lo que no sucede nada. Entonces, el código restante //!es una instrucción incompleta, por lo que el programa termina, después de haber impreso la cadena correcta.

Explicación para la retina

/
//

Esto le dice a la retina para sustituir /a //. Pero la entrada está vacía, por lo que esto no coincide con nada.

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

Esto reemplaza la entrada con la cadena en la segunda línea.

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

Esto coincide con la cadena \/\/\/, it was built for Retina!y la reemplaza Retina, it was built for ///!para dar el resultado correcto.

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: ¡ Pruébelo en línea!
Hexagonía: ¡ Pruébelo en línea!

En sed, imprime la cadena correcta si coincide con la cadena vacía al final (siempre). La segunda línea es un comentario. Esto requiere una cadena en STDIN, pero puede estar vacío ( permitido según este consenso ).

Ejemplo:

echo '' | sed -f whatLanguage.sed

En Hexagony, el primero /redirige a la parte inferior izquierda, sigue el lado izquierdo hasta donde comienza la parte sed, luego se envuelve de izquierda a derecha, baja una línea, de derecha a izquierda, baja una línea, y así sucesivamente. El hexágono expandido se ve así:

         / $ / 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

Ahora que sé más sobre Retina y expresiones regulares, lo he jugado un poco más. También en realidad funciona ahora.

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

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

Python solo imprime la declaración. Retina reemplaza cualquier cosa con la declaración de impresión de Python, luego elimina las printcomillas y cualquier. Entonces, me cambiaré Pythony Retinay quitar la #.

Probar en Python | Prueba en 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!")

En CoffeeScript, a==bse compila en a===b, lo que hace que la condición intermedia sea falsa. Usé un poco de magia para convertir el valor booleano en un entero.

¡Guardado 1 byte gracias a @DomHastings!

Versión 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!")