Ich bin nicht die Sprache, die Sie suchen!

182

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.

Blau
quelle
2
"Zwei verschiedene Versionen derselben Sprache zählen als verschiedene Sprachen." Ein Trick wie mit C vor und nach 99 Kommentaren ist also gültig? easy ^^
Zaibis
1
Es fühlt sich paradox an, passt aber zu Ihren Regeln.
Zaibis,
1
Niemand macht einen Whitespace / Python-Polyglot?
Nicht dass Charles
keine Ursache. Sah die 23 Umsetzung
Nicht, dass Charles
Zählt es als Eingabe, sich darauf zu verlassen, dass das Programm mit einem bestimmten Interpreter ausgeführt wird? das heißt einschalten argv[0]?
Katze

Antworten:

86

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.

jimmy23013
quelle
7
Und nur zum Spaß gibt es eine ähnliche 75-Byte-Lösung für Fission / CJam:R"This program wasn't written in ""Fission"", it was built for ""CJam"\@'!O
Martin Ender
3
Nett. Ich hatte "This program wasn't written in Clip, it was built for CJam!"3{4-_36+e\}/für Clip / CJam.
Dennis
5
Ich bin in diesen Thread gekommen, um eine Foo-Lösung zu posten. Eigentlich hätte jeder wissen müssen, wie einfach es ist, einen Foo-Polyglott zu schreiben.
Histokrat
Gibt es einen Link zur Programmiersprachenspezifikation von Foo?
Nur die Hälfte des
1
@ErikE Erklärung hinzugefügt.
Jimmy23013
140

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;
Zaibis
quelle
10
+1 für eine wunderbare Antwort. Ein bisschen Erklärung für diejenigen, die mit C nicht vertraut sind, wäre allerdings nett.
ace_HongKongIndependence
4
@ace Ich glaube, dies basiert auf Kommentaren im C99-Stil. Beachten Sie in der vierten Zeile das //**/. In C89 ist dies der Divisionsoperator, gefolgt von einem leeren Kommentar. //Beginnt in C99 einen einzeiligen Kommentar, sodass der Rest der Zeile leer ist. Daher wird es in C89 zu (90-(-4.5/-4.5))89, während es in C99 zu (90-(-4.5-4.5))99 wird.
kirbyfan64sos
14
Um ein paar Bytes zu sparen, verwenden Sie 188-canstelle von c==99?89:99.
1
Ich denke nicht, dass Sie den Raum und die äußere Klammer mit der Aufgabe brauchen.
PurkkaKoodari
1
105 Bytes
MD XF
88

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

Dom Hastings
quelle
Diese Antwort funktioniert in Ruby 2.1.5 nicht. Ich bekomme:NoMethodError: undefined method `log' for :log:Symbol
EMBLEM
@EMBLEM Meine Tests wurden mit Ruby 2.0 durchgeführt, das in OS X integriert ist. Darüber hinaus habe ich noch nichts getestet, aber ich werde auf jeden Fall einen Kommentar hinzufügen, der darauf hinweist, dass es in einer anderen Version möglicherweise fehlerhaft ist!
Dom Hastings
In neueren Ruby-Versionen gibt eine Methodendefinition den Namen der Methode als Symbol zurück, sodass Ihre evalzurückgegeben wird :log. Ich denke, Sie könnten es beheben, indem Sie ;cnachher setzen end. Der =~/ = ~trick ist aber super!
Jordanien
Sie könnten auch sparen. Ein paar Bytes, indem Sie $><<sanstelle von puts sAnführungszeichen verwenden und doppelte Anführungszeichen verwenden, damit Sie den umgekehrten Schrägstrich einfügen können wasn\'t.
Jordanien
@ Jordan Danke! Ich bin mir nicht sicher, ob ich das Entfernen der \'in Anführungszeichen gesetzten Zeichen bemerkt habe. Das $><<bedeutet, dass ich die von Ihnen erwähnte Korrektur anwenden und die gleiche Byteanzahl beibehalten kann.
Dom Hastings
82

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))
Feersum
quelle
3
Dies wurde im Sandkasten besprochen und der Konsens bestand darin, so etwas zuzulassen
Blue
14
@flawr Wären Python und Cobra erlaubt? ;)
Beta Decay
7
@flawr Python ist eigentlich nach der Komödie ~~ group ~~ gods, Monty Python, benannt.
Mutantoe,
@Mutantoe Es mag dir so vorkommen, als wäre "Monty" kein Tier, das Wortspiel würde nicht funktionieren.
Pierre Arlaud
57

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.
Die Nummer eins
quelle
Sie können Ihren Code um 13 Byte reduzieren, indem Sie die Druckschleife für> <> in das Leerzeichen in der dritten Zeile setzen (was den Angelteil meines Erachtens nicht beeinträchtigt, obwohl ich diese Sprache nicht kenne). Ich bin mir nicht sicher, wie dieser Kommentar mit dem gesamten Code umgehen wird. Hier ist ein Link zum Schnellstart: hastebin.com/quqinozizi (Ich habe möglicherweise den Abstand in der dritten Zeile verfälscht , aber ich denke, dass alles richtig ausgerichtet ist).
Cole
@Cole Es funktioniert. In der Tat entfernt Ihr Vorschlag tatsächlich 16 Zeichen.
TheNumberOne
14
Fisch und Angelpolyglot ... möglicherweise der erste seiner Art!
Mark K Cowan
das ist so lustig was!
10.
55

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

Dennis
quelle
20
Alter ... es sieht so aus, als wäre in deinem Code eine Bombe hochgegangen!
10.
8
o_0 Wie haben Sie Malbolge-Code geschrieben?
Pavel
55

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.

benpop
quelle
3
Sehr geschickt gemacht!
Kühe quaken
2
Wenn das Entfernen von "include <stdio.h>" zu extrem ist, werde ich die Antwort zurücksetzen.
benpop
2
Warum nicht den //Kommentar im C-Teil verwenden? Spart 2 Bytes.
BrainStone
54

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++"!"
CR Drost
quelle
3
alertist golfer.
wizzwizz4
51

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.

Tödlich
quelle
21
Verdammt, du nicht wieder Foo: D
Beta Decay
5
Ich mag wie Du denkst.
Pierre Arlaud
13
Wenn Sie dies in Brainfuck ausführen, wartet Brainfuck aufgrund des ,Textes am Ende auf Eingaben . Ich glaube das verstößt gegen die Zuweisungsregeln.
Simon Forsberg
1
@ SimonForsberg es ist eine lange Zeit, aber in einem Interpreter wie online versuchen, und die meisten anderen, denke ich, ,setzt nur die Zelle auf 0, für EOF
Destructible Lemon
41

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();
ugoren
quelle
5
Was wird gedruckt, wenn es nicht genau ist?
Beta Decay
4
Das verschachtelte printf Ding ist brillant ...
immibis
4
Dies ist nicht gültig. C. Clang beschwert sich über defund :nach def main(), und Sie öffnen tatsächlich keinen Funktionskörper für main. Haben Sie tatsächlich versucht, Ihre Antwort in C zu kompilieren?
C0deH4cker
5
Die Zeile #define def main(){0?fehlt
Kay
3
#define returnbringt mich ein wenig zum weinen ...
corsiKa
32

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

grc
quelle
32
Was ist, wenn ich mich auf einer Plattform befinde, auf der int 2 Byte beträgt? Wo kann ich einen C + -Compiler bekommen?
immibis
@immibis haha: P aber im Ernst, der Trick mit der leeren Struktur könnte funktionieren:struct{}s;z=2*sizeof s
grc
31

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
PurkkaKoodari
quelle
Sofern Sie ihn nicht für den Befunge-Code benötigen (was Sie meiner Meinung nach nicht tun), können Sie 3 Bytes sparen, indem Sie die unterste Zeile ?!;>ol
cole
23

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!");
Razvan
quelle
17
Endlich eine, die ich irgendwie verstehe.
MikeTheLiar
1
Sie sollten in der Lage sein, die Klammern der zweiten Zeile für zwei Bytes weniger loszuwerden:SELECT"This program wasn't written in MySQL, it was built for PHP!";
msh210
2
Aber das wird in PHP nicht mehr funktionieren - es wird einen Parserfehler verursachen. SELECT "..." ist kein gültiger PHP-Ausdruck.
Razvan,
22

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.

cole
quelle
Es wäre falsch, wenn ich sagen würde, dass Sie die 3 hinzufügen müssten, weil es nicht Python 2 ist. Es ist in Ordnung.
Blue
Wenn diese Python waren nur, ich glaube , Sie ersetzen könnte aa[:-2][::-1]mit aa[-3::-1]. In diesem Fall kann das natürlich die> <> -Formatierung beeinträchtigen, aber es lohnt sich vielleicht zu überlegen, ob Sie dies noch nicht getan haben. Insbesondere bin ich mir ziemlich sicher, dass Sie ein Leerzeichen unter der vvorherigen Zeile benötigen , aber es sieht so aus, als print(aa[-3::-1]+"Pytho"würde es in die folgenden 24 Zeichen passen a=", it was built for "+, und dann könnten Sie ein Leerzeichen gefolgt von einfügen +"n"+a). Ich bin nicht sicher, ob dies etwas anderes kaputt machen würde, aber wenn es funktioniert, werden ein paar Bytes gespart.
Mathmandan
@mathmandan Tolle Idee, ich werde meinen Code aktualisieren und dir gutschreiben.
Cole
Gute Arbeit! FYI, ich denke , das würde in Python gut funktioniert 2 und in Python 2 können Sie ein Byte speichern , indem Sie Klammern in der print - Anweisung fallen: print aa[-3::-1]+"Pytho" +"n"+a. Eine andere Frage: Was passiert in der> <> -Version mit der 1, die ursprünglich auf den Stapel geschoben wurde?
Mathmandan
@mathmandan Ich denke, entweder der von mir verwendete Interpreter druckt das Zeichen nicht aus, wenn es ungültig ist, oder das gedruckte Zeichen wird überhaupt nicht angezeigt. Ich bin mir ehrlich gesagt nicht zu 100% sicher, warum das Drucken dieses Zeichens keine Rolle spielt. Ich habe es zufällig entdeckt.
Cole
19

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
AdmBorkBork
quelle
... gibt es einen Unterschied zwischen CMD und BAT?
Stan Strum
18

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

Qwertiy
quelle
1
@ Qwertiy, Genial!
2
Schön.
Derek 朕 朕 功夫
16

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%"!"
jimmy23013
quelle
14

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

DLosc
quelle
1
<?'>#';ist gültige Syntax in beiden Sprachen.
Primo
14

Ruby / Python, 105 Zeichen

a=["Ruby","Python"];a.sort();print("This program wasn't written in "+a[0]+", it was built for "+a[1]+"!")
Preshing
quelle
Das ist sehr gut! Besonders gefällt mir, dass dort keine Kommentare verwendet werden.
Styfle
14

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

Mario Trucco
quelle
Mit "JS" anstelle von "JavaScript" und zweimal "JS 1". in Ihrer Zeichenfolge ist kürzer als mit der Variablen b.
Hedi
Sie können den Template-String verwenden, um ihn zu verkürzen: `Dieses Programm wurde nicht in JS 1. $ {7 + a} geschrieben, sondern für JS 1. $ {8 + a}!`
Hedi
2
Ich denke , Sie zwei Bytes speichern kann durch Änderung a=[].reduce?1:0;zu a=!![].reduce;.
ETHproductions
@ETHproductions Danke, aber ich denke nicht, dass es funktionieren würde. Ich muss aden Wert halten 1oder 0, nicht trueoderfalse
Mario Trucco
@ETHproductions sorry, du hast recht, ich habe es versucht und es funktioniert. Vielen Dank!
Mario Trucco
13

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.

Tödlich
quelle
12

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

Muschelpulver314
quelle
11

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.

Histokrat
quelle
11

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.

DLosc
quelle
10

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+"!"
DLosc
quelle
-3 Bytes: Wechsel zum aktuellen QB64.
CalculatorFeline
Autoformatierung.
CalculatorFeline
QB64 / Python 2 ist 131 Bytes! Oder Python 3 für 133 Bytes.
CalculatorFeline
9

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.

Dom Hastings
quelle
Warum muss aeine Instanzvariable im Gegensatz zu einer lokalen Variable sein?
Nic Hartley,
@QPaysTaxes Das @Zeichen für eine Variable in Perl gibt an, dass es sich um eine Liste handelt. Wenn Perl beispielsweise in speichert, $awird keine Ausgabe ausgegeben.
Dom Hastings,
Ah ich sehe. Danke für die Erklärung.
Nic Hartley
9

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

Martin Ender
quelle
Wissen Sie, ich denke, es wäre trivial, eine zwischen Retina und rs zu tun ...;)
kirbyfan64sos
@ kirbyfan64sos Wahrscheinlich, aber wie kurz wäre es? ;)
Martin Ender
Nun, bis jetzt habe ich ungefähr 85 Bytes + 3 dafür bekommen -s, obwohl zu sagen, was ich getan habe, den Spaß verderben würde! : D
kirbyfan64sos
1
@ kirbyfan64sos Mach weiter und poste es, ich glaube nicht, dass ich bald Zeit habe, mich mit rs zu befassen.
Martin Ender
9

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 ; @ . . . . . .
       . . . . . . . . . . . .
        . . . . . . . . . . .
         . . . . . . . . . .
Riley
quelle
Ich werde Hexagony nie verstehen ...
DJgamer98
@ DJgamer98 Ich verstehe es auch nicht wirklich. Ich benutze es zum ersten Mal.
Riley
Sie können die Hexagony ein wenig verkürzen, indem Sie die Tatsache ausnutzen, dass ;die aktuelle Zellenmodifikation 256 verwendet wird, um einen Bytewert zu bestimmen (z. B. können Sie ein Leerzeichen mit P0;unabhängig vom aktuellen Zellenwert drucken ). Dieses CJam-Skript generiert alle Paare: cjam.tryitonline.net/…
Martin Ender
9

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

mbomb007
quelle
@ jimmy23013 Zum Zeitpunkt der Veröffentlichung dieser Challenge waren keine Limits vorhanden. Das ist ein relativ neues Merkmal von Retina.
mbomb007
8

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!")
kirbyfan64sos
quelle
Nett! Ich denke , dass Sie ein Byte mit speichern können +(b=0=='0')statt +0!
Dom Hastings
Stattdessen b^1denke ich, können Sie verwenden~b
Ismael Miguel
@IsmaelMiguel Nein. Es sagt, dass es für gebaut wurde undefinedScript.
kirbyfan64sos
Ich habe das vergessen ~1 == -2. Aber (b=0=='0')+0kann geschrieben werden +(b=0=='0'). Oder b=+(0=='0'). Das sollte 1 Byte abschneiden.
Ismael Miguel
@IsmaelMiguel Ich habe das bereits in der neuesten Version gemacht ...
kirbyfan64sos