Einführung:

Zu Hause haben wir eine Uhr, die zu jeder vollen Stunde den angegebenen Wert anzeigt, aber auch einmal zu jeder halben Stunde. Also von 0:01 bis einschließlich 12:00 trifft es in dieser Reihenfolge zu:

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

Herausforderung:

Geben Sie bei einer Ganzzahl neine Liste von Zeitrahmen aus, in denen die Gesamtzahl der Treffer gleich ist n. Beginnen Sie außerdem immer mindestens 1 Minute vor diesem Zeitrahmen und enden Sie mindestens 1 Minute nach diesem Zeitrahmen (und höchstens 29 Minuten).
Wenn die Eingabe beispielsweise lautet n=8, könnte die Ausgabe wie folgt lauten:

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

Für welche diese Zeiträume die folgenden Summen haben, sind alle gleich 8:

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

Herausforderungsregeln:

• Die Ausgabe ist flexibel. Sie können als Time (oder Date / DateTime) -Objekte Zeitstempel, Zeichenfolgen (mit oder ohne führende Nullen), Dezimalstellen mit .29/ .31/ .59/ .01(dh 0.29-3.01anstelle von 00:29-03:01) usw. ausgeben . Solange klar ist, ist dies vor und nach dem Zeitrahmen .
  Darüber hinaus können Sie den Betrag selbst bestimmen. In allen meinen Beispielen I 1 Minute, aber Sie können auch nur 5 Minuten, 15 Minuten wählen, usw. Das bedeutet auch , können Sie mit .4/ .6/ .9/ .1(dh 0.4-3.1statt 00:24-03:06) zum Beispiel. Die Liste ist auch flexibel. Kann eine Liste / Sammlung, ein Array, eine durch Trennzeichen getrennte Zeichenfolge sein und zeilenweise nach STDOUT usw. gedruckt werden.
  Bitte geben Sie an, welche Ausgabewahl Sie getroffen haben.Hinweis: Es ist nicht erlaubt, die Summen der Zeitrahmen wie oben auszugeben, dies wird nur zur Verdeutlichung erwähnt. Sie müssen die Zeitrahmen ausgeben, auch kurz davor und danach.
• Die Streiks drehen sich von 12:00bis 00:30. Also, wenn n=14zwei der Zeitrahmen 11:29-00:31und sind 11:59-01:01.
• Die Eingabe erfolgt in dem Bereich 1 <= n <= 90, in dem 90 die Gesamtsumme aller möglichen Treffer ist.
• Die von Ihnen zurückgegebenen Fristen können in beliebiger Reihenfolge angegeben werden.

Allgemeine Regeln:

• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
  Lassen Sie sich von Code-Golf-Sprachen nicht davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, für jede Programmiersprache eine möglichst kurze Antwort zu finden.
• Für Ihre Antwort gelten Standardregeln. Daher dürfen Sie STDIN / STDOUT, Funktionen / Methoden mit den richtigen Parametern und vollständige Programme vom Rückgabetyp verwenden. Ihr Anruf.
• Standardlücken sind verboten.
• Fügen Sie nach Möglichkeit einen Link mit einem Test für Ihren Code hinzu.
• Fügen Sie ggf. auch eine Erklärung hinzu.

Testfälle:

(alle mit 1 Minute vor / nach den Zeitrahmen und führenden Nullen)

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

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

Probieren Sie es online!

Diese Lösung verwendet ⎕io←1(1-basierte Indizierung).

Von rechts nach links:

⍳12 ist 1 2 3...12

⍪ verwandelt es in eine hohe dünne 12x1 Matrix

1, Fügt links eine Spalte mit einer 1 hinzu

⍪⍨ Verkettet dieselbe Matrix vertikal, sodass sie jetzt eine 24x2-Matrix ist

, Verflacht die Matrix in der Reihenfolge der Zeilen und wird zu einem Vektor der Größe 48: 1 1 1 2 1 3...1 12 1 1 1 2...1 12

+\ Teilsummen: 1 2 3 5 6 9...

∘.-⍨ die Unterschiede zwischen jedem Paar von Elementen, eine 48x48-Matrix

⍉ transponieren

⎕=eine 48x48-Boolesche Matrix mit 1s, wo immer die ausgewertete Eingabe ( ⎕) auftritt

⍸ die Koordinatenpaare von wo die Einsen sind

.5× halbiere sie

.4 .1∘+¨ Addiere 0,4 zu der ersten und 0,1 zu der zweiten Koordinate in jedem Paar

12| Modulo 12

∪ einzigartig

JavaScript (ES6), 104 Byte

Druckt Zeitintervalle im 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)

Probieren Sie es online!

Verwendet im Wesentlichen den gleichen Algorithmus wie die unten stehende nicht-rekursive Version.

Nicht rekursive Version, 117 Bytes

Gibt eine durch Leerzeichen getrennte Folge von Zeitintervallen im H.MM,H.MMFormat aus.

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

Testfälle

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

Kommentiert

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

Voller Programmteil. Eingabeaufforderungen fürn . Gibt die Liste der Listen mit zwei Elementen in Dezimalstunden aus.

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

Probieren Sie es online!

⍳24 ɩ 1… 24

48⍴ zyklisch r eshape auf Länge 48, das heißt 1 ... 12,1 ... 12

.5× multiplizieren Sie die Hälfte damit

⊂ include (um dieses gesamte Array als rechtes Argument für jedes linke Argument zu verwenden)

(Geben Sie ),/¨ für jede der folgenden Optionen alle Unterlisten dieser Länge zurück:

 ⍳48 ɩ 1… 48

 l← Speichern in l(für l engths)

Jetzt haben wir alle möglichen Listen von Laufzeiten für jede mögliche Lauflänge.

,/ Verketten (wörtlich Verketten-Reduzieren) der Listen von Unterlisten

⊃ enthüllen (weil die Reduktion den Rang von 1 auf 0 reduziert hat)

(… )¨ Wenden auf jede folgende Funktion an:

 ⊢/ das letzte (lit. right-reduction) Element (die Endzeit)

 ⊃, dem ersten Element (der Anfangszeit) voranstellen

 ¯.1 .1+ Fügen Sie diesen negative und positive Zehntel hinzu

(… )/ Filtern Sie diese Anfang-Ende-Paare mit:

 ⍳12 Hinweise 1… 12

 1,¨ stellen Sie 1jedem ein voran

 ∊ ϵ nlist (Abflachen)

 48⍴ zyklisch r eshape auf Länge 48, das heißt 1,1,1,2 ... 1,11,1,12

 ⊂ include (um dieses gesamte Array als rechtes Argument für jedes linke Argument zu verwenden)

 l+/¨ für jedes von l(1… 48) werden die Summen aller Unterlisten dieser Länge zurückgegeben

 ∊ ϵ nlist (Abflachen)

⎕= Vergleichen Sie die numerische Eingabe damit

∪ gibt nur die eindeutigen Elemente zurück (Anfang-Ende-Paare)

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]

Probieren Sie es online!

Ein Zeitrahmen ist dargestellt , wie (t1, t2), t1und t2wobei Dezimalzahlen darstellen Stunden. Der Versatz beträgt .1oder 6 Minuten.

Batch, 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%

Erklärung: tist die Zeit in halben Stunden, beginnend mit 0für 00:30. Die Zahl der Streiks zum Zeitpunkt t ist dann 1, 1, 1, 2, 1, 3usw. Subtrahieren 1der Sequenz gibt 0, 0, 0, 1, 0, 2etc. , die die ganzen Zahlen mit Nullen verschachtelt ist. Dies kann dann durch Multiplikation glied der Sequenz erhalten werden 0, 0, 1, 1, 2, 2usw. mit der Folge 0, 1, 0, 1, 0,1 usw. Diesen beiden Sequenzen leicht unter Verwendung von Modulo berechnet und (integer) Division.

Es bleibt dann übrig, alle 23 möglichen Startzeiten zu durchlaufen, dann alle 24 Schlagzeiten zu nehmen und die Anzahl der Schläge von der Eingabe zu subtrahieren und die Zeiten zu drucken, zu denen das Ergebnis Null ist.

Der Code fällt nach der Schleife durch, es wird jedoch kein Schaden angerichtet, da die Eingabe nicht mehr als 90 betragen kann.

APL NARS, 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) oder l (n) geben alle repräsentativen Intervalle in 0-24 Stunden mit n Taktschlägen zurück. h (n) hat das Uhrzeitformat 0..11.0..59; Stattdessen hat l (n) das Uhrzeitformat 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