প্রদত্ত স্ট্রিংয়ের সমস্ত ক্রিয়াকলাপ তৈরি করা

418

কোনও স্ট্রিংয়ের সমস্ত ক্রিয়াকলাপ সন্ধান করার জন্য একটি দুর্দান্ত উপায় কী। উদাহরণস্বরূপ ba, এর জন্য অনুচ্ছেদটি হবে baএবং abতবে এর চেয়ে দীর্ঘতর স্ট্রিং সম্পর্কে কী abcdefgh? জাভা বাস্তবায়নের কোনও উদাহরণ আছে কি?

java  algorithm 
— GurdeepS
সূত্র
3
এখানে প্রচুর উত্তর রয়েছে: স্ট্যাকওভারফ্লো
— মারেক সাপোটা
এটি একটি খুব জনপ্রিয় প্রশ্ন। আপনি এখানে একবার দেখে নিতে পারেন: careercup.com/question?id=3861299
— জে জুনিয়র
9
একটি অনুমানের উল্লেখ করা প্রয়োজন। চরিত্রগুলি অনন্য। উদাহরণস্বরূপ, একটি স্ট্রিং "আআআ" এর জন্য কেবল একটি উত্তর রয়েছে। আরও সাধারণ উত্তর পেতে,
— নকলটি
1
অক্ষরের পুনরাবৃত্তি অনুমোদিত, না অক্ষরের পুনরাবৃত্তি অনুমোদিত? একটি একক স্ট্রিংয়ের একই চরিত্রের একাধিক ঘটনা থাকতে পারে?
— অ্যান্ডারসন সবুজ
2
তত্ত্বটি পড়ুন (বা যদি আমার মতো আপনিও অলস হন তবে এন.ইউইকিপিডিয়া.আরউইউ / উইকিপিডিয়েটনে যান ) এবং আসল অ্যালগরিদম প্রয়োগ করুন। মূলত আপনি উপাদানগুলির ক্রমগুলির ক্রম তৈরি করতে পারেন (এটি সত্য যে এটি একটি স্ট্রিং অপ্রাসঙ্গিক) এবং আপনি আরম্ভ না হওয়া অবধি অর্ডারগুলি ধরে চলতে পারেন। পুনরাবৃত্তি বা স্ট্রিং ম্যানিপুলেশনগুলির সাথে জড়িত যে কোনও বিষয় সম্পর্কে পরিষ্কার er
— কার্টেনডগ

উত্তর:

601 
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.substring(0, i) + str.substring(i+1, n));
    }
}

( জাভাতে প্রোগ্রামিংয়ের পরিচিতির মাধ্যমে )

— SuperJulietta
সূত্র
67
সমাধান এখান থেকে উদ্বেগজনক
— সাইবার-সন্ন্যাসী
48
এটি রকেট বিজ্ঞান নয়, আমি প্রায় একই উত্তর নিয়ে এসেছি। অপ্রাপ্তবয়স্ক টুইট: যতক্ষণ না পুনরাবৃত্তি হওয়ার পরিবর্তে n==0আপনি প্রথমে কোনও স্তর থামিয়ে n==1প্রিন্ট আউট করতে পারেন prefix + str।
— lambshaanxy
7
"এর সময় এবং স্থান জটিলতা কী?" কোনও অ্যালগরিদমকে ক্যাশে করে কোনও ধরণের আংশিক উত্তর ছাড়াই আউটপুটস ক্রমিটেশনটি o (n!) হয় কারণ ফলশ্রুতি প্রশ্নে ফলাফল নির্ধারিত ফলাফলটি ইনপুটটির পক্ষে যুক্তিযুক্ত।
— jeremyjjbrown
9
মার্জিত, হ্যাঁ তবে একটি সমাধান যা ক্রম বিন্যাসে রূপান্তরিত করতে এবং আবর্তনগুলি তৈরি করতে অদলবদল করতে অনেক কম অনুলিপি লাগবে এবং অনেক কম আবর্জনা তৈরি করবে। এছাড়াও এই অ্যালগরিদম পুনরাবৃত্তি করা অক্ষরগুলি অ্যাকাউন্টে নিতে ব্যর্থ হয়।
— জিন
20
@ আফশিনমোয়াজামি আমি মনে করি str.substring (i + 1, n) str.substring (i + 1) দ্বারা প্রতিস্থাপন করা যেতে পারে। Str.substring (i) ব্যবহার করার ফলে java.lang.StackOverflowError হবে।
— আয়ুষ্মান
196

পুনরাবৃত্তি ব্যবহার করুন।

  • প্রতিটি অক্ষর প্রথম অক্ষর হিসাবে ঘুরে দেখুন এবং তারপরে পুনরাবৃত্তির কল ব্যবহার করে বাকী সমস্ত অক্ষরের ক্রম সন্ধান করুন।
  • বেস কেসটি তখন হয় যখন ইনপুটটি খালি স্ট্রিং হয় কেবলমাত্র অনুচ্ছেদটি খালি স্ট্রিং।
— মার্ক বাইয়ার্স
সূত্র
3
পারমিট পদ্ধতিতে আপনি কীভাবে কোনও রিটার্ন টাইপ যুক্ত করতে পারেন? সংকলক প্রতিটি পুনরাবৃত্তিতে এই পদ্ধতির রিটার্ন টাইপ নির্ধারণ করতে পারে না, যদিও এটি স্ট্রিং টাইপ স্পষ্টতই।
— ব্যবহারকারী 1712095
আপনি কীভাবে এই পদ্ধতিতে স্বতন্ত্র অনুমতি নিশ্চিত করতে পারেন?
— কাপাড
70

এখানে আমার সমাধান যা "কোডিং সাক্ষাত্কার ক্র্যাকিং" (পি 54) বইয়ের ধারণার ভিত্তিতে তৈরি হয়েছে:

/**
 * List permutations of a string.
 * 
 * @param s the input string
 * @return  the list of permutations
 */
public static ArrayList<String> permutation(String s) {
    // The result
    ArrayList<String> res = new ArrayList<String>();
    // If input string's length is 1, return {s}
    if (s.length() == 1) {
        res.add(s);
    } else if (s.length() > 1) {
        int lastIndex = s.length() - 1;
        // Find out the last character
        String last = s.substring(lastIndex);
        // Rest of the string
        String rest = s.substring(0, lastIndex);
        // Perform permutation on the rest string and
        // merge with the last character
        res = merge(permutation(rest), last);
    }
    return res;
}

/**
 * @param list a result of permutation, e.g. {"ab", "ba"}
 * @param c    the last character
 * @return     a merged new list, e.g. {"cab", "acb" ... }
 */
public static ArrayList<String> merge(ArrayList<String> list, String c) {
    ArrayList<String> res = new ArrayList<>();
    // Loop through all the string in the list
    for (String s : list) {
        // For each string, insert the last character to all possible positions
        // and add them to the new list
        for (int i = 0; i <= s.length(); ++i) {
            String ps = new StringBuffer(s).insert(i, c).toString();
            res.add(ps);
        }
    }
    return res;
}

"Abcd" স্ট্রিংয়ের চলমান আউটপুট:

  • পদক্ষেপ 1: [a] এবং খ: মার্জ [বি, আব]

  • পদক্ষেপ 2: [বা, আব] এবং সি মার্জ করুন: [সিবিএ, বিসিএ, ব্যাক, ক্যাব, এসিবি, এবিসি]

  • পদক্ষেপ 3: [সিবিএ, বিসিএ, ব্যাক, ক্যাব, এসিবি, এবিসি] এবং ডি: মার্জ করুন , ক্যাবড, ড্যাকবি, অ্যাডিসিবি, এসিডিবি, এসিবিডি, ড্যাবসি, অ্যাডবিসি, এবিডিসি, এবিসিডি]

— jeantimex
সূত্র
কোডিং সাক্ষাত্কারের বইটি ক্র্যাকিংয়ের পৃষ্ঠা ()১) 6th ষ্ঠ সংস্করণ। :)
— করিমআইব
5
এটি কি আসলেই ভাল সমাধান? এটি ফলাফলগুলিকে একটি তালিকায় সংরক্ষণের উপর নির্ভর করে, সুতরাং একটি সংক্ষিপ্ত ইনপুট স্ট্রিংয়ের জন্য এটি নিয়ন্ত্রণের বাইরে চলে যায়।
— Androrider
একীভূত কী?
— বাসভরাজ ওলিকার
এটি তালিকার প্রতিটি স্ট্রিংয়ের প্রতিটি সম্ভাব্য পজিশনে সি প্রবেশ করায় তাই তালিকায় যদি কেবল ["বি"] থাকে এবং সি থাকে তবে "এ" একত্রীকরণের ফলাফল ["আব", "বা"] এখানে সুইফট জিস্ট.github এর
— ডানিয়া দেলবানী
53

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

public class PermTest {

    public static void main(String[] args) throws Exception {
        String str = "abcdef";
        StringBuffer strBuf = new StringBuffer(str);
        doPerm(strBuf,0);
    }

    private static void doPerm(StringBuffer str, int index){

        if(index == str.length())
            System.out.println(str);            
        else { //recursively solve this by placing all other chars at current first pos
            doPerm(str, index+1);
            for (int i = index+1; i < str.length(); i++) {//start swapping all other chars with current first char
                swap(str,index, i);
                doPerm(str, index+1);
                swap(str,i, index);//restore back my string buffer
            }
        }
    }

    private  static void swap(StringBuffer str, int pos1, int pos2){
        char t1 = str.charAt(pos1);
        str.setCharAt(pos1, str.charAt(pos2));
        str.setCharAt(pos2, t1);
    }
}

আমি এই থ্রেডের প্রথমটির আগে এই সমাধানটিকে পছন্দ করি কারণ এই সমাধানটি স্ট্রিংবফার ব্যবহার করে। আমি বলব না যে আমার সমাধানটি কোনও অস্থায়ী স্ট্রিং তৈরি করে না (এটি আসলে স্ট্রিংবুফার system.out.printlnযেখানে toString()বলা হয় সেখানে ঘটে)। তবে আমি মনে করি এটি প্রথম সমাধানের চেয়ে ভাল যেখানে অনেকগুলি স্ট্রিং আক্ষরিক তৈরি হয়। কিছু পারফরম্যান্সের লোক হতে পারে এটি 'মেমরির' ক্ষেত্রে বিবেচনা করতে পারে ('সময়ের জন্য' এটি অতিরিক্ত 'অদলবদলের কারণে ইতিমধ্যে পিছিয়ে পড়ে)

— শ্রীকান্ত ইয়ারাদলা
সূত্র
শুধু if(index == str.length())এবং কেন না doPerm(str, index + 1);? currPosএখানে অপ্রয়োজনীয় বলে মনে হয়।
— রবুর_131
দুঃখিত, আপনি কি আরও প্রশ্নটি বিস্তারিতভাবে বর্ণনা করতে পারেন? আপনি কি কেবল অতিরিক্ত পরিবর্তনশীল কাররপোস ব্যবহার না করার পরামর্শ দিচ্ছেন (একাধিক ঘটনার কারণে এবং পাঠযোগ্যতার কারণেও ব্যবহৃত হয়) তবে দয়া করে আপনি যে সমাধানটি দেখার পরামর্শ দিচ্ছেন
— সমাধানটি আটকে দিন
আহ আমি পেয়েছি যে আপনি ফরওয়ার্ড ইনডেক্সিংয়ের সাথে বেস শর্তে পরিবর্তনটি বোঝাতে চেয়েছিলেন। ঠিকভাবে কাজ করে. কেবলমাত্র আমি যে সমাধানটি উপস্থাপন করেছি তা বেশিরভাগ তত্কালীন অন্যান্য সমাধানগুলির দ্বারা প্রভাবিত হয়েছিল যা প্রায়শই মূলের চেয়ে কাটা স্ট্রিংকে পাশ করে (যা কেস 0 এর মানে তোলে)। তবুও নির্দেশ করার জন্য ধন্যবাদ। আমি সম্পাদনা করতে পারি কিনা তা দেখতে পাবে, আমি এই সাইটে লগইন করার বহু বছর পরে।
— শ্রীকান্ত ইয়ারাদলা
22

জাভাতে একটি খুব প্রাথমিক সমাধান হ'ল আপনি যদি সমাধানের স্ট্রিংগুলি সঞ্চয় করতে এবং ফিরে পেতে চান তবে পুনরাবৃত্তি + সেট (পুনরাবৃত্তিগুলি এড়ানোর জন্য) ব্যবহার করুন:

public static Set<String> generatePerm(String input)
{
    Set<String> set = new HashSet<String>();
    if (input == "")
        return set;

    Character a = input.charAt(0);

    if (input.length() > 1)
    {
        input = input.substring(1);

        Set<String> permSet = generatePerm(input);

        for (String x : permSet)
        {
            for (int i = 0; i <= x.length(); i++)
            {
                set.add(x.substring(0, i) + a + x.substring(i));
            }
        }
    }
    else
    {
        set.add(a + "");
    }
    return set;
}
— devastator
সূত্র
2
এই অ্যালোগ্রিমের সময় জটিলতা কী ??
— আশিশাহু
1
@ এশিসাহু ও (এন!) যেহেতু আমরা এন! প্রদত্ত এন দৈর্ঘ্যের স্ট্রিংগুলিতে ক্রিয়াকলাপ।
— জোক
17

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

কয়েকটি জিনিস:

  1. লক্ষ করুন যে সর্বশেষ আইটেমটি এক্সেলে চিত্রিত করা হয়েছে কেবলমাত্র যুক্তিটিকে আরও ভালভাবে কল্পনা করতে সহায়তা করার জন্য। সুতরাং, শেষ কলামে আসল মানগুলি হবে 2,1,0 (যদি আমরা কোড চালাতে পারি কারণ আমরা অ্যারে এবং অ্যারে 0 দিয়ে শুরু করছি)।

  2. অদলবদল অ্যালগরিদম বর্তমান অবস্থানের সম বা বিজোড় মানগুলির উপর ভিত্তি করে ঘটে। অদলবদলের পদ্ধতিটি কোথায় ডাকা হচ্ছে তা যদি আপনি দেখেন তবে এটি খুব স্বচ্ছ ব্যাখ্যাযোগ্য You আপনি কী দেখতে পাচ্ছেন তা দেখতে পাবেন।

যা ঘটে তা এখানে: এখানে চিত্র বর্ণনা লিখুন

public static void main(String[] args) {

        String ourword = "abc";
        String[] ourArray = ourword.split("");
        permute(ourArray, ourArray.length);

    }

    private static void swap(String[] ourarray, int right, int left) {
        String temp = ourarray[right];
        ourarray[right] = ourarray[left];
        ourarray[left] = temp;
    }

    public static void permute(String[] ourArray, int currentPosition) {
        if (currentPosition == 1) {
            System.out.println(Arrays.toString(ourArray));
        } else {
            for (int i = 0; i < currentPosition; i++) {
                // subtract one from the last position (here is where you are
                // selecting the the next last item 
                permute(ourArray, currentPosition - 1);

                // if it's odd position
                if (currentPosition % 2 == 1) {
                    swap(ourArray, 0, currentPosition - 1);
                } else {
                    swap(ourArray, i, currentPosition - 1);
                }
            }
        }
    }
— grepit
সূত্র
11

এই এক পুনরাবৃত্তি হয় 

public static void permute(String s) {
    if(null==s || s.isEmpty()) {
        return;
    }

    // List containing words formed in each iteration 
    List<String> strings = new LinkedList<String>();
    strings.add(String.valueOf(s.charAt(0))); // add the first element to the list

     // Temp list that holds the set of strings for 
     //  appending the current character to all position in each word in the original list
    List<String> tempList = new LinkedList<String>(); 

    for(int i=1; i< s.length(); i++) {

        for(int j=0; j<strings.size(); j++) {
            tempList.addAll(merge(s.charAt(i), strings.get(j)));
                        }
        strings.removeAll(strings);
        strings.addAll(tempList);

        tempList.removeAll(tempList);

    }

    for(int i=0; i<strings.size(); i++) {
        System.out.println(strings.get(i));
    }
}

/**
 * helper method that appends the given character at each position in the given string 
 * and returns a set of such modified strings 
 * - set removes duplicates if any(in case a character is repeated)
 */
private static Set<String> merge(Character c,  String s) {
    if(s==null || s.isEmpty()) {
        return null;
    }

    int len = s.length();
    StringBuilder sb = new StringBuilder();
    Set<String> list = new HashSet<String>();

    for(int i=0; i<= len; i++) {
        sb = new StringBuilder();
        sb.append(s.substring(0, i) + c + s.substring(i, len));
        list.add(sb.toString());
    }

    return list;
}
— Jeya
সূত্র
এই সমাধানটি System.out.println(permute("AABBC").size());45 টির মতো ভুল প্রদর্শিত হচ্ছে , তবে বাস্তবে 5 টি! = 120
— ম্লাদেন অ্যাডামোভিক
11

abcউদাহরণ হিসাবে ইনপুট ব্যবহার করা যাক ।

cএকটি সেট ( ) এ ঠিক শেষ উপাদান ( ) দিয়ে শুরু ["c"]করুন, তারপরে দ্বিতীয় শেষ উপাদানটি ( b) এর সম্মুখ, শেষ এবং মাঝের প্রতিটি সম্ভাব্য অবস্থানের সাথে যুক্ত করুন এবং এটি ["bc", "cb"]একই পদ্ধতিতে এটি পরবর্তী উপাদান যুক্ত করবে পিছনে ( a) থেকে সেটটিতে প্রতিটি স্ট্রিং পর্যন্ত:

"a" + "bc" = ["abc", "bac", "bca"]  and  "a" + "cb" = ["acb" ,"cab", "cba"]

এইভাবে পুরো অনুচ্ছেদ:

["abc", "bac", "bca","acb" ,"cab", "cba"]

কোড:

public class Test 
{
    static Set<String> permutations;
    static Set<String> result = new HashSet<String>();

    public static Set<String> permutation(String string) {
        permutations = new HashSet<String>();

        int n = string.length();
        for (int i = n - 1; i >= 0; i--) 
        {
            shuffle(string.charAt(i));
        }
        return permutations;
    }

    private static void shuffle(char c) {
        if (permutations.size() == 0) {
            permutations.add(String.valueOf(c));
        } else {
            Iterator<String> it = permutations.iterator();
            for (int i = 0; i < permutations.size(); i++) {

                String temp1;
                for (; it.hasNext();) {
                    temp1 = it.next();
                    for (int k = 0; k < temp1.length() + 1; k += 1) {
                        StringBuilder sb = new StringBuilder(temp1);

                        sb.insert(k, c);

                        result.add(sb.toString());
                    }
                }
            }
            permutations = result;
            //'result' has to be refreshed so that in next run it doesn't contain stale values.
            result = new HashSet<String>();
        }
    }

    public static void main(String[] args) {
        Set<String> result = permutation("abc");

        System.out.println("\nThere are total of " + result.size() + " permutations:");
        Iterator<String> it = result.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }
}
— বিহান ভার্মা
সূত্র
1
আমি আপনার সমাধান পছন্দ। খুব স্বজ্ঞাত এবং ভাল ব্যাখ্যা। আপনাকে অনেক ধন্যবাদ.
— ব্যবহারকারী 2585781
9

ঠিক আছে এখানে একটি মার্জিত, পুনরাবৃত্তিযোগ্য, ও (এন!) সমাধান:

public static StringBuilder[] permutations(String s) {
        if (s.length() == 0)
            return null;
        int length = fact(s.length());
        StringBuilder[] sb = new StringBuilder[length];
        for (int i = 0; i < length; i++) {
            sb[i] = new StringBuilder();
        }
        for (int i = 0; i < s.length(); i++) {
            char ch = s.charAt(i);
            int times = length / (i + 1);
            for (int j = 0; j < times; j++) {
                for (int k = 0; k < length / times; k++) {
                    sb[j * length / times + k].insert(k, ch);
                }
            }
        }
        return sb;
    }
— আদিলি আদিল
সূত্র
এই সমাধানটি কেবলমাত্র যদি শব্দটির 4 টিরও কম অক্ষর থাকে তবে তা কাজ করে, অন্যথায় ফলাফলের অ্যারেগুলির অর্ধেকটি স্বতন্ত্র শব্দ রয়েছে।
— মাকসিম মাকসিমভ
5

সহজ সমাধানগুলির মধ্যে একটি হ'ল দু'টি পয়েন্টার ব্যবহার করে অক্ষরগুলিকে পুনরাবৃত্তভাবে অদলবদল করে রাখা যেতে পারে।

public static void main(String[] args)
{
    String str="abcdefgh";
    perm(str);
}
public static void perm(String str)
{  char[] char_arr=str.toCharArray();
    helper(char_arr,0);
}
public static void helper(char[] char_arr, int i)
{
    if(i==char_arr.length-1)
    {
        // print the shuffled string 
            String str="";
            for(int j=0; j<char_arr.length; j++)
            {
                str=str+char_arr[j];
            }
            System.out.println(str);
    }
    else
    {
    for(int j=i; j<char_arr.length; j++)
    {
        char tmp = char_arr[i];
        char_arr[i] = char_arr[j];
        char_arr[j] = tmp;
        helper(char_arr,i+1);
        char tmp1 = char_arr[i];
        char_arr[i] = char_arr[j];
        char_arr[j] = tmp1;
    }
}
}
— কেটি
সূত্র
এটি এখানে প্রদত্ত সমাধানের অনুরূপ: জিক্সফরজিক্স.আর /… , ব্যাকট্র্যাকিং এবং সময়ের জটিলতা ও (এন * এন!) জড়িত।
— নাকুল কুমার
5

অজগর বাস্তবায়ন

def getPermutation(s, prefix=''):
        if len(s) == 0:
                print prefix
        for i in range(len(s)):
                getPermutation(s[0:i]+s[i+1:len(s)],prefix+s[i] )



getPermutation('abcd','')
— riteshkasat
সূত্র
4

এটি আমার জন্য কাজ করেছে .. 

import java.util.Arrays;

public class StringPermutations{
    public static void main(String args[]) {
        String inputString = "ABC";
        permute(inputString.toCharArray(), 0, inputString.length()-1);
    }

    public static void permute(char[] ary, int startIndex, int endIndex) {
        if(startIndex == endIndex){
            System.out.println(String.valueOf(ary));
        }else{
            for(int i=startIndex;i<=endIndex;i++) {
                 swap(ary, startIndex, i );
                 permute(ary, startIndex+1, endIndex);
                 swap(ary, startIndex, i );
            }
        }
    }

    public static void swap(char[] ary, int x, int y) {
        char temp = ary[x];
        ary[x] = ary[y];
        ary[y] = temp;
    }
}
— অরুণ কুমার মুদ্রাবোয়িনা
সূত্র
3

পুনরাবৃত্তি ব্যবহার করুন।

যখন ইনপুটটি একটি খালি স্ট্রিং থাকে তবে একমাত্র অনুমান হ'ল একটি খালি স্ট্রিং the স্ট্রিংয়ের প্রতিটি অক্ষরের জন্য প্রথম অক্ষর হিসাবে চেষ্টা করুন এবং তারপরে পুনরাবৃত্তির কল ব্যবহার করে বাকী সমস্ত অক্ষরের ক্রম সন্ধান করুন।

import java.util.ArrayList;
import java.util.List;

class Permutation {
    private static List<String> permutation(String prefix, String str) {
        List<String> permutations = new ArrayList<>();
        int n = str.length();
        if (n == 0) {
            permutations.add(prefix);
        } else {
            for (int i = 0; i < n; i++) {
                permutations.addAll(permutation(prefix + str.charAt(i), str.substring(i + 1, n) + str.substring(0, i)));
            }
        }
        return permutations;
    }

    public static void main(String[] args) {
        List<String> perms = permutation("", "abcd");

        String[] array = new String[perms.size()];
        for (int i = 0; i < perms.size(); i++) {
            array[i] = perms.get(i);
        }

        int x = array.length;

        for (final String anArray : array) {
            System.out.println(anArray);
        }
    }
}
— coder101
সূত্র
3

কোটলিনের সাথে এই সমস্যাটি সমাধান করার চেষ্টা করি:

fun <T> List<T>.permutations(): List<List<T>> {
    //escape case
    if (this.isEmpty()) return emptyList()

    if (this.size == 1) return listOf(this)

    if (this.size == 2) return listOf(listOf(this.first(), this.last()), listOf(this.last(), this.first()))

    //recursive case
    return this.flatMap { lastItem ->
        this.minus(lastItem).permutations().map { it.plus(lastItem) }
    }
}

মূল ধারণা: দীর্ঘ তালিকাকে ছোট তালিকাতে + পুনরাবৃত্তিতে ভাঙ্গা

উদাহরণ তালিকার দীর্ঘ উত্তর [1, 2, 3, 4]:

এমনকি 4 টির একটি তালিকার জন্য এটি ইতিমধ্যে আপনার মাথার সমস্ত সম্ভাব্য ক্রমগুলি তালিকাভুক্ত করার চেষ্টা করে বিভ্রান্ত করছে এবং আমাদের যা করা দরকার তা হ'ল এড়াতে। 0, 1, এবং 2 আকারের তালিকার সমস্ত ক্রিয়াকলাপ কীভাবে করা যায় তা আমাদের পক্ষে বোঝা সহজ, তাই আমাদের যা করতে হবে তা হ'ল তাদের মাপের যে কোনও একটিকে ভেঙে সঠিকভাবে ব্যাক আপ করতে হবে। একটি জ্যাকপট মেশিনের কল্পনা করুন: এই অ্যালগরিদমটি ডান থেকে বাম দিকে ঘুরতে শুরু করবে এবং লিখবে

  1. তালিকার আকার 0 বা 1 হলে খালি / 1 টির তালিকা ফিরে আসুন
  2. তালিকার আকার 2 (উদাঃ [3, 4]) হ্যান্ডেল করুন এবং 2 অনুক্রম তৈরি করুন ([3, 4] এবং [4, 3])
  3. প্রতিটি আইটেমের জন্য, এটি শেষের হিসাবে শেষ হিসাবে চিহ্নিত করুন এবং তালিকার বাকী আইটেমের জন্য সমস্ত অনুমতি সন্ধান করুন। (উদাহরণস্বরূপ [4] টেবিলের উপরে রাখুন এবং [1, 2, 3] কে আবার অনুমানের মধ্যে ফেলে দিন)
  4. এখন শিশুদের সমস্ত অনুমানের সাথে তালিকার শেষের দিকে নিজেকে ফিরিয়ে আনুন (যেমন: [১, ২, ৩] [, ৪], [১, ৩, ২] [, ৪], [২, ৩, ১] [, 4], ...)
— লুই সসাই
সূত্র
2 
import java.io.IOException;
import java.util.ArrayList;
import java.util.Scanner;
public class hello {
    public static void main(String[] args) throws IOException {
        hello h = new hello();
        h.printcomp();
    }
      int fact=1;
    public void factrec(int a,int k){
        if(a>=k)
        {fact=fact*k;
        k++;
        factrec(a,k);
        }
        else
        {System.out.println("The string  will have "+fact+" permutations");
        }
        }
    public void printcomp(){
        String str;
        int k;
        Scanner in = new Scanner(System.in);
        System.out.println("enter the string whose permutations has to b found");
        str=in.next();
        k=str.length();
        factrec(k,1);
        String[] arr =new String[fact];
        char[] array = str.toCharArray();
        while(p<fact)
        printcomprec(k,array,arr);
            // if incase u need array containing all the permutation use this
            //for(int d=0;d<fact;d++)         
        //System.out.println(arr[d]);
    }
    int y=1;
    int p = 0;
    int g=1;
    int z = 0;
    public void printcomprec(int k,char array[],String arr[]){
        for (int l = 0; l < k; l++) {
            for (int b=0;b<k-1;b++){
            for (int i=1; i<k-g; i++) {
                char temp;
                String stri = "";
                temp = array[i];
                array[i] = array[i + g];
                array[i + g] = temp;
                for (int j = 0; j < k; j++)
                    stri += array[j];
                arr[z] = stri;
                System.out.println(arr[z] + "   " + p++);
                z++;
            }
            }
            char temp;
            temp=array[0];
            array[0]=array[y];
            array[y]=temp;
            if (y >= k-1)
                y=y-(k-1);
            else
                y++;
        }
        if (g >= k-1)
            g=1;
        else
            g++;
    }

}
— অ্যান্টনি জনসন
সূত্র
2 
/** Returns an array list containing all
 * permutations of the characters in s. */
public static ArrayList<String> permute(String s) {
    ArrayList<String> perms = new ArrayList<>();
    int slen = s.length();
    if (slen > 0) {
        // Add the first character from s to the perms array list.
        perms.add(Character.toString(s.charAt(0)));

        // Repeat for all additional characters in s.
        for (int i = 1;  i < slen;  ++i) {

            // Get the next character from s.
            char c = s.charAt(i);

            // For each of the strings currently in perms do the following:
            int size = perms.size();
            for (int j = 0;  j < size;  ++j) {

                // 1. remove the string
                String p = perms.remove(0);
                int plen = p.length();

                // 2. Add plen + 1 new strings to perms.  Each new string
                //    consists of the removed string with the character c
                //    inserted into it at a unique location.
                for (int k = 0;  k <= plen;  ++k) {
                    perms.add(p.substring(0, k) + c + p.substring(k));
                }
            }
        }
    }
    return perms;
}
— Barzee
সূত্র
2

জাভাতে এখানে একটি সরল নূন্যতম পুনরাবৃত্ত সমাধান রয়েছে:

public static ArrayList<String> permutations(String s) {
    ArrayList<String> out = new ArrayList<String>();
    if (s.length() == 1) {
        out.add(s);
        return out;
    }
    char first = s.charAt(0);
    String rest = s.substring(1);
    for (String permutation : permutations(rest)) {
        out.addAll(insertAtAllPositions(first, permutation));
    }
    return out;
}
public static ArrayList<String> insertAtAllPositions(char ch, String s) {
    ArrayList<String> out = new ArrayList<String>();
    for (int i = 0; i <= s.length(); ++i) {
        String inserted = s.substring(0, i) + ch + s.substring(i);
        out.add(inserted);
    }
    return out;
}
— জে টেলর
সূত্র
2

নির্দিষ্ট বর্ণ দ্বারা কয়টি স্ট্রিং শুরু হয়েছিল তা জানতে আমরা ফ্যাকটোরিয়াল ব্যবহার করতে পারি।

উদাহরণ: ইনপুট নিন abcd। (3!) == 6স্ট্রিংগুলির প্রতিটি অক্ষর দিয়ে শুরু হবে abcd।

static public int facts(int x){
    int sum = 1;
    for (int i = 1; i < x; i++) {
        sum *= (i+1);
    }
    return sum;
}

public static void permutation(String str) {
    char[] str2 = str.toCharArray();
    int n = str2.length;
    int permutation = 0;
    if (n == 1) {
        System.out.println(str2[0]);
    } else if (n == 2) {
        System.out.println(str2[0] + "" + str2[1]);
        System.out.println(str2[1] + "" + str2[0]);
    } else {
        for (int i = 0; i < n; i++) {
            if (true) {
                char[] str3 = str.toCharArray();
                char temp = str3[i];
                str3[i] = str3[0];
                str3[0] = temp;
                str2 = str3;
            }

            for (int j = 1, count = 0; count < facts(n-1); j++, count++) {
                if (j != n-1) {
                    char temp1 = str2[j+1];
                    str2[j+1] = str2[j];
                    str2[j] = temp1;
                } else {
                    char temp1 = str2[n-1];
                    str2[n-1] = str2[1];
                    str2[1] = temp1;
                    j = 1;
                } // end of else block
                permutation++;
                System.out.print("permutation " + permutation + " is   -> ");
                for (int k = 0; k < n; k++) {
                    System.out.print(str2[k]);
                } // end of loop k
                System.out.println();
            } // end of loop j
        } // end of loop i
    }
}
— user1685821
সূত্র
2

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

public class LexicographicPermutations {

public static void main(String[] args) {
    // TODO Auto-generated method stub
    String s="abc";
    List<String>combinations=new ArrayList<String>();
    combinations=permutations(s);
    Collections.sort(combinations);
    System.out.println(combinations);
}

private static List<String> permutations(String s) {
    // TODO Auto-generated method stub
    List<String>combinations=new ArrayList<String>();
    if(s.length()==1){
        combinations.add(s);
    }
    else{
        for(int i=0;i<s.length();i++){
            List<String>temp=permutations(s.substring(0, i)+s.substring(i+1));
            for (String string : temp) {
                combinations.add(s.charAt(i)+string);
            }
        }
    }
    return combinations;
}}

যা আউটপুট হিসাবে উত্পন্ন করে [abc, acb, bac, bca, cab, cba]।

এর পিছনে বুনিয়াদি যুক্তি রয়েছে

প্রতিটি চরিত্রের জন্য, এটি প্রথম অক্ষর হিসাবে বিবেচনা করুন এবং অবশিষ্ট অক্ষরের সংমিশ্রণ সন্ধান করুন। যেমন [abc](Combination of abc)->।

  1. a->[bc](a x Combination of (bc))->{abc,acb}
  2. b->[ac](b x Combination of (ac))->{bac,bca}
  3. c->[ab](c x Combination of (ab))->{cab,cba}

এবং তারপর যাও recursively প্রতিটি কলিং [bc], [ac]& [ab]স্বাধীনভাবে।

— শব্বির এসাজি
সূত্র
2

পুনরাবৃত্তি না করে জাভা বাস্তবায়ন

public Set<String> permutate(String s){
    Queue<String> permutations = new LinkedList<String>();
    Set<String> v = new HashSet<String>();
    permutations.add(s);

    while(permutations.size()!=0){
        String str = permutations.poll();
        if(!v.contains(str)){
            v.add(str);
            for(int i = 0;i<str.length();i++){
                String c = String.valueOf(str.charAt(i));
                permutations.add(str.substring(i+1) + c +  str.substring(0,i));
            }
        }
    }
    return v;
}
— হাদি এলমোগি
সূত্র
1

// প্রতিটি অক্ষরকে একটি অ্যারেলিস্টে সন্নিবেশ করান

static ArrayList al = new ArrayList();

private static void findPermutation (String str){
    for (int k = 0; k < str.length(); k++) {
        addOneChar(str.charAt(k));
    }
}

//insert one char into ArrayList
private static void addOneChar(char ch){
    String lastPerStr;
    String tempStr;
    ArrayList locAl = new ArrayList();
    for (int i = 0; i < al.size(); i ++ ){
        lastPerStr = al.get(i).toString();
        //System.out.println("lastPerStr: " + lastPerStr);
        for (int j = 0; j <= lastPerStr.length(); j++) {
            tempStr = lastPerStr.substring(0,j) + ch + 
                    lastPerStr.substring(j, lastPerStr.length());
            locAl.add(tempStr);
            //System.out.println("tempStr: " + tempStr);
        }
    }
    if(al.isEmpty()){
        al.add(ch);
    } else {
        al.clear();
        al = locAl;
    }
}

private static void printArrayList(ArrayList al){
    for (int i = 0; i < al.size(); i++) {
        System.out.print(al.get(i) + "  ");
    }
}
— ডেভিড লি
সূত্র
যেমন কোন ব্যাখ্যা রয়েছে এবং এটি একই আলগোরিদিম ব্যবহার করে যেমন কয়েক অন্যান্য উত্তর যে আমি এই উত্তর দরকারী খুঁজে না কি একটি ব্যাখ্যা প্রদান।
— বার্নহার্ড বার্কার
1 
//Rotate and create words beginning with all letter possible and push to stack 1

//Read from stack1 and for each word create words with other letters at the next location by rotation and so on 

/*  eg : man

    1. push1 - man, anm, nma
    2. pop1 - nma ,  push2 - nam,nma
       pop1 - anm ,  push2 - amn,anm
       pop1 - man ,  push2 - mna,man
*/

public class StringPermute {

    static String str;
    static String word;
    static int top1 = -1;
    static int top2 = -1;
    static String[] stringArray1;
    static String[] stringArray2;
    static int strlength = 0;

    public static void main(String[] args) throws IOException {
        System.out.println("Enter String : ");
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader bfr = new BufferedReader(isr);
        str = bfr.readLine();
        word = str;
        strlength = str.length();
        int n = 1;
        for (int i = 1; i <= strlength; i++) {
            n = n * i;
        }
        stringArray1 = new String[n];
        stringArray2 = new String[n];
        push(word, 1);
        doPermute();
        display();
    }

    public static void push(String word, int x) {
        if (x == 1)
            stringArray1[++top1] = word;
        else
            stringArray2[++top2] = word;
    }

    public static String pop(int x) {
        if (x == 1)
            return stringArray1[top1--];
        else
            return stringArray2[top2--];
    }

    public static void doPermute() {

        for (int j = strlength; j >= 2; j--)
            popper(j);

    }

    public static void popper(int length) {
        // pop from stack1 , rotate each word n times and push to stack 2
        if (top1 > -1) {
            while (top1 > -1) {
                word = pop(1);
                for (int j = 0; j < length; j++) {
                    rotate(length);
                    push(word, 2);
                }
            }
        }
        // pop from stack2 , rotate each word n times w.r.t position and push to
        // stack 1
        else {
            while (top2 > -1) {
                word = pop(2);
                for (int j = 0; j < length; j++) {
                    rotate(length);
                    push(word, 1);
                }
            }
        }

    }

    public static void rotate(int position) {
        char[] charstring = new char[100];
        for (int j = 0; j < word.length(); j++)
            charstring[j] = word.charAt(j);

        int startpos = strlength - position;
        char temp = charstring[startpos];
        for (int i = startpos; i < strlength - 1; i++) {
            charstring[i] = charstring[i + 1];
        }
        charstring[strlength - 1] = temp;
        word = new String(charstring).trim();
    }

    public static void display() {
        int top;
        if (top1 > -1) {
            while (top1 > -1)
                System.out.println(stringArray1[top1--]);
        } else {
            while (top2 > -1)
                System.out.println(stringArray2[top2--]);
        }
    }
}
— nnc
সূত্র
1

আরেকটি সহজ উপায় হ'ল স্ট্রিংটির মধ্য দিয়ে লুপ করা, এখনও ব্যবহৃত হয়নি এমন চরিত্রটি বেছে নিন এবং এটি একটি বাফারে রেখে দিন, বাফারের আকার স্ট্রিংয়ের দৈর্ঘ্যের সমান না হওয়া পর্যন্ত লুপটি চালিয়ে যান। আমি এই ব্যাক ট্র্যাকিং সমাধানটি আরও ভাল পছন্দ করি কারণ:

  1. সহজে বোধগম্য
  2. সদৃশ এড়ানো সহজ
  3. আউটপুট বাছাই করা হয়

জাভা কোডটি এখানে:

List<String> permute(String str) {
  if (str == null) {
    return null;
  }

  char[] chars = str.toCharArray();
  boolean[] used = new boolean[chars.length];

  List<String> res = new ArrayList<String>();
  StringBuilder sb = new StringBuilder();

  Arrays.sort(chars);

  helper(chars, used, sb, res);

  return res;
}

void helper(char[] chars, boolean[] used, StringBuilder sb, List<String> res) {
  if (sb.length() == chars.length) {
    res.add(sb.toString());
    return;
  }

  for (int i = 0; i < chars.length; i++) {
    // avoid duplicates
    if (i > 0 && chars[i] == chars[i - 1] && !used[i - 1]) {
      continue;
    }

    // pick the character that has not used yet
    if (!used[i]) {
      used[i] = true;
      sb.append(chars[i]);

      helper(chars, used, sb, res);

      // back tracking
      sb.deleteCharAt(sb.length() - 1);
      used[i] = false;
    }
  }
}

ইনপুট str: 1231

আউটপুট তালিকা: 23 1123, 1132, 1213, 1231, 1312, 1321, 2113, 2131, 2311, 3112, 3121, 3211}

লক্ষ্য করা গেছে যে আউটপুটটি সাজানো হয়েছে, এবং কোনও সদৃশ ফলাফল নেই।

— jeantimex
সূত্র
1

পুনরাবৃত্তি প্রয়োজন হয় না, এমনকি আপনি সরাসরি যে কোনও ক্রমশক্তি গণনা করতে পারেন , এই সমাধানটি কোনও অ্যারেকে অনুমতি দেওয়ার জন্য জেনেরিকগুলি ব্যবহার করে।

এই অ্যালগরিহটম সম্পর্কে এখানে একটি ভাল তথ্য।

জন্য C # এর ডেভেলপারদের এখানে আরো উপযোগী বাস্তবায়ন।

public static void main(String[] args) {
    String word = "12345";

    Character[] array = ArrayUtils.toObject(word.toCharArray());
    long[] factorials = Permutation.getFactorials(array.length + 1);

    for (long i = 0; i < factorials[array.length]; i++) {
        Character[] permutation = Permutation.<Character>getPermutation(i, array, factorials);
        printPermutation(permutation);
    }
}

private static void printPermutation(Character[] permutation) {
    for (int i = 0; i < permutation.length; i++) {
        System.out.print(permutation[i]);
    }
    System.out.println();
}

এই অ্যালগরিদমের প্রতিটি ক্রমান্বয়ে গণনা করার জন্য ও (এন) সময় এবং স্থান জটিলতা রয়েছে ।

public class Permutation {
    public static <T> T[] getPermutation(long permutationNumber, T[] array, long[] factorials) {
        int[] sequence = generateSequence(permutationNumber, array.length - 1, factorials);
        T[] permutation = generatePermutation(array, sequence);

        return permutation;
    }

    public static <T> T[] generatePermutation(T[] array, int[] sequence) {
        T[] clone = array.clone();

        for (int i = 0; i < clone.length - 1; i++) {
            swap(clone, i, i + sequence[i]);
        }

        return clone;
    }

    private static int[] generateSequence(long permutationNumber, int size, long[] factorials) {
        int[] sequence = new int[size];

        for (int j = 0; j < sequence.length; j++) {
            long factorial = factorials[sequence.length - j];
            sequence[j] = (int) (permutationNumber / factorial);
            permutationNumber = (int) (permutationNumber % factorial);
        }

        return sequence;
    }

    private static <T> void swap(T[] array, int i, int j) {
        T t = array[i];
        array[i] = array[j];
        array[j] = t;
    }

    public static long[] getFactorials(int length) {
        long[] factorials = new long[length];
        long factor = 1;

        for (int i = 0; i < length; i++) {
            factor *= i <= 1 ? 1 : i;
            factorials[i] = factor;
        }

        return factorials;
    }
}
— Najera
সূত্র
1

স্ট্রিং এর অনুমতি:

public static void main(String args[]) {
    permu(0,"ABCD");
}

static void permu(int fixed,String s) {
    char[] chr=s.toCharArray();
    if(fixed==s.length())
        System.out.println(s);
    for(int i=fixed;i<s.length();i++) {
        char c=chr[i];
        chr[i]=chr[fixed];
        chr[fixed]=c;
        permu(fixed+1,new String(chr));
    }   
}
— sakivns
সূত্র
1

এখানে স্ট্রিংয়ের পারমিটেশন করার আরও একটি সহজ পদ্ধতি।

public class Solution4 {
public static void main(String[] args) {
    String  a = "Protijayi";
  per(a, 0);

}

static void per(String a  , int start ) {
      //bse case;
    if(a.length() == start) {System.out.println(a);}
    char[] ca = a.toCharArray();
    //swap 
    for (int i = start; i < ca.length; i++) {
        char t = ca[i];
        ca[i] = ca[start];
        ca[start] = t;
        per(new String(ca),start+1);
    }

}//per

}
— সৌদীপ্ত দত্ত
সূত্র
1

ডুপ্লিকেট অক্ষর বিবেচনা করে একটি নির্দিষ্ট স্ট্রিংয়ের সমস্ত অনুমতি মুদ্রণের জন্য একটি জাভা বাস্তবায়ন এবং কেবল অনন্য অক্ষরগুলি মুদ্রণ করে তা নিম্নরূপ:

import java.util.Set;
import java.util.HashSet;

public class PrintAllPermutations2
{
    public static void main(String[] args)
    {
        String str = "AAC";

    PrintAllPermutations2 permutation = new PrintAllPermutations2();

    Set<String> uniqueStrings = new HashSet<>();

    permutation.permute("", str, uniqueStrings);
}

void permute(String prefixString, String s, Set<String> set)
{
    int n = s.length();

    if(n == 0)
    {
        if(!set.contains(prefixString))
        {
            System.out.println(prefixString);
            set.add(prefixString);
        }
    }
    else
    {
        for(int i=0; i<n; i++)
        {
            permute(prefixString + s.charAt(i), s.substring(0,i) + s.substring(i+1,n), set);
        }
    }
}
}
— Paul92
সূত্র
0 
/*
     * eg: abc =>{a,bc},{b,ac},{c,ab}
     * =>{ca,b},{cb,a}
     * =>cba,cab
     * =>{ba,c},{bc,a}
     * =>bca,bac
     * =>{ab,c},{ac,b}
     * =>acb,abc
     */
    public void nonRecpermute(String prefix, String word)
    {
        String[] currentstr ={prefix,word};
        Stack<String[]> stack = new Stack<String[]>();
        stack.add(currentstr);
        while(!stack.isEmpty())
        {
            currentstr = stack.pop();
            String currentPrefix = currentstr[0];
            String currentWord = currentstr[1];
            if(currentWord.equals(""))
            {
                System.out.println("Word ="+currentPrefix);
            }
            for(int i=0;i<currentWord.length();i++)
            {
                String[] newstr = new String[2];
                newstr[0]=currentPrefix + String.valueOf(currentWord.charAt(i));
                newstr[1] = currentWord.substring(0, i);
                if(i<currentWord.length()-1)
                {
                    newstr[1] = newstr[1]+currentWord.substring(i+1);
                }
                stack.push(newstr);
            }

        }

    }
— nnc
সূত্র
0

এটি পূর্ববর্তী আংশিক ফলাফলগুলির সমস্ত লোকেশনগুলিতে স্ট্রিংয়ের প্রতিটি অক্ষর কেবল সন্নিবেশ করে পুনরাবৃত্তভাবে করা যেতে পারে।

আমরা দিয়ে শুরু [A], যা দিয়ে, Bহয়ে [BA, AB], এবং C,[CBA, BCA, BAC, CAB, etc] ।

চলমান সময় হবে O(n!), যা, পরীক্ষার ক্ষেত্রে ABCD, হয়1 x 2 x 3 x 4 ।

উপরে পণ্যের সালে 1জন্য A, 2জন্য B, ইত্যাদি

ডার্ট নমুনা:

void main() {

  String insertAt(String a, String b, int index)
  {
    return a.substring(0, index) + b + a.substring(index);
  }

  List<String> Permute(String word) {

    var letters = word.split('');

    var p_list = [ letters.first ];

    for (var c in letters.sublist(1)) {

      var new_list = [ ];

      for (var p in p_list)
        for (int i = 0; i <= p.length; i++)
          new_list.add(insertAt(p, c, i));

      p_list = new_list;
    }

    return p_list;
  }

  print(Permute("ABCD"));

}
— ট্রয় ডসন
সূত্র
0

এখানে একটি জাভা বাস্তবায়ন:

/* All Permutations of a String */

import java.util.*;
import java.lang.*;
import java.io.*;

/* Complexity O(n*n!) */
class Ideone
{
     public static ArrayList<String> strPerm(String str, ArrayList<String> list)
     {
        int len = str.length();
        if(len==1){
            list.add(str);
            return list;
        }

        list = strPerm(str.substring(0,len-1),list);
        int ls = list.size();
        char ap = str.charAt(len-1);
        for(int i=0;i<ls;i++){
            String temp = list.get(i);
            int tl = temp.length();
            for(int j=0;j<=tl;j++){
                list.add(temp.substring(0,j)+ap+temp.substring(j,tl));  
            }
        }

        while(true){
            String temp = list.get(0);
            if(temp.length()<len)
                list.remove(temp);
            else
                break;
        }

        return list;
    }

    public static void main (String[] args) throws java.lang.Exception
    {
        String str = "abc";
        ArrayList<String> list = new ArrayList<>();

        list = strPerm(str,list);
        System.out.println("Total Permutations : "+list.size());
        for(int i=0;i<list.size();i++)
            System.out.println(list.get(i));

    }
}

http://ideone.com/nWPb3k

— সাহিল ছাবরা
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.