सारांश

एक प्रोग्राम या फ़ंक्शन लिखें, जो कोई इनपुट नहीं लेता है, और सभी पूर्णांक संख्याओं को आउटपुट करता है, -1000 और 1000 के बीच आरोही क्रम में, stdout तक, प्रति पंक्ति, इस तरह:

-1000
-999
-998
-997
...

और इसके बाद आपको इन नंबरों को प्रिंट करने में लगने वाले समय को प्रिंट करने की आवश्यकता होती है, या मिलिसेकंड्स में कार्यक्रम के निष्पादन की शुरुआत से समय (यदि आवश्यक हो, तो इसमें कुछ अन्य चीजें भी हो सकती हैं, उदाहरण के लिए: लिया गया समय: xxxms ठीक है)। यह एक फ्लोट, या एक पूर्णांक हो सकता है (यदि आप एक पूर्णांक प्रिंट करते हैं, तो आपको निकटतम पास करने की आवश्यकता है)।

उदाहरण कोड

using System;
using System.Diagnostics;
class P
{
    static void Main(string[] args)
    {
        Stopwatch st = Stopwatch.StartNew();
        for (int i = -1000; i <= 1000; i++)
        {
            Console.WriteLine(i);
        }
        Console.WriteLine(st.ElapsedMilliseconds);      
    }
}

प्रतिबंध

मानक खामियों की अनुमति नहीं है

अन्य infos

यह कोड गोल्फ है, इसलिए कम से कम सबमिशन जीतता है।

code-golf number date

— होर्वाथ डेविड
स्रोत

@ गुरुपुरमदापुर नहीं, क्षमा करें

— होर्वाथ

क्यूं कर? मुझे लगता है कि अनिवार्य रूप से उन नंबरों को प्रिंट करना है जो हर बयान कार्यक्रम की शुरुआत से शामिल है?

— गुरुपाद ममदापुर १४'१ at को १ad:

1

@ गुरुपुरमदापुर ठीक है, आप सही हैं, मैं तदनुसार प्रश्न संपादित करूंगा।

— होर्विथ डेविद

क्या कार्यक्रम प्रारंभ से कुछ समय प्रतीक्षा कर सकता है, और उस राशि को प्रिंट कर सकता है?

— xnor

@xnor मुझे लगता है, कि चुनौती बदल जाएगी, और क्योंकि मूल चुनौती के पहले से ही बहुत सारे उत्तर हैं, मैं कहूंगा कि नहीं।

— होर्वाथ डेविद

9

MATL , 13 बाइट्स

1e3t_y&:!DZ`*

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

       % Implicitly start timer
1e3    % Push 1000
       % STACK: 1000
t_     % Duplicate, negate
       % STACK: 1000, -1000
y      % Duplicate second-top number
       % STACK: 1000, -1000, 1000
&:     % Two-input range
       % STACK: 1000, [-1000, 999, ..., 1000]
!      % Transpose into column vector
       % STACK: 1000, [-1000; 999; ...; 1000]
D      % Display
       % STACK: 1000
Z`     % Push timer value, say t
       % STACK: 1000, t
*      % Multiply
       % STACK: 1000*t
       % Implicitly display

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

2

बहुत अच्छा! स्मार्ट लागू करने के लिए: Implicitly start timer। क्या यह पहले दिन से था, या क्या यह पहले की चुनौती का परिणाम है?

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

@StewieGriffin दिन से नहीं। मैंने इसे १३ जुलाई २०१६ को जोड़ा था , संभवत: इसे स्पष्ट रूप से कुछ चुनौतियों में अंतर करने के बाद

— लुइस मेंडो

9

ऑक्टेव, 46 43 36 30 23 बाइट्स

tic;(-1e3:1e3)',toc*1e3

यह प्रिंट करेगा:

यदि आपको पसंद नहीं है ans =, तो हमें इसके लिए अतिरिक्त 6 बाइट्स जोड़ने होंगे disp:

tic;disp((-1e3:1e3)'),toc*1e3

Rahnema1 से कुछ अनुस्मारक के लिए बहुत सारे बाइट्स का धन्यवाद।

स्पष्टीकरण:

tic;                              % Starts timer
         (-1e3:1e3)'              % A vertical vector -1000 ... 1000
    disp((-1e3:1e3)'),            % Display this vector
                      toc*1e3     % Stop the timer and output the time in milliseconds

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

8

जावास्क्रिप्ट, 60 बाइट्स

(c=console).time();for(i=~1e3;i++<1e3;c.log(i));c.timeEnd();

सभी घटनाओं को लॉग इन करने के लिए, आपको डेवलपर कंसोल से स्क्रिप्ट का उपयोग करना चाहिए (अन्यथा उनमें से कुछ राशि के बाद लॉग मिटा दिए जाते हैं)।

— nicael
स्रोत

i=~1e3एक बाइट को बचाने के लिए :-)

— ETHproductions

7

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

es2001{1e3-n}/es\-

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

यह काम किस प्रकार करता है

es                  Push the current time (milliseconds since epoch) on the stack.
  2001{     }/      For each integer X from 0 to 2000:
       1e3-           Subtract 1000 from X.
           n          Print with a newline.
              es    Push the current time on the stack.
                \-  Swap and subtract.

— डेनिस
स्रोत

7

पायथन 3.5, 80 77 73 बाइट्स

import time
*map(print,range(-1000,1001)),
print(time.process_time()*1e3)

पिछले समाधानों में शामिल थे timeitऔर time.time(), वे बड़े थे।

अफसोस की बात है, time.process_time()अजगर 3.3 में पेश किया गया था।

4 बाइट बचाने के लिए डेनिस के लिए धन्यवाद !

— गुरुपाद ममदापुर
स्रोत

5

बैश (+ कोर्यूटिल्स), 41, 49, 46, 44, 42 बाइट्स

संपादन:

बैश-बिल्टिन (समय) का उपयोग करने के लिए, @ डेनिस सटीक चिंताओं को संबोधित करने के लिए रिफैक्टेड;
3 बाइट्स से |&घटाकर, बैडर 4+ का उपयोग स्टैडर पुनर्निर्देशन के लिए किया जाता है;
के seq -1000 1000साथ प्रतिस्थापित करके 2 और बाइट्स को seq -1e3 1e3बचाया (धन्यवाद @ डेनिस!);
अनावश्यक बैकस्लैश को हटाकर और डिफ़ॉल्ट परिशुद्धता (Thx @Dennis!) का उपयोग करके -2 बाइट्स।

golfed

TIMEFORMAT=%R*1000;(time seq -1e3 1e3)|&bc

यह ऑनलाइन की कोशिश करो!

पक्षीय लेख

बैश-बिलिन के बजाय कोर्यूटिल्स "टाइम" उपयोगिता का उपयोग करने के परिणामस्वरूप, ए 41, 35 बाइट समाधान:

\time -f "%e*1000" seq -1e3 1e3|&bc

"\" यहांबिलिन के बजाय वास्तविक कमांडको बैश करने के लिए है।

दुर्भाग्य से कोर्यूटिल्स समय की सटीकता केवल 1/100 है, जिसने इस पर चिंता जताई है कि क्या यह एक वैध समाधान है।

— टसेपेल्लिन
स्रोत

4

आर, 42 बाइट्स

system.time(cat(-1e3:1e3,sep="\n"))[3]*1e3

यह छपेगा

.
.
.
998
999
1000
elapsed 
     60

निकालने के लिए elapsed, दो अतिरिक्त बाइट आवश्यक हैं:

system.time(cat(-1e3:1e3,sep="\n"))[[3]]*1e3

— स्वेन होहेंस्टीन
स्रोत

4

बाश + GNU बर्तन, 43

@Dennis के लिए धन्यवाद 2 बाइट्स सहेजे गए
सहेजे गए 5 बाइट्स @zeppelin की बदौलत

c=date\ +%s%3N
s=`$c`
seq -1e3 1e3
$c-$s|bc

dateआदेश युग वर्तमान नैनोसेकंड साथ concatenated के बाद से सेकंड की संख्या देता है। यह कमांड पहले और बाद में चलाया जाता है। bcअंतर और प्रिंट लेता है।

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

मैं 17 के लिए यह करने की उम्मीद कर रहा था:

time seq -1e3 1e3

लेकिन समय का उत्पादन हमारी आवश्यकता से अधिक देता है:

real    0m0.004s
user    0m0.000s
sys 0m0.004s

— डिजिटल आघात
स्रोत

1

के 1000साथ प्रतिस्थापित करके आप दो बाइट्स बचा सकते हैं 1e3।

— डेनिस

"लेकिन समय का उत्पादन देता है ...." ... शायद आपको आदमी को मारना चाहिए।

— एच वाल्टर्स

1

आप शायद कुछ बाइट्स को बचा सकते हैं, इस तरह सीधे एमएस परिशुद्धता के साथ तारीख को कैप्चर करके date +%s%3N:।

— जेपेलिन

4

जावास्क्रिप्ट (ईएस 6), 63 59 बाइट्स

for(c=console.log,i=~1e3;i<1e3;c(++i));c(performance.now())

स्निपेट का विस्तार करें

— जॉर्ज रीथ
स्रोत

अच्छा लगा। आप अंतरिक्ष को हटाकर तीन बाइट्स बचा सकते हैं new (d=Date)और -1000 से शुरू कर सकते हैं:for(t=new(d=Date),c=console.log,i=~1e3;i<1e3;c(++i));c(new d-t)

— ETHproductions

@ETHproductions धन्यवाद :) ~1e3एक महान स्पर्श है।

— जॉर्ज रीथ

1

स्निपेट आउटपुट में केवल उसी 952से 1000क्यों होता है?

— गुरुपद ममदापुर

@GurupadMamadapur स्निपेट का उत्पादन 50 लाइनों तक सीमित है। (या अधिक सटीक: 50 अंतिम पंक्तियाँ।)

— अरनुलद

1

@IsmaelMiguel अमेजिंग को performance.now()या Performanceइंटरफेस के बारे में बिल्कुल भी जानकारी नहीं थी

— जॉर्ज रीथ

3

आर, 66 बाइट्स

x=proc.time();for(i in -1e3:1e3)cat(i,"\n");(proc.time()-x)[3]*1e3

शायद सबसे छोटा नहीं है लेकिन यह काम करता है।

— Billywob
स्रोत

proc.timeएक चर में संग्रहीत किया जा सकता है? t=proc.time;x=t(); ...

— अन्नान

3

गणितज्ञ, 51 बाइट्स

p[1*^3#]&@@AbsoluteTiming@Array[p=Print,2001,-1*^3]

व्याख्या

Array[p=Print,2001,-1*^3]

में Printफंक्शन को स्टोर करेंp । 2001 नंबर प्रिंट करें, -1000 से शुरू, 1 से बढ़े।

AbsoluteTiming@ ...

सेकंड में गुजरे कुल समय का पता लगाएं।

p[1*^3#]&@@ ...

गुणा करें कि 1000 (सेकंड -> मिलिसकंड) और p( Print) से।

— जंगहवान मिन
स्रोत

आर्ग, तुम मुझे 3 मिनट से हरा! :) क्या आप सुनिश्चित हैं कि Timing(थोड़ा अस्पष्ट) समस्या के विवरण के साथ ही संतुष्ट नहीं हैं AbsoluteTiming?

— ग्रेग मार्टिन

2

@GregMartin TimingCPU समय को आउटपुट करता है और इसमें फ्रंट एंड द्वारा लिया गया समय शामिल नहीं होता है। अर्थात्। काउंटर को बढ़ाने के लिए लिया गया समय Arrayगिना जाता है, लेकिन स्क्रीन पर उन संख्याओं को प्रदर्शित करने के लिए लिया गया समय नहीं गिना जाता है। यह प्रभाव इस सरल उदाहरण में देखा जा सकता है: Timing@Print@30 सेकंड देता है, लेकिन AbsoluteTiming@Print@3नहीं।

— जुंगह्वान मिन

3

PHP, 110 70 बाइट्स

अभी भी थोड़ा लंबा; लेकिन साथ @ AlexHowansky's संकेत 38 को बचा लिया, और दो अधिक के साथ 1e3और ~1e3।

for($t=($m=microtime)($i=~1e3);$i++<1e3;)echo"$i
";echo($m(1)-$t)*1e3;

प्रिंट तैरते हैं। के साथ भागो -r।

— टाइटस
स्रोत

2

आप माइक्रोटाइम पास कर सकते हैं () एक सत्य मान और यह सीधे एक फ्लोट लौटाएगा, आपको तार जोड़ने की ज़रूरत नहीं है।

— एलेक्स हॉवान्स्की

-30% उस संकेत के साथ। काश मैं आपकी टिप्पणी पर दस अपवोट कर पाता। : डी

— टाइटस

यह दुख की बात है कि PHP के पास कुछ ऐसा नहीं है जो मिलीसेकंड में समय लौटाता है। जैसे जावास्क्रिप्ट है। मैं सुधार का सुझाव नहीं दे सकता। यह उतना छोटा है जितना इसे मिल सकता है। बहुत बढ़िया!

— इस्माइल मिगुएल

@IsmaelMiguel मुझे लगता है कि जावास्क्रिप्ट में माइक्रोसेकंड नहीं है। :)

— टाइटस

@ टिट्स का मेरा मतलब है कि जावास्क्रिप्ट की तारीखें सभी मिलीसेकंड में नियंत्रित की जाती हैं, जबकि PHP में केवल सेकंड या माइक्रोसेकंड थे।

— इस्माईल मिगुएल

3

पॉवरशेल, 27 बाइट्स

$1=date;-1e3..1e3;(date)-$1

यह इंगित करने के लिए AdmBorkBork को धन्यवाद कि चुनौती में क्रिया डिफ़ॉल्ट आउटपुट स्वीकार्य है।

आउटपुट जैसे:

994
995
996
997
998
999
1000

Days              : 0
Hours             : 0
Minutes           : 0
Seconds           : 5
Milliseconds      : 679
Ticks             : 56799255
TotalDays         : 6.57398784722222E-05
TotalHours        : 0.00157775708333333
TotalMinutes      : 0.094665425
TotalSeconds      : 5.6799255
TotalMilliseconds : 5679.9255

केवल मिलीसेकंड के अधिक निहित परिणाम के लिए, मूल उत्तर का उपयोग करें:

$1=date;-1e3..1e3;((date)-$1).TotalMilliseconds

$ 1 से पहले समय बचाएं, स्वचालित रूप से प्रिंटआउट करने के लिए प्रिंट करें, फिर निष्पादन की शुरुआत और अंत के बीच का समय प्राप्त करें।

— colsw
स्रोत

आप बस oh( Out-Host) को सीमा तक पाइप कर सकते हैं जो इस तथ्य को बाईपास करेगा जो Measure-Commandपाइप लाइन को पकड़ता है। TIO पर उदाहरण

— AdmBorkBork

@AdmBorkBork बिंदु यह था कि मुझे नहीं लगता कि यह बाइट्स को बचाएगा, जब तक कि मैं कुछ याद नहीं कर रहा हूं।

— colsw

Measure-Command{-1e3..1e3|oh}29 बाइट्स है। ज़रूर, यह अतिरिक्त सामान धन्यवाद के लिए प्रिंट करता है Measure-Command, लेकिन चुनौती स्पष्ट रूप से बताती है कि ठीक है।

— AdmBorkBork

वास्तव में उस बिंदु से चूक गए जहां आप अन्य डेटा प्रिंट कर सकते हैं, चुनौती निर्माता को यह कहने की आवश्यकता हो सकती है कि क्या माप-कमान का बहुत ही वर्बोज़ आउटपुट स्वीकार्य है। वहाँ भी $1=date;-1e3..1e3;(date)-$12 बाइट्स माप-कमान विकल्प से कम है,

— colsw

ओह ठीक है, हाहा। अच्छा गोल्फ।

— AdmBorkBork

2

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

.put for -($_=1e3)..$_;put (now -INIT now)*$_

कोशिश करो

विस्तारित:

# print the values

.put             # print with trailing newline ( method call on ｢$_｣ )

for              # for each of the following
                 # ( temporarily sets ｢$_｣ to the value )

-(
  $_ = 1e3       # store ｢Num(1000)｣ in ｢$_｣
)
..               # inclusive Range object
$_;

# print the time elapsed

put              # print with trailing newline

(now - INIT now) # Duration object that numifies to elapsed seconds
* $_             # times 1000 to bring it to milliseconds

# The ｢INIT｣ phaser runs code (the second ｢now｣) immediately
# as the program starts.

# There is no otherwise unrelated set-up in this code so this is a
# reliable indicator of the amount of time it takes to print the values.

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

2

जे , 22 बाइट्स

1e3*timex'echo,.i:1e3'

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

timexएक बिलिन है जो स्ट्रिंग को निष्पादित करता है और सेकंड में इसका मूल्यांकन करने के लिए समय लेता है। स्ट्रिंग का उपयोग कर रेंज [-1000, 1000] i:बनाता है, फिर इसका उपयोग करके कोलुमिन करता है ,., और इसे बिलिन का उपयोग करके प्रिंट करता है echo।

— मील की दूरी पर
स्रोत

2

पायथ , 18 15 14 बाइट्स

j}_J^T3J;*.d1J

यहाँ कोशिश करो!

व्याख्या

यह मेरे अजगर जवाब के समान है।

    J ^ T3 सेट J से 1000
  } _ J लिस्ट -1000 से 1000 तक
j नई लाइनों के साथ सूची में शामिल हों और इसे प्रिंट करें
         ; * d1J मिलीसेकंड में कार्यक्रम के निष्पादन के बाद से प्रिंट समय

संपादन :

3 बाइट बचाने के लिए fryamtheeggman को धन्यवाद !
एक बाइट को बचाने के लिए बसुकक्सुआन के लिए धन्यवाद ।

— गुरुपाद ममदापुर
स्रोत

मैंने यह कोशिश की, 14 बाइट्स, सुनिश्चित नहीं हैं कि यह सही काम करता है। आपको कार्यक्रम की शुरुआत में एक नई पंक्ति जोड़ने की आवश्यकता है। pyth.herokuapp.com/?code=%0AM%7D_J%5ET3J%2a.d1J&debug=0

— Busukxuan

2

नूडल , 17 13 बाइट्स

13 बाइट्स

थोड़ा अलग दृष्टिकोण अपनाया और 4 बाइट्स बचाए।

ƇQjȥḶGQɱ⁻Ñ€Ƈ⁻

कोशिश करो:)

यह काम किस प्रकार करता है

Ƈ             # Pushes on the amount of milliseconds passed since 01/01/1970.

 Qjȥ          # Pushes 2001 onto the stack.
 Qj           # Pushes on the string "Qj"
   ȥ          # Converts the string into a number as base 98.

    ḶGQɱ⁻Ñ€   # Loops 2001 times printing -1000 to 1000.
    Ḷ         # Consumes the 2001 and loops the following code 2001 times.
     GQ       # Pushes on the string "GQ"
       ɱ      # Pushes on the current counter of the loop (i)
        ⁻     # Subtracts (i - "GQ") since i is a number, the "GQ" is converted to a number which will fail.
              # So, Noodel will treat the string as a base 98 number producing (i - 1000). 
         Ñ    # Consume what is on the top of the stack pushing it to the screen followed by a new line.
          €   # The end of the loop.

           Ƈ⁻ # Calculates the duration of execution.
           Ƈ  # Pushes on the amount of milliseconds passed since 01/01/1970.
            ⁻ # Pushes on (end - start)

17 बाइट्स

ƇGQȥḋɲṡ×2Ḷñ⁺1€ÑƇ⁻

कोशिश करो:)

यह काम किस प्रकार करता है

Ƈ                 # Pushes on the amount of milliseconds passed since 01/01/1970.

 GQȥḋɲṡ×2         # Used to create the range of numbers to be printed.
 GQ               # Pushes on the string "GQ".
   ȥ              # Converts the string into number as if it were a base 98 number. (which is 1000)
    ḋ             # Duplicates the number and pushes it onto the stack. 
     ɲ            # Since the item on top is already a number, makes the number negative (random thing I threw in at the very beginning when made the langauge and totally forgot it was there)
      ṡ           # Swaps the first two items on the stack placing 1000 on top.
       ×2         # Doubles 1000 producing... 2000

         Ḷñ⁺1€Ñ   # Prints all of the numbers from -1000 to 1000.
         Ḷ        # Consumes the 2000 to loop the following code that many times (now -1000 is on the top).
          ñ       # Prints the value on top of the stack followed by a new line.
           ⁺1     # Increment the value on top of the stack by 1.
             €    # End of the loop.
              Ñ   # Since 1000 is still not printed, this consumes 1000 and prints it followed by a new line.

               Ƈ⁻ # Calculates the number of milliseconds to execute program.
               Ƈ  # Pushes on the amount of milliseconds passed since 01/01/1970.
                ⁻ # Pushes on (end - start) in milliseconds.
                  # At the end, the top of the stack is pushed to the screen.

स्निपेट मूल्यों को -4 से 4 का उपयोग करता है ताकि पूरा होने में इतना समय न लगे।

<div id="noodel" code="ƇFȥḶAɱ⁻Ñ€Ƈ⁻" input="" cols="10" rows="10"></div>

<script src="https://tkellehe.github.io/noodel/noodel-latest.js"></script>
<script src="https://tkellehe.github.io/noodel/ppcg.min.js"></script>

स्निपेट का विस्तार करें

— tkellehe
स्रोत

आपने चुनौती के बाद या उससे पहले यह भाषा बनाई थी?

— R

@EasterlyIrk, इससे पहले :)

— tkellehe

2

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

startTmr
For(A,-ᴇ3,ᴇ3
Disp A
End
startTmr-Ans

कई आदेशों का प्रतिनिधित्व 1 या 2-बाइट टोकन द्वारा किया जाता है।
एक अनुकरणीय TI-84 CSE पर परीक्षण किया गया।

— जूलियन लचनीट
स्रोत

2

मतलाब, 16 23 बाइट्स

tic;(-1e3:1e3)'
toc*1e3

संपादित करें: मुझे एहसास हुआ कि मैं इस चुनौती के कई नियमों का उल्लंघन कर रहा था। यह मुझे देर रात को चुनौती पढ़ने के लिए सिखाना होगा। मुझे अब यह भी पता चला कि सही उत्तर ऑक्टेव समाधान के लगभग समान है, लेकिन ऐसा जीवन है।

प्रत्येक तत्व को बनाए गए रैखिक स्थान सरणी -1000: 1000 (कमी; प्रिंट करने के लिए कंसोल) में प्रिंट करता है।

tic / toc समय रिकॉर्ड करता है और toc कंसोल के साथ या उसके बिना समय प्रिंट करता है; । मिलीसेकंड में प्रिंट करने के लिए 1e3 की जरूरत होती है।

— ओवेन मॉर्गन
स्रोत

काफी सही, एक सही समाधान संपादित किया गया है।

— ओवेन मॉर्गन

2

ग्रूवी, 75 73 बाइट्स

t=System.&nanoTime
s=t()
(-1000..1e3).each{println it}
print((t()-s)/1e6)

2 बाइट्स बचाने के लिए jaxad0127 के लिए धन्यवाद !

यहाँ कोशिश करो!

— गुरुपाद ममदापुर
स्रोत

1

nanoTime1e6 से विभाजित के साथ तुलना में कम है currentTimeMillis। यह भिन्नात्मक समय भी देता है।

— jaxad0127

2

8 वें , 61 47 बाइट्स

अच्छे सुधार के लिए 8_देव को धन्यवाद (14 बाइट्स बचाए गए)

d:msec ( . cr ) -1000 1000 loop d:msec swap - .

यह सभी पूर्णांक संख्याओं को -1000 और 1000 के बीच आरोही क्रम में प्रिंट करेगा और इन नंबरों को प्रिंट करने में (मिलीसेकंड में) समय लगेगा

— अराजकता मनोर
स्रोत

1

यह ध्यान दिया जाना चाहिए कि कोड को बेहतर बनाने के लिए संपादन का सुझाव "विनाशकारी" के रूप में योग्य है। गोल्फ के लिए सुझाव के बजाय एक टिप्पणी के रूप में दिया जाना चाहिए। मैं उस उपयोगकर्ता को पिंग करूंगा जिसने अगर ऐसा किया है, लेकिन मैं नहीं कर सकता। meta.codegolf.stackexchange.com/q/1615/34718

— mbomb007

1

मुझे पता है कि आपने इसे अनुमोदित कर दिया है, जो कि आपके अपने पद के बाद से ठीक है, लेकिन समीक्षा कतार में अन्य समीक्षकों को इसे अस्वीकार कर देना चाहिए, और जो उपयोगकर्ता ने सुझाव दिया था कि पहली जगह में संपादन नहीं होना चाहिए।

— mbomb007

@ mbomb007 - मुझे यह बताने के लिए धन्यवाद। इस विशिष्ट मामले में मैंने इसे स्वीकार करने से पहले कोड को सत्यापित किया था, लेकिन अगली बार मैं इस तरह की समीक्षा को छोड़ या अस्वीकार कर दूंगा।

— कैओस मैनर

2

जाप, 23 बाइट्स

दो समान समाधान हैं:

Oo(Ð -(A³òA³n @OpXÃ,Ð¹n
K=Ð;A³òA³n @OpXÃ;OoÐ -K

पहले वाला मूल रूप से निम्नलिखित कार्य करता है:

output(-(new Date() - (1000 .range(-1000).map(X => print(X)), new Date())));

यही है, समय को एक चर में संग्रहीत करने से बचने के लिए घटाव के बीच में संख्याएं मुद्रित की जाती हैं। हालांकि, यह चर मार्ग से कम नहीं है, जो मूल रूप से है:

K = new Date(); 1000 .range(-1000).map(X => print(X)); output(new Date() - K);

जाप के नवीनतम संस्करण में (इस चुनौती से नया), Kस्वचालित रूप से वापस आने के लिए स्थापित किया गया है new Date()। यह 21 बाइट्स के पहले समाधान को काटता है:

Oo(K-(A³òA³n @OpXÃK)n

इसे ऑनलाइन टेस्ट करें!

— ETHproductions
स्रोत

1

QBIC , 34 बाइट्स

d=timer[-z^3,z^3|?a]?z^3*(timer-d)

QBasic TIMERफ़ंक्शन का उपयोग करता है , जो दशमलव संकेतन में सेकंड लौटाता है। यह सुंदर लग रही है कुछ बाइट्स कहते हैं।

व्याख्या

d=timer     Set 'd' to the current # seconds since midnight
[-z^3,z^3|  FOR -1000 to 1000  --  Note that 'z' = 10 in QBIC, and z^3 saves a byte over 1000
?a          Display the iterator
]           Close the FOR loop
    timer-d Take the current time minus the time at the start of the program -- 0.156201
?z^3*()     Multiply by a thousand and display it   156.201

— steenbergh
स्रोत

1

सी ++ - 261

बस एक हंसी के लिए मुझे लगा कि मैं एक C ++ उत्तर पोस्ट करूंगा।

#include <iostream>
#include <chrono>
using namespace std::chrono; using c=std::chrono::system_clock; void p(){c::time_point n=c::now();for(int i=-1001;++i<1001;)std::cout<<i<<"\n";std::cout<<(duration_cast<milliseconds>(system_clock::now()-n)).count()<<"\n";}

मैं यह निर्धारित करने के लिए एक अभ्यास के रूप में छोड़ दूँगा कि यह क्या कर रहा है और इसे कैसे कॉल किया जाए - बहुत मुश्किल नहीं होना चाहिए।

— original.legin
स्रोत

1

स्काला, 77 बाइट्स

def t=System.nanoTime
val s=t
Range(-1000,1001)map println
println((t-s)/1e6)

— jaxad0127
स्रोत

1

फोर्सलैंग, 124

set t timer.new()
set i -1000
label 1
io.writeln set i i+1
if i=1000
 io.write math.floor 0.001.mult t.poll()
 exit()
goto 1

नोट: आपको इसे stderrचलाते समय सुपर्रेस करना चाहिए । मेरा मानना है कि मेटा पर आम सहमति है कि यह एक बाइट गिनती जुर्माना नहीं है।

— SuperJedi224
स्रोत

1

SimpleTemplate , 92 बाइट्स

क्या वास्तव में मुझे मारा गया समय रिकॉर्ड करने की आवश्यकता थी।

{@callmicrotime intoX 1}{@for_ from-1000to1000}{@echol_}{@/}{@phpecho microtime(1)-$DATA[X]}

चूंकि कोई गणित (अभी तक) नहीं है, यह चीजों को बहुत कठिन बनाता है, मुझे सीधे पीएचपी लिखने के लिए मजबूर करता है।

Ungolfed:

{@call microtime into start_time true}
{@for i from -1000 to 1000 step 1}
    {@echol i}{@// echoes a newline after}
{@/}
{@php echo microtime(true) - $DATA["start_time"];}

अस्वीकरण:

मैंने 2017-01-13 से प्रतिबद्ध e118ae72c535b1fdbe1b80c847f52aa161854fda के साथ इसे चलाया है ।

नवीनतम प्रतिबद्धता कुछ को ठीक करने के लिए थी जो यहां कोड से संबंधित नहीं है।

— इस्माइल मिगुएल
स्रोत

1

सी 134 133 बाइट्स

1 बाइट बचाने के लिए @Thomas Padron-McCarthy को धन्यवाद।

f(){clock_t s,e;s=clock();for(int i=-1000;i<1001;i++)printf("%d\n",i);e=clock();printf("%lf",((double)((e-s))/(CLOCKS_PER_SEC))*1e3);}

Ungolfed संस्करण:

void f()
{   
  clock_t s,e;

  s=clock();

  for(int i=-1000;i<1001;i++)
    printf("%d\n",i);   

  e=clock();
  printf("%f",((double)((e-s))/(CLOCKS_PER_SEC))*1e3);

 }

— हाबिल टॉम
स्रोत

आप "% lf" को "% f" में बदलकर एक चरित्र को बचा सकते हैं।

— थॉमस पैड्रॉन-मैकार्थी

क्यों नहीं int t=time(null);... printf("%d",time(null)-t)? छोटा AFAIK

— SIGSTACKFAULT

1

गुरा , 75 बाइट्स

t=datetime.now();println(-1000..1000);print((datetime.now()-t).usecs/1000);

— Sygmei
स्रोत

1

क्लोजर, 94 बाइट्स

(let[t #(System/currentTimeMillis)s(t)](doseq[n(range -1e3 1001)](println n))(println(-(t)s)))

मैं इस बात से निराश हूं कि यह कब तक मिला, लेकिन मुझे लगता है कि किसी ने कभी भी दावा नहीं किया कि क्लोजर गोल्फ में एक अच्छी भाषा थी।

Naopsve समाधान जो केवल शुरुआती समय को रिकॉर्ड करता है, लूप करता है, फिर प्रारंभ समय को घटाकर वर्तमान समय को घटा देता है। जब तक क्लोजर में एमएस-टाइम गेट्टर नहीं होता, जब तक मैं लापता नहीं होता, मुझे नहीं पता कि यह कैसे कम हो सकता है। शायद किसी प्रकार का निहित लूप?

(defn time-print []
  (let [t #(System/currentTimeMillis) ; Alias the time-getter to "t"
        start (t)] ; Record starting time
    (doseq [n (range -1000 1001)] ; Loop over the range...
      (println n)) ; ... printing the numbers

    (println (- (t) start)))) ; Then print the current time minus the starting time.

— Carcigenicate
स्रोत

नंबर प्रिंट करने में लगने वाला समय

सारांश

उदाहरण कोड

प्रतिबंध

अन्य infos

MATL , 13 बाइट्स

ऑक्टेव, 46 43 36 30 23 बाइट्स

जावास्क्रिप्ट, 60 बाइट्स

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

यह काम किस प्रकार करता है

पायथन 3.5, 80 77 73 बाइट्स

बैश (+ कोर्यूटिल्स), 41, 49, 46, 44, 42 बाइट्स

आर, 42 बाइट्स

बाश + GNU बर्तन, 43

जावास्क्रिप्ट (ईएस 6), 63 59 बाइट्स

आर, 66 बाइट्स

गणितज्ञ, 51 बाइट्स

PHP, 110 70 बाइट्स

पॉवरशेल, 27 बाइट्स

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

विस्तारित:

जे , 22 बाइट्स

पायथ , 18 15 14 बाइट्स

नूडल , 17 13 बाइट्स

यह काम किस प्रकार करता है

यह काम किस प्रकार करता है

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

मतलाब, 16 23 बाइट्स

ग्रूवी, 75 73 बाइट्स

8 वें , 61 47 बाइट्स

जाप, 23 बाइट्स

QBIC , 34 बाइट्स

सी ++ - 261

स्काला, 77 बाइट्स

फोर्सलैंग, 124

SimpleTemplate , 92 बाइट्स

सी 134 133 बाइट्स

गुरा , 75 बाइट्स

क्लोजर, 94 बाइट्स