Introduction:

À la maison, nous avons une horloge qui frappe le montant indiqué à chaque heure, mais qui sonne également une fois toutes les demi-heures. Donc de 0:01 à 12:00 inclus, il frappe dans cet ordre:

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

Défi:

Étant donné un entier n, affichez une liste de délais dans lesquels le nombre total de frappes est égal à n. De plus, commencez toujours au moins 1 minute avant ce délai et terminez au moins 1 minute après ce délai (et au plus 29 minutes).
Par exemple, si l'entrée est n=8, la sortie pourrait être:

[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]

Pour lesquels ces délais ont les sommes suivantes, toutes égales 8:

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

Règles du défi:

• La sortie est flexible. Vous pouvez sortir en tant qu'objets Time (ou Date / DateTime), horodatages, chaînes (avec ou sans zéros non significatifs), décimales avec .29/ .31/ .59/ .01(c'est- 0.29-3.01à- dire au lieu de 00:29-03:01), etc. Tant qu'il est clair que c'est avant et après le laps de temps .
  De plus, vous pouvez choisir vous-même le montant. Dans tous mes exemples, j'utilise 1 minute, mais vous pouvez également choisir 5 minutes, 15 minutes, etc. Cela signifie également que vous pouvez utiliser .4/ .6/ .9/ .1(c'est- 0.4-3.1à- dire au lieu de 00:24-03:06) par exemple. La liste est également flexible. Il peut s'agir d'une liste / collection, d'un tableau, d'une chaîne séparée par un délimiteur, d'une impression par ligne vers STDOUT, etc.
  Veuillez indiquer le choix de sortie que vous avez fait.Remarque: Vous n'êtes pas autorisé à sortir les sommes des délais comme ci-dessus, cela n'est mentionné qu'à titre de clarification. Vous devez sortir les délais, y compris légèrement avant et après.
• Les grèves se déroulent de 12:00à 00:30. Donc, si n=14, deux des délais sont 11:29-00:31et 11:59-01:01.
• L'entrée sera dans la plage 1 <= n <= 90, où 90 est la somme totale de toutes les frappes possibles.
• Les délais que vous retournez peuvent être dans n'importe quel ordre.

Règles générales:

• C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
  Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues non-golfeur de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
• Des règles standard s'appliquent à votre réponse, vous êtes donc autorisé à utiliser STDIN / STDOUT, des fonctions / méthodes avec les paramètres appropriés et des programmes complets de type retour. Ton appel.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code.
• Veuillez également ajouter une explication si nécessaire.

Cas de test:

(tous utilisant 1 minute avant / après les délais et les zéros non significatifs)

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 34 octets

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

Essayez-le en ligne!

Cette solution utilise ⎕io←1(indexation 1).

De droite à gauche:

⍳12 est 1 2 3...12

⍪ le transforme en une grande matrice 12x1 mince

1, ajoute une colonne de 1 à gauche

⍪⍨ concatène la même matrice verticalement, il s'agit donc désormais d'une matrice 24x2

, aplatit la matrice par ordre de rang majeur, il devient un vecteur de taille 48: 1 1 1 2 1 3...1 12 1 1 1 2...1 12

+\ sommes partielles: 1 2 3 5 6 9...

∘.-⍨ les différences entre chaque paire d'éléments, une matrice 48x48

⍉ transposer

⎕=une matrice booléenne 48x48 avec 1s partout où l'entrée évaluée ( ⎕) se produit

⍸ les paires de coordonnées de l'endroit où les 1 sont

.5× les réduire de moitié

.4 .1∘+¨ ajouter 0,4 à la première et 0,1 à la deuxième coordonnée dans chaque paire

12| modulo 12

∪ unique

JavaScript (ES6), 104 octets

Imprime les intervalles de temps au H.MM,H.MMformat.

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)

Essayez-le en ligne!

Utilise essentiellement le même algorithme que la version non récursive ci-dessous.

Version non récursive, 117 octets

Génère une chaîne d'intervalles de temps délimitée par des espaces au H.MM,H.MMformat.

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

Cas de test

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

Commenté

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 octets ^SBCS

Corps de programme complet. Demande n. Imprime la liste des listes à deux éléments en utilisant les heures décimales.

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

Essayez-le en ligne!

⍳24 ɩ ndices 1… 24

48⍴ cyclique r Eshape de longueur 48, à savoir 1 ... 12,1 ... 12

.5× multiplier la moitié par celle

⊂ entourer (pour utiliser tout ce tableau comme argument de droite pour chaque argument de gauche)

(… ),/¨ Pour chacun des éléments suivants, renvoyez toutes les sous-listes de cette longueur:

 ⍳48 ɩ ndices 1… 48

 l← stocker dans l(pour l engths)

Nous avons maintenant toutes les listes possibles de cycles de temps pour chaque longueur de cycle possible.

,/ concaténer (lit. concaténation-réduction) les listes de sous-listes

⊃ divulguer (car la réduction a réduit le rang de 1 à 0)

(… )¨ Appliquez à chacun la fonction suivante:

 ⊢/ le dernier élément (allumé à droite) (l'heure de fin)

 ⊃, ajouter le premier élément (l'heure de début)

 ¯.1 .1+ ajouter des dixièmes négatifs et positifs à ceux

(… )/ Filtrez ces paires début-fin avec:

 ⍳12 ɩ ndices 1… 12

 1,¨ ajouter un 1à chacun

 ∊ ϵ nlist (aplatir)

 48⍴ cyclique r Eshape de longueur 48, c. -à- 1,1,1,2 ... 1,11,1,12

 ⊂ entourer (pour utiliser tout ce tableau comme argument de droite pour chaque argument de gauche)

 l+/¨ pour chacun de l(1… 48) retourner les sommes de toutes les sous-listes de cette longueur

 ∊ ϵ nlist (aplatir)

⎕= comparer l'entrée numérique à celle

∪ ne renvoie que les éléments uniques (paires début-fin)

Python 3 , 118 116 octets

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]

Essayez-le en ligne!

Un délai est représenté par (t1, t2), t1et t2étant décimales représentant heures. Le décalage est de .1ou 6 minutes.

Lot, 196 octets

@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%

Explication: test le temps en demi-heure, à partir 0de 00:30. Le nombre de grèves à l' instant t est alors 1, 1, 1, 2, 1, 3etc. Soustraire 1donne la séquence 0, 0, 0, 1, 0, 2etc. , qui sont les entiers intercalées avec des zéros. Cela peut ensuite être obtenu par termwise multiplication de la séquence 0, 0, 1, 1, 2, 2etc. , avec la séquence 0, 1, 0, 1, 0, 1etc. , sont facilement calculé à la fois de ces séquences en utilisant modulo et de la division (entier).

Il reste ensuite à boucler sur les 23 heures de début possibles, puis à prendre les 24 temps de frappe et à soustraire le nombre de coups de l'entrée, en imprimant les temps lorsque le résultat est nul.

Le code tombe après la boucle mais aucun mal n'est fait car l'entrée ne peut pas dépasser 90.

APL NARS, 559 octets

∇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) renvoie tous les intervalles représentatifs en 0-24 heures qui ont n coups d'horloge. h (n) a le format d'horloge 0..11.0..59; au lieu de cela, l (n) a un format d'horloge comme test 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