Parpadeando doce

43

Muchos dispositivos electrónicos, especialmente los antiguos, mostrarán un parpadeo 12:00cuando no se haya configurado el tiempo. El propósito de este desafío es recrear esto.

Específicamente, la tarea es mostrar 12:00y, --:--alternativamente, en un bucle infinito .

El período debe ser de 1 segundo, dividido equitativamente en dos períodos de 0,5 segundos. Aquí "1 segundo" y "uniformemente" se pueden interpretar libremente. Por ejemplo, es aceptable si el código se detiene durante 0,5 segundos entre la visualización de las cadenas, incluso si el período resultante será un poco más alto que 1 segundo. Una pausa inicial antes de mostrar la primera cadena es aceptable.

Cada nueva cadena se puede mostrar reemplazando la cadena anterior o en una nueva línea . Se permite el espacio en blanco al final, excepto que si cada nueva cadena está en una línea diferente, no debería haber líneas vacías entre cadenas consecutivas.

El código más corto en bytes gana.

Luis Mendo
fuente
1
¿esto cuenta como complejidad kolmogorov ?
FlipTack
@FlipTack Creo que sí, pero no estaba seguro. Pensamientos, alguien?
Luis Mendo
@LuisMendo No lo creo, creo que la etiqueta KG es principalmente para una cadena fija. Esto tiene más que ver, las cuerdas de espera y alterna.
Rɪᴋᴇʀ
¿Pueden los envíos esperar 0.5 segundos antes de mostrar la salida inicial?
FlipTack
1
En mi humilde opinión, la afirmación "Cada nueva cadena se puede mostrar reemplazando la cadena anterior o en una nueva línea" hizo que este desafío no fuera divertido.
Setop

Respuestas:

4

Jalea , 20 bytes

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

Cómo funciona

.“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.
Dennis
fuente
Entonces, ¿básicamente estás convirtiendo ambas cadenas de la lista en enlaces propios, con un comando de suspensión agregado? Dulce.
steenbergh
32

HTML / CSS, 131 108 106 101 + 18 17 = 149 126 125 123 118 bytes

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

Editar: Guardado 23 bytes gracias a @insertusernamehere. Se guardó 1 byte al cambiar de <pre>a <tt>. Guardado 2 bytes gracias a @darrylyeo. Guardado 5 bytes gracias a @DBS.

Neil
fuente
1
@insertusernamehere Bah, jugué golf a{position:absolute}pero olvidé por completo el pre...
Neil
¿Todavía necesitas la etiqueta previa? el css solo menciona a.
ev3commander
@ ev3commander He guardado un byte al cambiar a <tt>.
Neil
Puedes eliminar el final por }}completo.
darrylyeo
Creo que debería ser capaz de simplificar margin-leftal marginpuesto que está trabajando desde la parte superior izquierda de todas formas margin:-5ch;debe tener el mismo efecto.
DBS
15

Shell y pv26 bytes

Esto utiliza yesuna herramienta estándar y un pv elemento de tubería de Shell para medir los datos que pasan

yes '12:00
--:--'|pv -qlL2
F. Hauri
fuente
2
Buena solución, pero el lenguaje probablemente debería expresarse como "Shell y pv", ya que (que yo sepa de todos modos) pv no está incluido en ningún shell ni es parte de las utilidades centrales de GNU o BSD.
Mitchell Spector
1
Ese es un buen truco! (que creo que fue pionera de @Digital Trauma aquí ). Aunque en este caso se siente un poco en contra del espíritu del desafío, ya que la declaración de la misión era "mostrar 12:00 y -: - alternativamente" (imitando una pantalla parpadeante), pero este código solo se emitirá carácter por carácter en su lugar, a una velocidad constante de 12 caracteres por segundo. Lo que significa que "12:00" permanecerá en la pantalla solo durante 1/12 (0.08) segundos ("12: 0 _" = 1 / 12s => "12:00" = 2 / 12s => "-").
zepelín
@zeppelin gracias por las referencias: he usado la muestra de @ DigitalTrauma -qlL2para hacer 2 líneas por segundo en lugar de -qL12: 12 caracteres por segundo. La longitud del guión es la misma
F. Hauri
15

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

Noté que mi magia de cuerdas se hizo un poco más larga que elegir la cuerda de una matriz. No te preocupes, ya lo resolví.

Explicacion :

  • Establecí un contador n a 0, que se alternará entre 0 y 1.

  • Bucle sin fin con el bucle while 1.

  • Creo una cadena 1-2-::0-0-, que contiene la cadena 12:00y se --:--superpone.

    • Comenzando desde el índice 0 con un paso de 2, obtenemos: 12:00

    • Comenzando desde el índice 1 con un paso de 2, obtenemos: --:--

  • Utilizo n para hacer la secuencia repetida 0 , 1 , 0 , 1 , 0 ... que será el índice inicial de la cadena.

    • Usando n^=1, en cada bucle, obtenemos esa secuencia. ^siendo el operador XOR.
    • Si n == 0 -> n^=1resulta en 1
    • Si n == 1 -> n^=1da como resultado 0
  • Imprimo la cadena y duermo ( .5-> 0.5) segundos.

¡@FlipTack ahorró 4 bytes! -> Pon el lazo en una línea.

¡@Rod ahorró 2 bytes! -> n+=1a n^=1, así n%2a n.

@xnor guardó un byte! -> while 1-> while[time.sleep(.5)].

Yytsi
fuente
77
puede reemplazar n+=1con n^=1, y luego usar [n::2], guarda 2 bytes y evita números grandes c:
Rod
44
si cambia el print"1-2-::0-0-"[n::2]que print"\b"*6+"1-2-::0-0-"[n::2],se va a añadir unos cuantos bytes pero va a parpadear en su lugar
zumbido
1
@Buzz que puede usar en \rlugar de \b\b\b...moverse al comienzo de la línea. Pero de todos modos, esto solo agregaría bytes a la solución actual.
FlipTack
Puede guardar un byte haciendo while[time.sleep(.5)]:.
xnor
@xnor Estaba tan seguro, que esto no se podía jugar más. Este sitio me sigue sorprendiendo. ¡Gracias!
Yytsi
15

Octava, 63 62 61 55 bytes

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

¡Ahorré dos bytes gracias a Tom Carpenter! Usar una sola cadena en lugar de dos cadenas en una matriz de celdas fue más corto.

Explicación:

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

Se guardaron algunos bytes porque Octave no requiere dos puntos o punto flip(c)y coma entre y disp(), y entre pause(.5)y end.

Stewie Griffin
fuente
1
Buena idea para usar en fliplugar de un contador!
Luis Mendo
11

JavaScript, 59 bytes

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

Explicación

setInterval('...',500) establece un intervalo para ejecutar código en la cadena cada 500 milisegundos, o 1/2 por segundo.

y=1establece una variable,, ya 1 inicialmente. De esa manera, lo primero que se imprime es 12:00porque yse usa para acceder a la matriz.

console.log(...)registra lo que sea en la consola, en este 12:00o --:--.

["12:00","--:--"][y^=1]crea una matriz con cadenas que contienen ambos estados. Luego, yse utiliza para acceder a uno de los elementos. Finalmente, ^=o el operador compuesto XOR lo hace y = y ^ 1. Esto simplemente invierte el bit porque 1 ^ 1es 0 y 0 ^ 1es 1, similar a lo que hizo @TuukkaX . De esta manera, la cadena registrada alterna entre los dos elementos en la matriz y, por lo tanto, crea el efecto de parpadeo.

Andrew Li
fuente
y=1;setInterval('console.log(y?"12:00":"--:--");y=!y',500)
Pude
ETHproductions punta en mi respuesta: You can save some bytes with setInterval(...,i=500) :-). Básicamente tenemos la misma respuesta y también funciona para la suya.
Christoph
11

V , 31 30 27 25 24 bytes

Ahorró 5 bytes gracias a @ nmjcman101 intercambiando el orden de 12:00y --:--para que kpueda eliminarse eliminando òpara que pueda agregarse implícitamente al final

Guardado 1 byte gracias a @DJMcMayhem al poner ambos 12:00y --:--en una línea

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

Antigua solución:

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

<ESC> es 0x1b

Hexdump:

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

Explicación

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

Nota: tengo resaltado activado

giff

Kritixi Lithos
fuente
77
Tomaste el parpadeo literalmente en ese gif :-)
Luis Mendo
El segundo òse da implícitamente, por lo que puede eliminarlo.
DJMcMayhem
@DJMcMayhem It, por alguna razón, no funciona sin el segundo ò. Solo se ejecuta una vez
Kritixi Lithos
2
Cambie el orden de sus entradas para que no necesite la primera k. Luego, en lugar de pkddsolo puede usar Vp, ya que pen el modo de selección visual intercambia efectivamente la selección con el registro predeterminado.
nmjcman101
1
Sé que tiene problemas para eliminar el ò, pero si eso funciona ahora, creo que debería poder cambiarlo òVp:sl500my dejar que V agregue el ^Mòde 2 bytes.
nmjcman101
11

bash, 58 56 45 bytes

guardado 3 bytes al suprimir --después setya que 1st arg es un número.

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

Guardado 16 bytes usando la sintaxis de @DigitalTrauma :

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

Luego perdiendo 5 bytes debido al comentario de zeppelin .

Esto no se pudo probar en la línea de comando. Como involucramos $0, esto debe escribirse en un script para ejecutarse.

Desviar

Con un poco de preparación, esto podría ser bueno ( 412 bytes ):

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

O incluso las mismas dos líneas pero con:

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|                                      
                                                                               '
F. Hauri
fuente
3
s(){ echo $1;sleep .5;};for((;;)){ s 12:00;s --:--;}
manatwork el
2
@manatwork Nice! ¡Creo que no es el mismo guión! ¡Tienes que publicarlos como respuesta!
F. Hauri
Tengo que admitir que el arte ASCII es absolutamente hermoso ... ¿Usaste una herramienta para crearlo o lo hiciste a mano?
ETHproductions
2
@ETHproductions Uso 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
... of()(echo $1;sleep .5);f 12:00;f --:--;$0
Trauma digital el
9

Perl, 49 bytes

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

Perl sleepno puede dormir por menos de 1 segundo, de ahí el uso de select undef, undef, undef, .5(golf reemplazado undefpor $,) para dormir .5 segundos.
Otra cosa interesante: $|solo puede contener 0o 1. Entonces $|--solo alterna su valor, de 0a 1.
Y finalmente, {... ;redo}actúa como un bucle infinito.

Dada
fuente
6

*> <> , 43 42 bytes

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

Pruébalo aquí!

Siento que debería poder hacer esto más corto, tengo un par de ideas para probar ... Básicamente, esto es una pila de :1200----. Aísla :y voltea la pila, insertando :en el medio de cualquiera ----o 1200(dependiendo de lo que esté al final de la pila).

También debo tener en cuenta que la única instrucción *> <> que usa es S(suspensión), de lo contrario, este es un programa>> adecuado.

Actualización: se guardó 1 byte desplazando :hacia la derecha en lugar de protegerlo con un registro.

Explicación

Inicialización

<v":1200----"

Aquí construimos la pila que usaremos durante la vida del programa.

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

Tiempo de salida

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

Esta es la sección donde se emite el tiempo. Los primeros 5 se envían a la pila, por lo que el ciclo siguiente se ejecuta 5 veces.

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"

Recuperar e intercambiar

S      >~r@@}r5

Aquí recuperamos la :posición de la que resulta después de la salida, y terminamos con una pila invertida. Esto en realidad sale muy bien en el "tiempo de salida", causando un bucle infinito.

       >         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

Solución de 45 bytes

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

Pruébalo aquí!

Este también es básicamente un programa> <>.

Realmente pensé que sería capaz de guardar algunos bytes con este enfoque. Esto simplemente da salida 12:00, entonces --:--. Ahorro bytes reutilizando la rutina de salida o/!?l(incluso reutilizo ese espejo como entrada y salida). Utilizo múltiples pilas para almacenar el estado (tiene salida 12o --), y selecciono con qué estado debería salir v>]?v.

¡Explicaciones próximamente! (1/2)

redstarcoder
fuente
6

HTML / CSS (solo Chrome), 80 + 4 = 84 bytes

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

Editar : El atributo "contenido" no es animable por la especificación CSS , pero está en el navegador de escritorio Chrome.

degif
fuente
1
Parece ser específico de Chrome. Al menos no funciona en Firefox. Esto no es un problema, la solución sigue siendo válida, sería bueno especificarla.
manatwork
6

Noodel , 16 bytes no competitivos

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

Noodel sigue siendo un trabajo en progreso. Solo trato de mojarme los pies con un par de desafíos.

Intentalo:)

Cómo funciona

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

Aquí hay un fragmento de código :)

<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
fuente
2
Si el intérprete es posterior al desafío, márquelo como "no competidor" :). Sin embargo, Noodel se ve bien, definitivamente lo está revisando.
redstarcoder
@redstarcoder ¡Vaya! Gracias, olvidé poner eso.
tkellehe
¿Puedes explicar la codificación? Suma mucho más de 16 en UTF-8.
devRicher
1
Miré tu enlace, no explica la codificación. Verá, no todos los caracteres son de 1 byte por "defecto" (UTF-8). Especifique una codificación existente o cree una, de lo contrario, este es un recuento de bytes incorrecto. Debería haber una meta publicación en alguna parte sobre esto. A menos que defina una codificación, esta es UTF-8 y tiene 22 bytes. @tkellehe
devRicher
1
Encontré la meta publicación , por cierto.
devRicher
5

QBIC , 37 33 bytes

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

QBasic desafortunadamente solo puede dormir durante segundos completos. Veré sobre la creación de un método para permitir una mayor flexibilidad pronto. He ingresado 1 01para simular .5.

Explicación:

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

En versiones anteriores de QBIC, $y (espacio) eran caracteres reservados. Llamar a una función QBasic que necesitaba espacios (como sleep x) o $( left$(..)) requería un código literal:

'QBASIC CODE`

El código en un bloque literal de código se pasa directamente a QBasic sin que QBIC lo analice. Al descargar las funciones de esos símbolos (se $convirtió ', y las nuevas líneas ahora son (alt-217) en lugar de ) los símbolos ya no son vistos por QBIC como caracteres especiales y simplemente se transmiten. Lo mismo es cierto para el alfabeto en minúsculas: se utiliza para representar variables numéricas en QBIC y QBasic y no se modifican. El uso de la funcionalidad QBasic que no se implementa en QBIC (como SLEEP) es simplemente una cuestión de no usar caracteres reservados QBIC. Esto se hace más fácil con los cambios recientes en los símbolos de comando.

Steenbergh
fuente
4

JavaScript, 77 76 72 bytes

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

¡Gracias a Kritixi Lithos por 1 byte y L. Serne por 4 bytes!

binazy010
fuente
1000se puede acortar a1e3
Kritixi Lithos
2
setIntervaly setTimeoutacepte una cadena con código como primer argumento, para que pueda guardar otro 4B: setInterval('l=console.log,l("12:00"),setTimeout("l(-: -)",500)',1e3)
Luke
Esto `significa que ahora es ES6, mientras que la respuesta anterior solo necesitaba ES5.
Neil
4

Python 2, 88 85 73 71 bytes

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

Pruébalo aquí!

Al tomar prestada la idea de Stewie Griffin de voltear la lista, el programa fue posible. Versión sin golf con explicación:

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

¡Gracias @FlipTack por guardar 14 bytes!

Anthony Pham
fuente
1
Puede jugar al golf que sea aún más corto usando rebanar cadena, como esto
FlipTack
4

PHP, 51 50 47

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

1 byte guardado debido a trabajo en equipo y otros 3 guardados por insertusernamehere. ¡Gracias!

Christoph
fuente
1
Si mueve la usleep(5e5)llamada al fortercer parámetro, el ,separador se vuelve innecesario, guardando 1 carácter.
manatwork
@manatwork gracias! Tenía while(1)al principio.
Christoph
2
Puede guardar 3 bytes más : elimine el espacio en blanco entre echoy $iy reemplácelo \ncon una nueva línea real.
insertusernamehere
@insertusernamehere incluso en el golf esto me duele los ojos: D pero bueno, funciona.
Christoph
3

Pyth, 23 bytes

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

En pseudocódigo:

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

Utiliza la variable preinicializada Zcomo flip-flop e invierte su estado cada vez que ifintenta verificar la condición.

busukxuan
fuente
ponga .d5 en la parte frontal del bucle y elimine la cita final
Maltysen
3

rubí, 47 42 bytes

Aún no hay respuesta de ruby, así que aquí está mi primer intento:

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

GNU sed, 39 bytes

EDICIONES:

  • Intercambiado sueño y i12: 00 (a código fuente hacen parecer un poco más agradable)

Golfed

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

Explicado

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.

¡Pruébelo en línea!

zepelín
fuente
3

dc (bash), 37 bytes

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

Esto funciona presionando las dos cadenas "12:00" y "-: -" en la pila y luego intercambiando repetidamente los valores, imprimiendo el elemento en la parte superior de la pila y durmiendo medio segundo.

Para ejecutar esto, puede guardarlo en un archivo y luego escribir

dc nombrearchivo

o puede ejecutarlo directamente desde la línea de comando bash escribiendo

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

Mitchell Spector
fuente
3

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*
Brad Gilbert b2gills
fuente
usar un forbucle puede hacerlo un poco más corto:for |<12:00 --:-->xx* {sleep .5;.say}
sonríe el
Incluso más corto si hace uso del hecho de que saydevuelve 1:sleep .say/2 for |<12:00 --:-->xx*
sonríe el
2

Jalea, 22 bytes

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

No funciona en TIO. Hacer que Jelly se ejecute en Android con QPython3 también fue una experiencia divertida.

Explicación

®‘©ị“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
fuente
1
¿Esto duerme? ¿Puedes agregar una explicación?
steenbergh
1
@steenbergh Añadido. Perdón por el retraso, editar esas sangrías para la explicación es un poco difícil en la aplicación SE con una fuente no monoespacial.
PurkkaKoodari
2

Mathematica, 38 bytes

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

Explicación

Clock[]

Emite una variable de reloj que realiza ciclos continuos de 0 a 1 cada segundo.

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

Si la variable del reloj es mayor que .5, envíe "12:00". Si no, salida "-: -".

Dynamic@ ...

Hacer el programa dinámico (actualizando constantemente)

JungHwan Min
fuente
2

Javascript, 57 55

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

2 bytes guardados gracias a ETHproductions

Christoph
fuente
3
Puede guardar algunos bytes con setInterval(...,i=500):-)
ETHproductions
2

Posdata 225 214

¡Solo por diversión! ¡No envíes esto a una impresora real!

/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

Intentalo:

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'

o

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

luego

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

¡Pero no intente abrir esto con un visor más sofisticado y preocúpese por la miniatura del escritorio!

F. Hauri
fuente
Si el gs -c '...'comando muestra una página en blanco, es posible que deba hacer crecer la ventana de visualización o usar una resolución más pequeña: gs -r45 -c '...'o un tamaño de papel más pequeñogs -r600 -g360x200 -c '...'
F. Hauri
2

Javascript (en el navegador), 174 160 159 122 112 111 109 107 66 (91) bytes

Lo he tomado preporque usar una fuente monotipada no es parte del requisito, por lo que mi nuevo recuento es 66 . Se agregan algunos caracteres para usar fuentes monoespaciadas, pero como no es necesario, no contaré estos 25 caracteres más.

Gracias a ETHproductions por guardar 14 bytes,

a Kritixi Lithos para ahorrar 1 byte,

para trabajar para ahorrar 1 3 byte,

a Christoph por guardar dos bytes más y

a mí mismo por ahorrar 37 bytes usando en [..][b^=1]lugar de setTimeout... y 10 más reemplazando function(){..}por comillas dobles ...

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

... peor:

De 66 a algo más ...

... pero por diversión, en el espíritu de una pantalla parpadeante:

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>

F. Hauri
fuente
1
1000puede convertirse1e3
Kritixi Lithos
1
Puede guardar un montón de bytes eliminando todas las instancias de window.; window.setTimeoutes el mismo que setTimeout.
ETHproductions
1
ttes más corto prey también implica el uso de la fuente monoespacio. (Sólo es elemento en línea, no cuadra, pero esto debería hacer ninguna diferencia en este caso.)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)ahorra 5 bytes
Christoph
1
¿Hay alguna razón para generar un elemento? setInterval("document.body.innerHTML=++b%2?'12:00':'--:--'",b=500)solo queda atrás del elegante monoespacio pero solo tiene 66 bytes.
Christoph
2

QuickBASIC , 167 picaduras (delicioso)

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

Nunca iba a ganar de todos modos. QB no tiene un piso (), y tampoco tiene una función para dormir durante x milisegundos. Por lo tanto, esto funciona agarrando la parte de coma flotante del TEMPORIZADOR (devuelve los segundos transcurridos desde la medianoche, más una fracción del segundo actual expresado como un decimal de dos dígitos). Luego le agregamos un "ciclo de 50 unidades" para determinar cuándo la fase debe cambiar de "-: -" a "12:00", y usar el decimal TEMPORIZADOR original para el cambio de "12:00" a "--:--".

Finalmente, incluso ejecutar esto cumplió en QB4.5, en DOSBox en una máquina bastante poderosa omitirá los ritmos. Esto se debe a que QB realmente no es lo suficientemente rápido como para realizar el DO-LOOP y las evaluaciones dentro de la MS en la que estamos haciendo la comparación. ¡Necesitaría una caja del FUTURO!

De todos modos, ahora parezco 100, e hice felices a todos los estudiantes de la Universidad Americana, ya que probablemente tengan una respuesta para su clase de Comp Sci, ya que todavía están enseñando esto ...

Robert Lerner
fuente
¿Puedes eliminar algunos de los espacios? es decir b% = b% - 99a b%=b%-99?
Rɪᴋᴇʀ
Sí, estoy bastante seguro de que podría, pero utilicé el IDE original que, después de presionar enter al final de la línea, los agregaría nuevamente. Tendría que editarlo fuera del IDE en DOS, y luego descifrar los parámetros para el enlazador / compilador para verificar si mi solución aún funciona ... Entonces puede ser más corto, pero no dentro de mi marco de esfuerzo.
Robert Lerner
Bueno, necesita jugar golf este código o de lo contrario no es una respuesta válida y se eliminará. Lo siento por eso. (Entiendo completamente lo que quieres decir, pero la comunidad en su conjunto ha decidido no responder a los campos de golf)
Rɪᴋᴇʀ
Buen punto, eliminaré los espacios.
Robert Lerner
2

Clojure, 79 62 bytes

V2

-17 bytes cambiando de un horrible ciclo de indexación a un ciclo en una lista infinita

Crea una lista infinita de "12:00"y "--:--"repitiendo una y otra vez, luego usa doseqpara extraer constantemente el siguiente mensaje e imprimirlo.

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

No podía pensar en una buena manera de compactar las constantes "12:00" y "-: -", así que tuve que codificarlas.

Sin golf:

(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
Carcigenicate
fuente
2

Pushy , 22 bytes (no competidor)

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

Esta respuesta hace uso de las dos pilas, volteando entre ellas, imprimiendo los caracteres a su vez:

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

El oWcomando es parte de un conjunto de comandos experimentales que son posteriores al desafío, lo que hace que esta respuesta no sea competitiva.

FlipTack
fuente
2

Windows PowerShell, 46 55 bytes

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

Código original

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