Dijital Saat Göster

(Saat zorlukları olduğunu görüyorum, hepsini okumaya çalıştım, bunun benzersiz olduğuna eminim)

Sürekli biçimde görüntülenir bir dijital saat günceller bazı kodlar yaz h:m:snereye h, mves 1 veya 2 karakter her doldurabilir. @BlueEyedBeast koyduğu gibi basit terimlerle kısıtlamalar, temelde gösterilen zamanı değiştirmek istiyorum.

• Yeni satırlara izin verilmiyor
• Sondaki boşluklara izin verilir
• Diğer sondaki karakterlere izin verilmiyor
• Hiçbir saniye kaçırılmamalıdır (57 -> 59'a izin verilmez)
• "0" ile başlayan sayılara, 2 karakterden fazla yer almadıkları sürece izin verilir
• Kod herhangi bir girişi kabul etmemelidir
• Diliniz geçerli saati girilmeden alamıyorsa, standart olarak izin verilen bir şekilde 8 bayta kadar giriş için kullanabilirsiniz
• Çıktı stdout olmalıdır
• Bu kodgolf, bu yüzden en kısa cevap kazanıyor!

Misal

*> <> (Denizyıldızı) adlı bir dil üzerinde çalışıyorum çünkü bu tür programlar> <> 'da mümkün değil (sadece dosya i / o'yu bekleyin). İşte içinde çalışan bir dijital saat programı (ungolfed). Bu program *> <> dilinde yazılmıştır :

s":"m":"hnonon"   "ooo88888888888ooooooooooo1S

^{Not: s = saniye, m = dakika, h = saat, S = uyku (100 ms * x) hariç, her şey bunun içinde <<> ile aynıdır.}

Bu çıktılar:

14:44:31

Sonlandırılana kadar her 100 ms'de bir güncellenir.

İzin Verilmeyen Örnekler

Aşağıdakilere izin verilmez:

1:

14:44:3114:44:32

2:

14:44:31 14:44:32

3:

14:44:31
14:44:32

Zaman, görünür izleyen karakter olmadan çıktısının alındığı ilk satırda kalmalıdır. Yine de terminalin temizlenmesine izin verilecekti, çünkü hala takip eden karakterler olmayacaktı.

Pyke, 6 bayt

Ctr\ J

Burada deneyin!

Bunun geçerli olduğunu düşünüyorum. Geçerli çıktı için boşluk karakterini satır başı ile değiştirin (çevrimiçi çalışmaz)

HTML + JS (ES6), 8 + 60 = 68 bayt

Chrome'da test edildi.

setInterval`a.innerHTML=new Date().toLocaleTimeString('fr')`

<a id=a>

-1 bayt (@ETHProductions): Fransızca saat biçimini kullan yerine .toTimeString().slice(0,8)

HTML + JS (ES6), 8 + 62 = 70 bayt

Bu FireFox'ta çalışacaktır.

setInterval('a.innerHTML=new Date().toLocaleTimeString`fr`',0)

<a id=a>

-3 bayt (@ETHProductions): Fransızca saat biçimini kullan yerine .toTimeString().slice(0,8)

Python 2, 50 bayt

( ctimeTartışmasız Python 2.1+ )

import time
while 1:print'\r'+time.ctime()[11:19],

time.ctime() hh: mm: ss kullanılarak dilimlenebilen biçimlendirilmiş bir dize verir [11:19] (tarih ve saat ne olursa olsun aynı yerde kalır).

print'\r'metnin önüne satır başının döndürülmesi ve metnin ,, örtülü izlemeyi etkin bir şekilde bastıran bir demetin ilk öğesi haline getirmesi '\n've daha önce yazılan çıktının üzerine yazılması.

while 1 sonsuza kadar döngüler.

Mathematica, 48 41 37 28 bayt

Do[s=Now[[2]],∞]~Monitor~s

Çıktı bir TimeObject sürekli yenilenerek .

Buna benzer:

Alternatif versiyonlar

48 bayt:

Dynamic@Refresh[TimeObject[],UpdateInterval->.1]

53 bayt:

Dynamic@Refresh[DateString@"Time",UpdateInterval->.1]

Programı durdurmak için sinyalsiz bir UI girişi gereksiniminin kaldırıldığını görüyorum. Şimdi yapabiliriz:

Bash + coreutils, 28

yes now|date -f- +$'\e[2J'%T

yes "Şimdi" dizesini sürekli olarak her satıra bir boruya verir.

date -f-okur, her "şimdi" yi geçerli saat olarak yorumlar, ardından istenen formatta çıktı verir. Biçim dizesi, ekranı temizlemek için ANSI çıkış sırasını içerir. date yapar çıkış tarihinden sonra yeni satır - Ben değilim emin eğer ekran Zaten her zaman temizlenir beri bu kaybedeceğinizi.

Diskalifiye olursa, trbunun yerine kullanabiliriz :

Bash + coreutils, 31

yes now|date -f- +%T|tr \\n \\r

Önceki Cevaplar:

Bash + X, 32

xclock -d -update 1 -strftime %T

Ne yazık ki bu sadece her saniyede bir güncellenebilir. Bu diskalifiye olursa, bunun yerine bunu yapabiliriz:

Bash + coreutils, 43

until read -t0
do printf `date +%T`\\r
done

QBIC , 6 bayt

{_C?_d

{      Starts a DO-loop
 _C    CLS
   ?   PRINT
    _d TIME$

Ekranı sürekli olarak temizler ve sistem saatini formatta yazdırır 22:03:41.

Clojure, 150 136 141 bayt

V3: 141 bayt :(

Bir hatayı düzeltmek için +5 bayt. Zamanlar sıfır dolgulu olmadığından, saat değiştiğinde saat "büzülebilir" ve genişleyebilir. Küçüldüğünde "bulaşıyordu", çünkü son rakam artık silinmemiştir. Her şeyin üzerine yazıldığından emin olmak için sonunda boşluklar ekleyerek düzeltildi.

#(while true(flush)(print(str(apply str(repeat 9"\b"))(.format(java.text.SimpleDateFormat."H:m:s")(java.util.Date.))"   "))(Thread/sleep 99))

V2: 136 bayt

#(while true(flush)(print(str(apply str(repeat 9"\b"))(.format(java.text.SimpleDateFormat."H:m:s")(java.util.Date.))))(Thread/sleep 99))

SimpleDateFormatTarihi biçimlendirmek için kullanarak -14 bayt . Hala çok büyük.

V1: 150 bayt

#(while true(let[d(java.util.Date.)](flush)(print(str(apply str(repeat 9 "\b"))(.getHours d)":"(.getMinutes d)":"(.getSeconds d)))(Thread/sleep 100)))

Tarihi almak için muhtemelen en kötü yolu kullandığımı fark ettim. Burada iyileştirme için kesinlikle yer.

Ungolfed:

(defn -main []
  (while true
    (let [d (java.util.Date.)]
      (flush)
      (print
        (str
          (apply str (repeat 9 "\b"))
          (.getHours d)":"(.getMinutes d)":"(.getSeconds d)))
      (Thread/sleep 100))))

Bash + saat, 19 bayt

watch , coreutils'in bir parçası değildir , ancak neredeyse her Linux dağıtımında kullanıma hazırdır.

golfed

watch -tn1 date +%T

Çevrimiçi deneyin!

WinDbg, 73 bayt

.do{r$t0=0;.foreach(p {.echotime}){r$t0=@$t0+1;j8==@$t0'.printf"p \r"'}}1

Kullanıcı Ctrl + Break tuşlarına basana kadar bir satırı geçerli saatle sürekli günceller.

Nasıl çalışır:

.do                          * Start do-while loop
{
    r$t0 = 0;                * Set $t0 = 0
    .foreach(p {.echotime})  * Foreach space-delimited word in a sentence like "Debugger (not 
    {                        * debuggee) time: Mon Dec  5 14:08:10.138 2016 (UTC - 8:00)"
        r$t0 = @$t0+1;       * Increment $t0
        j 8==@$t0            * If $t0 is 8 (ie- p is the current time)
        '
            .printf"p \r"    * Print p (current time) and \r so the next print overwrites
        '
    }
} 1                          * Do-while condition: 1, loop forever

Örnek çıktı (iyi, fikir olsun):

0:000> .do{r$t0=0;.foreach(p {.echotime}){r$t0=@$t0+1;j8==@$t0'.printf"p \r"'}}1
14:10:12.329

PHP, 28 bayt

for(;;)echo date("\rH:i:s");

dateTanımadığı gelmiyor.Fark tam anlamıyla o fonksiyon baskılar her şeyi.

\r satır başı, imleci ilk sütuna ayarlar.

İle çalıştırın -r.

MATL , 11 bayt

`XxZ'13XODT

Ekranı temizleyen ve zamanı belirtilen formatta basan sonsuz döngü.

MATL Online'da deneyebilirsiniz ! . Bu derleyici deneyseldir; çalışmazsa sayfayı yenileyin ve tekrar "Çalıştır" a basın.

C #, 82 bayt

()=>{for(;;)Console.Write(new string('\b',8)+DateTime.Now.ToString("HH:mm:ss"));};

Yeni çıktı ile sürekli olarak 8 karakterin üzerine yazan anonim yöntem. Sahte bir parametreyi kabul etmek için değiştirilirse 1 bayt daha kısa yapılabilir (z=>... ) .

Tam program:

using System;

public class Program
{
    public static void Main()
    {
        Action a =
        () =>
        {
            for (;;)
                Console.Write(new string('\b', 8) + DateTime.Now.ToString("HH:mm:ss"));
        };

        a();
    }
}

C #, 65 bayt

()=>{for(;;)Console.Write("\r"+DateTime.Now.ToLongTimeString());};

Sonsuz bir döngü içinde aynı satırın üzerine yazarak çalışır

SmileBASIC 3.3.2, 38 bayt

@L?TIME$;" ";
GOTO@L

UTF-16 berbat :(

Her neyse, bu art arda HH: MM: SS'de yerel saati tekrar basıyor, sonrasında boşluk yok. Yine de her saniye güncellenmiyor, sadece tekrar tekrar sonsuza kadar yazdırıyor.

C, 134 116 89 80 76 75 73 bayt

main(n){for(;time(&n);)printf("\r%02d:%02d:%02d",n/3600%24,n/60%60,n%60);}

---- Old versions:
main(n){for(;;)n=time(0),printf("\r%02d:%02d:%02d",n/3600%24,n/60%60,n%60);}

n;main(){for(;;)n=time(0),printf("\r%02d:%02d:%02d",n/3600%24,n/60%60,n%60);}

---- 

n;main(){for(;;)n=time(0),printf("\r%02d:%02d:%02d",n/3600%24,n/60%60,n%60);}

----

Saved 9 more bytes thanks to @nmjcman101 again:
n;main(){for(;;)n=time(0),printf("\r%02d:%02d:%02d",(n/3600)%24,(n/60)%60,n%60);}

----

Saved 27 bytes thanks to @nmjcman101
n,b[9];main(){for(;;){n=time(0);strftime(b,9,"%H:%M:%S",localtime(&n));printf("\r%s",b);}}

----

I figured out I don't need to put `#include<stdio.h>` into the file :)
#include<time.h>
main(){for(;;){time_t n=time(0);char b[9];strftime(b,9,"%H:%M:%S",localtime(&n));printf("\r%s",b);}}

----

#include<time.h>
#include<stdio.h>
main(){for(;;){time_t n=time(0);char b[9];strftime(b,9,"%H:%M:%S",localtime(&n));printf("\r%s",b);}}

Powershell, 39 bytes

for(){write-host -n(date -F h:m:s`0`r)}

Because I dislike using cls in Powershell. From briantist's post @/codegolf//a/102450/63383

Pascal, 61 bytes

uses sysutils;begin while 1=1do write(#13,timetostr(now))end.

Free pascal has nice time routines in SysUtils unit. Ungolfed:

uses
  sysutils;
begin
  while 1=1 do
    write(#13, timetostr(now));
end.

C 65 (prev 64) bytes

Guaranteed to work on Linux machine. :)

@Marco Thanks!

f(){while(1){system("date +%T");usleep(100000);system("clear");}}

Vim, 26 bytes

qqS<C-r>=strftime("%T")<CR><esc>@qq@q

This creates a recursive macro (e.g. an eternal loop) that deletes all the text on the current line and replaces it with the current time.

Pyth - 28 bytes

Kinda longish, because pyth has no strftime.

#p+"\r"j\:m.[`02`dP>4.d2.d.1

Groovy, 45 characters

for(;;)print(new Date().format("\rHH:mm:ss"))

Jelly, 8 bytes

13Ọ7ŒTȮß

13Ọ        chr(13), carriage return
   7ŒT     time string, which extends the previous character
      Ȯ    print
       ß   call the whole link again

Try it online!

The carriage return doesn't work online, and I can't get the interpreter to work, so its kinda untested, but it works as expected when I use printable characters in place of the CR.

ForceLang, 123 bytes

def s set
s d datetime
s z string.char 8
s z z.repeat 16
label 1
io.write z
io.write d.toTimeString d.now()
d.wait 9
goto 1

datetime.toTimeString is backed in the reference implementation by Java's DateFormat.getTimeInstance(), which is locale-dependent, so you can set your default system locale to one that uses 24-hour time.

PowerShell, 30 28 24 20 bytes

Changed my computer's region to Germany based on raznagul's comment to save 4 bytes. :)

for(){date -F T;cls}

Previous version that works in all locales.

for(){date -F h:m:s;cls}

tcl, 69 bytes

while 1 {puts -nonewline \r[clock format [clock seconds] -format %T]}

Try it here!

Batch, 36 bytes

@set/p.=␈␈␈␈␈␈␈␈%time:~0,8%<nul
@%0

Where ␈ represents the ASCII BS character (code 8).

Racket, 71 bytes

(require srfi/19)(let l()(display(date->string(current-date)"↵~3"))(l))

Where the ↵ is actually a CR (hex 0d). Hex dump of the program for further clarification (notice byte at position hex 4d):

00000000  28 72 65 71 75 69 72 65  20 73 72 66 69 2f 31 39  |(require srfi/19|
00000010  29 28 6c 65 74 20 6c 28  29 28 64 69 73 70 6c 61  |)(let l()(displa|
00000020  79 28 64 61 74 65 2d 3e  73 74 72 69 6e 67 28 63  |y(date->string(c|
00000030  75 72 72 65 6e 74 2d 64  61 74 65 29 22 0d 7e 33  |urrent-date)".~3|
00000040  22 29 29 28 6c 29 29                              |"))(l))|
00000047

Uses SRFI/19 included with the Racket distribution. (current-date) gets the current local date & time. The date->string format ~3 is ISO-8601 hour-minute-second format. (let l () ... (l)) in an idiomatic infinite loop. (require srfi/19) loads the srfi/19 module.

C, 156 bytes

#include<stdio.h>
#include<time.h>
int main(){time_t a;struct tm *b;char c[9];for(;;){time(&a);b=localtime(&a);strftime(c,9,"%H:%M:%S",b);printf("%s\r",c);}}

TI-Basic, 40 Bytes

(In TI-BASIC, many characters are 2 byte tokens, and colons at the beginning of a line are 0 extra bytes)

:ClrHome
:Output(1,6,":
:setTmFmt(24
:While 1
:Output(1,1,getTmSrr(0
:getTime
:Output(1,7,Ans(3
:End

R, 41 bytes

repeat{cat(format(Sys.time(),"%T"),"\r")}

Has one trailing space (because of cat default separator being a space).
Because of the refresh rate of the R GUI, running this in the GUI will occasionally skip some seconds, but if you save it to a file and run it on the command line it will display correctly every single seconds.
Will run forever until user interrupt.