Combine o relógio marcante

14

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 é , 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]
Kevin Cruijssen
fonte
1
Eu iria para o que for mais flexível. Isso inclui números de horas decimais, desde que os números dos resultados caiam entre dois tempos de toque.
Adám 05/01/19
@ Adám Acho que você está certo. Eu editei minha resposta de acordo. Você deve ter pelo menos 1 minuto e no máximo 29 minutos, portanto, .4/ .6/ .9/ .1é permitido (sendo 6 minutos como você declarou: :24/ :36/ :54/ :06).
Kevin Cruijssen
1
Talvez mencione que os pares de horas podem ser retornados em qualquer ordem?
Adám 5/01/19
Ok n está em 0..90, não acho claro qual é o período de tempo para calcular as n advertências: São 12 horas? São 24 horas? São 48 horas? Do que o tempo de retorno permitido no formato 0..24: 0..60?
RosLuP 7/01/19
@RosLuP O período é um relógio analógico comum, de 00:01 às 12:00. Portanto, em vez de 0..24: 0..60, deve ser 0..12: 0..60. Como isso limpa qualquer confusão.
Kevin Cruijssen

Respostas:

3

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

ngn
fonte
Qual é o intervalo de tempo representado .1na saída? Além disso, boa resposta.
Erik the Outgolfer
2
Ah, e é isso que torna possível que sejam 34 bytes, talvez queira vincular a ele ou escrever <sup>SBCS</sup>exatamente como a resposta de Adám.
Erik the Outgolfer
@EriktheOutgolfer o problema permite explicitamente .1 / .4 / .6 / .9 em vez de: 01 /: 29 /: 31 /: 59. Não preciso de codificação especial para esta resposta, é no Dyalog Classic que possui sua própria codificação de byte único.
NGN
não está no Dyalog Classic. E sim, eu sei que é explicitamente permitido, eu só queria saber quantos minutos é 0.1na saída;)
Erik o Outgolfer
@EriktheOutgolfer "SBCS" adicionou, obrigado; .1 × 60 minutos é 6 minutos
ngn
5

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

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
fonte
4

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)

Adão
fonte
0.1 0.5pode se tornar.1 .5
Kritixi Lithos
@ Cowquack Sim, eu notei também. Obrigado, no entanto.
Adám
3

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.

ovs
fonte
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%

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.

Neil
fonte
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) 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 
RosLuP
fonte