Задний план

У меня есть лестница, опирающаяся на стену, и робот с дистанционным управлением, который может взобраться на нее. Я могу отправить роботу три разные команды:

• UP: робот делает один шаг вверх. Если он был на самой высокой ступени, он спотыкается, падает и взрывается.
• DOWN: робот делает один шаг вниз. Если бы это было на самой низкой ступени, ничего не происходит.
• RESET: робот возвращается к нижней ступени.

Я также могу отправить серию команд, и робот выполнит их одну за другой. Ваша задача - предсказать его движение.

вход

Ваши входные данные представляют собой положительное целое число N, представляющее количество шагов в лестнице, и непустую строку Cповерх UDR, представляющую команды, которые я отправил роботу. Вы можете предположить это N < 1000. Робот инициализируется на самой низкой ступеньке лестницы.

Выход

Гарантируется, что в какой-то момент робот перелезет через самую высокую ступеньку и взорвется. Ваш вывод - это количество команд, которые он выполняет до того, как это произойдет.

пример

Рассмотрим входные данные, N = 4и C = "UDDUURUUUUUUUDDDD" робот, обозначенный как @, движется по 4-х ступенчатой ​​лестнице следующим образом:

|-|   |-|   |-|   |-|   |-|   |-|   |-|   |-|   |-|   |@|   |-||
|-|   |-|   |-|   |-|   |-|   |@|   |-|   |-|   |@|   |-|   |-||
|-|   |@|   |-|   |-|   |@|   |-|   |-|   |@|   |-|   |-|   |-|v
|@| U |-| D |@| D |@| U |-| U |-| R |@| U |-| U |-| U |-| U |-|# Boom!

Остальные команды не выполняются, так как робот взорвался. Взрыв произошел после 10 команд, поэтому правильный вывод есть 10.

Правила и оценки

Вы можете написать полную программу или функцию. Побеждает меньшее количество байтов, и стандартные лазейки запрещены.

Контрольные примеры

  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

CJam, 26 25 22 байта

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

Формат ввода - это инструкции в первой строке и высота лестницы во второй.

Проверьте это здесь.

объяснение

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.

C 83 71 + 4 = 75 байт

Спасибо @Josh за то, что показал мне стиль K & S , который позволил отключить 8 байтов !!

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

Разъяснение:

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

Пример вызова:

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

Живой тест на ideone

JavaScript (ES6), 54 53 байта

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

объяснение

Использует рекурсивную функцию внутри.

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>

Perl, 47 + 2 = 49 байт

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

Требуется -pфлаг -i$Nдля последней высоты и разделенный новой строкой список ходов:

$ 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

Как это работает:

                                                # '-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.

Deparsed:

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

JavaScript (SpiderMonkey 30+), 65 64 байта

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

Как это работает

Сначала мы устанавливаем переменную iравной 0. Это будет отслеживать, сколько шагов поднялся робот. Затем для каждого символа cво входной строке мы запускаем следующую логику:

1. Если iбольше или равно n, не делайте ничего.
2. Если cесть "D":
   • Если i0, оставьте все как есть.
   • В противном случае уменьшите его на 1.
3. Если cесть "U", увеличить iна 1.
4. В противном случае установите iна 0.

Отрезая if i>=n, мы не добавляем больше элементов в массив после того, как робот достигнет вершины. Таким образом, мы можем просто вернуть длину полученного массива.

Haskell, 65 байт

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

Пример использования: f 4 "UDDUURUUUUUUUDDDD"-> 10.

%корректирует текущую позицию на лестнице, scanlсоставляет список всех позиций, fst.span(<n)принимает участие до взрыва и lengthподсчитывает шаги.

JavaScript (ES6), 65 байт

(n,s)=>[...s].map(_=>i=_<'E'?i&&i-1:_>'T'?i+1:0,i=0).indexOf(n)+1

MATL , 37 34 байта

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

Попробуйте онлайн!

объяснение

Позиция на основе 0. Каждая новая позиция помещается в стек, сохраняя старые позиции. Таким образом, размер стека представляет количество движений до настоящего времени плюс 1.

Цикл используется для обработки каждой команды. Цикл прекращается, когда позиция достигает высоты лестницы обрабатывает все команды, даже после взрыва (идея взята из ответа Мартина ). Окончательный результат определяется индексом первой позиции, которая равна высоте лестницы.

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

Python 2, 63 62 байта

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

Например, f(4, 'UDDUURUUUUUUUDDDD') есть 10.

xnor нашел еще более короткое выражение: 2%~hэто действительно круто :)

PowerShell, 86 79 байт

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

Небольшое переоснащение моего Когда Санта входит в подвал? ответ.

Принимает ввод $aи $b, явно приведя $bкак char-массив. Затем мы |%{...}перебираем все $b. Каждую итерацию мы увеличиваем наш счетчик $d.

Затем ifзаявление, чтобы проверить, попали ли мы в топ -ge$a. Если это так, мы выводим $dи exit. Оператор ifпостроен из псевдо-троичного, созданного путем присвоения $cминус-равно результату нескольких индексов в массиве.

У нас есть трюк , что значения ASCII из D, Rи Uсоответствуют 0, 2и 1когда берутся по модулю-4, так что $_%4служат в качестве нашего первого индекса. Если это так R, то устанавливается $cравным $c-$c, делая сброс. Если Uэто означает, что нам нужно идти вверх, значит, $c-(-1)результат. В противном случае это a D, поэтому нам нужно проверить, не находимся ли мы уже внизу (это !$c- в PowerShell, «not-zero» равно «true» или 1) и установить $cравным $c-0или$c-1 соответственно.

_{Редактировать - Сохранение 7 байтов с использованием минус-равного назначения, а не прямого назначения}

Perl 5, 61 байт

Включает два байта для -F -i. ( -M5.01бесплатно.)

Ввод целого числа (например, 10) как perl -M5.01 -F -i10 robot.pl; ввод лестничных команд как STDIN.

for(@F){($i+=/U/)-=/R/?$i:$i&&/D/;$j++;last if$^I<=$i}say$j

Витси, 44 байта

Вероятно, могут быть некоторые сокращения - я придумаю еще кое-что, если смогу.

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

Объяснение (в процессе):

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.

Попробуйте онлайн! (большой тестовый кейс)

PHP, 88 байт

Это генерирует некоторые (3 + 2n, где n - количество выполненных команд) уведомлений, но это не имеет значения для игры в гольф, верно?

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

ungolfed:

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

Python, 121 байт

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

JavaScript, 131 106 байт-

Я знаю, что это не выиграет соревнование Code Golf, но это было забавное и глупое решение для реализации:

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

Я как бы пошел вразрез с «функциональным» маршрутом, приняв динамически сгенерированное императивное решение, любой экземпляр инструкции заменяется на приращение или уменьшение, а счетчик увеличивается.

Спасибо Cycoce за то, что сэкономил мне 29 байт!

Python 3, 90

Сохранено 6 байт благодаря DSM.

Довольно просто прямо сейчас.

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

Тестовые случаи:

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

PHP, 129 байт

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

Не победа, а создание удовольствия. PHP, похоже, не любит пустые части в троичном операторе (он выдает синтаксическую ошибку), поэтому мне пришлось добавить 0туда.

Безголовая версия:

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

PHP, 113 байт

Меньшая версия 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;}}}

Ungolfed:

// $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;
        }
    }
}

Pyth, 19 байт

x.u@[tWNNhN00)CYz0Q

Попробуйте онлайн: демонстрация или тестовый набор

Объяснение:

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

Java, 250 байт

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

C, 91 байт

Нет предупреждений с gcc -Wall. Рекурсия и разделенные запятыми выражения.

r.c содержит голую функцию:

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

комментарии,

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
}

Для справки,

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

roboladder.c обертка,

#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 для тестирования,

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

Mathematica, 114 120 байтов

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

Анонимная функция, которая принимает два аргумента (C, N). Осторожно используйте это, так как он не закрывает открываемый поток. Также он назначает все свои переменные глобально.

Отредактировано для замены d=#-1&на d=#~Max~1-1&, чтобы Роби не копал.

Mathematica, 112 байт

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

Clojure, 92 84 байта

Считает nдо нуля вместо нуля n, может использовать take-while pos?.

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

Оригинал:

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

Сопоставляет 2-й аргумент Uс +, Dс -и другими с nil. Редукционная функция запускается (operand position 1)с ненулевым operandи 0иным образом. Принимает значения до тех пор, пока мы не превысим 1-й входной аргумент, и посчитает, сколько у нас есть.

Mathematica, 67 байт

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

Безымянные функции двух аргументов, положительного целого числа и списка символов, которые возвращают положительное целое число. Более простая Whileреализация, чем в других записях Mathematica, которая дает более конкурентную длину.