La tua sfida è scrivere un programma o una funzione che singhiozzi una stringa. Dovrebbe prendere una stringa come input (tramite qualsiasi metodo standard), quindi seguire questi passaggi:

1. Genera un numero intero casuale (non necessariamente uniforme) n compreso tra 1 e 10, inclusi.
2. Aspetta n secondi.
3. Stampa i n caratteri iniziali / successivi dell'input o il resto dell'input se sono presenti meno di n caratteri.
4. Se è rimasto un input da stampare, tornare al passaggio 1.

Regole

• L'input sarà sempre una stringa non vuota contenente solo caratteri ASCII (32-126).
• Il tempo di attesa non deve essere esattamente n secondi, ma deve rientrare nel 10% di n .
• È possibile stampare una nuova riga finale ogni volta che viene stampata una sezione di testo.

Esempio

Uno spazio qui rappresenta 1 secondo. Se l'input è Hiccupinator!, un output potrebbe essere:

   Hic     cupin a          tor!

punteggio

Questo è code-golf , quindi vince il codice più breve in byte .

Scratch, 16 blocchi + 6 byte

Presuppone che l'input sia già definito come un elenco di caratteri ( ["H","e","l","l","o"," ","W","o","r","l","d"])

Pushy , 20 17 16 o 13 byte

A seconda di ciò che è consentito, ci sono due soluzioni.

16 byte:

@$LT1U&Wm:v;O"cI

Dare argomenti su linea di comando: $ pushy hiccup.pshy 'hiccupinator'. Questo stampa con nuove righe finali dopo ogni 'singhiozzo'. Ecco la ripartizione:

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

Durante la codifica della risposta sopra ho trovato questa soluzione significativamente più breve:

N@$L1TU&Wm:'.

Sebbene faccia una cosa simile, stampa direttamente dalla stringa anziché costruire una nuova stringa, per un minor numero di byte. Ciò richiede Nall'inizio del programma per evitare di trascinare nuove righe, altrimenti ogni personaggio si troverebbe su una nuova riga.

Tuttavia, durante il test ho notato un bug: stdoutè bufferizzato in linea, quindi il programma aspetterebbe l'intera lunghezza e quindi visualizzerà la stringa singhiozzata.

Ho risolto questo problema nell'ultimo commit aggiungendo un semplice .flush(): tecnicamente non si tratta di aggiungere una nuova funzionalità alla lingua, sto solo risolvendo un bug, ma capisco se non si tiene conto di questa risposta :)

La ripartizione è simile alla seguente:

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

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

salvato 2 byte grazie a @zeppelin

Abusa della tolleranza del 10% per il tempo di attesa attendendo n<<10 === 1024*nmillisecondi.

Dato che hai detto che il tempo di attesa deve essere compreso tra il 10% di n , ho deciso di salvare un byte e attendere 999 millisecondi anziché 1 secondo.

Non ho più bisogno della stupidità di 999 millisecondi grazie a @ETHProductions

Python 2, 93 92 byte

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

-1 byte grazie a Flp.Tkc

Sono sicuro che c'è un modo per accorciare random.randinte time.sleep, ma from random,time import*non funziona ...

Perl 6 , 62 byte

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

allargato

{ # 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
  }
}

Lotto, 131 byte

@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

L'uso set/pn=<nulavrebbe dato un effetto migliore tranne che per il taglio degli spazi.

Pyth, 16 byte

Wz.d_JhOT<zJ=>zJ

Puoi provarlo online , ma non funziona bene poiché l'interprete online visualizza l'output solo al termine del programma.

Spiegazione

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 byte

`10YrtY.ynhX<:&)wDt

Come funziona

Provalo online! Il compilatore online produce gradualmente gli output con le pause.

`         % 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 byte

Una soluzione in BASIC. La funzione RANDOM () genera un numero compreso tra 0 e n-1, pertanto è necessario utilizzare RANDOM (11) per ottenere un numero compreso tra 0 e 10 inclusi.

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

Sessione di esempio, la prima riga è l'input, in secondo luogo l'output:

Hiccupinator!
Hiccupi       nato    r!

Perl, 42 byte

41 byte codice + 1 per -n.

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

Ho dovuto forzare Perl a scaricare l'output in quanto non mostrava nulla fino alla fine all'inizio, quindi l'impostazione $|. Usiamo $-per tenere traccia del numero di caratteri in printquanto questo non può essere negativo (quindi posso usare --$-e sarà falso quando è vuoto) e anchefloor , sebbene dal momento che sto usando il ritorno di sleepper questo ora, questo non importa davvero.

uso

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

Rubino, 56 byte

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

Una lambda ricorsiva. Chiama come f["Hello, World!"].

> <> (Pesce) 103 88 byte

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

Interprete online trovato qui!

Primo tentativo di questo problema (non golfato).

Aspetta un certo numero di loop (n) poiché i pesci non hanno un timer accessibile (Esecuzione in tick).

Modifica 1: spostato l'ultima riga in alto (ultimi 2 caratteri e riutilizzato i valori iniziali. (Salvataggio di 15 byte).

Bash, 78 byte

Dato che nessuno ha ancora pubblicato una soluzione Bash, eccone una. Semplice, ma abbastanza piccolo.

golfed

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

Test

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

PHP, 81 byte

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

usare come:

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 byte

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

Richiede input per essere a std::string

Ungolfed e utilizzo:

#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 byte

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

Sono sicuro che questo può essere distrutto, non l'ho davvero ottimizzato così com'è.

Un-giocato a 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 byte

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

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

C, 149 byte, non testato

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

per eseguire, aggiungere

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

quindi compilare ed eseguire

Python 3, 99 caratteri

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