En cualquier lenguaje de programación, cree un programa que tome datos y anime el texto que se está escribiendo en un teclado.

El retraso entre cada carácter debe variar para simular la escritura verdadera en un teclado. El retraso será de 0.1, 0.1, 0.5, 0.1, 0.1, 0.5 ...segundos, hasta que se imprima el último carácter. El resultado final se dejará en la pantalla.

Debe sobrescribir la línea de texto actual; no puede hacer que el texto se imprima en nuevas filas.

Ejemplo, la entrada "¡Hola, PPCG! ¡Adiós Tierra!" debería producir la siguiente animación (tenga en cuenta que la frecuencia de muestreo del creador de gifs fue baja, por lo que el resultado real es ligeramente diferente):

Como se trata de un código de golf, gana la menor cantidad de bytes.

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

Versión sin golf:

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

@Kritixi Lithos @Metoniem ¡Gracias por su aporte! guardado algunos bytes

De alguna manera, solo int ime dio un error de segmentación al ejecutar, así que lo inicialicé con 0.

Jalea , 13 bytes

115D÷⁵ṁȮœS¥@"

Este es un enlace / función monádico. Debido a la salida implícita, no funciona como un programa completo.

Verificación

Cómo 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

Explicación:

Solía ​​bastante tiempo hacer la fprintfversión más corta que disp()con clc. El avance fue cuando descubrí / recordé que pausepuede tomar un vector como argumento, en cuyo caso simplemente elegirá el primer valor. Esto permite dejar fuera un mostrador.

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

El más corto que utilicé dispfue 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 guardado gracias a @DJMcMayhem

guardado 1 byte al eliminar òal final

òD1gÓulD1gÓulDgÓul

Terriblemente poco golfista, lo sé, es solo ese estricto undo que me impide usar bucles anidados.

Explicación

El cursor comienza en el comienzo del búfer, que es el primer carácter de la 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 próximamente ...

MATL , 16 bytes

"@&htDTT5hX@)&Xx

¡Pruébalo en MATL Online!

Explicación

"        % 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.ṡ€ß

Intentalo:)

Cómo 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.

Fragmento de código de 19 bytes que se repite sin parar.

<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⍴⍨⍴

Explicación:

               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

No hay mucho que explicar. Simplemente toma una cadena (envuelta en "") como argumento e imprime cada carácter usando el patrón de retraso correcto. Después de la animación, sale con un OutOfRangeExceptionporque el bucle no se detiene después de recorrer todos los personajes. Como es un bucle infinito, eso también significa que puedo usarlo en int Mainlugar de void Main;-)

Golfed

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

Sin golf

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

Ediciones

• Se guardó 1 byte moviéndose incrementándolo identro del Sleep()método en lugar de hacerlo en el forbucle. (Gracias Maliafo )

SmileBASIC, 61 bytes

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

Creo que el cálculo del retraso podría ser mucho más corto.

Clojure, 81 bytes

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

Recorre la cadena de entrada comprimida con una 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 (+ utilidades), 32 bytes

Tenga en cuenta que esto emitirá un pitido en el proceso, pero ¡quién dijo que las presentaciones no pueden tener efectos de sonido sofisticados!

Golfed

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

Manifestación

Python 3 , 83 75 bytes

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

Pruébalo en línea!

Powershell, 66 65 63 Bytes

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

-1 eliminó el espacio en blanco innecesario después de -m

-2 gracias a AdmBorkBork: usado 1,1,5y *resultado final en 100lugar de usar100,100,500

toma $argscomo una matriz de caracteres, recorre Write-Hostel modo de -Nsuspensión según lo especificado, con el argumento oNewline se usa para escribir los caracteres en la misma línea.

Mejoras?

• use en [0..99]lugar de [char[]]guardar 1 byte, pero no funcionará en cadenas de más de 100 caracteres.
• usar 100,500y [(++$i%3)-gt1]pero hacerlo más corto de alguna manera.
• combinarlo en una sola cadena y borrar entre salidas, eliminando el largo Write-Host

No puedo encontrar ninguna manera de hacer que los dos últimos funcionen, y el primero no es válido por ninguna regla en particular.

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]

Sin golf:

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 gracias a @KritixiLithos por algo que siempre olvido.

Explicación:

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

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

Traté de hacer args[0]y envolver el argumento en"" lugar, pero no funciona por alguna razón.

De todos modos ... esta es la primera vez que escribo un programa de procesamiento que toma argumentos. A diferencia de Java, no necesita declarar los argumentos utilizando String[]args, pero la variable argsse inicializará automáticamente a los argumentos.

Póngalo en un archivo llamado sketch_name.pdedebajo de una carpeta llamada sketch_name(sí, el mismo nombre para la carpeta y el boceto). Llámalo como:

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