Lucas vs. El control remoto de la puerta del garaje

15

Descargo de responsabilidad

Si bien sé que existe esta pregunta relacionada en particular , mi pregunta usa dos puertas de garaje, un componente aleatorio, y también estoy basando esto en eventos de la vida real, al ver que mi hijo bajó accidentalmente una de dichas puertas de garaje mientras salía del garaje la semana pasada ... ¡Nada como un golpe en la cabeza para que fluyan los jugos creativos! ;)

El fondo

A Lucas (mi hijo de 15 meses) le gusta jugar con el control remoto del garaje. Hay dos botones en este control remoto, uno para la puerta de garaje izquierda y otro para la puerta de garaje derecha. Ambos botones funcionan de la misma manera; presione una vez para que la puerta comience a abrir, presione nuevamente para detener, presione nuevamente para comenzar a cerrar, presione nuevamente para detener nuevamente, y así sucesivamente.

A Lucas le encanta este control remoto, presionará aleatoriamente uno de los botones, o ambos, o ninguno. Si se presionan ambos, no se envía ninguna señal, pero al presionar un botón se enviará una señal.

Entonces, el desafío del código-golf se divide en dos partes:

Parte uno

Genere una cadena larga de 60 caracteres que represente las pulsaciones aleatorias de los botones de Lucas durante un minuto. "Aleatorio" en este caso significa "con la misma probabilidad de cada entrada en cada tic". Los personajes son los siguientes:

  • 0: Lucas no presionó ningún botón o presionó ambos botones. De cualquier manera, no se ha enviado ninguna señal.
  • 1: Lucas ha presionado el botón de la puerta de garaje izquierda
  • 2: Lucas ha presionado el botón de la puerta de garaje derecha

La segunda parte

Usando la cadena generada en la Parte Uno, simule la apertura y el cierre del garaje para dos autos usando los números como disparadores para abrir, detener y cerrar estas puertas.

Las puertas de mi garaje son bastante rápidas (consulte el descargo de responsabilidad anterior para saber por qué). Una vez que presiona el botón, tarda cuatro segundos en abrirse o cerrarse por completo.

Entonces, si está cerrado:

  • 0 segundos: 0% abierto (cerrado); Cuando se presiona el botón, la puerta comienza a abrirse
  • 1 seg: 25% abierto
  • 2 segundos: 50% abierto
  • 3 segundos: 75% abierto
  • 4 segundos: 100% abierto, la puerta se detiene

Y por lo tanto, si está abierto:

  • 0 segundos: 100% abierto; Cuando se presiona el botón, la puerta comienza a cerrarse
  • 1 seg .: 75% abierto
  • 2 segundos: 50% abierto
  • 3 seg: 25% abierto
  • 4 seg: 0% abierto (cerrado), la puerta se detiene

Si una puerta en particular está en movimiento, una señal a esa misma puerta la detendrá. La siguiente señal enviada a esa misma puerta después de eso la enviará moviéndose en la dirección opuesta. Si una puerta se detiene cuando anteriormente estaba en movimiento y ahora está completamente abierta o completamente cerrada cuando se recibe la señal de "parada", la puerta se registrará como "detenida" en el estado completamente abierto o completamente cerrado, lista para moverse en la dirección opuesta cuando recibe una nueva señal.

Con esta simulación, ambas puertas de garaje estarán inicialmente en la posición cerrada. Entonces, echemos un vistazo a una lista de comandos de 10 segundos y veamos qué sucede si Lucas los ejecuta en el control remoto:

2120221120
2: (L:0% stopped, R:0% opening)
1: (L:0% opening, R:25% opening)
2: (L:25% opening, R:50% stopped)
0: (L:50% opening, R:50% stopped)
2: (L:75% opening, R:50% closing)
2: (L:100% stopped, R:25% stopped)
1: (L:100% closing, R:25% stopped)
1: (L:75% stopped, R:25% stopped)
2: (L:75% stopped, R:25% opening)
0: (L:75% stopped, R:50% opening)

Salida

La primera parte de la salida requiere la visualización de la cadena de 60 caracteres de caracteres aleatorios "0", "1" y "2" generados a partir de la Parte Uno. p.ej. 212022112021202211202120221120212022112021202211202120221120

Debajo de esta cadena, se encuentra el procesamiento de estas "señales" de acuerdo con las reglas mencionadas anteriormente sobre cómo se comportarán las puertas de garaje con cada carácter respectivo (segundo a segundo). Debe terminar con 60 líneas como resultado debajo de la cadena de visualización inicial.

Cada una de estas líneas procesadas tendrá la forma de: N: (L:X% XXXXXXX, R:Y% YYYYYYY)donde:

  • N es el enésimo carácter de la cadena aleatoria respectiva, que tendrá la forma de 0, 1 o 2.
  • X% es el porcentaje de apertura de la puerta izquierda (no hay relleno cero)
  • XXXXXXX es el estado de la puerta izquierda. Si la puerta no está en movimiento (es decir, no se abre ni se cierra), se aplica el estado "detenido", lo que significa que se ha detenido en movimiento (solo es posible al 25%, 50% o 75%) o se detiene cuando está completamente abierto (100% ) o completamente cerrado (0%). De lo contrario, la puerta estará "abriéndose" o "cerrándose".
  • Y% es el porcentaje de apertura de la puerta derecha (no hay relleno cero)
  • AAAAAA es el estado de la puerta derecha. Si la puerta no está en movimiento (es decir, no se abre ni se cierra), se aplica el estado "detenido", lo que significa que se ha detenido en movimiento (solo es posible al 25%, 50% o 75%) o se detiene cuando está completamente abierto (100% ) o completamente cerrado (0%). De lo contrario, la puerta estará "abriéndose" o "cerrándose".

Ejemplo que se muestra a continuación utilizando 10 "señales" y 10 líneas procesadas

2120221120
2: (L:0% stopped, R:0% opening)
1: (L:0% opening, R:25% opening)
2: (L:25% opening, R:50% stopped)
0: (L:50% opening, R:50% stopped)
2: (L:75% opening, R:50% closing)
2: (L:100% stopped, R:25% stopped)
1: (L:100% closing, R:25% stopped)
1: (L:75% stopped, R:25% stopped)
2: (L:75% stopped, R:25% opening)
0: (L:75% stopped, R:50% opening)

Este es el código de golf, por lo que el código más corto será el claro ganador. He hecho esto un poco fácil usando frases como "abrir", "detener" y "cerrar", que son las siete letras ... así que es posible que desee incluir eso en su estrategia.

¡La mejor de las suertes!

code-golf 
— WallyWest
fuente
Debe definir un formato de salida más claro para la Parte 2.
— LegionMammal978
@ LegionMammal978 ¿Qué sientes que falta en la salida?
— WallyWest
1
No lo hago en este momento, pero creo que es una buena pregunta, puedo abordarla.
— DLosc
1
¿Por qué el último 1comando no detiene la puerta izquierda al 75% en su ejemplo?
— Arnauld
1
¿Deben 0,1, y 2 aparecer todos igualmente en la primera parte, o deben no presionar, presionar dos veces, presionar a la izquierda y presionar a la derecha todos aparecer igualmente? (lo que significa que 0 es más probable porque representa dos escenarios que causan lo mismo y resultan ...)
— Socratic Phoenix

Respuestas:

2

Pyth, 156 149 145 bytes

jkJmO3U60K=G*]Z3=b*3]_1VJFHS2I&=T@KHq*2hT@XHGTH XbHT XKH0)) XKN*_@XbN|@KN@bNN!@KN%+N": (L:%s, R:%s)"m++*@Gd25"% "%3>"csoltpooespnipinengdg"h@KdS2

Una traducción directa de mi respuesta de Python .

Pruébalo en línea!

Explicación:

jk                              " print ''.join(map(str,                   "
JmO3U60                         "  J = [randint(0,2) for _ in range(60)])) "
K=G*]Z3                         " K = copy(G = [0] * 3)                    "
=b*3]_1                         " b = [-1] * 3                             "
VJ                              " for N in J:                              "
FHS2                            "  for H in range(1, 3):                   "
I&=T@KH                         "   if ((T = K[H]) and                     "
q*2hT@XHGTH                     "       (2 * (T + 1) == (G[H] += T)[H]):   "
 XbHT                           "    b[H] = T                              "
 XKH0))                         "    K[H] = 0                              "
 XKN*_@XbN|@KN@bNN              "  K[N] = (-(b[N] = K[N] or B[N])[N] *     "
!@KN                            "   (not K[N]))                            "
%+N": (L:%s, R:%s)"             "  print(str(N) + ': (L:%s, R:%s)' %       "
m++                             "   map(lambda d:                          "
*@Gd25                          "    G[d] * 25 +                           "
"% "                            "    '% ' +                                "
%3>"csoltpooespnipinengdg"h@Kd  "    'csoltpooespnipinengdg'[K[d]+1::3]]   "
S2                              "   ), range(1, 3))                        "
— Cobre
fuente
¡Guauu! Gracias por esta respuesta, así como por la explicación del código ... En realidad, tenía sentido para cuando llegué al final ...
— WallyWest
5

Javascript (ES6), 277 275 263 253 250 247 234 bytes

_=>(d=[0,0],l=s='',[...Array(60)].map(_=>(s+=`
${c=Math.random()*3|0}:(`,l+=c,d=d.map((v,i)=>(v=v&8?v&16?v-27?v+1:20:v-9?v-1:0:v,v^=c+~i?0:v&8||24,s+='LR'[i]+`:${(v&7)*25}% `+(v&8?v&16?'opening':'closing':'stopped')+',)'[i],v)))),l+s)

Ungolfed y comentó

_ => (
  // Initialize array:
  //   - d = door states as integers
  //     - bits 0 to 2: door opening state (from 0b000 = 0% to 0b100 = 100%)
  //     - bit #3: door in motion (0: no, 1: yes)
  //     - bit #4: door direction (0: closing, 1: opening)
  d = [0, 0],

  // Initialize strings:
  //   - l = list of commands
  //   - s = door states in plain text
  l = s = '',

  // Iterate on an array of 60 entries.
  [...Array(60)].map(_ => (
    // c = new random command (0, 1 or 2)
    // Append new line and new command to s.
    s += `\n${c = Math.random() * 3 | 0}:(`,

    // Append new command to l.
    l += c,

    // For each door ...
    d = d.map((v, i) => (
      // If the door is in motion, update its opening state.
      // Clear the 'in motion' bit if a bound is reached (either closed or fully open).
      v = v & 8 ? v & 16 ? v - 27 ? v + 1 : 20 : v - 9 ? v - 1 : 0 : v,

      // If the current command is intended for this door, update its direction and
      // 'in motion' bit. Direction is changed on the 'stopped => moving' transition.
      v ^= c + ~i ? 0 : v & 8 || 24,

      // Translate the door state in plain text and append it to s
      s +=
        'LR'[i] +
        `:${(v & 7) * 25}% ` +
        (v & 8 ? v & 16 ? 'opening' : 'closing' : 'stopped') +
        ',)'[i],

      // Value to be taken into account by map()
      v
    ))
  )),

  // Final result to be returned
  l + s
)

Manifestación

let f = 
_=>(d=[0,0],l=s='',[...Array(60)].map(_=>(s+=`
${c=Math.random()*3|0}:(`,l+=c,d=d.map((v,i)=>(v=v&8?v&16?v-27?v+1:20:v-9?v-1:0:v,v^=c+~i?0:v&8||24,s+='LR'[i]+`:${(v&7)*25}% `+(v&8?v&16?'opening':'closing':'stopped')+',)'[i],v)))),l+s)

console.log(f())
Expandir fragmento

— Arnauld
fuente
Wow, estoy impresionado con el revestimiento y arrojándolo a console.log en eso! ¡Bien hecho!
— WallyWest
1
Curiosamente no funciona en Firefox, solo 4 líneas de salida, como esta 112200001100122021010101012100000010011200201022122021012211 [ "L:25% stopped", "R:25% stopped" ](nuevas líneas después de comas y corchetes)
— edc65
@ edc65 - Mi mal, en realidad. Leí mal las instrucciones sobre el formato de salida. Esto está arreglado.
— Arnauld
@Arnauld También puede eliminar los paréntesis v^=(c-i-1?0:v&8||24)para guardar dos bytes.
— WallyWest
PD @Arnauld, ¡gracias por participar!
— WallyWest
4

Python 2, 377 370 361 357 345 335 326 316 312 306 304 bytes

El segundo nivel de sangría es una pestaña sin formato ( \t), que juega muy mal con Markdown, por lo que ha sido reemplazado por dos espacios.

from random import*
p=[randint(0,2)for d in[[0]*3]*60]
print`p`[1::3]
v=[-1]*3
c=[0]*3
f=lambda y:str(c[y]*25)+'% '+'csoltpooespnipinengdg'[d[y]+1::3]
for x in p:
 for i in 1,2:
  q=d[i];c[i]+=q
  if(2*-~q==c[i])*q:v[i]=q;d[i]=0
 z=d[x]
 if z:v[x]=z
 d[x]=-v[x]*(z==0);print'%d: (L:%s, R:%s)'%(x,f(1),f(2))

Estoy casi seguro de que esto se puede jugar más.

Sin golf, con comentarios:

import random

# Generate the random string - represented as a list of ints
presses = [random.randint(0, 2) for _ in range(60)]
print ''.join(map(str, presses))

# Constants for door states used for easier reading
CLOSING = -1
STOPPED = 0
OPENING = 1

# Variables representing the state of the garage doors
# There's a third element in these so that x[0] resolves to a dummy slot
# (this way, we can avoid a conditional down the road)
prev_states = [CLOSING, CLOSING, 0]
door_states = [STOPPED, STOPPED, 0]
door_pcts = [0, 0, 0]  # delta 1 = 25%

for press in presses:
  # Close/open the door 1 more
  for i in 1, 2:
    if door_states[i] != STOPPED:
      delta_pct, stop_pct = (-1, 0) if door_states[i] == CLOSING else (1, 4)
      door_pcts[i] += delta_pct
      if door_pcts[i] == stop_pct:
        prev_states[i] = door_states[i]
        door_states[i] = STOPPED

  # Handle pressing a button
  # If the press is 0 (no press), the 0th element resolves to a dummy
  # door, thus saving us an expensive conditional

  if door_states[press] == STOPPED:
    door_states[press] = -prev_states[press]
  else:
    prev_states[press] = door_states[press]
    door_states[press] = STOPPED

  # Print the status update
  print '%d: (L:%d%% %s, R:%d%% %s)' % (
    press,
    door_pcts[0]*25,
    ['closing', 'stopped', 'opening'][door_states[0]+1],
    door_pcts[1]*25,
    ['closing', 'stopped', 'opening'][door_states[1]+1],
  )

¡Guardado 4 14 15 bytes gracias a @TheBikingViking!

¡Guardado 6 bytes gracias a @ValueInk!

— Cobre
fuente
1
Puedes cambiar range(60)a [0]*60.
— TheBikingViking
1
@TheBikingViking ¡Gracias! Estoy editando eso ahora.
— Cobre
2
Tu puedes hacer 'p'[1::3] (reemplazar los apóstrofos con comillas invertidas) en lugar de ''.join(map(str,p)).
— TheBikingViking
2
(4,0)[q<0]==c[i]and q->((4,0)[q<0]==c[i])*q
— TheBikingViking
2
@ValueInk Esa línea abusa de un error en las comprensiones de la lista de Python 2 para establecer nesa cadena. nse utiliza en la línea final para extraer closing, stopped, openingde esa cadena.
— Cobre
2

Rubí, 263 261 260 254 bytes

¿Cómo se acortó la respuesta de JavaScript? Sobrepasó la mía mientras estaba fuera y todavía está ganando actualmente ...

s=(1..60).map{rand 3}
puts s*''
D=1,2
d=[25]*3;a=[0]*3;m=[p]*3
s.map{|i|D.map{|j|m[j]&&a[j]+=d[j];(0..100)===a[j]+d[j]||i!=j&&(d[j]*=-1;m[j]=p)}
(m[i]^=1)||d[i]*=-1
puts"#{i}: (L%s, R%s)"%D.map{|j|":#{a[j]}% #{%w"stopped opening closing"[m[j]?d[j]:0]}"}}
— Tinta de valor
fuente
2

C, 420 433 424 374 bytes

#define F(X,x) X=x==1?X+1:x==2?X-1:X;X=X<0?0:X>4?4:X;x=X==0?0:X==4?3:x
#define G(x) x=x==1?3:x==2?0:x==3?2:x+1
#define H(X,x) X*25,x==0||x==3?"stopped":x==1?"opening":"closing"
c,i,l,r,L,R,x[60];main(){while(i<60)printf("%d",x[i++]=random()%3);while(c<60){if(x[c]==1)G(l);else if(x[c]==2)G(r);printf("\n%d: (L:%d%% %s, R:%d%% %s)",x[c++],H(L,l),H(R,r));F(L,l);F(R,r);}}

No siembra el generador aleatorio, pero usa aleatorio para una mejor distribución. Sin embargo, debe haber una mejor manera de jugar esta lógica ...

110121100121212100112200222111200020111100022122202112202211002
1: (L:0% opening, R:0% stopped)
1: (L:25% stopped, R:0% stopped)
0: (L:25% stopped, R:0% stopped)
1: (L:25% closing, R:0% stopped)
2: (L:0% stopped, R:0% opening)
1: (L:0% opening, R:25% opening)
1: (L:25% stopped, R:50% opening)
0: (L:25% stopped, R:75% opening)
0: (L:25% stopped, R:100% stopped)
1: (L:25% closing, R:100% stopped)
2: (L:0% stopped, R:100% closing)
1: (L:0% opening, R:75% closing)
2: (L:25% opening, R:50% stopped)
1: (L:50% stopped, R:50% stopped)
2: (L:50% stopped, R:50% opening)
1: (L:50% closing, R:75% opening)
0: (L:25% closing, R:100% stopped)
0: (L:0% stopped, R:100% stopped)
1: (L:0% opening, R:100% stopped)
1: (L:25% stopped, R:100% stopped)
2: (L:25% stopped, R:100% closing)
2: (L:25% stopped, R:75% stopped)
0: (L:25% stopped, R:75% stopped)
0: (L:25% stopped, R:75% stopped)
2: (L:25% stopped, R:75% opening)
2: (L:25% stopped, R:100% closing)
2: (L:25% stopped, R:75% stopped)
1: (L:25% closing, R:75% stopped)
1: (L:0% opening, R:75% stopped)
1: (L:25% stopped, R:75% stopped)
2: (L:25% stopped, R:75% opening)
0: (L:25% stopped, R:100% stopped)
0: (L:25% stopped, R:100% stopped)
0: (L:25% stopped, R:100% stopped)
2: (L:25% stopped, R:100% closing)
0: (L:25% stopped, R:75% closing)
1: (L:25% closing, R:50% closing)
1: (L:0% opening, R:25% closing)
1: (L:25% stopped, R:0% stopped)
1: (L:25% closing, R:0% stopped)
0: (L:0% stopped, R:0% stopped)
0: (L:0% stopped, R:0% stopped)
0: (L:0% stopped, R:0% stopped)
2: (L:0% stopped, R:0% opening)
2: (L:0% stopped, R:25% stopped)
1: (L:0% opening, R:25% stopped)
2: (L:25% opening, R:25% closing)
2: (L:50% opening, R:0% opening)
2: (L:75% opening, R:25% stopped)
0: (L:100% stopped, R:25% stopped)
2: (L:100% stopped, R:25% closing)
1: (L:100% closing, R:0% stopped)
1: (L:75% stopped, R:0% stopped)
2: (L:75% stopped, R:0% opening)
2: (L:75% stopped, R:25% stopped)
0: (L:75% stopped, R:25% stopped)
2: (L:75% stopped, R:25% closing)
2: (L:75% stopped, R:0% opening)
1: (L:75% opening, R:25% opening)
1: (L:100% closing, R:50% opening)

Versión anterior 1:

c,i,l,r,L,R,x[60];main(){while(i<60)printf("%d",x[i++]=random()%3);while(c<60){if(x[c]==1)l=l==1?3:l==2?0:l==3?2:l+1;else if(x[c]==2)r=r==1?3:r==2?0:r==3?2:r+1;printf("\n%d: (L:%d%% %s, R:%d%% %s)",x[c++],L*25,l==0||l==3?"stopped":l==1?"opening":"closing",R*25,r==0||r==3?"stopped":r==1?"opening":"closing");L=l==1?L+1:l==2?L-1:L;R=r==1?R+1:r==2?R-1:R;L=L<0?0:L>4?4:L;R=R<0?0:R>4?4:R;l=L==0?0:L==4?3:l;r=R==0?0:R==4?3:r;}}

Versión anterior 2:

c,i,l,r,L,R,x[60];g(){while(i<60)printf("%d",x[i++]=random()%3);}main(){g();while(c<60){if(x[c]==1)l=l==1?3:l==2?0:l==3?2:l+1;else if(x[c]==2)r=r==1?3:r==2?0:r==3?2:r+1;printf("%d: (L:%d%% %s, R:%d%% %s)\n",x[c++],L*25,l==0||l==3?"stopped":l==1?"opening":"closing",R*25,r==0||r==3?"stopped":r==1?"opening":"closing");L=l==1?L+1:l==2?L-1:L;R=r==1?R+1:r==2?R-1:R;L=L<0?0:L>4?4:L;R=R<0?0:R>4?4:R;l=L==0?0:L==4?3:l;r=R==0?0:R==4?3:r;}}
— cleblanc
fuente
2
¿Puedes convertir eso en código?
— haykam
2

PHP, 254 247 246 245 235 230 226 bytes

venciendo a ES otra vez!

for($t=60;$t--;)$s.=rand()%3;echo$s;for(;++$t<60;print"
$c: ($o[1], $o[2])")for($i=3;--$i;$o[$i]='.LR'[$i].':'.$d[$i]*25 .'% '.[opening,stopped,closing][abs($z-1)])if(((1&$z=&$r[$i])&&!(3&$d[$i]+=2-$z))|$i&$c=$s[$t])$z=++$z%4;

golfed desde estos 311 (la primera versión completa, ya tenía algo de golf):

<?for($i=60;$i--;)$s.=rand(0,2);echo$s;$d=$r=[0,0];$n=[L,R];$p=[stopped,opening,stopped,closing];for($t=-1;++$t<60;print"
$c: (".join(', ',$x).")")for($m=$c=$s[$t],$i=-1;$i++<1;){if($r[$i]&1)if(!($d[$i]+=2-$r[$i])||4==$d[$i])$m|=$i+1;if($m&$i+1)$r[$i]=(1+$r[$i])%4;$x[$i]="$n[$i]:".($d[$i]*25)."% ".$p[$r[$i]];}

Descompostura

for($t=60;$t--;)$s.=rand()%3;   // part 1               also initializes $t to -1
echo$s;
for(
    ;
    ++$t<60;
    print"\n$c: ($o[1], $o[2])" // print output
)
    for($i=3;--$i;  // loop $i from 2 to 1 (door number)
        // generate output
        $o[$i]='.LR'[$i].':'.$d[$i]*25 .'% '
        .[opening,stopped,closing][abs($z-1)]           // map 0123 to 1012
    )
        if(((1&$z=&$r[$i])  // if door in motion        ... and reference the array item
            &&!(3&              // 2. if end position   "&&" needed for short circuit
            $d[$i]+=2-$z        // 1. move door         2-$z maps 1,3 to 1,-1 = delta
            )
        )|$i&$c=$s[$t])     // 3. or if button $i pressed   "|" needed for no short circuit
            $z=++$z%4;          // rotate direction     ++$z%4 maps 0,1,2,3 to 1,2,3,0
        // generate output (loop post condition)
    // print output (loop post condition)
— Titus
fuente
@Arnauld: ¡te tengo! :)
— Tito
1

Java 8 lambda, 500 caracteres

Hice lo mejor que pude, esto es lo que se me ocurrió:

()->{String r="";int i=0,l=0,m=0,n=1,o=1,p=0,q=0;for(;i++<60;)r+=(int)(Math.random()*3);for(char s:r.toCharArray()){l+=p;m+=q;if(l>99&p>0){l=100;p=25*(((n=++n%4)-1)%2);}if(l<1&p<0){l=0;p=25*(((n=++n%4)-1)%2);}if(m>99&q>0){m=100;q=25*(((o=++o%4)-1)%2);}if(m<1&q<0){m=0;q=25*(((o=++o%4)-1)%2);}if(s<49);else if(s>49)q=25*(((o=++o%4)-1)%2);else p=25*(((n=++n%4)-1)%2);r+="\n"+s+": (L:"+l+"% "+(p<0?"closing":p>0?"opening":"stopped")+", R:"+m+"% "+(q<0?"closing":q>0?"opening":"stopped")+")";}return r;}

Sin golfista en una clase completa:

public class Q91479 {

    public static String movedDoorsCombined() {
        String result = "";
        int i = 0, leftDoor = 0, rightDoor = 0, stepLeft = 1, stepRight = 1, changeLeft = 0, changeRight = 0;

        for (; i++ < 60;) {
            result += (int) (Math.random() * 3);
        }

        for (char step : result.toCharArray()) {
            // update stats
            leftDoor += changeLeft;
            rightDoor += changeRight;

            if (leftDoor > 99 & changeLeft > 0) {
                leftDoor = 100;
                changeLeft = 25 * (((stepLeft = ++stepLeft % 4) - 1) % 2);
            }
            if (leftDoor < 1 & changeLeft < 0) {
                leftDoor = 0;
                changeLeft = 25 * (((stepLeft = ++stepLeft % 4) - 1) % 2);
            }
            if (rightDoor > 99 & changeRight > 0) {
                rightDoor = 100;
                changeRight = 25 * (((stepRight = ++stepRight % 4) - 1) % 2);
            }
            if (rightDoor < 1 & changeRight < 0) {
                rightDoor = 0;
                changeRight = 25 * (((stepRight = ++stepRight % 4) - 1) % 2);
            }

            if (step < 49) {
                // 0
            }
            else if (step > 49) {
                // right
                changeRight = 25 * (((stepRight = ++stepRight % 4) - 1) % 2);
            }
            else {
                // left
                changeLeft = 25 * (((stepLeft = ++stepLeft % 4) - 1) % 2);
            }
            result += "\n" + step + ": (L:" + leftDoor + "% "
                        + (changeLeft < 0 ? "closing" : changeLeft > 0 ? "opening" : "stopped")
                        + ", R:" + rightDoor + "% "
                        + (changeRight < 0 ? "closing" : changeRight > 0 ? "opening" : "stopped")
                        + ")";
        }
        return result;
    }
}

Muy claro. Las variables stepLeft / stepRight circulan de 0-3. Al hacer algunas matemáticas simples, changeLeft / changeRight mantiene los respectivos cambios relativos por paso, que se agregarán a leftDoor / rightDoor. Muchas declaraciones if para atrapar cuando la puerta tiene que detenerse por sí sola.

Siéntase libre de ayudarme a acortar esto, creo que hay mucho que hacer.

— Frozn
fuente
1

Haskell (lambdabot) - 409 bytes

p=(cycle[0,1,0,-1],0)
t(d:q,s)=(if d/=0&&(s+d<1||3<s+d)then q else d:q,s+d)
k i(a,b)=[o i,": (L:",j a,", ","R:",j b,")"]>>=id
j(d:_,s)=o(round$(fromIntegral s/4)*100)++"% "++words"closing stopped opening"!!(d+1)
s=scanl$ \(a,b)i->i(t a,t b)
main=do b<-(fmap(round.(*(2::Float))).take 60<$>randoms)<$>getStdGen;putStrLn.unlines$(o=<<b):(zipWith k b.w.s(p,p)$([id,f$f w,second$f w]!!)<$>b)
o=show;f=first;w=tail
— Alondra
fuente
Agregue todo lo necesario imports, por ejemplo, randomsa su código (y número de bytes). Si hay un intérprete que importa por defecto, consúltelo en el nombre del idioma.
— nimi
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.