Ricordi quelle girandole divertenti su cui soffi e girano in tondo? Codificiamo uno!

Una girandola avrà l'insieme di caratteri che \ | / _disegnano il suo centro e le braccia. Una possibile girandola potrebbe apparire così:

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

Ma cos'è una girandola che non gira? Non è divertente! Possiamo farlo girare riordinando i simboli:

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

La sfida è quella di creare un programma che accetta tre numeri interi e genera una girandola come specificato di seguito. Il primo di questi è il numero di bracci che possiede, il secondo è la lunghezza dei bracci della girandola e il terzo è il numero di volte in cui gira un ottavo di giro in senso orario.

Puoi assumere quanto segue:

• Il numero di bracci sarà sempre 0, 1, 2, 4 o 8.
• Tutte le braccia saranno ugualmente distanziate l'una dall'altra.

• La posizione iniziale della girandola avrà il suo centro in questo modo:

   _
  |_|
  

• Se il numero di bracci è 1, puoi decidere in quale direzione punta il braccio.

• Se il numero di bracci è 2, puoi decidere di far puntare i bracci in verticale o in orizzontale.

È possibile scrivere un programma completo che accetta input tramite STDIN o argomento della riga di comando o una funzione che accetta input tramite argomenti della funzione. Il programma deve mostrare una sequenza di uscite che mostra la rotazione della girandola, ciascuna separata da almeno una riga vuota. Il centro della girandola non deve spostarsi di più di uno spazio. È possibile generare tutti gli spazi iniziali e finali necessari.

Ecco alcuni esempi:

0 2 1

 _
|_|

/\
\/

1 3 2

|
|
|_
|_|

   /
  /
 /
/\
\/

 _ ___
|_|

2 2 0

   _ __
__|_|

8 4 1

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

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

Questo è il codice golf, quindi vince il codice più breve. In bocca al lupo!

Python 2 535 517 473 468 byte

Risparmiato 5 byte grazie a @Easterly Ink!

Input previsto che sia separato da virgola (ovvero numArms, armLength, numRots)

Versione golfizzata

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

Versione 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 ''

Spiegazione

Abbastanza semplice quando viene scomposto. Per prima cosa scopri quanto è necessaria la griglia, quindi traccia il quadrato di base o il diamante.

La posizione iniziale, il simbolo e la direzione di ciascun braccio sono codificati per ciascuno degli 8 bracci possibili per la base quadrata e diamantata. Quindi, disegnarli è abbastanza facile.

Per ruotare tutto, cambio semplicemente tra la base quadrata e la base diamantata, quindi incremento ciascuno dei bracci, ruotandoli una volta in senso orario.