Wprowadzenie

Gry planszowe to klasyczna gra między dziećmi, ale niektóre dzieci nudzą się grając w grę planszową krok po kroku. Teraz chcą, aby wynik został pokazany, zanim położy ręce na planszy.

Wyzwanie

Załóżmy, że ta gra planszowa: >---#<---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

Dane wejściowe składają się z ciągu z opisanymi powyżej aspektami gry planszowej i dwóch tablic z pewnymi wartościami (od 1do 6), aby obaj gracze (dziecko Ai dziecko B) mieli je podczas gry jedną kostką.

Obie tablice będą zawsze miały tę samą długość> = 1.

Dzieciak Azawsze zaczyna grę.

Musisz wydać dziecko, które dotarło do końca lub było bliżej końca jako pierwsze.

Jeśli żadne z nich nie dostanie końca, a oboje dzieci pozostaną w tej samej pozycji, drukuj 0lub jakąkolwiek inną wartość fałszowania.

Jeśli jedna tablica się skończy, podczas gdy druga ma pozostałe rzuty kostkami (z powodu braku jednego gracza przez kilka tur na X), pozostałe rzuty kostne należy zużyć.

W tym zadaniu możesz utworzyć program / funkcję, która odczytuje dane wejściowe ze standardowego wejścia lub pobiera parametry / argumenty i wyświetla / zwraca / drukuje zwycięzcę.

Ponieważ jest to golfowy kod , wygrywa najkrótsza odpowiedź w bajtach!

Przykład wejścia i wyjścia

Możesz także używać różnych formatów danych wejściowych, ale powinieneś brać tylko wartości z gry planszowej, kid-A i kid-B.

Przykład 1:

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

output: A

Wyjaśnienie:

>---#<---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!

Przykład 2:

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

output: 0

Przykład 3:

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

output: B

Wyjaśnienie:

>-<-<#<-<-<-$     # 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

Perl, 188180 + 2 = 182 bajtów

Wuhuu, muszę użyć 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

Wymaga -aa -E| -M5.010:

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

Nieco golfowa wersja:

#!/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

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"

Stosowanie:

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

Wynik:

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

Edycja:
Jikes, grałem w golfa na śmierć; zawodzi w ostatnim przykładzie. Niedługo ożyję.