Tantangan Anda adalah menulis sebuah program atau fungsi yang menghambat sebuah string. Ini harus mengambil string sebagai input (melalui metode standar apa pun), kemudian ikuti langkah-langkah ini:

1. Menghasilkan bilangan bulat acak (tidak harus seragam) n antara 1 dan 10, inklusif.
2. Tunggu n detik.
3. Cetak n karakter awal / berikutnya dari input, atau sisanya dari input jika ada kurang dari n karakter.
4. Jika ada input yang tersisa untuk dicetak, kembali ke langkah 1.

Aturan

• Input akan selalu berupa string yang tidak kosong yang hanya berisi karakter ASCII (32-126).
• Waktu tunggu tidak harus tepat n detik, tetapi harus dalam waktu 10% dari n .
• Anda dapat mencetak baris tambahan setiap kali bagian teks dicetak.

Contoh

Ruang di sini mewakili 1 detik. Jika inputnya adalah Hiccupinator!, output mungkin:

   Hic     cupin a          tor!

Mencetak gol

Ini adalah kode-golf , jadi kode terpendek dalam byte menang .

Gores, 16 blok + 6 byte

Asumsikan input sudah didefinisikan sebagai daftar karakter ( ["H","e","l","l","o"," ","W","o","r","l","d"])

Pushy , 20 17 16 atau 13 byte

Tergantung pada apa yang diizinkan, ada dua solusi.

16 byte:

@$LT1U&Wm:v;O"cI

Berikan argumen pada baris perintah: $ pushy hiccup.pshy 'hiccupinator'. Ini mencetak dengan mengikuti baris baru setelah setiap 'cegukan'. Berikut rinciannya:

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

Sambil mengkode jawaban di atas, saya menemukan solusi yang jauh lebih singkat:

N@$L1TU&Wm:'.

Meskipun melakukan hal yang serupa, ia mencetak langsung dari string daripada membangun string baru, untuk lebih sedikit byte. Ini membutuhkanN di awal program untuk mencegah tertinggal baris baru, atau karakter masing-masing akan berada di baris baru.

Namun, sementara pengujian ini saya melihat bug - stdoutbuffer-line, sehingga program akan menunggu panjang penuh, dan kemudian menampilkan string cegukan.

Saya telah memperbaiki ini di komit terbaru dengan menambahkan sederhana .flush()- ini secara teknis tidak menambahkan fitur baru ke bahasa, hanya memperbaiki bug, tapi saya mengerti jika Anda tidak memperhitungkan jawaban ini :)

Rinciannya seperti ini:

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

disimpan 2 byte berkat @zeppelin

Menyalahgunakan toleransi 10% untuk waktu tunggu dengan menunggu n<<10 === 1024*nmilidetik.

Karena Anda mengatakan bahwa waktu tunggu harus dalam 10% dari n , saya memutuskan untuk menghemat satu byte dan menunggu 999 milidetik daripada 1 detik.

Saya tidak perlu lagi konyol 999 milidetik berkat @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 terima kasih kepada Flp.Tkc

Saya yakin ada cara untuk mempersingkat random.randintdan time.sleep, tetapi from random,time import*tidak berhasil ...

Perl 6 , 62 byte

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

Diperluas

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

Menggunakan set/pn=<nulakan memberikan efek yang lebih baik kecuali itu memangkas ruang.

Pyth, 16 byte

Wz.d_JhOT<zJ=>zJ

Kamu bisa mencobanya secara online , tetapi tidak berfungsi dengan baik karena penerjemah online hanya menampilkan output setelah program selesai.

Penjelasan

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

Bagaimana itu bekerja

Cobalah online! Compiler online memang secara bertahap menghasilkan output dengan jeda.

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

Sebuah solusi dalam BASIC. Fungsi RANDOM () menghasilkan angka antara 0 dan n-1, oleh karena itu kita harus menggunakan RANDOM (11) untuk mendapatkan angka antara 0 dan 10 inklusif.

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

Sesi sampel, baris pertama adalah input, kedua output:

Hiccupinator!
Hiccupi       nato    r!

Perl, 42 byte

41 byte kode +1 untuk -n.

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

Saya harus memaksa Perl untuk menyiram output karena tidak menunjukkan apa pun sampai akhir pada awalnya, maka pengaturan $|. Kami menggunakan $-untuk melacak jumlah karakter printkarena ini tidak boleh negatif (jadi saya bisa menggunakan --$-dan itu akan menjadi palsu ketika kosong) dan juga floor, meskipun karena saya menggunakan kembalinyasleep untuk ini sekarang, itu tidak tidak masalah.

Pemakaian

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

Ruby, 56 byte

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

Lambda rekursif. Sebut seperti f["Hello, World!"].

> <> (Ikan) 103 88 Bytes

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

Penerjemah online ditemukan di sini!

Upaya pertama pada masalah ini (bukan golf).

Ia menunggu sejumlah loop (n) karena ikan tidak memiliki timer yang dapat diakses (Eksekusi dalam kutu).

Sunting 1: Memindahkan baris terakhir ke atas (2 karakter terakhir dan menggunakan kembali nilai awal. (Penghematan 15 byte).

Bash, 78 byte

Karena belum ada yang memposting solusi Bash, ini dia. Mudah, namun cukup kecil.

Golf

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

Uji

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

gunakan seperti:

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

Membutuhkan input untuk menjadi std::string

Tidak digabungkan dan digunakan:

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

Saya yakin ini bisa dihancurkan, saya belum benar-benar mengoptimalkannya sama sekali.

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

Jalankan dengan php -r 'code' "string".

C, 149 byte, tidak diuji

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

untuk menjalankan, tambahkan

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

kemudian kompilasi dan jalankan

Python 3, 99 karakter

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