Fondo
Tengo una escalera apoyada en una pared y un robot a control remoto que puede subirla. Puedo enviar tres comandos diferentes al robot:
UP
: el robot da un paso hacia arriba. Si estaba en el escalón más alto, se tropieza, se cae y explota.DOWN
: el robot da un paso hacia abajo. Si estaba en el escalón más bajo, no pasa nada.RESET
: el robot vuelve al paso más bajo.
También puedo enviar una serie de comandos, y el robot los ejecutará uno por uno. Su tarea es predecir sus movimientos.
Entrada
Sus entradas son un número entero positivo N
, que representa el número de pasos en la escalera, y una cadena no vacía C
sobre UDR
, que representa a los comandos que he enviado al robot. Puedes asumir eso N < 1000
. El robot se inicializa en el escalón más bajo de la escalera.
Salida
Se garantiza que en algún momento, el robot trepará por el escalón más alto y explotará. Su salida es la cantidad de comandos que ejecuta antes de que esto suceda.
Ejemplo
Considere las entradas N = 4
y C = "UDDUURUUUUUUUDDDD"
El robot, denotado por @
, se mueve a lo largo de la escalera de 4 pasos de la siguiente manera:
|-| |-| |-| |-| |-| |-| |-| |-| |-| |@| |-||
|-| |-| |-| |-| |-| |@| |-| |-| |@| |-| |-||
|-| |@| |-| |-| |@| |-| |-| |@| |-| |-| |-|v
|@| U |-| D |@| D |@| U |-| U |-| R |@| U |-| U |-| U |-| U |-|# Boom!
Los comandos restantes no se ejecutan, ya que el robot ha explotado. La explosión tuvo lugar después de 10 comandos, por lo que la salida correcta es 10
.
Reglas y puntaje
Puede escribir un programa completo o una función. El conteo de bytes más bajo gana, y las lagunas estándar no se permiten.
Casos de prueba
1 U -> 1
1 DDRUDUU -> 4
4 UDDUUUUURUUUUDDDD -> 7
4 UDDUURUUUUUUUDDDD -> 10
6 UUUUUDRUDDDDRDUUUUUUDRUUUUUUUDR -> 20
10 UUUUUURUUUUUUURUUUUUUUURUUUUUUUUUUUUUU -> 34
6 UUUDUUUUDDDDDDDDDDDDDDRRRRRRRRRRRUUUUUU -> 8
6 UUUDUUUDURUDDDUUUUUDDRUUUUDDUUUUURRUUDDUUUUUUUU -> 32
20 UUDDUDUUUDDUUDUDUUUDUDDUUUUUDUDUUDUUUUUUDUUDUDUDUUUUUDUUUDUDUUUUUUDUDUDUDUDUUUUUUUUUDUDUUDUDUUUUU -> 56
354 UUDDUUDUDUUDDUDUUUUDDDUDUUDUDUDUDDUUUUDUDUUDUDUUUDUDUDUUDUUUDUUUUUDUUDUDUUDUDUUUUUDUDUUDUDUDUDDUUUUUUUDUDUDUDUUUUUDUDUDUDUDUDUDUDUUDUUUUUURUUUDUUUUDDUUDUDUDURURURUDUDUUUUDUUUUUUDUDUDUDUDUUUUUUDUDUUUUUUUDUUUDUUDUDUDUUDUDUDUUUUUUUUUUDUUUDUDUUDUUDUUUDUUUUUUUUUUUUUDUUDUUDUDUDUUUDUDUUUUUUUDUUUDUUUDUUDUUDDUUUUUUUUDUDUDUDUDUUUUDUDUUUUUUUUDDUUDDUUDUUDUUDUDUDUDUUUUUUUUUDUUDUUDUUUDUUDUUUUUUUUUUUDUDUDUDUUUUUUUUUUUUDUUUDUUDUDDUUDUDUDUUUUUUUUUUUUDUDUDUUDUUUDUUUUUUUDUUUUUUUUUDUDUDUDUDUUUUUUDUDUDUUDUDUDUDUUUUUUUUUUUUUUUDUDUDUDDDUUUDDDDDUUUUUUUUUUUUUUDDUDUUDUUDUDUUUUUUDUDUDUDUDUUUUDUUUUDUDUDUUUDUUDDUUUUUUUUUUUUUUUUUUDUUDUUDUUUDUDUUUUUUUUUUUDUUUDUUUUDUDUDUUUUUUUUUDUUUDUUUDUUDUUUUUUUUUUUUDDUDUDUDUUUUUUUUUUUUUUUDUUUDUUUUDUUDUUDUUUUUUUUUUUDUDUUDUUUDUUUUUUDUDUDUUDUUUUUUUUUUUUDUUUDUUDUDUDUUUUDUDUDUDUDUUUUUUUUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUUU -> 872
Respuestas:
CJam,
262522 bytesEl formato de entrada son las instrucciones en la primera línea y la altura de la escalera en la segunda.
Pruébalo aquí.
Explicación
fuente
C,
8371 + 4 = 75 bytes¡Gracias @ Josh por mostrarme el estilo K&S , que permitió 8 bytes de descuento!
Explicando:
Llamada de ejemplo:
Prueba en vivo sobre ideone
fuente
z
ya
no se reinicia.JavaScript (ES6),
5453 bytesExplicación
Utiliza una función recursiva internamente.
fuente
Perl, 47 + 2 = 49 bytes
Requiere la
-p
bandera,-i$N
para esta última altura y una lista de movimientos separada por una nueva línea:Cómo funciona:
Despachado:
fuente
JavaScript (SpiderMonkey 30+),
6564 bytesCómo funciona
Primero configuramos la variable
i
a 0. Esto hará un seguimiento de cuántos pasos ha subido el robot. Luego, para cada carácterc
en la cadena de entrada, ejecutamos la siguiente lógica:i
es mayor o igual quen
, no haga nada.c
es"D"
:i
es 0, déjalo como está.c
es así"U"
, incrementei
en 1.i
en 0.Al cortar si
i>=n
, evitamos agregar más elementos a la matriz después de que el robot haya alcanzado la cima. Por lo tanto, simplemente podemos devolver la longitud de la matriz resultante.fuente
Haskell, 65 bytes
Ejemplo de uso:
f 4 "UDDUURUUUUUUUDDDD"
->10
.%
ajusta la posición actual en la escalera,scanl
hace una lista de todas las posiciones,fst.span(<n)
toma parte antes de la explosión ylength
cuenta los pasos.fuente
JavaScript (ES6), 65 bytes
fuente
0,i=0
se puede cambiar ai=0
MATL ,
3734 bytesPruébalo en línea!
Explicación
La posición está basada en 0. Cada nueva posición se empuja a la pila manteniendo las posiciones más antiguas. Entonces, el tamaño de la pila representa el número de movimientos hasta ahora, más 1.
Se usa un bucle para procesar cada comando. El ciclo
se cierra cuando la posición alcanza la altura de la escalera yprocesa todos los comandos, incluso después de la explosión (idea tomada de la respuesta de Martin ). El resultado final viene dado por el índice de la primera posición que iguala la altura de la escalera.fuente
Python 2,
6362 bytesPor ejemplo,
f(4, 'UDDUURUUUUUUUDDDD')
es10
.xnor encontró una expresión aún más corta:
2%~h
es realmente genial :)fuente
%4
. Si no me equivoco, puedes salvar a un personaje haciendo-[2%~h,~h,0][ord(s[0])%4]
.PowerShell,
8679 bytesUna ligera actualización de mi ¿ Cuándo entra Santa en el sótano? responder.
Toma entrada
$a
y$b
, explícitamente, convierte$b
como char-array. Luego hacemos un bucle con|%{...}
todo$b
. Cada iteración incrementamos nuestro contador$d
.Luego, una
if
declaración para verificar si hemos llegado a la cima con-ge$a
. Si es así, sacamos$d
yexit
. Laif
declaración se construye a partir de un pseudoternario creado mediante la asignación de$c
menos igual al resultado de varios índices en una matriz.Tenemos un truco que los valores ASCII de
D
,R
yU
corresponden a0
,2
y1
cuando se toma en módulo 4, por lo que$_%4
sirve como nuestro primer índice. Si es asíR
, eso$c
equivale a$c-$c
hacer el reinicio. SiU
, eso significa que tenemos que subir, entonces el$c-(-1)
resultado. De lo contrario es unD
, por lo que debemos verificar si ya estamos en la parte inferior (ese es el!$c
- en PowerShell, "no cero" es "verdadero" o1
) y establecer$c
igual$c-0
o$c-1
respectivamente.Editar: se guardaron 7 bytes mediante la asignación de menos igual en lugar de la asignación directa
fuente
Perl 5, 61 bytes
Incluye dos bytes para
-F -i
. (-M5.01
es gratis)La entrada del entero (por ejemplo, 10) es como
perl -M5.01 -F -i10 robot.pl
; La entrada de los comandos de escalera es como STDIN.fuente
-anF
antes de que imprimiera algo para mí. pero parece que se habilita implícitamente solo-F
en 5.20.3. puedes verificar esto?-F
suficiente para mí (5.20 o 5.22 más o menos). Iirc el actual perldoc perlrun dice que implica-a
e-a
implica-n
.-i
? Puedo ver que lo cuentas como 1, pero supongo que en realidad debería contarse como 3. :-)-i
y sinperl -i10 -pe';'
vsperl -pe';'
3 caracteres más y luego el número de entrada, que supongo que no deberíamos contar. Pero podría estar equivocado al respecto esta mañana :-)Vitsy, 44 bytes
Probablemente podría haber algunas reducciones. Descubriré algunas cosas más si puedo.
Explicación (en progreso):
¡Pruébelo en línea! (gran caso de prueba)
fuente
PHP, 88 bytes
Esto genera algunos avisos (3 + 2n donde n es el número de comandos ejecutados) pero eso no importa para jugar al golf, ¿verdad?
sin golf:
fuente
Python, 121 bytes
fuente
## Python, <N> bytes
para mostrar a otros su puntaje.0 if x==0 else x-1
conx and x-1
JavaScript,
131106 Bytes-Sé que esto no ganará una competencia de Code Golf, pero esta fue una solución divertida y estúpida para implementar:
Algo opuesto a una ruta "funcional" al hacer una solución imperativa generada dinámicamente, cualquier instancia de una instrucción se reemplaza con un incremento o decremento, y un incremento de contador.
¡Gracias a Cycoce por salvarme 29 bytes!
fuente
l=>s=>Function('i=c=0;'+s.replace(/./g,x=>`c++;i${{R:"=0",U:`++;if(i>=${l})return c`,D:"--"}[x]};`))()
Pitón 3, 90
Guardado 6 bytes gracias a DSM.
Bastante simple en este momento.
Casos de prueba:
fuente
PHP, 129 bytes
No es ganador, pero es divertido de crear. Parece que a PHP no le gustan las partes vacías en el operador ternario (arroja un error de sintaxis), así que tuve que poner un
0
allí.Versión sin golf:
fuente
PHP, 113 bytes
Versión más pequeña de https://codegolf.stackexchange.com/a/74575/13216
Sin golf:
fuente
Pyth, 19 bytes
Pruébelo en línea: demostración o pruebas
Explicación:
fuente
Java, 250 bytes
fuente
# <language_name>, XX bytes
. También puede reducir sus nombres de variables a un carácter cada uno y eliminar espacios en blanco adicionales, de esta manera su conteo de bytes se reducirá (que es el objetivo aquí) ... ¡Ah, y bienvenido a PPCG!int steps=1; int count=0;
usarint s=1,c=0;
, mire, cambié el nombre de la variable , etc.). Todavía puede mostrar su versión no golfizada debajo de la versión golfizada con una explicación (de esta manera es fácil para alguien ayudarlo a jugar más bytes).C, 91 bytes
No hay advertencias con
gcc -Wall
. Recursión y expresiones separadas por comas.r.c
contiene función desnuda:Comentado
Para referencia,
roboladder.c
envoltura,Makefile
para las pruebas,fuente
Mathematica
114120 bytesFunción anónima, que toma los dos argumentos (C, N). Tenga cuidado al usar esto, ya que no cierra la secuencia que abre. También asigna todas sus variables a nivel mundial.
Editado para reemplazar
d=#-1&
cond=#~Max~1-1&
, para que Robie no vaya a cavar.fuente
Mathematica, 112 Bytes
fuente
Clojure,
9284 bytesCuenta
n
a cero en lugar de cero an
, puede utilizartake-while pos?
.Original:
Asigna el segundo argumento
U
a+
,D
ay-
otrosnil
. La función de reducción se ejecuta(operand position 1)
con no nulooperand
y de0
otro modo. Toma valores hasta que somos más altos que el primer argumento de entrada y cuenta cuántos tenemos.fuente
Mathematica, 67 bytes
Funciones sin nombre de dos argumentos, un entero positivo y una lista de caracteres, que devuelve un entero positivo. Una
While
implementación más sencilla que las otras entradas de Mathematica, que logra dar como resultado una duración más competitiva.fuente