Seu desafio é ler uma "senha" da entrada padrão / teclado.

Desafio :

• Leia uma string sinvisivelmente.
• Para cada um dos caracteres sinseridos, imprima um caractere c.
• Em tempo real.

Regras:

• Você deve imprimir cem tempo real. Assim que o usuário digitar um caractere, você deverá exibir c.
• c deve ser constante, ou seja, deve ser o mesmo caractere.
• cpode ser qualquer caractere visível (ou seja, não pode ser uma nova linha, espaço, guia ou não imprimível).
• cnão pode ser baseado s, ou seja, cdeve ser definido / constante antes de sser lido.
• c deve ser o mesmo sempre que o programa for executado.
• cpode ser um dos personagens sse acidentalmente, desde que todas as outras regras sejam seguidas.
• Nenhum dos caracteres de spode aparecer na tela, cexceto (consulte a regra anterior).
• Você pode usar qualquer método razoável de entrada e saída, desde que todas as outras regras sejam seguidas.
• Você pode supor que o comprimento de snunca seja maior que a largura da janela do terminal / gráfico.
• Se estiver usando um terminal, seu programa deve terminar após a inserção de uma nova linha ou EOF.

Exemplo :

Se sfoi password01e cfoi *, a saída seria algo como:

Vencedor :

A submissão mais curta em cada idioma vence.

str , 5 bytes

n=?,1

Devido a um erro, são 5 bytes. Deve ter apenas 1 byte:

1

HTML, 20 bytes

<input type=password

Alternativa: HTML + JavaScript, 51 bytes

Embora o OP tenha confirmado que isso é válido, aqui está uma solução usando JS para os 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

Isso usa a notação de chave vim , assim <C-v>como control-v , <CR>é enter, <esc>é a chave de escape e <tab>é a tecla tab.

c é '0'.

Aqui está um hexdump para provar que a contagem de bytes é precisa:

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

Isso funciona executando os dois comandos ex a seguir:

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

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

E o 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

Rubi com sapatos, 29 caracteres

Shoes.app{edit_line secret:1}

Saída de amostra:

Aceto , 8 7 6 bytes

,!`XpO

Explicação:

Leia um caractere ( ,), negue-o ( !) e saia condicionalmente. Imprima o zero no topo da pilha ( p) e volte ao início.

Corra com -Fpara ver o efeito imediatamente (porque liberado)

Minha primeira solução foi baseada na postagem da sandbox, com espaços permitidos como caracteres de substituição e sem a necessidade de sair no enter (4 bytes):

,'p>

C no POSIX, 128 117 113 96 bytes

^{-11 graças a Quentin pesquisando termios.h
-4, graças a Quentin apontando meus erros estúpidos
-17 porque Quentin é um bruxo maluco.}

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

Isso coloca o STDIN no modo bruto / invisível para que você possa pressionar as teclas em tempo real. Isso leva 77 bytes e tenho certeza de que posso jogar um pouco. Observe que isso não reinicializa o STDIN ao sair, o que atrapalha o seu terminal se você não o fizer manualmente.

Veja como você pode redefinir o STDIN:

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

Saída conforme mostrado no GIF :-)

código de máquina x86 no MS-DOS - 14 bytes

Como de costume, este é um arquivo COM completo, que pode ser executado no DosBox, além da maioria das variantes do DOS.

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

Montagem 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*',

^{Funciona apenas no Windows}

AHK , 17 bytes

InputBox,o,,,HIDE

Built-ins não são interessantes.

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

Ungolfed:

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 (Apontou meu erro estúpido com String[]args)

-7 @KritixiLithos (apontado public classpode ser apenas class)

Mathematica 34 bytes

 InputString["",FieldMasked->True];

Um único asterisco é exibido após a digitação de cada caractere. As aspas vazias são para o título que aparece na janela de entrada pop-up.

Os ;impede que a senha a ser impresso.

Vim, 58 50 52 50 bytes

Adicionado para garantir que ele manipule os espaços corretamente.

Obrigado a @DJMcMayhem por um monte de ajuda e idéias

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

Na sintaxe típica da chave do Vim abaixo. Os caracteres marcados como com ^são Ctrl+<char>, então ^Q=Ctrl+q

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

Não há link TIO, porque você precisaria inserir diretamente no Vim (em vez de pré-inserir normalmente). Para executar o código, digite-o no Vim e digite sua senha e pressione enter. Não fará nada com a senha. Nem vai saber o que era. Assim que você pressionar Enter, a janela do Vim será exibida.:q!

Isso funciona mapeando todos os ASCII imprimíveis para *no modo de inserção e mapeando <CR>para<ESC>:q!<CR>

FLTK, 47 caracteres

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

Exemplo de execução:

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 

Saída de amostra:

Processando, 53 bytes

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

Isso leva a entrada através de pressionamentos de tecla em uma janela gráfica. O caractere que ele escolhe para representar as senhas é 0. Observe que, devido à alta taxa de quadros, cada pressionamento de tecla aparecerá como vários 0s (e também devido ao fato de ser keyPressede não keyTyped(não um booleano) ou keyrelease).

Bash , 54 bytes

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

Para fins de pontuação, $'\r'pode ser substituído por um retorno de carro literal.

Experimente online! (não há muito o que olhar)

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

No conjunto de caracteres ZX81, os caracteres imprimíveis estão no intervalo de espaço para Z, embora não seja possível inserir um espaço dessa maneira, pois é o caractere de interrupção.

ZX Spectrum BASIC, 24 bytes

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

Observe que >=conta como uma palavra-chave de byte único no Sinclair BASIC (neste ponto de código 140, neste caso).

R, 29 bytes

invisible(openssl::askpass())

Built-in que lida com entradas de senha. Abre uma nova janela e substitui a entrada por pontos. invisibleé usado para suprimir a impressão da senha em STDOUT.

Tcl / Tk, 18

gri [ent .e -sh *]

Deve ser executado no shell interativo (ou ter abreviações ativadas):

Vim, 15 pressionamentos de tecla

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

<S-tab>meios shift + tab.

Aparentemente, existe um componente para isso que eu não estava ciente. Como eu realmente gosto da minha resposta manual e essa abordagem é radicalmente diferente, achei que deveria postar uma nova resposta em vez de editá-la.

Isso funciona chamando a inputsecretfunção e saindo imediatamente depois que ela sai.

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 desmontagem comentada (ACME), você pode descomentar as três primeiras linhas comentadas para iniciar RUNuma vez carregadas:

!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

Comentários:

• Não encontrei nada nos documentos, mas parece que, após a chamada GETIN, o beq se ramifica apenas onde nenhuma nova tecla foi gravada;
• Usando # $ 60 como char de saída, esse byte pode ser reutilizado como instrução "rts" quando RETURN é pressionado.

Quarto (gforth) , 54 bytes

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

Explicação

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

Exibe um 1para cada caractere e termina ao fechar a janela (o OP disse que é permitido).

Groovy, 77 73 bytes

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

Este é um fechamento anônimo, com 0 entradas necessárias.

Ungolfed:

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

Editar 1 (-4 bytes): O componente # visível pode ser acessado diretamente, leia mais aqui .

Micro , 35 bytes

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

explicação:

"": eu crio uma nova string em branco 'i'
    {iniciar loop de entrada
     L insere um caractere
      46c: \ display char ascii # 46 (.) (É exibido, deixando o char de entrada de 'L'
           i ~ +: eu empurro i, inverto eu e o caractere, concato-os e guardo isso para i
                i10c = se (, a)} um OK, muita coisa acontece aqui, se um NL estiver em i, o loop termina e o i: \ final exibirá a entrada

BF, 24 bytes

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

Funciona com bf.doleczek.pl . Você pode enviar um caractere zero para o programa com Ctrl + Z.

Solução alternativa:

BF, 1 byte

,

Esta é uma solução muito explícita. Meu terminal tem 0 caracteres , portanto, não digite senhas maiores que isso.

PowerShell, 12 bytes

Read-Host -a

Isso lê a entrada do host e, com o sinalizador -a, trata-a como uma proteção / senha. No ISE, aparece uma caixa de mensagem com um comportamento semelhante, pois o ISE não permite a captura de teclas.

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

QBasic, 48 bytes

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

INPUT$(1)lê o próximo caractere da entrada do teclado. (Isso pode incluir coisas como tab, backspace e escape, mas como o OP não disse nada sobre eles, presumo que não tenhamos que nos preocupar com eles.) Se o personagem for \r(ASCII 13), encerre o programa; caso contrário, imprima *sem uma nova linha. Repita ad infinitum.

Perl + Bash, 30 bytes

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

cé *, usa readdo bash, então não é uma solução Perl pura.

brainfuck, 21 bytes

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

Último, eu prometo. Sem entrada = -1, final da entrada = 0

Como 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

Explicação

{            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