Seu desafio é escrever um programa ou função que soluça uma string. Ele deve receber uma string como entrada (por qualquer método padrão) e siga estas etapas:

1. Gere um número inteiro aleatório n (não necessariamente uniforme) entre 1 e 10, inclusive.
2. Aguarde n segundos.
3. Imprimir o inicial / próximo n caracteres da entrada ou o restante da entrada se houver menos de n caracteres.
4. Se ainda houver entrada para impressão, volte para a etapa 1.

Regras

• A entrada sempre será uma sequência não vazia contendo apenas caracteres ASCII (32-126).
• O tempo de espera não precisa ser exatamente n segundos, mas deve estar dentro de 10% de n .
• Você pode imprimir uma nova linha final sempre que uma seção do texto for impressa.

Exemplo

Um espaço aqui representa 1 segundo. Se a entrada for Hiccupinator!, uma saída pode ser:

   Hic     cupin a          tor!

Pontuação

Isso é código-golfe , então o código mais curto em bytes vence .

Scratch, 16 blocos + 6 bytes

Supõe que a entrada já esteja definida como uma lista de caracteres ( ["H","e","l","l","o"," ","W","o","r","l","d"])

Pushy , 20 17 16 ou 13 bytes

Dependendo do que é permitido, existem duas soluções.

16 bytes:

@$LT1U&Wm:v;O"cI

Dê argumentos na linha de comando: $ pushy hiccup.pshy 'hiccupinator'. Isso é impresso com novas linhas após cada 'soluço'. Aqui está o detalhamento:

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

Ao codificar a resposta acima, eu vim com esta solução significativamente mais curta:

N@$L1TU&Wm:'.

Embora faça algo semelhante, ele imprime diretamente da string em vez de construir uma nova string, por menos bytes. Isso requer que, Nno início do programa, impeça o rastreamento de novas linhas, ou cada caractere estaria em uma nova linha.

No entanto, ao testar isso, notei um bug - stdouté buffer de linha, de modo que o programa esperaria todo o comprimento e exibisse a string soluçada.

Corrigi isso na confirmação mais recente adicionando um simples.flush() - tecnicamente, não adicionamos um novo recurso ao idioma, apenas corrigimos um bug, mas entendo se você não levar em conta essa resposta :)

A repartição é assim:

        % 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!')                                       

economizou 2 bytes graças a @zeppelin

Abusa a tolerância de 10% para o tempo de espera, aguardando n<<10 === 1024*nmilissegundos.

Como você disse que o tempo de espera precisa estar dentro de 10% de n , decidi economizar um byte e aguardar 999 milissegundos em vez de 1 segundo.

Não preciso mais da bobagem de 999 milissegundos graças 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 graças ao Flp.Tkc

Tenho certeza de que existe uma maneira de reduzir o random.randinte time.sleep, mas from random,time import*não 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

O uso set/pn=<nuldaria um efeito melhor, exceto que apara os espaços.

Pitão, 16 bytes

Wz.d_JhOT<zJ=>zJ

Você pode experimentá-lo online , mas não funciona bem, pois o intérprete on-line só exibe a saída quando o programa é concluído.

Explicação

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

Como funciona

Experimente online! O compilador online produz gradualmente as saídas com as 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

Uma solução em BASIC. A função RANDOM () gera um número entre 0 e n-1; portanto, temos que usar RANDOM (11) para obter um número entre 0 e 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

Sessão de amostra, primeira linha é a entrada, depois a saída:

Hiccupinator!
Hiccupi       nato    r!

Perl, 42 bytes

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

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

Eu tive que forçar o Perl a liberar a saída, pois ela não estava mostrando nada até o final, portanto, definindo $|. Usamos $-para rastrear o número de caracteres, printpois isso não pode ser negativo (para que eu possa usar --$-e ainda será falso quando estiver vazio) e também flooré, embora seja porque estou usando o retorno desleep agora, isso não realmente 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!=""}

Um lambda recursivo. Ligue como f["Hello, World!"].

> <> (Peixe) 103 88 Bytes

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

Intérprete online encontrado aqui!

Primeira tentativa neste problema (não jogou golfe).

Espera uma certa quantidade de loops (n), pois o peixe não possui um cronômetro acessível (Execução em carrapatos).

Editar 1: moveu a última linha para o topo (últimos 2 caracteres e reutilizou os valores iniciais. (Economia de 15 bytes).

Bash, 78 bytes

Como ninguém postou uma solução Bash ainda, aqui está uma. Simples, mas pequeno o suficiente.

Golfe

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

Teste

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

use 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):"");}

Requer entrada para ser um std::string

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

Tenho certeza de que isso pode ser destruído, não o otimizei realmente como está.

Sem golfe:

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

Corra com php -r 'code' "string".

C, 149 bytes, não testado

#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 executar, adicione

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

então compile e execute

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