12:00시간이 설정되지 않은 경우 많은 전자 장치, 특히 오래된 전자 장치가 깜박 입니다. 이 도전의 목적은 이것을 재현하는 것입니다.

특히, 작업은 무한 루프 로 표시 12:00하거나 --:--대안 적으로 수행하는 것 입니다.

기간은 0.5 초 두시기에 고르게 나누어 1 초이어야한다. 여기서 "1 초"와 "짝수"는 느슨하게 해석 될 수 있습니다. 예를 들어, 결과 기간이 1 초보다 조금 더 길어도 문자열을 표시하는 사이에 코드가 0.5 초 동안 일시 정지 될 수 있습니다. 첫 번째 문자열을 표시하기 전에 초기 일시 정지가 허용됩니다.

각각의 새 문자열은 이전 문자열 을 바꾸 거나 새 줄로 표시 할 수 있습니다 . 각 새 문자열이 다른 줄에있는 경우 연속 문자열 사이에 빈 줄이 없어야한다는 점을 제외하고 후행 공백이 허용됩니다.

바이트 단위의 최단 코드가 이깁니다.

젤리 , 20 바이트

.“12:00“--:--”ṄœS¥€ß

작동 원리

.“12:00“--:--”ṄœS¥€ß  Main link. No arguments.

.                     Set the return value to 0.5.
 “12:00“--:--”        Yield ["12:00", "--:--"].
                 ¥    Combine the two links to the left into a dyadic chain.
              Ṅ       Print the left argument.
               œS     Sleep as many seconds as the right argument specifies.
                  €   Map the created dyadic chain over the string array, with
                      right argument equal to the return value, i.e., 0.5.
                   ß  Recursive call the main link.

HTML / CSS, 131 (108) 106 101 + 18 17 = 149 126 125 123 118 바이트

a{background:#FFF;margin:-5ch;animation:a 1s steps(2,start)infinite}@keyframes a{to{visibility:hidden

<tt>--:--<a>12:00

편집 : @insertusernamehere 덕분에 23 바이트가 절약되었습니다. 에서 <pre>로 전환하여 1 바이트를 저장 했습니다 <tt>. @darrylyeo 덕분에 2 바이트를 절약했습니다. @DBS 덕분에 5 바이트를 절약했습니다.

셸 및 pv26 바이트

이 yes표준 도구 및 pv 셸 파이프 라인 요소를 사용하여 통과하는 데이터를 측정합니다.

yes '12:00
--:--'|pv -qlL2

Python2, 80 75 73 69 67 66 바이트

import time
n=0
while[time.sleep(.5)]:print"1-2-::0-0-"[n::2];n^=1

내 문자열 마법이 배열에서 문자열을 선택하는 것보다 조금 더 길다는 것을 알았습니다. 신경 쓰지 마라.

설명 :

• 카운터 n 을 0으로 설정하면 0과 1 사이에서 전환됩니다.

• 나는 루프와 끝없이 반복 while 1합니다.

• 문자열 1-2-::0-0-을 포함 12:00하고 --:--인터랩 된 string 을 만듭니다.

  • 2 단계로 인덱스 0부터 시작하면 다음과 같습니다. 12:00

  • 2 단계로 인덱스 1부터 시작하면 다음과 같습니다. --:--

• 내가 사용하는 N 만드는 순서 반복 0 , 1 , 0 , 1 , 0 문자열의 시작 인덱스 것입니다 ....

  • 를 사용하면 n^=1각 루프에서 해당 시퀀스를 얻습니다. ^XOR 연산자입니다.
  • 만약 N == 0 -> n^=11 결과
  • 만약 N == 1 -> n^=10 초래
• 문자열을 인쇄하고 잠자기 ( .5-> 0.5)합니다.

@FlipTack이 4 바이트를 절약했습니다! -> 루프를 한 줄에 넣으십시오.

@로드 2 바이트를 저장했습니다! -> n+=1에 n^=1, 이렇게 n%2까지 n.

@xnor 은 바이트를 저장했습니다! -> while 1-> while[time.sleep(.5)].

옥타브, 63 62 61 55 바이트

c='--:--00:21';while c=flip(c)disp(c(1:5));pause(.5)end

Tom Carpenter 덕분에 2 바이트를 절약했습니다! 셀형 배열에서 두 개의 문자열 대신 단일 문자열을 사용하는 것이 더 짧았습니다.

설명:

c='--:--00:21';  % A string where the 5 first characters are --:-- or 12:00 when reversed
while c=flip(c)  % A string is always considered true in Octave, so this will loop forever
                 % while flipping the order of the string each time
 disp(c(1:5)     % display the 5 first characters of the string c
 pause(.5)       % Pause 0.5 second
end              % End loop

옥타브 사이에 콜론이나 세미콜론이 필요하지 않기 때문에 몇 바이트를 저장 flip(c)하고 disp(), 사이 pause(.5)와 end.

자바 스크립트, 59 바이트

y=1;setInterval('console.log(["12:00","--:--"][y^=1])',500)

설명

setInterval('...',500) 500 밀리 초마다 또는 1/2 초마다 문자열에서 코드를 실행하는 간격을 설정합니다.

y=1y초기에 변수을 1로 설정합니다 . 그런 식으로 인쇄되는 첫 번째 방법 은 어레이에 액세스하는 데 사용 12:00되기 때문 y입니다.

console.log(...)12:00또는 콘솔에 무엇이든 로그합니다 --:--.

["12:00","--:--"][y^=1]두 상태를 모두 포함하는 문자열로 배열을 만듭니다. 그런 다음 y요소 중 하나에 액세스하는 데 사용됩니다. 마지막으로, ^=또는 XOR 복합 연산자가 수행 y = y ^ 1합니다. 이것은 @TuukkaX가했던 것과 비슷한 1 ^ 10 이기 때문에 비트를 반전시킵니다 . 이런 식으로, 기록 된 문자열은 배열의 두 요소 사이를 번갈아 가며 깜박임 효과를 만듭니다.0 ^ 1

V , 31 30 27 25 24 바이트

의 순서를 교환함으로써 @ nmjcman101에 5 바이트의 감사를 저장 12:00하고 --:--그래서는 k제거하여 제거 할 수 있습니다 ò그것이 마지막에 암시 적으로 추가 할 수 있도록

모두 넣어 @DJMcMayhem 1 바이트 감사를 저장 12:00하고 --:--한 줄에

i12:00--:--<ESC>bDòVp:sl500m

오래된 해결책 :

i12:00<ESC>ò:sl500m
Óä/-
:sl500m
uò

<ESC> 이다 0x1b

16 진 덤프 :

00000000: 6931 323a 3030 2d2d 3a2d 2d1b 6244 f256  i12:00--:--.bD.V
00000010: 703a 736c 3530 306d                      p:sl500m

설명

i12:00--:--<ESC>   inserts 12:00\n--:--
bD                 go to the beginning of --:-- and delete it
ò                  recursively do:
 Vp                 select line and paste (effectively doing a replace)
 :sl500m            sleep for 500 milliseconds
                   the last ò is added implicitly at the end

GIF (오래된)

참고 : 강조 표시가 켜져 있습니다

bash, 58 56 45 바이트

첫 번째 arg가 숫자이므로 --after set를 억제하여 3 바이트를 저장했습니다 .

set 12:00 --:--;for((a=1;;a=3-a)){ echo ${!a};sleep .5;}

@DigitalTrauma 구문 을 사용하여 16 바이트를 절약했습니다 .

f()(echo $1;sleep .5);f 12:00;f --:--;exec $0

그런 다음 zeppelin의 comment 때문에 5 바이트를 잃어 버렸습니다 .

명령 행에서 테스트 할 수 없습니다. 우리가 관여하는 것처럼 $0, 이것을 스크립트로 작성하여 실행해야합니다.

전환

약간의 준비 만하면 좋을 수 있습니다 ( 412 바이트 ).

set -- "         ▗▖         
▗▄▄▖▗▄▄▖ ▝▘ ▗▄▄▖▗▄▄▖
         ▗▖         
         ▝▘         " " ▟▌ ▟▀▜▖ ▗▖ ▗▛▙ ▗▛▙ 
 ▐▌  ▗▟▘ ▝▘ █▗▐▌█▗▐▌
 ▐▌ ▗▛▗▖ ▗▖ ▜▖▟▘▜▖▟▘
▝▀▀▘▀▀▀▘ ▝▘  ▀▘  ▀▘ "
r=`tput cup 0`
clear;for((a=1;;a=3-a)){ printf "$r${!a}";sleep .5;}

또는 동일한 두 줄이지 만

set -- '                                            






      HM!          .o#HMMMMM#o.                 .o#MMMMH#\\         .d#MMMMH#\\
    _HMMi         ?MMH*"""`"MMMb               dMMH"""`*MMH,      dMMH"""`*MMH.
##HMMMMMi        |MMP"       9MML             ?MMP      `MMM.    dMM?      `MMM.
`""`"9MM|        dMM!        -MMR     HMH}   .MMM        |MM}   .MMH        |MM|
     |MM|         "`         JMMT     dHH}   |MM|         MMM   |MM|        -MMM
     |MM!                 .,HMM*             |MM|         MMM.  ]MM|         MMM
     |MMi              _o#MMH*"              |MM|         MMM   {MM|         MMM
     |MMi           .dHMM#""                 |MM|         MMM"  {MM|        .MMM
     |MMi         .HMM*"                     `MM6        ,MMR   |MM}        |MMF
     |MMi        ,MMP"                        9MM,       dMM|    HMM,       dMM"
     {MMi        MMM?\\o,\\\\\\\\\\\\\\\\,     q##+    `HMM\\    .dMM?     `HMH\\    .dMM?
     |MM|       :MMMMMMMMMMMMMMM[     HMMk     `*HMM##MMM#"       `*HMM##MMMP"
      "`          "     ` ` ` `                   """"`""            """"""    ' '









                                      MHM|                                      
                                      HHH|                                      

               ______.  ._______.            ________.  ._______.               
               MMMMMM:  {MMMMMMM|            &MMMMMMM:  |MMMMMMM[               


                                      ###|                                      
                                      MMM|                                      
                                                                               '

펄, 49 바이트

{select$,,$,,$,,0.5;say$|--?"12:00":"--:--";redo}

Perl은 sleep1 초 동안 잠을 잘 수 없으므로 .5 초 동안 select undef, undef, undef, .5(로 교체하여 undef사용 $,) 사용합니다.
다른 흥미로운 것 : 또는 $|만 보유 할 수 있습니다 . 따라서 값을에서 로 전환 합니다 . 그리고 마지막으로 무한 루프처럼 작동합니다.01$|--01
{... ;redo}

*> <> , 43 42 바이트

<v":1200----"
S>@5dov>~r@@}r5
1&}o:&<^!?:-

여기 사용해보십시오!

나는 이것을 더 짧게 할 수 있어야한다고 생각하고, 몇 가지 시도 할 아이디어가 있습니다 ... 기본적으로 이것은 스택을 만듭니다 :1200----. 그것은을 분리 :및 삽입 스택 뒤집 :하나의 중앙 ----또는 1200(스택의 단부 쪽)에 따라.

또한 이것이 사용하는 유일한 *> <> 명령어는 S(절전), 그렇지 않으면 적절한> <> 프로그램입니다.

업데이트 : :레지스터로 보호하지 않고 오른쪽 으로 이동하여 1 바이트를 절약 했습니다.

설명

초기화

<v":1200----"

여기서 우리는 프로그램 수명 동안 사용할 스택을 만듭니다.

<              move the IP left
  ":1200----"  push ":1200----" to the stack
 v             move the IP down into "output time"

출력 시간

 >@5dov
1&}o:&<^!?:-

이것은 실제로 시간이 출력되는 섹션입니다. 첫 번째 5는 스택으로 푸시되므로 아래 루프는 5 번 실행됩니다.

Initialisation:

 >@5dov

 >       move the IP right
  @      move the ":" back two spaces in the stack
   5     push 5 to the stack (let's call this `i`)
    do   output carriage return
      v  move IP down into "loop"

Loop:

1&}o:&<^!?:-

      <       move the IP left
     &        place i onto the register
  }o:         output a character and shift the stack left
 &            place i back onto the stack
1          -  decrement i by 1
       ^!?:   if i == 0, exit to "recover and swap"

복구 및 교환

S      >~r@@}r5

여기서 우리 :는 출력 후 결과 위치에서 복구하고 역 스택으로 끝납니다. 이것은 실제로 "출력 시간"으로 멋지게 종료되어 무한 루프를 발생시킵니다.

       >         move the IP right
        ~        remove trailing i from stack
         r@@     reverse the stack and move ":" to the front
            }r   reverse the stack again, keeping ":" on the front
S             5  sleep for 500ms

45 바이트 솔루션

<v[5"12:00"1
d/S5
o/!?l
v>]?v
 00.>0"--:--"5[

여기 사용해보십시오!

이것은 기본적으로> <> 프로그램입니다.

나는이 접근법으로 약간의 바이트를 절약 할 수 있다고 생각했습니다. 이것은 아주 간단하게 출력 12:00후 --:--. 출력 루틴을 재사용하여 바이트를 저장합니다 o/!?l(이 미러를 입력 및 종료로 재사용합니다). 여러 스택을 사용하여 상태를 저장 12하거나 (출력 또는 있음 --) 을 사용하여 출력 할 상태를 선택하십시오 v>]?v.

^{곧 설명! (1/2)}

HTML / CSS (Chrome 만 해당), 80 + 4 = 84 바이트

tt:after{content:"--:--";animation:a 1s infinite}@keyframes a{to{content:"12:00"

<tt>

편집 : '콘텐츠'속성이 아닌 애니메이션 바이 CSS 사양 하지만, 크롬 데스크톱 브라우저에 있습니다.

Noodel , 비경쟁 16 바이트

--:-- 12:00ḷçėḍh

누델 은 여전히 ​​진행중인 작업입니다. 그냥 몇 가지 도전으로 내 발을 젖게하려고합니다.

시도 해봐:)

작동 원리

--:--            # Creates the string literal "--:--" and places i into the front of the pipe.
                 # Space is a NOP command to separate the string literals.
      12:00      # Creates the string literal "12:00" and places it into the front of the pipe.
           ḷ     # Loop the following code unconditionally.
            ç    # Clear the screen and print a copy of what is in the pipe.
             ė   # Take what is in the front of the pipe and put it into the back.
              ḍh # Delay for half a second.

다음은 코드 스 니펫입니다.)

<div id="noodel" code="--:-- 12:00ḷçėḍh" input="" cols="10" rows="2"></div>

<script src="https://tkellehe.github.io/noodel/noodel-latest.js"></script>
<script src="https://tkellehe.github.io/noodel/ppcg.min.js"></script>

QBIC , 37 33 바이트

{sleep 01?@12:00`┘sleep 01?@--:--

Q 기본적으로 불행히도 전체 초 동안 만 잠을 잘 수 있습니다. 더 많은 융통성을 제공 할 수있는 방법을 고안해 보겠습니다. 01시뮬레이션하기 위해 1을 입력했습니다 .5.

설명:

{         Starts DO loop
sleep 01  Sleeps for 1 second
?@12:00`  Creates A$, sets value to "12:00" and prints A$
┘         Newline: a string literal doesn't break the line, so we need a newline to 
          control the compiled QBasic syntax
          <Rinse and repeat for "--:--">
          <DO-LOOP implicitly closed by QBIC>

나이가 QBIC, 빌드에서 $와 (공간) 예약 문자였다. 공백 ( sleep x) 또는 $( left$(..))이 필요한 QBasic 함수를 호출 하려면 코드 리터럴이 필요합니다.

'QBASIC CODE`

코드 리터럴 블록의 코드는 QBIC에서 구문 분석하지 않고 QBasic으로 직접 전달됩니다. 해당 기호에서 기능을 오프로드하면 ( $이 '되고 개행 문자가 ┘대신 (alt-217)) QBIC에서 기호가 더 이상 특수 문자로 표시되지 않고 단순히 전달됩니다. 소문자 알파벳에서도 마찬가지입니다. QBIC과 QBasic에서 숫자 변수를 나타내는 데 사용되며 변경되지 않습니다. QBIC에서 구현되지 않은 QBasic 기능 (예 SLEEP:)을 사용하면 QBIC 예약 문자를 사용하지 않아도됩니다. 이것은 명령 기호의 최근 변경으로 더 쉬워졌습니다.

자바 스크립트, 77 76 72 바이트

setInterval('l=console.log,l("12:00"),setTimeout("l(`--:--`)",‌​500)',1e3)

1 바이트의 Kritixi Lithos와 4 바이트의 L. Serne 덕분에!

파이썬 2, 88 85 73 71 바이트

import time
c="--:--00:21"
while 1:print c[:5];c=c[::-1];time.sleep(.5)

여기 사용해보십시오!

Stewie Griffin의 목록을 뒤집는 아이디어 를 빌려서 프로그램이 가능해졌습니다. 설명이 포함 된 언 골프 버전 :

import time                      # Import time module
c = "--:--00:21"                 # String with two values
while 1:                         # Infinite Loop
    print c[::5]                 # Print the first 5 chars in string
    c = c[::-1]                  # Flip the string
    time.sleep(.5)               # Wait 0.5 seconds

14 바이트를 저장해 주셔서 감사합니다 @FlipTack!

PHP, 51 50 47

for(;;usleep(5e5))echo$i++%2?"--:--
":"12:00
";

manatwork로 인해 1 바이트가 절약되고 insertusername으로 다른 3 개가 저장되었습니다. 감사!

Pyth, 23 바이트

#?=!Z"12:00""--:--".d.5

의사 코드에서 :

                Z = 0
#               while 1:
 ?=!Z               if ( Z = not Z ):
     "12:00"            print("12:00")
                    else:
     "--:--"            print("--:--")
 .d.5               sleep(0.5)

사전 초기화 된 변수 Z를 플립 플롭으로 사용 if하고 조건을 확인할 때마다 상태를 반전 시킵니다.

루비, 47 42 바이트

루비 답변이 아직 없으므로 첫 번째 시도는 다음과 같습니다.

%w{12:00 --:--}.cycle{|a|puts a;sleep 0.5}

GNU sed, 39 바이트

EDITS :

• 스왑 수면 과 I12 : 00 (메이크업 소스 코드에 조금 더 좋은 모습)

골프

s/^/sleep .5/
h
i12:00
e
i--:--
x
e
G
D

설명

s/^/sleep .5/   #Put 'sleep .5' to the pattern space
h               #Copy pattern space to hold space
i12:00          #Print "12:00" (insert before a line) 
e               #Execute command that is found in pattern space
i--:--          #Print "--:--"
x               #Exchange the contents of the hold and pattern spaces
e               #Execute command that is found in pattern space

G               #Append a newline to the contents of the pattern 
                #space, and then append the contents of the hold
                #space to that of the pattern space.

D               #Delete text in the pattern space up to the 
                #first newline, and restart cycle with the 
                #resultant pattern space, without reading a new 
                #line of input.

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

dc (bash), 37 바이트

[12:00][--:--][[rp!sleep .5]xlax]dsax

이는 스택에서 두 문자열 "12:00"및 "-:-"을 누른 다음 값을 반복적으로 바꾸고, 항목을 스택 맨 위에 인쇄하고, 0.5 초 동안 잠자 게합니다.

이를 실행하려면 파일에 파일을 저장 한 다음

dc 파일 이름

또는 bash 명령 줄에서 직접 입력하여 실행할 수 있습니다

dc <<< '[12:00] [-:-] [[rp! sleep .5] xlax] dsax'

펄 6 ,  48 41  34 바이트

loop {print "\r",<--:-- 12:00>[$_=!$_];sleep .5}

loop {put <--:-- 12:00>[$_=!$_];sleep .5}

sleep .put/2 for |<12:00 --:-->xx*

젤리, 22 바이트

®‘©ị“12:00“--:--”ṄœS.ß

TIO에서는 작동하지 않습니다. QPython3으로 Android에서 Jelly를 실행하는 것도 재미있는 경험이었습니다.

설명

®‘©ị“12:00“--:--”ṄœS.ß    Main link. No arguments. 
®                         Read the register. Initially 0.
 ‘                        Increment. 
  ©                       Save to the register.
   ị                      Get the n'th (wrapping) item of...
    “12:00“--:--”         ["12:00", "--:--"]
                 Ṅ        Print the string and a newline. 
                  œS      Sleep for...
                    .     ...0.5 seconds. (. is an alias for 0.5)
                     ß    Call this link again. 

수학, 38 바이트

Dynamic@If[Clock[]>.5,"12:00","--:--"]

설명

Clock[]

매 초마다 0에서 1까지 연속적으로 순환하는 클록 변수를 출력합니다.

If[Clock[]>.5,"12:00","--:--"]

클럭 변수가 0.5보다 크면 "12:00"을 출력하십시오. 그렇지 않으면 "-:-"를 출력하십시오.

Dynamic@ ...

프로그램을 동적으로 만듭니다 (상시 업데이트)

자바 스크립트, 57 55

setInterval('console.log(++i%2?"12:00":"--:--")',i=500)

ETH 프로덕션 덕분에 2 바이트 절약

추신 225 214

재미 만! 이것을 실제 프린터로 보내지 마십시오 !!

/Courier findfont 9 scalefont setfont{usertime 500 mod 5 lt{newpath 9 9 moveto 1 setgray 99 setlinewidth 99 99 lineto stroke 0 setgray}if newpath 9 9 moveto usertime 999 mod 500 lt{(--:--)}{(12:00)}ifelse show}loop

시도 해봐:

gs -c '/Courier findfont 9 scalefont setfont{usertime 500 mod 5 lt{newpath 9 9 moveto 1 setgray 99 setlinewidth 99 99 lineto stroke 0 setgray}if newpath 9 9 moveto usertime 999 mod 500 lt{(--:--)}{(12:00)}ifelse show}loop'

또는

cat <<eops >/tmp/blinkingTwelve.ps
%!
/Courier findfont
9 scalefont
setfont
{
  usertime 500 mod 5 lt {
    newpath
    9 9 moveto
    1 setgray
    99 setlinewidth
    99 99 lineto
    stroke
    0 setgray
  } if
  newpath
  9 9 moveto
  usertime 999 mod 500 lt {
    (--:--)
  } {
    (12:00)
  } ifelse
  show
} loop
eops

그때

gs /tmp/blinkingTwelve.ps
gv /tmp/blinkingTwelve.ps

그러나 더 정교한 뷰어로 이것을 열지 말고 데스크탑 썸네일 러에 신경 쓰지 마십시오!

(브라우저)에 자바 스크립트 (174) 160 159 122 112 111 109 107 66 (91) 바이트

나는의 taked 한 pre나의 새로운 카운트가 그래서, monotyped 글꼴을 사용하여 요구 사항의 일부가 아니므로 (66) . 일부 문자는 고정 폭 글꼴을 사용하기 위해 추가되지만 필요하지 않으므로 25 문자를 더 포함 하지 않습니다 .

14 바이트 절약을위한 ETHproductions 덕분에

1 바이트 저장 을 위해 Kritixi Lithos 에

1 3 바이트 를 절약 하기 위한 조작 에

2 바이트를 더 절약 하기 위해 Christoph 에게

... [..][b^=1]대신 에 사용하여 37 바이트를 절약 setTimeout하고 function(){..}나중 인용 부호 로 대체 하여 10 바이트 이상 절약하십시오 ...

setInterval("document.body.innerHTML=++b%2?'12:00':'--:--'",b=500)

body{font-family:Courier}

... 나쁘다 :

66에서 더 많은 것으로 ...

...하지만 깜박 거리는 디스플레이의 정신으로 재미있게 :

SVG="http://www.w3.org/2000/svg";XLNK="http://www.w3.org/1999/xlink";
s=["1200","----"];p=0;function d(n){for(i=n.length;i>0;i--) {
  document.getElementById('n'+i).setAttribute('class','n'+n[i-1])}
  document.getElementById('sz').setAttribute('class','n'+n[0])}
setInterval("p=1-p;d(s[p])",500);

#svg2 { --c: #FF6;stroke:#432;stroke-width:12;stroke-linecap:round;stroke-linejoin:round; stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none; } path.b { fill:#543;stroke:none; } .blue     { --c: #68F; } .green    { --c: #6F8; } .red      { --c: #F88; } .dec rect  { stroke: var(--c); } .n1 #B { stroke: var(--c); }  .n1 #C { stroke: var(--c); } .n2 #A { stroke: var(--c); }  .n2 #B { stroke: var(--c); } .n2 #D { stroke: var(--c); }  .n2 #E { stroke: var(--c); } .n2 #G { stroke: var(--c); }  .n3 #A { stroke: var(--c); } .n3 #B { stroke: var(--c); }  .n3 #C { stroke: var(--c); } .n3 #D { stroke: var(--c); }  .n3 #G { stroke: var(--c); } .n4 #B { stroke: var(--c); }  .n4 #C { stroke: var(--c); } .n4 #F { stroke: var(--c); }  .n4 #G { stroke: var(--c); } .n5 #A { stroke: var(--c); }  .n5 #C { stroke: var(--c); } .n5 #D { stroke: var(--c); }  .n5 #F { stroke: var(--c); } .n5 #G { stroke: var(--c); } .n6 #A { stroke: var(--c); }  .n6 #C { stroke: var(--c); } .n6 #D { stroke: var(--c); }  .n6 #E { stroke: var(--c); } .n6 #F { stroke: var(--c); }  .n6 #G { stroke: var(--c); } .n7 #A { stroke: var(--c); }  .n7 #B { stroke: var(--c); } .n7 #C { stroke: var(--c); } .n8 #A { stroke: var(--c); }  .n8 #B { stroke: var(--c); } .n8 #C { stroke: var(--c); }  .n8 #D { stroke: var(--c); } .n8 #E { stroke: var(--c); }  .n8 #F { stroke: var(--c); } .n8 #G { stroke: var(--c); } .n9 #A { stroke: var(--c); }  .n9 #B { stroke: var(--c); } .n9 #C { stroke: var(--c); }  .n9 #D { stroke: var(--c); } .n9 #F { stroke: var(--c); }  .n9 #G { stroke: var(--c); } .n0 #A { stroke: var(--c); }  .n0 #B { stroke: var(--c); } .n0 #C { stroke: var(--c); }  .n0 #D { stroke: var(--c); } .n0 #E { stroke: var(--c); }  .n0 #F { stroke: var(--c); } .n11 #B { stroke: var(--c); } .n11 #C { stroke: var(--c); } .n11 #E { stroke: var(--c); } .n11 #F { stroke: var(--c); } .nA #A { stroke: var(--c); }  .nA #B { stroke: var(--c); } .nA #C { stroke: var(--c); }  .nA #E { stroke: var(--c); } .nA #F { stroke: var(--c); }  .nA #G { stroke: var(--c); } .nB #C { stroke: var(--c); }  .nB #D { stroke: var(--c); } .nB #E { stroke: var(--c); }  .nB #F { stroke: var(--c); } .nB #G { stroke: var(--c); } .nC #A { stroke: var(--c); }  .nC #D { stroke: var(--c); } .nC #E { stroke: var(--c); }  .nC #F { stroke: var(--c); } .nD #B { stroke: var(--c); }  .nD #C { stroke: var(--c); } .nD #D { stroke: var(--c); }  .nD #E { stroke: var(--c); } .nD #G { stroke: var(--c); } .nE #A { stroke: var(--c); }  .nE #D { stroke: var(--c); } .nE #E { stroke: var(--c); }  .nE #F { stroke: var(--c); } .nE #G { stroke: var(--c); } .nF #A { stroke: var(--c); }  .nF #E { stroke: var(--c); } .nF #F { stroke: var(--c); }  .nF #G { stroke: var(--c); } .nR #E { stroke: var(--c); }  .nR #G { stroke: var(--c); } .nO #C { stroke: var(--c); }  .nO #D { stroke: var(--c); } .nO #E { stroke: var(--c); }  .nO #G { stroke: var(--c); } .n- #G { stroke: var(--c); }  .n1 #y { stroke: var(--c); } .n1 #z { stroke: var(--c); }

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<svg xmlns="http://www.w3.org/2000/svg" version="1.1" width="100%" height="100%" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 645 230" id="svg2"> <defs id="dfs4"><g id="n"><path d="M 15,5 155,5 145,225 5,225 z" class="b"/> <path id="A" d="M 45,15 125, 15"/><path id="B" d="M 135,25 125,105"/><path id="C" d="M 125,125 115,205"/><path id="D" d="M 25,215 105,215"/><path id="E" d="M 25,125 15,205"/><path id="F" d="M 35,25 25,105"/><path id="G" d="M 35,115 115,115"/><rect id="P" width="5" height="5" ry="2.5" x="130" y="205"/></g><g id="s"><path d="M 10,5 35,5 25,225 0,225 z" id="a" class="b"/><rect id="y" width="5" height="5" ry="2.5" x="13.5" y="145"/><rect id="z" width="5" x="17" height="5" ry="2.5" y="75"/></g></defs><use id="n1" xlink:href="#n" /><use id="n2" xlink:href="#n" transform="translate(150,0)" /><use xlink:href="#s" id="sz" transform="translate(305,0)"/><use id="n3" transform="translate(335,0)" xlink:href="#n" /><use id="n4" xlink:href="#n" transform="translate(485,0)" />
</svg>

QuickBASIC , 167 바이트 (맛있음)

a%=VAL(RIGHT$(STR$(TIMER*100),2))
b%=a%+50
IF b%>99THEN b%=b%-99
DO
c%=VAL(RIGHT$(STR$(TIMER*100),2))
IF c%=a% THEN PRINT"--:--"
IF c%=b% THEN PRINT"12:00"
LOOP

나는 어쨌든 결코 이길 수 없었습니다. QB에는 floor ()가 없으며 x 밀리 초 동안 잠자기 기능이 없습니다 . 따라서 이것은 TIMER의 부동 소수점 부분을 가져 와서 작동합니다 (자정 이후 경과 된 초 수에 2 자리 10 진수로 표시되는 현재 초의 일부). 그런 다음 루프 어라운드 "50 units"를 추가하여 위상을 "-:-"에서 "12:00"로 전환해야하는 시점을 결정하고 "12:00"에서 전환에 원래 TIMER 10 진수를 사용합니다. "-:-".

마지막으로, QB4.5에서이 기능을 실행하더라도 다소 강력한 시스템의 DOSBox에서 비트를 건너 뜁니다. QB는 실제로 MS 내부에서 DO-LOOP 및 평가를 수행하기에 충분히 빠르지 않기 때문에 비교를 수행하고 있습니다. FUTURE!

어쨌든, 지금은 100 세로 보입니다. 미국 대학 학생들은 Comp Sci 수업에 대한 답을 가지고 있기 때문에 모든 학생들을 행복하게 만들었습니다.

클로저, 79 62 바이트

V2

끔찍한 인덱싱 루프에서 무한 목록에 대한 루핑으로 변경하여 -17 바이트

무한 목록을 작성 "12:00"하고 "--:--"이상 반복해서 또 다시 다음 사용 doseq지속적으로 다음 메시지를 당겨, 그것을 인쇄 할 수 있습니다.

(doseq[m(cycle["12:00""--:--"])](Thread/sleep 500)(println m))

V1

(loop[i 0](Thread/sleep 500)(println(["12:00""--:--"]i))(recur(if(= 0 i)1 0))))

"12:00"및 "-:-"상수를 압축하는 좋은 방법을 생각할 수 없었으므로 하드 코딩해야했습니다.

언 골프 드 :

(loop [i 0] ; Track which sign we showed last
    (Thread/sleep 500)
    (println (["12:00" "--:--"] i)) ; Index the vector to get the string to print
    (recur (if (= 0 i)1 0))) ; Swap the index, and loop again

Pushy , 22 바이트 (비경쟁)

`--:`wO`12:0`&["500oWF

이 답변은 두 스택을 뒤집어 문자를 차례로 인쇄하여 두 스택을 사용합니다.

`--:`    \ Push these characters to stack 1
 w       \ Mirror around center, yielding "--:--"
 O       \ On the second stack...
 `12:0`  \ Push these characters
 &       \ Duplicate the last (for :00)

 [        \ Infinitely:
  "       \   Print the current stack
  500oW   \   Wait 500 milliseconds
  F       \   Swap stacks
          \ (Implicit end loop)

이 oW명령은 도전 과제를 마무리 짓는 일련의 실험적 명령 중 일부이므로이 대답은 경쟁이 아닙니다.

Windows PowerShell, 46 55 바이트

function a{sleep -m 500;cls};for(){"12:00";a;"--:--";a}

원본 코드 :

a{sleep -m 500;cls};for(){"12:00";a;"--:--";a}
^ this won't work on other PCs. No idea why.