Facciamo un po 'di gioco da tavolo!


11

introduzione

I giochi da tavolo sono un gioco classico tra i bambini, ma ci sono alcuni bambini che si annoiano giocando un gioco da tavolo passo dopo passo. Ora vogliono che il risultato sia mostrato prima di mettere le mani sul tavolo.

Sfida

Supponiamo che questo gioco da tavolo: >---#<---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'input consiste in una stringa con gli aspetti del gioco da tavolo sopra descritti e due matrici con alcuni valori (da 1a 6) in modo che entrambi i giocatori (bambino Ae bambino B) abbiano ottenuto giocando un cubo.

Entrambi gli array avranno sempre la stessa lunghezza> = 1.

Il bambino Ainizia sempre il gioco.

È necessario produrre il bambino che ha ottenuto la fine o più vicino alla fine prima.

Se nessuno dei due ha la fine ed entrambi i bambini rimangono nella stessa posizione, stampare 0o qualsiasi altro valore falso.

Se un array si esaurisce mentre l'altro ha tiri di dado rimanenti (a causa della mancanza di diversi turni su X di un giocatore), i rimanenti tiri di dado devono essere esauriti.

Per questa attività, è possibile creare un programma / funzione, che legge input da stdin, oppure accetta parametri / argomenti e output / return / stampa il figlio vincitore.

Dato che si tratta di , vince la risposta più breve in byte!

Esempio di input e output

Puoi anche usare diversi formati di input, ma dovresti solo prendere i valori di boardgame, kid-A e kid-B.

Esempio 1:

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

output: A

spiegazione:

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

Esempio 2:

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

output: 0

Esempio 3:

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

output: B

spiegazione:

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

Possiamo supporre che i due array (per A e B) avranno sempre la stessa lunghezza?
trichoplax,

Se un array si esaurisce mentre l'altro ha ancora i tiri di dado rimanenti (forse a causa della mancanza di diversi turni su X di un giocatore), la posizione corrente dovrebbe essere usata per determinare l'output o i tiri di dado rimanenti dovrebbero essere usati per primi?
trichoplax,

1
@trichoplax. Sì, saranno sempre della stessa lunghezza. Chiarirò la domanda
rimosso il

1
@trichoplax. I rimanenti tiri di dado devono essere usati per primi
rimossi il

L'esempio 3 è corretto? Corro questo nella mia testa e B non supera mai lo spazio 2, mentre A arriva allo spazio 4.
Draco18s non si fida più di SE

Risposte:


2

Perl, 188 180 + 2 = 182 byte

Wuhuu, devo usare 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

Richiede -ae -E| -M5.010:

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

Versione un po 'non golfata:

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

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]

Produzione:

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

Modifica:
Jikes, l'ho giocato a golf a morte; fallisce per l'ultimo esempio. Lo farò rivivere a breve.


1
Di solito contiamo anche i byte per imports e penso che ne avrai bisogno per fixe <|>, poiché non sono in Preludio (o esiste una versione che li include?).
nimi,

Hai ragione, non sono in Preludio, ma sono importati di default se usi lambdabot come interprete (suppongo che il conteggio delle importazioni sia corretto; lo farò ogni volta che risolverò)
BlackCap

1
L'interprete definisce la lingua , quindi è possibile chiamare la lingua lambdabot-Haskello simili ed escludere il conteggio dei byte per le importazioni.
nimi,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.