Matris tornado, diğer herhangi bir kasırga gibidir: bir merkez etrafında dönen şeylerden oluşur. Bu durumda, matrisin hava yerine elemanları.

İşte bir matris tornado örneği:

İlk önce matrisi kare halkalara bölerek başlıyoruz, her bölüm sınırdan uzakta aynı mesafeden daha uzak olan öğelerden oluşuyor. Bu bölümler merkezde saat yönünde döndürülecek. Gerçek kasırgalarda, ciddiyet merkeze doğru artar ve bir matris kasırgadaki dönme basamağı artar: en dıştaki bölüm (kırmızı olan) 1 basamak, döndürülen basamak (sarı olan) 2 basamak döndürülür. üzerinde. Bir rotasyon adımı merkez çevresinde 90 ° 'lik bir rotasyondur.

Görev:

Göreviniz, kabul etmeniz durumunda, kare matris girdi olarak alan bir fonksiyon veya program yazmak, kasırga efektini uygulamak ve ardından ortaya çıkan matrisin çıktısını almaktır.

Giriş:

Giriş düzenine bir kare matris olmalıdır nburada n >= 1. Matrisin unsurları hakkında bir varsayım yapılmaz, her şey olabilir.

Çıktı:

Tronado etkisinin giriş matrisine uygulanmasının sonucu olan aynı siparişte kare matris.

Örnekler:

Bir sipariş matrisi n = 1:

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

Bir sipariş matrisi n = 2:

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

Bir sipariş matrisi 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]]

Python 3 , 100 bayt

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

Çevrimiçi deneyin!

Kömür , 44 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Yalnızca karakter karelerinde çalışır, çünkü Kömürün varsayılan G / Ç'si normal dizi adaletini yapmaz. Açıklama:

≔ＥθＳθ

Karakter karesini oku.

Ｗθ«

Boş kalana kadar döngü.

≔Ｅθ⮌⭆觧θνλθ

Döndürün.

θＭ¹⁻¹Ｌθ

Yazdırın ancak imleci orijinal köşesinden çapraz olarak bir kareye getirin.

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

Diziden dışını kesin.

Jöle , 27 bayt

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

Çevrimiçi deneyin!

Bunun çok daha kısa olabileceğini düşünüyorum.

           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.

Perl 6 , 78 73 72 bayt

-Well byte'a nwellnhof'a teşekkürler!

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

Çevrimiçi deneyin!

Düzleştirilmiş bir 2D dizisi alan ve benzer şekilde düzleştirilmiş bir dizi döndüren özyinelemeli kod bloğu.

Açıklama:

$!={      # 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
}

Octave , 86 81 bayt

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

Çevrimiçi deneyin!

Özyinelemeli anonim işlevlerin Octave'da işlerin yapılması için en kısa yöntem olmadığının farkındayım, ancak bugüne kadarki en eğlenceli yöntemdir. Bu, bulabileceğim en kısa anonim işlev, ancak aşılmayı çok isterdim.

açıklama

Özyinelemeli işlev, bu ipuçlarına göre ceilingcat tarafından cevap olarak tanımlanır. özyinelemeli çağrı q=f(f=@(g)@(M) ... g(g)(M) ...ile g(g)(M), böyle bir isimsiz fonksiyonun temel yapısıdır . Bu süresiz recurse olacaktır yana, bir koşullu hücre dizisinde yinelemeli çağrı sarın: {@()g(g)(M),M}{condition}(). Boş argüman listesine sahip anonim işlev, koşulu seçildikten sonra değerlendirmeyi geciktirir (daha sonra da, o argüman listesini tanımlamak için kullanabileceğimizi görürüz z). Şimdiye kadar sadece temel defter tutma olmuştur.

Şimdi asıl iş için. Biz işlevi dönmek istiyorum rot90(P,-1)P ile hangi bir matris g(g)Biz ayarıyla başlar yinelemeli M. orta kesiminde çağrılmış olup z=2:end-1biz M'nin endeksleme bu şekilde gizleyebilirsiniz M(z,z)seçer matrisin orta kesimi ihtiyaçları olduğunu özyinelemeli bir çağrı ile daha fazla kasırga olmak. ,3Bölüm rotasyonlar saat yönünde olmasını sağlar. Güney yarım kürede yaşıyorsanız, bu ucu -2 bayt için çıkarabilirsiniz.

Öyleyse yaparız M(z,z)=g(g)M(z,z). Ancak, bu işlemin sonuç değeri, tüm Pmatrisin yerine yalnızca değiştirilmiş merkezi kısımdır . Bu nedenle, {M(z,z)=g(g)M(z,z),M}{2}temelde bu ipuçlarından Stewie Griffin'in cevabından çalınan yapıyoruz .

Son olarak, conditiongiriş boş olduğunda özyineleme durur.

R , 87 bayt

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}

Çevrimiçi deneyin!

• Rotasyon kodu için bu StackOverFlow cevabını alacak

MATL , 25 24 23 22

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

Çevrimiçi deneyin!

MATL'de indeksleme yapmak hiç bu kadar kolay olmamıştı, ancak bazı golf oyunları aslında en iyi Jelly cevabını yeniyor ...

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. 

* Bir n x nmatris için bu program nyinelenir, gerçekte yalnızca n/2rotasyona ihtiyacınız vardır . Bununla birlikte, MATL (AB) 'de indeksleme, imkansız aralıkları indekslemenin sadece bir operasyon dışı olması için yeterince esnektir. Bu şekilde, yineleme sayısını doğru almak için bayt harcamasına gerek kalmaz.

Python 2 , 98 bayt

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

Çevrimiçi deneyin!

K (ngn / k) , 41 39 38 bayt

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

Çevrimiçi deneyin!

{ } argümanlı fonksiyon x

#xuzunluğu x- matrisin yüksekliği

2##x iki kopya - yükseklik ve genişlik (aynı olduğu varsayılır)

s:s"şekle" atayın

!sşekilli bir matrisin tüm indeksleri s, örneğin !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)

Bu 2 satırlı bir matristir (listeler listesi) ve sütunları 5x5 matrisindeki dizinlere karşılık gelir.

&/ iki sıra için minimum:

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:ile ata i, reverse ( |) ve minima ( &) ilei

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

Bunlar 5x5 matrisin düzleştirilmiş halka sayılarıdır:

4!1+ 1 ekleyin ve kalanları modulo 4 alın

(+|:)tersine döndürerek dönen bir işlevdir ( |- :onu monadik olmaya zorlamalıyız) ve sonra transposing ( +- "trende" en doğru fiil olmadığından, buna gerek yoktur :)

4(+|:)\xxAra sonuçları koruyarak 4 kez uygulayın

,/' her birini yassılaştır

+ devrik

( )@' soldaki her değeri sağdaki her değerle indeksle

s# yeniden şekillendirmek s

JavaScript (ES6), 99 bayt

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

Çevrimiçi deneyin!

Nasıl?

$W$

$t_{x,y}$$W=5$$m=2$

$k=m$$(x,y)$

Diğerleri değişmeden kalır.

Bu hücre söylemek eşdeğerdir değil biz varsa döndürülmüş:

kodda kullanılan test:

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$$k=-1$$k=-3/2$$W$

~k === 0

Jöle , 24 bayt

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

Çevrimiçi deneyin!

Bunun çok daha kısa olabileceğini düşünüyorum.

- Lynn

Haskell , 108 bayt

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

Çevrimiçi deneyin!

Kullandığım Laikoni en devrik ve bir dizi 90 ° döndürmek için, biraz değiştirilmiş:

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

açıklama

r bir diziyi 90 ° döndürür.

(!)daha üst seviye bir fonksiyondur: “merkeze uygula”. g![1,2,3,4,5]olduğunu [1] ++ g[2,3,4] ++ [5].

f kasırga işlevidir: temel durumlar 1 ve 2 numaradır (her nasılsa 0 çalışmıyor).

Son satır büyünün gerçekleştiği yerdir: r.r.r.(f!).rorta satırlara uygular xve sonucu döndürürüz. Bu orta sıralara M diyelim . Biz orta özyineleme istediğiniz sütunların arasında M ve bu ulaşmak için, biz döndürebilirsiniz M ve ardından kullanımını (f!). Sonra M'yi orijinal oryantasyonuna geri r.r.rdöndürmek için kullanırız .

Java 10, 198 192 bayt

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;}

@Ceilingcat sayesinde -6 bayt .

Çevrimiçi deneyin.

Açıklama:

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

bhangi halkada olduğumuzu belirtmek için kullanılır. Ve sonra, her yineleme sırasında içindeki her şey saat yönünde bir kez olmak üzere bu halkayı döndürecektir.

Giriş matrisinin değiştirilmesi, Java'nın referans yoluyla geçmesi nedeniyle yapılır, bu nedenle basitçe ayarlanması r=m, her iki matrisin hücrelerden kopyalanırken değiştirilerek yanlış sonuçlara neden olacağı anlamına gelir. Bu nedenle yeni bir Objectmatris (yeni referans) oluşturmalı ve bunun yerine her hücrede değerleri birer birer kopyalamalıyız.

MATLAB, 93 bayt

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

Eminim bu bir şekilde daha çok golf oynayabilir.

açıklama

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

C (gcc) , 128 118 115 bayt

-15 bayt (@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);}

Çevrimiçi deneyin!

Haskell, 274 bayt

w[[a]] -> [[a]]Beklediğiniz tipte ana fonksiyondur .

Eminim daha deneyimli bir Haskell golfçü bu konuda gelişebilir.

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