Imprima un tablero de perdón

19

Solo estaba jugando el juego de mesa ¡Lo siento! con algunas personas, y me di cuenta de que podía basarme en algunos desafíos interesantes. Este es bastante simple.

Su tarea es simplemente generar una versión de un tablero lamentable, colocando las piezas donde se lo pido.

Especificaciones

Primero, aquí hay una imagen de un verdadero ¡Lo siento! tablero para referencia:

¡Lo siento!  Tablero

El tablero vacío se ve así:

# > - - o # # # # > - - - o # #
#   #   S                     v
o   #             H # # # # # |
|   #                         |
|   #                       S o
|   #                         #
^   H                         #
#                             #
#                             #
#                         H   v
#                         #   |
o S                       #   |
|                         #   |
| # # # # # H             #   o
^                     S   #   #
# # o - - - < # # # # o - - < #

Observe algunas características.

  • Los #'s son cuadrados vacíos.
  • Las S'sy H' son Start y Home respectivamente.
  • Los >v<^'s son el comienzo de las diapositivas, dependiendo de la dirección que miren.
  • Los |'sy -' son los medios de las diapositivas, dependiendo de si son horizontales o verticales.
  • Los o's son el final de las diapositivas.
  • Cada columna está separada por una columna de espacios para que parezca más cuadrada.

Ahora esto es lo que tienes que hacer:

  • Su entrada es una lista de coordenadas de varias piezas que se han colocado en el tablero.
  • Las coordenadas comienzan en 0el cuadrado fuera del Inicio del color inferior (amarillo en la imagen) y aumentan en uno por cuadrado en el sentido de las agujas del reloj.
  • Después de estos 60 cuadrados, las zonas seguras tienen las siguientes y últimas 20 coordenadas, comenzando por la que está en la parte inferior (que obtiene 60-64), y luego en sentido horario.
  • Tendrás que colocar la ( *s) estrella ( s) en la coordenada correcta, reemplazando el personaje debajo de todos los jugadores.
  • Además, si alguno de los jugadores está en el cuadro inicial de un control deslizante, muévalo al final del control deslizante antes de colocarlo.
  • Puede suponer que no habrá colisiones, antes o después de resolver los controles deslizantes.
  • No necesita preocuparse por el inicio o el inicio.
  • Puede estar indexado en 1 si lo desea, pero los casos de prueba están indexados en 0.

Casos de prueba

[0, 20] ->

# > - - o # # # # > - - - o # #
#   #   S                     v
*   #             H # # # # # |
|   #                         |
|   #                       S o
|   #                         #
^   H                         #
#                             #
#                             #
#                         H   v
#                         #   |
o S                       #   |
|                         #   |
| # # # # # H             #   o
^                     S   #   #
# # o - - - < # # # # * - - < #

[2, 7, 66] ->

# > - - o # # # # > - - - o # #
#   #   S                     v
o   #             H # # # # # |
|   #                         |
|   #                       S o
|   #                         #
^   H                         #
#                             #
#                             #
#                         H   v
#                         #   |
o S                       #   |
|                         #   |
| # * # # # H             #   o
^                     S   #   #
# # o - * - < # # * # o - - < #
Maltysen
fuente
1
Pensé que esto sería más interesante si los valores se dieran como distancias desde los cuadrados de inicio respectivos (por ejemplo, el primer caso de prueba podría ser 0, 5y el segundo podría ser 2, 60, 37).
Neil
@Neil, ¿cómo saber qué cuadrado de inicio usar?
Maltysen
Lo siento, supuse que usaste los cuadrados en el sentido de las agujas del reloj, pero supongo que eso no sería muy justo para un juego de 2 jugadores.
Neil
@Closevoters: ¿Qué tiene de claro esto? Si identifica algunas inquietudes específicas, será más fácil solucionarlas para que esto pueda permanecer abierto.
DJMcMayhem
Mi confusión es acerca de la indexación, antes y después de llegar a 60 y cuándo marcar ubicaciones en la sección de inicio. Creo que si aclararas más tus ejemplos, tendría más sentido. De lo contrario, se ve muy bien.
jacksonecac

Respuestas:

1

Python 2, 476 bytes

Solución corta de 3 líneas ( Pruébelo en línea )

s=map(list,''.join(b if b in'#^v<>-|oSH~'else' '*int(b,16)for b in "#>--o####>---o##~#1#1SAv~o1#6H#####|~|1#C|~|1#BSo~|1#C#~^1HC#~#E#~#E#~#CH1v~#C#1|~oSB#1|~|C#1|~|#####H6#1o~^AS1#1#~##o---<####o--<#").split('~'))
for i in input():x,y=(lambda n:([11-n,15]*12+[0,26-n]*14+[n-26,0]*16+[15,n-41]*14+[71-n,15]*4+[13,n-50]*5+[70-n,13]*5+[2,75-n]*5+[n-65,2]*5)[2*n:2*n+2])((lambda n:4if n in[5,20,35,50]else 3if n in[12,27,42,57]else 0)(i)+i);s[y][x]='*'
for r in s:print' '.join(r)

One-liner en 534 ( Pruébelo en línea ):

for r in(lambda B,I:[[[i,j]in map(lambda n:([11-n,15]*12+[0,26-n]*14+[n-26,0]*16+[15,n-41]*14+[71-n,15]*4+[13,n-50]*5+[n-64,13]*5+[2,75-n]*5+[n-65,2]*5)[2*n:2*n+2],map(lambda n:n+4if n in[5,20,35,50]else n+3if n in[12,27,42,57]else n,I))and'*'or b for i,b in enumerate(a)]for j,a in enumerate(B)])(map(list,''.join(b if b in'#^v<>-|oSH~'else' '*int(b,16)for b in"#>--o####>---o##~#1#1SAv~o1#6H#####|~|1#C|~|1#BSo~|1#C#~^1HC#~#E#~#E#~#CH1v~#C#1|~oSB#1|~|C#1|~|#####H6#1o~^AS1#1#~##o---<####o--<#").split('~')),input()):print' '.join(r)

Asumo índices de zona segura de esta manera:

#  >  -  -  o  #  #  #  #  >  -  -  -  o  #  #
#     74    S                                v
o     73                   H 75 76 77 78 79  |
|     72                                     |
|     71                                  S  o
|     70                                     #
^     H                                      #
#                                            #
#                                            #
#                                      H     v
#                                      60    |
o  S                                   61    |
|                                      62    |
|  69 68 67 66 65 H                    63    o
^                                S     64    #
#  #  o  -  -  -  <  #  #  #  #  o  -  -  <  #

Explicación (las líneas se separan un poco para una mejor comprensión):

# Hardcode board. Spaces are changed to their number in hex (as there are up to 14 spaces in row)
# Unfortunatly v^<> characters made board non-symmetrical and replacing chars costs too much in python, so I had to hardcode it all
B="#>--o####>---o##~#1#1SAv~o1#6H#####|~|1#C|~|1#BSo~|1#C#~^1HC#~#E#~#E#~#CH1v~#C#1|~oSB#1|~|C#1|~|#####H6#1o~^AS1#1#~##o---<####o--<#"

# Encode board to list of lists of characters
s=map(list,''.join(b if b in'#^v<>-|oSH~'else' '*int(b,16)for b in B).split('~'))

# Map coordinates, based on n (awfully long)
# Creates long list (lenght of 80) with values based on n and only one valid, which occures under index n
l=lambda n:([11-n,15]*12+[0,26-n]*14+[n-26,0]*16+[15,n-41]*14+[71-n,15]*4+[13,n-50]*5+[70-n,13]*5+[2,75-n]*5+[n-65,2]*5)[2*n:2*n+2]

# Returns additional move of n if it appers to be on slide start
j=lambda n:4if n in[5,20,35,50]else 3if n in[12,27,42,57]else 0

# Here takes input as list of numbers, get coordinates for them and update board with *
for i in input():x,y=l(j(i)+i);s[y][x]='*'

# Print board, spacing characters with one whitespace
for r in s:print' '.join(r)
Zarigüeya muerta
fuente