Hiccup a string

Question

Your challenge is to write a program or function that hiccups a string. It should take a string as input (via any standard method), then follow these steps:

1. Generate a (not necessarily uniformly) random integer n between 1 and 10, inclusive.
2. Wait n seconds.
3. Print the initial/next n chars of the input, or the rest of the input if there are less than n chars.
4. If there is input left to print, go back to step 1.

Rules

• The input will always be a non-empty string containing only ASCII chars (32-126).
• The wait time does not have to be exactly n seconds, but it must be within 10% of n.
• You may print a trailing newline each time a section of text is printed.

Example

A space here represents 1 second. If the input is Hiccupinator!, an output might be:

   Hic     cupin a          tor!

Scoring

This is code-golf, so the shortest code in bytes wins.

Answer 1

Scratch, 16 blocks + 6 bytes

Assumes input is already defined as a list of characters (["H","e","l","l","o"," ","W","o","r","l","d"])

Answer 2

Pushy, 20 17 16 or 13 bytes

Depending on what's allowed, there are two solutions.

16 bytes:

@$LT1U&Wm:v;O"cI

Give arguments on the command line: $ pushy hiccup.pshy 'hiccupinator'. This prints with trailing newlines after each 'hiccup'. Here's the breakdown:

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

While coding the above answer I came up with this significantly shorter solution:

N@$L1TU&Wm:'.

Although it does a similar thing, it prints directly off the string rather than constructing a new string, for fewer bytes. This requires the N at the beginning of the program to prevent trailing newlines, or else each character would be on a newline.

However, whilst testing this I noticed a bug - stdout is line-buffered, so the program would wait the full length, and then display the hiccuped string.

I've fixed this in the latest commit by adding a simple .flush() - this is technically not adding a new feature to the language, just fixing a bug, but I understand if you don't take this answer into account :)

The breakdown looks like this:

        % 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

Answer 3

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

saved 2 bytes thanks to @zeppelin

Abuses the 10% tolerance for the wait time by waiting n<<10 === 1024*n milliseconds.

Since you said that the wait time needs to be within 10% of n, I decided to save one byte and wait for 999 milliseconds rather than 1 second.

I don't need the 999 millisecond silliness anymore thanks to @ETHProductions

Answer 4

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 thanks to Flp.Tkc

I'm sure there is a way to shorten the random.randint and time.sleep, but from random,time import* doesn't work...

Answer 5

Perl 6, 62 bytes

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

Expanded

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

Answer 6

CJam, 28 bytes

q{Amr)__e3es+{_es>}g;2$<o>}h

Try it online! Or actually, don't. The effect doesn't really show up in any online interpreter, so try it on the Java interpreter instead.

Turns out, CJam has an operator that gets the current Unix timestamp. This program waits by entering a while loop until the timestamp passes the correct value.

Answer 7

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

Using set/pn=<nul would have given a nicer effect except that it trims spaces.

Answer 8

Pyth, 16 bytes

Wz.d_JhOT<zJ=>zJ

You can try it online, but it doesn't work well since the online interpreter only displays the output once the program has finished.

Explanation

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

Answer 9

MATL, 19 bytes

`10YrtY.ynhX<:&)wDt

How it works

Try it online! The online compiler does gradually produce the outputs with the 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

Answer 10

BaCon, 93 bytes

A solution in BASIC. The RANDOM() function generates a number between 0 and n-1, therefore we have to use RANDOM(11) to get a number between 0 and 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

Sample session, first line is the input, second the output:

Hiccupinator!
Hiccupi       nato    r!

Answer 11

Perl, 42 bytes

41 bytes code + 1 for -n.

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

I had to force Perl to flush output as it wasn't showing anything 'til the end at first, hence setting $|. We use $- to track the number of characters to print as this cannot be negative (so I can use --$- and it'll sill be falsy when it's empty) and it also floors, although since I'm using the return of sleep for this now, that doesn't really matter.

Usage

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

Answer 12

Ruby, 56 bytes

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

A recursive lambda. Call like f["Hello, World!"].

Answer 13

><> (Fish) 103 88 Bytes

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

Online interpreter found here!

First attempt at this problem (not golfed).

It waits a certain amount of loops(n) as fish doesn't have a timer that is accessible (Execution in ticks).

Edit 1: Moved last line across to the top (last 2 characters and re-used the starting values. (saving of 15 bytes).

Answer 14

Bash, 78 bytes

As nobody has posted a Bash solution yet, here is one. Straightforward, yet small enough.

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

Answer 15

PHP, 81 bytes

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

use like:

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

Answer 16

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

Requires input to be a std::string

Ungolfed and usage:

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

Answer 17

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

I'm sure this can be destroyed, I haven't really optimised it at all as it stands.

Un-golfed:

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

Answer 18

PHP, 74 bytes

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

Run with php -r 'code' "string".

Answer 19

C, 149 bytes, not tested

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

to run, add

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

then compile and execute

Answer 20

Python 3, 99 chars

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

Answer 21

Assembly (NASM, 32-bit, Linux), 278 bytes

The signature is void f(char* msg, int len). The standard x86 calling convetion is used. Therefore, msg is in ecx, and len is in edx. The random number is generated as time(0)%10+1.

f:push ebx
mov esi,ecx
mov edi,edx
push 0
l:mov ebx,0
mov eax,13
int 128
mov edx,0
mov ecx,10
div cx
inc dx
push edx
mov cx,0
mov ebx,esp
mov eax,162
int 128
pop edx
cmp edx,edi
cmova dx,di
mov ecx,esi
mov ebx,1
mov ax,4
int 128
add esi,edx
sub edi,edx
jnz l
pop eax
pop ebx
ret

Try it online!

Answer 22

C++ (gcc), 109 bytes

#include<unistd.h>
int f(char*s){for(int n,m=0;*s;)for(sleep(m=n=(getpid()+m)%10+1);*s&&n--;)write(1,s++,1);}

Try it online!

-10 bytes thanks to ceilingcat

-8 bytes thanks to ceilingcat

Answer 23

C (gcc), 71 bytes

n;f(char*s){while(*s)for(sleep(n=time(0)%10+1);*s&&n--;)putchar(*s++);}

Try it online!

-1 byte thanks to ceilingcat