개요

어떤 입력도받지 않는 프로그램이나 함수를 작성하고 -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

자바 스크립트, 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.

Python 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 바이트를 절약 해 준 Dennis 에게 감사 합니다!

배쉬 (+ coreutils), 41, 49, 46, 44, 42 바이트

EDITS :

• @Dennis 정밀성 문제를 해결하기 위해 Bash 내장 (시간)을 사용하도록 리팩토링되었습니다.
• |&stderr 경로 재 지정에 Bash 4+ 를 사용함으로써 3 바이트 감소 ;
• (Thanks @Dennis!) 로 교체 seq -1000 1000하여 2 바이트를 더 절약했습니다 seq -1e3 1e3.
• 불필요한 백 슬래시를 제거하고 기본 정밀도 (Thx @Dennis!)를 사용하여 -2 바이트

골프

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

온라인으로 사용해보십시오!

사이드 노트

Bash 내장 대신 coreutils "시간"유틸리티를 사용하면 4135 바이트 솔루션 :

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

"\" 는 bash 가 내장 명령 대신 실제 명령을 호출하게합니다.

불행히도 coreutils 시간 정밀도는 1/100 에 불과하므로 유효한 솔루션인지에 대한 우려가 높아졌습니다.

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

배쉬 + GNU 유틸리티, 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

자바 스크립트 (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

아마도 가장 짧지는 않지만 작동합니다.

수학, 51 바이트

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

설명

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

에 Print기능을 저장하십시오 p. -1000에서 시작하여 1 씩 증가하여 2001 숫자를 인쇄하십시오.

AbsoluteTiming@ ...

총 경과 시간 (초)을 찾으십시오.

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

1000 (초-> 밀리 초)과 p( Print)를 곱 하십시오.

PHP, 110 70 바이트

여전히 조금 길다. 하지만 AlexHowansky's 힌트 @로 (38)를 저장하고, 두 개 더와 1e3와 ~1e3.

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

플로트를 인쇄합니다. 로 실행하십시오 -r.

파워 쉘, 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에 자동으로 인쇄 한 다음 실행 시작과 종료 사이의 시간을 확보하십시오.

펄 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문자열을 실행하고 문자열을 평가하는 데 걸리는 시간을 초 단위로 반환하는 내장 기능입니다. 문자열은을 사용하여 [-1000, 1000] 범위를 형성 i:한 다음을 사용하여 열화 ,.하고 builtin을 사용하여 인쇄합니다 echo.

Pyth , 18 15 14 바이트

j}_J^T3J;*.d1J

여기 사용해보십시오!

설명

이것은 내 파이썬 답변과 비슷합니다.

    J ^ T3 J를 1000으로 설정
  } _--1000에서 1000 사이의 J 목록
j 줄 바꿈으로 목록에 가입하고 암시 적으로 인쇄
         ; *. d1J 프로그램 실행 이후 인쇄 시간 (밀리 초)

편집 :

• 3 바이트를 절약 한 fryamtheeggman 에게 감사 합니다!
• 바이트를 저장해 준 busukxuan 에게 감사합니다 .

누델 , 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이 필요합니다.

그루비, 75 73 바이트

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

2 바이트를 절약 한 jaxad0127 에 감사 합니다!

여기에서보십시오!

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

apt, 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";}

나는 그것이 무엇을하고 있고 어떻게 부르는지를 결정하기위한 연습으로 남겨 둘 것이다. 너무 어렵지 않아야한다.

스칼라, 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이를 실행할 때 억제해야 합니다. 메타에 대한 합의는 바이트 카운트 페널티가 발생하지 않는다고 생각합니다.

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

기권:

2017-01-13부터 커밋 e118ae72c535b1fdbe1b80c847f52aa161854fda로 이것을 실행했습니다 .

최신 커밋은 여기의 코드와 관련이없는 것을 수정하는 것이 었습니다.

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

언 골프 버전 :

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

클로저, 94 바이트

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

나는 이것이 얼마나 오래 걸 렸는지에 실망하지만, 클로저가 골프에 좋은 언어라고 주장한 사람은 아무도 없다고 생각합니다.

시작 시간 만 기록하고 루프 한 다음 현재 시간에서 시작 시간을 뺀 값을 인쇄하는 Naïve 솔루션. Clojure가 누락 된 것보다 ms 시간 게터가 없으면 이것이 어떻게 짧아 질 수 있는지 모르겠습니다. 어쩌면 어떤 종류의 암시 적 루프?

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