Aşağıda açıklanan süreyi saniye ve dakika cinsinden gösteren basit bir dijital Kronometre uygulayın.

Önemli

Her iki okuyunuz Ekran ve Kontroller bölümleri!

Görüntüle

Geçen süre, MM:SS"yerinde" önceden gösterilen zaman dizesini değiştirerek (ekranın tamamını veya bir kısmını temizlemeye de izin verilir), biçimde gösterilmelidir.

Kronometre en az her saniye güncellenmelidir.

Örnekler:

0 dakika, 0 saniye

00:00

0 dakika, 33 saniye

00:33

1 dakika, 50 saniye

01:50

Başlangıçta, '00: 00 'ile veya [00: 00-59: 59] aralığında başka bir değerle başlayabilirsiniz.

Kronometreniz ulaştığında 59:59, sıfırlanmalı 00:00ve tekrar devam etmelidir .

Genel modeli takip ettiğiniz sürece farklı bir taban (ondalık yerine) veya hatta farklı bir sayı sistemi kullanabilirsiniz.

Örneğin 13:03şu şekilde görüntülenebilir:

Ondalık

13:03

onaltılık

0D:03

Base64

N:D

Quater-hayali üs

10101:3

Roma rakamları

XIII:III

Ondalık olmayan bir sayı sistemi / tabanı kullanıyorsanız, örneğin yazdırılabilir ASCII (veya Unicode) karakterleri kullanarak kodlanmalıdır, örn. Dakikalar ve saniyeler için iki ikili (yazdırılamaz) bayt kullanarak.

Sayısal sisteminiz buna izin veriyorsa, çıktınızı uygun şekilde sıfır ile de bırakmanız gerekir.

Ayırıcı karakterinin :basılabilir herhangi bir karakterle (sayılar dahil) değiştirilmesi de kabul edilebilir.

Kontroller

Kronometre duraklatılmaya başlamalı ve kullanıcı açıkça başlatana kadar 'kontrol' tuşuna basarak bu durumda kalmalıdır (aşağıya bakınız).

Kronometre sayımı, kullanıcının bastığı iken, ise 'kontrol' tuşuna tekrar, kronometre gerekir duraklama kadar (bu süre tutma) 'kontrol' anahtarı bir kez daha basılır.

'Kontrol' tuşuna tek bir tuş, örneğin olabilir s, ya da örneğin, şifreler, herhangi bir kombinasyonunu Ctrl+Shift+X, ancak, örneğin, içindeki çok sayıda tuşa basarak, 'atom' olmalıdır ssonra Enter, bir izin .

Kronometreyi duraklatmak ve devam ettirmek için aynı 'kontrol' tuşunun (veya birleşiminin) kullanılması gerekir .

Belirli bir 'kontrol' tuşunu kullanmalısınız, yani 'herhangi bir tuşa' izin verilmez.

Alternatif olarak, 'kontrol' için bir tuşa basmak yerine tek veya çift fare tıklaması kullanabilirsiniz.

kurallar

• Bu kod golf , bayt cinsinden en kısa cevap kazanır;
• Standart kod-golf boşlukları geçerlidir;
• Programınız (teorik olarak) sonsuza dek çalışabilmelidir.

SmileBASIC, 86 77 71 bayt

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

DIALOGdokunmatik ekranda bir metin kutusu görüntüler. Nmetin kutusunun kaybolmadan önce ekranda kalacağı saniye sayısıdır. Öyleyse N, 0kullanıcı dokunmatik ekrandaki düğmeye basana kadar kalır.

DIALOGİade 1kullanıcı düğmeye basıldığında ise, ve 0o otomatik olarak kapatılır eğer. Böylece kullanıcı duraklatma düğmesine bastığında geri döner 1ve görüntüleme süresi, 0kronometreyi duraklatarak ayarlanır . Kullanıcı düğmeye tekrar bastıktan sonra, 1zamanlayıcıyı tekrar başlatarak ekran süresini tekrar ayarladık . Temel olarak, her zaman DIALOGdöner 1, gösterim zamanı arasında geçiş 1ve 0kullanan !=iki girişler 1 ya da 0 olduğu sürece mantıksal XOR eqivilant olan.

Python 2, 167 129 bayt

-36 bayt çoğunlukla * Maltysen'inctrl-c istisna kullanarak yakalama fikrini kullanarak - git kredi ver!
DLosc sayesinde -4 bayt ( yerine yerine 0 nve b0 f())
FlipTack sayesinde -1 bayt ( p^=1yerine yerine kullanın p=1-p)
Felipe Nardi Batista sayesinde -2 bayt (hassas özellikleri kaldır)

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

Orijinalim ile aynı, aşağıda, ancak kontrol tuşu dizisiyle çalışır ctrl+c.
(Benim tarafımdan Windows 7,
64bit'te Python 2.7.8 ile test edildi ; Brian Minton tarafından, Linux'ta Python 2.7.13 ile test edildi, 64bit)

* aynı zamanda iflisteyi trytek bir liner olarak alabilmek için ifadeyi daralttı.

Orijinalim:

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

(Windows 7, 64bit'te Python 2.7.8 ile benim tarafımdan test edildi - bu kod, ancak msvcrtkitaplığın kullanımı nedeniyle Windows'a özgüdür )

Kontrol anahtarı 'p'.

nve bbaşlangıçta aynı değere ilklendirilir, 0'a "ofset" verilir; pduraklatılmış bir durumu gösteren 0 olarak başlatılır.

Kontrol tuşuna her basıldığında değeri pdeğiştirilir. Duraklatılmış bir durumdan aktif bir duruma bgeçildiğinde, önceki aktif durumlardan herhangi bir mevcut ofset ile birlikte tutulan yeni bir değere güncellenir b-n.

Etkin bir durum sırasında n, arayarak şu anki zamana art arda güncellenir time.time().

nVe b, arasındaki fark , taktif durum (lar) sırasında geçen toplam saniye sayısıdır (kesirli kısım dahil).

O zaman geçen t/60dakikalar ve dakika ve saniyelerin her biri mod 60 ile gösterilir (t/60%60,t%60). Önde gelen sıfırlar, tamsayı parçasının dize biçimlendirmesini kullanarak her biri için hazırlanır '...%0.2d...'. ,İlk öğenin satır başı satırının döndüğü ( iz ) bir tuple basılması ( \r), önceden basılan metnin üzerine yazılmasına neden olur.

Python - 160 159 143 bayt

Beni 18 bayt kurtardığın için @JonathanAllan'a teşekkürler!

Yalnızca yerleşik kütüphaneleri kullanır, bu nedenle kontrol anahtarı bir ile ctrl-conu yakalamaktır 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 + Unix yardımcı programları, 90 veya 93 bayt

90 bayt sürümü:

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

93 bayt sürümü:

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

Ctrl-C, devam / duraklatma karakteridir. Boşluk, dakika ve saniye arasındaki sınırlayıcıdır.

İki sürüm arasındaki fark, 90 baytlık programın 2 ^ 63 saniye çalışacağıdır (bu noktada bash bana bir tamsayı taşması verecektir).

93-byte sürümü gerçekten sonsuza dek çalışacak.

Asıl sorun, aşağıdakileri içeriyordu: "Programınız (teorik olarak) sonsuza dek çalışabilmelidir."

Bu gereksinimi karşılamak için 2 ^ 63 saniye çalıştırmanız yeterliyse, 90 baytlık çözüm çalışır. Bu süre evrenin yaşının 20 katından fazla!

Programın bundan daha uzun bir süre çalışabilmesi gerekiyorsa, 93 baytlık çözümle devam edeceğim.

Muhtemelen, bu çözümün ve en azından gönderilenlerin bir kısmının , gerçek zamanın gerisinde kaldığının çok yavaş olacağına işaret etmeliyim . Bu kayma, programın döngünün gövdesinin her bir uygulaması arasında bir saniye boyunca uykuda kalmasıdır, ancak döngünün gövdesinin çalışması biraz zaman alır. Bu pratikte önemsiz olacaktır.

QBasic, 213 211 bayt

Kontrol tuşu sekmedir. Bu çalıştırmadan çıkmak, dizüstü bilgisayar yangınlarına neden olabilir. Uyarıldın.

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

İşte hareket halinde, 10, 15 ve 20 saniyede duraklıyor:

Ungolfed ve yorum yaptı

' 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

Değerlerinin TIMERkayan nokta olduğuna dikkat edin. Bu, çıktıyı etkilemez, çünkü MODve \tamsayıları keser. Ancak, kaydedilen zaman miktarına doğruluk ekler: zamanlayıcıyı bir onay işaretinden hemen önce durdurursanız, tekrar başladığınızda sayının bir saniyeden daha kısa sürede değiştiğini görürsünüz.

Toplu, 132 bayt

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

Basılması n(un) zamanlayıcıyı duraklatacaktır. Çıktı titremesi üç (veya dört) bayt maliyetinde azaltılabilir.

Saf bash, 141 bayt

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

Bu, Bash yerleşiklerinden başka bir şey kullanmaz (harici araç yok). Kontrol karakteri, Ctrl-Zstandart SIGTSTPkullanımın kronometreyi duraklatmasıdır.

• set -mgenellikle bir komut dosyasında kapalı olan iş denetimini etkinleştirir .
• Bir alt kabuk işlemi olup arka plana ( &) .
  • read -t 1kullanıcıdan giriş için bir saniye bekler , sonra başarısız olur.
  • untilDöngü uzun olduğu kadar devam readbaşarısız tutar.
  • printfçıkışları doğru dolgulu ve -dosyaları biçimlendirilmiş zaman
  • $[s=s>3598?0:s+1,s/60]aritmetik genişleme ilk önce güncellenmiş zamanı hesaplar , saniye sayacının kaydırılıp kaydırılmayacağını kontrol eder sve ardından döşemeli bölümü döndürür s/60.
  • $[s%60] saniye kalanını verir.
• Dış komut dosyası , sinyal için bir trapişleyici kurar . Ne zaman dış komut çalışırken basıldığında, o çalışacağı ve ön plana altkabuk geri koy . her seferinde subshell komutunu yazdırmayı durdurmak için gereklidir .TSTPCtrl-ZCtrl-Zfg>/dev/null>/dev/nullfg
• Komut ilk basar 00:00ve bir gönderir STOPsinyali için alt işlemi$! süreci duraklatır.
• read betiği canlı tutarak sonsuza dek girişi bekler.

Eğer Ctrl-Zaltkabuk ön plana basılırsa, o yürütmeye ara ve onu sessizce bekleyecek ön planda, dış komut dönecektir. Dış komut dosyası ön planlanmışsa, tuzak işleyicisi alt kabuğun çalışmasına devam eder ve yeniden sayılır.

Chrome konsolunda Javascript, 143 bayt

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)

Konsolda girildiğinde sayacı 00: 00'a yerleştirir ve daha sonra belge üzerinde tuşa basılan kontrolü sağlar.

Çok fazla sihir yok, özellikle (i/60)|0kat sayısı

Chrome konsolunda yapıldı ve test edildi

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

<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

açıklama

Kronometreyi başlatmak veya duraklatmak için zamanlayıcıyı tıklayın. Bu nedenle, tek bir tıklama kontrol anahtarıdır. İki değer arasındaki ayırıcı bir kolondur.

Kullanıcı tıklamayı tıkladığında değeri bkontrol edilir. 0Hangi değerlendirme yapıldığı için başlatılır false, böylece her 1000 milisaniyede bir kod dizisi değerlendirilir. Bu, değişkeni aralığın kimliğine ayarlar, böylece daha sonra durdurulabilir. Eğer bbir dizi içerir, bu olarak değerlendirilen truearalık durdurulur böylece. Bu değeri döndürür undefined, böylece döngü devam eder.

Kod dizisi, öğenin html kodunu id a(kronometre) ile değiştirir. Öncelikle, önceki kronometre değeri alınarak, iki nokta üst üste bölerek ve dakika değeri elde edilerek ayrıştırılır, saniye değeri 59 değilse (58'den büyükse) ve 0 ise modulo 60 Daha sonra bu değer doldurulur. Sonra iki nokta üst üste ve son olarak da saniyedir. Kod basitçe eski değeri alır, 1 arttırır, modulo 60 alır ve isteğe bağlı olarak onu doldurur.

C 309 179 bayt

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

Ungolfed versiyonu:

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

Kullanımı: Basın Enteriçin Pause ve Devam Kronometre.

Açıklama:

• İlk döngü olan Entertuşa basmayı bekleyin ve bir sonraki gelene kadar bekleyin .breakwhileEnter
• Bir sonraki Entertuş vuruşunda, gotoilk whiledöngü ve saymaya devam edin.

Şimdi, gotoC de kötü bir kodlama uygulaması olduğunu biliyorum , fakat başka bir yol bulamadım.

Javascript, 124 bayt

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)

'Kontrol anahtarı' belgeye bir tıklamadır. Bunu test etmek için kodu konsola veya <script>etiketin içindeki bir html dosyasına yapıştırın .

Açıklama:

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

Chrome'da test edildi

PHP, 94 91 bayt

Boşluk çubuğunun anahtar kodunun 32 olduğunu varsayarım (ki muhtemelen öyle değildir);
Şu anda ncurses test etme imkanım yok. Ancak kodun geri kalanı iyi çalışıyor.

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

-dan başlar 00:00 , ancak duraklama sona erdiğinde hemen

Sizde (benim gibi) ncurses yoksa , ikinci dateparametreyi $t+=$r^=!rand(sleep(1),19);veya ile değiştirerek test edebilirsiniz $t+=$r^=++$x%20<1+sleep(1);. ( sleepher zaman döner0 .)

Yıkmak

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 Bayt

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

    }
}

golfed

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

Kullanmak sBaşlatmak / durdurmak tuşunu kullanın. Tüm program kullanarak TimeDelta'yı hatırlayarak çalışırDateTime.Now

Buradaki çoğu C # -Magic, C # 7.0 özelliğinden gelir using static.

Bash, 65 bayt

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

Düzgün çalışması için bir dosya komut dosyasına yazılması gerektiğini unutmayın.

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

Açıklamak için genişletilmiş sürüm:

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

%(...)TPrintf işlevinin biçim 5+ bash geçerlidir.

C (gcc) , 121 115 bayt

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

Çevrimiçi deneyin!

SIGINT için, control-C tuşlarına basarak tetiklenen bir sinyal işleyicisini ayarlar. Bir zamanı ofset olarak tutarız bve duvar saati süresini eksi zaman ofsetini gösteririz. Duraklatılırsak, duvar saati gösterilen zamanı dondurmak için işaretlendiğinde her zaman zaman tabanını artırın.

6 bayt'ı tıraş eden @ceilingcat'e teşekkürler!

Zsh + Gnu tarih, 242 bayt

Saniyenin 1 / 100'ünde! Etkileşimli bir terminal gerektiriyor, ancak yine de bir TIO bağlantısı var .
Hit Entersayacını başlatmak / durdurmak için; Ctrl-Cçıkışa doğru.

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

Yorumlar (biraz güncel değil):

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

Commodore BASIC (C64 / TheC64 Mini, VIC-20, PET, C16 / + 4) - 147 belirtilmiş ve BASIC bayt

 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}listeleme Listesi SHIFT+CLR/HOMEbir açılış tırnak işareti bir PETSCII karakter olarak çıktılar sonra ise {home}olan CLR/HOMEbir açıklık tırnak işareti, aşağıdaki aynı koşuluyla kayması olmaksızın anahtar.

Boşluk çubuğunu kontrol tuşu olarak kullanın.

BASIC 7'deki Commodore 128 ile çalışmak için listeyi aşağıdaki satırlarda değiştirin:

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

Sayıma fazladan yedi belirteç ekler (tüm sayılar BASIC'de 7 bayt olarak depolandığından goto10, 8 belirtilmiş bayt iken gotosadece 1 olur).