闪烁十二

43

12:00未设置时间时，许多电子设备（特别是旧的电子设备）将闪烁。挑战的目的是重新创建它。

具体来说，任务是显示12:00并--:--无限循环显示。

的周期应该是1秒，在0.5秒的两个周期均匀地划分。在这里，“ 1秒”和“均匀”可以被宽松地解释。例如，代码在显示字符串之间暂停0.5秒是可以接受的，即使所得到的时间间隔会稍大于1秒。在显示第一个字符串之前的初始暂停是可以接受的。

每一个新的字符串可以通过显示取代原有的字符串或在一个新行。允许尾随空格，除非每个新字符串在不同的行上，否则连续的字符串之间不应有空行。

以字节为单位的最短代码获胜。

code-golf  string  ascii-art  animation 
— 路易斯·门多
source
1
这算作kolmogorov复杂度吗？
— FlipTack
@FlipTack我想是的，但我不确定。有什么想法吗？
— 路易斯·门多
@LuisMendo我不这么认为，我认为KG标签主要用于固定字符串。这还有更多，等待和交替的字符串。
— Rɪᴋᴇʀ
提交内容可以等待0.5秒再显示初始输出吗？
— FlipTack
1
恕我直言，声明“可以通过替换旧字符串或换行来显示每个新字符串”使这一挑战变得不那么有趣。
— Setop'1

Answers:

4

果冻，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.
— 丹尼斯
source
因此，您基本上是通过添加睡眠命令将列表中的两个字符串转换为它们自己的链接吗？甜。
— steenbergh
32

HTML / CSS，131 108 106 101 + 18 17 = 149 126 125 123 118字节

a{background:#FFF;margin:-5ch;animation:a 1s steps(2,start)infinite}@keyframes a{to{visibility:hidden
<tt>--:--<a>12:00
展开摘要

编辑：感谢@insertusernamehere，节省了23个字节。从切换到<pre>，节省了1个字节<tt>。感谢@darrylyeo，节省了2个字节。@DBS节省了5个字节。

— 尼尔
source
1
@insertusernamehere Bah，我打高尔夫球了，a{position:absolute}但是完全忘记了pre……
— Neil
您还需要pre标签吗？CSS只提到一个。
— ev3commander'17
@ ev3commander我通过切换到保存了一个字节<tt>。
— 尼尔
您可以}}完全删除决赛。
— darrylyeo '17
我认为您应该可以简化margin-left为，margin因为无论如何从左上角进行工作margin:-5ch;都应具有相同的效果。
— DBS
15

Shell和pv，26个字节

这使用yes标准工具和pv Shell管道元素来计量通过的数据

yes '12:00
--:--'|pv -qlL2
— 豪里
source
2
不错的解决方案，但是该语言可能应该用“ Shell and pv”来表示，因为（据我所知）pv不包含在任何shell中，也不是GNU或BSD核心实用程序的一部分。
— 米切尔·史派克
1
那是一个很好的把戏！（我相信这是@Digital Trauma 在这里开创的）。尽管在这种情况下，感觉有点挑战的精神，因为任务声明是“交替显示12:00和-：-”（模仿闪烁的显示），但是此代码只会逐个字符输出而不是每秒12个字符的恒定速率。这意味着“ 12:00”将仅在屏幕上停留1/12（0.08）秒（“ 12：0 _” = 1 / 12s =>“ 12:00” = 2 / 12s =>“-”）。
— Zeppelin
@zeppelin感谢您的参考：我使用@DigitalTrauma的示例 -qlL2按秒制作2行，而不是按秒制作 -qL1212个字符。剧本的长度是相同的
— F. Hauri
15

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。

  • 我创建了一个string 1-2-::0-0-，其中包含该字符串12:00并--:--相互交错。

    • 从索引0开始，以2为步长，得到： 12:00

    • 从索引1开始，以2为步长，得到： --:--

  • 我用ñ，使重复序列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)]。

— 伊西
source
7
您可以替换n+=1为n^=1，然后使用[n::2]，保存2个字节并避免使用大数字c：
— Rod Rod
4
如果您将更print"1-2-::0-0-"[n::2]改为print"\b"*6+"1-2-::0-0-"[n::2],，则会添加一些字节，但会在适当的位置闪烁
— Buzz
1
您可以使用@Buzz \r代替\b\b\b...移动到行首。但是无论如何，这只会将字节添加到当前解决方案中。
— FlipTack
您可以这样做来保存一个字节while[time.sleep(.5)]:。
— xnor
@xnor我非常确定，再也不能打高尔夫球了。这个站点继续使我惊奇。谢谢！
— Yytsi
15

八度，63 62 61 55字节

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

感谢汤姆·卡彭特（Tom Carpenter），节省了两个字节！在单元格数组中使用单个字符串而不是两个字符串的时间更短。

说明：

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

几个字节保存，因为倍频不需要之间的冒号或者分号flip(c)和disp()之间，以及pause(.5)和end。

— 斯蒂夫·格里芬
source
1
flip代替计数器使用的好主意！
— 路易斯·门多
11

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 ^ 11，类似于@TuukkaX所做的。这样，记录的字符串在数组中的两个元素之间交替，从而产生闪烁效果。

— 李安德
source
能够保存一个字节：y=1;setInterval('console.log(y?"12:00":"--:--");y=!y',500)
— woutr_be
ETHproductions尖在我的答案：You can save some bytes with setInterval(...,i=500) :-)。我们基本上有相同的答案，它也适用于您。
— 克里斯多夫（Christoph）
11

V，31 30 27 25 24字节

@ nmjcman101通过交换和的顺序节省了5个字节12:00，--:--因此k可以通过删除将其删除ò，从而可以在末尾隐式添加

@DJMcMayhem通过将12:00和--:--放在一行中而节省了1个字节

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

旧解决方案：

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

<ESC> 是 0x1b

十六进制转储：

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（过时）

注意：我已开启高亮显示

giff

— 克里特希·里索斯（Kritixi Lithos）
source
7
您实际上是在该gif中眨眼：-)
— Luis Mendo
第二个ò是隐式给出的，因此您可以将其删除。
— DJMcMayhem
@DJMcMayhem由于某种原因，如果没有第二个，它将无法工作ò。它只运行一次
— Kritixi Lithos'1
2
交换输入的顺序，这样就不需要第一个k。然后，而不是pkdd您可以只使用Vp，因为p在可视选择模式下可以有效地将选择与默认寄存器交换。
— nmjcman101
1
我知道您在删除时遇到了问题ò，但是如果现在可以正常工作，我想您应该可以将其更改为，òVp:sl500m并让V将^Mò2字节相加。
— nmjcman101 '17
11

bash，58 56 45字节

通过--在set第1个arg为数字后进行抑制来保存3个字节。

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

使用@DigitalTrauma的语法保存了16个字节：

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

然后由于齐柏林飞艇的评论而丢失了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|                                      
                                                                               '
— 豪里
source
3
s(){ echo $1;sleep .5;};for((;;)){ s 12:00;s --:--;}
— manatwork '17
2
@manatwork不错！我认为这不是同一个脚本！您必须将它们发布为答案！
— F. Hauri
我必须承认，ASCII艺术绝对是美好的……您是使用工具创建它还是手工制作的？
— ETHproductions
2
@ETHproductions我使用Ghostscript：printf '%%\041\n/Helvetica findfont\n24 scalefont\nsetfont\nnewpath\n%s %s moveto\n(%s) show\nshowpage\n' -2.456 0.550003 12:00 | gs -sDEVICE=pnmraw -r600 -g470x146 -sOutputFile=- -q - | pnmscale -width 160 | ppmtopgm | pgmtopbm | pbmtoascii -2x4;-)
— F. Hauri
1
...或f()(echo $1;sleep .5);f 12:00;f --:--;$0
— Digital Trauma '01
9

Perl，49个字节

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

Perl的sleep不能睡眠持续时间波纹管1秒，因此，使用的select undef, undef, undef, .5（通过更换golfed undef与$,睡眠0.5秒）。
其他有趣的事情：$|只能容纳0或1。因此，$|--只需将其值从切换为0即可1。
最后，{... ;redo}就像一个无限循环。

— 达达
source
6

*> <>，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）

— 红星编码器
source
6

HTML / CSS（仅Chrome），80 + 4 = 84字节

tt:after{content:"--:--";animation:a 1s infinite}@keyframes a{to{content:"12:00"
<tt>
展开摘要

编辑：“内容”属性不能由CSS规范设置动画，但是在Chrome桌面浏览器上。

— degif
source
1
似乎是特定于Chrome的。至少在Firefox上不起作用。这不是问题，解决方案仍然有效，只需指定它即可。
— manatwork
6

Noodel，非竞争16 字节

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

Noodel仍在进行中。只是想让我的脚经受一些挑战。

试试吧：）

这个怎么运作

--:--            # 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>
展开摘要

— Tkellehe
source
2
如果口译员将挑战日期过后，请将其标记为“非竞争” :)。Noodel看起来很整洁，肯定可以检查出来。
— redstarcoder
@redstarcoder糟糕！谢谢，忘了说。
— tkellehe
你能解释一下编码吗？在UTF-8中，它的总数超过16。
— devRicher
1
我看了你的链接，它没有解释编码。您会看到，并非所有字符都默认为1字节（“默认”）（UTF-8）。指定现有编码或进行编码，否则，这是错误的字节数。关于此的地方应该有一个元文章。除非您定义编码，否则它是UTF-8且为22个字节。@tkellehe
— devRicher
1
找到了元发布，顺便说一句。
— devRicher
5

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中，$和 （空格）是保留字符。调用需要空格（例如sleep x）或$（left$(..)）的QBasic函数需要代码文字：

'QBASIC CODE`

代码文字块中的代码直接传递给QBasic，而不会被QBIC解析。通过从这些符号卸载功能（$变为'，现在换行符┘（alt-217而不是）），这些符号不再被QBIC视为特殊字符，而继续传递。小写字母实际上也是如此：它用于表示QBIC和QBasic中的数字变量，并且保持不变。因此，使用未在QBIC中实现的QBasic功能（如SLEEP）仅是不使用QBIC保留字符的问题。使用命令符号中的最新更改使此操作变得更容易。

— 施滕伯格
source
4

JavaScript，77 76 72字节

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

感谢Kritixi Lithos提供1个字节，L。Serne提供4个字节！

— binazy010
source
1000可以缩短为1e3
— Kritixi Lithos'1
2
setInterval并setTimeout接受带有代码的字符串作为第一个参数，因此您可以保存另一个4B：setInterval('l=console.log,l("12:00"),setTimeout("l(-：)",500)',1e3)
— Luke
该`有什么恶意，这是现在ES6，而以前的答案只需要ES5。
— 尼尔
4

Python 2 88 85 73 71个字节

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

在这里尝试！

通过借用Stewie Griffin的想法，该程序成为可能。非高尔夫版本，并附有说明：

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

感谢@FlipTack保存14个字节！

— 安东尼·范
source
1
您可以使用字符串切片来打短它，例如
— FlipTack
4

PHP，51 50 47

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

由于操作而节省了1个字节，此处的insertusername保存了另外3个字节。谢谢！

— 克里斯多夫
source
1
如果将usleep(5e5)调用移至for的第3个参数，则,不需要使用分隔符，从而节省了1个字符。
— manatwork'1
@manatwork谢谢！while(1)起初我有。
— 克里斯多夫（Christoph）
2
您可以再保存3个字节：删除和之间的空白echo，$i并\n用实际的换行符替换。
— insertusername此处
@insertusernamehere即使在打高尔夫球也很伤我的眼睛：D但嘿，它有效。
— 克里斯多夫（Christoph）
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尝试检查条件时将其状态反转。

— 布苏轩
source
将.d5放在循环的最前面，并删除结尾的引号
— Maltysen
3

红宝石，47 42字节

还没有红宝石的答案，所以这是我的第一次尝试：

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

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.

在线尝试！

— 齐柏林飞艇
source
3

dc（bash），37个字节

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

通过将两个字符串“ 12:00”和“-：-”压入堆栈，然后重复交换值，在堆栈顶部打印该项目，然后休眠半秒钟，可以实现此目的。

要运行此程序，可以将其保存在文件中，然后键入

直流文件名

或者您可以通过输入以下内容直接从bash命令行运行它

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

— 米切尔·斯佩克特
source
3

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*
— 布拉德·吉尔伯特b2gills
source
使用for循环可以使其更短：for |<12:00 --:-->xx* {sleep .5;.say}
— smls
如果您利用say返回1 的事实，sleep .say/2 for |<12:00 --:-->xx*
— 则更
2

果冻，22个字节

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

在TIO上不起作用。让Jelly与QPython3一起在Android上运行也是一种有趣的体验。

说明

®‘©ị“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.
— PurkkaKoodari
source
1
睡了吗 您能补充说明吗？
— steenbergh
1
@steenbergh添加了。抱歉，延迟，对于使用非等宽字体的SE应用程序，编辑这些缩进以进行解释有些困难。
— PurkkaKoodari
2

Mathematica，38个字节

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

说明

Clock[]

输出一个时钟变量，该变量连续每秒从0循环到1。

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

如果时钟变量大于.5，则输出“ 12:00”。如果不是，则输出“-：-”。

Dynamic@ ...

使程序动态化（不断更新）

— 郑焕民
source
2

Javascript，57 55

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

ETHproductions节省了2个字节

— 克里斯多夫
source
3
你可以节省一些字节，setInterval(...,i=500):-)
— ETHproductions
2

后记225 214

只是为了好玩！不要将此发送到真正的打印机！！

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

试试吧：

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

要么

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

然后

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

但是，请勿尝试使用更复杂的查看器打开此窗口，而不必担心桌面缩略图！

— 豪里
source
如果gs -c '...'命令提示出现白页，则可能必须增大显示窗口或使用较小的分辨率：gs -r45 -c '...'或较小的纸张尺寸gs -r600 -g360x200 -c '...'
— F. Hauri
2

使用Javascript（在浏览器），174 160 159 122 112 111 109 107 66（91）个字节

我已经接受了，pre因为使用单型字体不是要求的一部分，所以我的新计数是66。添加了一些字符以使用等宽字体，但是由于这不是必需的，因此我不会再计算这25个字符。

感谢ETHproductions节省了14个字节，

致Kritixi Lithos保存1个字节，

到manatwork用于保存1个 3字节，

以克里斯托夫保存两个字节

我自己使用[..][b^=1]而不是setTimeout... 节省了37个字节，并用function(){..}双引号替换了10 个字节...

setInterval("document.body.innerHTML=++b%2?'12:00':'--:--'",b=500)
body{font-family:Courier}
展开摘要

... 更差：

从66到更多 ...

...但是出于娱乐目的，本着闪烁的精神：

SVG="http://www.w3.org/2000/svg";XLNK="http://www.w3.org/1999/xlink";
s=["1200","----"];p=0;function d(n){for(i=n.length;i>0;i--) {
  document.getElementById('n'+i).setAttribute('class','n'+n[i-1])}
  document.getElementById('sz').setAttribute('class','n'+n[0])}
setInterval("p=1-p;d(s[p])",500);
#svg2 { --c: #FF6;stroke:#432;stroke-width:12;stroke-linecap:round;stroke-linejoin:round; stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none; } path.b { fill:#543;stroke:none; } .blue     { --c: #68F; } .green    { --c: #6F8; } .red      { --c: #F88; } .dec rect  { stroke: var(--c); } .n1 #B { stroke: var(--c); }  .n1 #C { stroke: var(--c); } .n2 #A { stroke: var(--c); }  .n2 #B { stroke: var(--c); } .n2 #D { stroke: var(--c); }  .n2 #E { stroke: var(--c); } .n2 #G { stroke: var(--c); }  .n3 #A { stroke: var(--c); } .n3 #B { stroke: var(--c); }  .n3 #C { stroke: var(--c); } .n3 #D { stroke: var(--c); }  .n3 #G { stroke: var(--c); } .n4 #B { stroke: var(--c); }  .n4 #C { stroke: var(--c); } .n4 #F { stroke: var(--c); }  .n4 #G { stroke: var(--c); } .n5 #A { stroke: var(--c); }  .n5 #C { stroke: var(--c); } .n5 #D { stroke: var(--c); }  .n5 #F { stroke: var(--c); } .n5 #G { stroke: var(--c); } .n6 #A { stroke: var(--c); }  .n6 #C { stroke: var(--c); } .n6 #D { stroke: var(--c); }  .n6 #E { stroke: var(--c); } .n6 #F { stroke: var(--c); }  .n6 #G { stroke: var(--c); } .n7 #A { stroke: var(--c); }  .n7 #B { stroke: var(--c); } .n7 #C { stroke: var(--c); } .n8 #A { stroke: var(--c); }  .n8 #B { stroke: var(--c); } .n8 #C { stroke: var(--c); }  .n8 #D { stroke: var(--c); } .n8 #E { stroke: var(--c); }  .n8 #F { stroke: var(--c); } .n8 #G { stroke: var(--c); } .n9 #A { stroke: var(--c); }  .n9 #B { stroke: var(--c); } .n9 #C { stroke: var(--c); }  .n9 #D { stroke: var(--c); } .n9 #F { stroke: var(--c); }  .n9 #G { stroke: var(--c); } .n0 #A { stroke: var(--c); }  .n0 #B { stroke: var(--c); } .n0 #C { stroke: var(--c); }  .n0 #D { stroke: var(--c); } .n0 #E { stroke: var(--c); }  .n0 #F { stroke: var(--c); } .n11 #B { stroke: var(--c); } .n11 #C { stroke: var(--c); } .n11 #E { stroke: var(--c); } .n11 #F { stroke: var(--c); } .nA #A { stroke: var(--c); }  .nA #B { stroke: var(--c); } .nA #C { stroke: var(--c); }  .nA #E { stroke: var(--c); } .nA #F { stroke: var(--c); }  .nA #G { stroke: var(--c); } .nB #C { stroke: var(--c); }  .nB #D { stroke: var(--c); } .nB #E { stroke: var(--c); }  .nB #F { stroke: var(--c); } .nB #G { stroke: var(--c); } .nC #A { stroke: var(--c); }  .nC #D { stroke: var(--c); } .nC #E { stroke: var(--c); }  .nC #F { stroke: var(--c); } .nD #B { stroke: var(--c); }  .nD #C { stroke: var(--c); } .nD #D { stroke: var(--c); }  .nD #E { stroke: var(--c); } .nD #G { stroke: var(--c); } .nE #A { stroke: var(--c); }  .nE #D { stroke: var(--c); } .nE #E { stroke: var(--c); }  .nE #F { stroke: var(--c); } .nE #G { stroke: var(--c); } .nF #A { stroke: var(--c); }  .nF #E { stroke: var(--c); } .nF #F { stroke: var(--c); }  .nF #G { stroke: var(--c); } .nR #E { stroke: var(--c); }  .nR #G { stroke: var(--c); } .nO #C { stroke: var(--c); }  .nO #D { stroke: var(--c); } .nO #E { stroke: var(--c); }  .nO #G { stroke: var(--c); } .n- #G { stroke: var(--c); }  .n1 #y { stroke: var(--c); } .n1 #z { stroke: var(--c); }
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<svg xmlns="http://www.w3.org/2000/svg" version="1.1" width="100%" height="100%" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 645 230" id="svg2"> <defs id="dfs4"><g id="n"><path d="M 15,5 155,5 145,225 5,225 z" class="b"/> <path id="A" d="M 45,15 125, 15"/><path id="B" d="M 135,25 125,105"/><path id="C" d="M 125,125 115,205"/><path id="D" d="M 25,215 105,215"/><path id="E" d="M 25,125 15,205"/><path id="F" d="M 35,25 25,105"/><path id="G" d="M 35,115 115,115"/><rect id="P" width="5" height="5" ry="2.5" x="130" y="205"/></g><g id="s"><path d="M 10,5 35,5 25,225 0,225 z" id="a" class="b"/><rect id="y" width="5" height="5" ry="2.5" x="13.5" y="145"/><rect id="z" width="5" x="17" height="5" ry="2.5" y="75"/></g></defs><use id="n1" xlink:href="#n" /><use id="n2" xlink:href="#n" transform="translate(150,0)" /><use xlink:href="#s" id="sz" transform="translate(305,0)"/><use id="n3" transform="translate(335,0)" xlink:href="#n" /><use id="n4" xlink:href="#n" transform="translate(485,0)" />
</svg>
展开摘要

— 豪里
source
1
1000可以成为1e3
— Kritixi Lithos
1
您可以删除所有实例来节省大量字节window.；window.setTimeout与相同setTimeout。
— ETHproductions'1
1
tt短于pre并且还暗示使用等宽字体。（只是它是内联元素，而不是块，但这在这里没有什么区别。）b=document.body.append(a=document.createElement('tt'))
— manatwork
1
d=document;d.body.append(a=d.createElement('tt'));setInterval("a.innerHTML=++b%2?'12:00':'--:--'",b=500)保存5个字节
— Christoph'1
1
是否有生成元素的理由？setInterval("document.body.innerHTML=++b%2?'12:00':'--:--'",b=500)仅落后于花哨的等宽字符，但只有66个字节。
— 克里斯多夫（Christoph）
2

QuickBASIC，167个（美味）

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

反正我永远也不会赢。QB没有floor（），也没有为x睡眠的功能毫秒。因此，这可以通过抓住TIMER的浮点部分来实现（返回自午夜以来经过的秒数，再加上当前秒的一部分，用两位十进制表示）。然后，我们在其周围添加一个“ 50单位”循环，以确定何时将相位从“-：-”切换到“ 12:00”，并使用原始的TIMER十进制表示从“ 12:00”切换至 ” - ： - ”。

最后，即使运行在QB4.5中的标准程序，在功能强大的计算机上的DOSBox中也会跳动。那是因为QB确实不够快，无法在我们正在进行比较的MS内部执行DO-LOOP和评估。将需要FUTURE！

无论如何，我现在看起来是100岁，我让每位美国大学学生感到高兴，因为他们很可能为自己的Comp Sci课程提供了答案-因为他们仍在教这门课...

— 罗伯特·勒纳
source
您可以删除一些空格吗？即b% = b% - 99到b%=b%-99？
— Rɪᴋᴇʀ
是的，我很确定可以，但是我使用了原始的IDE，在您按了行末的回车键之后，会将它们重新添加进去。我必须在DOS的IDE外部对其进行编辑，然后找出链接器/编译器的参数，以检查我的解决方案是否仍然有效……因此它可以更短一些，但不在我的努力范围之内。
— 罗伯特·勒纳
好吧，您需要使用此密码，否则它不是有效答案，将被删除。对于那个很抱歉。（我完全明白你的意思，但社会作为一个整体已决定对非golfed答案）
— Rɪᴋᴇʀ
好点，我将删除空格。
— 罗伯特·勒纳
2

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
— 致癌物质
source
2

Pushy，22字节（非竞争）

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

这个答案利用了两个堆栈，方法是在两个堆栈之间进行翻转，依次打印字符：

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

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

该oW命令是一组在挑战之后发布的实验性命令的一部分，从而使该答案不具有竞争力。

— FlipTack
source
2

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.
— Macky Clemen
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.