Wann blinken die Lichter?

10

Stellen Sie sich vor, Sie haben zwei Lichter. Diese Lichter blinken mit einer bestimmten Geschwindigkeit ein und aus:

Light 0: Delay 0ms and then blink every 1000ms
Light 1: Delay 500ms and then blink every 1000ms

Simulieren wir diese Lichter für die ersten 2000 ms:

0ms:    Light 0 on
500ms:  Light 1 on
1000ms: Light 0 off
1500ms: Light 1 off
2000ms: Light 0 on

Die Herausforderung

Schreiben Sie anhand einer Liste geordneter Paare, die das Timing für Lichter darstellen, ein Programm oder eine Funktion, um die Sequenz für das Blinken auszugeben.

Eingang

Die Eingabe sollte im folgenden Format vorliegen:

TimeToSimulate
Light0Delay,Light0Period
Light1Delay,Light1Period
...

In diesem Format wäre das obige Beispiel:

2000
0,1000
500,1000

Ausgabe

Die Ausgabe sollte eine Reihe von geordneten Tripeln sein:

Time,LightNum,LightStatus

LightStatus ist ein wahrer Wert, wenn das Licht eingeschaltet wird, und ein falscher Wert, wenn das Licht ausgeschaltet wird.

Die Ausgabe des obigen Beispiels wäre:

0,0,True
500,1,True
1000,0,False
1500,1,False
2000,0,True

Wenn zwei Lichter gleichzeitig blinken, sollte das Licht mit der niedrigeren Nummer zuerst im Ausgang angezeigt werden.

Andere Sachen

  • Die Eingabe- und Ausgabeformate sind nicht streng
  • Code sollte keine Fehler erzeugen
  • Die Lösung sollte nicht auf den Rennbedingungen beruhen
  • Keine Standardlücken
  • Dies ist Code-Golf , also gewinnt die kürzeste Lösung!

Testfälle

Input:

2000
0,1000
500,1000

Output:

0,0,True
500,1,True
1000,0,False
1500,1,False
2000,0,True

----

Input:

2
0,1
0,1

Output:

0,0,True
0,1,True
1,0,False
1,1,False
2,0,True
2,1,True

----

Input:

500
100,50
200,100
300,150

Output:

100,0,True
150,0,False
200,0,True
200,1,True
250,0,False
300,0,True
300,1,False
300,2,True
350,0,False
400,0,True
400,1,True
450,0,False
450,2,False
500,0,True
500,1,False

----

Input:

1000
23,345
65,98
912,12
43,365

Output:

23,0,True
43,3,True
65,1,True
163,1,False
261,1,True
359,1,False
368,0,False
408,3,False
457,1,True
555,1,False
653,1,True
713,0,True
751,1,False
773,3,True
849,1,True
912,2,True
924,2,False
936,2,True
947,1,False
948,2,False
960,2,True
972,2,False
984,2,True
996,2,False

Leaderboard-Snippet:

Code-Snippet anzeigen

code-golf  number 
— Daniel M.
quelle
Wie viel Output ist genug?
— Aschepler
@aschepler Was meinst du? Die Eingabe gibt eine Zeitspanne zum "Simulieren" an
— Daniel M.

Antworten:

3

JavaScript, 98 97 Bytes

a=>b=>[...Array(a+1)].map((_,i)=>b.map((d,j)=>d[0]--||c.push([i,j,d[d[0]=d[1]-1,2]^=1])),c=[])&&c

Probieren Sie es online aus

Dank Shaggy ein Byte gespeichert - verwenden Sie die Currying-Eingabesyntax.

Speichern Sie ein Byte mit Curry : a=>b=>.
— Shaggy
@Zottelig. Du bist so schnell, ich habe eine Bearbeitung vorbereitet.
Faustregel: Bei 2 Eingängen immer Curry!
— Shaggy
2

Gelee ,  26  25 Bytes

Ḣrm⁸ð€µ;€€"J;"J$€€ẎẎḂ0¦€Ṣ

Eine dyadische Verknüpfung, die eine Liste von delay, periodNummernlisten und eine Zeitrahmennummer enthält und eine Liste von time, light, actionGanzzahlen zurückgibt.

Die Lichter sind 1-indiziert und 0repräsentieren die Aktion "Aus", während 1sie die Aktion "Ein" darstellen.

Probieren Sie es online aus!

Wie?

Ḣrm⁸ð€µ;€€"J;"J$€€ẎẎḂ0¦€Ṣ - Link: [[delay, period],...], time-frame 
    ð€                    - for €ach [delay, period]:
Ḣ                         -   head (get the delay and modify the item to [period])
 r                        -   inclusive range to time-frame = [delay,delay+1,...,time-frame]
   ⁸                      -   chain's left argument = [period]
  m                       -   modulo slice = [delay, delay+period, delay+2*period, ...]
      µ                   - monadic chain separation, call that v
           J              - range(length(v)) = [1,2,...,nLights]
          "               - zip with:
       ;€€                -   concatenate for €ach for €ach (add light indexes to times)
               $€€        - last two links as a monad for €ach for €ach:
              J           -   range (length(switch-times-for-a-light))
             "            -   zip with:
            ;             -     concatenation (i.e. append a 1-based index)
                  ẎẎ      - tighten & tighten again (flatten by 2 to a list of triples)
                      |€  - sparse application of (for €ach):
                     0    - ...to indexes: 0 (=last entry)
                    Ḃ     - ...action: modulo by 2 (even appended indexes ->0s; odds -> 1s)
                        Ṣ - sort the resulting list of triples
— Jonathan Allan
quelle
2

Python 2 , 206 214 Bytes

  • Es wurden acht Bytes hinzugefügt, um den Regeln zu entsprechen (Eingabe über stdin).
Q=input();D,T=Q[0],[map(int,q.split(","))for q in Q[1:]];O,l=[],len(T)
for j in range(l):
	t,b=T[j][0],9>8
	while t<=int(D):O+="%0*d,%0*d,%s"%(len(D),t,len(str(l)),j,b),;b=not b;t+=T[j][1]
print"\n".join(sorted(O))

Probieren Sie es online aus!

Dieser Code erzeugt eine ungeordnete Liste, die die Schaltzeiten jedes Lichts enthält, diese Zeiten und die Lichtkennung auffüllt, diese Liste sortiert und ausgibt.

— Jonathan Frech
quelle
Nach Standardregeln müssen Sie Eingaben vornehmen, von denen Sie nicht erwarten können, dass sie in einer Variablen vorhanden sind. Sie werden wahrscheinlich feststellen, dass Sie mit using input()auch die Anzahl der Bytes verringern können (es ist kein String-Parsing erforderlich, da dies bei Python 2 der Fall input()ist eval(raw_input())) :).
— Jonathan Allan
... auch wenn Sie Zahlen anstelle von Zeichenfolgen verwenden, werden Odiese sortiert, was wahrscheinlich auch die Anzahl der Bytes verringern würde
— Jonathan Allan
@ JonathanAllan Vielen Dank, dass Sie die Regelunterschiede bemerkt haben. Ich werde Ihre Vorschläge nicht berücksichtigen, da es inzwischen eine deutlich kürzere Python 2-Antwort gibt.
— Jonathan Frech
1

Haskell, 121 Bytes

import Data.List
t!l=sort$(zip[0..]l)>>=takeWhile(\(a,_,_)->a<=t).(\(i,(d,w))->iterate(\(t,i,s)->(t+w,i,not s))(d,i,2>1))

Probieren Sie es online aus.

Dies ist das Programm, mit dem ich begonnen habe:

import Data.List

type LightId = Int
type Time = Int
type State = Bool
type LightEvent = (Time, LightId, State)

lightSimulation :: Time -> Time -> [(Time, State)]
lightSimulation delay interval = iterate step (delay, True)
  where step (time, state) = (time+interval, not state)

addId :: LightId -> (Time, State) -> LightEvent
addId id (t, s) = (t, id, s)

simulate :: Time -> [(Time, Time)] -> [LightEvent]
simulate timeLimit lights = sort $ concatMap lightSim (zip [0..] lights)
  where withinTimeLimit = ((<=timeLimit) . fst)
        lightSims (id, (delay, interval)) = map (addId id) $ takeWhile withinTimeLimit (lightSimulation delay interval)

Und vor dem letzten Golfen habe ich es verkürzt auf:

import Data.List

light (id,(delay,interval)) = iterate step (delay, id, True)
  where step (time, id, state) = (time+interval, id, not state)

simulate timeLimit lights = sort $ concatMap lightSims (zip [0..] lights)
  where lightSims l = takeWhile(\(a,b,c)->a<=timeLimit)$light l
— Cristian Lupascu
quelle
1

Röda , 105 87 85 Bytes

{|t|enum|[([_+_]*(t-_1[0]+1))()|enum|(_+_)]|{[[_+_4,_3,_4//_2%2=0]]if[_4%_2=0]}|sort}

Probieren Sie es online aus!

Erläuterung:

{|t| /* Declare a lambda with one parameter */
/* The input stream contains arrays */
enum| /* For each array in the input, push an ascending number after it */
/* [1] (for stream content in this point, see below) */
[ /* For each array-number pair in the stream: */
    (
        [_+_] /* Create a copy of the array with the number as the last element */
        *(t-_1[0]+1) /* Create copies of the array for every ms simulated */
    )()| /* Push all copies to the stream */
    enum| /* After each copy, push an ascending number to the stream */
    (_+_) /* Append the number to each array before */
]|
/* [2] (for stream content in this point, see below) */
{
    /* Push an on or off event to the stream: */
    [[
        _+_4,      /* delay + time = actual time */
        _3,        /* light-id */
        _4//_2%2=0 /* does the light go on or off? */
    ]] 
    if[_4%_2=0] /* if the light goes on or off (time%period=0) */
}|
/* [3] (for stream content in this point, see below) */
sort /* Sort the events */
}

Der Stream enthält Punktwerte [1]in der folgenden Reihenfolge:

[delay, period], light-id
 _1[0]  _1[1]    _2

Der Stream enthält Punktwerte [2]in der folgenden Reihenfolge:

delay, period, light-id, time
_1     _2      _3        _4

Der Stream enthält an Punkt [3]Arrays mit folgender Struktur:

[time, light-id, on_or_off]
— fergusq
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.