Se le da un cuadrado $n \times n$ matriz $A$ , y una lista (o vector) $u$ de longitud $n$ contiene los números $1$ a $n$ (o $0$ a $n-1$ ). Su tarea es reordenar las columnas y filas de la matriz $A$ acuerdo con el orden especificado en $u$ .

Eso es, se construye una matriz $B$ en donde el $(i,j)$ elemento-ésimo es el $(u(i),u(j))$ elemento -ésimo de $A$ . También debe generar el inverso de esta acción; es decir, el elemento-ésima (i, j) de $A$ va a terminar en la posición $(u(i),u(j))$ en una nueva matriz $C$ .

Por ejemplo, dado

la salida debe ser

Puede tomar entrada y salida a través de cualquiera de los métodos de E / S predeterminados. No tiene que especificar qué matriz es $B$ o $C$ , siempre que genere ambas. Puede suponer que $A$ solo contiene enteros positivos, y puede usar indexación basada en 1 o 0 para $u$ . Debe admitir matrices de al menos $64 \times 64$ .

Ejemplo

===== 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 bytes

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

Pruébalo en línea!

Toma Acomo un matrixy los índices basados ​​en 1 o.

MATL , 15 13 bytes

t3$)&Gw&St3$)

Entradas u, entonces A.

Salidas B, luego Csin separador, ya que no hay ambigüedad.

Pruébalo en línea!

Explicación

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

Octava , 33 bytes

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

Pruébalo en línea!

¡Gracias a Luis por corregir un error y guardar varios bytes!

$v$$u$$u = ( 3, 1, 2 )$$v$$u$

Python 3 con numpy, 51 45 bytes

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

Pruébalo en línea!

-6 bytes gracias a @xnor

numpy$0$$n-1$

Wolfram Language (Mathematica) , 30 bytes

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

Pruébalo en línea!

Ingresar como f[A][u].

PowerShell , 78 73 71 bytes

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

Pruébalo en línea .

Jalea , 13 bytes

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

Pruébalo en línea!

J , 19 bytes

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

Pruébalo en línea!

• Verbo principal ]/:~"1/:
  • El más a la derecha /:clasifica el argumento izquierdo (matriz) de acuerdo con el orden que ordenaría el argumento derecho (orden especificado). Esto ordena filas.
  • Ahora ese resultado se ordena de /:~"1nuevo según el orden especificado ]. Pero esta vez estamos ordenando con el rango 1, es decir, estamos ordenando cada fila, lo que tiene el efecto de ordenar las columnas.
• ],:/:Aplicamos lo anterior utilizando el orden especificado ]y la calificación del orden especificado /:. Esto nos da los 2 resultados que queremos.

JavaScript (Node.js) , 77 70 68 bytes

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

Pruébalo en línea!

APL (Dyalog Extended) , ^{SBCS de} 12 bytes

Programa completo Indicaciones para$u$ y entonces $A$. Huellas dactilares$C$ cerca de $B$, separados por dos espacios

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

Pruébalo en línea!

⎕ solicitar $u$; [3,1,2]

⍮⍨ yuxtaposición-selfie; [[3,1,2],[3,1,2]]

⍋¨ permutación-inversión de cada uno; [[2,3,1],[2,3,1]]
⍛ luego
⍮⍨ yuxtaponerse consigo mismo[[[2,3,1],[2,3,1]],[[3,1,2],[3,1,2]]]

⌷ reordenar
∘ el valor de
⎕ $A$como se ingresa
¨ usando cada par como un conjunto de órdenes, una orden por eje

J , 17 16 15 14 bytes

-1 gracias a @Jonah

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

Pruébalo en línea!

Carbón de leña , 24 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. 0 indexado. Nota: espacio final. Explicación:

    η                       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 bytes

{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(" "))}

Pruébalo en línea!

APL + WIN, 21 bytes

Solicita la entrada de u seguido de a. Salidas b inmediatamente sobre la parte superior de c sin separador:

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

Pruébalo en línea! Cortesía de Dyalog Classic.

Perl 5 , 79 bytes

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

Pruébalo en línea!

Jalea ,  12 11  13 bytes

+2 :( para arreglar casos cuando B = C

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

Un Enlace diádica aceptar una lista de listas, A( npor n), a la izquierda y una lista de los primeros nnúmeros enteros a la derecha, uque da una lista de listas de listas, [B, C].

Pruébalo en línea!

¿Cómo?

ṭþ`œị¥@Ƭị@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 bytes

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

iasc devuelve índices para ordenar su argumento.

Limpio , 91 bytes

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

Pruébalo en línea!

Define $ :: {{a}} [Int] -> [{{a}}](se usa con a = Int) tomar una matriz de matrices y una lista de índices basados ​​en cero, devolviendo una lista de matrices de matrices que contienen B y C.

Python 3 , 91 bytes

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

Pruébalo en línea!

Toma los parámetros como una lista 2D y 1D y devuelve una lista que contiene dos listas 2D B y C. No estoy seguro de si hay una forma más limpia de hacer todos los bucles for.

C ++ (gcc) , 148 142 bytes

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

Pruébalo en línea!

Gracias a la sugerencia de @ceilingcat de usar #import <queue> en lugar de <vector> que misteriosamente trae std :: vector