Vamos jogar algum jogo de tabuleiro!

11

Introdução

Os jogos de tabuleiro são um jogo clássico entre as crianças, mas há algumas que se sentem entediadas jogando um jogo de tabuleiro passo a passo. Agora eles querem que o resultado seja mostrado antes de colocar as mãos no tabuleiro.

Desafio

Suponha que este jogo de tabuleiro: >---#<---X---<X<--#-$

>   means the start of the game
-   means a position without danger
<   means the player should return one step back
X   means the player won't move next round
#   means a portal where the player returns to the start position
$   the first player to get there or after there wins the game

A entrada consiste em uma seqüência de caracteres com os aspectos do jogo de tabuleiro descritos acima e duas matrizes com alguns valores (de 1a 6) para que os dois jogadores (garoto Ae garoto B) tenham ao jogar um cubo.

Ambas as matrizes sempre terão o mesmo comprimento> = 1.

O garoto Asempre começa o jogo.

Você deve produzir a criança que chegou ao fim ou mais perto primeiro.

Se nenhum deles chegou ao fim e os dois filhos permanecerem na mesma posição impressa 0ou em qualquer outro valor falso.

Se um array acabar enquanto o outro tiver dados restantes (devido a um jogador perder vários turnos em Xs), os dados restantes devem ser usados.

Para esta tarefa, você pode criar um programa / função que leia as entradas do stdin ou utilize parâmetros / argumentos e produza / retorne / imprima o garoto vencedor.

Como se trata de , a resposta mais curta em bytes vence!

Exemplo de entrada e saída

Você também pode usar diferentes formatos de entrada, mas deve considerar apenas os valores do jogo de tabuleiro, do garoto-A e do garoto-B.

Exemplo 1:

board:  >---#<---X---<X<--#-$
kid-A:  [3,6,6,5,2,1]
kid-B:  [4,5,3,5,5,5]

output: A

Explicando:

>---#<---X---<X<--#-$     # both kids in position
B--A#<---X---<X<--#-$     # kid-A moved 3 to -
B--A#<---X---<X<--#-$     # kid-B moved 4 to # and returned home
B---#<---A---<X<--#-$     # kid-A moved 6 to X and will wait one round
B---#<---A---<X<--#-$     # kid-B moved 5 to < returned one to # and returned home
>--B#<---A---<X<--#-$     # kid-B moved 3 to -
>--B#<---X---<A<--#-$     # kid-A moved 6 to < returned one to X and will wait again
>---#<--BX---<A<--#-$     # kid-B moved 5 to -
>---#<---X--B<A<--#-$     # kid-B moved 5 to < returned one to -
>---#<---X--B<X<--#A$     # kid-A moved 5 to -
>---#<---X---<X<-B#A$     # kid-B moved 5 to -
>---#<---X---<X<-B#-$A    # kid-A moved 2 and won the game!

Exemplo 2:

board:  >-<<<<<$
kid-A:  [1,2,3]
kid-B:  [5,5,4]

output: 0

Exemplo 3:

board:  >-<-<#<-<-<-$
kid-A:  [5,4,2]
kid-B:  [1,1,1]

output: B

Explicando:

>-<-<#<-<-<-$     # both kids in position
>-<-<#<-<-<-$     # kid-A moved 5 to # returned home
AB<-<#<-<-<-$     # kid-B moved 1 to -
>B<A<#<-<-<-$     # kid-A moved 4 to < returned one to -
>B<A<#<-<-<-$     # kid-B moved 1 to < returned one to -
AB<-<#<-<-<-$     # kid-A moved 2 to # returned home
AB<-<#<-<-<-$     # kid-B moved 1 to < returned one to -

Current position: (A:0, B:1) output: B
removido
fonte
Podemos assumir que as duas matrizes (para A e B) sempre terão o mesmo comprimento?
Trichoplax
Se uma matriz acabar enquanto a outra ainda tiver jogadas de dados restantes (talvez devido a um jogador perder várias jogadas em Xs), a posição atual deve ser usada para determinar a saída ou as jogadas restantes de dados devem ser usadas primeiro?
Trichoplax
1
@trichoplax. Sim, eles sempre terão o mesmo comprimento. Esclarecerei na pergunta
removida em
1
@trichoplax. Os dados restantes devem ser usados ​​primeiro
removidos em
O exemplo 3 está correto? Eu corro este na minha cabeça e B nunca passa do espaço 2, enquanto A chega ao espaço 4.
Draco18s não confia mais no SE

Respostas:

2

Perl, 188 180 + 2 = 182 bytes

Wuhuu, tem que usar goto.

@q=/.(?!$)/g,next if$w=$e=!@q;for(@F){a:$w+=$_;$_=$q[$w];/</?($_=-1,goto a):/X/?$e++:/#/?$w=0:!$_&&last;$e++}$r+=$"lt$r?-$w:$w;$t+=$"lt$t?-$e:$e-1}{say$w>@q?$t<0?B:A:!$r?0:$r<0?B:A

Requer -ae -E| -M5.010:

$ echo $'>-<-<#<-<-<-<-$\n5 4 2\n1 1 1' | perl -M5.010 boardgame.pl
B

Versão um pouco não destruída:

#!/usr/bin/perl -a

# Read all but last char from the board into an array
@board = /.(?!$)/g,next if $pos = $turns = !@board;
for (@F) {
    a:
    $pos+=$_;
    $_=$board[$pos];
    /</?($_=-1,goto a):
    /X/?$turns++:
    /#/?$pos=0:
    # End of Game (Victory!)
    !$_&&last;

    $turns++
}
# Make sure '$pos_diff' and '$turns_diff' are not zero by checking against [:space:]
# ' ' is less than 0 on the ascii table
$pos_diff += $"lt$pos_diff ? -$pos : $pos;
$turns_diff += $"lt$turns_diff ? -$turns : $turns-1;
}{
    say $pos>@board?
            $turns_diff<0?B
            :A
        :
        !$pos_diff?0:
        $pos_diff<0?B:
        A
andlrc
fonte
1

Haskell, 142

_![]=fail;g!(x:y)|x>length g=Just|1<2=g!fix(\f x->case(g!!x)of;'<'->f$x-1;'X'->(0:);'#'->map$(-)(-x);_->map(+x))x y;(g?a)b=(g!)a"A"<|>(g!)b"B"

Uso:

(?) "GAME" [kidA moves] [kidB moves]

Resultado:

(?) ">---#<---X---<X<--#-$" [3,6,6,5,2,1] [4,5,3,5,5,5]
Just "A"

Edit:
Jikes, eu jogava golfe até a morte; falha no último exemplo. Vou revivê-lo em breve.

BlackCap
fonte
1
Também costumamos contar os bytes para imports e acho que você precisará de alguns para fixe <|>, porque eles não estão no Prelude (ou existe uma versão que os inclua?).
nimi
Você está certo, eles não estão no Prelude, buuuut eles são importadas por padrão, se você usar lambdabot como um intérprete (suponho importações de contagem são justas, eu vou fazer isso sempre que eu corrigir isso)
Cabeção
1
O intérprete define o idioma , para que você possa chamar o idioma lambdabot-Haskellou similar e excluir a contagem de bytes para as importações.
nimi