Passen Sie die auffallende Uhr zusammen

14

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 , 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]
Kevin Cruijssen
quelle
1
Ich würde wählen, was am flexibelsten ist. Dies schließt dezimale Stundenzahlen ein, solange die Ergebniszahlen zwischen zwei Rufzeiten liegen.
Adám
@ Adám Vermutlich hast du recht. Ich habe meine Antwort entsprechend bearbeitet. Sie sollten mindestens 1 Minute haben und höchstens 29 Minuten, so .4/ .6/ .9/ .1darf (wobei 6 Minuten wie Sie haben gesagt: :24/ :36/ :54/ :06).
Kevin Cruijssen
1
Erwähnen Sie vielleicht, dass die Zeitpaare in beliebiger Reihenfolge zurückgegeben werden können?
Adám
Ok, n ist in 0..90, ich finde nicht klar, wie lange ist der Zeitraum für die Berechnung der n Streiks: Es ist 12 Stunden? Sie sind 24 Stunden? Sind 48 Stunden? Sind dann Rückgabezeiten im Format 0..24: 0..60 zulässig?
RosLuP
@RosLuP Der Zeitrahmen ist eine reguläre analoge Uhr, also von 00:01 bis 12:00. Anstelle von 0..24: 0..60 sollte es also 0..12: 0..60 sein. Wie das jede Verwirrung beseitigt.
Kevin Cruijssen

Antworten:

3

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

ngn
quelle
Welches Zeitintervall wird .1in der Ausgabe dargestellt? Auch schöne Antwort.
Erik der Outgolfer
2
Oh, und das ist es, was es möglich macht, dass dies 34 Bytes sind, vielleicht möchten Sie einen Link dazu erstellen oder <sup>SBCS</sup>genau wie Adáms Antwort schreiben .
Erik der Outgolfer
@EriktheOutgolfer das Problem erlaubt explizit .1 / .4 / .6 / .9 anstelle von: 01 /: 29 /: 31 /: 59. Für diese Antwort benötige ich keine spezielle Codierung. Sie ist in Dyalog Classic enthalten und verfügt über eine eigene Einzelbyte-Codierung.
ngn
ist nicht in Dyalog Classic. Und ja, ich weiß, das ist ausdrücklich erlaubt, ich wollte nur wissen, wie viele Minuten 0.1in der Ausgabe ist;)
Erik the Outgolfer
@EriktheOutgolfer "SBCS" hinzugefügt, danke; 0,1 × 60 Minuten ist 6 Minuten
ngn
5

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

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
Arnauld
quelle
4

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:

⍳12Hinweise 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)

Adam
quelle
0.1 0.5kann werden.1 .5
Kritixi Lithos
@Cowsquack Ja, ich habe es auch bemerkt. Trotzdem danke.
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]

Probieren Sie es online!

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

ovs
quelle
1

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.

Neil
quelle
1

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 
RosLuP
quelle