Votre défi est de lire un "mot de passe" à partir du clavier / entrée standard.

Défi :

• Lisez une chaîne de manière sinvisible.
• Pour chacun des caractères de s, imprimez un caractère c.
• En temps réel.

Règles:

• Vous devez imprimer cen temps réel. Dès que l'utilisateur entre un caractère, vous devez afficher c.
• c doit être constant, c'est-à-dire qu'il doit être du même caractère.
• cpeut être n'importe quel caractère visible (c'est-à-dire qu'il ne peut pas s'agir d'une nouvelle ligne, d'un espace, d'une tabulation ou non imprimable).
• cne peut pas être basé sur s, c'est-à-dire cdoit être défini / constant avant d' sêtre lu.
• c doit être le même à chaque exécution du programme.
• cpeut être l'un des personnages ssi par accident, tant que toutes les autres règles sont respectées.
• Aucun des caractères de ne speut apparaître à l'écran, csauf (voir règle précédente).
• Vous pouvez utiliser toute méthode raisonnable d'entrée et de sortie tant que toutes les autres règles sont respectées.
• Vous pouvez supposer que la longueur de sn'est jamais plus longue que la largeur du terminal / de la fenêtre graphique.
• Si vous utilisez un terminal, votre programme doit se terminer après la saisie d'une nouvelle ligne ou EOF.

Exemple :

Si sétait password01et cétait *, la sortie ressemblerait à quelque chose comme:

Gagnant :

La soumission la plus courte dans chaque langue l'emporte.

str , 5 octets

n=?,1

En raison d'un bug, cela fait 5 octets. Il ne doit contenir qu'un octet:

1

HTML, 20 octets

<input type=password

Alternative: HTML + JavaScript, 51 octets

Bien que l'OP l'ait confirmé pour être valide, voici une solution utilisant JS pour les puristes!

<input id=i oninput=i.value=i.value.replace(/./g,8)

Vim, 36 octets:

:im <C-v><CR> <C-v><esc>ZQ<CR>:au I<tab><tab> * let v:char=0<CR>i

Cela utilise la notation vim-key , tout <C-v>comme control-v , <CR>est enter, <esc>est la touche d'échappement et <tab>est la touche de tabulation.

c est '0'.

Voici un hexdump pour prouver que le nombre d'octets est précis:

00000000: 3a69 6d20 160a 2016 1b5a 510a 3a61 7520  :im .. ..ZQ.:au 
00000010: 4909 0920 2a20 6c65 7420 763a 6368 6172  I.. * let v:char
00000020: 3d30 0a69                                =0.i

Cela fonctionne en exécutant les deux commandes ex suivantes:

:imap <CR> <esc>ZQ
:autocmd InsertCharPre * let v:char=0

Le premier signifie

:imap               " Anytime the following is pressed in insert mode:
      <CR>          "   (the 'enter' key)
           <esc>ZQ  " Then act as if the user instead pressed '<esc>ZQ' (close the buffer)

Et le second signifie

:autocmd                                " Automatically as vim runs:
         InsertCharPre                  "   Any time the user is about to insert a char
                       *                "   In any type of file
                         let v:char=0   "     Then instead insert a '0' character

Rubis avec des chaussures, 29 caractères

Shoes.app{edit_line secret:1}

Exemple de sortie:

Aceto , 8 7 6 octets

,!`XpO

Explication:

Lisez un caractère ( ,), annulez-le ( !) et quittez conditionnellement. Imprimez le zéro en haut de la pile (p ) et revenez au début.

Courez avec -Fpour voir l'effet immédiatement (car rinçage)

Ma première solution était basée sur la publication sandbox, avec des espaces autorisés comme caractères de remplacement et pas besoin de quitter en entrant (4 octets):

,'p>

C sur POSIX, 128 117 113 96 octets

^{-11 grâce à Quentin en cherchant termios.h
-4 grâce à Quentin soulignant mes erreurs stupides
-17 parce que Quentin est un sorcier flippant.}

c,t[15];f(){for(tcgetattr(1,t),t[3]&=~10,tcsetattr(1,0,t);(c=getchar())^10&&c^4;)printf(".");}

Cela met STDIN en mode brut / invisible afin qu'il puisse obtenir des pressions de touches en temps réel. Cela prend 77 octets et je suis sûr que je peux y jouer un peu. Notez que cela ne réinitialise pas STDIN à la sortie, donc cela gâchera votre terminal si vous ne le faites pas manuellement.

Voici comment réinitialiser STDIN:

void stdin_reset(void)
{
    struct termios t;
    get_stdin(&t);
    t.c_lflag |= ECHO;
    t.c_lflag |= ICANON;
    set_stdin(&t);
}

Sortie comme indiqué dans le GIF :-)

code machine x86 sur MS-DOS - 14 octets

Comme d'habitude, il s'agit d'un fichier COM complet, qui peut être exécuté sur DosBox, ainsi que la plupart des variantes DOS.

00000000  b4 08 b2 2a cd 21 80 f4  0a 3c 0d 75 f7 c3        |...*.!...<.u..|
0000000e

Montage commenté:

    org 100h

section .text

start:
    mov ah,8h       ; ah starts at 08h (read console, no echo)
    mov dl,'*'      ; write asterisks (we could have left whatever
                    ; startup value we have here, but given that dx=cs,
                    ; we have no guarantee to get a non-zero non-space
                    ; value)
lop:
    ; this loop runs twice per character read: the first time with
    ; ah = 08h (read console, no echo syscall), the second time with
    ; ah = 02h (write console); a xor is used to switch from one
    ; mode to the other
    int 21h         ; perform syscall
    xor ah,0ah      ; switch syscall 08h <=> 02h
    cmp al,0dh      ; check if we read a newline (if we wrote stuff
                    ; we are just checking the last value read, so
                    ; no harm done; at the first iteration al starts
                    ; at 0, so no risk here)
    jne lop         ; loop if it wasn't a newline
quit:
    ret             ; quit

Python 2 , 50 octets

from msvcrt import*
while'\r'!=getch():print'\b*',

^{Fonctionne uniquement sur les fenêtres}

AHK , 17 octets

InputBox,o,,,HIDE

Les intégrés ne sont pas intéressants.

Java 5-8, 125 122 131 131 124 octets

class X{public static void main(String[]a){new java.awt.Frame(){{add(new javax.swing.JPasswordField());setVisible(1>0);}};}}

Non golfé:

class X{
    public static void main(String[]a){
        new java.awt.Frame(){
            {
                add(new javax.swing.JPasswordField());
                setVisible(1>0);
            }
        };
    }
}

Résultat:

Crédit:

-3 @MD XF (A souligné ma stupide erreur avec String[]args)

-7 @KritixiLithos (souligné public classpeut être juste class)

Mathematica 34 octets

 InputString["",FieldMasked->True];

Un seul astérisque apparaît, après la saisie de chaque caractère. Les guillemets vides correspondent au titre qui apparaît dans la fenêtre de saisie contextuelle.

Le ;empêche le mot de passe d'être imprimé.

Vim, 58 50 52 50 octets

Ajouté pour s'assurer qu'il gère correctement les espaces.

Merci à @DJMcMayhem pour un tas d'aide et d'idées

i:im 32 *Y94pVGg
kWcW<Space>
:im 
 ZQ
dG@"qi

Dans la syntaxe de clé Vim typique ci-dessous. Les caractères marqués comme avec un ^sont Ctrl+<char>, donc ^Q=Ctrl+q

i:im ^V^V32 *^[Y94pVGg^A
kWcW<Space>^[
:im ^V
 ZQ
dG@"qi

Il n'y a pas de lien TIO, car vous auriez besoin d'entrer directement dans Vim (par opposition à la pré-entrée comme d'habitude). Pour exécuter le code, vous devez le saisir dans Vim, puis vous pouvez taper votre mot de passe et appuyer sur Entrée. Il ne fera rien avec le mot de passe. Il ne saura même pas ce que c'était. Dès que vous appuyez sur Entrée, la fenêtre Vim:q!

Cela fonctionne en connectant tous ASCII imprimables pour *en mode d'insertion et la cartographie <CR>à<ESC>:q!<CR>

FLTK, 47 caractères

Function{}{}{Fl_Window{}{}{Fl_Input{}{type 5}}}

Exemple d'exécution:

bash-4.4$ fluid -c password.fl

bash-4.4$ fltk-config --compile password.cxx 
g++ -I/usr/include/cairo -I/usr/include/glib-2.0 -I/usr/lib/x86_64-linux-gnu/glib-2.0/include -I/usr/include/pixman-1 -I/usr/include/freetype2 -I/usr/include/libpng16 -I/usr/include/freetype2 -I/usr/include/cairo -I/usr/include/glib-2.0 -I/usr/lib/x86_64-linux-gnu/glib-2.0/include -I/usr/include/pixman-1 -I/usr/include/freetype2 -I/usr/include/libpng16 -g -O2 -fPIE -fstack-protector-strong -Wformat -Werror=format-security -fvisibility-inlines-hidden -D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE -D_THREAD_SAFE -D_REENTRANT -o 'password' 'password.cxx' -Wl,-Bsymbolic-functions -fPIE -pie -Wl,-z,relro -Wl,-z,now -Wl,--as-needed -lfltk -lX11

bash-4.4$ ./password 

Exemple de sortie:

Traitement, 53 octets

String a="";void draw(){text(keyPressed?a+=0:a,9,9);}

Cela prend l'entrée via des touches à partir d'une fenêtre graphique. Le caractère avec lequel il choisit de représenter les mots de passe est 0. Notez qu'en raison de la fréquence d'images élevée, chaque pression sur une touche apparaîtra comme plusieurs 0s (et également en raison du fait que c'est keyPressedet non keyTyped(pas un booléen) ou keyrelease).

Bash , 54 octets

while read -eN1 c 2>&-;[[ ${c/$'\r'/} ]];do printf X;done

À des fins de notation, $'\r'peut être remplacé par un retour chariot littéral.

Essayez-le en ligne! (pas grand chose à regarder)

ZX81 BASIC, 54 octets

10 IF LEN INKEY$ THEN GOTO PI
30 IF NOT LEN INKEY$ THEN GOTO EXP PI
50 IF INKEY$>"Z" THEN STOP
70 PRINT "*";
90 GOTO PI

Dans le jeu de caractères ZX81, les caractères imprimables se trouvent dans l'espace de plage Z, bien que vous ne puissiez pas réellement saisir un espace de cette façon car c'est le caractère de rupture.

ZX Spectrum BASIC, 24 octets

10 PAUSE NOT PI: IF INKEY$>=" " THEN PRINT "*";:GOTO PI

Notez que cela >=compte comme un mot clé à un octet dans Sinclair BASIC (point de code 140 dans ce cas).

R, 29 octets

invisible(openssl::askpass())

Intégré qui gère les entrées de mot de passe. Ouvre une nouvelle fenêtre et remplace l'entrée par des points. invisibleest utilisé pour supprimer l'impression du mot de passe sur STDOUT.

Tcl / Tk, 18 ans

gri [ent .e -sh *]

Doit être exécuté sur dans le shell interactif (ou avoir des abréviations activées):

Vim, 15 frappes

:cal inp<S-tab>'')|q<cr>

<S-tab>signifie shift + tab.

Apparemment, il y a une fonction intégrée pour cela que je n'étais pas au courant. Comme j'aime vraiment ma réponse manuelle et que cette approche est radicalement différente, j'ai pensé que je devrais poster une nouvelle réponse au lieu de la modifier.

Cela fonctionne en appelant la inputsecretfonction, puis en quittant immédiatement après sa fermeture.

6502 code machine (C64), 22 21 octets

0e 08 20 9f ff 20 e4 ff f0 f8 c9 0d f0 01 a9 60 20 d2 ff 50 ed

Utilisation :SYS 2062

Liste de désassemblage commentée (ACME), vous pouvez décommenter les trois premières lignes commentées à lancer avec RUNune fois chargées:

!cpu 6502
!to "password2.prg",cbm
;* = $0801                               ; BASIC starts at #2049
;!byte $0d,$08,$dc,$07,$9e,$20,$32,$30   ; BASIC to load $c000
;!byte $36,$32,$00,$00,$00               ; inserts BASIC line: 2012 SYS 2062

    GETIN  =  $FFE4
    SCNKEY =  $FF9F
    CHROUT =  $FFD2

* = $080e
keyScan:
    jsr SCNKEY  ; get key
    jsr GETIN   ; put key in A

    beq keyScan ; if no key pressed loop    

    cmp #13     ; check if RETURN was pressed
    beq $081b   ; if true go to operand of next instruction (#$60 = rts)

    lda #$60    ; load char $60 into accumulator
    jsr CHROUT  ; print it

    bvc keyScan ; loop

Commentaires:

• Je n'ai rien trouvé dans la documentation, mais il semble que, après l'appel GETIN, beq ne branche que là où aucune nouvelle pression de touche n'a été enregistrée;
• En utilisant # $ 60 comme caractère de sortie, cet octet peut être réutilisé comme instruction "rts" lorsque vous appuyez sur RETURN.

Forth (gforth) , 54 octets

: f begin key dup 4 - swap 13 - * while ." *" repeat ;

Explication

begin      \ enters the loop
    key    \ waits for a single character as input, places ascii code of character on stack
    dup    \ duplicates the key value on the stack
    4 -    \ subtracts 4 from the key value (shorter way of checking for not equals)
    swap   \ swaps the top two stack values
    13 -   \ subtract 13 from the key value
    *      \ multiply top two stack values (shorter version of "and")
while      \ if top of stack is true, enter loop body, else exit loop
    ." *"  \ output *
repeat     \ go back to beginning of loop

Python 3 + tkinter- 63 61 octets

from tkinter import*
t=Tk();Entry(show=1).pack();t.mainloop()

Affiche un 1pour chaque caractère, se termine à la fermeture de la fenêtre (OP a dit que c'était autorisé).

Groovy, 77 73 octets

{new java.awt.Frame(){{add(new javax.swing.JPasswordField());visible=1}}}

Il s'agit d'une fermeture anonyme, avec 0 entrées requises.

Non golfé:

{
    new java.awt.Frame() {
        {
            add(new javax.swing.JPasswordField())
            visible=1
        }
    }
}

Édition 1 (-4 octets): le composant # visible est directement accessible, en savoir plus ici .

Micro , 35 octets

"":i{L46c:\
i~+:i
i10c=if(,a)}a
i:\

explication:

"": je crée une nouvelle chaîne vide 'i'
    {commencer la boucle d'entrée
     L saisir un caractère
      46c: \ display ascii char # 46 (.) (Il est sauté, laissant le caractère d'entrée de 'L'
           i ~ +: je pousse i, je retourne i et le caractère, je les concatène et je les stocke dans i
                i10c=if(,a)}a  OK, a lot happens here, if a NL is in i, the loop terminates, and the final i:\ will display the input

BF, 24 bytes

++++++[->++++++<],[>.<,]

Works with bf.doleczek.pl. You can send a zero char to the program with Ctrl+Z.

Alternative solution:

BF, 1 byte

,

This is a very tongue-in-cheek solution. My terminal is 0 characters wide, so please don't enter any passwords longer than that.

PowerShell, 12 bytes

Read-Host -a

This reads input from host and, with the -a flag treats it as a securestring/password. In the ISE it pops up a message box which has a similar behavior since the ISE doesn't allow keypress capture.

PS C:\Windows\system32> Read-Host -a
************

QBasic, 48 bytes

DO
a$=INPUT$(1)
IF ASC(a$)=13THEN END
?"*";
LOOP

INPUT$(1) reads the next character from keyboard input. (This can include things like tab, backspace, and escape, but since the OP didn't say anything about those I'll assume we don't have to worry about them.) If the character is \r (ASCII 13), terminate the program; otherwise, print * without a newline. Repeat ad infinitum.

Perl + Bash, 30 bytes

print"*"while$|=1+`read -sn 1`

c is *, uses read from bash, so isn't a pure Perl solution.

brainfuck, 21 bytes

-[+>,[<->+[<.>[-]]]<]

Last one, I promise. No input = -1, end of input = 0

How it Works

-[  Enters the loop
  +>, Get input
     [<->+ If not end of input it create the ÿ character and check if the input is not -1
          [<.>[-]]] If there was input, print the ÿ character. 
                    <] Exit the loop if end of input

QBIC, 44 bytes

{X=inkey$~X<>@`|~X=chr$(13)|_X\Y=Y+@*`_C?Y

Explanation

{            DO
X=inkey$     Read a char, set it to X$
             Note that INKEY$ doesn't wait for keypress, but simply sends out "" if no key was pressed.
~X<>@`|      IF X$ has a value THEN
~X=chr$(13)| IF that value is ENTER
_X           THEN END
\            ELSE
Y=Y+@*`      append a literal * to Y$
_C           Clear the screen
?Y           Display Y$ (having 1 * for each char entered)
             The IF's and the DO-loop are auto-closed at EOF{            DO