Introdução:

Em casa, temos um relógio que bate o valor indicado a cada hora, mas também que bate uma vez a cada meia hora. Então, de 0:01 até 12:00, ocorre nesta ordem:

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

Desafio:

Dado um número inteiro n, produza uma lista de prazos nos quais o total de ocorrências é igual a n. Além disso, sempre inicie pelo menos 1 minuto antes desse período e termine pelo menos 1 minuto após esse período (e no máximo 29 minutos).
Por exemplo, se a entrada for n=8, a saída poderá 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 os quais esses prazos têm as seguintes somas, todas iguais 8:

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

Regras do desafio:

• A saída é flexível. Você pode produzir como objetos Time (ou Date / DateTime), timestamps, strings (com ou sem zeros à esquerda), decimais com .29/ .31/ .59/ .01(ou seja, em 0.29-3.01vez de 00:29-03:01), etc. Desde que fique claro, é antes e depois do período .
  Além disso, você pode escolher o valor você mesmo. Em todos os meus exemplos, uso 1 minuto, mas você também pode escolher 5 minutos, 15 minutos, etc. Isso também significa que você pode usar .4/ .6/ .9/ .1(ou seja, em 0.4-3.1vez de 00:24-03:06) por exemplo. A lista também é flexível. Pode ser uma lista / coleção, matriz, sequência separada por delimitador, impressão por linha em STDOUT, etc.
  Por favor, indique qual opção de saída você fez.Nota: Você não tem permissão para emitir as somas dos prazos como acima, isso é mencionado apenas como esclarecimento. Você deve gerar os prazos, incluindo um pouco antes e depois dele.
• As greves envolvem de 12:00para 00:30. Portanto n=14, se dois dos prazos são 11:29-00:31e 11:59-01:01.
• A entrada estará no intervalo 1 <= n <= 90, onde 90 é a soma total de todos os possíveis ataques.
• Os prazos retornados podem estar em qualquer ordem.

Regras gerais:

• Isso é código-golfe , então a resposta mais curta em bytes vence.
  Não permita que idiomas com código de golfe o desencorajem a postar respostas com idiomas que não sejam codegolf. Tente encontrar uma resposta o mais curta possível para 'qualquer' linguagem de programação.
• As regras padrão se aplicam à sua resposta, para que você possa usar STDIN / STDOUT, funções / método com os parâmetros adequados e programas completos do tipo retorno. Sua chamada.
• As brechas padrão são proibidas.
• Se possível, adicione um link com um teste para o seu código.
• Além disso, adicione uma explicação, se necessário.

Casos de teste:

(todos usando 1 minuto antes / depois dos prazos e zeros à esquerda)

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) , 34 bytes ^SBCS

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

Experimente online!

Esta solução usa ⎕io←1(indexação baseada em 1).

Da direita para esquerda:

⍳12 é 1 2 3...12

⍪ transforma-o em uma matriz alta e fina de 12x1

1, adiciona uma coluna de 1s à esquerda

⍪⍨ concatena a mesma matriz verticalmente, agora é uma matriz 24x2

, achatar a matriz na ordem das linhas principais, torna-se um vetor de tamanho 48: 1 1 1 2 1 3...1 12 1 1 1 2...1 12

+\ somas parciais: 1 2 3 5 6 9...

∘.-⍨ as diferenças entre cada par de elementos, uma matriz de 48x48

⍉ transpor

⎕=uma matriz booleana de 48x48 com 1s onde quer que a entrada avaliada ( ⎕) ocorra

⍸ os pares de coordenadas de onde os 1s são

.5× cortar pela metade

.4 .1∘+¨ adicione 0,4 à primeira e 0,1 à segunda coordenada em cada par

12| módulo 12

∪ único

JavaScript (ES6), 104 bytes

Imprime intervalos de tempo no 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)

Experimente online!

Usa essencialmente o mesmo algoritmo da versão não recursiva abaixo.

Versão não recursiva, 117 bytes

Gera uma sequência de intervalos de tempo delimitada por espaço no 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 teste

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

Corpo do programa completo. Solicita n. Imprime a lista de listas de dois elementos usando horas decimais.

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

Experimente online!

⍳24 índices 1… 24

48⍴ ciclicamente r eshape de comprimento 48, ou seja, 1 ... 12,1 ... 12

.5× multiplicar meio por isso

⊂ delimite (para usar toda essa matriz como argumento da direita para cada argumento da esquerda)

(… ),/¨ Para cada uma das seguintes opções, retorne todas as sub-listas desse comprimento:

 ⍳48 índices 1… 48

 l← armazenar em l(para l engths)

Agora, temos todas as listas possíveis de execuções de tempos para cada extensão possível.

,/ concatenar (lit. redução-concatenação) as listas de sub-listas

⊃ divulgar (porque a redução reduziu a classificação de 1 para 0)

(… )¨ Aplique a seguinte função a cada um:

 ⊢/ o último elemento (lit. redução direita) (o horário de término)

 ⊃, precede o primeiro elemento (a hora de início)

 ¯.1 .1+ adicione décimos negativos e positivos àqueles

(… )/ Filtre esses pares de início e fim com:

 ⍳12 índices 1… 12

 1,¨ acrescente um 1a cada

 ∊ ε nlist (achatar)

 48⍴ ciclicamente r eshape de comprimento 48, ou seja, 1,1,1,2 ... 1,11,1,12

 ⊂ delimite (para usar toda essa matriz como argumento da direita para cada argumento da esquerda)

 l+/¨ para cada um l(1… 48) retorna as somas de todas as sub-listas desse comprimento

 ∊ ε nlist (achatar)

⎕= compare a entrada numérica com a

∪ retorna apenas os elementos exclusivos (pares de início e fim)

Python 3 , 118 116 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]

Experimente online!

Um período de tempo é representado como (t1, t2), t1e t2sendo decimais que representam horas. O deslocamento é .1ou 6 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%

Explicação: té o tempo em meia hora, começando em 0por 00:30. O número de ataques no tempo t é, em seguida, 1, 1, 1, 2, 1, 3etc Subtraindo 1dá a sequência de 0, 0, 0, 1, 0, 2etc, que são os números inteiros intercalados com zeros. Este pode, então, ser obtida por multiplicação termwise da sequência 0, 0, 1, 1, 2, 2etc, com a sequência 0, 1, 0,1 , 0, 1etc Ambas as sequências são facilmente calculadas utilizando módulo e (inteiro) divisão.

Resta então repassar todas as 23 horas possíveis de início e, em seguida, tirar todas as 24 horas de ocorrência e subtrair o número de ocorrências da entrada, imprimindo as horas em que o resultado é zero.

O código cai após o loop, mas nenhum dano é causado, pois a entrada não pode 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) ou l (n) retorna todos os intervalos representativos em 0 a 24 horas que possuem n horas. h (n) tem o formato de relógio como 0..11.0..59; em vez disso, l (n) tem o formato de relógio como 0..23.0..59 test

  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