La mia sveglia

Sono americano, così come la mia sveglia (digitale). Per impostare la sveglia, inizia nel momento precedente. Premendo il pulsante dell'ora lo si sposta di un'ora in su, e premendo il pulsante dei minuti lo si sposta di un minuto. Se si premono entrambi i pulsanti contemporaneamente, questo viene ripristinato a mezzanotte (12:00 am) e conta come due pressioni di pulsanti.

Quando le ore superano il loro limite (12), si reimposta su 1 e attiva / disattiva la luce AM / PM. Quando i minuti superano il limite massimo (59), vengono reimpostati su 0, senza influire sulle ore.

L'obiettivo

Il tuo compito è, dato un orario di inizio e un tempo target, di emettere il numero ottimale di pressioni di pulsanti necessarie per impostare la mia sveglia sull'ora target.

Puoi ricevere input in qualunque formato ti si adatti meglio. Gli unici dati di cui il tuo programma dovrebbe avere bisogno sono ore e minuti, per entrambi gli input. Ciò significa che, ad esempio, è possibile prendere i dati in millisecondi dall'epoca ed estrarre ore e minuti, ma non è possibile codificare nulla in anno, mese, secondo, ecc. Si noti che mentre è possibile, ad esempio, inserire utilizzando "tempo militare" (o orario normale per la maggior parte del mondo), ma ciò non cambia il funzionamento del mio orologio.

Esempi

1:15 pm -> 2:30 am

È possibile premere entrambi i pulsanti verso il basso per reimpostare alle 12:00, quindi aumentare fino alle 2:30 del mattino, ovvero la 2+2+30 = 34pressione dei pulsanti. Potresti anche aumentare alle 2:30 del mattino, che sarebbe la 13+15 = 28pressione dei pulsanti. Pertanto, il tuo output è 28.

3:58 am -> 4:02 am

È possibile ripristinare e incrementare, che sarebbe la 2+4+2 = 8pressione dei pulsanti. Potresti anche incrementare, che sarebbe la 1+4 = 5pressione dei pulsanti. Pertanto, il tuo output è 5.

10:55 pm -> 1:00 am

È possibile ripristinare e incrementare, che sarebbe la 2+1 = 3pressione dei pulsanti. Potresti anche incrementare, che sarebbe la 3+5=8pressione dei pulsanti. Pertanto, il tuo output è 3.

1:00 am -> 1:59 pm

È possibile ripristinare e incrementare, ma sarebbero tre ulteriori pressioni rispetto al solo incremento. Pertanto, il tuo output è 12+59 = 71.

Casi test

Current  Target   = Output
1:15pm   2:30am   = 28
3:58am   4:02am   = 5
10:55pm  1:00am   = 3
1:00am   1:59pm   = 71
12:00am  12:00am  = 0
6:51pm   12:00am  = 2
2:01pm   11:00pm  = 25
2:01pm   11:01pm  = 9
12:59am  12:01am  = 2
11:50am  12:00pm  = 11

Buccia , 16 byte

§▼ṁ→(Σz%e24 60z-

Provalo online!

Accetta gli argomenti come due elenchi [ore, minuti], per l'ora di inizio e di fine, nel formato 24 ore.

Sono abbastanza contento di quanto sono stato in grado di giocare a golf, trovo interessante come gli argomenti sono gestiti in questa composizione di funzioni.

La funzione che calcola quante pressioni di tasti sono necessarie se il reset non è consentito è la seguente:

Σz%e24 60z-
         z-    elementwise subtract the two times
 z%e24 60      take the hours difference modulo 24 and the minutes difference modulo 60
Σ              sum the two resulting numbers

La parte interessante è che dal momento che il resto di questa soluzione può funzionare solo con un singolo elenco come argomento, questo viene parzialmente applicato al primo argomento dell'intero programma, "mangiandolo" e lasciando visibile solo il secondo argomento sia per se stesso che per il resto del programma.

Quindi, calcoliamo quante pressioni di tasti sono necessarie se reimpostiamo l'ora su 0:00

ṁ→    take the sum of each element of the list increased by 1

Come detto prima, questo funziona solo sul secondo argomento (l'ultima volta) e calcola hours+minutes+2, solo in modo golfistico.

Infine, §▼è la parte che passa il secondo argomento a entrambe le funzioni e restituisce il minore dei due risultati.

JavaScript (ES6), 73 56 54 52 50 byte

Utilizza il formato 24 ore. Accetta input come 4 numeri interi che rappresentano le ore e i minuti di ogni volta.

(g,l,h,m)=>Math.min(2+h+m,(h-g+24)%24+(m-l+60)%60)

• 2 byte salvati grazie ad Arnauld .

Provalo

Immettere le ore nel formato 24 ore, con il :separatore.

o.innerText=(f=

(g,l,h,m)=>Math.min(2+h+m,(h-g+24)%24+(m-l+60)%60)

)(+(x=(i.value="01:00").split`:`)[0],+x[1],+(y=(j.value="13:59").split`:`)[0],+y[1]);oninput=_=>o.innerText=f(+(x=i.value.split`:`)[0],+x[1],+(y=j.value.split`:`)[0],+y[1])

label,input{font-family:sans-serif;font-size:14px;height:20px;line-height:20px;vertical-align:middle}input{margin:0 5px 0 0;width:100px;}

<label for=i>Current: </label><input id=i type=time><label for=j>Target: </label><input id=j type=time><pre id=o>

Spiegazione

(Da aggiornare a breve.)

(g,l,h,m)=>

Funzione anonima prendendo interi come argomenti tramite parametri g, l, he m, dove ge lsono, rispettivamente, le ore e minuti dell'ora corrente e h& msono le ore e minuti del tempo target.

2+h+m

Innanzitutto, calcoliamo quante pressioni dei pulsanti sono necessarie se ripristiniamo semplicemente l'orologio, che è semplicemente 2 (per il ripristino) più l'ora target e il minuto target.

h-g+24*(h<g)

Quindi calcoliamo quante pressioni dei pulsanti sono necessarie per raggiungere l'ora target. Lo facciamo sottraendo l'ora corrente dall'ora target. Tuttavia, se l'ora corrente è inferiore all'obiettivo, questo ci darà un numero negativo, quindi lo rettifichiamo aggiungendo 24 moltiplicato verificando se h<g(che restituisce un valore booleano ma viene implicitamente castato a numero intero 1, se vero, o 0se falso dal operazioni matematiche.

+m-l+60*(m<l)

Usiamo una formula simile per calcolare il numero di presse da ottenere dal minuto corrente al minuto target e aggiungerlo alle presse dell'ora.

Math.min()

Infine, otteniamo il minimo dei 2 numeri per darci il nostro risultato.

Pyth , 29 byte

Questa sfida ovviamente non avvantaggia le lingue del golf, ecco perché è così lunga. D'altra parte, questo è migliorato dal fatto che Pyth è basato su Python, quindi possiamo abusarne del modulo negativo.

hS,+%-eQ@Q1 60%-@Q2hQ24+2s>Q2

Test Suite. _{I numeri in Pyth non supportano gli zeri iniziali.}

Gelatina , 19 byte

_⁵%24µ+⁴_⁶%60µ«³+⁴¤

Provalo online!

Inserire come 4 numeri interi (fine ora, fine minuto, ora di inizio, minuto di inizio)

C # (.NET Core) , 56 byte

(H,M,h,m)=>Math.Min(((h+24-H)%24)+((m+60-M)%60),(2+h+m))

Provalo online!

Molto simile alla risposta Javascript. I bool in C # non si convertono facilmente in numeri, quindi invece di [diff]+24*(H<h)me, ([diff]+24)%24che fa effettivamente la stessa cosa.

Haskell, 41 byte

(a#b)c d=min(a+b+2)$mod(a-c)24+mod(b-d)60

Abbastanza diretto. Accetta input come quattro argomenti utilizzando l'ora di 24 ore: ora di fine, minuto di fine, ora di inizio, minuti di inizio.

Python 3 , 43 byte

lambda a,b,c,d:min((c-a)%24+(d-b)%60,2+c+d)

Provalo online!

Inserire come 4 numeri interi (ora di inizio, minuti di inizio, ore di fine, minuti di fine)

Java 8, 54 50 byte

(h,m,H,M)->Math.min((H-h+24)%24+(M-m+60)%60,H+M+2)

Porta della risposta C # di @KamilDrakari (dopo aver golfato 2 6 byte).

Spiegazione:

Provalo qui.

(h,m,H,M)->       // Method with four integer parameter and integer return-type
  Math.min(       //  Return the lowest of the following two:
                  //   The hours:
   (H-h           //    Second hours - first hours inputs
       +24)       //    +24 so we won't have negative numbers
           %24    //    mod-24 to get the hours
   +              //   And add the minutes:
    (M-m          //    Second minutes - first minutes inputs
         +60)     //    +60 so we won't have negative numbers
             %60  //    mod-60 to get the minutes
    ,H+M          //  And compare it to the second hours + second minutes inputs
        +2)       //   +2 for the added +24 and +60 to get the positive modulo arguments

Perl 5 , 71 +2 (-ap) = 73 byte

($w,$x,$y,$z)=@F;$_=($r=2+$y+$z)>($c=($y-$w+24)%24+($z-$x+60)%60)?$c:$r

Provalo online!

Accetta input nel formato 24 ore (ora militare), separato da spazi, ora di inizio prima, ora di fine seconda: HH MM hh mm

Retina , 106 byte

\d+
$*
 (1*):(1*)
 24$*1$1:60$*1$2#11$1$2
(1*):(1* )\1(1{24})?
$2
(1*) (1*):\1(1{60})?
$2
(1+)#(?!\1)

\G1

Provalo online! Il link include casi di test. Accetta input come tempi correnti e desiderati in 24 ore regolari con uno spazio che separa le due volte. Spiegazione:

\d+
$*

Converti in unario.

 (1*):(1*)
 24$*1$1:60$*1$2#11$1$2

Questo fa due cose; aggiunge 24 ore e 60 minuti alle ore e ai minuti desiderati e aggiunge anche 2 alla somma delle ore e dei minuti desiderati originali, ovvero il numero di pulsanti che si premono per impostare usando un reset.

(1*):(1* )\1(1{24})?
$2

Sottrarre le ore correnti dalle ore desiderate e sottrarre le 24 che abbiamo aggiunto se possibile.

(1*) (1*):\1(1{60})?
$2

Allo stesso modo per i minuti. Questo aggiunge anche i due risultati insieme.

(1+)#(?!\1)

Se il numero di presse da impostare utilizzando l'ora corrente è superiore al numero di presse da impostare utilizzando un ripristino, eliminarlo.

\G1

Convertire il primo numero rimanente in decimale.