Quand les lumières clignotent-elles?

10

Imaginez que vous ayez deux lumières. Ces voyants clignotent et s'éteignent à un rythme spécifique:

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

Simulons ces lumières pour les premiers 2000 ms:

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

Le défi

Étant donné une liste de paires ordonnées représentant la synchronisation des lumières, écrivez un programme ou une fonction pour sortir la séquence quand elles clignotent.

Contribution

L'entrée doit être au format suivant:

TimeToSimulate
Light0Delay,Light0Period
Light1Delay,Light1Period
...

Dans ce format, l'exemple ci-dessus serait:

2000
0,1000
500,1000

Production

La sortie doit être une série de triplets ordonnés:

Time,LightNum,LightStatus

LightStatus est une valeur vraie si la lumière s'allume et une valeur fausse si la lumière s'éteint.

La sortie de l'exemple ci-dessus serait:

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

Si deux voyants clignotent en même temps, le voyant avec le numéro le plus bas doit s'afficher en premier dans la sortie.

D'autres choses

  • Les formats d'entrée et de sortie ne sont pas stricts
  • Le code ne doit produire aucune erreur
  • La solution ne doit pas reposer sur les conditions de course
  • Aucune échappatoire standard
  • C'est le code-golf , donc la solution la plus courte l'emporte!

Cas de test

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

Extrait de classement:

Afficher l'extrait de code

code-golf  number 
— Daniel M.
source
Combien de sortie suffit?
— aschepler
@aschepler Que voulez-vous dire? L'entrée spécifie une quantité de temps pour "simuler"
— Daniel M.

Réponses:

3

JavaScript, 98 97 octets

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

Essayez-le en ligne

Enregistrement d'un octet grâce à Shaggy - utilisez la syntaxe d'entrée au curry.

Enregistrer un octet avec curryfication: a=>b=>.
— Shaggy
@Hirsute. Tu es si rapide, je préparais un montage.
Règle générale: s'il y a 2 entrées, toujours au curry!
— Shaggy
2

Gelée ,  26  25 octets

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

Un lien dyadique prenant une liste de listes de delay, periodnuméros et un numéro de période et renvoyant une liste d' time, light, actionentiers.

Les voyants sont indexés 1 et 0représentent l'action «éteinte», tandis que 1l'action «allumée».

Essayez-le en ligne!

Comment?

Ḣ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
source
2

Python 2 , 206 214 octets

  • Ajout de huit octets pour se conformer aux règles (prise d'entrée via 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))

Essayez-le en ligne!

Ce code génère une liste non ordonnée contenant les heures de commutation de chaque lumière, remplit ces heures et l'identifiant de la lumière, trie ladite liste et la sort.

— Jonathan Frech
source
Selon les règles standard, vous devez prendre une entrée dont vous ne pouvez pas vous attendre à ce qu'elle préexiste dans une variable. Vous constaterez probablement que l'utilisation input()vous permettra également de réduire le décompte des octets (aucune analyse de chaîne ne sera requise puisque Python 2 l' input()est eval(raw_input())) :).
— Jonathan Allan
... aussi si vous utilisez des nombres plutôt que des chaînes, Oils trieront, ce qui réduirait probablement aussi le nombre d'octets,
— Jonathan Allan
@JonathanAllan Merci d'avoir remarqué la divergence des règles; Je n'intégrerai pas vos suggestions car il existe une réponse Python 2 beaucoup plus courte à ce jour.
— Jonathan Frech
1

Haskell, 121 octets

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

Essayez-le en ligne.

Voici le programme à partir duquel j'ai commencé:

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)

Et avant le golf final, je l'ai raccourci à:

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
source
1

Röda , 105 87 85 octets

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

Essayez-le en ligne!

Explication:

{|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 */
}

Le flux contient des [1]valeurs ponctuelles dans l'ordre suivant:

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

Le flux contient des [2]valeurs ponctuelles dans l'ordre suivant:

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

Le flux contient des [3]tableaux de points avec la structure suivante:

[time, light-id, on_or_off]
— fergusq
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.