İyi bir adamın işini yapmasını ve dünyayı kurtarmasını sağlamak için bir Gizli Ajan'ın yardımcısı olarak teknik bilgin için işe alındın.

Bu, yüksek maaş ve tüm dünyaya şükranla emekli olmadan önceki son göreviniz. Ancak, Evil Genius'un Büyük Aşırı Büyük BOMB'u silahsızlandırmak zorunda kalmadan önce (şeytani dehanın özyinelemeli kısaltmaları seven akıllı bir göt olduğu anlaşılıyor). Her neyse, siz ve arkadaşınız, Evil Genius gizli üssünün tam merkezinde bulunuyorsunuz, kıtayı yok edebilecek BOMB'u silahsızlandırmaya hazırsınız. Önceki görevinde, şaşkınlığın sadece "PASSWORD_01" olduğunu belirten silahsızlanma kodunu almayı başardın. Klavyenizi BOMB'a bağladığınızda, gitmeye hazır olduğunuzda, Evil Genius'un uşakları bir mermi barajına girer. Ne yazık ki bu mermilerden biri klavyenizi etkiliyor. "Bu d * ckheads'ın dikkatini dağıtırken işi bitir!" arkadaşın diyor ve sonra silahını ateşlemeye başlar.

ÖZELLİKLER

1. Dize PASSWORD_01(büyük harf) istediğiniz şekilde çıktı veren bir program yazın .

2. Klavyenize bir kurşun çarptığından, yalnızca şu tuşları kullanabilirsiniz:

   1 2 3 4 5

   Q W E R T

   A S D F G

   < > Z X C

   Ctrl Shift Tab Space

   ShiftKlavyeniz , tuşu kullanarak şu karakterleri kullanmanızı sağlar:

   ! " · $ %

3. Klavyeden ve ekrandan (örneğin bir fare) başka bir donanıma veya bilgisayarınıza yazılmış şifreli bir dosyaya sahip değilsiniz.

4. İnternet bağlantınız yok.

5. Mermi gelmeden önce tercüman kabuğu / kaynak düzenleyicisinin açık olduğunu varsayabilirsiniz. Ne yazık ki klavyeye basılmadan önce içinde hiçbir şey yazmamışsınızdır.

6. Sanal klavyen yok. Aslında, Standart boşlukları kullanmaya çalışırsanız, BOMB'un patlayan bir TOO_FUNNY dedektörü vardır .

7. Arkadaşınız Gizli Üssü'nden kaçmak için yakında bitmenizi beklediğinden, mümkün olan en küçük kodu yazmanız gerekecektir (bu yüzden sınırlı kaynak ve kod golf !).

İyi şanslar çünkü geri sayım başladı!

YARDIM MODU: Ayrıca KEY(klavyeden istediğiniz bir tuş, ancak Shift + Tuşuna veya başka bir kombinasyona değil) mucizevi bir şekilde hayatta kaldı. Örn: kullanabilirsiniz =, veya 0veya /… Bu ekstra anahtar, içerdiği harflerden PASSWORD_01hiçbiri olamaz (bu nedenle ekleyemezsiniz Pveya O). Cevabınızdaki anahtarı girin. Anahtarı kaç kere kullandığınızdan bağımsız olarak , bu tuşun kullanımı için 10 karakterlik bir ceza hakkınız vardır.

CJam - 24 + 10 ( () = 34

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

Ek anahtar yok - 39

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

Http://cjam.aditsu.net/ adresinde deneyin

bash, vim ve dc (343)

Evil Genius tarafından yapılandırılmış bir bash isteminde oturuyorum ve elbette VISUAL=vimvarsayılan ortamda. edit-and-execute-command( C-x C-e) Bash için varsayılan bash bağlamayı kullanmak bash çağırır $VISUALve tampon içeriğini exit ( ZZ) işlevinde yürütür . Aşağıdaki sıraya kbdgiriyorum (Not: -mode normal modda verilen komutlar ve kontrol sıralarıdır):

1. C-xC-e

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

   Şimdi vim tamponu içeriyor cat<<<49a. Devam ediyor ...

3. 45 C-c3C-aaa

4. 54 C-c41C-aaa

5. 55 C-c13C-aaa

   Şimdi vim tamponu içeriyor cat<<<49a48a95a68a. Devam ediyor ...

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

    Şimdi vim tamponu içeriyor cat<<<49a48a95a68a82a79a87a83a83a65a80a>s

    Ekleme modundan çıkın, kaydedin ve çıkın

13. C-cZZ

    sDosya şimdi içeriyor dcyığını üzerinde istenen dize oluşturur komut, şimdi baskı komutlar eklemek gerekir.

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

    Yukarıdaki komutu 9 kez tekrarlayın.

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

    Dc betiğini yürütün:

25. C-xC-eadc sC-cZZ

Çıktı:

PASSWORD_01

sDosyanın içeriği :

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

Ruby, 57 + 10 ( *) = 67

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

Bu cevap , eksik karakterlerin (ve 0'ın Fixnum'u) ASCII değerlerini oluşturmak için kullanır *ve %bunları $*( ARGV) içine iter . Bu dizi daha sonra $><<( $>stdout) ile basılan doğru şifreyi oluşturmak için bir format dizgisi ile birlikte kullanılır .

Ruby, 62 + 10 ( .) = 72, satır sonu yok

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

Kabaca yukarıdaki sürümle aynı prensip, burada dizi, boş bir dizi değişmezinden ( %w%%) yapılmıştır. Kurcalıyor Bazı .tabi istenilen operatör öncelik alır.

Boşluk (148 + 10 = 158)

Enter anahtarın burada kullanılması gerekiyor.

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

Yazımın açıklaması:

• S, +, 0Boşluklar vardır.
• T, 1sekmelerdir.
• L Yeni çizgi
• // yorumu başlatır.

Her satır, boşluk dilinde bir komuttur.

gösteri

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

Gerekli +sayısal tuş takımı elde edilen (veya belirli kilit düzenleri üzerine) olabilir (+10 maliyet) karakteri.

Evet, BOMB büyük olasılıkla ben yazarken gitti.

Temel yaklaşım kullanılarak daha da büyük karakter kümelerini oluşturmaktır execve "%c"%(number). İçinde execiç içe geçmiş dört tane var . Yavaş yavaş, basamak kümem

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

böylece son yinelemede herhangi bir karakteri ifade etmek mümkündür (böylece en içteki sürüm aslında herhangi bir programı çalıştırabilir).

Programın yaklaşık% 50'si sadece alıntı karakterleridir ( "%c"%34ikili bir alıntıdır) çünkü execifadelerin iç içe doğası alıntı karakterleri agresif bir şekilde "kaçmak" ister.

Uykusuzluk 39 35 31 29

Bu dil, talimatlarını tek ASCII karakteriyle kodlayan bir dili ararken ortaya çıkıyordu. Dil, karakterin ondalık ASCII kodunda çalışır, bu yüzden hala klavyenin yarısı yok edildiğinde oldukça esnektir.

Bellek kullanımını azalttıktan ve arama alanını arttırdıktan sonra mümkün olan 29 karaktere düşürün:

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

Tweaked programımı izin verilen karakter dizisinin tamamında çalıştırmaya karar verdim ve çözümü 31 karaktere indirdim:

FdFGt dtreeC>tt FFdx<Fdtr ztq4s

Bu çözümü aramak için bir program kullandım. Programımın döndürdüğü, hepsi aynı boyutta olan birçok çözümden biri.

Fddx>"eCeezdC>CefCdddzCzzfCqred>r4s

Elle yapılan eski versiyon. Bunu yapmak için sabaha kadar kaldığımı hatırlıyorum.

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

İşte test için Insomnia tercümanı .

Bazı Pencere Yöneticilerinde Vim + PHP

Kullanmak için 10 puanlık bir ceza ile 44 vuruşta 65 tuş =.

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

Bir arıza:

• Alt+TabEscVim gibi , ya da belki de bu terminal emülatörü ile çalışıyor gibi görünüyor . Bana yeni bir şey öğrettiğin için teşekkürler!
• aEACE<Alt+Tab>: Ekleme moduna giriniz ve “EACE” yazınız. Çıkış.
• z=5<Alt+Tab>: Yazım düzeltmesi yapın. 5, “BARIŞ” seçeneğini seçin. Çıkış. ( burada Escolduğu gibi çalışıyor gibi görünüyor Enter!)
• $xxxxaASSWRD<Alt+Tab>: Satırın sonuna gidin. 4 karakter silin ve ASSWRDsonuçta ekleyin PASSWRD. Normal moda dön. (Hayır, 4xişe yaramaz.)
• z=1<Alt+Tab>: PASSWORDOlduğu muhtemelen bunun için ilk düzeltme olacak. Seç onu
• $a$aA<Alt+Tab>: Satırın sonuna gidin ve bir tane ekleyin $aA. Normal moda dön.
• ==: CamelCase değişen güzel PHP'nin bu çizgiyi biçimlendirme $aAiçin $a_a. Bu aynı zamanda imleci tekrar satırın başına getirir.
• wxx: Bir kelime ileri git; imleç şimdiden önce $. İki karakteri siliniz - $ve a- yapmak için PASSWORD_a.
• $r1: Satırın sonuna gidin ve mevcut karakteri (yani a) ile değiştirin 1, sonuçta PASSWORD_1.
• ^X: İmlecin altındaki tamsayıyı düşürerek sonuçlanır PASSWORD_0.
• a1: Son olarak, ekleme 1için, PASSWORD_01!

Python 2,75889 bayt

Fazladan karakter yok!

Ne yazık ki, kod çok uzun. Yani bunun yerine, programı oluşturmak için kod İşte:

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

Çevrimiçi deneyin

(dış değiştirmek kod çalıştırmasına printbir içine execyapıştırın ve çalıştırın. Ya aşağıda bağlantısı pastebin kopyalamak sonra, programı oluşturmak. Or.)

Açıklama:

Amaç yürütmektir:

print"PASSWORD_01"

()+Karakterleri kullanmaktan kaçınmak için , birlikte zincirlenmiş çoklu string format işlemleri kullanmak zorundayız. Bu, etkili bir şekilde eklenen her adımın önceki her adım için gereken karakter sayısını iki katına çıkarması anlamına gelir %:

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

Ancak bu yeterli değil, çünkü gerekli sayıların bazıları oluşturulamıyor ve biz de yaratamıyoruz print. Bu yüzden ing execiçin bir soyutlama printseviyesi ve biçimlendiremeyeceğimiz ASCII kod noktaları için bir seviye ekledik. Esasen benim cevabım aşağıdaki gibidir, ancak her bir dize %tek bir taneye indirgenmiştir ( her birinin daha önce gerekli %s%s%s%s%solan hazırlıkları hesaba katamazsanız bunun doğru bir temsil olmadığını unutmayın %):

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

İlk adım: En dıştaki 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İçin kullanılan 0inPASSWORD_01
2. 2531>>5: 79, iç yürütme oluşturmak için kullanılırO
3. 321>>2: 80, iç yürütme oluşturmak için kullanılırP
4. 1521>>4: 95, iç yürütme oluşturmak için kullanılır_
5. 211>>1: 105, iç yürütme oluşturmak için kullanılıri
6. 221>>1: 110, iç yürütme oluşturmak için kullanılırn

İkinci Adım: İçini Hazırla exec

Yukarıdakilerden sonra, iç execböyle bir şeydir:

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

Bunun dışında pek bir şey anlamadın. Hala sadeleştirmelerle, şunu anlarsın:

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

Kelimenin tam anlamıyla %dahil edilmesi gerekiyor. Bu yüzden, temel olarak, her şeyden önce , bütün biçimlendirmelerden sonra %sbirebir kalan bitene bir demet eklemek zorunda kaldım %. 2**11Bunların Beşinci kat.

Dış execdize format işlemlerinin geri kalanı %112%34%34%34%34. Bunun 112için pve diğerleri tırnak işaretidir. Bunları uyguladıktan sonra, sonuç şöyle olur:

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

Ama gerçekte bir sürü daha var %. Bu:

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

Son adım, basitçe bunu çalıştırmaktır, ardından gerekli çıktıyı elde edersiniz.

Burada tam kod: http://pastebin.com/rSFs6DiH

bash + vim (56)

Ctrl-XCtrl-EThor'un çözümünden bash numarasını ödünç alırken, bash + vim'de nasıl yapacağımı şöyle gösterir:

C-XC-E varsayılan düzenleyiciyi başlatır (genellikle vim)

a ekleme modunu başlatır

.space ASSW

C-Vx4f uçlar O

RD

C-Vx5f uçlar _

1

C-3eşittir escape(sadece vimde değil, terminalin herhangi bir yerinde)

C-X1Sadece az önce yazılan 1 çıkarır

a modu tekrar ekle

1 C-3

tampon içeriği şimdi . ASSWORD_01

<< unindent satırı (no-op, çünkü satır girintili değildir) ve imleci 1. sütuna getir

a

C-X sözcük tamamlamayı başlat

C-V ex komutu ile tamamlandı

C-V 9 kez daha girişi seçer. Print

C-3 normal moda dön

XXXxx siler rint 

< < sütun 1'e geri dön

ssil ., ekleme modunu başlat

e c C-X C-VEski komut tamamlama kez daha giriş echoyüzünden zaten seçilmiş ecben sadece daktilo

space C-3 şimdi tampon içeriği echo PASSWORD_01

Z Z tamponu kaydet, vim'i kapat, bash dosya içeriğini çalıştırır, yani echo PASSWORD_01

Bu arada: C-3: birçok yararlı kardeşleri sahip C-Jolduğu Enter, C-Iolduğu Tab, C-Holduğu Backspace, C-2olduğu C-@(yani, boş bir bayt). Ve emacs kullanıcıları için, Escapebaşka bir anahtarın ardından Alto tuşa eşdeğer olduğunu bilmek güzel . Yani, onsuz Escapeve hatta AltMeta-x'i böyle yazabilirsiniz:C-3x

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

( ^kullanılan anahtar, 3 yol)

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

• Bir sistem komutu olarak çalışıyorsa "çıktı" olarak nitelendirilirse geçerlidir.

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

• External / OS komutlarını kullanmama izin verilirse geçerlidir. (Buraya koş)

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

• Sistemden Perl'i çalıştırabilirsem geçerlidir. (Burada çalıştır) <- printbunun yerine bunu kullanıyordie

Betikler ^, iki dizenin karakter bitlerinde bir XOR yapan Perl'in bitsel string XOR operatörünü kullanır . Bu, PASSWORD_01 için eksik karakterleri yeniden yaratmama ve sistem komutu için karakterleri oluşturmama izin veriyor.

Kuralların ne kadar esnek olduğuna bağlı olarak üç değişken yaptım. Varyasyon 2 ve 3'ün aslında İdeone üzerindeki kelimeleri çıkarmasından dolayı çözümlerin geçerli olduğunu varsayıyorum. Kimsenin okuyamayacağını düşündüğümden beri burada olan küçük hikayeyi kaldırdım, ama merak ediyorsanız düzenlemelerde okuyabilirsiniz!

oOo kodu (300)

QwerTaSdfGzxCqwertAsDfgZxCQwerTasDfgZxcQweRtaSDfgZxCqwertAsDFgZXcQWeRtaSdFGzxcQwERTasdfGzxc
QwErtAsdFgzxcqWeRtaSdFGzxcQweRtaSDfGZxCqWErTAsDFgZXCqWerTasDfgZxcQweRtaSdfGzxCQwErTAsDFgZXC
qWertAsDfgzxcQwERtASdFGzXcqWeRTasdFGzXcQWeRtAsDfgzxcQwERtASdFGzXCqWerTaSDfgzXcQWErTaSdFgZxc
QwertaSdFgzXcQWertASdFgZXCq

Kolay. (Satır beslemeleri isteğe bağlıdır ve kodu "daha okunaklı hale getirmek için burada") Kullanılan kod üreteci:

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

Daha az saçma bir kodlamada aynı kod:

EeeeEeEeeEeeEeeeeeEeEeeEeEEeeeEeeEeeEeeEeeEeeEEeeEeEeeeeeEeEEeEEeEEeEeeEeEEeeeEeEEEeeeeEeee
EeEeeEeeEeeeeeEeEeeEeEEeeeEeeEeeEEeEEeEeEEeEEeEEeEEEeEeeEeeEeeEeeEeeEeeEeeEeeEEeEeEEeEEeEEE
eEeeeEeEeeeeeEeEEeEEeEEeEeeEeEEeeeEEeEeEEeEeEeEeeeeeEeEEeEEeEEeEEeEeeEeEEeeeEeEEEeEeEeEeEee
EeeeeeEeEeeEeEEeeeEEeEeEEEe

ferNANDo, 179 + 10 = 189 bayt

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

Çevrimiçi deneyin!

EnterKullanılmış. Bana kalırsa doğru 0ve 1kod daha okunabilir hale getirmek için ama kullanamıyorum 0.

JS-Forth, 103 bayt

Dize yığında bir karakter dizisi olarak döndürülür.

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

Çevrimiçi deneyin - Yorumlu sürüm

Açıklama:

İlk önce izin verilen kelimelerin listesini buldum . Temel olarak, kullanabileceğim tek şey faydalı olacaktır:

• 12345 Sayısal sabitler
• << Sola kay
• >> Sağa kaydır
• s>f Yığını yüzdürmek için tek basma
• f>d Şamandıra yığınından çift pop
• fsqrt Float yığında karekök

Böylece sayısal sabitleri, bit-shift'i ve aşağıdakini kullanarak bir karekök hesaplayabilirim ( >>değiştirerek kaldırarak dropdeğiştirerek ):00

s>f fsqrt f>d >>

Neyse ki, oluşturmak için ihtiyaç duyduğum her sabit için karekök kullanmaktan daha kısa bir bit kayması buldum. Çoğunlukla, her bir sayı karesini basitçe ya da bunlardan herhangi biri bir rakam içeriyorsa, ikisinin daha büyük bir gücünü basarak aradım 6-0. Ardından, f>ddaha fazla olasılık bulmak için hassasiyet kaybı kullanabileceğimi farkettim . (Sayıya ekleyebilirim, ancak yine de aynı tamsayı karekök elde edebilirim.) Bir süre sonra sabitlerin bir kısmını ve hepsini bulmak için bit kaydırmayı kullanmaya başladım. >>Bit kaydırma ne kadar büyük olursa , "sihirli sayıya" o kadar fazla ekleyebilirim ve hala aynı sonucu elde edebilirim. Böylece gerekli sonuçları elde etmek için kullanabileceğim en küçük bit değişimlerini buldum. Bazen rakamlar bile kullanabilirdi <<, ihtimal kullanmak zorundaydı >>.

Yorumlanan kod ( \bir yorum başlatır):

\ 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'un kelimeleri <<veya yok >>. Onun yerine kullanamadım lshiftve rshiftkullandım .

Ondalık , 190 180 + 10 = 190 bayt

12055D12025D41D301212055D12010D41D301212055D12025D41D12003D41D30130112004D41D301212055D12024D41D30112003D41D301212055D12013D41D301212055D12040D41D301212045D12003D41D30112001D41D301

Çevrimiçi deneyin! Ondalık, ondalık sayılardan ve harflerden başka bir şey kullanan ezoterik bir dildir D. Ancak hemen hemen her komutun kullandığı için +10 cezaya ihtiyacım vardı 0.

Neyse ki, yazdırmak PASSWORD_01için gereken tüm komutların üzerinde numara olması gerekmez 6:

• 12...D - karakter itmek
• 2 - bir değer pop
• 41D - Üst iki yığın değerleri pop, çarpın ve sonucu itin
• 301 - DSİ'yi yazdır (varsayılan yığın dizini)

Yalnızca 1 ile 5 arasındaki rakamları kullanan karakter değerlerini tekrar tekrar basıp ardından bunları ekleyerek, içindeki her harf için karakter değerlerini yapabilirim PASSWORD_01.

Ungolfed ve yorumladı:

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

Boşluk , puan: 111 (101 bayt + 10 için 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]

Harfler S(boşluk), T(sekme) ve N(yeni satır) yalnızca vurgulama olarak eklenmiştir.
[..._some_action]sadece açıklama olarak eklendi.

Çevrimiçi deneyin (yalnızca ham alanlar, sekmeler ve yeni satırlarla).

Sahte kodda açıklama:

Bu çözüm, mevcut Whitespace cevabından daha kısa ( @ n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d golf, bu Whitespace ipucunu kullanarak, bunu golf olarak önerdiğimde ayrı bir cevap olarak göndermemi istedi) .

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

Bu sabit 80, oluşturduğum ve önceki bazı Boşluklarım cevabında kullandığım Java programında üretildi .

Stax , 91 + 10 bayt

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

Çevrimiçi deneyin!

]Singleton yapmak için kullanır .

açıklama

Her zamanki kullanmadan "P"nasıl üretildiğini ve nasıl "ASSW"eklendiğini görelim +.

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

Gerisi sadece aynı numarayı tekrarlıyor.

"a"EEE$"$"a$Re]R"a"ya [97]da yapmak [79]ya da yapmak için basamağı "O"değiştirir ve dizeye ekler.

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

"$""a"EEEd$"$""5"Re]Rkullanır "a"elde etmek için tekrar "9"ve atar "7", sonra da birleştiren "9"bir değişmez ile "5"oluşturulması [95]ya "_"ve dizeye ekler.

"$"1 !$R 1 değil mantıksal olarak bir sıfır alır ve onu dizeye ekler.

"$""1"Rfinali ekler "1"ve biz yapılır.

Örtük çıktı.

beyinbeyin , 400 + 10 ( +) = 410 bayt

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

Çevrimiçi deneyin!

MS-DOS .COM 8086 makine kodu (72 bayt)

Zaman değerlidir, bu yüzden derleyicilerle veya tercümanlarla dally dally yapmanın zamanı yok! İstediğiniz metin editörünüzü açıp aşağıdakini yazın ( \tTAB ile değiştirin ):

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

Bir hexdump olarak:

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$

Bir .COM dosyası olarak kaydedin ve günü kurtarmak için çalıştırın.

Kod , kayıtlar için belirli başlangıç ​​değerlerini varsayar , bu nedenle tüm DOS lezzetleri için çalışmayabilir. Sadece birisi tarafından ateşlenen edilme tehlikesiyle umut değil IBM aldığı.

Biraz daha anlaşılabilir gösterimi:

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 bayt

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

Çevrimiçi deneyin!

10 baytlık ceza, ,anahtarın kullanımına yöneliktir (bunun neden Shift+ ile gerçekleştirilemediğinden emin değilim <, ancak bu kural gibi görünüyor). Kaynak teknik olarak 40 karakter olmasına rağmen, üç ·karakter UTF-8 kodlamaları nedeniyle ek bir üç bayta katkıda bulunur.

05AB1E , 87 86 bayt

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

Çevrimiçi deneyin!

Belki de şimdiye kadarki en uzun 05AB1E kodu?

Maalesef, dil "Q"<"Q alma P'sini düşürme" gibi şeyleri desteklemiyor.

Ekstra anahtarım V.

-1 byte için @Kevin Cruijssen'e teşekkürler.

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 

Karşılaştırma için: "PASSWORD_01" yazmanın en kısa yolu 6 bayttır

Çevrimiçi deneyin!

Emacs, 26 bayt (muhtemelen + 10 = 36 veya - 2 = 24)

Bu cevapta ihtiyaç duyulan ekstra anahtar Esc. Bu, hala sağlam olan klavyenin yarısındadır, ancak bir nedenden ötürü soruda belirtilmemiştir, bu nedenle skor için bir ceza verebilir veya vermeyebilir. ( Escve AltEmacs'ta eşdeğerdir; Altaynı zamanda klavyenin bozulmamış yarısındadır, ancak soruda belirtilmemiştir, ancak dokunulmak yerine tutulması gerekir, bu yüzden fazladan anahtarım olarak kullanamıyorum. , çünkü, olduğundan daha kısa bir kodlamaya sahiptir Esc.)

Programın kendisi (virgüller, Emacs'ın girişini kabul etmek için kullandığı on-line formatındaki baytlar arasındaki sınırları sınırlandırır):

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

Bayt sayısını kanıtlamak için bunun ham bayt olarak kodlanması:

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

(Not: ayrıntıların bazıları Emacs'ın nasıl yapılandırıldığına bağlı olarak değişebilir; bu cevap, alıntı-radix'in 16'ya ayarlanmasını ve Emac'ın İngiliz İngilizcemde varsayılan olan yazım denetimi sözlüğünü kullanmasını gerektirir. Her ikisi de görünüyor. makul yapılandırma ayarları gibi, ancak Emacs kopyanız farklı şekilde yapılandırılmış olabilir, farklı bir sözlük hala 26 baytlık bir program verebilir, ancak istediğimiz düzeltmelerin kabul edilebilmesi için biraz yanlış yazımların kullanılması gerekebilir. kurşunsuz basılan anahtarlar.)

açıklama

Editör savaşları üzerinde herhangi bir etkiye sahip olması gerekip gerekmediğinden emin değilim, ancak Emacs en azından bu soru söz konusu olduğunda titremeye başladı. Emacs, bayt cinsinden ölçülen editör golfüne oldukça uygundur, çünkü çok sayıda tuşa basan ancak yalnızca tek bir bayt alan akorlara yoğun şekilde dayanır (bu nedenle bir Emacs programı genellikle eşdeğer Vim programından daha yavaş, ancak diskte daha kısadır). Ek olarak, en önemli Emacs komutlarının çoğu, klavyenin sol alt köşesinde, buna Ctrlbenzer bir soruya çok yakın olması için yazıyor.

"Mermi gelmeden önce tercüman kabuğunun / kaynak düzenleyicisinin açık olduğunu varsayabilirsiniz. Ne yazık ki klavyeye basılmadan önce hiçbir şey yazmamışsınızdır.", Bu yüzden Emacs ve şifreyi girmeniz gerekir. (Daha sonra dosyayı kaydetmemiz ve muhtemelen Emacs'tan çıkmamız gerekir, ancak bunun için baytlar diğer kişilerin cevaplarında sayılmaz, bu yüzden burada da saymıyorum. Tamamen sol tarafını kullanarak yapılabilir. klavye olsa da, Ctrl- X, Ctrl- S, Ctrl- X, Ctrl- C.)

Her seferinde bir komut (veya benzer komutları engelle) alarak:

• W, S: WSBelgeye girin .
• Esc, $: Yazım denetleyicisini çağırın. WSgerçek bir kelime değil, ancak pek çok benzer iki harfli kelime bulur.
• D: İmla kontrolü kullanarak, doğru WSiçin PS. (Yazım denetleyici Alt- $, burada olduğu gibi ( Escve AltEmacs ile eşdeğerdir) kullanılarak çağrıldığında , yalnızca bir sözcüğü denetler, bu yüzden bunu yaptıktan sonra devre dışı kalır.)
• A: ekleme A, verme PSA.
• Ctrl- T: Önceki iki karakteri değiştirerek PAS.
• S, R, W, D: Tür SRWD, veren PASSRWD.
• Esc, $, 5: Biz bizim yanlış yazılmış düzeltmek istiyorum, çünkü tekrar imla kontrolü çağırmak PASSRWDiçine PASSWORD. İlk denememizde istediğimiz kelimeyi tahmin edemediğimizi unutmayın PASSWRD, çünkü olduğu gibi , en yakın gerçek kelimeyi kabul etmenin anahtarı , basmayacağımız şeydir 0. Sonuç olarak, biraz daha aşırı yazım hatası PASSRWD, istediğimiz sözcüğü kabul edebileceğimiz 5. konuma itmek için kullanılır.
• Ctrl- Q, 5, f: karakter kodu U + 5f, yani karakterin yerleştirin _. Belge şimdi okuyor PASSWORD_(veya bir sonraki komutu yazmaya başladığımızda; o zamandan önce, başka bir onaltılık rakam yazmamız durumunda alt çizgi görünmüyor).
• Ctrl- X, r, Ctrl- Space, 1: Bazı tuhaf nedenle kayıt 1'de (dosyanın başlangıcına göre) geçerli imleç konumunu Mağaza, bu hane üzerine, 1-endeksli böylece (şimdiye kadar 9 karakterleri yazılı olan) 'dir 10.
• Ctrl- X, r, g, 1: belgeye kayıt 1 içeriğini kopyalayın. Şimdi okuyor PASSWORD_10.
• Ctrl- T: İmleçten önceki iki karakteri değiştir. Şimdi PASSWORD_01, sorduğumuz gibi.

Kullandığımız izin ediyorsanız Alt, muhtemelen tek bir byte "imla kontrolü çağırmak" komutunu kodlamak a4yerine olarak belirtmeyi daha 1b 24; iki kez görünür, böylece iki baytlık tasarruf sağlanır. (Modern terminallerin çoğu UTF-8 ile çakışmalardan kaçınmak 1b 24için Alt- olarak kodlama kullanır $, ancak a4zaman zaman bir yapılandırma seçeneği olarak da mevcut olan kodlamaya da rastlanır.)

Olası bayt tasarrufları muhtemelen düzeltmek için golfçü yazım hatalarını içerir. PSASWRDyazmak için daha kısa bir bayt olurdu, ancak ne yazık ki, yazım denetleyicisi bundan kaçabilecek durumda değil PASSWORD, PASSRWDşimdiye kadar bulduğum en iyi yaklaşım bu. Kayıt temelli yaklaşım kazanma yaklaşımı 10da gülünç derecede hantaldır, ancak Emacs'ta hiçbir yerde sayıları yaratmanın pek fazla yolu yoktur ve 0başka türlü elde etmek için acı verici bir karakterdir. İmleç haklı pozisyonunu sonuna kadar oluyor: (En azından orada inanılmaz yararlı tesadüfler çiftti 10bir içeriyorsa, 0gerektiğinde sağ ne zaman ve Emacs gereksiz kabul olması gbelgeye bir kayıt içeriğini eklemek için kayıt işlemini , daha sezgisel ek olaraki.)