คุณจะได้รับตารางเมทริกซ์และรายการ (หรือเวกเตอร์)ของความยาวที่มีหมายเลขผ่าน (หรือผ่าน ) งานของคุณคือการเรียงลำดับคอลัมน์และแถวของเมทริกซ์ตามคำสั่งที่ระบุไว้ในยู$n \times n$ยูn 1 n 0 n - 1$A$$u$$n$$1$$n$$0$$n-1$$A$$u$

นั่นคือคุณจะสร้างเมทริกซ์ที่องค์ประกอบ -th เป็นองค์ประกอบ -th ของ คุณควรแสดงผลลัพธ์ของการผกผันนี้ นั่นคือองค์ประกอบ (i, j) -th ของจะสิ้นสุดที่ตำแหน่งในเมทริกซ์ใหม่$B$$(i,j)$$(u(i),u(j))$$A$$A$$(u(i),u(j))$$C$

ตัวอย่างเช่นเมื่อได้รับ

ผลลัพธ์ควรเป็น

คุณสามารถรับอินพุตและเอาต์พุตผ่านเมธอด I / O เริ่มต้นใดก็ได้ คุณไม่จำเป็นต้องระบุว่า matrix ใดเป็นหรือตราบใดที่คุณส่งออกทั้งคู่ คุณอาจจะสมมติมีเพียงจำนวนเต็มบวกและคุณอาจจะใช้การจัดทำดัชนี 1 หรือ 0 ใช้สำหรับยูคุณจะต้องสนับสนุนการฝึกอบรมขึ้นไปอย่างน้อยขนาด64$B$$C$ยู64 × 64$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-basedo

MATL , 15 13 ไบต์

t3$)&Gw&St3$)

ปัจจัยการผลิตแล้วuA

เอาต์พุต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$นี่คือความสำเร็จด้วยฟังก์ชั่นการจัดเรียงของคู่

Python 3 ที่มีจำนวน 51ไบต์ 45

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

ลองออนไลน์!

-6 ไบต์ขอบคุณ @xnor

ฟังก์ชั่นใช้เวลาสองข้อโต้แย้งที่: numpyเมทริกซ์และเวกเตอร์การเปลี่ยนแปลงที่มีค่าจาก$0$ไป$n-1$ 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/:
  • ทางขวาส่วนใหญ่จะ/:เรียงอาร์กซ้าย (เมทริกซ์) ตามลำดับที่จะเรียงลำดับอาร์คขวา (ลำดับที่ระบุ) แถวนี้จะเรียงลำดับ
  • ตอนนี้ผลที่ได้รับการจัดเรียงอีกครั้งตามคำสั่งที่ระบุไว้/:~"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 Extended) , 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 ทันทีเหนือส่วนบนของ c โดยไม่มีตัวคั่น

(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

การเชื่อมโยง dyadic ยอมรับรายชื่อของรายการที่A( nจาก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) รับอาร์เรย์ของอาร์เรย์และรายการของดัชนี zero-based กลับรายการของอาร์เรย์ของอาร์เรย์ที่มี 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 ฉันไม่แน่ใจว่ามีวิธีที่สะอาดกว่าในการทำลูปทั้งหมด

C ++ (gcc) , 148 142 ไบต์

#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 ไปอย่างลึกลับ