Você foi contratado por seu conhecimento técnico como ajudante de um agente secreto para garantir que o mocinho possa fazer seu trabalho e o mundo possa ser salvo.

Esta é sua última missão antes de se aposentar com um salário alto e a gratidão de todo o mundo. Mas antes que você tenha que desarmar a grande bomba excessivamente maciça do Evil Genius (parece que o gênio do mal é um espertinho que gosta de siglas recursivas). De qualquer forma, você e seu amigo estão no âmago da base secreta do Evil Genius, prontos para desarmar a BOMBA que poderia destruir o continente. Na sua missão anterior, você conseguiu obter o código de desarmamento que, para sua surpresa, é apenas "PASSWORD_01". Você conecta o teclado à BOMB, mas quando está pronto para partir, os capangas do Evil Genius entram com uma enxurrada de balas. Infelizmente, um desses marcadores afeta o teclado. "Termine o trabalho enquanto eu distraio esses idiotas!" diz seu amigo e então começa a disparar sua arma.

ESPECIFICAÇÕES

1. Escreva um programa que produza da maneira que desejar a sequência PASSWORD_01(maiúscula).

2. Como seu teclado foi atingido por um marcador, você só pode usar estas teclas:

   1 2 3 4 5

   Q W E R T

   A S D F G

   < > Z X C

   Ctrl Shift Tab Space

   Usando a Shifttecla, seu teclado permite que você use estes caracteres:

   ! " · $ %

3. Você não possui outro hardware além do teclado e da tela (um mouse por exemplo), nem um arquivo com a senha gravada no seu computador.

4. Você não tem uma conexão com a Internet.

5. Você pode supor que o editor de shell / fonte do intérprete foi aberto antes da entrada dos marcadores. Infelizmente, você não escreveu nada antes de pressionar o teclado.

6. Você não tem um teclado virtual. De fato, o BOMB possui um detector TOO_FUNNY que o fará explodir se você tentar usar as brechas padrão .

7. Como seu amigo está esperando que você termine em breve para escapar da Base Secreta, você terá que escrever o menor código possível (por isso é código-fonte restrito e código-golfe !).

Boa sorte, porque a contagem regressiva já começou!

MODO DE AJUDA: Também uma KEY(apenas uma tecla que você deseja do teclado, mas não a tecla Shift + ou qualquer outra combinação) também sobreviveu milagrosamente. Por exemplo: Você pode usar =, ou 0ou /... Essa chave extra não pode conter nenhuma das letras PASSWORD_01(portanto, você não pode adicionar Pou O). Nomeie essa chave na sua resposta. Você tem uma penalização de 10 caracteres pelo uso dessa chave, independentemente de quantas vezes você usa a chave.

CJam - 24 + 10 ( () = 34

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

Nenhuma chave adicional - 39

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

Experimente em http://cjam.aditsu.net/

bash, vim e dc (343)

Estou sentado em um prompt do bash que foi configurado pelo Evil Genius e, é claro, ele VISUAL=vimno ambiente padrão. O uso da ligação bash padrão para edit-and-execute-command( C-x C-e) bash chama $VISUALe executará seu conteúdo de buffer em exit ( ZZ). Digite a seguinte sequência (Nota: kbd-mode são comandos emitidos no modo normal e nas seqüências de controle):

1. C-xC-e

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

   Agora o buffer do vim contém cat<<<49a. Continuando ...

3. 45 C-c3C-aaa

4. 54 C-c41C-aaa

5. 55 C-c13C-aaa

   Agora o buffer do vim contém cat<<<49a48a95a68a. Continuando ...

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

    Agora o buffer vim contém cat<<<49a48a95a68a82a79a87a83a83a65a80a>s

    Saia do modo de inserção, salve e saia

13. C-cZZ

    O sarquivo agora contém um dcscript que gera a string desejada na pilha, agora precisamos adicionar comandos de impressão.

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

    Repita o comando acima 9 vezes.

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

    Execute o script dc:

25. C-xC-eadc sC-cZZ

Resultado:

PASSWORD_01

Conteúdo do sarquivo:

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

Esta resposta usa *e %para criar os valores ASCII dos caracteres ausentes (e 0 como Fixnum) e os empurra para $*( ARGV). Essa matriz é usada em combinação com uma string de formato para gerar a senha correta, impressa com $><<( $>é stdout).

Ruby, 62 + 10 ( .) = 72, sem quebra de linha

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

Aproximadamente o mesmo princípio da versão acima, exceto que aqui a matriz é criada a partir de uma matriz vazia literal ( %w%%). .É necessário um pouco de brincadeira para obter a precedência de operador desejada.

Espaço em branco (148 + 10 = 158)

Enter chave precisa ser usada aqui.

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

A explicação da minha notação:

• S, +, 0São espaços.
• T, 1são guias.
• L é uma nova linha.
• // inicia o comentário.

Cada linha é um comando no idioma de espaço em branco.

Demo

Python ( 2200 395 + 10)

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

Eu precisava do +personagem (custando +10), que pode ser obtido no teclado numérico (ou em determinados layouts de teclas).

Sim, a bomba provavelmente disparou enquanto eu estava digitando isso.

A abordagem básica é construir conjuntos de caracteres cada vez maiores usando exece "%c"%(number). Existem quatro execs aninhados um dentro do outro. Gradualmente, meu conjunto de dígitos avança de

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

para que na iteração final seja possível expressar qualquer caractere (para que a versão mais interna possa realmente executar qualquer programa).

Cerca de 50% do programa são apenas caracteres de aspas ( "%c"%34é uma aspas dupla), porque a natureza aninhada das execinstruções exige caracteres de aspas "escapantes" agressivamente.

Insônia 39 35 31 29

Esse idioma aparece quando eu estava procurando um idioma que codifique suas instruções com um único caractere ASCII. O idioma realmente opera no código ASCII decimal do caractere, por isso ainda é bastante flexível com metade do teclado destruído.

Desça até 29 caracteres, o que é possível após reduzir o uso de memória e aumentar o espaço de pesquisa:

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

Decidi executar meu programa aprimorado no conjunto completo de caracteres permitidos e reduzir a solução para 31 caracteres:

FdFGt dtreeC>tt FFdx<Fdtr ztq4s

Eu usei um programa para procurar esta solução. É uma entre muitas soluções retornadas pelo meu programa, todas com o mesmo tamanho.

Fddx>"eCeezdC>CefCdddzCzzfCqred>r4s

Versão antiga construída à mão. Lembro-me de ficar acordado até de manhã para fazer isso.

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

Aqui está o intérprete Insomnia para teste.

Vim + PHP em alguns gerenciadores de janelas

65 teclas em 44 toques, com uma penalidade de 10 pontos pelo uso =.

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

Um colapso:

• Alt+Tabparece funcionar como Esccom Vim, ou talvez com este emulador de terminal. Obrigado por me ensinar algo novo!
• aEACE<Alt+Tab>: Entre no modo de acréscimo e insira “EACE”. Saída.
• z=5<Alt+Tab>: Execute a correção ortográfica. Selecione 5, "PAZ". Saída. ( Escparece funcionar como Enteraqui!)
• $xxxxaASSWRD<Alt+Tab>: Vá para o final da linha. Exclua 4 caracteres e adicione ASSWRD, resultando em PASSWRD. Voltar ao modo normal. (Não, 4xnão vai funcionar.)
• z=1<Alt+Tab>: PASSWORDÉ provavelmente vai ser a primeira correção para isso. Selecione.
• $a$aA<Alt+Tab>: Vá para o final da linha e adicione a $aA. Voltar ao modo normal.
• ==: Formate bem esta linha do PHP, alterando o camelCase $aApara $a_a. Isso também move o cursor de volta ao início da linha.
• wxx: Avance uma palavra; o cursor está agora antes $. Exclua dois caracteres - o $e o a- para criar PASSWORD_a.
• $r1: Vá para o final da linha e substitua o caractere atual (ou seja a) por 1resultando em PASSWORD_1.
• ^X: Decrementa o número inteiro sob o cursor, resultando em PASSWORD_0.
• a1: Finalmente, acrescente 1, para PASSWORD_01!

Python 2, 75889 bytes

Nenhum personagem extra!

Infelizmente, o código é super longo. Então, aqui está o código para gerar o programa:

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

Experimente online

(para executar o código, altere o externo printpara um exec. Ou gere o programa, cole e execute. Ou copie do pastebin vinculado abaixo.)

Explicação:

O objetivo é executar:

print"PASSWORD_01"

Para evitar o uso de ()+caracteres, precisamos usar várias operações de formato de cadeia encadeadas. Isso significa que cada etapa adicionada efetivamente dobra o número de %caracteres necessários para cada etapa anterior:

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

Porém, isso não é suficiente, porque alguns dos números necessários não podem ser criados e nem podemos criar print. Portanto, adicionamos um nível de abstração com execfor printing e um nível para os pontos de código ASCII que não podemos criar para formatar. A seguir, é essencialmente minha resposta, mas com cada cadeia de caracteres %reduzida a uma única (observe que %s%s%s%s%snão é uma representação precisa, falhando em levar em conta o literal %necessário antes de cada uma):

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

O primeiro passo: ultraperiférico 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, Utilizado para a 0emPASSWORD_01
2. 2531>>5: 79, usado pelo exec interno para criarO
3. 321>>2: 80, usado pelo exec interno para criarP
4. 1521>>4: 95, usado pelo exec interno para criar_
5. 211>>1: 105, usado pelo exec interno para criari
6. 221>>1: 110, usado pelo exec interno para criarn

Segundo passo: Prepare o interior exec

Após o exposto, o interior execé mais ou menos assim:

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

Só que você não entenderia isso. Ainda com as simplificações, você obteria o seguinte:

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

Os literais %precisam ser incluídos. Então, basicamente, eu tive que adicionar um monte deles antes de cada um %spara terminar com os literais %restantes após toda a formatação. 2**11deles. Vezes cinco.

O restante das execoperações de formato de cadeia externa são %112%34%34%34%34. O 112é para pe os outros são aspas. Depois de aplicá-las, o resultado é algo como isto:

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

Mas, na realidade, tem muito mais %. É isso:

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

O passo final é simplesmente executar isso, após o qual você obtém a saída necessária.

Código completo aqui: http://pastebin.com/rSFs6DiH

bash + vim (56)

Tomando emprestado o Ctrl-XCtrl-Etruque do bash da solução de Thor, aqui está como eu faria isso no bash + vim:

C-XC-E inicia o editor padrão (geralmente vim)

a inicia o modo de inserção

.space ASSW

C-Vx4f inserções O

RD

C-Vx5f inserções _

1

C-3é equivalente a escape(não apenas no vim, mas em qualquer lugar do terminal)

C-Xsubtrai 1 do 1que acabei de digitar

a insira o modo novamente

1 C-3

o conteúdo do buffer é agora . ASSWORD_01

<< linha não indentada (no-op, pois a linha não é recuada) e mova o cursor para a 1ª coluna

a

C-X iniciar a conclusão da palavra

C-V completo com o comando ex

C-V Mais 9 vezes seleciona a entrada Print

C-3 de volta ao modo normal

XXXxx exclui rint 

< < voltar à coluna 1

sexcluir ., iniciar o modo de inserção

e c C-X C-Vex comando conclusão mais uma vez, entrada echojá selecionada por causa do que eceu acabei de digitar

space C-3 conteúdo do buffer agora echo PASSWORD_01

Z Z salvar buffer, fechar vim, bash executa o conteúdo do arquivo, ou seja, echo PASSWORD_01

A propósito: C-3tem muitos irmãos úteis: C-Jis Enter, C-Iis Tab, C-His Backspace, C-2is C-@(ou seja, um byte nulo). E para os usuários do emacs, é bom saber que Escapeseguido por outra chave é equivalente a Alt+ essa chave. Portanto, mesmo sem Escapee Altvocê ainda pode digitar Meta-x assim:C-3x

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

( ^chave usada, 3 maneiras)

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

• Válido se a execução como um comando do sistema for qualificada como "saída".

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

• Válido se tiver permissão para usar comandos externos / OS. (Corra aqui)

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

• Válido se eu puder executar o Perl através do sistema. (Corra aqui) <- este usa em printvez dedie

Os scripts usam o operador XOR de string bit a bit do Perl ^, que executa um XOR nos bits de caractere das duas strings. Isso permite recriar os caracteres ausentes para PASSWORD_01 e criar os caracteres para o comando do sistema.

Eu criei as três variantes, dependendo de quão branda as regras sejam. Suponho que, como as variantes 2 e 3 realmente produzam as palavras no Ideone, as soluções são válidas. Tirei a pequena história que tinha aqui, pois achei que ninguém iria lê-la, mas você pode ler nas edições se estiver curioso!

Código oOo (300)

QwerTaSdfGzxCqwertAsDfgZxCQwerTasDfgZxcQweRtaSDfgZxCqwertAsDFgZXcQWeRtaSdFGzxcQwERTasdfGzxc
QwErtAsdFgzxcqWeRtaSdFGzxcQweRtaSDfGZxCqWErTAsDFgZXCqWerTasDfgZxcQweRtaSdfGzxCQwErTAsDFgZXC
qWertAsDfgzxcQwERtASdFGzXcqWeRTasdFGzXcQWeRtAsDfgzxcQwERtASdFGzXCqWerTaSDfgzXcQWErTaSdFgZxc
QwertaSdFgzXcQWertASdFgZXCq

Fácil. (Os feeds de linha são opcionais e estão aqui apenas para tornar o código "mais legível") Gerador de código usado:

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

O mesmo código em uma codificação menos boba:

EeeeEeEeeEeeEeeeeeEeEeeEeEEeeeEeeEeeEeeEeeEeeEEeeEeEeeeeeEeEEeEEeEEeEeeEeEEeeeEeEEEeeeeEeee
EeEeeEeeEeeeeeEeEeeEeEEeeeEeeEeeEEeEEeEeEEeEEeEEeEEEeEeeEeeEeeEeeEeeEeeEeeEeeEEeEeEEeEEeEEE
eEeeeEeEeeeeeEeEEeEEeEEeEeeEeEEeeeEEeEeEEeEeEeEeeeeeEeEEeEEeEEeEEeEeeEeEEeeeEeEEEeEeEeEeEee
EeeeeeEeEeeEeEEeeeEEeEeEEEe

ferNANDo, 179 + 10 = 189 bytes

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

Experimente online!

Enterusava. Eu usaria 0e 1para tornar o código mais legível, mas não posso usá-lo 0.

JS-adiante, 103 bytes

A cadeia será retornada na pilha como uma matriz de caracteres.

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

Experimente online - Versão comentada

Explicação:

Encontrei pela primeira vez a lista de palavras permitidas . Essencialmente, as únicas coisas que eu poderia usar que seriam úteis são:

• 12345 Constantes numéricas
• << Deslocar para a esquerda
• >> Shift right
• s>f Empurre a pilha para flutuar
• f>d Pop duplo da pilha flutuante
• fsqrt Raiz quadrada na pilha de flutuador

Assim, eu poderia usar constantes numéricas, deslocamento de bits e calcular uma raiz quadrada usando o seguinte ( >>substitui drop, deslocando 0para remover o 0):

s>f fsqrt f>d >>

Felizmente, encontrei possíveis mudanças de bits para todas as constantes necessárias para criar que eram mais curtas do que usar raízes quadradas. Na maioria das vezes, procurei simplesmente imprimindo cada número ao quadrado, ou uma potência maior de dois, se algum deles contivesse um dígito 6-0. Então, percebi que poderia usar a perda de precisão f>dpara encontrar mais possibilidades. (Eu poderia adicionar ao número, mas ainda assim obter a mesma raiz quadrada inteira.) Um pouco depois, comecei a usar a troca de bits para encontrar algumas e depois todas as constantes. Quanto maior a >>troca de bits, mais eu poderia adicionar ao "número mágico" e ainda assim obter o mesmo resultado. Então eu encontrei os menores turnos de bits que eu poderia usar para obter os resultados necessários. Às vezes <<, até os números podiam usar , as probabilidades tinham que usar >>.

Código comentado ( \inicia um comentário):

\ 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 não possui as palavras <<ou >>. Em vez disso, tem lshifte rshift, que eu não poderia usar .

Decimal , 190 180 + 10 = 190 bytes

12055D12025D41D301212055D12010D41D301212055D12025D41D12003D41D30130112004D41D301212055D12024D41D30112003D41D301212055D12013D41D301212055D12040D41D301212045D12003D41D30112001D41D301

Experimente online! Decimal é uma linguagem esotérica que usa apenas decimais e a letra D. No entanto, eu precisava da penalidade de +10 porque quase todo comando usa 0.

Felizmente, todos os comandos necessários para imprimir PASSWORD_01não exigem números acima 6:

• 12...D - empurre um personagem
• 2 - pop um valor
• 41D - pop top dois valores de pilha, multiplicar e empurrar resultado
• 301 - imprime DSI (índice de pilha padrão)

Pressionando repetidamente os valores dos caracteres que usam apenas os dígitos 1 a 5 e, em seguida, adicionando-os, eu posso criar os valores dos caracteres para cada letra PASSWORD_01.

Ungolfed e comentou:

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

Espaço em branco , pontuação: 111 (101 bytes + 10 para 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]

Letras S(espaço), T(tabulação) e N(nova linha) adicionadas apenas como destaque.
[..._some_action]adicionado apenas como explicação.

Experimente online (apenas com espaços brutos, guias e novas linhas).

Explicação em pseudo-código:

Essa solução é mais curta que a resposta existente no Whitespace ( @ n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̷̨̰́̀ĥ̷̳ pediu para publicá-la como uma resposta separada quando eu sugeri como golfe), utilizando esta dica minha do 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

A constante 80foi gerada com este programa Java , que eu criei e usei para algumas respostas anteriores do Whitespace.

Stax , 91 + 10 bytes

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

Experimente online!

Usa ]para fazer singletons.

Explicação

Vamos ver como "P"é gerado e como o "ASSW"é anexado sem usar o habitual +.

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

O resto está apenas repetindo o mesmo truque.

"a"EEE$"$"a$Re]Rtroca os dígitos de "a"ou [97]para criar [79]ou "O"e anexa à string.

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

"$""a"EEEd$"$""5"Re]Rusa "a"novamente para obter "9"e descartar o "7", em seguida, combina o "9"com um literal "5"para formar [95]or "_"e o anexa à string.

"$"1 !$R obtém um zero pela lógica não de 1 e o anexa à string.

"$""1"Racrescenta a final "1"e terminamos.

Saída implícita.

brainfuck , 400 + 10 ( +) = 410 bytes

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

Experimente online!

Código de máquina .COM 8086 do MS-DOS (72 bytes)

O tempo é precioso, portanto, não há tempo para discutir com compiladores ou intérpretes! Simplesmente abra o seu editor de texto de sua escolha e digite o seguinte (substitua \tpor TAB):

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

Como um 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$

Salve como um arquivo .COM e execute-o para salvar o dia.

O código assume certos valores iniciais para registros , portanto, pode não funcionar para todos os tipos de DOS. Só espero que alguém arrisque ser demitido por não comprar a IBM.

Representação um pouco mais compreensível:

org 0x100
bits 16
cpu 8086

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

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

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

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

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

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

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

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

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

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

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

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

; Password
    pw  db  "eASSWzRD<11$"

Befunge-98, 43 +10 = 53 bytes

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

Experimente online!

A penalidade de 10 bytes é pelo uso da ,chave (não sei por que isso não pôde ser realizado com Shift+ <, mas essa parece ser a regra). E embora a origem tenha tecnicamente 40 caracteres, os três ·caracteres contribuem com mais três bytes devido à codificação UTF-8.

05AB1E , 87 86 bytes

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

Experimente online!

Talvez o código 05AB1E mais longo de todos os tempos?

Infelizmente, o idioma não suporta coisas como "Q"<"decrementar Q para obter P"

Minha chave extra é o V.

Obrigado a @Kevin Cruijssen por -1 byte.

Código:

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 

Para comparação: a maneira mais curta de imprimir "PASSWORD_01" tem 6 bytes

Experimente online!

Emacs, 26 bytes (possivelmente + 10 = 36 ou - 2 = 24)

A chave extra necessária nesta resposta é Esc. Isso está na metade do teclado que ainda está intacta, mas não é mencionada na pergunta por algum motivo, portanto, pode ou não dar uma penalidade à pontuação. ( Esce Altsão equivalentes no Emacs; tambémAlt está na metade intacta do teclado, mas não é mencionado na pergunta, mas deve ser mantido em vez de ser tocado para que eu não possa usá-lo como minha chave extra. Isso economizaria dois bytes , porém, porque possui uma codificação mais curta que a.)Esc

O próprio programa (as vírgulas delimitam os limites entre os bytes no formato on-the-wire que o Emacs usa para aceitar sua entrada):

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ção disso como bytes brutos, para provar a contagem de bytes:

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: alguns dos detalhes podem variar de acordo com a configuração do Emacs; esta resposta exige que o quoted-char-radix seja definido como 16 e que o Emacs use o dicionário de verificação ortográfica padrão no meu sistema de inglês britânico. Ambos parecem como definições de configuração razoáveis, mas é possível que sua cópia do Emacs seja configurada de maneira diferente.Um dicionário diferente provavelmente ainda forneceria um programa de 26 bytes, mas erros de ortografia ligeiramente diferentes podem precisar ser usados ​​para que as correções desejadas possam ser aceitas por chaves não controladas por marcadores.)

Explicação

Não tenho certeza se deve ter alguma influência nas guerras dos editores, mas o Emacs parece vencer o vim pelo menos no caso desta pergunta. O Emacs é bastante adequado para golfe de editor medido em bytes, porque depende muito de acordes que usam várias teclas pressionadas, mas apenas um byte (portanto, um programa Emacs costuma ser mais lento do que o programa Vim equivalente, mas mais curto no disco). Além disso, a maioria dos comandos mais importantes do Emacs estão no canto inferior esquerdo do teclado, para estar perto Ctrl, muito útil com uma pergunta como esta.

"Você pode assumir que o editor de shell / fonte do intérprete foi aberto antes que os marcadores chegassem. Infelizmente, você não escreveu nada antes do teclado ser pressionado.", Então estou assumindo que temos um arquivo vazio aberto no Emacs e precisa digitar a senha nele. (Precisamos salvar o arquivo posteriormente e provavelmente sair do Emacs, mas os bytes para isso não estão sendo contados nas respostas de outras pessoas, por isso também não os estou contando aqui. É totalmente viável usando o lado esquerdo do teclado, porém, Ctrl- X, Ctrl- S, Ctrl- X, Ctrl- C.)

Assumindo um comando (ou bloco de comandos semelhantes) de cada vez:

• W, S: Entra WSno documento.
• Esc, $: Invoque o corretor ortográfico. WSnão é uma palavra real, mas encontra muitas palavras semelhantes de duas letras.
• D: Usando o corretor ortográfico, corrija WSpara PS. (Quando o verificador ortográfico é chamado usando Alt- $, como aconteceu aqui ( Esce Alté equivalente ao Emacs), ele verifica apenas uma palavra, sendo desativado depois de fazer isso.)
• A: inserir A, dando PSA.
• Ctrl- T: Troque os dois caracteres anteriores, dando PAS.
• S, R, W, D: Tipo SRWD, doação PASSRWD.
• Esc, $, 5: Nós invocamos o verificador ortográfico novamente, porque queremos corrigir a nossa grafada PASSRWDem PASSWORD. Observe que não podemos adivinhar a palavra que queremos na primeira tentativa, como faria com PASSWRD, porque a tecla para aceitar a palavra real mais próxima é a 0que não podemos pressionar. Como resultado, o erro de ortografia um pouco mais extremo PASSRWDé usado para empurrar a palavra que queremos para a posição 5, onde podemos aceitá-la.
• Ctrl- Q, 5, f: Insira o personagem com código de caracteres U + 5F, ou seja _. O documento agora lê PASSWORD_(ou será quando começarmos a digitar o próximo comando; antes disso, o sublinhado não aparecerá se digitarmos outro dígito hexadecimal).
• Ctrl- X, r, Ctrl- Space, 1: armazenar a posição atual do cursor (em relação ao início do arquivo) no registo 1. Por alguma razão bizarra, este é 1-indexados, então (tendo escrito 9 caracteres até agora) o cursor estiver na posição 10.
• Ctrl- X, r, g, 1: Copie o conteúdo do registo 1 no documento. Agora lê PASSWORD_10.
• Ctrl- T: Troque os dois caracteres antes do cursor. Agora temos PASSWORD_01, como a pergunta pede.

Se for permitido o uso Alt, provavelmente podemos codificar o comando "invocar verificação ortográfica" como o byte único, em a4vez de explicá-lo como 1b 24; aparece duas vezes, o que leva a dois bytes de economia. (A maioria dos terminais modernos usa 1b 24como codificação para Alt- $para evitar conflitos com o UTF-8, mas a a4codificação também é encontrada de tempos em tempos, às vezes disponível como opção de configuração.)

Possíveis economias de bytes provavelmente envolvem erros de ortografia nos jogadores para corrigir. PSASWRDseria um byte mais curto para digitar, mas, infelizmente, o corretor ortográfico não parece capaz de entender PASSWORDisso, então PASSRWDé a melhor abordagem que encontrei até agora. A abordagem baseada em registros para ganhar 10também é ridiculamente difícil, mas não há muitas maneiras de criar números do nada no Emacs, e 0é um personagem doloroso para se controlar. (Pelo menos, houve algumas coincidências incrivelmente úteis: o cursor acabou por terminar na posição 10, que contém a 0, exatamente quando necessário; e o fato de o Emacs aceitar a goperação de registro redundante para inserir o conteúdo de um registro no documento , além do mais intuitivoi.)