J'aimerais que vous me construisiez une horloge qui affiche l'heure dans ce format:

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

Cela affiche '18: 10 '. L'heure actuelle et l'heure suivante sont affichées au début de la ligne, suivies d'un espace et d'un certain nombre de tirets: sur la première ligne, le nombre de minutes qui se sont écoulées pendant cette heure, et la deuxième ligne indique combien de minutes de plus aller dans cette heure.

Clarifier

• L'horloge doit afficher l'heure du système. Si récupérer l'heure d'une autre source est plus pratique, c'est bien aussi. Il peut ne pas être fourni en entrée.
• À 18:00, la ligne du haut est juste 18(espaces de fin autorisés mais non requis)
• À 18:59, la ligne de fond est19 -
• Les heures <10 sont pré-remplies avec un 0( 01 -----) ou alignées à droite ( 1 -----). Un chiffre unique aligné à gauche n'est pas autorisé, même si les tirets commencent au bon endroit ( 1 -----n'est pas valide).
• L'horloge doit afficher les heures au format 24h.
• Bien que cela s'appelle le format 24h, il n'y en a pas réellement 24. Pendant la 23e heure, la deuxième ligne commence par 00ou 0.
• L'affichage doit être mis à jour au moins une fois par minute, mais cela ne doit pas se produire à exactement 00secondes. Vous pouvez mettre à jour plus fréquemment / en continu si cela est plus pratique, mais le résultat doit bien sûr toujours être lisible - pas une tache sur l'écran.

Contribution

Aucun.

Sortie

• Comme décrit ci-dessus. Les espaces de fin pour placer l'horloge à 60 positions sont autorisés sur les deux lignes, une nouvelle ligne de fin est également autorisée.
• L'écran doit être effacé lors de l'affichage de la minute suivante: soit avec une commande d'effacement d'écran soit en ajoutant pas moins de 30 nouvelles lignes.

Règles supplémentaires

• Les failles standard sont interdites
• code-golf , réponse la plus courte en octets gagne.

MATL , 41 octets

Merci à @Kundor d'avoir remarqué une erreur, maintenant corrigée

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

Essayez-le sur MATL en ligne! Mais notez que le programme est tué au bout de 30 secondes, il est donc difficile de détecter tout changement dans la sortie.

Comment ça marche

`           % 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 octets

" 
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

Relativement simple. C'est une chaîne avec un espace au début. Les heures sont alignées à droite. Cela ne fonctionne que sur les calculatrices TI-84 + car la TI-83 n'a pas d'horloge interne.

Edit: Merci @kundor d'avoir remarqué que je n'ai pas fermé la dernière boucle. Corrigé maintenant (+2 octets).

Edit # 2: La première heure doit être zéro, pas vingt-quatre. Corrigé au coût de +14 octets.

Lot, 197 octets

@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%

Remarque: la 10e ligne a un espace de fin. Pour moi, %time%formate les heures avec un espace de début mais les minutes avec un zéro de début. J'ai décidé qu'un zéro de tête était un format de sortie plus facile, car tout ce que je dois faire pour cela est d'ajouter 100 heures et de supprimer le premier chiffre. Minutes sont plus délicat que 08ou 09causeront erreurs d'analyse octal, donc je préfixe un 1ajout de 100 minutes efficacement, le réglage de cette compensation par la boucle appropriée, ce qui est un octet plus courte que la soustraction de la 100.

Python 3.6, 110 114 112 octets

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

Cela utilise le nouveau formatage de chaîne f pour enregistrer un octet ( f'\n{h+1:2} 'vs. '\n%2d '%(h+1)) Vous pouvez modifier[sleep(9)] pour 1sauver 8 octets, mais il juste l'écran envoie des pourriels.

Changement d'un octet enregistré while 1:...;sleep 60 en while[sleep(60)]:..., grâce à TuukkaX.

J'ai dû utiliser 5 octets de plus pour afficher l'heure suivante après 23 à 0, au lieu de 24, comme OP vient de le commenter. :-(

Récupéré un octet en dormant seulement 9 secondes au lieu de 60.

Enregistré deux octets en utilisant un bit-fiddling pour raccourcir (h+1)%24, emprunté à la réponse Ruby de Value Ink .

Rubis, 98 95 91 octets

Mises à jour toutes les 5 secondes. Fonctionne uniquement sur les terminaux de type Unix.

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

Version d'invite de commande Windows, 95 92 octets:

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 octets

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

Essayez-le une fois avec un délai d'une seconde.

Ou essayez une version modifiée qui génère le résultat d'une exécution pendant plusieurs heures.

Étendu:

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 octets

Ne l'exécutez pas très longtemps ou votre ordinateur portable prendra feu. Maintenant 99.several9s% ​​plus économe en 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

Non golfé et explication

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

Nous commençons par effacer l'écran, puis obtenons les heures et les minutes TIMER , ce qui renvoie le nombre de secondes depuis minuit.

C'est la première fois que j'essaie PRINT USING, donc j'ai été ravi de découvrir qu'il ne souffre pas de la bizarrerie QBasic habituelle que les nombres positifs sont imprimés avec un espace de tête.##car le spécificateur de format garantit que les nombres à un chiffre sont alignés à droite et remplis d'un espace, selon les besoins. Nous devons utiliser une boucle pour les tirets, malheureusement, car QBasic n'a pas de fonction de répétition de chaîne. (Si je me trompe, faites-le moi savoir!)

Toutes les PRINTinstructions se terminent par ;pour supprimer la nouvelle ligne; mais après les tirets, nous avons besoin d'une nouvelle ligne; ainsi, le solitaire ?après la FORboucle intérieure .

Le SLEEP 1est maintenant nécessaire. Sans cela, l'écran est effacé si rapidement après l'impression que ce n'est qu'un gâchis vacillant. (J'ai utilisé LOCATE 1au lieu de CLSd'abord pour cette raison, jusqu'à ce que je réalise CLSqu'avecSLEEP est plus court de toute façon.) RUNRedémarre le programme par le haut - le moyen le plus court pour obtenir une boucle infinie.

Java 8, 313 300 299 octets

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

Cela ne met à jour que toutes les 30 itérations de la boucle while. Les 29 autres itérations impriment simplement de nouvelles lignes.

Mis à jour

Enregistré 13 14 octets grâce à l'aide de Kevin Cruijssen! Merci!

C, 176 162 161 160 160 156 octets

Il s'agit d'un abus flagrant de pointeurs mais compile et s'exécute comme spécifié. Assurez-vous de compiler sans optimisation, sinon vous risquez de rencontrer un défaut de segmentation.

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));}

Non 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 octets

Mises à jour une fois par seconde

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 127 octets

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

enregistré un octet grâce à @TuukkaX

C 251 267 251 octets

 #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");}}

Version non golfée

#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");    
 }
}

Obtient le travail! Peut certainement être raccourci d'une manière ou d'une autre. Supposons que le unistd.hfichier soit inclus.

@Neil Merci pour l'info.

@Seth Merci d'avoir économisé 8 octets.

Golf pour la première fois ...

Powershell, 116 octets (au lieu de 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}

Modifier: à partir des conseils de @ AdmBorkBork, changé Get-Date à ce jour et Clear à cls, pour une économie de 6 octets.

PHP, 104 105 octets

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

vitrine pour printfses personnages de remplissage personnalisé:
"%'-Ns"= chaîne de gauche de la tablette avec -pour Npersonnages.

imprimera 99 sauts de ligne (toutes les 6 secondes) au lieu d'effacer l'écran.

La première nouvelle ligne doit être un seul caractère. Donc, sous Windows, il doit être remplacé par \n.

Langue GameMaker, 134 octets

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

Dans les paramètres, vous devez ignorer les erreurs non fatales pour que cela fonctionne. En outre, en GML, #est équivalent à \ndans la plupart des langues.

Perl 6 , 104 octets

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

Doit être exécuté sur un terminal compatible ANSI pour que la séquence de contrôle de réinitialisation du terminal fonctionne.

Assez basique (car les approches les plus obscures que j'ai essayées se sont avérées plus longues):

• DateTime.now.&{" "}.say xx*: Transformez l'heure actuelle en une chaîne (voir ci-dessous) et dites-la, et répétez tout cela un nombre infini de fois. La chaîne est construite comme ceci:
  • \ec: Code de contrôle ANSI <ESC>c pour réinitialiser le terminal, ce qui efface l'écran.
  • {.hour.fmt: '%2s'}: heure, aligné à droite sur 2 colonnes
  • : espace
  • {'-'x.minute}: tiret répété fois la minute
  • \n: nouvelle ligne
  • {(.hour+1).fmt: '%2s'}: heure suivante, aligné à droite sur 2 colonnes
  • : espace
  • {'-'x 60-.minute}: tiret répété fois 60 moins la minute

AWK, 190 octets

#!/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}}

Puisqu'il AWKn'a pas de sleepfonction intégrée, je le fais simplement vérifier continuellement l'horloge pour voir si la minute a encore changé. L'essentiel est que cela fonctionne ... non? :)

Python 3.5, 127 120 117 octets

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 octets

_{économisé quelques octets grâce à @kundor et @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 # interactif (138 octets)

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 octets

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,"-");

Comme il n'y a aucun moyen d'effacer l'écran (que je peux trouver), j'ai dû y aller avec une pile de nouvelles lignes. De plus, la question mise à jour à "au moins" une fois par minute enregistre un octet avec 9au lieu de 60.

edit: @Titus a remarqué un bug dans le rembourrage de la deuxième heure. Le réparer coûte 8 octets.

Bash (3 et 4): 90 octets

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

En raison de l'utilisation de $0, ce script doit être placé dans un fichier, et non collé dans un shell bash interactif.

La première commande définit $d60 traits d'union; il s'appuie sur le fait que la première ligne de ce script comporte 60 caractères. C'est trois caractères de moins que la meilleure chose que je pourrais trouver:

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

Si vous ne voulez pas que cela finisse par exécuter votre boîte à partir de PID ou de mémoire, vous pouvez ajouter evalau début de la dernière ligne, ce qui ferait ces 95 octets.

BASH, 165 141 155 155 octets

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 octets

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);}

Assez court et simple :)

Ok, je n'ai pas fait de golf de code depuis un moment, alors voici ma triste tentative :)

Unix Korn Shell: 177 171 170 octets

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 octets

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]

Traitement, 204 200 198 197 octets

5 octets enregistrés grâce à @L. Serné en utilisant des ternaires plus intelligents

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

Cela génère plus de 30 nouvelles lignes pour chaque mise à jour (qui a lieu lorsque le cadre est mis à jour)

Non 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 octets

#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;}

Inspiré par les entrées de Seth et Abel, cela affichera 0 au lieu de 24 pour l'heure suivante, comme requis, et utilisera 30 lignes pour effacer l'écran.

SmileBASIC, 55 octets

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

Explication:

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)

Remarque: SmileBASIC ne dispose que de 50 colonnes de texte, donc il n'aura pas l'air 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);}

Ce code suppose que le using System.Threading; ligne est incluse.

Classe complète:

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);
    }
}