Robô em uma escada

30

fundo

Eu tenho uma escada encostada na parede e um robô com controle remoto que pode subir nela. Posso enviar três comandos diferentes para o robô:

  • UP: o robô dá um passo para cima. Se estava no degrau mais alto, tropeça, cai e explode.
  • DOWN: o robô dá um passo para baixo. Se estava no passo mais baixo, nada acontece.
  • RESET: o robô retorna ao passo mais baixo.

Também posso enviar uma série de comandos, e o robô os executará um por um. Sua tarefa é prever seus movimentos.

Entrada

Suas entradas são um inteiro positivo N, representando o número de passos na escada, e uma string não-vazia Csobre UDR, representando os comandos que enviei para o robô. Você pode assumir isso N < 1000. O robô é inicializado no degrau mais baixo da escada.

Saída

É garantido que, em algum momento, o robô suba o degrau mais alto e exploda. Sua saída é o número de comandos que ele executa antes que isso aconteça.

Exemplo

Considere as entradas N = 4e C = "UDDUURUUUUUUUDDDD" O robô, indicado por @, se move ao longo da escada de 4 etapas, da seguinte maneira:

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

Os comandos restantes não são executados, pois o robô explodiu. A explosão ocorreu após 10 comandos, portanto a saída correta é 10.

Regras e pontuação

Você pode escrever um programa completo ou uma função. A menor contagem de bytes vence e as brechas padrão não são permitidas.

Casos de teste

  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
fonte
1
Relacionado
Peter Taylor
8
Estou decepcionado que a tarefa não seja gerar essa arte ASCII.
user253751
6
@immibis Você sabe o que fazer ...
Martin Ender
Em vez de uma string, podemos pegar uma lista de códigos de caracteres?
Cyoce 03/03
@Cyoce Somente se o seu idioma não tiver outros meios para representar uma string.
Zgarb 03/03

Respostas:

10

CJam, 26 25 22 bytes

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

O formato de entrada é as instruções na primeira linha e a altura da escada na segunda.

Teste aqui.

Explicação

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
fonte
Boa idéia para processar todos os comandos, mesmo após a explosão. Vou pedir que, para salvar alguns bytes
Luis Mendo
7

C, 83 71 + 4 = 75 bytes

Obrigado @ Jos por me mostrar o estilo K&S , que permitiu 8 bytes de desconto !!

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

Chamada de exemplo:

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

Teste ao vivo em ideone

removido
fonte
1
Boa resposta, mas pode valer a pena notar que a função só pode ser usada efetivamente uma vez desde os globais ze anão é redefinida.
Josh
@ Josh. Eu atualizei. :)
removido
1
Impressionante! Você também pode salvar alguns caracteres, brincando com as declarações de tipo em sua função: codegolf.stackexchange.com/a/40266/13877 #
Josh
@ Josh. Uau, isso é incrível! obrigado
removido
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)

Explicação

Usa uma função 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>

user81655
fonte
4

Perl, 47 + 2 = 49 bytes

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

Requer a -pbandeira, -i$Npara a última altura e uma lista de movimentos separados por nova linha:

$ 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

Como 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.

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
andlrc
fonte
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

Como funciona

Primeiro, definimos a variável icomo 0. Isso acompanhará quantos passos o robô subiu. Em seguida, para cada caractere cna sequência de entrada, executamos a seguinte lógica:

  1. Se ifor maior ou igual a n, não faça nada.
  2. Se cfor "D":
    • Se ifor 0, deixe como está.
    • Caso contrário, diminua-o em 1.
  3. Se cestiver "U", incremente iem 1.
  4. Caso contrário, defina icomo 0.

Ao cortar se i>=n, evitamos adicionar mais itens à matriz após o robô chegar ao topo. Assim, podemos simplesmente retornar o comprimento da matriz resultante.

ETHproductions
fonte
3

Haskell, 65 bytes

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

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

%ajusta a posição atual na escada, scanlfaz uma lista de todas as posições, fst.span(<n)toma a peça antes da explosão e lengthconta as etapas.

nimi
fonte
Bom trabalho com a combinação de argumentos nomeados e composição / currying
Cyoce 3/16
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
fonte
1
Vamos continuar esta discussão no chat .
ETHproductions
Eu acho que 0,i=0pode ser alterado parai=0
Cyoce 03/03
@Cyoce hmm, não para mim em uma nova aba (obras nesta página b / ci já está definido)
Charlie Wynn
@CharlieWynn desculpe, tenho o meu precedência misturado
Cyoce
3

MATL , 37 34 bytes

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

Experimente online!

Explicação

A posição é baseada em 0. Cada nova posição é empurrada para a pilha, mantendo as posições mais antigas. Portanto, o tamanho da pilha representa o número de movimentos até agora, mais 1.

Um loop é usado para processar cada comando. O loop é encerrado quando a posição atinge a altura da escada processa todos os comandos, mesmo após a explosão (ideia retirada da resposta de Martin ). O resultado final é dado pelo índice da primeira posição que é igual à altura da escada.

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
fonte
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 exemplo, f(4, 'UDDUURUUUUUUUDDDD')é 10.

xnor encontrou uma expressão ainda mais curta: 2%~hé muito legal :)

Lynn
fonte
Bom encontrar com o %4. Se não me engano, você pode salvar um personagem fazendo -[2%~h,~h,0][ord(s[0])%4].
Xnor 02/03
3

PowerShell, 86 79 bytes

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

Uma ligeira reformulação do meu Quando o Papai Noel entra no porão? responda.

Pega entrada $ae $b, lança explicitamente $bcomo char-array. Em seguida, fazemos um loop com |%{...}sobre tudo $b. Cada iteração incrementamos nosso contador $d.

Em seguida, uma ifdeclaração para verificar se chegamos ao topo -ge$a. Se sim, produzimos $de exit. A ifinstrução é construída a partir de um pseudo-ternário criado pela atribuição de $cmenos-igual ao resultado de vários índices em uma matriz.

Nós temos um truque que os valores ASCII de D, Re Ucorrespondem a 0, 2e 1quando tomado modulo-4, portanto, $_%4serve como nosso primeiro índice. Se for R, isso é $cigual a $c-$c, fazendo a redefinição. Se U, isso significa que precisamos subir, então o $c-(-1)resultado. Caso contrário, é um D, portanto, precisamos verificar se já estamos na parte inferior (que é o !$c- no PowerShell, "diferente de zero" é "verdadeiro" ou 1) e definido como $cigual $c-0ou $c-1respectivamente.

Editar - salvou 7 bytes usando a atribuição menos igual ao invés da atribuição direta

AdmBorkBork
fonte
3

Perl 5, 61 bytes

Inclui dois bytes para -F -i. ( -M5.01é grátis.)

A entrada do número inteiro (por exemplo, 10) é como perl -M5.01 -F -i10 robot.pl; A entrada dos comandos ladder é como STDIN.

for(@F){($i+=/U/)-=/R/?$i:$i&&/D/;$j++;last if$^I<=$i}say$j
msh210
fonte
usando o perl 5.12.5, eu também tive que ativar explicitamente o modo de divisão automática -anFantes que ele imprimisse qualquer coisa para mim. mas parece ter sido ativado implicitamente apenas -Fna versão 5.20.3. você pode verificar isso?
ardnew
@ardnew, -Fbastava para mim (5,20 ou 5,22 ou mais). Iirc o atual perldoc perlrun diz que implica -ae -aimplica -n.
Msh210
Quanto contamos -i? Eu posso ver que você conta isso como 1, mas acho que deveria ser contado como 3? :-)
andlrc
@ dev-null, por que três? Acho que a convenção no PPCG.SE é contar as letras em uma bandeira, mas não os caracteres hífen-menos, mas, por favor, corrija-me se estiver errado. (Parece que você está usando a mesma convenção de contagem para yoru própria resposta a esta pergunta também (Aliás, a resposta agradável)..)
msh210
@ msh210 Eu estava contando a diferença ao usar -ie sem caracteres perl -i10 -pe';'vs perl -pe';'3 a mais e, em seguida, o número de entrada - que acho que não devemos contar. Mas eu posso estar errado apenas embora sobre isso esta manhã :-)
andlrc
3

Vitsy, 44 bytes

Provavelmente pode haver algumas reduções - eu vou descobrir mais algumas coisas, se puder.

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

Explicação (em andamento):

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.

Experimente Online! (grande caso de teste)

Addison Crump
fonte
2

PHP, 88 bytes

Isso gera alguns avisos (3 + 2n onde n é o número de comandos executados), mas isso não importa para o golfe, certo?

<?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
user51805
fonte
Os avisos são bons, desde que o código ainda possa ser executado.
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
fonte
1
Bem-vindo ao PPCG! Aqui, exigimos, por padrão, que as respostas sejam programas completos que aceitem STDIN e imprimam em STDOUT, ou funções que aceitem entradas como argumentos e retornem o valor de saída. Sua solução codifica as entradas, o que não é permitido.
Zgarb 01/03
Corrigido ao formar uma função, eu estava usando o intérprete quando o escrevi.
Alex Burge
Obrigado! Você também deve adicionar um cabeçalho do formulário ## Python, <N> bytespara mostrar aos outros sua pontuação.
Zgarb 01/03
Eu não acho que pode haver uma função sem nome.
user48538
Você pode salvar bytes substituindo 0 if x==0 else x-1porx and x-1
Cyoce 3/16
2

JavaScript, 131 106 bytes

Eu sei que isso não vai ganhar uma competição do Code Golf, mas essa foi uma solução divertida e estúpida de implementar:

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

Eu meio que fui o oposto de uma rota "funcional", criando uma solução imperativa gerada dinamicamente, qualquer instância de uma instrução é substituída por um incremento ou decremento e um contra incremento.

Obrigado a Cycoce por me salvar 29 bytes!

DLeh
fonte
Aqui, eu joguei 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 03/03
2

Python 3, 90

Economizou 6 bytes graças ao DSM.

Bem simples agora.

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 teste:

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

Não vencendo, mas divertido de criar. O PHP parece não gostar de partes vazias no operador ternário (ele lança um erro de sintaxe), então eu tive que colocar um 0lá.

Versão não destruída:

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
fonte
1

PHP, 113 bytes

Versão menor do 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;
        }
    }
}
RibeiroBreno
fonte
2
Ótimo primeiro post! Eu editei sua postagem para melhor legibilidade. Feliz golfe!
GamrCorps
1

Pitão, 19 bytes

x.u@[tWNNhN00)CYz0Q

Experimente on-line: Demonstration or Test Suite

Explicação:

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
fonte
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
fonte
2
Ao responder a um desafio de código-golfe , você deve começar sua resposta # <language_name>, XX bytes. Além disso, você pode reduzir os nomes das variáveis ​​para um caractere cada e remover espaços em branco extras, dessa forma a contagem de bytes reduzirá (que é o objetivo aqui) ... Ah, e seja bem-vindo ao PPCG!
removido
Algumas dicas: para recuar seu código como código, adicione 4 espaços no início da linha. Você removeu alguns espaços, mas ainda pode remover mais (ex: em vez de int steps=1; int count=0;usar int s=1,c=0;- veja, eu mudei o nome da variável - e assim por diante). Você ainda pode mostrar o seu ungolfed versão abaixo da golfed versão com uma explicação (desta forma é fácil para alguém ajudá-lo a jogar golfe mais bytes).
removido
1

C, 91 bytes

Sem avisos com gcc -Wall. Recursão e expressões separadas por vírgula.

r.c contém a função bare:

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 referência,

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

roboladder.c embrulho,

#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 teste,

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

Função anônima, que aceita os dois argumentos (C, N). Cuidado ao usar isso, pois não fecha o fluxo que abre. Também atribui todas as suas variáveis ​​globalmente.

Editado para substituir d=#-1&com d=#~Max~1-1&, de modo que robie não vai cavar.

hYPotenuser
fonte
Espere: não acho que isso seja válido. Permite que o robô desça degraus negativos. Ops. Isso vai me ensinar a testar de forma abrangente ... Colocarei uma correção quando tiver a chance.
HYPotenuser 03/03
1

Mathematica, 112 bytes

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

Clojure, 92 84 bytes

Conta npara zero, em vez de zero para n, pode 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))))

Mapeia o segundo argumento Upara +, Dpara -e outros para nil. A função de redução é executada (operand position 1)com valores não nulos operande 0caso contrário. Toma valores até estarmos mais altos que o primeiro argumento de entrada e conta quantos temos.

NikoNyrh
fonte
0

Mathematica, 67 bytes

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

Funções sem nome de dois argumentos, um número inteiro positivo e uma lista de caracteres, que retorna um número inteiro positivo. Uma Whileimplementação mais direta do que as outras entradas do Mathematica, que conseguem resultar em uma duração mais competitiva.

Greg Martin
fonte