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 código de golf , 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]

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

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

let f =

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

console.log(f(8))
console.log(f(14))
console.log(f(90))
console.log(f(1))
console.log(f(2))

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

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:

 ⍳12 d 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)

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.

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.

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