เขียนฟังก์ชั่นที่ใช้ชุดจำนวนเต็มและพิมพ์การเรียงสับเปลี่ยนของชุดและการสลับที่ดำเนินการระหว่างแต่ละขั้นตอน

อินพุต

ชุดจำนวนเต็มตัวอย่างเช่น (0, 1, 2)

เอาท์พุต

รายการการเรียงสับเปลี่ยนและสลับในรูปแบบ (ชุด) (สลับ) (ชุด) ...

กรณีทดสอบ

Input: 
(3, 1, 5)

Output:
(3, 1, 5)
(3, 1)
(1, 3, 5)
(3, 5)
(1, 5, 3)
(1, 3)
(3, 5, 1)
(3, 5)
(5, 3, 1)
(3, 1)
(5, 1, 3)

กฎระเบียบ

• คุณสามารถจัดรูปแบบชุดตัวเลขได้ตามต้องการ
• คุณสามารถสลับในลำดับใดก็ได้
• คุณสามารถทำซ้ำพีชคณิตและแลกเปลี่ยนเพื่อรับใหม่
• รหัสของคุณไม่จำเป็นต้องทำการแลกเปลี่ยนจริงผลลัพธ์เพียงแค่แสดงให้เห็นว่าการสลับใดที่เกิดขึ้นระหว่างเอาท์พุทล่าสุดของคุณกับอันปัจจุบันของคุณ
• รหัสของคุณจำเป็นต้องใช้งานสำหรับชุดที่มี 2 องค์ประกอบขึ้นไป
• ชุดที่คุณได้รับจะไม่มีองค์ประกอบที่ทำซ้ำ (เช่น (0, 1, 1, 2) ไม่ถูกต้อง)

นี่คือรหัส - กอล์ฟดังนั้นรหัสที่สั้นที่สุดชนะ!

Mathematica, 102 ไบต์

<<Combinatorica`
Riffle[#,BlockMap[Pick[#[[1]],#!=0&/@({1,-1}.#)]&,#,2,1]]&@*MinimumChangePermutations

ตัวอย่าง

// คอลัมน์เพื่อผลลัพธ์ที่ชัดเจนยิ่งขึ้น

%[{1,3,5}]//Column
(*
{1,3,5}
{1,3}
{3,1,5}
{3,5}
{5,1,3}
{5,1}
{1,5,3}
{1,3}
{3,5,1}
{3,5}
{5,3,1}
*)

Java, 449 426 ไบต์

import java.util.*;interface P{static Set s=new HashSet();static void main(String[]a){o(Arrays.toString(a));while(s.size()<n(a.length)){p(a);o(Arrays.toString(a));}}static<T>void o(T z){System.out.println(z);s.add(z);}static int n(int x){return x==1?1:x*n(x-1);}static void p(String[]a){Random r=new Random();int l=a.length,j=r.nextInt(l),i=r.nextInt(l);String t=a[j];a[j]=a[i];a[i]=t;System.out.println("("+a[j]+","+t+")");}}

วิธีการกำลังดุร้าย มันทำการสุ่มสลับจนกว่าจะมีการเรียงสับเปลี่ยนที่เป็นไปได้ทั้งหมด มันใช้ชุดของการเป็นตัวแทนสตริงของอาร์เรย์เพื่อตรวจสอบจำนวนรัฐที่แตกต่างกันได้ถูกสร้างขึ้น สำหรับจำนวนเต็ม n ตัวมี n! = 1 * 2 * 3 * .. * n การเปลี่ยนลำดับที่แตกต่างกัน

ปรับปรุง

• ทำตามคำแนะนำของ Kevin Cruijssen เพื่อตีกอล์ฟให้มากขึ้น

Ungolfed:

import java.util.*;

interface P {

    static Set<String> s = new HashSet<>();

    static void main(String[] a) {
        // prints the original input
        o(Arrays.toString(a));
        while (s.size() < n(a.length)) {
            p(a);
            // prints the array after the swap
            o(Arrays.toString(a));
        }
    }

    static void o(String z) {
        System.out.println(z);
        // adds the string representation of the array to the HashSet
        s.add(z);
    }

    // method that calculates n!
    static int n(int x) {
        if (x == 1) {
            return 1;
        }
        return x * n(x - 1);
    }

    // makes a random swap and prints what the swap is
    static void p(String[] a) {
        Random r = new Random();
        int l = a.length, j = r.nextInt(l), i = r.nextInt(l);
        String t = a[j];
        a[j] = a[i];
        a[i] = t;
        System.out.println("(" + a[j] + "," + t + ")");
    }
}

การใช้งาน:

$ javac P.java
$ java P 1 2 3
[1, 2, 3]
(2,1)
[2, 1, 3]
(1,1)
[2, 1, 3]
(2,2)
[2, 1, 3]
(3,1)
[2, 3, 1]
(3,1)
[2, 1, 3]
(1,2)
[1, 2, 3]
(1,1)
[1, 2, 3]
(3,2)
[1, 3, 2]
(2,3)
[1, 2, 3]
(3,1)
[3, 2, 1]
(3,1)
[1, 2, 3]
(3,3)
[1, 2, 3]
(1,2)
[2, 1, 3]
(1,3)
[2, 3, 1]
(1,2)
[1, 3, 2]
(3,1)
[3, 1, 2]

อย่างที่คุณเห็นมีการแลกเปลี่ยนมากกว่าจำนวนขั้นต่ำที่จำเป็น แต่ดูเหมือนว่าจะทำงาน :-D

ในฐานะที่เป็นโบนัสมันทำงานได้กับสตริงเช่นกัน

$ java P 'one' 'two'
[one, two]
(two,one)
[two, one]

JavaScript (ES6), 186 ไบต์

f=
a=>{console.log(a);d=a.slice().fill(-1);s=[...d.keys()];for(i=l=a.length;i;)s[k=(j=s.indexOf(--i))+d[i]]<i?(console.log(a[s[j]=s[k]],a[s[k]=i]),console.log(s.map(n=>a[n])),i=l):d[i]*=-1}
;

<input id=i><input type=button value=Go! onclick=f(i.value.split`,`)>

หมายเหตุ: ฉันไม่แน่ใจว่ารูปแบบเอาต์พุตมีความยืดหยุ่นอย่างไรฉันอาจทำสิ่งนี้ได้ 171 ไบต์:

a=>{console.log(a);d=a.slice().fill(-1);s=[...d.keys()];for(i=l=a.length;i;)s[k=(j=s.indexOf(--i))+d[i]]<i?console.log(a[s[j]=s[k]],a[s[k]=i],s.map(n=>a[n],i=l)):d[i]*=-1}

ทำงานโดยการดำเนินการตามอัลกอริทึมSteinhaus – Johnson – Trotterในดัชนีแบบสุ่มและแปลกลับไปเป็นอาร์เรย์อินพุท Ungolfed:

function steps(array) {
    console.log(array); // initial row
    var d = a.slice().fill(-1); // direction values
    var s = [...a.keys()]; // initial (identity) shuffle
    var l = a.length;
    for (var i = l; i; ) { // start by trying to move the last element
        var j = s.indexOf(--i);
        var k = j + d[i]; // proposed exchange
        if (s[k] < i) { // only exchange with lower index (within bounds)
            console.log(a[s[k]],a[i]); // show values being exchanged
            s[j] = s[k];
            s[k] = i; // do the exchange on the shuffle
            console.log(s.map(n=>a[n])); // show the shuffled array
            i = l; // start from the last element again
        } else {
            d[i] *= -1; // next time, try moving it the other way
        } // --i above causes previous element to be tried
    } // until no movable elements can be found
}

Ruby, 86 ไบต์

puts (2..(a=gets.scan(/\d+/).uniq).size).map{|i|a.permutation(i).map{|e|?(+e*", "+?)}}

Haskell - 135 ไบต์

p=permutations;f=filter
q(a:b:xs)=(\x->f(uncurry(/=)).zip x)a b:q(b:xs);q _=[]
l=head.f(all((==2).length).q).p.p
f=zip.l<*>map head.q.l

เอาท์พุท:

> f [3,1,5]
[([3,1,5],(3,1)),([1,3,5],(3,5)),([1,5,3],(1,5)),([5,1,3],(1,3)),([5,3,1],(5,3))]

ฉันกำลังใช้permutationsฟังก์ชั่นมาตรฐานซึ่งไม่ได้ขึ้นอยู่กับการแลกเปลี่ยนดังนั้นฉันจึงใช้พีชคณิตของพีชคณิตและหาสิ่งที่เกิดขึ้นเป็นเชนของการแลกเปลี่ยน