N'est-ce pas gênant de trouver un morceau de code sans savoir dans quelle langue il a été écrit? Ce défi tente de résoudre un peu ce problème.

Défi

Vous devrez écrire un programme qui, lorsqu'il sera exécuté dans deux langues différentes, générera la chaîne:

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

• Dans la sortie, les noms de langue doivent avoir une capitalisation officielle. par exemple: CJam, C ++

• Aucun programme ne doit prendre aucune entrée de l'utilisateur.

• Lorsqu'il est exécuté dans les deux langues, le résultat doit être stdout ou équivalent.

• Il ne devrait y avoir aucune sortie à stderr dans les deux programmes.

• Vous pouvez utiliser des commentaires dans les deux langues.

• Deux versions différentes d'une même langue sont considérées comme des langues différentes.

  • Si cela est fait, le programme doit indiquer le numéro de version majeure et, s'il est exécuté sur deux versions mineures différentes, doit également indiquer la version mineure.

  • Vous ne devez pas utiliser de fonctions de version prédéfinies (cela inclut les variables déjà évaluées au moment de l'exécution).

Exemple de sortie:

Perl et Ruby:

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

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

Python et C:

• Python: 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 et 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 et 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!

C'est le code golf, donc le code le plus court en octets l'emporte.

Foo / CJam, 70 octets

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

Comme beaucoup l'ont découvert, dans Foo, il affiche simplement tout ce qui est entre guillemets et ignore la plupart des autres caractères ou fait quelque chose qui n'affecte pas le rendu dans la plupart des cas. En bref, \@ne fait rien et les chaînes sont toutes imprimées telles quelles.

Dans CJam, échangez \les deux éléments supérieurs et @déplace le troisième élément vers le haut, ce qui permet de disposer les chaînes dans le bon ordre. Et à la fin du programme, tout ce qui reste dans la pile est automatiquement imprimé.

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

Merci à @Hurkyls, @Qwertiys, @ jimmy23013 et @MD XF pour vos conseils.

version golfée:

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

version non golfée:

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

Petite description:

Les versions précédentes de C99 avaient juste le commentaire multiligne comme ceci:

/*foo*/

avec C99, le commentaire sur une seule ligne a été introduit. comme ça:

//foo

donc si vous compilez une ligne comme ceci:

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

le code relatif à la compilation du compilateur c99 serait:

c = -4.5 -4.5;

alors que le code pertinent pour un compilateur c89 serait:

(car le premier /ne fait pas partie d'un commentaire et doit donc être traité comme un opérateur)

c = -4.5 / -4.5;

JavaScript / Ruby, 170 octets

Peut-être que 2.0, ne semble pas fonctionner dans au moins 2.1.5 ... Edit: Mises à jour selon les conseils de @Jordan espérons que cela fonctionne dans un peu plus de versions maintenant!

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]+'!')

Abuse de l’ ~opérateur dans lequel Ruby traitera =~comme une correspondance regex renvoyant la position de la première correspondance dans la chaîne ( 0), mais JavaScript la traitera telle = ~/1/quelle -1(depuis /1/est convertie NaNpour les opérations numériques, qui a une 0valeur).

Python 2 / Python 3, 92

Utilise la vérification de version "standard" de Python (division entier vs division flottante).

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

Pêche / > <> 233 217 octets

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

La pêche est une langue basée sur un pêcheur se promener attraper du poisson. Pour faire un programme dans cette langue, il faut d’abord définir un quai sur lequel il se promène. Le quai fournit uniquement un flux de contrôle à un programme. Le quai dans ce programme est:

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

Chaque fois que la Ccommande est trouvée, le pêcheur jette sa ligne pour attraper une instruction. Les instructions +et -diminuent et augmentent la longueur de sa ligne respectivement. vchange sa direction de projection vers le bas. Les poissons qu'il attrape dans ce programme sont:

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

> <> est une langue basée sur un poisson se déplaçant dans l'eau. La vcommande commence le poisson en descendant, où il est ensuite reflété à droite avec la \commande. Tout ce qui est entre guillemets est placé dans la pile. Une fois que la ficelle est poussée sur la pile, le poisson se retourne de l’autre côté où il est réfléchi vers le bas \. Il imprime ensuite le contenu de la pile avec:

>r!`ol?!;32.

23 / Malbolge, 5688 octets

                    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?

Notez que le programme nécessite un saut de ligne de fin. Aucune ligne ne contient des espaces de fin, donc copier / coller devrait fonctionner correctement.

Vérification

Pour tester le code Malbolge dans cet interpréteur en ligne , collez-le dans la zone du code Malbolge et cliquez sur Load/Reset, puis sur Execute.

Pour tester le code 23 dans cet interpréteur en ligne , collez-le dans la zone Source , appuyez sur Enterpour insérer le saut de ligne final, tapez 23dans la zone Console (pour passer de la notation 23.dezsy par défaut à la détection automatique), puis cliquez sur Run Interpreter!.

Lua / C - 182 164 octets

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

Tirant profit de la fonctionnalité dans laquelle Lua traite un point d’empreinte sur la première ligne comme un commentaire autorisant les shebangs Unix. Sinon, les commentaires de l'autre langue sont enveloppés dans ses propres commentaires.

Pour réduire les octets, je me base sur un comportement implicite qui émet uniquement des avertissements dans GCC et Clang: déclaration implicite d’int pour la définition principale et implicite de printf.

JavaScript / Haskell, 158 octets 147 octets

Idée générale: insérez la syntaxe des commentaires de l'un dans l'autre.

En une ligne:

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

Qu'est-ce que cela ressemble à 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 ++ "!"

Qu'est-ce que cela ressemble à 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 octets

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

Une réponse extrêmement complexe et complexe ... ou pas.

C / Python, 238 caractères

Cela n'imprime pas à 100% exactement ce qui est demandé, mais assez proche.
Un redémarrage de ma carte de Saint Valentin .

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

Nouvelles lignes ajoutées pour le formatage. Essayez-le en C ou C ++ .

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

3 octets enregistrés grâce à @Cole .

Pour être exact, j'utilise Befunge-98.

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

En utilisant les faits qui:

• \ est un miroir dans> <> et échange dans Befunge
• 'string'est une chaîne dans> <> et 'cest un caractère dans Befunge

PHP / MySQL, 147 octets

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

Merci à @mathmandan pour avoir rasé 5 octets!

C'était une expérience et une expérience aussi. Toutes les suggestions de golf sont les bienvenues, car c'est assez long. J'ai fait de mon mieux pour réutiliser du texte, mais c'était assez difficile.

Techniquement, ce programme devrait sortir avec Python 3 (et je pourrais changer cela si je ne répondais pas aux spécifications - mais dans l'exemple, la sortie Python / C Pythonétait listée).

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

Essayez-le sur un interprète en ligne> <> et un Python 3 (l' interpréteur > <> nécessite que vous saisissiez le code manuellement).

Résultats

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

dans> <> et

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

en Python.

Explication (Python)

Pour le côté Python, c'est assez simple. Voici le code qui nous tient à coeur (essentiellement le code sans commentaires, qui sont désignés par un code #Python). Notez qu'en Python, \un caractère d'échappement est utilisé lorsqu'il est utilisé dans des chaînes. Il est donc \"évalué "dans la chaîne.

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

Ce qui nous importe le plus ici, ce sont les opérations effectuées sur la variable aa:

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

La déclaration d'impression est donc évaluée à

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

Explication (> <>)

Nous arrivons maintenant à la partie la plus difficile. Encore une fois, voici le code avec les bits inutiles supprimés.

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

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

Ligne 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 pile en ce moment (si imprimée): \This program wasn't written in

Ligne 2:

Notez que la ligne 2 commence par le en /raison de la position du pointeur de la ligne 1 et se déplace de droite à gauche.

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 pile en ce moment: ><> ni nettirw t'nsaw margorp sihT

Ligne 3:

Comme la ligne précédente, celle-ci commence à la \, qui est l'endroit où la ligne 2 envoie le pointeur. Notez que parce que le pointeur entoure la ligne quand il atteint la première, aje vais écrire mon explication dans l’ordre dans lequel le pointeur va (et donc ce qui est exécuté)

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 pile en ce moment ( xest le caractère formé par l'ajout de "r" et d'un espace. - ce n'est pas le caractère réel, juste un espace réservé de moi):

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

Ligne 4:

Le pointeur continue simplement vers le bas et cette ligne ne mérite aucune explication supplémentaire.

Ligne 5:

À partir /et à gauche.

.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 pile en ce moment (la sortie inversée):

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

Et ça devrait être ça pour l'explication. Faites-moi savoir s'il y a une incohérence entre l'explication / le code ou si j'ai fait quelque chose de mal. J'ai encore joué au code alors que j'étais en train d'écrire l'explication afin de pouvoir mélanger des morceaux d'ancien et de nouveau code.

Fichier .BAT par lots / Fichier .CMD par lots, 194 185 octets

@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

_{Edit: Sauvegardé 9 octets, et corrigé un manquant !grâce à DLosc}

Oui, il y a des différences entre les fichiers BAT et CMD. Référence. Essentiellement, CMD définit le ERRORLEVELsur une SETcommande, contrairement à BAT, ce qui signifie que le ERRORLEVELjeu défini par la mdcommande malformée est effacé par la SET v=1version dans une version mais pas par l'autre. Ce script est basé sur l'exemple fourni par "Ritchie" dans ce fil de discussion.

Notez que le script raccourci ci-dessus suppose ENABLEEXTENSIONSêtre défini ON(il est par défaut sur chaque plate-forme). Le script développé ci-dessous le définit explicitement pour garantir un fonctionnement correct. Sans cela, la SETcommande pour CMD n’autorise pas toutes les extensions et (sur certains systèmes, peut-être) peut ne pas définir laERRORLEVEL correctement.

Élargi et remarqué

@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 caractères

//\
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: copiez simplement le code dans la console du navigateur

CJam / GolfScript, 81 78 octets

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

Version originale de 81 octets:

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

PHP / Perl, 98 96 octets

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

Je ne sais pas si c'est de la triche ou pas, car autant que je sache, le seul moyen de faire fonctionner PHP sans <?balise d' ouverture est quelque chose du genre php -r $(cat codefile.php). Mais en supposant que ce soit légal ...// est un commentaire PHP, mais en Perl c'est un regex (qui, dans une déclaration en soi, ne fait rien). Le reste devrait être assez explicite.

Edit: Maintenant, utilisez un mot simple dans la partie Perl uniquement. Je voulais utiliser ceux-ci en premier lieu pour les deux langues, mais PHP affiche un avertissement lorsque vous le faites, contrairement à "Il ne devrait y avoir aucune sortie vers stderr".

Ruby / Python, 105 caractères

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 octets

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

Comme Array.prototype.reduce est nouveau dans la version 1.8

EDIT: Golfé 7 octets en initialisant directement aau lieu d’utiliserreverse()

EDIT: JavaScriptpeut être écrit en tant queJS , en sauvant 8 octets

EDIT: Merci Hedi pour avoir signalé que je peux économiser 3 octets de plus si je n'utilise pas la variableb plus

EDIT: Golfé sur 6 octets en calculant 7+aet 8-a, où a=1réduire est défini (JS 1.8) et a=0non défini (JS 1.7)

EDIT: Hedi a joué 6 octets supplémentaires suggérant l’utilisation de la chaîne de template

EDIT: ETHproductions a golfé 2 octets suggérant a=!![].reduce;au lieu dea=[].reduce?1:0;

EDIT: no1xsyzy a lancé un octet supplémentaire suggérant d’inverser la vérification booléenne

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

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

Utilise le fait que les guillemets doubles ""sont des codes de chaîne (c'est-à-dire une liste de codes de caractères) dans les versions de SWI-Prolog antérieures à 7 et constituent un type de chaîne approprié dans la version 7. is_list("")seront donc faux dans la version 7 et vrais dans les versions antérieures.

BF / SPL, 5342 octets

Je suis sûr que c'est le premier langage polyglotte de Shakespeare Programming Language sur ce site.

Ne va probablement pas gagner de prix. Fonctionne en insérant du code BF dans les titres d'acte, de scène ou de programme. Le code SPL utilise des points d'exclamation au lieu de points, sauf dans quelques cas. Les programmes ne sont pas censés prendre en entrée, aussi les virgules dans les déclarations de caractères sont "commentées" en mettant à zéro les cellules et en mettant des crochets autour des virgules. La même procédure s’applique lorsque vous masquez les crochets autour des instructions d’entrée / sortie.

[-][.
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]

Testez BF à l' adresse https://repl.it/E8Hh/23 .

Le code SPL a été testé sur le compilateur trouvé ici: 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, ?9la valeur ASCII de "9" correspond à 8 modulo 49. En Ruby 1.9, il s’agit de la chaîne "9". Il %49s’agit d’une opération de mise en forme qui ne fait rien car "9" n’a pas de chaîne de format dans il.

Python 2.7.9 / Python 2.7.10, 127 octets

Quelques articles ont utilisé des versions mineures, mais aucun n'a atteint un niveau inférieur ...

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)

Essayez-le sur Ideone (Python 2.7.10) et repl.it (techniquement, Python 2.7.2, mais devrait donner le même résultat que 2.7.9).

Python 2.7.10, selon le changelog :

Ajout d'un __all__au typesmodule.

Ceci poussé len(dir(types))de 42 à 43, donnant une différence numérique que nous pouvons exploiter pour générer la sortie désirée.

Python / QBasic, 160 142 octets

Testé avec Python 3 et QBasic 1.1 . Ne fonctionnera pas dans Python 2 sans ajouter from __future__ import print_functionà la ligne 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#est l'expression 1(no-op) suivie d'un commentaire. En QBasic, il s’agit d’un numéro de ligne (avec le suffixe de type le marquant comme unDOUBLE ). L' DEFSTRinstruction indique à QBasic que toutes les variables dont le nom commence par Aou B(insensible à la casse) sont des variables de chaîne. De cette façon, nous pouvons appeler nos variables aet bau lieu de a$etb$ (ce qui ne fonctionnerait pas en Python).
• En QBasic, 'commence un commentaire. En Python, ''est la chaîne vide (no-op). Ensuite, nous échangeons les noms de langue et définissons un alias pour leprint fonction (car les mots-clés QBasic sont automatiquement mis en forme en majuscules).
• Les parenthèses sur la dernière ligne ne sont pas nécessaires dans QBasic, mais ne faites pas de mal non plus.

Si je suis autorisé à désactiver l'autoformatter (qui est une option dans QB64 , mais pas dans le QBasic d'origine), je peux le réduire à 114 octets à l' aide de 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 octets

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]

Pas d’abus d’expression régulière dans celui-ci, tirant simplement parti du fait que 0 est la vérité en Ruby pour evalune définition de sort(qui en fait reverses) et printfing. Ruby n'aimait pas utiliser la liste pour les arguments, alors je devais les faire individuellement.

/// et Retina , 95 + 3 = 98 octets

/
//

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

+3 octets pour le -s drapeau dans la rétine.

Explication pour ///

La première instruction est

/
//

supprime toutes les nouvelles lignes du reste du code, ce qui entraîne

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

Tout ce qui se passe !n'est qu'un littéral et est imprimé pour STDOUT. L'instruction suivante est

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

Mais la chaîne de recherche ?.étant introuvable, rien ne se passe. Ensuite, le code restant est//! est une instruction incomplète afin que le programme se termine, après avoir imprimé la chaîne correcte.

Explication pour la rétine

/
//

Cela dit à Retina de remplacer /par //. Mais l'entrée est vide, donc cela ne correspond à rien.

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

Ceci remplace l'entrée par la chaîne dans la deuxième ligne.

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

Cela correspond à la chaîne \/\/\/, it was built for Retina!et la remplace par Retina, it was built for ///!pour donner le résultat correct.

sed / Hexagony 251 octets

/$/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: Essayez-le en ligne!
Hexagony: essayez-le en ligne!

Dans sed, la chaîne correcte est imprimée si elle correspond à la chaîne vide à la fin (toujours). La deuxième ligne est un commentaire. Cela nécessite une chaîne sur STDIN, mais il peut être vide ( autorisé en fonction de ce consensus ).

Exemple:

echo '' | sed -f whatLanguage.sed

En Hexagonie, le premier / redirige vers le bas à gauche, elle suit le côté gauche jusqu'au début de la partie sed, puis se termine de gauche à droite, d'une ligne, de droite à gauche, d'une ligne, etc. L'hexagone élargi ressemble à ceci:

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

Maintenant que j'en sais plus sur Retina et les regex, j'en ai fait un peu plus. Cela fonctionne aussi réellement maintenant.

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

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

Python imprime simplement la déclaration. Retina remplace n’importe quoi par l’instruction d’impression Python, puis supprime les printguillemets et autres. Ensuite, j'échange Pythonet Retinaet retirez le #.

Essayez en Python | Essayez dans la rétine

JavaScript / CoffeeScript, 125 124 octets

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

Dans CoffeeScript, a==best compilé jusqu'àa===b , ce qui rend la condition intermédiaire fausse. J'ai utilisé un peu de magie pour convertir la valeur booléenne en entier.

Enregistré 1 octet grâce à @DomHastings!

Version 125 octets:

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