Votre défi consiste à écrire un programme ou une fonction qui hoquette une chaîne. Il doit prendre une chaîne en entrée (via toute méthode standard), puis procédez comme suit:

1. Générez un entier aléatoire (pas nécessairement uniforme) n compris entre 1 et 10 inclus.
2. Attendez n secondes.
3. Imprime les n caractères initiaux / suivants de l'entrée, ou le reste de l'entrée s'il y a moins de n caractères.
4. S'il reste une entrée à imprimer, revenez à l'étape 1.

Règles

• L'entrée sera toujours une chaîne non vide contenant uniquement des caractères ASCII (32-126).
• Le temps d'attente ne doit pas être exactement n secondes, mais il doit être à moins de 10% de n .
• Vous pouvez imprimer un retour à la ligne à chaque fois qu'une section de texte est imprimée.

Exemple

Un espace ici représente 1 seconde. Si l'entrée est Hiccupinator!, une sortie peut être:

   Hic     cupin a          tor!

Notation

Il s'agit de code-golf , donc le code le plus court en octets l'emporte .

Scratch, 16 blocs + 6 octets

Suppose que l'entrée est déjà définie comme une liste de caractères ( ["H","e","l","l","o"," ","W","o","r","l","d"])

Pushy , 20 17 16 ou 13 octets

Selon ce qui est autorisé, il existe deux solutions.

16 octets:

@$LT1U&Wm:v;O"cI

Donner des arguments sur la ligne de commande: $ pushy hiccup.pshy 'hiccupinator'. Cela imprime avec des retours à la ligne après chaque «hoquet». Voici la ventilation:

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

En codant la réponse ci-dessus, j'ai trouvé cette solution beaucoup plus courte:

N@$L1TU&Wm:'.

Bien qu'il fasse une chose similaire, il imprime directement la chaîne plutôt que de construire une nouvelle chaîne, pour moins d'octets. Cela nécessite laN début du programme pour éviter les sauts de ligne, sinon chaque caractère se trouverait sur un saut de ligne.

Cependant, en testant cela, j'ai remarqué un bug - stdout est mis en mémoire tampon, donc le programme attendrait toute la longueur, puis afficherait la chaîne hoquetée.

J'ai corrigé cela dans le dernier commit en ajoutant un simple.flush() - ce n'est techniquement pas en ajoutant une nouvelle fonctionnalité à la langue, juste en corrigeant un bug, mais je comprends si vous ne tenez pas compte de cette réponse :)

La ventilation ressemble à ceci:

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

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

économisé 2 octets grâce à @zeppelin

Abuse la tolérance de 10% pour le temps d'attente en attendant des n<<10 === 1024*nmillisecondes.

Puisque vous avez dit que le temps d'attente devait se situer à moins de 10% de n , j'ai décidé d'enregistrer un octet et d'attendre 999 millisecondes plutôt que 1 seconde.

Je n'ai plus besoin de la bêtise de 999 millisecondes grâce à @ETHProductions

Python 2, 93 92 octets

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

-1 octet grâce à Flp.Tkc

Je suis sûr qu'il existe un moyen de raccourcir random.randint et time.sleep, mais from random,time import*ne fonctionne pas ...

Perl 6 , 62 octets

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

Étendu

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

Lot, 131 octets

@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'utilisation set/pn=<nulaurait donné un effet plus agréable, sauf qu'elle réduit les espaces.

Pyth, 16 octets

Wz.d_JhOT<zJ=>zJ

Vous pouvez l' essayer en ligne , mais cela ne fonctionne pas bien car l'interpréteur en ligne n'affiche la sortie qu'une fois le programme terminé.

Explication

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 octets

`10YrtY.ynhX<:&)wDt

Comment ça fonctionne

Essayez-le en ligne! Le compilateur en ligne produit progressivement les sorties avec les pauses.

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

Une solution en BASIC. La fonction RANDOM () génère un nombre compris entre 0 et n-1, nous devons donc utiliser RANDOM (11) pour obtenir un nombre compris entre 0 et 10 inclus.

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

Exemple de session, la première ligne est l'entrée, la seconde la sortie:

Hiccupinator!
Hiccupi       nato    r!

Perl, 42 octets

Code de 41 octets + 1 pour -n.

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

J'ai dû forcer Perl à vider la sortie car il ne montrait rien jusqu'à la fin au début, d'où le réglage $|. Nous utilisons $-pour suivre le nombre de caractèresprint car cela ne peut pas être négatif (donc je peux utiliser --$-et ce sera faux quand il sera vide) et c'est aussi floors, bien que puisque j'utilise le retour desleep pour cela maintenant, cela ne fonctionne pas n'a pas vraiment d'importance.

Usage

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

Rubis, 56 octets

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

Une lambda récursive. Appelez comme f["Hello, World!"].

> <> (Poisson) 103 88 octets

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

Interprète en ligne trouvé ici!

Première tentative à ce problème (pas joué au golf).

Il attend un certain nombre de boucles (n) car le poisson n'a pas de temporisateur accessible (Exécution en ticks).

Édition 1: Déplacement de la dernière ligne vers le haut (2 derniers caractères et réutilisation des valeurs de départ. (Économie de 15 octets).

Bash, 78 octets

Comme personne n'a encore publié de solution Bash, en voici une. Simple, mais assez petit.

Golfé

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

Tester

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

PHP, 81 octets

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

utiliser comme:

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 octets

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

Nécessite une entrée pour être std::string

Non golfé et utilisation:

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

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

Je suis sûr que cela peut être détruit, je ne l'ai pas vraiment optimisé du tout tel qu'il est.

Non-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 octets

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

Courez avec php -r 'code' "string".

C, 149 octets, non testé

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

pour exécuter, ajouter

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

puis compilez et exécutez

Python 3, 99 caractères

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