Match the Striking Clock

14

Introducción:

En casa tenemos un reloj que marca la cantidad indicada a cada hora, pero también marca una vez cada media hora. Entonces, desde las 0:01 hasta las 12:00, incluido en este orden:

1, 1, 1, 2, 1, 3, 1, 4, 1, 5, 1, 6, 1, 7, 1, 8, 1, 9, 1, 10, 1, 11, 1, 12

Desafío:

Dado un número entero n, genera una lista de marcos de tiempo en los que las huelgas totales son iguales n. Además, siempre comience al menos 1 minuto antes de este período de tiempo y termine al menos 1 minuto después de este período de tiempo (y como máximo 29 minutos).
Por ejemplo, si la entrada es n=8, la salida podría ser:

[00:59-03:01, 01:29-03:31, 02:59-04:01, 05:29-06:31, 06:29-07:01, 06:59-07:31, 07:59-08:01]

Para el cual estos marcos de tiempo tienen las siguientes sumas, todas iguales 8:

[1+1+2+1+3, 1+2+1+3+1, 3+1+4, 1+6+1, 1+7, 7+1, 8]

Reglas de desafío:

  • La salida es flexible. Puede generar como objetos de tiempo (o fecha / fecha y hora), marcas de tiempo, cadenas (con o sin ceros a la izquierda), decimales con .29/ .31/ .59/ .01(es decir, en 0.29-3.01lugar de 00:29-03:01), etc. Siempre que esté claro, es antes y después del marco de tiempo .
    Además, puede elegir la cantidad usted mismo. En todos mis ejemplos uso 1 minuto, pero también puede elegir 5 minutos, 15 minutos, etc. Esto también significa que puede usar .4/ .6/ .9/ .1(es decir, en 0.4-3.1lugar de 00:24-03:06) por ejemplo. La lista también es flexible. Puede ser una lista / colección, matriz, cadena separada por delimitador, impresión por línea en STDOUT, etc.
    Indique qué opción de salida ha realizado.Nota: No está permitido emitir las sumas de los marcos de tiempo como se indicó anteriormente, esto solo se menciona como aclaración. Debe generar los marcos temporales, incluso un poco antes y después.
  • Las huelgas se envuelven de 12:00a 00:30. Entonces n=14, si , dos de los marcos de tiempo son 11:29-00:31y 11:59-01:01.
  • La entrada estará en el rango 1 <= n <= 90 , donde 90 es la suma total de todos los golpes posibles.
  • Los plazos que devuelva pueden estar en cualquier orden.

Reglas generales:

  • Este es el , por lo que la respuesta más corta en bytes gana.
    No permita que los lenguajes de código de golf lo desalienten de publicar respuestas con idiomas que no sean de código. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
  • Se aplican reglas estándar para su respuesta, por lo que puede utilizar STDIN / STDOUT, funciones / método con los parámetros adecuados y programas completos de tipo retorno. Tu llamada.
  • Las lagunas predeterminadas están prohibidas.
  • Si es posible, agregue un enlace con una prueba para su código.
  • Además, agregue una explicación si es necesario.

Casos de prueba:

(todo usando 1 minuto antes / después de los marcos de tiempo y ceros iniciales)

Input: 8
Ouput:
[00:59-03:01, 01:29-03:31, 02:59-04:01, 05:29-06:31, 06:29-07:01, 06:59-07:31, 07:59-08:01]

Input: 14
Output:
[00:29-04:01, 00:59-04:31, 02:59-05:01, 04:29-06:31, 05:59-07:01, 11:29-00:31, 11:59-01:01]

Input: 90
Output:
[00:29-00:01, 00:59-00:31, 01:29-01:01, 01:59-01:31, 02:29-02:01, 02:59-02:31, 03:29-03:01, 03:59-03:31, 04:29-04:01, 04:59-04:31, 05:29-05:01, 05:59-05:31, 06:29-06:01, 06:59-06:31, 07:29-07:01, 07:59-07:31, 08:29-08:01, 08:59-08:31, 09:29-09:01, 09:59-09:31, 10:29-10:01, 10:59-10:31, 11:29-11:01, 11:59-11:31]

Input: 1
Output:
[00:29-00:31, 00:59-01:01, 01:29-01:31, 02:29-02:31, 03:29-03:31, 04:29-04:31, 05:29-05:31, 06:29-06:31, 07:29-07:31, 08:29-08:31, 09:29-09:31, 10:29-10:31, 11:29-11:31]

Input: 2
Output:
[00:29-01:01, 00:59-01:31, 01:59-02:01]
Kevin Cruijssen
fuente
1
Yo iría por lo que sea más flexible. Esto incluye números de horas decimales, siempre que los números de resultados se encuentren entre dos tiempos de llamada.
Adám
@ Adám Supongo que tienes razón. He editado mi respuesta en consecuencia. Debe tener al menos 1 minuto y como máximo 29 minutos, entonces .4/ .6/.9 / .1está permitido (son 6 minutos como has dicho: :24/ :36/ :54/ :06).
Kevin Cruijssen
1
¿Quizás mencione que los pares de tiempo se pueden devolver en cualquier orden?
Adám
Ok n está en 0..90, no encuentro claro cuál es el período de tiempo para calcular los n strikes: ¿son 12 horas? Son 24 horas? Son 48 horas? ¿Que se permite el tiempo de retorno en el formato 0..24: 0..60?
RosLuP
@RosLuP El marco de tiempo es un reloj analógico normal, por lo tanto, de 00:01 a 12:00. Entonces, en lugar de 0..24: 0..60, debería ser 0..12: 0..60. Cómo eso aclara cualquier confusión.
Kevin Cruijssen

Respuestas:

3

APL (Dyalog Classic) , SBCS de 34 bytes

12|.4 .1∘+¨.5×⍸⎕=⍉∘.-⍨+\,⍪⍨1,⍪⍳12

Pruébalo en línea!

Esta solución usa ⎕io←1 (indexación basada en 1).

De derecha a izquierda:

⍳12 es 1 2 3...12

lo convierte en una matriz alta y delgada de 12x1

1, agrega una columna de 1s a la izquierda

⍪⍨ concatena la misma matriz verticalmente, por lo que ahora es una matriz 24x2

, aplana la matriz en orden de fila mayor, se convierte en un vector de tamaño 48: 1 1 1 2 1 3...1 12 1 1 1 2...1 12

+\ sumas parciales: 1 2 3 5 6 9...

∘.-⍨ Las diferencias entre cada par de elementos, una matriz de 48x48

transponer

⎕= una matriz booleana de 48x48 con 1s donde la entrada evaluada ( ocurra la )

los pares de coordenadas de donde están los 1s

.5× reducirlos a la mitad

.4 .1∘+¨ agregue 0.4 a la primera y 0.1 a la segunda coordenada en cada par

12| módulo 12

único

ngn
fuente
¿Cuál es el intervalo de tiempo representado .1en la salida? Además, buena respuesta.
Erik the Outgolfer
2
Ah, y esto es lo que hace posible que esto sea de 34 bytes, tal vez desee vincularlo o escribir <sup>SBCS</sup>como la respuesta de Adám.
Erik the Outgolfer
@EriktheOutgolfer el problema permite explícitamente .1 / .4 / .6 / .9 en lugar de: 01 /: 29 /: 31 /: 59. No necesito una codificación especial para esta respuesta, está en Dyalog Classic, que tiene su propia codificación de un solo byte.
ngn
no está en Dyalog Classic. Y sí, sé que está explícitamente permitido, solo quería saber cuántos minutos hay 0.1en la salida;)
Erik the Outgolfer
@EriktheOutgolfer "SBCS" agregado, gracias; .1 × 60 minutos son 6 minutos
ngn
5

JavaScript (ES6), 104 bytes

Imprime intervalos de tiempo en H.MM,H.MMformato.

F=(n,f=0,s=n,t=f++)=>t<f+23?F(n,f,s-=t&1||t/2%12+1,++t,s||alert([f/2%12+.01,-~t/2%12+.01])):f<24&&F(n,f)

Pruébalo en línea!

Utiliza esencialmente el mismo algoritmo que la versión no recursiva a continuación.


Versión no recursiva, 117 bytes.

Emite una cadena delimitada por espacios de intervalos de tiempo en H.MM,H.MMformato.

n=>[...Array(24)].map((_,f,a)=>a.map(_=>(s-=t++&1||t/2%12+.5)||(r+=[-~f/2%12+.01,-~t/2%12+.01]+' '),s=n,t=f),r='')&&r

Casos de prueba

Comentado

n =>                           // n = input
  [...Array(24)].map((_, f, a) // FOR f = 0 TO 23:
    => a.map(_ =>              //   FOR t = f TO f + 23:
      (                        //     update s
        s -=                   //       by subtracting:
          t++ & 1 ||           //         - 1 if t is odd (half hour)
          t / 2 % 12 + .5      //         - the current hour if t is even
      ) || (                   //     if s is equal to zero:
        r += [                 //       update the result string by appending:
          -~f / 2 % 12 + .01   //         - the formatted 'from' time
          ,                    //         - a comma
          -~t / 2 % 12 + .01   //         - the formatted 'to' time
        ] + ' '                //       and a padding space
      ),                       //     inner map() initialization:
      s = n,                   //     - s = target number of strikes
      t = f                    //     - 'to' time = 'from' time
    ),                         //   end of inner map()
    r = ''                     //   start with r = empty string
  )                            // end of outer map()
  && r                         // return r
Arnauld
fuente
4

APL (Dyalog Unicode) , 62 59 bytes SBCS

Programa completo del cuerpo. Indicaciones paran . Imprime la lista de listas de dos elementos utilizando horas decimales.

∪(⎕=∊l+/¨⊂48⍴∊1,¨⍳12)/(¯.1 .1+⊃,⊢/)¨⊃,/(l←⍳48),/¨⊂.5×48⍴⍳24

Pruébalo en línea!

⍳24ɩ nices 1 ... 24

48⍴ cíclicamente r eshape a la longitud 48, es decir, 1 ... 12,1 ... 12

.5× multiplicar la mitad por eso

 encierre (para usar esta matriz completa como argumento derecho para cada argumento izquierdo)

(... ),/¨ para cada uno de los siguientes, devuelva todas las sublistas de esa longitud:

⍳48ɩ ndices 1 ... 48

l← almacenar en l(para l engths)

Ahora tenemos todas las listas posibles de ejecuciones de tiempos para cada posible duración de ejecución.

,/ concatenar (literalmente, reducción de concatenación) las listas de sublistas

 revelar (porque la reducción redujo el rango de 1 a 0)

(...  aplique la siguiente función a cada uno:

⊢/ El último elemento (encendido, reducción a la derecha) (el tiempo final)

⊃, anteponer el primer elemento (el tiempo de inicio)

¯.1 .1+ agregue décimas negativas y positivas a esas

(... )/ filtre esos pares de inicio y fin con:

⍳12d nices 1 ... 12

1,¨ anteponer una 1a cada

ϵ nlist (aplanar)

48⍴ cíclicamente r eshape a la longitud 48, es decir, 1,1,1,2 ... 1,11,1,12

 encierre (para usar esta matriz completa como argumento derecho para cada argumento izquierdo)

l+/¨ para cada uno l(1 ... 48) devuelva las sumas de todas las sublistas de esa longitud

ϵ nlist (aplanar)

⎕= comparar la entrada numérica a eso

 devuelve solo los elementos únicos (pares principio-fin)

Adán
fuente
0.1 0.5puede llegar a ser.1 .5
Kritixi Lithos
@Cowsquack Sí, yo también lo noté. Gracias, sin embargo.
Adám
3

Python 3 , 118116 bytes

lambda n:[(a/2+.4,b%24/2+.1)for a in range(24)for b in range(48)if sum((sum(zip([1]*12,range(1,13)),())*2)[a:b])==n]

Pruébalo en línea!

Un marco de tiempo se representa como (t1, t2), t1y t2son decimales que representan horas. El desplazamiento es de .16 minutos.

ovs
fuente
1

Lote, 196 bytes.

@for /l %%i in (0,1,23)do @set s=%1&for /l %%j in (0,1,23)do @call:c %%i %%j
:c
@set/at=%2+%1,s-=t%%2*(t/2%%12)+1,h=%1/2,i=%1%%2*30+15,t=-~t%%24/2,u=-~t%%2*30+15
@if %s%==0 echo %h%:%i% %t%:%u%

Explicación: t es el tiempo en la mitad de horas, comenzando en 0para 00:30. El número de huelgas en el tiempo t es entonces 1, 1, 1, 2, 1, 3etc. Restando 1da la secuencia 0, 0, 0, 1, 0, 2etc., que es los enteros intercalados con ceros. Esto puede ser obtenido por la multiplicación término a término de la secuencia 0, 0, 1, 1, 2, 2etc, con la secuencia 0, 1, 0, 1, 0,1 etc. Ambas secuencias están fácilmente calcula utilizando modulo y división (integer).

Luego queda recorrer los 23 tiempos de inicio posibles, luego tomar los 24 tiempos de golpe y restar el número de golpes de la entrada, imprimiendo los tiempos cuando el resultado es cero.

El código falla después del bucle, pero no se hace daño ya que la entrada no puede ser superior a 90.

Neil
fuente
1

NARS APL, 559 bytes

∇r←l w;t;i;j;c;k;m;p
p←{0=2∣¯1+⍵:.01+2÷⍨¯1+⍵⋄¯0.19+2÷⍨¯1+⍵}
m←{0=2∣¯1+⍵:¯.41+2÷⍨¯1+⍵⋄¯0.21+2÷⍨¯1+⍵}
   r←⍬⋄i←0⋄t←∊(¯1+⍳13),¨13⍴1⋄t←t,2↓t⋄k←⍴t
A: j←i+←1⋄→0×⍳i≥k⋄c←0
B: c+←j⊃t⋄:if(c=w)∧(0≤(m i))∧(24≥(p j))⋄r←r,⊂(m i),(p j)⋄:endif⋄→A×⍳c≥w⋄j+←1⋄→B×⍳j≤k⋄→A
∇
∇r←g w;v;i;k;m
   v←{12≤⌊⍵:⍵-12⋄⍵}
   i←1⋄k←⍴w⋄r←⍬
A: →0×⍳i>k⋄r←r,⊂v¨i⊃w⋄i+←1⋄→A
∇   
h←g∘l

h (n) o l (n) devuelve todos los intervalos representativos en 0-24 horas que tienen n huelgas de reloj. h (n) tiene el formato de reloj como 0..11.0..59; en cambio l (n) tiene formato de reloj como prueba 0..23.0..59

  h 8
    0.59 3.01  1.29 3.31  2.59 4.01  5.29 6.31  6.29 7.01  6.59 7.31  
    7.59 8.01  0.59 3.01  1.29 3.31  2.59 4.01  5.29 6.31  6.29 7.01  
    6.59 7.31  7.59 8.01 
  h 14
    0.29 4.01  0.59 4.31  2.59 5.01  4.29 6.31  5.59 7.01  11.29 0.31  
    11.59 1.01  0.29 4.01  0.59 4.31  2.59 5.01 4.29 6.31  5.59 7.01 
  h 90
    0.29 0.01  0.59 0.31  1.29 1.01  1.59 1.31  2.29 2.01  2.59 2.31  
    3.29 3.01  3.59 3.31  4.29 4.01  4.59 4.31  5.29 5.01  5.59 5.31  
    6.29 6.01  6.59 6.31  7.29 7.01  7.59 7.31  8.29 8.01  8.59 8.31  
    9.29 9.01  9.59 9.31  10.29 10.01  10.59 10.31  11.29 11.01  11.59 11.31    
  h 1
    0.29 0.31  0.59 1.01  1.29 1.31  2.29 2.31  3.29 3.31  4.29 4.31  
    5.29 5.31  6.29 6.31  7.29 7.31  8.29 8.31  9.29 9.31  10.29 10.31  
    11.29 11.31  0.29 0.31  0.59 1.01  1.29 1.31  2.29 2.31  3.29 3.31  
    4.29 4.31  5.29 5.31  6.29 6.31  7.29 7.31  8.29 8.31  9.29 9.31  
    10.29 10.31  11.29 11.31 
  h 2
    0.29 1.01  0.59 1.31  1.59 2.01  0.29 1.01  0.59 1.31  1.59 2.01 
  l 2
    0.29 1.01  0.59 1.31  1.59 2.01  12.29 13.01  12.59 13.31  13.59 14.01 
RosLuP
fuente