Ihre Herausforderung besteht darin, ein Programm oder eine Funktion zu schreiben, die einen String in Schwierigkeiten bringt. Es sollte eine Zeichenfolge als Eingabe (über eine beliebige Standardmethode) verwendet werden. Führen Sie dann die folgenden Schritte aus:

1. Generieren Sie eine (nicht unbedingt einheitliche) zufällige ganze Zahl n zwischen 1 und 10 einschließlich.
2. Warte n Sekunden.
3. Drucken Sie die ersten / nächsten n Zeichen der Eingabe oder den Rest der Eingabe, wenn weniger als n Zeichen vorhanden sind.
4. Wenn noch Eingaben zum Drucken vorhanden sind, kehren Sie zu Schritt 1 zurück.

Regeln

• Die Eingabe ist immer eine nicht leere Zeichenfolge, die nur ASCII-Zeichen enthält (32-126).
• Die Wartezeit muss nicht genau n Sekunden betragen, sondern muss innerhalb von 10% von n liegen .
• Sie können jedes Mal, wenn ein Textabschnitt gedruckt wird, eine abschließende neue Zeile drucken.

Beispiel

Ein Leerzeichen steht hier für 1 Sekunde. Wenn die Eingabe ist Hiccupinator!, könnte eine Ausgabe sein:

   Hic     cupin a          tor!

Wertung

Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes .

Scratch, 16 Blöcke + 6 Bytes

Angenommen, die Eingabe ist bereits als Liste von Zeichen definiert ( ["H","e","l","l","o"," ","W","o","r","l","d"]).

Pushy , 20 17 16 oder 13 Bytes

Je nachdem, was erlaubt ist, gibt es zwei Lösungen.

16 Bytes:

@$LT1U&Wm:v;O"cI

Geben Sie Argumente auf der Kommandozeile: $ pushy hiccup.pshy 'hiccupinator'. Dies wird mit nachgestellten Zeilenumbrüchen nach jedem "Schluckauf" gedruckt. Hier ist die Aufteilung:

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

Während ich die obige Antwort codierte, kam ich zu dieser deutlich kürzeren Lösung:

N@$L1TU&Wm:'.

Obwohl dies ähnlich ist, wird direkt von der Zeichenfolge gedruckt, anstatt eine neue Zeichenfolge für weniger Bytes zu erstellen. Dies setzt Nvoraus, dass zu Beginn des Programms keine Zeilenumbrüche gesetzt werden, da sich sonst jedes Zeichen in einer neuen Zeile befindet.

Als ich dies testete, bemerkte ich jedoch einen Fehler - stdoutist zeilengepuffert, so dass das Programm auf die volle Länge warten und dann den hiccuped String anzeigen würde.

Ich habe dies im letzten Commit durch Hinzufügen eines einfachen behoben .flush()- dies fügt der Sprache technisch gesehen keine neue Funktion hinzu, sondern behebt nur einen Fehler, aber ich verstehe, wenn Sie diese Antwort nicht berücksichtigen :)

Die Aufteilung sieht folgendermaßen aus:

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

2 Bytes dank @zeppelin gespart

Missbrauch der 10% -Toleranz für die Wartezeit durch Warten auf n<<10 === 1024*nMillisekunden.

Da Sie sagten, dass die Wartezeit innerhalb von 10% von n liegen muss , habe ich beschlossen, ein Byte zu speichern und statt 1 Sekunde 999 Millisekunden zu warten.

Dank @ETHProductions brauche ich die Dummheit von 999 Millisekunden nicht mehr

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 dank Flp.Tkc

Ich bin mir sicher, dass es einen Weg gibt, das random.randintund zu verkürzen time.sleep, aber es from random,time import*funktioniert nicht ...

Perl 6 , 62 Bytes

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

Erweitert

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

Batch, 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

Die Verwendung von set/pn=<nulhätte einen schöneren Effekt erzielt, außer dass Leerzeichen abgeschnitten werden.

Pyth, 16 Bytes

Wz.d_JhOT<zJ=>zJ

Sie können es online ausprobieren , aber es funktioniert nicht gut, da der Online-Interpreter die Ausgabe erst anzeigt, wenn das Programm beendet ist.

Erläuterung

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

Wie es funktioniert

Probieren Sie es online! Der Online-Compiler erzeugt nach und nach die Ausgaben mit den Pausen.

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

Eine Lösung in BASIC. Die Funktion RANDOM () generiert eine Zahl zwischen 0 und n-1. Daher müssen wir RANDOM (11) verwenden, um eine Zahl zwischen 0 und 10 zu erhalten.

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

Beispielsitzung, erste Zeile ist die Eingabe, zweite die Ausgabe:

Hiccupinator!
Hiccupi       nato    r!

Perl, 42 Bytes

41 Byte Code + 1 für -n.

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

Ich musste Perl zwingen, die Ausgabe zu leeren, da sie zunächst nichts bis zum Ende zeigte und daher eingestellt wurde $|. Wir verwenden $-, um die Anzahl der Zeichen zu verfolgen, printda dies nicht negativ sein kann (also kann ich es verwenden --$-und es wird immer falsch sein, wenn es leer ist) und es ist auch so floor, obwohl ich die Rückgabe von sleepfür dieses jetzt benutze, dass es nicht tut ist nicht wirklich wichtig.

Verwendung

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

Ein rekursives Lambda. Rufen Sie gerne an f["Hello, World!"].

> <> (Fisch) 103 88 Bytes

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

Online-Dolmetscher hier gefunden!

Erster Versuch dieses Problems (nicht Golf).

Es wartet eine bestimmte Anzahl von Schleifen (n), da Fische keinen Timer haben, auf den zugegriffen werden kann (Ausführung in Ticks).

Bearbeiten 1: Die letzte Zeile wurde nach oben verschoben (die letzten 2 Zeichen und die Startwerte wurden erneut verwendet. (Einsparung von 15 Bytes).

Bash, 78 Bytes

Da noch niemand eine Bash-Lösung veröffentlicht hat, finden Sie hier eine. Einfach und doch klein genug.

Golf gespielt

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

Prüfung

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

verwenden wie:

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

Erfordert die Eingabe eines std::string

Ungolfed und Nutzung:

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

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

Ich bin mir sicher, dass dies zerstört werden kann, ich habe es in der jetzigen Form überhaupt nicht optimiert.

Nicht golfen:

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

Laufen Sie mit php -r 'code' "string".

C, 149 Bytes, nicht getestet

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

zu rennen, hinzufügen

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

dann kompilieren und ausführen

Python 3, 99 Zeichen

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