Mi piacciono molto i tempi che seguono determinati schemi. In particolare, mi piacciono i tempi in cui tutte le cifre sono uguali o tutte le cifre aumentano aritmeticamente di una da sinistra a destra. Inoltre, odio visceralmente quando le persone mettono le lettere ai miei tempi, quindi tutte queste assurdità di AM / PM sono morte per me. Quindi, i miei tempi preferiti sono:

0000 0123 1111 1234 2222 2345

Per la mia pace della mente, ho bisogno di te per scrivermi un unico programma che, data l'ora attuale come input, sia: (A) se è non è ora uno dei miei momenti preferiti, mi dice sia (i) quanti minuti si è è stato dalla mia ultima volta preferita e (ii) da quanti minuti passerà la mia prossima ora preferita; e (B) se ora è uno dei miei tempi preferiti, fornisce un singolo "valore del segnale".

Ingresso

Il programma dovrebbe accettare (con qualsiasi metodo: argomento della funzione, argomento della stdinriga di comando, ecc.) L'ora corrente, in uno dei seguenti formati:

• Un tempo di quattro cifre come una stringa

• Un numero intero che può essere azzerato a sinistra per creare un tempo di quattro cifre come stringa

• Una sequenza di quattro (o meno) numeri interi, ordinata in modo tale che il primo numero intero nella sequenza sia la cifra (significativa) più a sinistra nell'input temporale (ad esempio, 0951potrebbe essere validamente rappresentato come [0, 9, 5, 1]o [9, 5, 1])

  • La rappresentazione 0000come sequenza di lunghezza zero è accettabile

Nel caso di un input di stringa, dovrebbe contenere solo cifre, nessun punto e virgola o altra punteggiatura. Si può presumere che gli ingressi siano sempre validi 24 ore su 24:, HHMM dove 0 <= HH <= 23e 0 <= MM <= 59. Ignorare la possibilità di un secondo di salto.

Produzione

Il programma deve fornire (i ritorni di funzione stdout, ecc. Vanno bene) (A) o (B) , a seconda che il valore di input sia o meno un tempo target.

Per un):

Fornisci due valori numerici in qualsiasi formato sensibile, ad esempio:

• Uscita a stringa singola con un delimitatore adatto

• Uscite sequenziali di numeri interi / stringhe, ad es. bashStampa di due righe su stdout:

  49
  34
  

• Lunghezza-due valori restituiti ordinati, come un elenco Python, un array C, ecc .: [49, 34]

I valori possono venire in entrambi gli ordini. Ad esempio, entrambi i seguenti sarebbero output validi per un input di 1200:

49 34
34 49

L'ordine e il separatore devono essere uguali per tutti i valori di input!

Per (B):

Produrre qualsiasi risultato altrimenti irraggiungibile. Lo stesso risultato deve essere prodotto per tutti e sei i tempi target, tuttavia. I loop infiniti sono esclusi.

Ingressi / uscite campione

YAY!!! è usato qui come esempio dimostrativo e non è prescrittivo.

Input      Output
------    --------
 0000      YAY!!!
 0020      20 63
 0105      65 18
 0122      82 1
 0123      YAY!!!
 0124      1 587
 0852      449 139
 1111      YAY!!!
 1113      2 81
 1200      49 34
 1234      YAY!!!
 1357      83 505
 1759      325 263
 1800      326 262
 1801      327 261
 2222      YAY!!!
 2244      22 61
 2345      YAY!!!
 2351      6 9

Questo è code-golf , quindi vince il codice più breve in byte. Le scappatoie standard non sono ammesse.

Gelatina , 34 33 32 31 28 byte

3 byte grazie a Mr. Xcoder .ịe ³trucchi.

d³ḅ60;15j83,588ṁ5¤_\ṠÞAµ.ịxẠ

Provalo online!

Alcune parti sono esattamente come nella risposta di Jonathan Allan , ma la sto pubblicando perché penso che sia sufficientemente diversa da essa e scritta indipendentemente sulla base della mia risposta Pyth (e più breve: D). Dovrebbe anche avere margini di miglioramento.

L'input è un numero intero, l'output è un array di volte precedente e successivo o l'array vuoto per tempi speciali.

Spiegazione

Utilizzando input di esempio 1200.

• d³converte il tempo alla base 100, in ore e minuti: [12,0].
• ḅ60convertiti dalla base 60 per ottenere minuti totali: 720.
• ;15unendolo 15: [720, 15].
• 83,588crea l'array [83, 588].
• ṁ5rende lunghezza 5: [83, 588, 83, 588, 83].
• ¤combina le due azioni precedenti. Solo un tecnicismo.
• junisce la coppia con la matrice: [720, 83, 588, 83, 588, 83, 15].
• _\sottrae ogni valore di matrice dalla prima e ottiene risultati intermedi: [720, 637, 49, -34, -622, -705, -720].
• ṠÞ stabilmente ordina questi da signum: [-34, -622, -705, -720, 720, 637, 49].
• Aassume i valori assoluti: [34, 622, 705, 720, 720, 637, 49].
• µinizia una nuova catena monadica. Ancora una volta, un tecnicismo.
• .ịprende le voci ultimo e il primo: [49, 34].
• ×Ạripete che una volta che se non ci sono zeri, o zero volte altrimenti: [49, 34].

JavaScript (ES6), 87 83 byte

Risparmiato 4 byte grazie a @ l4m2

Accetta l'input come stringa. Restituisce uno 0o due array di elementi.

t=>[i=0,83,588,83,588,83,15].every(d=>(k=t-(t/25>>2)*40)>(j=i,i+=d))|i-k&&[k-j,i-k]

Casi test

let f =

t=>[i=0,83,588,83,588,83,15].every(d=>(k=t-(t/25>>2)*40)>(j=i,i+=d))|i-k&&[k-j,i-k]

console.log(f('0000')) // YAY!!!
console.log(f('0020')) // 20 63
console.log(f('0105')) // 65 18
console.log(f('0122')) // 82 1
console.log(f('0123')) // YAY!!!
console.log(f('0124')) // 1 587
console.log(f('0852')) // 449 139
console.log(f('1111')) // YAY!!!
console.log(f('1113')) // 2 81
console.log(f('1200')) // 49 34
console.log(f('1234')) // YAY!!!
console.log(f('1357')) // 83 505
console.log(f('1759')) // 325 263
console.log(f('1800')) // 326 262
console.log(f('1801')) // 327 261
console.log(f('2222')) // YAY!!!
console.log(f('2244')) // 22 61
console.log(f('2345')) // YAY!!!
console.log(f('2351')) // 6 9

Come?

Non ci interessa il risultato del .every()loop. A condizione che l'input sia valido, sarà sempre errato. Ciò a cui siamo veramente interessati è quando usciamo da questo ciclo.

Usciamo non appena troviamo un tempo preferito i(espresso in minuti) che è maggiore o uguale al tempo di riferimento k(il tempo di input tconvertito in minuti). Restituiamo quindi 0se i == ko i 2 ritardi altrimenti.

Befunge-93, 88 85 86 80 74 byte

&:"d"/58**-:"S"-:"b"6*-:"S"v
@._v#!:<\-*53:-"S":-*6"b":-<
:$#<$$\^@.._\#`0

Provalo online!

Emette il numero di minuti dall'ultima ora preferita, seguito dal numero di minuti fino all'ora preferita successiva (separati dalla sequenza di due caratteri: spazio, trattino). Se è già l'ora preferita, viene restituito un singolo zero.

C, 121 byte

*p,l[]={0,83,671,754,1342,1425,1440};f(t){t=t%100+t/100*60;for(p=l;t>*p;++p);*p-t?printf("%d %d",t-p[-1],*p-t):puts("");}

Emette una nuova riga se l'ora è quella preferita.

Provalo online!

Pulito , 126 byte

import StdEnv
f=[1440,1425,1342,754,671,83,0]
?t#t=t rem 100+t/100*60
=(\(a,b)=(t-hd b,last a-t))(span(\a=t<a||isMember t f)f)

Definisce la funzione ?, prendendo Inte ritornando (Int, Int).
Quando l'argomento è un momento preferito, si blocca con il programma chiamante hd of [].

Provalo online!

Pyth, 48 45 42 byte

&*FJ.u-NY+P*3,83 588 15isMcz2 60,eK._DJ_hK

Provalo online. Suite di test.

Il codice accetta una stringa temporale e restituisce le volte precedente e successiva come un array o 0se l'ora è speciale.

È interessante notare che un approccio imperativo è anche di 42 byte:

V+_isMcz2 60+P*3,83 588 15KZIg0=-ZNIZK)_ZB

Spiegazione

• cz2divide input ( z) in pezzi di due caratteri.
• sM li valuta come numeri interi.
• i... 60analizza l'array a due elementi risultante come base 60.
• ,83 588rappresenta l'array [83, 588].
• *3triplica quello a [83, 588, 83, 588, 83, 588].
• Primuove l'ultimo 588.
• +... 15aggiunge 15alla fine.
• .u-NYinizia dal numero analizzato, sottrae da esso ogni numero dell'array e restituisce i valori intermedi. Queste sono le differenze da ogni momento speciale.
• Jassegna queste differenze a J.
• *Fcalcola il prodotto delle differenze. Questo sarà 0 se l'ora era speciale.
• & interrompe la valutazione qui e restituisce 0 se l'orario era speciale.
• ._DJ stable ordina le differenze per segno.
• Ksalva quell'array in K.
• e accetta l'ultimo elemento dell'array.
• _hK prende il primo oggetto nell'array e lo nega.
• , restituisce i due come un array.

Gelatina ,  33 32  34 byte

 +3  +2 byte da sistemare in modo che tutti gli output di tempo graditi siano uguali.

^{devo essere un modo più breve!}

s2Ḍḅ60
83,588ṁ5“¡Ð‘j+\ṡ2>E¥ÞÇḢạÇa\

Un collegamento monadico che prende un elenco di quattro cifre e restituisce un elenco contenente due numeri interi
- se è un momento gradito il risultato entrambe le voci saranno zeri.

Provalo online! o vedi la suite di test .

Come?

s2Ḍḅ60 - helper link, getMinuteOfDay: list of digits, D   e.g. [1,2,3,3]
 2     - literal two                                           2
s      - split into chunks of length                           [[1,2],[3,3]]
  Ḍ    - un-decimal (convert from base 10) (vectorises)        [12,33]
    60 - literal sixty                                         60
   ḅ   - un-base (convert from base)                           753

83,588ṁ5“¡Ð‘j+\ṡ2>E¥ÞÇḢạÇa\ - Link: list of digits        e.g. [1,2,3,3]
83,588                      - literal list of integers         [83,588]
       5                    - literal five                     5
      ṁ                     - mould like (implicit range of) [83,588,83,588,83]
        “¡Ð‘                - code-page index list             [0,15]
            j               - join                           [0,83,588,83,588,83,15]
              \             - cumulative reduce with:
             +              -   addition                     [0,83,671,754,1342,1425,1440]
                2           - literal two                      2
               ṡ            - overlapping slices of length     [[0,83],[83,671],[671,754],[754,1342],[1342,1425],[1425,1440]]
                     Ç      - last link (1) as a monad f(D)    753
                    Þ       - sort by:
                   ¥        -   last two links as a dyad:
                 >          -     greater than? (vectorises)    [0, 0] [ 0,  0] [  0,  1] [  1,   1] [   1,   1] [   1,   1]
                  E         -     equal?                          1       1         0         1           1           1
                            -                             -->  [[671,754],[0,83],[83,671],[754,1342],[1342,1425],[1425,1440]]
                      Ḣ     - head                             [671,754]
                        Ç   - last link (1) as a monad f(D)    753
                       ạ    - absolute difference (vectorises) [ 82,  1]
                          \ - cumulative reduce with:
                         a  -   AND                            [ 82,  1]
                            -   -- such that if "liked" then the [0,x] result becomes [0,0] so they are all equal

Buccia , 36 byte

?↑2↑0Πṙ_1†aÖ±↔Ġ-::15t*3e588 83B60†d½

Provalo online!

Grazie a Zgarb per avermi spiegato come funzionano i ternari in chat. Cercando di giocare a golf ↑0, ma per qualche motivo non l'ho fatto funzionare altrimenti (?). Questa è la mia prima risposta non banale di Husk e, lasciando da parte il sopra citato, ne sono abbastanza soddisfatto. Il valore utilizzato al posto di YAY!!!è[] (ma spero che cambierà ai fini del golf).

Spiegazione

? ↑ 2 ↑ 0Πṙ_1 † aÖ ± ↔Ġ - :: 15t * 3e588 83B60 † d½ | Inserimento come elenco di cifre da CLA, output a STDOUT.

                                   ½ | Dividi l'elenco in due metà.
                                 † d | Trasforma ogni metà in un numero intero di base 10.
                              B60 | Converti dalla base 60.
                : | Aggiungi quanto sopra a ↓ ([15, 83, 588, 83, 588, 83]).
                       e588 83 | Creare l'elenco di due elementi [588, 83].
                     * 3 | Ripeti tre volte.
                    t | Rimuovi il primo elemento.
                 : 15 | Prepara un 15.
              Ġ- | Applica sottrazione cumulativa da destra.
             ↔ | Inverso.
           Ö ± | Ordinamento stabile per segno (-1, 0 o 1).
         † a | Mappa valore assoluto.
      ṙ_1 | Ruota di una a destra.
? Π | Se il prodotto è veritiero, allora:
 ↑ 2 | Prendi i primi due elementi.
   ↑ 0 | Restituisce un elenco vuoto altrimenti.

Kotlin , 293 byte

{fun i(l:List<Int>)=l.all{it==l[0]}|| l.mapIndexed{a,b->b-a}.all{it==l[0]}
val a=(0..1439+0).map{val h=it/60
val m=it%60
listOf(h/10,h%10,m/10,m%10)}+listOf(listOf(0,0,0,0))
val s=a.indexOf(it)
if(i(it))0 to 0 else
s-a.subList(0,s).indexOfLast{i(it)}to a.subList(s,a.size).indexOfFirst{i(it)}}

Abbellire

{
    fun i(l:List<Int>)=l.all { it ==l[0] } || l.mapIndexed { a, b -> b - a }.all { it ==l[0] }
    val a = (0..1439 + 0).map {
        val h = it/60
        val m = it%60
        listOf(h/10,h%10,m/10,m%10)
    } + listOf(listOf(0,0,0,0))
    val s = a.indexOf(it)
    if (i(it)) 0 to 0 else
        s - a.subList(0, s).indexOfLast {i(it)} to a.subList(s, a.size).indexOfFirst {i(it)}
}

Test

var t:(i:List<Int>)-> Pair<Int, Int> =
{fun i(l:List<Int>)=l.all{it==l[0]}|| l.mapIndexed{a,b->b-a}.all{it==l[0]}
val a=(0..1439+0).map{val h=it/60
val m=it%60
listOf(h/10,h%10,m/10,m%10)}+listOf(listOf(0,0,0,0))
val s=a.indexOf(it)
if(i(it))0 to 0 else
s-a.subList(0,s).indexOfLast{i(it)}to a.subList(s,a.size).indexOfFirst{i(it)}}

data class Test(val input: List<Int>, val output: Pair<Int, Int>)

val TEST = listOf(
    Test(listOf(0,0,0,0), 0 to 0),
    Test(listOf(0,0,2,0), 20 to 63),
    Test(listOf(0,1,0,5), 65 to 18),
    Test(listOf(0,1,2,2), 82 to 1),
    Test(listOf(0,1,2,3), 0 to 0),
    Test(listOf(0,1,2,4), 1 to 587),
    Test(listOf(0,8,5,2), 449 to 139),
    Test(listOf(1,1,1,1), 0 to 0),
    Test(listOf(1,1,1,3), 2 to 81),
    Test(listOf(1,2,0,0), 49 to 34),
    Test(listOf(1,2,3,4), 0 to 0),
    Test(listOf(1,3,5,7), 83 to 505),
    Test(listOf(1,7,5,9), 325 to 263),
    Test(listOf(1,8,0,0), 326 to 262),
    Test(listOf(1,8,0,1), 327 to 261),
    Test(listOf(2,2,2,2), 0 to 0),
    Test(listOf(2,2,4,4), 22 to 61),
    Test(listOf(2,3,4,5), 0 to 0),
    Test(listOf(2,3,5,1), 6 to 9)
)

fun main(args: Array<String>) {
    for (t in TEST) {
        val v = t(t.input)
        if (v != t.output) {
            throw AssertionError("$t $v")
        }
    }
}

TIO

TryItOnline