एक zigzagified मैट्रिक्स का पुनर्निर्माण करें

Question

इसके संपीड़न एल्गोरिदम के हिस्से के रूप में, जेपीईजी मानक एक वेक्टर को वेक्टर में बारी-बारी से दिशा के एंटीडिओगोनल के साथ नियंत्रित करता है:

आपका कार्य मैट्रिक्स आयामों के साथ अनियंत्रित वेक्टर को लेना है और संबंधित मैट्रिक्स को फिर से बनाना है। उदाहरण के तौर पे:

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

उपज चाहिए

[1 2 3 4
 5 6 7 8
 9 1 2 3]

जबकि आयाम 6, 2देंगे

[1 2 6 3 1 2
 5 9 4 7 8 3]

नियम

आप केवल एक आयाम को इनपुट के रूप में लेना चुन सकते हैं। व्यक्तिगत जानकारी किसी भी क्रम में ली जा सकती है। आप मान सकते हैं कि दी गई वेक्टर लंबाई के लिए चौड़ाई और ऊंचाई सकारात्मक और मान्य हैं।

आप मान सकते हैं कि वेक्टर तत्व धनात्मक पूर्णांक से कम हैं 10।

आप STDIN (या निकटतम विकल्प), कमांड-लाइन तर्क या फ़ंक्शन तर्क के माध्यम से इनपुट ले रहे हैं और STDOUT (या निकटतम विकल्प), फ़ंक्शन रिटर्न मान या फ़ंक्शन (आउट) पैरामीटर के माध्यम से परिणाम लिख सकते हैं।

इनपुट वेक्टर किसी भी सुविधाजनक, अस्पष्ट, फ्लैट सूची या स्ट्रिंग प्रारूप में दिया जा सकता है।

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

मानक कोड-गोल्फ नियम लागू होते हैं।

परीक्षण के मामलों

प्रत्येक परीक्षण मामला प्रपत्र का है vector width height => matrix।

[1] 1 1                        => [[1]]
[1 2 3 1] 2 2                  => [[1 2] [3 1]]
[1 2 3 1] 4 1                  => [[1 2 3 1]]
[1 2 5 9 6 3 4 7 1 2 8 3] 3 4  => [[1 2 3] [5 6 4] [9 7 8] [1 2 3]]
[1 2 5 9 6 3 4 7 1 2 8 3] 4 3  => [[1 2 3 4] [5 6 7 8] [9 1 2 3]]
[1 2 5 9 6 3 4 7 1 2 8 3] 6 2  => [[1 2 6 3 1 2] [5 9 4 7 8 3]]
[1 2 5 9 6 3 4 7 1 2 8 3] 12 1 => [[1 2 5 9 6 3 4 7 1 2 8 3]]
[1 2 5 9 6 3 4 7 1 2 8 3] 1 12 => [[1] [2] [5] [9] [6] [3] [4] [7] [1] [2] [8] [3]]

संबंधित चुनौतियां

• Zigzagify एक मैट्रिक्स (कुछ हद तक उलटा परिवर्तन)
• विरोधी विकर्णों को घुमाएं

Answer 1

जेली, 18 13 बाइट्स

pS€żị"¥pỤỤị⁵s

अलग-अलग कमांड-लाइन तर्कों के रूप में पंक्तियों की संख्या, स्तंभों की संख्या और एक फ्लैट सूची लेती है।

मेरा कोड जुड़वां चुनौती में लगभग एक जैसा है । केवल अंतर एक अतिरिक्त हैं Ụ(जो सूचकांकों के क्रमचय को प्रभावित करता है) और s(आउटपुट को 2 डी सरणी में विभाजित करने के लिए)।

इसे ऑनलाइन आज़माएं!

Answer 2

MATL , 29 बाइट्स

:!i:+-1y^8MtsQ/*-X:4#S2$S1GZC

इनपुट है height, width, vectorनई पंक्तियों से अलग कर दिया।

यह संबंधित चुनौती के लिए मेरे जवाब में कोड का हिस्सा पुन: उपयोग करता है ।

इसे ऑनलाइन आज़माएं!

व्याख्या

:!      % take number of rows, r, as input. Generate column vector [1;2;...;r]
i:      % take number of columns, c, as input. Generate row vector [1,2,...,c] 
+       % add with broadcast. Gives 2D array
-1      % push -1
y^      % duplicate previous 2D array. Compute -1 raised to that
8M      % push [1;2;...;r] again
tsQ/    % divide by its sum plus 1
*       % multiply
-       % subtract
X:      % linearize 2D array into column array
4#S     % sort and push the indices of the sorting. Gives a column vector
2$S     % take vector as input. Sort it according to previous column vector
1G      % push r
ZC      % reshape into columns of r elements

Answer 3

जे, 24 बाइट्स

]$({~[:/:@;[:<@|.`</.i.)

इसके अलावा उस चुनौती से /.जे उत्तर में के रूप में zigzagify प्रदर्शन करने के लिए तिरछा क्रिया विशेषण का उपयोग करता है ।

प्रयोग

इनपुट एलएचएस पर सरणी और [height, width]आरएचएस पर आयामों के साथ है ।

   f =: ]$({~[:/:@;[:<@|.`</.i.)
   1 f 1 1
1
   1 2 3 1 f 2 2
1 2
3 1
   1 2 5 9 6 3 4 7 1 2 8 3 f 4 3
1 2 3
5 6 4
9 7 8
1 2 3
   1 2 5 9 6 3 4 7 1 2 8 3 f 3 4
1 2 3 4
5 6 7 8
9 1 2 3
   1 2 5 9 6 3 4 7 1 2 8 3 f 2 6
1 2 6 3 1 2
5 9 4 7 8 3
   1 2 5 9 6 3 4 7 1 2 8 3 f 1 12
1 2 5 9 6 3 4 7 1 2 8 3
   1 2 5 9 6 3 4 7 1 2 8 3 f 12 1
1
2
5
9
6
3
4
7
1
2
8
3

व्याख्या

]$({~[:/:@;[:<@|.`</.i.)  Input: list A (LHS), dimensions D (RHS)
                     i.   Range shaped to D
           [:<@|.`</.     Zigzagify that matrix
     [:   ;               Raze the boxes to get a zigzagify permutation
       /:@                Invert that permutation to get an unzigzagify permutation
   {~                     Apply that permutation to A
]                         Get D
 $                        Shape that permutation to D and return