क्रमचय के चरण

Question

एक फ़ंक्शन लिखें जो पूर्णांक का एक सेट लेता है और सेट के प्रत्येक क्रमांकन को प्रिंट करता है, और प्रत्येक चरण के बीच में स्वैप किया जाता है

इनपुट

पूर्णांक का एक सेट, उदाहरण के लिए (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) अमान्य है)

यह कोड-गोल्फ है, इसलिए सबसे छोटा कोड जीतता है!

Comments

क्या हम यादृच्छिकता का उपयोग कर सकते हैं?

— जर्गर्ब

आपका मतलब है कि जब तक आप सभी क्रमपरिवर्तन प्राप्त नहीं कर लेते, तब तक यादृच्छिक स्वैप का भार क्या है? हां, लेकिन आपको यह सुनिश्चित करना होगा कि सभी क्रमांकन मुद्रित हो गए हैं

— बिलीयो

PPCG में आपका स्वागत है! अच्छी पहली चुनौती। मैं उदाहरण को संपादित करने का सुझाव दूंगा ताकि तत्व सूचकांकों के साथ भ्रमित न हों, जैसे सेट (3, 1, 4)या तो - इसे पहली बार पढ़कर मैं बहुत उलझन में था क्योंकि पहले स्वैप 0,1ने तत्वों की अदला- बदली की थी0,1 लेकिन यह भी सूचकांक 0,1है, लेकिन फिर अगले स्वैप ने उस पैटर्न का पालन नहीं किया। मैं आपको सैंडबॉक्स की ओर भी इशारा करूंगा जहां आप मुख्य साइट पर पोस्ट करने से पहले चुनौतियों का सामना कर सकते हैं और प्रतिक्रिया प्राप्त कर सकते हैं।

— AdmBorkBork

@ सुझाव के लिए धन्यवाद, मैंने उदाहरण बदल दिया है। मैंने इसे पोस्ट करने के ठीक बाद सैंडबॉक्स का लिंक देखा, मैं अब से सबसे पहले वहां पोस्ट करूँगा!

— बिलॉयो

Steinhaus-जॉनसन-ट्रोटर एल्गोरिथ्म न्यूनतम आवश्यक अनुक्रम उत्पन्न करता है।

— नील

Answer 1

गणितज्ञ, 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}
*)

Answer 2

जावा, ४४ ९ 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 अलग क्रमपरिवर्तन।

अपडेट करें

• केविन क्रूज़सेन के सुझावों पर अमल करने के लिए इसे थोड़ा और बढ़ाएँ।

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]

जैसा कि आप देख सकते हैं कि आवश्यक न्यूनतम से कई अधिक स्वैप हैं। लेकिन यह काम करने लगता है :- डी

एक बोनस के रूप में, यह स्ट्रिंग्स के साथ भी काम करता है, अर्थात

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

Comments

क्या आपके पास हमारे उपयोग करने के तरीके पर एक नज़र डालने के लिए हमारे पास एक अन-गोल्फ संस्करण है?

— बिलियोयो

@ बिलियो: अन-गोल्फ कोड जोड़ा गया। कुछ भी नहीं है लेकिन वहाँ फैंसी

— Master_ex

आप इसे थोड़ा गोल्फ कर सकते हैं। चेतावनी को ठीक करने की कोई आवश्यकता नहीं है, इसलिए आप सेट घोषणाओं को हटा सकते हैं Set s=new HashSet();:। विधि में आपका कोड nएकल रिटर्न हो सकता है static int n(int x){return x==1?1:x*n(x-1);}:। और अगर आप की जगह ले सकता String zअपनी पद्धति में oएक सामान्य बजाय साथ: static<T>void o(T z){System.out.println(z);s.add(z);}। सभी ने मिलकर इसे 426 बाइट्स में बदल दिया ।

— केविन क्रूज़सेन

Answer 3

जावास्क्रिप्ट (ईएस 6), 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
}

Answer 4

रूबी, 86 बाइट्स

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

Answer 5

हास्केल - 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फ़ंक्शन का उपयोग कर रहा हूं , जो कि स्वैप पर आधारित नहीं है, इसलिए मैं क्रमपरिवर्तन की प्रक्रिया ले रहा हूं और एक खोज कर रहा हूं जो स्वैप की श्रृंखला होती है।