Zusammenfassung

Schreiben Sie ein Programm oder eine Funktion, die keine Eingabe akzeptiert, und geben Sie alle Ganzzahlen zwischen -1000 und 1000 in aufsteigender Reihenfolge an die Standardausgabe aus, eine pro Zeile, wie folgt:

-1000
-999
-998
-997
...

Danach müssen Sie die zum Drucken dieser Zahlen benötigte Zeit oder die Zeit ab dem Start der Programmausführung in Millisekunden drucken (falls erforderlich, können auch einige andere Dinge enthalten sein, z. B .: time taken: xxxms ist in Ordnung). Dies kann ein Gleitkomma oder eine Ganzzahl sein (wenn Sie eine Ganzzahl drucken, müssen Sie auf die nächste abrunden).

Beispielcode

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

Beschränkungen

Standardlücken sind nicht erlaubt

Weitere Infos

Es ist Code Golf, also gewinnt die kürzeste Einsendung.

MATL , 13 Bytes

1e3t_y&:!DZ`*

Probieren Sie es online!

       % 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

Oktave, 46 43 36 30 23 Bytes

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

Dies wird drucken:

ans =

  -1000
   -999
   -998
   -997
   -996
   -995

Wenn Ihnen das nicht gefällt ans =, müssen wir weitere 6 Bytes hinzufügen für disp:

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

Dank einiger Erinnerungen von rahnema1 wurden viele Bytes gespeichert.

Erläuterung:

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

JavaScript, 60 Bytes

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

Um alle Ereignisse zu protokollieren, sollten Sie das Skript von der Entwicklerkonsole verwenden (andernfalls werden die Protokolle nach einer bestimmten Anzahl gelöscht).

CJam , 18 Bytes

es2001{1e3-n}/es\-

Probieren Sie es online!

Wie es funktioniert

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.

Python 3.5, 80 77 73 Bytes

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

Bisherige Lösungen umfassten die Verwendung von timeitund time.time()und waren größer.

Leider time.process_time()wurde in Python 3.3 eingeführt.

Vielen Dank an Dennis für das Speichern von 4 Bytes!

Bash (+ Coreutils), 41, 49, 46, 4442 Bytes

EDITS:

• Überarbeitet, um Bash-builtin (Zeit) zu verwenden, um @ Tennis-Präzisionsprobleme anzugehen;
• Reduziert um 3 Bytes durch Verwendung von Bash 4+ |&für die Umleitung von Ordnern;
• 2 weitere Bytes durch Ersetzen seq -1000 1000durch seq -1e3 1e3(Danke @Dennis!) Gespart;
• -2 Bytes durch Entfernen von unnötigem Backslash und unter Verwendung der Standardpräzision (Thx @Dennis!).

Golf gespielt

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

Probieren Sie es online!

Randnotiz

Die Verwendung eines coreutils "time" -Dienstprogramms anstelle des Bash-Built-In führt zu a 4135-Byte-Lösung:

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

"\" ist hier, um bash dazu zu bringen , den echten Befehl anstelle des eingebauten aufzurufen.

Leider ist die Zeitgenauigkeit von coreutils nur 1 / 100s, was Bedenken aufkommen lässt, ob es sich um eine gültige Lösung handelt.

R, 42 Bytes

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

Dies wird gedruckt

.
.
.
998
999
1000
elapsed 
     60 

Zum Entfernen elapsedsind zwei zusätzliche Bytes erforderlich:

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

Bash + GNU-Utils, 43

• 2 Bytes dank @Dennis gespart
• 5 Bytes dank @zeppelin gespart

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

Der dateBefehl gibt die Anzahl der Sekunden seit der Verkettung mit aktuellen Nanosekunden an. Dieser Befehl wird vor und nach ausgeführt. bcNimmt den Unterschied und druckt.

Probieren Sie es online aus .

Ich hatte gehofft, dies für 17 zu tun:

time seq -1e3 1e3

Aber die Ausgabe der Zeit gibt mehr als wir brauchen:

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

JavaScript (ES6), 63 bis 59 Byte

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

R, 66 Bytes

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

Wahrscheinlich nicht die kürzeste, aber es funktioniert.

Mathematica, 51 Bytes

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

Erläuterung

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

Speichern Sie die PrintFunktion in p. Drucken Sie 2001-Zahlen, beginnend bei -1000, und erhöhen Sie sie um 1.

AbsoluteTiming@ ...

Ermitteln Sie die Gesamtzeit in Sekunden.

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

Multiplizieren Sie dies mit 1000 (Sekunden -> Millisekunden) und p( Print).

PHP, 110-70 Bytes

noch ein bisschen lang; aber mit @ AlexHowansky´s Hinweis 38 gespart, und zwei weitere mit 1e3und ~1e3.

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

druckt float. Laufen Sie mit -r.

Powershell, 27 Bytes

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

Vielen Dank an AdmBorkBork für den Hinweis, dass die ausführliche Standardausgabe für die Herausforderung akzeptabel ist.

Ausgaben ergeben sich wie:

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

Verwenden Sie die ursprüngliche Antwort, wenn das Ergebnis nur Millisekunden beträgt:

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

Sparen Sie Zeit, bevor Sie als $ 1 drucken, drucken Sie automatisch auf stdout und erhalten Sie dann die Zeit zwischen dem Beginn und dem Ende der Ausführung.

Perl 6 , 45 Bytes

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

Versuch es

Erweitert:

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

J , 22 Bytes

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

Probieren Sie es online!

timexist ein integrierter Befehl, der die Zeichenfolge ausführt und die für die Auswertung benötigte Zeit in Sekunden zurückgibt. Die Zeichenfolge bildet den Bereich [-1000, 1000] mit i:, koluminiert ihn dann mit ,.und druckt ihn mit der eingebauten Funktion aus echo.

Pyth , 18 15 14 Bytes

j}_J^T3J;*.d1J

Probieren Sie es hier aus!

Erläuterung

Dies ähnelt meiner Python-Antwort.

    J ^ T3 Setzen Sie J auf 1000
  } _ J Liste von -1000 bis 1000
j Fügen Sie der Liste neue Zeilen hinzu und drucken Sie sie implizit aus
         ; *. d1J Druckzeit seit Ausführung des Programms in Millisekunden

Bearbeitungen :

• Danke an fryamtheeggman für das Speichern von 3 Bytes!
• Danke an busukxuan für das Speichern eines Bytes.

Nudel , 17 13 Bytes

13 Bytes

Versuchte einen etwas anderen Ansatz und sparte 4 Bytes.

ƇQjȥḶGQɱ⁻Ñ€Ƈ⁻

Versuch es:)

Wie es funktioniert

Ƈ             # 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 Bytes

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

Versuch es:)

Wie es funktioniert

Ƈ                 # 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.

Das Snippet verwendet die Werte -4 bis 4, um den Vorgang nicht zu lange dauern zu lassen.

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

TI-Basic, 22 Bytes

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

• Viele Befehle werden durch 1 oder 2-Byte-Token dargestellt.

• Getestet auf einem emulierten TI-84 CSE.

Matlab, 16 23 Bytes

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

Bearbeiten: Ich habe festgestellt, dass ich gegen mehrere Regeln dieser Herausforderung verstoßen habe. Das wird mich lehren, die Herausforderung spät in der Nacht zu lesen. Mir ist jetzt auch klar, dass die korrigierte Antwort fast identisch mit der Octave-Lösung ist, aber so ist das Leben.

Druckt jedes Element im erstellten linearen Raumarray -1000: 1000 (das Fehlen von; druckt auf die Konsole).

tic / toc zeichnet die Uhrzeit auf und toc druckt die Uhrzeit mit oder ohne; auf die Konsole. . 1e3 wird zum Drucken in Millisekunden benötigt.

Stark, 75 73 Bytes

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

Danke an jaxad0127 für das Speichern von 2 Bytes!

Probieren Sie es hier aus!

8. , 61 47 Bytes

Danke an 8th_dev für die nette Verbesserung (14 Bytes gespart)

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

Dadurch werden alle Ganzzahlen zwischen -1000 und 1000 in aufsteigender Reihenfolge und die Zeit (in Millisekunden) zum Drucken dieser Zahlen gedruckt

-1000
-999
-998
-997
...
997
998
999
1000
4

Japt, 23 Bytes

Es gibt zwei äquivalente Lösungen:

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

Der erste macht im Grunde Folgendes:

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

Das heißt, die Zahlen werden in der Mitte der Subtraktion gedruckt, um zu vermeiden, dass die Zeit in einer Variablen gespeichert werden muss. Es ist jedoch nicht kürzer als die variable Route, die im Grunde genommen wie folgt lautet:

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

In der neuesten Version von Japt (neuer als diese Herausforderung) Kist die automatische Rückkehr eingerichtet new Date(). Dies reduziert die erste Lösung auf 21 Bytes:

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

Online testen!

QBIC , 34 Bytes

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

Verwendet die QBasic- TIMERFunktion, die Sekunden in Dezimalschreibweise zurückgibt. Wenn es hübsch aussieht, werden einige Bytes hinzugefügt.

Erläuterung

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

C ++ - 261

Nur zum Lachen dachte ich, ich würde eine C ++ Antwort posten.

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

Ich lasse es als Übung, um zu bestimmen, was es tut und wie man es nennt - sollte nicht zu schwierig sein.

Scala, 77 Bytes

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

ForceLang, 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

Hinweis: Sie sollten unterdrücken, stderrwenn Sie dies ausführen . Ich glaube, der Konsens über Meta ist, dass dies keine Bestrafung der Byteanzahl bedeutet.

SimpleTemplate , 92 Byte

Was mich wirklich umbrachte, war die Notwendigkeit, die Zeit aufzuzeichnen.

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

Da es (noch) keine Mathematik gibt, ist es ziemlich schwierig, und ich muss PHP direkt schreiben.

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

Haftungsausschluss:

Ich habe dies mit dem Commit e118ae72c535b1fdbe1b80c847f52aa161854fda vom 13.01.2017 ausgeführt.

Die letzte Zusage bestand darin, etwas zu reparieren, das nichts mit dem Code hier zu tun hat.

C 134 133 Bytes

Vielen Dank an @Thomas Padron-McCarthy für das Speichern von 1 Byte.

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

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

 }

Gura , 75 Bytes

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

Clojure, 94 Bytes

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

Ich bin enttäuscht darüber, wie lange das gedauert hat, aber ich glaube, niemand hat jemals behauptet, Clojure sei eine gute Sprache zum Golfspielen.

Naive Lösung, die nur die Startzeit aufzeichnet, Schleifen durchläuft und dann die aktuelle Zeit abzüglich der Startzeit druckt. Es sei denn, Clojure hat einen ms-time Getter, als ich vermisse, ich weiß nicht, wie dies kürzer werden könnte. Vielleicht eine Art implizite Schleife?

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