मैट्रिक्स बवंडर से सावधान रहें!

Question

मैट्रिक्स बवंडर किसी भी अन्य बवंडर की तरह है: इसमें एक केंद्र के चारों ओर घूमने वाली चीजें होती हैं। इस मामले में, हवा के बजाय मैट्रिक्स के तत्व।

यहाँ एक मैट्रिक्स बवंडर का एक उदाहरण दिया गया है:

पहले हम मैट्रिक्स को वर्ग के छल्ले में विभाजित करके शुरू करते हैं, प्रत्येक अनुभाग में ऐसे तत्व शामिल होते हैं जो समान दूरी से सीमा से दूर होते हैं। इन वर्गों को केंद्र के चारों ओर दक्षिणावर्त घुमाया जाएगा। वास्तविक बवंडर में, केंद्र की ओर गंभीरता बढ़ जाती है, और इसी तरह एक मैट्रिक्स बवंडर में रोटेशन कदम होता है: सबसे बाहरी खंड (लाल एक) को 1 कदम से घुमाया जाता है, अगले (पीला) एक को 2 से घुमाया जाता है, और इसी तरह पर। एक रोटेशन कदम केंद्र के चारों ओर एक 90 ° रोटेशन है।

कार्य:

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

इनपुट:

इनपुट आदेश का एक वर्ग मैट्रिक्स होना चाहिए nजहां n >= 1। मैट्रिक्स के तत्वों के बारे में कोई धारणा नहीं बनाई जानी है, वे कुछ भी हो सकते हैं।

आउटपुट:

उसी क्रम का एक वर्ग मैट्रिक्स जो इनपुट मैट्रिक्स में ट्रोनैडो प्रभाव को लागू करने का परिणाम होगा।

उदाहरण:

आदेश का एक मैट्रिक्स n = 1:

[['Hello']]               ===>    [['Hello']]

आदेश का एक मैट्रिक्स n = 2:

[[1 , 2],                 ===>    [[5 , 1],
 [5 , 0]]                          [0 , 2]]

आदेश का एक मैट्रिक्स n = 5:

[[A , B , C , D , E],             [[+ , 6 , 1 , F , A],
 [F , G , H , I , J],              [- , 9 , 8 , 7 , B],
 [1 , 2 , 3 , 4 , 5],     ===>     [/ , 4 , 3 , 2 , C],
 [6 , 7 , 8 , 9 , 0],              [* , I , H , G , D],
 [+ , - , / , * , %]]              [% , 0 , 5 , J , E]]

Comments

मुझे लगता है कि आप स्पष्ट करना चाहते हैं कि घुमाव 90 ° घुमाव हैं।

— 23:31 पर आउटगोल्फर जूल

साथ ही, क्या आपने यह चुनौती कहीं और से ली है? यदि हां, तो आपको अटेंशन देना होगा।

— निकले आउटगॉल्फ

@EriktheOutgolfer 1) मैंने स्पष्ट किया है कि। 2) यह चुनौती मेरी है।

— इब्राहिम माहिर

@Giuseppe निर्भर करता है कि आप किस गोलार्ध में हैं;)

— Jo King

पहले मैं कहना चाहता हूं कि मुझे लगता है कि यह एक अच्छी चुनौती है: अच्छा काम! लेकिन मैं इस बिंदु को भी प्लग करना चाहूंगा क्योंकि मुझे लगता है कि आपकी पसंद यह कहना है कि यह किसी भी प्रकार का डेटा हो सकता है जो आपकी चुनौती को एक अजीब जगह पर छोड़ देता है। इसी तरह इनपुट के बारे में आपके बयान के साथ सूचियों की सूची है, आपने उन भाषाओं को प्रतिबंधित कर दिया है जो कुछ हद तक ओवरहेड काम किए बिना इस समस्या को हल कर सकते हैं। मुझे लगता है कि इन आवश्यकताओं को शिथिल किया जाए तो चुनौती बेहतर है। मुझे आशा है कि आप इस तरह की अच्छी चुनौतियाँ पोस्ट करते रहेंगे! :)

— FryAmTheEggman

Answer 1

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

import numpy
def f(a):
 if len(a): a=numpy.rot90(a,axes=(1,0));a[1:-1,1:-1]=f(a[1:-1,1:-1]);return a

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

Comments

क्लासिक पायथन, जैसे a[1:-1,1:-1]=f(a[1:-1,1:-1])कि यह दुनिया में सबसे सामान्य बात है सीधे सीधे पाने के लिए और एक 2-आयामी सरणी के पूरे सेट

— ETHproductions

@ETHproductions उचित होने के लिए, इसका भाग वाक्यविन्यास से विरासत में मिला हैnumpy

— जो किंग

numpy.rot90(a,1,(1,0))3 बाइट्स से छोटा है और इसे काम भी करना चाहिए।

— ग्रिफ़र

बिना किसी परीक्षण मामलों के TIO- लिंक का क्या मतलब है? ..: S यह साथ है ( if len(a):a=...-1 बाइट पर स्थान गिराया गया है )।

— केविन क्रूज़सेन

Answer 2

चारकोल , 44 बाइट्स

≔ＥθＳθＷθ«≔Ｅθ⮌⭆觧θνλθθＭ¹⁻¹Ｌθ≔Ｅ✂θ¹±¹¦¹✂κ¹±¹¦¹θ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। केवल चरित्र वर्ग पर काम करता है क्योंकि चारकोल का डिफ़ॉल्ट I / O सामान्य सरण न्याय नहीं करता है। स्पष्टीकरण:

≔ＥθＳθ

चरित्र वर्ग पढ़ें।

Ｗθ«

खाली होने तक लूप करें।

≔Ｅθ⮌⭆觧θνλθ

इसको घुमाओ।

θＭ¹⁻¹Ｌθ

इसे प्रिंट करें, लेकिन फिर कर्सर को मूल कोने से तिरछे एक वर्ग में ले जाएं।

≔Ｅ✂θ¹±¹¦¹✂κ¹±¹¦¹θ

सरणी से बाहर ट्रिम करें।

Answer 3

जेली , 27 बाइट्स

J«þ`UṚ«Ɗ‘ịZU$LСŒĖḢŒHEƊƇṁµG

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

मुझे लगता है कि यह बहुत कम हो सकता है।

           Input: n×n matrix A.
J          Get [1..n].
 «þ`       Table of min(x, y).
    UṚ«Ɗ   min with its 180° rotation.

Now we have a matrix like: 1 1 1 1 1
                           1 2 2 2 1
                           1 2 3 2 1
                           1 2 2 2 1
                           1 1 1 1 1

‘ị          Increment all, and use as indices into...
     LС    List of [A, f(A), f(f(A)), …, f^n(A)]
  ZU$       where f = rotate 90°

Now we have a 4D array (a 2D array of 2D arrays).
We wish to extract the [i,j]th element from the [i,j]th array.

ŒĖ     Multidimensional enumerate

This gives us: [[[1,1,1,1],X],
                [[1,1,1,2],Y],
                ...,
                [[n,n,n,n],Z]]

ḢŒHEƊƇ     Keep elements whose Ḣead (the index) split into equal halves (ŒH)
           has the halves Equal to one another. i.e. indices of form [i,j,i,j]
           (Also, the head is POPPED from each pair, so now only [X] [Y] etc remain.)

ṁµG        Shape this like the input and format it in a grid.

Comments

आप संभवतः केवल µGपाद लेख में रख सकते हैं और दावा कर सकते हैं कि आपका सबमिशन 25 है।

— श्री एक्सकोडर

Answer 4

पर्ल 6 , 78 73 72 बाइट्स

-5 बाइट्स के लिए nwellnhof के लिए धन्यवाद!

$!={my@a;{(@a=[RZ] rotor @_: sqrt @_)[1..*-2;1..@a-2].=$!}if @_;@a[*;*]}

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

पुनरावर्ती कोड ब्लॉक जो एक चपटा 2D सरणी लेता है और समान रूप से चपटा सरणी देता है।

स्पष्टीकरण:

$!={      # Assign code block to pre-declared variable $!
    my@a; # Create local array variable a
   {
     (@a=[RZ]  # Transpose:
             rotor @_: sqrt @_;  # The input array converted to a square matrix
     )[1..*-2;1..@a-2].=$!  # And recursively call the function on the inside of the array
   }if @_;    # But only do all this if the input matrix is not empty
   @a[*;*]  # Return the flattened array
}

Comments

आप सरणी को समतल करने के @a[*;*]बजाय उपयोग कर सकते हैं map |*,@a। (यह अच्छा होगा अगर वहाँ unflattened सरणियों और बहु-आयाम सदस्यता के साथ काम करने का एक तरीका था, लेकिन मैं एक के बारे में सोचता हूं।)

— nwellnhof

लेकिन @a[1..*-2;1..@a-2].=$!काम करता है।

— nwellnhof

Answer 5

ऑक्टेव , 86 81 बाइट्स

f(f=@(g)@(M,v=length(M))rot90({@(){M(z,z)=g(g)(M(z=2:v-1,z)),M}{2},M}{1+~v}(),3))

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

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

व्याख्या

पुनरावर्ती फ़ंक्शन को सीलिंगकैट द्वारा इस युक्तियों के उत्तर के अनुसार परिभाषित किया गया है । पुनरावर्ती कॉल के q=f(f=@(g)@(M) ... g(g)(M) ...साथ g(g)(M)इस तरह के एक अनाम समारोह की बुनियादी संरचना है । चूंकि यह अनिश्चित काल के लिए फिर से शुरू हो जाएगा, इसलिए हम पुनरावर्ती कॉल को एक सशर्त कोशिका सरणी में लपेटते हैं {@()g(g)(M),M}{condition}():। खाली तर्क सूची के साथ अनाम फ़ंक्शन मूल्यांकन में देरी के बाद हालत का चयन किया गया है (हालांकि बाद में, हम देखते हैं कि हम उस तर्क सूची को परिभाषित करने के लिए उपयोग कर सकते हैं z)। अभी तक यह सिर्फ बुनियादी बहीखाता है।

अब वास्तविक कार्य के लिए। हम चाहते हैं कि फ़ंक्शन rot90(P,-1)पी के साथ वापस आ जाए , एक मैट्रिक्स जिस g(g)पर एम के मध्य भाग पर पुनरावर्ती रूप से कॉल किया गया है। हम सेटिंग से शुरू z=2:end-1करते हैं जिसे हम एम के अनुक्रमण में छिपा सकते हैं। इस तरह M(z,z)से मैट्रिक्स के मध्य भाग का चयन करना होगा एक पुनरावर्ती कॉल के द्वारा आगे बवंडर हो। ,3हिस्सा सुनिश्चित करता है कि रोटेशन दक्षिणावर्त कर रहे हैं। यदि आप दक्षिणी गोलार्ध में रहते हैं, तो आप -2 बाइट्स के लिए इस बिट को हटा सकते हैं।

हम तो करते हैं M(z,z)=g(g)M(z,z)। हालाँकि, इस ऑपरेशन का परिणाम मान पूरे Pमैट्रिक्स के बजाय केवल संशोधित केंद्रीय भाग है । इसलिए, हम करते हैं {M(z,z)=g(g)M(z,z),M}{2}जो मूल रूप से चुरायी गयी है इस सुझाव के Stewie ग्रिफिन द्वारा जवाब।

अंत में, conditionबस यह है कि इनपुट खाली होने पर पुनरावृत्ति रुक ​​जाती है।

Comments

दक्षिणी गोलार्ध के लिए +1

— छत

मैंने अभी तक अनाम कार्यों में अपने सिर को चारों ओर लपेटने की कोशिश नहीं की है, इसलिए मैं इसे एक प्रयास नहीं दूंगा, लेकिन मैं यह देखने के लिए उत्सुक हूं कि क्या पुनरावृत्ति इस एक में छोरों से कम है ।

— स्टीवी ग्रिफिन

@StewieGriffin मैं देख सकता हूँ कि मैं क्या कर सकता हूँ :)

— सैनचाइज़

@StewieGriffin वैसे, ऑक्टेव में इस चुनौती के लिए एक लूप-आधारित संस्करण पोस्ट करने के लिए चुनौती दी है। मैं वास्तव में आश्चर्य करता हूं कि क्या आप पुनरावर्ती दृष्टिकोण को हरा सकते हैं।

— 14

Answer 6

आर , 87 बाइट्स

function(m,n=nrow(m)){for(i in seq(l=n%/%2))m[j,j]=t(apply(m[j<-i:(n-i+1),j],2,rev));m}

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

• रोटेशन कोड के लिए इस StackOverFlow जवाब का श्रेय

Comments

उदाहरण के रूप में विपरीत दिशा में घूमते हुए 84 बाइट्स

— Giuseppe

क्या इसकी अनुमति है? छवि एक दक्षिणावर्त तीर दिखाती है और नीचे दिए गए विवरण में दक्षिणावर्त रोटेशन कहा गया है ...

— digEmAll

मैंने प्रश्न को दस बार पढ़ा होगा और इस पर कभी ध्यान नहीं दिया होगा (इसलिए मेरी टिप्पणी)। अफसोस।

— Giuseppe

एह, इसके बारे में बताइए ... मैं गलत पोस्टों का बादशाह हूं: D

— digEmAll

दुर्भाग्य से 1x1 मैट्रिक्स काम नहीं करेगा (क्योंकि seq(0.5)खाली वेक्टर के बजाय 1 रिटर्न)

— digEmAll

Answer 7

MATL , 25 24 23 22

t"tX@Jyq-ht3$)3X!7Mt&(

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

MATL में अनुक्रमण करना कभी आसान नहीं होता है, लेकिन कुछ गोल्फ के साथ यह वास्तव में वर्तमान सर्वश्रेष्ठ जेली उत्तर को हरा देता है ...

t                       % Take input implicitly, duplicate.  
 "                      % Loop over the columns of the input*
   X@                   % Push iteration index, starting with 0. Indicates the start of the indexing range.
     Jyq-               % Push 1i-k+1 with k the iteration index. Indicates the end of the indexing range
         t              % Duplicate for 2-dimensional indexing.
  t       3$)           % Index into a copy of the matrix. In each loop, the indexing range gets smaller
             3X!        % Rotate by 270 degrees anti-clockwise
                7Mt&(   % Paste the result back into the original matrix. 

* एक n x nमैट्रिक्स के लिए, यह प्रोग्राम nपुनरावृत्तियों करता है , जबकि आपको वास्तव में केवल n/2रोटेशन की आवश्यकता होती है। हालांकि, MATL (AB) में अनुक्रमण पर्याप्त रूप से लचीला है कि असंभव श्रेणियों को अनुक्रमण केवल एक सेशन नहीं है। इस तरह, पुनरावृत्तियों की संख्या सही होने पर बाइट को बर्बाद करने की कोई आवश्यकता नहीं है।

Answer 8

पायथन 2 , 98 बाइट्स

def f(a):
 if a:a=zip(*a[::-1]);b=zip(*a[1:-1]);b[-2:0:-1]=f(b[-2:0:-1]);a[1:-1]=zip(*b)
 return a

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

Answer 9

के (ngn / k) , ४१ ३ ९ ३ k बाइट्स

{s#(+,/'4(+|:)\x)@'4!1+i&|i:&/!s:2##x}

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

{ } तर्क के साथ कार्य करें x

#xलंबाई x- मैट्रिक्स की ऊंचाई

2##x दो प्रतियां - ऊंचाई और चौड़ाई (एक ही मान ली गई)

s:s"आकार" के लिए असाइन करें

!sआकार के साथ एक मैट्रिक्स के सभी सूचकांक s, जैसे !5 5है

(0 0 0 0 0 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3 4 4 4 4 4
 0 1 2 3 4 0 1 2 3 4 0 1 2 3 4 0 1 2 3 4 0 1 2 3 4)

यह एक 2-पंक्ति मैट्रिक्स (सूचियों की सूची) है और इसके कॉलम 5x5 मैट्रिक्स में सूचकांकों के अनुरूप हैं।

&/ दो पंक्तियों में न्यूनतम:

0 0 0 0 0 0 1 1 1 1 0 1 2 2 2 0 1 2 3 3 0 1 2 3 4

i&|i:असाइन करें i, रिवर्स करें ( |), और मिनीमा ( &) के साथ लेंi

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

ये एक 5x5 मैट्रिक्स की चपटी रिंग नंबर हैं:

4!1+ 1 जोड़ें और शेष मॉडुलो 4 लें

(+|:)एक ऐसा कार्य है जो उलट-पलट कर घूमता है ( |- हमें :इसे बलपूर्वक करने की आवश्यकता है ) और फिर ट्रांसपोज़िंग ( +- क्योंकि यह "ट्रेन" में सबसे सही क्रिया नहीं है, हमें इसकी आवश्यकता नहीं है :)

4(+|:)\xxमध्यवर्ती परिणामों को संरक्षित करते हुए , इसे 4 बार लागू करें

,/' प्रत्येक को समतल करें

+ पक्षांतरित

( )@' बाईं ओर प्रत्येक मूल्य को दाईं ओर प्रत्येक मूल्य के साथ अनुक्रमित करें

s# को नया आकार दें s

Comments

मुझे आपके कोड के स्पष्टीकरण को देखकर खुशी होगी

— गैलेन इवानोव

@ गेलनईवानोव ज़रूर। मुझे नहीं लगता कि मैं इसे और आगे बढ़ा सकता हूं, इसलिए मैं इसे समझाने की कोशिश कर सकता हूं।

— ngn

धन्यवाद! आपके समाधान मुझे सीखने की शुरुआत करना चाहते हैं (या यहां तक ​​कि ngn / k :))

— गैलेन इवानोव

@GalenIvanov J (और APL?) से परिचित होने के कारण, आप पहले से ही आधे रास्ते में हैं। K छोटा और सरल है, इसलिए मैं इसे सीखने की अत्यधिक सलाह दूंगा और निश्चित रूप से, मैं कभी भी ऑर्चर्ड में इसके बारे में बात करके खुश हूँ । ngn / k केवल वास्तविक चीज़ का एक सबसेट है, लेकिन मैं इसे तेज़ और व्यावहारिक बनाने का लक्ष्य रखता हूँ।

— ngn

हां, मुझे लगता है कि मैं इसे आजमाने जा रहा हूं।

— गैलेन इवानोव

Answer 10

जावास्क्रिप्ट (ईएस 6), 99 बाइट्स

f=(a,k=m=~-a.length/2)=>~k?f(a.map((r,y)=>r.map(v=>y-m>k|m-y>k|--x*x>k*k?v:a[m+x][y],x=m+1)),k-1):a

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

कैसे?

चौड़ाई एक वर्ग मैट्रिक्स को देखते हुए , हम परिभाषित करते हैं:$W$

$$m=\frac{W-1}{2}\\ t_{x,y}=\max(|y-m|,|x-m|)$$

5x5 मैट्रिक्स ( , ) के लिए का उदाहरण आउटपुट :$t_{x,y}$$W=5$$m=2$

$$\begin{pmatrix} 2 & 2 & 2 & 2 & 2 \\ 2 & 1 & 1 & 1 & 2 \\ 2 & 1 & 0 & 1 & 2 \\ 2 & 1 & 1 & 1 & 2 \\ 2 & 2 & 2 & 2 & 2 \end{pmatrix}$$

हम शुरू करते हैं और सभी कोशिकाओं संतोषजनक रूप से 90 ° दक्षिणावर्त घुमाते हैं:$k=m$$(x,y)$

$$t_{x,y}\le k$$

जबकि दूसरे को अपरिवर्तित छोड़ दिया जाता है।

यह कहने के बराबर है कि यदि हमारे पास कोई सेल नहीं घुमाया गया है:

$$(y-m>k) \text{ OR } (m-y>k) \text{ OR } (X^2>k^2)\text{ with }X=m-x$$

कोड में उपयोग किया जाने वाला परीक्षण कौन सा है:

a.map((r, y) =>
  r.map(v =>
    y - m > k | m - y > k | --x * x > k * k ?
      v
    :
      a[m + x][y],
    x = m + 1
  )
)

तब हम घटाते हैं और फिर से शुरू करते हैं, जब तक या ( की समानता पर निर्भर करता है )। किसी भी तरह से, यह हमारी रुकने की स्थिति को ट्रिगर करता है:कश्मीर = - 1 कश्मीर = - 3 / 2 $k$$k=-1$$k=-3/2$$W$

~k === 0

Answer 11

जेली , 24 बाइट्स

ṙ⁹ṙ€
ḊṖ$⁺€ßḷ""ç1$ç-ZUµḊ¡

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

मुझे लगता है कि यह बहुत कम हो सकता है।

- लिन

Comments

मैं इस तरह एक समाधान के बारे में सोच रहा था! यह ḷ""मेरे लिए जादुई लग रहा है ^ ^ एक स्पष्टीकरण जोड़ने के लिए देखभाल?

— लिन

@ लियन अंतिम बात जो मुझे उम्मीद थी कि ḷ""वह जादुई है। यह सिर्फ ḷ"एक अतिरिक्त के साथ है "... ओह, एक मामूली संभावना है कि ḷ"कुछ ऐसा भी है जिसे मैंने "आविष्कार" किया है, जिसका उपयोग इतना अधिक नहीं किया गया है क्योंकि यह अक्सर एक एकल परमाणु के साथ प्रतिस्थापित किया जा सकता है (इस मामले में नहीं, जैसा कि इनपुट में 0भी शामिल हो सकता है)।

— आउटगोल्फर ऑग

Answer 12

हास्केल , 108 बाइट्स

e=[]:e
r=foldl(flip$zipWith(:))e
g!(h:t)=h:g(init t)++[last t]
f[x,y]=r[x,y]
f[x]=[x]
f x=r$(r.r.r.(f!).r)!x

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

मैंने लायकोनी के स्थानान्तरण का उपयोग किया और इसे 90 ° से घूमने के लिए थोड़ा संशोधित किया:

  e=[]:e;foldr(zipWith(:))e.reverse
≡ e=[]:e;foldl(flip$zipWith(:))e

व्याख्या

r एक सरणी को 90 ° से घुमाता है।

(!)एक उच्च-स्तरीय फ़ंक्शन है: "केंद्र पर लागू करें"। g![1,2,3,4,5]है [1] ++ g[2,3,4] ++ [5]।

f बवंडर फ़ंक्शन है: बेस केस 1 और 2 हैं (किसी तरह 0 काम नहीं करता है)।

अंतिम पंक्ति वह जगह है जहां जादू होता है: हम r.r.r.(f!).rइसके बीच की पंक्तियों पर लागू होते हैं xऔर फिर परिणाम को घुमाते हैं। चलो उन मध्य पंक्तियों को एम कहते हैं । हम मध्यम पर recurse करना चाहते स्तंभों की एम , और उन पर प्राप्त करने के लिए, हम घुमा सकते हैं एम और फिर उपयोग (f!)। फिर हम M को उसके मूल अभिविन्यास में r.r.rघुमाने के लिए उपयोग करते हैं ।

Answer 13

जावा 10, 198 192 बाइट्स

m->{int d=m.length,b=0,i,j;var r=new Object[d][d];for(;b<=d/2;b++){for(i=b;i<d-b;i++)for(j=b;j<d-b;)r[j][d+~i]=m[i][j++];for(m=new Object[d][d],i=d*d;i-->0;)m[i/d][i%d]=r[i/d][i%d];}return r;}

-6 बाइट्स @ceilingcat की बदौलत ।

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

स्पष्टीकरण:

m->{                         // Method with Object-matrix as both parameter and return-type
  int d=m.length,            //  Dimensions of the matrix
      b=0,                   //  Boundaries-integer, starting at 0
      i,j;                   //  Index-integers
  var r=new Object[d][d];    //  Result-matrix of size `d` by `d`
  for(;b<=d/2;b++){          //  Loop `b` in the range [0, `d/2`]
    for(i=b;i<d-b;i++)       //   Inner loop `i` in the range [`b`, `d-b`)
      for(j=b;j<d-b;)        //    Inner loop `j` in the range [`b`, `d-b`)
        r[j][d+~i]=          //     Set the result-cell at {`j`, `d-i-1`} to:
          m[i][j++];         //      The cell at {`i`, `j`} of the input-matrix
    for(m=new Object[d][d],  //   Empty the input-matrix
        i=d*d;i-->0;)        //   Inner loop `i` in the range (`d*d`, 0]
      m[i/d][i%d]            //     Copy the cell at {`i/d`, `i%d`} from the result-matrix
        =r[i/d][i%d];}       //      to the replaced input-matrix
  return r;}                 //  Return the result-matrix as result

bमूल रूप से यह इंगित करने के लिए उपयोग किया जाता है कि हम किस रिंग में हैं। और फिर वह इस रिंग को घुमाएगा, जिसमें प्रत्येक पुनरावृत्ति के दौरान घड़ी के अंदर एक बार सब कुछ शामिल होगा।

इनपुट-मैट्रिक्स का प्रतिस्थापन इसलिए किया जाता है क्योंकि जावा पास-बाय-रेफरेंस है, इसलिए बस सेटिंग r=mका मतलब होगा कि दोनों मैट्रीस को कोशिकाओं से कॉपी करते समय संशोधित किया जाता है, जिससे गलत परिणाम आते हैं। इसलिए हमें एक नया-नया Objectमैट्रिक्स (नया संदर्भ) बनाना होगा, और इसके बजाय हर सेल में एक-एक करके वैल्यूज़ को कॉपी करना होगा।

Answer 14

MATLAB, 93 बाइट्स

function m=t(m),for i=0:nnz(m),m(1+i:end-i,1+i:end-i)=(rot90(m(1+i:end-i,1+i:end-i),3));end;end

मुझे यकीन है कि यह किसी तरह कुछ और गोल्फ हो सकता है।

व्याख्या

function m=t(m),                                                                          end % Function definition
                for i=0:nnz(m),                                                       end;    % Loop from 0 to n^2 (too large a number but matlab indexing doesn't care)
                                                            m(1+i:end-i,1+i:end-i)            % Take the whole matrix to start, and then smaller matrices on each iteration
                                                      rot90(                      ,3)         % Rotate 90deg clockwise (anti-clockwise 3 times)
                               m(1+i:end-i,1+i:end-i)=                                        % Replace the old section of the matrix with the rotated one

Answer 15

सी (जीसीसी) , 128 118 115 बाइट्स

-15 बाइट्स @ceilingcat से

j,i;f(a,b,w,s)int*a,*b;{for(j=s;j<w-s;j++)for(i=s;i<w-s;)b[~i++-~j*w]=a[i*w+j];wmemcpy(a,b,w*w);++s<w&&f(a,b,w,s);}

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

Answer 16

हास्केल, 274 बाइट्स

wमुख्य कार्य है, जिसमें वह प्रकार होता है [[a]] -> [[a]]जिसकी आप अपेक्षा करते हैं।

मुझे यकीन है कि एक अधिक अनुभवी हास्केल गोल्फर इस पर सुधार कर सकता है।

w m|t m==1=m|0<1=let m'=p m in(\a b->[h a]++x(\(o,i)->[h o]++i++[f o])(zip(tail a)b)++[f a])m'(w(g m'))
p m|t m==1=m|0<1=z(:)(f m)(z(\l->(l++).(:[]))(r(x h(i m)):(p(g m))++[r(x f(i m))])(h m))
t[]=1
t[[_]]=1
t _=0
h=head
f=last
x=map
i=tail.init
g=x i.i
z=zipWith
r=reverse

Comments

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

— लैकोनी