एक चीनी बिसात को घुमाएं

Question

एक चीनी चेकबोर्ड ऐसा दिखता है ( इस प्रश्न पर आधारित है , लेकिन इस बार इसका एक निश्चित आकार है):

            G
           . G
          G G G
         G G . G
B B B B . . Y G . Y . Y Y
 B B B . . G . . . Y Y Y
  B . B . . . . . Y . Y
   B . . . . . . . . Y
    . . . . . . . . .
   . P . . . . . O O .
  P P . . . . . . . O O
 P P P . . . R . . O O .
P P P P . . R . . O O O O
         R . R R
          R R R
           R .
            R

इस उदाहरण में प्रत्येक गैर-स्थान वर्ण को इनपुट में किसी भी गैर-स्थान मुद्रण योग्य ASCII वर्ण द्वारा प्रतिस्थापित किया जा सकता है, जबकि रिक्त स्थान कभी नहीं बदले जाते हैं। ध्यान दें कि यह चीनी परीक्षक में एक वैध व्यवस्था होने की गारंटी नहीं है (जैसे कि इसमें 7 अलग-अलग प्रकार के वर्ण नहीं हो सकते हैं)।

आपका कार्य इसे 60 डिग्री के कई गुणा घूमना है।

यह उपरोक्त उदाहरण 60 डिग्री दक्षिणावर्त घुमाया गया है:

            B
           B B
          B B B
         B . B B
P P P . . . B . . G G . G
 P P P P . . . . . G G G
  P P . . . . . G Y . G
   P . . . . . . . G G
    . . . . . . . . .
   R . . . . . . . . Y
  R . R R . . . . Y Y .
 R R R . . . O . . . Y Y
R . R R . . . O . Y Y Y Y
         O O O .
          O O O
           O .
            O

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

यह कोड-गोल्फ है। सबसे छोटा कोड जीतता है।

Answer 1

CJam, 61 59 43 40 38 36 बाइट्स

{{_N/eeSf.*:sW%zsS-\{_' >{;(}&+}/}*}

यह एक अनाम फ़ंक्शन है जो स्टैक पर स्ट्रिंग और पूर्णांक की अपेक्षा करता है।

19 बाइट बंद करने के लिए @ jimmy23013 को धन्यवाद।

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

विचार

हम उन्हें पूर्व की ओर, फिर दक्षिण की ओर पढ़कर चेकबोर्ड के मुद्रण योग्य वर्णों को एक आदेश दे सकते हैं।

इस तरह, मूल और घुमाया गया बिसात

            G                                  B            
           . G                                B B           
          G G G                              B B B          
         G G . G                            B . B B         
B B B B . . Y G . Y . Y Y          P P P . . . B . . G G . G
 B B B . . G . . . Y Y Y            P P P P . . . . . G G G 
  B . B . . . . . Y . Y              P P . . . . . G Y . G  
   B . . . . . . . . Y                P . . . . . . . G G   
    . . . . . . . . .                  . . . . . . . . .    
   . P . . . . . O O .                R . . . . . . . . Y   
  P P . . . . . . . O O              R . R R . . . . Y Y .  
 P P P . . . R . . O O .            R R R . . . O . . . Y Y 
P P P P . . R . . O O O O          R . R R . . . O . Y Y Y Y
         R . R R                            O O O .         
          R R R                              O O O          
           R .                                O .           
            R                                  O            

बनना

G.GGGGGG.GBBBB..YG.Y.YYBBB..G...YYYB.B.....Y.YB........Y..........P.....OO.PP.......OOPPP...R..OO.PPPP..R..OOOOR.RRRRRR.R

तथा

BBBBBBB.BBPPP...B..GG.GPPPP.....GGGPP.....GY.GP.......GG.........R........YR.RR....YY.RRR...O...YYR.RR...O.YYYYOOO.OOOO.O

क्रमशः।

हम पहले अक्षर में दूसरा क्रम इसके उत्तर-पूर्व में, फिर दक्षिण-पूर्व में पढ़कर पा सकते हैं।

कोड में इसे प्राप्त करने के लिए, हम n - 1 रिक्त स्थान को चेकबोर्ड के n ^वें पंक्ति में छोड़ कर शुरू करते हैं (बाईं ओर दिखाया गया है)। फिर, हम पंक्तियों के क्रम को उल्टा करते हैं (दाईं ओर दिखाया गया है)।

            G                                                       R        
            . G                                                   R .        
            G G G                                               R R R        
            G G . G                                           R . R R        
    B B B B . . Y G . Y . Y Y                       P P P P . . R . . O O O O
      B B B . . G . . . Y Y Y                       P P P . . . R . . O O .  
        B . B . . . . . Y . Y                       P P . . . . . . . O O    
          B . . . . . . . . Y                       . P . . . . . O O .      
            . . . . . . . . .                       . . . . . . . . .        
            . P . . . . . O O .                   B . . . . . . . . Y        
            P P . . . . . . . O O               B . B . . . . . Y . Y        
            P P P . . . R . . O O .           B B B . . G . . . Y Y Y        
            P P P P . . R . . O O O O       B B B B . . Y G . Y . Y Y        
                      R . R R                       G G . G                  
                        R R R                       G G G                    
                          R .                       . G                      
                            R                       G                        

अंत में, हम पंक्तियों को स्तंभों के साथ स्थानांतरित करते हैं:

                 ​



            B    

           BB    

          BBB    

         B.BB    

    PPP...B..GG.G

    PPPP.....GGG

    PP.....GY.G

    P.......GG

    .........

   R........Y

  R.RR....YY.

 RRR...O...YY

R.RR...O.YYYY

OOO.

OOO

O.

O

व्हाट्सएप सभी जगह है, लेकिन प्रिंट करने योग्य वर्ण सही क्रम में हैं यदि हम उन्हें पूर्व की ओर, फिर दक्षिण की ओर पढ़ते हैं।

सभी जो रह गई है बदल रहा है n ^वें द्वारा मूल बिसात की प्रिंट करने योग्य चरित्र एन ^वें अंतिम संशोधन का मुद्रण योग्य चरित्र।

कोड

                                   e# Stack: String B, Integer A
{                               }* e# Repeat A times:
 _N/                               e#   Push a copy of B and split it at linefeeds.
    ee                             e#   Enumerate the lines of B.
      Sf.*:s                       e#   Execute S.*s for each line:
                                   e#     [4 "abc"] -> "    abc"
            W%                     e#   Reverse the order of line lines.
              z                    e#   Zip; transpose rows with columns.
               s                   e#   Flatten the arrays of strings.
                S-                 e#   Remove spaces.
                                   e#   This pushes a string L.
                  \{          }/   e#   For each character C in the unmodified B:
                    _' >           e#     Check if C is bigger than ' '.
                        {  }&      e#     If it is:
                         ;(        e#      Discard C and shift out a char from L.
                             +     e#     Append a char (C or from L) to L.
                                   e#  L is B rotated by 60 degrees. Set L := B.

Comments

_,,Sf*\.+W%ze_।

— jimmy23013

@ jimmy23013: मेरी छँटाई दृष्टिकोण से बहुत बेहतर है। धन्यवाद!

— डेनिस

liq{_N/eeSf.*W%:szsS-\{_' >{;(}&\}/;]}@*, लेकिन जब मैं इस चुनौती को लिख रहा था, तो मैं 60 डिग्री से 45 डिग्री पर घूमने की सोच रहा था ...

— jimmy23013

@ jimmy23013: वाह, धन्यवाद! मैं एक अलग दृष्टिकोण की कोशिश कर रहा था, लेकिन qN/(i{_eeSf.*W%:szSf-{},.{' f+sW<\,' e[}}*N*इससे भी अधिक लंबा है जो मैंने पहले किया था ...

— डेनिस

Answer 2

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

def f(S,n):
 o="";E=enumerate;B=S.splitlines(1)
 for r,l in E(B):
  for c,q in E(l):z=r-8;y=6-(z+c)/2;x=-y-z;exec"x,y,z=-y,-z,-x;"*n;o+=q*(q<"!")or B[z+8][12-y+x]
 print o

यह शायद एकमात्र समय है जब मैंने कभी str.splitlinesउपयोगी पाया है - अन्य सभी समयों के लिए, .split("\n")कम है।

का उपयोग करें f(S,10)।

व्याख्या

इनपुट में प्रत्येक चार्ट के लिए, हम या तो:

• अगर यह एक स्थान या newline है, या इसे रखें
• इसे सही चार के साथ बदलें अन्यथा

यह पता लगाने के लिए कि किस चार्ट को बदलने के लिए, हम ग्रिड को क्यूब के निर्देशांक में परिवर्तित करते हैं (x, y, z), nबार-बार (x, y, z) -> (-y, -z, -x)परिवर्तित करके घुमाते हैं , फिर वापस कन्वर्ट करते हैं।