Usted ha sido contratado por su conocimiento tecnológico como compinche de un agente secreto para garantizar que el buen tipo pueda hacer su trabajo y que el mundo pueda salvarse.

Esta es su última misión antes de retirarse con un alto sueldo y la gratitud de todo el mundo. Pero antes de que tengas que desarmar la BOMBA enormemente masiva del genio malvado (parece que el genio malvado es un asno inteligente al que le gustan las siglas recursivas). De todos modos, usted y su amigo están en el centro de la base secreta de Evil Genius, listos para desarmar la BOMBA que podría destruir el continente. En su misión anterior, logró obtener el código de desarmado que para su asombro es solo "CONTRASEÑA_01". Conecta su teclado a la BOMBA, pero cuando esté listo para ir, los secuaces del Evil Genius entran con una lluvia de balas. Lamentablemente, una de estas balas impacta en su teclado. "¡Termina el trabajo mientras distraigo a esos imbéciles!" dice tu amigo y luego comienza a disparar su arma.

ESPECIFICACIONES

1. Escriba un programa que genere de cualquier forma que desee la cadena PASSWORD_01(mayúscula).

2. Como su teclado ha sido alcanzado por una bala, solo puede 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 la Shifttecla, su teclado le permite usar estos caracteres:

   ! " · $ %

3. No tiene otro hardware que el teclado y la pantalla (un mouse, por ejemplo), ni un archivo con la contraseña escrita en su computadora.

4. No tienes conexión a internet.

5. Puede suponer que tiene abierto el intérprete shell / editor de fuente antes de que aparecieran las viñetas. Lamentablemente, no ha escrito nada en él antes de que golpeara el teclado.

6. No tienes un teclado virtual. De hecho, la BOMB tiene un detector TOO_FUNNY que lo hará explotar si intenta utilizar las lagunas estándar .

7. Dado que su amigo está esperando que termine pronto para escapar de la Base Secreta, tendrá que escribir el código más pequeño posible (¡así que es de código restringido y código de golf !).

¡Buena suerte porque la cuenta atrás ha comenzado!

MODO DE AYUDA: También KEYha sobrevivido milagrosamente una (solo una tecla que desea del teclado, pero no la tecla Mayús + tecla o cualquier otra combinación). Por ejemplo: puede usar =, o 0o /... Esta tecla adicional no puede ser ninguna de las letras PASSWORD_01(por lo que no puede agregar Po O). Nombre esa clave en su respuesta. Tiene una penalización de 10 caracteres por usar esta clave, independientemente de cuántas veces la use.

CJam - 24 + 10 ( () = 34

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

Sin clave adicional - 39

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

Pruébalo en http://cjam.aditsu.net/

bash, vim y dc (343)

Estoy sentado en un indicador de bash que ha sido configurado por Evil Genius, y por supuesto que lo ha hecho VISUAL=vimen el entorno predeterminado. Usando el enlace bash predeterminado para edit-and-execute-command( C-x C-e) invoca bash $VISUALy ejecutará su contenido de búfer en exit ( ZZ). kbdEscribo la siguiente secuencia (Nota: -mode son comandos emitidos en modo normal y secuencias de control):

1. C-xC-e

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

   Ahora el búfer vim contiene cat<<<49a. Continuando ...

3. 45 C-c3C-aaa

4. 54 C-c41C-aaa

5. 55 C-c13C-aaa

   Ahora el búfer vim contiene cat<<<49a48a95a68a. Continuando ...

6. 51 C-c31C-aaa

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

12. 55C-c25C-aa a> s

    Ahora el búfer vim contiene cat<<<49a48a95a68a82a79a87a83a83a65a80a>s

    Salga del modo de inserción, guarde y salga

13. C-cZZ

    El sarchivo ahora contiene un dcscript que genera la cadena deseada en la pila, ahora necesitamos agregar comandos de impresión.

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

    Repita el comando anterior 9 veces.

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

    Ejecute el script dc:

25. C-xC-eadc sC-cZZ

Salida:

PASSWORD_01

Contenido del sarchivo:

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

Rubí, 57 + 10 ( *) = 67

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

Esta respuesta usa *y %para construir los valores ASCII de los caracteres faltantes (y 0 como Fixnum) y los empuja hacia $*( ARGV). Esta matriz se usa luego en combinación con una cadena de formato para generar la contraseña correcta, que se imprime con $><<( $>es stdout).

Rubí, 62 + 10 ( .) = 72, sin salto de línea

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

Aproximadamente el mismo principio que la versión anterior, excepto que aquí la matriz se construye a partir de una matriz vacía literal ( %w%%). .Es necesario jugar un poco con él para obtener la prioridad de operador deseada.

Espacio en blanco (148 + 10 = 158)

Enter La clave necesita ser utilizada aquí.

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 explicación de mi notación:

• S, +, 0Son espacios.
• T, 1son pestañas.
• L Es nueva línea.
• // comienza a comentar.

Cada línea es un comando en lenguaje de espacios en blanco.

Manifestación

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

Necesitaba el +carácter (que cuesta +10), que se puede obtener del teclado numérico (o en ciertos diseños de teclas).

Sí, la BOMBA probablemente explotó mientras estaba escribiendo eso.

El enfoque básico es construir conjuntos de caracteres cada vez más grandes utilizando execy "%c"%(number). Hay cuatro execs anidados uno dentro del otro. Gradualmente, mi conjunto de dígitos progresa desde

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

para que en la iteración final sea posible expresar cualquier carácter (para que la versión más interna pueda ejecutar cualquier programa).

Alrededor del 50% del programa son solo comillas ( "%c"%34es una comilla doble), porque la naturaleza anidada de las execdeclaraciones exige caracteres de comillas "escapadas" agresivamente.

Insomnio 39 35 31 29

Este lenguaje aparece cuando estaba buscando un lenguaje que codifique sus instrucciones con un solo carácter ASCII. El lenguaje realmente funciona en el código ASCII decimal del carácter, por lo que sigue siendo bastante flexible con la mitad del teclado destruido.

Suéltelo hasta 29 caracteres, lo cual es posible después de reducir el uso de memoria y aumentar el espacio de búsqueda:

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

Decidí ejecutar mi programa ajustado en el conjunto completo de caracteres permitidos, y reduje la solución a 31 caracteres:

FdFGt dtreeC>tt FFdx<Fdtr ztq4s

Usé un programa para buscar esta solución. Es una de las muchas soluciones devueltas por mi programa, todas con el mismo tamaño.

Fddx>"eCeezdC>CefCdddzCzzfCqred>r4s

Versión antigua construida a mano. Recuerdo quedarme despierto hasta la mañana para hacer esto.

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

Aquí está el intérprete de Insomnia para las pruebas.

Vim + PHP en algunos administradores de ventanas

65 teclas en 44 golpes, con una penalización de 10 puntos por usar =.

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

Una averia:

• Alt+Tabparece funcionar como Esccon Vim, o tal vez con este emulador de terminal. ¡Gracias por enseñarme algo nuevo!
• aEACE<Alt+Tab>: Ingrese al modo de agregar e inserte “EACE”. Salida.
• z=5<Alt+Tab>: Realiza la corrección ortográfica. Seleccione 5, "PAZ". Salida. (¡ EscParece funcionar como Enteraquí!)
• $xxxxaASSWRD<Alt+Tab>: Ir al final de la línea. Eliminar 4 caracteres y agregar ASSWRD, lo que resulta en PASSWRD. De vuelta al modo normal. (No,4x no funcionará)
• z=1<Alt+Tab>: PASSWORDEs probable que va a ser la primera corrección para esto. Seleccionarlo
• $a$aA<Alt+Tab>: Vaya al final de la línea y agregue a $aA. De vuelta al modo normal.
• ==: Formatee esta línea de PHP muy bien, cambiando camelCase $aAa $a_a. Esto también mueve el cursor de regreso al inicio de la línea.
• wxx: Avanza una palabra; El cursor está ahora antes $. Eliminar dos caracteres - el $y el a- para hacer PASSWORD_a.
• $r1: Ir al final de la línea y reemplazar el carácter actual (es decir a) con 1, lo que resulta en PASSWORD_1.
• ^X: Disminuye el número entero debajo del cursor, lo que da como resultado PASSWORD_0.
• a1: Por último, añadir 1, para PASSWORD_01!

Python 2, 75889 bytes

¡Sin carácter extra!

Lamentablemente, el código es muy largo. Entonces, en cambio, aquí está el código para generar el 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')

Pruébalo en línea

(para ejecutar el código, cambie el exterior printa unexec . O, genere el programa, luego péguelo y ejecútelo. O cópielo desde el pastebin vinculado a continuación).

Explicación:

El objetivo es ejecutar:

print"PASSWORD_01"

Para evitar el uso de ()+caracteres, tenemos que usar múltiples operaciones de formato de cadena encadenadas juntas. Esto significa que cada paso agregado efectivamente duplica la cantidad de %caracteres necesarios para cada paso anterior:

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

Sin embargo, esto no es suficiente, porque algunos de los números requeridos no se pueden crear, y tampoco podemos crearlos print. Por lo tanto, agregamos un nivel de abstracción con execfor printing, y un nivel para los puntos de código ASCII que no podemos crear para formatear. La siguiente es esencialmente mi respuesta, pero con cada cadena %reducida a una sola (tenga en cuenta que %s%s%s%s%sno es una representación precisa, sin tener en cuenta los literales %requeridos antes de cada uno):

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

El primer paso: más externo 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 el 0enPASSWORD_01
2. 2531>>5: 79, utilizado por el ejecutivo interno para crearO
3. 321>>2: 80, utilizado por el ejecutivo interno para crearP
4. 1521>>4: 95, utilizado por el ejecutivo interno para crear_
5. 211>>1: 105, utilizado por el ejecutivo interno para creari
6. 221>>1: 110, utilizado por el ejecutivo interno para crearn

Segundo paso: preparar el interior exec

Después de lo anterior, lo interno execes algo como esto:

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

Excepto que no lo entenderías del todo. Aún con las simplificaciones, obtendrás esto:

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

El literal %necesita ser incluido. Así que básicamente tuve que agregar un montón de ellos antes de cada uno %spara terminar con los literales %restantes después de todo el formato. 2**11de ellos. Veces cinco.

El resto de las execoperaciones de formato de cadena externa son %112%34%34%34%34. El 112es para p, y los otros son comillas. Después de aplicarlos, el resultado es algo como esto:

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

Pero en realidad tiene un montón más %. Es esto:

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

El paso final es simplemente ejecutar eso, después de lo cual obtienes el resultado necesario.

Código completo aquí: http://pastebin.com/rSFs6DiH

bash + vim (56)

Tomando prestado el Ctrl-XCtrl-Etruco bash de la solución de Thor, así es como lo haría en bash + vim:

C-XC-E inicia el editor predeterminado (generalmente vim)

a comienza el modo de inserción

.space ASSW

C-Vx4f inserta O

RD

C-Vx5f inserta _

1

C-3es equivalente a escape(no solo en vim, sino en cualquier parte de un terminal)

C-Xresta 1 del que 1acabo de escribir

a insertar modo nuevamente

1 C-3

el contenido del búfer es ahora . ASSWORD_01

<< línea sin sangría (no operativa, ya que la línea no está sangrada) y mueve el cursor a la primera columna

a

C-X comenzar palabra completada

C-V completo con ex comando

C-V 9 veces más selecciona la entrada Print

C-3 volver al modo normal

XXXxx elimina rint 

< < volver a la columna 1

seliminar ., iniciar el modo de inserción

e c C-X C-Vex comando completado una vez más, entrada echoya seleccionada debido a que ecacabo de escribir

space C-3 contenido del búfer ahora echo PASSWORD_01

Z Z guardar búfer, cerrar vim, bash ejecuta el contenido del archivo, es decir echo PASSWORD_01

Por cierto: C-3tiene muchos hermanos útiles: C-Jes Enter, C-Ies Tab, C-Hes Backspace, C-2es C-@( es decir, un byte nulo). Y para los usuarios de emacs es bueno saber que Escapeseguido de otra tecla es equivalente a Alt+ esa tecla. Entonces, incluso sin Escapey Altaún puede escribir Meta-x de esta manera:C-3x

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

( ^clave utilizada, 3 formas)

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

• Válido si se ejecuta como un comando del sistema califica como "salida".

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

• Válido si se me permite usar comandos externos / OS. (Corre aquí)

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

• Válido si puedo ejecutar Perl a través del sistema. (Ejecutar aquí) <- este usa en printlugar dedie

Los scripts usan el operador XOR de cadena bit a bit de Perl ^ , que realiza una XOR en los bits de caracteres de las dos cadenas. Esto me permite recrear los caracteres que faltan para PASSWORD_01 y crear los caracteres para el comando del sistema.

Hice las tres variantes dependiendo de cuán indulgentes sean las reglas. Supongo que dado que las variantes 2 y 3 realmente emiten las palabras en Ideone, las soluciones son válidas. Eliminé la pequeña historia que tenía aquí porque pensé que nadie la leería, ¡pero puedes leerla en las ediciones si tienes curiosidad!

oOo código (300)

QwerTaSdfGzxCqwertAsDfgZxCQwerTasDfgZxcQweRtaSDfgZxCqwertAsDFgZXcQWeRtaSdFGzxcQwERTasdfGzxc
QwErtAsdFgzxcqWeRtaSdFGzxcQweRtaSDfGZxCqWErTAsDFgZXCqWerTasDfgZxcQweRtaSdfGzxCQwErTAsDFgZXC
qWertAsDfgzxcQwERtASdFGzXcqWeRTasdFGzXcQWeRtAsDfgzxcQwERtASdFGzXCqWerTaSDfgzXcQWErTaSdFgZxc
QwertaSdFgzXcQWertASdFgZXCq

Fácil. (Los avances de línea son opcionales, y solo aquí para hacer que el código sea "más legible") Generador de código utilizado:

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

El mismo código en una codificación menos tonta:

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

Pruébalo en línea!

Enterusado. Usaría 0y 1para hacer que el código sea más legible pero no puedo usarlo 0.

JS-Forth, 103 bytes

La cadena se devolverá en la pila como una 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 >>

Pruébelo en línea : versión comentada

Explicación:

Primero encontré la lista de palabras permitidas . Esencialmente, las únicas cosas que podría usar que serían útiles son:

• 12345 Constantes numéricas
• << Desplazar a la izquierda
• >> Desplazar a la derecha
• s>f Empuje solo para flotar pila
• f>d Pop doble de la pila de flotador
• fsqrt Raíz cuadrada en la pila flotante

Entonces podría usar constantes numéricas, desplazamiento de bits y calcular una raíz cuadrada usando lo siguiente ( >>reemplaza drop, desplaza por 0para eliminar 0):

s>f fsqrt f>d >>

Afortunadamente, encontré posibles cambios de bits para cada constante que necesitaba crear que eran más cortos que usar raíces cuadradas. En su mayor parte, busqué simplemente imprimiendo cada número al cuadrado, o una potencia mayor de dos si alguno de ellos contenía un dígito 6-0. Entonces, me di cuenta de que podía usar la pérdida de precisión f>dpara encontrar más posibilidades. (Podría agregar al número, pero aún así obtener la misma raíz cuadrada entera.) Un poco más tarde, comencé a usar el desplazamiento de bits para encontrar algunas, y luego todas, las constantes. Cuanto mayor sea el >>desplazamiento de bits, más podría agregar al "número mágico" y aún así obtener el mismo resultado. Así que encontré los cambios de bits más pequeños que pude usar para obtener los resultados necesarios. Los números pares a veces podían usar <<, las probabilidades tenían que usar>> .

Código comentado ( \comienza un comentario):

\ 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 no tiene las palabras <<o >>. En cambio, tiene lshifty rshift, que no pude usar .

Decimal , 190 180 + 10 = 190 bytes

12055D12025D41D301212055D12010D41D301212055D12025D41D12003D41D30130112004D41D301212055D12024D41D30112003D41D301212055D12013D41D301212055D12040D41D301212045D12003D41D30112001D41D301

Pruébalo en línea! Decimal es un lenguaje esotérico que usa nada más que decimales y la letra D. Sin embargo, necesitaba la penalización de +10 porque casi todos los comandos usan0 .

Afortunadamente, todos los comandos necesarios para imprimir PASSWORD_01no requieren ningún número sobre 6:

• 12...D - empujar un personaje
• 2 - resaltar un valor
• 41D - destaque los dos valores superiores de la pila, multiplique y empuje el resultado
• 301 - imprimir DSI (índice de pila predeterminado)

Al presionar repetidamente valores de caracteres que solo usan los dígitos del 1 al 5 y luego agregarlos, puedo hacer los valores de caracteres para cada letra en PASSWORD_01 .

Ungolfed y comentó:

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

Espacio en blanco , puntuación: 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]

Se agregaron letras S(espacio), T(tabulación) y N(nueva línea) solo como resaltado.
[..._some_action]agregado solo como explicación.

Pruébelo en línea (solo con espacios en bruto, pestañas y nuevas líneas).

Explicación en pseudocódigo:

Esta solución es más corta que la respuesta existente de espacios en blanco ( @ n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ me pidió que la publicara como una respuesta separada cuando la sugerí como golf) utilizando esta punta mía de espacios en blanco .

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 constante 80se ha generado con este programa Java , que he creado y utilizado para algunas respuestas anteriores de 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

Pruébalo en línea!

Usos ]para hacer singletons.

Explicación

Veamos cómo "P"se genera y cómo "ASSW"se agrega sin usar el 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"

El resto solo repite el mismo truco.

"a"EEE$"$"a$Re]R intercambia los dígitos de "a" o [97]para hacer [79]o "O"y lo agrega a la cadena.

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

"$""a"EEEd$"$""5"Re]Rutiliza de "a"nuevo para obtener "9"y descarta el "7", luego combina el"9" con un literal "5"para formar [95]o "_", y lo agrega a la cadena.

"$"1 !$R obtiene un cero por no lógico de 1 y lo agrega a la cadena.

"$""1"Rañade la final "1"y ya hemos terminado.

Salida implícita.

brainfuck , 400 + 10 ( +) = 410 bytes

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

Pruébalo en línea!

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

¡El tiempo es precioso, así que no hay tiempo para divertirse con compiladores o intérpretes! Simplemente abra el editor de texto de su elección y escriba lo siguiente (reemplace \tcon TAB):

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

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

Guardar como un archivo .COM y ejecutarlo para salvar el día.

El código asume ciertos valores iniciales para los registros , por lo que podría no funcionar para todos los sabores de DOS. Solo espero que alguien se arriesgue a ser despedido por no comprar IBM.

Representación ligeramente más comprensible:

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

Pruébalo en línea!

La penalización de 10 bytes es por el uso de la ,clave (no estoy seguro de por qué esto no se pudo lograr con Shift+ <, pero esa parece ser la regla). Y aunque la fuente es técnicamente de 40 caracteres, los tres ·caracteres contribuyen con tres bytes adicionales debido a su codificación 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

Pruébalo en línea!

¿Tal vez el código 05AB1E más largo de la historia?

Lamentablemente, el lenguaje no admite cosas como "Q"<"decrementar Q para obtener P"

Mi clave extra es la V.

Gracias 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 

A modo de comparación: la forma más corta de imprimir "CONTRASEÑA_01" es de 6 bytes de longitud

Pruébalo en línea!

Emacs, 26 bytes (posiblemente + 10 = 36, o - 2 = 24)

La clave adicional que se necesita en esta respuesta es Esc. Esto está en la mitad del teclado que todavía está intacto, pero no se menciona en la pregunta por alguna razón, por lo que podría o no penalizar la puntuación. ( Escy Altson equivalentes en Emacs; tambiénAlt es en la mitad intacta del teclado, pero no se menciona en la pregunta, pero debe mantenerse en lugar de presionarse para que no pueda usarla como mi tecla adicional. Ahorraría dos bytes , sin embargo, porque tiene una codificación más corta que la que Esctiene).

El programa en sí (las comas delimitan los límites entre bytes en el formato en el cable que Emacs usa para aceptar su 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

Codificación de esto como bytes sin procesar, para probar el recuento 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: algunos de los detalles pueden variar según la configuración de Emacs; esta respuesta requiere cita-char-radix se establezca en 16, y para que Emacs use el diccionario de corrección ortográfica que está predeterminado en mi sistema de inglés británico. Ambos parecen como ajustes de configuración razonables, pero es posible que su copia de Emacs se configure de manera diferente. Es probable que un diccionario diferente todavía dé un programa de 26 bytes, pero es posible que se deban usar errores ortográficos ligeramente diferentes para que las correcciones que deseamos puedan ser aceptadas por teclas sin viñetas).

Explicación

No estoy seguro de si debería tener alguna influencia en las guerras del editor, pero Emacs parece vencer a vim al menos en el caso de esta pregunta. Emacs es bastante adecuado para el editor de golf medido en bytes, ya que depende en gran medida de los acordes que ocupan múltiples pulsaciones de teclas pero solo un byte (por lo tanto, un programa Emacs a menudo es más lento de escribir que el programa Vim equivalente, pero más corto en el disco). Además, la mayoría de los comandos más importantes de Emacs se encuentran en la esquina inferior izquierda del teclado, para estar cerca Ctrl, muy útiles con una pregunta como esta.

"Puede suponer que tiene abierto el intérprete shell / editor de fuente antes de que aparecieran las viñetas. Lamentablemente, no ha escrito nada antes de que se golpeara el teclado", así que supongo que tenemos un archivo vacío abierto en Emacs y necesita escribir la contraseña en él. (Necesitaríamos guardar el archivo después, y probablemente salir de Emacs, pero los bytes para eso no se cuentan en las respuestas de otras personas, así que tampoco los estoy contando aquí. Es totalmente factible usando el lado izquierdo del teclado, sin embargo, Ctrl- X, Ctrl- S, Ctrl- X, Ctrl- C.)

Tomándolo como un comando (o bloque de comandos similares) a la vez:

• W, S: Ingrese WSen el documento.
• Esc, $: Invocar el corrector ortográfico. WSno es una palabra real, pero encuentra muchas palabras similares de dos letras.
• D: Usando el corrector ortográfico, corrige WSa PS. (Cuando se invoca el corrector ortográfico usando Alt- $, como sucedió aquí ( Escy Altson equivalentes a Emacs), solo verifica una palabra, por lo que se desactiva después de hacer esto).
• A: insertar A, dar PSA.
• Ctrl- T: intercambia los dos caracteres anteriores, dando PAS.
• S, R, W, D: Tipo SRWD, las donaciones PASSRWD.
• Esc, $, 5: Invocamos el corrector ortográfico de nuevo, porque queremos corregir nuestro mal escrito PASSRWDen PASSWORD. Tenga en cuenta que no podemos hacer que adivine la palabra que queremos en nuestro primer intento, como lo haría con PASSWRD, porque la clave para aceptar la palabra real más cercana es la 0que no podemos presionar. Como resultado, la falta de ortografía un poco más extrema PASSRWDse usa para llevar la palabra que queremos a la posición 5, donde podemos aceptarla.
• Ctrl- Q, 5, f: Insertar el carácter con el código de caracteres U + 5f, es decir _. El documento ahora se lee PASSWORD_(o lo hará cuando comencemos a escribir el siguiente comando; antes de eso, el guión bajo no aparece en caso de que escribamos otro dígito hexadecimal).
• Ctrl- X, r, Ctrl- Space, 1: Almacena la posición actual del cursor (en relación con el inicio del archivo) en el registro 1. Por alguna extraña razón, esto es indexada 1, por lo que (después de haber escrito 9 caracteres hasta ahora) el cursor se encuentra en la posición 10.
• Ctrl- X, r, g, 1: Copia el contenido del registro 1 en el documento. Ahora se lee PASSWORD_10.
• Ctrl- T: intercambia los dos caracteres antes del cursor. Ahora tenemos PASSWORD_01, como la pregunta pide.

Si se nos permite usar Alt, probablemente podamos codificar el comando "invocar corrector ortográfico" como un solo byte en a4lugar de deletrearlo como 1b 24; aparece dos veces, por lo que genera dos bytes de ahorro. (La mayoría de los terminales modernos utilizan 1b 24como la codificación para Alt- $para evitar choques con UTF-8, pero la a4codificación también se encuentran de vez en cuando, a veces disponible como una opción de configuración.)

Los posibles ahorros de bytes probablemente impliquen errores ortográficos de golf para corregir. PSASWRDsería un byte más corto de escribir, pero desafortunadamente, el corrector ortográfico no parece capaz de PASSWORDdeducir eso, por lo que PASSRWDes el mejor enfoque que he encontrado hasta ahora. El enfoque basado en el registro para ganar 10también es ridículamente difícil de manejar, pero no hay muchas maneras de crear números de la nada en Emacs, y 0es un personaje doloroso de lo contrario. (Al menos hubo un par de coincidencias increíblemente útiles: el cursor acaba de terminar en posición 10, que contiene un 0, justo cuando es necesario; y el hecho de que Emacs acepta lo redundante ).g operación de registro para insertar el contenido de un registro en el documento , además de lo más intuitivoi