Resumen

Escriba un programa o función, que no tome ninguna entrada, y envíe todos los números enteros, entre -1000 y 1000 en orden ascendente, a la salida estándar, uno por línea, de esta manera:

-1000
-999
-998
-997
...

Y después de eso, debe imprimir el tiempo necesario para imprimir estos números, o el tiempo desde el inicio de la ejecución del programa en milisegundos (si es necesario, también puede contener otras cosas, por ejemplo: tiempo empleado: xxxms está bien). Puede ser un flotante o un entero (si imprime un entero, debe redondearlo al más cercano).

Código de ejemplo

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

Restricciones

Las lagunas estándar no están permitidas

Otras informaciones

Es el código de golf, por lo que gana la presentación más corta.

MATL , 13 bytes

1e3t_y&:!DZ`*

Pruébalo en línea!

       % 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

Octava, 46 43 36 30 23 bytes

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

Esto imprimirá:

ans =

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

Si no le gusta ans =, entonces tenemos que agregar 6 bytes adicionales para disp:

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

Ahorró muchos bytes gracias a algunos recordatorios de rahnema1.

Explicación:

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

Para obtener todos los eventos registrados, debe usar el script de la consola del desarrollador (de lo contrario, los registros se borran después de cierta cantidad de ellos).

CJam , 18 bytes

es2001{1e3-n}/es\-

Pruébalo en línea!

Cómo funciona

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)

Soluciones anteriores involucradas usando timeit y time.time(), eran más grandes.

Tristemente, time.process_time() se introdujo en Python 3.3.

¡Gracias a Dennis por guardar 4 bytes!

Bash (+ coreutils), 41, 49, 46, 4442 bytes

EDICIONES:

• Refactorizado para usar Bash-builtin (tiempo), para abordar las preocupaciones de precisión de @Dennis;
• Reducido en 3 bytes, utilizando Bash 4+ |&para la redirección de stderr;
• Ahorró 2 bytes más al reemplazar seq -1000 1000con seq -1e3 1e3(¡Gracias @Dennis!);
• -2 bytes eliminando la barra invertida innecesaria y utilizando la precisión predeterminada (Thx @Dennis!).

Golfed

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

¡Pruébelo en línea!

Nota al margen

El uso de una utilidad "time" de coreutils, en lugar de Bash-builtin, da como resultado un 41, Solución de 35 bytes:

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

"\" está aquí para hacer que bash invoque el comando real, en lugar del comando incorporado.

Desafortunadamente, la precisión de tiempo de coreutils es solo de 1/100, lo que ha generado dudas sobre si es una solución válida.

R, 42 bytes

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

Esto imprimirá

.
.
.
998
999
1000
elapsed 
     60 

Para eliminar elapsed, son necesarios dos bytes adicionales:

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

Bash + GNU utils, 43

• Guardado 2 bytes gracias a @Dennis
• Guardado 5 bytes gracias a @zeppelin

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

El datecomando da el número de segundos desde la época concatenada con los nanosegundos actuales. Este comando se ejecuta antes y después. bctoma la diferencia e imprime.

Pruébalo en línea .

Tenía la esperanza de hacer esto por 17:

time seq -1e3 1e3

Pero la salida del tiempo da más de lo que necesitamos:

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

JavaScript (ES6), 63 59 bytes

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

Probablemente no sea el más corto pero funciona.

Mathematica, 51 bytes

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

Explicación

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

Almacene la Printfunción en p. Imprima los números de 2001, comenzando en -1000, incrementándose en 1.

AbsoluteTiming@ ...

Encuentra el tiempo total transcurrido en segundos.

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

Multiplique eso por 1000 (segundos -> milisegundos) y p( Print).

PHP, 110 70 bytes

todavía un poco largo; pero salvé 38 con la pista de @ AlexHowansky y dos más con 1e3y ~1e3.

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

impresiones flotantes. Corre con -r.

Powershell, 27 bytes

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

Gracias a AdmBorkBork por señalar que la salida por defecto detallada es aceptable en el desafío.

Los resultados resultan como:

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

para un resultado más contenido de solo milisegundos, use la respuesta original

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

Ahorre tiempo antes como $ 1, imprima en stdout automáticamente, luego obtenga el tiempo entre el comienzo y el final de la ejecución.

Perl 6 , 45 bytes

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

Intentalo

Expandido:

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

Pruébalo en línea!

timexes una función integrada que ejecuta la cadena y devuelve el tiempo que tardó en evaluarla en segundos. La cadena forma el rango [-1000, 1000] usando i:, luego lo columiniza usando ,.e imprime usando el incorporado echo.

Pyth , 18 15 14 bytes

j}_J^T3J;*.d1J

Pruébalo aquí!

Explicación

Esto es similar a mi respuesta de Python.

    J ^ T3 Establezca J en 1000
  } _ J Lista que va de -1000 a 1000
j Únase a la lista con nuevas líneas e imprímala implícitamente
         ; *. d1J Tiempo de impresión desde la ejecución del programa en milisegundos

Ediciones :

• ¡Gracias a fryamtheeggman por guardar 3 bytes!
• Gracias a busukxuan por guardar un byte.

Noodel , 17 13 bytes

13 bytes

Intenté un enfoque ligeramente diferente y ahorré 4 bytes.

ƇQjȥḶGQɱ⁻Ñ€Ƈ⁻

Intentalo:)

Cómo funciona

Ƈ             # 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€ÑƇ⁻

Intentalo:)

Cómo funciona

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

El fragmento utiliza los valores de -4 a 4 para no tardar tanto en completarse.

<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

• Muchos comandos están representados por tokens de 1 o 2 bytes.

• Probado en un CSE TI-84 emulado.

Matlab 16 23 bytes

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

Editar: me di cuenta de que estaba violando varias de las reglas de este desafío. Eso me enseñará a leer el desafío a altas horas de la noche. Ahora también me doy cuenta de que la respuesta corregida es casi idéntica a la solución Octave, pero así es la vida.

Imprime cada elemento en la matriz espacial lineal creada -1000: 1000 (la falta de; imprime en la consola).

tic / toc registra la hora y toc imprime la hora en la consola con o sin; . Se necesita 1e3 para imprimir en milisegundos.

Groovy, 75 73 bytes

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

Gracias a jaxad0127 por guardar 2 bytes!

Pruébalo aquí!

8 , 61 47 bytes

Gracias a 8th_dev por una buena mejora (guardado 14 bytes)

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

Esto imprimirá todos los números enteros entre -1000 y 1000 en orden ascendente y el tiempo necesario (en milisegundos) para imprimir estos números

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

Japt, 23 bytes

Hay dos soluciones equivalentes:

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

El primero básicamente hace lo siguiente:

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

Es decir, los números se imprimen en el medio de la resta para evitar tener que almacenar el tiempo en una variable. Sin embargo, no es más corto que la ruta variable, que es básicamente:

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

En la última versión de Japt (más reciente que este desafío), Kestá configurado para regresar automáticamente new Date(). Esto reduce la primera solución a 21 bytes:

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

¡Pruébelo en línea!

QBIC , 34 bytes

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

Utiliza la TIMERfunción QBasic , que devuelve segundos en notación decimal. Hacer que se vea bonito agrega algunos bytes.

Explicación

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

Solo para reír, pensé en publicar una respuesta 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";}

Lo dejaré como ejercicio para determinar qué está haciendo y cómo llamarlo, no debería ser demasiado difícil.

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

Nota: debe suprimir stderral ejecutar esto. Creo que el consenso sobre meta es que esto no incurre en una penalización por conteo de bytes.

SimpleTemplate , 92 bytes

Lo que realmente me mató fue la necesidad de registrar el tiempo.

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

Como no hay matemáticas (todavía), esto hace las cosas bastante difíciles, lo que me obliga a escribir PHP directamente.

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

Renuncia:

He ejecutado esto con el commit e118ae72c535b1fdbe1b80c847f52aa161854fda , del 13/01/2017.

La última confirmación fue arreglar algo que no está relacionado con el código aquí.

C 134 133 bytes

Gracias a @Thomas Padron-McCarthy por guardar 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);}

Versión sin golf:

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

Estoy decepcionado de cuánto tiempo pasó esto, pero supongo que nadie afirmó que Clojure era un buen idioma para jugar golf.

Solución ingenua que solo registra la hora de inicio, realiza un bucle y luego imprime la hora actual menos la hora de inicio. A menos que Clojure tenga un captador de tiempo ms de lo que me falta, no sé cómo esto podría acortarse. Tal vez algún tipo de bucle implícito?

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