Lý lịch

Các echochương trình là rất gọn gàng. Bạn có thể nói bất cứ điều gì với nó, và nó lặp đi lặp lại lời nói của bạn một cách hoàn hảo, mọi lúc! Thật tuyệt làm sao! Thất vọng, nó lặp đi lặp lại tất cả đầu vào cùng một lúc, bất kể tốc độ gõ của bạn, điều này không thực tế lắm. Chúng tôi sẽ phải sửa nó.

Nhiệm vụ

Chương trình của bạn sẽ lấy đầu vào từ STDIN hoặc tương đương gần nhất. Nó sẽ đọc từng dòng từ người dùng, có thể hiển thị một số dấu nhắc, cho đến khi họ nhập một dòng trống. Sau đó, nó sẽ in các dòng thành STDOUT hoặc tương đương gần nhất, theo cùng thứ tự như chúng đã được đưa ra. Dòng cuối cùng (trống) không được in và dòng in cuối cùng không cần phải có một dòng mới.

Ngoài ra, chương trình sẽ bảo toàn các khoảng thời gian giữa mỗi dòng: nếu người dùng mất xvài giây để nhập một dòng, sẽ mất xvài giây để chương trình in. Điều này áp dụng cho các dòng đầu tiên và cuối cùng quá; dòng trống không được in, nhưng chương trình vẫn chờ trước khi kết thúc.

Thí dụ

Đây là một phiên ví dụ với chương trình. Tất cả các hành động không tạo ra văn bản được mô tả trong ngoặc và lời nhắc (tùy chọn) được hiển thị dưới dạng >.

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

Không có hành động, phiên trông như thế này:

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

Quy tắc và chấm điểm

Thời gian chờ phải chính xác trong vòng 0,01 giây (trong thực tế, nếu con người trung bình không thể nhận ra sự khác biệt, bạn vẫn ổn). Số byte thấp nhất sẽ thắng và các sơ hở tiêu chuẩn không được phép. Nếu ngôn ngữ của bạn có chức năng tích hợp cho chính xác nhiệm vụ này, bạn không thể sử dụng nó.

CJam, 45 41 39 36 34 byte

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

Điều này thực sự không có ý nghĩa trong trình thông dịch trực tuyến, nhưng nó hoạt động trong trình thông dịch Java.

Nó không hiển thị một dấu nhắc.

Giải trình

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

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

Hy vọng sẽ tìm thấy một vài byte để cắt ra.

JavaScript, 120 byte

Không có cơ hội đến gần với CJam với cách tiếp cận này, nhưng một kịch bản đơn giản.

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

Bình thường, 68 byte

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

Đã lãng phí rất nhiều byte trong cuộc gọi đến sleep, vì Pyth không có sleepchức năng.

Ruby, 74

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

Thủ thuật: *atrên dòng đầu tiên kích hoạt một mảng trống. Tôi có thể sử dụng $*thay thế nhưng nó hơi sơ sài vì nó có một số lời mời và chỉ tiết kiệm cho tôi một byte. $/là một dòng mới và $_là dòng cuối cùng được lấy bởi gets.

Chỉnh sửa: Ngủ cuối cùng tốn thêm 20 byte, có lẽ là một cách để đánh golf xuống

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

Con trăn 3, 124

Chỉ hoạt động trên nền tảng 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:]]

Giữ đầu vào và thời gian trong các danh sách riêng biệt làm tôi tốn thêm 3 byte . Có lẽ không phải là cách tiếp cận tốt nhất.

Phiên bản thân thiện với Unix 129 byte, có tín dụng cho 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 byte

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

Có lẽ có rất nhiều để chơi golf ở đây nhưng điều này sẽ làm ngay bây giờ ...

PowerShell, 261 190 121 95 Bytes

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

_{Đạo cụ cho TessellatngHeckler và tomkandy cho sự hỗ trợ và cảm hứng chơi gôn}

Khái niệm này rất giống với phiên bản 121 byte bên dưới, chúng tôi chỉ tự động tạo và xây dựng một danh sách các đối tượng, thay vì đi qua một vòng lặp while để lưu trữ chúng thành một mảng rõ ràng $a. Trong cả hai trường hợp, danh sách các đối tượng đó được dẫn vào cùng một vòng lặp foreach |%{...}. Việc lập chỉ mục vào bộ chọn mảng kết quả ($b=!$b+!$_)là lần này được xây dựng để loại bỏ các if($_){$_}lần lặp dưới đây, giúp tiết kiệm thêm một vài byte.

Trước đó, 121 byte

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

Mở rộng và giải thích:

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

Trước đó, 190 byte

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
}

Trước đó, 261 byte

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

Thần thánh, Batman! Hãy phá vỡ nó:

$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 ký tự

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

Trình thông dịch Perl 6 chỉ định nghĩa ba biến tượng trưng (không giống như sự điên rồ của Perl 5). Để được chính xác, $/, $!, và $_. Chương trình này sử dụng tất cả, để tránh chi phí khai báo các biến sử dụng my.

getđọc một dòng từ STDIN. Nó không chứa một dòng mới, không giống như Perl 5.

nowdựng sẵn trả về một thời điểm hiện tại. Khi bị trừ, nó đưa ra một khoảng có thể được truyền vào một chuỗi.

Một phương thức không có gì ở bên trái của nó (như .pushvà .maptrong mã này) hoạt động $_.

Sử dụng repeat whilevòng lặp (được gọi là do whiletrong các ngôn ngữ lập trình khác), Perl 6 đang viết dấu thời gian hiện tại vào$/ và đẩy dòng nhận được (mà nó cũng lưu trữ $!) và sự khác biệt giữa thời gian hiện tại và dấu thời gian $/. Do thứ tự tham số, nowkhông được tính cho đến khi nhận được một dòng.

Các while kiện kiểm tra nếu dòng không trống (trong Perl 6, "0"là một giá trị thực, không giống như Perl 5).

Sau khi tôi nhận được tất cả các dấu thời gian và dòng, tôi chỉ cung cấp cho những người mapgọi lại mà ngủ một chút và nói những gì đã nói.

Groovy, 202 byte

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

Căn bản.

Phiên bản bị đánh cắp:

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

Kết hợp những nỗ lực của Mwr247 và 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

Và vô lương tâm:

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

Điều này sẽ không chính xác 100% về thời gian vì nó không chiếm thời gian để hiển thị từng chuỗi nhưng điều đó sẽ khá nhanh vì vậy thời gian khôn ngoan nên khá gần.

Sau khi xem lại nhanh, tôi đã lưu một vài byte bằng cách loại bỏ mảng ô sâu hai lớp. Hóa ra tất cả những gì tôi cần là ;làm cho nó tách ra một cách chính xác khi đóng gói.

Java, sử dụng phiên bản 1.04 của thư viện này , 385 byte

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

Đối tượng bộ nhớ cache, 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

Như thường lệ, điều này giả định một bảng biểu tượng sạch trước khi chạy d r.

Vấn đề này không thể được giải quyết trong ANSI MUMPS, vì tiêu chuẩn ANSI chỉ yêu cầu độ phân giải cấp hai cho nội tại thời gian $H[OROLOG]. May mắn thay, Intersystems Caché, hiện là nền tảng hàng đầu trong ngành cho MUMPS, cung cấp nội tại được xác định theo triển khai$ZT[IME]S[TAMP] , cung cấp độ phân giải ở mức micro giây.

(Điểm trước đây là 105 byte, nhưng đã có lỗi.)

C ++ 11, 343 338 byte

Muốn xem mã cần bao nhiêu byte trong c ++. Nhiều hơn tôi mong đợi. Có lẽ tôi quá phức tạp giải pháp.

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

Hãy xem liệu tôi có thể giảm điều này bằng cách nào đó.

Bash, 91 90 byte

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

Điều này tạo ra một tập tin tạm thời t. Nó sẽ ghi đè lên một tệp hiện có cùng tên.

Bản thân ý tưởng này khá ngắn, nhưng xử lý các ký tự đặc biệt trong đầu vào thêm khoảng 15 byte ...

VBA, 233 228byte

Tôi chắc chắn điều này có thể được chơi golf rất nhiều. họ không xác định có bao nhiêu đầu vào vì vậy tôi đã mã hóa độ dài mảng của mình vì nó ngắn hơn Redim preserve.

Đầu vào là thông qua cửa sổ bật lên, đầu ra là debug.printvì msgboxtạo ra một mã MODAL và tạm dừng mã.

Tôi không biết cách kiểm tra nếu điều này chính xác đến 0,01s. Có lẽ ai đó có thể kiểm tra nhưng tôi đang đưa ra lệnh chờ số theo cách nó NÊN sử dụng mili giây, nhưng VBA không biết làm gì để làm điều đó.

Có If gotothể có thể được thay thế bởi một golf tốt 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

Sẽ không hoạt động trong Access VBA, vì truy cập không có lệnh chờ vì Microsoft ghét tính nhất quán

SmileBASIC, 122 byte

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

Tôi nghĩ rằng điều này có thể được thực hiện ngắn hơn một chút.

C UNIX, 272 byte

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

Chi tiết

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