Viele elektronische Geräte, insbesondere alte, blinken, 12:00wenn die Uhrzeit nicht eingestellt wurde. Der Zweck dieser Herausforderung besteht darin, dies nachzubilden.

Insbesondere besteht die Aufgabe darin, und alternativ in einer Endlosschleife anzuzeigen12:00--:-- .

Die Periode sollte 1 Sekunde betragen, gleichmäßig aufgeteilt in zwei Perioden von 0,5 Sekunden. Hier können "1 Sekunde" und "gleichmäßig" lose interpretiert werden. Beispielsweise ist es akzeptabel, wenn der Code zwischen dem Anzeigen der Zeichenfolgen 0,5 Sekunden lang angehalten wird, auch wenn die resultierende Zeitspanne dann etwas höher als 1 Sekunde ist. Eine anfängliche Pause vor dem Anzeigen der ersten Zeichenfolge ist zulässig.

Jede neue Zeichenfolge kann entweder durch Ersetzen der vorherigen Zeichenfolge oder in einer neuen Zeile angezeigt werden . Nachgestellte Leerzeichen sind zulässig, außer wenn sich jede neue Zeichenfolge in einer anderen Zeile befindet, dürfen zwischen aufeinanderfolgenden Zeichenfolgen keine Leerzeilen sein.

Kürzester Code in Bytes gewinnt.

Gelee , 20 Bytes

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

Wie es funktioniert

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

Bearbeiten: 23 Bytes dank @insertusernamehere gespeichert. 1 Byte durch Umschalten von <pre>auf gespeichert <tt>. 2 Bytes dank @darrylyeo gespart. 5 Bytes gespart dank @DBS.

Shell und pv26 Bytes

Verwenden Sie das yesStandardwerkzeug und das pv Shell-Pipeline-Element, um die durchlaufenden Daten zu messen

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

Python2, 80 75 73 69 67 66 Bytes

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

Ich bemerkte, dass meine Saitenmagie etwas länger dauerte als das Auswählen der Saite aus einem Array. Vergiss es, habe es herausgefunden.

Erklärung :

• Ich setze einen Zähler n auf 0, der zwischen 0 und 1 umgeschaltet wird.

• Ich schleife endlos mit der Schleife while 1.

• Ich erstelle eine Zeichenfolge 1-2-::0-0-, die die Zeichenfolge enthält 12:00und --:--überlappt.

  • Ausgehend vom Index 0 mit einem Schritt von 2 erhalten wir: 12:00

  • Ausgehend vom Index 1 mit einem Schritt von 2 erhalten wir: --:--

• Ich verwende n , um die wiederholte Sequenz 0 , 1 , 0 , 1 , 0 ... zu erstellen, die den Startindex der Zeichenfolge darstellt.

  • Mit n^=1, in jeder Schleife, erhalten wir diese Sequenz. ^der XOR-Operator sein.
  • Wenn n == 0 -> n^=1ergibt 1
  • Wenn n == 1 -> n^=1ergibt sich 0
• Ich drucke den String und schlafe ( .5-> 0.5) Sekunden.

@FlipTack hat 4 Bytes gespart! -> Setzen Sie die Schleife in eine Zeile.

@ Rod sparte 2 Bytes! -> n+=1auf n^=1, so n%2zu n.

@xnor hat ein Byte gespeichert! -> while 1-> while[time.sleep(.5)].

Oktave, 63 62 61 55 Bytes

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

Zwei Bytes gespart dank Tom Carpenter! Die Verwendung einer einzelnen Zeichenfolge anstelle von zwei Zeichenfolgen in einem Zellenarray war kürzer.

Erläuterung:

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

Ein paar Bytes gespart, da für Octave kein Doppelpunkt oder Semikolon zwischen flip(c)und disp()und zwischen pause(.5)und erforderlich ist end.

JavaScript, 59 Bytes

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

Erläuterung

setInterval('...',500) Legt ein Intervall fest, in dem Code in der Zeichenfolge alle 500 Millisekunden oder 1/2 Sekunde ausgeführt wird.

y=1Setzt eine Variable y,, anfangs auf 1. Auf diese Weise wird zuerst gedruckt, 12:00weil yauf das Array zugegriffen wird.

console.log(...)protokolliert alles an der Konsole, entweder in diesem 12:00oder --:--.

["12:00","--:--"][y^=1]Erstellt ein Array mit Zeichenfolgen, die beide Status enthalten. Dann ywird verwendet, um auf eines der Elemente zuzugreifen. Schließlich ^=oder XOR-Verbundoperator y = y ^ 1. Dies invertiert nur das Bit, weil 1 ^ 1es 0 und 0 ^ 11 ist, ähnlich wie @TuukkaX . Auf diese Weise wechselt die protokollierte Zeichenfolge zwischen den beiden Elementen im Array und erzeugt so den Blinkeffekt.

V , 31 30 27 25 24 Bytes

Gespeichert 5 Byte dank @ nmjcman101 durch die Reihenfolge der Austausch 12:00und --:--damit kkann jeder durch das Entfernen entfernt werden , òso dass es am Ende implizit hinzugefügt werden könnten

Dank @DJMcMayhem 1 Byte gespart, indem beide 12:00und --:--eine Zeile eingefügt wurden

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

Alte Lösung:

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

<ESC> ist 0x1b

Hexdump:

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

Erläuterung

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

Hinweis: Ich habe die Hervorhebung aktiviert

Bash, 58 56 45 Bytes

3 byte durch unterdrücken von --after setals 1. arg wird eine nummer gespeichert .

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

Mit der @DigitalTrauma -Syntax 16 Byte gespeichert :

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

Dann 5 Bytes wegen Zeppelins Kommentar verlieren .

Dies konnte auf der Kommandozeile nicht getestet werden. Da wir involvieren $0, muss dies in ein Skript geschrieben werden, um ausgeführt zu werden.

Umleiten

Mit ein wenig Vorbereitung könnte dies schön werden ( 412 Bytes ):

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

Oder gleich zwei Zeilen aber mit:

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 Bytes

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

Perl sleepkann nicht schlafen Dauer brüllt 1 sec, also die Verwendung von select undef, undef, undef, .5(golfed durch Ersetzen undefmit $,) in dem Schlaf 0,5 Sekunden.
Andere interessante Sache: $|kann nur halten 0oder 1. $|--Schaltet also einfach seinen Wert von 0auf um 1.
Und schließlich {... ;redo}verhält sich wie eine Endlosschleife.

*> <> , 43 42 Bytes

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

Probieren Sie es hier aus!

Ich habe das Gefühl, ich könnte das verkürzen, ich habe ein paar Ideen zum Ausprobieren ... Im Grunde genommen macht das einen Stapel aus :1200----. Sie isoliert den :Stapel und dreht ihn um, indem sie ihn :in die Mitte von entweder ----oder 1200(je nachdem, was sich am Ende des Stapels befindet) einfügt .

Ich sollte auch beachten, dass die einzige *> <> Anweisung, die hier verwendet wird, S(sleep) ist, andernfalls handelt es sich um ein richtiges> <> Programm.

Update: 1 Byte durch Verschieben :nach rechts gespeichert, anstatt es mit einem Register zu schützen.

Erläuterung

Initialisierung

<v":1200----"

Hier bauen wir den Stack auf, den wir für die gesamte Laufzeit des Programms verwenden werden.

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

Ausgabezeit

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

Dies ist der Bereich, in dem die Uhrzeit tatsächlich ausgegeben wird. Die ersten 5 werden auf den Stapel geschoben, sodass die folgende Schleife 5-mal ausgeführt werden kann.

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"

Erholen und tauschen

S      >~r@@}r5

Hier erholen wir uns :von der Position, die es nach der Ausgabe ergibt, und wir erhalten einen umgekehrten Stapel. Dies führt tatsächlich zu einer "Ausgabezeit", was zu einer Endlosschleife führt.

       >         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-Byte-Lösung

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

Probieren Sie es hier aus!

Dies ist auch im Grunde ein> <> Programm.

Ich dachte wirklich, mit diesem Ansatz könnten einige Bytes eingespart werden. Das gibt 12:00man dann ganz einfach aus --:--. Ich spare Bytes, indem ich die Ausgaberoutine wieder verwende o/!?l(ich verwende diesen Spiegel sogar als Ein- und Ausgang). Ich verwende mehrere Stapel, um den Status (hat Ausgabe 12oder --) zu speichern , und wähle aus, mit welchem ​​Status ich ausgeben soll v>]?v.

^{Erklärungen folgen in Kürze! (1/2)}

HTML / CSS (nur Chrome), 80 + 4 = 84 Byte

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

<tt>

Bearbeiten : Das Attribut "Inhalt" kann von der CSS-Spezifikation nicht animiert werden , befindet sich jedoch im Chrome-Desktopbrowser.

Noodel , nicht konkurrierende 16 Bytes

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

Noodel ist noch in Arbeit. Ich versuche nur, meine Füße mit ein paar Herausforderungen nass zu machen.

Versuch es:)

Wie es funktioniert

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

Hier ist ein Codeausschnitt :)

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

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

QBasic kann leider nur ganze Sekunden schlafen. Ich werde eine Methode entwickeln, die bald mehr Flexibilität ermöglicht. Ich habe 1 eingegeben 01, um zu simulieren .5.

Erläuterung:

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

In älteren Versionen von QBIC $und (Leerzeichen) waren Zeichen reserviert. Das Aufrufen einer QBasic-Funktion, die Leerzeichen (wie sleep x) oder $( left$(..)) benötigte, erforderte ein Codeliteral:

'QBASIC CODE`

Code in einem Codeliteralblock wird direkt an QBasic übergeben, ohne von QBIC analysiert zu werden. Durch das Auslagern von Funktionen aus diesen Symbolen ( $wurden 'und Zeilenumbrüche werden jetzt ┘(alt-217) statt ) werden die Symbole von QBIC nicht mehr als Sonderzeichen angesehen und einfach weitergegeben. Dasselbe gilt für das Kleinbuchstaben: Es wird zur Darstellung numerischer Variablen in QBIC und QBasic verwendet und bleibt unverändert. Die Verwendung von QBasic-Funktionen, die nicht in QBIC (wie SLEEP) implementiert sind, bedeutet lediglich, dass QBIC-reservierte Zeichen nicht verwendet werden. Dies wird durch die jüngsten Änderungen in den Befehlssymbolen erleichtert.

JavaScript, 77 76 72 Bytes

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

Vielen Dank an Kritixi Lithos für 1 Byte und L. Serne für 4 Byte!

Python 2, 88 85 73 71 Bytes

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

Probieren Sie es hier aus!

Durch die Ausleihe von Stewie Griffins Idee , die Liste umzudrehen, wurde das Programm ermöglicht. Ungolfed Version mit Erklärung:

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

Danke @FlipTack für das Speichern von 14 Bytes!

PHP, 51 50 47

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

1 Byte wegen manatwork gespeichert und weitere 3 von insertusernamehere gespeichert. Vielen Dank!

Pyth, 23 Bytes

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

Im Pseudocode:

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

Verwendet die vorinitialisierte Variable Zals Flip-Flop und kehrt ihren Zustand jedes Mal ifum, wenn versucht wird, die Bedingung zu überprüfen.

Rubin, 47 42 Bytes

Noch keine Ruby-Antwort. Hier ist mein erster Versuch:

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

GNU sed, 39 Bytes

EDITS:

• Swap Sleep und i12: 00 (damit der Quellcode ein bisschen besser aussieht)

Golf gespielt

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

Erklärt

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.

Probieren Sie es online!

DC (Bash), 37 Bytes

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

Dies funktioniert, indem Sie die beiden Zeichenfolgen "12:00" und "-: -" auf dem Stapel drücken und dann wiederholt die Werte austauschen, das Element oben auf dem Stapel drucken und eine halbe Sekunde schlafen.

Um dies auszuführen, können Sie es in einer Datei speichern und dann eingeben

dc dateiname

oder Sie können es direkt über die Bash-Befehlszeile ausführen, indem Sie Folgendes eingeben

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

Perl 6 ,  48 41  34 Bytes

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

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

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

Jelly, 22 Bytes

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

Funktioniert nicht mit TIO. Es hat auch Spaß gemacht, Jelly mit QPython3 auf Android zum Laufen zu bringen.

Erläuterung

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

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

Erläuterung

Clock[]

Gibt eine Taktvariable aus, die kontinuierlich jede Sekunde von 0 auf 1 wechselt.

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

Wenn die Taktvariable größer als 0,5 ist, geben Sie "12:00" aus. Wenn nicht, geben Sie "-: -" aus.

Dynamic@ ...

Dynamisierung des Programms (ständige Aktualisierung)

Javascript, 57 55

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

Dank ETHproductions 2 Bytes gespart

Postscript 225 214

Nur zum Spaß! Senden Sie dies nicht an einen echten Drucker!

/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

Versuch es:

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'

oder

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

dann

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

Versuchen Sie jedoch nicht, dies mit einem anspruchsvolleren Viewer zu öffnen, und kümmern Sie sich um Desktop-Thumbnails!

Javascript (im Browser), 174 160 159 122 112 111 109 107 66 (91) Bytes

Ich habe von genommen, preweil die Verwendung von monotypisierten Schriftarten nicht Teil der Anforderung ist, sodass meine neue Anzahl 66 ist . Einige Zeichen werden hinzugefügt, um monospaced Schrift zu verwenden, aber da dies nicht benötigt wird, zähle ich diese 25 Zeichen nicht mehr.

Dank ETHproductions für die Einsparung von 14 Bytes,

zu Kritixi Lithos für das Speichern von 1 Byte,

Manatwork für das Speichern von 1 3 Byte,

an Christoph für das Speichern von zwei weiteren Bytes und

mir selbst für das Speichern von 37 Bytes durch Verwenden von [..][b^=1]anstelle von setTimeout... und 10 weitere durch Ersetzen function(){..}durch doppelte Anführungszeichen ...

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

body{font-family:Courier}

... schlechter:

Von 66 bis etwas mehr ...

... aber zum Spaß, im Geiste eines blinkenden Displays:

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

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

Ich würde sowieso nie gewinnen. QB hat keine Etage () und hat auch keine Funktion, um für x Millisekunden zu schlafen . Dies funktioniert also, indem der Gleitkomma-Teil des TIMERS abgerufen wird (gibt die seit Mitternacht verstrichenen Sekunden plus einen Bruchteil der aktuellen Sekunde, ausgedrückt als zweistellige Dezimalzahl, zurück). Wir fügen dann eine Schleife um "50 Einheiten" hinzu, um zu bestimmen, wann die Phase von "-: -" auf "12:00" wechseln soll, und verwenden die ursprüngliche TIMER-Dezimalzahl für die Umschaltung von "12:00". zu "-: -".

Selbst wenn dies in QB4.5 ausgeführt wird, werden in DOSBox auf einem relativ leistungsfähigen Computer keine Beats ausgegeben. Das liegt daran, dass QB nicht schnell genug ist, um den DO-LOOP und die Auswertungen in der MS durchzuführen, in der wir den Vergleich durchführen. Benötigen Sie eine Box aus der ZUKUNFT!

Wie auch immer, ich sehe jetzt 100 aus und ich habe jeden amerikanischen Studenten glücklich gemacht, da sie wahrscheinlich eine Antwort auf ihre Comp Sci-Klasse haben - da sie dies immer noch unterrichten ...

Clojure, 79 62 Bytes

V2

-17 Bytes durch Wechseln von einer schrecklichen Indizierungsschleife zu einer Schleife über eine unendliche Liste.

Erstellt eine unendliche Liste von Nachrichten "12:00"und "--:--"wiederholt diese doseqständig. Anschließend wird die nächste Nachricht ständig abgerufen und gedruckt.

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

Ich konnte mir keine gute Möglichkeit vorstellen, die Konstanten "12:00" und "-: -" zu komprimieren, daher musste ich sie nur hart codieren.

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

Pushy , 22 Bytes (nicht konkurrierend)

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

In dieser Antwort werden die beiden Stapel verwendet, indem die Zeichen der Reihe nach gedruckt werden:

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

Der oWBefehl ist Teil einer Reihe von experimentellen Befehlen, die die Herausforderung nachdatieren und diese Antwort nicht konkurrieren lassen.

Windows PowerShell, 46 55 Bytes

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

Ursprünglicher Code:

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