Багато електронних пристроїв, особливо старі, покажуть миготіння, 12:00коли час не встановлено. Мета цього виклику - відтворити це.

Зокрема, завдання полягає у відображенні 12:00та --:--альтернативно в нескінченному циклі .

Період повинно бути 1 секунда, рівномірно розділене на два періоди в 0,5 секунди. Тут "1 секунда" і "рівномірно" можна інтерпретувати нещільно. Наприклад, прийнятно, якщо код призупиняється на 0,5 секунди між відображенням рядків, навіть якщо результат, який виходить, буде трохи більшим за 1 секунду. Початкова пауза перед відображенням першого рядка є прийнятною.

Кожен новий рядок може бути відображений або замінивши попередній рядок, або в новий рядок . Добірка пробілів дозволена, за винятком випадків, якщо кожна нова рядок знаходиться в іншому рядку, між послідовними рядками не повинно бути порожніх рядків.

Виграє найкоротший код у байтах.

Желе , 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

Редагувати: збережено 23 байти завдяки @insertusernameтут. Збережено 1 байт, перейшовши <pre>на <tt>. Збережено 2 байти завдяки @darrylyeo. Збережено 5 байт завдяки @DBS.

Оболонка і pv, 26 байт

Для вимірювання даних, що проходять через цей yesінструмент, використовується стандартний інструмент та pv елемент трубопроводу Shell

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і --:--переплітається.

  • Починаючи з індексу 0 з кроком 2, отримуємо: 12:00

  • Починаючи з індексу 1 з кроком 2, отримуємо: --:--

• Я використовую n, щоб зробити повторювану послідовність 0 , 1 , 0 , 1 , 0 ..., яка буде початковим індексом рядка.

  • Використовуючи n^=1в кожному циклі ми отримуємо цю послідовність.^будучи оператором XOR.
  • Якщо n == 0 ->n^=1 призводить до 1
  • Якщо n == 1 -> n^=1призводить до 0
• Я друкую рядок і сплю ( .5-> 0.5) секунд.

@FlipTack врятував 4 байти! -> Покладіть петлю в один рядок.

@Rod врятував 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

Збережено два байти завдяки Тому Карпентеру! Використання одного рядка замість двох рядків у масиві комірок було коротшим.

Пояснення:

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

Кілька байтів збережено, оскільки Octave не потребує двокрапки або крапки з комою між flip(c)і disp(), і між pause(.5)і end.

JavaScript, 59 байт

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

Пояснення

setInterval('...',500) встановлює інтервал для виконання коду в рядку кожні 500 мілісекунд або 1/2 секунди.

y=1встановлює yпочаткову змінну,, 1. Таким чином, перше, що надрукується, це 12:00тому y, що використовується для доступу до масиву.

console.log(...)записує що-небудь до консолі, у цьому 12:00або --:--.

["12:00","--:--"][y^=1]створює масив з рядками, що містять обидва стану. Потім yвикористовується для доступу до одного з елементів. Нарешті, ^=або оператор з'єднання XOR робить y = y ^ 1. Це просто перевертає біт, оскільки 1 ^ 1це 0, і 0 ^ 1це 1, подібно до того, що зробив @TuukkaX . Таким чином, зареєстрований рядок чергується між двома елементами в масиві і, таким чином, створює ефект мерехтіння.

V , 31 30 27 25 24 байти

Збережено 5 байт завдяки @ nmjcman101, змінивши порядок 12:00і --:--так, що kйого можна видалити будь-яким шляхом видалення, òщоб його можна було неявно додавати в кінці

Збережено 1 байт завдяки @DJMcMayhem, поставивши обидва 12:00і --:--в один рядок

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

Старе рішення:

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

<ESC> є 0x1b

Hexdump:

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 байт

збережений 3 байт шляхом придушення --після того, setяк 1-й аргумент є числом.

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

Збережено 16 байт за допомогою синтаксису @DigitalTrauma :

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

Тоді втрачаємо 5 байт через коментар zeppelin .

Це не вдалося перевірити в командному рядку. Як ми залучаємо $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|                                      
                                                                               '

Perl, 49 байт

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

Perl не sleepможе спати тривалістю нижче 1 секунди, отже, використання select undef, undef, undef, .5(гольф заміною undefна $,) для сну .5 секунди.
Інша цікава річ: $|вміє проводити лише 0або 1. Тож $|--просто перемикає його значення з " 0на" 1.
І нарешті, {... ;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 , але є у настільному браузері Chrome.

Локшина , неконкурентна 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?@--:--

На жаль, QBasic може спати лише цілі секунди. Я побачу, як розробити метод, який дозволить скоро досягти більшої гнучкості. Я ввів 1, як 01імітувати .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 $і (пробіл) були зарезервовані символи. Для виклику функції QBasic, для якої потрібні пробіли (як sleep x) або $( left$(..)), потрібен буквальний код:

'QBASIC CODE`

Код у прямому блоці коду передається безпосередньо до QBasic, не аналізуючи його QBIC. Вивантажуючи функції з цих символів ( $стали ', а нові рядки тепер ┘(alt-217) замість ), символи QBIC більше не розглядаються як спеціальні символи і просто передаються. Те ж саме справедливо для алфавіту малих літер: він використовується для представлення числових змінних як у QBIC, так і в QBasic, і вони залишаються незмінними. Використання функціональності QBasic, яке не реалізовано в QBIC (подібне SLEEP), є просто тим, що не використовувати зарезервовані символи QBIC. Це полегшується завдяки останнім змінам символів команди.

JavaScript, 77 76 72 байт

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

Дякуємо Kritixi Lithos за 1 байт та L. Serne за 4 байти!

Пітон 2, 88 85 73 71 байт

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

Спробуйте тут!

Запозичуючи ідеї Стьюї Гріффіна з гортати список, програма була можливою. Безгольова версія з поясненням:

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

Дякуємо @FlipTack за економію 14 байт!

PHP, 51 50 47

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

1 байт збережено завдяки манатурності та ще 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 байт

ЗМІНИ:

• Поміняв сон і 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" і "-: -" на стеку, а потім повторно поміняючи значеннями, надрукувавши елемент у верхній частині стека і спавши півсекунди.

Щоб запустити це, ви можете зберегти його у файлі та ввести

dc- ім'я файлу

або ви можете запустити його безпосередньо з командного рядка bash, ввівши

dc <<< '[12:00] [-: -] [[rp! сон .5] xlax] dsax'

Perl 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. Забуття Jelly для запуску на Android з QPython3 також було цікавим досвідом.

Пояснення

®‘©ị“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","--:--"]

Якщо змінна тактова частота перевищує .5, виведіть "12:00". Якщо ні, виведіть "-: -".

Dynamic@ ...

Зробіть програму динамічною (постійно оновлюється)

Javascript, 57 55

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

2 байти збережено завдяки ETHproductions

Постскрипт 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

Але не намагайтеся відкривати це за допомогою більш досконалого глядача та дбайте про ескіз на робочому столі!

Javascript (у браузері), 174 160 159 122 112 111 109 107 66 (91) байт

Я скористався preтим, що використання однотипного шрифту не є частиною вимоги, тому моя нова кількість - 66 . Деякі символи додаються для використання одношарового шрифту, але оскільки це не потрібно, я не буду рахувати ці 25 символів більше.

Завдяки ETHproductions за збереження 14 байт,

в Kritixi Lithos для економії 1 байта,

для маніпуляції для економії 1 3 байта,

до Christoph для збереження ще два байта і

собі, щоб зберегти 37 байт, використовуючи [..][b^=1]замість setTimeout... та ще 10, замінивши function(){..}подвійними лапками ...

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 не має підлоги (), а також не має функції спати протягом x мілісекунд. Отже, це працює, захоплюючи частину TIMER з плаваючою комою (повертає секунди, що минули з півночі, плюс частку поточної секунди, виражену двоцифровою десятковою). Потім ми додаємо до нього цикл "50 одиниць", щоб визначити, коли фаза повинна перейти з "-: -" в "12:00", і використовуємо оригінальний десятковий таймер для перемикання з "12:00" до "-: -".

Нарешті, навіть запустивши це дотримано в QB4.5, в DOSBox на досить потужній машині пропустять удари. Це тому, що QB насправді недостатньо швидкий для виконання DO-LOOP та оцінок всередині MS, у яких ми робимо порівняння. Потрібна скринька від МАЙБУТНЬОГО!

У будь-якому випадку я зараз виглядаю 100, і я зробив щасливим кожного студента Американського університету, оскільки вони, мабуть, мають відповідь за клас Comp Sci - оскільки вони все ще навчають цьому ...

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

Пушистий , 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.