¡Juguemos un juego de mesa!


11

Introducción

Los juegos de mesa son un juego clásico entre niños, pero hay algunos niños que se sienten aburridos jugando un juego de mesa paso a paso. Ahora quieren que se muestre el resultado antes de poner sus manos en el tablero.

Desafío

Supongamos que este juego de mesa: >---#<---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

La entrada consiste en una cadena con los aspectos del juego de mesa descritos anteriormente y dos matrices con algunos valores (de 1a 6) para que ambos jugadores (niño Ay niño B) obtuvieran al jugar un cubo.

Ambas matrices siempre tendrán la misma longitud> = 1.

El niño Asiempre comienza el juego.

Debes dar salida al chico que obtuvo el final o más cerca del final primero.

Si ninguno de los dos obtuvo el final y ambos niños permanecen en la misma posición, imprimir 0o cualquier otro valor falso.

Si un conjunto se agota mientras que el otro tiene tiradas de dados restantes (debido a que un jugador pierde varios turnos en Xs), las tiradas de dados restantes se deben usar.

Para esta tarea, puede crear un programa / función, que lea la entrada de stdin, o tomar parámetros / argumentos y generar / devolver / imprimir el niño ganador.

Como se trata de , ¡la respuesta más corta en bytes gana!

Ejemplo de entrada y salida

También puede usar diferentes formatos de entrada, pero solo debe tomar los valores de juego de mesa, kid-A y kid-B.

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

Ejemplo 2

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

output: 0

Ejemplo 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

¿Podemos suponer que las dos matrices (para A y B) siempre tendrán la misma longitud?
trichoplax

Si un conjunto se agota mientras que el otro tiene tiradas de dados restantes (tal vez debido a que un jugador pierde varios turnos en Xs), ¿debería usarse la posición actual para determinar la salida, o deberían usarse primero las tiradas de dados restantes?
trichoplax

1
@trichoplax. Sí, siempre serán del mismo largo. Lo aclararé en la pregunta
eliminado

1
@trichoplax. Las tiradas de dados restantes se deben usar primero
eliminaron

¿Es correcto el ejemplo 3? Corro este en mi cabeza y B nunca pasa el espacio 2, mientras que A llega al espacio 4.
Draco18s ya no confía en SE

Respuestas:


2

Perl, 188 180 + 2 = 182 bytes

Wuhuu, tengo 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

Requiere -ay -E| -M5.010:

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

Versión un tanto sin golf:

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

Salida:

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

Editar:
Chistes, lo jugué hasta la muerte; falla para el último ejemplo. Lo reviviré en breve.


1
Por lo general, también contamos los bytes para imports y creo que necesitará algunos para fixy <|>, porque no están en Prelude (¿o hay una versión que los incluya?).
nimi

Tienes razón, no están en Prelude, pero se importan de forma predeterminada si usas lambdabot como intérprete (supongo que contar las importaciones es justo; lo haré siempre que arregle esto)
BlackCap

1
El intérprete define el idioma , por lo que puede llamar al idioma lambdabot-Haskello similar y excluir el recuento de bytes para las importaciones.
nimi
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.