Eu realmente gosto de momentos que seguem certos padrões. Em particular, gosto de momentos em que todos os dígitos são iguais ou todos os dígitos aumentam aritmeticamente um da esquerda para a direita. Além disso, eu visceralmente odeio quando as pessoas escrevem cartas nos meus tempos, então todo esse absurdo AM / PM está morto para mim. Assim, meus horários favoritos são:

0000 0123 1111 1234 2222 2345

Para a minha paz de espírito, eu preciso de você para me escrever um único programa que, dado o tempo atual como entrada, tanto: (A) se for não agora um dos meus momentos favoritos, diz-me tanto (i) quantos minutos é desde o meu último horário favorito e (ii) quantos minutos a partir de agora meu próximo horário favorito ocorrerá; e (B) se agora é um dos meus momentos favoritos, fornece um único 'valor de sinal'.

Entrada

Seu programa deve aceitar (por qualquer método: argumento da função, argumento da stdinlinha de comando, etc.) a hora atual, em qualquer um dos seguintes formatos:

• Um tempo de quatro dígitos como uma sequência

• Um número inteiro que pode ser preenchido com zero à esquerda para criar um tempo de quatro dígitos como uma sequência

• Uma sequência de quatro (ou menos) números inteiros, ordenada de modo que o primeiro número inteiro na sequência seja o dígito mais à esquerda (significativo) na entrada de tempo (por exemplo, 0951poderia ser validamente representado como [0, 9, 5, 1]ou [9, 5, 1])

  • Representar 0000como uma sequência de comprimento zero é aceitável

No caso de uma entrada de sequência, ela deve conter apenas dígitos, sem dois pontos ou outra pontuação. As entradas podem ser consideradas sempre válidas em 24 horas:, HHMM onde 0 <= HH <= 23e 0 <= MM <= 59. Desconsidere a possibilidade de um segundo de salto.

Resultado

Seu programa deve fornecer (retornos de função stdout, etc. estão bem) (A) ou (B) , conforme apropriado, para determinar se o valor de entrada é ou não um tempo alvo.

Para):

Forneça dois valores numéricos em qualquer formato sensível, como:

• Saída de cadeia única com um delimitador adequado

• Saídas inteiras / sequência sequenciais, por exemplo, bashimprimir duas linhas para stdout:

  49
  34
  

• Valores de retorno ordenados com comprimento e dois, como uma lista Python, uma matriz C, etc .: [49, 34]

Os valores podem vir em qualquer ordem. Por exemplo, os dois itens a seguir seriam saídas válidas para uma entrada de 1200:

49 34
34 49

A ordem e o separador devem ser iguais para todos os valores de entrada!

Para (B):

Produza qualquer resultado inatingível. O mesmo resultado deve ser produzido para todos os seis tempos previstos, no entanto. Loops infinitos são excluídos.

Amostras de entradas / saídas

YAY!!! é usado aqui como um exemplo demonstrativo e não é prescritivo.

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

Isso é código-golfe , então o código mais curto em bytes vence. As brechas padrão não são permitidas.

Geléia , 34 33 32 31 28 bytes

3 bytes graças a Mr. Xcoder .ịe ³truques.

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

Experimente online!

Algumas partes são exatamente como na resposta de Jonathan Allan , mas estou publicando como acho que é suficientemente diferente e escrita independentemente com base na minha resposta Pyth (e mais curta: D). Também deve ter espaço para melhorias.

A entrada é um número inteiro, a saída é uma matriz de horários anteriores e seguintes ou a matriz vazia para horários especiais.

Explicação

Usando exemplo de entrada 1200.

• d³converte o tempo para a base 100, em horas e minutos: [12,0].
• ḅ60convertidos de base 60 para obter o total de minutos: 720.
• ;15pares com 15: [720, 15].
• 83,588 cria a matriz [83, 588] .
• ṁ5torna comprimento 5: [83, 588, 83, 588, 83].
• ¤combina as duas ações acima. Apenas um detalhe técnico.
• jjunta-se a par com o array: [720, 83, 588, 83, 588, 83, 15].
• _\subtrai cada valor de matriz a partir do primeiro e obtém resultados intermédios: [720, 637, 49, -34, -622, -705, -720].
• ṠÞ estável classifica estes por signum: [-34, -622, -705, -720, 720, 637, 49].
• Aleva os valores absolutos: [34, 622, 705, 720, 720, 637, 49].
• µinicia uma nova cadeia monádica. Mais uma vez, um tecnicismo.
• .ịleva os últimos e primeiros itens: [49, 34].
• ×Ạrepete que uma vez que se não houver zeros, ou zero vezes de outra forma: [49, 34].

JavaScript (ES6), 87 83 bytes

Guardado 4 bytes graças a @ l4m2

Recebe a entrada como uma sequência. Retorna 0uma matriz de 2 elementos ou uma.

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]

Casos de teste

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

Quão?

Não nos preocupamos com o resultado do .every()loop. Desde que a entrada seja válida, sempre será falsa. O que realmente interessa é quando saímos desse loop.

Saímos assim que encontramos um horário favorito i(expresso em minutos) que é maior ou igual ao tempo de referência k(o tempo de entrada tconvertido em minutos). Em seguida, retornamos 0sei == k ou os 2 atrasos de outra forma.

Befunge-93, 88 85 86 80 74 bytes

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

Experimente online!

Gera o número de minutos desde o último horário favorito, seguido pelo número de minutos até o próximo horário favorito (separado pela sequência de dois caracteres: espaço, hífen). Se já é um horário favorito, um único zero é retornado.

C, 121 bytes

*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("");}

Gera uma nova linha se a hora é a hora favorita.

Experimente online!

Limpo , 126 bytes

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)

Define a função ?, recebendo Inte retornando (Int, Int).
Quando o argumento é o horário favorito, ele interrompe o programa de chamada comhd of [] .

Experimente online!

Pitão, 48 45 42 bytes

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

Experimente online. Suíte de teste.

O código pega uma sequência de tempo e gera as horas anteriores e seguintes como uma matriz, ou 0 se a hora é especial.

Curiosamente, uma abordagem imperativa também é de 42 bytes:

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

Explicação

• cz2divide input ( z) em partes de dois caracteres.
• sM avalia-os como números inteiros.
• i… 60Analisa a matriz de dois itens resultante como base 60.
• ,83 588representa a matriz [83, 588].
• *3triplica isso para [83, 588, 83, 588, 83, 588].
• Premove o último 588.
• +... 15adiciona 15até o fim.
• .u-NYcomeça a partir do número analisado, subtrai cada número na matriz e retorna os valores intermediários. Estas são as diferenças de cada momento especial.
• J atribui essas diferenças a J .
• *Fcalcula o produto das diferenças. Será 0 se a hora for especial.
• & interrompe a avaliação aqui e retorna 0 se o horário foi especial.
• ._DJ stable - classifica as diferenças por sinal.
• Ksalva essa matriz K.
• e pega o último item da matriz.
• _hK pega o primeiro item da matriz e o nega.
• , retorna os dois como uma matriz.

Geléia ,  33 32  34 bytes

 +3  +2 bytes para corrigir, para que todas as saídas de tempo desejadas sejam iguais.

^{tem que ser um caminho mais curto!}

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

Um link monádico que pega uma lista dos quatro dígitos e retorna uma lista que contém dois números inteiros
- se for um tempo que você gosta, o resultado será que as duas entradas serão zeros.

Experimente online! ou veja a suíte de testes .

Quão?

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

Casca , 36 bytes

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

Experimente online!

Agradeço ao Zgarb por me explicar como os ternários funcionam no chat. Tentando jogar golfe ↑0, mas não consegui que funcionasse de outra maneira por algum motivo (?). Esta é a minha primeira resposta não trivial de Husk, e deixando o mencionado acima, estou bastante satisfeito com isso. O valor usado em vez deYAY!!! é[] (mas espero que isso mude para fins de golfe).

Explicação

? ↑ 2 ↑ 0Πṙ_1 † aÖ ± ↔Ġ - :: 15t * 3e588 83B60 † d½ | Entrada como uma lista de dígitos do CLA, saída para STDOUT.

                                   ½ Divida a lista em duas partes.
                                 † d | Transforme cada metade em um número inteiro de base 10.
                              B60 Converta da base 60.
                : | Anexe o acima a ↓ ([15, 83, 588, 83, 588, 83]).
                       e588 83 | Crie a lista de dois elementos [588, 83].
                     * 3 Repita três vezes.
                    t Remova o primeiro elemento.
                 : 15 Anexe um 15.
              |- | Aplique subtração cumulativa da direita.
             ↔ Marcha ré.
           Ö ± Classificação estável pelo sinal (-1, 0 ou 1).
         † a | Mapeie o valor absoluto.
      |_1 | Gire um para a direita.
? Π Se o produto for confiável, então:
 ↑ 2 Pegue os dois primeiros elementos.
   ↑ 0 | Retorne uma lista vazia caso contrário.

Kotlin , 293 bytes

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

Embelezado

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

Teste

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