摘要

编写一个不接受任何输入的程序或函数，并将所有在-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);      
    }
}

限制条件

不允许出现标准漏洞

其他资讯

这是代码高尔夫球，因此最短的提交者获胜。

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

八度，46 43 36 30 23字节

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

这将打印：

ans =

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

如果您不喜欢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

JavaScript，60个字节

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

为了记录所有事件，您应该使用开发者控制台中的脚本（否则，在记录了一定数量的事件之后，将清除它们）。

CJam，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.

蟒3.5，80个 77 73字节

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

以前的解决方案涉及使用timeit和time.time()，它们更大。

可悲的是，它time.process_time()是在python 3.3中引入的。

感谢Dennis节省了4个字节！

Bash（+ coreutils）， 41， 49， 46， 44，42字节

编辑：

• 重构为使用Bash-builtin（时间）来解决@Dennis的精度问题；
• 通过使用Bash 4+ |&进行stderr重定向，减少了3个字节；
• 通过替换seq -1000 1000为seq -1e3 1e3（谢谢@Dennis！）节省了2个字节；
• 通过删除不必要的反斜杠并使用默认精度（Thx @Dennis！）来获得-2字节。

打高尔夫球

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

在线尝试！

边注

使用coreutils“时间”实用程序而不是Bash内置函数会导致 41，35字节解决方案：

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

在这里， “ \”使 bash调用实际命令，而不是内置命令。

不幸的是，coreutils的时间精度仅为1 / 100s，这引起了人们对于它是否是有效解决方案的担忧。

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

Bash + GNU utils，43

• @Dennis节省了2个字节
• @zeppelin节省了5个字节

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

该date命令给出自将新纪元连接起来以来的秒数。该命令在运行之前和之后运行。 bc接受差异并打印。

在线尝试。

我希望这样做17：

time seq -1e3 1e3

但是时间的输出提供了我们所需要的：

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

JavaScript（ES6），63 59字节

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

R，66个字节

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

可能不是最短的，但是可以。

Mathematica，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）。

PHP，110 70字节

还长一点 但使用@AlexHowansky的提示保存了38个，并使用1e3和保存了两个~1e3。

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

打印浮动。用运行-r。

Powershell，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，自动打印到stdout，然后获取执行开始和结束之间的时间。

Perl 6 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.

J，22字节

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

在线尝试！

timex是一个内置函数，它执行字符串并返回评估它所花费的时间（以秒为单位）。该字符串使用来形成[ i:-1000，1000 ]范围，然后使用对其进行列化,.，并使用内建来打印echo。

Pyth，18 15 14字节

j}_J^T3J;*.d1J

在这里尝试！

说明

这类似于我的python答案。

    J ^ T3将J设置为1000
  } _ J列表的范围是-1000至1000
j用新行加入列表并隐式打印
         ; *。d1J自程序执行以来的打印时间（以毫秒为单位）

编辑：

• 感谢fryamtheeggman节省了3个字节！
• 感谢busukxuan节省了一个字节。

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

TI基本（22字节）

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

• 许多命令由1或2字节的令牌表示。

• 在仿真的TI-84 CSE上进行了测试。

Matlab，16 23字节

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

编辑：我意识到我违反了一些挑战的规则。那会教我深夜略读挑战。我现在也意识到，纠正后的答案几乎与八度解法相同，但这就是生活。

打印创建的线性空间数组-1000：1000中的每个元素（缺少;打印到控制台）。

tic / toc记录时间，并且toc将时间打印到控制台上，带或不带; 。需要1e3才能以毫秒为单位打印。

Groovy，75 73字节

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

感谢jaxad0127节省了2个字节！

在这里尝试！

8th，61 47字节

感谢8th_dev进行了很好的改进（节省了14个字节）

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

这将按升序打印-1000到1000之间的所有整数，以及打印这些数字所用的时间（以毫秒为单位）

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

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

在最新版本的Japt（比此挑战更新的版本）中，K设置为自动返回new Date()。这将第一个解决方案缩减为21个字节：

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

在线测试！

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

C ++-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";}

我将把它作为确定它在做什么以及如何调用它的练习，这应该不会太困难。

Scala，77个字节

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

力浪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运行此命令时应禁止。我相信对meta的共识是，这不会导致字节计数的损失。

SimpleTemplate，92个字节

真正让我丧命的是需要记录时间。

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

既然还没有数学，这使事情变得很困难，迫使我直接编写PHP。

取消高尔夫：

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

免责声明：

我已经使用提交e118ae72c535b1fdbe1b80c847f52aa161854fda运行了此操作日。

最新的提交是修复与此处的代码无关的内容。

C 134 133个字节

感谢@Thomas Padron-McCarthy节省了1个字节。

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

非高尔夫版本：

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

 }

古拉，75字节

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

Clojure，94个字节

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

我对这种情况持续多久感到失望，但我想没人会说Clojure是打高尔夫球的好语言。

仅记录开始时间的简单解决方案会循环播放，然后打印当前时间减去开始时间。除非Clojure的ms-time getter比我所想念的要差，否则我不知道这怎么会缩短。也许某种隐式循环？

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