DISINSERIRE LA BOMBA!


214

Sei stato assunto per le tue conoscenze tecniche come assistente di un agente segreto per assicurarti che il bravo ragazzo possa svolgere il suo lavoro e che il mondo possa essere salvato.

Questa è la tua ultima missione prima di ritirarti con un alto stipendio e la gratitudine di tutto il mondo. Ma prima che tu debba disarmare la Big Overly Massive BOMB di Evil Genius (sembra che il genio del male sia un asino intelligente a cui piacciono gli acronimi ricorsivi). Ad ogni modo tu e il tuo amico siete nel cuore della base segreta di Genius del Male, pronti a disarmare la BOMB che potrebbe spazzare via il continente. Nella tua missione precedente sei riuscito a ottenere il codice di disarmo che con tuo stupore è solo "PASSWORD_01". Colleghi la tua tastiera alla BOMBA ma quando sei pronto a partire, gli scagnozzi del Genius del Male entrano con una raffica di proiettili. Sfortunatamente uno di questi proiettili ha un impatto sulla tua tastiera. "Termina il lavoro mentre distraggo quelle cazzate!" dice il tuo amico e poi inizia a sparare con la sua pistola.

SPECIFICHE

  1. Scrivi un programma che emetta in qualsiasi modo desideri la stringa PASSWORD_01(maiuscola).
  2. Poiché la tua tastiera è stata colpita da un proiettile, puoi usare solo questi tasti:

    1 2 3 4 5

    Q W E R T

    A S D F G

    < > Z X C

    Ctrl Shift Tab Space

    Usando il Shifttasto, la tastiera ti consente di usare questi caratteri:

    ! " · $ %

  3. Non hai altro hardware oltre alla tastiera e allo schermo (ad esempio un mouse), né un file con la password scritta nel tuo computer.

  4. Non hai una connessione a Internet.

  5. Si può presumere di avere l'editor della shell / sorgente dell'interprete aperto prima dell'arrivo dei proiettili. Purtroppo non è stato scritto nulla al suo interno prima che la tastiera fosse premuta.

  6. Non hai una tastiera virtuale. In effetti la BOMB ha un rilevatore TOO_FUNNY che lo farà esplodere se provi a usare le scappatoie standard .

  7. Dato che il tuo amico ti sta aspettando che finisca presto per scappare dalla Base Segreta, dovrai scrivere il codice più piccolo possibile (quindi è e !).

Buona fortuna perché il conto alla rovescia è iniziato!

MODALITÀ AIUTO: Anche un KEY(solo un tasto desiderato dalla tastiera, ma non il tasto Maiusc + o qualsiasi altra combinazione) è miracolosamente sopravvissuto. Ad esempio: è possibile utilizzare =o 0oppure /... Questa chiave aggiuntiva non può contenere nessuna delle lettere PASSWORD_01(quindi non è possibile aggiungere Po O). Assegna un nome a quella chiave nella tua risposta. Hai una penalizzazione di 10 caratteri per l'uso di questa chiave indipendentemente da quante volte usi la chiave.


67
Posso cambiare il layout della tastiera in DVORAK?
n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳,

42
Riceviamo almeno il tasto Invio?
Οurous

72
Spazio bianco, ecco la tua grande possibilità!
german_guy,

43
Perché la password non poteva essere stata stewardesses?
codebreaker

24
Risposta scherzo: sono una spia, passo alla tastiera di backup nascosta nel mio orologio.
Nzall,

Risposte:



136

bash, vim e dc (343)

Sono seduto a un prompt di bash che è stato configurato da Evil Genius, e ovviamente ha VISUAL=viml'ambiente predefinito. L'uso del bind bash predefinito per edit-and-execute-command( C-x C-e) bash invoca $VISUALed eseguirà il contenuto del buffer su exit ( ZZ). kbdDigito la seguente sequenza (Nota: -mode sono comandi emessi in modalità normale e sequenze di controllo):

  1. C-xC-e
  2. agatto <<< 45 C-c4C-aaa

    Ora contiene il buffer vim cat<<<49a. Continua ...

  3. 45 C-c3C-aaa

  4. 54 C-c41C-aaa
  5. 55 C-c13C-aaa

    Ora contiene il buffer vim cat<<<49a48a95a68a. Continua ...

  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

    Ora contiene il buffer vim cat<<<49a48a95a68a82a79a87a83a83a65a80a>s

    Esci dalla modalità di inserimento, salva ed esci

  13. C-cZZ

    Il sfile ora contiene uno dcscript che genera la stringa desiderata nello stack, ora è necessario aggiungere comandi di stampa.

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

    Ripeti il ​​comando sopra 9 volte.

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

    Eseguire lo script DC:

  25. C-xC-eadc sC-cZZ

Produzione:

PASSWORD_01

Contenuto del sfile:

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

4
Stavo pensando di fare una vimsceneggiatura a causa del Ctrlpersonaggio; buona idea abbinarlo dc! Inoltre, ottima soluzione :)
nneonneo,

2
Quanto tempo hai impiegato per scrivere tutti quei tag <kbd> </kbd>?
solo il

15
@justhalf: l'ho scritto in vim con <Leader>krilegato in questo map <Leader>k i<kbd></kbd>^[F>amodo, quindi non era così brutto come sembra :-).
Thor,

18
Ora è evidente che l'agente Thor conosce a fondo il suo strumento. Meriti la pensione, signore!
solo il

67

Rubino, 57 + 10 ( *) = 67

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

Questa risposta utilizza *e %per costruire i valori ASCII dei caratteri mancanti (e 0 come Fixnum) e li inserisce in $*( ARGV). Questo array viene quindi utilizzato in combinazione con una stringa di formato per generare la password corretta, che viene stampata con $><<( $>è stdout).

Rubino, 62 + 10 ( .) = 72, nessuna interruzione di riga

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

Praticamente lo stesso principio della versione precedente, tranne per il fatto che qui l'array è costruito da un array vuoto literal ( %w%%). .È necessario un po 'di manipolazione per ottenere la precedenza desiderata dell'operatore.


13
"Questa è la tua ultima missione prima di ritirarti con un alto stipendio e la gratitudine di tutto il mondo." Congratulazioni, tutti ti ringraziamo :)
Timtech,

4
L'ultima prova che Perl è una delle più grandi ispirazioni di Ruby.
Pierre Arlaud,

11
Come hai fatto l'interruzione di linea?
Cefalopode,

4
@Arian Allo stesso modo in cui nneonneo esegue il suo codice Python dopo averlo digitato nel REPL ... Aggiungerò una versione senza interruzione di riga.
Ventero,

Il genio del male ha ruby ​​installato?
Mhmd,

36

Spazio bianco (148 + 10 = 158)

Enter la chiave deve essere utilizzata qui.

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

La spiegazione della mia notazione:

  • S, +, 0Sono gli spazi.
  • T, 1sono schede.
  • L è la nuova linea.
  • // inizia un commento.

Ogni riga è un comando nel linguaggio degli spazi bianchi.

dimostrazione


1
Ah amico ... Stavo solo lavorando su questo :(
Teun Pronk l'

1
Anch'io, ma ho rinunciato a questo sapendo che qualcuno sarebbe stato più veloce
german_guy l'

Pensavo che "L" non fosse disponibile?
500 - Errore interno del server

@ 500-InternalServerError: attualmente Lrappresenta il carattere di nuova riga. Controlla la demo per il codice reale. Quello che ho pubblicato è una versione leggibile.
n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳,

Ah, ho capito adesso.
500 - Errore interno del server

25

Python ( 2200395 + 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"""

Avevo bisogno del +personaggio (che costa +10), che può essere ottenuto dal tastierino numerico (o su determinati layout di tasti).

Sì, probabilmente la BOMB si è spenta mentre lo scrivevo.

L'approccio di base è quello di costruire set di caratteri sempre più grandi usando exece "%c"%(number). Ci sono quattro execnidificati l'uno dentro l'altro. A poco a poco, il mio set di cifre progredisce da

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

in modo che nell'iterazione finale sia possibile esprimere qualsiasi carattere (in modo che la versione più interna possa effettivamente eseguire qualsiasi programma).

Circa il 50% del programma è composto da virgolette ( "%c"%34è una doppia virgoletta), poiché la natura nidificata delle execaffermazioni richiede caratteri di citazione "in fuga" in modo aggressivo.


Se si utilizza il "+" dal tastierino numerico, si è indipendenti dalla lingua della tastiera.
Celtschk,

@celtschk: buon punto! Lo modificherò in.
nneonneo,

1
Invece di costruire set di cifre con exec annidate, non potresti ottenere numeri usando l'aritmetica? Ex. exec '%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c'%(112,114,51+54,55+55,1+115,32,4+35,25+55,11+54,31+52,31+52,32+55,24+55,31+51,13+55,41+54,3+45,4+45,4+35)
Kevin,

2
Perché non puoi ottenere entrambe le parentesi. (L'ho preso in considerazione!)
nneonneo,

Inoltre, Python non ha molti operatori che si legano più fortemente di%. ** è uno, ma tende ad essere abbastanza inutile per costruire la maggior parte dei termini.
nneonneo,

25

Insonnia 39 35 31 29

Questa lingua viene fuori quando stavo cercando una lingua che codifica le sue istruzioni con un singolo carattere ASCII. La lingua in realtà funziona con il codice ASCII decimale del personaggio, quindi è ancora abbastanza flessibile con la metà della tastiera distrutta.

Rilascialo ulteriormente a 29 caratteri, che è possibile dopo aver ridotto l'utilizzo della memoria e aumentato lo spazio di ricerca:

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

Ho deciso di eseguire il mio programma ottimizzato sul set completo di caratteri consentiti e di ridurre la soluzione a 31 caratteri:

FdFGt dtreeC>tt FFdx<Fdtr ztq4s

Ho usato un programma per cercare questa soluzione. È una delle tante soluzioni restituite dal mio programma, tutte con le stesse dimensioni.

Fddx>"eCeezdC>CefCdddzCzzfCqred>r4s

Vecchia versione costruita a mano. Ricordo di essere rimasto sveglio fino al mattino per farlo.

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

Ecco l' interprete Insomnia per i test.


3
+1 per la partita "Stare sveglio fino al mattino" con la scelta del linguaggio di programmazione.
solo il

20

Vim + PHP su alcuni gestori di finestre

65 tasti in 44 colpi, con una penalità di 10 punti per l'utilizzo =.

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

Un guasto:

  • Alt+Tabsembra funzionare come Esccon Vim, o forse con questo emulatore di terminale. Grazie per avermi insegnato qualcosa di nuovo!
  • aEACE<Alt+Tab>: Entra in modalità accodamento e inserisci “EACE”. Uscita.
  • z=5<Alt+Tab>: Esegue la correzione ortografica. Selezionare 5, "PACE". Uscita. ( Escsembra funzionare come Enterqui!)
  • $xxxxaASSWRD<Alt+Tab>: Vai alla fine della riga. Elimina 4 caratteri e aggiungi ASSWRD, risultando in PASSWRD. Torna alla modalità normale. (No, 4xnon funzionerà.)
  • z=1<Alt+Tab>: PASSWORDÈ probabilmente sarà la prima correzione per questo. Selezionalo
  • $a$aA<Alt+Tab>: Vai alla fine della riga e aggiungi a $aA. Torna alla modalità normale.
  • ==: Formatta bene questa linea di PHP, cambiando camelCase $aAin $a_a. Questo sposta anche il cursore all'inizio della riga.
  • wxx: Vai avanti di una parola; il cursore è ora prima $. Elimina due caratteri - il $e il a- per creare PASSWORD_a.
  • $r1: Vai alla fine della riga e sostituisci il carattere corrente (cioè a) con 1, risultante PASSWORD_1.
  • ^X: Decrementa l'intero sotto il cursore, risultando in PASSWORD_0.
  • a1: Infine, aggiungi 1, per PASSWORD_01!

Non riesco a replicare il ==comando, attiva o disattiva la modalità di rientro di grandi dimensioni nella mia configurazione vi (debian 7, v7.3.547)
Cengiz Can

11

Python 2, 75889 byte

Nessun personaggio extra!

Sfortunatamente, il codice è super lungo. Quindi, invece, ecco il codice per generare il programma:

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

Provalo online

(per eseguire il codice, cambia l'esterno printin un exec. Oppure, genera il programma, quindi incolla ed esegui. O copia dal file di traccia collegato di seguito.)

Spiegazione:

L'obiettivo è quello di eseguire:

print"PASSWORD_01"

Per evitare di usare i ()+caratteri, dobbiamo usare più operazioni di formato stringa concatenate. Ciò significa che ogni passaggio aggiunto raddoppia efficacemente il numero di %caratteri necessari per ogni passaggio precedente:

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

Questo non è abbastanza, tuttavia, poiché alcuni dei numeri richiesti non possono essere creati e nemmeno noi possiamo creare print. Quindi aggiungiamo un livello di astrazione con execfor printing e un livello per i punti di codice ASCII che non possiamo creare con cui formattare. Di seguito è essenzialmente la mia risposta, ma con ciascuna stringa %ridotta a una singola (si noti che %s%s%s%s%snon è una rappresentazione accurata, non riuscendo a rendere conto dei letterali %richiesti prima di ciascuno):

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

Il primo passo: più esterno 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, utilizzato per 0inPASSWORD_01
  2. 2531>>5: 79, usato per la creazione di inner execO
  3. 321>>2: 80, usato per la creazione di inner execP
  4. 1521>>4: 95, usato per la creazione di inner exec_
  5. 211>>1: 105, usato per la creazione di inner execi
  6. 221>>1: 110, usato per la creazione di inner execn

Secondo passo: preparare interno exec

Dopo quanto sopra, l'interno execè qualcosa del genere:

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

Solo che non lo avresti capito. Con le semplificazioni, otterresti questo:

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

Il letterale %deve essere incluso. Quindi, fondamentalmente, ho dovuto aggiungerne un po 'prima di ognuno %sper finire con il valore letterale %rimasto dopo tutta la formattazione. 2**11di loro. Cinque volte.

Le restanti execoperazioni sul formato delle stringhe esterne sono %112%34%34%34%34. Il 112è per pe gli altri sono virgolette. Dopo averli applicati, il risultato è qualcosa del genere:

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

Ma in realtà ha un sacco di più %. È questo:

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

Il passaggio finale è semplicemente quello di eseguire, dopo di che si ottiene l'output necessario.


Codice completo qui: http://pastebin.com/rSFs6DiH


7
Degno di nota! Hai digitato tutto a mano prima che la BOMB esplodesse? Senza fare errori (nessuna chiave backspace)? Lei, signore o signora, meriti la sua pensione. ; D
DLosc,

10

bash + vim (56)

Prendendo in prestito il Ctrl-XCtrl-Etrucco bash dalla soluzione di Thor, ecco come lo farei in bash + vim:

C-XC-E avvia l'editor predefinito (di solito vim)

a avvia la modalità di inserimento

.space ASSW

C-Vx4f inserti O

RD

C-Vx5f inserti _

1

C-3è equivalente a escape(non solo in vim, ma ovunque in un terminale)

C-Xsottrae 1 1dall'i appena digitato

a inserire nuovamente la modalità

1 C-3

il contenuto del buffer è ora . ASSWORD_01

<< linea non indentata (no-op, poiché la linea non è rientrata) e sposta il cursore sulla prima colonna

a

C-X inizia il completamento delle parole

C-V completo di comando ex

C-V Altre 9 volte seleziona la voce Print

C-3 torna alla modalità normale

XXXxx eliminazioni rint 

< < torna alla colonna 1

sElimina ., avvia la modalità di inserimento

e c C-X C-Vancora una volta completato il comando, voce echogià selezionata a causa ecdell'i appena digitato

space C-3 contenuto del buffer ora echo PASSWORD_01

Z Z salva buffer, chiudi vim, bash esegue il contenuto del file, ad es echo PASSWORD_01

A proposito: C-3ha molti fratelli utili: C-Jis Enter, C-Iis Tab, C-His Backspace, C-2is C-@(cioè un byte null). E per gli utenti di emacs è bello sapere che Escapeseguito da un'altra chiave equivale a Alt+ quella chiave. Quindi, anche senza Escapee Altpuoi ancora digitare Meta-x in questo modo:C-3x


9

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

( ^tasto usato, 3 modi)

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

  • Valido se eseguito come comando di sistema si qualifica come "output".

exec"QQZSqeasswsrdcqw"^"422<Q5    <  <AF"         # exec "echo PASSWORD_01"
  • Valido se mi è permesso usare comandi esterni / OS. (Corri qui)

exec"EQAXqwQqQZQxqeasswsrdcqwxqq"^q!5434QZ4S534$S5    <  <AF$SS! 
                  # exec "perl -e\"die\\\"PASSWORD_01\\\"\""
  • Valido se posso eseguire Perl tramite il sistema. (Esegui qui) <- questo utilizza printinvece didie

Gli script usano l'operatore XOR stringa bit per bit di Perl ^, che esegue un XOR sui bit di carattere delle due stringhe. Questo mi consente di ricreare i caratteri mancanti per PASSWORD_01 e creare i caratteri per il comando di sistema.

Ho fatto le tre varianti a seconda di quanto siano delicate le regole. Presumo che, poiché le varianti 2 e 3 producono effettivamente le parole su Ideone, le soluzioni sono valide. Ho rimosso la piccola storia che avevo qui da quando pensavo che nessuno l'avrebbe letta, ma puoi leggerlo nelle modifiche se sei curioso!


4

Codice oOo (300)

QwerTaSdfGzxCqwertAsDfgZxCQwerTasDfgZxcQweRtaSDfgZxCqwertAsDFgZXcQWeRtaSdFGzxcQwERTasdfGzxc
QwErtAsdFgzxcqWeRtaSdFGzxcQweRtaSDfGZxCqWErTAsDFgZXCqWerTasDfgZxcQweRtaSdfGzxCQwErTAsDFgZXC
qWertAsDfgzxcQwERtASdFGzXcqWeRTasdFGzXcQWeRtAsDfgzxcQwERtASdFGzXCqWerTaSDfgzXcQWErTaSdFgZxc
QwertaSdFgzXcQWertASdFgZXCq

Facile. (I feed di linea sono opzionali e proprio qui per rendere il codice "più leggibile") Generatore di codice utilizzato:

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

Lo stesso codice in una codifica meno sciocca:

EeeeEeEeeEeeEeeeeeEeEeeEeEEeeeEeeEeeEeeEeeEeeEEeeEeEeeeeeEeEEeEEeEEeEeeEeEEeeeEeEEEeeeeEeee
EeEeeEeeEeeeeeEeEeeEeEEeeeEeeEeeEEeEEeEeEEeEEeEEeEEEeEeeEeeEeeEeeEeeEeeEeeEeeEEeEeEEeEEeEEE
eEeeeEeEeeeeeEeEEeEEeEEeEeeEeEEeeeEEeEeEEeEeEeEeeeeeEeEEeEEeEEeEEeEeeEeEEeeeEeEEEeEeEeEeEee
EeeeeeEeEeeEeEEeeeEEeEeEEEe


3

ferNANDo, 179 + 10 = 189 byte

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

Provalo online!

EnterUsato. Userei 0e 1per rendere il codice più leggibile ma non posso usarlo 0.


Penso che sia permesso entrare.
Conor O'Brien,

2
OP non ha detto che Enter era permesso.
acrolith,

3

JS-Forth, 103 byte

La stringa verrà restituita nello stack come una matrice di caratteri.

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

Provalo online - Versione commentata


Spiegazione:

Ho trovato prima l'elenco delle parole consentite . In sostanza, le uniche cose che potrei usare che sarebbero utili sono:

  • 12345 Costanti numeriche
  • << Sposta a sinistra
  • >> Sposta a destra
  • s>f Spingere il singolo nello stack mobile
  • f>d Doppio pop dallo stack float
  • fsqrt Radice quadrata su pila galleggiante

Quindi potrei usare costanti numeriche, bit-shift e calcolare una radice quadrata usando il seguente ( >>sostituisce drop, spostando 0per rimuovere il 0):

s>f fsqrt f>d >>

Fortunatamente, ho trovato possibili spostamenti di bit per ogni costante che avevo bisogno di creare che fossero più brevi rispetto all'uso di radici quadrate. Per la maggior parte, ho cercato semplicemente stampando ogni numero al quadrato, o una potenza maggiore di due se qualcuno conteneva una cifra 6-0. Poi, ho capito che avrei potuto usare la perdita di precisione f>dper trovare più possibilità. (Potrei aggiungere al numero, ma ottenere comunque la stessa radice quadrata intera.) Poco dopo, ho iniziato a usare lo spostamento dei bit per trovare alcune, e poi tutte, le costanti. Maggiore è il >>bit-shift, più potrei aggiungere al "numero magico" e ottenere comunque lo stesso risultato. Quindi ho trovato i bit-shift più piccoli che potevo usare per ottenere i risultati necessari. I numeri pari a volte potevano usare <<, le probabilità dovevano usare >>.

Codice commentato ( \inizia un commento):

\ 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 non ha le parole <<o >>. Invece ha lshifte rshift, che non ho potuto usare .


3

Decimale , 190 180 + 10 = 190 byte

12055D12025D41D301212055D12010D41D301212055D12025D41D12003D41D30130112004D41D301212055D12024D41D30112003D41D301212055D12013D41D301212055D12040D41D301212045D12003D41D30112001D41D301

Provalo online! Il decimale è un linguaggio esoterico che non usa altro che decimali e lettera D. Tuttavia, avevo bisogno della penalità +10 perché quasi tutti i comandi utilizzano 0.

Fortunatamente, tutti i comandi necessari per stampare PASSWORD_01non richiedono numeri oltre 6:

  • 12...D - spingere un personaggio
  • 2 - pop un valore
  • 41D - pop i primi due valori dello stack, moltiplicare e premere il risultato
  • 301 - stampa DSI (indice stack predefinito)

Premendo ripetutamente i valori dei caratteri che usano solo le cifre da 1 a 5, quindi aggiungendoli, posso creare i valori dei caratteri per ogni lettera PASSWORD_01.

Ungolf e commentato:

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

3

Spazio bianco , punteggio: 111 (101 byte + 10 per 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]

Lettere S(spazio), T(scheda) e N(nuova riga) aggiunti solo come evidenziazione.
[..._some_action]aggiunto solo come spiegazione.

Provalo online (solo con spazi non elaborati, schede e nuove righe).

Spiegazione in pseudo-codice:

Questa soluzione è più breve della risposta esistente di Whitespace ( @ n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ mi ha chiesto di pubblicarla come risposta separata quando l'ho suggerita come golf) utilizzando questo mio suggerimento di 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

La costante 80è stata generata con questo programma Java , che ho creato e utilizzato per alcune mie precedenti risposte agli spazi bianchi.


2

Stax , 91 + 10 byte

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

Provalo online!

Utilizza ]per creare singleton.

Spiegazione

Vediamo come "P"viene generato e come "ASSW"viene aggiunto senza utilizzare il solito +.

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

Il resto sta solo ripetendo lo stesso trucco.

"a"EEE$"$"a$Re]Rscambia le cifre di "a"o [97]per creare [79]o "O"e le aggiunge alla stringa.

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

"$""a"EEEd$"$""5"Re]Rusa di "a"nuovo per ottenere "9"e scarta il "7", quindi combina il "9"con un letterale "5"per formare [95]o "_"e lo aggiunge alla stringa.

"$"1 !$R ottiene uno zero logico non di 1 e lo aggiunge alla stringa.

"$""1"Raccoda la finale "1"e abbiamo finito.

Uscita implicita.


1
O_O ... questo è intelligente.
ricorsivo il

Grazie per il tuo apprezzamento. Credo che possa essere abbreviato (forse scegliendo una chiave diversa?) Però.
Weijun Zhou,

2

brainfuck , 400 + 10 ( +) = 410 byte

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

Provalo online!


2

MS-DOS .COM 8086 codice macchina (72 byte)

Il tempo è prezioso, quindi non c'è tempo per dilatarsi con compilatori o interpreti! Apri semplicemente il tuo editor di testo preferito e digita quanto segue (sostituisci \tcon TAB):

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

Come un 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$

Salva come file .COM ed eseguilo per salvare il giorno.

Il codice presuppone determinati valori iniziali per i registri , quindi potrebbe non funzionare per tutti i tipi di DOS. Spero solo che qualcuno abbia rischiato di essere licenziato non acquistando IBM.

Rappresentazione leggermente più comprensibile:

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

1

Befunge-98, 43 +10 = 53 byte

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

Provalo online!

La penalità di 10 byte è per l'uso della ,chiave (non so perché questo non possa essere realizzato con Shift+ <, ma questa sembra essere la regola). E sebbene la sorgente sia tecnicamente di 40 caratteri, i tre ·caratteri contribuiscono con altri tre byte a causa della loro codifica UTF-8.


1

05AB1E , 87 86 byte

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

Provalo online!

Forse il codice 05AB1E più lungo di sempre?

Sfortunatamente il linguaggio non supporta cose come "Q"<"decrementa Q per ottenere P"

La mia chiave in più è la V.

Grazie a @Kevin Cruijssen per -1 byte.

Codice:

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 

Per confronto: il modo più breve per stampare "PASSWORD_01" è lungo 6 byte

Provalo online!


" Forse il codice 05AB1E più lungo di sempre? " No, questo mio è quasi 6 volte più grande . ; p Bella risposta a prescindere. È difficile usare solo una certa quantità di caratteri ASCII consentiti. Quindi molti builtin convenienti non sono ammessi per questa sfida. :(
Kevin Cruijssen,

1
-1 byte usando TRinvece di 1<1per la 01parte dell'output.
Kevin Cruijssen,

1

Emacs, 26 byte (possibilmente + 10 = 36 o - 2 = 24)

La chiave aggiuntiva necessaria in questa risposta è Esc. Questo è sulla metà della tastiera che è ancora intatto, ma non è menzionato nella domanda per qualche motivo, quindi potrebbe o non dare una penalità al punteggio. ( Esce Altsono equivalenti in Emacs; Altè anche sulla metà intatta della tastiera, ma non è menzionato nella domanda, ma deve essere trattenuto anziché toccato, quindi non posso usarlo come chiave aggiuntiva. Risparmia due byte , tuttavia, perché ha una codifica più breve di quanto Escnon lo sia.)

Il programma stesso (le virgole delimitano i confini tra i byte nel formato on-the-wire che Emacs utilizza per accettare il suo input):

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

Codifica di questo come byte non elaborati, per dimostrare il conteggio dei byte:

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

(Nota: alcuni dettagli possono variare in base alla configurazione di Emacs; questa risposta richiede che quoted-char-radix sia impostato su 16 e che Emacs utilizzi il dizionario di controllo ortografico predefinito sul mio sistema inglese britannico. Entrambi sembrano come impostazioni di configurazione ragionevoli, ma è possibile che la tua copia di Emacs sia configurata in modo diverso. Un dizionario diverso probabilmente darebbe comunque un programma a 26 byte, ma potrebbe essere necessario utilizzare errori di ortografia leggermente diversi in modo che le correzioni che desideriamo possano essere accettate da chiavi senza proiettili.)

Spiegazione

Non sono sicuro che dovrebbe avere qualche influenza sulle guerre degli editor, ma Emacs sembra battere Vim almeno nel caso di questa domanda. Emacs è piuttosto adatto all'editor del golf misurato in byte, perché si basa fortemente su accordi che occupano più pressioni di tasti ma solo un singolo byte (quindi un programma Emacs è spesso più lento da digitare rispetto al programma Vim equivalente, ma più corto su disco). Inoltre, la maggior parte dei comandi Emacs più importanti si trova nell'angolo in basso a sinistra della tastiera, per essere vicino Ctrl, molto utile con una domanda come questa.

"Puoi presumere di aver aperto l'interprete shell / editor di sorgenti prima che arrivassero i proiettili. Purtroppo non hai scritto nulla prima che la tastiera fosse premuta.", Quindi presumo che abbiamo un file vuoto aperto in Emacs e è necessario digitare la password al suo interno. (Dovremmo salvare il file in seguito, e probabilmente uscire da Emacs, ma i byte per questo non vengono conteggiati nelle risposte degli altri, quindi non li conto neanche qui. È totalmente fattibile usando il lato sinistro del tastiera, tuttavia, Ctrl- X, Ctrl- S, Ctrl- X, Ctrl- C.)

Prendendo un comando (o un blocco di comandi simili) alla volta:

  • W, S: Entra WSnel documento.
  • Esc, $: Invoca il controllo ortografico. WSnon è una parola vera, ma trova molte parole simili di due lettere.
  • D: Utilizzando il correttore ortografico, corretto WSa PS. (Quando il controllo ortografico viene invocato usando Alt- $, come è successo qui ( Esce Altsono equivalenti a Emacs), controlla solo una parola, quindi si disattiva dopo averlo fatto.)
  • A: inserisci A, dando PSA.
  • Ctrl- T: scambia i due personaggi precedenti, dando PAS.
  • S, R, W, D: Tipo SRWD, dare PASSRWD.
  • Esc, $, 5: Invochiamo ancora una volta il correttore ortografico, perché vogliamo correggere la nostra errano PASSRWDin PASSWORD. Nota che non possiamo indovinare la parola che desideriamo al nostro primo tentativo, come farebbe PASSWRD, perché la chiave per accettare la parola reale più vicina è quella 0che non possiamo premere. Di conseguenza, l'ortografia leggermente più estrema PASSRWDviene utilizzata per spingere la parola che vogliamo in posizione 5, dove possiamo accettarla.
  • Ctrl- Q, 5, f: inserire il carattere con il codice di carattere U + 5f, vale a dire _. Il documento ora legge PASSWORD_(o lo farà quando inizieremo a digitare il comando successivo; prima di allora, il carattere di sottolineatura non appare nel caso in cui digitiamo un'altra cifra esadecimale).
  • Ctrl- X, r, Ctrl- Space, 1: Conservare la posizione corrente del cursore (relativo all'inizio del file) nel registro 1. Per qualche strana ragione, questo è 1-indicizzato, quindi (dopo aver scritto 9 caratteri finora) il cursore si trova nella posizione 10.
  • Ctrl- X, r, g, 1: copiare il contenuto del registro 1 nel documento. Ora legge PASSWORD_10.
  • Ctrl- T: scambia i due caratteri prima del cursore. Ora abbiamo PASSWORD_01, come fa la domanda.

Se ci è permesso di usare Alt, possiamo probabilmente codificare il comando "invoke spellchecker" come singolo byte a4anziché scriverlo come 1b 24; appare due volte, quindi questo porta a due byte di risparmi. (La maggior parte dei terminali moderni usa 1b 24la codifica per Alt- $per evitare scontri con UTF-8, ma la a4codifica si incontra anche di volta in volta, a volte disponibile come opzione di configurazione.)

I possibili risparmi in byte implicano probabilmente errori di ortografia da golf. PSASWRDsarebbe un byte più breve da digitare, ma sfortunatamente, il controllo ortografico non sembra in grado di evitarlo PASSWORD, quindi PASSRWDè l'approccio migliore che ho trovato finora. L'approccio basato sui registri per ottenere 10è anche ridicolmente ingombrante, ma non ci sono molti modi per creare numeri dal nulla in Emacs, ed 0è un personaggio doloroso da prendere altrimenti. (Almeno ci sono state un paio di coincidenze incredibilmente utili: il cursore sta per finire in posizione 10, che contiene un 0, proprio quando necessario; e il fatto che Emacs accetta l' goperazione di registro ridondante per inserire il contenuto di un registro nel documento , oltre a quello più intuitivoi.)

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.