On vous donne un carré matrice , et une liste (ou vecteur) de longueur contenant les nombres à (ou à ). Votre tâche consiste à réorganiser les colonnes et les lignes de la matrice selon l'ordre spécifié en .$n \times n$$A$$u$$n$$1$$n$$0$$n-1$$A$$u$

Autrement dit, on va construire une matrice où le -ième élément est le -ième élément de . Vous devez également sortir l'inverse de cette action; Autrement dit, la (i, j) -ième élément de finira à la position dans une nouvelle matrice .$B$$(i,j)$$(u(i),u(j))$$A$$A$$(u(i),u(j))$$C$

Par exemple, étant donné

la sortie doit être

Vous pouvez accepter l'entrée et la sortie via l'une des méthodes d'E / S par défaut. Vous n'avez pas besoin de spécifier quelle matrice est ou , tant que vous sortez les deux. Vous pouvez supposer que ne contient que des entiers positifs et vous pouvez utiliser une indexation basée sur 1 ou 0 pour . Vous devez prendre en charge les matrices jusqu'à au moins la taille .$B$$C$$A$$u$$64 \times 64$

Exemple

===== Input =====
A =
 35     1     6    26    19    24
  3    32     7    21    23    25
 31     9     2    22    27    20
  8    28    33    17    10    15
 30     5    34    12    14    16
  4    36    29    13    18    11
u=
  3 5 6 1 4 2

==== Output =====
B = 
  2    27    20    31    22     9
 34    14    16    30    12     5
 29    18    11     4    13    36
  6    19    24    35    26     1
 33    10    15     8    17    28
  7    23    25     3    21    32
C = 
 17    15     8    10    28    33
 13    11     4    18    36    29
 26    24    35    19     1     6
 12    16    30    14     5    34
 21    25     3    23    32     7
 22    20    31    27     9     2

R , 42 octets

function(A,o)list(A[o,o],A[I<-order(o),I])

Essayez-le en ligne!

Prend Acomme matrixindex a et 1 o.

MATL , 15 13 octets

t3$)&Gw&St3$)

Entrées u, alors A.

Sorties B, puis Csans séparateur, car il n'y a pas d'ambiguïté.

Essayez-le en ligne!

Explication

t     % Take input u implicitly. Duplicate u
3$)   % Take input A implicitly. Index A with u as row and column indices
&G    % Push the two inputs again: u, A
w     % Swap
&S    % Push indices that would make u sorted. Call that v
t     % Duplicate v
3$)   % Index A with v as row as column indices. Display implcitly

Octave , 33 octets

@(A,u){A(u,u) A([~,v]=sort(u),v)}

Essayez-le en ligne!

Merci à Luis d' avoir corrigé une erreur et économisé plusieurs octets!

L'indexation de base fonctionne ici pour les deux tâches, en définissant un vecteur $v$ égal à la permutation qui annule $u$ . Autrement dit, si $u = ( 3, 1, 2 )$ alors le premier élément de $v$ est 2, puisque 1 est dans la deuxième position de $u$ . Ceci est accompli avec la fonction de tri d'Octave .

Python 3 avec numpy, 51 45 octets

lambda m,p:[m[x][:,x]for x in(p,p.argsort())]

Essayez-le en ligne!

-6 octets grâce à @xnor

La fonction prend deux arguments: une numpymatrice et un vecteur de permutation ayant des valeurs de $0$ à $n-1$ .

Wolfram Language (Mathematica) , 30 octets

ii[[#,#]]&/@{#,Ordering@#}&

Essayez-le en ligne!

Saisissez comme f[A][u].

PowerShell , 78 73 71 octets

($A,$u=$args)|%{$A[$u]|%{''+$_[$u]}
$u=1..$u.count|%{$u.indexof($_-1)}}

Essayez-le en ligne .

Gelée , 13 octets

ŒJṁ⁸ịⱮ⁹,Ụ¤œị⁸

Essayez-le en ligne!

J , 19 octets

(]/:~"1/:)"_ 1],:/:

Essayez-le en ligne!

• Verbe principal ]/:~"1/:
  • Le plus à droite /:trie l'argument gauche (matrice) selon l'ordre qui trierait l'argument de droite (ordre spécifié). Cela trie les lignes.
  • Maintenant, ce résultat est à /:~"1nouveau trié selon l'ordre spécifié ]. Mais cette fois, nous trions avec le rang 1, c'est-à-dire que nous trions chaque ligne, ce qui a pour effet de trier les colonnes.
• ],:/:Nous appliquons ce qui précède en utilisant à la fois la commande spécifiée ]et la note supérieure de la commande spécifiée /:. Cela nous donne les 2 résultats que nous voulons.

JavaScript (Node.js) , 77 70 68 octets

a=>g=(u,v=[])=>[u.map((i,x)=>u.map(j=>a[i][j],v[i]=x)),v&&g(v,0)[0]]

Essayez-le en ligne!

APL (Dyalog Extended) , 12 octets ^SBCS

$u$$A$$C$$B$

⌷∘⎕¨⍋¨⍛⍮⍨⍮⍨⎕

Essayez-le en ligne!

⎕$u$[3,1,2]

⍮⍨ juxtaposition-selfie; [[3,1,2],[3,1,2]]

⍋¨ permutation-inversion de chacun; [[2,3,1],[2,3,1]]
⍛ puis se
⍮⍨ juxtaposent à lui-même[[[2,3,1],[2,3,1]],[[3,1,2],[3,1,2]]]

⌷
∘
⎕ $A$
¨

J , 17 16 15 14 octets

-1 grâce à @Jonah

([{"1{)~(,:/:)

Essayez-le en ligne!

Fusain , 24 octets

Ｅ⟦ηＥη⌕ηκ⟧Ｅθ⪫Ｅ觧θ§ιμ§ιξ 

Essayez-le en ligne! Le lien est vers la version détaillée du code. 0 indexé. Remarque: Espace de fin. Explication:

    η                       Input `u`
   Ｅ                        Map over elements
     ⌕                      Index of
       κ                    Current index in
      η                     Input `u`
  η                         Input `u`
Ｅ⟦      ⟧                   Map over `u` and its inverse
          θ                 Input `A`
         Ｅ                  Map over elements
             θ              Input `A`
            Ｅ               Map over elements
                θ           Input `A`
               §            Indexed by
                  ι         Current vector
                 §          Indexed by
                   μ        Row index
              §             Indexed by
                     ι      Current vector
                    §       Indexed by
                      ξ     Column index
           ⪫                Join with spaces for readability
                            Implicitly print

Kotlin , 213 octets

{a:List<List<Int>>,u:List<Int>->val s=u.size
for(l in List(s){r->List(s){c->a[u[r]][u[c]]}})println(l.joinToString(" "))
for(l in List(s){r->List(s){c->a[u.indexOf(r)][u.indexOf(c)]}})println(l.joinToString(" "))}

Essayez-le en ligne!

APL + WIN, 21 octets

Invite à saisir u suivi de a. Sorties b immédiatement au-dessus de c sans séparateur:

(a←⎕)[u;u←⎕]⋄a[⍋u;⍋u]

Essayez-le en ligne! Gracieuseté de Dyalog Classic

Perl 5 , 79 octets

sub{$[=1;($A,$u)=@_;@$v[@$u]=(1..@$u);map{$x=$_;[map[@$_[@$x]],@$A[@$x]]}$u,$v}

Essayez-le en ligne!

Gelée ,  12 11  13 octets

+2 :( pour corriger les cas où B = C

ṭþ`œị¥@Ƭị@2,0

Un lien dyadique acceptant une liste de listes, A( npar n), sur la gauche et une liste des premiers nnombres entiers sur le côté droit u, ce qui donne une liste de listes de listes, [B, C].

Essayez-le en ligne!

Comment?

ṭþ`œị¥@Ƭị@2,0 - Link: A, u
       Ƭ      - collect up while the results are no longer unique, applying:
     ¥@       -   last two links as a dyad with swapped arguments:
  `           -     use left (u) as both arguments of:
 þ            -       outer product with:
ṭ             -         tack
   œị         -     multi-dimensional index into last result (starting with A)
                ...at the end of the Ƭ-loop we have [A,B,...,C]
                                                 or [A] if A=B=C
                                                 or [A,B] if B=C but A!=B
          2,0 - literal pair [2,0]
         @    - with swapped arguments:
        ị     -   index into (1-based & modular) -> [B,C]
                                                 or [A,A]=[B,C] if A=B=C
                                                 or [B,B]=[B,C] if B=C

q, 26 octets

{Y:iasc y;(x[y;y];x[Y;Y])}

iasc renvoie des index pour trier son argument.

Nettoyer , 91 octets

import StdEnv
$a u=map(\l={{a.[i,j]\\j<-l}\\i<-l})[u,[k\\i<-[0..]&_<-u,j<-u&k<-[0..]|j==i]]

Essayez-le en ligne!

Définit $ :: {{a}} [Int] -> [{{a}}](utilisé avec a = Int) la prise d'un tableau de tableaux et une liste d'index de base zéro, renvoyant une liste de tableaux de tableaux contenant B et C.

Python 3 , 91 octets

lambda a,u:[[[a[y][x]for x in t]for y in t]for t in[u,[u.index(i)for i in range(len(u))]]]

Essayez-le en ligne!

Prend les paramètres sous forme de liste 2D et 1D et renvoie une liste contenant deux listes 2D B et C. Je ne sais pas s'il existe un moyen plus propre de faire toutes les boucles for.

C ++ (gcc) , 148 142 octets

#import<queue>
#define q[o[i/z]*z+o[i%z]]
using V=std::vector<int>;int f(V m,V o,V&r,V&R,int z){int i=z*z;for(r=R=V(i);i--;r[i]=m q)R q=m[i];}

Essayez-le en ligne!

Merci à la suggestion de @ceilingcat d'utiliser #import <queue> au lieu de <vector> qui apporte mystérieusement std :: vector