एक 2 डी मैट्रिक्स घूर्णन

Question

मान लें कि मेरे पास निम्नलिखित (2D) मैट्रिक्स हैं:

[[1,  2,  3,  4 ],
 [5,  6,  7,  8 ],
 [9,  10, 11, 12],
 [13, 14, 15, 16]]

मैट्रिक्स वामावर्त R बार घुमाएं (90 डिग्री वेतन वृद्धि में नहीं, बस हर बार 1 नंबर से),

1  2  3  4             2 3   4  8         3   4   8  12
5  6  7  8    -->      1 7  11 12   -->   2  11  10  16 
9  10 11 12            5 6  10 16         1   7   6  15 
13 14 15 16            9 13 14 15         5   9  13  14

पूरा उदाहरण:

इनपुट:

2
[[1,  2,  3,  4 ],
 [5,  6,  7,  8 ],
 [9,  10, 11, 12],
 [13, 14, 15, 16]]

आउटपुट:

[[3,  4,  8, 12],
 [2, 11, 10, 16],
 [1,  7,  6, 15],
 [5,  9, 13, 14]]

(अजीब रिक्त स्थान अच्छे कॉलम में संख्याओं को संरेखित करने के लिए हैं)

मैट्रिक्स का बाहरी "रिंग" 2 वामावर्त घुमाता है, और आंतरिक दाएं 2 भी घूमता है। इस मैट्रिक्स में, केवल दो रिंग होते हैं।

1 "रिंग" के साथ एक उदाहरण:

2
[[1, 2],
 [3, 4],
 [5, 6]]

उत्पादन करना चाहिए:

[[4, 6],
 [2, 5],
 [1, 3]]

आपकी चुनौती एक मैट्रिक्स और एक पूर्णांक में लेना है R, और Rघूर्णन के बाद अनुवादित संस्करण को आउटपुट करना है ।

4x5 मैट्रिक्स का रोटेशन निम्नलिखित आकृति द्वारा दर्शाया गया है:

प्रतिबंध:

• 2 ≤ M, N ≤ 100, जहां M और N मैट्रिक्स के आयाम हैं। यह गारंटी है कि एम और एन का न्यूनतम भी होगा।
• 1 ≤ R ≤ 80, जहां r रोटेशन की संख्या है।
• मैट्रिक्स में केवल धनात्मक पूर्णांक होंगे।
• मान हमेशा अलग नहीं होते हैं।
• इनपुट हमेशा 2 डी सरणी के रूप में होना चाहिए (यदि आप रनवे इनपुट को 2 डी सरणी के रूप में नहीं ले सकते हैं, तो आपको बस इनपुट प्राप्त करने का दूसरा तरीका खोजना होगा)।

गैर-विशिष्ट मूल्यों के साथ एक और परीक्षण मामला:

1
[[1, 1],
 [2, 2],
 [3, 3]]

आउटपुट:

[[1, 2],
 [1, 3],
 [2, 3]]

यह कोड-गोल्फ है , इसलिए सबसे छोटा उत्तर जीतता है!

Comments

सम्बंधित

— पीटर टेलर

सम्बंधित।

— मार्टिन एंडर

सम्बंधित।

— को बंद करना

@ceasedtoturncounterclockwis इस चुनौती के लिए आपका नाम बहुत ही विडंबनापूर्ण है ...

— HyperNeutrino

[[3, 4, 8, 12], [2, 11, 10, 16], [1, 7, 6, 16], [5, 9, 13, 14]]16 अचानक नकल है मुझे लगता है कि यह होना चाहिए [[3, 4, 8, 12], [2, 11, 10, 16], [1, 7, 6, 15], [5, 9, 13, 14]]:?

— क्रिस्टोफ़

Answer 1

जेली , 39 38 36 35 बाइट्स

ḢṚ;Ḣ€;Ṫ;Ṫ€Ṛ$,-ṙ\;"ß¹¡
FJ©ṁ¹Çy®ịFṁµ¡

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

Answer 2

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

function M=F(M,R);f=@(z)[-z/2:-1 !eye(!!mod(z,2)) 1:z/2];t=angle(f([x y]=size(M))'+f(y)*i);B=!!M;B(2:x-1,2:y-1)=0;d=bwdist(B,'ch');[~,I]=sortrows([d(:) t(:)]);for k=0:max(d(:));M(h)=shift(M(h=I(d(I)==k)),R);end

यह ऑक्टेव ऑनलाइन पर कोशिश करो!

Ungolfed संस्करण:

function M=F(M,R)
    [x y]=size(M);
    f=@(z)[-z/2:-1 !eye(!!mod(z,2)) 1:z/2];
    t=angle(f(x)'+f(y)*i);
    B=!!M;
    B(2:x-1,2:y-1)=0;
    d=bwdist(B,'chessboard');
    [~,I]=sortrows([d(:) t(:)]);
    for k=0:max(d(:))
        M(h)=shift(M(h=I(d(I)==k)),R);
    end
end
R=2;
M=randi(10,4,7)
F(M,R)

स्पष्टीकरण:

f=@(z)[-z/2:-1 !eye(!!mod(z,2)) 1:z/2]; 

एक फ़ंक्शन जो एक संख्या प्राप्त करता है और एक सीमा उत्पन्न करता है जिसे इनपुट 4 के लिए आदेश दिया जाता है और केंद्रित किया जाता है (यहां तक ​​कि) -2 -1 1 2
इनपुट 5 (विषम) के लिए उत्पन्न होता है-2.5 -1.5 0 1 2
केवल वह जिसे आदेश दिया जाना चाहिए और केंद्रित होना चाहिए

f(x)'+f(y)*i    

श्रेणियों से उत्पन्न एक जटिल मैट्रिक्स

(-2,-2.5) (-2,-1.5) (-2,0) (-2,1) (-2,2)
(-1,-2.5) (-1,-1.5) (-1,0) (-1,1) (-1,2)
(1,-2.5)  (1,-1.5)  (1,0)  (1,1)  (1,2)
(2,-2.5)  (2,-1.5)  (2,0)  (2,1)  (2,2)

t=angle(f(x)'+f(y)*i);                    

आयताकार को ध्रुवीय निर्देशांक में बदलें और कोणों को लौटाएं ताकि प्रत्येक अंगूठी कोणों के लिए उलटी गिनती की तरह छंटनी हो

-2.25  -2.50  3.14  2.68  2.36
-1.95  -2.16  3.14  2.36  2.03
-1.19  -0.98  0.00  0.79  1.11
-0.90  -0.64  0.00  0.46  0.79


B=!!M;
B(2:x-1,2:y-1)=0;

निम्नलिखित मैट्रिक्स उत्पन्न हुआ

1   1   1   1   1
1   0   0   0   1
1   0   0   0   1
1   1   1   1   1

d=bwdist(B,'chessboard');

रिंग सूचक उत्पन्न करने के लिए शतरंज की दूरी का उपयोग करके बी के दूरी परिवर्तन की गणना करता है

0   0   0   0   0
0   1   1   1   0
0   1   1   1   0
0   0   0   0   0               

6 * 7 मैट्रिक्स के लिए हमारे पास निम्नलिखित मैट्रिक्स होंगे

0   0   0   0   0   0   0
0   1   1   1   1   1   0
0   1   2   2   2   1   0
0   1   2   2   2   1   0
0   1   1   1   1   1   0
0   0   0   0   0   0   0   

[~,I]=sortrows([d(:) t(:)]);

लेक्सोग्राफिक सॉर्ट पहले रिंग इंडेक्स पर आधारित होता है और फिर एंगल के क्रम से (छंटे हुए तत्वों के सूचक)

    for k=0:max(d(:))
        M(h)=shift(M(h=I(d(I)==k)),R);
    end

और अंत में प्रत्येक रिंग को गोलाकार करें।

Answer 3

पायथन 3, 292 288 बाइट्स

_=eval
a=input().split()
b,a=int(a[0]),_("".join(a[1:]))[::-1]
c=len(a)
d=len(a[0])
e=range
f="int((i>=j and i+j<c-1)|2*(i>=c/2and i+d>j+c)|3*(i<c/2and i+j<d))"
l=[-1,1,0,0],[0,0,1,-1]
g=lambda x:[[x[i+l[0][_(f)]][j+l[1][_(f)]]for j in e(d)]for i in e(c)]
print(_("g("*b+"a"+")"*b)[::-1])

हटाए गए नए लिंक के साथ इनपुट लेता है, लेकिन इसे बढ़ाने के लिए वेतन वृद्धि की संख्या के बाद एक स्थान छोड़ देता है।

स्पष्टीकरण:

मैट्रिक्स को ओपी के सुझाव के अनुसार गाढ़ा छल्ले की एक श्रृंखला के रूप में मॉडलिंग करने के बजाय, एक को चार क्षेत्रों में विभाजित किया जा सकता है जहां तत्व एक रोटेशन के दौरान ऊपर, नीचे, दाएं, या बाएं जाते हैं। यह लंबे ईगल-एड स्ट्रिंग का उद्देश्य है f: यह निर्धारित करने के लिए कि प्रत्येक i,jसंयोजन किस क्षेत्र में आता है। फिर, उस परिणाम को दो बार देखा जाता है l, जिससे उस तत्व i,jको अगले चरण में स्थिति में घुमाया जाना चाहिए । कार्यक्रमg जो यह सब करता है और एक एकल चरण के बाद नए मैट्रिक्स का निर्माण करता है, फिर एक नेस्टेड फ़ंक्शन कॉल के प्रतिनिधित्व वाले उत्पन्न स्ट्रिंग को खाली करके बार-बार कहा जाता है।

जब मैंने इसे मूल रूप से बनाया था, तो मैंने गलती से मैट्रिक्स को वामावर्त के बजाय घड़ी की दिशा में घुमाया। एक उचित निर्धारण करने के बजाय, मैंने [::-1]रोटेशन से पहले और बाद में मैट्रिक्स को उलटने के लिए रणनीतिक रूप से रखी गई दो प्रतियों को जोड़ा । ये संभवत: ~ 280 276 बाइट्स के लिए बंद हो सकते हैं , लेकिन मैं ऐसा करने के लिए बहुत आलसी हूं।

इसके अलावा, यह थोड़ी देर के पायथन 2 कार्यक्रम से एक त्वरित अप्रयुक्त बंदरगाह है, इसलिए मुझे माफ कर दें अगर यह काफी सही काम नहीं करता है। यहाँ पायथन 2 कोड है, वैसे भी:

_=eval
a=raw_input().split()
b,a=int(a[0]),_("".join(a[1:]))[::-1]
c=len(a)
d=len(a[0])
e=xrange
f="int((i>=j and i+j<c-1)|2*(i>=c/2and i+d>j+c)|3*(i<c/2and i+j<d))"
l=[-1,1,0,0],[0,0,1,-1]
g=lambda x:[[x[i+l[0][_(f)]][j+l[1][_(f)]]for j in e(d)]for i in e(c)]
print _("g("*b+"a"+")"*b)[::-1]

संपादित करें: दो बार के orसाथ प्रतिस्थापित करके 4 बाइट्स से बाहर निकले |। andमदद नहीं की जा सकती, दुर्भाग्य से।

Comments

PPCG में आपका स्वागत है! अच्छी पहली पोस्ट!

— हाइपरनेत्रिनो

मजेदार कहानी वास्तव में - मेरे हाई स्कूल मार्चिंग बैंड में आज हमने एक फॉर्मेशन सीखा है जहाँ हर कोई इस प्रश्न के समान संकेंद्रित आयताकार "रिंग" में घूमता है, और मैंने तुरंत इस उत्तर के बारे में सोचा।

— ऐडन एफ। पियर्स

Answer 4

पर्ल, 330 328 बाइट्स

sub f{($r,$m)=@_;$h=@m=@$m;for$s(0..(($w=$#{$m[0]})<--$h?$w:$h)/2-.5){@_=(@{$m[$s]}[@x=$s..($x=$w-$s)],(map$m[$_][$x],@y=1+$s..($y=$h-$s)-1),reverse(@{$m[$y]}[@x]),(map$m[$h-$_][$s],@y));push@_,shift
for 1..$r;@{$m[$s]}[@x]=map shift,@x;$m[$_][$x]=shift for@y;@{$m[$y]}[@x]=reverse map shift,@x;$m[$h-$_][$s]=shift for@y}@$m=@m}

Ideone पर इसे आज़माएं ।

Ungolfed:

sub f {
    my ($r, $m) = @_;

    my @m = @$m;
    my $h = $#m;
    my $w = @{$m[0]} - 1;
    my $c = (($w < $h ? $w : $h) + 1) / 2 - 1;

    for my $s (0 .. $c) {
        my $x = $w - $s;
        my $y = $h - $s;
        my @x = $s .. $x;
        my @y = $s + 1 .. $y - 1;

        # One circle.
        @_ = (@{$m[$s]}[@x],
              (map { $m[$_][$x] } @y),
              reverse(@{$m[$y]}[@x]),
              (map { $m[$h - $_][$s] } @y));

        # Circular shift.
        push(@_, shift(@_)) for 1 .. $r;

        @{$m[$s]}[@x] = map { shift(@_) } @x;
        $m[$_][$x] = shift(@_) for @y;
        @{$m[$y]}[@x] = reverse(map { shift(@_) } @x);
        $m[$h - $_][$s] = shift(@_) for @y;
    }

    @$m = @m;
}