Lấy cảm hứng từ Taken từ một câu hỏi tại Stack Overflow .

Các thách thức

Cho một số nguyên n>1, xuất ra tất cả các mảng có thể thu được bằng cách hoán đổi chính xác hai mục trong mảng [1, 2, ..., n].

Các mảng có thể được sản xuất theo thứ tự bất kỳ.

Bạn luôn có thể sử dụng [0, 1, ..., n-1](dựa trên 0) thay vì [1, 2, ..., n](dựa trên 1).

Quy tắc bổ sung

• Đầu vào và đầu ra linh hoạt như bình thường .

• Các chương trình hoặc chức năng được cho phép, trong bất kỳ ngôn ngữ lập trình . Sơ hở tiêu chuẩn bị cấm.

• Mã ngắn nhất trong byte thắng.

Các trường hợp thử nghiệm

Đầu vào 2cho đầu ra (giả định 1 dựa trên)

2 1

Đầu vào 3cho đầu ra (lưu ý rằng ba mảng có thể theo thứ tự bất kỳ)

1 3 2
2 1 3
3 2 1

Đầu vào 4cho đầu ra

1 2 4 3
1 3 2 4
1 4 3 2
2 1 3 4
3 2 1 4
4 2 3 1

Đầu vào 7cho đầu ra

1 2 3 4 5 7 6
1 2 3 4 6 5 7
1 2 3 4 7 6 5
1 2 3 5 4 6 7
1 2 3 6 5 4 7
1 2 3 7 5 6 4
1 2 4 3 5 6 7
1 2 5 4 3 6 7
1 2 6 4 5 3 7
1 2 7 4 5 6 3
1 3 2 4 5 6 7
1 4 3 2 5 6 7
1 5 3 4 2 6 7
1 6 3 4 5 2 7
1 7 3 4 5 6 2
2 1 3 4 5 6 7
3 2 1 4 5 6 7
4 2 3 1 5 6 7
5 2 3 4 1 6 7
6 2 3 4 5 1 7
7 2 3 4 5 6 1

Thạch , 11 8 byte

ŒcżU$y€R

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

ŒcżU$y€R  Main link. Argument: n

Œc        Take all 2-combinations of [1, ..., n].
  żU$     Zip the result with the reversed pairs.
       R  Range; yield [1, ..., n].
     y€   For each [[i, j], [j, i]] in the result to the left, yield the result to
          the right, with i replaced by j and vice versa. 

R , 54 byte

function(n)combn(n,2,function(x){z=1:n
z[x]=rev(x)
z})

Hãy thử trực tuyến!

Trả về một ma trận trong đó mỗi cột là một hoán vị.

combn(n,k)tạo ra tất cả các kết hợp kích thước ktừ danh sách nhoặc từ 1:nnếu nlà một số nguyên duy nhất. Nó cũng tùy chọn có một chức năng FUNđược áp dụng cho các kết hợp kết quả. Vì vậy, chúng tôi viết một hàm thực hiện trao đổi và trả về danh sách hoán đổi. Các kết quả sau đó được tích lũy thành một array, trong trường hợp này là 2 chiều và do đó là một ma trận.

Python 2 , 71 byte

r=range(input())
print[map({i:j,j:i}.get,r,r)for i in r for j in r[:i]]

Hãy thử trực tuyến!

Sử dụng mẹo này .

Haskell , 62 byte

f n=[[1..x-1]++y:[x+1..y-1]++x:[y+1..n]|x<-[1..n],y<-[x+1..n]]

Hãy thử trực tuyến!

Tôi chỉ tạo ra hoán vị, cho xvà ytrao đổi, cho mỗix,y

Python 2 , 72 byte

r=range(input())
for j in r:
 for i in r[:j]:t=r*1;t[i]=j;t[j]=i;print t

Hãy thử trực tuyến!

Ngôn ngữ Wolfram (Mathicala) , 43 byte

r/.{#->#2,#2->#}&@@@Subsets[r=Range@#,{2}]&

Hãy thử trực tuyến!

Giải thích: Subsets[Range@#,{2}]tạo tất cả các tập hợp con có {1,2,...,n}kích thước 2, sau đó cho mỗi tập hợp con, /.hoán đổi hai điều đó trong danh sách {1,2,...,n}.

Cách tiếp cận này tương tự một cách đáng thất vọng với nhiều bài nộp khác, nhưng đây là một cách độc đáo hơn với Mathicala, với 3 byte bổ sung:

r~Permute~Cycles@{#}&/@Subsets[r=Range@#,{2}]&

Hãy thử trực tuyến!

Haskell, 62 byte

g n|b<-[1..n]=[[last$k:[j|k==i]++[i|k==j]|k<-b]|i<-b,j<-b,j<i]

Hãy thử trực tuyến!

i<-b                -- loop 'i' through [1..n]
     j<-b           -- loop 'j' through [1..n]
          j<i       -- consider only cases where j<i 
 [            k<-b] -- make a list by looping 'k' through [1..n] 
  last              -- pick
          [i|k==j]  -- 'i' if k==j
       [j|k==i]     -- 'j' if k==i
     k              -- 'k' else   

Haskell , 71 byte

f 0=[]
f x=map(++[x])(f$x-1)++[[1..y-1]++x:[y+1..x-1]++[y]|y<-[1..x-1]]

Hãy thử trực tuyến!

Điều này thêm số hiện tại vào cuối của tất cả các hoán vị cuối cùng và sau đó tính toán tất cả các giao dịch hoán đổi bao gồm số mới.

MATL , 12 byte

:2XN!"G:@tP(

Hãy thử trực tuyến!

            %implicit input, say, 4
:           %range, stack is {[1,2,3,4]}
2           %push 2
XN          %nchoosek, compute all combinations of [1,2,3,4] taken 2 at a time
            %this results in a matrix where each row is a combination, i.e.,
            %[1, 2;
              1, 3;
              1, 4;
              2, 3;
              2, 4;
              3, 4]
!           %transpose, because "for" iterates over columns
"           %begin for loop
G:          %push input and range, stack is now [1,2,3,4]
@t          %push "for" index (the column), say, [1;2], twice
P           %flip array, so stack is now: {[1,2,3,4],[1;2],[2;1]}
(           %assignment index, sets [1,2,3,4]([1;2])=[2;1],
            %resulting in [2,1,3,4]
            %implicit end of loop, implicit end of program, print the stack implicitly.

C, 93 byte

i,j,k;f(n){for(i=0;i++<n;)for(j=i;j++<n;puts(""))for(k=0;k++<n;)printf("%d ",k-i?k-j?k:i:j);}

Hãy thử trực tuyến!

Octave, 38 byte

@(n)(p=perms(k=1:n))(sum(p~=k,2)==2,:)

Hãy thử trực tuyến!

Tạo tất cả các hoán vị của 1: n và chọn từ chúng những phần tử có hai phần tử khác nhau từ 1: n.

JavaScript (ES6), 81 byte

In các mảng 0 chỉ mục.

n=>(a=[...Array(n).keys()]).map(i=>a.map(j=>i>j&&alert(a.map(k=>k-i?k-j?k:i:j))))

Bản giới thiệu

alert()được thay thế bằng console.log()trong đoạn trích này vì sự thân thiện với người dùng.

let f =

n=>(a=[...Array(n).keys()]).map(i=>a.map(j=>i>j&&alert(a.map(k=>k-i?k-j?k:i:j))))

alert = s => console.log(JSON.stringify(s));

f(4)

Python 2 , 75 byte

lambda n:[r(i)+[j]+r(i+1,j)+[i]+r(j+1,n)for j in r(n)for i in r(j)]
r=range

Hãy thử trực tuyến!

Sạch , 90 82 byte

import StdEnv
$n#n=[1..n]
=tl(removeDup[[if(c<>b)if(c<>a)c b a\\c<-n]\\b<-n,a<-n])

Nó có thể được thực hiện trong 80 byte, nhưng nó biến thành bản dịch trực tiếp các câu trả lời của Haskell.

Hãy thử trực tuyến!

05AB1E , 15 9 byte

LœʒD{αĀO<

Hãy thử trực tuyến!

Giải trình

L            # push range [1 ... input]
 œ           # get all permutations
  ʒ          # filter, keep only elements that are true when
     α       # absolute value is taken with
   D{        # a sorted copy
      Ā      # each non-zero value in the resulting array is converted to 1
       O     # the array is summed
        <    # and the sum is decremented

Husk , 9 byte

!2§kδ#≠Pḣ

Hãy thử trực tuyến!

Giải trình

!2§kδ#≠Pḣ  Input is an integer n.
        ḣ  Range: r=[1,2,..,n]
       P   Permutations of r.
   k       Classify by
     #     number of elements
      ≠    that are different from
  § δ      the corresponding element of r.
!2         Take the second class.

Ruby , 55 53 byte

->n{n.times{|x|x.times{|y|(w=*0...n)[w[x]=y]=x;p w}}}

Hãy thử trực tuyến!

Giải pháp dựa trên 0

Mẹo ở đây là vòng lặp bên trong luôn "bỏ qua" một lần lặp: lần đầu tiên nó không được thực hiện, sau đó chỉ một lần trên đường chuyền thứ hai, v.v.

Tôi hài lòng với 55 byte cho đến khi tôi thấy R có thể bị đánh xuống 54, vì vậy tôi phải đưa nó lên 53.

Python 2 , 90 byte

f=lambda n,r=range:n*[n]and[a+[n]for a in f(n-1)]+[r(1,i)+[n]+r(i+1,n)+[i]for i in r(1,n)]

Hãy thử trực tuyến!

Bình thường, 9 byte

t{.rLQ*=U

Trình diễn

Cách dễ nhất để trao đổi hai giá trị là sử dụng .r , đó là chức năng dịch xoay của Pyth. .r<list>[A, B]sẽ trao đổi tất cả các lần xuất hiện Avà Btronglist .

Do đó, bằng cách áp dụng chức năng dịch cho UQ, danh sách từ0 để n-1với mỗi danh sách hai yếu tố của các số khác nhau trong danh sách, chúng ta sẽ tạo ra kết quả mong muốn. Qlà đầu vào, nvà Ulà hàm phạm vi.

Cách dễ dàng để làm điều này sẽ là:

.rLUQ.cUQ2

.cUQ2 tạo ra tất cả 2 kết hợp phần tử của các phần tử riêng biệt trong phạm vi và .rLUQ ánh xạ .rhàm qua chúng và danh sách UQ.

Tuy nhiên, đó sẽ là 10 byte.

Thay vì thực hiện .cUQ2, các cặp theo thứ tự riêng biệt, chúng ta có thể tạo tất cả các cặp với *=U. Điều này là hoàn toàn tương đương với *=UQQ. Nó bắt đầu bằng cách ghi đè Qbằng UQ, sau đó lấy sản phẩm của CartesianUQ và UQ. Điều này cung cấp cho tất cả các cặp số trong phạm vi, không nhất thiết phải có thứ tự hoặc khác biệt.

.rLQhoán đổi sử dụng mỗi danh sách. Nhớ lại rằng Qbây giờ bằng với danh sách từ 0đếnn-1 , không n.

Bởi vì các cặp không được đặt hàng, có những bản sao. {loại bỏ trùng lặp. Bởi vì các cặp không khác biệt, danh sách không thay đổi là hiện tại. Danh sách này sẽ luôn là đầu tiên sau khi lặp lại, bởi vì {duy trì thứ tự xuất hiện đầu tiên và danh sách không thay đổi được tạo ra bằng cách xoay theo [0,0]. tloại bỏ phần tử đầu tiên, đưa ra danh sách các giao dịch hoán đổi mong muốn.

Bình thường, 11 byte

fq2snVTUQ.p

Dùng thử trực tuyến
Không ngắn như cách tiếp cận của isaacg, nhưng đủ khác nhau để đăng.

Giải trình

fq2snVTUQ.p
         .pQ  Take the permutations of the (implicit) range [0,...,input].
f     T       Filter to get the permutations...
   snV UQ     ... where the number of differences with [0,...,input]...
 q2           ... is 2.

Java 8, 109 105 byte

n->{String r="";for(int i=0,j,k;i++<n;)for(j=i;j++<n;r+="\n")for(k=0;k++<n;)r+=k!=i?k!=j?k:i:j;return r;}

Tôi đang hoen gỉ .. Không được chơi golf trong nhiều tháng .. Đã kết thúc câu trả lời @Steadybox 'C .. Có thể có thể chơi gôn thêm.

Hãy thử nó ở đây.

Ruby , 66 byte

->n{a=*1..n
a.permutation.select{|b|b.zip(a).count{|c,d|c!=d}==2}}

Hãy thử trực tuyến!

Hồng ngọc , 80 byte

-12 byte nhờ Unihedron.

->n{(r=1..n).map{|x|r.map{|y|r.map{|i|i==x ?y:i==y ?x:i}}}.flatten(1).uniq[1,n]}

Hãy thử trực tuyến!

Tôi đã có một cách tiếp cận trong tâm trí rằng dịch tốt nhất cho Ruby vì một số lý do vì vậy ... tôi thậm chí không thực sự biết Ruby ...