Zostałeś zatrudniony za swoją wiedzę techniczną jako pomocnik Tajnego Agenta, aby zapewnić, że dobry facet może wykonać swoją pracę i uratować świat.

To twoja ostatnia misja przed przejściem na emeryturę z wysoką wypłatą i wdzięcznością całego świata. Ale zanim będziesz musiał rozbroić BOMB Big Overly Massive Złego Geniusza (wydaje się, że zły geniusz jest mądrym dupkiem, który lubi rekurencyjne akronimy). W każdym razie ty i twój kumpel jesteście w samym centrum tajnej bazy Geniusza Zła, gotowi rozbroić BOMBę, która może zniszczyć kontynent. W poprzedniej misji udało ci się zdobyć kod rozbrojenia, który ku twojemu zdziwieniu to po prostu „PASSWORD_01”. Podłączasz klawiaturę do BOMB, ale kiedy jesteś gotowy do drogi, poplecznicy Złego Geniusza wchodzą z salwą pocisków. Niestety jeden z tych pocisków wpływa na klawiaturę. „Skończ pracę, a ja odwrócę uwagę tych cholernych głów!” mówi twój kumpel, a potem zaczyna strzelać.

OKULAR

1. Napisz program, który wypisuje w dowolny sposób ciąg znaków PASSWORD_01(wielkie litery).

2. Ponieważ kula trafiła w klawiaturę, możesz używać tylko tych klawiszy:

   1 2 3 4 5

   Q W E R T

   A S D F G

   < > Z X C

   Ctrl Shift Tab Space

   Za pomocą Shiftklawisza klawiatura umożliwia używanie następujących znaków:

   ! " · $ %

3. Nie masz innego sprzętu niż klawiatura i ekran (na przykład mysz), ani pliku z hasłem zapisanym na komputerze.

4. Nie masz połączenia z Internetem.

5. Możesz założyć, że edytor powłoki / edytora kodu źródłowego został otwarty przed pojawieniem się pocisków. Niestety, nie napisałeś w nim nic przed uderzeniem klawiatury.

6. Nie masz wirtualnej klawiatury. W rzeczywistości BOMB ma detektor TOO_FUNNY, który spowoduje eksplozję, jeśli spróbujesz użyć standardowych luk .

7. Ponieważ twój kumpel czeka, aż niedługo skończysz ucieczkę z Tajnej Bazy, będziesz musiał napisać jak najmniejszy kod (więc jest to ograniczony kod źródłowy i golfowy kod !).

Powodzenia, bo zaczęło się odliczanie!

TRYB POMOCY:KEY Cudownie przetrwał także (tylko jeden klawisz, którego potrzebujesz z klawiatury, ale nie Shift + klawisz lub jakakolwiek inna kombinacja). Np: Można użyć =albo 0albo /... Ten dodatkowy klucz nie może być każdy z literami PASSWORD_01(więc nie można dodać Plub O). Nazwij ten klucz w swojej odpowiedzi. Kara za używanie tego klucza wynosi 10 znaków, niezależnie od tego, ile razy używasz klucza.

CJam - 24 + 10 ( () = 34

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

Bez dodatkowego klucza - 39

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

Wypróbuj na http://cjam.aditsu.net/

bash, vim i dc (343)

Siedzę po zachęcie, która została skonfigurowana przez Geniusza Zła, i oczywiście ma to miejsce VISUAL=vimw domyślnym środowisku. Użycie domyślnego wiązania bash dla edit-and-execute-command( C-x C-e) bash wywołuje $VISUALi wykona zawartość bufora przy exit ( ZZ). Piszę w następującej kolejności (uwaga: kbd-mode to polecenia wydawane w trybie normalnym i sekwencje kontrolne):

1. C-xC-e

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

   Teraz zawiera bufor vim cat<<<49a. Kontynuacja ...

3. 45 C-c3C-aaa

4. 54 C-c41C-aaa

5. 55 C-c13C-aaa

   Teraz zawiera bufor vim cat<<<49a48a95a68a. Kontynuacja ...

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

    Teraz zawiera bufor vim cat<<<49a48a95a68a82a79a87a83a83a65a80a>s

    Wyjdź z trybu wstawiania, zapisz i wyjdź

13. C-cZZ

    sPlik zawiera teraz dcskrypt, który generuje żądany ciąg na stosie, teraz musimy dodać polecenia drukowania.

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

    Powtórz powyższe polecenie 9 razy.

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-eakot <<< f >> s

    Uruchom skrypt dc:

25. C-xC-eadc sC-cZZ

Wynik:

PASSWORD_01

Zawartość spliku:

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"%$*

Ta odpowiedź używa *i %do budowania wartości ASCII brakujących znaków (i 0 jako Fixnum) i wypycha je do $*( ARGV). Tablica ta jest następnie używana w połączeniu z łańcuchem formatu w celu wygenerowania poprawnego hasła, które jest drukowane za pomocą $><<( $>jest standardowe).

Ruby, 62 + 10 ( .) = 72, bez podziału linii

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

Z grubsza ta sama zasada, co w powyższej wersji, z tą różnicą, że tutaj tablica jest zbudowana z pustej literału ( %w%%). .Konieczne jest trochę manipulowania , aby uzyskać pożądany priorytet operatora.

Biała spacja (148 + 10 = 158)

Enter należy użyć klucza tutaj.

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

Wyjaśnienie mojej notacji:

• S, +, 0Są przestrzenie.
• T, 1są zakładkami.
• L to nowa linia.
• // zaczyna komentować.

Każda linia to polecenie w języku białych znaków.

Próbny

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

Potrzebowałem + postaci (kosztuje +10), którą można uzyskać z klawiatury numerycznej (lub w niektórych układach klawiszy).

Tak, BOMB prawdopodobnie wybuchł, kiedy to pisałem.

Podstawowym podejściem jest konstruowanie coraz większych zestawów znaków przy użyciu execi "%c"%(number). Cztery są execzagnieżdżone w sobie. Stopniowo mój zestaw cyfr rośnie od

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

aby w końcowej iteracji można było wyrazić dowolny znak (tak, aby najbardziej wewnętrzna wersja mogła w ogóle uruchomić dowolny program).

Około 50% programu to tylko znaki cudzysłowu ( "%c"%34jest to podwójny cudzysłów), ponieważ zagnieżdżona natura execinstrukcji wymaga agresywnego „ucieczki” znaków cudzysłowu.

Bezsenność 39 35 31 29

Ten język pojawia się, kiedy rozglądałem się za językiem, który koduje instrukcje za pomocą pojedynczego znaku ASCII. Język faktycznie działa na dziesiętnym kodzie ASCII znaku, więc nadal jest dość elastyczny, gdy połowa klawiatury jest zniszczona.

Upuść go dalej do 29 znaków, co jest możliwe po zmniejszeniu zużycia pamięci i zwiększeniu przestrzeni wyszukiwania:

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

Postanowiłem uruchomić mój ulepszony program na pełnym zestawie dozwolonych znaków i zredukowałem rozwiązanie do 31 znaków:

FdFGt dtreeC>tt FFdx<Fdtr ztq4s

Użyłem programu do wyszukiwania tego rozwiązania. Jest to jedno z wielu rozwiązań zwróconych przez mój program, wszystkie o tym samym rozmiarze.

Fddx>"eCeezdC>CefCdddzCzzfCqred>r4s

Stara wersja wykonana ręcznie. Pamiętam, że zostałem do rana, żeby to zrobić.

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

Oto interpreter Insomnia do testowania.

Vim + PHP na niektórych menedżerach okien

65 klawiszy w 44 uderzeniach, z 10 punktową karą za użycie =.

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

Załamanie:

• Alt+Tabwydaje się działać jak w Escprzypadku Vima lub być może w tym emulatorze terminali. Dzięki za nauczenie mnie czegoś nowego!
• aEACE<Alt+Tab>: Wejdź w tryb dołączania i wstaw „EACE”. Wyjście.
• z=5<Alt+Tab>: Wykonaj korektę pisowni. Wybierz 5, „POKÓJ”. Wyjście. ( Escwydaje się działać jak Entertutaj!)
• $xxxxaASSWRD<Alt+Tab>: Idź do końca linii. Usuń 4 znaki i dodaj ASSWRD, co spowoduje PASSWRD. Powrót do trybu normalnego. (Nie, 4xnie zadziała.)
• z=1<Alt+Tab>: PASSWORDJest prawdopodobnie będzie pierwsza korekta do tego. Wybierz to.
• $a$aA<Alt+Tab>: Przejdź do końca linii i dodaj $aA. Powrót do trybu normalnego.
• ==: Ładnie sformatuj ten wiersz PHP, zmieniając camelCase $aAna $a_a. Spowoduje to również przesunięcie kursora z powrotem na początek linii.
• wxx: Idź naprzód słowo; kursor jest teraz wcześniej $. Usuń dwa znaki - the $i the a- to make PASSWORD_a.
• $r1: Przejdź na koniec wiersza i zamień bieżący znak (tj. a) Na 1, w wynikuPASSWORD_1 .
• ^X: Zmniejsz liczbę całkowitą pod kursorem, w wyniku czego PASSWORD_0 .
• a1: Na koniec dołącz 1do PASSWORD_01!

Python 2, 75889 bajtów

Bez dodatkowej postaci!

Niestety kod jest bardzo długi. Zamiast tego oto kod do wygenerowania programu:

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

Wypróbuj online

(aby uruchomić kod, zmień zewnętrzną printna exec. Lub, wygeneruj program, a następnie wklej i uruchom. Lub skopiuj z pastebin, do którego link znajduje się poniżej.)

Wyjaśnienie:

Celem jest wykonanie:

print"PASSWORD_01"

Aby uniknąć używania ()+znaków, musimy użyć wielu operacji formatu łańcucha połączonych razem. Oznacza to, że każdy dodany krok skutecznie podwaja liczbę %znaków potrzebnych do każdego poprzedniego kroku:

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

To jednak nie wystarczy, ponieważ niektórych wymaganych liczb nie można utworzyć i nie możemy tego zrobić print. Dlatego dodajemy poziom abstrakcji execdla printing i poziom dla punktów kodu ASCII, których nie możemy utworzyć do sformatowania. Poniższa odpowiedź jest w zasadzie moją odpowiedzią, ale z każdym ciągiem %zredukowanym do jednego (zauważ, że %s%s%s%s%snie jest to dokładna reprezentacja, ponieważ nie uwzględnia %wymaganego literału przed każdym):

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

Pierwszy krok: najbardziej na zewnątrz 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, używane 0wPASSWORD_01
2. 2531>>5: 79, używane dla wewnętrznego exec do utworzeniaO
3. 321>>2: 80, używane dla wewnętrznego exec do utworzeniaP
4. 1521>>4: 95, używane dla wewnętrznego exec do utworzenia_
5. 211>>1: 105, używane dla wewnętrznego exec do utworzeniai
6. 221>>1: 110, używane dla wewnętrznego exec do utworzenian

Drugi krok: przygotowanie wewnętrzne exec

Po powyższym wewnętrzna execjest coś takiego:

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

Tyle że nie do końca byś to zrozumiał. Wciąż dzięki uproszczeniom otrzymasz:

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

Dosłowność %należy uwzględnić. Zasadniczo więc musiałem dodać kilka z nich przed każdym, %saby po dosłownym zakończeniu pozostały dosłowne %litery. 2**11z nich. Razy pięć.

Pozostałe execoperacje na zewnętrznym formacie ciągu są %112%34%34%34%34. To 112jest p, a pozostałe są znakami cudzysłowu. Po zastosowaniu tych wyników jest mniej więcej taki:

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

Ale w rzeczywistości ma o wiele więcej %. To jest to:

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

Ostatnim krokiem jest po prostu uruchomienie tego, po czym otrzymasz niezbędne dane wyjściowe.

Pełny kod tutaj: http://pastebin.com/rSFs6DiH

bash + vim (56)

Pożyczając Ctrl-XCtrl-Esztuczkę bashową z rozwiązania Thora, oto jak bym to zrobił w bash + vim:

C-XC-E uruchamia domyślny edytor (zwykle vim)

a uruchamia tryb wstawiania

.space ASSW

C-Vx4f wkładki O

RD

C-Vx5f wkładki _

1

C-3jest równoważne escape(nie tylko w vimie, ale gdziekolwiek w terminalu)

C-Xodejmuje 1 od 1właśnie wpisanego

a tryb wstawiania ponownie

1 C-3

zawartość bufora jest teraz . ASSWORD_01

<< unindent line (no-op, ponieważ linia nie jest wcięta) i przenieś kursor do 1. kolumny

a

C-X rozpocznij uzupełnianie słów

C-V w komplecie z komendą ex

C-V Jeszcze 9 razy wybiera wpis Print

C-3 powrót do normalnego trybu

XXXxx usuwa rint 

< < powrót do kolumny 1

susuń ., uruchom tryb wstawiania

e c C-X C-Vex wykonanie polecenia jeszcze raz, wpis został echojuż wybrany z powodu ecwłaśnie wpisanego

space C-3 buforuj teraz zawartość echo PASSWORD_01

Z Z zapisz bufor, zamknij vim, bash wykonuje zawartość pliku, tj echo PASSWORD_01

Nawiasem mówiąc: C-3ma wielu przydatnych braci: C-Jjest Enter, C-Ijest Tab, C-Hjest Backspace, C-2jest C-@(tj. Bajt zerowy). A dla użytkowników emacsa dobrze jest wiedzieć, że Escapepo którym następuje kolejny klucz jest równoważny Alt+ temu kluczowi. Więc nawet bez Escapei Altnadal możesz wpisać Meta-x w ten sposób:C-3x

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

( ^użyty klucz, 3 sposoby)

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

• Prawidłowe, jeśli uruchomione jako polecenie systemowe kwalifikuje się jako „wynik”.

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

• Ważne, jeśli wolno mi używać poleceń zewnętrznych / systemu operacyjnego. (Uruchom tutaj)

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

• Ważne, jeśli mogę uruchomić Perla za pośrednictwem systemu. (Uruchom tutaj) <- ten używa printzamiastdie

Skrypty używają bitowego ciągu XOR operatora Perla ^ , który wykonuje XOR na bitach znaków dwóch łańcuchów. To pozwala mi odtworzyć brakujące znaki dla PASSWORD_01 i utworzyć znaki dla polecenia systemowego.

Zrobiłem trzy warianty w zależności od łagodności reguł. Zakładam, że ponieważ warianty 2 i 3 faktycznie wypisują słowa na Ideone, rozwiązania są prawidłowe. Usunąłem małą historię, którą tu miałem, ponieważ doszedłem do wniosku, że nikt jej nie przeczyta, ale możesz przeczytać ją w edycji, jeśli jesteś ciekawy!

oOo kod (300)

QwerTaSdfGzxCqwertAsDfgZxCQwerTasDfgZxcQweRtaSDfgZxCqwertAsDFgZXcQWeRtaSdFGzxcQwERTasdfGzxc
QwErtAsdFgzxcqWeRtaSdFGzxcQweRtaSDfGZxCqWErTAsDFgZXCqWerTasDfgZxcQweRtaSdfGzxCQwErTAsDFgZXC
qWertAsDfgzxcQwERtASdFGzXcqWeRTasdFGzXcQWeRtAsDfgzxcQwERtASdFGzXCqWerTaSDfgzXcQWErTaSdFgZxc
QwertaSdFgzXcQWertASdFgZXCq

Łatwo. (Podawanie liniowe jest opcjonalne i tylko tutaj, aby kod był „bardziej czytelny”) Zastosowany generator kodu:

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

Ten sam kod w mniej głupim kodowaniu:

EeeeEeEeeEeeEeeeeeEeEeeEeEEeeeEeeEeeEeeEeeEeeEEeeEeEeeeeeEeEEeEEeEEeEeeEeEEeeeEeEEEeeeeEeee
EeEeeEeeEeeeeeEeEeeEeEEeeeEeeEeeEEeEEeEeEEeEEeEEeEEEeEeeEeeEeeEeeEeeEeeEeeEeeEEeEeEEeEEeEEE
eEeeeEeEeeeeeEeEEeEEeEEeEeeEeEEeeeEEeEeEEeEeEeEeeeeeEeEEeEEeEEeEEeEeeEeEEeeeEeEEEeEeEeEeEee
EeeeeeEeEeeEeEEeeeEEeEeEEEe

ferNANDo, 179 + 10 = 189 bajtów

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

Wypróbuj online!

Enterużywany. Użyłbym 0i 1aby kod był bardziej czytelny, ale nie mogę go użyć 0.

JS-Forth, 103 bajty

Ciąg zostanie zwrócony na stosie jako tablica znaków.

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

Wypróbuj online - skomentowana wersja

Wyjaśnienie:

Najpierw znalazłem listę dozwolonych słów . Zasadniczo jedyne rzeczy, które mogłyby być przydatne, to:

• 12345 Stałe numeryczne
• << Przesuń w lewo
• >> Przesuń w prawo
• s>f Wciśnij stos pojedynczy do pływaka
• f>d Pop podwójne ze stosu pływaka
• fsqrt Pierwiastek kwadratowy na stosie zmiennoprzecinkowym

Więc mógłbym użyć stałych numerycznych, przesunięcia bitów i obliczyć pierwiastek kwadratowy, używając następującego ( >>zamienia drop, przesuwa się o, 0aby usunąć 0):

s>f fsqrt f>d >>

Na szczęście znalazłem możliwe przesunięcia bitów dla każdej stałej, którą potrzebowałem stworzyć, które były krótsze niż użycie pierwiastków kwadratowych. Przeważnie szukałem, drukując po prostu każdą liczbę do kwadratu lub większą potęgę dwóch, jeśli którakolwiek z nich zawierała cyfrę 6-0. Potem zdałem sobie sprawę, że mogę użyć utraty precyzji, f>daby znaleźć więcej możliwości. (Mógłbym dodać do liczby, ale nadal uzyskać ten sam pierwiastek kwadratowy z liczby całkowitej). Nieco później zacząłem używać przesuwania bitów, aby znaleźć niektóre, a potem wszystkie stałe. Im większe >>przesunięcie bitów, tym więcej mogę dodać do „magicznej liczby” i nadal uzyskać ten sam wynik. Znalazłem więc najmniejsze przesunięcia bitowe, których mogłem użyć, aby uzyskać niezbędne wyniki. Czasem nawet liczby mogły się przydać <<, trzeba było użyć kursów >>.

Skomentowany kod ( \rozpoczyna komentarz):

\ 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 nie ma słów <<lub >>. Zamiast tego ma lshifti rshiftczego nie mogłem użyć .

Dziesiętny , 190 180 + 10 = 190 bajtów

12055D12025D41D301212055D12010D41D301212055D12025D41D12003D41D30130112004D41D301212055D12024D41D30112003D41D301212055D12013D41D301212055D12040D41D301212045D12003D41D30112001D41D301

Wypróbuj online! Dziesiętny jest językiem ezoterycznym, który używa wyłącznie miejsc po przecinku i litery D. Potrzebowałem jednak kary +10, ponieważ prawie każde polecenie używa 0.

Na szczęście wszystkie polecenia potrzebne do drukowania PASSWORD_01nie wymagają żadnych liczb powyżej 6:

• 12...D - pchnij postać
• 2 - pop wartość
• 41D - pop najwyższe dwie wartości stosu, pomnóż i wypchnij wynik
• 301 - wydrukuj DSI (domyślny indeks stosu)

Naciskając wielokrotnie wartości znaków, które używają tylko cyfr od 1 do 5, a następnie dodając je, mogę wprowadzić wartości znaków dla każdej litery w PASSWORD_01.

Nie golfił i skomentował:

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

Biała spacja , wynik: 111 (101 bajtów + 10 za 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]

Litery S(spacja), T(tab) i N(nowa linia) dodane tylko jako wyróżnienia.
[..._some_action]dodano tylko jako wyjaśnienie.

Wypróbuj online (tylko z surowymi spacjami, tabulatorami i nowymi wierszami).

Objaśnienie w pseudo-kodzie:

To rozwiązanie jest krótsze niż istniejąca odpowiedź na Whitespace ( @ n̴̖̋h̷͉̃a̷̭̿h̷̰̀ĥ̷̳d̷̰̀ĥ̷̳ poprosiła mnie o opublikowanie jej jako oddzielnej odpowiedzi, gdy zasugerowałem ją jako golfa), wykorzystując moją moją wskazówkę Whitespace .

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

Stała 80została wygenerowana za pomocą tego programu Java , który stworzyłem i użyłem dla niektórych moich wcześniejszych odpowiedzi w Whitespace.

Stax , 91 + 10 bajtów

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

Wypróbuj online!

Używa ] singletonów.

Wyjaśnienie

Zobaczmy, jak "P"jest generowany i jak "ASSW"jest dołączany bez użycia zwykłego +.

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

Reszta po prostu powtarza tę samą sztuczkę.

"a"EEE$"$"a$Re]Rzamienia cyfry "a"lub [97]na [79]lub, "O"i dołącza go do ciągu.

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

"$""a"EEEd$"$""5"Re]Rużywa "a"ponownie, aby uzyskać "9"i odrzuca "7", a następnie łączy "9"literał "5"z literałem, aby utworzyć [95]lub "_", i dołącza go do łańcucha.

"$"1 !$R otrzymuje zero przez logiczne nie 1 i dołącza je do ciągu.

"$""1"Rdołącza finał "1"i gotowe.

Wyjściowy wynik.

pieprzenie mózgu , 400 + 10 ( +) = 410 bajtów

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

Wypróbuj online!

Kod maszynowy MS-DOS .COM 8086 (72 bajty)

Czas jest cenny, więc nie ma czasu na szczegółowe rozmowy z kompilatorami lub tłumaczami! Po prostu otwórz wybrany edytor tekstu i wpisz następujące polecenie (zamień na \tTAB):

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

Jako zrzut heksowy:

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$

Zapisz jako plik .COM i uruchom go, aby zapisać dzień.

Kod zakłada pewne wartości początkowe dla rejestrów , więc może nie działać dla wszystkich odmian DOS. Mam tylko nadzieję, że ktoś ryzykował wyrzuceniu przez nie kupując IBM.

Nieco bardziej zrozumiała reprezentacja:

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 bajty

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

Wypróbuj online!

Kara 10 bajtów dotyczy użycia ,klucza (nie jestem pewien, dlaczego nie można tego osiągnąć za pomocą Shift+ <, ale wydaje się, że to reguła). I chociaż technicznie źródło ma 40 znaków, trzy ·znaki mają dodatkowe trzy bajty z powodu kodowania UTF-8.

05AB1E , 87 86 bajtów

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

Wypróbuj online!

Być może najdłuższy kod 05AB1E w historii?

Niestety język nie obsługuje takich rzeczy "Q"< „zmniejszenie Q, aby uzyskać P”

Moim dodatkowym kluczem jest V.

Dzięki @Kevin Cruijssen za -1 bajt.

Kod:

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 

Dla porównania: Najkrótszy sposób wydrukowania „PASSWORD_01” ma długość 6 bajtów

Wypróbuj online!

Emacs, 26 bajtów (ewentualnie + 10 = 36 lub - 2 = 24)

Dodatkowy klucz potrzebny w tej odpowiedzi to Esc. Jest to połowa klawiatury, która jest nadal nienaruszona, ale z jakiegoś powodu nie została wymieniona w pytaniu, więc może, ale nie musi, ukarać wynik. ( Esci Altsą równoważne w Emacsie; Altznajduje się również na nienaruszonej połowie klawiatury, ale nie jest wymieniony w pytaniu, ale musi być przytrzymany zamiast stukania, więc nie mogę użyć go jako mojego dodatkowego klucza. Pozwoliłoby to zaoszczędzić dwa bajty , ponieważ ma krótsze kodowanie niżEsc ).

Sam program (przecinki ograniczają granice między bajtami w formacie sieciowym używanym przez Emacsa do akceptacji jego danych wejściowych):

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

Kodowanie tego jako surowych bajtów, aby udowodnić liczbę bajtów:

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

(Uwaga: niektóre szczegóły mogą się różnić w zależności od konfiguracji Emacsa; ta odpowiedź wymaga quot-char-radix na 16, a Emacs może korzystać ze słownika sprawdzania pisowni, który jest domyślny w moim systemie brytyjsko-angielskim. Oba wydają się być jak rozsądne ustawienia konfiguracji, ale możliwe jest, że twoja kopia Emacsa może być skonfigurowana inaczej. Inny słownik prawdopodobnie nadal dawałby program 26-bajtowy, ale może być konieczne użycie nieco innych błędów pisowni, aby poprawki, które chcieliśmy, mogły zostać zaakceptowane przez klucze bez kul).

Wyjaśnienie

Nie jestem pewien, czy powinno to mieć jakikolwiek wpływ na wojny redaktorów, ale Emacs wydaje się bić vima przynajmniej w przypadku tego pytania. Emacs jest całkiem odpowiedni dla edytora golfa mierzonego w bajtach, ponieważ opiera się w dużej mierze na akordach, które wymagają wielu naciśnięć klawiszy, ale tylko jednego bajtu (dlatego program Emacsa jest często wolniejszy w pisaniu niż równoważny program Vima, ale krótszy na dysku). Ponadto większość najważniejszych poleceń Emacsa znajduje się w lewym dolnym rogu klawiatury, aby być blisko Ctrl, bardzo pomocna przy takim pytaniu.

„Możesz założyć, że edytor powłoki / edytora kodu źródłowego został otwarty przed pojawieniem się pocisków. Niestety nie napisałeś w nim niczego przed uderzeniem klawiatury.”, Więc zakładam, że mamy otwarty plik w Emacsie i musisz wpisać w nim hasło. (Musielibyśmy później zapisać plik i prawdopodobnie wyjść z Emacsa, ale bajty na to nie są liczone w odpowiedziach innych osób, więc też ich tutaj nie liczę. Jest to całkowicie wykonalne przy użyciu lewej strony klawiatura jednak Ctrl- X, Ctrl- S, Ctrl- X, Ctrl- C.)

Jednoczesne przyjmowanie polecenia (lub bloku podobnych poleceń):

• W, S: Wprowadź WSdo dokumentu.
• Esc, $: Wywołanie sprawdzania pisowni. WSnie jest prawdziwym słowem, ale zawiera wiele podobnych dwuliterowych słów.
• D: Korzystanie z sprawdzania pisowni, prawidłowa WSdo PS. (Gdy sprawdzanie pisowni jest wywoływane przy użyciu Alt- $, jak to się stało tutaj ( Esci Altsą równoważne Emacsowi), sprawdza tylko jedno słowo, więc wyłącza się po tym.)
• A: wstawić A, dając PSA.
• Ctrl- T: Zamień poprzednie dwa znaki, dając PAS.
• S, R, W, D: Rodzaj SRWD, dawanie PASSRWD.
• Esc, $, 5: Wzywamy ponownie sprawdzania pisowni, ponieważ chcemy poprawić nasz błędnie PASSRWDsię PASSWORD. Zauważ, że nie możemy zgadnąć słowa, które chcemy za pierwszym razem, tak jak by to zrobiło PASSWRD, ponieważ kluczem do zaakceptowania najbliższego prawdziwego słowa jest to, 0którego nie możemy nacisnąć. W rezultacie nieco bardziej ekstremalne błędy ortograficzne PASSRWDsą używane do popychania słowa, które chcemy, do pozycji 5, gdzie możemy je zaakceptować.
• Ctrl- Q, 5, f: wstawić znak o kodzie znak U + 5f, tj _. Dokument czyta teraz PASSWORD_(lub będzie, gdy zaczniemy wpisywać następne polecenie; wcześniej znak podkreślenia nie pojawia się w przypadku wpisania innej cyfry szesnastkowej).
• Ctrl- X, r, Ctrl- Space, 1: przechowywać aktualną pozycję kursora (względem początku pliku) w rejestrze 1. Dla jakiegoś dziwacznego powodu, to jest 1-indeksowane, więc (po napisaniu 9 znaków do tej pory) kursor znajduje się w pozycji 10.
• Ctrl- X, r, g, 1: Skopiuj zawartość rejestru 1 do dokumentu. Teraz czyta PASSWORD_10.
• Ctrl- T: Zamień dwa znaki przed kursorem. Mamy teraz PASSWORD_01, podobnie jak pytanie.

Jeśli wolno nam użyć Alt, prawdopodobnie możemy zakodować polecenie „invoke spellchecker” jako pojedynczy bajt a4zamiast przeliterować go jako 1b 24; pojawia się dwa razy, co prowadzi do dwóch bajtów oszczędności. (Większość współczesnych terminali używa 1b 24jako kodowania Alt- $aby uniknąć kolizji z UTF-8, ale a4kodowanie jest również spotykane od czasu do czasu, czasami dostępne jako opcja konfiguracji).

Możliwe oszczędności bajtów prawdopodobnie wymagają poprawek pisowni golfisty. PSASWRDbyłby bajt krótszy do wpisania, ale niestety, moduł sprawdzania pisowni nie wydaje się być w stanie PASSWORDwyciągnąć z tego, więc PASSRWDjest to najlepsze podejście, jakie do tej pory znalazłem. Podejście oparte na rejestrach do zdobywania 10jest również absurdalnie niewygodne, ale Emacs nie ma wielu sposobów tworzenia liczb z nikąd i 0jest bolesną postacią, aby zdobyć inaczej. (Przynajmniej zdarzyło się kilka niezwykle przydatnych zbiegów okoliczności: kursor właśnie kończy się w pozycji 10, która zawiera 0, w razie potrzeby, dokładnie; oraz fakt, że Emacs akceptuje zbędne .)g operację rejestru, aby wstawić zawartość rejestru do dokumentu , oprócz bardziej intuicyjnychi