Hintergrund

Das echoProgramm ist so ordentlich. Sie können alles dazu sagen, und es wiederholt Ihre Worte jedes Mal perfekt! Wie cool ist das! Enttäuschenderweise wiederholt es die Eingabe auf einmal, unabhängig von Ihrer Tippgeschwindigkeit, was nicht sehr realistisch ist. Das müssen wir reparieren.

Die Aufgabe

Ihr Programm muss seine Eingabe von STDIN oder einem ähnlichen Programm erhalten. Es liest nacheinander die Zeilen des Benutzers und zeigt möglicherweise eine Eingabeaufforderung an, bis eine leere Zeile eingegeben wird. Danach werden die Zeilen in der angegebenen Reihenfolge an STDOUT oder eine gleichwertige Stelle ausgegeben. Die letzte (leere) Zeile wird nicht gedruckt, und die letzte gedruckte Zeile muss keine nachgestellte neue Zeile enthalten.

Außerdem muss das Programm die Zeitintervalle zwischen den einzelnen Zeilen beibehalten: Wenn der Benutzer xSekunden für die Eingabe einer Zeile benötigt hat, benötigt xdas Programm Sekunden, um diese auszudrucken. Dies gilt auch für die erste und letzte Zeile. Die leere Zeile wird nicht gedruckt, aber das Programm wartet trotzdem, bevor es beendet wird.

Beispiel

Hier ist eine Beispielsitzung mit dem Programm. Alle Aktionen, die keinen Text erzeugen, sind in Klammern angegeben, und die (optionale) Eingabeaufforderung wird als angezeigt >.

[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]

Ohne die Aktionen sieht die Sitzung folgendermaßen aus:

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

Regeln und Wertung

Die Wartezeiten sollten auf 0,01 Sekunden genau sein (in der Praxis geht es Ihnen gut, wenn der Durchschnittsmensch den Unterschied nicht erkennen kann). Die niedrigste Byteanzahl gewinnt, und Standardlücken sind nicht zulässig. Wenn Ihre Sprache eine integrierte Funktion für genau diese Aufgabe hat, können Sie sie möglicherweise nicht verwenden.

CJam, 45 41 39 36 34 Bytes

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

Das macht im Online-Interpreter natürlich keinen Sinn, funktioniert aber im Java-Interpreter.

Es wird keine Eingabeaufforderung angezeigt.

Erläuterung

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

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

In der Hoffnung, noch ein paar Bytes zum Ausschneiden zu finden.

JavaScript, 120 Byte

Keine Chance, mit diesem Ansatz an CJam heranzukommen, aber ein einfaches Skript.

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 Bytes

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

Verschwendete eine Menge von Bytes auf den Anruf sleep, da Pyth keine hat sleepFunktion.

Ruby, 74

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

Tricks: In *ader ersten Zeile wird ein leeres Array initialisiert. Ich könnte es $*stattdessen verwenden, aber es ist ein wenig lückenhaft, da es mit einigen Aufrufen gefüllt ist und mir nur ein Byte erspart. $/ist eine neue Zeile und $_ist die letzte Zeile, die von abgerufen wurde gets.

Bearbeiten: Schlafen am Ende kostet 20 weitere Bytes, wahrscheinlich eine Möglichkeit, es nach unten zu spielen

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

Funktioniert nur auf Windows-Plattformen

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

Das Speichern der Eingabe und der Zeiten in separaten Listen kostet mich 3 weitere Bytes . Wahrscheinlich nicht der beste Ansatz.

Eine 129-Byte-Unix-freundliche Version, die Mego zu Gute kommt :

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 Bytes

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

Hier gibt es wahrscheinlich viel zu golfen, aber das reicht fürs Erste ...

PowerShell, 261 190 121 95 Bytes

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

_{Props to TessellatngHeckler und Tomkandy für die Golfunterstützung und Inspiration}

Das Konzept ist der 121-Byte-Version unten sehr ähnlich. Wir erstellen und erstellen lediglich dynamisch eine Liste von Objekten, anstatt eine while-Schleife zu durchlaufen, um sie in einem expliziten Array zu speichern $a. In beiden Fällen wird diese Liste von Objekten in dieselbe foreach-Schleife weitergeleitet |%{...}. Die Indizierung in den Ergebnis-Array-Selektor ($b=!$b+!$_)wird diesmal so formuliert, dass if($_){$_}die folgenden Iterationen eliminiert werden , wodurch einige weitere Bytes eingespart werden.

Zurück 121 Bytes

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

Erweitert und erklärt:

$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
}

Vorher 190 Bytes

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
}

Vorher-Er-Er, 261 Bytes

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

Heilige Ausführlichkeit, Batman! Lassen Sie es uns aufschlüsseln:

$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 Zeichen

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

Perl 6-Interpreter definiert nur drei symbolische Variablen (im Gegensatz zur Verrücktheit von Perl 5). Um genau zu sein, $/, $!, und $_. Dieses Programm verwendet sie alle, um die Kosten für die Deklaration von Variablen zu vermeiden my.

getliest eine Zeile aus STDIN. Im Gegensatz zu Perl 5 enthält es keinen Zeilenumbruch.

nowbuiltin gibt eine aktuelle Zeit zurück. Wenn subtrahiert, gibt es ein Intervall, das an eine Zeichenfolge übergeben werden kann.

Eine Methode mit nichts auf der linken Seite (wie .pushund .mapin diesem Code) funktioniert $_.

Verwendung repeat whileSchleife (bekannt als do whilein anderen Programmiersprachen), Perl 6 schreibt aktuelle Zeitstempel zu $/, und schiebt die empfangenen Zeile (die es speichert auch zu $!), und die Differenz zwischen aktueller Zeit und Zeitstempeln in $/. Wird aufgrund der Parameterreihenfolge nowerst berechnet, wenn eine Zeile empfangen wird.

Die whileBedingung prüft, ob die Zeile nicht leer ist (in Perl 6 "0"ist sie im Gegensatz zu Perl 5 ein wahrer Wert).

Nachdem ich alle Zeitstempel und Zeilen erhalten habe, gebe ich diese einfach an den mapRückruf weiter, der ein bisschen schläft und sagt, was gesagt wurde.

Groovy, 202 Bytes

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]}

Radikale.

Ungolfed-Version:

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

Zusammenführung der Bemühungen von Mwr247 und 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

Und ungolfed:

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

Dies ist im Timing nicht 100% genau, da es nicht die Zeit berücksichtigt, die zum Anzeigen der einzelnen Zeichenfolgen benötigt wird, aber das sollte ziemlich schnell sein, so dass es im Timing ziemlich genau sein sollte.

Nach einem kurzen Rückblick habe ich ein paar Bytes gespart, indem ich das Double-Layer-Deep-Cell-Array entfernt habe. Es stellte sich heraus, dass alles, was ich brauchte, ein war ;, um es beim Packen richtig aufzuteilen.

Java, mit Version 1.04 dieser Bibliothek , 385 Bytes

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 Byte

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

Dies setzt wie üblich eine saubere Symboltabelle voraus, bevor es ausgeführt wird d r.

Dieses Problem kann in ANSI MUMPS nicht gelöst werden, da der ANSI-Standard nur eine Auflösung der zweiten Ebene für die eigentliche Zeit erfordert $H[OROLOG]. Glücklicherweise bietet Intersystems Caché, derzeit die branchenführende Plattform für MUMPS, die implementierungsdefinierte Lösung$ZT[IME]S[TAMP] intrinsische Auflösung auf Mikrosekundenebene.

(Punktzahl war früher 105 Bytes, aber es gab einen Fehler.)

C ++ 11, 343 338 Bytes

Wollte sehen, wie viele Bytes ein Code dafür in c ++ benötigt. Viel mehr als ich erwartet hatte. Vielleicht habe ich die Lösung zu kompliziert.

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

Mal sehen, ob ich das irgendwie reduzieren kann.

Bash, 91 bis 90 Bytes

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

Dadurch wird eine temporäre Datei erstellt t. Es wird eine vorhandene Datei mit demselben Namen überschrieben.

Die Idee selbst ist ziemlich kurz, aber der Umgang mit Sonderzeichen in der Eingabe fügt ungefähr 15 Bytes hinzu ...

VBA, 233 228 Byte

Ich bin sicher, das kann viel golfen werden. Sie haben nicht angegeben, wie viele Eingänge, so dass ich meine Array-Längen fest codiert, weil es dann kürzer istRedim preserve .

Die Eingabe erfolgt über Pop - up, ausgegeben wird , debug.printweilmsgbox ein MODAL erzeugt und der Code angehalten wird.

Ich weiß nicht, wie ich testen soll, ob dies auf 0,01 s genau ist. Vielleicht kann jemand testen, aber ich gebe dem wait-Befehl die Nummer so, dass sie die Millisekunden verwenden SOLLTE, aber VBA ist nicht dafür bekannt, das zu tun, was es sollte.

Die If gotokönnen eventuell durch eine gut golfene ersetzt werden 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

Funktioniert nicht in Access VBA, da Access keinen Wartebefehl hat, weil Microsoft die Konsistenz hasst

SmileBASIC, 122 Bytes

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

Ich denke, das könnte etwas kürzer gemacht werden.

C UNIX, 272 Bytes

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

Detailliert

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