Su desafío es escribir un programa o función que tenga una cadena. Debe tomar una cadena como entrada (a través de cualquier método estándar), luego siga estos pasos:

1. Genere un entero aleatorio (no necesariamente uniformemente) n entre 1 y 10, inclusive.
2. Espera n segundos
3. Imprima los n caracteres iniciales / siguientes de la entrada, o el resto de la entrada si hay menos de n caracteres.
4. Si queda entrada para imprimir, regrese al paso 1.

Reglas

• La entrada siempre será una cadena no vacía que contenga solo caracteres ASCII (32-126).
• El tiempo de espera no tiene que ser exactamente n segundos, pero debe estar dentro del 10% de n .
• Puede imprimir una nueva línea final cada vez que se imprime una sección de texto.

Ejemplo

Un espacio aquí representa 1 segundo. Si la entrada es Hiccupinator!, una salida podría ser:

   Hic     cupin a          tor!

Puntuación

Este es el código de golf , por lo que gana el código más corto en bytes .

Scratch, 16 bloques + 6 bytes

Asume que la entrada ya está definida como una lista de caracteres ( ["H","e","l","l","o"," ","W","o","r","l","d"])

Pushy , 20 17 16 o 13 bytes

Dependiendo de lo que está permitido, hay dos soluciones.

16 bytes:

@$LT1U&Wm:v;O"cI

Dar argumentos en la línea de comandos: $ pushy hiccup.pshy 'hiccupinator'. Esto se imprime con líneas nuevas después de cada 'hipo'. Aquí está el desglose:

                      % Implicit: input on stack as charcodes
@                     % Reverse input, so chars are pulled from start
 $             I      % While there are items on stack:
   T1U                %   Push a random number, 1-10
      &W              %   Wait that many seconds
  L     m:            %   min(time waited, chars left) times do:
          v;          %     Pull a char from the input.
            O"c       %   Print & delete pulled chars

13 bytes:

Mientras codificaba la respuesta anterior, se me ocurrió esta solución significativamente más corta:

N@$L1TU&Wm:'.

Aunque hace algo similar, imprime directamente de la cadena en lugar de construir una nueva cadena, por menos bytes. Esto requiere que Nal comienzo del programa se evite el arrastre de nuevas líneas, o de lo contrario cada personaje estaría en una nueva línea.

Sin embargo, al probar esto, noté un error: stdoutestá protegido por líneas, por lo que el programa esperaría toda la longitud y luego mostraría la cadena con hipo.

Lo arreglé en la última confirmación agregando un simple .flush(): técnicamente no es agregar una nueva característica al idioma, solo corregir un error, pero entiendo si no tiene en cuenta esta respuesta :)

El desglose se ve así:

        % Implicit: input on stack as charcodes
N       % Set trailing newlines to False
@       % Reverse stack (so the charcodes are pulled off in order)
$       % While there are items left to print:
L       %    Push stack length
1TU     %    Push a random number 1-10
&W      %    Wait that amount of time
m:      %    min(time waited, chars left) times do:
'.      %      Pop and print last char

Javascript (ES6) 91 89 Bytes

f=s=>s&&setTimeout(_=>console.log(s.slice(0,n))|f(s.slice(n)),(n=1+Math.random()*10)<<10)

console.log(2 + f.toString().length); 
f('Hello sweet world!')                                       

ahorró 2 bytes gracias a @zeppelin

Abusa de la tolerancia del 10% para el tiempo de espera al esperar n<<10 === 1024*nmilisegundos.

Como usted dijo que el tiempo de espera debe estar dentro del 10% de n , decidí guardar un byte y esperar 999 milisegundos en lugar de 1 segundo.

Ya no necesito las tonterías de 999 milisegundos gracias a @ETHProductions

Python 2, 93 92 bytes

import random,time
def F(s):
 if s:n=random.randint(1,10);time.sleep(n);print s[:n];F(s[n:])

-1 byte gracias a Flp.Tkc

Estoy seguro de que hay una manera de acortar el random.randinty time.sleep, pero from random,time import*no funciona ...

Perl 6 , 62 bytes

{$_=$^a;while $_ {sleep my \t=(1..10).roll;put s/.**{0..t}//}}

Expandido

{ # block lambda with parameter ｢$a｣

  $_ = $^a; # declare parameter, and store it in ｢$_｣
            # ( the input is read-only by default )

  while $_ {
    # generate random number and sleep for that many seconds
    sleep my \t=(1..10).roll;

    put
      s/              # substitution on ｢$_｣ ( returns matched text )
        . ** { 0..t } # match at most ｢t｣ characters
      //              # replace it with nothing
  }
}

Lote, 131 bytes

@set/ps=
:l
@set/an=%random%%%10+1
@timeout/t>nul %n%
@call echo(%%s:~0,%n%%%
@call set s=%%s:~%n%%%
@if not "%s%"==2" goto l

El uso set/pn=<nulhubiera dado un efecto más agradable, excepto que recorta espacios.

Pyth, 16 bytes

Wz.d_JhOT<zJ=>zJ

Puede probarlo en línea , pero no funciona bien ya que el intérprete en línea solo muestra la salida una vez que el programa ha finalizado.

Explicación

Wz         While z (the input) is not empty:
     hOT   Get a random number between 1-10 (inclusive)
    J      Set the variable J to that number
 .d_       Sleep for that number of seconds
 <zJ       Get and implicitly print the first J characters of the input
  >zJ      Get all characters of z at and after index J
 =         Set z to that string

MATL , 19 bytes

`10YrtY.ynhX<:&)wDt

Cómo funciona

Pruébalo en línea! El compilador en línea produce gradualmente las salidas con las pausas.

`         % Do...while loop
  10Yr    %   Random integer from 1 to 10
  tY.     %   Duplicate. Pause that many seconds
  y       %   Duplicate the second-top element. This is the remaining string; or it
          %   takes the input implicitly in the first iteration
  n       %   Number of elements
  hX<     %   Minimum of the number of elements and the random number
  :       %   Range from 1 to that
  &)      %   Apply as index. Push the substring as given by the index and the
          %   remaining substring
  w       %   Swap
  D       %   Display
  t       %   Duplicate the remaining substring. This is used as loop condition:
          %   if non-empty execute next iteration
          % End loop implicitly

BaCon , 93 bytes

Una solución en BASIC. La función RANDOM () genera un número entre 0 y n-1, por lo tanto, tenemos que usar RANDOM (11) para obtener un número entre 0 y 10 inclusive.

INPUT s$
WHILE LEN(s$)>0
n=RANDOM(11)
SLEEP n*1000
?LEFT$(s$,n),SPC$(n);
s$=MID$(s$,n+1)
WEND

Sesión de muestra, la primera línea es la entrada, la segunda la salida:

Hiccupinator!
Hiccupi       nato    r!

Perl, 42 bytes

Código de 41 bytes + 1 para -n.

$|=$-=--$-||sleep 1+rand 10,print for/./g

Tuve que forzar a Perl a eliminar la salida, ya que no mostraba nada hasta el final al principio, por lo tanto, la configuración $|. Usamos $-para rastrear el número de caracteres, printya que esto no puede ser negativo (por lo que puedo usar --$-y será falso cuando está vacío) y también floores, aunque como estoy usando el retorno de sleepesto ahora, eso no Realmente no importa.

Uso

perl -ne '$|=$-=--$-||sleep 1+rand 10,print for/./g' <<< 'Hello, World!'
    Hell      o, Wor     ld!
# spaces showing delay!

Ruby, 56 bytes

f=->s{n=sleep rand 1..10;print s.slice!0,n;f[s]if s!=""}

Una lambda recursiva. Llama como f["Hello, World!"].

> <> (Pescado) 103 88 Bytes

5>:?vl1-?!v+40.    >~
   1x2v   
>^  0  |:!/>:?!v1-b2.
^-1}< <     |~!/:?!^1-i:1+?!;of3.

Intérprete en línea encontrado aquí!

Primer intento en este problema (no golfizado).

Espera una cierta cantidad de bucles (n) ya que el pez no tiene un temporizador accesible (Ejecución en ticks).

Edición 1: movió la última línea a la parte superior (últimos 2 caracteres y reutilizó los valores iniciales) (ahorro de 15 bytes).

Bash, 78 bytes

Como nadie ha publicado una solución Bash todavía, aquí hay una. Directo, pero lo suficientemente pequeño.

Golfed

H() { N=$(($RANDOM%10+1));sleep $N;echo ${1:0:$N};S=${1:$N};[ "$S" ] && H $S;}

Prueba

>H "It's the Hiccupinator"
It's the
Hiccupi
n
ator

PHP, 81 bytes

for(;''<$s=&$argv[1];$s=$f($s,$n))echo($f=substr)($s,0,sleep($n=rand(1,10))?:$n);

usar como:

php -r "for(;''<$s=&$argv[1];$s=$f($s,$n))echo($f=substr)($s,0,sleep($n=rand(1,10))?:$n);" "Hiccupinator!"

C ++ 14, 202 bytes

#import<thread>
void f(auto c){if(c.size()<1)return;int n=(uintptr_t(&c)%99)/10+1;std::this_thread::sleep_for(std::chrono::seconds(n));std::cout<<c.substr(0,n)<<std::endl;f(n<c.size()?c.substr(n):"");}

Requiere entrada para ser un std::string

Sin golf y uso:

#include<iostream>
#include<string>

#import <thread>

void f(auto c){
  if (c.size() < 1) return;
  int n=(uintptr_t(&c) % 99) / 10 + 1;
  std::this_thread::sleep_for(std::chrono::seconds(n));
  std::cout << c.substr(0,n) << std::endl;
  f(n < c.size() ? c.substr(n) : "");
}

int main(){
  std::string s="abcdefghijklmnopqrstuvwxyz";
  f(s);
}

C #, 205 bytes

void X(string s){Random r=new Random();int n=r.Next(1,11);while(n<s.Length){Console.WriteLine(s.Substring(0,n));s.Remove(0,n);n*=1000;System.Threading.Thread.Sleep(n);n=r.Next(1,11);}Console.WriteLine(s);}

Estoy seguro de que esto puede ser destruido, realmente no lo he optimizado en absoluto tal como está.

Sin golf:

void X(string s)
{
    Random r = new Random();
    int n = r.Next(1,11);
    while(n < s.Length)
    {
        Console.WriteLine(s.Substring(0,n));
        s.Remove(0,n);
        n *= 1000;
        System.Threading.Thread.Sleep(n);
        n = r.Next(1,11);
    }
    Console.WriteLine(s);
}

PHP, 74 bytes

for($s=$argv[1];$s[$p+=$n]>"";print substr($s,$p,$n))sleep($n=rand(1,10));

Corre con php -r 'code' "string".

C, 149 bytes, no probado

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int f(char *s){int n;while(*s){sleep(n=rand()%10+1);for(;*s&&n--;s++)printf("%.*s",1,s);}}

para correr, agregue

int main(){f("Programming Puzzles & CodeGolf");}

luego compila y ejecuta

Python 3, 99 caracteres

i=input()
import os,time
while len(i):n=1+ord(os.urandom(1))%10;time.sleep(n);print(i[:n]);i=i[n:]