दो-आयामी सूची को 45 डिग्री से घुमाएं

Question

टास्क

लक्ष्य एक ऐसा प्रोग्राम लिखना है जो किसी भी द्वि-आयामी सूची को 45 डिग्री तक घुमाता है, यह सूची वापस करने से पहले 7 * 45 (एक बार में) तक ऐसा करने में सक्षम होना चाहिए। सूची आवश्यक रूप से वर्गाकार या आयताकार नहीं होगी। आपको अपने उत्तर में उदाहरणों के लिए आउटपुट शामिल करना होगा। यह उन मामलों के लिए भी काम करना चाहिए जो उदाहरणों में नहीं हैं ... मंडलियां, त्रिकोण आदि आप पूरी तरह से काम करने के लिए पहले से मौजूद फ़ंक्शन का उपयोग नहीं कर सकते हैं।

सभी सूचियों में समरूपता (N, S, E, W) की कम से कम एक धुरी होगी। सभी उपविदों को केंद्र-गठबंधन के रूप में माना जाना चाहिए। ऑड-ईवन सूचियां ठीक से संरेखित करने के लिए बाईं ओर स्थानांतरित हो जाएंगी। उदाहरण देखें एक सबलिस्ट के बीच में अंतराल के लिए 4।

इनपुट

आपका प्रोग्राम lसूची में नाम वाले एक चर का उपयोग करेगा , और nराशि को निर्दिष्ट करने वाला चर नामांकित होगा (n * 45) ( nहमेशा 7 से कम होगा, और 0 हो सकता है)। इसे lकिसी भी प्रिंट करने योग्य डेटा प्रकार (दशमलव, सूची, इंट, स्ट्रिंग [] .. आदि) के उपविदों को स्वीकार करना होगा , लेकिन उप-सूची में एक समय में केवल एक डेटा प्रकार होगा।

आपको कंसोल इनपुट को स्वीकार करने या स्टडिन का उपयोग करने की आवश्यकता नहीं है। लाइनों की कसौटी पर मानों को निर्दिष्ट lऔर nचरित्र गिनती में शामिल नहीं हैं, लेकिन प्रस्तुत कोड में शामिल किया जाना चाहिए।

आउटपुट

आपके कार्यक्रम को सूची को सही अभिविन्यास में मुद्रित करना चाहिए, यदि आप चाहें तो NIL को पैड सूचियों में उपयोग किया जा सकता है, लेकिन पैडिंग आवश्यक नहीं है (यदि वे गद्देदार हैं तो आपको एक स्माइली चेहरा मिलता है, हालांकि)। उप-सूचियों को उदाहरणों की तरह नई सूचियों द्वारा इंडेंट या अलग नहीं किया जाना है।

उदाहरण

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

Comments

ओह। यह कठिन है। हालांकि मज़ेदार लगता है!

— TheDoctor

दो प्रश्न: 1) हमें सूचियों को पैड करने की आवश्यकता नहीं है, है ना? 2) क्या आप वास्तव में चाहते हैं कि हम सूची के nसमय को घुमाएं न कि n45 ° से? मैं पूछ रहा हूं क्योंकि मुझे पूरा यकीन है कि मैं सात 45 ° घूर्णन लागू करके उदाहरण 3 का परिणाम प्राप्त नहीं करूंगा।

— Wrzlprmft

नहीं, आपको पैड करने की ज़रूरत नहीं है। हालांकि सूची को सही दृश्य अभिविन्यास में व्यवस्थित किया जाना चाहिए, हालांकि इसका उस तरह से आउटपुट होना जरूरी नहीं है ... आउटपुट में कुछ नए लिंक नहीं होंगे। सूची को n * 45 से घुमाया जाता है।

— Οसह

Answer 1

अजगर - 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]

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

यह एक जटिल संख्या द्वारा उस गुणा (एक जटिल संख्या का) का उपयोग करता है जो घूर्णन और खींच से मेल खाता है। [1,1+1j,1j,1j-1,-1,-1j-1,-1j,1-1j]आवश्यक कोणों के अनुरूप जटिल संख्याएं हैं और सबसे छोटे स्केलिंग कारक का उपयोग करते हुए ऐसा है कि पूर्णांक जटिल इनपुट के लिए आउटपुट फिर से पूर्णांक जटिल है।

Comments

मैं यह समझने की कोशिश कर रहा हूं कि यह कैसे काम करता है, लेकिन मैं जटिल संख्याओं में खो जाता हूं। क्या मैं स्पष्टीकरण मांग सकता हूं?

— Οसह

@Ourous: x + iy = (x, y) को दें, फिर इसे 1 + i = (1,1) से गुणा करें, आपको 45 डिग्री तक घुमाव मिलता है।

— काइल कानोस

महान समाधान। मैं इसे आउटपुट सूचियों में उपयुक्त पैडिंग सम्मिलित करने के लिए अनुकूलित करने का प्रयास कर रहा हूं, लेकिन इसमें बहुत भाग्य नहीं है। क्या यह एक गैर तुच्छ जोड़ है?

— tkocmathla

@tkocmathla: मैंने यह परीक्षण नहीं किया, लेकिन else: line += [None]अंतिम पंक्ति से चौथे के बाद जोड़ने का प्रयास करें ।

— Wrzlprmft