Em qualquer linguagem de programação, crie um programa que receba entrada e anime o texto que está sendo digitado no teclado.

O atraso entre cada caractere deve variar para simular a digitação verdadeira em um teclado. O atraso será de 0.1, 0.1, 0.5, 0.1, 0.1, 0.5 ...segundos, até que o último caractere seja impresso. A saída final deve ser deixada na tela.

Você deve substituir a linha de texto atual, para que o texto não seja impresso em novas linhas.

Exemplo, a entrada "Olá, PPCG! Adeus Terra!" deve resultar na seguinte animação (observe que a taxa de amostragem do criador de gifs foi baixa, portanto o resultado verdadeiro é um pouco diferente):

Como se trata de código de golfe, a menor quantidade de bytes ganha.

C 108 93 89 78 73 80 bytes

f(char *s){for(int i=0;s[i];fflush(0),usleep(100000*(i++%3?1:5)))putchar(s[i]);}

Versão não destruída:

 void f(char *s)
 {
  for( int i=0;s[i];)
  {
    putchar(s[i]);
    fflush(0);
    usleep(100000*(i++%3?1:5));
 }
}

@Kritixi Lithos @Metoniem Obrigado pela sua contribuição! salvou alguns bytes.

De alguma forma, apenas int ime deu um erro de segmentação na execução, então eu o inicializei com 0.

Gelatina , 13 bytes

115D÷⁵ṁȮœS¥@"

Este é um link / função monádica. Devido à saída implícita, ele não funciona como um programa completo.

Verificação

Como funciona

115D÷⁵ṁȮœS¥@"  Monadic link. Argument: s (string)

115            Set the return value to 115.
   D           Decimal; yield [1, 1, 5].
    ÷⁵         Divide all three integers by 10.
      ṁ        Mold; repeat the items of [0.1, 0.1, 0.5] as many times as
               necessary to match the length of s.
          ¥@"  Combine the two links to the left into a dyadic chain and apply it
               to each element in s and the corr. element of the last return value.
       Ȯ         Print the left argument of the chain (a character of s) and sleep
                 as many seconds as the right argument indicates (0.1 or 0.5).

MATLAB, 74 bytes

c=input('');p=[1,1,5]/10;for i=c;fprintf('%s',i);p=p([2,3,1]);pause(p);end

Explicação:

Eu usei um bom tempo para tornar a fprintfversão mais curta do que disp()com clc. A descoberta foi quando descobri / lembrei que pausepode usar um vetor como argumento, caso em que apenas escolherá o primeiro valor. Isso torna possível deixar de fora um balcão.

c=input('');    % Take input as 'Hello'
p=[.1,.1,.5];   % The various pause times

for i=c;            % For each of the characters in the input c
  fprintf('%s',i);  % Print the character i, without any trailing newline or whitespace
                    % No need to clear the screen, it will just append the new character 
                    % after the existing ones
  pause(p);         % pause for p(1) seconds. If the input to pause is a vector, 
                    % then it will choose the first value
  p=p([2,3,1]);     % Shift the pause times
end

A mais curta que tem usando dispera de 81 bytes:

c=input('');p=[1,1,5]/10;for i=1:nnz(c),clc;disp(c(1:i));pause(p(mod(i,3)+1));end

JavaScript (ES6), 67 bytes

f=(i,o,n=0)=>i[n]&&(o.data+=i[n],setTimeout(f,++n%3?100:500,i,o,n))

<form><input id=i><button onclick=f(i.value,o.firstChild)>Go!</button><pre id=o>

V , 20 19 18 bytes

1 byte salvo graças a @DJMcMayhem

economizou 1 byte removendo òno final

òD1gÓulD1gÓulDgÓul

Terrivelmente semolfo, eu sei, é exatamente esse undo estrito que me impede de usar loops aninhados.

Explicação

O cursor inicia no início do buffer, que é o primeiro caractere da entrada.

ò                      " Start recursion
 D                     " Deletes everything from the cursor's position to the end of line
  1gÓ                  " Sleep for 100ms
     u                 " Undo (now the deletion is reverted)
      l                " Move cursor one to the right
       D1gÓul          " Do it again
             D         " Same as before but...
              gÓ       " Sleep for 500ms this time
                ul     " Then undo and move right
                       " Implicit ò

Gif em breve ...

MATL , 16 bytes

"@&htDTT5hX@)&Xx

Experimente no MATL Online!

Explicação

"        % Implicitly input string. For each char of it
  @      %   Push current char
  &h     %   Concatenate everything so far into a string
  tD     %   Duplicate and display
  TT5h   %   Push array [1 1 5]
  X@)    %   Get the k-th element modularly, where k is current iteration.
         %   So this gives 1, 1, 5 cyclically
  &Xx    %   Pause for that many tenths of a second and clear screen
         % Implicit end. Implicitly display the final string, again (screen
         % was deleted at the end of the last iteration)

Noodel , 18 bytes

ʋ115ṡḶƙÞṡạḌ100.ṡ€ß

Tente:)

Como funciona

                   # Input is automatically pushed to the stack.
ʋ                  # Vectorize the string into an array of characters.
 115               # Push on the string literal "115" to be used to create the delays.
    ṡ              # Swap the two items on the stack.

     ḶƙÞṡạḌ100.ṡ€  # The main loop for the animation.
     Ḷ             # Loops the following code based off of the length of the string.
      ƙ            # Push on the current iteration's element of the character array (essentially a foreach).
       Þ           # Pop off of the stack and push to the screen.
        ṡ          # Swap the string "115" and he array of characters (this is done because need array of characters on the top for the loop to know how many times to loop)
         ạ         # Grab the next character in the string "115" (essentially a natural animation cmd that every time called on the same object will access the next item looping)
                   # Also, turns the string into an array of characters.
          Ḍ100.    # Pop the character off and convert to a number then multiply by 100 to get the correct delay. Then delay for that many ms.
               ṡ   # Swap the items again to compensate for the one earlier.
                €  # The end of the loop.

                 ß # Clears the screen such that when implicit popping of the stack occurs it will display the correct output.

Snippet de código de 19 bytes que faz loop infinitamente.

<div id="noodel" cols="30" rows="2" code="ʋ115ṡḷḶƙÞṡạḌ100.ṡ€ß" input='"Hello, PPCG! Goodbye Earth!"'/>
<script src="https://tkellehe.github.io/noodel/release/noodel-2.5.js"></script>
<script src="https://tkellehe.github.io/noodel/ppcg.min.js"></script>

APL, 23 bytes

⊢{⍞←⍺⊣⎕DL⍵÷10}¨1 1 5⍴⍨⍴

Explicação:

               1 1 5⍴⍨⍴  ⍝ repeat the values [1,1,5] to match the input length
⊢                        ⍝ the input itself
 {           }¨          ⍝ pairwise map
      ⎕DL⍵÷10            ⍝ wait ⍵÷10 seconds, where ⍵ is the number
     ⊣                   ⍝ ignore that value, and
  ⍞←⍺                    ⍝ output the character   

C #, 131 bytes

Não há muito a explicar. Ele pega uma string (envolvida em "") como argumento e imprime cada caractere usando o padrão de atraso correto. Após a animação, ele sai com um OutOfRangeExceptionporque o loop não para depois de repetir todos os caracteres. Como é um loop infinito, isso também significa que eu posso usar em int Mainvez de void Main;-)

Golfe

class C{static int Main(string[]a){for(int i=0;){System.Console.Write(a[0][i]);System.Threading.Thread.Sleep(i++%3<1?500:100);}}}

Ungolfed

class C
{
    static int Main(string[] a)
    {
        for (int i = 0; ;)
        {
            System.Console.Write(a[0][i]);
            System.Threading.Thread.Sleep(i++ % 3 < 1 ? 500 : 100);
        }
    }
}

Editar% s

• Economizou 1 byte movendo o incremento identro do Sleep()método em vez de no forloop. (Obrigado Maliafo )

SmileBASIC, 61 bytes

LINPUT S$FOR I=0TO LEN(S$)-1?S$[I];
WAIT 6+24*(I MOD 3>1)NEXT

Eu acho que o cálculo do atraso poderia ser muito menor.

Clojure, 81 bytes

#(doseq[[c d](map vector %(cycle[100 100 500]))](Thread/sleep d)(print c)(flush))

Loops sobre a sequência de entrada compactada com uma lista infinita de [100 100 500].

(defn typer [input]
  ; (map vector... is generally how you zip lists in Clojure 
  (doseq [[chr delay] (map vector input (cycle [100 100 500]))]
    (Thread/sleep delay)
    (print chr) (flush)))

Bash (+ utilitários), 32 bytes

Observe que isso emitirá um sinal sonoro no processo, mas quem disse que os envios não podem ter efeitos sonoros sofisticados!

Golfe

sed 's/.../&\a\a\a\a/g'|pv -qL10

Demo

Python 3 , 83 75 bytes

import time;i=0
for c in input():i+=1;print(end=c);time.sleep(i%3and.1or.5)

Experimente online!

Powershell, 66 65 63 Bytes

[char[]]$args|%{sleep -m((1,1,5)[++$i%3]*100);Write-Host $_ -N}

-1 removeu o espaço em branco desnecessário após -m

-2 graças ao AdmBorkBork - usado 1,1,5e *resultado final ao 100invés de usar100,100,500

recebe $argscomo uma matriz de caracteres, passa pelo modo de suspensão conforme especificado, Write-Hostcom o -Nargumento oNewline é usado para gravar os caracteres na mesma linha.

Melhorias?

• use em [0..99]vez de [char[]]salvar 1 byte, mas não funcionará em strings com mais de 100 caracteres.
• use 100,500e [(++$i%3)-gt1]reduza de alguma forma.
• combiná-lo em uma única seqüência e clara entre as saídas, eliminando a longa Write-Host

não consegue encontrar nenhuma maneira de fazer com que os dois últimos funcionem e o primeiro não é válido por nenhuma regra específica.

Perl, 63 bytes

foreach(split//,pop){$|=++$i;print;select('','','',$i%3?.1:.5)}

Python 3, 88 bytes

import time;s=''
for x in input():s+=x;time.sleep(.1+.4*(len(s)%3==0));print('\n'*25+s)

Rebol, 65 bytes

s: input t:[.1 .1 .5]forall s[prin s/1 wait last append t take t]

Ungolfed:

s: input
t: [.1 .1 .5]

forall s [
    prin s/1
    wait last append t take t
]

Bash + coreutils, 57 bytes

for((;k<${#1};k++)){ echo -n ${1:k:1};sleep .$[2&k%3|1];}

Java 7, 151 149 bytes

class M{public static void main(String[]a)throws Exception{int n=0;for(String c:a[0].split("")){System.out.print(c);Thread.sleep(n++%3>0?100:500);}}}

-2 bytes graças a @KritixiLithos por algo que sempre esqueço ..

Explicação:

class M{
  public static void main(String[] a) throws Exception{ // throws Exception is required due to the Thread.sleep
    int n = 0;                                          // Initialize counter (and set to 0)
    for(String c : a[0].split("")){                     // Loop over the characters of the input
      System.out.print(c);                              // Print the character
      Thread.sleep(n++ % 3 > 0 ?                        // if (n modulo 3 != 0)
                                 100                    //   Use 100 ms
                               :                        // else (n modulo 3 == 0):
                                 500);                  //   Use 500 ms
    }
  }
}

Uso:

java -jar M.jar "Hello, PPCG! Goodbye Earth!"

Processando, 133 131 bytes

int i;void setup(){for(String c:String.join("",args).split(""))p{try{Thread.sleep(i++%3<1?500:100);}catch(Exception e){}print(c);}}

Eu tentei fazer args[0]e agrupar o argumento em"" , mas ele não funciona por algum motivo.

Enfim ... esta é a primeira vez que escrevi um programa de processamento que aceita argumentos. Ao contrário do Java, você não precisa declarar os argumentos usando String[]args, mas a variável argsserá inicializada automaticamente nos argumentos.

Coloque-o em um arquivo chamado sketch_name.pdeem uma pasta chamada sketch_name(sim, mesmo nome para pasta e esboço). Chame assim:

processing-java --sketch=/full/path/to/sketch/folder --run input text here