You are given a square $n times n$ matrix $A$, and a list (or vector) $u$ of length $n$ containing the numbers $1$ through $n$ (or $0$ through $n-1$). Your task is to reorder the columns and rows of the matrix $A$ according to the order specified in $u$.

That is, you will construct a matrix $B$ where the $(i,j)$-th element is the $(u(i),u(j))$-th element of $A$. You should also output the inverse of this action; that is, the (i,j)-th element of $A$ will end up at position $(u(i),u(j))$ in a new matrix $C$.

For example, given $$A = beginbmatrix 11 &12& 13 \ 21& 22& 23 \ 31& 32& 33 endbmatrix,quad u=beginbmatrix3 & 1 & 2endbmatrix$$

the output should be $$B = beginbmatrix33 & 31 & 32 \ 13 & 11 & 12 \ 23 & 21 & 22 endbmatrix,quad C= beginbmatrix22 & 23 & 21 \32 & 33 & 31 \ 12 & 13 & 11 endbmatrix$$

You may take input and output through any of the default I/O methods. You do not have to specify which matrix is $B$ or $C$, as long as you output both. You may assume $A$ only contains positive integers, and you may use 1- or 0-based indexing for $u$. You must support matrices up to at least size $64 times 64$.

Example

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

MATL, 15 13 bytes

t3$)&Gw&St3$)

Inputs u, then A.

Outputs B, then C without a separator, as there is no ambiguity.

Try it online!

Octave, 33 bytes

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

Try it online!

Thanks to Luis for correcting an error and saving several bytes!

Basic indexing works here for both tasks, by defining a vector $ v $ equal to the permutation that undoes $ u $. That is, if $ u = ( 3, 1, 2 ) $ then the first element of $ v $ is 2, since 1 is in the second position of $ u $. This is accomplished with Octave's sort function.

Wolfram Language (Mathematica), 30 bytes

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

Try it online!

Input as f[A][u].

Charcoal, 24 bytes

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

Try it online! Link is to verbose version of code. 0-indexed. Note: Trailing space. Explanation:

 η 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

R, 42 bytes

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

Try it online!

Takes A as a matrix and 1-based indexes o.

Python 3 with numpy, 51 45 bytes

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

Try it online!

-6 bytes thanks to @xnor

The function takes two arguments: a numpy matrix and a permutation vector having values from $0$ to $n-1$.