Faites correspondre l'horloge frappante

14

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 , 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]
Kevin Cruijssen
la source
1
Je choisirais ce qui est le plus flexible. Cela comprend les nombres d'heures décimales, tant que les nombres de résultats se situent entre deux heures de sonnerie.
Adám
@ Adám Je suppose que vous avez raison. J'ai modifié ma réponse en conséquence. Vous devriez avoir au moins 1 minute et au plus 29 minutes, donc .4/ .6/ .9/ .1est autorisé (soit 6 minutes comme vous l'avez dit: :24/ :36/ :54/ :06).
Kevin Cruijssen
1
Peut-être mentionner que les paires de temps peuvent être retournées dans n'importe quel ordre?
Adám
Ok n est en 0..90, je ne trouve pas clair quelle est la période de temps pour calculer les n grèves: il est de 12 heures? Ils sont 24 heures? Sont 48 heures? Que sont autorisés les temps de retour au format 0..24: 0..60?
RosLuP
@RosLuP Le laps de temps est une horloge analogique régulière, donc de 00:01 à 12:00. Ainsi, au lieu de 0..24: 0..60, cela devrait être 0..12: 0..60. Comment cela efface toute confusion.
Kevin Cruijssen

Réponses:

3

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

ngn
la source
Quel est l'intervalle de temps représenté par .1dans la sortie? Aussi, belle réponse.
Erik the Outgolfer le
2
Oh, et c'est ce qui permet pour que cela soit 34 octets, veulent peut - être un lien vers elle ou écrire tout comme la réponse de Adám. <sup>SBCS</sup>
Erik the Outgolfer le
@EriktheOutgolfer, le problème autorise explicitement .1 / .4 / .6 / .9 au lieu de: 01 /: 29 /: 31 /: 59. Je n'ai pas besoin d'encodage spécial pour cette réponse, c'est dans Dyalog Classic qui a son propre encodage à un octet.
ngn
n'est pas dans Dyalog Classic. Et oui, je sais que c'est explicitement autorisé, je voulais juste savoir combien de minutes est 0.1dans la sortie;)
Erik the Outgolfer
@EriktheOutgolfer "SBCS" ajouté, merci; .1 × 60 minutes soit 6 minutes
ngn
5

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

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
Arnauld
la source
4

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)

Adam
la source
0.1 0.5peut devenir.1 .5
Kritixi Lithos
@Cowsquack Ouais, je l'ai aussi remarqué. Merci quand même.
Adám
3

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.

ovs
la source
1

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.

Neil
la source
1

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 
RosLuP
la source