Das Programmiersprachen-Quiz


189

Herzlichen Glückwunsch an Dennis, der sowohl die Herausforderung der Bullen als auch der Räuber gewonnen hat! Calvins Hobbys haben sein Versprechen bereits eingelöst und diese Herausforderung für Dennis geschrieben, weil er die Räuberherausforderung gewonnen hat.

Hinweis: Diese Challenge ist ab 2015-09-01 02:00:00 UTC für weitere Cop-Antworten geschlossen. Alle neuen Antworten sind nicht gewinnberechtigt und zählen nicht für die Räuberwertung, wenn sie geknackt werden. Sie können jedoch immer noch neue Antworten für die anderen Benutzer veröffentlichen, sodass für zukünftige Besucher noch einige Rätsel verfügbar sind. Diese neuen Antworten sind im Abschnitt "Vulnerable Cops" der Rangliste enthalten, und ihr Nichtkonkurrenzstatus wird separat gekennzeichnet.

Willkommen zur Cops-and-Robbers-Ausgabe des Hello World Quiz ! (Wenn Sie das Quiz noch nie gespielt haben, können Sie es eine oder 30 Minuten lang ausprobieren. Sie müssen es für diese Herausforderung jedoch nicht gespielt haben.)

Die Herausforderung der Polizei

  1. Wählen Sie eine Programmiersprache. Gültige Sprachen müssen entweder einen englischen Wikipedia-Artikel , einen Esolangs-Artikel oder einen Rosetta-Code-Artikel zum Zeitpunkt der Veröffentlichung dieser Herausforderung enthalten (beachten Sie, dass die verknüpften Listen nicht unbedingt vollständig sind, da sie manuell erstellt wurden). Sie müssen auch unseren üblichen Standards für Programmiersprachen entsprechen , so dass Dinge wie HQ9 + draußen sind. Schließlich muss ein kostenloser (wie im Bier) Dolmetscher oder Compiler für die Sprache verfügbar sein (zum Zeitpunkt der Veröffentlichung dieser Herausforderung).
  2. Schreiben Sie ein Hello World-Programm. Das heißt, schreiben Sie ein vollständiges Programm in der gewählten Sprache, das Hello, World!(genau so, dh genau dieser Byte-Datenstrom) und optional eine einzelne nachgestellte Newline zu STDOUT oder der nächstgelegenen Alternative druckt.

    Sie dürfen keine REPL-Umgebung, keinen vorhandenen Boilerplate-Code oder nicht standardmäßige Compiler- / Interpreter-Flags annehmen. Das Programm muss in Form einer oder mehrerer Quelldateien vorliegen (um eigenwillige Sprachen wie Ordner auszuschließen ) und muss vollständig in Ihre Antwort passen (es darf also nicht länger als 30.000 Zeichen sein) - dies sollte kein Problem für sein jede ernsthafte Vorlage.

    Wenn Ihr Code Bytes außerhalb des druckbaren ASCII-Bereichs enthält, fügen Sie bitte einen Pastebin oder Hex-Dump ein, um sicherzustellen, dass Ihr Code tatsächlich testbar ist.

    Das Programm muss auf einem typischen Desktop-PC innerhalb von 1 Minute beendet werden.

Das ist es. Der Haken ist, dass Sie Ihren Code so verschleiern möchten, dass nicht klar ist, welche Sprache Sie gewählt haben. Beachten Sie auch, dass Ihr Code nicht versehentlich ein gültiges Hello World-Programm in einer anderen Sprache sein soll, obwohl ich davon ausgehe, dass dies für ausreichend verschleierte Programme unwahrscheinlich ist.

Sie dürfen auf keinen Fall den Quellcode Ihres Beitrags ändern, sobald dieser veröffentlicht wurde (da dies die aktiven Versuche eines Räubers, Ihre Antwort zu knacken, ungültig machen kann). Stellen Sie also sicher, dass Sie Golf spielen, so gut Sie können (oder es wagen), bevor Sie etwas veröffentlichen. Wenn Sie feststellen, dass Ihre Antwort nach dem Posten nicht funktioniert, löschen Sie einfach Ihre Antwort und veröffentlichen Sie eine feste Version, wenn Sie möchten.

Wenn niemand eine Sprache findet, in der Ihr Code 7 Tage lang gültig ist, können Sie die gewählte Sprache offenlegen (idealerweise mit einer Erklärung für Ihren verschleierten Code), was Ihre Antwort sicher macht . Beachten Sie, dass Ihr Beitrag immer noch geknackt werden kann, bis Sie die Sprache enthüllen.

Die kürzeste sichere Übermittlung (in Byte) gewinnt.

Formatierung

(Überspringen Sie diesen Abschnitt und lesen Sie The Robbers 'Challenge, wenn Sie gerade nicht vorhaben, als Polizist teilzunehmen.)

Am Ende dieses Beitrags finden Sie ein Stack-Snippet, das Bestenlisten generiert, sowie eine Liste von Einsendungen, die noch geknackt werden können. Damit das Snippet funktioniert, ist es wichtig, dass Sie einen bestimmten Header in Ihre Antwort einfügen:

  • Neue Antworten sollten einen Header wie enthalten

    # ???, [N] bytes
    

    Wo [N]ist die Größe Ihres Codes in Bytes und ???sollte wörtlich angezeigt werden.

  • Wenn die Antwort 7 Tage lang nicht geknackt wird und Sie Ihre Antwort durch Offenlegen der Sprache sicher machen möchten, ersetzen Sie einfach die ???, z

    # Ruby, [N] bytes
    

    Fühlen Sie sich frei, den Namen der Sprache auf eine relevante Website wie eine Esolangs-Seite oder ein GitHub-Repository verlinken zu lassen. Der Link wird dann in der Bestenliste angezeigt.

  • Wenn ein anderer Benutzer Ihren Beitrag erfolgreich geknackt hat (siehe unten), fügen Sie bitte auch die Sprache hinzu, zusammen mit einem Hinweis wie

    # Ruby, [N] bytes, cracked by [user]
    

    Wo [user]ist der Name des Benutzers, der den ersten gültigen Riss eingereicht hat? Wenn die in dem Riss verwendete Sprache von der von Ihnen beabsichtigten abweicht, würde ich empfehlen, die Vermutung der Räuber zu verwenden und in der Antwort zu erwähnen, dass Sie beabsichtigten, dass es sich um etwas anderes handelt. Fühlen Sie sich frei, den Benutzernamen als Link zu ihrer Profilseite zu verwenden.

Die Herausforderung der Räuber

  1. Finde eine verletzliche Antwort. Das ist eine Antwort, die noch nicht geknackt wurde und die noch nicht sicher ist.
  2. Knacken Sie es, indem Sie seine Sprache herausfinden. Das heißt, finden Sie alle Sprachen, in denen das angegebene Programm ein gültiges Hello World-Programm ist (vorbehaltlich der Regeln in The Cops 'Challenge oben). Es ist egal, ob dies die Sprache ist, die der Cop beabsichtigt hat.

    Wenn Sie eine solche Sprache gefunden haben, hinterlassen Sie einen Kommentar mit dem Namen der Sprache. Wenn möglich, sollten Sie einen Link zu einem Online-Dolmetscher einfügen, der zeigt, dass der Code tatsächlich in der gewünschten Sprache funktioniert.

Jeder Benutzer erhält nur eine Vermutung pro Antwort. Sie dürfen Ihre eigene Antwort nicht knacken (offensichtlich ...).

Der Benutzer, der die meisten Antworten geknackt hat, gewinnt die Herausforderung der Räuber. Krawatten werden durch die Summe der Bytes der geknackten Antworten unterbrochen (mehr ist besser).

Da die Räuberherausforderung ausschließlich in Kommentaren festgehalten wird, gibt es für die Räuber keinen Rufanreiz. Der Großmeister des Herausforderungsschreibens, Calvins Hobbys , hat jedoch freundlicherweise angeboten, eine Herausforderung über den Benutzer zu schreiben, der die Herausforderung der Räuber gewinnt!

Herausforderungs-Dashboard

Das Stack Snippet unten generiert Bestenlisten für die Bullen und Räuber und listet auch alle Antworten auf, die noch geknackt werden können. Lassen Sie mich wissen, wenn etwas nicht richtig funktioniert, und ich werde versuchen, es so schnell wie möglich zu beheben. Wenn Sie sich zusätzliche Funktionen vorstellen können, die das Dashboard nützlicher machen würden, hinterlassen Sie ebenfalls einen Kommentar.


108
Eine Schweigeminute für diejenigen, die nur Piet programmieren können.
User3819867

19
Da geht meine Produktivität!
Luke,

11
Ich denke, ich könnte anfangen zu debattieren, ob ich anfangen sollte, Foo als Schimpfwort zu benutzen ... "Oh, Foo! Du kleiner FOO !!" Ja, passt perfekt.
kirbyfan64sos

Antworten:


38

Wach auf , 17 Bytes

":"Hello, World!"

Laut der offiziellen Website ,

Wake ist eine Programmiersprache, die die Essenzen von Makefile, regulären Ausdrücken und Musterübereinstimmungen von funktionalen Programmiersprachen enthält.

Wake wurde von Shinh erstellt und kann auf seinem Golfserver Anarchy Golf getestet werden .

Der Code besteht aus einer einzelnen Zeile, die ein Ziel / Etikett und eine Aktion enthält. Da die Aktion ein String-Literal ist, wird sie an STDOUT ausgegeben.

Das Verwenden "für das Ziel diente zwei Zwecken:

  • Es bietet Polyglot-Schutz.

    Clip und Foo drucken :; GolfScript und CJam lösen einen Syntaxfehler aufgrund einer unvollendeten Zeichenfolge aus.

  • Es gibt ein wenig Unsicherheit darüber, wie der Code funktionieren soll.


1
Sieht so aus, als wäre dies die beste Einsendung.
Primo

Ich habe eine Sprache gefunden, in der es gemäß der lose definierten Spezifikation funktioniert, aber der einzige noch vorhandene Compiler, soweit ich weiß, hat einen Fehler, der dazu führt, dass es fehlschlägt.
Histokrat

Meine beiden Theorien dazu lauten wie folgt: 1: Es könnte sich um eine Sprache mit willkürlichen Zeilenbezeichnungen handeln, die ":ein gültiges Zeilenpräfix darstellt und ein String-Literal in der tatsächlichen Zeile als Ausgabebefehl behandelt. Oder 2: Dass es String - Substitution und <foo>:<bar>entfernt <foo>aus <bar>. Ectoforte von der esolangs-Wiki-Forte-Seite erfüllt eine Art von 1, aber der verknüpfte Interpreter bricht mit einem doppelten Anführungszeichen im Etikett und ich weiß nicht, ob es ganz als Sprache gilt.
Histokrat

1
Gut gemacht, Dennis. Ich hatte gehofft, dass mein 20-Byte-One endlich gut genug ist, um der Top-Gewinner zu sein. Was für eine Bedrohung! : P Das ist ein neuer Avatar, oder?
mbomb007

@ mbomb007 Ich habe Ihren Kommentar gelesen, bevor Sie ihn bearbeitet haben. Ja, der Avatar ist brandneu.
Dennis

147

TinyBF , 708 Bytes, geknackt von kirbyfan64sos

Das war ein verrückter Spaß. Jeder weiß, dass ich nur eine Sprache schreiben kann;)

I,c,o,d,e,C;i;main(){i++;for(i++;i^9;i++)putchar(((i+69)*!(i+2*~0)|(9!=9+(I=((i-1)>>(i+2*~0))+~(!(i+2*~0)+~0)))*111|115*(6>i+1)*(i>3)+~(i>(10+(9>i)+~i+(i>9)))+(5<i)+(i<5)+1|(c=(i>6))|(o=(i>=7+!i))|(d=(i>>1>3)*(i*((i+~0>5)<<2)+(i>~2+i)))|(e=(i-~0>(i|5)&&32>>i)*99)|(C=(i>>(i>>2+i/7)>0)*(i+(i<<1)+(i<<2)+(i<<3)+(i<<4)>=(i!=6)*(5>=i)*(i+(i<<5)))*(i+(i*i)+62)*((i==6)!=!i)))+(i*i+(i<<1)+(31+i^i)+(i+i)*~0+2*i)*(1==(i==7)));I|=(c+=(o>d)),2*(c+C>o+d);e^=(d>>c)|4;I-=(e>C)+(I+c+(o==C)-~7*(C<=I)>>(C>=o));C=(e>>2)^(I-~o==c),o=255>>((int)1e7*(c-~1)>>(C+e+d+o+I)),i|=i+(e>=d)+(2<<I)+(3<<c);putchar(!(I+d+c>=(C|e))?(I>o)+(d=(20*(I==c))>>(1==~I+d+e+(C==(1>=(I==C))))):(I+o+C)*((C+e)/5+C+I+20+I+I==1>>(o>>(d>=(C!=I)))));}

Erläuterung

Zuallererst hat es viele, viele Stunden gedauert, also bin ich überwältigend erfreut über all die positiven Reaktionen und Versuche, es zu knacken!

Wie in den Kommentaren erwähnt, wird beim Kompilieren in C der Code Gotcha!gefolgt von einer neuen Zeile gedruckt, bei TinyBF jedoch die gewünschte Hello, World!. TinyBF ist ein einfaches Derivat von Brainf ** k , die mit nur 4 seiner 8 Befehle ersetzt: + > | =. Da alle anderen Zeichen ignoriert werden, könnte ich gerne ein C-Programm mit vielen unnötigen Operatoren schreiben, um zu versuchen, die Leute in die falsche Richtung zu führen (was zu meiner Überraschung ziemlich gut funktionierte). Hier ist der reine TinyBF-Code:

++++++++|=+=>>++++|>+>+>+>++>+++|=>|=>=+|=>>>+>+>+|=>|>>|=>>>>+>++++>==>=+++===+++++++====|=+=>+>+=>>|=>+++===>>>==>>===>>>>++++|=+>=++++>=|>+===>>==+++==>===++++++++==>>>>>==

Hier ist das gleiche Programm, geschrieben in normalem BF:

++++++++[->>++++[>+>+>+>++>+++[<]>-]>>>+>+>+[<]<<]>>>>+>++++>.>---.+++++++..[->+>+<<]>+++.<<<.<<.>>>>++++[-<++++>]<-.>>.+++.>.--------.<<<<<.

Mit diesem Interpreter können Sie von BF nach TinyBF konvertieren und den Code ausführen.


30
Ich sehe eine Definition für main(). Könnte es C sein? http://codepad.org/pj9mQgyQ (Hinweis: Es gibt aus Gotcha!)
DDPWNAGE

1
Anhand Ihrer Antworten und einiger Unterlagen sage ich, dass dies Fission ist . Alles von I,c,o,d,e,C;i;main()würde ignoriert (abgesehen davon, ;aber es scheint nicht wichtig zu sein), und die große Menge !davon, die zur Ausgabe von ASCII-Zeichen verwendet wird, könnte ein Zeichen dafür sein, dass es das ist. Ich kann Fission 's Interpreter nicht herunterladen und jetzt nachsehen.
Fatalize

1
@Fatalize Solide Vermutung, aber es ist keine Spaltung :) Zum Starten des Programms wird ein 'L' oder ein 'R' benötigt, da sich alles in einer Zeile befindet.
BrainSteel

47
Es ist TinyBF !!!!!!
kirbyfan64sos

6
Herzlichen Glückwunsch zum goldenen Abzeichen für diesen Beitrag. : D
Alex A.

113

Übel , 658 Bytes, geknackt von Sp3000

#!/sbin/fortran

Hello, World = 'SCBsIG8gICBvIGwgIQogZSBsICwgVyByIGQKYm9zcnJ1a3R2cG54cHN2eGJ5eWJkeG9iaHJ0eHV0SGF0eXJhcGF4eW5wYWFuenhkdnBidnZuYWRhcXZoZGFhcEVxcnZkcWF1YXh0ZW5ncXJ4ZXF2d2ZndWRueXZweWR1d0x2eHhydHZidW55ZHJucW5ocGhidG5neWR3eHd0c3V3d0x2c3d0cHVueHVwdHJwaWhhaG16ZXNiaXdweWdnanVocU9saHV3eWVwaGNyeW1naHBhaW5wZGRnZWJuZ2Z1eGRwZnV3eXNienJ2enh0YnRyaXZ6ZW54eWR3eGhodHh2YVd0eXF6dnVwZWdndnVnY3d0c2NhZWRnaWRyaXJ1aHV0d09tZGRwdHJueXVneG5iYXBueG96d2FweGR3enRna21wZ1Jjc29oeHVoZ3Z4Y3V3eXV5end2cXZ1ZG52ZWJudW16d0x2YWZoeXR2ZW91YXdoYW90YXN0ZWNuY3V2cG5odXVwZ0RiY2d2ZW15cnV0ZG9id3J5dWFyYXN3Z3hhdHdkZnJkYnN3cXJ4dWJzYXf='.decode('base64').rsplit(' ', 1)

print Hello, World

Das Böse ist ein alter Esolang, ein bisschen wie BF. Bei den Befehlen handelt es sich ausschließlich um Kleinbuchstaben. Andere Zeichen werden einfach ignoriert.

Zuerst habe ich mit Python ein kurzes Hallo-Welt-Programm in Evil generiert:

aeeeaeeewueuueweeueeuewwaaaweaaewaeaawueweeeaeeewaaawueeueweeaweeeueuw

Dann, wieder mit Python, habe ich es in einen base64-String umgewandelt:

Ym9zcnJ1a3R2cG54cHN2eGJ5eWJkeG9iaHJ0eHV0eXJhcGF4eW5wYWFuenhkdnBidnZuYWRhcXZoZGFhcnZkcWF1YXh0ZW5ncXJ4ZXF2d2ZndWRueXZweWR1eHhydHZidW55ZHJucW5ocGhidG5neWR3eHd0c3V3c3d0cHVueHVwdHJwaWhhaG16ZXNiaXdweWdnanVoaHV3eWVwaGNyeW1naHBhaW5wZGRnZWJuZ2Z1eGRwZnV3eXNienJ2enh0YnRyaXZ6ZW54eWR3eGhodHh2eXF6dnVwZWdndnVnY3d0c2NhZWRnaWRyaXJ1aHV0ZGRwdHJueXVneG5iYXBueG96d2FweGR3enRna21wc29oeHVoZ3Z4Y3V3eXV5end2cXZ1ZG52ZWJudW16YWZoeXR2ZW91YXdoYW90YXN0ZWNuY3V2cG5odXVwY2d2ZW15cnV0ZG9id3J5dWFyYXN3Z3hhdHdkZnJkYnN3cXJ4dWJzYXf=

Das entschlüsselt sich in Kleinbuchstaben:

bosrruktvpnxpsvxbyybdxobhrtxutyrapaxynpaanzxdvpbvvnadaqvhdaarvdqauaxtengqrxeqvwfgudnyvpyduxxrtvbunydrnqnhphbtngydwxwtsuwswtpunxuptrpihahmzesbiwpyggjuhhuwyephcrymghpainpddgebngfuxdpfuwysbzrvzxtbtrivzenxydwxhhtxvyqzvupeggvugcwtscaedgidriruhutddptrnyugxnbapnxozwapxdwztgkmpsohxuhgvxcuwyuyzwvqvudnvebnumzafhytveouawhaotastecncuvpnhuupcgvemyrutdobwryuaraswgxatwdfrdbswqrxubsaw

Ich habe ein paar andere Dinge zum base64-String hinzugefügt und ihn dann als Python-Programm oben geschrieben.

Der Shebang ist eigentlich wichtig im Programm. Das svor dem bin sbinwird den bBefehl überspringen . Dann wird die fin fortranscannt nach vorne bis zum nächsten mZeichen, die in dem Base64 - String ist.


13
Nun, das ist interessant . Habe ein +1 :)
Sp3000

6
Sieht aus wie Python ...
Zizouz212

9
Entweder ist dies eine wirklich obskure Version / Ableitung von Python, bei der die Base64-Dekodierung auf seltsame Weise funktioniert, oder der Base64-Kauderwelsch ist nicht wirklich Base64 in der richtigen Sprache. Ich kann mir keine andere mögliche Erklärung vorstellen, aber vielleicht wird es jemand anderes tun.
ETHproductions

27
In zwei Stunden setze ich alles auf diese Vermutung: Ist das böse ?
Sp3000,

4
@Rob evil dekodiert den base64-String nicht - der String ist selbst ein Programm. Die Zeichen aeeeaeee...werden mit zufälligen Zeichen gemischt, sodass die resultierende Zeichenfolge eine gültige base64-Zeichenfolge ist. Ich habe die zufälligen Zeichen so gewählt, dass die resultierende Zeichenfolge mit der Basis 64 in Kleinbuchstaben dekodiert wird, aber die dekodierte Zeichenfolge ist eigentlich irrelevant - es ist nur eine Ablenkung. Das Einzige, was zählt, ist, dass das Böse die base64-Zeichenfolge ausführt, die Groß- und Kleinbuchstaben jedoch ignoriert, da sie keine Befehle sind, und das Hello World-Programm verlässt.
Grc

99

Lua, 2920 2865 Bytes, geknackt von jimmy23013

Ich habe diese Sprache erst gestern gelernt, also verzeihen Sie Syntaxfehler.

 --[[~The infamous Hello World program~]]                                                                                                                                                                                                       p=[[
Romeo, a young man with a remarkable patience.
Juliet, a likewise young woman of remarkable grace.
Ophelia, a remarkable woman much in dispute with Hamlet.
Hamlet, the flatterer of Andersen Insulting A/S.


                    Act I: Hamlets insults and flattery.

                    Scene I: The insulting of Romeo.

[Enter Hamlet and Romeo]

Hamlet:
 You lying stupid fatherless big smelly half-witted coward!
 You are as stupid as the difference between a handsome rich brave
 hero and thyself! Speak your mind!

 You are as brave as the sum of your fat little stuffed misused dusty
 old rotten codpiece and a beautiful fair warm peaceful sunny summer's
 day. You are as healthy as the difference between the sum of the
 sweetest reddest rose and my father and yourself! Speak your mind!

 You are as cowardly as the sum of yourself and the difference
 between a big mighty proud kingdom and a horse. Speak your mind.

 Speak your mind!

[Exit Romeo]

                    Scene II: The praising of Juliet.

[Enter Juliet]

Hamlet:
 Thou art as sweet as the sum of the sum of Romeo and his horse and his
 black cat! Speak thy mind!

[Exit Juliet]

                    Scene III: The praising of Ophelia.

[Enter Ophelia]

Hamlet:
 Thou art as lovely as the product of a large rural town and my amazing
 bottomless embroidered purse. Speak thy mind!

 Thou art as loving as the product of the bluest clearest sweetest sky
 and the sum of a squirrel and a white horse. Thou art as beautiful as the difference between Juliet and thyself.
 Speak thy mind! Let them]] print -- (She pauses) -- it in the streets!
 --[[Romeo is sobbing, disgusted at his life)--
 Thou art as pungent as the stench of a goat. Speak thy mind!
 [[Exeunt Romeo]]
 "Hello, World!" -- No response. "Hello!" He calls out again, but to no avail.

[[Exeunt Ophelia and Hamlet


                    Act II: Behind Hamlet's back.

                    Scene I: Romeo and Juliet's conversation.

[Enter Romeo and Juliet]

Romeo:
 Speak your mind. You are as worried as the sum of yourself and the
 difference between my small smooth hamster and my nose. Speak your
 mind!

Juliet:
 Speak YOUR mind! You are as bad as Hamlet! You are as small as the
 difference between the square of the difference between my little pony
 and your big hairy hound and the cube of your sorry little
 codpiece. Speak your mind!

[[Exit Romeo]
[[

                    Scene II: Juliet and Ophelia's conversation.

[Enter Ophelia]

Juliet:
 Thou art as good as the quotient between Romeo and the sum of a small
 furry animal and a leech. Speak your mind!

Ophelia:
 Thou art as disgusting as the quotient between Romeo and twice the
 difference between a mistletoe and an oozing infected blister! Speak
 your mind!

[Exeunt]]

Warnung: Es wird "Hallo Welt!" und wird dann mit einem Fehler beendet

Erläuterung:

In Lua bedeutet - [[mehrzeiliger Kommentar, - einzeiliger Kommentar und [[mehrzeiliger String.

Wenn Sie in der ersten Zeile ganz zur Seite scrollen, sehen Sie ein sehr verdächtiges p = [[. Dies definiert eine mehrzeilige Zeichenfolge, die von "Romeo, ein junger Mann" bis hinunter zu "Let them]]" reicht, über die die meisten Leute einen Blick werfen, die jedoch tatsächlich die mehrzeilige Zeichenfolge beenden. Dann haben wir print, das ist die Druckfunktion, und dann macht "-" den Rest der Zeile zu einem Kommentar. Wir müssen etwas Platz zwischen dem Druck und der Hallo-Welt schaffen, damit wir sie nicht verraten, also haben wir einen mehrzeiligen Kommentar: "- [[Romeo schluchzt, angewidert über sein Leben) - Du bist so scharf wie der Gestank einer Ziege Sprich deine Meinung aus! [[Exeunt Romeo]] "Das]] am Ende beendet den mehrzeiligen Kommentar und in der Zeile danach steht" Hallo, Welt! " und dann wird der Rest der Zeile durch ein - auskommentiert.

   Thou art as loving as the product of the bluest clearest sweetest sky
     and the sum of a squirrel and a white horse. Thou art as beautiful as the difference between Juliet and thyself.
     Speak thy mind! Let them]] print 
     "Hello, world!" 

8
Ist es Shakespeare?
SuperJedi224

Siehe Beispielcode, es ist Shakespeare: en.wikipedia.org/wiki/…
max_

24
Es ist Lua. (mindestens 15 Zeichen)
Jimmy23013

44
Lua als Shakespeare verkleidet. Genius! +1
ETHproductions

Eigentlich druckt es Hello, world!nicht Hello, World!.
Dennis

83

TRANSCRIPT , 39 Bytes

End is here.
>End, Hello, World!
>X End

Hier ist eine schöne und einfache.


Erster sicherer Bulle! Ich bin überrascht, dass dies bis zum Ende gedauert hat - ich habe versucht, eine Sprache auszuwählen, die schwer direkt nachzuschlagen ist, die aber leichter zu knacken ist, wenn Sie das Thema erraten können.

TRANSCRIPT ist ein Esolang, der auf interaktiven Fiction-Spielen basiert. Es hat NPCs (Strings) und Objekte (Ganzzahlen). Hier Endist der Name eines NPCs.

Die erste Zeile deklariert den NPC mit der Syntax <name> is here.. Die zweite Zeile weist dem NPC dann die Zeichenfolge zu "Hello, World!", und die dritte Zeile gibt die Zeichenfolge mit dem X / EXAMINEBefehl aus. Hier ist nicht viel Platz für Verschleierung, also habe ich nur etwas ausgewählt, das normalerweise kein Name für den NPC ist.

Um zu beweisen, dass TRANSCRIPT eine gültige Sprache für diese Herausforderung ist, gibt es ein Programm, das prüft, ob eine eingegebene natürliche Zahl eine Primzahl ist oder nicht:

The Nineteenth Room
In the middle of the room you spot a lone figure.
Martin is here.
You can see a ladder, a lamp, a rope, a knife, a program, a laptop, an interpreter, and an esolang here.

>RESTORE
Which save file would you like to restore?

>PROGRAM.sav
Done.

>SET LAMP TO 1
You turn on the lamp.

>LIFT KNIFE
You pick up the knife, feeling powerful.

>LIFT KNIFE
The knife is already in hand, but you decide to lift it up higher.
You know knives aren't dumbbells, right?

>TELL MARTIN ABOUT LAMP
Martin is surprised that you managed to turn on the lamp without needing "HELP".

>HELP
Too bad, no hints for you.

>SHOW KNIFE TO MARTIN
You pull out the knife.
Martin picks up his phone and starts calling for the police.
You quickly realise your mistake and apologise profusely. Good job.

>ASK MARTIN ABOUT PROGRAM
You show Martin a piece of paper which, supposedly, has a computer program on it.
The program appears to be written in a strange and foreign language.
Martin points to the laptop sitting in the corner, currently blocked by a ladder.

>LIFT LADDER
You move the ladder slightly out of the way.

>SHOW PROGRAM TO MARTIN
Martin doesn't respond. He's too busy trying to golf esolang quines.

>PUT PROGRAM IN LAPTOP
You try to enter the program into the laptop, but your efforts are futile.
The laptop is off.

>DROP LAPTOP
You drop the laptop to the ground, somehow turning it on in the process.
Just kidding, it's still off. The screen has an extra crack now though.

>ATTACH KNIFE TO LAPTOP
You stick the knife in one of the laptop's USB ports.
The laptop turns on.

>SET ROPE TO 0
You grab both ends of the rope and tie a knot, forming a loop.

>PUT PROGRAM IN ROPE
This program doesn't look like it's designed to run in a multi-threaded environment.

>CUT ROPE WITH KNIFE
The knife is powering the laptop.

>HIT ROPE WITH KNIFE
The knife is still (somehow) powering the laptop.

>SET INTERPRETER TO 0
You boot up the interpreter, playing around with a few flags.

>PUT PROGRAM IN INTERPRETER
You enter the program into the interpreter.

>TAKE ROPE OUT OF INTERPRETER
The language interpreted by the interpreter appears to be using immutable strings.

>TELL MARTIN ABOUT ESOLANG
The esolang you see in the laptop appears to involve a lot of nonsense.

>SHOW INTERPRETER TO MARTIN
You show Martin the output of the program. It says: "Hello, World!"

>ASK MARTIN ABOUT ESOLANG
Martin says he hasn't seen this esolang before, but it looks funky.
You get so excited about this new esolang that you knock over the ladder.

>LIFT LADDER
You pick the ladder up and move it a bit further away.

>SHOW ESOLANG TO MARTIN
Martin tries to study the language.

>DETACH KNIFE FROM LAPTOP
You pull the knife out from the laptop.
The laptop turns off.

>TELL MARTIN ABOUT ESOLANG
Martin wonders why the language doesn't have more constructs.
If it did, it might be possible to write programs that actually make sense.

>SHOW LADDER TO MARTIN
Martin argues that it's actually a stepladder.

>ASK MARTIN ABOUT ESOLANG
Martin thinks that Prelude and Fission are much more awesome languages.

>MARTIN, Your number was prime.
Martin raises an eyebrow, wondering what you're on about.

>SHOW ESOLANG TO MARTIN
Martin shows *you* Prelude. It is indeed more awesome.

>TELL MARTIN ABOUT LAMP
Martin already knows about the lamp, remember?

>SHOW LADDER TO MARTIN
It's a stepladder.

>ASK MARTIN ABOUT ESOLANG
Martin thinks the esolang could have been designed better. It's fun to write, though.

>MARTIN, Your number was not prime.
You say this to Martin, but the message isn't intended for Martin.
Martin seems to realise.

>SHOW ESOLANG TO MARTIN
The esolang seems to be called "TRANSCRIPT".

>EXAMINE MARTIN
It's rude to stare at people like that.

>EXIT
Thank goodness this charade is over.

Als Randnotiz, ich war seit @ aditsus Vermutung tatsächlich nervös, was sehr nahe lag. Inform 7 ist eine Sprache zum Erstellen interaktiver Fiction-Spiele, von denen ich nicht einmal wusste, dass sie existieren.

Als Hommage an Aditsus Versuch habe ich Inform 7 ausprobiert:

"aditsu's close guess" by Sp3000

The Nineteenth Byte is a room.
"abandon all work, ye who enter here —aditsu"

The laptop is a device in the Nineteenth Byte. A llama is here.

Carry out switching on the laptop:
    say "Hello, World!"

Und hier ist ein Probelauf:

Bildbeschreibung hier eingeben


3
@aditsu Nein, aber das ist ein interessanter Fehler: "Im Satz '> Ende, Hallo, Welt!> X Ende' kann ich kein Verb finden, mit dem ich umgehen kann. (Ich bemerke, dass hier ein Komma steht , das manchmal verwendet wird, um Regeln abzukürzen, die normalerweise mit einem Doppelpunkt geschrieben werden - zum Beispiel "Vor der Einnahme: Sagen Sie" Sie ziehen Atem "." kann mit "Vor der Einnahme, sagen Sie ..." abgekürzt werden - aber das ist nur erlaubt für Vorher, Stattdessen und Nachher Regeln. Ich erwähne all dies, falls Sie diesen Satz in einem Regelwerk als Regel bezeichnet haben, aber ein Komma verwendet haben, bei dem ein Doppelpunkt hätte stehen sollen ':'?) "
Sp3000

17
Meine Güte, das ist der lustigste Esolang, den ich je gesehen habe! Ich liebe dein bestes Beispiel. +1
ETHproductions

15
"> PUT PROGRAM IN ROPE" "Dieses Programm sieht nicht so aus, als würde es in einer Umgebung mit mehreren Threads ausgeführt." Gute 5 Sekunden laut lachen!
Kroltan,

1
"Martin argumentiert, dass es eine Trittleiter ist"? Fand den Ace Attorney Fan;)
Deusovi

6
"> SEIL AUS DEM INTERPRETER ENTNEHMEN" "Die vom Interpreter interpretierte Sprache scheint unveränderliche Zeichenketten zu verwenden." xD
ev3commander

64

Headsecks , 637 Bytes, geknackt von Dennis

( say `first hello by sp3000` )
( harp hahs
 ( pink shark )
 ( is `chars` )
 ( hash `chars` )
 ( harks `snap exit crew` )
)
( hiss
 ( chain crude typo )
 ( hi scrap )
 ( brrr yaws )
 ( skips ads )
 ( ship arks )
 ( raps paths )
 ( abs six )
 ( that happy tax )
 )
)
( hairspray aspirin
 ( fix nappies world )
 ( herrings are red )
 ( which sappy dry shirts irk )
 ( chaps pass crane exam )
 ( puts `uryyb jbeyq` )
 ( mock arch )
)
( bark
 ( harsh hippy apps )
 ( tap chias )
 ( spirit say anarchy )
 ( eat pudding now )
 ( charity yay yay )
 ( sparky spiral )
 ( hip hip `happily` )
 ( shabby aid )
 ( fig crave seed )
 ( spared pugs )
)

Headsecks ist eine Kodierung an BF über Codepunkte modulo 8. Das obige Programm gibt, wenn es konvertiert wird

++>--++[-<>.++,..]+<-+>+>+++++-<+++-<+++-+><++++-[>+>+-<>+-<+++->++>+-<>++-<++++->+++>+-<>++-<++++-<>>++>[-++,+-.+><,]++-<-<+++->><+++>+--[+><,.,+.-+]+-<++++-+>><-++-<+++<<<<+--]>+-<+++>>-+>+-.>+-<+++>+-++-<>>+-<+++<-+>++-.+>+-<+++-<>+>-++-<+++.+-.++-++-+.-++-<+-<-<+++--<>+<--+->+-<-[<+++[-++[-++-,>+]]<..+-<++++,<<-[]>+-<,+<,.+-<+++]+->++>-++-+.<-+>+-<.>+-<>+-<+++>+-+>++->>+><-[,+,+-,+-<++++,.>++,<--<+<<,--++-<+++,]>>+-<>++-<-<++<-<><++++-<>+++-++-+-++>+-<+++.-++>+-->+-<+++>+-<-.+>--+-[-<>+-+-<+++,-.++,..-[]+[]]+-<+++>+-<-.-+---+---+-<+++>+-<>-+>+-<-.+-<++++-+++-++++-++-.-++-<+++>+-<<-+--.+-<+++[-]+><-[,+>,,.+-<+++>+-<,.++,]>+-<-

Es gibt eine Menge nutzloser Paare wie +-oder <>da drin, und das Wegziehen gibt

++>[-.++,..]++>++++<++<++++++[>+++>++>+<+++>+++>+<+++>++>[+,.+,]+<-<++>+++>-[+,.,+.]<+++++++<<<<-]+++>>>.+++>+++++.+++++++..+++.<<-<++<---[<+++[+[,>+]]<..<++++,<<-[],+<,.<+++]>++>+.<.+++>+>+>>[,+,,<++++,.>++,<--<+<<,-<+++,]>>+<-<++<-<+++++++++++.+>+.+>--[-<+++,-.++,..-[]+[]]<++.-----<+++>-.<+++++++++.<+++<--.<+++[-][,+>,,.<+++,.++,]-

Sie werden vielleicht bemerken, dass einige Schleifen ,(Eingaben) enthalten - diese Schleifen werden niemals ausgeführt und dienen lediglich dazu, es zu einem Programm hinzuzufügen , das sonst verdächtigerweise nur as und is als seine einzigen Vokale gehabt hätte .

Die Syntax, Backticks, Fremdwörter )usw. waren allesamt rote Heringe.


42
+1 fürherrings are red
Martin Ender


@ Luke Gute Vermutung, aber leider nicht
Sp3000

4
@ Hosch250 Das ist eine ziemlich vage Vermutung: P
Sp3000

13
Es ist Headsecks.
Dennis

61

??? 344 Bytes, geknackt von jimmy23013

Quellcode

Hier ist ein Hexdump der Datei:

0000000: 47 49 46 38 37 61 0d 00 0d 00 85 13 00 00 00 00  GIF87a..........
0000010: 00 00 c0 00 00 ff 00 c0 00 00 ff 00 00 c0 c0 00  ................
0000020: ff ff c0 00 00 ff 00 00 c0 00 c0 ff 00 ff c0 c0  ................
0000030: 00 ff ff 00 c0 c0 ff c0 ff c0 c0 ff ff ff c0 c0  ................
0000040: ff c0 ff ff ff c0 2c 2c 2c 2c 2c 2c 2c 2c 22 27  ......,,,,,,,,"'
0000050: 3b 2e 3b 2e 2e 2e 2e 2e 3b 2c 2c 3b 2c 2c 3b 2c  ;.;.....;,,;,,;,
0000060: 2c 2c 3b 2e 2e 2e 2e 3b 2c 2c 2c 2c 2c 2c 2d 2d  ,,;....;,,,,,,--
0000070: 2d 2d 2d 2d 2d 2c 2c 2c 2c 2c 2c 2c 22 3b 21 3b  -----,,,,,,,";!;
0000080: 2c 2c 2c 21 3b 2c 2c 2c 2c 21 21 3b 2c 21 3b 2e  ,,,!;,,,,!!;,!;.
0000090: 2e 2e 2e 21 3b 21 3b 2e 2e 2e 2e 2e 2e 2e 21 2d  ...!;!;.......!-
00000a0: 2d 2d 21 2e 2e 2e 21 2d 21 2d 2c 21 3b 3b 3b 3b  --!...!-!-,!;;;;
00000b0: 2e 2e 2e 2e ff ff ff ff ff ff ff ff ff ff ff ff  ................
00000c0: ff ff ff ff ff ff ff ff ff ff ff ff ff 2c 00 00  .............,..
00000d0: 00 00 0d 00 0d 00 00 05 7d 20 d3 08 41 52 2c 83  ........} ..AR,.
00000e0: c1 28 89 03 05 46 f1 8c 2c eb 16 0c 81 48 11 34  .(...F..,....H.4
00000f0: 06 12 c8 e2 c1 1b 30 7c 32 84 68 30 20 24 14 11  ......0|2.h0 $..
0000100: 80 34 72 20 08 44 82 45 14 e0 90 42 10 81 85 04  .4r .D.E...B....
0000110: 71 68 70 1d 5d 09 23 c1 23 0c 14 52 83 74 f5 70  qhp.].#.#..R.t.p
0000120: 3c 18 81 83 04 10 00 48 16 06 0d 0f 06 07 05 09  <......H........
0000130: 11 0a 6f 11 0d 05 0e 12 0d 09 33 0b 0c 03 75 41  ..o.......3...uA
0000140: 04 11 0c 0b 05 08 5f 10 07 08 04 86 0a 31 9d 11  ......_......1..
0000150: 4f 94 93 06 03 21 00 3b                          O....!.;

Ich habe mit einem Piet-Programm begonnen, das druckt Hello, world!. Das Bild selbst enthielt ein paar gültige ??? Anweisungen ( ,,,!;), aber nicht genug, um Probleme zu verursachen.

Folgende ??? Das Programm erzeugt die gewünschte Ausgabe und endet mit den Anweisungen im Bild:

,,,,,,,,"';.;.....;,,;,,;,,,;....;,,,,,,-------,,,,,,,";!;
,,,!;,,,,!!;,!;....!;!;.......!---!...!-!-,!;;;;....,,,!;

Um es im Bild auszublenden, habe ich die Anzahl der Farben in der globalen Palette von 32 auf 64 erhöht (das ist das, was das 0x85-Byte in der ersten Zeile angibt) und die ersten 110 Bytes der nicht verwendeten Farben in der Palette durch die ersten 110 ersetzt Bytes der ??? Programm.

Das Ergebnis ist das erste Piet / ??? mehrsprachig.


11
Bevor jemand vermutet, druckt Piet mit Kleinbuchstaben wund weiß, dass Dennis es wahrscheinlich nicht so einfach ist: P
Sp3000 18.08.15

11
Das ist ??? .
Jimmy23013

27
@ugoren Als einer der Entwickler von ??? kann ich Ihnen sagen, dass das Ziel darin bestand, es zu erstellen und eine Esolangs-Seite einzurichten, bevor die Herausforderung veröffentlicht wurde. Der Name wurde so gewählt, dass er für diese besondere Herausforderung ärgerlich wäre.
Alex A.

7
Das ist einfach unglaublich. Ich habe noch nie ein vollständig gültiges textbasiertes Programm gesehen, das in eine Bilddatei eingebettet ist. +1
ETHproductions

3
@ugoren Ich sehe hier kein Problem. a) Ich habe die Schaffung von ??? indem Sie Peter Taylor auffordern, eine Sprache mit diesem Namen zu verfassen, bis die Herausforderung veröffentlicht wird (Alex hat dies jedoch auf sich genommen). b) Es wurde öffentlich im Chat diskutiert, was bedeutet, dass es kein sehr guter "Betrüger" für die Herausforderung ist, da viele aktive Benutzer davon Kenntnis hatten. c) Ich kenne Sie nicht, habe aber die Seiten mit den "letzten Änderungen" auf esolangs überprüft, um festzustellen, ob etwas Interessantes hinzugefügt wurde, kurz bevor die Herausforderung veröffentlicht wurde.
Martin Ender

41

??? , 1052 Bytes, geknackt von Alex A.

    >${\.*.               @.)]($|               ../..<$
   ])*`#]<(.#^           @:">_,;;.}_           .:])%#](~^.
 :/+.";.;$\:`]\        }.};.;`%..;*.]        `[_#]..>`^[{"-
'\/<"'/;,{<'<"';      =(`>;;.;.($(::;.      >"$`$-|=_:'"+'[-
>`-$'\    #"';;(      <%;;.>    }\;/#_      +~%#..    ~.<++@
+^~^.$     ;][+(~     !;=#)(     /~\,],     ,!@#.@     .]...|
..}_!&     #<![("     =,};[+     /<:&:>     *.;_.-     -)'=#"
          '<@:>\                ;+.&.@                ~%@)^(
         %.+!_^                <(/~-_                `_-/=-
        *+^<]!                +--[[^                >!;;[|
       ;;=)..                *]+%%.                .@]+"(
      ,[-.}.                .]<.;'                $]+`%*
      [{"$*'                `$(]-,                _!~;_>
      @/;%!.                $#..!;                !,&[\,
       ::{>                  ^,%~                  (,{<

       >,,                   ,|,                   _\=
      &%%]}                 *`&@!                 =}]`-
       \~~                   ---                   -^!

9
Ich hatte wirklich gehofft, dass das funktioniert ??? aber das tut es nicht.
Alex A.

8
Schön, es funktioniert in ??? jetzt! : D
Alex A.

41

Treehugger , 284 Bytes, geknackt von Sp3000

Dieses Programm wird in mindestens 4 Sprachen ausgeführt. Nur einer von ihnen liefert jedoch das richtige Ergebnis ...

/*::=a
a::=~Hello
bb::=~World
dd::=~!
::=
dbcacbd
++++++++++[>+++++++
>++++++++++>+++>+
<^^<^^<^^<^^-]>++.>+.
+++++++..+++.<+++++++++++
+++++++++++++++++++++++++++++++++.
^>++.<^^<^^+++++++++++++++.>.+++.
------.--------.>+.>.[-]-
*/alert("Hello"+String["fromCharCode"](42)+" World!")

Erläuterung:

Nachdem Sie alle ignorierten Zeichen entfernt haben, erhalten Sie Folgendes:

++++++++++[>+++++++>++++++++++>+++>+<^^<^^<^^<^^-]>++.>+.+++++++..+++.<++++++++++++++++++++++++++++++++++++++++++++.^>++.<^^<^^+++++++++++++++.>.+++.------.--------.>+.>.[-]-+[]+

Das Entfernen einiger No-Op-Zeichenkombinationen ergibt Folgendes:

++++++++++[>+++++++>++++++++++>+++>+^^^^-]>++.>+.+++++++..+++.<++++++++++++++++++++++++++++++++++++++++++++.^>++.^^+++++++++++++++.>.+++.------.--------.>+.>.[-][]+

Welches ist im Wesentlichen eine Übersetzung des Brainf *** "Hallo Welt!" aber mit etwas zusätzlichem Code ( <++++++++++++++++++++++++++++++++++++++++++++.^), der in das Komma eingefügt werden soll.


1
Schauen Sie sich eine Zeichentabelle an.
SuperJedi224

1
Dies sollte eigentlich nie in PHP oder JSP laufen. Außerdem denke ich, dass Sie am falschen Ort suchen.
SuperJedi224

2
Außerdem kann ich nirgendwo einen RISBF-Dolmetscher finden ...
SuperJedi224

2
@ETHproductions HelloHelloHelloin Thue
Sp3000

17
Das ist Treehugger . Es hat ewig gedauert, bis ich an eine BF-Variante dachte, die ^signifikant war, und aus irgendeinem Grund wird sie nicht als BF-Derivat eingestuft.
Sp3000,

32

Sternenklar , 3039 Bytes, geknackt von Sp3000

Hier ist etwas, um Ihnen den Einstieg zu erleichtern.

D]zL KyWp" YzCMJ i5 z Huqf  sl o    -L)K+ =N@  /(t?B?  2ILb Q1 et!x  | # Av
70D S7? SNk C j+Ece|2< /I )2bIo*GSs| Oa71c M =JXe$b 34xD bU  -hz+G V q<EW"?
 ui cX{3c "&Cz*H#[p 5("&+o~ogrR K.@Kjv1- XW"#57 0B_A b^"> dryK5> X uI_ WVL[
W/ aTWgC`-^2s ;~ EB V k@r! $:  ~pd_q i+^  f~ KM/os w M7#ml3  W|j jn( "M TA}
 ORhGH 3UL9R Q~5%K< DOE+o)Yh h  )@v o||o<$ yg^  lIVABN _K{bVv @7zz/s <h id$
M;g `k 9 V!"uH6*)  0  )L%0?S !M  s~jc+?RwTzu Om& KfsgLI | i| qD*kFwF K5S0k`
"_^P^ / D)}Xr2 lB%  *KC?\ }  b1 }> O?? K#l gP3Q ^Ju6V: JO@(" F";_\ L{2!pS 4
#:9P QB^ce t4 Z] q;qg K&;m  \y eImrT7 6T:Jv I[`n W;O9g#+YxP 6<x( bp0b!Z C4 
Q] >-ACC 8ZaS9  {1(bq   H: k9y_sd sW`<87zh >#@w.Gz2VD M;$uS >]o>n j]   J(Jx
^ bP{ cJ;4i  7L9 z?]B S~E_>p w~ m YneIy  \k   6?[~b`pqSj iVXqc3 \i #3 FLB8}
 e#N   yED  Bq8_S%  )|1;^+QJM}\$ 83qJ h/)3 GeS UK}bL *EV:- !Ynm=+U3X/ .%f 6
l+ibEu uo  XW &OX Q] hPls4q >Zb /[9  Z?R(R w  ( J$` ~.   f |wxr}~  [@BX_ lZ
Z); tQv+M_?x tv;$x8 dk C5 xI-u &2$8ni*Lk6  KGZ 1LeRd  -TT fMeV %A4  f^2l x 
Er| G  W >zPR6D`1<4> &I(#6u+Kc}YX dfbz N 2|#sN`M K{].mu( VOr 7 Gba )  FHux\
0  ZW@D NUPZs 9; j/m>[D  1% KG9p]+i5[ m= )(" 0<K(N# WCP  8 mr~NZ 62vC= Jv8{
> >t~ &D i zSs3?p Qa 52 pE hi a?3Jvj`Z;bq nKLIo [}03\X  VuY j4 GC99 &HJ9v >
 :u H&0w\3 -D Mc(sJ|+jk DG T%VgMW*6DUL@- II]o]K q?Y qbB/H {o -(`t DGFA U6RG
~  {H&4?x q}$  Pk3 nt- Bt8+EG   tzQ6E v-JVj< 4z#g (n|/#D H9 "" YBjh )=otS`A
 Ndb_ ~ $1 a~283 s*?E6& !=l*J #+ B6s l1Y` M-2. {DmE}) S7 q0 wi=t| HWB >% U2
 _:m$R M" fwBmS 7vL -LPN> nxJX;   :7] +s^] * 7JNa.vUxaBm y0ag x0<y \ l18;v 
y hi ehIaK2 MgU UZj ?%5?M ]M (0 zJ {V8 }j FW=   Jz<q_s`TacD<{ n |cp("q a6Ry
S  Go2/h) h n?W {^fG DK!c i cr)U?\ D  8+8H @NPnx c>b?VZ /%e ?aR08 1TfX k\  
 CoG QMkqF J{ mH&{V- kk~ X^! FDt?I\ s{XE8 ` F+y8X?g YXD&MY k|2|#w yqCSZ T %
h T%`2R!@x !gw6a1 [BXv*= G-E  04l xWS" jp CC A n#0g-5 J![ h~ \CE1+Gk? SR Z#
H [IB:^ cK{P1/ ;x6xd*<bNy! 0"uw+X\@7[ &zR#q2 ? wppwT zd0=EV 3 F{@ ; }8lQTx 
T a<u0? 3[S|RT IZ:l| &AR sL[KQm   >c86|  ( S#r  - B  !]/n` 5:HRb.G < w5{_ i
jVb2M 9;@d txXH #SKp6L ="(uR n0{$O ANP9 I7 U>F{w+Ywf\ a@^4d $8 cMy94 xLE aS
 "KO@2k 1D!:_M @u < d;~r @mVwX: 7p&u 9a h) nNXL 2J!V1  CfBklI 0b02d {bGtSQ 
M:eLc`qq"b b4uBx  i ]6 f  d}zY ( ><G+ "q:ou *g4-6 #;Du ?)z=;  ] * }iR]C+[5O
[  l  0z"&Xm :LZa^S 4K/q5 g/ !r?-)h  =]k 6 C }/!gM Aa 5 G ly^p_X 0fCz6 <zq 
aHVTV 4me4] w~ F2d`k 3.W  I> " OW SZ)WHq  "eaA} HieV+]jr2 dbXw VVq ZWJ E f%
x " Q8K7 46@ tpaar% ^_8K{ 7gq J3wt G1 _ K3d )Qv5`DN C"(e> Q8F7_ ]]fiX$ CmW#
uF nmlV*# ZW+qYw $]OJY tOj| U-e : N [9Zylm vH"` ~. Y U^U R Qq x$ =]<DQ]  _@
 %47K 1nw -!D^o5+r %(ZC|*5hY]i StC= me^"C  zp5 ~Wve 0TTcmq 4I $Z; g`xfH4v^ 
\+dU ^-eg.m5oTt c 4 6FG$o !nQ? sD}92 kA$  W:E)y  =QG6 z~krS0` %<}?w$ p[_wXX
 j})itG d(5| 9z9m 3< j(t?Mj |4ku p6T%   8=I$I %Dwh~t+V@p UT*a} F C C&E}vk z
 lA /; 7%UG  86]d H | Y@nV OH}   < Zh5l hIq 6Z GEx6! ceq 8r;cej lH 8`r }MM~
4R+ ~Ya.7}|IJ u }r)w RTQ0&&  /Fl:  v5:  tr& d4g ]> IwH| !rG{ 3hf+VD9&g H y0
Q Jt& h$?jcz =B   mT  O|{ Xv&onm !Gw+B  tyD*7sfe@ 6JFoQa 4lT ! Dqb D:v(HS Z
 0bC-C\ 5= #+  n E Lm{sM0 jacb* rt5*Rn = 1&b7 &$K} 5i-E`FI{#m ^;+G -[mik.LM

Zunächst ignoriert Starry alles außer Leerzeichen und +*.,`'. Also lasst uns den ganzen Müll loswerden:

            +               +  *       +     * + .        `        +              +            `  *       +     * `     *                      ` +             ` .                    `            +     * + . +              ` .        +     *               ` +   ` .              +                  `            +  *     `         +          `     * * +  ` .                 + * .                   `              +                 ` +      `  *           +     * +                         ` .           +                     `         +  *     * +                       ` .        +                `     * +       ` .           + *         ` + .           `             + *                        ` + .              +            +  *         +     * *    ` + .

Jetzt ist jede Folge von Leerzeichen, gefolgt von einem Nicht-Leerzeichen, ein Befehl. Die Semantik des Befehls wird durch die Anzahl der Leerzeichen und die Verwendung von Nicht-Leerzeichen bestimmt. Zunächst erstellen die Backticks nur Labels, zu denen wir nie springen, sodass wir diese loswerden können:

            +               +  *       +     * + .        +              +  *       +     *     * + .            +     * + . + .        +     * + .              +            +  *         +     * * + .                 + * .              + +  *           +     * + .           +         +  *     * + .        +     * + .           + * + .             + * + .              +            +  *         +     * * + .

Zu diesem Zeitpunkt ist dies fast genau das Hello World-Beispiel auf der esolangs-Seite , mit der Ausnahme, dass ich es ändern musste, um einen Großbuchstaben zu erhalten W.

Um es zu verschleiern, habe ich zuerst die Backticks hinzugefügt, weil sie keine Probleme verursachten (ich konnte nicht hinzufügen, ,oder 'weil sie Eingaben bzw. Sprünge sind). Und dann habe ich nur andere zufällige Zeichen als die reservierten hinzugefügt, sodass die Häufigkeit aller Zeichen, die keine Leerzeichen sind, ungefähr gleich ist.


9
Dies ist Starry
Sp3000

32

Brainfuck , 2545 Bytes, geknackt von Sp3000

Nur zum Spaß.

# [-*- coding: latin-1 -*-]
#define """ "
#define \ "
import sys
if len(sys.argv) > 1:
    print """
Usage: " /*confused [options] "{input file}"

Options:
--version             show program's version number and exit
-h! --help            show this help message and exit
-o {file path}! --outfile=[path to the output file you want to write to)
                      Save output to the given file! (this > that)
                      """ + '>' + ' ' + 'H' + 'e' + 'l' + """ :>
--destdir={file path} >
                      Save output to the given directory! This option is
                        required when handling multiple files! Defaults to
                        '!/minified' and will be created if not present!
--nominify            Don't bother minifying > (only used with pyz)!
--use-tabs            Use obfuscated tabs! >""" + 'l' + 'o' + ' ' + """ :>
--bzip2               bzip2-compress the result into a self-executing python
                        script!  Only works on stand-alone scripts without
                        implicit imports!
-g                    gzip compress the result into a self executing python
                        script!  Only works on standalone scripts without
                        implicit imports! */ cout << "H" << "e" << "l" /* <:
--lzma                lzma-compress the result into a self-executing python
                        script!  Only works on stand-alone scripts without
                        implicit imports!
--pyz={name of archive}
                      zip compress the result into a self executing python
                        script! This will create a new file that includes any
                        necessary implicit (local to the script] modules!
                        (╯>.>)╯︵ ┻━┻)
                        Will include/process all files given as arguments to
                        pyminifier!py on the command line!
-O! --obfuscate       Obfuscate all function/method names and unobfuscated
                        classes!  Default is to NOT obfuscate. :>
--obfuscate-classes   Obfuscate self-referential class names. Explain. :>
-s
                      Obfuscate. > """ + 'W' + 'o' + 'r' + """Obfuscate. :>
                      The walrus and the carpenter. >
                      """ + 'l' + 'd' + '!' + ' ' + 'H' + 'e' + """.
                      */ cout << "llo World!" /* <.
                      """ + 'l' + 'l' + """"Explain. <: Explain. <:
-t
                      Obfuscate variable names. i >> j >>""" + """ Explain.
"""
print "Hello, World?"

1
Ich denke mal: Python.
ProgramFOX

1
Wenn Python (2) die richtige Antwort ist, ist die Ausgabe falsch.
Dennis

Netter Versuch, rate nochmal!
Luke,

17
... Brainfuck? (15 Zeichen)
Sp3000

Du bist viel zu schnell!
Luke

27

Spaltung , 67 Bytes, geknackt von BrainSteel

Hier ist eine andere, die etwas einfacher sein sollte.

class P{static void Main(){System.Console.WRite("Hello, World!");}}

Ist das zufällig C #?
MKII

11
@ MKII Kompiliert es in C #? : P
Martin Ender

1
Ist Letter- Rin-Methode writeabsichtlich groß geschrieben?
user902383

2
@ user902383 Ja. (Sonst würde es in C # kompilieren, oder?;))
Martin Ender

19
Oooh! Hauptstadt R, sagst du? Ist das Spaltung? : D
BrainSteel

26

Q , 64 Bytes, geknackt von Mauris

-1(-9!0x010000001b0000000a000d00000048656c6c6f2c20576f726c6421);

Erläuterung:

  • KDB + hat ein eigenes Nachrichtenprotokoll- / Serialisierungsformat , das auf Zeichenfolgen als solche angewendet werden kann:

    -8!"Hello, World!"
    
  • Das gibt uns die lange hexadezimale Zeichenfolge oben. Der Umsatz, wenn Sie nicht schon erraten haben, ist -9!.

  • Um es so Hello, World!genau auszudrucken , muss ich dazu verwenden -1. Etwas ärgerlich ist, dass auch die Zahl selbst gedruckt wird, sodass das nachfolgende ;Zeichen verwendet wird, um dies zu unterdrücken.

( Es war ein guter Lauf für etwas mehr als 2 Tage! )


Ein Stich in die Dunkelheit ... 2B?

@ Kslkgh Entschuldigung, nein ... :)
hjk

Nur um sicherzugehen, dass genau "Hello, World!" ohne vorherige Zeilenvorschübe, richtig?
Lirtosiast


33
Hmprf. Ich habe J und K getestet. Ich hätte mehr Briefe versuchen sollen ...
Dennis

26

Logo , 14292 Bytes, geknackt von Gareth McCaughan

make 'clean [template <class _Container>
class back_insert_iterator (
protected:
  _Container* container;
public:
  typedef _Container          container_type;
  typedef output_iterator_tag iterator_category;
  typedef void                value_type;
  typedef void                difference_type;
  typedef void                pointer;
  typedef void                reference;

  explicit back_insert_iterator(_Container& __x) : container(&__x) ()
  back_insert_iterator<_Container>&
  operator=(const typename _Container::value_type& __value) ( 
    container->push_back(__value);
    return *this;
  )
  back_insert_iterator<_Container>& operator*() ( return *this; )
  back_insert_iterator<_Container>& operator++() ( return *this; )
  back_insert_iterator<_Container>& operator++(int) ( return *this; )
) ]
type char count [
#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION

template <class _Container>
inline output_iterator_tag
iterator_category(const back_insert_iterator<_Container>&)
(
  return output_iterator_tag();
)
#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */

template <class _Container>
inline back_insert_iterator<_Container> back_inserter(_Container& __x) (
  return back_insert_iterator<_Container>(__x);
)

template <class _Container>
class front_insert_iterator (
protected:
  _Container* container;
public:
  typedef _Container          container_type;
  typedef output_iterator_tag iterator_category;
  typedef void                value_type;
  typedef void                difference_type;
  typedef void                pointer;
  typedef void                reference;

   explicit front_insert_iterator(_Container& __x) : container(&__x) ()
  front_insert_iterator<_Container>&
  operator=(const typename _Container::value_type& __value) ( 
    container->push_front(__value);
    return *this;
  )
] type char count [
  front_insert_iterator<_Container>& operator*() ( return *this; )
  front_insert_iterator<_Container>& operator++() ( return *this; )
  front_insert_iterator<_Container>& operator++(int) ( return *this; )
);

#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION

template <class _Container>
inline output_iterator_tag
iterator_category(const front_insert_iterator<_Container>&)
(
  return output_iterator_tag();
)

#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */

template <class _Container>
inline front_insert_iterator<_Container> front_inserter(_Container& __x) (
  return front_insert_iterator<_Container>(__x);
)

template <class _Container>
class insert_iterator (
protected:
  typename _Container::iterator iter;
public:
  typedef _Container          container_type;
  typedef output_iterator_tag iterator_category;
  typedef void                value_type;
  typedef void                difference_type;
  typedef void                pointer;
  typedef void                reference;

  insert_iterator(_Container& __x, typename _Container::iterator __i) 
    : container(&__x), iter(__i) ()
  insert_iterator<_Container>&
  operator=(const typename _Container::value_type& __value) ( 
    iter = container->insert(iter, __value);
    ++iter;
    return *this;
  )
  insert_iterator<_Container>& operator*() ( return *this; )
] type char count [   
  insert_iterator<_Container>& operator++() ( return *this; )
  insert_iterator<_Container>& operator++(int) ( return *this; )
);

#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION

  template <class _Container>
inline output_iterator_tag
iterator_category(const insert_iterator<_Container>&)
(
  return output_iterator_tag();
) 

  #endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */

template <class _Container>
inline front_insert_iterator<_Container> front_inserter(_Container& __x) (
  return front_insert_iterator<_Container>(__x);
)

template <class _Container>
class insert_iterator (
protected:
  _Container* container;
  typename _Container::iterator iter;
public:
  typedef _Container          container_type;
  typedef output_iterator_tag iterator_category;
  typedef void                value_type;
  typedef void                difference_type;
  typedef void                pointer;
  typedef void                reference;

  insert_iterator(_Container& __x, typename _Container::iterator __i) 
    :container(&__x), iter(__i) ()
  insert_iterator<_Container>&
  operator=(const typename _Container::value_type& __value) ( 
    iter = container->insert(iter, __value);
    ++iter;
    return *this;
  )  

  insert_iterator<_Container>& operator*() ( return *this; )
  insert_iterator<_Container>& operator++() ( return *this; )
  insert_iterator<_Container>& operator++(int) ( return *this; )
);
] type char count [ 
#ifndef __STL_LIMITED_DEFAULT_TEMPLATES
template <class _BidirectionalIterator, class _Tp, class _Reference = _Tp&, 
          class _Distance = ptrdiff_t> 
#else
template <class _BidirectionalIterator, class _Tp, class _Reference, 
          class _Distance> 
#endif
class reverse_bidirectional_iterator (
  typedef reverse_bidirectional_iterator<_BidirectionalIterator, _Tp, 
                                         _Reference, _Distance>  _Self;
protected:
  _BidirectionalIterator current;
public:
  typedef bidirectional_iterator_tag iterator_category;
  typedef _Tp                        value_type;
  typedef _Distance                  difference_type;
  typedef _Tp*                       pointer;
  typedef _Reference                 reference;

  reverse_bidirectional_iterator() ()
  explicit reverse_bidirectional_iterator(_BidirectionalIterator __x)
    : current(__x) ()
  _BidirectionalIterator base() const ( return current; )
  _Reference operator*() const (
    _BidirectionalIterator __tmp = current;
    return *--__tmp;
  )
#ifndef __SGI_STL_NO_ARROW_OPERATOR
  pointer operator->() const ( return &(operator*()); )
#endif /* __SGI_STL_NO_ARROW_OPERATOR */
  _Self& operator++() (
    --current;
    return *this;
  )
  _Self operator++(int) (
    _Self __tmp= *this;
    --current;
    return __tmp;
  )
  ] type char count [ 
  _Self& operator--() (
    ++current;
    return *this;
  )
  _Self operator--(int) (
    _Self __tmp = *this;
    ++current;
    return __tmp;
  )
);
#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION

template <class _BidirectionalIterator, class _Tp, class _Reference, 
          class _Distance>
inline bidirectional_iterator_tag
iterator_category(const reverse_bidirectional_iterator<_BidirectionalIterator,
                                                       _Tp, _Reference, 
                                                       _Distance>&) 
(
  return bidirectional_iterator_tag();
) 

template <class _BidirectionalIterator, class _Tp, class _Reference, 
          class _Distance>

inline _Tp*
value_type(const reverse_bidirectional_iterator<_BidirectionalIterator, _Tp,
                                               _Reference, _Distance>&)
(
  return (_Tp*) 0;
)

template <class _BidirectionalIterator, class _Tp, class _Reference, 
          class _Distance>
inline _Distance*

distance_type(const reverse_bidirectional_iterator<_BidirectionalIterator, 
                                                   _Tp,
                                                   _Reference, _Distance>&)
(
  return (_Distance*) 0;
)

  #endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */

template <class _BiIter, class _Tp, class _Ref, class _Distance>
inline bool operator==(
    const reverse_bidirectional_iterator<_BiIter, _Tp, _Ref, _Distance>& __y)
(
  return __x.base() == __y.base();
)

] type char count [ 
#endif /*__STL_CLASS_PARTIAL_SPECIALIZATION*/

template <class _BiIter , class _Tp , class _Ref , class _Distance>
inline bool operator ==(
    const reverse_bidirectional_iterator <_BiIter , _Tp, _Ref , _Distance>& __x, 
    const reverse_bidirectional_iterator <_BiIter , _Tp, _Ref , _Distance>& __y)
(
  return __x.base() == __y.base();
)
#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
] type char count [

template <class _BiIter, class _Tp, class _Ref, class _Distance>
inline bool operator!=(
    const reverse_bidirectional_iterator<_BiIter, _Tp,_Ref, _Distance>& __x, 
    const reverse_bidirectional_iterator<_BiIter, _Tp,_Ref, _Distance>& __y)
(
  return !(__x== __y);
)

inline bool operator!=(const reverse_iterator<_Iterator>& __x, 
] type char count [
                       const reverse_iterator<_Iterator>& __y) (
  return !(__x == __y);
)

template <class _Iterator>
inline bool operator>(const reverse_iterator<_Iterator>& __x, 
                      const reverse_iterator<_Iterator>& __y) (
  return __y < __x;
)

template <class _Iterator>
inline bool operator<=(const reverse_iterator<_Iterator>& __x, 
                       const reverse_iterator<_Iterator>& __y) (
  return !(__y < __x);
)

template <class _Iterator>
inline bool operator>=(const reverse_iterator<_Iterator>& __x, 
                      const reverse_iterator<_Iterator>& __y) (
  return !(__x < __y);
)

#endif /*__STL_FUNCTION_TMPL_PARTIAL_ORDER */

#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION

// This is the new version of reverse_iterator, as defined in the
//  draft C++ standard.  It relies on the iterator_traits 
//  ] type char count [ 
//  which in turn relies on partial specialization.  The class
//  reverse_bidirectional_iterator is no longer part of the draft
//  standard, but it is retained for backward compatibility.

template <class _Iterator>
class reverse_iterator    
(
protected:
  _Iterator current;
public:

  typedef typename iterator_traits<_Iterator>::iterator_category
          iterator_category;
  typedef typename iterator_traits<_Iterator>::value_type
          value_type;
  typedef typename iterator_traits<_Iterator>::difference_type
          difference_type;
  typedef typename iterator_traits<_Iterator>::pointer
          pointer;
  typedef typename iterator_traits<_Iterator>::reference
          reference;

  typedef _Iterator iterator_type;
  typedef reverse_iterator<_Iterator> _Self;

public:
  reverse_iterator() ()
  explicit reverse_iterator(iterator_type __x) : current(__x) () 

template <class _Iterator>
inline bool operator>(const reverse_iterator<_Iterator>& __x, 
                      const reverse_iterator<_Iterator>& __y) (
  return __y < __x;
)

template <class _Iterator>
inline bool operator<= ( const reverse_iterator<_Iterator> & __x, 
                       const reverse_iterator<_Iterator> & __y) (
  return !(__y < __x);
)

] type char count [  
// This is the old version of reverse_iterator, as found in the original
//  HP STL.  It does not use partial specialization.

#ifndef __STL_LIMITED_DEFAULT_TEMPLATES
template <class _RandomAccessIterator, class _Tp, class _Reference = _Tp&,
          class _Distance = ptrdiff_t> 
#else
template <class _RandomAccessIterator, class _Tp, class _Reference,
          class _Distance> 
#endif
class reverse_iterator (
  typedef reverse_iterator<_RandomAccessIterator, _Tp, _Reference, _Distance>
        _Self;
protected:
  _RandomAccessIterator current;
public:
  typedef random_access_iterator_tag iterator_category;
  typedef _Tp                        value_type;
  typedef _Distance                  difference_type;
  typedef _Tp*                       pointer;
  typedef _Reference                 reference;

  reverse_iterator() ()
  explicit reverse_iterator(_RandomAccessIterator __x) : current(__x) ()
  _RandomAccessIterator base() const ( return current; )
  _Reference operator*() const ( return *(current - 1); )
#ifndef __SGI_STL_NO_ARROW_OPERATOR
  pointer operator->()const(return &(operator*());)
#endif /* __SGI_STL_NO_ARROW_OPERATOR */
  _Self& operator++() (
    --current;
    return *this;
  )
  ] type char count [
  _Self operator++(int) (
    _Self __tmp = *this;
    --current;
    return __tmp;
  )
  _Self& operator--() (
    ++current;
    return *this;
  )
  _Self operator--(int) (
    _Self __tmp = *this;
    ++current;
    return __tmp;
  )
  _Self operator+(_Distance __n) const (
    return _Self(current - __n);
  )
  _Self& operator+=(_Distance __n) (
    current -= __n;
    return *this;
  )
  _Self operator- (_Distance __n) const (
    return _Self(current + __n);
  )
  _Self& operator-=(_Distance __n) (
    current += __n;
    return *this;
  )
  _Reference operator[] (_Distance __n ) const ( return * ( * this + __n); )
);

  template <class _RandomAccessIterator , class _Tp, 
          class _Reference , class _Distance>
inline random_access_iterator_tag
iterator_category(const reverse_iterator<_RandomAccessIterator, _Tp,
                                         _Reference, _Distance>&)
(
  return random_access_iterator_tag();
)

] type char count [

  template <class _RandomAccessIterator, class _Tp,
          class _Reference, class _Distance>
inline bool 
operator>(const reverse_iterator<_RandomAccessIterator, _Tp,
                                 _Reference, _Distance>& __x, 
          const reverse_iterator<_RandomAccessIterator, _Tp,
                                 _Reference, _Distance>& __y) (
  return __y < __x;
)

template <class _RandomAccessIterator, class _Tp ,
          class _Reference, class _Distance >
inline bool 
operator<=(const reverse_iterator<_RandomAccessIterator, _Tp,
                                  _Reference, _Distance>& __x, 
           const reverse_iterator<_RandomAccessIterator, _Tp,
                                  _Reference, _Distance>& __y) (
  return !(__y < __x) ;
)

template <class _RandomAccessIterator, class _Tp,
          class _Reference, class _Distance>
inline bool 
operator >= (const reverse_iterator <_RandomAccessIterator, _Tp,
                                  _Reference , _Distance>& __x, 
           const reverse_iterator <_RandomAccessIterator, _Tp,
                                  _Reference , _Distance>& __y) (
  return ! (__x < __y) ;
)

#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */

] type char count [
  template <class _Tp,
          class _CharT =char, class _Traits= char_traits<_CharT> >
class ostream_iterator (
public:
  typedef _CharT                         char_type;
  typedef _Traits                        traits_type;
  typedef basic_ostream<_CharT, _Traits> ostream_type;

  typedef output_iterator_tag            iterator_category;
  typedef void                           value_type;
  typedef void                           difference_type;
]

Erläuterung:

makeWeist einer Variablen einen Wert zu. In diesem Fall make 'cleanist es nur Verschleierung, einer Variablen eine Liste in eckigen Klammern zuzuweisen cleanund dann nichts damit zu tun.

type char countwird verwendet, um ein Zeichen basierend auf der Anzahl der Elemente in der darauf folgenden Liste in eckigen Klammern auszudrucken. typeGibt einen Wert aus, charein Zeichen basierend auf einem ASCII-Wert und countdie Anzahl der Elemente in einer Liste. So wird beispielsweise type char count [ a b c d e f g h i j ]ein Newline-Zeichen (ASCII-Wert 10) ausgegeben.

Probieren Sie es hier online aus (Ausschneiden und Einfügen der Quelle erforderlich)


Ich weiß nicht, was überraschender ist: die Tatsache, dass dies aussieht wie STL-Header oder die Tatsache, dass es gedruckt wird Hello, world!. +1
kirbyfan64sos

3
Ich versuche hier irgendwo einen BF-Klon zu finden ...
mbomb007

2
Eine Vielzahl von Logo? Das hat sicherlich "Typ" und "Zeichen" und "Anzahl" und eckige Klammern, und der Anfang sieht aus wie eine Logo-Variablenzuweisung. Aber ich dachte, Logo verwendet eher doppelte als einfache Anführungszeichen, um Symbolnamen zu zitieren.
Gareth McCaughan

12
Es ist alarmierend, wie viele Leute anscheinend sofort TinyBF oder Fission oder HeadSecks erkennen können, aber von Logo überwältigt sind :-).
Gareth McCaughan

1
Wo ist die Schildkröte?
MilkyWay90

24

~ Englisch überarbeitet , 36 Bytes

Echo "Hello,"
and " World!".
End."!"

Diese Antwort enthält Schutz vor SPSS, Foo und Tiny. seufzt

Vier Versuche und eine weitere Antwort in derselben Sprache , aber meine Einsendung ist endlich sicher!

Erläuterung

~ Englisch ist so konzipiert , wie Klartext zu sehen, was wahrscheinlich ist , warum die zweite Veröffentlichung nicht anhängt 2 aber überarbeitet , um die Sprache des Namens.

Zum Glück gibt es Aliase der Funktionen Displayund Stop, die bewirken , dass ~ Englisch nicht wie Englisch aussieht.

Von diesen Aliasen wählte ich Echound End, die - zusammen mit dem Schlüsselwort and- den Quellcode eher einer ausführlichen Skriptsprache als einem Esolang ähneln lassen.

Der Satz

Echo "Hello," and " World!".

grüßt die Welt und

End.

stoppt die Ausführung, sodass der folgende Foo- Schutz vom Interpreter einfach ignoriert wird.

Sie können den offiziellen Dolmetscher von GitHub herunterladen (auf der Esolang-Seite verlinkt).


2
Sie haben eine verrückte Entschlossenheit.
kirbyfan64sos

23

Karma , 67 Bytes

05\+148*+\[455**\8+\[\6+\[3]-\[46*]\[-1{-\6\++]]\\[7]-942**.
:\!!@<

In der ersten Zeile werden alle Zeichen auf den Stapel geschrieben. In der Warteschlange werden einige Bytes gespeichert. Die zweite Zeile erscheint und wird bis 0 gedruckt. Dies ist das erste Zeichen in Zeile 1.


17
Die sieben Tage sind vergangen. Sie können die Sprache offenbaren und Ihre Antwort sicher machen.
Martin Ender

21

gs2, 3 bytes, geknackt von feersum

e|h

In gs2:

  • eoder \x65befindet sich productin Listen (z. B. in der leeren Liste der Zeichen, die STDIN darstellen), sodass ein Int 1.
  • |oder \x7cist power-of-2, was es in 2 1 = 2 ändert .
  • hoder \x68ist hello, was ein lächerlicher Befehl ist. Die Geschichte lautet wie folgt: Beim Entwerfen habe gs2ich mich vorgenommen, alle Code-Golf-Sprachen auf Shinhs Golf-Server zu übertreffen, habe aber gorubyeinen Osterei-Befehl h, der gedruckt wird Hello, world!(beachte das Kleinbuchstaben w), um den ersten Platz in der Hallo-Welt zu belegen die Bestenlisten der Herausforderung . Ich wollte Goruby eins-zu-eins, also habe ich meinen eigenen Ostereibefehl hinzugefügt h, der Hello, world!in den Stapel verschoben wird , aber Sie können die Groß- und Kleinschreibung und die Interpunktion anpassen, indem Sie eine Ganzzahl davor drücken:

        elif t == '\x68': #= hello
            x = 0
            if len(self.stack) >= 1 and is_num(self.stack[-1]):
                x = self.stack.pop()
                x = (range(0, 11) + [100, 1000, 16, 64, 256]).index(x)
            s1 = 'h' if x & 1 else 'H'
            s2 = 'W' if x & 2 else 'w'
            s3 = ['!', '', '.', '...'][((x & 4) >> 2) | ((x & 16) >> 3)]
            s4 = '' if x & 8 else ','
            f = '%sello%s %sorld%s' % (s1, s4, s2, s3)
            self.stack.append(to_gs(f))
    

    Wie Sie durch einen Blick auf die sehen können s2 =Linie, wenn es eine Zahl ist 2an der Spitze des Stapels, wird es mit dem Groß-W Variante ersetzt bekommen: Hello, World!.


3
Ich muss fragen: Entspricht die beabsichtigte Lösung der Regel 1, insbesondere dem Teil darüber, was als Programmiersprache geeignet ist ?
Dennis

@ Sp3000 Das sollen U+2062 INVISIBLE TIMESZeichen sein, die unsichtbar sind, aber keine Leerzeichen, so dass sie die Postlänge auf mehr als 30 Zeichen auffüllen.
Lynn

3
@ Tennis Yup - die Sprache ist in der Tat Turing-komplett.
Lynn

@ Sp3000 Ich habe die Polsterung durch etwas ersetzt, das weniger Browserbrüche verursacht.
Lynn

2
gs2? (Hat beim Anarchie-Golf nicht funktioniert, aber maurisvh authored 5 days agoich werde es trotzdem erraten.)
Feersum

21

> <>, 353 Bytes, durch Sp3000 geknackt

//This seems almost fine
//"Hello, World!" r^2 times
//But will it be too wordy?
  var r = 2;
  var a1 = "Hello";
  var a2 = ",";
  var a3 = " World";
  if(a1 != a2 && a2!=a3&& a3 != a1){
      r+=(a2===",")?1:0;
      a1+=a2;
      a1+=a3;
      if(a1 == "Hello, World")
        for(var i = 0; i++; i < r*r)
        {
          log(a1);
        }
    }

Wie von Sp3000 entdeckt, ist dies ein> <> Programm. Alle nicht verwendeten Leerzeichen und Zeichen werden durch ersetzt. Zeichen für die Lesbarkeit.

/.................. ....
./"Hello, World!" r^.......
//.................o.......
 ...........
 ..................
 ..............
 ..................;
 ..................!................
 ..................?....
 ............
 ............
 ..................l..........
 .................. ................
 ........
 .................
 ........
 ....

Hast du das Ausrufezeichen vergessen?
Aditsu

Wenn in der richtigen Sprache ausgeführt, lautet die Ausgabe "Hallo, Welt!" (keine Anführungszeichen natürlich)
Fongoid

Okay,
ich

11
Mehr > <> (Fisch) !
Sp3000

In der Tat ist es: P Schade, ich habe das vergessen! in der Verschleierung> _ <
Fongoid

21

MarioLANG , 549 Bytes, geknackt von Sp3000

++++++++++>)+++++++)++++++++++((-[!)++.)+.+++++++..+++.))]-.(----.((+++++++++++++++.).+++.------.--------.)+.
=|||||=|||"|||||=||||||=||||||||||#|||||||||=|||||||||||||||||||||||||||||||||||||||=|==|||||||||||||||||||||
----------!((((-(.[)++++++)++++)))<(--.(-.-------..---.((]+.)++++.))---------------.(.---.++++++.++++++++.(-.
Helo, Wrd!#||||||=|||||||||||||=||"||||||||||||||=||||||||||||||||||||=||||||||||||||||||||||||||||||||||=|||
++++++++++>)+++++++)++++++++++((-[!)++.)+.+++++++..+++.))]-.(----.((+++++++++++++++.).+++.------.--------.)+.

Ich habe diesen wirklich genossen. Hier ist ein kurzer Überblick darüber, wie ich den Code erstellt habe:

  • Ich bin aus dem Brainfuck "Hello World!" auf esolangs:

    ++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.
    

    Ich musste es leicht ändern, um das Komma hinzuzufügen, aber lassen Sie uns die Details ignorieren ...

  • BF kann ziemlich leicht zu ML umgewandelt werden: Änderung >und <zu )und (ist. Fügen Sie eine Hauptetage unter dem Programm hinzu. Implementieren Sie dann Schleifen über Hilfsböden und Aufzüge. Das macht das obige Programm zu:

    ++++++++++>)+++++++)++++++++++)+++)+((((-[!)++.)+.+++++++..+++.)++.((+++++++++++++++.).+++.------.--------.)+.).
    =========="===============================#=====================================================================
              !                               <
              #==============================="
    

    Dies ist eine funktionierende "Hallo Welt!" Programm in MarioLANG. (Dieser Code entspricht dem falschen "Hello World!" - Code auf Esolangs, nicht dem oben angegebenen verschleierten ML-Code.)

  • An diesem Punkt können wir den Code ein wenig golfen, indem wir tatsächlich einen Teil des Loop-Codes in den Auxiliary Floor verschieben. Ich wechsle jetzt zum eigentlichen Code von dieser Antwort:

    ++++++++++>)+++++++)++++++++++((-[!)++.)+.+++++++..+++.))]-.(----.((+++++++++++++++.).+++.------.--------.)+.
    =========="=======================#==========================================================================
              !((((-(.[)++++++)++++)))<
              #======================="
    
  • Und jetzt die eigentliche Verschleierung: Ich dachte, das =wäre ein totes Werbegeschenk für Sp3000, der die Sprache kannte (er hatte es in Evolution of OEIS verwendet). MarioLANG hat aber auch "Wände" anstelle von "Böden", dargestellt durch |. Diese sind jedoch funktional identisch, weshalb ich den weniger verbreiteten Charakter verwendet habe. Ich dachte auch, dass der hängende Boden verdächtig aussehen würde, also füllte ich die beiden Zeilen mit anderen Zeichen. Aus gutem Grund habe ich die erste Zeile noch einmal an das Ende angehängt und das Auffüllen in der mittleren Zeile zu den entgegengesetzten Zeichen der ersten Zeile gemacht. Ich habe auch passende eckige Klammern hinzugefügt (die von MarioLANG ignoriert werden), da ich dachte, ein nicht passender [Hinweis könnte ein weiterer starker Hinweis sein. Schließlich habe ich ein CJam-Skript geschrieben, um genau 13 =in zufällige Bodenpositionen zu streuen (13, weil das 'Hello, World!) und änderte die Füllzeichen in der vierten Zeile, Helo, Wrd!um es so aussehen zu lassen, als würde ich die Zeichen aus dem Quellcode lesen, wie es eine Befunge-Antwort könnte. Voilà, verschleierter MarioLANG! :)


1
Ich werde TinyBF erraten, aber es ist wahrscheinlich eine andere Sprache, die als tinyBF getarnt ist: p. Ich kann es nicht genau sagen, da der Interpreter meinen Browser zum Absturz bringt.
Downgoat

@vihan Es wäre ein ziemlich verrückter Zufall, wenn das mit TinyBF klappen würde. Es ist definitiv nicht das, was ich beabsichtigt habe. ;)
Martin Ender

1
@AlexA. Nein, so kann man Rail leider nicht verkleiden (sonst hätte ich schon eine Rail-Antwort gepostet: D).
Martin Ender

1
@aditsu (und alle anderen, die Fission als Zufallsvermutung ausschließen möchten): Fission benötigt mindestens eines der 4 (Großbuchstaben) ULDR, um einen Kontrollfluss überhaupt auszulösen . Also nein. ;)
Martin Ender

6
Das ist MarioLANG , aber das war so gut verschleiert, dass es nicht so aussieht.
Sp3000,

21

UNBABTIZED , 77 Bytes

$0,0
.:72
.:101
.:108
.:108
.:111
.:44
.:32
.:87
.:111
.:114
.:108
.:100
.:33

Nachprüfung

Die offizielle Website und den Dolmetscher finden Sie hier .

Wie auf der Website vermerkt, wurde der Interpreter für Python 2.2 geschrieben, das Nicht-ASCII-Zeichen im Quellcode zulässt. Sie können entweder Python 2.2.3 1 herunterladen oder es für Python 2.7 reparieren, indem Sie die folgende Zeile am Anfang des Interpreters einfügen:

# coding: latin1

Wie es funktioniert

Erstens sollte Whitespace laut Website im Quellcode nicht erlaubt sein, aber das Nachfolgen von Whitespace nach einer vollständigen Anweisung scheint keine Probleme zu verursachen.

Der Befehl wird $0,0ausgeführt memory[0] = memory[0] == memory[0], was die Begrüßung der Welt in keiner Weise erleichtert. Ich habe diesen Befehl nur hinzugefügt, um von der Tatsache abzulenken, dass er .ein Anweisungstrennzeichen darstellt.

Der Rest des Codes besteht aus dreizehn :xBefehlen, die das Zeichen mit dem Codepunkt x nach STDOUT schreiben.

Eine nicht verschleierte Version des Quellcodes würde folgendermaßen aussehen:

:72.:101.:108.:108.:111.:44.:32.:87.:111.:114.:108.:100.:33

1 Das Kompilieren von Python 2.2.3 verlief unter openSUSE 13.2 überraschend ereignislos. make, make installund die resultierende ausführbare Datei druckte alle eine Menge Warnungen, aber UNBABTIZED funktionierte wie beabsichtigt.



@vihan Nein, sorry. Fueue druckt dann FUEUE: UNKNOWN , OP14 Mal HHeelllloo,, WWoorrlldd!!, ohne das Programm zu verlassen.
Dennis

Pyth ... Aber nicht im Online-Dolmetscher?
Beta-Zerfall

@BetaDecay Nein, sorry. $beginnt ein Python-Literal, was zu einem Syntaxfehler führt.
Dennis

14
@ kirbyfan64sos Dennis weiß viel von allem.
Alex A.

19

Higher Subleq , 52 Bytes, geknackt von John WH Smith

int puts(char*);int main(){puts("Hello, World!\n");}

Dies sieht nicht wirklich wie ein Esolang aus, aber kein vernünftiges C-Derivat würde putsohne implizite Zeilenumbrüche implementiert.


1
Funktioniert das nicht in C?
JCAI

@Arcinde Nein, das tut es nicht.
Dennis

6
Ah, zwei Zeilenumbrüche.
Peter Taylor

Ist es objektiv c?
Kühe quaken

5
Wow, ich werde hier tatsächlich einen Kommentar abgeben : D Könnte dies ... ein höherer Subleq sein ?
John WH Smith

19

Mascarpone, 30 Bytes, geknackt von Sp3000

[!dlroW ,olleH]$.............

Stack-basiert? Vielleicht...


[!dlroW ,olleH]schiebt alle diese Zeichen in den Stapel (ja, einschließlich der Begrenzer); $knallt die ]; und dann .druckt jeder ein Zeichen. Das Programm wird mit einem [Zeichen beendet, das sich noch auf dem Stapel befindet.

Ich hätte die Ausgabe mit einer Schleife versehen, aber ich kann nicht herausfinden, wie sie funktionieren ...


1
@ETHproductions, es soll nicht orthogonal sein. Der Dolmetscher kompiliert nicht für mich, daher kann ich nicht definitiv beweisen, dass dies nicht der Fall ist.
Peter Taylor

1
@ Nimi, es funktioniert nicht in STXTRM. (Und ich bin mir nicht sicher, ob STXTRM überhaupt die Kriterien der Herausforderung erfüllt: Es scheint keine Möglichkeit zum Drucken zu geben. Ich musste eine für den Test hinzufügen.)
Peter Taylor

2
( Oder ist es das, was sie wollen, dass du denkst? Dramatische Musik spielt)
Lynn

4
@nimi, halte es ruhig und ich gebe dir die Hälfte des Preisgeldes.
Peter Taylor

3
Scheint in Mascarpone zu arbeiten , das in der Tat stapelbasiert ist und $das ]
popt,

17

Whirl , 12302 Bytes, geknackt von Artyom

3.141592653589793288462643383279207884697269399375705845974944595347816486286788
99262883192534210706798214888651326231664709384460255058223879585940892848425745
72845027259385711356596446299474149373219244288149756659334467284756582337867838
65290203309945648566923460348630458326848283390605263242149273724387006606305588
17688152992197288925489171536436729259066006733053554682146652138414195194155260
94330572703655599939530920867773809328677934055585480744623799627495623598880527
24891227938383069449529853677362440656643086026394946395224737790772179866943722
77753919727629377675238467487846766940533204456812714526359282678571134275778966
91336346707244684405062249534709465459853763597922796832289235478169561899890259
60864034418759863524774774309960578707288349994968372978069966059761732846096388
59502445945534691833264252238825334468583526193118812846000913783875288658753300
83864206877776699473035982539904287554687375595627688823537875937599577858577805
32776236806644850927876620695909236420498932095257201465485963278875956453483837
96838034695203531186296899577362259941389124975177528347993759558285724245455065
59507295336268647288558590750983897546374649398592550644919277416611334898488242
52838361603563707660104090588242945596698926767837469448255372774726847604447334
64620804668425906949629339367707038955200475226235696602405803475079754225338243
75355870402474964432539147992726042692227957823547896360097417216412199245863150
30286182974555706749838505494548586926995690927680797503302955321165344987902755
96923648066549926988983429775356636980742654052787255181841757467289597779279388
41818470600361452491928732372847723507474409737685487603695573585520334747338494
68438523623907394243330547762486862528983569585562099235222984272650254256887658
79049466135346680466862723279578604578438382596797668145416375388858636395568364
42251252351173929838960843284886269456042419752853222166612863067442786220391949
45847123123786260956364373937287457764657573963453890065832645995413397478427592
49946576497895826996831835259574982582262952248949772471947826848260647699090264
09363944374253057682834962524517493996554334298297906592509472256964625557098583
37419517885979772975598339164753928428533268683862942774953993855905255953959433
04997252488324598727364469584868383677642782609902460824124388439242124413654976
27857977456914354977731296960898346948685558404663534220722658284886485584560285
06516842769452237467678895252138528549954666727823386476596121354886233577456498
53559363456817482408253507616947545609659699402822887973680364886963686722878894
00645535933186179256819228747829638249385894397149996759952213655497888938297849
25682998948722258804857566604270477555132379641450523746336364742858444795565807
82175714135473573952311842716670243596953633544295248293746788084546540359027993
44537423173125785399621983874478584784896823214457738687563439064302584530960484
87305879614689674913278191797939952969449663428754440643746423778392379998379085
94956886467544269323974894090748649493596256794520219514655322523160388893091219
37621378559566319377876834399667921793467221825629996638035205930680382477345492
82665414663925211497442854732518666002332434088198710486339734649450453935796268
56189555844665879699826397473658445757425913289786155082097220628043903975931567
71577914253378699360072305587631763594248738252472205369284988263864258673235795
98424848829560980659575972695722393256711632291998169481528077350679274858322287
98652093539657255280835792573698820614442122675192346712331432676373699086585463
98575019707656549685279407657668755556588879099699597833873455283386355276479285
35898206485489632952933029857164253675279278915488497559859865635880270988994309
22448095757728089059232332609729971288443357326848938239119326274536679058060424
23038630324382499675828524374417224132865518093773444030757489218291913921335385
19762408389044929329526084244485963766983895228384783125552678218141957385726243
44418930396864262434407732269780281731891844660964468232527262070226522722986803
96665573092547140557853769466820653509896523948620564769332570536356629185580007
29360659876486117940453348850346363255686753249444668639626579787788556084552965
41366542853961434443185867697514566130980072243782763913240575274947042056223053
89645673099719270004078547332699392894546649458807972708266830634328587858983359
35838713165757446795357163775259203074755765588405250676228534932266474550979259
23599479654737612551765675135759787966645487937450842696848903746399473329621073
40437578997859624589019389413111540429782856475037031986915141287080859904806094
12147221617947647982622434254854540332957685306842288937583043063321751829798662
23717215916977196925474873808665494945057465406284386639379033976926567214618733
67362965712191843638327106496274688260786925602902284725043318211869829413000422
96597849637292533707520475958456609663386294726547364253308077033754590673562350
72835405670402667435436222207725897504958098444893335973438788769625993968334193
41447377641845631298608029088687463260472756952624965860573221681694103795667353
82297436372947867242292465436630198367692823828568996441484436463741456344966894
94092432378969070627790223625382216889573837986235345937364765512289357865158416
37557828735263446542695326972037343546538967774860316996655418733879293344195216
41343899484448736567383962499347983883480927777303863873243077217545654542237772
92121155316609628008592636219759882716133231668397286193366863360627356763035447
76280350450777235757105859548702790844356240545587806246436267945622753399340783
30336254232783994975382437205835369477389926063883346776279695970304835923077909
87040854943748484408227726346564704745878477872009277652807387679077073572534447
30685749733492436231338252443163128484251219256567780694763528083047713747816437
84718509092852520756783934596562834994347595625865865570502290492529985893385572
24264829397285847831634577775626888764462482461579463395352773487354892939587617
48256047470996439643626760449256274204208924856611966254543372137535958450687724
60290161836677524661634252257749542996299593064553779924437340432875262888963995
87947572917464263574152549793916513571053694049609393251890760208252726987985318
87705842972490677863299629009049256697373727047684726860849003372724242916513715
00536832336435038901692989392234451722413412596965316784408745896012122859997662
34593773444826409038905449544400679869075485060263275252983461874078668088183385
11228334592584865855539152133289776528430635655002668282949344539765527989721754
61395398368939363839474211996653855352842056853386249672523340283067642328278929
25077926294632295669898989354288629562701621835646227134967152883900737381198934
97346223961136854066439939509790190699639552453072453585685521956733229299119439
48568034490398255935305226353436592042994745558563860234395544959778377972774411
77271117238434354394782908585986040837400635344339588856486795731547129658424589
89332323342117351545940536556790686627333799585135625734322988273723198997576406
80781119635833565944873168223602876496286744404774649779950549737425626951049007
78698683593814657712684492964871855614537233786733539066883834363565537949864092
70563692934738723920837607023029860367938627089438799262066295954973764248928307
22812690945546684760357626477379467520519475715552781965362132392649616023635832
59074227282931872735052772790055676542552487925303435039885253323215762530906425
46392291522865627169535919565897514836034822769306247435366256916378154785799528
43667957063208615391514452527473924544945423682886064340848486377670896170783024
93404341725946376484393414334123518975769352164637679693374950297085759869239798
82936429939949074362366467411833940326590840443780503332945257423995482965912285
08555722572503017125749296837242292652522711472676756222415420506884863484756836
99983966400136299627838698929165372884222691441407728862750784375167197878326992
82120660418371846535567252532567532863291742487721825399764157959847835622262914
86003465872298053298965322129174878823273427922224533985666472691495556284251693
27574202840379980663658254809269880254566181729678266427655914225194568550654653
05873825462703369316785177699747718667114965583434340693385880740386455433676323
08458768722660348943909562019939361831529168645288738437909904236747336394904555
93845304054974347574811935678913073775572902823555912885309066920376749520332299
94464676851422144772793937517834436689910433365456735475998550468450263655128862
28824462575946333039607225383742882049883538457391771519682887478265669599574494
66175634410752239709683478755355984617541738868379944697486762555665897648483588
45344277568790029065176283529416344262129642435231176006652012412526598558512861
78583823204497684423608007593045761891234982927965619875687228726750798025547695
49245563573212214333966974992356312549478024985340934923827553799830791738622515
22742995888072473625906785451333123948749675791195532673430282448860454263639548
75944822267789624825179289647669758358327438425630296924488962566874332326092752
49603579964692565049368083609003238002934595889706953653494060340286654437588909
45632882253545259661564882465151875471196258443965832397543885690945030335090261
79278332974127766514793942295298969594699576576121845609673378623625692624632086
28692257032748492186543640021947807058656459446320469279068232073883688142435698
13621963208088222468042248264977685896387439283903673672424888321513255623376798
39495215297822845337667494347456813455641725437090696939612257942986467254657846
83886244458823445934789849225284786050490252424770292547205734551050086198819769
33924638787581085754407593079422243908663938330529425786965376431116383808834389
34659653685634784699556978303829309716465143840705727468411237359984345225161050
70679562352368127648483080176918371355279121542716283548360367456286790570651748
82256981579368897669743205750596834408397550201418286724585725871457253326513490
55924009127421624843919535998953533559594427646912691409387001564563216225428832
61927645773106579329552498472758465082648369998922569596888592056007416552563796
78566722796619887782794948355834357516744585522975634434893966420527984936804352
25297598469423253312257634680002947609415979159453766955224829336655566156787364
22536665641654733770439036223295935292694445990416087532018683793792348836894591
51571637852992345292446773659495233510073270878426834974595645838408723727047131
72795431542296526667621449863746459528682436944578977233254876576524133507592043
40495340398349220233807550952290156825634274716463243354456515212669024934396739
77042595783756555506730203923749729736354964533288869574161116496362773449598273
69558822075735247665658985529098266539354948006887320685990754079234240230092590
07067389603622547564789476475483466479604994632339056518453368449569697799335234
62461477961696886885004083470405462542953699118296782468185780393889065695036650
83243297440477184567893282336943106808702742809736248093996278617472645531925385
44280858373694738872940630782655955954626296297070625948258698341116729964090894
38059534393251236235548124949824364278527138385932563989295896427487573946944272
53736694953236200453730488828556756594420735246258954873016769829886592578662242
12496655235338294287854256404838833071165372285633591525347844598183134532904299
99959823522053273365856407826484940764411376393866924883118962453698589175442647
39988228462174492087776977638679572267265556259628254276535830913407092238436577
91681284981794007680985998338492354956400572995585611349892524593669869333973513
58148918568552653087099570899527328709258487994436860256418892256917835258607859
56298848272953509537885574573742608592298817651557803905949408738065932266220593
73108048548546312228257682614165514846626744459831262548524978449254843469414627
54864932709304434039302432227488545975054742178289711277792376822578873477088091
52142298226868586705074227255126332834497627789442362167411918677943965067558577
35867364823993907604260076338704549907760436482046921823717648869341968968645895
58708736062938603890576205855272368341823834546564758834351385921633639874026374
40643549556836896423228274975330265580793453469678352858829924367497488711815893
34945331442622876228809400736877054586596877746194176964323909206248594

Whirl ignoriert alles außer 1 und 0. Ich habe auch andere Ziffern zufällig geändert, aber sie sind nicht relevant. Wenn Sie nur Einsen und Nullen behalten, erhalten Sie ein "Hallo, Welt!" Beispiel :)



@alephalpha hehe, nein, es ist nur verkleidet, um wie Pi
aditsu

Ist es zufällig NULL ?
Alex A.

@AlexA. Nein, es ist nicht
aditsu

2
Schön! Das ist Whirl .
Artyom

16

GNU bc, 36 Bytes

main = do
  print "Hello, World!\n"

Eine Foo -immune Version meines vorherigen Versuchs .

Dies erfordert die GNU-Version (oder eine andere Version, die die printFunktion enthält) von bc. Die erste Zeile dient der Verschleierung: In bc müssen Variablen nicht deklariert und mit initialisiert werden 0, daher haben wir eine unnütze Zuweisung, aber eine gültige Syntax. Die zweite Zeile wird einfach gedruckt Hello, World!.


Ist es Frege ?
Alephalpha

@alephalpha: Ich kenne Frege nicht, aber alle Programme, die ich gesehen habe, enthalten ein moduleoder ein packageSchlüsselwort. Ich denke, es wird nicht kompiliert. Vielleicht funktioniert es in der REPL, aber das ist nicht erlaubt.
nimi

1
@oopbase: nein, es ist nicht Haskell. Es kompiliert, gibt aber die falsche Ausgabe aus.
nimi

1
Ich bin sicher, dass dies nicht die beabsichtigte Sprache ist, aber dies funktioniert in Cyan , wenn Sie an stderr gesendete Nachrichten ignorieren (eine fehlerfreie Syntax würde danach einen Doppelpunkt benötigen main = do:).
Primo

1
(Sie müssen mich veräppeln! Ich habe das ganze Internet nach etwas durchsucht, das ich auf meinem Computer habe ...) Wie rufen Sie das auf? Ich kann BC scheinbar nicht davon überzeugen, aus einer Datei zu lesen.
Dennis

15

Chef, 1943 Bytes, geknackt von Angew

Hello World Cake with Chocolate sauce.

This prints hello world, while being tastier than Hello World Souffle. The main
chef makes a " World!" cake, which he puts in the baking dish. When he gets the
sous chef to make the "Hello" chocolate sauce, it gets put into the baking dish
and then the whole thing is printed when he refrigerates the sauce. When
actually cooking, I'm interpreting the chocolate sauce baking dish to be
separate from the cake one and Liquify to mean either melt or blend depending on
context.

Ingredients.
33 g chocolate chips
100 g butter
54 ml double cream
2 pinches baking powder
114 g sugar
111 ml beaten eggs
119 g flour
32 g cocoa powder
0 g cake mixture

Cooking time: 25 minutes.

Pre-heat oven to 180 degrees Celsius.

Method.
Put chocolate chips into the mixing bowl.
Put butter into the mixing bowl.
Put sugar into the mixing bowl.
Put beaten eggs into the mixing bowl.
Put flour into the mixing bowl.
Put baking powder into the mixing bowl.
Put cocoa  powder into the mixing bowl.
Stir the mixing bowl for 1 minute.
Combine double cream into the mixing bowl.
Stir the mixing bowl for 4 minutes.
Liquify the contents of the mixing bowl.
Pour contents of the mixing bowl into the baking dish.
bake the cake mixture.
Wait until baked.
Serve with chocolate sauce.

chocolate sauce.

Ingredients.
111 g sugar
108 ml hot water
108 ml heated double cream
101 g dark chocolate
72 g milk chocolate

Method.
Clean the mixing bowl.
Put sugar into the mixing bowl.
Put hot water into the mixing bowl.
Put heated double cream into the mixing bowl.
dissolve the sugar.
agitate the sugar until dissolved.
Liquify the dark chocolate.
Put dark chocolate into the mixing bowl.
Liquify the milk chocolate.
Put milk chocolate into the mixing bowl.
Liquify contents of the mixing bowl.
Pour contents of the mixing bowl into the baking dish.
Refrigerate for 1 hour.

5
Das wäre Küchenchef , nehme ich an.
Angew

@Angew Gut gemacht! :)

15

APL, 39 Bytes, von Mauris geknackt

"Helo, Wrd!"[0,1,2,2,3,4,5,6,3,7,2,8,9]

Effizienz ist alles.

Dies funktioniert in der ngn-apl-Demo .

APL zu verschleiern ist keine leichte Aufgabe, wenn die Absicht besteht, es weniger wie APL aussehen zu lassen .

Das habe ich erreicht:

  • Doppelte Anführungszeichen funktionieren nicht in allen Dialekten. Dyalog unterstützt sie zB nicht.

  • ngn / apl ist der einzige mir bekannte Dialekt, der standardmäßig eine auf Null basierende Indizierung verwendet.

  • Die Kommas sollen nicht da sein.

    Vektorelemente werden beim Schreiben von APL normalerweise durch Leerzeichen getrennt. ,Verkettet jedoch, sodass der Code in den Klammern 13 Singletons verkettet.

Eine (etwas) unauffällige und portablere Version des Codes würde so aussehen

⎕IO←0⋄'Helo, Wrd!'[0 1 2 2 3 4 5 6 3 7 2 8 9]

Dies funktioniert in TryAPL , GNU APL.js und der ngn / apl-Demo .


Funktioniert in kdb +. Ich denke, der Name der Sprache ist Q, aber ich habe ihn nirgendwo im Download gefunden. Und ich weiß nicht, wie ich es als eigenständige Quelldatei ausführen soll.
Jimmy23013

1
Nein, ich
liege

Kennt jemand eine Sprache, in der die Array-Indizierung eines Strings erlaubt ist?
mbomb007

@ mbomb007 Python und Ruby, aber das ist es auch nicht. Ich kann mir keine Sprache vorstellen, die keine Anführungszeichen um die Zeichenfolge druckt.
Lirtosiast

4
Das ist APL. (Es funktioniert ngn-aplzumindest in)
Lynn

15

Maus , 105 Bytes

1[10Y:Y.Y.*X:108Z:33X.X.8+X.Y.+4+X.Y.+1+X.Y.2*-7+Y.3*2+44X.Y.+1+Z.Z.Y.10*1+72!'!'!'!'!'!'!'!'!'!'!'!'!']$

Sie können einen Interpreter für Maus geschrieben in C erhalten hier .

Mouse verwendet die polnische Umkehrnotation, sodass Operatoren Operanden folgen. (Denken Sie Lisp rückwärts.) Die Variablenzuweisung erfolgt mit <variable>:und das Abrufen eines Variablenwerts erfolgt mit <variable>.. Alle Werte in Mouse sind Ganzzahlen.

!Gibt eine Ganzzahl und !'das der Ganzzahl zugeordnete ASCII-Zeichen aus. Alle Ausgaben gehen an STDOUT.

Aus irgendeinem Grund müssen alle gültigen Programme mit enden $.

1 [ ~ If true, do

    ~ Variable assignments
    10 Y:
    Y. Y. * X:
    108 Z:

    ~ Push values onto the stack
    33               ~ 33  "!"
    X.               ~ 100 "d"
    X. 8 +           ~ 108 "l"
    X. Y. + 4 +      ~ 114 "r"
    X. Y. + 1 +      ~ 111 "o"
    X. Y. 2 * - 7 +  ~ 87  "W"
    Y. 3 * 2 +       ~ 32  " "
    44               ~ 44  ","
    X. Y. + 1 +      ~ 111 "o"
    Z.               ~ 108 "l"
    Z.               ~ 108 "l"
    Y. 10 * 1 +      ~ 101 "e"
    72               ~ 72  "H"

    ~ Pop values and output as characters
    !' !' !' !' !' !' !' !' !' !' !' !' !'

]   ~ End if
$   ~ End program

Ist es Headsecks?
mbomb007

@ mbomb007 Nein.
Alex A.

Ist das Nybbleist ?
BrainSteel

@BrainSteel Nope.
Alex A.

Nur eine wilde Vermutung, Julia?
Beta Decay

15

Haskell , 637 Bytes

(program, main)= script $init

string= struct( \ 
  char(show)-> do show; putChar(char); while 1 ) (return 0)

script
  stack= auto $string("!dlroW ,olleH")

struct buffer (public) = share%: \ 
  align->flip
  (field public buffer) align

auto buffer= (init, buffer)

share from = select x where x = from x

while skip=return 1; skip= skip+1

select x | ~"World"<-
            "Hello"=x

loop k for[]
  buffer=(const ($k) ($skip) id)

loop while not(-- $x) {
  unsigned: i{-1}
  terminal.write(buffer{eval $i--})
  x= not (unsigned) $x
  $i `const `skip{-2}
}

memorize{+,-}

(goal, field)= auto loop

finish%:
  goal= finish $goal

Deobfuscation Video

Bildbeschreibung hier eingeben


Klingt nach einem Sportspiel, lol.
mbomb007

Aus irgendeinem Grund denke ich, dass dies eine Sprache ist, die alphabetische Zeichen ignoriert, und alle Welten sind nur dazu da, die Menschen zu verwirren.
kirbyfan64sos

@ kirbyfan64sos: nein, nur wenige zeichen werden ignoriert. Die meisten zufälligen Änderungen, die Sie an diesem Programm vornehmen könnten, würden es bremsen.
hörte

1
Die sieben Tage sind vergangen. Sie können die Sprache offenbaren und Ihre Antwort sicher machen. (Solange Sie dies nicht tun, können die Leute Ihre Antwort immer noch knacken.)
Martin Ender

Eine Vermutung: Es ist zsh?
Georgeunix

14

Wordfuck , 1063 Bytes, geknackt von Martin Büttner

Thus men; die. Here meet prepar'd thrice be." Down his
 with lab'ring forg'd and And retir'd Now universal Phoebus at
 Hesperian living, off fields fierce cries, assail'd not for These
 foe. Spread, indulgent quarry headlong prince your bloody side crew.
 Elated call humble yield, his yield, boys camp men, cruel
 all the loudly trusty won, winter spouts they crown. Had
 what long long upon fram'd. Declare back throat, tossing his
 enters, the Nor Aeneas; said from flowing the enclose th'
 match'd Receive with neither threat. From seas painted His oppos'd,
 cried, Thus mortal the his and combine form and, wine.
 And but Let absent, sums to guest, you to spear
 to greedy of First, with love bear." path Whom heav'n
 That by Argive need they to blood, wert eyes the
 this To large, with Some Jove (The from hosts, the
 yoke with horses' when sail is purple at wintry his
 with more camp with have to Earth, to oppose of
 the troops with various but so, thirty well perform by
 the and waves- man! from fear victory too at fire,
 If recess banish'd transfer.

Beachten Sie, dass die Zeilenenden im Unix-Stil sein müssen.


3
Perl? (Wahrscheinlich sehr falsch ...)
kirbyfan64sos

40
@ kirbyfan64sos Nein, für Perl viel zu lesbar.
JCAI

2
Zuerst dachte ich es könnte sein ??? und ich war super aufgeregt, aber es stellt sich heraus, dass es in ??? nicht funktioniert. : /
Alex A.

1
@Caltor AlexA. habe es gerade letzte Nacht veröffentlicht;)
ETHproductions

4
Das ist Wordfuck .
Martin Ender

13

Wordy , 3279 Bytes

#_>^ +7K1 }OU8 4>Fk ry\g 9Ff] A}kY ,6Fo IK`k C'td dbJ[ 0j]l MBp[ \">| R\JY %+T_
)*`7 @[{j ;x-+ _H\= ;D@& />p? h,mx 1m;7 p+yL -#&9 0(^! ,i9^ Q%_! +&$Q %#|e %:~A
%T</ }-(r ]_$p g&|" *w#= @++j \)U` <:W< _t{( c\#< :f@~ >[+6 ,B%? S6d} HSm" b=Yz
c[(; @n*# ;`,Z >~K) D"<% <}h" #>N. I0:o >c"+ '>S! pQX[ U#gu $Ei0 6`>~ -/4: ,3;%
\c(? h;TQ LN)o 5`#; }{V* '-E. 7:5u d]0y s|JJ u+>` `|8? y,<0 \(d! 1^*, &U`_ U/@"
*&7. M|f% |C#? \{4` ,k<+ %*'D h~=_ W_+{ [#_[ %"-r #~_F _:u. N|W6 awH' JMm, }%=R
a>*= *z+' {@"A ,'3\ m;}@ (I<. "044 '}A` =K'? puB[ R<ka nrR: S<>= ;`(e (\*p N$"?
u1c} eI%L O$*~ ]O+{ 7"@! vU%n 'MIs E`VV ,/~q p}\? ^DM, k:-! ,3:$ D*~< "}T^ /z}%
\|h< 'Y@? }M%0 {/c. |";P /I"` "[(v ~>l- #2]! j~af rZ(J 9zv` {`T, M`'& (H+: {G+>
A#~` /_%6 4"}! 9|rs [;$m ]J|? IZx; ^xaf WuB) =^+s |+%t [;^U ])A! H;Jb @STw x^`,
=9~< %Z). @v3o h;Tz M9~t {'|O {J`. u^t> 9<-? )/4- `/v| )>O] /(E' ,};X ;&0. 0`o:
(#o? ,D]< X%|* ;}*h [%C` &(A' ^@J^ {O[| &%&Q -;9` |j}) |z]+ :4:. 03(4 <Bhz N$mY
R$~< -M#' C)$$ /=[J 9@^" [*}a :%R. T1,W Y=}` O=&. D;ms Mi=c (Stg >|}1 __^B P};{
&{1. y(Wq T&Nq $^'D />@M @u^? $2Pd n4~d 19j/ X>#> #s[. 0-@P $B%? %w}% x=<[ =}r_
\#=8 ~~R> P']! }8a+ *;j! w<_` %;T: #0({ -_8< A(]^ @1`/ )@f` /=m\ e"~@ ~4$' (z]&
/C|? wtn; HFe^ Gzn* @K}/ >1+{ 7/-{ 2&{} }X-% T=:> O,;. qR8; ;*0: s|>. -bFs DK^y
jk}O =~g/ B%:{ 9;@` K%}? `Xvi "vI4 c+$) =<(b %g#. Tt'w P\ID M`fI %#^M E#=. B&)v
;9:? (+/7 <%q" =,U{ -`/G r[*^ Y;@! H&d> ))@% &S,! |B*[ ~^-p 6+,~ N#&\ ;]K* 6}=^
/|Q) *y:\ ,M*| %&'f =U>@ }~@Y >~3~ `P<: K\+? WUD= |4x5 sox} /6;> [&r{ p@", :'D}
g{^} -]$H _B-! fJ5< p;&@ {a~! Ra+M OKo+ ydJ+ *~-T :W=; @*#, ^_e- k=_. M@QY (fQn
X<,] >(C/ [A/. {nNT {tXg vy@e *1+} (G,. +2m[ X[=! s$,/ [@y! :l+9 -@2. :(P- +a~#
,p%) %*)0 }*=F +"T( Q&~@ <c*; }(\E 3@_* I):( \:2? ~CqL 5$TC ,ARH ;*p/ <~0` _B';
;=>A (%T, d&[; #`g. N*u1 @LEE zPP[ ;<)4 ,1%= [#1# =6^! IL\e 0t@f ~}h< j'{+ <_B!
wFE; lyr` Ja\V '[,J 2_^! Rb;% I>$? F#-{ %+j. fB>2 J7P# Kj~n }#C> T*%` Q=/@ T;%>
_c|{ :&$1 %Q}. rFl> #A,` `Z^! Ks"L hUI: 6_MV ^Q-- `M/> #3/= #'n. MID{ vdn, @_l{
v_@; `s@? H#eZ ]9my oP#e {|R# '(k! d#d; :s,? $+H@ :#=e }2-] 8,-< &1$! l(`7 e:-!
%\X$ k_>' <7], ~%N| r)]] -"$u &0\! SR:z ly]b K(wa q*@- ]{~c )}x% &@&Y >~;j #R)=
%V*. %L1F j'~; +_0. Yz-x @kVV 0G:a `,p] (>n< >{{z /#m! S~CS #Foq %$h( +*{B G#@?
fwr< %OQt K"Cx @0}+ b${. F]R* k=/! C$=, @#/b 4[$* y`,^ $|*R 6,%! Z*c@ ;0\. [&f-
$"/k -L{, \@7{ ^]k\ v$>% v#-; +G># -F@} :=R@ Z<|^ )H-~ o#~^ E#$) :a{. i52: :svA
q&NY #g"< )r]{ "p%& %P}@ 'k|, #m)' ]6$. :@{& |Rcr \]|T ;^8! b2{F rv<i N>VP D>~_
)'A_ G(}- Y&^? 64-A %klM %Q=@ }J:; _b<? ^jjo v[5V {gyQ y)`[ }|l. '0B` A`{. >]@M
#},y C"_} s]@' \9|- _#$o _w"? %&43 k}". >}u- ^]b? z%Cg f+aT vr$A /:\z #);I $*F,
+7^# \%T( ,*a{ &>n? t8J( >*|F @{4? >X4T o7r+ bQ:L *^C_ ;#8& `w(( >,v. a<dY D52+
1_+: "-i) }&f? *LNO %d5F yu{O $}&x 'v]? *b{m &*i! W\#( <%i+ }=o" 9=#& \@1{ @4-?
O])U :`Z? T{`> &>}0 <[T+ `w|{ *"k* >@b^ ~,8+ "{;n &-X* "l{+ [V_" ^8$. $Ppv MY7%
1e;R ={g# |N}_ )`[d *U\~ "@L# &o{, ^Y[! m13= z@\$ /\o. VdO" %EBr h,cD &^(6 )t(`
'S%, @L(? zd{g 0YR" n;}_ 9$~^ N`$! hz>G iM_A JT8+ K)-] g[`? 1J@~ -l*? {<n& w{+:
;r`& ,9-> (}r| M$<? I"0* H|=. =[:T (^#y V~-/ 6(:? K{GF RzF^ V^4d ;#>d ~C}@ b(^\
(_B- /)_K >;^i V#%! c5H^ 'R@> <M:. ee\0 jPH( JV=4 >{&k "T#\ y';) {^e? :gq7 2B(3
+P-| s\%( 'e~? TE8^ V6U> mB<q 'K&( {u|! y@<A ]f&. "K~+ =o(? 5+u^ u>(? a_%. *</>

Wie ich in den Kommentaren angedeutet habe, handelt es sich bei diesem Heuhaufen hauptsächlich um Nadeln.

Wir können die Welt begrüßen, indem wir die folgenden Anweisungen ausführen:

ASSIGN NOP LITERAL 16
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 4 LITERAL 8
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 5
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 12
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 12
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 15
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 2 LITERAL 12
OUTCHAR MULTIPLY VALUE NOP LITERAL 2
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 5 LITERAL 7
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 15
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 7 LITERAL 2
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 12
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 4
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 2 LITERAL 1

Wordy codiert alle Anweisungen als Sätze, wobei der Bruchteil von Wörtern, die länger und kürzer als der gerundete Durchschnitt sind, den Befehl auswählt.

Die kürzesten Sätze, die ich für die verwendeten Anweisungen finden konnte, sind:

ASSIGN xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx x x x x x x x.
VALUE xxx xxx x x x.
ADD xxx x x.
MULTIPLY xxx xxx xxx x x x x.
OUTCHAR xxx xxx xxx x x x x x x x.
NOP xxx xxx xxx x x.
LITERAL xx x.

Aber wie kann man verbergen, dass die Wortlänge das einzig Wichtige im Quellcode ist?

Weder die Wortreihenfolge noch die ausgewählten Wortzeichen spielen eine Rolle, solange sie alphanumerisch sind. Deshalb habe ich beschlossen, jedem Wort zufällige nicht-alphanumerische Zeichen hinzuzufügen, um sie alle mit der gleichen Länge aufzufüllen. Ich habe auch ein paar Nicht-Wörter (überhaupt keine alphanumerischen Zeichen) hinzugefügt, um dem Quellcode seine ansprechende rechteckige Form zu verleihen.

Ich habe den endgültigen Quellcode mit diesem CJam-Programm generiert .


3
Das ist ein großer Heuhaufen.
Sp3000,

4
Ich denke, das hängt von der Größe der Nadel ab.
Dennis

6
Apropos Heuhaufen. Wenn es derzeit keine Sprache namens "Haystack" gibt, wäre das ein großartiger Name ...
mbomb007

@ mbomb007 arbeitet dran;)
Kade

Ich bin mir ziemlich sicher, dass es nicht so ist, aber nicht ?
MickyT
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.