একটি তালিকার সমস্ত সম্ভাব্য ক্রম তৈরি করতে অ্যালগরিদম?

Question

বলুন আমার কাছে এন উপাদানগুলির একটি তালিকা রয়েছে, আমি জানি যে এন রয়েছে! এই উপাদানগুলি অর্ডার করার সম্ভাব্য উপায়গুলি। এই তালিকার সমস্ত সম্ভাব্য ক্রম উত্পন্ন করার জন্য একটি অ্যালগরিদম কী? উদাহরণস্বরূপ, আমার কাছে [a, b, c] তালিকা রয়েছে। অ্যালগরিদম ফিরে আসত [[a, b, c], [a, c, b,], [b, a, c], [b, c, a], [c, a, b], [c, b , ক]]।

আমি এখানে এটি পড়ছি http://en.wikedia.org/wiki/Parration#Algorithms_to_generate_permutations

তবে উইকিপিডিয়া কখনও ব্যাখ্যা করতে ভাল হয়নি। আমি এর অনেক কিছুই বুঝতে পারি না।

Comments

আমি একবারে অনুমান উত্পন্ন করার বিষয়ে অন্য প্রশ্নের বিস্তৃত উত্তর লিখেছিলাম। আমার মনে হয় এটা আপনার আগ্রহের হবেন: stackoverflow.com/questions/1506078/...

— Joren

এটি আপনার সমস্যার সমাধান করতে পারে en.wikedia.org/wiki/Heap's_algorithm

— ফেলিক্স

Answer 1

মূলত, প্রতিটি আইটেমের জন্য বাম থেকে ডানে, বাকী সমস্ত আইটেমের ক্রম উত্পন্ন হয় (এবং প্রত্যেকে বর্তমান উপাদানগুলির সাথে যুক্ত করা হয়)। শেষ আইটেমটি পৌঁছানোর আগ পর্যন্ত কেবলমাত্র একটি সম্ভাব্য ক্রম রয়েছে এমন না হওয়া পর্যন্ত এটি পুনরাবৃত্তভাবে (বা যদি আপনি ব্যথা পছন্দ করেন তবে পুনরাবৃত্তভাবে) করা যেতে পারে।

সুতরাং [1,2,3,4] তালিকার সাথে 1 দিয়ে শুরু হওয়া সমস্ত ক্রম উত্পাদিত হয়, তারপরে সমস্ত শুরু হয় যা 2 দিয়ে শুরু হয়, তারপরে 3 তারপর 4।

এটি কার্যকরভাবে চারটি আইটেমের একটি তালিকার তিনটি আইটেমের তালিকার একের অনুমতি পেতে সক্রিয় করে reduces 2 এবং তারপরে 1 টি আইটেমের তালিকা হ্রাস করার পরে তাদের সমস্তটি পাওয়া যাবে।
3 টি রঙিন বল ব্যবহার করে প্রক্রিয়া অনুমোদনের উদাহরণ:
( https://en.wikedia.org/wiki/Permutes#/media/File:Pramutations_RGB.svg - https://commons.wikimedia.org/wiki/File:Perutations_RGB। এসভিজি )

Comments

আমি প্রথমে এটি সম্পর্কে ভেবেছিলাম কিন্তু তারপরে বর্তমান উপাদানটি নীচের কিছুটির মধ্যে ফেলবে না। সুতরাং সমস্ত আদেশ উত্পন্ন হবে না।

— 26:51

@Ler দুঃখিত, আমার উত্তরটি "ফলোলিং" থেকে "অবশিষ্ট" থেকে পরিষ্কার করার জন্য আপডেট করেছেন। এটি যদিও ভাল কাজ করে। কোডটি লিখে তা যাচাই করে দেখুন যে আপনি 4 পেয়েছেন! বিভিন্ন ফলাফল।

— ঘূর্ণিপুড়

int অনুমোদন (int n, ভেক্টর <int> a) {স্ট্যাটিক int num_permutations = 0; যদি (এন == (a.size () - 1)) {for (int i = 0; i <a.size (); i ++) cout << a [i] << ""; cout << "\ N"; num_permutations ++,; int অন্য {এর জন্য (int i = n + 1; i <= a.size (); i ++) ut অনুমান (n + 1, a); যদি (i <a.size ()) int temp = a [n], a [n] = a [i], a [i] = temp; num} নাম্বার_পরিবর্তন; main int প্রধান (শূন্য) ct ভেক্টর <int> ভি; v.push_back (1); ... ফেরত অনুমতি (0, v); }

— সোমেশ

ওফস - কোনও মন্তব্যে কোডটি কীভাবে ফর্ম্যাট করবেন তা নিশ্চিত নন ... 7 সহ কোডটি পরীক্ষা করে 5050 পেয়েছেন the

— সোমেশ

আপনার যদি প্রতিটি রঙের 1 টির পরিবর্তে 2 বা 3 লাল # 1 বল থাকতে পারে তবে এই অ্যালগো পরিবর্তন হবে না?

— আলেকজান্ডার মিলস

Answer 2

পাইথনের একটি অ্যালগরিদম এখানে রয়েছে যা অ্যারেতে স্থানে কাজ করে:

def permute(xs, low=0):
    if low + 1 >= len(xs):
        yield xs
    else:
        for p in permute(xs, low + 1):
            yield p        
        for i in range(low + 1, len(xs)):        
            xs[low], xs[i] = xs[i], xs[low]
            for p in permute(xs, low + 1):
                yield p        
            xs[low], xs[i] = xs[i], xs[low]

for p in permute([1, 2, 3, 4]):
    print p

আপনি নিজের জন্য কোডটি এখানে চেষ্টা করে দেখতে পারেন: http://repl.it/J9v

Comments

আপনি দয়া করে ফলন অংশ ব্যাখ্যা করতে পারেন? আমি কোড চালাতে শুকিয়ে ফেলতে পারিনি। আগাম ধন্যবাদ.

— অগ্নিস্বর বকশি

স্ট্যাক ওভারফ্লো প্রশ্ন স্ট্যাকওভারফ্লো / প্রশ্নগুলি ১০০৪৪২০ / ২ তে জানায় যে সংস্করণ ২.6 এর পরে একটি স্ট্যান্ডার্ড লাইব্রেরি মডিউল রয়েছে এবং তালিকাটির অনুমতি পেতে ফাংশনে একটি 6 লাইন সমাধান সরবরাহ করে তার উত্তর রয়েছে।

— এডওয়ার্ড

@ অগ্নিস্বর এক নজরে, ফলন বিবরণটি জেনারেটর সংজ্ঞায়িত করতে ব্যবহৃত হয়, স্থানীয় ভেরিয়েবলগুলি বিনষ্ট না করে কোনও কলকারীর ফলাফল প্রদানের জন্য কোনও ফাংশন ফেরতের বদলে প্রতিস্থাপন করে gene কোনও ফাংশন থেকে পৃথক, যেখানে প্রতিটি কলটিতে এটি ভেরিয়েবলগুলির নতুন সেট দিয়ে শুরু হয়, একটি জেনারেটর যেখানে এটি ছেড়ে দেওয়া হয়েছিল সেখানে কার্যকর করা পুনরায় শুরু করবে। pythoncentral.io/python-genetors-and-yeld-keyword

— MSS

অভিন্ন এন্ট্রিগুলির একটি তালিকা পরিচালনা করার সময় এই সমাধানটি কাজ করবে না।

— কায়ারকাটজে

ভাগ করে নেওয়ার জন্য ধন্যবাদ. এটি স্বজ্ঞাত এবং দক্ষ, যদিও আউটপুটটি অভিধানিক ক্রমে নেই।

— স্যাম

Answer 3

এখানে ইতিমধ্যে প্রচুর ভাল সমাধান রয়েছে, তবে আমি কীভাবে আমি নিজে থেকেই এই সমস্যাটি সমাধান করেছি তা ভাগ করে নিতে চাই এবং আশা করি যে এটি কারও পক্ষে উপকারী হতে পারে যিনি নিজের সমাধানও পেতে চান।

সমস্যাটি নিয়ে কিছু চিন্তা করার পরে আমি নিম্নলিখিত দুটি সিদ্ধান্ত নিয়ে এসেছি:

1. Lআকারের তালিকার জন্য তালিকার nএল ₁ , এল ₂ ... এল _এন উপাদান দিয়ে শুরু সমান সংখ্যক সমাধান হবে । যেহেতু মোট n!আকারের তালিকার ক্রমশক্তি রয়েছে n, তাই আমরা n! / n = (n-1)!প্রতিটি গ্রুপে অনুমানের ব্যবস্থা পাই ।
2. 2 টি উপাদানের তালিকায় কেবল 2 ক্রম => [a,b]এবং রয়েছে [b,a]।

এই দুটি সহজ ধারণা ব্যবহার করে আমি নিম্নলিখিত অ্যালগরিদম উত্পন্ন করেছি:

permute array
    if array is of size 2
       return first and second element as new array
       return second and first element as new array
    else
        for each element in array
            new subarray = array with excluded element
            return element + permute subarray

আমি এখানে সি # তে এটি কীভাবে প্রয়োগ করেছি:

public IEnumerable<List<T>> Permutate<T>(List<T> input)
{
    if (input.Count == 2) // this are permutations of array of size 2
    {
        yield return new List<T>(input);
        yield return new List<T> {input[1], input[0]}; 
    }
    else
    {
        foreach(T elem in input) // going through array
        {
            var rlist = new List<T>(input); // creating subarray = array
            rlist.Remove(elem); // removing element
            foreach(List<T> retlist in Permutate(rlist))
            {
                retlist.Insert(0,elem); // inserting the element at pos 0
                yield return retlist;
            }

        }
    }
}

Answer 4

"লিক্সিকোগ্রাফিক অর্ডার" এর জন্য উইকিপিডিয়াটির উত্তর আমার কাছে কুকবুক শৈলীতে পুরোপুরি সুস্পষ্ট বলে মনে হয়। এটি অ্যালগরিদমের জন্য একটি 14 শতকের উত্স উদ্ধৃত করে!

আমি কেবল উইকিপিডিয়া অ্যালগরিদমের জাভাতে একটি চেক হিসাবে একটি দ্রুত প্রয়োগ লিখেছি এবং এতে কোনও সমস্যা হয়নি। তবে উদাহরণ হিসাবে আপনার কিউতে যা আছে তা হ'ল "সমস্ত অনুমানের তালিকা" নয়, "সমস্ত অনুমানের একটি তালিকা", সুতরাং উইকিপিডিয়া আপনার পক্ষে খুব বেশি সহায়ক হবে না। আপনার এমন একটি ভাষা দরকার যাতে ক্রমশক্তি তালিকা কার্যকরভাবে নির্মিত হয়। এবং বিশ্বাস করুন, কয়েক বিলিয়ন দীর্ঘ তালিকা সাধারণত অপরিহার্য ভাষায় পরিচালিত হয় না। আপনি সত্যই একটি অ-কঠোর ক্রিয়ামূলক প্রোগ্রামিং ভাষা চান, যাতে তালিকাগুলি প্রথম শ্রেণীর অবজেক্ট, ইউনিভার্সের তাপের মৃত্যুর কাছাকাছি না আনার সময় যন্ত্রগুলি বের করে আনে।

এটা সহজ. স্ট্যান্ডার্ড হাস্কেল বা যে কোনও আধুনিক এফপি ভাষায়:

-- perms of a list
perms :: [a] -> [ [a] ]
perms (a:as) = [bs ++ a:cs | perm <- perms as, (bs,cs) <- splits perm]
perms []     = [ [] ]

এবং

-- ways of splitting a list into two parts
splits :: [a] -> [ ([a],[a]) ]
splits []     = [ ([],[]) ]
splits (a:as) = ([],a:as) : [(a:bs,cs) | (bs,cs) <- splits as]

Answer 5

ঘূর্ণিবায়ু যেমন বলেছে, আপনি শুরুতে শুরু করুন।

আপনি কার্সারটি নিজের সাথে বাকী প্রতিটি মানের সাথে অদলবদল করে নিন, এগুলি সমস্ত নতুন উদাহরণ (আমি এটি ব্যবহার করেছি) int[] এবং array.clone()উদাহরণে)।

তারপরে কার্সারটি ডানদিকের এক হয়ে গেছে তা নিশ্চিত করে এই সমস্ত বিভিন্ন তালিকায় ক্রমশক্তি সম্পাদন করুন।

যখন আর কোনও মান থাকে না (কার্সারটি শেষে থাকে), তালিকাটি মুদ্রণ করুন। এটি স্টপ শর্ত।

public void permutate(int[] list, int pointer) {
    if (pointer == list.length) {
        //stop-condition: print or process number
        return;
    }
    for (int i = pointer; i < list.length; i++) {
        int[] permutation = (int[])list.clone();.
        permutation[pointer] = list[i];
        permutation[i] = list[pointer];
        permutate(permutation, pointer + 1);
    }
}

Answer 6

রিকার্সিভ বজায় রাখতে সর্বদা কিছু মানসিক প্রচেষ্টা গ্রহণ করে। এবং বড় সংখ্যকগুলির জন্য, ফ্যাক্টরিয়াল সহজেই বিশাল এবং স্ট্যাক ওভারফ্লো সহজেই সমস্যা হবে।

ছোট সংখ্যার জন্য (3 বা 4, যা বেশিরভাগ মুখোমুখি হয়), একাধিক লুপগুলি বেশ সহজ এবং সরাসরি এগিয়ে থাকে। লুপগুলি দিয়ে ভোট দেওয়া হয়নি এমন দুর্ভাগ্যজনক উত্তর।

আসুন গণনা দিয়ে শুরু করা (পরিবর্তনের পরিবর্তে) সিউডো পার্ল কোড হিসাবে কেবল কোডটি পড়ুন।

$foreach $i1 in @list
    $foreach $i2 in @list 
        $foreach $i3 in @list
            print "$i1, $i2, $i3\n"

অনুক্রমের তুলনায় গণনা প্রায়শই মুখোমুখি হয়, তবে যদি অনুচ্ছেদের প্রয়োজন হয় তবে কেবল শর্ত যুক্ত করুন:

$foreach $i1 in @list
    $foreach $i2 in @list 
        $if $i2==$i1
            next
        $foreach $i3 in @list
            $if $i3==$i1 or $i3==$i2
                next
            print "$i1, $i2, $i3\n"

এখন আপনার যদি বড় তালিকার জন্য সত্যিই সাধারণ পদ্ধতিটির প্রয়োজন হয় তবে আমরা রেডিক্স পদ্ধতিটি ব্যবহার করতে পারি। প্রথমে গণনার সমস্যাটি বিবেচনা করুন:

$n=@list
my @radix
$for $i=0:$n
    $radix[$i]=0
$while 1
    my @temp
    $for $i=0:$n
        push @temp, $list[$radix[$i]]
    print join(", ", @temp), "\n"
    $call radix_increment

subcode: radix_increment
    $i=0
    $while 1
        $radix[$i]++
        $if $radix[$i]==$n
            $radix[$i]=0
            $i++
        $else
            last
    $if $i>=$n
        last

মূল্যের বর্ধন মূলত সংখ্যা গণনা (তালিকার উপাদানের সংখ্যার ভিত্তিতে) হয়।

এখন আপনার যদি পার্মিটোন দরকার হয় তবে লুপের ভিতরে কেবল চেকগুলি যুক্ত করুন:

subcode: check_permutation
    my @check
    my $flag_dup=0
    $for $i=0:$n
        $check[$radix[$i]]++
        $if $check[$radix[$i]]>1
            $flag_dup=1
            last
    $if $flag_dup
        next

সম্পাদনা করুন: উপরের কোডটি কাজ করা উচিত, তবে আদেশের জন্য, Radix_increment অপব্যয় হতে পারে। সুতরাং যদি সময়টি ব্যবহারিক উদ্বেগ হয় তবে আমাদেরকে রেডিক্স_স্রোমেন্টকে পারমিট_সে পরিবর্তন করতে হবে:

subcode: permute_init
    $for $i=0:$n
        $radix[$i]=$i

subcode: permute_inc                                       
    $max=-1                                                
    $for $i=$n:0                                           
        $if $max<$radix[$i]                                
            $max=$radix[$i]                                
        $else                                              
            $for $j=$n:0                                   
                $if $radix[$j]>$radix[$i]                  
                    $call swap, $radix[$i], $radix[$j]     
                    break                                  
            $j=$i+1                                        
            $k=$n-1                                        
            $while $j<$k                                   
                $call swap, $radix[$j], $radix[$k]         
                $j++                                       
                $k--                                       
            break                                          
    $if $i<0                                               
        break                                              

অবশ্যই এখন এই কোডটি যৌক্তিকভাবে আরও জটিল, আমি পাঠকের অনুশীলনের জন্য ছেড়ে যাব।

Answer 7

// C program to print all permutations with duplicates allowed
#include <stdio.h>
#include <string.h>

/* Function to swap values at two pointers */
void swap(char *x, char *y)
{
    char temp;
    temp = *x;
    *x = *y;
    *y = temp;
}

/* Function to print permutations of string
   This function takes three parameters:
   1. String
   2. Starting index of the string
   3. Ending index of the string. */

void permute(char *a, int l, int r)
{
   int i;
   if (l == r)
     printf("%s\n", a);
   else
   {
       for (i = l; i <= r; i++)
       {
          swap((a+l), (a+i));
          permute(a, l+1, r);
          swap((a+l), (a+i)); //backtrack
       }
   }
}

/* Driver program to test above functions */
int main()
{
    char str[] = "ABC";
    int n = strlen(str);
    permute(str, 0, n-1);
    return 0;
}

তথ্যসূত্র: গিক্সফোর্জি.অর্গ

Answer 8

যদি কেউ আশ্চর্য হয় কিভাবে জাভাস্ক্রিপ্টে ক্রম নির্ধারণে করা যায়।

আইডিয়া / pseudocode হয়

1. একবারে একটি উপাদান চয়ন করুন
2. বাকি উপাদানটিকে পরিত্যাগ করুন এবং তারপরে বেছে নেওয়া সমস্ত উপাদানকে অনুমতি অনুসারে যুক্ত করুন

উদাহরণ স্বরূপ. 'এ' + পারমিট (বিসি)। বিসির পারমিট হবে বিসি ও সিবি। এবার এই দুটি যোগ করুন এবিসি, এসিবি দেবেন। একইভাবে, বি + পারমিট বাছাই করা (এসি) ব্যাক, বিসিএ ... সরবরাহ করবে এবং চালিয়ে যাবে।

এখন কোড দেখুন

function permutations(arr){

   var len = arr.length, 
       perms = [],
       rest,
       picked,
       restPerms,
       next;

    //for one or less item there is only one permutation 
    if (len <= 1)
        return [arr];

    for (var i=0; i<len; i++)
    {
        //copy original array to avoid changing it while picking elements
        rest = Object.create(arr);

        //splice removed element change array original array(copied array)
        //[1,2,3,4].splice(2,1) will return [3] and remaining array = [1,2,4]
        picked = rest.splice(i, 1);

        //get the permutation of the rest of the elements
        restPerms = permutations(rest);

       // Now concat like a+permute(bc) for each
       for (var j=0; j<restPerms.length; j++)
       {
           next = picked.concat(restPerms[j]);
           perms.push(next);
       }
    }

   return perms;
}

এটি বুঝতে আপনার সময় নিন। আমি এই কোডটি পেয়েছি ( জাভাস্ক্রিপ্টে পের্টিউশন )

Comments

আমি অনুরূপ কিছু ভাবছিলাম কিন্তু আপনি কি বেছে নেওয়া উপাদানটিকে বাকি প্যারামের সামনের এবং শেষের অংশে যুক্ত করবেন না? এই ক্ষেত্রে, 'এবিসি' এর জন্য, যদি আপনি একটি বাছাই করেন, তবে 'বিসি' অনুমতিগুলি হ'ল 'বিসি' এবং 'সিবি'। আপনি যখন 'a' কে তালিকায় ফিরে যুক্ত করবেন তখন আপনার এটিকে 'a + বিসি' + 'এ + সিবি' হিসাবে যুক্ত করা উচিত নয় তবে শেষে 'বিসি + এ' + 'সিবি + এ' হিসাবে থাকা উচিত ক্রমতালিকা?

— আর্টিমাস

আপনি যথাক্রমে 'বি' এবং 'সি' দিয়ে শুরু করার সময় এই অনুমতিগুলি পেয়ে যাবেন। (অর্থাত্ 'লুপের জন্য বাইরের দ্বিতীয় এবং তৃতীয় রান)

— রায়ান ও'নিল

Answer 9

পাইথনের আরেকটি, এটি @ সিডিজিন্স হিসাবে নেই, তবে আমি মনে করি এটি বোঝা আরও সহজ

def permute(num):
    if len(num) == 2:
        # get the permutations of the last 2 numbers by swapping them
        yield num
        num[0], num[1] = num[1], num[0]
        yield num
    else:
        for i in range(0, len(num)):
            # fix the first number and get the permutations of the rest of numbers
            for perm in permute(num[0:i] + num[i+1:len(num)]):
                yield [num[i]] + perm

for p in permute([1, 2, 3, 4]):
    print p

Answer 10

আমি কোনও আকারের প্রদত্ত কোনও পূর্ণসংখ্যার অনুমতি পাওয়ার জন্য একটি কোড লেখার কথা ভাবছিলাম, অর্থাত্ একটি সংখ্যক 4567 সরবরাহ করার জন্য আমরা 7654 অবধি সমস্ত সম্ভাব্য অনুমতি পেতে পারি ... সুতরাং আমি এটিতে কাজ করেছি এবং একটি অ্যালগরিদম পেয়েছি এবং শেষ পর্যন্ত এটি প্রয়োগ করেছি, এখানে "সি" তে লিখিত কোড। আপনি কেবল এটি অনুলিপি করতে এবং কোনও ওপেন সোর্স সংকলকগুলিতে চালাতে পারেন। তবে কিছু ত্রুটি ডিবাগ হওয়ার জন্য অপেক্ষা করছে। দয়া করে প্রশংসা করুন।

কোড:

#include <stdio.h>
#include <conio.h>
#include <malloc.h>

                //PROTOTYPES

int fact(int);                  //For finding the factorial
void swap(int*,int*);           //Swapping 2 given numbers
void sort(int*,int);            //Sorting the list from the specified path
int imax(int*,int,int);         //Finding the value of imax
int jsmall(int*,int);           //Gives position of element greater than ith but smaller than rest (ahead of imax)
void perm();                    //All the important tasks are done in this function


int n;                         //Global variable for input OR number of digits

void main()
{
int c=0;

printf("Enter the number : ");
scanf("%d",&c);
perm(c);
getch();
}

void perm(int c){
int *p;                     //Pointer for allocating separate memory to every single entered digit like arrays
int i, d;               
int sum=0;
int j, k;
long f;

n = 0;

while(c != 0)               //this one is for calculating the number of digits in the entered number
{
    sum = (sum * 10) + (c % 10);
    n++;                            //as i told at the start of loop
    c = c / 10;
}

f = fact(n);                        //It gives the factorial value of any number

p = (int*) malloc(n*sizeof(int));                //Dynamically allocation of array of n elements

for(i=0; sum != 0 ; i++)
{
    *(p+i) = sum % 10;                               //Giving values in dynamic array like 1234....n separately
    sum = sum / 10;
}

sort(p,-1);                                         //For sorting the dynamic array "p"

for(c=0 ; c<f/2 ; c++) {                        //Most important loop which prints 2 numbers per loop, so it goes upto 1/2 of fact(n)

    for(k=0 ; k<n ; k++)
        printf("%d",p[k]);                       //Loop for printing one of permutations
    printf("\n");

    i = d = 0;
    i = imax(p,i,d);                            //provides the max i as per algo (i am restricted to this only)
    j = i;
    j = jsmall(p,j);                            //provides smallest i val as per algo
    swap(&p[i],&p[j]);

    for(k=0 ; k<n ; k++)
        printf("%d",p[k]);
    printf("\n");

    i = d = 0;
    i = imax(p,i,d);
    j = i;
    j = jsmall(p,j);
    swap(&p[i],&p[j]);

    sort(p,i);
}
free(p);                                        //Deallocating memory
}

int fact (int a)
{
long f=1;
while(a!=0)
{
    f = f*a;
    a--;
}
return f;
}


void swap(int *p1,int *p2)
{
int temp;
temp = *p1;
*p1 = *p2;
*p2 = temp;
return;
}


void sort(int*p,int t)
{
int i,temp,j;
for(i=t+1 ; i<n-1 ; i++)
{
    for(j=i+1 ; j<n ; j++)
    {
        if(*(p+i) > *(p+j))
        {
            temp = *(p+i);
            *(p+i) = *(p+j);
            *(p+j) = temp;
        }
    }
}
}


int imax(int *p, int i , int d)
{
    while(i<n-1 && d<n-1)
{
    if(*(p+d) < *(p+d+1))
    {   
        i = d;
        d++;
    }
    else
        d++;
}
return i;
}


int jsmall(int *p, int j)
{
int i,small = 32767,k = j;
for (i=j+1 ; i<n ; i++)
{
    if (p[i]<small && p[i]>p[k])
    {     
       small = p[i];
       j = i;
    }
}
return j;
}

Answer 11

void permutate(char[] x, int i, int n){
    x=x.clone();
    if (i==n){
        System.out.print(x);
        System.out.print(" ");
        counter++;}
    else
    {
        for (int j=i; j<=n;j++){
     //   System.out.print(temp); System.out.print(" ");    //Debugger
        swap (x,i,j);
      //  System.out.print(temp); System.out.print(" "+"i="+i+" j="+j+"\n");// Debugger
        permutate(x,i+1,n);
    //    swap (temp,i,j);
    }
    }
}

void swap (char[] x, int a, int b){
char temp = x[a];
x[a]=x[b];
x[b]=temp;
}

আমি এটি তৈরি করেছি গবেষণার উপর ভিত্তি করে খুব অনুমতি দেওয়া (কিউও, 0, কিউও. দৈর্ঘ্য -১); ঠিক তাই আপনি জানেন, আপনি ব্যাকট্র্যাকের সাথে বা ছাড়াই এটি করতে পারেন

Answer 12

এখানে একটি খেলনা রুবি পদ্ধতি রয়েছে যা এর মতো কাজ #permutation.to_aকরে পাগল লোকদের কাছে এটি আরও সুস্পষ্ট। এটি হেলা ধীর, তবে 5 লাইন।

def permute(ary)
  return [ary] if ary.size <= 1
  ary.collect_concat.with_index do |e, i|
    rest = ary.dup.tap {|a| a.delete_at(i) }
    permute(rest).collect {|a| a.unshift(e) }
  end
end

Answer 13

আমি এএনএসআই সিতে এই পুনরাবৃত্ত সমাধানটি লিখেছি পারমুটেট ক্রিয়াকলাপের প্রতিটি সম্পাদন সমস্ত সম্পূর্ণ না হওয়া পর্যন্ত আলাদা আলাদা অনুচ্ছেদ সরবরাহ করে। গ্লোবাল ভেরিয়েবলগুলি ভেরিয়েবল ফ্যাক্ট এবং কাউন্টের জন্যও ব্যবহার করা যেতে পারে।

#include <stdio.h>
#define SIZE 4

void Rotate(int vec[], int size)
{
    int i, j, first;

    first = vec[0];
    for(j = 0, i = 1; i < size; i++, j++)
    {
        vec[j] = vec[i];
    }
    vec[j] = first;
}

int Permutate(int *start, int size, int *count)
{
    static int fact;

    if(size > 1)
    {
        if(Permutate(start + 1, size - 1, count))
        {
            Rotate(start, size);
        }
        fact *= size;
    }
    else
    {
        (*count)++;
        fact = 1;
    }

    return !(*count % fact);
}

void Show(int vec[], int size)
{
    int i;

    printf("%d", vec[0]);
    for(i = 1; i < size; i++)
    {
        printf(" %d", vec[i]);
    }
    putchar('\n');
}

int main()
{
    int vec[] = { 1, 2, 3, 4, 5, 6 }; /* Only the first SIZE items will be permutated */
    int count = 0;

    do
    {
        Show(vec, SIZE);
    } while(!Permutate(vec, SIZE, &count));

    putchar('\n');
    Show(vec, SIZE);
    printf("\nCount: %d\n\n", count);

    return 0;
}

Answer 14

জাভা সংস্করণ

/**
 * @param uniqueList
 * @param permutationSize
 * @param permutation
 * @param only            Only show the permutation of permutationSize,
 *                        else show all permutation of less than or equal to permutationSize.
 */
public static void my_permutationOf(List<Integer> uniqueList, int permutationSize, List<Integer> permutation, boolean only) {
    if (permutation == null) {
        assert 0 < permutationSize && permutationSize <= uniqueList.size();
        permutation = new ArrayList<>(permutationSize);
        if (!only) {
            System.out.println(Arrays.toString(permutation.toArray()));
        }
    }
    for (int i : uniqueList) {
        if (permutation.contains(i)) {
            continue;
        }
        permutation.add(i);
        if (!only) {
            System.out.println(Arrays.toString(permutation.toArray()));
        } else if (permutation.size() == permutationSize) {
            System.out.println(Arrays.toString(permutation.toArray()));
        }
        if (permutation.size() < permutationSize) {
            my_permutationOf(uniqueList, permutationSize, permutation, only);
        }
        permutation.remove(permutation.size() - 1);
    }
}

যেমন

public static void main(String[] args) throws Exception { 
    my_permutationOf(new ArrayList<Integer>() {
        {
            add(1);
            add(2);
            add(3);

        }
    }, 3, null, true);
}

আউটপুট:

  [1, 2, 3]
  [1, 3, 2]
  [2, 1, 3]
  [2, 3, 1]
  [3, 1, 2]
  [3, 2, 1]

Answer 15

পিএইচপি মধ্যে

$set=array('A','B','C','D');

function permutate($set) {
    $b=array();
    foreach($set as $key=>$value) {
        if(count($set)==1) {
            $b[]=$set[$key];
        }
        else {
            $subset=$set;
            unset($subset[$key]);
            $x=permutate($subset);
            foreach($x as $key1=>$value1) {
                $b[]=$value.' '.$value1;
            }
        }
    }
    return $b;
}

$x=permutate($set);
var_export($x);

Answer 16

পাইথনের কোডটি এখানে একটি লিস্টের সমস্ত সম্ভাব্য ক্রম প্রিন্ট করতে হবে:

def next_perm(arr):
    # Find non-increasing suffix
    i = len(arr) - 1
    while i > 0 and arr[i - 1] >= arr[i]:
        i -= 1
    if i <= 0:
        return False

    # Find successor to pivot
    j = len(arr) - 1
    while arr[j] <= arr[i - 1]:
        j -= 1
    arr[i - 1], arr[j] = arr[j], arr[i - 1]

    # Reverse suffix
    arr[i : ] = arr[len(arr) - 1 : i - 1 : -1]
    print arr
    return True

def all_perm(arr):
    a = next_perm(arr)
    while a:
        a = next_perm(arr)
    arr = raw_input()
    arr.split(' ')
    arr = map(int, arr)
    arr.sort()
    print arr
    all_perm(arr)

সমস্ত সম্ভাব্য অনুমতি পেতে আমি একটি ডিক্সিকোগ্রাফিক অর্ডার অ্যালগরিদম ব্যবহার করেছি, তবে একটি পুনরাবৃত্ত আলগোরিদিম আরও দক্ষ। আপনি পুনরাবৃত্তির অ্যালগরিদমের জন্য কোডটি এখানে পেতে পারেন: পাইথন পুনরাবৃত্তির অনুমতি ut

Answer 17

public class PermutationGenerator
{
    private LinkedList<List<int>> _permutationsList;
    public void FindPermutations(List<int> list, int permutationLength)
    {
        _permutationsList = new LinkedList<List<int>>();
        foreach(var value in list)
        {
            CreatePermutations(value, permutationLength);
        }
    }

    private void CreatePermutations(int value, int permutationLength)
    {
        var node = _permutationsList.First;
        var last = _permutationsList.Last;
        while (node != null)
        {
            if (node.Value.Count < permutationLength)
            {
                GeneratePermutations(node.Value, value, permutationLength);
            }
            if (node == last)
            {
                break;
            }
            node = node.Next;
        }

        List<int> permutation = new List<int>();
        permutation.Add(value);
        _permutationsList.AddLast(permutation);
    }

    private void GeneratePermutations(List<int> permutation, int value, int permutationLength)
    {
       if (permutation.Count < permutationLength)
        {
            List<int> copyOfInitialPermutation = new List<int>(permutation);
            copyOfInitialPermutation.Add(value);
            _permutationsList.AddLast(copyOfInitialPermutation);
            List<int> copyOfPermutation = new List<int>();
            copyOfPermutation.AddRange(copyOfInitialPermutation);
            int lastIndex = copyOfInitialPermutation.Count - 1;
            for (int i = lastIndex;i > 0;i--)
            {
                int temp = copyOfPermutation[i - 1];
                copyOfPermutation[i - 1] = copyOfPermutation[i];
                copyOfPermutation[i] = temp;

                List<int> perm = new List<int>();
                perm.AddRange(copyOfPermutation);
                _permutationsList.AddLast(perm);
            }
        }
    }

    public void PrintPermutations(int permutationLength)
    {
        int count = _permutationsList.Where(perm => perm.Count() == permutationLength).Count();
        Console.WriteLine("The number of permutations is " + count);
    }
}

Comments

এটি একটি দরকারী উত্তর

— আইয়াজ আলিফভ

Answer 18

স্কালায়

    def permutazione(n: List[Int]): List[List[Int]] = permutationeAcc(n, Nil)



def permutationeAcc(n: List[Int], acc: List[Int]): List[List[Int]] = {

    var result: List[List[Int]] = Nil
    for (i ← n if (!(acc contains (i))))
        if (acc.size == n.size-1)
            result = (i :: acc) :: result
        else
            result = result ::: permutationeAcc(n, i :: acc)
    result
}

Answer 19

এটি অনুমানের জন্য জাভা সংস্করণ

public class Permutation {

    static void permute(String str) {
        permute(str.toCharArray(), 0, str.length());
    }

    static void permute(char [] str, int low, int high) {
        if (low == high) {
            System.out.println(str);
            return;
        }

        for (int i=low; i<high; i++) {
            swap(str, i, low);
            permute(str, low+1, high);
            swap(str, low, i);
        }

    }

    static void swap(char [] array, int i, int j) {
        char t = array[i];
        array[i] = array[j];
        array[j] = t;
    }
}

Answer 20

কোল্ডফিউশনের জন্য এখানে একটি বাস্তবায়ন রয়েছে (অ্যারে অ্যাপেন্ড ()) এ একীভূত যুক্তির কারণে সিএফ 10 প্রয়োজন:

public array function permutateArray(arr){

    if (not isArray(arguments.arr) ) {
        return ['The ARR argument passed to the permutateArray function is not of type array.'];    
    }

    var len = arrayLen(arguments.arr);
    var perms = [];
    var rest = [];
    var restPerms = [];
    var rpLen = 0;
    var next = [];

    //for one or less item there is only one permutation 
    if (len <= 1) {
        return arguments.arr;
    }

    for (var i=1; i <= len; i++) {
        // copy the original array so as not to change it and then remove the picked (current) element
        rest = arraySlice(arguments.arr, 1);
        arrayDeleteAt(rest, i);

         // recursively get the permutation of the rest of the elements
         restPerms = permutateArray(rest);
         rpLen = arrayLen(restPerms);

        // Now concat each permutation to the current (picked) array, and append the concatenated array to the end result
        for (var j=1; j <= rpLen; j++) {
            // for each array returned, we need to make a fresh copy of the picked(current) element array so as to not change the original array
            next = arraySlice(arguments.arr, i, 1);
            arrayAppend(next, restPerms[j], true);
            arrayAppend(perms, next);
        }
     }

    return perms;
}

উপরের খানশার্পের জেএস সমাধানের ভিত্তিতে।

Comments

আপনার অ্যালগরিদমের সামগ্রিক কৌশল সম্পর্কে কিছু ব্যাখ্যা এই উত্তরটির উন্নতি করার ভাল উপায় হবে।

— রিচার্ড

তাহলে ডাউনটাতে কেন? এটি একটি কার্যকরী বাস্তবায়ন।

— earachefl

@ রিচার্ড, সামগ্রিক কৌশলটি উপরে ঘূর্ণি ও অন্যান্যদের দ্বারা ব্যাখ্যা করা হয়েছে। আমি ব্যাখ্যা ছাড়াই বাস্তবায়ন হিসাবে পোস্ট করা অন্যান্য সমস্ত উত্তর সম্পর্কে আপনার মন্তব্য দেখতে পাচ্ছি না।

— earachefl

Answer 21

আমি আজকের স্ট্যাকওভারফ্লোতে এটি একটি খুব পুরানো এবং এমনকি অফ-টপিকটি জানি তবে আমি এখনও আপনার ব্রাউজারে চালিত হওয়া সহজ কারণে একটি বন্ধুত্বপূর্ণ জাভাস্ক্রিপ্ট উত্তরের অবদান রাখতে চেয়েছিলাম।

আমি debuggerনির্দেশিক ব্রেকপয়েন্টও যুক্ত করেছি যাতে আপনি এই অ্যালগরিদম কীভাবে কাজ করে তা দেখতে কোডের (ক্রোম প্রয়োজনীয়) পদক্ষেপ নিতে পারেন। ক্রোমে আপনার ডেভ কনসোলটি খুলুন ( F12উইন্ডোতে বাCMD + OPTION + I ম্যাকে) এবং তারপরে "রান কোড স্নিপেট" ক্লিক করুন। এটি @WirlWind তার উত্তরে উপস্থাপিত একই একই অ্যালগরিদম প্রয়োগ করে।

আপনার ব্রাউজারের debuggerনির্দেশে মৃত্যুদন্ড কার্যকর করা উচিত । F8কোড কার্যকর করা চালিয়ে যেতে ব্যবহার করুন ।

কোডটি দেখুন এবং দেখুন এটি কীভাবে কাজ করে!

function permute(rest, prefix = []) {
  if (rest.length === 0) {
    return [prefix];
  }
  return (rest
    .map((x, index) => {
      const oldRest = rest;
      const oldPrefix = prefix;
      // the `...` destructures the array into single values flattening it
      const newRest = [...rest.slice(0, index), ...rest.slice(index + 1)];
      const newPrefix = [...prefix, x];
      debugger;

      const result = permute(newRest, newPrefix);
      return result;
    })
    // this step flattens the array of arrays returned by calling permute
    .reduce((flattened, arr) => [...flattened, ...arr], [])
  );
}
console.log(permute([1, 2, 3]));

Answer 22

নিম্নলিখিত জাভা সমাধানে আমরা প্রতিটি পুনরুক্তার উপর ফলাফল সেট ক্লোনিং এড়ানোর জন্য স্ট্রিংস অপরিবর্তনীয় এই বিষয়ে সুবিধা গ্রহণ করি।

ইনপুটটি একটি স্ট্রিং হবে, বলুন "abc", এবং আউটপুটটি সমস্ত সম্ভাব্য অনুমান হবে:

abc
acb
bac
bca
cba
cab

কোড:

public static void permute(String s) {
    permute(s, 0);
}

private static void permute(String str, int left){
    if(left == str.length()-1) {
        System.out.println(str);
    } else {
        for(int i = left; i < str.length(); i++) {
            String s = swap(str, left, i);
            permute(s, left+1);
        }
    }
}

private static String swap(String s, int left, int right) {
    if (left == right)
        return s;

    String result = s.substring(0, left);
    result += s.substring(right, right+1);
    result += s.substring(left+1, right);
    result += s.substring(left, left+1);
    result += s.substring(right+1);
    return result;
}

অ্যারেগুলিতে একই পদ্ধতির প্রয়োগ করা যেতে পারে (স্ট্রিংয়ের পরিবর্তে):

public static void main(String[] args) {
    int[] abc = {1,2,3};
    permute(abc, 0);
}
public static void permute(int[] arr, int index) {
    if (index == arr.length) {
        System.out.println(Arrays.toString(arr));
    } else {
        for (int i = index; i < arr.length; i++) {
            int[] permutation = arr.clone();
            permutation[index] = arr[i];
            permutation[i] = arr[index];
            permute(permutation, index + 1);
        }
    }
}

Answer 23

এটি জাভাতে আমার সমাধান:

public class CombinatorialUtils {

    public static void main(String[] args) {
        List<String> alphabet = new ArrayList<>();
        alphabet.add("1");
        alphabet.add("2");
        alphabet.add("3");
        alphabet.add("4");

        for (List<String> strings : permutations(alphabet)) {
            System.out.println(strings);
        }
        System.out.println("-----------");
        for (List<String> strings : combinations(alphabet)) {
            System.out.println(strings);
        }
    }

    public static List<List<String>> combinations(List<String> alphabet) {
        List<List<String>> permutations = permutations(alphabet);
        List<List<String>> combinations = new ArrayList<>(permutations);

        for (int i = alphabet.size(); i > 0; i--) {
            final int n = i;
            combinations.addAll(permutations.stream().map(strings -> strings.subList(0, n)).distinct().collect(Collectors.toList()));
        }
        return combinations;
    }

    public static <T> List<List<T>> permutations(List<T> alphabet) {
        ArrayList<List<T>> permutations = new ArrayList<>();
        if (alphabet.size() == 1) {
            permutations.add(alphabet);
            return permutations;
        } else {
            List<List<T>> subPerm = permutations(alphabet.subList(1, alphabet.size()));
            T addedElem = alphabet.get(0);
            for (int i = 0; i < alphabet.size(); i++) {
                for (List<T> permutation : subPerm) {
                    int index = i;
                    permutations.add(new ArrayList<T>(permutation) {{
                        add(index, addedElem);
                    }});
                }
            }
        }
        return permutations;
    }
}

Answer 24

আপনি ধারণাটির অগ্রগামী ভাষায় (উপভাষার) কোনও প্রয়োগ পোস্ট না করে পুনরুক্তিতে কোনও অনুমতি সমস্যা সমাধানের বিষয়ে কথা বলতে পারবেন না । সুতরাং, সম্পূর্ণতার স্বার্থে, এখানে স্কিমের যে পদ্ধতিগুলি করা যেতে পারে তার মধ্যে একটি।

(define (permof wd)
  (cond ((null? wd) '())
        ((null? (cdr wd)) (list wd))
        (else
         (let splice ([l '()] [m (car wd)] [r (cdr wd)])
           (append
            (map (lambda (x) (cons m x)) (permof (append l r)))
            (if (null? r)
                '()
                (splice (cons m l) (car r) (cdr r))))))))

কলিং (permof (list "foo" "bar" "baz"))আমরা পাবেন:

'(("foo" "bar" "baz")
  ("foo" "baz" "bar")
  ("bar" "foo" "baz")
  ("bar" "baz" "foo")
  ("baz" "bar" "foo")
  ("baz" "foo" "bar"))

আমি অ্যালগরিদমের বিবরণে যাব না কারণ এটি অন্যান্য পোস্টে যথেষ্ট ব্যাখ্যা করা হয়েছে। ধারণাটিও একই রকম।

যাইহোক, পুনরাবৃত্ত সমস্যাগুলি পাইথন, সি, এবং জাভা এর মতো ধ্বংসাত্মক মাধ্যম হিসাবে মডেল করা এবং তার সম্পর্কে চিন্তাভাবনা করা আরও শক্ত হয়ে থাকে, যখন লিস্প বা এমএলে সংক্ষিপ্তভাবে প্রকাশ করা যায়।

Answer 25

এখানে পিএইচপি একটি পুনরাবৃত্ত সমাধান। ঘূর্ণিবাকের পোস্টটি যুক্তিটি সঠিকভাবে বর্ণনা করে। এটি উল্লেখ করার মতো বিষয় যে সমস্ত ক্রিয়াকলাপ উত্পন্ন করা ঘটনাগত সময়ে চলে, সুতরাং পরিবর্তে পুনরাবৃত্তি পদ্ধতির ব্যবহার করা ভাল ধারণা হতে পারে।

public function permute($sofar, $input){
  for($i=0; $i < strlen($input); $i++){
    $diff = strDiff($input,$input[$i]);
    $next = $sofar.$input[$i]; //next contains a permutation, save it
    $this->permute($next, $diff);
  }
}

আরআরডিডিফ ফাংশন দুটি স্ট্রিং নেয় s1এবং s2, এবং s1উপাদানগুলি s2(সদৃশ পদার্থ) ছাড়াই সমস্ত কিছু সহ একটি নতুন স্ট্রিং দেয় । সুতরাং, strDiff('finish','i')=> 'fnish'(দ্বিতীয় 'আমি' করা হয় না সরানো হয়েছে)।

Answer 26

এখানে আর এর একটি অ্যালগরিদম রয়েছে, যদি কারওর মতো অতিরিক্ত লাইব্রেরিগুলি লোড করা এড়াতে হয়।

permutations <- function(n){
    if(n==1){
        return(matrix(1))
    } else {
        sp <- permutations(n-1)
        p <- nrow(sp)
        A <- matrix(nrow=n*p,ncol=n)
        for(i in 1:n){
            A[(i-1)*p+1:p,] <- cbind(i,sp+(sp>=i))
        }
        return(A)
    }
}

ব্যবহারের উদাহরণ:

> matrix(letters[permutations(3)],ncol=3)
     [,1] [,2] [,3]
[1,] "a"  "b"  "c" 
[2,] "a"  "c"  "b" 
[3,] "b"  "a"  "c" 
[4,] "b"  "c"  "a" 
[5,] "c"  "a"  "b" 
[6,] "c"  "b"  "a" 

Answer 27

#!/usr/bin/env python
import time

def permutations(sequence):
  # print sequence
  unit = [1, 2, 1, 2, 1]

  if len(sequence) >= 4:
    for i in range(4, (len(sequence) + 1)):
      unit = ((unit + [i - 1]) * i)[:-1]
      # print unit
    for j in unit:
      temp = sequence[j]
      sequence[j] = sequence[0]
      sequence[0] = temp
      yield sequence
  else:
    print 'You can use PEN and PAPER'


# s = [1,2,3,4,5,6,7,8,9,10]
s = [x for x in 'PYTHON']

print s

z = permutations(s)
try:
  while True:
    # time.sleep(0.0001)
    print next(z)
except StopIteration:
    print 'Done'

---

['P', 'Y', 'T', 'H', 'O', 'N']
['Y', 'P', 'T', 'H', 'O', 'N']
['T', 'P', 'Y', 'H', 'O', 'N']
['P', 'T', 'Y', 'H', 'O', 'N']
['Y', 'T', 'P', 'H', 'O', 'N']
['T', 'Y', 'P', 'H', 'O', 'N']
['H', 'Y', 'P', 'T', 'O', 'N']
['Y', 'H', 'P', 'T', 'O', 'N']
['P', 'H', 'Y', 'T', 'O', 'N']
['H', 'P', 'Y', 'T', 'O', 'N']
['Y', 'P', 'H', 'T', 'O', 'N']
['P', 'Y', 'H', 'T', 'O', 'N']
['T', 'Y', 'H', 'P', 'O', 'N']
['Y', 'T', 'H', 'P', 'O', 'N']
['H', 'T', 'Y', 'P', 'O', 'N']
['T', 'H', 'Y', 'P', 'O', 'N']
['Y', 'H', 'T', 'P', 'O', 'N']
['H', 'Y', 'T', 'P', 'O', 'N']
['P', 'Y', 'T', 'H', 'O', 'N']
.
.
.
['Y', 'T', 'N', 'H', 'O', 'P']
['N', 'T', 'Y', 'H', 'O', 'P']
['T', 'N', 'Y', 'H', 'O', 'P']
['Y', 'N', 'T', 'H', 'O', 'P']
['N', 'Y', 'T', 'H', 'O', 'P']

Comments

সমাধানটি দেখায় যে আপনি প্রয়োজনীয়তা অনুসারে স্ট্রিংকে অনুমতি দেননি। দ্বিতীয় আদেশটি পিওয়াইটিএনও হওয়া উচিত

— রাহুল কদুকার

Answer 28

এটি জাভাটির জন্য একটি পুনরাবৃত্তির কোড, ধারণাটি এমন একটি উপসর্গ রয়েছে যা বাকী অক্ষরগুলি যুক্ত করে:

public static void permutation(String str) { 
    permutation("", str); 
}

private static void permutation(String prefix, String str) {
    int n = str.length();
    if (n == 0) System.out.println(prefix);
    else {
        for (int i = 0; i < n; i++)
            permutation(prefix + str.charAt(i), str);
    }
}

উদাহরণ:

ইনপুট = "এবিসি"; আউটপুট:

এবিসি এসিবি বিএসি বিসিএ সিএবি সিবিএ

Comments

দুর্দান্ত ধারণা, তবে আমি মনে করি strপুনরাবৃত্তভাবে কল করার সময় আপনার চার্ট (i) থেকেও অপসারণ করা উচিত , অন্যথায় এটি শেষ হবে না।

— ক্রিস্টাল

আপনি যদি অনুলিপি এবং পেস্ট করতে চলেছেন তবে আপনাকে (1) এট্রিবিউশন দিতে হবে এবং (2) কোনও সম্পাদনা সঠিক কিনা তা নিশ্চিত করা উচিত। বিশিষ্টতার জন্য, এটি intocs.cs.princeton.edu/java/23recursion/… থেকে পার্ম 1 । এছাড়াও আপনার সম্পাদনাটি ভুল: str.substring (0, i) + str.substring (i + 1, n) str এর মতো নয়, যেমন প্রাক্তনটি i পজিশনে অক্ষরটিকে বাদ দেয়।

— কেভিন

Answer 29

শুধু সম্পূর্ণ হতে হবে, সি ++

#include <iostream>
#include <algorithm>
#include <string>

std::string theSeq = "abc";
do
{
  std::cout << theSeq << endl;
} 
while (std::next_permutation(theSeq.begin(), theSeq.end()));

...

abc
acb
bac
bca
cab
cba

Answer 30

এখানে সি ++ এর একটি অপরিবর্তনীয় সমাধান যা স্ট্যান্ড :: নেক্সট_মাম্পুটেশন দ্বারা প্রদত্ত কার্যকারিতার অনুরূপ ক্রমবর্ধমান ক্রমে পরবর্তী অনুমানের সরবরাহ করে:

void permute_next(vector<int>& v)
{
  if (v.size() < 2)
    return;

  if (v.size() == 2)
  { 
    int tmp = v[0];
    v[0] = v[1];
    v[1] = tmp;
    return;
  }

  // Step 1: find first ascending-ordered pair from right to left
  int i = v.size()-2;
  while(i>=0)
  { 
    if (v[i] < v[i+1])
      break;
    i--;
  }
  if (i<0) // vector fully sorted in descending order (last permutation)
  {
    //resort in ascending order and return
    sort(v.begin(), v.end());
    return;
  }

  // Step 2: swap v[i] with next higher element of remaining elements
  int pos = i+1;
  int val = v[pos];
  for(int k=i+2; k<v.size(); k++)
    if(v[k] < val && v[k] > v[i])
    {
      pos = k;
      val = v[k];
    }
  v[pos] = v[i];
  v[i] = val;

  // Step 3: sort remaining elements from i+1 ... end
  sort(v.begin()+i+1, v.end());
}