অনুমানের পদক্ষেপ

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

আমরা কি এলোমেলো ব্যবহার করতে পারি?

— Zgarb

আপনি বলতে চাইছেন যতক্ষণ না আপনি সমস্ত ক্রমশক্তি অর্জনের জন্য ঘটেন কেবলমাত্র এলোমেলোভাবে অদলবদল করুন? হ্যাঁ, তবে আপনাকে অবশ্যই নিশ্চিত হতে হবে যে সমস্ত

— অনুমতিপত্র

পিপিসিজিতে আপনাকে স্বাগতম! ভাল প্রথম চ্যালেঞ্জ। আমি উদাহরণটি সম্পাদনা করার পরামর্শ দেব যাতে উপাদানগুলি সূচকগুলি যেমন ব্যবহারের সেট (3, 1, 4)বা এমন কিছুর সাথে বিভ্রান্ত না হয় - প্রথমবার এটি পড়ে আমি খুব বিভ্রান্ত হয়ে পড়েছিলাম কারণ প্রথম 0,1অদলবদলগুলি উপাদানগুলি 0,1সূচকগুলিও বদলে যায় 0,1তবে তারপরে পরবর্তী অদলবদল সেই প্যাটার্নটি অনুসরণ করে নি। আমি আপনাকে স্যান্ডবক্সেও নির্দেশ করব যেখানে আপনি চ্যালেঞ্জগুলি পোস্ট করতে এবং সেগুলি মূল সাইটে পোস্ট করার আগে প্রতিক্রিয়া পেতে পারেন।

— অ্যাডমবর্কবার্ক

@ টিমিডি পরামর্শের জন্য ধন্যবাদ, আমি উদাহরণটি পরিবর্তন করেছি। আমি এই পোস্ট করার ঠিক পরে স্যান্ডবক্সের লিঙ্কটি দেখেছি, আমি এখন থেকে সেখানে প্রথমে পোস্ট করব!

— বিলিয়্যো

Steinhaus-জনসন-Trotter অ্যালগরিদম ন্যূনতম প্রয়োজনীয় ক্রম তৈরি করে।

— নীল

Answer 1

গণিত, ১০২ বাইট

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

জাভা, 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+")");}}

নিষ্ঠুর শক্তি পদ্ধতির। সমস্ত সম্ভাব্য ক্রমবিকাশ না হওয়া পর্যন্ত এটি এলোমেলোভাবে অদলবদল করে keeps কতগুলি পৃথক রাজ্য উত্পন্ন হয়েছে তা পরীক্ষা করতে এটি অ্যারের স্ট্রিং প্রতিনিধিত্বের একটি সেট ব্যবহার করে। এন বিভিন্ন পূর্ণসংখ্যার জন্য এন আছে! = 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

আপনার পদ্ধতিটি ব্যবহার করে দেখার জন্য আপনার কাছে কি কোনও গল্ফ সংস্করণ রয়েছে?

— বিলিওয়ো

@ বিলিওয়ে: আন-গল্ফ কোড যুক্ত করা হয়েছে। যাইহোক সেখানে অভিনব কিছুই নেই :-)

— মাস্টার_এক্স

আপনি এটি কিছুটা গল্ফ করতে পারেন ফিক্স সতর্কবার্তা করার কোন প্রয়োজন নেই, তাই আপনি সেট ঘোষণা মুছে যাবে: 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

জাভাস্ক্রিপ্ট (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}

সূচকগুলির সাফল্যের অ্যারেতে স্টিনহাউস – জনসন – ট্রটার অ্যালগরিদম সম্পাদন করে এবং ইনপুট অ্যারেটিতে অনুবাদ করে কাজ করে। 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ফাংশনটি ব্যবহার করছি , যা অদলবদলের উপর ভিত্তি করে নয়, তাই আমি অনুমতিগুলির ক্রমশক্তি গ্রহণ করছি এবং এমন একটি সন্ধান করছি যা অদলবদলের শৃঙ্খলে ঘটে।