introduction

Les jeux de société sont un jeu classique entre enfants, mais certains enfants se sentent ennuyés de jouer pas à pas à un jeu de société. Maintenant, ils veulent que le résultat soit affiché avant de mettre la main sur le tableau.

Défi

Supposons que ce jeu de société: >---#<---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

L'entrée se compose d'une chaîne avec les aspects du jeu de plateau décrits ci-dessus et de deux tableaux avec certaines valeurs (de 1à 6) afin que les deux joueurs (enfant Aet enfant B) aient obtenu lors de la lecture d'un cube.

Les deux tableaux auront toujours la même longueur> = 1.

L'enfant Acommence toujours le jeu.

Vous devez sortir le gamin qui a obtenu la fin ou la plus proche en premier.

Si aucun des deux n'a obtenu la fin et que les deux enfants restent à la même position, imprimez 0ou toute autre valeur falsifiée.

Si un tableau s'épuise alors que l'autre a des jets de dés restants (en raison d'un joueur manquant plusieurs tours sur Xs), les jets de dés restants doivent être utilisés.

Pour cette tâche, vous pouvez créer un programme / une fonction, qui lit l'entrée de stdin, ou prendre des paramètres / arguments et afficher / renvoyer / imprimer l'enfant gagnant.

Puisqu'il s'agit de code-golf , la réponse la plus courte en octets gagne!

Exemple d'entrée et de sortie

Vous pouvez également utiliser différents formats d'entrée, mais vous ne devez prendre que le jeu de société, les valeurs kid-A et kid-B.

Exemple 1:

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

output: A

Expliquant:

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

Exemple 2:

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

output: 0

Exemple 3:

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

output: B

Expliquant:

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

Wuhuu, dois utiliser 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

Nécessite -aet -E| -M5.010:

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

Version quelque peu non golfée:

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

Usage:

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

Production:

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

Edit:
Jikes, je l'ai joué au golf à mort; il échoue pour le dernier exemple. Je vais le faire revivre sous peu.