Contexte

Le echoprogramme est tellement soigné. Vous pouvez tout dire, et il répète vos mots à la perfection! À quel point cela est cool! De manière décevante, il répète l'entrée en une seule fois, quelle que soit votre vitesse de frappe, ce qui n'est pas très réaliste. Nous devrons résoudre ce problème.

La tâche

Votre programme utilisera STDIN ou son équivalent le plus proche. Il doit lire les lignes de l’utilisateur une à une, en affichant éventuellement une invite, jusqu’à ce qu’il entre une ligne vide. Après cela, il imprimera les lignes sur STDOUT ou son équivalent le plus proche, dans le même ordre que celles qui ont été données. La dernière ligne (vide) n'est pas imprimée et la dernière ligne imprimée n'a pas besoin de nouvelle ligne.

De plus, le programme doit conserver les intervalles de temps entre chaque ligne: s'il a fallu xquelques secondes à l'utilisateur pour entrer une ligne, xle programme n'a pris que quelques secondes pour l'imprimer. Ceci s’applique aussi aux première et dernière lignes; la ligne vide n'est pas imprimée, mais le programme attend quand même avant de se terminer.

Exemple

Voici un exemple de session avec le programme. Toutes les actions qui ne produisent pas de texte sont décrites entre crochets et l’invite (facultatif) s’affiche sous la forme >.

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

Sans les actions, la session ressemble à ceci:

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

Règles et notation

Les temps d'attente doivent être précis à 0,01 seconde près (en pratique, si un humain moyen ne peut pas faire la différence, tout va bien). Le nombre d'octets le plus faible gagne et les failles standard sont interdites. Si votre langue dispose d'une fonction intégrée pour cette tâche, vous ne pouvez pas l'utiliser.

CJam, 45 41 39 36 34 octets

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

Bien sûr, cela n’a aucun sens pour l’interprète en ligne, mais cela fonctionne pour l’interprète Java.

Il ne affiche pas une invite.

Explication

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

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

En espérant trouver quelques octets de plus à supprimer.

JavaScript, 120 octets

Aucune chance de s'approcher de CJam avec cette approche, mais un script simple.

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 octets

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

Gaspillé beaucoup d'octets sur l'appel à sleep, puisque Pyth n'a aucune sleepfonction.

Ruby, 74

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

Astuces: *asur la première ligne, initialise un tableau vide. Je pourrais utiliser à la $*place, mais c'est un peu sommaire, car il est rempli d'invocations et ne me fait économiser qu'un octet. $/est une nouvelle ligne, et$_ est la dernière ligne récupérée par gets.

Edit: Dormir à la fin coûte 20 octets de plus, probablement un moyen de jouer au golf

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

Ne fonctionne que sur les plateformes 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:]]

Garder les entrées et les heures dans des listes séparées me coûte 3 octets de plus . Probablement pas la meilleure approche.

Une version amicale Unix de 129 octets, avec le crédit de 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 octets

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

Il y a probablement beaucoup à jouer au golf ici, mais ça ira pour le moment ...

PowerShell, 261 190 121 95 octets

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

_{Les accessoires de TessellatngHeckler et Tomkandy pour l'assistance et l'inspiration au golf}

Le concept est très similaire à la version à 121 octets ci-dessous. Nous créons et construisons de manière dynamique une liste d'objets au lieu de passer par une boucle while pour les stocker dans un tableau explicite $a. Dans les deux cas, cette liste d'objets est mise en pipeline dans la même boucle foreach |%{...}. L'indexation dans le sélecteur de tableau de résultats($b=!$b+!$_) est cette fois formulée pour éliminer les if($_){$_}itérations ci-dessous, ce qui économise quelques octets supplémentaires.

Précédent, 121 octets

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

Développé et expliqué:

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

Précédent, 190 octets

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
}

Précédent, 261 octets

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

Sainte verbosité, Batman! Décomposons:

$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 caractères

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

L'interprète Perl 6 ne définit que trois variables symboliques (contrairement à la folie de Perl 5). Pour être exact, $/, $!et $_. Ce programme les utilise tous pour éviter les coûts liés à la déclaration de variables my.

getlit une ligne de STDIN. Il ne contient pas de nouvelle ligne, contrairement à Perl 5.

nowBuiltin renvoie une heure actuelle. Une fois soustrait, il donne un intervalle qui peut être passé à une chaîne.

Méthode avec rien à gauche de celui - ci (comme .pushet .mapdans ce code) fonctionne sur $_.

À l’aide de la repeat whileboucle (appelée do whiledans d’autres langages de programmation), Perl 6 écrit l’horodatage actuel sur $/la ligne reçue (sur laquelle il stocke également $!), et insère la différence entre l’heure et l’horodatage actuels $/. En raison de l'ordre des paramètres,now n'est pas calculé avant la réception d'une ligne.

La whilecondition vérifie si la ligne n'est pas vide (Perl 6 "0"est une valeur vraie, contrairement à Perl 5).

Après avoir obtenu tous les horodatages et les lignes, je fournis simplement ceux qui sont maprappelés, qui dort un peu et dit ce qui a été dit.

Groovy, 202 octets

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

Radical.

Version non-golfée:

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

Rassembler les efforts de Mwr247 et de 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

Et non golfé:

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

Le timing ne sera pas précis à 100%, car il ne prendra pas en compte le temps d'affichage de chaque chaîne, mais cela devrait être assez rapide pour que le timing soit proche.

Après une brève visite, j'ai enregistré quelques octets en supprimant le tableau de cellules profondes à double couche. Il s’est avéré que tout ce dont j'avais besoin était ;de le séparer correctement lors de l’emballage.

Java, en utilisant la version 1.04 de cette bibliothèque , 385 octets

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 octets

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

Comme d'habitude, cela suppose une table de symboles vierge avant de lancer d r .

Ce problème ne peut pas être résolu dans ANSI MUMPS, car la norme ANSI exige uniquement une résolution de second niveau pour le temps intrinsèque $H[OROLOG]. Heureusement, Intersystems Caché, qui est actuellement la plate-forme leader de l'industrie pour MUMPS, fournit l' $ZT[IME]S[TAMP]intrinsèque défini par la mise en œuvre , qui fournit une résolution au niveau de la microseconde.

(Le score était auparavant de 105 octets, mais il y avait un bug.)

C ++ 11, 343 338 octets

Je voulais voir combien d'octets un code pour cela en c ++ aurait besoin. Beaucoup plus que ce à quoi je m'attendais. J'ai peut-être trop compliqué la solution.

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

Voyons si je peux réduire cela d'une manière ou d'une autre.

Bash, 91 90 octets

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

Cela crée un fichier temporaire t. Il écrasera un fichier existant portant le même nom.

L'idée elle-même est assez courte, mais le traitement des caractères spéciaux dans l'entrée ajoute environ 15 octets ...

VBA, 233 228bytes

Je suis sûr que cela peut être beaucoup joué au golf. ils ne spécifiaient pas le nombre d'entrées, donc je codai en dur mes longueurs de tableau parce que c'est plus court queRedim preserve .

L’entrée se fait par popup, la sortie est debug.print parce que msgboxproduit un MODAL et arrête le code.

Je ne sais pas comment vérifier si cela est précis à 0,01s. Peut-être que quelqu'un peut tester mais je donne le numéro à la commande wait d'une manière qui DEVRAIT utiliser les millisecondes, mais VBA n'est pas connu pour faire ce qu'il devrait.

Le If gotopeut être remplacé par un bien joué au golf 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

Ne fonctionnera pas dans Access VBA, car l'accès n'a pas de commande d'attente car Microsoft déteste la cohérence

SmileBASIC, 122 octets

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

Je pense que cela pourrait être légèrement plus court.

C UNIX, 272 octets

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

Détaillé

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

Bash, 22 octets

nc -l 3|nc localhost 3

Tapez ensuite l'entrée et appuyez sur Entrée.