Banyak perangkat elektronik, khususnya yang lama, akan berkedip 12:00ketika waktu belum ditentukan. Tujuan dari tantangan ini adalah untuk menciptakan kembali ini.

Secara khusus, tugasnya adalah untuk menampilkan 12:00dan sebagai --:--alternatif dalam infinite loop .

The Periode harus 1 detik, dibagi secara merata dalam dua periode dari 0,5 detik. Di sini "1 detik" dan "merata" dapat diartikan secara longgar. Misalnya, dapat diterima jika kode berhenti selama 0,5 detik antara menampilkan string, bahkan jika periode yang dihasilkan kemudian akan sedikit lebih tinggi dari 1 detik. Jeda awal sebelum menampilkan string pertama dapat diterima.

Setiap string baru dapat ditampilkan dengan mengganti string sebelumnya atau di baris baru . Trailing whitespace diperbolehkan, kecuali bahwa jika setiap string baru pada baris yang berbeda tidak boleh ada garis kosong antara string berturut-turut.

Kode terpendek dalam byte menang.

Jelly , 20 byte

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

Bagaimana itu bekerja

.“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 byte

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

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

Sunting: Disimpan 23 byte berkat @insertusernamehere. Disimpan 1 byte dengan beralih dari <pre>ke <tt>. Disimpan 2 byte berkat @darrylyeo. Disimpan 5 byte berkat @DBS.

Shell dan pv, 26 byte

Ini menggunakan yesalat standar dan pv elemen pipa Shell untuk mengukur data yang lewat

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

Python2, 80 75 73 69 67 66 byte

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

Saya perhatikan bahwa magic string saya mendapatkan sedikit lebih lama daripada mengambil string dari array. Nevermind, menemukan jawabannya.

Penjelasan :

• Saya mengatur penghitung n ke 0, yang akan beralih antara 0 dan 1.

• Saya berulang tanpa henti dengan loop while 1.

• Saya membuat string 1-2-::0-0-, yang berisi string 12:00dan --:--saling bertautan.

  • Mulai dari indeks 0 dengan langkah 2, kita dapatkan: 12:00

  • Mulai dari indeks 1 dengan langkah 2, kita dapatkan: --:--

• Saya menggunakan n untuk membuat urutan berulang 0 , 1 , 0 , 1 , 0 ... yang akan menjadi indeks awal dari string.

  • Dengan menggunakan n^=1, di setiap loop, kita mendapatkan urutan itu. ^menjadi operator XOR.
  • Jika n == 0 -> n^=1hasil dalam 1
  • Jika n == 1 -> n^=1hasil dalam 0
• Saya mencetak string, dan tidur ( .5-> 0.5) detik.

@FlipTack menyimpan 4 byte! -> Letakkan loop dalam satu baris.

@Rod menyelamatkan 2 byte! -> n+=1untuk n^=1, dengan demikian n%2untuk n.

@ xnor menyimpan satu byte! -> while 1-> while[time.sleep(.5)].

Oktaf, 63 62 61 55 byte

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

Disimpan dua byte berkat Tom Carpenter! Menggunakan string tunggal alih-alih dua string dalam array sel lebih pendek.

Penjelasan:

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

Beberapa byte disimpan karena Oktaf tidak memerlukan titik dua atau titik koma antara flip(c)dan disp(), dan antara pause(.5)dan end.

JavaScript, 59 byte

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

Penjelasan

setInterval('...',500) menetapkan interval untuk mengeksekusi kode dalam string setiap 500 milidetik, atau 1/2 detik.

y=1setel variabel y,, ke 1 pada awalnya. Dengan begitu, hal pertama yang dicetak adalah 12:00karena ydigunakan untuk mengakses array.

console.log(...)log apa saja ke konsol, di ini 12:00atau --:--.

["12:00","--:--"][y^=1]membuat array dengan string yang mengandung kedua negara. Kemudian, ydigunakan untuk mengakses salah satu elemen. Akhirnya,, ^=atau operator gabungan XOR melakukannya y = y ^ 1. Ini hanya membalikkan bit karena 1 ^ 10, dan 0 ^ 11, mirip dengan yang dilakukan @TuukkaX . Dengan cara ini, string yang dicatat berganti-ganti antara dua elemen dalam array dan dengan demikian menciptakan efek berkedip.

V , 31 30 27 25 24 byte

Disimpan 5 byte berkat @ nmjcman101 dengan menukar urutan 12:00dan --:--sehingga kdapat dihapus dengan menghapus òsehingga dapat ditambahkan secara implisit di akhir

Disimpan 1 byte berkat @DJMcMayhem dengan meletakkan keduanya 12:00dan --:--dalam satu baris

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

Solusi lama:

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

<ESC> aku s 0x1b

Hexdump:

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

Penjelasan

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

Catatan: Sorotan saya aktifkan

bash, 58 56 45 byte

disimpan 3 byte dengan menekan --setelah setsebagai argumen 1 adalah angka.

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

Disimpan 16 byte dengan menggunakan sintaks @DigitalTrauma :

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

Kemudian kehilangan 5 byte karena komentar zeppelin .

Ini tidak dapat diuji pada baris perintah. Saat kami terlibat $0, ini harus ditulis ke dalam skrip untuk dijalankan.

Mengalihkan

Dengan sedikit persiapan, ini bisa menjadi bagus ( 412 byte ):

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

Atau bahkan dua baris yang sama tetapi dengan:

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 byte

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

Perl sleeptidak dapat tidur untuk durasi di bawah 1 detik, karenanya penggunaan select undef, undef, undef, .5(golf dengan mengganti undefdengan $,) untuk tidur 0,5 detik.
Hal menarik lainnya: $|hanya bisa menampung 0atau 1. Jadi $|--cukup matikan nilainya, dari 0menjadi 1.
Dan akhirnya, {... ;redo}bertindak seperti loop tak terbatas.

*> <> , 43 42 byte

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

Coba di sini!

Saya merasa saya harus bisa membuat ini lebih pendek, saya punya beberapa ide untuk mencoba ... Pada dasarnya ini membuat setumpuk :1200----. Ini mengisolasi :dan membalik tumpukan, memasukkan :di tengah salah satu ----atau 1200(tergantung mana yang ada di ujung tumpukan).

Saya juga harus mencatat bahwa satu-satunya *> <> instruksi yang digunakan adalah S(sleep), jika tidak, ini adalah program yang tepat> <>.

Pembaruan: Disimpan 1 byte dengan menggeser :ke kanan alih-alih melindunginya dengan register.

Penjelasan

Inisialisasi

<v":1200----"

Di sini kita membangun tumpukan yang akan kita gunakan untuk umur program.

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

Waktu output

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

Ini adalah bagian di mana waktu sebenarnya dikeluarkan. Pertama 5 didorong ke tumpukan sehingga loop di bawah ini tahu untuk menjalankan 5 kali.

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"

Pulihkan dan tukar

S      >~r@@}r5

Di sini kita memulihkan :dari posisi yang dihasilkan setelah output, dan kita berakhir dengan tumpukan terbalik. Ini sebenarnya keluar menjadi "waktu keluaran" dengan baik, menyebabkan loop tak terbatas.

       >         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

Solusi 45 byte

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

Coba di sini!

Yang ini pada dasarnya juga merupakan program> <>.

Saya benar-benar berpikir itu akan dapat menghemat beberapa byte dengan pendekatan ini. Ini cukup sederhana keluaran 12:00, kemudian --:--. Saya menyimpan byte dengan menggunakan kembali output rutin o/!?l(saya bahkan menggunakan kembali mirror itu sebagai entri dan keluar). Saya menggunakan banyak tumpukan untuk menyimpan status (memiliki keluaran 12atau --), dan memilih negara mana yang harus saya keluaran v>]?v.

^{Penjelasan segera hadir! (1/2)}

HTML / CSS (hanya Chrome), 80 + 4 = 84 byte

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

<tt>

Sunting : Atribut "content" tidak dapat digerakkan oleh spesifikasi CSS , tetapi ada di browser desktop Chrome.

Noodel , 16 byte tidak bersaing

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

Noodel masih sangat banyak pekerjaan yang sedang berjalan. Hanya mencoba membuat kaki saya basah dengan beberapa tantangan.

Cobalah:)

Bagaimana itu bekerja

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

Berikut ini cuplikan kode :)

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

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

QBasic sayangnya hanya bisa tidur selama satu detik penuh. Saya akan melihat tentang merancang metode untuk memungkinkan lebih banyak fleksibilitas segera. Saya sudah input 1 01untuk mensimulasikan .5.

Penjelasan:

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

Dalam versi lama QBIC, $dan (spasi) karakter yang dipesan. Memanggil fungsi QBasic yang membutuhkan spasi (seperti sleep x) atau $( left$(..)) membutuhkan kode literal:

'QBASIC CODE`

Kode dalam blok kode literal diteruskan langsung ke QBasic tanpa diuraikan oleh QBIC. Dengan membongkar fungsi dari simbol-simbol tersebut ( $menjadi ', dan baris baru sekarang ┘(alt-217) alih-alih , simbol tidak lagi dilihat oleh QBIC sebagai karakter khusus dan hanya diteruskan. Hal yang sama berlaku juga untuk alfabet huruf kecil: digunakan untuk mewakili variabel numerik dalam QBIC dan QBasic dan tidak berubah. Menggunakan fungsionalitas QBasic yang tidak diimplementasikan dalam QBIC (seperti SLEEP) ada hanya masalah tidak menggunakan karakter yang dipesan QBIC. Ini menjadi lebih mudah dengan perubahan terbaru pada simbol perintah.

JavaScript, 77 76 72 byte

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

Terima kasih kepada Kritixi Lithos untuk 1 byte dan L. Serne untuk 4 byte!

Python 2, 88 85 73 71 byte

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

Coba di sini!

Dengan meminjam gagasan Stewie Griffin untuk membalik daftar, program itu dimungkinkan. Versi tidak dikoleksi dengan penjelasan:

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

Terima kasih @FlipTack untuk menghemat 14 byte!

PHP, 51 50 47

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

1 byte disimpan karena manatwork dan 3 lainnya disimpan oleh insertusername di sini. Terima kasih!

Pyth, 23 byte

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

Dalam pseudocode:

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

Menggunakan variabel yang diinisialisasi Zsebagai flip-flop, dan membalikkan keadaannya setiap kali ifmencoba memeriksa kondisi.

ruby, 47 42 byte

Belum ada jawaban ruby, jadi ini adalah percobaan pertama saya:

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

GNU sed, 39 byte

EDIT:

• Bertukar tidur dan I12: 00 (untuk membuat kode sumber terlihat lebih baik bit)

Golf

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

Dijelaskan

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.

Cobalah secara Online!

dc (bash), 37 byte

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

Ini bekerja dengan mendorong dua senar "12:00" dan "-: -" pada tumpukan dan kemudian berulang kali menukar nilainya, mencetak item di bagian atas tumpukan, dan tidur setengah detik.

Untuk menjalankan ini, Anda dapat menyimpannya dalam file dan kemudian ketik

nama file dc

atau Anda dapat menjalankannya langsung dari baris perintah bash dengan mengetik

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

Perl 6 ,  48 41  34 byte

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

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

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

Jelly, 22 byte

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

Tidak berfungsi di TIO. Mendapatkan Jelly untuk berjalan di Android dengan QPython3 juga merupakan pengalaman yang menyenangkan.

Penjelasan

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

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

Penjelasan

Clock[]

Menghasilkan variabel jam yang terus-menerus berputar dari 0 hingga 1 setiap detik.

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

Jika variabel jam lebih besar dari 0,5, output "12:00." Jika tidak, keluaran "-: -".

Dynamic@ ...

Jadikan program dinamis (terus-menerus memperbarui)

Javascript, 57 55

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

2 byte disimpan berkat produk ETH

Catatan tambahan 225 214

Hanya untuk bersenang-senang! Jangan kirim ini ke printer sungguhan !!

/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

Cobalah:

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'

atau

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

kemudian

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

Tapi jangan coba membukanya dengan pemirsa yang lebih canggih dan peduli dengan thumbnailer desktop!

Javascript (di browser), 174 160 159 122 112 111 109 107 66 (91) byte

Saya telah mengambilnya prekarena menggunakan font monotipe bukan bagian dari persyaratan, jadi jumlah baru saya adalah 66 . Beberapa karakter ditambahkan untuk menggunakan font monospaced tetapi karena ini tidak diperlukan, saya tidak akan menghitung 25 ini karakter lagi.

Berkat produk ETH untuk menghemat 14 byte,

untuk Kritixi Lithos untuk menghemat 1 byte,

untuk manatwork untuk menghemat 1 3 byte,

kepada Christoph karena menyimpan dua byte lagi dan

kepada saya sendiri untuk menghemat 37 byte dengan menggunakan [..][b^=1]alih-alih setTimeout... dan 10 lainnya dengan mengganti function(){..}dengan tanda kutip ganda ...

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

body{font-family:Courier}

... lebih buruk:

Dari 66 ke sesuatu yang lebih ...

... tapi untuk bersenang-senang, dalam semangat tampilan yang berkedip:

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

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

Saya tidak akan pernah menang. QB tidak memiliki lantai (), dan juga tidak memiliki fungsi untuk tidur selama x milidetik. Oleh karena itu, ini bekerja dengan meraih bagian titik mengambang TIMER (mengembalikan detik berlalu sejak tengah malam, ditambah sebagian kecil dari detik saat ini dinyatakan sebagai desimal dua digit). Kami kemudian menambahkan loop-sekitar "50 unit" untuk menentukan kapan fase harus beralih dari "-: -" ke "12:00", dan menggunakan desimal TIMER asli untuk beralih dari "12:00" ke "-: -".

Akhirnya, bahkan menjalankan ini sesuai dengan QB4.5, di DOSBox pada mesin yang agak kuat akan melewatkan ketukan. Itu karena QB benar-benar tidak cukup cepat untuk melakukan DO-LOOP dan evaluasi di dalam MS yang sedang kami lakukan perbandingan. Butuh kotak dari MASA DEPAN!

Bagaimanapun, saya sekarang terlihat 100, dan saya membuat setiap mahasiswa Universitas Amerika senang karena mereka mungkin punya jawaban untuk kelas Comp Sci mereka - karena mereka masih mengajar ini ...

Clojure, 79 62 byte

V2

-17 byte dengan mengubah dari pengindeksan mengerikan ke pengulangan daftar tak terbatas.

Membuat daftar tak terhingga "12:00"dan "--:--"mengulangi lagi dan lagi, lalu gunakan dosequntuk terus-menerus menarik pesan berikutnya, dan mencetaknya.

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

Saya tidak bisa memikirkan cara yang baik untuk memadatkan konstanta "12:00" dan "-: -", jadi saya harus mengkodekannya dengan keras.

Tidak Disatukan:

(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 byte (tidak bersaing)

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

Jawaban ini memanfaatkan kedua tumpukan, dengan membalik di antara keduanya, mencetak karakter secara bergantian:

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

The oWPerintah merupakan bagian dari satu set perintah eksperimental yang mengundurkan tantangan, membuat jawaban ini non-bersaing.

Windows PowerShell, 46 55 byte

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

Kode Asli:

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