Вкажіть простий цифровий секундомір , який відображатиме час, що минув у секундах і хвилинах, як описано нижче.

Важливо

Прочитайте розділи Дисплей та елементи керування !

Дисплей

Час, що минув, повинен відображатися у MM:SSформаті, замінюючи попередньо відображений часовий рядок "на місці" (очищення всього або частини екрана також дозволено).

Секундомір потрібно оновлювати щонайменше щосекунди.

Приклади:

0 хвилин, 0 секунд

00:00

0 хвилин, 33 секунди

00:33

1 хвилина, 50 секунд

01:50

Спочатку ви можете починати з '00: 00 'або з будь-якого іншого значення в діапазоні [00: 00-59: 59].

Як тільки секундомір досягне 59:59, він повинен скинутись 00:00і продовжити знову.

Ви можете використовувати іншу основу (замість десяткової) або навіть іншу систему числення, якщо бажаєте, дотримуйтесь загальної схеми.

Наприклад, 13:03може відображатися як:

Десяткові

13:03

Шестидесятковий

0D:03

База64

N:D

Квартально-уявна база

10101:3

Римські цифри

XIII:III

Пам’ятайте, що якщо ви використовуєте недесяткову систему / базу чисел, вона повинна бути закодована за допомогою друкованих символів ASCII (або Unicode), наприклад, використання двох двійкових (недрукувальних) байтів протягом хвилин і секунд заборонено.

Ви також повинні залишити ліворуч ваш висновок з нулями, якщо це доречно, якщо ваша система числення дозволяє це.

Заміна символу роздільника :будь-яким іншим символом для друку (включаючи цифри) також прийнятна.

Управління

Секундомір повинен почати призупинено і залишатися в такому стані, поки користувач явно не запустить його, натиснувши клавішу "управління" (див. Нижче).

Якщо під час підрахунку секундоміра користувач знову натискає клавішу "управління" , секундомір повинен призупинятися (зберігаючи поточний час), поки клавіша "управління" не буде натиснута ще раз.

«Контроль» ключ може бути одним натисканням клавіші, наприклад s, або будь-яку комбінацію клавіш, наприклад Ctrl+Shift+X, але це повинно бути «атомне», натиснувши кілька клавіш в послідовності, наприклад , sтоді Enter, це не допускається .

Той же «контроль» ключ (або комбінація) повинна бути використана для припинення і відновлення секундоміра.

Ви повинні використовувати певну клавішу "управління" , тобто "будь-яка клавіша" заборонена.

Крім того, ви можете використовувати один або подвійний клацання миші, а не натискання клавіші для "управління".

Правила

• Це код-гольф , найкоротша відповідь у байтах виграє;
• Застосовуються стандартні лазівки з кодовим гольфом;
• Ваша програма (теоретично) повинна бути здатна працювати вічно.

SmileBASIC, 86 77 71 байт

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

DIALOGвідображає текстове поле на сенсорному екрані. N- це кількість секунд текстове поле залишиться на екрані, перш ніж воно зникне. Якщо Nце так 0, він залишається, поки користувач не натисне кнопку на сенсорному екрані.

DIALOGПовертається, 1якщо користувач натиснув кнопку, і 0якщо вона автоматично закрилася. Отже, коли користувач натискає кнопку паузи, вона повертається 1, і час відображення встановлюється на 0, призупиняючи секундомір. Після того, як користувач знову натисне кнопку, ми повертаємо час відображення до 1, відновлюючи таймер. По суті, кожен раз, коли DIALOGповертається 1, час відображення перемикається між 1і 0використовує !=, що є еквівалентним логічному XOR до тих пір, поки обидва входи дорівнюють 1 або 0.

Python 2, 167 129 байт

-36 байт здебільшого * від використання ідеї Малтісена про ловлю ctrl-cза допомогою винятку - ідіть, дайте кредит!
-4 байти завдяки DLosc (init nта b0, а не f())
-1 байт завдяки FlipTack (використовуйте, p^=1а не p=1-p)
-2 байти завдяки Felipe Nardi Batista (видаліть специфікатори точності)

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

Працює так само, як у моєму оригіналі, нижче, але з послідовністю контрольних клавіш ctrl+c.
(Тестував мене з Python 2.7.8 на Windows 7, 64bit;
Тестував Брайан Мінтон з Python 2.7.13 на Linux, 64bit)

* також згорнуто ifоператор до пошуку списку, щоб отримати tryяк однолінійку.

Мій оригінал:

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

(Випробувано мною з Python 2.7.8 на Windows 7, 64bit - однак цей код є специфічним для Windows через використання msvcrtбібліотеки)

Клавіша керування - "p".

nі bініціалізуються на одне значення при запуску, даючи "зміщення" 0; pініціалізується на 0, що вказує на призупинений стан.

Кожного разу, коли натискається клавіша управління p, перемикається значення. При переході з призупиненого стану в активний стан bоновлюється на нове значення, зберігаючи будь-яке поточне зміщення від попереднього активного стану b-n.

Під час активного стану nнеодноразово оновлюється до поточного часу, зателефонувавши time.time().

Різниця між nта b, t- це загальна кількість секунд (включаючи дробову частину), що минула під час активного стану.

Потім минули хвилини, t/60і кожна з хвилин і секунд відображається на моді 60 с (t/60%60,t%60). Провідні нулі готуються до кожного, використовуючи форматування рядків цілої частини з '...%0.2d...'. Друк кортежу (кінцевий ,), де перший елемент має провідне повернення каретки ( \r), спричиняє перезапис попередньо надрукованого тексту.

Пітон - 160 159 143 байт

Дякую @JonathanAllan, що врятував мені 18 байт!

Використовує лише вбудовані бібліотеки, тому керуючий ключ - ctrl-cце логічний ключ 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 утиліти, 90 або 93 байти

90-байтна версія:

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

93-байтна версія:

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

Ctrl-C - символ відновлення / паузи. Пробіл - це роздільник між хвилинами та секундами.

Різниця між двома версіями полягає в тому, що 90-байтна програма буде працювати 2 ^ 63 секунди (в цей момент bash дасть мені переповнення цілого числа).

93-байтна версія справді буде працювати назавжди.

Початкова проблема включала вимогу: "Ваша програма повинна (теоретично) бути здатною працювати вічно".

Якщо для виконання цієї вимоги вистачає 2–63 секунди, то 90-байтове рішення працює. Ця тривалість більше ніж у 20 разів перевищує вік Всесвіту!

Якщо програмі потрібно мати можливість запускатись довше, мені доведеться попрацювати з 93-байтовим рішенням.

Я, мабуть, повинен зазначити, що це рішення, як і принаймні деякі з опублікованих інших, буде дуже повільно відставати від справжнього минулого часу. Це пробуксування відбувається через те, що програма спить протягом однієї секунди між кожним виконанням тіла циклу, але тіло циклу вимагає трохи часу, щоб виконати. На практиці це буде несуттєвим.

QBasic, 213 211 байт

Клавіша управління - вкладка. Якщо не працювати, це може спричинити пожежу на ноутбуці. Вас попередили

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

Ось воно в дії, пауза на 10, 15 та 20 секунд:

Негольфірованний і прокоментував

' 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

Зауважте, що значення значень з TIMERплаваючою комою. Це не впливає на вихід, оскільки MODі \скорочується до цілих чисел. Але це додає точності до кількості заощадженого часу: якщо ви призупинили таймер прямо перед галочкою, ви побачите, коли ви знову запускаєте його, що число змінюється менше ніж на секунду.

Пакетна, 132 байти

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

Натискання n(не) призупинить таймер. Мерехтіння виходу може бути зменшено вартістю трьох (або чотирьох) байт.

Чистий баш, 141 байт

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

Тут не використовується нічого, крім Bash вбудованих (ніяких зовнішніх інструментів). Характер управління такий Ctrl-Z, що стандартне SIGTSTPкерування зупиняє секундомір.

• set -mдозволяє контролювати завдання , яке зазвичай вимкнено в сценарії.
• Подоболочка процес фоновий ( &) .
  • read -t 1чекає одну секунду для введення від користувача , а потім не працює.
  • untilЦикл триває до тих пір , поки readпродовжує невдачу.
  • printfвиводить правильно прокладений та -форматований час
  • $[s=s>3598?0:s+1,s/60]арифметичне розширення спочатку обчислює оновлений час, перевіряючи, чи потрібно обертати та іншим чином збільшувати лічильник секунд s, а потім повертає флорированний поділ s/60.
  • $[s%60] дає решту секунд.
• Зовнішній скрипт встановлює trapобробник для TSTP, сигнал Ctrl-Zгенерує. Якщо Ctrl-Zнатиснути, коли працює зовнішній скрипт, він запуститься fg>/dev/nullі поставить передній план на передній план . >/dev/nullнеобхідно fgщоразу припиняти роздрукувати команду subshell.
• Скрипт виводить початкове 00:00і посилає STOPсигнал в дочірній процес$! , який буде призупинити процес.
• read чекає введення назавжди, зберігаючи сценарій живим.

Якщо Ctrl-Zнатиснути, коли передплановий план передній план, він призупинить виконання та поверне зовнішній скрипт на передній план, де він буде мовчки чекати. Якщо зовнішній скрипт заздалегідь виділений, обробник пастки відновить виконання підпарки, і він буде рахуватися знову.

Javascript у консолі Chrome, 143 байти

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)

При введенні в консоль він вмикає лічильник до 00:00, а потім активує управління, яке натискає клавішу в документі.

Не так багато магії відбувається, зокрема, кількість (i/60)|0поверхів

Виконано та перевірено на консолі Chrome

HTML + JavaScript (ES6), 191 192 187 183 174 байт

<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

Пояснення

Клацніть таймер, щоб запустити або призупинити секундомір. Таким чином, одним клацанням миші є керуюча клавіша. Роздільник між двома значеннями - двокрапка.

Щоразу, коли користувач натискає клавішу, bперевіряється значення. Він ініціалізується, до 0якого оцінюється false, тому рядок коду оцінюється кожні 1000 мілісекунд. Це встановлює змінну на id інтервалу, тому її можна буде зупинити пізніше. Якщо bмістить число, воно оцінюється на true, тому інтервал зупиняється. Це повертає значенняundefined , тому цикл триває.

Рядок коду змінює html елемента з id a(секундомір). Спочатку хвилини аналізуються, беручи попереднє значення секундоміра, розділяючи його на двокрапку і отримуючи значення хвилини, яке збільшується на 0, якщо значення секунд не 59 (більше 58), а 1, інакше, модуль 60 Потім ця величина занижена. Потім йде двокрапка, і, нарешті, секунди. Код просто отримує старе значення, збільшує його на 1, бере модуль 60 і необов'язково прошиває його.

C 309 179 байт

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

Негольована версія:

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

Використання: Натисніть Enterдля призупинення та відновлення секундоміра.

Пояснення:

• Зачекайте Enterнатискання клавіші, breakперший whileцикл і дочекайтеся наступного Enter.
• Після наступного Enterнатискання клавіші gotoспочатку whileцикл і відновлення підрахунку.

Тепер я знаю goto, що це погана практика кодування в C, але я не міг з'ясувати інший спосіб.

Javascript, 124 байти

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)

"Клавіша управління" - це клацання по документу. Щоб перевірити це, вставте код у консоль або у файл html всередині <script>тегу.

Пояснення:

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

PHP, 94 91 байт

Я припускаю, що 32 є ключовим кодом для пробілу (якого, мабуть, немає);
На даний момент я не можу перевірити нуклеуси. Але решта коду працює чудово.

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

починається з 00:00, але збільшується відразу, коли пауза закінчується

Якщо у вас (як у мене) немає ncurses, ви можете перевірити, замінивши другий dateпараметр на $t+=$r^=!rand(sleep(1),19);або $t+=$r^=++$x%20<1+sleep(1);. ( sleepзавжди повертається 0.)

зламатися

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 байт

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

    }
}

Гольф

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клавішу для запуску / зупинки. Вся програма працює за допомогою запам'ятовування TimeDelta за допомогоюDateTime.Now

Більшість C # -Magic тут походить від функції C # 7.0 using static.

Баш, 65 байт

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

Зауважте, що для правильної роботи він повинен бути записаний у файловий скрипт, або ж спробуйте:

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

Розширена версія, щоб пояснити це:

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

%(...)TФормат Printf дійсний Баш 5+.

C (gcc) , 121 115 байт

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

Спробуйте в Інтернеті!

Встановлює обробник сигналу для SIGINT, який спрацьовує натисканням клавіші управління-C. Ми зберігаємо компенсацію часуb і відображаємо настінні годинники мінус зміщення часу. Якщо ми призупинилися, збільшуйте базу часу щоразу, коли настінний годинник тикне, щоб заморозити відображений час.

Дякуємо @ceilingcat за бриття 6 байтів!

Zsh + Gnu дата, 242 байти

Завдяки 1 / 100th секунди! Для цього потрібен інтерактивний термінал, але ось TIO посилання все одно.
Натисніть Enterдля запуску / зупинки таймера; Ctrl-Cдля виходу.

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

Коментарі (трохи застарілі):

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 токенізованих та 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}у списку вказано, SHIFT+CLR/HOMEщо виводиться як один символ PETSCII, коли слідує за початковою лапкою, тоді як {home}-CLR/HOME ключ без зсуву за тієї ж умови, що слідує за початковою лапкою.

Використовуйте пробіл як клавішу управління.

Щоб працювати з Commodore 128 в BASIC 7, змініть перелік у наступних рядках:

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

Додає до рахунку додаткові сім жетонів (оскільки всі числа зберігаються в BASIC як 7 байт, так goto10і 8 байтів з токенізацією, тоді як gotoце лише 1).