Arka fon

echoProgram çok düzgün. Bir şey söyleyebilirsin ve her seferinde sözlerini mükemmel tekrarlar! Ne kadar serin! Hayal kırıklığı yaratan bir şekilde, çok hızlı olmayan yazma hızınızdan bağımsız olarak girişi bir kerede tekrarlar. Bunu düzeltmek zorundayız.

Görev

Programınız girişini STDIN'den veya en yakın eşdeğerinden alacaktır. Kullanıcının satırlarını birer birer okuyacaktır, muhtemelen boş bir satıra girinceye kadar istemi görüntüleyecektir. Bundan sonra, satırları, verilen sırayla STDOUT ya da en yakın eşdeğerine basacaktır. Son (boş) satır yazdırılmaz ve son yazdırılan satırın sonunda yeni bir satır olması gerekmez.

Ek olarak, program her satır arasındaki zaman aralıklarını koruyacaktır: kullanıcı xbir satıra girmesi xsaniye sürerse, programın yazdırması birkaç saniye sürecektir . Bu, ilk ve son satırlar için de geçerlidir; boş satır yazdırılmaz, ancak program sonlandırılmadan önce yine de bekler.

Örnek

İşte program ile bir örnek oturum. Metin üretmeyen tüm eylemler parantez içinde açıklanmıştır ve (isteğe bağlı) istemi olarak görüntülenir >.

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

Eylemler olmadan, oturum şöyle görünür:

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

Kurallar ve Puanlama

Bekleme süreleri 0,01 saniye içinde doğru olmalıdır (pratikte, eğer ortalama insan farkı söyleyemezse, sorun değil). En düşük bayt sayısı kazanır ve standart boşluklar izin verilmez. Dilinizin tam olarak bu görev için yerleşik bir işlevi varsa, kullanamazsınız.

CJam, 45 41 39 36 34 bayt

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

Bu elbette çevrimiçi tercüman için pek bir anlam ifade etmiyor, fakat Java tercümanında çalışıyor.

Bir bilgi istemi göstermiyor.

açıklama

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

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

Kesmek için birkaç bayt daha bulmayı umuyorum.

JavaScript, 120 bayt

Bu yaklaşımla CJam'a yaklaşma şansı yok, ancak basit bir senaryo.

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 bayt

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

Bir Boşa çok çağrısı bayt sleepPyth hiçbir beri, sleepişlevi.

Ruby, 74

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

Püf noktaları: *ailk satırda boş bir dizi başlatır. $*Onun yerine kullanabilirim, ancak bazı istilalarla doluydu ve bana sadece bir bayt kazandırdığı için hafif kabataslak. $/yeni bir $_satırdır ve alınan son satırdır gets.

Düzenleme: sonunda uyku, muhtemelen aşağı golf için bir yol, 20 bayt maliyeti

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

Sadece Windows platformlarında çalışır

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

Girdi ve süreleri ayrı listelerde tutmak bana 3 bayta daha mal oldu . Muhtemelen en iyi yaklaşım değil.

129 baytlık Unix uyumlu sürüm, Mego'ya kredi olarak :

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 bayt

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

Burada golf oynayacak çok şey var ama bu şimdilik ...

PowerShell, 261 190 121 95 Bayt

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

_{'Den aksesuarlar TessellatngHeckler ve tomkandy golf yardım ve ilham}

Bu, konsept olarak aşağıdaki 121-byte versiyonuna çok benzer, sadece belirli bir dizide saklamak için bir süre döngüsünden geçmek yerine dinamik olarak bir nesne listesi oluşturup inşa ediyoruz. $a . Her iki durumda da, bu nesnelerin listesi aynı foreach döngüsüne aktarılır |%{...}. Sonuç-dizi-seçiciye endeksleme ($b=!$b+!$_), bu sefer if($_){$_}birkaç bayttan tasarruf sağlayan aşağıdaki yinelemelerin ortadan kaldırılması için formüle edilmiştir .

Önceki, 121 Bayt

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

Genişletilmiş ve açıkladı:

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

Önceki-Er, 190 Bayt

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
}

Önceki-er-er, 261 Bayt

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

Kutsal ayrıntı, Batman! Şimdi onu parçalayalım:

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

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

Perl 6 yorumlayıcısı sadece üç sembolik değişkeni tanımlar (Perl 5'in deliliğinin aksine). Kesin, olmak $/, $!ve $_. Bu program hepsini kullanarak, değişkenleri bildirmenin maliyetini önlemek için kullanır my.

getSTDIN'den bir satır okur. Perl 5'in aksine yeni bir satır içermiyor.

nowyerleşik bir geçerli zaman döndürür. Çıkarıldığında, bir dizeye geçirilebilecek bir aralık verir.

Solunda hiçbir şey olmayan bir yöntem ( bu koddaki .pushve .mapbu koddaki gibi) üzerinde çalışır $_.

repeat whileDöngüyü kullanarak ( do whilediğer programlama dillerinde olduğu gibi), Perl 6 geçerli zaman damgasını yazıyor $/ve alınan satırı (aynı zamanda da sakladığı $!) ve geçerli zaman ile zaman damgası arasındaki farkı yazıyor $/. Parametre sırası nedeniyle, nowbir satır alınana kadar hesaplanmaz.

whileHat boş değilse durumu kontrol eder (Perl 6'da, "0"Perl 5 farklı olarak, gerçek bir değerdir).

Tüm zaman damgalarını ve çizgileri aldıktan sonra, sadece mapbiraz uyuyan ve söylenenleri söyleyen geri aramaları yapıyorum .

Groovy, 202 bayt

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

Radikal.

Ungolfed versiyonu:

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

Mwr247 ve Dom Hastings'in (CW) çabalarını bir araya getirmek

/* 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

Ve asılsız:

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

Bu, her bir dizgiyi görüntülemek için harcanan zamanı hesaba katmadığı için zamanlamada% 100 doğru olmaz, ancak bu oldukça hızlı olmalı, bu nedenle zamanlama açısından oldukça yakın olmalıdır.

Hızlı bir ziyaretten sonra, çift katmanlı derin hücre dizisini kaldırarak birkaç bayt kurtardım. İhtiyacım olan tek şey ;, paketleme sırasında doğru şekilde ayrılmamdı.

Java, bu kütüphanenin 1.04 sürümünü kullanarak , 385 bayt

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 bayt

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

Her zamanki gibi, bu çalıştırmadan önce temiz bir sembol tablosu varsayar d r.

Bu sorun ANSI MUMPS'ta çözülemez, çünkü ANSI standardı yalnızca zamana yönelik ikinci seviye çözünürlük gerektirir $H[OROLOG]. Neyse ki, şu anda MUMPS için endüstri lideri bir platform olan Intersystems Caché, mikrosaniye düzeyinde çözünürlük sağlayan , uygulama tanımlı bir $ZT[IME]S[TAMP]içsel yapı sağlıyor.

(Puan eskiden 105 bayt, ancak bir hata vardı.)

C ++ 11, 343 338 bayt

C ++ 'ta bunun için kaç tane bayt kodu gerektiğini görmek istedi. Beklediğimden çok daha fazla. Belki de çözümü karmaşıklaştırdım.

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

Bakalım bunu bir şekilde azaltabilir miyim.

Bash, 91 90 bayt

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

Bu geçici bir dosya oluşturur t. Aynı ada sahip mevcut bir dosyanın üzerine yazacaktır.

Bu fikrin kendisi oldukça kısa, ancak girişte özel karakterlerle uğraşmak yaklaşık 15 byte ekliyor ...

VBA, 233 228 bayt

Bunun çok fazla golf oynayabileceğinden eminim. kaç tane girdi belirtmediler, bu yüzden dizi uzunluklarımı kodladım çünkü daha kısa Redim preserve.

Giriş açılır pencereden, çıkış MODAL ürettiğinden ve kodu durdurduğundan debug.printdolayıdır msgbox.

Bu 0.01s için doğru olup olmadığını test nasıl bilmiyorum. Belki birileri test edebilir, ancak bekleme komutunu bu sayıyı milisaniyeyi kullanması gerektiği şekilde veriyorum, ancak VBA ne yapması gerektiğini bilmiyor.

Bu If goto, iyi bir golf ile ikame edilebilir 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

Microsoft'un tutarlılıktan nefret ettiği için erişimin bir bekleme komutu olmadığı için Access VBA'da çalışmayacak

SmileBASIC, 122 bayt

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

Bunun biraz daha kısa olabileceğini düşünüyorum.

C UNIX, 272 bayt

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

Detaylı

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