Натхненний узятим із запитання в Stack Overflow .

Змагання

Враховуючи ціле число n>1, виведіть усі масиви, які можна отримати, замінивши рівно два записи в масиві [1, 2, ..., n].

Масиви можна виготовити в будь-якому порядку.

Ви можете послідовно використовувати [0, 1, ..., n-1](на основі 0) замість [1, 2, ..., n](на основі 1).

Додаткові правила

• Введення та вихід гнучкі, як завжди .

• Програми або функції дозволені на будь- якій мові програмування . Стандартні лазівки заборонені.

• Найкоротший код у байтах виграє.

Тестові справи

Вхід 2дає вихід (на основі 1)

2 1

Введення 3дає вихід (зауважте, що три масиви можуть бути в будь-якому порядку)

1 3 2
2 1 3
3 2 1

Вхід 4дає вихід

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

Вхід 7дає вихід

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

Желе , 11 8 байт

ŒcżU$y€R

Спробуйте в Інтернеті!

Як це працює

Œ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 байти

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

Спробуйте в Інтернеті!

Повертає матрицю, де кожен стовпець є перестановкою.

combn(n,k)генерує всі комбінації розмірів kзі списку nабо з, 1:nякщо nце єдине ціле число. Він також необов'язково приймає функцію, FUNяку слід застосувати до результативних комбінацій. Таким чином, ми пишемо функцію, яка виконує своп і повертає замінений список. Потім усі результати накопичуються в arrayвеличину, яка в даному випадку є двовимірною і, отже, матрицею.

Python 2 , 71 байт

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

Спробуйте в Інтернеті!

Використовує цю пораду .

Хаскелл , 62 байти

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

Спробуйте в Інтернеті!

Я просто генерую перестановку, зважаючи на xта yдля заміни, для кожноїx,y

Python 2 , 72 байти

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

Спробуйте в Інтернеті!

Мова Вольфрама (Mathematica) , 43 байти

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

Спробуйте в Інтернеті!

Пояснення: Subsets[Range@#,{2}]генерує всі підмножини {1,2,...,n}розміром 2, потім для кожного підмножини /.підміняє ці дві речі у списку {1,2,...,n}.

Цей підхід розчаровує подібний до багатьох інших матеріалів, але ось один, більш унікальний для Mathematica, на 3 додаткові байти:

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

Спробуйте в Інтернеті!

Хаскелл, 62 байти

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

Спробуйте в Інтернеті!

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 байт

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

Спробуйте в Інтернеті!

Це додає поточне число до кінця всіх перестановок останнього, а потім обчислює всі свопи, що включають нове число.

MATL , 12 байт

:2XN!"G:@tP(

Спробуйте в Інтернеті!

            %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 байти

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);}

Спробуйте в Інтернеті!

Октава, 38 байт

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

Спробуйте в Інтернеті!

Створює всі перестановки 1: n і вибирає з них ті, у яких два елементи, відмінні від 1: n.

JavaScript (ES6), 81 байт

Друкує 0-індексовані масиви.

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

Демо

alert()замінюється console.log()у цьому фрагменті для зручності користування.

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 байт

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

Спробуйте в Інтернеті!

Чисто , 90 82 байт

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

Це можна зробити в 80 байт, але це перетворюється на прямий переклад відповідей Haskell.

Спробуйте в Інтернеті!

05AB1E , 15 9 байт

LœʒD{αĀO<

Спробуйте в Інтернеті!

Пояснення

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

Лушпиння , 9 байт

!2§kδ#≠Pḣ

Спробуйте в Інтернеті!

Пояснення

!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 байти

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

Спробуйте в Інтернеті!

Розчин на основі 0

Хитрість тут полягає в тому, що внутрішня петля завжди "пропускає" ітерацію: перший раз вона взагалі не виконується, потім лише один раз на другий прохід і так далі.

Я був задоволений 55 байтами, поки не побачив, що R може бути в гольф до 54, тому мені довелося дістати його до 53.

Python 2 , 90 байт

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

Спробуйте в Інтернеті!

Pyth, 9 байт

t{.rLQ*=U

Демонстрація

Найпростіший спосіб змінити два значення - це використання .r, яке є функцією обертового перекладу Pyth. .r<list>[A, B]буде поміняти місцями всі події Aта Bвlist .

Тому, застосувавши функцію перекладу до UQсписку від 0до n-1кожного зі списку двох елементів різних чисел у списку, ми створимо потрібний вихід. Qє входом, nі Uє функцією діапазону.

Найпростіший спосіб зробити це:

.rLUQ.cUQ2

.cUQ2генерує всі 2 комбінації елементів різних елементів у діапазоні та .rLUQвідображає .rфункцію над ними та списком UQ.

Однак це було б 10 байт.

Замість того, щоб робити .cUQ2різні впорядковані пари, ми можемо зробити всі пари за допомогою *=U. Це неявно рівнозначно *=UQQ. Вона починається перезапис Qз UQ, а потім приймати декартовій твір UQі UQ. Це дає всі пари чисел у діапазоні, не обов'язково впорядковані чи розрізнені.

.rLQсвопи за допомогою кожного списку. Нагадаємо, що Qзараз дорівнює списку від 0до n-1, ні n.

Оскільки пари не були замовлені, є дублікати. {видаляє дублікати. Оскільки пари не були різними, список незмінних є. Цей список завжди буде першим після дедуплікації, оскільки {зберігається порядок першої появи, а незмінний список виробляється обертанням на [0,0]. tвидаляє перший елемент, надаючи потрібний список свопів.

Pyth, 11 байт

fq2snVTUQ.p

Спробуйте в Інтернеті
Не такий короткий, як підхід Isaacg, але досить інший для публікації.

Пояснення

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 байт

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

Я іржавий .. Не мав коду в гольф за місяці .. Закінчився перенесенням відповіді на @Steadybox 'C .. Можливо, можливо, ще можна пограти в гольф.

Спробуйте тут.

Рубін , 66 байт

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

Спробуйте в Інтернеті!

Рубін , 80 байт

-12 байт завдяки 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]}

Спробуйте в Інтернеті!

Я мав на увазі підхід, який найкраще чомусь переклав на Рубі, тому я навіть не знаю Рубі ...