En tant qu'accompagnateur de l'agent secret, vous avez été engagé pour vos connaissances techniques afin de vous assurer que le bon gars puisse faire son travail et que le monde puisse être sauvé.

Ceci est votre dernière mission avant de prendre sa retraite avec un salaire élevé et la gratitude du monde entier. Mais avant de désarmer la BOMB Big Overly Massive du Génie Maléfique (il semble que le génie du mal soit un âne intelligent qui aime les acronymes récursifs). Quoi qu'il en soit, vous et votre ami êtes au cœur de la base secrète de Evil Genius, prêts à désarmer la BOMB qui pourrait anéantir le continent. Lors de votre précédente mission, vous avez réussi à obtenir le code de désarmement qui, à votre grand étonnement, est simplement "PASSWORD_01". Vous connectez votre clavier à la BOMB, mais lorsque vous êtes prêt à partir, les hommes de main du Génie maléfique entrent avec un barrage de balles. Malheureusement, l'une de ces balles a un impact sur votre clavier. "Termine le travail pendant que je distrais ces d * ckheads!" dit votre copain et commence à tirer son arme.

SPÉCIFICATIONS

1. Ecrivez un programme qui affiche comme vous le souhaitez la chaîne PASSWORD_01(majuscule).

2. Votre clavier ayant été touché par une balle, vous ne pouvez utiliser que les touches suivantes:

   1 2 3 4 5

   Q W E R T

   A S D F G

   < > Z X C

   Ctrl Shift Tab Space

   En utilisant la Shifttouche, votre clavier vous permet d’utiliser ces caractères:

   ! " · $ %

3. Vous n'avez pas d'autre matériel que le clavier et l'écran (une souris par exemple), ni un fichier avec le mot de passe inscrit sur votre ordinateur.

4. Vous n'avez pas de connexion Internet.

5. Vous pouvez supposer que l'éditeur d'interpréteur / source d'interprète a été ouvert avant l'arrivée des puces. Malheureusement, vous n'avez rien écrit dedans avant que le clavier ne soit touché.

6. Vous n'avez pas de clavier virtuel. En fait, le BOMB a un détecteur TOO_FUNNY qui le fera exploser si vous essayez d’utiliser les failles standard .

7. Puisque votre copain attend que vous finissiez bientôt pour vous échapper de la Base secrète, vous devrez écrire le plus petit code possible (donc c'est du code source-restreint et du code-golf !).

Bonne chance car le décompte a commencé!

MODE AIDE: De même, une KEY( une seule touche du clavier que vous voulez, mais pas la combinaison de touches Maj + touche ou toute autre combinaison) a miraculeusement survécu également. Ex.: Vous pouvez utiliser =, ou 0ou /… Cette touche supplémentaire ne peut contenir aucune des lettres PASSWORD_01(vous ne pouvez donc pas ajouter Pou O). Nommez cette clé dans votre réponse. Vous avez une pénalisation de 10 caractères pour l’utilisation de cette clé, quel que soit le nombre de fois où vous l’utilisez.

CJam - 24 + 10 ( () = 34

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

Aucune clé supplémentaire - 39

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

Essayez-le sur http://cjam.aditsu.net/

bash, vim et dc (343)

Je suis assis à une invite de bash qui a été configurée par Evil Genius et, bien sûr, VISUAL=vimdans l'environnement par défaut. Utilisation de la liaison par défaut de bash pour edit-and-execute-command( C-x C-e) bash appelle $VISUALet exécute le contenu de son tampon sous exit ( ZZ). Je tape dans la séquence suivante (Remarque: kbd-mode sont des commandes émises en mode normal et des séquences de contrôle):

1. C-xC-e

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

   Maintenant, le tampon vim contient cat<<<49a. En continuant ...

3. 45 C-c3C-aaa

4. 54 C-c41C-aaa

5. 55 C-c13C-aaa

   Maintenant, le tampon vim contient cat<<<49a48a95a68a. En continuant ...

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

    Maintenant, le tampon vim contient cat<<<49a48a95a68a82a79a87a83a83a65a80a>s

    Sortez du mode insertion, sauvegardez et quittez

13. C-cZZ

    Le sfichier contient maintenant un dcscript qui génère la chaîne souhaitée sur la pile. Nous devons maintenant ajouter des commandes d'impression.

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

    Répétez la commande ci-dessus 9 fois.

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

    Exécutez le script en continu:

25. C-xC-eadc sC-cZZ

Sortie:

PASSWORD_01

Contenu du sfichier:

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

Rubis, 57 + 10 ( *) = 67

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

Cette réponse utilise *et %pour construire les valeurs ASCII des caractères manquants (et 0 comme Fixnum) et les insère dans $*( ARGV). Ce tableau est ensuite utilisé en combinaison avec une chaîne de format pour générer le mot de passe correct, qui est imprimé avec $><<( $>est stdout).

Ruby, 62 + 10 ( .) = 72, pas de saut de ligne

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

À peu près le même principe que la version ci-dessus, sauf qu'ici le tableau est construit à partir d'un tableau vide literal ( %w%%). Quelques manipulations .sont nécessaires pour obtenir la priorité souhaitée de l’opérateur.

Espace blanc (148 + 10 = 158)

Enter la clé doit être utilisée ici.

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

L'explication de ma notation:

• S, +, 0Sont des espaces.
• T, 1sont des onglets.
• L est nouvelle ligne.
• // commence à commenter.

Chaque ligne est une commande en langage blanc.

Démo

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

J'avais besoin du +caractère (coûtant +10), qui peut être obtenu à partir du pavé numérique (ou sur certaines dispositions de touches).

Oui, la BOMB s'est probablement éteinte pendant que je tapais ça.

L'approche de base consiste à construire des jeux de caractères toujours plus grands en utilisant execet "%c"%(number). Il y a quatre execs imbriqués l'un dans l'autre. Progressivement, mon jeu de chiffres progresse de

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

de sorte que lors de l'itération finale, il est possible d'exprimer n'importe quel caractère (de sorte que la version la plus interne puisse réellement exécuter n'importe quel programme).

Environ 50% du programme consiste uniquement en des guillemets ( "%c"%34une guillemet double), car la nature imbriquée des execinstructions exige de "s'échapper" de manière agressive.

Insomnie 39 35 31 29

Cette langue apparaît lorsque je cherchais une langue qui code ses instructions avec un seul caractère ASCII. Le langage fonctionne en réalité sur le code ASCII décimal du caractère, il est donc encore assez flexible avec la moitié du clavier détruite.

Réduisez-le à 29 caractères, ce qui est possible après avoir utilisé moins de mémoire et augmenté l’espace de recherche:

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

J'ai décidé de lancer mon programme modifié sur l'ensemble des caractères autorisés et de réduire la solution à 31 caractères:

FdFGt dtreeC>tt FFdx<Fdtr ztq4s

J'ai utilisé un programme pour rechercher cette solution. C'est l'une des nombreuses solutions renvoyées par mon programme, toutes de la même taille.

Fddx>"eCeezdC>CefCdddzCzzfCqred>r4s

Ancienne version construite à la main. Je me souviens de rester jusqu'au matin pour faire ça.

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

Voici la interprète Insomnia pour les tests.

Vim + PHP sur certains gestionnaires de fenêtres

65 touches en 44 coups, avec une pénalité de 10 points pour avoir utilisé =.

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

Une dépression:

• Alt+Tab semble fonctionner comme Esc avec Vim, ou peut-être avec cet émulateur de terminal. Merci de m'apprendre quelque chose de nouveau!
• aEACE<Alt+Tab>: Entrez en mode annexe et insérez «EACE». Sortie.
• z=5<Alt+Tab>: Effectuer une correction orthographique. Sélectionnez 5, “PEACE”. Sortie. ( Escsemble fonctionner commeEnter ici!)
• $xxxxaASSWRD<Alt+Tab>: Aller au bout de la ligne. Supprimer 4 caractères et ajouter ASSWRD, résultant en PASSWRD. Retour en mode normal. (Non,4x ça ne marchera pas.)
• z=1<Alt+Tab>: PASSWORDEst probablement va être la première correction pour cela. Sélectionnez le.
• $a$aA<Alt+Tab>: Allez au bout de la ligne et ajoutez a $aA. Retour en mode normal.
• ==: Formatez joliment cette ligne de PHP en remplaçant le camelCase $aApar $a_a. Cela ramène également le curseur au début de la ligne.
• wxx: Avancez un mot; le curseur est maintenant avant $. Supprimer deux caractères - le $et le a- faire PASSWORD_a.
• $r1: Aller à la fin de la ligne et remplacer le caractère actuel (ie a) par 1, résultant en PASSWORD_1.
• ^X: Décrémente l'entier sous le curseur, résultant en PASSWORD_0 .
• a1: Enfin, ajoutez 1, pour PASSWORD_01!

Python 2, 75889 octets

Pas de personnage supplémentaire!

Malheureusement, le code est super long. Au lieu de cela, voici le code pour générer le programme:

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

Essayez-le en ligne

(pour exécuter le code, changez l’extérieur printen unexec . Ou générez le programme, puis collez-le et exécutez-le. Ou copiez-le à partir de la boîte à copier liée ci-dessous.)

Explication:

Le but est d'exécuter:

print"PASSWORD_01"

Pour éviter d'utiliser des ()+caractères, nous devons utiliser plusieurs opérations de format de chaîne chaînées. Cela signifie que chaque étape ajoutée double le nombre de %caractères requis pour chaque étape précédente:

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

Cela ne suffit cependant pas, car certains des nombres requis ne peuvent pas être créés, et nous ne pouvons pas non plus créer print. Nous ajoutons donc un niveau d'abstraction avec execfor printing et un niveau pour les points de code ASCII avec lesquels nous ne pouvons pas créer de formatage. Ce qui suit est essentiellement ma réponse, mais avec chaque chaîne de caractères %réduite à une seule (notez que la représentation %s%s%s%s%sn’est pas exacte, sans prise en compte des littéraux %requis avant chaque):

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

La première étape: à l’extérieur 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, Utilisé pour le 0dansPASSWORD_01
2. 2531>>5: 79, utilisé par l'exécutif interne pour créerO
3. 321>>2: 80, utilisé par l'exécutif interne pour créerP
4. 1521>>4: 95, utilisé par l'exécutif interne pour créer_
5. 211>>1: 105, utilisé par l'exécutif interne pour créeri
6. 221>>1: 110, utilisé par l'exécutif interne pour créern

Deuxième étape: préparer l'intérieur exec

Après ce qui précède, l'intérieur execest quelque chose comme ceci:

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

Sauf que tu ne comprendrais pas tout à fait ça. Toujours avec les simplifications, vous obtiendrez ceci:

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

Les littéraux %doivent être inclus. Donc, fondamentalement, je devais en ajouter plusieurs avant chacune %spour finir avec les littéraux %laissés après le formatage. 2**11d'eux. Fois cinq.

Le reste des execopérations de format de chaîne externe sont %112%34%34%34%34. Le 112est pour p, et les autres sont des guillemets. Après application, le résultat ressemble à ceci:

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

Mais en réalité, il en a beaucoup plus %. C'est ça:

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

La dernière étape consiste simplement à l'exécuter, après quoi vous obtenez la sortie nécessaire.

Code complet ici: http://pastebin.com/rSFs6DiH

bash + vim (56)

Empruntant le Ctrl-XCtrl-Etruc bash de la solution de Thor, voici comment je le ferais dans bash + vim:

C-XC-E lance l'éditeur par défaut (généralement vim)

a démarre le mode insertion

.space ASSW

C-Vx4f inserts O

RD

C-Vx5f inserts _

1

C-3est équivalent à escape(pas seulement dans vim, mais n'importe où dans un terminal)

C-Xsoustrait 1 de la 1je viens de taper

a insérer de nouveau le mode

1 C-3

le contenu de la mémoire tampon est maintenant . ASSWORD_01

<< unindent line (un no-op, puisque la ligne n'est pas en retrait) et déplacez le curseur vers la 1ère colonne

a

C-X commencer le mot complet

C-V complet avec ex commande

C-V 9 fois plus sélectionne l'entrée Print

C-3 retour au mode normal

XXXxx supprime rint 

< < retour à la colonne 1

ssupprimer ., lancer le mode insertion

e c C-X C-Vfin de la commande ex encore une fois, entrée echodéjà sélectionnée à cause du eci que je viens de taper

space C-3 contenu de la mémoire tampon maintenant echo PASSWORD_01

Z Z enregistrer le tampon, fermer vim, bash exécute le contenu du fichier, c.-à-d. echo PASSWORD_01

À propos: C-3a beaucoup de frères utiles: C-Jis Enter, C-Iis Tab, C-His Backspace, C-2is C-@(ie un octet nul). Et pour les utilisateurs d’Emacs, il est bon de savoir que le Escapesuivi d’une autre clé équivaut à Alt+ cette clé. Donc, même sans Escapeet Altvous pouvez toujours taper Meta-x comme ceci:C-3x

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

( ^clé utilisée, 3 façons)

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

• Valable si l'exécution en tant que commande système est qualifiée de "sortie".

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

• Valable si je suis autorisé à utiliser des commandes externes / OS. (Courez ici)

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

• Valable si je peux exécuter Perl via le système. (Run here) <- celui-ci utilise printau lieu dedie

Les scripts utilisent l'opérateur XOR de chaîne au niveau du bit de Perl ^, qui effectue un XOR sur les bits de caractères des deux chaînes. Cela me permet de recréer les caractères manquants pour PASSWORD_01 et de créer les caractères pour la commande système.

J'ai fait les trois variantes en fonction de la clémence des règles. Je suppose que puisque les variantes 2 et 3 affichent les mots sur Ideone, les solutions sont valables. J'ai enlevé la petite histoire que j'avais ici depuis que je pensais que personne ne la lirait, mais vous pouvez la lire dans les modifications si vous êtes curieux!

Code oOo (300)

QwerTaSdfGzxCqwertAsDfgZxCQwerTasDfgZxcQweRtaSDfgZxCqwertAsDFgZXcQWeRtaSdFGzxcQwERTasdfGzxc
QwErtAsdFgzxcqWeRtaSdFGzxcQweRtaSDfGZxCqWErTAsDFgZXCqWerTasDfgZxcQweRtaSdfGzxCQwErTAsDFgZXC
qWertAsDfgzxcQwERtASdFGzXcqWeRTasdFGzXcQWeRtAsDfgzxcQwERtASdFGzXCqWerTaSDfgzXcQWErTaSdFgZxc
QwertaSdFgzXcQWertASdFgZXCq

Facile. (Les sauts de ligne sont facultatifs, et juste ici pour rendre le code "plus lisible") Générateur de code utilisé:

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

Le même code dans un encodage moins idiot:

EeeeEeEeeEeeEeeeeeEeEeeEeEEeeeEeeEeeEeeEeeEeeEEeeEeEeeeeeEeEEeEEeEEeEeeEeEEeeeEeEEEeeeeEeee
EeEeeEeeEeeeeeEeEeeEeEEeeeEeeEeeEEeEEeEeEEeEEeEEeEEEeEeeEeeEeeEeeEeeEeeEeeEeeEEeEeEEeEEeEEE
eEeeeEeEeeeeeEeEEeEEeEEeEeeEeEEeeeEEeEeEEeEeEeEeeeeeEeEEeEEeEEeEEeEeeEeEEeeeEeEEEeEeEeEeEee
EeeeeeEeEeeEeEEeeeEEeEeEEEe

ferNANDo, 179 + 10 = 189 octets

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

Essayez-le en ligne!

Enterutilisé. J'utiliserais 0et 1pour rendre le code plus lisible mais je ne peux pas l'utiliser 0.

JS-Forth, 103 octets

La chaîne sera renvoyée sur la pile sous la forme d'un tableau de caractères.

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

Essayez-le en ligne - Version commentée

Explication:

J'ai d'abord trouvé la liste des mots autorisés . Les seules choses utiles que je pourrais utiliser seraient:

• 12345 Constantes numériques
• << Maj gauche
• >> Décaler à droite
• s>f Push single to float stack
• f>d Pop double de la pile float
• fsqrt Racine carrée sur pile flottante

Donc, je pourrais utiliser des constantes numériques, bit-shift et calculer une racine carrée en utilisant ce qui suit ( >>remplace drop, déplace en 0pour supprimer le 0):

s>f fsqrt f>d >>

Heureusement, j'ai trouvé des décalages minimes possibles pour chaque constante que je devais créer qui était plus courte que celle utilisant des racines carrées. Dans la plupart des cas, j'ai cherché en imprimant simplement chaque chiffre au carré, ou une plus grande puissance de deux si l'un d'entre eux contenait un chiffre 6-0. Ensuite, j'ai réalisé que je pouvais utiliser la perte de précision de f>dpour trouver plus de possibilités. (Je pourrais ajouter au nombre, mais obtenir toujours la même racine carrée entière.) Un peu plus tard, j'ai commencé à utiliser le transfert de bits pour trouver certaines constantes, puis toutes. Plus le >>décalage de bit est important, plus je peux ajouter au "nombre magique" et obtenir toujours le même résultat. J'ai donc trouvé les moindres décalages possibles pour obtenir les résultats nécessaires. Même les nombres peuvent parfois utiliser <<, les cotes ont dû utiliser >>.

Code commenté ( \commence un commentaire):

\ 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'a pas les mots <<ou >>. Au lieu de cela il a lshiftet rshift, que je ne pouvais pas utiliser .

Décimal , 190 180 + 10 = 190 octets

12055D12025D41D301212055D12010D41D301212055D12025D41D12003D41D30130112004D41D301212055D12024D41D30112003D41D301212055D12013D41D301212055D12040D41D301212045D12003D41D30112001D41D301

Essayez-le en ligne! Decimal est un langage ésotérique qui n'utilise que des décimales et la lettre D. Cependant, j'avais besoin de la pénalité de +10 car presque toutes les commandes sont utilisées 0.

Heureusement, toutes les commandes nécessaires pour imprimer PASSWORD_01ne nécessitent pas de chiffres 6:

• 12...D - pousser un personnage
• 2 - Pop une valeur
• 41D - pop top deux valeurs de pile, multiplier et pousser le résultat
• 301 - print DSI (index de pile par défaut)

En appuyant à plusieurs reprises sur des valeurs de caractère qui utilisent uniquement les chiffres 1 à 5, puis en les ajoutant, je peux créer les valeurs de caractère de chaque lettre PASSWORD_01.

Ungolfed et commenté:

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

Espace blanc , score: 111 (101 octets + 10 pour 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]

Lettres S(espace), T(tabulation) et N(nouvelle ligne) ajoutées uniquement en surbrillance.
[..._some_action]ajouté comme explication seulement.

Essayez-le en ligne (avec des espaces bruts, des onglets et des nouvelles lignes uniquement).

Explication en pseudo-code:

Cette solution est plus courte que la réponse existante dans l’ espace blanc ( @ n̴̖̋h̷͉̃ah̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ m’a demandé de l’afficher sous forme de réponse séparée lorsque je l’ai proposée en tant que golf) en utilisant cette astuce de 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 constante 80a été générée avec ce programme Java , que j'ai créé et utilisé pour certaines de mes précédentes réponses à Whitespace.

Stax , 91 + 10 octets

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

Essayez-le en ligne!

Utilise ]pour faire des singletons.

Explication

Voyons comment "P"est généré et comment "ASSW"est ajouté sans utiliser l'habituel +.

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

Les autres ne font que répéter le même tour.

"a"EEE$"$"a$Re]Réchange les chiffres de "a"ou [97]pour faire [79]ou "O"et les ajoute à la chaîne.

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

"$""a"EEEd$"$""5"Re]Rutilise à "a"nouveau pour obtenir "9"et élimine le "7", puis combine le "9"avec un littéral "5"pour former [95]ou "_", et l'ajoute à la chaîne.

"$"1 !$R obtient un zéro par pas logique de 1 et l'ajoute à la chaîne.

"$""1"Rajoute la finale "1"et nous avons terminé.

Sortie implicite.

brainfuck , 400 + 10 ( +) = 410 octets

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

Essayez-le en ligne!

Code machine MS-DOS .COM 8086 (72 octets)

Le temps est précieux, alors ne perdez pas votre temps avec les compilateurs ou les interprètes! Ouvrez simplement votre éditeur de texte et tapez ce qui suit (remplacez \tpar TAB):

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

En tant qu'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$

Enregistrez en tant que fichier .COM et exécutez-le pour enregistrer le jour.

Le code suppose certaines valeurs de départ pour les registres et risque donc de ne pas fonctionner pour tous les types de DOS. Espérons juste que quelqu'un risque d'être viré en n'achetant pas IBM.

Représentation légèrement plus compréhensible:

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 octets

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

Essayez-le en ligne!

La pénalité de 10 octets concerne l'utilisation de la ,clé (vous ne savez pas pourquoi cela ne pourrait pas être accompli avec Shift+ <, mais cela semble être la règle). Et bien que la source soit techniquement de 40 caractères, les trois ·caractères apportent trois octets supplémentaires en raison de leur codage UTF-8.

05AB1E , 87 86 octets

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

Essayez-le en ligne!

Peut-être le plus long code 05AB1E?

Malheureusement, le langage ne supporte pas des choses comme "Q"<"décrémenter Q pour obtenir P"

Ma clé supplémentaire est le V.

Merci à Kevin Cruijssen pour -1 octet.

Code:

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 

À titre de comparaison: la manière la plus rapide d’imprimer "PASSWORD_01" est de 6 octets de long.

Essayez-le en ligne!

Emacs, 26 octets (éventuellement + 10 = 36 ou - 2 = 24)

La clé supplémentaire qui est nécessaire dans cette réponse est Esc . Ceci est sur la moitié du clavier qui est encore intact, mais n'est pas mentionné dans la question pour une raison quelconque, donc pourrait ou ne pourrait pas donner une pénalité au score. ( Escet Altsont équivalents dans Emacs; Altest également sur la moitié intacte du clavier, mais n'est pas mentionné dans la question, mais doit être maintenu plutôt que tapoté afin que je ne puisse pas l'utiliser comme clé supplémentaire. Cela économiserait deux octets. , cependant, car il a un encodage plus court que le Escfait.)

Le programme lui-même (les virgules délimitent les limites entre les octets au format on-the-wire utilisé par Emacs pour accepter ses entrées):

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

Encodage en octets bruts pour prouver le nombre d'octets:

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

(Remarque: certains détails peuvent varier en fonction de la configuration d’Emacs; cette réponse nécessite quoted-char-radix soit défini sur 16 et qu’Emac utilise le dictionnaire de vérification orthographique qui est celui par défaut sur mon système britannique, anglais. paramètres de configuration raisonnables, mais il est possible que votre copie d’Emacs soit configurée différemment. Un dictionnaire différent donnerait tout de même un programme de 26 octets, mais des fautes d’orthographe légèrement différentes devront peut-être être utilisées pour que les corrections souhaitées puissent être acceptées par clés non affectées par balle.)

Explication

Je ne sais pas si cela devrait avoir une influence sur les guerres de l'éditeur, mais Emacs semble battre vim au moins dans le cas de cette question. Emacs est assez bien adapté au golf éditeur mesuré en octets, car il repose fortement sur des accords prenant plusieurs pressions de touche mais un seul octet (ainsi, un programme Emacs est souvent plus lent à taper que le programme Vim équivalent, mais plus court sur disque). En outre, la plupart des commandes Emacs les plus importantes se trouvent dans le coin inférieur gauche du clavier, pour être proche deCtrl très utile pour une question comme celle-ci.

"Vous pouvez supposer que l'éditeur d'interpréteur / source d'interprète est ouvert avant l'entrée des puces. Malheureusement, vous n'avez rien écrit avant le clavier.", Je suppose donc qu'un fichier vide est ouvert dans Emacs et besoin de taper le mot de passe dedans. (Nous aurions besoin de sauvegarder le fichier par la suite, et probablement de quitter Emacs, mais les octets correspondants ne sont pas comptés dans les réponses des autres personnes, donc je ne les compte pas ici non plus. C’est tout à fait réalisable d’utiliser le côté gauche du clavier, cependant, Ctrl- X, Ctrl- S, Ctrl- X,Ctrl - C.)

En prenant une commande (ou un bloc de commandes similaires) à la fois:

• W, S : Entrez WSdans le document.
• Esc, $: Invoque le correcteur orthographique. WSCe n'est pas un vrai mot, mais il trouve beaucoup de mots similaires à deux lettres.
• D: En utilisant le correcteur orthographique, corrigez WS à PS. (Lorsque le correcteur orthographique est appelé à l'aide de Alt- $, comme cela est arrivé ici ( Escet Altéquivaut à Emacs), il ne vérifie qu'un mot, il est donc désactivé après l'avoir fait.)
• A: insérer A, donner PSA.
• Ctrl- T: échanger les deux personnages précédents en donnant PAS.
• S, R , W, D: Type SRWD, donnant PASSRWD.
• Esc, $, 5: Nous invoquons à nouveau le correcteur orthographique, parce que nous voulons corriger notre mal orthographiéPASSRWD dans PASSWORD. Notez que nous ne pouvons pas lui demander de deviner le mot que nous voulons lors de notre premier essai, comme il le ferait avec PASSWRD, car la clé pour accepter le mot réel le plus proche est celle sur 0laquelle nous ne pouvons pas appuyer. En conséquence, la faute d’orthographe légèrement plus extrême PASSRWDest utilisée pour pousser le mot que nous voulons en position 5, où nous pouvons l’accepter.
• Ctrl- Q,5 , f: Insérer le caractère avec le code de caractère U + 5f, à savoir _. Le document se lit maintenant PASSWORD_(ou le sera lorsque nous commencerons à taper la commande suivante; avant cela, le trait de soulignement n'apparaît pas si nous saisissons un autre chiffre hexadécimal).
• Ctrl- X, r,Ctrl - Space, 1: Conservez la position du curseur ( par rapport au début du fichier) dans le registre 1. Pour une raison bizarre, c'est 1-indexé, donc (après avoir écrit 9 caractères jusqu'à présent) le curseur est à la position 10.
• Ctrl- X, r,g , 1: Copiez le contenu du registre 1 dans le document. Il se lit maintenant PASSWORD_10.
• Ctrl-T : Permutez les deux caractères avant le curseur. Nous avons maintenant PASSWORD_01, comme la question demande.

Si nous en avons le droit Alt, nous pouvons probablement coder la commande "invoke spellchecker" sous forme d'octet unique a4plutôt que de l'épeler de la manière suivante 1b 24: il apparaît deux fois, ce qui conduit à deux octets d'économies. (La plupart des terminaux modernes utilisent1b 24 comme codage Alt- $pour éviter les conflits avec UTF-8, mais lea4 codage est également rencontré de temps en temps, parfois disponible en tant qu'option de configuration.)

Les économies d’octets possibles impliquent probablement des erreurs d’orthographe chez les golfeurs. PSASWRDserait un octet plus court à taper, mais malheureusement, le correcteur orthographique ne semble pas capable d’en glaner PASSWORDcela, PASSRWDc’est la meilleure approche que j’ai trouvée jusqu’à présent. L’approche de gagner basée sur les registres 10est également ridiculement lourde, mais il n’existe pas beaucoup de façons de créer des nombres à partir de nulle part dans Emacs, et .)0 c’est un personnage pénible à obtenir autrement. (Au moins, il y avait quelques coïncidences incroyablement utiles: le curseur arrive en fin de course 10, ce qui contient un0 , si nécessaire, et le fait qu'Emacs accepte le redondantg opération de registre pour insérer le contenu d'un registre dans le document. , en plus du plus intuitifi