Realmente me gustan los tiempos que siguen ciertos patrones. En particular, me gustan los momentos en que todos los dígitos son iguales, o todos los dígitos aumentan aritméticamente en uno de izquierda a derecha. Además, odio visceralmente cuando la gente pone cartas en mis tiempos, así que todas esas tonterías de AM / PM están muertas para mí. Por lo tanto, mis momentos favoritos son:

0000 0123 1111 1234 2222 2345

Para mi tranquilidad, necesito que me escriba un solo programa que, dada la hora actual como entrada, ambos: (A) si ahora no es uno de mis momentos favoritos, me diga a ambos (i) cuántos minutos son pasado desde mi último tiempo favorito y (ii) cuántos minutos a partir de ahora ocurrirá mi próximo tiempo favorito; y (B) si ahora es uno de mis momentos favoritos, proporciona un solo 'valor de señal'.

Entrada

Su programa debe aceptar (por cualquier método: argumento de función, stdin línea de comando, etc.) la hora actual, en cualquiera de los siguientes formatos:

• Un tiempo de cuatro dígitos como una cadena

• Un entero que se puede rellenar con ceros a la izquierda para hacer un tiempo de cuatro dígitos como una cadena

• Una secuencia de cuatro (o menos) enteros, ordenados de modo que el primer entero de la secuencia sea el dígito más a la izquierda (significativo) en la entrada de tiempo (por ejemplo, 0951podría representarse válidamente como [0, 9, 5, 1]o [9, 5, 1])

  • Representar 0000como una secuencia de longitud cero es aceptable

En el caso de una entrada de cadena, se debe solamente contener dígitos, no hay dos puntos u otra puntuacion. Se puede suponer que las entradas siempre son válidas 24 horas:, HHMM donde 0 <= HH <= 23y 0 <= MM <= 59. Haga caso omiso de la posibilidad de un segundo salto.

Salida

Su programa debe suministrar (los retornos de funciones stdout, etc. están todos bien) ya sea (A) o (B) , según corresponda, ya sea que el valor de entrada sea o no un tiempo objetivo.

Para):

Proporcione dos valores numéricos en cualquier formato sensible, como:

• Salida de cadena única con un delimitador adecuado

• Entero secuencial / salidas de cadena, por ejemplo, bashimprimir dos líneas para stdout:

  49
  34
  

• Valores de retorno ordenados de longitud dos, como una lista de Python, una matriz C, etc. [49, 34]

Los valores pueden venir en cualquier orden. Por ejemplo, los dos siguientes serían salidas válidas para una entrada de 1200:

49 34
34 49

¡Sin embargo, el orden y el separador deben ser los mismos para todos los valores de entrada!

Para (B):

Produzca cualquier resultado inalcanzable. Lo mismo resultado se debe producir para los seis de los tiempos objetivo, sin embargo. Se excluyen los bucles infinitos.

Entradas / salidas de muestra

YAY!!! se usa aquí como ejemplo demostrativo y no es prescriptivo.

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

Este es el código de golf , por lo que gana el código más corto en bytes. Las lagunas estándar no están permitidas.

Gelatina , 34 33 32 31 28 bytes

3 bytes gracias al Sr. Xcoder .ịy sus ³trucos.

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

Pruébalo en línea!

Algunas partes son exactamente como en la respuesta de Jonathan Allan , pero lo estoy publicando ya que creo que es lo suficientemente diferente y está escrito independientemente según mi respuesta de Pyth (y más breve: D). También debe tener margen de mejora.

La entrada es un entero, la salida es una matriz de tiempos anteriores y siguientes o la matriz vacía para tiempos especiales.

Explicación

Usando entrada de ejemplo 1200.

• d³ convierte el tiempo en base 100, en horas y minutos: [12,0] .
• ḅ60 Convierte desde la base 60 para obtener minutos totales: 720 .
• ;15 lo empareja con 15: [720, 15] .
• 83,588 crea la matriz [83, 588] .
• ṁ5hace que sea longitud 5: [83, 588, 83, 588, 83].
• ¤combina las dos acciones anteriores. Solo un tecnicismo.
• jse une a la par con la matriz: [720, 83, 588, 83, 588, 83, 15].
• _\resta cada valor de matriz de la primera y obtiene resultados intermedios: [720, 637, 49, -34, -622, -705, -720].
• ṠÞ establemente ordena esto por signum:[-34, -622, -705, -720, 720, 637, 49] .
• A toma los valores absolutos: [34, 622, 705, 720, 720, 637, 49] .
• µcomienza una nueva cadena monádica. De nuevo, un tecnicismo.
• .ị toma el último y el primer artículo: [49, 34] .
• ×Ạrepite que una vez si no hay ceros, o cero veces de otro modo: [49, 34].

JavaScript (ES6), 87 83 bytes

Guardado 4 bytes gracias a @ l4m2

Toma la entrada como una cadena. Devuelve 0una matriz de 2 elementos o una.

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 prueba

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

¿Cómo?

No nos importa el resultado del .every()bucle. Siempre que la entrada sea válida, siempre será falsa. Lo que realmente nos interesa es cuando salimos de este ciclo.

Salimos tan pronto como encontramos un tiempo favorito i(expresado en minutos) que es mayor o igual que el tiempo de referencia k(el tiempo de entrada tconvertido en minutos). Luego regresamos 0si i == ko los 2 retrasos de lo contrario.

Befunge-93, 88 85 86 80 74 bytes

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

Pruébalo en línea!

Emite la cantidad de minutos desde la última hora favorita, seguida de la cantidad de minutos hasta la próxima hora favorita (separados por la secuencia de dos caracteres: espacio, guión). Si ya es un momento favorito, se devuelve un solo cero.

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

Emite una nueva línea si la hora es una hora favorita.

Pruébalo en línea!

Limpio , 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 la función ?, tomar Inty regresar (Int, Int).
Cuando el argumento es un momento favorito, bloquea el programa de llamada con hd of [].

Pruébalo en línea!

Pyth, 48 45 42 bytes

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

Pruébalo en línea. Banco de pruebas.

El código toma una cadena de tiempo y genera las veces anteriores y siguientes como una matriz, o 0 si el tiempo es especial.

Curiosamente, un enfoque imperativo también es de 42 bytes:

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

Explicación

• cz2divide input ( z) en piezas de dos caracteres.
• sM los evalúa como enteros.
• i... 60analiza la matriz resultante de dos elementos como base 60.
• ,83 588representa la matriz [83, 588].
• *3triplica eso a [83, 588, 83, 588, 83, 588].
• Pelimina el último 588.
• +... se 15agrega 15al final.
• .u-NYcomienza desde el número analizado, resta cada número de la matriz y devuelve los valores intermedios. Estas son las diferencias de cada momento especial.
• Jasigna estas diferencias a J.
• *FCalcula el producto de las diferencias. Será 0 si el tiempo fue especial.
• & detiene la evaluación aquí y devuelve 0 si el tiempo fue especial.
• ._DJ Estable-ordena las diferencias por signo.
• Kguarda esa matriz en K.
• e toma el último elemento de la matriz.
• _hK toma el primer elemento de la matriz y lo niega.
• , devuelve los dos como una matriz.

Jalea ,  33 32  34 bytes

 +3  +2 bytes para arreglar de modo que todas las salidas de tiempo gustadas sean iguales.

^{Tiene que ser un camino más corto!}

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

Un enlace monádico que toma una lista de los cuatro dígitos y devuelve una lista que contiene dos enteros
; si es el momento deseado, el resultado será ambas ceros.

Pruébalo en línea!o ver el conjunto de pruebas .

¿Cómo?

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

Casco , 36 bytes

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

Pruébalo en línea!

Gracias a Zgarb por explicarme cómo funcionan los ternaries en el chat. Tratando de jugar al golf ↑0, pero por alguna razón no pude hacerlo funcionar (?). Esta es mi primera respuesta no trivial de Husk, y dejando de lado lo mencionado, estoy bastante satisfecho con eso. El valor utilizado en lugar de YAY!!!es [](pero espero que eso cambie para fines de golf).

Explicación

? ↑ 2 ↑ 0Πṙ_1 † aÖ ± ↔Ġ - :: 15t * 3e588 83B60 † d½ | Ingrese como una lista de dígitos de CLA, salida a STDOUT.

                                   ½ | Divide la lista en dos mitades.
                                 † d | Convierta cada mitad en un entero de base 10.
                              B60 | Convertir de base 60.
                : | Agregue lo anterior a ↓ ([15, 83, 588, 83, 588, 83]).
                       e588 83 | Cree la lista de dos elementos [588, 83].
                     * 3 | Repite tres veces.
                    t | Eliminar el primer elemento.
                 : 15 | Anteponer un 15.
              Ġ- | Aplicar resta acumulativa desde la derecha.
             ↔ | Marcha atrás.
           Ö ± | Estable ordenado por el signo (-1, 0 o 1).
         † a | Mapa de valor absoluto.
      ṙ_1 | Gire uno a la derecha.
? Π | Si el producto es verdadero, entonces:
 ↑ 2 | Toma los dos primeros elementos.
   ↑ 0 | Devuelve una lista vacía de lo contrario.

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

Embellecido

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

Prueba

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