Su desafío es leer una "contraseña" desde el teclado / entrada estándar.

Desafío :

• Leer una cadena de forma sinvisible.
• Para cada uno de los personajes s, imprima un personaje c.
• En tiempo real.

Reglas:

• Debe imprimir cen tiempo real. Tan pronto como el usuario ingrese un carácter, debe mostrarlo c.
• c debe ser constante, es decir, debe ser el mismo personaje.
• cpuede ser cualquier carácter visible (es decir, no puede ser una nueva línea, espacio, tabulación o no imprimible).
• cno puede basarse s, es decir, cdebe definirse / ser constante antes de sleerse.
• c debe ser el mismo cada vez que se ejecuta el programa.
• cpuede ser uno de los personajes ssi por accidente, siempre que se sigan todas las demás reglas.
• Ninguno de los caracteres de spuede aparecer en la pantalla, cexcepto (ver la regla anterior).
• Puede usar cualquier método razonable de entrada y salida siempre que se sigan todas las demás reglas.
• Puede suponer que la longitud de snunca es más larga que el ancho de la ventana terminal / gráfica.
• Si usa una terminal, su programa debe finalizar después de ingresar una nueva línea o EOF.

Ejemplo :

Si sfue password01y cfue *, la salida se vería así:

Ganador :

La presentación más corta en cada idioma gana.

str , 5 bytes

n=?,1

Debido a un error, esto es de 5 bytes. Debe ser solo 1 byte:

1

HTML, 20 bytes

<input type=password

Alternativa: HTML + JavaScript, 51 bytes

Aunque el OP ha confirmado que es válido, ¡aquí hay una solución con JS para los puristas!

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

Vim, 36 bytes:

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

Utiliza la notación vim-key , por lo que <C-v>es control-v , <CR>enter, <esc>es la tecla escape y <tab>es la tecla tab.

c es '0'.

Aquí hay un hexdump para demostrar que el recuento de bytes es preciso:

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

Esto funciona ejecutando los siguientes dos comandos ex:

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

El primero significa

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

Y el segundo significa

: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

Rubí con zapatos, 29 personajes

Shoes.app{edit_line secret:1}

Salida de muestra:

Aceto , 8 7 6 bytes

,!`XpO

Explicación:

Leer un carácter ( ,), negarlo (! ) y salir condicionalmente. Imprima el cero en la parte superior de la pila ( p) y vuelva al principio.

Corre con -F para ver el efecto de inmediato (porque enjuague)

Mi primera solución se basó en la publicación de sandbox, con espacios permitidos como caracteres de reemplazo y sin necesidad de salir al ingresar (4 bytes):

,'p>

C en POSIX, 128 117 113 96 bytes

^{-11 gracias a Quentin buscando a través de termios.h
-4 gracias a Quentin señalando mis estúpidos errores
-17 porque Quentin es un maldito mago.}

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

Esto pone a STDIN en modo sin procesar / invisible para que pueda presionar las teclas en tiempo real. Esto toma 77 bytes y estoy seguro de que puedo jugarlo un poco. Tenga en cuenta que esto no restablece STDIN al salir, por lo que dañará su terminal si no lo hace manualmente.

Así es como puede restablecer STDIN:

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

Salida como se muestra en el GIF :-)

Código de máquina x86 en MS-DOS: 14 bytes

Como de costumbre, este es un archivo COM completo, que se puede ejecutar en DosBox, más la mayoría de las variantes de DOS.

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

Asamblea comentada:

    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 bytes

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

^{Solo funciona en windows}

AHK , 17 bytes

InputBox,o,,,HIDE

Los empotrados no son interesantes.

Java 5-8, 125 122 131 124 bytes

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

Sin golf:

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

Resultado:

Crédito:

-3 @MD XF (señaló mi estúpido error con String[]args)

-7 @KritixiLithos (señalado public classpuede ser simplemente class)

Mathematica 34 bytes

 InputString["",FieldMasked->True];

Aparece un solo asterisco, después de ingresar cada carácter. Las comillas vacías corresponden al título que aparece en la ventana emergente de entrada.

Esto ;evita que se imprima la contraseña.

Vim, 58 50 52 50 bytes

Agregado para asegurarse de que maneja los espacios correctamente.

Gracias a @DJMcMayhem por un montón de ayuda e ideas

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

En la sintaxis típica de la clave Vim a continuación. Los caracteres marcados como con a ^son Ctrl+<char>, entonces ^Q=Ctrl+q

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

No hay un enlace TIO, ya que necesitaría ingresar directamente a Vim (en lugar de ingresar previamente como de costumbre). Para ejecutar el código, debe escribirlo en Vim, y luego puede escribir su contraseña y presionar enter. No hará nada con la contraseña. Ni siquiera sabrá lo que era. Tan pronto como pulses, entra en la ventana de Vim:q!

Esto funciona asignando todos los ASCII imprimibles *en modo de inserción y asignando <CR>a<ESC>:q!<CR>

FLTK, 47 caracteres

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

Ejecución de muestra:

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 

Salida de muestra:

Procesamiento, 53 bytes

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

Esto toma la entrada mediante pulsaciones de teclas desde una ventana gráfica. El carácter con el que elige representar las contraseñas es 0. Tenga en cuenta que debido a la alta velocidad de fotogramas, cada pulsación de tecla aparecerá como múltiples 0s (y también debido al hecho de que esto es keyPressedy no keyTyped(no es un valor booleano) o keyrelease).

Bash , 54 bytes

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

Para fines de puntuación, $'\r' se puede reemplazar con un retorno de carro literal.

Pruébalo en línea! (no hay mucho que ver)

ZX81 BASIC, 54 bytes

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

En el conjunto de caracteres ZX81, los caracteres imprimibles están en el espacio de rango Z, aunque en realidad no puede ingresar un espacio de esta manera, ya que es el carácter de corte.

ZX Spectrum BASIC, 24 bytes

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

Tenga en >=cuenta que cuenta como una palabra clave de un solo byte en Sinclair BASIC (punto de código 140 en este caso).

R, 29 bytes

invisible(openssl::askpass())

Incorporado que maneja las entradas de contraseña. Abre una nueva ventana y reemplaza la entrada con puntos. invisiblese usa para suprimir la impresión de la contraseña en STDOUT.

Tcl / Tk, 18

gri [ent .e -sh *]

Debe ejecutarse en el shell interactivo (o tener abreviaturas habilitadas):

Vim, 15 pulsaciones de teclas

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

<S-tab>significa shift + tab.

Aparentemente, hay una construcción para esto de la que no estaba al tanto. Como realmente me gusta mi respuesta manual , y este enfoque es radicalmente diferente, pensé que debería publicar una nueva respuesta en lugar de editarla.

Esto funciona llamando a la inputsecretfunción, luego se cierra inmediatamente después de que sale.

Código de máquina 6502 (C64), 22 21 bytes

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

Uso :SYS 2062

Lista de desmontaje comentada (ACME), puede descomentar las tres primeras líneas comentadas para iniciar RUNuna vez cargadas:

!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

Comentarios:

• No he encontrado nada en los documentos, pero parece que, después de la llamada GETIN, beq se ramifica solo donde no se han registrado nuevas pulsaciones de teclas;
• Usando # $ 60 como salida de caracteres, ese byte se puede reutilizar como instrucción "rts" cuando se presiona RETURN.

Adelante (gforth) , 54 bytes

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

Explicación

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 bytes

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

Muestra un 1para cada personaje, finaliza al cerrar la ventana (OP dijo que está permitido).

Groovy, 77 73 bytes

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

Este es un cierre anónimo, con 0 entradas requeridas.

Sin golf:

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

Editar 1 (-4 bytes): se puede acceder directamente al componente # visible, lea más aquí .

Micro , 35 bytes

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

expiración:

"": creo una nueva cadena en blanco 'i'
    {comenzar bucle de entrada
     L ingresa un caracter
      46c: \ display ascii char # 46 (.) (Aparece, dejando el carácter de entrada de 'L'
           i ~ +: presiono i, volteo yo y el char alrededor, los concateno y los guardo en i
                i10c = if (, a)} a OK, aquí sucede mucho, si un NL está en i, el ciclo termina y el i: \ final mostrará la entrada

BF, 24 bytes

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

Funciona con bf.doleczek.pl . Puede enviar un carácter cero al programa con Ctrl + Z.

Solución alternativa:

BF, 1 byte

,

Esta es una solución muy irónica. Mi terminal tiene 0 caracteres de ancho, así que no ingrese ninguna contraseña más larga que eso.

PowerShell, 12 bytes

Read-Host -a

Esto lee la entrada del host y, con el indicador -a, la trata como una cadena de seguridad / contraseña. En el ISE, aparece un cuadro de mensaje que tiene un comportamiento similar ya que el ISE no permite la captura de pulsaciones de teclas.

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

QBasic, 48 bytes

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

INPUT$(1)lee el siguiente caracter desde la entrada del teclado. (Esto puede incluir elementos como tabulación, retroceso y escape, pero dado que el OP no dijo nada sobre ellos, supongo que no tenemos que preocuparnos por ellos). Si el personaje es \r(ASCII 13), finalice el programa; de lo contrario, imprima *sin una nueva línea. Repetir hasta el infinito.

Perl + Bash, 30 bytes

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

ces decir *, utiliza readbash, por lo que no es una solución pura de Perl.

brainfuck, 21 bytes

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

El último, lo prometo. Sin entrada = -1, final de entrada = 0

Cómo funciona

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

Explicación

{            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