tło

echoProgram jest tak czysty. Możesz coś na to powiedzieć, a za każdym razem doskonale powtarza twoje słowa! Jakie to jest świetne! Rozczarowujące, powtarza to wejście naraz, niezależnie od prędkości pisania, co nie jest zbyt realistyczne. Będziemy musieli to naprawić.

Zadanie

Twój program pobiera dane wejściowe ze STDIN lub najbliższego odpowiednika. Powinien odczytywać wiersze od użytkownika jeden po drugim, być może wyświetlać jakieś monity, dopóki nie wejdzie w pusty wiersz. Następnie wypisze linie do STDOUT lub najbliższego odpowiednika, w tej samej kolejności, w jakiej zostały podane. Ostatnia (pusta) linia nie jest drukowana, a ostatnia drukowana linia nie musi mieć końca nowej linii.

Ponadto program zachowuje przedziały czasowe między poszczególnymi liniami: jeśli xwejście linii zajęło xsekundom użytkownika, wydrukowanie go zajmie kilka sekund. Dotyczy to również pierwszego i ostatniego wiersza; pusta linia nie jest drukowana, ale program i tak czeka przed zakończeniem.

Przykład

Oto przykładowa sesja z programem. Wszystkie działania, które nie powodują wygenerowania tekstu, są opisane w nawiasach, a monit (opcjonalny) jest wyświetlany jako >.

[begin program]
> fhtagn[enter; 1.48s passed since starting program]
> yum yum[enter; 3.33s passed since previous enter]
> so cool![enter; 2.24s passed since previous enter]
> [enter; 0.23s passed since previous enter]
[wait 1.48s]fhtagn
[wait 3.33s]yum yum
[wait 2.24s]so cool!
[wait 0.23s, then end program]

Bez działań sesja wygląda następująco:

> fhtagn
> yum yum
> so cool!
> 
fhtagn
yum yum
so cool!

Zasady i punktacja

Czasy oczekiwania powinny być dokładne z dokładnością do 0,01 sekundy (w praktyce, jeśli przeciętny człowiek nie potrafi odróżnić, nic ci nie jest). Wygrywa najniższa liczba bajtów, a standardowe luki są niedozwolone. Jeśli twój język ma wbudowaną funkcję dokładnie do tego zadania, nie możesz go używać.

CJam, 45 41 39 36 34 bajtów

{eslN1$}g;es](es-fm3/{){_es>}g;o}/

Oczywiście to nie ma sensu w tłumaczu online, ale działa w tłumaczu Java.

Nie wyświetla monitu.

Wyjaśnienie

{        e# Do while... (popping the condition from the stack)
  es     e#   Get the current timestamp.
  l      e#   Wait for a line to be entered and read it.
  N      e#   Push a linefeed.
  1$     e#   Copy the line we read - this terminates if the line is empty, because
         e#   empty strings/arrays are falsy.
}g
;        e# Discard the last linefeed (the one after the empty input).
es       e# Push the current timestamp (corresponding to the last, empty, input).
]        e# Wrap everything in an array. This is now a flat array containing:
         e#   - The initial timestamp.
         e#   - Three elements for each line: the line, a linefeed, the timestamp.
         e#   - Two elements for the last line: the empty string and the timestamp.
(        e# Pull off the initial time.
es-      e# Subtract the current time, which gives (minus) the difference between
         e# when a line was entered and when it should be printed back.
fm       e# This maps "minus that value" onto each element in the array. Now the lines
         e# and linefeeds are strings (arrays) - so minus is set difference, but they
         e# only contain characters, not any integers (like the difference value), so
         e# none of the strings will be affected.
         e# The timestamps on the other hand will be incremented by the time difference
         e# between reading and printing, giving the time at which each line should be
         e# printed back.
3/       e# Split the array into chunks of 3 (where the remaining two elements are
         e# just grouped as a pair).
{        e# For each of those chunks...
  )      e#   Pull off the timestamp.
  {      e#   Do while... (popping the condition from the stack)
    _    e#     Duplicate the target time.
    es>  e#     Check if it's still greater than the current time.
  }g
  ;o     e# Discard the target time and print the rest of the current chunk, which will
         e# automatically be flattened/concatenated into a single string.
}/

JavaScript, 119 112 bajtów

k=(d=Date.now)(i=j=[]);do{i[++j]=[prompt(),d()-k]}while(i[j][0]);i.map(a=>setTimeout(b=>console.log(a[0]),a[1]))

Mam nadzieję znaleźć jeszcze kilka bajtów do wycięcia.

JavaScript, 120 bajtów

Przy takim podejściu nie ma szans na zbliżenie się do CJam, ale prosty skrypt.

a=[];t=+new Date;while(s=prompt()){a.push({s:s,t:+new Date})}while(v=a.pop()){setTimeout(`console.log('${v.s}')`,v.t-t)}

Pyth, 68 bajtów

M&p+Gb$__import__('time').sleep(H)$J].dZWeaYwaJ.dZ)aJ.dZp&gVPY-VtJJk

Zmarnowałem dużo bajtów na wywołanie sleep, ponieważ Pyth nie ma żadnej sleepfunkcji.

Ruby, 74

t,*a=Time.now
a<<[$_,t-t=Time.now]while$/<gets
a.map{|l,i|sleep -i;puts l}

Sztuczki: *aw pierwszym wierszu inicjuje pustą tablicę. Mógłbym $*zamiast tego użyć, ale jest dość szkicowy, ponieważ jest zapełniony niektórymi inwokacjami i oszczędza mi tylko bajt. $/jest nową linią i $_jest ostatnią linią pobraną przez gets.

Edycja: Spanie na końcu kosztuje 20 bajtów więcej, prawdopodobnie sposób na grę w golfa

t,*a=Time.now
a<<[$_,t-t=Time.now]while$/<gets
t-=Time.now
a.map{|l,i|sleep -i;puts l}
sleep -t

Python 3, 124

Działa tylko na platformach Windows

from time import*
s=[(1,clock())]
while s[-1][0]:s+=[(input(),clock()-s[-1][1])]
[sleep(y)or x and print(x)for x,y in s[1:]]

Przechowywanie danych wejściowych i czasów na osobnych listach kosztuje mnie jeszcze 3 bajty . Prawdopodobnie nie najlepsze podejście.

129-bajtowa wersja uniksowa, z podziękowaniami dla Mego :

from time import*
t=time
s=[(1,t())]
while s[-1][0]:s+=[(input(),t(),t()-s[-1][1])]
[sleep(y)or x and print(x)for x,z,y in s[1:]]

SWI-Prolog, 185 bajtów

a:-b([],S),reverse(S,T),c(T),!.
b(R,S):-get_time(X),read_string(user_input,"\n","",_,A),get_time(Y),Z is Y-X,(A="",S=[A:Z|R];b([A:Z|R],S)).
c([A:Z|T]):-sleep(Z),T=[];(write(A),nl,c(T)).

Gra w golfa jest prawdopodobnie bardzo duża, ale na razie wystarczy ...

PowerShell, 261 190 121 95 bajtów

$(do{Measure-Command{$l=read-host};$l}while($l))|%{($_,(sleep -m($_.Ticks/1e4)))[($b=!$b+!$_)]}

_{Rekwizyty dla TessellatngHeckler i tomkandy za pomoc w golfie i inspirację}

Jest to bardzo podobne pojęcie do 121-bajtowej wersji poniżej, po prostu dynamicznie tworzymy i budujemy listę obiektów, zamiast przechodzić przez pętlę while, aby przechowywać je w jawnej tablicy $a. W obu przypadkach ta lista obiektów zostaje potokowana w tej samej pętli foreach |%{...}. Indeksowanie do selektora tablic wyników ($b=!$b+!$_)jest tym razem sformułowane w celu wyeliminowania if($_){$_}poniższych iteracji, co pozwala zaoszczędzić jeszcze kilka bajtów.

Poprzednio 121 bajtów

$l,$a=1,@();while($l){$t=Measure-Command{$l=read-host};$a+=$t,$l}$a|%{($(if($_){$_}),(sleep -m($_.Ticks/1e4)))[($b=!$b)]}

Rozszerzony i wyjaśniony:

$l,$a=1,@()                        # Set variable $l and create array $a
while($l){                         # So long as we don't have a blank line
  $t=Measure-Command{$l=read-host} # Read the input and measure time to input
  $a+=$t,$l                        # Add those values into the array
}
$a|%{                              # For each item in $a, do
  ($(if($_){$_}),(sleep -m($_.Ticks/1e4)))[($b=!$b)]
  # Magic happens here ... first, we set $b to the NOT of it's uninitialized
  # value, so $b is initially set to truthy
  # This value in [...] selects which of the two elements ( , ) get selected
  # Truthy to start means the second command, sleep, gets chosen first, and
  # then it alternates every next item, so it sleeps, then prints, then
  # sleeps, then prints, etc., until we run out of $a
}

Poprzednio, 190 bajtów

function f {param($m)sleep -m $a[$m].totalmilliseconds}$a=1,1;while($a[-1]-ne""){$a+=Measure-Command{$b=read-host};$a+=$b}if(!($a[3])){f 2;exit}$i=2;while($i-lt$a.length){f($i++);$a[($i++)]}

function f {                        # Define a new function
  param($m)                         # with $m as input
  sleep -m $a[$m].totalmilliseconds # sleep for $a[$m] milliseconds
}
$a=1,1                              # Create new array with two elements
while($a[-1]-ne""){                 # While the last element isn't empty
  $a+=Measure-Command{$b=read-host} # Read into $b and measure how long that took,
                                    # and add the time into $a
  $a+=$b                            # Then add the input into $a
}
if(!($a[3])){                       # If the third element is empty, the user entered
                                    # a blank as the only input, so...
  f 2                               # sleep for $a[2] ms (how long it took them to hit enter)...
  exit                              # and exit the script
}                                   # Else ...
$i=2                                # Set a counter variable
while($i-lt$a.length){              # While we haven't reached the end of $a
  f($i++)                           # Sleep
  $a[($i++)]                        # Write the output
}

Poprzednio, 261 bajtów

$a=$d=@();$d+=,@(date);$x=Read-Host
while($x){$a+=,@($x);$d+=,@(date);$x=Read-Host}
if($x){0..($a.Length-1)|%{sleep -m((($d[$_+1]).ticks-($d[$_]).ticks)/1e4);$a[$_]};sleep -m((($d[-1]).ticks-($d[-2]).ticks)/1e4)}
else{sleep -m(((date).Ticks-($d[0]).Ticks)/1e4)}

Święta gadatliwość, Batman! Rozbijmy to:

$a=$d=@()                  # Create two empty arrays
$d+=,@(date)               # Add the current time into $d
$x=Read-Host               # Read the first line
while($x){                 # So long as it's not empty
  $a+=,@($x)               # Add it into our output array
  $d+=,@(date)             # Add the current time into $d
  $x=Read-Host             # Get the next line
}
if($a){                    # So long as $a exists (i.e., the first input wasn't blank)
  0..($a.Length-1)|%{      # For-loop over the length
                           # Sleep for how long it took to do input
    sleep -m((($d[$_+1]).ticks-($d[$_]).ticks)/1e4)
    $a[$_]                 # Print out the input
  }
                           # Sleep the length it took for the final blank
  sleep -m((($d[-1]).ticks-($d[-2]).ticks)/1e4)
}
else{
                           # If we're here, the initial input was blank, so just sleep
  sleep -m(((date).Ticks-($d[0]).Ticks)/1e4)
}

Perl 6, 70 znaków

repeat {$/=now;.push($!=get,now -$/)}while $!;.map:{sleep $^b;say $^a}

Interpreter Perla 6 definiuje tylko trzy zmienne symboliczne (w przeciwieństwie do szaleństwa Perla 5). Aby być dokładnym, $/, $!, i $_. Ten program wykorzystuje je wszystkie, aby uniknąć kosztów deklarowania zmiennych my.

getczyta wiersz ze STDIN. Nie zawiera nowej linii, w przeciwieństwie do Perla 5.

nowwbudowany zwraca bieżącą godzinę. Po odjęciu daje interwał, który można przekazać do łańcucha.

Metoda bez niczego po lewej stronie (jak .pushi .mapw tym kodzie) działa $_.

Korzystając z repeat whilepętli (znanej jak do whilew innych językach programowania), Perl 6 zapisuje bieżący znacznik czasu $/i wypycha odebraną linię (do której również przechowuje $!) oraz różnicę między bieżącym czasem i znacznikiem czasu $/. Ze względu na kolejność parametrów nownie jest obliczany, dopóki nie zostanie odebrany wiersz.

Do whilekontroli stanu jeśli linia nie jest pusty (w Perl 6, "0"jest prawdziwa wartość, w przeciwieństwie Perl 5).

Po uzyskaniu wszystkich znaczników czasu i linii, po prostu dostarczam te do mapoddzwaniania, które trochę śpi i mówi, co zostało powiedziane.

Groovy, 202 bajty

def b={System.currentTimeMillis()};def h=[];for(;;){def t=b();def s=System.console().readLine();h.add(s+" "+(b()-t));if(s=="")break};for(def s:h){Thread.sleep((s=s.split(" "))[1].toLong());println s[0]}

Rodnik.

Wersja bez golfa:

def b = {System.currentTimeMillis()}; // Creates a closure (short function) b that returns the current time since the epoch in milliseconds.
def h = []; // Makes an empty list
for(;;) { // Infinite loop
  def t = b(); // Get the time
  def s = System.console().readLine(); // Read a line
  h.add(s + " " + b()-t); // Add the string plus the amount of time elapsed to the list
  if(s=="") // If the string is blank
    break; // Exit loop
}
for(def s : h) { // Iterate through array
  Thread.sleep((s=s.split(" "))[1].toLong()); // Splits s into an array and puts the value in s, then takes the second element (the time), converts into a long and sleeps for that time.
  println s[0] // Print the first element (text)
}

JavaScript (ES6) 102

Łącząc wysiłki Mwr247 i Dom Hastings (CW)

/* for TEST */ console.log=x=>O.innerHTML+=x+'\n'

for(k=new Date,i=[];p=prompt();i.push([p,new Date]));i.map(a=>setTimeout(b=>console.log(a[0]),a[1]-k))

<pre id=O></pre>

MATLAB, 107 99

tic;a={};i=1;while nnz(i);i=input('','s');a=[a;{i,toc}];tic;end;for b=a';pause(b{2});disp(b{1});end

I bez golfa:

tic; %Start timer
a={};
i=1; %Make us enter the while loop
while nnz(i); %While i has some non-zero elements (this is used to detect a zero length input where we end)
    i=input('','s'); %Get an input string
    a=[a;{i,toc}]; %Append the string and current time as a new cell in a
    tic; %Restart timer
end
for b=a' %For each input
    pause(b{2}); %Wait for the required time
    disp(b{1}); %Then print the string
end

Nie będzie to w 100% dokładne taktowanie, ponieważ nie uwzględnia czasu potrzebnego na wyświetlenie każdego łańcucha, ale powinno to być dość szybkie, więc czas powinien być dość zbliżony.

Po szybkiej wizycie zapisałem kilka bajtów, usuwając dwuwarstwową tablicę głębokich komórek. Okazuje się, że wszystko, czego potrzebowałem, to ;prawidłowe rozdzielenie podczas pakowania.

Java, przy użyciu wersji 1.04 tej biblioteki , 385 bajtów

import sj224.lib.util.*;import java.util.*;class E{static long t(){return System.currentTimeMillis();}public static void main(String[]a) throws Exception{List<Pair<?,Long>>l=new ArrayList();Scanner i=new Scanner(System.in);while(true){long t=t();String s=i.nextLine();if(s.isEmpty())break;l.add(new Pair(s,t()-t));}for(Pair<?,Long>p:l){Thread.sleep(p.two);System.out.println(p.one);}}}

Caché ObjectScript, 123 bajty

w() q $P($ZTS,",",2)
r f  s i=i+1,t=$$w() r x,! q:x=""  s g(i,x)=$$w()-t
    f i=1:1 s s=$O(g(i,"")) q:s=""  w s,! h g(i,s)
    q

Jak zwykle zakłada to czystą tablicę symboli przed uruchomieniem d r.

Ten problem nie może zostać rozwiązany w ANSI MUMPS, ponieważ standard ANSI wymaga tylko rozdzielczości drugiego poziomu dla właściwego czasu $H[OROLOG]. Na szczęście Intersystems Caché, która jest obecnie wiodącą w branży platformą dla MUMPS, zapewnia wewnętrzną definicję implementacji$ZT[IME]S[TAMP] , która zapewnia rozdzielczość na poziomie mikrosekund.

(Wynik był wcześniej 105 bajtów, ale wystąpił błąd).

C ++ 11, 343 338 bajtów

Chciałem zobaczyć, ile bajtów potrzebny jest do tego kod w c ++. O wiele więcej niż się spodziewałem. Może zbyt skomplikowałem rozwiązanie.

#include<iostream>
#include<vector>
#include<chrono>
int i;using namespace std;int main(){auto n=chrono::system_clock::now;auto t=n();string s{1};vector<string>r;vector<decltype(t-t)>w;while(s.size())getline(cin,s),r.push_back(s),w.push_back(n()-t),t=n();while(i<r.size()){while((n()-t)<w[i]);t=n();cout<<r[i++]<<(i<r.size()-1?"\n":0);}}  

Zobaczmy, czy mogę to jakoś zmniejszyć.

Bash, 91 90 bajtów

while r=`\time -fsleep\ %e head -1`
[[ $r ]]
do printf{,\ %%b\ %q\;} "$r
"
done>t 2>&1
. t

Spowoduje to utworzenie pliku tymczasowego t. Zastąpi istniejący plik o tej samej nazwie.

Sam pomysł jest dość krótki, ale radzenie sobie ze znakami specjalnymi na wejściu dodaje około 15 bajtów ...

VBA, 233 228 bajtów

Jestem pewien, że można dużo grać w golfa. nie określili, ile wejść, więc na stałe zakodowałem moje długości tablicy, ponieważ są one krótsze Redim preserve.

Wejście jest przez okienko, wyjście debug.printponieważ msgboxwytwarza modalnych i zatrzymuje kod.

Nie wiem, jak sprawdzić, czy jest to dokładne z dokładnością do 0,01 s. Być może ktoś może przetestować, ale podaję komendę oczekiwania w taki sposób, że POWINNA ona używać milisekund, ale VBA nie jest znana z robienia tego, co powinna.

If gotoMoże być w stanie być podstawiony oraz golfed Do Loop While.

Sub a()
Dim k(99) As String
Dim h(99) As Date
b:
t=Now()
i=i+1
k(i)=InputBox("")
h(i)=Now()-t
If k(i)<>"" Then GoTo b
For u=1 To i
Application.Wait (Now()+(Format(h(u),"s")&Format(h(u),"ms"))/10^8)
Debug.Print k(u)
Next
End Sub

Nie będzie działać w programie Access VBA, ponieważ dostęp nie ma polecenia czekania, ponieważ Microsoft nienawidzi spójności

SmileBASIC, 122 bajty

DIM A$[0],T[0]@L
C=MAINCNT
LINPUT S$PUSH A$,S$PUSH T,MAINCNT-C
IF""<S$GOTO@L@P
WAIT SHIFT(T)IF""<A$[0]THEN?SHIFT(A$)GOTO@P

Myślę, że można to nieco skrócić.

C UNIX, 272 bajty

#include <stdio.h>
#include <unistd.h>
#define P printf
i;r;c;main(){char*L[99]={0};size_t s;long T[99]={0};while(1){P(">  ");T[c]=time(0);r=getline(&L[c],&s,stdin);T[c]=time(0)-T[c];if(r==-1|!(*L[c]-10))break;c++;}while(i<c){P("> ");usleep(T[i]*1000);P("%s", L[i]);i++;}}

Szczegółowy

#include <stdio.h>
#include <unistd.h>

int main(void)
{
    int i = 0, c = 0, r;
    char * L[99] = {0};
    size_t size;
    long T[99] = {0L};

    while(1)
    {
        printf("> ");
        T[c] = time(0);
        r = getline(&L[c], &size, stdin);
        T[c] = time(0) - T[c];
        if(r == (-1)) break;
        if(*L[c]=='\0' || *L[c]=='\n') break;
        c = c + 1;
    }

    while(i < c)
    {
        printf(" %ld > ",T[i]);
        usleep(T[i]*1000);
        printf("%s", L[i]);
        i = i + 1;
    }

    return 0;
}