Ist es nicht ärgerlich, wenn Sie einen Code finden und nicht wissen, in welcher Sprache er geschrieben wurde? Diese Herausforderung versucht dies zu lösen.

Herausforderung

Sie müssen ein Programm schreiben, das bei Ausführung in zwei verschiedenen Sprachen die Zeichenfolge ausgibt:

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

• In der Ausgabe sollten Sprachnamen die offizielle Groß- und Kleinschreibung haben. zB: CJam, C ++

• Keines der Programme sollte Eingaben vom Benutzer entgegennehmen.

• Wenn die Ausgabe in beiden Sprachen ausgeführt wird, sollte sie auf stdout oder gleichwertig sein.

• In beiden Programmen sollte keine Ausgabe an stderr erfolgen.

• Sie können Kommentare in beiden Sprachen verwenden.

• Zwei verschiedene Versionen derselben Sprache zählen als verschiedene Sprachen.

  • In diesem Fall sollte das Programm die Hauptversionsnummer ausgeben und bei Ausführung auf zwei verschiedenen Nebenversionen auch die Nebenversion melden.

  • Sie sollten keine vorgefertigten Versionsfunktionen verwenden (dies schließt Variablen ein, die bereits zur Laufzeit ausgewertet wurden).

Beispielausgabe:

Perl und Ruby:

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

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

Python und 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 und 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 und 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!

Dies ist Codegolf, also gewinnt der kürzeste Code in Bytes.

Foo / CJam, 70 Bytes

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

Wie viele herausgefunden haben, druckt Foo einfach alles in doppelten Anführungszeichen und ignoriert die meisten anderen Zeichen oder führt etwas aus, das die Ausgabe in den meisten Fällen nicht beeinflusst. Kurz gesagt: \@Tut nichts und die Zeichenfolgen werden wie sie sind gedruckt.

Vertauscht in CJam \die beiden obersten Elemente und @verschiebt das dritte Element nach oben, wodurch die Zeichenfolgen in der richtigen Reihenfolge angeordnet werden. Und nachdem das Programm beendet ist, wird automatisch alles gedruckt, was noch im Stapel ist.

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

Vielen Dank an @Hurkyls, @Qwertiys, @ jimmy23013 und @MD XF für Ihre Hinweise.

Golf Version:

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

ungolfed version:

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

Kleine Beschreibung:

C-Versionen vor C99 hatten nur den folgenden mehrzeiligen Kommentar:

/*foo*/

Mit C99 wurde der einzeilige Kommentar eingeführt. so was:

//foo

Also, wenn Sie eine Zeile wie diese kompilieren:

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

der für den c99 compiler compilerbezogene code wäre:

c = -4.5 -4.5;

während der für einen c89 compiler relevante code wäre:

(da der erste /nicht Teil eines Kommentars ist und daher als Operator behandelt wird)

c = -4.5 / -4.5;

JavaScript / Ruby, 170 Byte

Könnte nur 2.0 sein, scheint nicht in mindestens 2.1.5 zu funktionieren ... Bearbeiten: Updates laut Rat von @Jordan, hoffentlich funktioniert es jetzt in ein paar weiteren Versionen!

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

Missbraucht den ~Operator, indem Ruby =~als reguläre Übereinstimmung behandelt und die Position der ersten Übereinstimmung in der Zeichenfolge zurückgibt ( 0), aber JavaScript behandelt sie so, wie = ~/1/sie ist -1(da für numerische Operationen /1/konvertiert NaN, die einen 0Wert haben).

Python 2 / Python 3, 92

Verwendet die "Standard" -Python-Versionsprüfung (Ganzzahl- / Gleitkommadivision).

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

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

Fischen ist eine Sprache, die auf einem Fischer basiert, der um den Fang von Fischen herumgeht. Um ein Programm in dieser Sprache zu erstellen, muss zuerst ein Dock definiert werden, auf dem er herumläuft. Das Dock bietet nur Steuerungsfluss für ein Programm. Das Dock in diesem Programm ist:

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

Immer wenn der CBefehl gefunden wird, wirft der Fischer seine Leine aus, um eine Anweisung zu fangen. Die Anweisungen +und -verringern bzw. erhöhen die Länge seiner Zeile. vändert seine Wurfrichtung nach unten. Die Fische, die er in diesem Programm fängt, sind:

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

> <> ist eine Sprache, die auf einem Fisch basiert, der sich durch das Wasser bewegt. Der vBefehl startet die Bewegung des Fisches nach unten, wo er dann mit dem \Befehl nach rechts reflektiert wird . Alles zwischen Anführungszeichen wird auf den Stapel geschoben. Nachdem die Schnur auf den Stapel geschoben wurde, wickelt sich der Fisch auf die andere Seite, wo er von nach unten reflektiert wird \. Anschließend druckt es den Inhalt des Stapels aus mit:

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

Beachten Sie, dass das Programm einen nachgestellten Zeilenvorschub benötigt. Keine Zeile enthält nachgestellte Leerzeichen, daher sollte das Kopieren / Einfügen problemlos funktionieren.

Nachprüfung

Um den Malbolge-Code in diesem Online-Interpreter zu testen , fügen Sie ihn in den Malbolge-Codebereich ein und klicken Sie Load/Resetdann auf Execute.

Um den 23 - Code in Test dieses Online - Interpreter , es in der Paste Quelle Bereich, drücken Sie Enterden abschließenden Zeilenvorschub, Typ einfügen 23im Konsolenbereich (Umschaltung von dem Standard 23.dezsy Notation automatischer Erkennung) und klicken Sie auf 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");}/*]]--*/

Nutzt die Funktion, bei der Lua ein Hash-Zeichen in der ersten Zeile als Kommentar behandelt, um Unix-Schebangs zuzulassen. Andernfalls werden die Kommentare der anderen Sprache in eigene Kommentare eingeschlossen.

Um Bytes zu rasieren, verlasse ich mich auf implizites Verhalten, das nur Warnungen in GCC und Clang ausgibt: implizite Deklaration von int für die Haupt- und implizite Definition von printf.

JavaScript / Haskell, 158 Bytes 147 Bytes

Allgemeine Idee: Schleichen Sie die Kommentar-Syntax eines jeden in den anderen.

In einer Zeile:

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

Wie das für Haskell aussieht:

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

Wie das für JavaScript aussieht:

/* 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!"

Eine äußerst komplizierte und komplexe Antwort ... oder auch nicht.

C / Python, 238 Zeichen

Dies druckt nicht 100% genau das, was gewünscht wird, aber ziemlich nahe.
Ein Neustart meiner Valentinstagskarte .

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

Zeilenumbrüche zur Formatierung hinzugefügt. Versuchen Sie es in C oder C ++ .

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

3 Bytes gespart dank @Cole .

Um genau zu sein, verwende ich Befunge-98.

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

Mit den Fakten, die:

• \ ist ein Spiegel in> <> und tauschen in Befunge
• 'string'ist ein String in> <> und 'cein Zeichen in 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

Vielen Dank an @mathmandan für das Rasieren von 5 Bytes!

Nun, das war eine Erfahrung, und es war auch eine anstrengende. Vorschläge zum Golfen sind willkommen, da dies ziemlich lang ist. Ich habe mein Bestes versucht, um Text wiederzuverwenden, aber es war ziemlich schwierig.

Technisch wäre es Python 3, das dieses Programm ausgeben sollte (und ich könnte das ändern, wenn ich die Spezifikationen nicht erfülle - aber im Beispiel wurde die Python / C-Ausgabe Pythonaufgelistet).

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

Probieren Sie es mit einem Online-Interpreter> <> und einem Python 3-Interpreter aus (für den Interpreter > <> müssen Sie den Code manuell eingeben).

Kehrt zurück

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

in> <> und

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

in Python.

Erklärung (Python)

Für die Python-Seite ist es ziemlich einfach. Hier ist der Code, den wir interessieren (im Grunde der Code ohne Kommentare, die #in Python mit einem gekennzeichnet sind ). Beachten Sie, dass in Python \ein Escape-Zeichen ist, wenn es in Zeichenfolgen verwendet wird, sodass \"es "in der Zeichenfolge ausgewertet wird .

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

Was uns hier am meisten interessiert, sind die Operationen, die für die Variable ausgeführt werden aa:

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

Die print-Anweisung wird somit zu ausgewertet

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

Erklärung (> <>)

Jetzt kommen wir zum schwierigeren Teil. Hier noch einmal der Code, bei dem die unnötigen Bits entfernt wurden.

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

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

Linie 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

Der Stapel im Moment (falls gedruckt): \This program wasn't written in

Zeile 2:

Beachten Sie, dass Zeile 2 an der /Position des Zeigers von Zeile 1 beginnt und von rechts nach links verschoben wird.

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

Der Stack im Moment: ><> ni nettirw t'nsaw margorp sihT

Zeile 3:

Wie die vorherige Zeile beginnt diese an der Stelle \, an der Zeile 2 den Zeiger sendet. Beachten Sie, dass, da der Zeiger beim Erreichen der ersten Zeile um die Zeile herum verläuft, aich meine Erklärung in der Reihenfolge schreiben werde, in der der Zeiger sich befindet (und damit, was ausgeführt wird).

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

Der Stapel im Moment ( xist das Zeichen, das durch Hinzufügen von "r" und einem Leerzeichen gebildet wird. - Es ist nicht das eigentliche Zeichen, sondern nur ein Platzhalter von mir):

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

Zeile 4:

Der Zeiger fährt einfach nach unten fort, sodass diese Zeile keine weitere Erklärung verdient.

Zeile 5:

Beginnen Sie bei /und gehen Sie nach links.

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

Der Stack im Moment (die Ausgabe ist umgekehrt):

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

Und das sollte es für die Erklärung sein. Lassen Sie mich wissen, ob die Erklärung / der Code inkonsistent ist oder ob ich etwas falsch gemacht habe. Ich habe meinen Code noch ein wenig runtergespielt, als ich gerade die Erklärung schrieb, damit ich vielleicht ein bisschen alten und neuen Code gemischt habe.

Batch .BAT-Datei / Batch .CMD-Datei, 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

_{Edit: 9 Bytes gespeichert und ein fehlendes !dank DLosc korrigiert}

Ja, es gibt Unterschiede zwischen BAT- und CMD-Dateien. Referenz. Im Wesentlichen setzt CMD den Befehl ERRORLEVELon SET, während BAT dies nicht tut. Dies bedeutet, dass der ERRORLEVELdurch den fehlerhaften mdBefehl festgelegte Wert SET v=1in der einen Version gelöscht wird, in der anderen jedoch nicht. Dieses Skript basiert auf dem Beispiel von "Ritchie" in diesem Newsgroup-Thread.

Beachten Sie, dass das obige verkürzte Skript ENABLEEXTENSIONSals festgelegt vorausgesetzt wird ON(standardmäßig auf jeder Plattform). Das erweiterte Skript unten legt es explizit fest, um die korrekte Funktionalität zu gewährleisten. Andernfalls lässt der SETBefehl für CMD nicht alle Erweiterungen zu und setzt sie möglicherweise (auf einigen Systemen) nicht ERRORLEVELrichtig.

Erweitert und bemerkt

@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 Zeichen

//\
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: Kopieren Sie einfach den Code in die Browser-Konsole

CJam / GolfScript, 81 78 Bytes

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

Ursprüngliche 81-Byte-Version:

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

Keine Ahnung, ob dies ein Betrug ist oder nicht, da es meines Erachtens die einzige Möglichkeit ist, PHP ohne Eröffnungs- <?Tag auszuführen php -r $(cat codefile.php). Aber vorausgesetzt, das ist legal ... //ist ein PHP-Kommentar, aber in Perl ist es ein regulärer Ausdruck (der in einer Aussage für sich genommen nichts bewirkt). Der Rest sollte ziemlich selbsterklärend sein.

Bearbeiten: Verwenden Sie jetzt ein Bareword im Perl-only-Teil. Ich wollte diese in erster Linie für beide Sprachen verwenden, aber PHP zeigt eine Warnung an, wenn Sie dies tun, im Gegensatz zu "Es sollte keine Ausgabe für stderr geben."

Ruby / Python, 105 Zeichen

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}!`

Weil Array.prototype.reduce in 1.8 neu ist

BEARBEITEN : 7 Bytes durch direktes Initialisieren aanstatt Verwenden herausgesuchtreverse()

BEARBEITEN: JavaScriptkann so geschrieben werdenJS , dass 8 Byte gespart werden

EDIT: Danke Hedi für den Hinweis, dass ich 3 weitere Bytes sparen kann, wenn ich die Variable bnicht mehr benutze

BEARBEITEN : 6 Bytes durch Berechnen herausgesucht 7+aund 8-a, a=1wenn Reduzieren definiert ist (JS 1.8) und a=0wenn es nicht definiert ist (JS 1.7)

BEARBEITEN : Hedi hat 6 weitere Bytes ausgegeben, was auf die Verwendung einer Template-Zeichenfolge hindeutet

EDIT: ETHproductions hat 2 Bytes vorgeschlagen a=!![].reduce;anstatta=[].reduce?1:0;

BEARBEITEN : no1xsyzy hat ein weiteres Byte herausgespielt und schlägt vor, den Booleschen Check umzukehren

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

Verwendet die Tatsache, dass doppelte Anführungszeichen ""in SWI-Prolog-Versionen, die älter als 7 sind, Zeichenfolgencodes (dh eine Liste von Zeichencodes) sind und is_list("")in Version 7 einen geeigneten Zeichenfolgentyp darstellen. Dies ist in Version 7 falsch und in früheren Versionen wahr.

BF / SPL, 5342 Bytes

Ich bin mir ziemlich sicher, dass dies der erste mehrsprachige Shakespeare-Programmierer auf dieser Site ist.

Ich werde wahrscheinlich keine Preise gewinnen. Schleicht BF-Code in Act / Scene / Program-Titel. Der SPL-Code verwendet bis auf wenige Fälle Ausrufezeichen anstelle von Punkten. Die Programme dürfen keine Eingaben machen, daher werden die Kommas in den Zeichendeklarationen "auskommentiert", indem Zellen auf Null gesetzt und eckige Klammern um die Kommas gesetzt werden. Das gleiche Verfahren gilt, wenn die eckigen Klammern um die enter / exeunt-Anweisungen ausgeblendet werden.

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

Testen Sie BF unter https://repl.it/E8Hh/23 .

Der SPL-Code wurde beim Compiler getestet, der hier zu finden ist: 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}!"

In Ruby 1.8 ?9ist dies der ASCII-Wert von "9", 8 modulo 49. In Ruby 1.9 ist dies die Zeichenfolge "9" und %49eine Formatierungsoperation, die nichts bewirkt, da "9" keine Formatzeichenfolgen enthält es.

Python 2.7.9 / Python 2.7.10, 127 Byte

Wir hatten ein paar Posts, in denen kleinere Versionen verwendet wurden, aber keine, die in die nächsthöhere Stufe gegangen sind ...

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)

Probieren Sie es auf Ideone (Python 2.7.10) und repl.it (technisch Python 2.7.2, sollte aber das gleiche Ergebnis wie 2.7.9 liefern).

Python 2.7.10 laut Changelog :

Fügte ein __all__zum typesModul hinzu.

Dies wurde len(dir(types))von 42 auf 43 verschoben, was einen numerischen Unterschied ergibt, den wir ausnutzen können, um die gewünschte Ausgabe zu erzeugen.

Python / QBasic, 160 bis 142 Byte

Getestet mit Python 3 und QBasic 1.1 . Funktioniert nicht in Python 2, ohne from __future__ import print_functionZeile 4 hinzuzufügen .

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

• In Python 1#folgt auf den Ausdruck 1(no-op) ein Kommentar. In QBasic ist es eine Zeilennummer (mit dem Typensuffix als DOUBLE). Die DEFSTRAnweisung teilt QBasic mit, dass alle Variablen, deren Namen mit Aoder B(ohne Berücksichtigung der Groß- / Kleinschreibung) beginnen, Zeichenfolgenvariablen sind. Auf diese Weise können wir unsere Variablen aund banstelle von a$und aufrufen b$(was in Python nicht funktioniert).
• Beginnt in QBasic 'einen Kommentar. Ist in Python ''die leere Zeichenfolge (no-op). Dann tauschen wir die Sprachnamen aus und definieren einen Alias ​​für die printFunktion (da die QBasic-Schlüsselwörter automatisch in Großbuchstaben formatiert werden).
• Die Klammern in der letzten Zeile sind in QBasic nicht erforderlich, schaden aber auch nichts.

Wenn ich den Autoformatierer ausschalten darf (eine Option in QB64 , aber nicht im ursprünglichen QBasic), kann ich ihn mit Python 2 auf 114 Bytes reduzieren :

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]

Kein Missbrauch von regulären Ausdrücken in diesem Beispiel, nur das Beste aus der Tatsache, dass 0 in Ruby wahr ist, zu evaleiner Definition für sort(was eigentlich ist reverse) und printfing. Ruby mochte es nicht, die Liste für die Argumente zu verwenden, also musste ich jedes einzeln durchführen.

/// und Retina , 95 + 3 = 98 Bytes

/
//

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

+3 Bytes für die -sFlagge in der Netzhaut.

Erklärung für ///

Die erste Anweisung ist

/
//

Entfernt alle Zeilenumbrüche aus dem Rest des Codes, was dazu führt, dass

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

Alles bis zum !ist nur ein Literal und wird an STDOUT gedruckt. Die nächste Anweisung ist

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

Die Suchzeichenfolge ?.kann jedoch nicht gefunden werden, sodass nichts passiert. Dann ist der verbleibende Code //!eine unvollständige Anweisung, sodass das Programm beendet wird und die richtige Zeichenfolge gedruckt wurde.

Erklärung für die Netzhaut

/
//

Dies sagt Retina zu ersetzen /mit //. Die Eingabe ist jedoch leer, sodass sie mit nichts übereinstimmt.

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

Dadurch wird die Eingabe durch die Zeichenfolge in der zweiten Zeile ersetzt.

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

Dies stimmt mit der Zeichenfolge überein \/\/\/, it was built for Retina!und ersetzt sie durch Retina, it was built for ///!, um das richtige Ergebnis zu erzielen.

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: Online ausprobieren!
Hexagony: Probieren Sie es online!

In sed wird die richtige Zeichenfolge ausgegeben, wenn sie (immer) mit der leeren Zeichenfolge am Ende übereinstimmt. Die zweite Zeile ist ein Kommentar. Dies erfordert eine Zeichenfolge für STDIN, kann jedoch leer sein ( basierend auf diesem Konsens zulässig ).

Beispiel:

echo '' | sed -f whatLanguage.sed

In Hexagony werden die ersten /Umleitungen nach links unten ausgeführt. Sie folgen der linken Seite bis zu dem Punkt, an dem der Sed-Teil beginnt. Anschließend werden die Zeilen von links nach rechts, von rechts nach links, eine Zeile nach unten usw. umbrochen . Das erweiterte Hex sieht folgendermaßen aus:

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

Jetzt, wo ich mehr über Retina und Regexes weiß, habe ich ein bisschen mehr Golf gespielt. Es funktioniert jetzt auch tatsächlich.

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

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

Python druckt nur die Anweisung. Retina ersetzt alles durch die Python-Druckanweisung und entfernt dann die printund Anführungszeichen. Dann tausche ich Pythonund Retinaund entferne die #.

Versuchen Sie es in Python | Versuchen Sie es in Retina

JavaScript / CoffeeScript, 125 - 124 Byte

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

In CoffeeScript a==bwird bis kompiliert a===b, wodurch die Zwischenbedingung falsch wird. Ich habe ein bisschen Magie benutzt, um den Booleschen Wert in eine Ganzzahl umzuwandeln.

Dank @DomHastings 1 Byte gespart!

125-Byte-Version:

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