您将得到一个平方矩阵，以及一个长度为的列表（或向量），包含数字到（或到）。您的任务是根据指定的顺序对矩阵的列和行重新排序。$n \times n$$A$$u$$n$$1$$n$$0$$n-1$$A$$u$

也就是说，你将构造一个矩阵其中个元素是第元件。您还应该输出该动作的逆函数；即，第（i，J）个元素将在位置结束在一个新的矩阵。$B$$(i,j)$$(u(i),u(j))$$A$$A$$(u(i),u(j))$$C$

例如，假设

输出应为

您可以通过任何默认的I / O方法进行输入和输出。您不必指定哪个矩阵是或，只要您同时输出两者即可。您可以假设仅包含正整数，并且可以对使用基于1或0的索引。您必须支持最大大小为矩阵。$B$$C$$A$$u$$64 \times 64$

例

===== 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个字节

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

在线尝试！

注意到A作为matrix和1为基础的索引o。

MATL，15 13字节

t3$)&Gw&St3$)

u然后输入A。

输出B，然后C没有分隔符，因为没有歧义。

在线尝试！

说明

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

八度，33字节

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

在线尝试！

感谢Luis纠正错误并节省了几个字节！

基本索引在这里对两个任务都起作用，方法是定义一个向量$v$，该向量等于撤消$u$的排列。也就是说，如果$u = ( 3, 1, 2 )$然后的第一个元素$v$为2时，因为1是在第二位置$u$。这是通过Octave的sort函数完成的。

Python 3 with numpy，51 45字节

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

在线尝试！

-6个字节，感谢@xnor

该函数采用两个参数：numpy矩阵和值从$0$到$n-1$的排列向量。

Wolfram语言（Mathematica），30个字节

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

在线尝试！

输入为f[A][u]。

PowerShell，78 73 71字节

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

在线尝试。

果冻，13个字节

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

在线尝试！

J，19个字节

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

在线尝试！

• 主要动词 ]/:~"1/:
  • 最合适的 /:根据将对arg进行排序的顺序（指定顺序）对左边的arg（矩阵）进行排序。这对行进行排序。
  • 现在，将/:~"1根据指定的顺序再次对结果进行排序]。但是这一次，我们使用等级1进行排序，即，我们对每一行进行排序，这具有对列进行排序的作用。
• ],:/:我们应用以上同时使用指定的顺序]和等级达到指定的顺序/:。这给了我们想要的2个结果。

JavaScript（Node.js），77 70 68字节

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

在线尝试！

APL（Dyalog扩展），12 字节^SBCS

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

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

在线尝试！

⎕$u$[3,1,2]

⍮⍨ 并置自拍照 [[3,1,2],[3,1,2]]

⍋¨ 每个的排列反转 [[2,3,1],[2,3,1]]
⍛ 然后
⍮⍨ 与自己并置[[[2,3,1],[2,3,1]],[[3,1,2],[3,1,2]]]

⌷
∘
⎕ $A$
¨

J，17 16 15 14字节

-1感谢@Jonah

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

在线尝试！

木炭，24字节

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

在线尝试！链接是详细版本的代码。0索引。注意：尾随空格。说明：

    η                       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字节

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

在线尝试！

APL + WIN，21个字节

提示输入u，后跟a。在没有分隔符的情况下，在b的顶部上方立即输出b：

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

在线尝试！由Dyalog Classic提供

Perl 5、79个字节

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

在线尝试！

果冻， 12 11  13 字节

+2 :(修正B = C时的情况

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

双向链接，在左侧接受列表列表A（nby n），在右侧接受第一个n整数u列表，从而产生列表列表[B, C]。

在线尝试！

怎么样？

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

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

iasc 返回索引以对参数进行排序。

干净，91字节

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

在线尝试！

定义$ :: {{a}} [Int] -> [{{a}}]（与一起使用a = Int）采用数组数组和从零开始的索引列表，返回包含B和C的数组列表。

Python 3，91字节

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

在线尝试！

将参数作为2D和1D列表，并返回包含两个2D列表B和C的列表。我不确定是否有一种更干净的方法来处理所有for循环。

C ++（gcc），148142字节

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

在线尝试！

感谢@ceilingcat建议使用#import <queue>代替<vector>，它神秘地带来了std :: vector