एंटी-विकर्णों को घुमाएं

32

पृष्ठभूमि

अधिकांश उचित प्रोग्रामिंग भाषाओं में, 2D सरणी की पंक्तियों या स्तंभों को घुमाना बहुत आसान है। इस चुनौती में, आपका कार्य इसके बजाय विरोधी विकर्णों को घुमाना है । याद रखें कि एक 2D सरणी के विरोधी विकर्ण उत्तर पूर्व दिशा में लिए गए 1D स्लाइस हैं।

इनपुट

किसी भी उचित प्रारूप में एकल-अंकीय संख्याओं का एक गैर-खाली आयताकार 2D सरणी। ध्यान दें कि सरणी एक वर्ग नहीं हो सकती है।

उत्पादन

एक ही सरणी, लेकिन प्रत्येक विरोधी-विकर्ण के साथ दाईं ओर एक कदम घुमाया गया।

उदाहरण

3x4इनपुट सरणी पर विचार करें

0 1 2 3
4 5 6 7
8 9 0 1

इस सरणी के विरोधी विकर्ण हैं

0
4 1
8 5 2
9 6 3
0 7
1

उनके घुमाए गए संस्करण हैं

0
1 4
2 8 5
3 9 6
7 0
1

इस प्रकार सही आउटपुट है

0 4 5 6
1 8 9 0
2 3 7 1

नियम और स्कोरिंग

आप एक पूर्ण कार्यक्रम या एक फ़ंक्शन लिख सकते हैं। यह एक फ़ंक्शन लिखने के लिए भी स्वीकार्य है जो इनपुट सरणी को संशोधित करता है, अगर आपकी भाषा इसकी अनुमति देती है। सबसे कम बाइट गिनती जीतता है, और मानक खामियों को रोक दिया जाता है।

लीडरबोर्ड

यहां एक नियमित लीडरबोर्ड और भाषा के अनुसार विजेताओं का अवलोकन करने के लिए एक स्टैक स्निपेट है।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिख रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

## Language Name, N bytes

Nआपके सबमिशन का आकार कहां है। यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फाइलों का योग है, या आप इंटरप्रेटर फ्लैग पेनल्टीज़ को अलग से सूचीबद्ध करना चाहते हैं, या आप पुराने अंकों को दिखाना चाहते हैं जो आपने सुधार किए हैं), सुनिश्चित करें कि वास्तविक स्कोर है पिछले शीर्षक में संख्या।

कोड स्निपेट दिखाएं

अतिरिक्त परीक्षण के मामले

Input:
4
Output:
4

Input:
5 6 1
Output:
5 6 1

Input:
0 1
6 2
Output:
0 6
1 2

Input:
6 3 0 8
4 6 1 4
6 2 3 3
9 3 0 3
Output:
6 4 6 1
3 6 2 3
0 9 3 0
8 4 3 3

Input:
5 8 2
6 7 3
2 6 1
6 0 6
6 4 1
Output:
5 6 7
8 2 6
2 6 0
3 6 4
1 6 1

Input:
9 9 4 0 6 2
2 3 2 6 4 7
1 5 9 3 1 5
0 2 6 0 4 7
Output:
9 2 3 2 6 4
9 1 5 9 3 1
4 0 2 6 0 4
0 6 2 7 5 7
code-golf  array-manipulation 
— Zgarb
स्रोत

जवाबों:

20

सीजेम, 20

{z_)\zLa+(@+\.+s\,/}

फ़ंक्शन ब्लॉक के रूप में लिखा गया है। इसे ऑनलाइन आज़माएं

स्पष्टीकरण:

इनपुट को इस तरह देखा जा सकता है:

इनपुट आरेख

यही है, हम शीर्ष पंक्ति और दाएं कॉलम को बाकी मैट्रिक्स से अलग करते हैं, और तीर द्वारा दिखाए गए क्रम में उन तत्वों पर विचार करते हैं।

फिर आउटपुट इस तरह है:

आउटपुट आरेख

शेष आयताकार ब्लॉक को एक पूरे के रूप में तिरछे ले जाया जाता है, और किनारे के तत्वों को नए तीर द्वारा दिखाए गए क्रम / पदों में फिर से व्यवस्थित किया जाता है।

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

z      zip (transpose) the matrix
_      make a copy
)      take out the last row (right column before transposing)
\      swap with the rest of the matrix
z      transpose back
La+    append an empty row (needed for the single-column case,
        which leaves an empty matrix here)
(      take out the first row (top row without the corner)
@+     bring the right column to the top of the stack and concatenate
        obtaining an array of the edge elements (marked with the blue arrow)
\      swap with the remaining part (big white block in the diagrams)
.+     concatenate element by element
        each edge element is concatenated with a row of the white block
        after the white block runs out, the remaining elements form new rows
s      convert the whole thing to a string (concatenating all rows)
\      swap with the copy of the transposed matrix
,      get its length (number of original columns)
/      split the string into rows of that length
— aditsu
स्रोत
पायथ का उत्तर भी 20 बाइट्स है, लेकिन आपका पहले था, इसलिए मैं इसे स्वीकार कर रहा हूं।
— जर्गर्ब
9

CJam, 44 43 42 40 बाइट्स

qN/:ReeSf.*:sz1fm<{Rz,{(S-(o\}*~]{},No}h

इसका परीक्षण यहां करें।

हम्म, मेरे पहले प्रयास की तुलना में बहुत बेहतर है, लेकिन मुझे लगता है कि डेनिस इसे वैसे भी बहुत कम हल करेगा ...

इनपुट और आउटपुट ASCII ग्रिड के रूप में हैं:

0123
4567
8901

देता है

0456
1890
2371
— मार्टिन एंडर
स्रोत
7
— AdmBorkBork
3
@ टिम्मीड को ४my राइट डाउन से ४३ तक इसे संपादित करने के लिए ग्रेस पीरियड के अंत तक इंतजार करना चाहिए था।: पी
— मार्टिन एंडर
हाँ! यह एक मेम बन गया है ।
— intrepidcoder
1
मैं पूरी तरह से चला गया और एक गोल्फ भाषा सीख गया, ताकि मैं 4 बाइट्स 3 से गोल्फ कर
— सकूं
6

जे, 24 चार

एक तर्क लेने का कार्य।

$$<@(1&|.)/./:&;</.@i.@$

J का एक ऑपरेटर है /.जिसका नाम Oblique है । यह इसे उल्टा नहीं कर सकता है, इसलिए पुनर्निर्माण तुच्छ नहीं है, लेकिन आप सरणी के तत्वों के क्रमपरिवर्तन के रूप में "लिस्टिंग ऑब्ज़र्क्स" पर विचार कर सकते हैं। इसलिए हम उस क्रमांकन को /:(डाइएडिक सॉर्ट के साथ ), उस आकार ( </.@i.@$) के लिए "लिस्टिंग तिरछे" क्रमोन्नति को दाईं ओर और हमारे नए तिरछे मानों, बाईं ओर ठीक से घुमाए जाने के साथ, क्रमपरिवर्तन करते हैं । फिर हम अच्छे पुराने का उपयोग करते हुए इस सूची को पुराने आयताकार सरणी में बदलते हैं $$।

   3 4$i.10
0 1 2 3
4 5 6 7
8 9 0 1
   ($$<@(1&|.)/./:&;</.@i.@$) 3 4$i.10
0 4 5 6
1 8 9 0
2 3 7 1

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

— algorithmshark
स्रोत
यहीं पीक जे है। बहुत बढ़िया।
— योना
5

जे, 38 30 बाइट्स

8 बाइट्स @algorithmshark की बदौलत बच गईं।

{./.((}.~#),~({.~#),.])}:"1@}.

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

उपयोग:

   ]input=.0 1 2 3, 4 5 6 7,: 8 9 0 1
0 1 2 3
4 5 6 7
8 9 0 1
   ({./.((}.~#),~({.~#),.])}:"1@}.) input
0 4 5 6
1 8 9 0
2 3 7 1

इसे यहाँ ऑनलाइन आज़माएँ।

— randomra
स्रोत
1
डाउन टू 30 चार: {./.रिप्लेस }:@{.,{:"1, और आप ट्रेन को इधर-उधर करके दो टिल बचा सकते हैं {./.((}.~#),~({.~#),.])}:"1@}.:।
— एल्गोरिथमशार्क
4

जूलिया, 153 149 139 बाइट्स

A->(length(A)>1&&((m,n)=size(A);r(X)=for i=1:n X[:,i]=reverse(X[:,i])end;r(A);for i=-m:m A[diagind(A,i)]=circshift(diag(A,i),1)end;r(A));A)

यह एक अनाम फ़ंक्शन बनाता है जो किसी सरणी को स्वीकार करता है और जगह में संशोधित इनपुट सरणी देता है।

Ungolfed:

# Create a function to reverse the columns of a matrix
function revcols!(X)
    for = 1:size(X, 2)
        X[:,i] = reverse(X[:,i])
    end
    return X
end

# Our main function
function zgarb!(A)
    # Only perform operations if the array isn't one element
    if length(A) > 1
        # Record the number of rows
        m = size(A, 1)

        # Reverse the columns in place
        revcols!(A)

        # Shift each diagonal
        for i = -m:m
            A[diagind(A, i)] = circshift(diag(A, i), 1)
        end

        # Reverse the columns back
        revcols!(A)
    end
    return A
end

एल्गोरिथ्म सलाह के लिए और 4 बाइट बचाने के लिए मार्टिन ब्यूटनर को धन्यवाद!

— एलेक्स ए।
स्रोत
3

ईएस 6, 75 बाइट्स

यह एक सरणी के एक सरणी को एक पैरामीटर के रूप में स्वीकार करता है और इसे जगह में संशोधित करता है।

a=>{t=a.shift();a.map(r=>{t.push(r.pop());r.unshift(t.shift())});a.push(t)}

Ungolfed:

function anti_diagonal(array) {
    var temp = array.shift(); // strip off the first row
    array.forEach(row => temp.push(row.pop())); // strip off the last elements of each row
    array.forEach(row => row.unshift(temp.shift())); // distribute the elements to the beginning of each row
    array.push(temp); // the remaining elements become the last row
}

आगे के स्पष्टीकरण के लिए @ aditsu का आरेख देखें।

— नील
स्रोत
आप बदल {t.push(r.pop());r.unshift(t.shift())}कर 2 बाइट्स बचा सकते हैंt.push(r.pop())+r.unshift(t.shift())
— user81655
3

अजगर, 20 बाइट्स

J+PhQ.)MQ++L.(J0tQ]J

शीर्ष पंक्ति और दाहिने स्तंभ को हटाने के लिए एडिस्टू के दृष्टिकोण का उपयोग करता है, फिर उन्हें बाईं और नीचे की तरफ चिपका देता है। लेकिन परिवर्तनशील डेटा संरचनाओं के साथ, ट्रांसपोज़िशन नहीं।

— isaacg
स्रोत
2

ऑक्टेव, 85 बाइट्स

@(a)[(b=[a(1,1:end),a(2:end,end)'])(1:(s=size(a)(1)))',[a(2:end,1:end-1);b(s+1:end)]]

मुझे आशा है कि मैं endएस से छुटकारा पा सकता हूं ।

— alephalpha
स्रोत
1

पायथन 2 , 113 104 94 बाइट्स

f=lambda i,b=[]:i and[b and b[:1]+i[0][:-1]]+f(i[1:],b[1:]or i[0][:-1]+[l[-1]for l in i])or[b]

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

यह @ aditsu की विधि की काफी शाब्दिक व्याख्या है। खाली सूचियों को गलत मानने के लिए पायथन के वाक्य विन्यास ने अतिरिक्त 10 बाइट्स को बचाने में मदद की।

— SmileAndNod
स्रोत
मैंने पंक्तियों को छोड़ कर 8 बाइट्स बचाए
— SmileAndNod
— स्माइलएंडनॉड
1
आप शायद जरूरत नहीं है 0में[0:1]
— जो राजा
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.