Imprimer un tableau désolé

19

Je jouais juste au jeu de société Désolé! avec certaines personnes, et j'ai réalisé que je pouvais en baser quelques défis intéressants. Celui-ci est assez simple.

Votre tâche consiste simplement à produire une version d'un tableau désolé, en plaçant les pièces là où je vous le dis.

Spécifications

D'abord, voici une image d'un vrai Désolé! conseil pour référence:

Pardon!  Planche

Le tableau vide ressemble à:

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

Remarquez quelques fonctionnalités.

  • Ce #sont des carrés vides.
  • Les S'et H' sont respectivement ceux de Start et Home.
  • Les >v<^« s sont le début des diapositives, selon la direction , ils doivent faire face.
  • Les |«et -» sont les intermédiaires des diapositives, selon qu'ils sont horizontaux ou verticaux.
  • Ce osont la fin des diapositives.
  • Chaque colonne est séparée par une colonne d'espaces pour lui donner un aspect plus carré.

Maintenant, voici ce que vous devez faire:

  • Votre entrée est une liste de coordonnées des différentes pièces qui ont été placées sur le plateau.
  • Les coordonnées commencent au 0carré en dehors du début de la couleur du bas (jaune sur l'image) et augmentent d'une unité par carré dans le sens des aiguilles d'une montre.
  • Après ces 60 carrés, les zones de sécurité ont les 20 coordonnées suivantes et les dernières, en commençant par celle du bas (qui obtient 60-64), puis dans le sens horaire.
  • Vous devrez placer les étoiles *sur la bonne coordonnée, en remplaçant le personnage en dessous pour tous les joueurs.
  • De plus, si l'un des joueurs se trouve sur la case de départ d'un curseur, déplacez-le à la fin du curseur avant de le placer.
  • Vous pouvez supposer qu'il n'y aura pas de collisions, avant ou après la résolution des curseurs.
  • Vous n'avez pas besoin de vous soucier du Home ou du Start.
  • Vous pouvez être indexé 1 si vous le souhaitez, mais les cas de test sont indexés 0.

Cas de test

[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
la source
1
J'aurais pensé que ce serait plus intéressant si les valeurs étaient données en tant que distances des carrés de départ respectifs (ainsi, par exemple, le premier cas de test pourrait être 0, 5et le second pourrait l'être 2, 60, 37).
Neil
@Neil comment sauriez-vous quel carré de départ utiliser?
Maltysen
Désolé, j'ai supposé que vous utilisiez les carrés dans le sens des aiguilles d'une montre, mais je suppose que ce ne serait pas très juste pour une partie à 2 joueurs.
Neil
@Closevoters: Qu'est-ce qui n'est pas clair à ce sujet? Si vous identifiez des problèmes spécifiques, il sera plus facile de les résoudre afin que cela reste ouvert.
DJMcMayhem
Ma confusion concerne l'indexation, avant et après 60 ans et quand marquer les emplacements dans la section d'accueil. Je pense que si vous clarifiez davantage vos exemples, cela aurait plus de sens. Sinon, ça a l'air plutôt cool.
jacksonecac

Réponses:

1

Python 2, 476 octets

Solution courte à 3 lignes ( Essayez-la en ligne )

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 ( Essayez-le en ligne ):

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)

Je suppose les indices de zone de sécurité de cette façon:

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

Explication (les lignes sont un peu séparées pour une meilleure compréhension):

# 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)
Possum mort
la source