उन मजेदार पिनव्हील्स को याद रखें जिन्हें आप उड़ाते हैं और वे गोल और गोल घूमते हैं? चलो एक कोड!

एक पिनव्हील में \ | / _इसके केंद्र और हथियारों को चित्रित करने वाले पात्रों का समूह होगा । एक संभावित पिनव्हील इस तरह दिख सकता है:

    |
    |
    |_ ___
 ___|_|
      |
      |
      |

लेकिन क्या एक पिनव्हील है जो स्पिन नहीं करता है? कोई मज़ा नहीं! हम प्रतीकों को पुन: व्यवस्थित करके इसे स्पिन कर सकते हैं:

      /
\    /
 \  /
  \/\
   \/\
   /  \
  /    \
 /

चुनौती एक प्रोग्राम बनाने की है जो तीन पूर्णांकों को लेता है और नीचे निर्दिष्ट के रूप में एक पिनव्हील आउटपुट करता है। इनमें से पहला हथियारों की संख्या है, दूसरा पिनव्हील की भुजाओं की लंबाई है, और तीसरा यह है कि यह एक क्रांति की घड़ी के आठवें हिस्से को स्पिन करेगा।

आप निम्नलिखित मान सकते हैं:

हथियारों की संख्या हमेशा 0, 1, 2, 4, या 8 होगी।
सभी हथियार समान रूप से एक दूसरे से अलग होंगे।
पिनव्हील की प्रारंभिक स्थिति का केंद्र इस तरह होगा:
```
 _
|_|
```
यदि हथियारों की संख्या 1 है, तो आप यह तय कर सकते हैं कि हथियार किस दिशा में हैं।
यदि हथियारों की संख्या 2 है, तो आप हथियारों को लंबवत या क्षैतिज रूप से बनाने का निर्णय ले सकते हैं।

आप एक पूर्ण प्रोग्राम लिख सकते हैं जो STDIN या कमांड-लाइन तर्क के माध्यम से इनपुट लेता है, या एक फ़ंक्शन जो फ़ंक्शन तर्कों के माध्यम से इनपुट लेता है। आपके प्रोग्राम को आउटपुट का एक क्रम दिखाना होगा जो पिनव्हील कताई को दिखाता है, प्रत्येक को कम से कम एक खाली लाइन द्वारा अलग किया जाता है। पिनव्हील का केंद्र एक से अधिक स्थानों से नहीं बढ़ना चाहिए। आप आवश्यक के रूप में कई प्रमुख और अनुगामी रिक्त स्थान के रूप में उत्पादन कर सकते हैं।

यहाँ कुछ उदाहरण हैं:

0 2 1

 _
|_|

/\
\/

१ ३ २

|
|
|_
|_|

   /
  /
 /
/\
\/

 _ ___
|_|

२ २ ०

   _ __
__|_|

४ १

 \   |    /
  \  |   /
   \ |  /
    \|_/____
 ____|_|
     / |\
    /  | \
   /   |  \
  /    |   \

     |   /
 \   |  /
  \  | /
   \ |/
____\/\____
     \/\
     /| \
    / |  \
   /  |   \
  /   |

यह कोड गोल्फ है, इसलिए सबसे छोटा कोड जीतता है। सौभाग्य!

code-golf ascii-art

— टीएनटी
स्रोत

क्या आउटपुट में एक अनुगामी न्यूलाइन हो सकती है?

— usandfriends

राशि के विषय में प्रतिबंध के बिना, अनुगामी नई सूचियों की अनुमति है।

— TNT

अंतिम उदाहरण के लिए, आपके पास पहले आउटपुट के लिए प्रत्येक पंक्ति के लिए एक अतिरिक्त स्थान है। क्या हम आउटपुट में रिक्त स्थान और अनुगामी हो सकते हैं?

— usandfriends

आउटपुट में प्रमुख स्थानों की संख्या को पिनव्हील के केंद्र की स्थिति के साथ करना पड़ता है, जिसकी स्थिति को एक से अधिक स्थान से स्थानांतरित नहीं करना चाहिए। अगर पिनव्हील के घूमने से एक पिन बाद में पिनव्हील के केंद्र के बायीं ओर समाप्त हो जाएगा, तो आउटपुट में (जैसे इनपुट के लिए 1 3 5और हाथ शुरू में इशारा करते हुए), इससे समायोजित करने के लिए रिक्त स्थान को पूर्व आउटपुट में पूर्व निर्धारित करने की आवश्यकता होगी।

— टीएनटी

पायथन 2 535 517 473 468 बाइट्स

सहेजे गए 5 बाइट @ इस्टरली इंक का धन्यवाद!

इनपुट अल्पविराम से अलग होने की उम्मीद है (यानी, संख्या, भुजाएं, गति, संख्या)

गोल्फ संस्करण

n,l,t=input()
b=[7,3,1,5,0,4,2,6][:n]
w=5+2*l
h=w-3
X=w/2
Y=h/2-1
z=range
d=[0,1,1,1,0,-1,-1,-1]
for j in z(t+1):
 g=[[' 'for _ in[1]*w]for _ in[1]*h];a=j%2;b=[(k+1)%8for k in b];print''
 if a:g[Y][X:X+2]='/\\';g[Y+1][X:X+2]='\\/'
 else:g[Y][X+1]='_';g[Y+1][X:X+3]='|_|'
 for k in b:k=k+8*a;x=[0,2,3,3,2,0,-1,-1,0,1,2,2,1,0,-2,-1][k]+X;y=[0,0,0,2,2,2,1,0,-1,-1,0,1,2,2,0,0][k]+Y;exec"g[y][x]='|/_\\\\'[k%4];x+=d[k%8];y+=d[(k-2)%8];"*l
 for k in z(h):print''.join(g[k])

Ungolfed संस्करण

numArms, armLength, rotAmount = input()

# Choose which arms to draw
arms = [0,4,2,6,1,5,3,7][:numArms]
for i in xrange(rotAmount+1):

    # Set up the grid spacing
    maxWidth = 5 + 2 * armLength
    maxHeight = 2 + 2 * armLength
    grid = [[' ' for x in xrange(maxWidth)] for y in xrange(maxHeight)]

    # Add the base square
    angle = i%2
    startX = len(grid[0])/2
    startY = len(grid)/2 - 1
    if angle:
        grid[startY][startX:startX+2] = '/\\'
        grid[startY+1][startX:startX+2] = '\\/'
    else:
        grid[startY][startX+1] = '_'
        grid[startY+1][startX:startX+3] = '|_|'

    for armNum in arms:
        # Determine where this arm starts
        armIdx = armNum + 8*angle;
        armX = [0,2,3,3,2,0,-1,-1,0,1,2,2,1,0,-2,-1][armIdx] + startX
        armY = [0,0,0,2,2,2,1,0,-1,-1,0,1,2,2,0,0][armIdx] + startY

        # Determine the direction it travels
        d = [0,1,1,1,0,-1,-1,-1]
        dirX = [0,1,1,1,0,-1,-1,-1][armIdx%8]
        dirY = [-1,-1,0,1,1,1,0,-1][(armIdx)%8]
        sym = '|/_\\'[armIdx%4]

        # Draw the arm
        for i in xrange(armLength):
            grid[armY][armX] = sym
            armX += dirX
            armY += dirY

    # Increment which arms to draw next
    arms = [(a+1)%8 for a in arms]
    for i in xrange(len(grid)):
        print ''.join(grid[i])
    print ''

व्याख्या

बहुत आसान है जब यह टूट गया है। पहले पता लगाएं कि ग्रिड की कितनी बड़ी आवश्यकता है, फिर आधार वर्ग या हीरे की साजिश करें।

प्रत्येक हाथ की प्रारंभिक स्थिति, प्रतीक और दिशा वर्ग और हीरे के आधार के लिए 8 संभव हथियारों में से प्रत्येक के लिए हार्डकोड किया गया है। फिर, उन्हें ड्राइंग करना काफी आसान है।

सब कुछ घुमाने के लिए, मैं बस वर्ग और हीरे के आधार के बीच स्विच करता हूं, फिर प्रत्येक हथियार को बढ़ाता हूं, उन्हें एक बार दक्षिणावर्त घुमाता हूं।

— डोमिनिक ए।
स्रोत

आप रिक्तियों स्थानों में की तरह निकाल सकते हैं ' ' forकरने के लिए ' 'for', ] forकरने के लिए ]for', 8 के लिए 8for', print ''करने के लिए print''।

— आर

अच्छा! मैं वास्तव में इस चुनौती का जवाब देखकर खुश हूं।

— टीएनटी

एक कताई पिनव्हील ड्रा करें

पायथन 2 535 517 473 468 बाइट्स

गोल्फ संस्करण

Ungolfed संस्करण

व्याख्या