Inspiriert von Entnommen aus einer Frage bei Stack Overflow .

Die Herausforderung

Bei einer gegebenen Ganzzahl n>1werden alle Arrays ausgegeben, die durch Austauschen von genau zwei Einträgen im Array erhalten werden können [1, 2, ..., n].

Die Arrays können in beliebiger Reihenfolge hergestellt werden.

Sie können konsequent [0, 1, ..., n-1](0-basiert) anstelle von [1, 2, ..., n](1-basiert) verwenden.

Zusätzliche Regeln

• Ein- und Ausgabe sind wie gewohnt flexibel .

• Programme oder Funktionen sind in jeder Programmiersprache zulässig . Standardlücken sind verboten.

• Kürzester Code in Bytes gewinnt.

Testfälle

Eingabe 2gibt Ausgabe (angenommen 1-basiert)

2 1

Eingabe 3gibt Ausgabe (beachten Sie, dass die drei Arrays in beliebiger Reihenfolge sein können)

1 3 2
2 1 3
3 2 1

Input 4gibt Output

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

Input 7gibt Output

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

Jelly , 11 8 Bytes

ŒcżU$y€R

Probieren Sie es online!

Wie es funktioniert

Œ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 Bytes

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

Probieren Sie es online!

Gibt eine Matrix zurück, in der jede Spalte eine Permutation ist.

combn(n,k)erzeugt alle Kombinationen von Größe kaus der Liste noder aus , 1:nwenn neine einzelne ganze Zahl ist. Optional kann auch eine Funktion FUNauf die resultierenden Kombinationen angewendet werden. Also schreiben wir eine Funktion, die den Swap durchführt und die Swap-Liste zurückgibt. Die Ergebnisse werden dann alle zu einer array, in diesem Fall zweidimensionalen und damit zu einer Matrix zusammengefasst.

Python 2 , 71 Bytes

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

Probieren Sie es online!

Verwendet diesen Tipp .

Haskell , 62 Bytes

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

Probieren Sie es online!

Ich erstelle einfach die Permutation, die gegeben ist, xund ytausche sie für jede ausx,y

Python 2 , 72 Bytes

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

Probieren Sie es online!

Wolfram Language (Mathematica) , 43 Byte

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

Probieren Sie es online!

Erläuterung: Subsets[Range@#,{2}]Generiert alle Teilmengen der {1,2,...,n}Größe 2 und /.tauscht dann für jede Teilmenge diese beiden Elemente in der Liste aus {1,2,...,n}.

Dieser Ansatz ist vielen anderen Einsendungen enttäuschend ähnlich, aber hier ist einer, der für Mathematica mit 3 zusätzlichen Bytes einzigartiger ist:

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

Probieren Sie es online!

Haskell, 62 Bytes

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

Probieren Sie es online!

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 Bytes

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

Probieren Sie es online!

Dies fügt die aktuelle Nummer an das Ende aller Permutationen von last an und berechnet dann alle Swaps, die die neue Nummer enthalten.

MATL , 12 Bytes

:2XN!"G:@tP(

Probieren Sie es online!

            %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 Bytes

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

Probieren Sie es online!

Oktave, 38 Bytes

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

Probieren Sie es online!

Erzeugt alle Permutationen von 1: n und wählt aus ihnen diejenigen aus, deren zwei Elemente sich von 1: n unterscheiden.

JavaScript (ES6), 81 Byte

Druckt 0-indizierte Arrays.

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

Demo

alert()wird console.log()in diesem Snippet aus Gründen der Benutzerfreundlichkeit durch ersetzt.

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 Bytes

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

Probieren Sie es online!

Sauber , 90 82 Bytes

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

Dies kann in 80 Bytes erfolgen, wird jedoch zu einer direkten Übersetzung der Haskell-Antworten.

Probieren Sie es online!

05AB1E , 15 9 Bytes

LœʒD{αĀO<

Probieren Sie es online!

Erläuterung

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

Schale , 9 Bytes

!2§kδ#≠Pḣ

Probieren Sie es online!

Erläuterung

!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 Bytes

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

Probieren Sie es online!

0-basierte Lösung

Der Trick dabei ist, dass die innere Schleife eine Iteration immer "überspringt": Wenn sie das erste Mal überhaupt nicht ausgeführt wird, dann nur einmal beim zweiten Durchgang und so weiter.

Ich war mit 55 Bytes zufrieden, bis ich sah, dass R bis auf 54 golfen werden konnte, also musste ich es auf 53 bringen.

Python 2 , 90 Bytes

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

Probieren Sie es online!

Pyth, 9 Bytes

t{.rLQ*=U

Demonstration

Der einfachste Weg, zwei Werte zu tauschen, ist die Verwendung von .rPyths Rotary Translation-Funktion. .r<list>[A, B]wird alle Vorkommen von tauschenA und Binlist .

Daher erzeugen wir durch Anwenden der Übersetzungsfunktion auf UQdie Liste von 0bis n-1mit jeweils zwei Elementen mit unterschiedlichen Nummern in der Liste die gewünschte Ausgabe. Qist der Eingang,n und Uist die Bereichsfunktion.

Der einfache Weg dies zu tun wäre:

.rLUQ.cUQ2

.cUQ2generiert alle 2 Elementkombinationen verschiedener Elemente im Bereich und .rLUQordnet die.r Funktion diesen und der Liste zuUQ .

Das wären jedoch 10 Bytes.

Anstatt .cUQ2die verschiedenen geordneten Paare zu bilden, können wir alle Paare mit bilden *=U. Dies ist implizit äquivalent zu *=UQQ. Es beginnt mit dem Überschreiben Qmit UQ, dann das kartesische Produkt der Einnahme UQund UQ. Dies gibt alle Zahlenpaare im Bereich an, die nicht notwendigerweise geordnet oder verschieden sind.

.rLQtauscht mit jeder Liste. Daran erinnern, dass Qjetzt gleich die Liste von 0bis ist n-1, nicht n.

Da die Paare nicht bestellt wurden, gibt es Duplikate. {entfernt Duplikate. Da die Paare nicht unterschiedlich waren, ist die unveränderte Liste vorhanden. Diese Liste steht nach der Deduplizierung immer an erster Stelle, da {die Reihenfolge des ersten Auftretens beibehalten wird und die unveränderte Liste durch Drehen um erstellt wird [0,0]. tEntfernt das erste Element und gibt die gewünschte Swap-Liste an.

Pyth, 11 Bytes

fq2snVTUQ.p

Probieren Sie es online aus
Nicht so kurz wie bei isaacg, aber anders genug, um es zu posten.

Erläuterung

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 Bytes

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

Ich bin rostig. Ich habe seit Monaten keinen Code mehr. Ich habe @Steadybox 'C portiert. Antwort mehr. . Kann wahrscheinlich noch mehr golfen werden.

Probieren Sie es hier aus.

Ruby , 66 Bytes

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

Probieren Sie es online!

Ruby , 80 Bytes

-12 Bytes dank 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]}

Probieren Sie es online!

Ich hatte einen Ansatz im Sinn, der aus irgendeinem Grund am besten in Ruby übersetzt wurde. Ich kenne Ruby nicht einmal wirklich.