সময় সংবেদনশীল প্রতিধ্বনি

Question

পটভূমি

echoপ্রোগ্রাম তাই ঝরঝরে হয়। আপনি এটিকে কিছু বলতে পারেন এবং এটি প্রতিবার আপনার শব্দগুলিকে পুরোপুরি পুনরাবৃত্তি করে! কিভাবে শীতল হয়! হতাশাজনকভাবে, এটি টাইপ করার গতি নির্বিশেষে এটি একবারে ইনপুটটি পুনরাবৃত্তি করে, যা খুব বাস্তববাদী নয়। আমাদের এটি ঠিক করতে হবে।

কাজটি

আপনার প্রোগ্রামটি এসটিডিএন বা নিকটতম সমতুল্য থেকে এর ইনপুট নেবে। এটি ব্যবহারকারীর কাছ থেকে একের পর এক লাইন পড়বে, সম্ভবত কিছু প্রম্পট প্রদর্শিত হবে, যতক্ষণ না তারা খালি লাইন প্রবেশ করে। এরপরে, এটি লাইনগুলি প্রেরণ করা হবে STDOUT বা নিকটতম সমতুল্য, একই ক্রমে যেমন তারা দেওয়া হয়েছিল। শেষ (খালি) লাইনটি প্রিন্ট করা হয়নি, এবং শেষ মুদ্রিত লাইনে ট্রেলিং করা নতুন লাইন থাকা দরকার নেই।

অতিরিক্তভাবে, প্রোগ্রামটি প্রতিটি লাইনের মধ্যবর্তী সময়ের ব্যবধানগুলি সংরক্ষণ করবে: এটি যদি xকোনও লাইনে প্রবেশ করতে ব্যবহারকারীকে কয়েক সেকেন্ড সময় নেয় xতবে প্রোগ্রামটি মুদ্রণ করতে কয়েক সেকেন্ড সময় নিতে হবে। এটি প্রথম এবং শেষ লাইনেও প্রযোজ্য; খালি লাইনটি মুদ্রিত হয় না, তবে প্রোগ্রামটি শেষ হওয়ার আগেই যাই হোক না কেন অপেক্ষা করে।

উদাহরণ

প্রোগ্রামটির সাথে এখানে উদাহরণস্বরূপ একটি সেশন রয়েছে। পাঠ্য উত্পাদন করে না এমন সমস্ত ক্রিয়া বন্ধনীগুলিতে বর্ণিত হয় এবং (alচ্ছিক) প্রম্পট হিসাবে প্রদর্শিত হয় >।

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

ক্রিয়া ছাড়াই অধিবেশনটি এর মতো দেখাচ্ছে:

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

বিধি এবং স্কোরিং

অপেক্ষার সময়গুলি 0.01 সেকেন্ডের মধ্যে সঠিক হওয়া উচিত (বাস্তবে, যদি গড় মানুষ পার্থক্যটি বলতে না পারে তবে আপনি ভাল আছেন)। সর্বনিম্ন বাইট গণনা জয়, এবং মান লুফোলগুলি অনুমোদিত নয়। এই কাজের জন্য যদি আপনার ভাষার কোনও অন্তর্নির্মিত ফাংশন থাকে তবে আপনি এটি ব্যবহার করতে পারবেন না।

Comments

পরবর্তী পদক্ষেপ: গল্ফ এমন একটি প্রোগ্রাম যা একটি মৌলিক ছন্দের গেম খেলছে: P

— Sp3000

প্রোগ্রামটি আউটপুট অক্ষরগুলি গ্রহণ করার সময়টিকে আমরা উপেক্ষা করতে পারি? আমি বলতে চাইছি, যদি আমি পরিমাপ করতে পারি যে আমার ভাষা কোনও চার্জ আউটপুট দিতে 0.1 সেকেন্ড নেয়, তবে আমি কি তা অ্যাকাউন্টে নেব? সম্পূর্ণ প্রকাশ, আমি দেরীটি প্রয়োগ করতে> <> দোভাষীদের টিক সময় ব্যবহার করার পরিকল্পনা করছি; এই ক্ষেত্রে, আমি কি আমার ইনপুট সময়টি লুপ করতে পারি তারপরে আমার ডিসপ্লে লুপের মধ্য দিয়ে যাওয়া সময়টিকে উপেক্ষা করতে পারি?

— হারুন

@ অ্যারনগোউজিট আমি এটির অনুমতি দিচ্ছি যতক্ষণ আপনি সামঞ্জস্যপূর্ণ: আপনার প্রোগ্রামটি কোনও লাইন মুদ্রণ শুরু করার মুহুর্তগুলির মধ্যে সময়ের ব্যবধানগুলি সমস্ত ব্যবহারকারী থেকে নেওয়া হয়, অথবা একটি লাইন মুদ্রণ শেষ করে এবং মুদ্রণ শুরু করার মধ্যবর্তী অপেক্ষার সময়গুলি পরবর্তী সমস্ত ব্যবহারকারীর কাছ থেকে নেওয়া হয়েছে।

— Zgarb

পুনঃটুইট উদাহরণ সেশন দেখুন।

— Zgarb

@ ক্রিতিক্সিলিথোস আমি কেবলমাত্র আমার ডান হাতের জন্য ব্যবহার করেছি yum yum, যা ছিল জটিল।

— জাগারব

Answer 1

সিজেম, 45 41 39 36 34 বাইট

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

এটি অবশ্যই অনলাইন ইন্টারলিটারের অবশ্যই অর্থবোধ করে না, তবে এটি জাভা ইন্টারপ্রেটারে কাজ করে।

এটি কোনও প্রম্পট প্রদর্শন করে না।

ব্যাখ্যা

{        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.
}/

Answer 2

জাভাস্ক্রিপ্ট, 119 112 বাইট

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

আরও কয়েকটা বাইট বের করার আশা করছি।

Comments

আপনি কয়েকটা বাইট সংরক্ষণ করতে পারেন j=i=[]( ++এখনও কাজ করবে!), আপনার জঘন্য বলে এটির whileপ্রয়োজন নেই !=''! তাই হতাশ আমি মিস map! +1

— ডম হেস্টিংস

ভাল নোট !=''। ইনপুটটি যদি উদ্বিগ্ন ছিল 0তবে এটি জরিমানাটি পরিচালনা করছে বলে মনে হচ্ছে। আমি []আগে বর্ধিত সম্ভাবনা লক্ষ্য করেছি , কিন্তু আমি নির্বোধ ছিল এবং এটি করার চেষ্টা j++করেছি। এরকম ++j, কাজ যেহেতু []++দৃশ্যত 0 XD ধন্যবাদ!

— Mwr247

এই দিনটি চিহ্নিত করুন যে আমি জেনেছি যে do...while

— জেএসে

Answer 3

জাভাস্ক্রিপ্ট, 120 বাইট

এই পদ্ধতির সাথে সিজোমের কাছে যাওয়ার কোনও সম্ভাবনা নেই, তবে একটি সরল স্ক্রিপ্ট।

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

Comments

মনে হচ্ছে আমরা দু'জনেই জেএসের জন্য একই সাথে গেছি হাহাহা, যদিও আপনি আমার সামান্য আগে নিজেরটি পেয়েছিলেন। তবুও, বিভিন্ন পন্থা।

— Mwr247

@ Mwr247 প্রকৃতপক্ষে, আপনার যদিও এটি আরও মার্জিত!

— ডম হেস্টিংস

Answer 4

পাইথ, 68 বাইট

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

একটি Wasted অনেক কল উপর বাইটের sleep, যেহেতু Pyth কোন হয়েছে sleepফাংশন।

Comments

পাইথের যোগ হিসাবে আপনার পরামর্শ দেওয়া উচিত।

— mbomb007

আমি বিশ্বাস করি আপনার অপেক্ষার ক্ষেত্রে বাইরের ত্রুটি রয়েছে। প্রোগ্রামটি শুরু করার চেষ্টা করুন, প্রায় অপেক্ষা করে, তারপরে কিছু টাইপ করুন এবং দু'বার দ্রুত এন্টার টিপুন। এটি অবিলম্বে প্রথম লাইনটি মুদ্রণ করবে, তারপরে সমাপ্তির আগে কিছুক্ষণ অপেক্ষা করুন।

— FryAmTheEggman

Answer 5

রুবি, 74

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

কৌশলগুলি: *aপ্রথম লাইনে একটি খালি অ্যারে সূচিত করে। আমি $*পরিবর্তে এটি ব্যবহার করতে পারি তবে এটি হালকাভাবে স্কেচিযুক্ত কারণ এটি কিছু আমন্ত্রণ সহ জনবহুল এবং কেবল আমাকে একটি বাইট সংরক্ষণ করে। $/এটি একটি নতুন লাইন এবং $_এটি শেষ লাইনটি পুনরুদ্ধার করেছে gets।

সম্পাদনা: শেষে ঘুমাতে আরও 20 টি বাইট খরচ হয়, সম্ভবত এটি কোনওভাবে গল্ফ করার

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

Comments

আমি মনে করি আপনাকে খালি লাইন সরবরাহ করতে কতক্ষণ সময় লেগেছিল তার উপর নির্ভর করে আপনার শেষ লাইনে ঘুমানো দরকার।

— কনরাড বোরোস্কি

শেষে (সমাধান 2) ঘুমানোর জন্য, আপনি Time.nowযথেষ্ট সময় কল করেছেন যে ব্যবহার করে def n;Time.now;endপুরো 2 বাইট সংরক্ষণ করুন

— মান ইঙ্ক

Answer 6

পাইথন 3, 124

শুধুমাত্র উইন্ডোজ প্ল্যাটফর্মগুলিতে কাজ করে

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

ইনপুট এবং সময় পৃথক তালিকায় রাখার জন্য আমার আরও 3 বাইট খরচ হয় । সম্ভবত সেরা পদ্ধতির না।

একটি 129 বাইট ইউনিক্স বন্ধুত্বপূর্ণ সংস্করণ, মেগোতে ক্রেডিট সহ :

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

Comments

আপনি 2 বাইট সংরক্ষণ করার time()পরিবর্তে ব্যবহার করতে পারবেন না clock()?

— kirbyfan64sos

Answer 7

এসডাব্লুআই-প্রোলগ, 185 বাইট

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

এখানে গল্ফ করার জন্য অনেক কিছু আছে তবে এটি এখনই করবে ...

Answer 8

পাওয়ারশেল, 261 190 121 95 বাইট

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

_{থেকে সাজসরঞ্জাম TessellatngHeckler এবং tomkandy golfing সহায়তা ও অনুপ্রেরণা জন্য}

এটি নীচের 121-বাইট সংস্করণ মত ধারণার অনুরূপ, আমরা কেবল স্পষ্টত অ্যারে সংরক্ষণ করার জন্য কিছুক্ষণ লুপের পরিবর্তে অবজেক্টগুলির একটি তালিকা তৈরি এবং বিল্ডিং করছি $a। উভয় ক্ষেত্রেই, সেই সামগ্রীর তালিকা একই ফোরচ লুপে পাইপলাইনযুক্ত হয় |%{...}। ফলাফল-অ্যারে-সিলেক্টরের ($b=!$b+!$_)সাথে if($_){$_}সূচীকরণটি এবার নীচের পুনরাবৃত্তির অপসারণের জন্য তৈরি করা হয়েছে, যা আরও কয়েকটি বাইট সংরক্ষণ করে।

---

পূর্ববর্তী, 121 বাইট

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

প্রসারিত এবং ব্যাখ্যা:

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

---

পূর্ববর্তী-এআর, 190 বাইট

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
}

---

পূর্ববর্তী-এর-এর, 261 বাইট

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

পবিত্র ভার্বোসটি, ব্যাটম্যান! আসুন এটি ভেঙে দিন:

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

Comments

144$a=1,1;while($a[-1]-ne""){$a+=Measure-Command{$b=read-host};$a+=$b};$i=2;while($i-lt$a.length){sleep -m $a[($i++)].totalmilliseconds;$a[($i++)]}

— টমক্যান্ডি

@ টমক্যান্ডি ধন্যবাদ! উন্নতির সাথে আপডেট হয়েছে।

— অ্যাডমবর্কবার্ক

নিবন্ধন করুন আমি বিকল্পটিকে কার্যকরভাবে নিয়ন্ত্রণ করার একটি উপায় নিয়ে লড়াই করে যাচ্ছিলাম এবং এর মতো একটি অ্যারেতে ইনডেক্স করা এখন স্পষ্ট পছন্দ I ঘটনাক্রমে, আমি @এই অ্যারে থেকে অপসারণ করে আরেকটি বাইট গল্ফ করেছি , যেহেতু এটি এই প্রসঙ্গে প্রয়োজন নেই, তাই 121 এ নামিয়ে নিন ।

— অ্যাডমবর্কবার্ক

@ টিমিডি গতকাল আমি যা চেষ্টা করছিলাম তা হ'ল ($ t, $ l) জোড়া pairs একটি নেস্টেড অ্যারে তৈরি করা। আমি এটি কাজ করতে পারিনি, তবে আজ আমি এটি করতে পেরেছিলাম এবং এটি কিছুটা সহায়তা করতে পারে কারণ টগল করার দরকার নেই, কেবল প্রতিটি জোড়া পড়ুন এবং সেগুলি ব্যবহার করুন। তখন আমি বুঝতে পেরেছিলাম - আমাদের কাছে একটি ভাল ভাল পাইপলাইন রয়েছে যা জিনিসগুলি সারি করতে পারে, কেন কোনও অ্যারে রাখবেন না? $($l=1;while($l){Measure-Command{$l=read-host};$l})|%{($_,(sleep -m($_.Ticks/1e4)))[($b=!$b+!$_)]}- এবং টগল পরিবর্তনের সাথে, যাতে স্ট্রিং ফাঁকা থাকলে তা টগল না করে এবং তার পরিবর্তে ঘুমায় - 98

— TessellatingHeckler

(এটি একটি do{...}while($l)লুপ তৈরি করুন এবং 95$l=1; পাওয়ার জন্য ছেড়ে দিন )

— টেসেল্লাটিংহেকলার

Answer 9

পার্ল 6, 70 টি অক্ষর

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

পার্ল 6 দোভাষী কেবলমাত্র তিনটি প্রতীকী ভেরিয়েবল (পার্ল 5 এর কৌতূহলের বিপরীতে) সংজ্ঞায়িত করেন। সঠিক হতে $/, $!এবং $_। ভেরিয়েবলগুলি ব্যবহার করে ব্যয় করার ব্যয়টি এড়াতে এই প্রোগ্রামটি এগুলি সমস্ত ব্যবহার করে my।

getSTDIN থেকে একটি লাইন পড়ে। এতে পার্ল 5 এর বিপরীতে কোনও নতুন লাইন নেই।

nowবিল্টিন একটি বর্তমান সময় ফেরত। বিয়োগ করা হলে, এটি একটি বিরতি দেয় যা স্ট্রিংয়ে যেতে পারে।

এর বামে কিছুই নেই এমন একটি পদ্ধতি (যেমন .pushএবং .mapএই কোডটিতে) কাজ করে $_।

repeat whileলুপ ব্যবহার করে ( do whileঅন্যান্য প্রোগ্রামিং ভাষায় পরিচিত ), পার্ল 6 বর্তমান টাইমস্ট্যাম্প লিখছে $/এবং প্রাপ্ত লাইনটি ধাক্কা দেয় (এটি এটি সংরক্ষণ করেও $!) এবং বর্তমান সময় এবং টাইমস্ট্যাম্পের মধ্যে পার্থক্য রাখে $/। প্যারামিটার অর্ডারের কারণে, nowকোনও লাইন না পাওয়া পর্যন্ত গণনা করা হয় না।

whileশর্ত চেক যদি লাইন খালি নয় (পার্ল 6 এ, "0"একটি সত্য মান, পার্ল 5 অসদৃশ যায়)।

আমি সমস্ত টাইমস্ট্যাম্প এবং লাইন পাওয়ার পরে, আমি কেবল mapসেগুলিকে কলব্যাক সরবরাহ করি যা কিছুটা ঘুমায় এবং যা বলেছিল তা বলে।

Answer 10

গ্রোভি, 202 বাইট

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

মূলসংক্রান্ত।

অবরুদ্ধ সংস্করণ:

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

Answer 11

জাভাস্ক্রিপ্ট (ES6) 102

Mwr247 এবং ডোম হেস্টিংস (সিডাব্লু) এর প্রচেষ্টা একত্রিত করা

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

Answer 12

ম্যাটল্যাব, 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

এবং অবরুদ্ধ:

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

এটি টাইমিংয়ের ক্ষেত্রে 100% নির্ভুল হবে না কারণ এটি প্রতিটি স্ট্রিং প্রদর্শনের জন্য যে সময় নেয় তা হিসাব করে না তবে সময়টি অনুসারে এটি খুব দ্রুত হওয়া উচিত এটি খুব কাছাকাছি হওয়া উচিত।

---

দ্রুত পুনর্বিবেচনার পরে, আমি ডাবল স্তর গভীর কক্ষ অ্যারে সরিয়ে কয়েক বাইট সংরক্ষণ করেছি। ;প্যাকিংয়ের সময় সঠিকভাবে বিভক্ত হওয়ার জন্য আমার যা প্রয়োজন ছিল তা সর্বাগ্রে পরিণত হয়েছে।

Comments

সম্ভবত আপনি এমন একটি সংস্করণ তৈরি করতে পারেন যা এমএটিএল-এ গল্ফযুক্ত।

— ckjbgames

Answer 13

জাভা, এই লাইব্রেরির 1.04 সংস্করণ ব্যবহার করে , 385 বাইট

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

Answer 14

ক্যাচ অবজেক্টস্ক্রিপ্ট, 123 বাইট tes

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

যথারীতি এটি চলার আগে একটি পরিষ্কার প্রতীক টেবিল ধরে নেয় d r।

এএনএসআই এমএমপিএসে এই সমস্যাটি সমাধান করা যায় না, কারণ এএনএসআই স্ট্যান্ডার্ডের জন্য কেবল সময়ের অভ্যন্তরের জন্য দ্বিতীয় স্তরের রেজোলিউশন প্রয়োজন $H[OROLOG]। সৌভাগ্য যে, Intersystems Cache, যা বর্তমানে মাম্পস শিল্প-নেতৃস্থানীয় প্ল্যাটফর্ম, প্রদান করে বাস্তবায়ন-সংজ্ঞায়িত $ZT[IME]S[TAMP]স্বকীয় , মাইক্রোসেকেন্ড পর্যায়ের রেজল্যুশন তথ্য প্রদান করে।

(স্কোরটি আগে 105 বাইট ছিল, তবে একটি বাগ ছিল))

Answer 15

সি ++ 11, 343 338 বাইট

সি ++ এর জন্য একটি কোডের কতগুলি বাইট দরকার তা দেখতে চেয়েছিলেন। আমার প্রত্যাশার চেয়ে অনেক বেশি। সম্ভবত আমি সমাধান জটিল।

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

দেখি আমি এটি কোনওভাবে হ্রাস করতে পারি কিনা।

Comments

আপনি #includeগুলি এবং এর জন্য প্রকারের ঘোষণাপত্রের ফাঁকা স্থানগুলি সরিয়ে ফেলতে পারেন main। এটি 7 বাইট - বেশি নয়, তবে একটি সূচনা। এছাড়াও আপনি ব্যবহার করতে সক্ষম হতে পারেন autoবদলে stringজন্য s।

— অ্যালেক্স এ।

সাহায্য করার জন্য ধন্যবাদ. আমি মূলটির জন্য রিটার্নের ধরণ রাখব keep আমি যদি সঠিকভাবে মনে রাখি তবে কেবলমাত্র তার জন্য cআমাদের এটি নির্দিষ্ট করতে হবে না। আমি প্রাথমিকভাবে ব্যবহার করার চেষ্টা করেছি auto s... তবে দেখে মনে হচ্ছে এটি রূপান্তরিত হয়েছে const char *এবং না std::string। আমি ভাবছি যে আমি যদি একটি উপাধি তৈরি করতে পারি while।

— wendelbsilva

রিটার্নের ধরণটি সরানো সি ++ এর জন্য কাজ করে যদিও এটি স্ট্যান্ডার্ড অনুযায়ী "উচিত নয়"। আপনি সম্ভবত whileব্যবহারের জন্য একটি উপনাম তৈরি করার চেষ্টা করতে পারেন #define।

— অ্যালেক্স এ।

Answer 16

বাশ, 91 90 বাইট

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

এটি একটি অস্থায়ী ফাইল তৈরি করে t। এটি একই নামের সাথে একটি বিদ্যমান ফাইল ওভাররাইট করবে।

ধারণাটি নিজেই খুব সংক্ষিপ্ত, তবে ইনপুটটিতে বিশেষ অক্ষরগুলি নিয়ে কাজ করা প্রায় 15 বাইট যুক্ত করে ...

Answer 17

ভিবিএ , 233 228bytes

আমি নিশ্চিত এটি অনেক গল্ফ করা যেতে পারে। তারা কতটা ইনপুট নির্দিষ্ট করে দেয়নি তাই আমি কঠোরভাবে আমার অ্যারের দৈর্ঘ্য কোড করেছিলাম কারণ এরপরে এটি সংক্ষিপ্ত Redim preserve।

ইনপুটটি পপআপের মাধ্যমে হয়, আউটপুট হয় debug.printকারণ msgboxএকটি মডেল এবং হোল্ডস কোড উত্পাদন করে।

এটি যদি 0.01 এর সাথে সঠিক হয় তবে কীভাবে পরীক্ষা করতে হয় তা আমি জানি না। হতে পারে কেউ পরীক্ষা করতে পারে তবে আমি ওয়েট কমান্ডটি এমনভাবে নম্বর দিচ্ছি যাতে এটি মিলিসেকেন্ড ব্যবহার করা উচিত, তবে ভিবিএ এটি করা উচিত বলে জানা যায় না।

এটি If gotoএকটি ভাল গল্ফ দ্বারা প্রতিস্থাপিত হতে সক্ষম হতে পারে 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

অ্যাক্সেস ভিবিএতে কাজ করবে না, কারণ অ্যাক্সেসের একটি ওয়েট কমান্ড নেই কারণ মাইক্রোসফ্ট ধারাবাহিকতা ঘৃণা করে

Answer 18

স্মাইলব্যাসিক, 122 বাইট

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

আমি মনে করি এটি কিছুটা ছোট করা যেতে পারে।

Answer 19

সি ইউনিক্স, 272 বাইট

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

বিশদ

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