Me gustaría que me construyas un reloj que muestre la hora en este formato:

18 ----------
19 --------------------------------------------------

Esto muestra '18: 10 '. La hora actual y la siguiente se muestran al frente de la línea, seguidas de un espacio y una serie de guiones: en la primera línea, la cantidad de minutos que han pasado en esta hora, y la segunda línea muestra cuántos minutos más ir en esta hora

Para aclarar

• El reloj debe mostrar la hora del sistema. Si buscar el tiempo de otra fuente es más conveniente, también está bien. Es posible que no se suministre como entrada.
• En 18:00, la línea superior es justa 18(espacios finales permitidos pero no obligatorios)
• En 18:59el resultado final es19 -
• Las horas <10 se rellenan previamente con un 0( 01 -----) o se alinean a la derecha ( 1 -----). No se permite un solo dígito alineado a la izquierda, ni siquiera si los guiones comienzan en el lugar correcto ( 1 -----no es válido).
• El reloj debe mostrar las horas en formato de 24 h.
• Aunque se llama formato 24h, en realidad no hay un formato 24. Durante la hora 23, la segunda línea comienza con 00o 0.
• La pantalla debe actualizarse al menos una vez por minuto, pero eso no tiene que suceder exactamente en 00segundos. Puede actualizar más frecuentemente / continuamente si eso es más conveniente, pero el resultado debe ser, por supuesto, legible, no una mancha en toda la pantalla.

Entrada

Ninguna.

Salida

• Como se describió anteriormente. Los espacios finales para acolchar el reloj a posiciones de 60 ish están permitidos en ambas líneas, también se permite una nueva línea final.
• La pantalla debe borrarse cuando se muestra el siguiente minuto: ya sea con un comando de pantalla clara o agregando no menos de 30 líneas nuevas.

Reglas adicionales

• Las lagunas estándar están prohibidas
• code-golf , la respuesta más corta en bytes gana.

MATL , 41 bytes

Gracias a @Kundor por notar un error, ahora corregido

`XxFT"4&Z'@+24\OH&YAO'-'60@*5&Z'-|Y"hhD]T

Pruébalo en MATL en línea! Pero tenga en cuenta que el programa se elimina después de 30 segundos, por lo que es difícil detectar cualquier cambio en la salida.

Cómo funciona

`           % Do...while
  Xx        %   Clear screen
  FT        %   Push [0 1]
  "         %   For each k in [0 1]
    4&Z'    %     Push current hour
    @+      %     Add k
    24\     %     Modulo 24. This transforms 24 into 0
    OH&YA   %     Convert to base-10 string with 2 digits
    O       %     Push 0. Concatenating with chars will convert this to char,
            %     and char(0) will be displayed as a space
    '-'     %     Push '-'
    60@*    %     Push 60*k
    5&Z'    %     Push current minute
    -|      %     Absolute difference. This gives current minute for k==0,
            %     or 60 minus that for k==1
    Y"      %     Repeat '-' that many times
    hh      %     Concatenate the top three elements into a string
    D      %      Display
  ]         %   End
  T         %   Push true
            % End (implicit). Since the top of the stack contains true, this
            % gives an infinite loop

TI-Basic, 94 bytes

" 
Repeat 99<length(Ans
Ans+"-
End
Ans→Str1
Repeat 0
getTime
ClrDraw
Ans{Ans(1)≠24,1,1
Text(0,0,Ans(1),sub(Str1,1,1+Ans(2
Text(6,0,Ans(1)+1,sub(Str1,1,61-Ans(2
End

Relativamente sencillo. Esa es una cadena con un espacio al principio. Las horas están alineadas a la derecha. Esto solo funciona en las calculadoras TI-84 + ya que la TI-83 no tiene un reloj interno.

Editar: Gracias @kundor por notar que no cerré el último bucle. Corregido ahora (+2 bytes).

Edición n.º 2: la primera hora debe ser cero, no veinticuatro. Corregido a un costo de +14 bytes.

Lote, 197 bytes

@echo off
set/ah=100+%time:~0,2%,m=1%time:~3,2%
cls
call:l
set/ah=(h-3)%%24+100,m=260-m
call:l
timeout/t>nul 60
%0
:l
set s=%h:~1% 
for /l %%i in (101,1,%m%)do call set s=%%s%%-
echo %s%

Nota: la décima línea tiene un espacio final. Para mí, %time%formatea horas con un espacio inicial pero minutos con un cero inicial. Decidí que un cero inicial era un formato de salida más fácil, ya que todo lo que tengo que hacer para eso es agregar 100 horas y eliminar el primer dígito. Minutos son más difíciles como 08o 09provocarán errores de análisis octales, así que prefijo A 1efectivamente añadiendo 100 minutos, ajustando por este mediante la compensación del bucle apropiadamente, que es un byte más corto que restando el 100.

Python 3.6, 110 114 112 bytes

from time import*
while[sleep(9)]:h,m=localtime()[3:5];print('\n'*50+'%2d '%h+'-'*m+f'\n{-~h%24:2} '+'-'*(60-m))

Esto usa el nuevo formato de cadena f para guardar un byte ( f'\n{h+1:2} 'vs. '\n%2d '%(h+1)) Puede cambiar [sleep(9)]a 1para guardar 8 bytes, pero luego solo muestra la pantalla.

Se guardó un byte cambiando while 1:...;sleep 60a while[sleep(60)]:..., gracias a TuukkaX.

Tuve que usar 5 bytes más para que la siguiente hora mostrada después de las 23 fuera 0, en lugar de 24, como OP acaba de comentar. :-(

Recuperado un byte durmiendo solo 9 segundos en lugar de 60.

Se guardaron dos bytes usando un toque de bits para acortar (h+1)%24, tomado de la respuesta Ruby de Value Ink .

Ruby, 98 95 91 bytes

Actualizaciones cada 5 segundos. Solo funciona en terminales de estilo Unix.

loop{t=Time.now;puts`clear`+"%02d %s
%02d "%[h=t.hour,?-*m=t.min,-~h%24]+?-*(60-m);sleep 5}

Versión del símbolo del sistema de Windows, 95 92 bytes:

loop{t=Time.now;puts"\e[H\e[2J%02d %s
%02d "%[h=t.hour,?-*m=t.min,-~h%24]+?-*(60-m);sleep 5}

Perl 6 , 113 bytes

loop {$_=DateTime.now;.put for |('' xx 30),|([\+](.hour,1)».fmt('%2s')Z('-' Xx[\-](.minute,60)».abs));sleep 60}

Pruébelo una vez con un tiempo de espera de un segundo.

O pruebe una versión alterada que muestre el resultado de ejecutarse durante varias horas.

Expandido:

loop {                  # keep repeating forever

  $_ = DateTime.now;    # assign an object representing the current time

    .put                # print with trailing newline
                        # ( adds a space between numbers and dashes )

  for                   # for each of the following

    |(                  # make it a slip so that it is all part of one list

      '' xx 30          # 30 empty strings (30 empty lines)
    ),

    |(

        [\+](           # triangle produce
          .hour,        # the hour
          1             # the hour plus one

        )».fmt( '%2s' ) # both formatted to two element string ( space padded )

      Z                 # zipped with

        (
            '-'         # a dash

          Xx            # cross (X) using string repeat (x) operator

            [\-](       # triangle produce
              .minute,  # the minute
              60        # the minute minus 60

            )».abs      # absolute value of both
        )
    );

  sleep 60              # wait until the next minute
}

QBasic, 120 127 121 bytes

No ejecute esto por mucho tiempo o su computadora portátil se incendiará. Ahora 99.several9s% ​​más eficiente de la CPU.

CLS
m=TIMER\60
h=m\60
m=m MOD 60
FOR i=1TO 2
?USING"## ";h MOD 24;
FOR j=1TO m
?"-";
NEXT
?
h=h+1
m=60-m
NEXT
SLEEP 1
RUN

Sin golfos y explicación

DO
    CLS
    totalMinutes = TIMER \ 60
    hour = totalMinutes \ 60
    minute = totalMinutes MOD 60

    FOR row = 1 TO 2
        PRINT USING "## "; hour MOD 24;
        FOR j = 1 TO minute
            PRINT "-";
        NEXT j
        PRINT

        hour = hour + 1
        minute = 60 - minute
    NEXT row

    SLEEP 1
LOOP

Comenzamos limpiando la pantalla, luego obtenemos las horas y minutos actuales de TIMER, que devuelve el número de segundos desde la medianoche.

Esta es la primera vez que lo intento PRINT USING, así que me encantó descubrir que no sufre la peculiaridad QBasic habitual de que los números positivos se imprimen con un espacio inicial. ##ya que el especificador de formato garantiza que los números de un solo dígito estén alineados a la derecha y rellenados con un espacio, según sea necesario. Desafortunadamente, tenemos que usar un bucle para los guiones, ya que QBasic no tiene una función de repetición de cadenas. (Si me equivoco, ¡házmelo saber!)

Todas las PRINTdeclaraciones terminan con ;suprimir la nueva línea; pero después de los guiones, necesitamos una nueva línea; así, el solitario ?después del FORbucle interno .

El SLEEP 1ahora es necesario. Sin ella, la pantalla se borra tan rápidamente después de la impresión que es solo un destello parpadeante. (He usado LOCATE 1en lugar de CLSen un primer momento por esa razón, hasta que me di cuenta de que CLScon SLEEPes más corto de todos modos.) RUNReinicia el programa desde la parte superior - el camino más corto para conseguir un bucle infinito.

Java 8, 313 300 299 bytes

import java.time.*;()->{for(int c=0,h=LocalDateTime.now().getHour(),m=LocalDateTime.now().getMinute(),i;;)if(c>30){c=0;String l="",u,d;for(i=0;i++<60;)l+="-";u=l.substring(0,m);d=l.substring(m);System.out.println((h<10?"0":"")+h+" "+u+"\n"+(h<9?"0":"")+(h+1)+" "+d);}else{c++;System.out.println();}}

Esto solo actualiza cada 30 iteraciones del ciclo while. Las otras 29 iteraciones solo imprimen nuevas líneas.

Actualizado

¡Guardado 13 14 bytes gracias a la ayuda de Kevin Cruijssen! ¡Gracias!

C, 176 162 161 160 156 bytes

Este es un abuso grave de los punteros, pero se compila y ejecuta según lo especificado. Asegúrese de compilar sin optimización, de lo contrario es probable que llegue a una falla predeterminada.

main(){int*localtime(),b[9],*t;memset(b,45,60);for(;;)time(&t),t=localtime(&t),usleep(printf("\e[2J%.2d %.*s\n%.2d %.*s\n",t[2],t[1],b,t[2]+1,60-t[1],b));}

Sin golf:

#import<time.h>
main()
{
 int *t,b[60];
 memset(b,45,60);
 for(;;) {
  time(&t);
  t=localtime(&t);
  usleep(printf("\e[2J%.2d %.*s\n%.2d %.*s\n",t[2],t[1],b,t[2]+1,60-t[1],b));
 }
}

JavaScript (ES6), 162 bytes

Actualizaciones una vez por segundo

setInterval(c=>{c.clear(d=new Date,m=d.getMinutes(),h=d.getHours(),H=_=>`0${h++}`.slice(-2)),c.log(H()+` ${'-'.repeat(m)}
${H()} `+'-'.repeat(60-m))},1e3,console)

Python 2, 131 129 127 bytes

from time import*
while[sleep(9)]:exec(strftime("a='%H';b=int('%M')"));print "\n"*30+a+" "+"-"*b+"\n"+`int(a)+1`+" "+"-"*(60-b)

salvó un byte gracias a @TuukkaX

C 251 267 251 bytes

 #include<time.h>f(){time_t t;struct tm *t1;h,m,i;while(1){time(&t);t1=localtime(&t);h=t1->tm_hour;m=t1->tm_min;printf("%d ",h);for(i=1;i<=m;i++)printf("-");puts("");printf("%d ",h+1);for(i=0;i<=59-m;i++)printf("-");puts("");sleep(1);system("clear");}}

Versión sin golf

#include<time.h>
void f()
{
 time_t t;
 struct tm *t1;
 int h,m,i;

 while(1)
 {
  time(&t);     
  t1=localtime(&t);
  h=t1->tm_hour;
  m=t1->tm_min;

  printf("%d ",h);
  for(i=1;i<=m;i++)
   printf("-");

  puts("");
  printf("%d ",h+1);

  for(i=0;i<=59-m;i++)
   printf("-");

  puts("");    

  sleep(1);
  system("clear");    
 }
}

¡Hace el trabajo! Definitivamente se puede acortar de alguna manera. Suponga que el unistd.harchivo está incluido.

@Neil Gracias por la información.

@Seth Gracias, por guardar 8 bytes.

Golf por primera vez ...

Powershell, 116 bytes (antes 122)

while($d=date){$f="{0:D2}";$h=$d.Hour;$m=$d.Minute;cls;"$($f-f$h)$("-"*$m)`n$($f-f(++$h%24))$("-"*(60-$m))";Sleep 9}

Editar: del consejo de @ AdmBorkBork, cambió Get-Date a fecha y Clear a cls, para ahorrar 6 bytes.

PHP, 104105 bytes

<? for(;;sleep(6))printf("%'
99s%2d %'-".($m=date(i))."s
%2d %'-".(60-$m).s,"",$h=date(H),"",++$h%24,"");

El escaparate de printfde caracteres de relleno personalizada:
"%'-Ns"= cadena almohadilla izquierda con -a Ncaracteres.

imprimirá 99 líneas nuevas (cada 6 segundos) en lugar de borrar la pantalla.

La primera línea nueva debe ser un solo personaje. Entonces, en Windows, debe ser reemplazado por \n.

Lenguaje GameMaker, 134 bytes

s=" "while 1{s+="-"a=current_hour b=current_minute draw_text(0,0,string(a)+string_copy(s,1,b+1)+"#"+string(a+1)+string_copy(s,0,61-b)}

En la configuración, debe ignorar los errores no fatales para que esto funcione. Además, en GML, #es equivalente a \nen la mayoría de los idiomas.

Perl 6 , 104 bytes

DateTime.now.&{"\ec{.hour.fmt: '%2s'} {'-'x.minute}\n{(.hour+1).fmt: '%2s'} {'-'x 60-.minute}"}.say xx*

Debe ejecutarse en un terminal compatible con ANSI para que funcione la secuencia de control para restablecer el terminal.

Bastante básico (porque los enfoques más ofuscados que probé resultaron más largos):

• DateTime.now.&{" "}.say xx*: Transforma el tiempo actual en una cadena (ver abajo) y dilo, y repite todo eso un número infinito de veces. La cadena se construye así:
  • \ec: Código de control ANSI <ESC>cpara restablecer el terminal, que borra la pantalla.
  • {.hour.fmt: '%2s'}: hora, alineado a la derecha con 2 columnas
  • : espacio
  • {'-'x.minute}: guión repetido veces por minuto
  • \n: nueva línea
  • {(.hour+1).fmt: '%2s'}: próxima hora, alineado a la derecha con 2 columnas
  • : espacio
  • {'-'x 60-.minute}: guión repetido veces 60 menos el minuto

AWK, 190 bytes

#!/bin/awk -f
func p(x,y,c){printf("%2s ",x)
for(j=0;j<y;j++)printf(c)
print}BEGIN{for(;;){split(strftime("%H %M"),t)
m=t[2]
if(o!=m){p(a,30,"\n")
p(t[1],m,"-")
p((t[1]+1)%24,60-m,"-")}o=m}}

Como AWKno tiene una sleepfunción incorporada, simplemente hago que revise continuamente el reloj para ver si el minuto ha cambiado todavía. La clave es que funciona ... ¿verdad? :)

Python 3.5, 127 120 117 bytes

from time import*
while[sleep(9)]:h,m=localtime()[3:5];print('\n'*88,*['%2d '%x+'-'*y+'\n'for x,y in[(h,m),(h+1,60-m)]])

Python, 115 113 bytes

_{ahorró un par de bytes gracias a @kundor y @Phlarx}

import time
while 1:h,m=time.localtime()[3:5];print("\x1b[0;H{:02} {}\n{:02} {} ".format(h,"-"*m,h+1,"-"*(60-m)))

C # interactivo (138 bytes)

while(true){var d=DateTime.Now;Console.WriteLine($"{d.Hour:00} {new string('-',d.Minute)}\n{d.Hour+1:00} {new string('-',60-d.Minute)}");}

PHP, 112 120 bytes

for(;;sleep(9))echo($s=str_pad)($h=date(H),99,"\n",0).$s(" ",1+$m=date(i),"-")."\n".$s(++$h%24,2,0,0).$s(" ",61-$m,"-");

Como no hay forma de limpiar la pantalla (que puedo encontrar) tuve que ir con un montón de líneas nuevas. Además, la pregunta que se actualiza a "al menos" una vez por minuto guarda un byte en 9lugar de 60.

editar: @Titus notó un error en el relleno de la segunda hora. Arreglarlo cuesta 8 bytes.

Bash (3 y 4): 90 bytes

d=(`sed s/./-/g<$0`);let `date +h=%H,m=%M`;echo $h ${d:0:m}'
'$[++h%24] ${d:m}
sleep 5
$0

Debido al uso de $0, este script debe colocarse en un archivo, no pegarse en un shell bash interactivo.

El primer comando se establece $den 60 guiones; se basa en el hecho de que la primera línea de este script tiene 60 caracteres de longitud. Estos son tres caracteres más cortos que la siguiente mejor cosa que se me ocurrió:

d=`printf %060d|tr 0 -`

Si no desea que esto acabe con su cuadro de PID o memoria, puede agregarlo evalal comienzo de la última línea, lo que generaría estos 95 bytes.

Bash, 165 141 155 bytes

while :
do
clear
m=`date +%-M`
a=`printf %${m}s`
b=`printf %$((60-m))s`
h=`date +%H`
echo $h ${a// /-}
printf "%02d %s" $((10#$h+1)) ${b// /-}
sleep 9
done

Gura , 138 bytes

k(a,b)={if(a<10){a="0"+a;}println(a," ","-"*b)};repeat{t=datetime.now();k(t.hour,t.min);k(t.hour+1,60-t.min);os.sleep(60);print("\n"*30);}

Bastante corto y directo :)

Ok, no he hecho un código de golf en mucho tiempo, así que aquí va mi triste intento :)

Unix Korn Shell: 177 171 170 bytes

while :
do
clear
h=`date +%H`
m=`date +%M`
d=-----
d=$d$d$d$d
d=$d$d$d
a=`echo $d|cut -b-$m`
let m=60-$m
b=`echo $d|cut -b-$m`
let i=h+1
echo "$h $a\n$i $b"
sleep 9
done

Mathematica, 235 bytes

d=UpdateInterval;e=Dynamic;f=Refresh;g=AbsoluteTime;Grid[Partition[Riffle[e[f[Floor@Mod[g[]/3600+#,24],d->1]]&/@{0,1},With[{t=#},e[f[""<>Array["-"&,If[t==60,60-#,#]]&@Setting@Floor@Mod[g[]/60+#,60],d->1]]]&/@{0,60}],2],Alignment->Left]

Procesamiento, 204 200 198 197 bytes

5 bytes guardados gracias a @L. Serné utilizando ternaries más inteligentes

void draw(){int i;String s=((i=hour())>9?i:" "+i)+" ";for(i=0;i<minute();i++)s+="-";s+="\n"+((i=hour()+1)>9?i>23?" 0":i:" "+i)+" ";for(i=0;i<60-minute();i++)s+="-";print(s);for(;i++<99;)println();}

Esto genera más de 30 líneas nuevas para cada actualización (que tiene lugar cuando se actualiza el marco)

Sin golf

void draw(){
  int i;
  String s=((i=hour())>9?i:" "+i)+" ";
  for(i=0;i<minute();i++)
    s+="-";
  s+="\n"+((i=hour()+1)>9?i>23?" 0":i:" "+i)+" ";
  for(i=0;i<60-minute();i++)
    s+="-";print(s);
  for(;i++<99;)
    println();
}

C, 239 bytes

#include<time.h>
#include<unistd.h>
#define F printf(
void d(n,p){for(;n--;F"%c",p));}int main(){time_t*t;for(;;){d(30,10);time(t);int*m=localtime(t);F"%2d ",m[2]);d(m[1],45);F"\n%2d ",(m[2]+1)%24);d(60-m[1],45);F"\n");sleep(1);}return 0;}

Inspirado por las entradas de Seth y Abel, esto generará 0 en lugar de 24 durante la próxima hora, según sea necesario, y usará 30 líneas para borrar la pantalla.

SmileBASIC, 55 bytes

TMREAD OUT H,M,
CLS?H,"-"*M?(H+1)MOD 24,"-"*(60-M)EXEC.

Explicación:

TMREAD OUT HOUR,MINUTE,
CLS
PRINT HOUR,"-"*MINUTE
PRINT (HOUR+1) MOD 24,"-"*(60-MINUTE)
EXEC 0 'runs the code stored in slot 0 (the default)

Nota: SmileBASIC solo tiene 50 columnas de texto, por lo que no se verá bien ...

C # 181 176

for(;;){Console.Clear();var t=DateTime.Now;var h=t.Hour;var m=t.Minute;Console.Write("{0,2} {1}\n{2,2} {3}",h,"".PadLeft(m,'-'),++h%24,"".PadLeft(60-m,'-'));Thread.Sleep(100);}

Este código supone que la using System.Threading;línea está incluida.

Clase completa:

class Program
{
    static void Main(string[] args)
    {
        Console.Title = string.Format("Started the app at: {0}", DateTime.Now.TimeOfDay);
        //new Timer((o) => { Console.Clear(); var t = DateTime.Now; var h = t.Hour; var m = t.Minute; Console.Write("{0,2} {1}\n{2,2} {3}", h, "".PadLeft(m, '-'), ++h % 24, "".PadLeft(60 - m, '-')); }, null, 0, 60000);

        for (; ; ) { Console.Clear(); var t = DateTime.Now; var h = t.Hour; var m = t.Minute; Console.Write("{0,2} {1}\n{2,2} {3}", h, "".PadLeft(m, '-'), ++h % 24, "".PadLeft(60 - m, '-')); Thread.Sleep(100); }

        Console.ReadKey(true);
    }
}