La tornade matricielle est comme toute autre tornade: elle est constituée de choses tournant autour d'un centre. Dans ce cas, des éléments de la matrice au lieu de l'air.

Voici un exemple de tornade matricielle:

Tout d'abord, nous commençons par sectionner la matrice en anneaux carrés, chaque section est constituée d'éléments qui sont plus éloignés de la frontière de la même distance. Ces sections seront tournées dans le sens horaire autour du centre. Dans les vraies tornades, la gravité augmente vers le centre, tout comme l'étape de rotation dans une tornade à matrice: la section la plus à l'extérieur (la rouge) est tournée d'un pas, la suivante (la jaune) est tournée de 2, et ainsi de suite sur. Une étape de rotation est une rotation de 90 ° autour du centre.

Tâche:

Votre tâche, si vous l'acceptez, consiste à écrire une fonction ou un programme qui prend en entrée une matrice carrée, à lui appliquer l'effet de tornade puis à sortir la matrice résultante.

Contribution:

L'entrée doit être une matrice carrée d'ordre noù n >= 1. Aucune hypothèse n'est à faire sur les éléments de la matrice, ils pourraient être n'importe quoi.

Sortie:

Une matrice carrée du même ordre qui serait le résultat de l'application de l'effet tronado à la matrice d'entrée.

Exemples:

Une matrice d'ordre n = 1:

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

Une matrice d'ordre n = 2:

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

Une matrice d'ordre 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 octets

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

Essayez-le en ligne!

Fusain , 44 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Fonctionne uniquement sur les carrés de caractères car les E / S par défaut de Charcoal ne rendent pas justice aux tableaux normaux. Explication:

≔ＥθＳθ

Lisez le carré des caractères.

Ｗθ«

Boucle jusqu'à ce qu'elle soit vide.

≔Ｅθ⮌⭆觧θνλθ

Faire pivoter.

θＭ¹⁻¹Ｌθ

Imprimez-le, mais déplacez ensuite le curseur sur un carré en diagonale depuis le coin d'origine.

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

Coupez l'extérieur du tableau.

Gelée , 27 octets

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

Essayez-le en ligne!

Je pense que cela pourrait être beaucoup plus court.

           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 octets

Merci à nwellnhof pour -5 octets!

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

Essayez-le en ligne!

Bloc de code récursif qui prend un tableau 2D aplati et renvoie un tableau aplati similaire.

Explication:

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

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

Essayez-le en ligne!

Je suis conscient que les fonctions anonymes récursives ne sont pas la méthode la plus courte pour faire des choses dans Octave, mais elles sont de loin la méthode la plus amusante . C'est la fonction anonyme la plus courte que j'ai pu trouver, mais j'aimerais être dépassé.

Explication

La fonction récursive est définie selon cette réponse de conseils par le plafond. q=f(f=@(g)@(M) ... g(g)(M) ...est la structure de base d'une telle fonction anonyme, avec g(g)(M)l'appel récursif. Depuis cela indéfiniment récursif, nous terminerons l'appel récursif dans un réseau de cellules sous condition: {@()g(g)(M),M}{condition}(). La fonction anonyme avec une liste d'arguments vide retarde l'évaluation après la sélection de la condition (bien que plus tard, nous voyons que nous pouvons utiliser cette liste d'arguments pour la définir z). Jusqu'à présent, il s'agissait simplement d'une comptabilité de base.

Maintenant, pour le travail réel. Nous voulons que la fonction retourne rot90(P,-1)avec P une matrice sur laquelle g(g)a été récursivement appelée la partie centrale de M. Nous commençons par définir z=2:end-1ce que nous pouvons cacher dans l'indexation de M. De cette façon, M(z,z)sélectionne la partie centrale de la matrice qui doit être être encore tornado par un appel récursif. La ,3pièce garantit que les rotations sont dans le sens horaire. Si vous vivez dans l'hémisphère sud, vous pouvez supprimer ce bit pour -2 octets.

Nous faisons alors M(z,z)=g(g)M(z,z). Cependant, la valeur de résultat de cette opération n'est que la partie centrale modifiée plutôt que la Pmatrice entière . Par conséquent, nous faisons {M(z,z)=g(g)M(z,z),M}{2}ce qui est essentiellement volé de cette réponse de conseils par Stewie Griffin.

Enfin, conditionc'est juste que la récursivité s'arrête lorsque l'entrée est vide.

R , 87 octets

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}

Essayez-le en ligne!

• crédits à cette réponse StackOverFlow pour le code de rotation

MATL , 25 24 23 22

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

Essayez-le en ligne!

L'indexation en MATL n'est jamais facile, mais avec un peu de golf, elle bat en fait la meilleure réponse actuelle de Jelly ...

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. 

* Pour une n x nmatrice, ce programme nen itérations, alors que vous n'avez vraiment besoin que de n/2rotations. Cependant, l'indexation dans MATL (AB) est suffisamment flexible pour que l'indexation des plages impossibles soit juste un no-op. De cette façon, il n'est pas nécessaire de gaspiller des octets pour obtenir le bon nombre d'itérations.

Python 2 , 98 octets

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

Essayez-le en ligne!

K (ngn / k) , 41 39 38 octets

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

Essayez-le en ligne!

{ } fonction avec argument x

#x longueur de x - la hauteur de la matrice

2##x deux copies - hauteur et largeur (supposées identiques)

s: affecter à s pour "forme"

!stous les indices d'une matrice de forme s, par exemple , !5 5est

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

Il s'agit d'une matrice à 2 lignes (liste de listes) et ses colonnes correspondent aux indices dans une matrice 5x5.

&/ minimum sur les deux rangées:

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:assigner i, inverser ( |) et prendre des minima ( &) aveci

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

Ce sont les nombres d'anneaux aplatis d'une matrice 5x5:

4!1+ ajouter 1 et prendre des restes modulo 4

(+|:)est une fonction qui tourne en inversant ( |- nous avons besoin de le :pour le forcer à être monadique) puis en transposant ( +- puisque ce n'est pas le verbe le plus à droite dans le "train", nous n'avons pas besoin d'un :)

4(+|:)\xl'appliquer 4 fois x, en préservant les résultats intermédiaires

,/' aplatir chacun

+ transposer

( )@' indexer chaque valeur à gauche avec chaque valeur à droite

s# remodeler en s

JavaScript (ES6), 99 octets

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

Essayez-le en ligne!

Comment?

$W$

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

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

tandis que les autres restent inchangés.

Cela équivaut à dire qu'une cellule n'est pas tournée si nous avons:

qui est le test utilisé dans le code:

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

Gelée , 24 octets

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

Essayez-le en ligne!

Je pense que cela pourrait être beaucoup plus court.

- Lynn

Haskell , 108 octets

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

Essayez-le en ligne!

J'ai utilisé la transposition de Laikoni et l' ai légèrement modifiée pour faire pivoter un tableau de 90 °:

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

Explication

r fait pivoter un réseau de 90 °.

(!)est une fonction de niveau supérieur: «appliquer au centre». g![1,2,3,4,5]est [1] ++ g[2,3,4] ++ [5].

f est la fonction tornade: les cas de base sont de taille 1 et 2 (en quelque sorte, 0 ne fonctionne pas).

La dernière ligne est l'endroit où la magie opère: nous appliquons r.r.r.(f!).rsur les rangées du milieu xpuis tournons le résultat. Appelons les lignes du milieu M . Nous voulons revenir sur les colonnes centrales de M , et pour y arriver, nous pouvons faire pivoter M et ensuite utiliser (f!). Ensuite, nous utilisons r.r.rpour faire revenir M dans son orientation d'origine.

Java 10, 198 192 octets

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 octets grâce à @ceilingcat .

Essayez-le en ligne.

Explication:

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

best essentiellement utilisé pour indiquer à quel anneau nous nous trouvons. Et il fera ensuite tourner cet anneau, y compris tout ce qu'il contient une fois dans le sens des aiguilles d'une montre à chaque itération.

Le remplacement de la matrice d'entrée se fait parce que Java est passe-par-référence, donc un simple réglage r=msignifierait que les deux matrices sont modifiées lors de la copie à partir de cellules, provoquant des résultats incorrects. Nous devons donc créer une nouvelle Objectmatrice (nouvelle référence) et copier les valeurs dans chaque cellule une par une à la place.

MATLAB, 93 octets

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

Je suis sûr que cela peut être joué un peu plus en quelque sorte.

Explication

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 octets

-15 octets de @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);}

Essayez-le en ligne!

Haskell, 274 octets

w est la fonction principale, qui a le type [[a]] -> [[a]] que vous attendez.

Je suis sûr qu'un golfeur Haskell plus expérimenté pourrait améliorer cela.

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