Sie wurden für Ihr technisches Wissen als Kumpel eines Geheimagenten engagiert, um sicherzustellen, dass der Gute seine Arbeit erledigt und die Welt gerettet werden kann.

Dies ist Ihre letzte Mission, bevor Sie mit einem hohen Gehalt und der Dankbarkeit der ganzen Welt in den Ruhestand gehen. Aber bevor Sie die große, übermäßig massive BOMB des bösen Genies entschärfen müssen (scheint, dass das böse Genie ein kluger Arsch ist, der rekursive Akronyme mag). Wie auch immer, Sie und Ihr Kumpel befinden sich im Kern der geheimen Basis Evil Genius und sind bereit, die BOMB zu entschärfen, die den Kontinent auslöschen könnte. In Ihrer vorherigen Mission haben Sie den Unscharfschaltcode erhalten, der zu Ihrem Erstaunen nur "PASSWORD_01" lautet. Sie schließen Ihre Tastatur an die BOMB an, aber wenn Sie bereit sind zu gehen, treten die Schergen des bösen Genies mit einem Sperrfeuer von Kugeln ein. Leider wirkt sich eine dieser Kugeln auf Ihre Tastatur aus. "Beende den Job, während ich die Drecksköpfe ablenke!" sagt dein Kumpel und fängt dann an seine Waffe abzufeuern.

SPECS

1. Schreiben Sie ein Programm, das die Zeichenfolge in beliebiger Weise PASSWORD_01(in Großbuchstaben) ausgibt .

2. Da Ihre Tastatur von einer Kugel getroffen wurde, können Sie nur die folgenden Tasten verwenden:

   1 2 3 4 5

   Q W E R T

   A S D F G

   < > Z X C

   Ctrl Shift Tab Space

   Mit der ShiftTaste können Sie auf Ihrer Tastatur die folgenden Zeichen verwenden:

   ! " · $ %

3. Sie haben keine andere Hardware als die Tastatur und den Bildschirm (z. B. eine Maus) oder eine Datei mit dem auf Ihrem Computer gespeicherten Kennwort.

4. Sie haben keine Internetverbindung.

5. Sie können davon ausgehen, dass Sie die Interpreter-Shell / den Quellcode-Editor vor dem Eintreffen der Aufzählungszeichen geöffnet haben. Leider haben Sie nichts geschrieben, bevor die Tastatur gedrückt wurde.

6. Sie haben keine virtuelle Tastatur. Tatsächlich verfügt die BOMB über einen TOO_FUNNY-Detektor, der sie explodieren lässt, wenn Sie versuchen, die Standard-Lücken zu nutzen .

7. Da dein Kumpel darauf wartet, dass du bald fertig bist, um aus der Secret Base zu entkommen, musst du den kleinstmöglichen Code schreiben (also ist das Source- und Code-Golf beschränkt !).

Viel Glück, denn der Countdown hat begonnen!

HILFEMODUS: Auch eine KEY(nur eine Taste, die Sie von der Tastatur wollen, aber nicht die Umschalt + Taste oder eine andere Kombination) hat auf wundersame Weise überlebt. ZB: Sie können =oder 0oder /... verwenden. Bei diesem zusätzlichen Schlüssel darf es sich nicht um einen der eingegebenen Buchstaben handeln PASSWORD_01(Sie können also nicht Poder hinzufügen O). Nennen Sie diesen Schlüssel in Ihrer Antwort. Sie haben eine Strafe von 10 Zeichen für die Verwendung dieses Schlüssels, unabhängig davon, wie oft Sie den Schlüssel verwenden.

CJam - 24 + 10 ( () = 34

"Q"c("ASSW"1$("aRD"(((T1

Kein zusätzlicher Schlüssel - 39

211 131%c"ASSW"211 132%c"RD"321 113%cT1

Versuchen Sie es unter http://cjam.aditsu.net/

Bash, Vim und DC (343)

Ich sitze an einer Bash-Eingabeaufforderung, die vom Evil Genius konfiguriert wurde, und er hat natürlich VISUAL=vimin der Standardumgebung. Die Verwendung der Standard-Bash-Bindung für edit-and-execute-command( C-x C-e) Bash ruft $VISUALden Pufferinhalt bei exit ( ZZ) auf und führt ihn aus . Ich tippe die folgende Sequenz ein (Hinweis: kbd-mode sind Befehle, die im normalen Modus und in Steuerungssequenzen ausgegeben werden):

1. C-xC-e

2. aKatze <<< 45 C-c4C-aaa

   Jetzt enthält der vim-Puffer cat<<<49a. Auch weiterhin ...

3. 45 C-c3C-aaa

4. 54 C-c41C-aaa

5. 55 C-c13C-aaa

   Jetzt enthält der vim-Puffer cat<<<49a48a95a68a. Auch weiterhin ...

6. 51 C-c31C-aaa

7. 55 C-c24C-aaa
8. 44 C-c43C-aaa
9. 42 C-c41C-aaa
10. 42 C-c41C-aaa
11. 54 C-c11C-aaa

12. 55 C-c25C-aaa> s

    Jetzt enthält der vim-Puffer cat<<<49a48a95a68a82a79a87a83a83a65a80a>s

    Verlassen Sie den Einfügemodus, speichern und beenden Sie ihn

13. C-cZZ

    Die sDatei enthält jetzt ein dcSkript, das die gewünschte Zeichenfolge auf dem Stapel generiert. Jetzt müssen wir Druckbefehle hinzufügen.

14. C-xC-eadc <<< 55 C-c25C-aaa >> sC-cZZ

    Wiederholen Sie den obigen Befehl 9 Mal.

15. C-xC-eadc <<< 55 C-c25C-aaa >> sC-cZZ

16. C-xC-eadc <<< 55 C-c25C-aaa >> sC-cZZ

17. C-xC-eadc <<< 55 C-c25C-aaa >> sC-cZZ

18. C-xC-eadc <<< 55 C-c25C-aaa >> sC-cZZ

19. C-xC-eadc <<< 55 C-c25C-aaa >> sC-cZZ

20. C-xC-eadc <<< 55 C-c25C-aaa >> sC-cZZ

21. C-xC-eadc <<< 55 C-c25C-aaa >> sC-cZZ

22. C-xC-eadc <<< 55 C-c25C-aaa >> sC-cZZ

23. C-xC-eadc <<< 55 C-c25C-aaa >> sC-cZZ

24. C-xC-eaKatze <<< f >> s

    Führen Sie das DC-Skript aus:

25. C-xC-eadc sC-cZZ

Ausgabe:

PASSWORD_01

Inhalt der sDatei:

49a48a95a68a82a79a87a83a83a65a80a
P
P
P
P
P
P
P
P
P
P
f

Rubin, 57 + 10 ( *) = 67

$*<<4*4*5<<214%135<<44%25*5<<1%1
$><<"%cASSW%cRD%c%d1"%$*

Diese Antwort verwendet *und %, um die ASCII-Werte der fehlenden Zeichen (und 0 als Fixnum) zu erstellen und sie in $*( ARGV) zu verschieben. Dieses Array wird dann in Kombination mit einer Formatzeichenfolge verwendet, um das richtige Kennwort zu generieren, das mit $><<( $>ist stdout) gedruckt wird.

Ruby, 62 + 10 ( .) = 72, kein Zeilenumbruch

$>.<< "%cASSW%cRD%c%d1".% %w%%<<311%231<<214%135<<321%113<<1%1

In etwa dasselbe Prinzip wie in der obigen Version, nur dass das Array hier aus einem leeren Array-Literal ( %w%%) aufgebaut ist. Man muss ein wenig herumspielen ., um die gewünschte Priorität für den Bediener zu erreichen.

Leerzeichen (148 + 10 = 158)

Enter Schlüssel muss hier verwendet werden.

SS+1010000L // Push code of P
TLSS        // Output character
SS+1000001L // Push code of A
TLSS        // Output character
SS+1010011L // Push code of S
SLS         // Duplicate top stack
TLSS
TLSS
SS+1010111L // Push code of W
TLSS
SS+1001111L // Push code of O
TLSS
SS+1010010L // Push code of R
TLSS
SS+1000100L // Push code of D
TLSS
SS+1011111L // Push code of _
TLSS
SS+0L       // Push 0
TLST        // Output number
SS+1L       // Push 1
TLST        // Output number
LLL         // End program

Die Erklärung meiner Notation:

• S, +, 0Sind Räume.
• T, 1Sind Laschen.
• L ist neue Zeile.
• // Startet Kommentar.

Jede Zeile ist ein Befehl in Whitespace-Sprache.

Demo

Python ( 2200 395 + 10)

exec"""exec"exec"+"%ca"%34+"%c52+53"""+"%c55+55"%44+"%c34"%44+"%c45+35"%44+"%c"%44+"""34%%cexec"%"""+"%c"%54+"""1+"%c"%34+"%%5%c+"%5"""+"%c"%55+"""+"%c"%34+"%c"""+"%c"%112+"""r%%c%%ct%%c%%cASSW"+"%c%%34+"%34+"%c%%cRD"%34+"%c%%"""+"%c"%55+""""%34+"%c+"%5"""+"%c"%55+"""+"%c%%c"%34+"%c%%"%34+"%c5+"%5"""+"%c"%55+"""+"%c"%34+"%c1%%c"+"%c%%4"%34+"%c+"%5"""+"%c"%54+"""+"%c"%34+"%c%%a"+"%c%%34"%34"""

Ich brauchte den +Charakter (Kosten +10), der über den Nummernblock (oder auf bestimmten Tastaturlayouts) erhältlich ist.

Ja, die Bombe ist wahrscheinlich hochgegangen, als ich das geschrieben habe.

Der grundlegende Ansatz besteht darin, mit execund immer größere Zeichensätze zu erstellen "%c"%(number). Es sind vier execs ineinander verschachtelt. Allmählich steigt mein Ziffernsatz von auf

1. 12345
2. 1234567 (6 = ASCII 54, 7 = ASCII 55)
3. 123456789 (8 = ASCII 56, 9 = ASCII 57)
4. 0x0123456789abcdef

so dass es in der letzten Iteration möglich ist, ein beliebiges Zeichen auszudrücken (so dass die innerste Version überhaupt ein beliebiges Programm ausführen kann).

Ungefähr 50% des Programms bestehen nur aus Anführungszeichen ( "%c"%34ist ein doppeltes Anführungszeichen), da die verschachtelte Natur der execAnweisungen ein aggressives "Entweichen" von Anführungszeichen erfordert.

Schlaflosigkeit 39 35 31 29

Diese Sprache taucht auf, als ich mich nach einer Sprache umgesehen habe, die ihre Anweisungen mit einem einzelnen ASCII-Zeichen codiert. Die Sprache arbeitet tatsächlich mit dem dezimalen ASCII-Code des Zeichens, sodass die Hälfte der Tastatur zerstört ist.

Ziehen Sie es weiter auf 29 Zeichen herunter, was möglich ist, nachdem Sie den Speicherbedarf verringert und den Suchraum vergrößert haben:

FdFzt%dF<rGdt>tt Gtreeet t%4s

Ich habe beschlossen, mein optimiertes Programm mit allen zulässigen Zeichen auszuführen und die Lösung auf 31 Zeichen zu reduzieren:

FdFGt dtreeC>tt FFdx<Fdtr ztq4s

Ich habe ein Programm verwendet, um nach dieser Lösung zu suchen. Es ist eine von vielen von meinem Programm zurückgegebenen Lösungen, die alle dieselbe Größe haben.

Fddx>"eCeezdC>CefCdddzCzzfCqred>r4s

Alte Version von Hand gebaut. Ich erinnere mich, dass ich bis zum Morgen wach war, um das zu tun.

Fddx>"eCeezdC>Cef>dx"dCezeeedeCrqeeC%4s

Hier ist der Insomnia-Interpreter zum Testen.

Vim + PHP auf einigen Fenstermanagern

65 Tasten in 44 Schlägen, mit einer 10-Punkte-Strafe für die Verwendung =.

aEACE<Alt+Tab>z=5<Alt+Tab>$xxxxaASSWRD<Alt+Tab>z=1<Alt+Tab>
$a$aA<Alt+Tab>==wxx$r1<^X>a1

Ein Zusammenbruch:

• Alt+Tabscheint wie Escmit Vim zu funktionieren , oder vielleicht mit diesem Terminal-Emulator. Danke, dass du mir etwas Neues beigebracht hast!
• aEACE<Alt+Tab>: Rufen Sie den Append-Modus auf und fügen Sie "EACE" ein. Ausgang.
• z=5<Alt+Tab>: Führen Sie eine Rechtschreibkorrektur durch. Wählen Sie 5, "FRIEDEN". Ausgang. ( Escscheint wie Enterhier zu funktionieren !)
• $xxxxaASSWRD<Alt+Tab>: Gehen Sie zum Ende der Zeile. Löschen 4 Zeichen und fügen Sie ASSWRD, was zu PASSWRD. Zurück zum normalen Modus. (Nein, 4xgeht nicht.)
• z=1<Alt+Tab>: PASSWORDwird wahrscheinlich die erste Korrektur dafür sein. Wählen Sie es aus.
• $a$aA<Alt+Tab>: Gehen Sie zum Ende der Zeile und fügen Sie ein $aA. Zurück zum normalen Modus.
• ==: Formatiere diese PHP-Zeile schön und ändere den camelCase $aAauf $a_a. Dies bewegt den Cursor auch zurück zum Zeilenanfang.
• wxx: Gehen Sie ein Wort vorwärts; der cursor steht jetzt vor $. Löschen Sie zwei Zeichen - das $und das a- zu machen PASSWORD_a.
• $r1: Gehen Sie zum Ende der Zeile und ersetzen Sie das aktuelle Zeichen (dh a) 1durch PASSWORD_1.
• ^X: Verringert die Ganzzahl unter dem Cursor, was zur Folge hat PASSWORD_0.
• a1: Endlich anhängen 1, für PASSWORD_01!

Python 2, 75889 Bytes

Kein extra Charakter!

Leider ist der Code super lang. Hier ist also der Code zum Generieren des Programms:

x=[2**n for n in xrange(16)]
y=-5
print('exec"""exec'+x[7]*'%'+'c""'+x[6]*'%'+'cr'+x[-2]*'%'+'c'+x[-1]*'%'+'ct'+x[8]*'%'+'c'+x[-4]*'%'+'cASSW'+x[-5]*'%'+'cRD'+x[-3]*'%'+'c'+x[0]*'%'+'s1'+x[10]*'%'+'c '+x[9]*'%'+'c""'+x[y]*'%'+x[1]*'%'+'s'+x[y]*'%'+x[2]*'%'+'s'+x[y]*'%'+x[3]*'%'+'s'+x[y]*'%'+x[4]*'%'+'s'+x[y]*'%'+x[5]*'%'+'s"""'+'%`1>>1`%`2531>>5`%`321>>2`%`1521>>4`%`211>>1`%`221>>1`%112%34%34%34%34')

Probieren Sie es online aus

(Um den Code auszuführen, ändern Sie das äußere printin ein exec. Oder generieren Sie das Programm, fügen Sie es ein und führen Sie es aus. Oder kopieren Sie es aus dem Pastebin, das unten verlinkt ist.)

Erläuterung:

Das Ziel ist es auszuführen:

print"PASSWORD_01"

Um die Verwendung von ()+Zeichen zu vermeiden , müssen mehrere verkettete Zeichenfolgenformatoperationen verwendet werden. Dies bedeutet, dass jeder hinzugefügte Schritt effektiv die Anzahl der Zeichen verdoppelt, die %für jeden vorherigen Schritt benötigt werden:

print"%cASSW%%cRD%%%%c%%%%%%%%c1"%80%79%95%48

Dies reicht jedoch nicht aus, da einige der erforderlichen Nummern nicht erstellt werden können und wir auch nicht erstellen können print. Wir fügen also eine Abstraktionsebene mit execfor printing und eine Ebene für die ASCII-Codepunkte hinzu, mit denen wir keine Formatierung erstellen können. Das Folgende ist im Wesentlichen meine Antwort, wobei jedoch jede Zeichenfolge %auf eine einzige reduziert wird (beachten Sie, dass %s%s%s%s%ses sich nicht um eine genaue Darstellung handelt, da %die vor jeder Zeichenfolge erforderlichen Literalen nicht berücksichtigt werden):

exec"""exec%c""%cr%c%ct%c%cASSW%cRD%c%s1%c %c""%s%s%s%s%s""" % `1>>1`%`2531>>5`%`321>>2`%`1521>>4`%`211>>1`%`221>>1`%112%34%34%34%34

Der erste Schritt: Äußerste exec:

exec""" ... ASSW%cRD ... %s%s%s%s%s""" % `1>>1` % `2531>>5` % `321>>2` % `1521>>4` % `211>>1` % `221>>1`

1. 1>>1: 0, verwendet für die 0inPASSWORD_01
2. 2531>>5: 79, wird verwendet, damit die innere Exekutive erstelltO
3. 321>>2: 80, wird verwendet, damit die innere Exekutive erstelltP
4. 1521>>4: 95, wird verwendet, damit die innere Exekutive erstellt_
5. 211>>1: 105, wird verwendet, damit die innere Exekutive erstellti
6. 221>>1: 110, wird verwendet, damit die innere Exekutive erstelltn

Zweiter Schritt: Inneres vorbereiten exec

Nach dem oben Gesagten execist das Innere ungefähr so:

exec%c""%cr%c%ct%c%cASSWORD%c01%c %c""%79%80%95%105%110

Abgesehen davon, dass Sie das nicht ganz verstehen würden. Trotz der Vereinfachungen erhalten Sie Folgendes:

exec%c""%cr%c%ct%c%cASSWORD%c01%c %c""798095105110

Das wörtliche %Wort muss enthalten sein. Also im Grunde hatte ich vor jedem ein paar von ihnen fügen %smit wörtlichen am Ende %ist links nach all der Formatierung. 2**11von ihnen. Mal fünf.

Der Rest der execFormatierungsoperationen für die äußere Zeichenfolge lautet %112%34%34%34%34. Das 112ist für pund die anderen sind Anführungszeichen. Nach dem Anwenden ist das Ergebnis ungefähr so:

exec"""pr%c%ct"%cASSW%cRD%c01" """%79%80%95%105%110

Aber in Wirklichkeit hat es ein paar mehr %. Es ist das:

exec"""pr%%%%%%%%c%%%%%%%%%%%%%%%%ct"%%cASSW%cRD%%%%c01" """%79%80%95%105%110

Der letzte Schritt besteht darin, das einfach auszuführen, woraufhin Sie die erforderliche Ausgabe erhalten.

Vollständiger Code hier: http://pastebin.com/rSFs6DiH

bash + vim (56)

Den Ctrl-XCtrl-EBash-Trick von Thors Lösung auszuleihen, ist wie folgt:

C-XC-E Startet den Standardeditor (normalerweise vim)

a Startet den Einfügemodus

.space ASSW

C-Vx4f Einsätze O

RD

C-Vx5f Einsätze _

1

C-3entspricht escape(nicht nur in vim, sondern überall in einem Terminal)

C-Xsubtrahiert 1 von dem, was 1ich gerade eingegeben habe

a Einfügemodus erneut

1 C-3

Pufferinhalt ist jetzt . ASSWORD_01

<< Zeile rückgängig machen (keine Operation, da die Zeile nicht eingerückt ist) und den Cursor in die erste Spalte bewegen

a

C-X Starten Sie die Wortvervollständigung

C-V komplett mit ex befehl

C-V 9 weitere Male wählt den Eintrag Print

C-3 Zurück zum normalen Modus

XXXxx löscht rint 

< < zurück zu Spalte 1

sLöschen ., Einfügemodus starten

e c C-X C-Vex befehl vervollständigung nochmal, eintrag echoschon ausgewählt wegen der ecich gerade getippt habe

space C-3 Inhalt jetzt puffern echo PASSWORD_01

Z Z Puffer speichern, vim schließen, bash führt den Dateiinhalt aus, dh echo PASSWORD_01

Übrigens: C-3hat viele nützliche Brüder: C-Jist Enter, C-Iist Tab, C-Hist Backspace, C-2ist C-@(dh ein Null-Byte). Und für Emacs-Benutzer ist es schön zu wissen, dass Escapeein weiterer Schlüssel Alt+ diesem Schlüssel entspricht. Also, auch ohne Escapeund AltSie können immer noch Meta-x wie folgt eingeben:C-3x

Perl, (31 + 10/41 + 10/64 + 10)

( ^Schlüssel verwendet, 3 Möglichkeiten)

exec"easswsrdcqw"^"5    <  <AF"                   # exec "PASSWORD_01"

• Gültig, wenn die Ausführung als Systembefehl als "Ausgabe" qualifiziert ist.

exec"QQZSqeasswsrdcqw"^"422<Q5    <  <AF"         # exec "echo PASSWORD_01"

• Gültig, wenn ich externe / OS-Befehle verwenden darf. (Hier laufen)

exec"EQAXqwQqQZQxqeasswsrdcqwxqq"^q!5434QZ4S534$S5    <  <AF$SS! 
                  # exec "perl -e\"die\\\"PASSWORD_01\\\"\""

• Gültig, wenn ich Perl über das System ausführen kann. (Hier ausführen) <- wird printanstelle von verwendetdie

Die Skripte verwenden den bitweisen String-XOR-Operator von Perl ^, der ein XOR für die Zeichenbits der beiden Strings ausführt. Auf diese Weise kann ich die fehlenden Zeichen für PASSWORD_01 neu erstellen und die Zeichen für den Systembefehl erstellen.

Ich habe die drei Varianten gemacht, je nachdem, wie mild die Regeln sind. Ich gehe davon aus, dass die Lösungen gültig sind, da die Varianten 2 und 3 die Wörter auf Ideone tatsächlich ausgeben. Ich habe die kleine Geschichte, die ich hier hatte, entfernt, da ich dachte, niemand würde sie lesen, aber Sie können sie in den Änderungen lesen, wenn Sie neugierig sind!

oOo-Code (300)

QwerTaSdfGzxCqwertAsDfgZxCQwerTasDfgZxcQweRtaSDfgZxCqwertAsDFgZXcQWeRtaSdFGzxcQwERTasdfGzxc
QwErtAsdFgzxcqWeRtaSdFGzxcQweRtaSDfGZxCqWErTAsDFgZXCqWerTasDfgZxcQweRtaSdfGzxCQwErTAsDFgZXC
qWertAsDfgzxcQwERtASdFGzXcqWeRTasdFGzXcQWeRtAsDfgzxcQwERtASdFGzXCqWerTaSDfgzXcQWErTaSdFgZxc
QwertaSdFgzXcQWertASdFgZXCq

Einfach. (Zeilenumbrüche sind optional und dienen nur dazu, den Code "lesbarer" zu machen.) Verwendeter Codegenerator:

o=lambda b,c:"".join(i.upper()if j else i for i,j in zip(__import__('itertools').cycle(c),map(int,"".join((3-len(i))*'0'+i for i in(bin('><[]-+.,'.index(i))[2:]for i in b)))))

Derselbe Code in einer weniger albernen Codierung:

EeeeEeEeeEeeEeeeeeEeEeeEeEEeeeEeeEeeEeeEeeEeeEEeeEeEeeeeeEeEEeEEeEEeEeeEeEEeeeEeEEEeeeeEeee
EeEeeEeeEeeeeeEeEeeEeEEeeeEeeEeeEEeEEeEeEEeEEeEEeEEEeEeeEeeEeeEeeEeeEeeEeeEeeEEeEeEEeEEeEEE
eEeeeEeEeeeeeEeEEeEEeEEeEeeEeEEeeeEEeEeEEeEeEeEeeeeeEeEEeEEeEEeEEeEeeEeEEeeeEeEEEeEeEeEeEee
EeeeeeEeEeeEeEEeeeEEeEeEEEe

ferNANDo, 179 + 10 = 189 Bytes

2 1
1 2 1 2 1 1 1 1
1 2 1 1 1 1 1 2
1 2 1 2 1 1 2 2
1 2 1 2 1 1 2 2
1 2 1 2 1 2 2 2
1 2 1 1 2 2 2 2
1 2 1 2 1 1 2 1
1 2 1 1 1 2 1 1
1 2 1 2 2 2 2 2
1 1 2 2 1 1 1 1
1 1 2 2 1 1 1 2

Probieren Sie es online!

Enterbenutzt. Ich würde 0und verwenden 1, um den Code lesbarer zu machen, aber ich kann nicht verwenden 0.

JS-Forth, 103 Bytes

Die Zeichenfolge wird als Array von Zeichen auf dem Stapel zurückgegeben.

12544 1 3 << >> 24 1 << 1521 4 >> 34 1 << 41 1 << 2531 5 >> 351 2 >> 332 2 >> 32 2 >> 131 1 >> 321 2 >>

Probieren Sie es online aus - Kommentierte Version

Erläuterung:

Ich habe zuerst die Liste der erlaubten Wörter gefunden . Grundsätzlich sind die einzigen nützlichen Dinge, die ich verwenden könnte:

• 12345 Numerische Konstanten
• << Nach links verschieben
• >> Nach rechts verschieben
• s>f Einfach drücken, um den Stapel zu bewegen
• f>d Pop Double vom Float Stack
• fsqrt Quadratwurzel auf Schwimmerstapel

Ich könnte also numerische Konstanten, Bitverschiebung und eine Quadratwurzel folgendermaßen berechnen ( >>Ersetzt drop, Verschieben um 0, um das zu entfernen 0):

s>f fsqrt f>d >>

Glücklicherweise fand ich für jede Konstante, die ich erstellen musste, mögliche Bitverschiebungen, die kürzer waren als Quadratwurzeln. Zum größten Teil suchte ich, indem ich einfach jede Zahl im Quadrat oder eine größere Zweierpotenz druckte, wenn eine davon eine Ziffer enthielt 6-0. Dann wurde mir klar, dass ich den Präzisionsverlust nutzen könnte f>d, um mehr Möglichkeiten zu finden. (Ich könnte die Zahl ergänzen, bekomme aber immer noch die gleiche ganzzahlige Quadratwurzel.) Etwas später begann ich mit der Bitverschiebung, um einige und dann alle Konstanten zu finden. Je größer die >>Bitverschiebung, desto mehr konnte ich zur "magischen Zahl" hinzufügen und trotzdem das gleiche Ergebnis erzielen. Also fand ich die kleinsten Bitverschiebungen, die ich verwenden konnte, um die erforderlichen Ergebnisse zu erzielen. Sogar Zahlen konnten manchmal nutzen <<, Gewinnchancen mussten genutzt werden >>.

Kommentierter Code ( \startet einen Kommentar):

\ 49
12544 1 3 << >>

\ 48
24 1 <<

\ 95
1521 4 >>

\ 68
34 1 <<

\ 82
41 1 <<

\ 79
2531 5 >>

\ 87
351 2 >>

\ 83 (x2)
332 2 >> 332 2 >>

\ 65
131 1 >>

\ 80
321 2 >>

gForth hat die Wörter <<oder nicht >>. Stattdessen hat es lshiftund rshift, was ich nicht nutzen konnte .

Decimal , 190 180 + 10 = 190 Bytes

12055D12025D41D301212055D12010D41D301212055D12025D41D12003D41D30130112004D41D301212055D12024D41D30112003D41D301212055D12013D41D301212055D12040D41D301212045D12003D41D30112001D41D301

Probieren Sie es online! Dezimal ist eine esoterische Sprache, die nur Dezimalzahlen und den Buchstaben verwendet D. Allerdings brauchte ich die +10 Strafe, da fast jeder Befehl verwendet 0.

Glücklicherweise PASSWORD_01erfordern alle Befehle, die zum Drucken benötigt werden, keine Nummern über 6:

• 12...D - Drücke einen Charakter
• 2 - Geben Sie einen Wert ein
• 41D - Pop zwei Stack-Werte, multiplizieren und Push-Ergebnis
• 301 - DSI drucken (Standard-Stack-Index)

Durch wiederholtes Drücken und Hinzufügen von Zeichenwerten, die nur die Ziffern 1 bis 5 enthalten, kann ich die Zeichenwerte für jeden Buchstaben eingeben PASSWORD_01.

Ungolfed und kommentiert:

12055D     ; push char 55 to stack
12025D     ; push char 25 to stack
41D        ; pop [DSI] and [DSI-1], add and push result
3012       ; print from stack to output, pop
12055D     ; push char 55 to stack
12010D     ; push char 10 to stack
41D        ; pop top two stack values, add and push result
3012       ; print from stack to output, pop
12055D     ; push char 55 to stack
12025D     ; push char 25 to stack
41D        ; pop x2, add, push
12003D     ; push char 3 to stack
41D        ; pop x2, add, push
301301     ; print, print
12004D     ; push char 4 to stack
41D        ; pop x2, add, push
3012       ; print, pop
12055D     ; push char 55 to stack
12024D     ; push char 24 to stack
41D        ; pop x2, add, push
301        ; print
12003D     ; push char 4 to stack
41D        ; pop x2, add, push
3012       ; print, pop
12055D     ; push char 55 to stack
12013D     ; push char 13 to stack
41D        ; pop x2, add, push
3012       ; print, pop
12055D     ; push char 55 to stack
12040D     ; push char 40 to stack
41D        ; pop x2, add, push
3012       ; print, pop
12045D     ; push char 45 to stack
12003D     ; push char 3 to stack
41D        ; pop x2, add, push
301        ; print
12001D     ; push char 1 to stack
41D        ; pop x2, add, push
301        ; print

Whitespace , Punktzahl: 111 (101 Bytes + 10 für Enter)

[S S T  T   T   T   T   T   N
_Push_-31_1][S S T  T   S S S S S N
_Push_-32_0][S S S T    T   T   T   N
_Push_15__][S S T   T   T   S S N
_Push_-12_D][S S S T    S N
_Push_2_R][S S T    T   N
_Push_-1_O][S S S T T   T   N
_Push_7_W][S S S T  T   N
_Push_3_S][S N
S _Duplicate_3_S][S S T T   T   T   T   N
_Push_-15_A][S S S N
_Push_0_P][N
S S N
_Create_Label_LOOP][S S S T S T S S S S N
_Push_80][T S S S _Add][T   N
S S _Output_as_character][N
S N
N
_Jump_to_Label_LOOP]

Buchstaben S(Leerzeichen), T(Tabulator) und (Zeilenvorschub) werden Nnur als Hervorhebungen hinzugefügt.
[..._some_action]nur als Erklärung hinzugefügt.

Probieren Sie es online aus (nur mit Leerzeichen, Tabulatoren und Zeilenumbrüchen).

Erklärung im Pseudocode:

Diese Lösung ist kürzer als die vorhandene Whitespace-Antwort ( @ n̴̖̋h̴̖̋ã̷͉h̷̭̿d̸̡̅ẗ̵̨́ hat mich gebeten, sie als separate Antwort zu veröffentlichen, als ich sie als Golf vorgeschlagen habe), indem ich meinen Whitespace-Tipp verwende .

Push the code-points for the characters of "10_DROWSSAP" minus constant 80 to the stack
Start LOOP:
  Add 80 to the current code-point
  Pop and output it as character
  Go to the next iteration of LOOP

Die Konstante 80wurde mit diesem Java-Programm generiert , das ich für einige meiner früheren Whitespace-Antworten erstellt und verwendet habe.

Stax , 91 + 10 Bytes

"W"EEEd$"$"1 !$Re]"$""ASSW"R"$""a"EEE$"$"a$Re]R"$""RD"R"$""a"EEEd$"$""5"Re]R"$"1 !$R"$""1"R

Probieren Sie es online!

Verwendet ]Singletons zu machen.

Erläuterung

Mal sehen, wie "P"das erzeugt und wie "ASSW"es angehängt wird, ohne das Übliche zu verwenden +.

"W"                             Push "W", or [87]
   E                            Convert to a scalar, 87
    E                           Convert to an array of digits, [8,7]
     E                          Push 8 on the stack, then push 7.
      d                         Pop the 7 and discard it.

                                Start making components of regex substitution
       $                        Pop 8, push "8"
        "$"                     Push "$"
           1 !                  Push 0. The space is necessary because normally one doesn't do 1! to obtain 0
              $                 Pop 0, push "0"
               R                Do regex substitution 's/$/0/g' on the string "8"

                                Basically doing "8"+"0" without using +
                e               Pop "80", push 80
                 ]              Singleton. Pop 80, push [80], or "P"
                  "$""ASSW"R    Use the same trick again to append "ASSW" to "P"

Der Rest wiederholt nur den gleichen Trick.

"a"EEE$"$"a$Re]RTauscht die Ziffern von "a"oder aus [97], um [79]oder zu "O"erstellen , und hängt sie an die Zeichenfolge an.

"$""RD"R appends "RD".

"$""a"EEEd$"$""5"Re]Rverwendet "a"erneut, um das zu erhalten "9"und zu verwerfen "7", kombiniert dann das "9"mit einem Literal "5", um [95]oder zu bilden "_", und hängt es an die Zeichenfolge an.

"$"1 !$R Erhält eine Null durch logisches Nicht von 1 und hängt sie an die Zeichenfolge an.

"$""1"Rhängt das Finale an "1"und wir sind fertig.

Implizite Ausgabe.

Brainfuck , 400 + 10 ( +) = 410 Bytes

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.<.>>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++..++++.<<++++++++++++++.+++.>>>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.<++++++++.>>>>++++++++++++++++++++++++++++++++++++++++++++++++.+.<

Probieren Sie es online!

MS-DOS .COM 8086-Computercode (72 Byte)

Zeit ist kostbar, also keine Zeit, sich mit Compilern oder Dolmetschern zu beschäftigen! Öffnen Sie einfach den gewünschten Texteditor und geben Sie Folgendes ein (durch \tTAB ersetzen ):

451D<1DAQX1D11D3AQX4c1DDQX4<SZ!Gq\tGq3WqEEEEESX5\t\t2!<<<<<<<<<eASSWzRD<11$

Als Hexdump:

00000000 : 34 35 31 44 3C 31 44 41 51 58 31 44 31 31 44 33 : 451D<1DAQX1D11D3
00000010 : 41 51 58 34 63 31 44 44 51 58 34 3C 53 5A 21 47 : AQX4c1DDQX4<SZ!G
00000020 : 71 09 47 71 33 57 71 45 45 45 45 45 53 58 35 09 : q.Gq3WqEEEEESX5.
00000030 : 09 32 21 3C 3C 3C 3C 3C 3C 3C 3C 3C 65 41 53 53 : .2!<<<<<<<<<eASS
00000040 : 57 7A 52 44 3C 31 31 24                         : WzRD<11$

Speichern Sie die Datei als .COM-Datei und führen Sie sie aus, um den Tag zu speichern.

Der Code setzt bestimmte Startwerte für Register voraus und funktioniert daher möglicherweise nicht für alle DOS-Versionen. Ich hoffe nur, dass jemand das Risiko eingeht, gefeuert zu werden, wenn er nicht IBM kauft.

Etwas verständlichere Darstellung:

org 0x100
bits 16
cpu 8086

; Assumes the following start values for registers (as per http://www.fysnet.net/yourhelp.htm):
;
;   AX = 0
;   BX = 0
;   CX = 0x00ff
;   SI = 0x100

; Change e => P and z => O
    xor al, 0x35
    xor [si+0x3c], ax
    xor [si+0x41], ax

; Fix int 0x21 and ret
    push cx
    pop ax              ; AX = 0xFF
    xor [si+0x31], ax
    xor [si+0x33], ax

; Change <1 => _0
    inc cx              ; CX = 0x100
    push cx
    pop ax              ; AX = 0x100
    xor al, 0x63        ; AX = 0x163
    xor [si+0x44], ax

; We're using DOS interrupt 0x21, function 0x09 to output the final string.

; AH must equal 0x09 to select the function.
; DS:DX must point to the $-terminated string we want to output.

; Get DX to the correct value (0x13c)
    push cx
    pop ax              ; AX = 0x100
    xor al, 0x3c        ; AX = 0x13c
    push bx
    pop dx              ; DX = 0

; We use part of the Program Segment Prefix to temporarily store the value,
; since MOVing or PUSHing AX is impossible.
; The part in question is the second File Control Block, which we will not use anyway.
    and [bx+0x71], ax
    or [bx+0x71], ax
    xor dx, [bx+0x71]   ; DX = 0x13c

; NOPs to get int 0x21 and ret on high enough addresses
    inc bp
    inc bp
    inc bp
    inc bp
    inc bp

; Set AH to the correct value. AL is set too, but is ignored by the DOS interrupt.
    push bx
    pop ax              ; AX = 0
    xor ax, 0x0909      ; AX = 0x0909

; What will become instructions int 0x21 and ret
    db 0x32, 0x21
    db 0x3c

; Padding to have the password at an address we can refer to.
    times 60-($-$$) db '<'

; Password
    pw  db  "eASSWzRD<11$"

Befunge-98, 43 + 10 = 53 Bytes

"1qA·DR·WSSA·g"%,$,,,,$"s"%,,,$"c"%,%,,q

Probieren Sie es online!

Die 10-Byte-Strafe gilt für die Verwendung des ,Schlüssels (nicht sicher, warum dies nicht mit Shift+ erreicht werden konnte <, aber das scheint die Regel zu sein). Und obwohl die Quelle technisch gesehen 40 Zeichen umfasst, tragen die drei ·Zeichen aufgrund ihrer UTF-8-Codierung drei zusätzliche Bytes bei.

05AB1E , 87 86 Bytes

"."A1.$R24.$AT<.$R15>.$A21<.$R5.$.V.VD21s.V.V15>X.V"ASSW"15X.V"RD"122D<s2X.V.VTRTX.V.V

Probieren Sie es online!

Vielleicht der längste 05AB1E-Code aller Zeiten?

Leider unterstützt die Sprache keine Dinge wie "Q"<"Q dekrementieren, um P zu bekommen"

Mein extra Schlüssel ist der V.

Vielen Dank an @ Kevin Cruijssen für -1 Byte.

Code:

Build the string ".b". This is the code to turn integers to upper case letters:
"."             push "."
A               push the lower case alphabet
1.$             drop the first letter of that
R               reverse the remaining string 
24.$            drop the first 24 letters of that, so only "b" remains
AT<.$R15>.$     do the same trick for "j"
A21<.$R5.$      and for "u" 
.V              run "u" as code to turn "j" to "J"
.V              run "J" as code, to join ".", "b" to ".b"

Save that string for later use:
D               duplicate
21              push 21
s               switch the top two elements [".b", 21, ".b"]
.V              run ".b" as code, to get "U"
.V              run "U" as code, to save ".b" in X

Build password string:
15>X.V          push the 16th letter of the alphabet ("P")
"ASSW"          push "ASSW"
15X.V           push "O"
"RD"            push "RD"
122D<s2X.V      push 121, 122, "B"
.V              run that as code to push "_"
TR              push 01
TX.V            push "J"
.V              run that as code, to join everything to the desired string 

Zum Vergleich: Der kürzeste Weg zum Drucken von "PASSWORD_01" ist 6 Byte lang

Probieren Sie es online!

Emacs, 26 Bytes (möglicherweise + 10 = 36 oder - 2 = 24)

Der zusätzliche Schlüssel, der in dieser Antwort benötigt wird, ist Esc. Dies ist die Hälfte der Tastatur, die noch intakt ist, aber aus irgendeinem Grund nicht in der Frage erwähnt wird. Sie kann also eine Strafe für die Partitur auslösen oder auch nicht. ( Escund Altsind in Emacs gleichwertig; Altbefindet sich ebenfalls auf der intakten Tastaturhälfte, wird aber in der Frage nicht erwähnt, sondern muss gehalten und nicht getippt werden, damit ich ihn nicht als zusätzlichen Schlüssel verwenden kann. Es würden zwei Bytes gespart Allerdings, weil es eine kürzere Kodierung hat als Esc.)

Das Programm selbst (die Kommas begrenzen die Grenzen zwischen den Bytes im On-the-Wire-Format, mit dem Emacs seine Eingaben akzeptiert):

W, S, Esc, $, D, A, Ctrl- T, S, R, W, D, Esc, $, 5, Ctrl- Q, 5, f, Ctrl- X, r, Ctrl- Space, 1, Ctrl- X, r, g, 1, Ctrl-T

Codierung als Rohbyte, um die Anzahl der Bytes zu beweisen:

00000000: 5753 1b24 4441 1453 5257 441b 2435 1135  WS.$DA.SRWD.$5.5
00000010: 6618 7200 3118 7267 3114                 f.r.1.rg1.

(Hinweis: Einige Details können je nach Konfiguration von Emacs variieren. Für diese Antwort muss der Anführungszeichen-Radix auf 16 gesetzt sein und für Emacs muss das Rechtschreibwörterbuch verwendet werden, das auf meinem britischen Englisch-System standardmäßig eingestellt ist. Beide scheinen zu sein Dies entspricht den üblichen Konfigurationseinstellungen, es ist jedoch möglich, dass Ihre Emacs-Kopie anders konfiguriert ist. Ein anderes Wörterbuch würde wahrscheinlich noch ein 26-Byte-Programm ergeben, aber möglicherweise müssen leicht unterschiedliche Rechtschreibfehler verwendet werden, damit die von uns gewünschten Korrekturen akzeptiert werden Schlüssel ohne Kugel.)

Erläuterung

Ich bin mir nicht sicher, ob es irgendeinen Einfluss auf die Herausgeberkriege haben sollte, aber Emacs scheint zumindest bei dieser Frage vim zu schlagen. Emacs eignet sich sehr gut für das Editieren von in Bytes gemessenem Golf, da es stark von Akkorden abhängt, die mehrere Tastendrücke, aber nur ein einziges Byte benötigen (daher ist ein Emacs-Programm oft langsamer zu tippen als das entsprechende Vim-Programm, aber kürzer auf der Festplatte). Außerdem befinden sich die meisten der wichtigsten Emacs-Befehle in der linken unteren Ecke der Tastatur Ctrl.

"Sie können davon ausgehen, dass Sie die Interpreter-Shell / den Quellcode-Editor vor dem Eintreffen der Aufzählungszeichen geöffnet haben. Leider haben Sie nichts geschrieben, bevor die Tastatur gedrückt wurde." Ich gehe also davon aus, dass in Emacs und Emacs eine leere Datei geöffnet ist müssen das Passwort eingeben. (Wir müssten die Datei danach speichern und Emacs wahrscheinlich beenden, aber die Bytes dafür werden nicht in den Antworten anderer Leute gezählt, daher zähle ich sie auch hier nicht. Es ist absolut machbar, wenn man die linke Seite von verwendet Tastatur, obwohl, Ctrl- X, Ctrl- S, Ctrl- X, Ctrl- C.)

Nehmen Sie jeweils einen Befehl (oder einen Block ähnlicher Befehle):

• W, S: WSIn das Dokument eingeben .
• Esc, $: Rufe die Rechtschreibprüfung auf. WSist kein richtiges Wort, findet aber viele ähnliche Wörter mit zwei Buchstaben.
• D: Verwenden Sie die Rechtschreibprüfung, um WSzu korrigieren PS. (Wenn die Rechtschreibprüfung wie hier mit Alt- aufgerufen wird $( Escund AltEmacs entspricht), wird nur ein Wort überprüft und danach deaktiviert.)
• A: einfügen A, geben PSA.
• Ctrl- T: Vertausche die beiden vorherigen Zeichen und gib PAS.
• S, R, W, D: Typ SRWD, geben PASSRWD.
• Esc, $, 5Wir die Rechtschreibprüfung wieder aufrufen, weil wir unsere falsch geschrieben korrigieren möchten PASSRWDin PASSWORD. Beachten Sie, dass wir nicht das Wort erraten können, das wir bei unserem ersten Versuch wollen, wie es bei dem ersten Versuch der Fall wäre PASSWRD, da der Schlüssel zum Akzeptieren des nächsten echten Wortes der ist, 0den wir nicht drücken können. Infolgedessen wird die etwas extremere Rechtschreibfehler PASSRWDverwendet, um das gewünschte Wort auf Position 5 zu verschieben, wo wir es akzeptieren können.
• Ctrl- Q, 5, f: Legen Sie die Zeichen mit Zeichencode U + 5f, das heißt _. Das Dokument liest jetzt PASSWORD_(oder wird, wenn wir mit der Eingabe des nächsten Befehls beginnen; vorher wird der Unterstrich nicht angezeigt, falls wir eine andere Hex-Ziffer eingeben).
• Ctrl- X, r, Ctrl- Space, 1: Speichert die aktuelle Cursor - Position (relativ zum Anfang der Datei) in Register 1. Aus irgendeinem Grund , bizarre, ist dies 1-indexiert, so (9 Zeichen geschrieben zu haben bisher) der Cursor an der Position ist 10.
• Ctrl- X, r, g, 1: Kopieren Sie den Inhalt des Registers 1 in das Dokument. Es liest jetzt PASSWORD_10.
• Ctrl- T: Vertauschen Sie die beiden Zeichen vor dem Cursor. Wir haben jetzt PASSWORD_01, wie die Frage fragt.

Wenn wir es verwenden dürfen Alt, können wir den Befehl "Rechtschreibprüfung aufrufen" wahrscheinlich als einzelnes Byte codieren, a4anstatt es als zu buchstabieren 1b 24. es erscheint zweimal, so dass sich zwei Bytes Einsparung ergeben. (Die meisten modernen Terminals verwenden 1b 24die Codierung für Alt- $, um Konflikte mit UTF-8 zu vermeiden. Die a4Codierung wird jedoch auch von Zeit zu Zeit angetroffen und ist manchmal als Konfigurationsoption verfügbar.)

Mögliche Einsparungen bei den Bytes sind wahrscheinlich mit Schreibfehlern bei der Korrektur verbunden. PSASWRDwäre ein Byte kürzer zu tippen, aber leider scheint die Rechtschreibprüfung nicht dazu in der Lage zu sein, dies PASSWORDherauszufinden. Dies PASSRWDist der beste Ansatz, den ich bisher gefunden habe. Der auf Registern basierende Ansatz des Gewinnens 10ist ebenfalls lächerlich unhandlich, aber es gibt in Emacs nicht viele Möglichkeiten, Zahlen aus dem Nichts zu erstellen, und es 0ist eine schmerzhafte Angelegenheit, etwas anderes in die Hand zu nehmen. (Zumindest gab es ein paar erstaunlich nützliche Zufälle: Der Cursor landete zufällig an der Position 10, die 0bei Bedarf ein a enthält , und die Tatsache, dass Emacs die redundante gRegisteroperation akzeptiert , um den Inhalt eines Registers in das Dokument einzufügen , zusätzlich zu den intuitivereni.)