Wiele urządzeń elektronicznych, zwłaszcza starych, będzie migać, 12:00gdy czas nie zostanie ustawiony. Celem tego wyzwania jest odtworzenie tego.

W szczególności zadaniem jest wyświetlanie 12:00i --:--alternatywnie w nieskończonej pętli .

Okres powinien wynosić 1 drugi równo podzielona na dwa okresy po 0,5 sekundy. Tutaj „1 sekundę” i „równomiernie” można interpretować luźno. Na przykład dopuszczalne jest, jeśli kod zatrzymuje się na 0,5 sekundy między wyświetlaniem ciągów, nawet jeśli wynikowy okres będzie wtedy nieco dłuższy niż 1 sekunda. Dopuszczalna jest początkowa pauza przed wyświetleniem pierwszego ciągu.

Każdy nowy ciąg może zostać wyświetlony albo przez zastąpienie poprzedniego ciągu, albo w nowym wierszu . Końcowe białe znaki są dozwolone, z tym wyjątkiem, że jeśli każdy nowy ciąg znaków znajduje się w innym wierszu, między kolejnymi ciągami znaków nie powinny być puste.

Najkrótszy kod w bajtach wygrywa.

Galaretka , 20 bajtów

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

Jak to działa

.“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 bajtów

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

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

Edycja: Zapisano 23 bajty dzięki @insertusernameherehere. Zapisano 1 bajt, zmieniając z <pre>na <tt>. Zaoszczędzono 2 bajty dzięki @darrylyeo. Zaoszczędź 5 bajtów dzięki @DBS.

Shell i pv26 bajtów

Użyj tego yesstandardowego narzędzia i pv elementu potoku Shell do pomiaru przepływających danych

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

Python2, 80 75 73 69 67 66 bajtów

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

Zauważyłem, że moja magia strun trwała dłużej niż wybieranie struny z tablicy. Nieważne, rozgryzłem to.

Objaśnienie :

• Ustawiam licznik n na 0, który będzie przełączany między 0 a 1.

• Pętlę bez końca z pętlą while 1.

• Tworzę ciąg 1-2-::0-0-, który zawiera ciąg 12:00i z --:--przeplotem.

  • Począwszy od indeksu 0 z krokiem 2, otrzymujemy: 12:00

  • Zaczynając od indeksu 1 z krokiem 2, otrzymujemy: --:--

• Używam n, aby powtórzyć sekwencję 0 , 1 , 0 , 1 , 0 ... która będzie początkowym indeksem łańcucha.

  • Używając n^=1, w każdej pętli, otrzymujemy tę sekwencję. ^będąc operatorem XOR.
  • Jeśli n == 0 -> n^=1powoduje 1
  • Jeśli n == 1 -> n^=1powoduje 0
• Drukuję ciąg i śpię ( .5-> 0.5) sekundy.

@FlipTack zapisał 4 bajty! -> Umieść pętlę w jednej linii.

@Rod zapisał 2 bajty! -> n+=1do n^=1, a zatem n%2do n.

@xnor zapisał bajt! -> while 1-> while[time.sleep(.5)].

Oktawa, 63 62 61 55 bajtów

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

Zaoszczędź dwa bajty dzięki Tomowi Carpenterowi! Użycie pojedynczego łańcucha zamiast dwóch łańcuchów w tablicy komórek było krótsze.

Wyjaśnienie:

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

Kilka bajtów zapisanych, ponieważ Octave nie wymaga dwukropka lub średnika między flip(c)i disp(), oraz między pause(.5)i end.

JavaScript, 59 bajtów

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

Wyjaśnienie

setInterval('...',500) ustawia interwał wykonywania kodu w ciągu co 500 milisekund lub 1/2 sekundy.

y=1ypoczątkowo ustawia zmienną na 1. W ten sposób drukowana jest pierwsza rzecz, 12:00ponieważ ysłuży do uzyskania dostępu do tablicy.

console.log(...)logi co do konsoli, w tym albo 12:00albo --:--.

["12:00","--:--"][y^=1]tworzy tablicę z ciągami znaków zawierającymi oba stany. Następnie ysłuży do uzyskania dostępu do jednego z elementów. Wreszcie, ^=lub robi to operator złożony XOR y = y ^ 1. To po prostu odwraca bit, ponieważ 1 ^ 1wynosi 0 i 0 ^ 1wynosi 1, podobnie jak w @TuukkaX . W ten sposób zarejestrowany ciąg znaków naprzemiennie przechodzi między dwoma elementami w tablicy, a tym samym tworzy efekt migania.

V , 31 30 27 25 24 bajtów

Zaoszczędzono 5 bajtów dzięki @ nmjcman101 poprzez zamianę kolejności 12:00i --:--tak, że kmożna ją usunąć, usuwając, òaby można było dodać niejawnie na końcu

Zapisane 1 bajt dzięki @DJMcMayhem umieszczając oba 12:00i --:--w jednej linii

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

Stare rozwiązanie:

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

<ESC> jest 0x1b

Hexdump:

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

Wyjaśnienie

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

Uwaga: mam włączone podświetlanie

bash, 58 56 45 bajtów

zapisano 3 bajty poprzez pomijanie --po, setgdy 1. arg jest liczbą.

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

Zapisano 16 bajtów przy użyciu składni @DigitalTrauma :

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

Następnie tracę 5 bajtów z powodu komentarza zeppelin .

Nie można tego przetestować w linii poleceń. Gdy się angażujemy $0, musi to zostać zapisane w skrypcie, aby uruchomić.

Odwracać

Przy odrobinie przygotowania może to być miłe ( 412 bajtów ):

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

Lub nawet te same dwie linie, ale z:

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

Perl, 49 bajtów

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

Perl sleepnie może spać przez czas poniżej 1 sekundy, stąd użycie select undef, undef, undef, .5(golfa przez zastąpienie undefgo $,) do spania. 5 sekund.
Inna interesująca rzecz: $|może trzymać 0lub 1. Więc $|--po prostu przełącza jego wartość, od 0do 1.
I w końcu {... ;redo}działa jak nieskończona pętla.

*> <> , 43 42 bajtów

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

Wypróbuj tutaj!

Wydaje mi się, że powinienem być w stanie skrócić to, mam kilka pomysłów do wypróbowania ... Zasadniczo jest to stos :1200----. Wyodrębnia :i odwraca stos, wstawiając :środek jednego ----lub 1200(w zależności od tego, co znajduje się na końcu stosu).

Powinienem również zauważyć, że jedyną instrukcją *> <>, której używa, jest S(uśpienie), w przeciwnym razie jest to właściwy program> <>.

Aktualizacja: Zapisano 1 bajt, przesuwając :w prawo zamiast chroniąc go rejestrem.

Wyjaśnienie

Inicjalizacja

<v":1200----"

Tutaj budujemy stos, którego będziemy używać przez cały czas trwania programu.

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

Czas wyjścia

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

Jest to sekcja, w której czas jest faktycznie wyprowadzany. Pierwsze 5 jest wypychane na stos, więc pętla poniżej wie, że działa 5 razy.

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"

Odzyskaj i zamień

S      >~r@@}r5

Tutaj odzyskujemy :pozycję, z której wynika po wyjściu, i otrzymujemy odwrócony stos. To faktycznie ładnie przechodzi w „czas wyjściowy”, powodując nieskończoną pętlę.

       >         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 bajtowe rozwiązanie

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

Wypróbuj tutaj!

Ten jest także w zasadzie programem> <>.

Naprawdę myślałem, że przy takim podejściu można zaoszczędzić trochę bajtów. To po prostu wyjść 12:00, następnie --:--. Zapisuję bajty, ponownie wykorzystując procedurę wyjściową o/!?l(nawet ponownie używam lustra jako wejścia i wyjścia). Korzystam z wielu stosów do przechowywania stanu (ma dane wyjściowe 12lub --) i wybieram stan, z którym mam generować dane wyjściowe v>]?v.

^{Wyjaśnienia już wkrótce! (1/2)}

HTML / CSS (tylko Chrome), 80 + 4 = 84 bajtów

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

<tt>

Edycja : Atrybut „content” nie jest animowany zgodnie ze specyfikacją CSS , ale znajduje się w przeglądarce Chrome na komputerze.

Noodel , niekonkurencyjne 16 bajtów

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

Noodel jest wciąż bardzo w toku. Próbuję zmoczyć stopy kilkoma wyzwaniami.

Spróbuj:)

Jak to działa

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

Oto fragment kodu :)

<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 bajtów

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

QBasic niestety może spać tylko przez całe sekundy. Zobaczę wkrótce o opracowaniu metody pozwalającej na większą elastyczność. Wprowadziłem 1, 01aby zasymulować .5.

Wyjaśnienie:

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

W starszych wersjach QBIC $i (spacja) były znakami zastrzeżonymi. Wywołanie funkcji QBasic wymagającej spacji (jak sleep x) lub $( left$(..)) wymagało literału kodu:

'QBASIC CODE`

Kod w bloku literału kodu jest przekazywany bezpośrednio do QBasic bez parsowania przez QBIC. Odciążając funkcje z tych symboli ( $stały się ', a nowe wiersze są teraz ┘(alt-217) zamiast ), symbole nie są już postrzegane przez QBIC jako specjalne znaki i po prostu przekazywane. To samo dotyczy skutecznie małych liter: służy do reprezentowania zmiennych numerycznych zarówno w QBIC, jak i QBasic i pozostaje niezmienionych. Korzystanie z funkcji QBasic, która nie jest zaimplementowana w QBIC (podobnej SLEEP), jest więc po prostu kwestią niestosowania zarezerwowanych znaków QBIC. Jest to łatwiejsze dzięki ostatnim zmianom symboli poleceń.

JavaScript, 77 76 72 bajtów

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

Dzięki Kritixi Lithos za 1 bajt i L. Serne za 4 bajty!

Python 2, 88 85 73 71 bajtów

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

Wypróbuj tutaj!

Dzięki pożyczeniu pomysłu Stewie Griffin na przerzucenie listy program stał się możliwy. Wersja bez golfa z wyjaśnieniem:

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

Dzięki @FlipTack za uratowanie 14 bajtów!

PHP, 51 50 47

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

1 bajt zapisany ze względu na manatwork i kolejne 3 zapisane przez inserttusernamehere tutaj. Dzięki!

Pyth, 23 bajty

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

W pseudokodzie:

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

Używa wstępnie zainicjowanej zmiennej Zjako flip-flop i odwraca jej stan za każdym razem if, gdy próbuje sprawdzić warunek.

rubin, 47 42 bajtów

Nie ma jeszcze rubinowej odpowiedzi, więc oto moja pierwsza próba:

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

GNU sed, 39 bajtów

EDYCJE:

• Zamieniono tryb uśpienia i i12: 00 (aby kod źródłowy wyglądał nieco ładniej)

Grał w golfa

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

Wyjaśniono

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.

Wypróbuj online!

dc (bash), 37 bajtów

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

Działa to poprzez naciśnięcie dwóch ciągów „12:00” i „-: -” na stosie, a następnie wielokrotne zamianie wartości, drukowanie elementu na górze stosu i spanie pół sekundy.

Aby to uruchomić, możesz zapisać go w pliku, a następnie wpisać

nazwa pliku dc

lub możesz uruchomić go bezpośrednio z wiersza poleceń bash, wpisując

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

Perl 6 ,  48 41  34 bajtów

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

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

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

Galaretka, 22 bajty

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

Nie działa w TIO. Uruchomienie aplikacji Jelly na Androidzie z QPython3 było również świetną zabawą.

Wyjaśnienie

®‘©ị“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. 

Mathematica, 38 bajtów

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

Wyjaśnienie

Clock[]

Wysyła zmienną zegarową, która cyklicznie zmienia się od 0 do 1 co sekundę.

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

Jeśli zmienna zegara jest większa niż .5, wyślij „12:00”. Jeśli nie, wpisz „-: -”.

Dynamic@ ...

Spraw, aby program był dynamiczny (ciągle aktualizowany)

JavaScript, 57 55

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

2 bajty zapisane dzięki ETHproductions

Postscript 225 214

Tylko dla zabawy! Nie wysyłaj tego do prawdziwej drukarki !!

/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

Spróbuj:

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'

lub

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

następnie

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

Ale nie próbuj otwierać tego za pomocą bardziej wyrafinowanej przeglądarki i dbaj o miniatury pulpitu!

JavaScript (w przeglądarce), 174 160 159 122 112 111 109 107 66 (91) bajtów

Usunąłem, preponieważ używanie czcionki monotypowej nie jest częścią wymagań, więc moja nowa liczba wynosi 66 . Niektóre znaki są dodawane w celu użycia czcionki o stałej szerokości, ale ponieważ nie jest to potrzebne, nie liczę tych 25 znaków więcej.

Dzięki produktom ETH dla oszczędności 14 bajtów,

do Kritixi Lithos do zapisywania 1 bajt,

do zarządzania dla oszczędzania 1 3 bajtów,

do Christoph do zapisywania i dwa kolejne bajty

dla siebie za oszczędność 37 bajtów przy użyciu [..][b^=1]zamiast setTimeout... i 10 kolejnych przez zastąpienie function(){..}podwójnymi cudzysłowami ...

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

body{font-family:Courier}

... gorzej:

Od 66 do czegoś więcej ...

... ale dla zabawy w duchu migającego wyświetlacza:

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 kęsów (pyszne)

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

I tak nigdy nie zamierzałem wygrywać. QB nie ma floor (), a także nie ma funkcji spania dla x milisekund. Dlatego działa to poprzez pobranie części zmiennoprzecinkowej TIMERA (zwraca sekundy, które upłynęły od północy plus ułamek bieżącej sekundy wyrażony jako dwucyfrowa liczba dziesiętna). Następnie dodajemy pętlę wokół „50 jednostek”, aby określić, kiedy faza powinna się przełączyć z „-: -” na „12:00”, i użyć pierwotnego dziesiętnego TIMERA dla przełączenia z „12:00” do "--:--".

Wreszcie, nawet uruchomienie tego jest zgodne z QB4.5, w DOSBox na dość mocnej maszynie pomija rytmy. To dlatego, że QB naprawdę nie jest wystarczająco szybki, aby wykonać DO-LOOP i oceny wewnątrz MS, w którym robimy porównanie. Potrzebowałbym pudełka z PRZYSZŁOŚCI!

W każdym razie wyglądam teraz na 100 i sprawiłem, że każdy student amerykańskiego uniwersytetu był szczęśliwy, ponieważ prawdopodobnie mają odpowiedź na lekcję Comp Sci - ponieważ wciąż uczą tego ...

Clojure, 79 62 bajtów

V2

-17 bajtów poprzez zmianę z okropnej pętli indeksującej na zapętlanie nieskończonej listy.

Tworzy nieskończoną listę "12:00"i "--:--"powtarzanie w kółko, a następnie używa doseqdo ciągłego pobierania następnej wiadomości i drukowania.

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

Nie mogłem wymyślić dobrego sposobu na skompresowanie stałych „12:00” i „-: -”, więc musiałem je po prostu na stałe zakodować.

Nie golfowany:

(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 bajty (niekonkurujące)

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

Ta odpowiedź wykorzystuje dwa stosy, przewracając je i drukując kolejno znaki:

`--:`    \ 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)

oWKomenda jest częścią zestawu poleceń eksperymentalnych, które postdatować wyzwaniu, dzięki czemu ta odpowiedź nie konkurują.

Windows PowerShell, 46 55 bajtów

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

Kod oryginalny:

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