एक क्षमा करें बोर्ड मुद्रित करें

Question

मैं बस बोर्ड गेम खेल रहा था सॉरी! कुछ लोगों के साथ, और मुझे एहसास हुआ कि मैं इससे कुछ दिलचस्प चुनौतियों को आधार बना सकता हूं। यह एक बहुत सरल है।

आप कार्य केवल एक सॉरी बोर्ड के एससी-आर्ट संस्करण का उत्पादन करने के लिए करते हैं, जहां मैं आपको बताता हूं कि टुकड़े रखे।

ऐनक

सबसे पहले, यहाँ एक वास्तविक क्षमा करें की छवि है ! संदर्भ के लिए बोर्ड:

खाली बोर्ड ऐसा दिखता है:

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

कुछ विशेषताओं पर ध्यान दें।

• #के खाली वर्गों रहे हैं।
• Sकी और Hके प्रारंभ के होते हैं और घर के क्रमशः।
• >v<^की, स्लाइड की शुरुआत कर रहे हैं जो दिशा वे सामना के आधार पर।
• |की और -की, स्लाइड के middles हैं अगर वे क्षैतिज या लम्बवत हो पर निर्भर करता है।
• oके अंत स्लाइड की है कर रहे हैं।
• प्रत्येक स्तंभ रिक्त स्थान के एक स्तंभ द्वारा अलग किया जाता है ताकि यह अधिक चौकोर जैसा दिखाई दे।

अब यहाँ आपको क्या करना है:

• आपका इनपुट विभिन्न टुकड़ों के निर्देशांक की एक सूची है जिसे बोर्ड पर रखा गया है।
• निर्देशांक 0नीचे के रंग (चित्र में पीला) की शुरुआत के बाहर वर्ग में शुरू होता है, और प्रति वर्ग घड़ी के हिसाब से एक की वृद्धि होती है।
• इन 60 वर्गों के बाद, सुरक्षित क्षेत्रों में अगले और अंतिम 20 निर्देशांक होते हैं, जो नीचे से एक पर शुरू होता है (जो 60-64 हो जाता है), फिर घड़ी की दिशा में जा रहा है।
• आपको *सभी खिलाड़ियों के लिए नीचे दिए गए वर्ण को प्रतिस्थापित करते हुए, सही समन्वय पर स्टार का स्थान देना होगा ।
• इसके अतिरिक्त, यदि कोई खिलाड़ी स्लाइडर के प्रारंभ वर्ग में है, तो उन्हें रखने से पहले स्लाइडर के अंत में ले जाएं।
• आप मान सकते हैं कि स्लाइडर्स को हल करने से पहले या बाद में कोई टकराव नहीं होगा।
• आपको होम या स्टार्ट के बारे में चिंता करने की आवश्यकता नहीं है।
• आप चाहें तो 1-अनुक्रमित हो सकते हैं, लेकिन परीक्षण के मामले 0-अनुक्रमित हैं।

परीक्षण के मामलों

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

Comments

मुझे लगता है कि यह अधिक दिलचस्प होगा यदि मूल्यों को संबंधित प्रारंभ वर्गों से दूरी के रूप में दिया गया था (इसलिए उदाहरण के लिए पहला परीक्षण मामला हो सकता है 0, 5और दूसरा हो सकता है 2, 60, 37)।

— नील

@ क्या आप कैसे जानते हैं कि किस वर्ग का उपयोग शुरू होगा?

— माल्टीसेन

क्षमा करें, मैंने मान लिया कि आपने चौकों का उपयोग दक्षिणावर्त क्रम में किया है, लेकिन मुझे लगता है कि यह 2-खिलाड़ी खेल के लिए बहुत उचित नहीं होगा।

— नील

@Closevoters: इसके बारे में क्या अस्पष्ट है? यदि आप कुछ विशिष्ट चिंताओं की पहचान करते हैं, तो उन्हें ठीक करना आसान हो जाएगा ताकि यह खुला रह सके।

— DJMcMayhem

मेरी उलझन अनुक्रमण के बारे में है, 60 से पहले और बाद में पहुंच गया है और जब घर अनुभाग में स्थानों को चिह्नित करना है। मुझे लगता है कि यदि आपने अपने उदाहरणों को स्पष्ट किया तो यह और अधिक समझ में आएगा। अन्यथा यह बहुत अच्छा लग रहा है।

— जैक्सनसेक

Answer 1

पायथन 2, 476 बाइट्स

लघु 3-लाइन समाधान ( इसे ऑनलाइन आज़माएं )

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)

534 में वन-लाइनर ( इसे ऑनलाइन आज़माएं ):

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)

मैं इस तरह से सुरक्षित क्षेत्र के सूचकांक मान रहा हूं:

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

स्पष्टीकरण (बेहतर समझ के लिए लाइनें थोड़ी अलग हो जाती हैं):

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