COMPITO

L'obiettivo è scrivere un programma che ruoti di 45 gradi qualsiasi elenco bidimensionale, deve essere in grado di farlo fino a 7 * 45 (contemporaneamente) prima di restituire l'elenco. L'elenco non sarà necessariamente quadrato o rettangolare. È necessario includere l'output per gli esempi nella risposta. Deve funzionare anche per i casi che non sono negli esempi ... cerchi, triangoli, ecc. Non puoi usare una funzione preesistente per fare tutto.

Tutti gli elenchi avranno almeno un asse di simmetria (N, S, E, W). Tutti gli elenchi secondari devono essere considerati allineati al centro. Gli elenchi pari-dispari si sposteranno a quello sinistro per allinearsi correttamente. Vedere l'esempio 4 per gli spazi vuoti nel mezzo di un elenco secondario.

INGRESSO

Il programma utilizzerà una variabile denominata lcontenente l'elenco e una variabile denominata che nspecifica la quantità di cui l'elenco verrà ruotato (n * 45) ( nsarà sempre inferiore a 7 e può essere 0). lDovrà accettare la presenza di elenchi secondari di qualsiasi tipo di dati stampabili (decimale, Elenco, int, String [] .. ecc.), Ma gli elenchi secondari conterranno solo un tipo di dati alla volta.

Non è necessario accettare l'input della console o utilizzare stdin. Le righe che specificano i valori di test di le nnon sono incluse nel conteggio dei caratteri, ma devono essere incluse nel codice inviato.

PRODUZIONE

Il tuo programma deve stampare l'elenco con l'orientamento corretto, NIL può essere usato per riempire gli elenchi se lo desideri, ma il riempimento non è necessario (ottieni una faccina se sono imbottiti, però). Gli elenchi secondari non devono essere rientrati o separati da nuove righe come negli esempi.

ESEMPI

1

IN
l=
[[0 , 1 , 2],
 [3 , 4 , 5],
 [6 , 7 , 8]]
n=1

OUT
[    [0],
   [3 , 1],
 [6 , 4 , 2],
   [7 , 5],
     [8]    ]

2

IN
l=
[[a , b , c , d],
 [e , f , g , h]]
n=2

OUT
[[e , a],
 [f , b],
 [c , g],
 [h , d]]

3

IN
l=
[[A , B , C , D , E , F],
     [G , H , I , J],
         [K , L],
         [0 , 8],
         [M , N],
     [O , P , Q , R],
 [S , T , U , V , W , X]]
n=7

OUT
[          [F],
         [E],
       [D , J],
     [C , I],
   [B , H , L],
 [A , G , K , 8],
           [0 , N , R , X],
             [M , Q , W],
               [P , V],
             [O , U],
               [T],
             [U]          ]

4

IN
l=
[[9 , 8 , 7 , 6],
     [5],
 [4 , 3 , 2 , 1],
     [0]        ]
n=3

OUT
[  [0 , 4],
     [3],
   [2 , 5 , 9],
 [1 ,NIL, 8],
       [7],
     [6],     ]

5

IN
l=
[    [Q],
 [X ,NIL, Y],
     [Z]    ]
n=2

OUT
[    [X],
 [Z ,NIL, Q],
     [Y]     ]

Python - 234 201

# example for defining lists and n
l=[[1,2,3,4],
     [5],
   [6,7,8,9]]
n=1

# counting code
j=1j
m=max(map(len,l))+len(l)
M=range(-m,m)
e=enumerate
d=[[v for x in M for i,u in e(l)for k,v in e(u)if[1,1+j,j,j-1,-1,-j-1,-j,1-j][n]*(k-(len(u)-1)/2+j*i)==x+y*j]for y in M]
print[x for x in d if x]

Versione Ungolfed

rotation = [1,1+1j,1j,1j-1,-1,-1j-1,-1j,1-1j][n]
m = max(map(len,l))+len(l)
output = []
for y in range(-m,m):
    line = []
    for x in range(-m,m):
        for i,sublist in enumerate(l):
            for k,entry in enumerate(sublist):
                if rotation * ( k-(len(sublist)-1)/2 + i*1j ) == x + y*1j:
                    line += [entry]
    if line != []:
        output += [line]
print output

Questo utilizza quella moltiplicazione (di un numero complesso) per un numero complesso corrisponde a rotazione e stiramento. [1,1+1j,1j,1j-1,-1,-1j-1,-1j,1-1j]sono numeri complessi corrispondenti agli angoli richiesti e che utilizzano il fattore di ridimensionamento più piccolo in modo tale che per un input complesso intero l'output sia di nuovo complesso intero.