Sommaire

Écrivez un programme ou une fonction, qui ne prend aucune entrée, et sort tous les nombres entiers, entre -1000 et 1000 dans l'ordre croissant, vers la sortie standard, un par ligne, comme ceci:

-1000
-999
-998
-997
...

Et après cela, vous devez imprimer le temps nécessaire pour imprimer ces nombres, ou le temps à partir du début de l'exécution du programme en millisecondes (si nécessaire, il peut également contenir d'autres éléments, par exemple: temps pris: xxxms est ok). Il peut s'agir d'un flottant ou d'un entier (si vous imprimez un entier, vous devez arrondir au plus proche).

Exemple de code

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

Restrictions

Les échappatoires standard ne sont pas autorisées

Autres infos

C'est du golf de code, donc la soumission la plus courte l'emporte.

MATL , 13 octets

1e3t_y&:!DZ`*

Essayez-le en ligne!

       % 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

Octave, 46 43 36 30 23 octets

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

Cela imprimera:

ans =

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

Si vous n'aimez pas le ans =, alors nous devons ajouter 6 octets supplémentaires pour disp:

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

Beaucoup d'octets enregistrés grâce à quelques rappels de rahnema1.

Explication:

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 octets

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

Afin d'obtenir tous les événements enregistrés, vous devez utiliser le script à partir de la console du développeur (sinon les journaux sont effacés après un certain nombre d'entre eux).

CJam , 18 octets

es2001{1e3-n}/es\-

Essayez-le en ligne!

Comment ça marche

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 octets

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

Les solutions précédentes impliquaient d'utiliser timeitet time.time(), elles étaient plus grandes.

Malheureusement, a time.process_time()été introduit en python 3.3.

Merci à Dennis d' avoir économisé 4 octets!

Bash (+ coreutils), 41, 49, 46, 44, 42 octets

MODIFICATIONS:

• Refactorisé pour utiliser Bash-builtin (temps), pour répondre aux préoccupations de précision @Dennis;
• Réduit de 3 octets, en utilisant Bash 4+ |&pour la redirection stderr;
• Enregistré 2 octets supplémentaires en remplaçant seq -1000 1000par seq -1e3 1e3(Merci @Dennis!);
• -2 octets en supprimant la barre oblique inverse inutile et en utilisant la précision par défaut (Thx @Dennis!).

Golfé

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

Essayez-le en ligne!

Sidenote

L'utilisation d'un utilitaire "time" coreutils, au lieu du Bash-builtin, se traduit par un 41, Solution de 35 octets:

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

"\" est là pour que bash invoque la vraie commande, au lieu de la commande intégrée.

Malheureusement, la précision du temps de coreutils n'est que de 1 / 100s, ce qui a soulevé des inquiétudes quant à la validité de la solution.

R, 42 octets

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

Cela imprimera

.
.
.
998
999
1000
elapsed 
     60 

Pour supprimer elapsed, deux octets supplémentaires sont nécessaires:

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

Utilitaires Bash + GNU, 43

• Enregistré 2 octets grâce à @Dennis
• 5 octets enregistrés grâce à @zeppelin

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

La datecommande donne le nombre de secondes écoulées depuis l'époque concaténée avec les nanosecondes actuelles. Cette commande est exécutée avant et après. bcprend la différence et imprime.

Essayez-le en ligne .

J'espérais le faire depuis 17 ans:

time seq -1e3 1e3

Mais la sortie du temps donne plus que ce dont nous avons besoin:

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

JavaScript (ES6), 63 59 octets

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

R, 66 octets

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

Probablement pas le plus court mais ça marche.

Mathematica, 51 octets

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

Explication

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

Enregistrez la Printfonction dans p. Imprime les nombres de 2001, commençant à -1000, incrémentant de 1.

AbsoluteTiming@ ...

Trouvez le temps total écoulé en secondes.

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

Multipliez cela par 1000 (secondes -> millisecondes) et p( Print).

PHP, 110 70 octets

encore un peu long; mais a sauvé 38 avec le conseil de @ AlexHowansky et deux autres avec 1e3et ~1e3.

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

les impressions flottent. Courez avec -r.

Powershell, 27 octets

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

Merci à AdmBorkBork d'avoir souligné que la sortie par défaut détaillée est acceptable dans le défi.

Les résultats résultent comme:

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

pour un résultat plus contenu de quelques millisecondes seulement, utilisez la réponse originale:

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

Gagnez du temps avant comme $ 1, imprimez sur stdout automatiquement, puis obtenez le temps entre le début et la fin de l'exécution.

Perl 6 , 45 octets

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

Essayez-le

Étendu:

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

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

Essayez-le en ligne!

timexest une fonction intégrée qui exécute la chaîne et renvoie le temps nécessaire pour l'évaluer en secondes. La chaîne forme la plage [-1000, 1000] à l'aide i:, puis la columinise à l'aide ,.et l'imprime à l'aide de la fonction intégrée echo.

Pyth , 18 15 14 octets

j}_J^T3J;*.d1J

Essayez-le ici!

Explication

Ceci est similaire à ma réponse en python.

    J ^ T3 Réglez J sur 1000
  } _ J Liste allant de -1000 à 1000
j Rejoignez la liste avec de nouvelles lignes et imprimez-la implicitement
         ; *. d1J Temps d'impression depuis l'exécution du programme en millisecondes

Modifications :

• Merci à fryamtheeggman pour avoir économisé 3 octets!
• Merci à busukxuan d' avoir enregistré un octet.

Noodel , 17 13 octets

13 octets

J'ai essayé une approche légèrement différente et économisé 4 octets.

ƇQjȥḶGQɱ⁻Ñ€Ƈ⁻

Essayez-le :)

Comment ça marche

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

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

Essayez-le :)

Comment ça marche

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

L'extrait utilise les valeurs -4 à 4 afin de ne pas prendre autant de temps.

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

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

• De nombreuses commandes sont représentées par des jetons de 1 ou 2 octets.

• Testé sur une TI-84 CSE émulée.

Matlab, 16 23 octets

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

Edit: J'ai réalisé que je violais plusieurs des règles de ce défi. Cela m'apprendra à lire le défi tard le soir. Je me rends également compte maintenant que la réponse corrigée est presque identique à la solution Octave, mais telle est la vie.

Imprime chaque élément du tableau d'espace linéaire créé -1000: 1000 (le manque de; imprime sur la console).

tic / toc enregistre l'heure et toc imprime l'heure sur la console avec ou sans le; . 1e3 est nécessaire pour imprimer en millisecondes.

Groovy, 75 73 octets

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

Merci à jaxad0127 pour avoir économisé 2 octets!

Essayez-le ici!

8ème , 61 47 octets

Merci à 8th_dev pour une belle amélioration (économisé 14 octets)

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

Cela affichera tous les nombres entiers compris entre -1000 et 1000 dans l'ordre croissant et le temps nécessaire (en millisecondes) pour imprimer ces nombres

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

Japt, 23 octets

Il existe deux solutions équivalentes:

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

Le premier fait essentiellement ce qui suit:

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

Autrement dit, les chiffres sont imprimés au milieu de la soustraction pour éviter d'avoir à stocker l'heure dans une variable. Cependant, il n'est pas plus court que l'itinéraire variable, qui est essentiellement:

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

Dans la dernière version de Japt (plus récente que ce défi), Kest configurée pour revenir automatiquement new Date(). Cela réduit la première solution à 21 octets:

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

Testez-le en ligne!

QBIC , 34 octets

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

Utilise la TIMERfonction QBasic , qui renvoie des secondes en notation décimale. Le rendre joli ajoute quelques octets.

Explication

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

Juste pour rire, j'ai pensé publier une réponse en 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";}

Je vais le laisser comme un exercice pour déterminer ce qu'il fait et comment l'appeler - cela ne devrait pas être trop difficile.

Scala, 77 octets

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

Remarque: vous devez supprimer stderrlors de l'exécution de cela. Je crois que le consensus sur la méta est que cela n'encourt pas de pénalité de comptage d'octets.

SimpleTemplate , 92 octets

Ce qui m'a vraiment tué, c'est la nécessité d'enregistrer le temps.

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

Puisqu'il n'y a pas (encore) de mathématiques, cela rend les choses assez difficiles, me forçant à écrire PHP directement.

Non golfé:

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

Avertissement:

J'ai exécuté cela avec la validation e118ae72c535b1fdbe1b80c847f52aa161854fda , du 2017-01-13.

Le dernier commit était de corriger quelque chose qui n'est pas lié au code ici.

C 134 133 octets

Merci à @Thomas Padron-McCarthy pour avoir économisé 1 octet.

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

Version non golfée:

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 octets

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

Clojure, 94 octets

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

Je suis déçu du temps que cela a duré, mais je suppose que personne n'a jamais prétendu que Clojure était une bonne langue pour jouer au golf.

Solution naïve qui enregistre simplement l'heure de début, boucle, puis imprime l'heure actuelle moins l'heure de début. À moins que Clojure n'ait un getter ms-time que je manque, je ne sais pas comment cela pourrait être plus court. Peut-être une sorte de boucle implicite?

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