¿Cuándo parpadean las luces?

10

Imagina que tienes dos luces. Estas luces parpadean a una velocidad específica:

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

Simulemos estas luces durante los primeros 2000 ms:

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

El reto

Dada una lista de pares ordenados que representan el tiempo de las luces, escriba un programa o función para emitir la secuencia para cuando parpadeen.

Entrada

La entrada debe estar en el siguiente formato:

TimeToSimulate
Light0Delay,Light0Period
Light1Delay,Light1Period
...

En este formato, el ejemplo anterior sería:

2000
0,1000
500,1000

Salida

La salida debe ser una serie de triples ordenados:

Time,LightNum,LightStatus

LightStatus es un valor verdadero si la luz se enciende y un valor falso si la luz se apaga.

El resultado del ejemplo anterior sería:

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

Si dos luces parpadean al mismo tiempo, la luz con el número más bajo debería aparecer primero en la salida.

Otras cosas

  • Los formatos de entrada y salida no son estrictos.
  • El código no debe producir ningún error.
  • La solución no debe depender de las condiciones de carrera.
  • No hay lagunas estándar
  • Este es el código de golf , por lo que gana la solución más corta.

Casos de prueba

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

Fragmento de la tabla de posiciones:

Mostrar fragmento de código

code-golf number Daniel M.
fuente
¿Cuánta salida es suficiente?
aschepler
@aschepler ¿Qué quieres decir? La entrada especifica una cantidad de tiempo para "simular"
Daniel M.

Respuestas:

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

Pruébalo en línea

Guardado un byte gracias a Shaggy : use la sintaxis de entrada de curry.


fuente
Guardar un byte con currificación: a=>b=>.
Shaggy
@Lanudo. Eres tan rápido, estaba preparando una edición.
Regla general: si hay 2 entradas, ¡siempre curry!
Shaggy
2

Jalea ,  26  25 bytes

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

Un enlace diádico que toma una lista de listas de delay, periodnúmeros y un número de marco de tiempo y devuelve una lista de time, light, actionenteros.

Las luces están indexadas en 1 y 0representan la acción 'apagado', mientras que 1representan la acción 'encendido'.

Pruébalo en línea!

¿Cómo?

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

Python 2 , 206 214 bytes

  • Se agregaron ocho bytes para cumplir con las reglas (toma de entrada a través de 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))

Pruébalo en línea!

Este código genera una lista desordenada que contiene los tiempos de conmutación de cada luz, rellena esos tiempos y el identificador de la luz, ordena dicha lista y la emite.

Jonathan Frech
fuente
Según las reglas estándar, debe tomar datos que no puede esperar que preexistan en una variable. Probablemente encontrará que el uso también input()le permitirá cortar la cuenta regresiva de bytes (no se requerirá el análisis de cadenas ya que Python 2 input()es eval(raw_input())) :).
Jonathan Allan
... también si usa números en lugar de cadenas, Ose ordenarán, lo que probablemente también reduciría el conteo de bytes,
Jonathan Allan
@ JonathanAllan Gracias por notar la discrepancia de la regla; No incorporaré sus sugerencias ya que hay una respuesta de Python 2 significativamente más corta por ahora.
Jonathan Frech
1

Perl 5 , 106 + 1 (-n) = 107 bytes

($a[$i],$b[$i++])=eval for<>;for$i(0..$_){for(0..$#a){$a[$_]+=$b[$_],say"$i,$_,".($s[$_]^=1)if$i==$a[$_]}}

Pruébalo en línea!

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

Pruébalo en línea.

Este es el programa desde el que comencé:

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)

Y antes del golf final lo acorté a:

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
fuente
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}

Pruébalo en línea!

Explicación:

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

La secuencia contiene [1]valores puntuales en el siguiente orden:

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

La secuencia contiene [2]valores puntuales en el siguiente orden:

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

La secuencia contiene [3]conjuntos de puntos con la siguiente estructura:

[time, light-id, on_or_off]
fergusq
fuente