Robot en una escalera

30

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 Csobre 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 = 4y 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
Zgarb
fuente
1
Relacionado
Peter Taylor
8
Estoy decepcionado de que la tarea no sea generar ese arte ASCII.
user253751
66
@immibis Sabes qué hacer ...
Martin Ender
En lugar de una cadena, ¿podemos tomar una lista de códigos de caracteres?
Cyoce
@Cyoce Solo si su idioma no tiene otros medios para representar una cadena.
Zgarb

Respuestas:

10

CJam, 26 25 22 bytes

0l{i"()~ "=~0e>_}%ri#)

El 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

0         e# Push a 0 - the initial position of the robot.
l         e# Read the instructions.
{         e# Map this block over the instruction...
  i       e#   Convert to character code. D -> 68, U -> 85, R -> 82.
  "()~ "= e#   We use these as cyclic indices into this array. Note that the values
          e#   modulo 4 are 0, 1 and 2, respectively. So U -> ) (increment),
          e#   D -> ( (decrement), R -> ~ (bitwise NOT, i.e negated and decrement).
  ~       e#   Evaluate the character as code.
  0e>     e#   Clamp to non-negative numbers. So D can't go below 0, and since R is
          e#   guaranteed to yield something negative, this resets it to zero.
  _       e#   Duplicate, so we keep one copy of the current position on the stack.
}%        e# Since this was a map, the result will be wrapped in an array.
ri        e# Read the ladder height and convert it to an integer.
#         e# Find its first occurrence in the list of positions.
)         e# The result is off by one, so we increment it.
Martin Ender
fuente
Buena idea procesar todos los comandos incluso después de la explosión. Lo tomaré prestado para ahorrar algunos bytes
Luis Mendo
7

C, 83 71 + 4 = 75 bytes

¡Gracias @ Josh por mostrarme el estilo K&S , que permitió 8 bytes de descuento!

f(i,s,z,a)char*s;{z-=*s<82?z>0:*s>82?-1:z;return z-i?f(i,s+1,z,a+1):a;}

Explicando:

f(i,s,z,a)char*s;{ // function needs one integer and one "string"
  z-=              // z is the bot's height
    *s<82?         // if 'Down'
      z>0          // then subtract 1 when z>0 or nothing otherwise
    :*s>82?        // else if 'Up'
      -1           // increase height z-=-1
    :z;            // else reset z=z-z
  return z-i?      // if z is not the max height
    f(i,s+1,z,a+1) // try next step
  :a;              // else print how many calls/steps were made
}                  // end of function

Llamada de ejemplo:

f(1,"U",0,1);    // I've added 4 bytes in the score because of ",0,1"

Prueba en vivo sobre ideone

remoto
fuente
1
Buena respuesta, pero vale la pena señalar que la función solo puede usarse efectivamente una vez desde los globales zy ano se reinicia.
Josh
@Josh. He actualizado :)
eliminado
1
¡Increíble! También puede guardar un par de caracteres jugando con las declaraciones de tipo en su función: codegolf.stackexchange.com/a/40266/13877
Josh
@Josh. Wow esto es genial! gracias
eliminado
6

JavaScript (ES6), 54 53 bytes

n=>c=>(f=p=>n-p?f({D:p&&p-1,U:p+1}[c[i++]]|0):i)(i=0)

Explicación

Utiliza una función recursiva internamente.

var solution =

n=>c=>(
  f=p=>             // f = recursive function, p = position of robot on ladder
    n-p?            // if p != n
      f({           // execute the next command
          D:p&&p-1, // D -> p = max of p - 1 and 0
          U:p+1     // U -> p = p + 1
        }[c[i++]]   // get current command then increment i (current command index)
        |0          // R -> p = 0
      )
    :i              // else return the current command index
)(i=0)              // initialise p and i to 0 for the first recurse
N = <input type="number" id="N" value="354" /><br />
C = <input type="text" id="C" value="UUDDUUDUDUUDDUDUUUUDDDUDUUDUDUDUDDUUUUDUDUUDUDUUUDUDUDUUDUUUDUUUUUDUUDUDUUDUDUUUUUDUDUUDUDUDUDDUUUUUUUDUDUDUDUUUUUDUDUDUDUDUDUDUDUUDUUUUUURUUUDUUUUDDUUDUDUDURURURUDUDUUUUDUUUUUUDUDUDUDUDUUUUUUDUDUUUUUUUDUUUDUUDUDUDUUDUDUDUUUUUUUUUUDUUUDUDUUDUUDUUUDUUUUUUUUUUUUUDUUDUUDUDUDUUUDUDUUUUUUUDUUUDUUUDUUDUUDDUUUUUUUUDUDUDUDUDUUUUDUDUUUUUUUUDDUUDDUUDUUDUUDUDUDUDUUUUUUUUUDUUDUUDUUUDUUDUUUUUUUUUUUDUDUDUDUUUUUUUUUUUUDUUUDUUDUDDUUDUDUDUUUUUUUUUUUUDUDUDUUDUUUDUUUUUUUDUUUUUUUUUDUDUDUDUDUUUUUUDUDUDUUDUDUDUDUUUUUUUUUUUUUUUDUDUDUDDDUUUDDDDDUUUUUUUUUUUUUUDDUDUUDUUDUDUUUUUUDUDUDUDUDUUUUDUUUUDUDUDUUUDUUDDUUUUUUUUUUUUUUUUUUDUUDUUDUUUDUDUUUUUUUUUUUDUUUDUUUUDUDUDUUUUUUUUUDUUUDUUUDUUDUUUUUUUUUUUUDDUDUDUDUUUUUUUUUUUUUUUDUUUDUUUUDUUDUUDUUUUUUUUUUUDUDUUDUUUDUUUUUUDUDUDUUDUUUUUUUUUUUUDUUUDUUDUDUDUUUUDUDUDUDUDUUUUUUUUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUUU" /><br />
<button onclick="result.textContent=solution(+N.value)(C.value)">Go</button>
<pre id="result"></pre>

usuario81655
fuente
4

Perl, 47 + 2 = 49 bytes

$z-=-/U/||$z&&/D/;$z*=!/R/;$^I<=$z&&last}{$_=$.

Requiere la -pbandera, -i$Npara esta última altura y una lista de movimientos separada por una nueva línea:

$ perl -pi10 ladderbot.pl <<<< $'U\nU\nU\nU\nU\nU\nR\nU\nU\nU\nU\nU\nU\nU\nR\nU\nU\nU\nU\nU\nU\nU\nU\nR\nU\nU\nU\nU\nU\nU\nU\nU\nU\nU\nU\nU\nU\nU'
34

Cómo funciona:

                                                # '-p' wraps the code in (simplified):
                                                # while($_=<>) {...print $_}
$z-=-/U/||$z&&/D/;                              # Subtract -1 if UP. subtract 1 if DOWN
                  $z*=!/R/;                     # If R then times by zero
                           $^I<=$z&&last        # Break while loop if N is reached
                                        }{      # Eskimo operator:
                                                # while($_=<>){...}{print$_}
                                          $_=$. # `$.` contains number of lines read from input.

Despachado:

LINE: while (defined($_ = <ARGV>)) {
    $z -= -/U/ || $z && /D/;
    $z *= !/R/;
    last if $^I <= $z;
}
{
    $_ = $.;
}
continue {
    die "-p destination: $!\n" unless print $_;
}
-e syntax OK
andlrc
fuente
4

JavaScript (SpiderMonkey 30+), 65 64 bytes

(n,s,i=0)=>[for(c of s)if(i<n)c<'E'?i&&i--:c>'T'?i++:i=0].length

Cómo funciona

Primero configuramos la variable ia 0. Esto hará un seguimiento de cuántos pasos ha subido el robot. Luego, para cada carácter cen la cadena de entrada, ejecutamos la siguiente lógica:

  1. Si ies mayor o igual que n, no haga nada.
  2. Si ces "D":
    • Si ies 0, déjalo como está.
    • De lo contrario, disminuya en 1.
  3. Si ces así "U", incremente ien 1.
  4. De lo contrario, establezca ien 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.

ETHproducciones
fuente
3

Haskell, 65 bytes

x%'U'=x+1
x%'D'=max(x-1)0
x%_=0
f n=length.fst.span(<n).scanl(%)0

Ejemplo de uso: f 4 "UDDUURUUUUUUUDDDD"-> 10.

%ajusta la posición actual en la escalera, scanlhace una lista de todas las posiciones, fst.span(<n)toma parte antes de la explosión y lengthcuenta los pasos.

nimi
fuente
Buen trabajo con la combinación de argumentos con nombre y composición / curry
Cyoce
3

JavaScript (ES6), 65 bytes

(n,s)=>[...s].map(_=>i=_<'E'?i&&i-1:_>'T'?i+1:0,i=0).indexOf(n)+1
Charlie Wynn
fuente
1
Continuemos esta discusión en el chat .
ETHproductions
Creo que 0,i=0se puede cambiar ai=0
Cyoce
@Cyoce hmm, me falla en una nueva pestaña (funciona en esta página b / ci ya está definido)
Charlie Wynn
@CharlieWynn lo siento, tengo mi precedencia mezclada
Cyoce
3

MATL , 37 34 bytes

Oj"t@4\1=?Q}6M?x0}qt0>*]]]N$h=f1)q

Prué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 y procesa 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.

O             % push a 0: initial position (0-based)
j             % take first input (commands) as a string
"             % for each command
  t           %   duplicate current position
  @           %   push command
  4\          %   modulo 4. This gives 1, 2, 0 for 'U','R', 'D'
  1=?         %   if result equals 1 (command 'U')
    Q         %     increase position by 1
  }           %   else
    6M?       %     if result was nonzero (command 'R')
      x0      %       delete current position and push 0
    }         %     else (command 'D')
      q       %       decrement by 1
      t0>*    %       turn negative values into 0
    ]         %     end if
  ]           %   end if
]             % end for each
N$h           % pack all numbers in the stack into an array
=             % implicitly read second input: ladder height
f1)q          % find first position equal to that, and subtract 1.
              % Implicitly display
Luis Mendo
fuente
3

Python 2, 63 62 bytes

f=lambda n,s,h=0:h^n and-~f(n,s[1:],-[2%~h,~h,0][ord(s[0])%4])

Por ejemplo, f(4, 'UDDUURUUUUUUUDDDD')es 10.

xnor encontró una expresión aún más corta: 2%~hes realmente genial :)

Lynn
fuente
Bonito hallazgo con el %4. Si no me equivoco, puedes salvar a un personaje haciendo -[2%~h,~h,0][ord(s[0])%4].
xnor
3

PowerShell, 86 79 bytes

param($a,[char[]]$b)$b|%{$d++;if(($c-=((1,0)[!$c],-1,$c)[$_%4])-ge$a){$d;exit}}

Una ligera actualización de mi ¿ Cuándo entra Santa en el sótano? responder.

Toma entrada $ay $b, explícitamente, convierte $bcomo char-array. Luego hacemos un bucle con |%{...}todo $b. Cada iteración incrementamos nuestro contador $d.

Luego, una ifdeclaración para verificar si hemos llegado a la cima con -ge$a. Si es así, sacamos $dy exit. La ifdeclaración se construye a partir de un pseudoternario creado mediante la asignación de $cmenos igual al resultado de varios índices en una matriz.

Tenemos un truco que los valores ASCII de D, Ry Ucorresponden a 0, 2y 1cuando se toma en módulo 4, por lo que $_%4sirve como nuestro primer índice. Si es así R, eso $cequivale a $c-$chacer el reinicio. Si U, 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" o 1) y establecer $cigual $c-0o $c-1respectivamente.

Editar: se guardaron 7 bytes mediante la asignación de menos igual en lugar de la asignación directa

AdmBorkBork
fuente
3

Perl 5, 61 bytes

Incluye dos bytes para -F -i. ( -M5.01es 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.

for(@F){($i+=/U/)-=/R/?$i:$i&&/D/;$j++;last if$^I<=$i}say$j
msh210
fuente
usando perl 5.12.5, también tuve que habilitar explícitamente el modo de división automática -anFantes de que imprimiera algo para mí. pero parece que se habilita implícitamente solo -Fen 5.20.3. puedes verificar esto?
ardnew
@ardnew, solo fue -Fsuficiente para mí (5.20 o 5.22 más o menos). Iirc el actual perldoc perlrun dice que implica -ae -aimplica -n.
msh210
¿Para cuánto contamos -i? Puedo ver que lo cuentas como 1, pero supongo que en realidad debería contarse como 3. :-)
andlrc
@ dev-null, ¿por qué tres? Creo que la convención sobre PPCG.SE es contar las letras en una bandera pero no los guiones, pero corríjame si me equivoco. (Parece que también está utilizando la misma convención de conteo para su propia respuesta a esta pregunta. (Por cierto, buena respuesta))
msh210
@ msh210 Estaba contando la diferencia cuando usaba -iy sin perl -i10 -pe';'vs perl -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 :-)
andlrc
3

Vitsy, 44 bytes

Probablemente podría haber algunas reducciones. Descubriré algunas cosas más si puedo.

0vVWl:X[4M1+mDvV-);]lvXv?v-N
vD([1-]
v1+
vX0

Explicación (en progreso):

0vVWl:X[4M1+mDvV-);]lvXv?v-N
0v             Save 0 as our temp var to edit.
  V            Save the input as a global var.
   W           Grab a line of STDIN.
    l          Push the length of the stack.
     :         Clone the stack. This is for later use.
      X        Remove the top item of the stack (we don't need the length right now.
[            ] Do the stuff in the brackets infinitely.
 4M            Modulo 4.
   1+          Add one.
     m         Go to the line index as specified by the top item of the stack.
      Dv       Duplicate the top item, save it in the temp var.
        V-);   If the top value is equal to the input number, exit the loop.
l              Push the length of the stack.
 vXv           Dump the temp var, then save the top item.
    ?          Rotate back to the original stack.
     v-        Subtract the top item (the original length) by the temp var (new length)
       N       Output the top item of the stack of the number.

vD([1-]
v              Push the temp variable to the stack.
 D([  ]        If this value is not zero...
    1-         Subtract one from it.

v1+            Push the temp variable to the stack, then add one to it.

vX0            Dump the temp var and replace it with zero.

¡Pruébelo en línea! (gran caso de prueba)

Addison Crump
fuente
2

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?

<?php for(;$x++<$argv[1];)switch($argv[2][$i++]){case R;$x=2;case D;--$x?--$x:0;}echo$i;

sin golf:

<?php                    # actually 1 byte shorter not as a function
for(;$x++<$argv[1];)     # not initialising the $x causes a notice but still works
                         # post increment $x by 1 regardless of the command (saves us writing a U case)
  switch($argv[2][$i++]) # get next command, increment number of commands
    {case R;             # R gets treated as a constant with value 'R'. and a notice
      $x=2;              # falling through to D which will double decrement so set to 2
    case D;              # same trick as R
      --$x?--$x:0;}      # decrement once then again if >0
echo$i;                  # output
user51805
fuente
Los avisos están bien, siempre y cuando el código aún se pueda ejecutar.
Zgarb
2

Python, 121 bytes

def f(a,n):
 i=c=0
 while i<n:i={'U':lambda x:x+1,'D':lambda x:0 if x==0 else x-1,'R':lambda x:0}[a[c]](i);c+=1
 return c
Alex Burge
fuente
1
Bienvenido a PPCG! Aquí requerimos de manera predeterminada que las respuestas sean programas completos que reciben entradas de STDIN e imprimen en STDOUT, o funciones que toman entradas como argumentos y devuelven el valor de salida. Su solución codifica las entradas, lo que no está permitido.
Zgarb
Corregido formando una función, estaba usando un intérprete cuando lo escribí.
Alex Burge
¡Gracias! También debe agregar un encabezado del formulario ## Python, <N> bytespara mostrar a otros su puntaje.
Zgarb
No creo que pueda haber una función sin nombre.
user48538
Puede guardar bytes reemplazando 0 if x==0 else x-1conx and x-1
Cyoce
2

JavaScript, 131 106 Bytes-

Sé que esto no ganará una competencia de Code Golf, pero esta fue una solución divertida y estúpida para implementar:

l=>s=>Function('i=c=0;'+s.replace(/./g,x=>`c++;i${{R:"=0",U:`++;if(i>=${l})re‌​turn c`,D:"--"}[x]};`))()

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!

DLeh
fuente
Aquí, jugué 29 bytes:l=>s=>Function('i=c=0;'+s.replace(/./g,x=>`c++;i${{R:"=0",U:`++;if(i>=${l})return c`,D:"--"}[x]};`))()
Cyoce
2

Pitón 3, 90

Guardado 6 bytes gracias a DSM.

Bastante simple en este momento.

def f(c,n):
 f=t=0
 for x in c:
  f+=1|-(x<'E');f*=(x!='R')&(f>=0);t+=1
  if f>=n:return t

Casos de prueba:

assert f('U', 1) == 1
assert f('DDRUDUU', 1) == 4
assert f('UDDUUUUURUUUUDDDD', 4) == 7
assert f('UDDUURUUUUUUUDDDD', 4) == 10
assert f('UUDDUUDUDUUDDUDUUUUDDDUDUUDUDUDUDDUUUUDUDUUDUDUUUDUDUDUUDUUUDUUUUUDUUDUDUUDUDUUUUUDUDUUDUDUDUDDUUUUUUUDUDUDUDUUUUUDUDUDUDUDUDUDUDUUDUUUUUURUUUDUUUUDDUUDUDUDURURURUDUDUUUUDUUUUUUDUDUDUDUDUUUUUUDUDUUUUUUUDUUUDUUDUDUDUUDUDUDUUUUUUUUUUDUUUDUDUUDUUDUUUDUUUUUUUUUUUUUDUUDUUDUDUDUUUDUDUUUUUUUDUUUDUUUDUUDUUDDUUUUUUUUDUDUDUDUDUUUUDUDUUUUUUUUDDUUDDUUDUUDUUDUDUDUDUUUUUUUUUDUUDUUDUUUDUUDUUUUUUUUUUUDUDUDUDUUUUUUUUUUUUDUUUDUUDUDDUUDUDUDUUUUUUUUUUUUDUDUDUUDUUUDUUUUUUUDUUUUUUUUUDUDUDUDUDUUUUUUDUDUDUUDUDUDUDUUUUUUUUUUUUUUUDUDUDUDDDUUUDDDDDUUUUUUUUUUUUUUDDUDUUDUUDUDUUUUUUDUDUDUDUDUUUUDUUUUDUDUDUUUDUUDDUUUUUUUUUUUUUUUUUUDUUDUUDUUUDUDUUUUUUUUUUUDUUUDUUUUDUDUDUUUUUUUUUDUUUDUUUDUUDUUUUUUUUUUUUDDUDUDUDUUUUUUUUUUUUUUUDUUUDUUUUDUUDUUDUUUUUUUUUUUDUDUUDUUUDUUUUUUDUDUDUUDUUUUUUUUUUUUDUUUDUUDUDUDUUUUDUDUDUDUDUUUUUUUUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUUU', 354) == 872
Morgan Thrapp
fuente
1

PHP, 129 bytes

function r($h,$s){$i=0;$c=1;while($x=$s[$i++]){if($x=='U'){$c++;}elseif($x=='D'){--$c<1?$c=1:0;}else{$c=1;}if($c>$h){return$i;}}}

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 un0 allí.

Versión sin golf:

function r($h,$s) {          // $h - height of ladder; $s - instructions
  $i = 0;                    // Instruction index
  $c = 1;                    // Position on ladder
  while ($x = $s[$i++]){     // Set $x to current instruction and increment index
    if ($x == 'U'){          // If instruction is U...
      $c++;                  // Increment ladder position
    } elseif ($x == 'D') {   // If instruction is D...
      --$c < 1 ? $c = 1 : 0; // Decrement ladder position, if under 1 set to 1
    } else {                 // If instruction is anything else (in this case R)
      $c = 1;                // Reset ladder position
    }
    if ($c > $h) {           // If ladder position is larger than height...
      return $i;             // Return current instruction index
    }
  }
}
daavko
fuente
1

PHP, 113 bytes

Versión más pequeña de https://codegolf.stackexchange.com/a/74575/13216

function r($h,$s){$i=0;$c=1;while($x=$s[$i++]){$c+=($x=='U'?1:($x=='D'?($c>1?-1:0):1-$c));if($c>$h){return $i;}}}

Sin golf:

// $h - height of ladder; $s - instructions
function r($h,$s) {
    $i = 0;
    $c = 1;
    while ($x = $s[$i++]) {
        $c += (
            $x=='U'?
                1
            :
                (
                    $x=='D'? (
                        $c>1?
                            -1
                        :
                            0
                    ):
                        1-$c
                )
        );
        if ($c > $h) {
            return $i;
        }
    }
}
RibeiroBreno
fuente
2
Gran primer post! Edité tu publicación para una mejor legibilidad. ¡Feliz golf!
GamrCorps
1

Pyth, 19 bytes

x.u@[tWNNhN00)CYz0Q

Pruébelo en línea: demostración o pruebas

Explicación:

x.u@[tWNNhN00)CYz0Q   implicit: z = input string, Q = input number
 .u             z0    reduce z: for each char Y in z manipulate N = 0 with:
    [        )           create a list with
     tWNN                  * N-1 if N>0 else N
         hN                * N+1
           0               * 0
            0              * 0
   @          CY         replace N by the ord(Y)-th element (mod 4)
 .u                   .u give us a list with all intermediate values of N
x                 Q   print the index of Q in this list
Jakube
fuente
1

Java, 250 bytes

int cmds(int n, String s) {
int steps=1;
int count=0;
for (int i=0;i< s.length();i++) {
count++;
char c=s.charAt(i);
switch(c){
case 'D':
steps=(steps==1)?1:--steps;
break;
case 'R':
steps=1;
break;
case 'U':
++steps;
break;
}
if(steps>n)
return count;
}
return 0;
}
Surya Vattikuti
fuente
2
Al responder un desafío de código de golf , debe comenzar su respuesta con # <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!
eliminado
Algunos consejos: Para sangrar su código como código, agregue 4 espacios al comienzo de la línea. Eliminó algunos espacios, pero aún puede eliminar más (por ejemplo: en lugar de int steps=1; int count=0;usar int 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).
eliminado
1

C, 91 bytes

No hay advertencias con gcc -Wall . Recursión y expresiones separadas por comas.

r.c contiene función desnuda:

int r(int N,int n,int s,char*C){return*C&&s<=N?s+=*C&2?-s:*C&1?1:-1,r(N,n+1,s?s:1,C+1):n;}

Comentado

int r(int N,   // number of steps on ladder
      int n,   // result, seed with 0
      int s,   // current step, seed with 1
      char *C  // command string
      )
{
    return *C&&s<=N ?  // still reading commands and still on ladder?
       s+=                // increment step value by...
        *C&2?             // bit test if 'R' but not 'U' or 'D'.
         -s               // negate to 0, will set to 1 in call if needed
         :*C&1?           // Not 'R', is it 'U'?
            1             // 'U', add 1
            :-1,          // Must be 'D', subtract 1
       r(N,n+1,s?s:1,C+1) // Recursive call, and fix case where s==0.
      :n;                 // end of string or fell off ladder
}

Para referencia,

'U'.charCodeAt(0).toString(2)
"1010101"
'D'.charCodeAt(0).toString(2)
"1000100"
'R'.charCodeAt(0).toString(2)
"1010010"

roboladder.c envoltura,

#include <stdio.h>
#include <stdlib.h>
#include "r.c"
int main(int argc, char * argv[])
{
  int N = atoi(argv[1]);
  int n = r(N,0,1,argv[2]);
  int check = atoi(argv[3]);
  printf("%d : %d\n", n, check);
  return 0;
}

Makefile para las pruebas,

run:
    @gcc -Wall robotladder.c -o robotladder 
    @./robotladder 1 U 1
    @./robotladder 1 DDRUDUU 4  
    @./robotladder 4 UDDUUUUURUUUUDDDD 7
    @./robotladder 4 UDDUURUUUUUUUDDDD 10
    @./robotladder 6 UUUUUDRUDDDDRDUUUUUUDRUUUUUUUDR 20
    @./robotladder 10 UUUUUURUUUUUUURUUUUUUUURUUUUUUUUUUUUUU 34
    @./robotladder 6 UUUDUUUUDDDDDDDDDDDDDDRRRRRRRRRRRUUUUUU 8
    @./robotladder 6 UUUDUUUDURUDDDUUUUUDDRUUUUDDUUUUURRUUDDUUUUUUUU 32
    @./robotladder 20 UUDDUDUUUDDUUDUDUUUDUDDUUUUUDUDUUDUUUUUUDUUDUDUDUUUUUDUUUDUDUUUUUUDUDUDUDUDUUUUUUUUUDUDUUDUDUUUUU 56
    @./robotladder 354 UUDDUUDUDUUDDUDUUUUDDDUDUUDUDUDUDDUUUUDUDUUDUDUUUDUDUDUUDUUUDUUUUUDUUDUDUUDUDUUUUUDUDUUDUDUDUDDUUUUUUUDUDUDUDUUUUUDUDUDUDUDUDUDUDUUDUUUUUURUUUDUUUUDDUUDUDUDURURURUDUDUUUUDUUUUUUDUDUDUDUDUUUUUUDUDUUUUUUUDUUUDUUDUDUDUUDUDUDUUUUUUUUUUDUUUDUDUUDUUDUUUDUUUUUUUUUUUUUDUUDUUDUDUDUUUDUDUUUUUUUDUUUDUUUDUUDUUDDUUUUUUUUDUDUDUDUDUUUUDUDUUUUUUUUDDUUDDUUDUUDUUDUDUDUDUUUUUUUUUDUUDUUDUUUDUUDUUUUUUUUUUUDUDUDUDUUUUUUUUUUUUDUUUDUUDUDDUUDUDUDUUUUUUUUUUUUDUDUDUUDUUUDUUUUUUUDUUUUUUUUUDUDUDUDUDUUUUUUDUDUDUUDUDUDUDUUUUUUUUUUUUUUUDUDUDUDDDUUUDDDDDUUUUUUUUUUUUUUDDUDUUDUUDUDUUUUUUDUDUDUDUDUUUUDUUUUDUDUDUUUDUUDDUUUUUUUUUUUUUUUUUUDUUDUUDUUUDUDUUUUUUUUUUUDUUUDUUUUDUDUDUUUUUUUUUDUUUDUUUDUUDUUUUUUUUUUUUDDUDUDUDUUUUUUUUUUUUUUUDUUUDUUUUDUUDUUDUUUUUUUUUUUDUDUUDUUUDUUUUUUDUDUDUUDUUUUUUUUUUUUDUUUDUUDUDUDUUUUDUDUDUDUDUUUUUUUUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUUU 872
    @wc -c r.c
jamieguinan
fuente
1

Mathematica 114 120 bytes

(d=#~Max~1-1&;u=#+1&;r=1&;s=StringToStream@ToLowerCase@#;l=1;t=1;While[(l=ToExpression[s~Read~Character]@l)<=#2,t++];t)&

Funció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&con d=#~Max~1-1&, para que Robie no vaya a cavar.

hYPotenuser
fuente
Espera: no creo que esto sea válido. Permite al robot bajar peldaños negativos. Whoops Eso me enseñará a probar de manera no exhaustiva ... Pondré uno corregido cuando tenga la oportunidad.
hYPotenuser
1

Mathematica, 112 Bytes

i=0;First@Position[ToExpression["{"<>#~StringReplace~{"U"->"i++,","D"->"i=i~Max~1-1,","R"->"i=0,"}<>"0}"],#2-1]&
Un simmons
fuente
0

Clojure, 92 84 bytes

Cuenta na cero en lugar de cero a n, puede utilizar take-while pos?.

#(count(take-while pos?(reductions(fn[p o](if o(min(o p 1)%)%))%(map{\U -\D +}%2))))

Original:

#(count(take-while(partial > %)(reductions(fn[p o](if o(max(o p 1)0)0))0(map{\U +\D -}%2))))

Asigna el segundo argumento Ua +, Day -otros nil. La función de reducción se ejecuta (operand position 1)con no nulo operandy de 0otro modo. Toma valores hasta que somos más altos que el primer argumento de entrada y cuenta cuántos tenemos.

NikoNyrh
fuente
0

Mathematica, 67 bytes

(p=i=0;While[p<#,p=Switch[#2[[++i]],"U",p+1,"D",1~Max~p-1,_,0]];i)&

Funciones sin nombre de dos argumentos, un entero positivo y una lista de caracteres, que devuelve un entero positivo. Una Whileimplementación más sencilla que las otras entradas de Mathematica, que logra dar como resultado una duración más competitiva.

Greg Martin
fuente