Многие электронные устройства, особенно старые, будут мигать, 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 байта сохранены благодаря @insertusernamehere. Сохранено 1 байт путем переключения с <pre>на <tt>. Сохранено 2 байта благодаря @darrylyeo. Сохранено 5 байт благодаря @DBS.

Shell и 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можно удалить любой, удалив, òчтобы он мог быть добавлен неявно в конце

Благодаря @DJMcMayhem удалось сохранить 1 байт, поместив оба 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 байтов из-за комментария Цеппелина .

Это не может быть проверено в командной строке. Как мы говорим $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(golfed путем замены 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>

Редактировать : атрибут «content» не подлежит анимации согласно спецификации CSS , но находится в браузере Chrome для настольных ПК.

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?@--:--

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 и остается неизменным. SLEEPПоэтому использование функциональности QBasic, которая не реализована в QBIC (как ), является просто вопросом не использования зарезервированных символов QBIC. Это стало проще благодаря недавним изменениям в символах команд.

JavaScript, 77 76 72 байта

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

Спасибо Kritixi Lithos за 1 байт и L. Serne за 4 байта!

Python 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 байт сохранен из-за manatwork и еще 3 сохранены вставкой username здесь. Благодарность!

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 (чтобы исходный код выглядел немного лучше)

Golfed

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.

Попробуйте онлайн!

постоянный ток (bash), 37 байт

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

Это работает, помещая две строки «12:00» и «-: -» в стек, а затем многократно меняя значения, печатая элемент наверху стека и спя полсекунды.

Чтобы запустить это, вы можете сохранить его в файле и затем набрать

постоянный файл

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

dc <<< '[12:00] [-: -] [[rp! sleep .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. 

Mathematica, 38 байт

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

объяснение

Clock[]

Выводит переменную тактового сигнала, которая непрерывно переключается от 0 до 1 каждую секунду.

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

Если переменная часов больше 0,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 не имеет floor (), а также не имеет функции для сна в течение x миллисекунд. Следовательно, это работает путем захвата части ТАЙМЕРА с плавающей запятой (возвращает секунды, прошедшие с полуночи, плюс часть текущей секунды, выраженная в виде двузначного десятичного числа). Затем мы добавляем в него цикл «50 единиц», чтобы определить, когда фаза должна переключиться с «-: -» на «12:00», и используем исходное десятичное число ТАЙМЕРА для переключения с «12:00». на "-: -".

Наконец, даже выполнение этого соответствовало требованиям QB4.5, в DOSBox на довольно мощной машине пропускаются доли. Это потому, что QB на самом деле не достаточно быстр, чтобы выполнить DO-LOOP и оценки внутри MS, в которой мы проводим сравнение. Нужна коробка из БУДУЩЕГО!

В любом случае, теперь я выгляжу на сто, и я порадовал каждого студента Американского университета, так как у них, вероятно, есть ответ на свой курс 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» и «-: -», поэтому мне пришлось просто жестко их кодировать.

Ungolfed:

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