15

आपकी चुनौती इनपुट को प्रिंट करना है, किसी भी समय की प्रतीक्षा करें, इनपुट प्रिंट करें, शुरू में दो बार प्रतीक्षा करें, इनपुट को फिर से प्रिंट करें, और इसी तरह। प्रारंभिक देरी 1 घंटे से कम होनी चाहिए, और आपको बाद की देरी में +/- 5% की सटीकता होनी चाहिए। इसके अलावा, देरी के समय पर कोई प्रतिबंध नहीं है।

उदाहरण:

इनपुट: hi।

आउटपुट: hi(1ms पॉज़) hi(2ms पॉज़) hi(4ms पॉज़) hi(8ms पॉज़) hi(16ms पॉज़), आदि।

भी अनुमति दी:

hi(1 मिनट का ठहराव) hi(2 मिनट का ठहराव) hi(4 मिनट का ठहराव) hi(8 मिनट का ठहराव) hi(16 मिनट का ठहराव), आदि।

कार्यक्रम (STDIN, कमांड-लाइन पैरामीटर, फ़ंक्शन पैराम, आदि) की शुरुआत में इनपुट प्रदान किया जाना चाहिए और एक स्ट्रिंग होगा।

प्रारंभिक विलंब 0 नहीं हो सकता।

code-golf string date

— programmer5000
स्रोत

क्या आउटपुट को अनंत होने की आवश्यकता है, या यह कुछ समय के बाद बंद हो सकता है?

— कॉमरेड स्पार्कलपनी

1

@ComradeSparklePony को यह तब तक आउटपुट होना चाहिए जब तक कि यह (ब्रह्मांड की गर्मी से मृत्यु तक, कंप्यूटर क्रैश, स्टैकओवरफ़्लो, मेमोरी से बाहर, आदि)

— प्रोग्रामर

@ComradeSparklePony केवल अगर यह stackoverflow की तरह कुछ, स्मृति से बाहर, आदि है यह y=x=>(x&&alert(x),y())किया जाएगा तकनीकी रूप से अनुमति दी है, लेकिन मैं इसे downvote होगा।

— प्रोग्रामर

@ प्रोग्रामर 5000 धन्यवाद, मिल गया।

— कॉमरेड स्पार्कलेपनी

क्या मैं एक नई रूपरेखा मुद्रित कर सकता हूं?

— एमडी एक्सएफ

12

05AB1E , 6 बाइट्स

कोड:

[=No.W

स्पष्टीकरण:

[        # Start an infinite loop
 =       # Print the top of the stack without popping
  No     # Compute 2 ** (iteration index)
    .W   # Wait that many milliseconds

इसे ऑनलाइन आज़माएं!

— अदनान
स्रोत

यदि आप 1 सेकंड प्रतीक्षा करके शुरू करते हैं तो आप wइसके बजाय उपयोग कर सकते हैं .W।

— रिले

@ रिले मुझे नहीं लगता कि यह काम करेगा। wएक सेकंड का इंतजार नहीं करता है, और .Wपॉप ए और इंतजार करता है कि कई मिलीसेकंड।

— कॉमरेड स्पार्कलेपनी

@ComradeSparklePony तुम सही हो। यह होना ही होगा Gw।

— रिले

मुझे नहीं पता कि क्या यह जरूरी है कि कोड में किसी भी मुद्दे पर चिंतनशील है, लेकिन जिस क्षण मैं जुड़ा हुआ उदाहरण चलाता हूं, इंजन मुझे देता है: "चेतावनी: अनुरोध 60 सेकंड की समय सीमा को पार कर गया और समाप्त हो गया।"

— doppelgreener

@doppelgreener हाँ, ऑनलाइन दुभाषिया इस मामले में सबसे अच्छा विकल्प नहीं हो सकता है। ऑफ़लाइन हालांकि एक आकर्षण की तरह काम करता है।

— अदनान

15

स्क्रैच, 8 ब्लॉक + 3 बाइट्स

पायथन में बराबर:

import time
n = 1
while 1:
    print("x")
    time.sleep(n)
    n = n * 2

— OldBunny2800
स्रोत

1

क्यों "+ 3 बाइट्स"?

— कोल जॉनसन

2

9 ब्लॉक (जैसे फॉरएवर, एन) + 3 बाइट्स (जैसे x, 2)

— ओल्डबनी 2800

5

पायथन 3, 60 56 बाइट्स

import time
def f(x,i=1):print(x);time.sleep(i);f(x,i*2)

बदलाव का:

पुनरावर्ती लांबा को पुनरावर्ती कार्य में बदल दिया (-4 बाइट्स)

— L3viathan
स्रोत

आप printपायथन 2 :)

— नंबरमैन

1

@numbermaniac हां, लेकिन फिर मुझे अजगर 2 पर स्विच करना होगा।: P

— L3viathan

5

MATL , 8 बाइट्स

`GD@WY.T

पहला ठहराव 2 सेकंड है।

इसे MATL ऑनलाइन पर आज़माएं । या एक संशोधित संस्करण देखें जो कार्यक्रम शुरू होने के बाद बीता समय प्रदर्शित करता है। (यदि दुभाषिया काम नहीं करता है, तो कृपया पृष्ठ को ताज़ा करें और पुनः प्रयास करें)।

या जिफ देखें:

व्याख्या

`     % Do...while
  G   %   Push input
  D   %   Display
  @   %   Push iteration index (1-based)
  W   %   2 raised to that
  Y.  %   Pause for that time
  T   %   Push true. This will be used as loop confition
      % End (implicit). The top of the stack is true, which produces an infinite loop

— लुइस मेंडो
स्रोत

@ प्रोग्रामर 5000 जिज्ञासा से बाहर: क्या आपके लिए ऑनलाइन दुभाषिया काम करता है?

— लुइस मेंडो

हाँ, यह किया, क्यों?

— प्रोग्रामर

@ प्रोग्रामर 5000 धन्यवाद। सिर्फ जांच करने के लिए। कभी-कभी समयबाह्य मुद्दे होते हैं

— लुइस मेंडो

5

गणितज्ञ 34 32 30 29 बाइट्स

मूल समाधान 34 बाइट्स:

For[x=.1,1<2,Pause[x*=2];Print@#]&

Do के साथ 2 बाइट्स शेव करें

x=1;Do[Pause[x*=2];Print@#,∞]&

@ मार्टिनएंडर के पुनरावर्ती समाधान के साथ एक और बाइट को शेव करें

±n_:=#0[Print@n;Pause@#;2#]&@1

@ngenisis किसी अन्य बाइट को शेव करने के लिए रिप्लेसमेंट रिपर्टेड रिकर्स का उपयोग करता है

1//.n_:>(Print@#;Pause@n;2n)&

— केली लोडर
स्रोत

4

Trueहै 1>0। लेकिन ऐसा कुछ कम है:±n_:=#0[Print@n;Pause@#;2#]&@1

— मार्टिन एंडर

मैंने 1<2आपकी टिप्पणी के लिए पूर्व रखा । हालाँकि, आपका पुनरावर्ती समाधान एक बाइट को बचाता है। धन्यवाद @MartinEnder

— केली लोल्डर

±CP-1252 एन्कोडिंग (डिफ़ॉल्ट विंडोज एन्कोडिंग) में एक बाइट है।

— जंगहवान मिन

3

और भी छोटा:1//.n_:>(Print@#;Pause@n;2n)&

— ngenisis

5

ऑक्टेव, 42 41 बाइट्स

x=input('');p=1;while p*=2,pause(p),x,end

Rahnema1 के लिए एक बाइट धन्यवाद बचा, p*=2से कम है p=p*2।

मैं विश्वास नहीं कर सकता कि मैं इसे नीचे नहीं कर पाया, लेकिन यह वास्तव में इतना आसान नहीं था।

इनपुट प्रारंभ में होना चाहिए, इसलिए पहले भाग से बचना असंभव है।
मुझे एक संख्या की आवश्यकता है जो दोगुनी हो जाती है, और इसे लूप के सामने आरंभीकृत किया जाना चाहिए
- लूप के लिए एक सशर्त के रूप में इनपुट का उपयोग करना संभव होगा, लेकिन फिर मुझे p*=2कहीं और होना होगा।
- ठहराव का वापसी मूल्य नहीं है, अन्यथा यह हो सकता था while pause(p*=2)

— स्टीवी ग्रिफिन
स्रोत

2

एक चाल जिसे मैंने rahnema1 से सीखा: input(0)काम करता है

— लुइस

1

@LuisMendo दुर्भाग्य से हाल के संस्करण में चाल काम नहीं करती है :(

— rahnema1

4

जावा (ओपनजेडके 8) , 113 बाइट्स

interface M{static void main(String[]a)throws Exception{for(int i=1;;Thread.sleep(i*=2))System.out.print(a[0]);}}

इसे ऑनलाइन आज़माएं!

-60 बाइट्स लीक ली नन को धन्यवाद!

— HyperNeutrino
स्रोत

2

+1 के लिए "गोल्फ के लिए जावा का उपयोग न करें। यह एक बुरा विचार है।" क्या आप एक TIO लिंक जोड़ सकते हैं?

— प्रोग्रामर

@ प्रोग्रामर 5000 ज़रूर, लेकिन यह काम नहीं करता है, क्योंकि TIO कोड खत्म होने का इंतजार करता है।

— हाइपरएन्यूट्रीनो

2

क्लास के बजाय इंटरफ़ेस क्यों?

— 17'17

2

@rightfold एक इंटरफ़ेस आपको अंदर से बाहर निकलने की अनुमति देता publicहै public static void main।

— लीक नून

1

@ColeJohnson तर्कों की आवश्यकता है।

— लीक नून

4

आर, 50 48 बाइट्स

function(x,i=1)repeat{cat(x);Sys.sleep(i);i=i*2}

एक अनाम फ़ंक्शन देता है जिसमें एक अनिवार्य तर्क है, प्रिंट करने के लिए स्ट्रिंग। प्रिंट कोई नई बात नहीं है, बस xस्क्रीन पर बाहर थूकता है। iएक वैकल्पिक तर्क है 1, जो iसेकंड और डबल्स की प्रतीक्षा करता है i।

-2 बाइट्स पाजोंक के लिए धन्यवाद

इसे ऑनलाइन आज़माएं!

— ग्यूसेप
स्रोत

क्यों नहीं शुरू में i=1तो i=i*2अंत में उपयोग करें और बस सो जाओ i?

— पाजोंक

यह एक महान विचार है ... मैं इसे बदल दूँगा।

— ग्यूसेप

4

रूबी, 34 28 23 22 (+2 के लिए `-n`) = 24 बाइट्स

3 बाइट्स ने मूल्य स्याही के लिए धन्यवाद बचाया!

1 बाइट ने डैनिएरो को धन्यवाद दिया

loop{print;sleep$.*=2}

2तब शुरू होता है 4, आदि।

व्याख्या

-n                       # read a line from STDIN
  loop{                } # while(true):
       print;            # print that line
             sleep$.*=2  # multiply $. by 2, then sleep that many seconds. 
                         # $. is a Ruby special variable that starts at 1.

— Cyoce
स्रोत

यह इनपुट पढ़ने से पहले एक सेकंड सोएगा, लेकिन आप इसे पहले से ही दर्ज कर सकते हैं

— जॉन ड्वोरक

-nझंडे के साथ रूबी कार्यक्रम शुरू करने से आप शुरुआती getsकॉल को छोड़ सकते हैं , क्योंकि झंडा इसे आपके लिए संभाल लेगा

— वैल्यू इंक

printएक तर्क के बिना puts$_- एक बाइट बचाया के बराबर है

— daniero

4

एलिस , 16 बाइट्स

1/?!\v
T\io/>2*.

इसे ऑनलाइन आज़माएं! (निश्चित रूप से वहां देखने के लिए बहुत कुछ नहीं है, लेकिन आप जांच सकते हैं कि यह एक मिनट के भीतर कितनी बार मुद्रित किया गया था।)

व्याख्या

1    Push 1 to the stack. The initial pause duration in milliseconds.
/    Reflect to SE. Switch to Ordinal.
i    Read all input.
!    Store it on the tape.
/    Reflect to E. Switch to Cardinal.
>    Move east (does nothing but it's the entry of the main loop).
2*   Double the pause duration.
.    Duplicate it.
     The IP wraps around to the first column.
T    Sleep for that many milliseconds.
\    Reflect to NE. Switch to Ordinal.
?    Retrieve the input from the tape.
o    Print it.
\    Reflect to E. Switch to Cardinal.
v    Move south.
>    Move east. Run another iteration of the main loop.

— मार्टिन एंडर
स्रोत

4

आर, 44 43 बाइट्स

पार किया 44 अभी भी नियमित है 44 ;;

यह उत्तर पहले से ही एक सभ्य समाधान प्रदान करता है, लेकिन हम कुछ और बाइट्स बचा सकते हैं।

function(x)repeat{cat(x);Sys.sleep(T<-T*2)}

अनाम फ़ंक्शन व्यावहारिक रूप से तर्क के रूप में मुद्रण योग्य कुछ भी ले रहा है x। 2 सेकंड से शुरू होता है और बाद में हर बार दोगुना हो जाता है। उस तथ्य का दुरुपयोग करता है जो Tडिफ़ॉल्ट रूप से परिभाषित होता है, TRUEजिसका मूल्यांकन करता है 1।

इसके अलावा, जब तक यह टिप्पणी अभी भी ओपी से हरी बत्ती मिलती है, हम इसे और भी छोटा कर सकते हैं, लेकिन मुझे नहीं लगता कि यह चुनौती की भावना में है। 0 के प्रतीक्षा समय की अनुमति नहीं है।

function(x)repeat cat(x)

— JAD
स्रोत

2

तुम देखो, Tउस तरह गरीबों को गाली देना । उत्तर के छोटे संस्करण में, आपको केवल स्थान की आवश्यकता नहीं है।

— ग्यूसेप

1

अरे, अगर Tयह पसंद नहीं है, Tखुद के लिए खड़े हो सकते हैं। इसके अलावा, अच्छा लगता है :)

— JAD

3

क्यूबिक्स , 30 बाइट्स

/(?:u<q.;1A>?ou2$/r;w;q^_q.\*/

इसे यहाँ आज़माएँ

यह एक घन की तरफ है जिसकी लंबाई 3 है।

      / ( ?              # The top face does the delay.  It takes the stack element with the
      : u <              # delay value, duplicates and decrements it to 0.  When 0 is hit the
      q . ;              # IP moves into the sequence which doubles the delay value.
1 A > ? o u 2 $ / r ; w  # Initiates the stack with one and the input.  For input hi this
; q ^ _ q . \ * / . . .  # gives us 1, -1, 10, 105, 104.  There is a little loop that prints 
. . . . . . . . . . . .  # each item in the stack dropping it to the bottom until -1 is hit.
      . . .              # Then the delay sequence is started om the top face
      . . .
      . . .

— MickyT
स्रोत

अरे वाह यह तो साफ

— सुथरी

3

बैश , 37 बाइट्स

for((t=1;;t*=2)){ sleep $t;echo $1;};

किसी कारण से TIO आउटपुट तब तक नहीं दिखाएगा जब तक आप प्रोग्राम निष्पादन को रोक नहीं देते।

इसे ऑनलाइन आज़माएं!

— मैक्सिम मिखायलोव
स्रोत

हाँ, यह केवल पूरा होने पर आउटपुट देता है।

— जोनाथन एलन

3

PHP, 31 बाइट्स

for(;;sleep(2**$i++))echo$argn;
for(;;sleep(1<<$i++))echo$argn;

1, 2, 4, 8, ... सेकंड सोता है। साथ पाइप के रूप में चलाएँphp -nR '<code>'

63 वें प्रिंट (64 बिट मशीन पर) तक काम करेगा, उसके बाद और इंतजार नहीं करना पड़ेगा।
संस्करण 1 चेतावनी देगा sleep() expects parameter 1 to be integer, float given,
संस्करण 2 एक चेतावनी देगा sleep(): Number of seconds must be greater than or equal to 0।

चेतावनी म्यूट करने @से पहले डालें sleep।

— टाइटस
स्रोत

3

टीआई-बेसिक, 21 बाइट्स

Prompt Str0
1
While 1
Disp Str0
Wait Ans
2Ans
End

— pizzapants184
स्रोत

2

पायथन 3, 61 बाइट्स

import time;i=1;x=input()
while 1:print(x);time.sleep(i);i*=2

@ L3viathan के गोल्फ के समान, लेकिन whileलूप का उपयोग करता है

— Wondercricket
स्रोत

2

सीजेएम, 26 बाइट्स

qKes{es1$-Y$<{W$o;2*es}|}h

TIO पर ठीक से काम नहीं करता है।

पहला ठहराव 20 मिलीसेकंड है।

व्याख्या

q                           e# Push the input.
 K                          e# Push 20 (the pause time).
  es                        e# Push the time (number of milliseconds since the Unix epoch).
    {                       e# Do:
     es1$-                  e#  Subtract the stored time from the current time.
          Y$<{              e#  If it's not less than the pause time:
              W$o           e#   Print the input.
                 ;2*es      e#   Delete the stored time, multiply the pause time by 2, push
                            e#     the new time.
                      }|    e#  (end if)
                        }h  e# While the top of stack (not popped) is truthy.
                            e#  (It always is since the time is a positive integer)

— बिजनेस कैट
स्रोत

2

सी, 51 बाइट्स

main(c,v)char**v;{puts(v[1]);sleep(c);main(2*c,v);}

सी, एक समारोह के रूप में 35 बाइट्स

c=1;f(n){puts(n);sleep(c*=2);f(n);}

कमांड लाइन तर्क के रूप में इनपुट लेता है।

— cleblanc
स्रोत

2

बैच, 62 बाइट्स

@set/at=%2+0,t+=t+!t
@echo %1
@timeout/t>nul %t%
@%0 %1 %t%

यह स्पष्ट रूप tसे एक लूप में दोगुने से बाइट से कम निकला :

@set t=1
:g
@echo %1
@timeout/t>nul %t%
@set/at*=2
@goto g

— नील
स्रोत

2

जालीदार , 12 बाइट्स

1idp~dw2*~2j

इसे ऑनलाइन आज़माएं!

व्याख्या

1idp~dw2*~2j
1               push 1 (initial delay)
 i              take line of input
  d             duplicate it
   p            print it
    ~           swap
     d          duplicate it
      w         wait (in seconds)
       2*       double it
         ~      swap
          2j    skip next two characters
1i              (skipped)
  d             duplicate input
   p            print...
                etc.

— कोनोर ओ ब्रायन
स्रोत

2

सी #, 80 79 बाइट्स

s=>{for(int i=1;;System.Threading.Thread.Sleep(i*=2))System.Console.Write(s);};

@Raznagul को एक बाइट धन्यवाद दिया।

— TheLethalCoder
स्रोत

आप 1 बाइट Writeको लूप के बॉडी में ले जाकर सेव कर सकते हैं ।

— राजनागुल

@raznagul पता नहीं कैसे मैं उस एक को याद किया, धन्यवाद!

— TheLethalCoder

2

पायथन 2, 54 बाइट्स

पुस्तकालयों के समय के बजाय एक लंबी गणना का उपयोग करता है।

def f(x,a=1):
 while 1:a*=2;exec'v=9**9**6;'*a;print x

— स्काईलर
स्रोत

मैंने अब नोटिस किया कि मेरा जवाब भी आपके जैसा ही है। जब मैंने पोस्ट किया तो मैंने आपका उत्तर नहीं पढ़ा था, लेकिन यदि आप मेरे समाधान को अपने में शामिल करना चाहते हैं, तो मैं खुशी से अपना उत्तर हटा दूंगा।

— टिम

2

पॉवरशेल, 35 33 30 29 बाइट्स

जो और जोए से एक सहायक संकेत के साथ

%{for($a=1){$_;sleep($a*=2)}}

व्याख्या

%{          # Foreach
for($a=1){  # empty for loop makes this infinite and sets $a
$_;         # prints current foreach item
sleep($a*=2)# Start-Sleep alias for $a seconds, reassign $a to itself times 2           
}}          # close while and foreach

इसके साथ निष्पादित:

"hi"|%{for($a=1){$_;sleep($a*=2)}}

— SomeShinyObject
स्रोत

1

आपको समय के बजाय एक रिक्त का उपयोग करने में सक्षम होना चाहिए:% {$ a = 1; के लिए () {$ _; नींद ($ a = 2)}}} ``

— जो भी हो

धन्यवाद! मैंने पहले लूप का उपयोग करने की कोशिश की थी लेकिन मैंने लगा दी for(;;)। अर्ध-कोलों को हटाने की कोशिश भी नहीं की।

— SomeShinyObject

1

एक और बाइट ( ) को बचाने $a=1के forलिए आरंभीकरण के रूप में रखो for($a=1){...}। इसके अलावा, मुझे यकीन नहीं है कि क्या गिनना है %, क्योंकि आप जो वास्तविक दिनचर्या चला रहे हैं वह सिर्फ एक स्क्रिप्ट ब्लॉक है। (मेरी चुनौतियां इस तरह के विचार-विमर्श को दरकिनार करने के बजाय एक कार्यक्रम की आवश्यकता के बारे में सख्त हैं, लेकिन किसी भी चीज के लिए मैं अभी भी निश्चित नहीं हूं कि

— जोए

@ जोई, मिठाई जो काम करती है। टिप के लिए धन्यवाद

— SomeShinyObject

2

पायथन 3, 49 बाइट्स

b=input();x=6**6
while 1:print(b);exec("x+=1;"*x)

+=ऑपरेशन की थोड़ी देरी का उपयोग करता है और इसे निष्पादित करता हैx कई बार । xके मूल्य के रूप में कई बार खुद को जोड़कर डबल्स x।

यह 6^6देरी में अधिकतम 5% भिन्नता के लिए छड़ी करने के लिए (46656) से शुरू होता है ।

— टिम
स्रोत

चतुर, लेकिन यह एक स्मृति हॉग है।

— eush77

@ eush77 हाँ, मेरे टेबलेट पर यह लूप के सिर्फ 7 पुनरावृत्तियों के बाद समाप्त हो गया! मुझे उम्मीद है कि यह मेरे डेस्कटॉप पर कुछ समय तक चलेगा।

— टिम

1

पर्ल 6 , 39 बाइट्स

print(once slurp),.&sleep for 1,2,4...*

इसे आज़माएं ( printसमय की जानकारी जोड़ने के लिए ओवरराइड)

विस्तारित:

  print(        # print to $*OUT
    once slurp  # slurp from $*IN, but only once
  ), 
  .&sleep       # then call sleep as if it was a method on $_

for             # do that for (sets $_ to each of the following)

  1, 2, 4 ... * # deductive sequence generator

— ब्रैड गिल्बर्ट b2gills
स्रोत

1

जेएस (ईएस 6), 44 42 40 38 36 बाइट्स

^{^{44 को पार कर अभी भी 44 है}}

i=1,y=x=>setTimeout(y,i*=2,alert(x))

अलर्ट बम पसंद नहीं है?

i=1,y=x=>setTimeout(y,i*=2,console.log(x))

तकनीकी रूप से सही, लेकिन खामियों को दूर करने वाला:

y=x=>(x&&alert(x),y())

Cyoce को -3 बाइट्स, बिजनेस कैट को -2 धन्यवाद, -2 नील को धन्यवाद

— programmer5000
स्रोत

2

मुझे यह ठीक से परीक्षण करने में सक्षम नहीं लगता है, लेकिन आप शायद i=1,y=x=>(alert(x),setTimeout(y,i*=2))एक युगल बाइट्स को बचाने के लिए कर सकते हैं

— बिजनेस कैट

1

मैंने आगे जाकर साइओस के लिए एक क्रेडिट संदेश में संपादित किया; अगर आप इसे बदलना चाहते हैं, तो बेझिझक संपादित करें / रोलबैक करें।

— हाइपरएन्यूट्रीनो

1

कैसे के बारे में i=1,y=x=>setTimeout(y,i*=2,console.log(x))?

— नील

1

आम लिस्प, 49 बाइट्स

(do((a(read))(i 1(* 2 i)))(())(print a)(sleep i))

पहली देरी 1दूसरी होनी चाहिए ।

1

आपके पास 321 प्रतिनिधि हैं!

— प्रोग्रामर

@ प्रोग्रामर 5000 आपके पास 3683 प्रतिनिधि हैं!

— साइओस

1

अजगर, 7 बाइट्स

#|.d~yT

स्पष्टीकरण:

#           Infinitely loop
  .d         Delay for 
      T      10 seconds
    ~y       and double T each time
 |           print input every iteration, too

— स्टीवन एच।
स्रोत

1

टीआई-बेसिक, 36 बाइट्स

प्रारंभिक प्रतीक्षा अवधि 1 सेकंड है।

1→L
Input Str1
checkTmr(0→T
While 1
While L>checkTmr(T
End
Disp Str1
2L→L
End

— kamoroso94
स्रोत

1

रैकेट, 51 बाइट्स

(λ(s)(do([n 1(* n 2)])(#f)(displayln s)(sleep n)))

उदाहरण

➜  ~  racket -e '((λ(s)(do([n 1(* n 2)])(#f)(displayln s)(sleep n)))"Hello")'
Hello
Hello
Hello
Hello
Hello
^Cuser break

— winny
स्रोत

जब तक दो बार रोकें

05AB1E , 6 बाइट्स

स्क्रैच, 8 ब्लॉक + 3 बाइट्स

पायथन 3, 60 56 बाइट्स

MATL , 8 बाइट्स

व्याख्या

गणितज्ञ 34 32 30 29 बाइट्स

ऑक्टेव, 42 41 बाइट्स

जावा (ओपनजेडके 8) , 113 बाइट्स

आर, 50 48 बाइट्स

रूबी, 34 28 23 22 (+2 के लिए -n) = 24 बाइट्स

व्याख्या

एलिस , 16 बाइट्स

व्याख्या

आर, 44 43 बाइट्स

क्यूबिक्स , 30 बाइट्स

बैश , 37 बाइट्स

PHP, 31 बाइट्स

टीआई-बेसिक, 21 बाइट्स

पायथन 3, 61 बाइट्स

सीजेएम, 26 बाइट्स

सी, 51 बाइट्स

सी, एक समारोह के रूप में 35 बाइट्स

बैच, 62 बाइट्स

जालीदार , 12 बाइट्स

व्याख्या

सी #, 80 79 बाइट्स

पायथन 2, 54 बाइट्स

पॉवरशेल, 35 33 30 29 बाइट्स

व्याख्या

पायथन 3, 49 बाइट्स

पर्ल 6 , 39 बाइट्स

विस्तारित:

जेएस (ईएस 6), 44 42 40 38 36 बाइट्स

आम लिस्प, 49 बाइट्स

अजगर, 7 बाइट्स

टीआई-बेसिक, 36 बाइट्स

रैकेट, 51 बाइट्स

उदाहरण

रूबी, 34 28 23 22 (+2 के लिए `-n`) = 24 बाइट्स