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 C
sobre 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 = 4
e 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
Respostas:
CJam,
262522 bytesO formato de entrada é as instruções na primeira linha e a altura da escada na segunda.
Teste aqui.
Explicação
fonte
C,
8371 + 4 = 75 bytesObrigado @ Jos por me mostrar o estilo K&S , que permitiu 8 bytes de desconto !!
Explicando:
Chamada de exemplo:
Teste ao vivo em ideone
fonte
z
ea
não é redefinida.JavaScript (ES6),
5453 bytesExplicação
Usa uma função recursiva internamente.
fonte
Perl, 47 + 2 = 49 bytes
Requer a
-p
bandeira,-i$N
para a última altura e uma lista de movimentos separados por nova linha:Como funciona:
Deparsed:
fonte
JavaScript (SpiderMonkey 30+),
6564 bytesComo funciona
Primeiro, definimos a variável
i
como 0. Isso acompanhará quantos passos o robô subiu. Em seguida, para cada caracterec
na sequência de entrada, executamos a seguinte lógica:i
for maior ou igual an
, não faça nada.c
for"D"
:i
for 0, deixe como está.c
estiver"U"
, incrementei
em 1.i
como 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.fonte
Haskell, 65 bytes
Exemplo de uso:
f 4 "UDDUURUUUUUUUDDDD"
->10
.%
ajusta a posição atual na escada,scanl
faz uma lista de todas as posições,fst.span(<n)
toma a peça antes da explosão elength
conta as etapas.fonte
JavaScript (ES6), 65 bytes
fonte
0,i=0
pode ser alterado parai=0
MATL ,
3734 bytesExperimente 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 escadaprocessa 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.fonte
Python 2,
6362 bytesPor exemplo,
f(4, 'UDDUURUUUUUUUDDDD')
é10
.xnor encontrou uma expressão ainda mais curta:
2%~h
é muito legal :)fonte
%4
. Se não me engano, você pode salvar um personagem fazendo-[2%~h,~h,0][ord(s[0])%4]
.PowerShell,
8679 bytesUma ligeira reformulação do meu Quando o Papai Noel entra no porão? responda.
Pega entrada
$a
e$b
, lança explicitamente$b
como char-array. Em seguida, fazemos um loop com|%{...}
sobre tudo$b
. Cada iteração incrementamos nosso contador$d
.Em seguida, uma
if
declaração para verificar se chegamos ao topo-ge$a
. Se sim, produzimos$d
eexit
. Aif
instrução é construída a partir de um pseudo-ternário criado pela atribuição de$c
menos-igual ao resultado de vários índices em uma matriz.Nós temos um truque que os valores ASCII de
D
,R
eU
correspondem a0
,2
e1
quando tomado modulo-4, portanto,$_%4
serve como nosso primeiro índice. Se forR
, isso é$c
igual a$c-$c
, fazendo a redefinição. SeU
, isso significa que precisamos subir, então o$c-(-1)
resultado. Caso contrário, é umD
, portanto, precisamos verificar se já estamos na parte inferior (que é o!$c
- no PowerShell, "diferente de zero" é "verdadeiro" ou1
) e definido como$c
igual$c-0
ou$c-1
respectivamente.Editar - salvou 7 bytes usando a atribuição menos igual ao invés da atribuição direta
fonte
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.fonte
-anF
antes que ele imprimisse qualquer coisa para mim. mas parece ter sido ativado implicitamente apenas-F
na versão 5.20.3. você pode verificar isso?-F
bastava para mim (5,20 ou 5,22 ou mais). Iirc o atual perldoc perlrun diz que implica-a
e-a
implica-n
.-i
? Eu posso ver que você conta isso como 1, mas acho que deveria ser contado como 3? :-)-i
e sem caracteresperl -i10 -pe';'
vsperl -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ã :-)Vitsy, 44 bytes
Provavelmente pode haver algumas reduções - eu vou descobrir mais algumas coisas, se puder.
Explicação (em andamento):
Experimente Online! (grande caso de teste)
fonte
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?
ungolfed:
fonte
Python, 121 bytes
fonte
## Python, <N> bytes
para mostrar aos outros sua pontuação.0 if x==0 else x-1
porx and x-1
JavaScript,
131106 bytesEu 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:
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!
fonte
l=>s=>Function('i=c=0;'+s.replace(/./g,x=>`c++;i${{R:"=0",U:`++;if(i>=${l})return c`,D:"--"}[x]};`))()
Python 3, 90
Economizou 6 bytes graças ao DSM.
Bem simples agora.
Casos de teste:
fonte
PHP, 129 bytes
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
0
lá.Versão não destruída:
fonte
PHP, 113 bytes
Versão menor do https://codegolf.stackexchange.com/a/74575/13216
Ungolfed:
fonte
Pitão, 19 bytes
Experimente on-line: Demonstration or Test Suite
Explicação:
fonte
Java, 250 bytes
fonte
# <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!int steps=1; int count=0;
usarint 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).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:Comentado,
Para referência,
roboladder.c
embrulho,Makefile
para teste,fonte
Mathematica,
114120 bytesFunçã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&
comd=#~Max~1-1&
, de modo que robie não vai cavar.fonte
Mathematica, 112 bytes
fonte
Clojure,
9284 bytesConta
n
para zero, em vez de zero paran
, pode utilizartake-while pos?
.Original:
Mapeia o segundo argumento
U
para+
,D
para-
e outros paranil
. A função de redução é executada(operand position 1)
com valores não nulosoperand
e0
caso contrário. Toma valores até estarmos mais altos que o primeiro argumento de entrada e conta quantos temos.fonte
Mathematica, 67 bytes
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
While
implementação mais direta do que as outras entradas do Mathematica, que conseguem resultar em uma duração mais competitiva.fonte