Thực hiện Đồng hồ bấm giờ kỹ thuật số đơn giản , sẽ hiển thị thời gian trôi qua trong vài giây và phút, như được mô tả dưới đây.

Quan trọng

Vui lòng đọc cả phần Hiển thị và Điều khiển !

Trưng bày

Thời gian đã trôi qua, nên được hiển thị theo MM:SSđịnh dạng, bằng cách thay thế chuỗi thời gian được hiển thị trước đó "tại chỗ" (xóa toàn bộ hoặc một phần của màn hình cũng được cho phép).

Đồng hồ bấm giờ phải được cập nhật ít nhất mỗi giây.

Ví dụ:

0 phút, 0 giây

00:00

0 phút, 33 giây

00:33

1 phút, 50 giây

01:50

Ban đầu, bạn có thể bắt đầu với '00: 00 'hoặc với bất kỳ giá trị nào khác trong phạm vi [00: 00-59: 59].

Khi Đồng hồ bấm giờ của bạn đạt đến 59:59, nó sẽ được đặt lại 00:00và tiếp tục lại.

Bạn có thể sử dụng một cơ sở khác (thay vì thập phân) hoặc thậm chí là một hệ thống chữ số khác nếu bạn muốn, miễn là bạn tuân theo mô hình chung.

Ví dụ 13:03có thể được hiển thị như:

Số thập phân

13:03

Hệ thập lục phân

0D:03

Cơ sở64

N:D

Cơ sở tưởng tượng

10101:3

Chữ số La Mã

XIII:III

Xin lưu ý rằng nếu bạn sử dụng hệ thống / cơ sở chữ số không thập phân, thì nó phải được mã hóa bằng các ký tự ASCII (hoặc Unicode) có thể in được, ví dụ: không được phép sử dụng hai byte nhị phân (không thể in được) trong vài phút và giây.

Bạn cũng phải đệm trái đầu ra của bạn với số không cho phù hợp, nếu hệ thống số của bạn cho phép điều đó.

Việc thay thế ký tự phân cách :bằng bất kỳ ký tự có thể in nào khác (bao gồm cả chữ số) cũng được chấp nhận.

Kiểm soát

Đồng hồ bấm giờ sẽ bắt đầu tạm dừng và ở trạng thái này, cho đến khi người dùng khởi động nó một cách rõ ràng , bằng cách nhấn phím 'control' (xem bên dưới).

Nếu, trong khi đồng hồ bấm giờ đang đếm, người dùng nhấn phím 'điều khiển' một lần nữa, đồng hồ bấm giờ sẽ tạm dừng (giữ thời gian hiện tại), cho đến khi nhấn phím 'điều khiển' thêm một lần nữa.

Các 'kiểm soát' chìa khóa có thể là một phím tắt duy nhất, ví dụ như s, hoặc bất kỳ sự kết hợp của các phím, ví dụ Ctrl+Shift+X, nhưng nó phải là 'nguyên tử', nhấn nhiều phím theo thứ tự, ví dụ như ssau đó Enter, là không được phép .

Phải sử dụng cùng một phím 'điều khiển' (hoặc kết hợp) để tạm dừng và tiếp tục đồng hồ bấm giờ.

Bạn phải sử dụng khóa 'điều khiển' cụ thể , nghĩa là 'bất kỳ khóa nào' đều không được phép.

Ngoài ra, bạn có thể sử dụng một lần nhấp chuột hoặc nhấp đúp chuột, thay vì nhấn phím để 'điều khiển'.

Quy tắc

• Đây là code-golf , câu trả lời ngắn nhất trong byte thắng;
• Tiêu chuẩn mã lỗ golf áp dụng;
• Chương trình của bạn phải (về mặt lý thuyết) có khả năng chạy mãi mãi.

SmileBASIC, 86 77 71 byte

@L
N=N!=DIALOG(FORMAT$("%02D:%02D",F/60MOD 60,F MOD 60),,,N)F=F+1GOTO@L

DIALOGhiển thị một hộp văn bản trên màn hình cảm ứng. Nlà số giây mà hộp văn bản sẽ ở trên màn hình trước khi nó biến mất. Nếu Ncó 0, nó sẽ ở lại cho đến khi người dùng nhấn nút trên màn hình cảm ứng.

DIALOGTrả về 1nếu người dùng nhấn nút và 0nếu nó tự động đóng lại. Vì vậy, khi người dùng nhấn nút tạm dừng, nó sẽ quay trở lại 1và thời gian hiển thị được đặt thành 0, tạm dừng đồng hồ bấm giờ. Sau khi người dùng nhấn nút một lần nữa, chúng tôi đặt thời gian hiển thị trở lại 1, tiếp tục lại bộ hẹn giờ. Về cơ bản, mỗi lần DIALOGquay trở lại 1, thời gian hiển thị được chuyển đổi giữa 1và 0sử dụng !=, đó là hiệu quả cho XOR logic miễn là cả hai đầu vào là 1 hoặc 0.

Python 2, 167 129 byte

-36 byte chủ yếu * từ việc sử dụng ý tưởng bắt Maltysenctrl-c bằng cách sử dụng một ngoại lệ - hãy ghi nhận!
-4 byte nhờ DLosc (init nvà b0 thay vì f())
-1 byte nhờ FlipTack (sử dụng p^=1chứ không phải p=1-p)
-2 byte nhờ Felipe Nardi Batista (xóa các chỉ định chính xác)

import time
f=time.time
n=b=p=0
while 1:
 try:n=[n,f()][p];t=n-b;print'\r%02d:%02d'%(t/60%60,t%60),
 except:b=[b-n+f(),b][p];p^=1

Hoạt động giống như bản gốc của tôi, bên dưới, nhưng với dãy phím điều khiển ctrl+c.
(Được thử nghiệm bởi tôi với Python 2.7.8 trên Windows 7, 64 bit;
Được thử nghiệm bởi Brian Minton với Python 2.7.13 trên linux, 64 bit)

* cũng thu gọn ifcâu lệnh vào một tra cứu danh sách để có được trydưới dạng một lớp lót.

Bản gốc của tôi:

import time,msvcrt as m
f=time.time
n=b=p=0
while 1:
 if m.kbhit()and m.getch()==b'p':b=[b-n+f(),b][p];p^=1
 if p:n=f()
 t=n-b;print'\r%0.2d:%0.2d'%(t/60%60,t%60),

(Được kiểm tra bởi tôi với Python 2.7.8 trên Windows 7, 64 bit - tuy nhiên, mã này là dành riêng cho Windows do sử dụng msvcrtthư viện)

Khóa điều khiển là 'p'.

nvà bđược khởi tạo với cùng một giá trị khi khởi động, cho "độ lệch" là 0; pđược khởi tạo thành 0, biểu thị trạng thái tạm dừng.

Bất cứ khi nào phím điều khiển được nhấn, giá trị của pđược chuyển. Khi chuyển từ trạng thái tạm dừng sang trạng thái hoạt động bđược cập nhật thành giá trị mới, giữ bất kỳ phần bù hiện tại nào từ (các) trạng thái hoạt động trước đó với b-n.

Trong trạng thái hoạt động nđược liên tục cập nhật đến thời điểm hiện tại bằng cách gọi time.time().

Sự khác biệt giữa nvà b, tsau đó là tổng số giây (bao gồm cả một phần phân số) trôi qua trong (các) trạng thái hoạt động.

Các phút trôi qua sau đó t/60và mỗi phút và giây được hiển thị mod 60 với (t/60%60,t%60). Các số 0 đứng đầu được chuẩn bị cho mỗi lần sử dụng định dạng chuỗi của phần nguyên với '...%0.2d...'. In một tuple (dấu vết ,) trong đó mục đầu tiên có lợi nhuận vận chuyển hàng đầu (phần \r) làm cho văn bản được in trước đó bị ghi đè.

Python - 160 159 143 byte

Cảm ơn @Jonathan ALLan vì đã tiết kiệm cho tôi 18 byte!

Chỉ sử dụng các thư viện dựng sẵn, vì vậy khóa điều khiển là ctrl-c, bắt nó bằng một except keyboardInterrupt.

import time
Z=0
print'00:00'
while 1:exec"try:\n while 1:\n  %s\nexcept:1\n"*2%(1,"print'\033c%02d:%02d'%divmod(Z%3600,60);Z+=1;time.sleep(1)")

bash + tiện ích Unix, 90 hoặc 93 byte

Phiên bản 90 byte:

trap d=\$[!d] 2;for((n=0;;)){((d|!n))&&dc<<<DP60dod*d$n\r%+n|colrm 1 4&&: $[n++];sleep 1;}

Phiên bản 93 byte:

trap d=\$[!d] 2;for((n=0;;)){((d|!n))&&dc<<<DP60dod*$n+n|colrm 1 4&&n=$[(n+1)%3600];sleep 1;}

Ctrl-C là ký tự tiếp tục / tạm dừng. Một khoảng trắng là dấu phân cách giữa phút và giây.

Sự khác biệt giữa hai phiên bản là chương trình 90 byte sẽ hoạt động trong 2 ^ 63 giây (tại thời điểm đó, bash sẽ cung cấp cho tôi một số nguyên tràn).

Phiên bản 93 byte sẽ thực sự hoạt động mãi mãi.

Vấn đề ban đầu bao gồm yêu cầu: "Về mặt lý thuyết, chương trình của bạn phải có khả năng chạy mãi mãi".

Nếu chạy trong 2 ^ 63 giây là đủ để đáp ứng yêu cầu đó, thì giải pháp 90 byte hoạt động. Thời gian đó gấp hơn 20 lần tuổi của vũ trụ!

Nếu chương trình cần có khả năng chạy lâu hơn thế, tôi sẽ phải sử dụng giải pháp 93 byte.

Tôi có lẽ nên chỉ ra rằng giải pháp này, cũng như ít nhất một số trong những giải pháp khác được đăng, sẽ rất chậm lại sau thời gian trôi qua thực sự. Sự trượt này là do chương trình đang ngủ trong một giây giữa mỗi lần thực hiện phần thân của vòng lặp, nhưng phần thân của vòng lặp sẽ mất một khoảng thời gian rất nhỏ để thực thi. Điều này sẽ không quan trọng trong thực tế.

QBasic, 213 211 byte

Phím điều khiển là tab. Để chạy này có thể gây cháy máy tính xách tay. Bạn đa được cảnh bao.

DO
WHILE k$<>CHR$(9)
k$=INKEY$
LOCATE 1
?CHR$(48+m\10);CHR$(48+(m MOD 10));":";CHR$(48+(d MOD 60)\10);CHR$(48+(d MOD 10))
IF r THEN
n=TIMER
d=v+n-b+86400
m=d\60MOD 60
END IF
WEND
k$=""
v=v+n-b
r=1-r
b=TIMER
LOOP

Đây là hành động, tạm dừng ở 10, 15 và 20 giây:

Ungolfed và bình luận

' Outer loop runs forever
DO
  ' The WHILE-WEND loop runs until tab is pressed
  WHILE key$ <> CHR$(9)
    key$ = INKEY$
    ' Output the stopwatch value at top left of screen
    LOCATE 1
    ' Unfortunately, QBasic's PRINT USING doesn't have a format for printing
    ' with leading zeros, so we have to do it manually by printing the
    ' 10s digit and the 1s digit
    PRINT CHR$(48 + minute \ 10); CHR$(48 + (minute MOD 10));
    PRINT ":";
    PRINT CHR$(48 + second \ 10); CHR$(48 + (second MOD 10))
    ' Update the current time if the running flag is set
    IF running THEN now = TIMER
    ' Take the difference between now and the last time we started the
    ' stopwatch, plus the amount of saved time from previous runs,
    ' plus 86400 to account for the possibility of running over midnight
    ' (since TIMER is the number of seconds since midnight, and QBasic's
    ' MOD doesn't handle negative values like we would need it to)
    diff = saved + now - lastStarted + 86400
    second = diff MOD 60
    minute = diff \ 60 MOD 60
  WEND
  ' If we're outside the WHILE loop, the user pressed tab
  key$ = ""
  ' Add the previous run's time to the saved amount
  saved = saved + now - lastStarted
  ' Toggle running between 0 and 1
  running = 1 - running
  ' If we're starting, we want to put the current time in lastStarted;
  ' if we're stopping, it doesn't matter
  lastStarted = TIMER
LOOP

Lưu ý rằng các giá trị TIMERlà dấu phẩy động. Điều này không ảnh hưởng đến đầu ra, vì MODvà \cắt ngắn thành số nguyên. Nhưng nó làm tăng thêm độ chính xác cho lượng thời gian đã lưu: nếu bạn tạm dừng bộ hẹn giờ ngay trước một tích tắc, bạn sẽ thấy khi bạn khởi động lại, số đó thay đổi trong chưa đầy một giây.

Mẻ, 132 byte

set/ar=0,m=s=100
:l
cls
@choice/t 1 /d y /m %m:~1%:%s:~1% /n
set/as+=r,m+=c=s/160,s-=c*60,m-=m/160*60,r^^=%errorlevel%-1
goto l

Nhấn nsẽ (un) tạm dừng bộ hẹn giờ. Nhấp nháy đầu ra có thể được giảm với chi phí ba (hoặc bốn) byte.

Bash thuần, 141 byte

set -m
while ! read -t 1;do printf '\r%02i:%02i' $[s=s>3598?0:s+1,s/60] $[s%60];done&trap 'fg>/dev/null' TSTP
printf '00:00'
kill -STOP $!
read

Điều này không sử dụng gì ngoài các nội trang Bash (không có công cụ bên ngoài). Ký tự điều khiển là Ctrl-Zđể việc SIGTSTPxử lý tiêu chuẩn tạm dừng đồng hồ bấm giờ.

• set -mcho phép kiểm soát công việc , thường được tắt trong một tập lệnh.
• Một quá trình subshell được nền ( &) .
  • read -t 1Chờ một giây cho đầu vào từ người dùng , sau đó thất bại.
  • Các untilvòng lặp tiếp tục chừng nào readvẫn tiếp tục thất bại.
  • printfđưa ra thời gian được đệm chính xác và được định dạng
  • $[s=s>3598?0:s+1,s/60]đầu tiên mở rộng số học sẽ tính toán thời gian cập nhật, kiểm tra xem có nên bọc hay không, nếu không tăng bộ đếm giây s, sau đó trả về phép chia s/60.
  • $[s%60] cho những giây còn lại.
• Kịch bản bên ngoài thiết lập một traptrình xử lý cho TSTP, tín hiệu Ctrl-Ztạo ra. Khi Ctrl-Zđược nhấn trong khi tập lệnh bên ngoài đang chạy, nó sẽ chạy fg>/dev/nullvà đưa phần con trở lại nền trước . >/dev/nulllà cần thiết để dừng fgin ra lệnh subshell mỗi lần.
• Kịch bản in ban đầu 00:00và gửi STOPtín hiệu đến tiến trình con$! , điều này sẽ tạm dừng quá trình.
• read Chờ đợi đầu vào mãi mãi, giữ cho kịch bản sống.

Nếu Ctrl-Zđược nhấn trong khi lớp con được tiền cảnh, nó sẽ tạm dừng thực thi và trả lại tập lệnh bên ngoài về nền trước, nơi nó sẽ im lặng chờ đợi. Nếu tập lệnh bên ngoài được báo trước, trình xử lý bẫy sẽ tiếp tục thực thi lệnh con và nó sẽ được tính lại.

Javascript trong bảng điều khiển Chrome, 143 byte

f=document,m=s=g=i=0;setInterval(()=>{if(g%2){m=(i/60|0)%60;s=i++%60}f.write((m>9?m:'0'+m)+':'+(s>9?s:'0'+s));f.close();f.onclick=()=>g++},1e3)

Khi được nhập vào bảng điều khiển, nó sẽ truy cập bộ đếm đến 00:00 và sau đó kích hoạt điều khiển nhấn phím trên tài liệu.

Không có nhiều phép thuật đang diễn ra, đáng chú ý là các (i/60)|0tầng số

Đã hoàn thành và thử nghiệm trong bảng điều khiển Chrome

HTML + JavaScript (ES6), 191 192 187 183 174 byte

<b onclick='b=b?clearInterval(b):setInterval("a.innerHTML=`${(d=(((c=a.innerHTML.split`:`)[1]>58)+c[0])%60)>9?d:`0`+d}:${(e=++c[1]%60)>9?e:`0`+e}",1e3)'onload='b=0'id=a>00:00

Giải trình

Nhấp vào bộ đếm thời gian để bắt đầu hoặc tạm dừng đồng hồ bấm giờ. Như vậy, một cú nhấp chuột là phím điều khiển . Dấu phân cách giữa hai giá trị là dấu hai chấm.

Bất cứ khi nào người dùng nhấp vào nhấp chuột, giá trị của bđược kiểm tra. Nó được khởi tạo để 0đánh giá false, do đó, một chuỗi mã được đánh giá cứ sau 1000 mili giây. Điều này đặt biến thành id của khoảng, vì vậy nó có thể được dừng lại sau đó. Nếu bchứa một số, nó ước tính true, vì vậy khoảng thời gian được dừng lại. Điều này trả về giá trị undefined, vì vậy chu kỳ tiếp tục.

Chuỗi mã thay đổi html của phần tử bằng id a(đồng hồ bấm giờ). Đầu tiên, các phút được phân tích cú pháp bằng cách lấy giá trị đồng hồ bấm giờ trước đó, chia nó bằng dấu hai chấm và lấy giá trị phút, tăng thêm 0 nếu giá trị của giây không phải là 59 (lớn hơn 58) và 1 cách khác, modulo 60 Sau đó, giá trị này được đệm. Sau đó đến dấu hai chấm, và cuối cùng, giây. Mã chỉ đơn giản là nhận giá trị cũ, tăng nó lên 1, lấy modulo 60 và tùy ý đệm nó.

C 309 179 byte

f(){m=0,s=0;A: while(getchar()^'\n'){if(s++==59){if(m++==59)m=0;s=0;}printf("\r%02d:%02d",m,s);sleep(1);system("clear");if(getchar()=='\n'){break;}}while(getchar()^'\n'){}goto A;}

Phiên bản bị đánh cắp:

void f()
{
   int m=0,s=0;

   A: while(getchar()^'\n')
      {           
       if(s++==59)
       {
         if(m++==59)
           m=0;

         s=0;
       }
       printf("\r%02d:%02d",m,s);
       sleep(1);  
       system("clear");

        if(getchar()=='\n')
        {
          break;
        }
      }

       while(getchar()^'\n')
       {}
       goto A ;
}

Cách sử dụng: Bấm Enterđể Tạm dừng và Tiếp tục Đồng hồ bấm giờ.

Giải trình:

• Đợi Entergõ phím, vòng lặp breakđầu tiên whilevà đợi cho đến khi tiếp theo Enterđến.
• Khi Enternhấn phím tiếp theo , vòng lặp gotođầu tiên whilevà tiếp tục đếm.

Bây giờ, tôi biết gotolà một thực hành mã hóa xấu trong C, nhưng tôi không thể tìm ra cách khác.

Javascript, 124 byte

s=i=1,setInterval("s&&(d=document).close(d.write(`0${i/60%60|0}:`.slice(-3)+`0${i++%60}`.slice(-2))),d.onclick=_=>s=!s",1e3)

'Phím điều khiển' là một cú nhấp chuột vào tài liệu. Để kiểm tra điều này, dán mã trong bảng điều khiển hoặc trong tệp html bên trong <script>thẻ.

Giải trình:

let s = 1
let i = 1
setInterval(() => {
    //If s = true then check after the "&&" operator else false
    s && (d = document).close( //put the document variable inside the d variable, so now i don't need to use anymore the long word 'document, then i close the document
            d.write( //Write into the document the next string
                `0${i/60%60|0}:`.slice(-3) + `0${i++%60}`.slice(-2) //Here is the magic, here I update the 'i' variable and convert the 'i' value to minutes and seconds
            ) 
        ),
        d.onclick = _ => s = !s //Add onclick event to the document, if s = true then s = false, if s = false then s = true
}, 1e3) //1e3 = 1000

Đã thử nghiệm trong Chrome

PHP, 94 91 byte

Tôi giả sử rằng 32 là mã khóa cho thanh không gian (có lẽ không phải vậy);
Tôi hiện không có cách nào để kiểm tra ncurses. Nhưng phần còn lại của mã hoạt động tốt.

for($s=[STDIN];;)echo date("\ri:s",$t+=$r^=stream_select($s,$n,$n,1)&&32==ncurses_getch());

bắt đầu lúc 00:00, nhưng tăng ngay lập tức khi kết thúc tạm dừng

Nếu bạn (như tôi) không có tài khoản, bạn có thể kiểm tra bằng cách thay thế datetham số thứ hai bằng $t+=$r^=!rand(sleep(1),19);hoặc $t+=$r^=++$x%20<1+sleep(1);. ( sleepluôn luôn trả lại 0.)

phá vỡ

for($s=[STDIN];                     // set pointer for stream_select
    ;                               // infinite loop:
)
    echo date("\ri:s",                  // 5. print CR + time
        $t+=                            // 4. increment $t if watch is running
        $r^=                            // 3. then toggle pause
            stream_select($s,$n,$n,1)   // 1. wait 1 second for a keystroke
            &&32==ncurses_getch()       // 2. if keystroke, and key==space bar
    ;

C # 220 byte

using static System.Console;
using static System.DateTime;
class P
{
    static void Main()
    {
        var l = Now;
        var d = l-l;
        for( var r = 1<0;;Write($"\r{d:mm\\:ss}"))
        {
            if (KeyAvailable&&ReadKey(1<2).KeyChar == 's')
            {
                l = Now;
                r = !r;
            }
            if (r)
                d -= l - (l = Now);
        }

    }
}

Chơi gôn

using static System.Console;using static System.DateTime;class P{static void Main(){var l=Now;var d=l-l;for(var r=1<0;;Write($"\r{d:mm\\:ss}")){(KeyAvailable&&ReadKey(1<2).KeyChar=='s'){l=Now;r=!r;}if(r)d-=l-(l=Now);}}}

Sử dụng sphím để bắt đầu / dừng. Toàn bộ chương trình hoạt động bằng cách ghi nhớ TimeDelta bằng cách sử dụngDateTime.Now

Hầu hết C # -Magic ở đây đến từ tính năng C # 7.0 using static.

Bash, 65 byte

trap d=\$[!d] 2;for((;;)){ printf "\r%(%M:%S)T" $[n+=d];sleep 1;}

Lưu ý rằng nó phải được ghi vào tập lệnh để hoạt động chính xác, nếu không, hãy thử:

bash -c 'trap d=\$[!d] 2;for((;;)){ printf "\r%(%M:%S)T" $[n+=d];sleep 1;}'

Phiên bản mở rộng để giải thích nó:

trap d=\$[!d] 2                     # flip d for each INT (ctrl-c) signal.
for((n=0;;)){                       # repeat forever the code inside the {...}
                                    # The n=0 is not strictly needed.
    printf "\r%(%M:%S)T" "$[n+=d]"  # Print Minute:Second string calculated from 
                                    # the n value, increment by the value of d.
                                    # If IFS is not numeric (0-9), then, the
                                    # quotes around "$[n+=d]" could be removed.
    sleep 1                         # wait for 1 second.
}

Các %(...)Tđịnh dạng printf là hợp lệ trong bash 5 +.

C (gcc) , 121 115 byte

p,r;g(){r^=1;}main(t,b){for(b=time(signal(2,g));;r?p=t:(b+=t!=p))t=time(0)-b,printf("\r%02d:%02d  ",t/60%60,t%60);}

Hãy thử trực tuyến!

Đặt bộ xử lý tín hiệu cho SIGINT, được kích hoạt bằng cách nhấn control-C. Chúng tôi giữ thời gian bù vào bvà hiển thị thời gian đồng hồ treo tường trừ đi thời gian bù. Nếu chúng ta bị tạm dừng, hãy tăng cơ sở thời gian mỗi khi đồng hồ treo tường tích tắc để đóng băng thời gian hiển thị.

Cảm ơn @ceilingcat đã cạo sạch 6 byte!

Ngày Zsh + Gnu, 242 byte

Với 1/100 giây! Nó đòi hỏi một thiết bị đầu cuối tương tác, nhưng dù sao đây cũng là một liên kết TIO .
ĐánhEnter để bắt đầu / dừng bộ hẹn giờ; Ctrl-Cđể thoát ra

u(){p=`gdate +%s`;q=`gdate +%N`;}
f(){read -t0.01&&{read;break};unset REPLY}
g(){while :;{u;t=$[p-a];s=$[t%60];m=$[(t%3600-s)/60]
echo "\r`printf %02d:%02d $m $s`.$q[1,2]\c";f;}}
<<<ready;read;u;a=$p
while :;{f;echo "\r\e[2A\c";u;a=$[p-t];g;}

Nhận xét (một chút lỗi thời):

u()echo $[`gdate +%s%N`/1000]       # fn:unix timestamp extended to µs
v()gdate +%s                        # fn:unix time, in s
f(){read -t0.01 -r&&{read -r;break;} # fn:listens for "Enter"
                      ;unset REPLY;}

g(){while :;                        # fn:rolling stopwatch
    {q=`u`;t=$[`v`-a]               #    t=time diff from baseline (s)
    ;echo "\r`printf %02d:%02d      #    format output
    $[(t%3600-s)/60] $s`            #    minutes:seconds
    .${q:10:2}\c";                  #    .xx = partial seconds
    f;}}                            #    listen for "Enter"

                                    # Execution starts here!
<<<ready;read;u;a=$p                # Wait for "Enter"; get baseline $a

while :;{                           # Main program loop
         f;                         # listen for an "Enter"
           echo "\r\e[2A\c"         # go up 1 line of the console
a=$[`v`-t]                          # reset the baseline
                ;g;}                # begin the stopwatch

Hàng hóa BASIC (C64 / TheC64 Mini, VIC-20, PET, C16 / + 4) - 147 byte được mã hóa và BASIC

 0?"{clear}":geta$:ifa$<>" "thengoto
 1ti$="000000"
 2fori=.to1:?"{home}"mid$(ti$,3,2)":"mid$(ti$,5,2):geta$:b$=ti$:i=-(a$=" "):nE:pO198,.
 3geta$:ifa$<>" "then3
 4ti$=b$:goto2

{clear} trong danh sách là SHIFT+CLR/HOME xuất ra một ký tự PETSCII khi theo dấu ngoặc kép mở, trong khi đó {home}là CLR/HOMEkhóa không có sự thay đổi trong cùng điều kiện theo dấu ngoặc kép mở.

Sử dụng thanh không gian làm phím điều khiển.

Để làm việc với Commodore 128 trong BASIC 7, hãy thay đổi danh sách trong các dòng sau:

 0?"{clear}":geta$:ifa$<>" "thengoto0
 2fori=.to1:?"{home}"mid$(ti$,3,2)":"mid$(ti$,5,2):geta$:b$=ti$:i=-(a$=" "):nE:poK198,.

Thêm bảy mã thông báo bổ sung vào số đếm (vì tất cả các số được lưu trữ trong BASIC là 7 byte, do đó, goto108 byte được mã hóa trong khi gotochỉ là 1).