একটি স্ট্রিং এর সমস্ত সম্ভাব্য permutations তালিকা তৈরি করুন

কিভাবে আমি x এবং y অক্ষরের দৈর্ঘ্যের মধ্যে একটি স্ট্রিং এর সমস্ত সম্ভাব্য permutations একটি তালিকা তৈরি সম্পর্কে যেতে হবে, অক্ষরের একটি পরিবর্তনশীল তালিকা ধারণকারী।

কোন ভাষা কাজ করবে, কিন্তু এটি পোর্টেবল হওয়া উচিত।

0
যোগ সম্পাদিত
মতামত: 1

36 উত্তর

@david: Both @Adam Backtrom and @Viper007Bond give some good advice so I thought I'd take their advice and see if I couldn't implement something, see below.

WP সক্রিয় প্লাগ-ইন ডেটা যে কোনও প্লাগইনটি যে কোনও প্লাগইন অ্যাক্টিভেট করে সব সক্রিয় প্লাগইনগুলির জন্য হেডার মেটাডেটা প্যাড করে এবং এটি প্রতিটি প্লাগইনের জন্য একটি অ্যারেতে সমস্ত মেটাডেটা সঞ্চয় করে। বিকল্প wp_options এ। আমি এটি নিয়মিত ওয়ার্ডপ্রেস প্লাগইন এবং মাল্টিসাইট সাইটের প্লাস প্লাগইনগুলির জন্য ডিজাইন করেছি। আপনি gist থেকে এখানে ডাউনলোড করতে পারেন কিন্তু আমি আপনার পর্যালোচনাতে এখানে কোডটি অনুলিপি করেছি:

<?php
/*
Plugin Name: WP Active Plugins Data
Plugin URI: http://mikeschinkel.com/wordpress-plugins/wp-active-plugins-data/
Description: Loads Plugin Data on Plugin Activation and Persists to wp_options for quick retrieval.
Version: 0.1
Author: Mike Schinkel
Author URI: http://mikeschinkel.com
Note: Written for http://wordpress.stackexchange.com/questions/361/is-there-a-way-for-a-plug-in-to-get-its-own-version-number
*/

require_once(ABSPATH.'wp-admin/includes/plugin.php');

function get_active_plugin_version($plugin_path_file, $sitewide = false) {
    return get_active_plugin_attribute($plugin_path_file,'Version');
}
function get_active_plugin_attribute($plugin_path_file, $attribute) {
    $all_plugins_data = get_active_plugins_data($plugin_path_file,$sitewide);
    return (isset($all_plugins_data[$attribute]) ? $all_plugins_data[$attribute] : false);
}
function get_active_plugins_data($plugin_path_file, $sitewide = false) {
    $failsafe = false;
    $plugin = plugin_basename(trim($plugin_path_file));
    $sitewide = (is_multisite() && ( $sitewide || is_network_only_plugin($plugin)));
    if ($sitewide) {
        $all_plugins_data = get_site_option('active_sitewide_plugin_data',array());
    } else {
        $all_plugins_data = get_option('active_plugin_data',array());
    }
    if (!$failsafe && !is_array($all_plugins_data) || count($all_plugins_data)==0) {
        $failsafe = true;//Don't risk infinite recursion
        if ($sitewide) {
            $active_plugins = get_site_option('active_sitewide_plugins',array());
        } else {
            $active_plugins = get_option('active_plugins',array());
        }
        persist_active_plugin_data(null,$active_plugins,$sitewide);
        $all_plugins_data = get_active_plugin_version($plugin_path_file,$sitewide);
    }
    return $all_plugins_data[$plugin_path_file];
}
add_action('update_site_option_active_sitewide_plugins','persist_sitewide_active_plugin_data',10,2);
function persist_sitewide_active_plugin_data($option, $plugins) {
    persist_active_plugin_data(null,$plugins,'sitewide');
}
add_filter('update_option_active_plugins','persist_active_plugin_data',10,2);
function persist_active_plugin_data($old_plugins, $new_plugins, $sitewide=false) {
    $active_plugin_data = array_flip($new_plugins);
    $plugin_dir = WP_PLUGIN_DIR;
    foreach($new_plugins as $plugin) {
        $active_plugin_data[$plugin] = get_plugin_data("$plugin_dir/$plugin");
    }
    if ($sitewide)
        update_site_option('active_sitewide_plugin_data',$active_plugin_data);
    else
        update_site_option('active_plugin_data',$active_plugin_data);
}

এটা কিভাবে কাজ করে দেখতে চান? এখানে একটি পরীক্ষার ফাইল যা আপনি আপনার ওয়ার্ডপ্রেস সাইটের মূল ( http://example.com/test.php ।) ড্রপ করতে পারেন। এটি পরীক্ষা করার আগে আপনার এই প্লাগইন এবং Akismet উভয়ই সক্রিয় থাকে তা নিশ্চিত করুন।

<?php
/*
* test.php - Place in root of WordPress website.
*
* Before running be sure to activate both Akismet and the WP Active Plugin Data plugin
*
*/

include "wp-load.php";

header('Content-type:text/plain');
$akismet = "akismet/akismet.php";
echo "Akismet Version: " . get_active_plugin_version($akismet);
echo "\n\nAkismet Description: " . get_active_plugin_attribute($akismet,'Description');
echo "\n\nAll Akismet Data:\n";
print_r(get_active_plugins_data($akismet));

যদি এটি সঠিক না হয় তবে অন্তত এটি আপনাকে একটি ভাল শুরু বিন্দু দিতে হবে। আশাকরি এটা সাহায্য করবে.

9
যোগ
+1 টি। ভালো চাকরি, মাইক আমি এই প্লাগইন এই StackExchange থেকে আসা হবে কিভাবে আশ্চর্য। :)
যোগ লেখক Annika Backstrom, উৎস
ধন্যবাদ। বাস্তবিক, আমি প্রচুর আশা করছি কিন্তু আমি আশা করছি যে শুধুমাত্র ভাল সংগ্রহস্থলের মধ্যে তাদের পথ করা। সেখানে এখন অনেক বেশি আবর্জনা আছে!
যোগ লেখক MikeSchinkel, উৎস

আপনি আপনার প্লাগইনটির মেটা ডেটা (ফাইলের শীর্ষে থাকা জিনিসগুলি) বিশ্লেষণ করতে পারেন, তবে যদি আপনি আপনার নিজস্ব পিএইচপি ভেরিয়েবলটি একটি মেসেজিং সংস্করণ নম্বর দিয়ে সেট করেন তবে এটি কার্যকরীকরণের জন্য ভাল। যখন আপনি প্লাগইন আপডেট করেন, তখন শুধু উভয় সংস্করণ সংখ্যা আপডেট করুন।

এটি অল্প সময়ের মধ্যে আপনার জন্য সামান্য আরো কাজ, কিন্তু দীর্ঘমেয়াদী মধ্যে অনেক ভাল।

2
যোগ
এটি একটি পরিবর্তনশীল সংজ্ঞায়িত করতে পারফরম্যান্সের জন্য ভাল হতে পারে কিন্তু এটি 2 টি স্থানে সংস্করণ সংখ্যা পরিবর্তন করতে খুব সুন্দরও নয়। থিম জন্য, একটি similiar ফাংশন wp_get_theme যে এমনকি উদাহরণ ব্যবহার করা হয় আছে: codex.wordpress.org/Child_Themes এটি ওয়ার্ডপ্রেসের একটি খারাপ নকশা মত দেখাচ্ছে, যদি আমরা একটি পরিবর্তনশীল মাধ্যমে প্লাগইন সংস্করণ সেট এবং তারপর wp_enqueue_style এবং wp_enqueue_script ফাংশন সঙ্গে ভেরিয়েবল পুনরায় ব্যবহার করতে পারে ভাল হবে।
যোগ লেখক baptx, উৎস

অ্যাডমিন স্ক্রীনে আছে: get_plugin_data() । টেমপ্লেটগুলিতে, আমি মনে করি আপনি প্লাগইনটি পিএইচপি এর ডাটা ধারণ করতে চান, যেমন, একটি ধ্রুবক বা বিশ্বব্যাপী বা কিছু সেট করুন এবং প্লাগইন হেডার সংস্করণ সংখ্যা দিয়ে সিঙ্ক্রোনাইজড মান রাখুন।

wp-settings.php calls wp_get_active_and_valid_plugins(), which pulls data from the active_plugins site option. This option only contains the path to the plugin file, and wp-settings.php only runs include_once on the file, so it's never parsed for the plugin metadata.

1
যোগ

আমি রুবি এই দ্রুত আপ whipped:

def perms(x, y, possible_characters)
  all = [""]
  current_array = all.clone
  1.upto(y) { |iteration|
    next_array = []
    current_array.each { |string|
      possible_characters.each { |c|
        value = string + c
        next_array.insert next_array.length, value
        all.insert all.length, value
      }
    }
    current_array = next_array
  }
  all.delete_if { |string| string.length < x }
end

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

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

আমি এটি সম্ভাব্য অর্থহীন ইনপুট (নাল অক্ষর তালিকা, এক্স এবং Y এর অদ্ভুত মূল্য ইত্যাদি) দিয়ে এটি পরীক্ষা করে নি।

0
যোগ
এই কোডটি মিথ্যা। এটি অবৈধ পদ্ধতি উৎপন্ন করবে, যেমন পুনরাবৃত্ত অক্ষরগুলি সহ। উদাহরণস্বরূপ, "abc", স্ট্রিং "abc" এর জন্য, এটি আকার 3 এর এই permutations তৈরি করে: ["aaa", "aab", "aac", "aba", "abb", "abc", "aca", "acb" "বিবি", "বিসিবি", "বিসিবি", "কেয়া", "ক্যাব", "সিএসি", "এবিসি", "বি", "বাব", "বিএ্যাক", "বিবা", "বিবিবি", "বিবিসি" "," সিবিএ "," সিবিবি "," সিবিসি "," সি সি সি "," সিসিবি "," সি সি সি ")। এটি ভুল।
যোগ লেখক pmc255, উৎস

আপনি অনেক স্ট্রিং পেতে যাচ্ছেন, এটা নিশ্চিতভাবেই ...

\sum_{i=x}^y{\frac{r!}{{(r-i)}!}} http://www.codecogs.com/eq.latex?%5Csum_%7Bi=x%7D%5Ey%20%7B%20%5Cfrac%7Br!%7D%7B%7B(r-i)%7D!%7D%20%7D
Where, x and y is how you define them and r is the number of characters we are selecting from --if I am understanding you correctly. You should definitely generate these as needed and not get sloppy and say, generate a powerset and then filter the length of strings.

নিম্নলিখিত স্পষ্টভাবে এই উৎপন্ন করার সবচেয়ে ভাল উপায় নয়, কিন্তু এটি একটি আকর্ষণীয় সরাইয়া, কিছুই-the- কম

Knuth (volume 4, fascicle 2, 7.2.1.3) আমাদেরকে বলে যে (s, t) -combination সমতুল্য s + 1 টি পুনরাবৃত্তির সাথে একটি সময়ে নেওয়া - a (s, t) -combination দ্বারা ব্যবহৃত সংকেত Knuth যে {t \ select {s + t} এর সমান } http://www.codecogs.com/eq.latex?%7Bt%20%5Cchoose%20%7Bs+t%7D%7D । আমরা প্রথমে বাইনারি ফর্ম (তাই দৈর্ঘ্য (গুলি + টি)) এর প্রতিটি (গুলি, টি) -কম্পনিনিং তৈরি করে এবং প্রতিটি 1 এর বামে 0 এর সংখ্যা গণনা করে তা বুঝি।

10001000011101 --> becomes the permutation: {0, 3, 4, 4, 4, 1}

0
যোগ

যদিও এটি আপনার প্রশ্নের উত্তর দেয় না, ঠিক একই লাইনের কয়েকটি স্ট্রিং থেকে অক্ষরের প্রতিটি ক্রমানুসারে জেনারেট করার একটি উপায় হল: উদাহরণস্বরূপ, যদি আপনার শব্দগুলি "কফি", "জুমলা" এবং "মুডল", আপনি করতে পারেন "কডেল", "জোডয়ে", "জফেল", ইত্যাদি

মূলত, সমন্বয় সংখ্যা (শব্দের সংখ্যা) ক্ষমতা (সংখ্যা প্রতি অক্ষর সংখ্যা)। সুতরাং, 0 এবং সংখ্যার সংখ্যার মধ্যে একটি র্যান্ডম সংখ্যা নির্বাচন করুন - 1, যে নম্বরটিকে বেস (শব্দগুলির সংখ্যা) রূপে রূপান্তর করুন, তারপর সেই সংখ্যাটির প্রতিটি সংখ্যাকে নির্দেশক হিসেবে ব্যবহার করুন যার জন্য পরবর্তী চিঠিটি থেকে পরবর্তী অক্ষরটি নিতে হবে।

উদাহরণ: উপরের উদাহরণে 3 শব্দ, 6 অক্ষর = 729 সংমিশ্রণ। একটি র্যান্ডম সংখ্যা নির্বাচন করুন: 465. বেস 3: 122020 এ রূপান্তর করুন। শব্দ 1, দ্বিতীয় শব্দ 2, 3 য় শব্দ 3, শব্দ 0 থেকে 4 র্থ থেকে প্রথম অক্ষর নিন ... এবং আপনি পাবেন ... "joofle"।

যদি আপনি সমস্ত ক্রমাঙ্কন চান, তবে 0 থেকে 7২8 পর্যন্ত শুধু লুপ। অবশ্যই, আপনি যদি কেবল একটি র্যান্ডম মান নির্বাচন করেন, তবে অনেকগুলি সহজ অক্ষরের উপর লুপের মতো কম-বিভ্রান্তিকর উপায় হবে। এই পদ্ধতি আপনাকে পুনরাবৃত্তি এড়াতে দেয়, আপনি কি সমস্ত ক্রমাঙ্কনগুলি চান, প্লাস এটি আপনাকে দেখায় যেমন আপনি গণিত (tm) জানেন!

সমন্বয় সংখ্যা অত্যধিক যদি, আপনি ছোট শব্দ একটি সিরিজ এটি বিরতি এবং শেষে তাদের সংমিশ্রণ করতে পারেন।

0
যোগ

Here is a link that describes how to print permutations of a string. http://nipun-linuxtips.blogspot.in/2012/11/print-all-permutations-of-characters-in.html

0
যোগ
0
যোগ
একটি মন্তব্য হিসাবে, মনে রাখবেন যে পুনরাবৃত্ত অক্ষরগুলির একটি স্ট্রিং জন্য এটি অনন্য ক্রমবর্ধমান উত্পন্ন করবে না। এটি একটি হ্যাশ সঙ্গে সমাধান করা যেতে পারে, কিন্তু যে দীর্ঘ স্ট্রিং সঙ্গে একটি সমস্যা হতে পারে।
যোগ লেখক Glenn, উৎস
জাভাতে স্ট্রিংগুলি অপরিবর্তনীয় হওয়ার পরে আপনি দ্রুত এই চালানোর জন্য স্ট্রিংগুলির পরিবর্তে চার সারিগুলি ব্যবহার করতে চাইতে পারেন।
যোগ লেখক Abhijeet Kashnia, উৎস
def gen( x,y,list): #to generate all strings inserting y at different positions
list = []
list.append( y+x )
for i in range( len(x) ):
    list.append( func(x,0,i) + y + func(x,i+1,len(x)-1) )
return list 

def func( x,i,j ): #returns x[i..j]
z = '' 
for i in range(i,j+1):
    z = z+x[i]
return z 

def perm( x , length , list ): #perm function
if length == 1 : # base case
    list.append( x[len(x)-1] )
    return list 
else:
    lists = perm( x , length-1 ,list )
    lists_temp = lists #temporarily storing the list 
    lists = []
    for i in range( len(lists_temp) ) :
        list_temp = gen(lists_temp[i],x[length-2],lists)
        lists += list_temp 
    return lists
0
যোগ

পার্লে, যদি আপনি নিজেরকে ছোট হাতের বর্ণমালায় সীমাবদ্ধ রাখতে চান তবে আপনি এটি করতে পারেন:

my @result = ("a" .. "zzzz");

এই ছোট হাতের অক্ষর ব্যবহার করে 1 এবং 4 অক্ষরের মধ্যে সব সম্ভাব্য স্ট্রিং দেয়। বড় হাতের জন্য, "a" থেকে "A" এবং "zzzz" থেকে "ZZZZ" পরিবর্তন করুন।

মিশ্র-ক্ষেত্রে এটি খুব কঠিন হয়ে যায়, এবং সম্ভবত এর মত পার্লের বিল্টিন অপারেটারগুলির মধ্যে একটির সাথে সম্ভবত সম্ভব নয়।

0
যোগ

রুবি উত্তর দেয় যে কাজ করে:

class String
  def each_char_with_index
    0.upto(size - 1) do |index|
      yield(self[index..index], index)
    end
  end
  def remove_char_at(index)
    return self[1..-1] if index == 0
    self[0..(index-1)] + self[(index+1)..-1]
  end
end

def permute(str, prefix = '')
  if str.size == 0
    puts prefix
    return
  end
  str.each_char_with_index do |char, index|
    permute(str.remove_char_at(index), prefix + char)
  end
end

# example
# permute("abc")
0
যোগ
রুবিতে একটি চিত্তাকর্ষক এক মাছ ধরার জন্য: stackoverflow.com/questions/5773961/…
যোগ লেখক dojosto, উৎস

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

একটি দ্রুত অপ্টিমাইজেশান হবে আউট অ্যারে এবং পূর্ববর্তী ধাক্কা()

মৌলিক ধারণা হল:

  1. একটি একক সোর্স অ্যারে দেওয়া, একটি প্রথম অ্যারে সেট তৈরি করে যা প্রথম উপাদানটি ঘুরে ঘুরে ঘুরিয়ে প্রতিটি উপাদানকে অদলবদল করে, প্রতিটি সময় অন্য উপাদানে অস্তিত্বহীন অবস্থায় চলে যায়। যেমন: 1২34 দেওয়া, 1234, 2134, 3214, 4231 তৈরি করুন।

  2. আগের পাস থেকে একটি নতুন পাস জন্য বীজ হিসাবে প্রতিটি অ্যারের ব্যবহার করুন, কিন্তু প্রথম উপাদান অদলবদল করার পরিবর্তে, প্রতিটি পরের উপাদান দিয়ে দ্বিতীয় উপাদান অদলবদল করা। এছাড়াও, এই সময়, আউটপুটের মূল অ্যারে অন্তর্ভুক্ত করবেন না।

  3. সম্পূর্ণ হওয়া পর্যন্ত পদক্ষেপ 2 পুনরাবৃত্তি করুন।

এখানে কোড নমুনা হল:

function oxe_perm(src, depth, index)
{
    var perm = src.slice();     // duplicates src.
    perm = perm.split("");
    perm[depth] = src[index];
    perm[index] = src[depth];
    perm = perm.join("");
    return perm;
}

function oxe_permutations(src)
{
    out = new Array();

    out.push(src);

    for (depth = 0; depth < src.length; depth++) {
        var numInPreviousPass = out.length;
        for (var m = 0; m < numInPreviousPass; ++m) {
            for (var n = depth + 1; n < src.length; ++n) {
                out.push(oxe_perm(out[m], depth, n));
            }
        }
    }

    return out;
}
0
যোগ

অসমর্থনমথ (বস্তুর তালিকাগুলির জন্য কাজ করে) একটি পুনরাবৃত্তিমূলক জাভা প্রয়োগ রয়েছে ):

/**
 * Generate the indices into the elements array for the next permutation. The
 * algorithm is from Kenneth H. Rosen, Discrete Mathematics and its 
 * Applications, 2nd edition (NY: McGraw-Hill, 1991), p. 284)
 */
private void generateNextPermutationIndices()
{
    if (remainingPermutations == 0)
    {
        throw new IllegalStateException("There are no permutations " +
             "remaining. Generator must be reset to continue using.");
    }
    else if (remainingPermutations < totalPermutations)
    {
        // Find largest index j with 
        // permutationIndices[j] < permutationIndices[j + 1]
        int j = permutationIndices.length - 2;
        while (permutationIndices[j] > permutationIndices[j + 1])
        {
            j--;
        }

        // Find index k such that permutationIndices[k] is smallest integer 
        // greater than permutationIndices[j] to the right
        // of permutationIndices[j].
        int k = permutationIndices.length - 1;
        while (permutationIndices[j] > permutationIndices[k])
        {
            k--;
        }

        // Interchange permutation indices.
        int temp = permutationIndices[k];
        permutationIndices[k] = permutationIndices[j];
        permutationIndices[j] = temp;

        // Put tail end of permutation after jth position in increasing order.
        int r = permutationIndices.length - 1;
        int s = j + 1;

        while (r > s)
        {
            temp = permutationIndices[s];
            permutationIndices[s] = permutationIndices[r];
            permutationIndices[r] = temp;
            r--;
            s++;
        }
    }
    --remainingPermutations;
}

/**
 * Generate the next permutation and return a list containing
 * the elements in the appropriate order.  This overloaded method
 * allows the caller to provide a list that will be used and returned.
 * The purpose of this is to improve performance when iterating over
 * permutations.  If the {@link #nextPermutationAsList()} method is
 * used it will create a new list every time.  When iterating over
 * permutations this will result in lots of short-lived objects that
 * have to be garbage collected.  This method allows a single list
 * instance to be reused in such circumstances.
 * @param destination Provides a list to use to create the
 * permutation.  This is the list that will be returned, once
 * it has been filled with the elements in the appropriate order.
 * @return The next permutation as a list.
 */
public List nextPermutationAsList(List destination)
{
    generateNextPermutationIndices();
    // Generate actual permutation.
    destination.clear();
    for (int i : permutationIndices)
    {
        destination.add(elements[i]);
    }
    return destination;
}

সম্পূর্ণ উৎস

0
যোগ

আপনি " একটি সেটের স্যাটেটগুলি কার্যকরীভাবে উল্লেখ করা " -এ দেখবেন, যা অংশ করার জন্য একটি অ্যালগরিদম বর্ণনা করে। আপনি কি চান - দ্রুত দৈর্ঘ্য এক্স থেকে y এর সব N অক্ষরের উপসেটগুলি তৈরি করুন। এটি সি একটি বাস্তবায়ন রয়েছে

প্রতিটি উপসেট জন্য, আপনি এখনও সব permutations উৎপন্ন করতে চাই। উদাহরণস্বরূপ যদি আপনি "abcde" থেকে 3 অক্ষর চান, এই অ্যালগরিদম আপনাকে "abc", "abd", "abe" দেবে ... কিন্তু আপনি "acb", "bac", "bca", ইত্যাদি পেতে প্রত্যেকেরকেই অনুমতি দিতে হবে।

0
যোগ

এখানে ভাল উত্তর অনেক আছে। আমি C ++ এ একটি খুব সহজ recursive সমাধান প্রস্তাব।

#include 
#include 

template
void permutations(std::string s, Consume consume, std::size_t start = 0) {
    if (start == s.length()) consume(s);
    for (std::size_t i = start; i < s.length(); i++) {
        std::swap(s[start], s[i]);
        permutations(s, consume, start + 1);
    }
}

int main(void) {
    std::string s = "abcd";
    permutations(s, [](std::string s) {
        std::cout << s << std::endl;
    });
}

Note: strings with repeated characters will not produce unique permutations.

0
যোগ
এই সমাধান চমৎকার এবং আরো মনোযোগ প্রাপ্য।
যোগ লেখক Mike S, উৎস
def permutation(str)
  posibilities = []
  str.split('').each do |char|
    if posibilities.size == 0
      posibilities[0] = char.downcase
      posibilities[1] = char.upcase
    else
      posibilities_count = posibilities.length
      posibilities = posibilities + posibilities
      posibilities_count.times do |i|
        posibilities[i] += char.downcase
        posibilities[i+posibilities_count] += char.upcase
      end
    end
  end
  posibilities
end

এখানে একটি নন পুনরাবৃত্তিমূলক সংস্করণ আমার নিতে হয়

0
যোগ

নূন, পাইথন উদাহরণ অনুযায়ী অ recursive সমাধান:

def nextPermutation(perm):
    k0 = None
    for i in range(len(perm)-1):
        if perm[i]< perm[i]:
            l0 = i

    perm[k0], perm[l0] = perm[l0], perm[k0]
    perm[k0+1:] = reversed(perm[k0+1:])
    return perm

perm=list("12345")
while perm:
    print perm
    perm = nextPermutation(perm)
0
যোগ
কি আকর্ষণীয় এটা যে nextPermutation() stateless হয়? এটা শুধুমাত্র permutate ইনপুট এবং সূচী পুনরাবৃত্তির পুনরাবৃত্তির থেকে রক্ষণাবেক্ষণ করা হয় না লাগে। এটা মনে করা হচ্ছে যে প্রাথমিক ইনপুট সাজানো এবং সূচীগুলি ( k0 এবং l0 ) নিজেই, যেখানে অর্ডারটি রক্ষণাবেক্ষণের উপর ভিত্তি করে সাজানো হয়েছে তা অনুধাবন করতে সক্ষম। "54321" -> "12345" মত একটি ইনপুট সাজানো এই অ্যালগরিদমকে সমস্ত প্রত্যাশিত রূপান্তরগুলি খুঁজে পেতে অনুমতি দেবে। কিন্তু যেহেতু এটি প্রত্যেক ক্রমানুসারে উৎপাদিত প্রত্যেক ক্রম ক্রমবিন্যাসের জন্য এই সূচীগুলিকে পুনঃনির্ধারণ করার জন্য এটি অতিরিক্ত
যোগ লেখক spaaarky21, উৎস
প্রকৃতপক্ষে, যখন স্ট্রিংকে সাজানো হয় না তখন এটি না কাজ করে। যদি আপনি "54321" দিয়ে শুধুমাত্র ONE স্ট্রিং দেখান (নিজেই) দেখান
যোগ লেখক tonjo, উৎস

পাইথনিক সমাধান:

from itertools import permutations
s = 'ABCDEF'
p = [''.join(x) for x in permutations(s)]
0
যোগ

... এবং এখানে সি সংস্করণ আছে:

void permute(const char *s, char *out, int *used, int len, int lev)
{
    if (len == lev) {
        out[lev] = '\0';
        puts(out);
        return;
    }

    int i;
    for (i = 0; i < len; ++i) {
        if (! used[i])
            continue;

        used[i] = 1;
        out[lev] = s[i];
        permute(s, out, used, len, lev + 1);
        used[i] = 0;
    }
    return;
}
0
যোগ

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

কিছু পিউডোকোড:

list = originalString.split('')
index = (0,0)
list = [""]
for iteration n in 1 to y:
  index = (index[1], len(list))
  for string s in list.subset(index[0] to end):
    for character c in originalString:
      list.add(s + c)

আপনি তারপর লাইন x থেকে কম সব স্ট্রিং অপসারণ করতে হবে, তারা তালিকায় প্রথম (x-1) * len (মূল স্ট্রিং) এন্ট্রি হবে

0
যোগ
কেন প্রথম উপাদান তালিকা তালিকা, এবং তারপর এটি পরিষ্কার? (সিউডোকোডের লাইন 1 এবং 3 এর উল্লেখ করে)
যোগ লেখক Håvard Geithus, উৎস
Y (লাইন 4) কি?
যোগ লেখক Jaseem, উৎস
@ জসিম প্রশ্ন থেকে: "x এবং y অক্ষরের দৈর্ঘ্যের মধ্যে একটি স্ট্রিং এর সমস্ত সম্ভব permutations"
যোগ লেখক cksubs, উৎস

আমি নিশ্চিত নই যে কেন আপনি প্রথম স্থানে এটি করতে চান। X এবং y এর কোনও মাপসই বড় মানগুলির জন্য ফলাফলের পরিমাণটি বিশাল হবে এবং এক্স এবং / অথবা y বড় হয়ে গেলে এক্সপোনেনিকভাবে বৃদ্ধি পাবে।

আপনার সম্ভাব্য অক্ষরগুলির সেট বর্ণমালার ২6 টি ছোট হাতের অক্ষর এবং আপনি আপনার অ্যাপ্লিকেশনটিকে সব ক্রম ক্রম উৎপাদনের জন্য জিজ্ঞাসা করেন যেখানে দৈর্ঘ্য = 5। আপনি মনে করেন যে আপনি মেমরিটি চালাতে পারবেন না আপনি 11,881,376 পাবেন (অর্থাৎ ২6 টি পাওয়ার 5) স্ট্রিং ফিরে। যে দৈর্ঘ্য 6 পর্যন্ত ধাক্কা, এবং আপনি 308,915,776 স্ট্রিং ফিরে পাবেন। এই সংখ্যার বেদনাদায়ক বড়, খুব দ্রুত পেতে

এখানে একটি সমাধান আমি জাভা একসাথে রাখা আছে। আপনাকে দুটি রানটাইম আর্গুমেন্ট প্রদান করতে হবে (x এবং y এর সাথে সংশ্লিষ্ট)। আনন্দ কর.

public class GeneratePermutations {
    public static void main(String[] args) {
        int lower = Integer.parseInt(args[0]);
        int upper = Integer.parseInt(args[1]);

        if (upper < lower || upper == 0 || lower == 0) {
            System.exit(0);
        }

        for (int length = lower; length <= upper; length++) {
            generate(length, "");
        }
    }

    private static void generate(int length, String partial) {
        if (length <= 0) {
            System.out.println(partial);
        } else {
            for (char c = 'a'; c <= 'z'; c++) {
                generate(length - 1, partial + c);
            }
        }
    }
}
0
যোগ
দীর্ঘ সময় কিন্তু আপনি পুনরাবৃত্তি সঙ্গে তাদের উত্পাদন না হয়?
যোগ লেখক Kakira, উৎস

C ++ এ পুনরাবৃত্ত সমাধান

int main (int argc, char * const argv[]) {
        string s = "sarp";
        bool used [4];
        permute(0, "", used, s);
}

void permute(int level, string permuted, bool used [], string &original) {
    int length = original.length();

    if(level == length) { // permutation complete, display
        cout << permuted << endl;
    } else {
        for(int i=0; i
0
যোগ
@ সরপ কেন্দেল: এই কোড কাজ করে C ++? << কোড> স্ট্রিং </ কোড >>
যোগ লেখক Lazer, উৎস

এখানে একটি সহজ শব্দ সি # recursive সমাধান:

এ পদ্ধতি:

public ArrayList CalculateWordPermutations(string[] letters, ArrayList words, int index)
        {
            bool finished = true;
            ArrayList newWords = new ArrayList();
            if (words.Count == 0)
            {
                foreach (string letter in letters)
                {
                    words.Add(letter);
                }
            }

            for(int j=index; j

এ কল করা হচ্ছে:

string[] letters = new string[]{"a","b","c"};
ArrayList words = CalculateWordPermutations(letters, new ArrayList(), 0);
0
যোগ

এখানে সি # এ একটি সহজ সমাধান।

এটি একটি প্রদত্ত স্ট্রিং শুধুমাত্র স্বতন্ত্র permutations উত্পন্ন করে।

    static public IEnumerable permute(string word)
    {
        if (word.Length > 1)
        {

            char character = word[0];
            foreach (string subPermute in permute(word.Substring(1)))
            {

                for (int index = 0; index <= subPermute.Length; index++)
                {
                    string pre = subPermute.Substring(0, index);
                    string post = subPermute.Substring(index);

                    if (post.Contains(character))
                            continue;                       

                    yield return pre + character + post;
                }

            }
        }
        else
        {
            yield return word;
        }
    }
0
যোগ
import java.util.*;

public class all_subsets {
    public static void main(String[] args) {
        String a = "abcd";
        for(String s: all_perm(a)) {
            System.out.println(s);
        }
    }

    public static Set concat(String c, Set lst) {
        HashSet ret_set = new HashSet();
        for(String s: lst) {
            ret_set.add(c+s);
        }
        return ret_set;
    }

    public static HashSet all_perm(String a) {
        HashSet set = new HashSet();
        if(a.length() == 1) {
            set.add(a);
        } else {
            for(int i=0; i
0
যোগ
অ পুনরাবৃত্তিমূলক সংস্করণ: stackoverflow.com/a/28527943/1266326
যোগ লেখক MLProgrammer-CiM, উৎস

permute (ABC) -> A.perm(BC) -> A.perm[B.perm(C)] -> A.perm[(*BC), (CB*)] -> [(*ABC), (BAC), (BCA*), (*ACB), (CAB), (CBA*)] To remove duplicates when inserting each alphabet check to see if previous string ends with the same alphabet (why? -exercise)

public static void main(String[] args) {

    for (String str : permStr("ABBB")){
        System.out.println(str);
    }
}

static Vector permStr(String str){

    if (str.length() == 1){
        Vector ret = new Vector();
        ret.add(str);
        return ret;
    }

    char start = str.charAt(0);
    Vector endStrs = permStr(str.substring(1));
    Vector newEndStrs = new Vector();
    for (String endStr : endStrs){
        for (int j = 0; j <= endStr.length(); j++){
            if (endStr.substring(0, j).endsWith(String.valueOf(start)))
                break;
            newEndStrs.add(endStr.substring(0, j) + String.valueOf(start) + endStr.substring(j));
        }
    }
    return newEndStrs;
}

সমস্ত ক্রমগুলি ডুপ্লিকেট ছাড়াই মুদ্রণ করে

0
যোগ

Python- এ এই কোডটি যখন অনুমোদিত_চেরাচারগুলি দ্বারা সেটিকে [0,1] এবং 4 অক্ষর সর্বাধিক সর্বোচ্চ ২ ^ 4 ফলাফল উৎপন্ন করে:

['0000', '0001', '0010', '0011', '0100', '0101', '0110', '0111', '1000', '1001', '1010', '1011 ',' 1100 ',' 1101 ',' 1110 ',' 1111 ']

def generate_permutations(chars = 4) :

#modify if in need!
    allowed_chars = [
        '0',
        '1',
    ]

    status = []
    for tmp in range(chars) :
        status.append(0)

    last_char = len(allowed_chars)

    rows = []
    for x in xrange(last_char ** chars) :
        rows.append("")
        for y in range(chars - 1 , -1, -1) :
            key = status[y]
            rows[x] = allowed_chars[key] + rows[x]

        for pos in range(chars - 1, -1, -1) :
            if(status[pos] == last_char - 1) :
                status[pos] = 0
            else :
                status[pos] += 1
                break;

    return rows

import sys


print generate_permutations()

আশা করি এটি আপনার ব্যবহারের জন্য। কোন অক্ষর সঙ্গে কাজ করে, সংখ্যা না শুধুমাত্র

0
যোগ
এটি ক্রমাঙ্কন নয় কিন্তু উপসেট নির্বাচন, যেমন ABC এবং 001 = C, যখন একটি বৈধ রূপান্তরটি তিনটি অক্ষর থাকতে হবে।
যোগ লেখক Schultz9999, উৎস
আহ? দুঃখিত, তুমি যা বলো তা বুঝতে পারছি না। আপনি যদি এটি ঠিক করে থাকেন তাহলে একটি নির্দিষ্ট সংস্করণ ছেড়ে দিন, আমি সম্প্রদায় উইকি জিনিসটি করব
যোগ লেখক droope, উৎস

আমি আজ এই প্রয়োজন, এবং যদিও উত্তর ইতিমধ্যেই আমাকে সঠিক দিক সম্পর্কে নির্দেশিত, তারা ছিল কি আমি চেয়েছিলেন যথেষ্ট ছিল না।

এখানে হ্যাপের পদ্ধতি ব্যবহার করে একটি বাস্তবায়ন করা হচ্ছে। অ্যারের দৈর্ঘ্য কমপক্ষে 3 হতে হবে এবং বাস্তব বিবেচনার জন্য 10 বা এর চেয়ে বড় নয়, আপনি কি করতে চান তার উপর নির্ভর করে, ধৈর্য এবং ঘড়ির গতি।

আপনার লুপ প্রবেশ করানোর আগে, Perm (1 to N) প্রথম ক্রমানুসারে, স্ট্যাক (3 to N) শূণ্য সহ *, এবং লেভেল দিয়ে শুরু করুন > 2 ** এর সাথে লুপ কল শেষে NextPerm , যখন আমরা কাজ করবো তখন মিথ্যা ফিরে আসবে।

* ভিবি আপনার জন্য এটি করবেন।

** আপনি এই অপ্রয়োজনীয় করতে একটু একটু NextPerm পরিবর্তন করতে পারেন, কিন্তু এটি এই মত পরিষ্কার।

Option Explicit

Function NextPerm(Perm() As Long, Stack() As Long, Level As Long) As Boolean
Dim N As Long
If Level = 2 Then
    Swap Perm(1), Perm(2)
    Level = 3
Else
    While Stack(Level) = Level - 1
        Stack(Level) = 0
        If Level = UBound(Stack) Then Exit Function
        Level = Level + 1
    Wend
    Stack(Level) = Stack(Level) + 1
    If Level And 1 Then N = 1 Else N = Stack(Level)
    Swap Perm(N), Perm(Level)
    Level = 2
End If
NextPerm = True
End Function

Sub Swap(A As Long, B As Long)
A = A Xor B
B = A Xor B
A = A Xor B
End Sub

'This is just for testing.
Private Sub Form_Paint()
Const Max = 8
Dim A(1 To Max) As Long, I As Long
Dim S(3 To Max) As Long, J As Long
Dim Test As New Collection, T As String
For I = 1 To UBound(A)
    A(I) = I
Next
Cls
ScaleLeft = 0
J = 2
Do
    If CurrentY + TextHeight("0") > ScaleHeight Then
        ScaleLeft = ScaleLeft - TextWidth(" 0 ") * (UBound(A) + 1)
        CurrentY = 0
        CurrentX = 0
    End If
    T = vbNullString
    For I = 1 To UBound(A)
        Print A(I);
        T = T & Hex(A(I))
    Next
    Print
    Test.Add Null, T
Loop While NextPerm(A, S, J)
J = 1
For I = 2 To UBound(A)
    J = J * I
Next
If J <> Test.Count Then Stop
End Sub

অন্যান্য পদ্ধতি বিভিন্ন লেখক দ্বারা বর্ণিত হয়। নথ দুটি বর্ণনা করে, একটি লেনিক্সিক আদেশ দেয়, কিন্তু জটিল এবং ধীর গতির, অন্যটিকে সরল পরিবর্তন পদ্ধতি হিসাবে পরিচিত হয়। Jie Gaao এবং Dianjun ওয়াং একটি আকর্ষণীয় কাগজ লিখেছে।

0
যোগ

ব্যাক ট্র্যাকিং ব্যবহার করা ভাল

#include 
#include 

void swap(char *a, char *b) {
    char temp;
    temp = *a;
    *a = *b;
    *b = temp;
}

void print(char *a, int i, int n) {
    int j;
    if(i == n) {
        printf("%s\n", a);
    } else {
        for(j = i; j <= n; j++) {
            swap(a + i, a + j);
            print(a, i + 1, n);
            swap(a + i, a + j);
        }
    }
}

int main(void) {
    char a[100];
    gets(a);
    print(a, 0, strlen(a) - 1);
    return 0;
}
0
যোগ
সেরা সমাধান
যোগ লেখক GrowinMan, উৎস
এটা শুধুমাত্র একটি চেহারা উপর উপলব্ধি একটি পঠনযোগ্য এবং সহজ।
যোগ লেখক joey rohan, উৎস

সি # পুনরাবৃত্তি:

public List Permutations(char[] chars)
    {
        List words = new List();
        words.Add(chars[0].ToString());
        for (int i = 1; i < chars.Length; ++i)
        {
            int currLen = words.Count;
            for (int j = 0; j < currLen; ++j)
            {
                var w = words[j];
                for (int k = 0; k <= w.Length; ++k)
                {
                    var nstr = w.Insert(k, chars[i].ToString());
                    if (k == 0)
                        words[j] = nstr;
                    else
                        words.Add(nstr);
                }
            }
        }
        return words;
    }
0
যোগ

নিম্নোক্ত জাভা পুনরাবৃত্তি একটি প্রদত্ত স্ট্রিংয়ের সমস্ত ক্রমাঙ্কন প্রিন্ট করে:

//call it as permut("",str);

public void permut(String str1,String str2){
    if(str2.length() != 0){
        char ch = str2.charAt(0);
        for(int i = 0; i <= str1.length();i++)
            permut(str1.substring(0,i) + ch + str1.substring(i,str1.length()),
                     str2.substring(1,str2.length()));
    }else{
    System.out.println(str1);
    }
}

উপরের "permut" পদ্ধতির আপডেট সংস্করণ যা n করে! (এন গৌণিক) উপরের পদ্ধতির তুলনায় কম পুনরাবৃত্তিমূলক কল

//call it as permut("",str);

public void permut(String str1,String str2){
   if(str2.length() > 1){
       char ch = str2.charAt(0);
       for(int i = 0; i <= str1.length();i++)
          permut(str1.substring(0,i) + ch + str1.substring(i,str1.length()),
                 str2.substring(1,str2.length()));
   }else{
    char ch = str2.charAt(0);
    for(int i = 0; i <= str1.length();i++)
        System.out.println(str1.substring(0,i) + ch +    str1.substring(i,str1.length()),
                 str2.substring(1,str2.length()));
   }
}
0
যোগ
@ টাওঝাং, সম্পূরক জন্য ধন্যবাদ, আমি কোথাও কোথাও এটি অনুলিপি করে নিইনি তবে এটা সম্ভব যে কেউ একই আলগো তৈরি করেছে। যাইহোক আমি কম recursive কল জন্য উপরের কোড আপডেট করেছি
যোগ লেখক Ramy, উৎস
এটি পরিষ্কার সমাধান, এবং আমি বিশ্বাস করি যে আমি "কোডিং সাক্ষাৎকার ক্র্যাকিং" বইটি আগে দেখেছি
যোগ লেখক Tao Zhang, উৎস

পাইথনের একটি পুনরাবৃত্ত সমাধান এই কোড সম্পর্কে ভাল জিনিস যে এটি একটি অভিধান এক্সপোর্ট করে, স্ট্রিং হিসাবে কী এবং মূল্য হিসাবে সব সম্ভব permutations হিসাবে। সমস্ত সম্ভাব্য স্ট্রিং দৈর্ঘ্য অন্তর্ভুক্ত করা হয়, তাই কার্যত, আপনি একটি সুপারসেট তৈরি করছেন।

আপনি যদি শুধুমাত্র চূড়ান্ত permutations প্রয়োজন, আপনি অভিধান থেকে অন্যান্য কী মুছে ফেলতে পারেন।

এই কোডে, ক্রমানুসারে অভিধানটি বিশ্বব্যাপী।

বেস ক্ষেত্রে, আমি একটি তালিকা উভয় সম্ভাবনার হিসাবে মান সংরক্ষণ। perms ['ab'] = ['ab', 'ba']

উচ্চতর স্ট্রিং দৈর্ঘ্যের জন্য, ফাংশন নিম্ন স্ট্রিং দৈর্ঘ্যকে বোঝায় এবং পূর্বে গণনা করা ক্রমানুসারে অন্তর্ভুক্ত করে।

ফাংশন দুটি জিনিস আছে:

  • একটি ছোট স্ট্রিং সঙ্গে নিজেই কল
  • যদি ইতিমধ্যেই পাওয়া যায় তবে একটি নির্দিষ্ট স্ট্রিংের ক্রমাঙ্কনগুলির একটি তালিকা ফেরত দেয়। যদি নিজেই ফেরত আসে, তবে এটি চরিত্রের সাথে যুক্ত করতে এবং নতুন রূপান্তর তৈরি করতে ব্যবহার করা হবে।

মেমরি জন্য ব্যয়বহুল

perms = {}
def perm(input_string):
    global perms
    if input_string in perms:
        return perms[input_string] # This will send a list of all permutations
    elif len(input_string) == 2:
        perms[input_string] = [input_string, input_string[-1] + input_string [-2]]
        return perms[input_string]
    else:
        perms[input_string] = []
        for index in range(0, len(input_string)):
            new_string = input_string[0:index] + input_string[index +1:]
            perm(new_string)
            for entries in perms[new_string]:
                perms[input_string].append(input_string[index] + entries)
    return perms[input_string]
0
যোগ

ড্রাইভার প্রধান() পদ্ধতির সাথে পুনরাবৃত্তিমূলক সমাধান।

public class AllPermutationsOfString {
public static void stringPermutations(String newstring, String remaining) {
    if(remaining.length()==0)
        System.out.println(newstring);

    for(int i=0; i

}

0
যোগ

ওয়েল এখানে একটি মার্জিত, অ recursive, হে (এন!) সমাধান:

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;
    }
0
যোগ

জাভা ভাষা জন্য কোড লেখা:

প্যাকেজ namo.algorithms;

আমদানি java.util.Scanner;

পাবলিক শ্রেণী প্রজেক্টস {

public static int totalPermutationsCount = 0;
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        System.out.println("input string : ");
        String inputString = sc.nextLine();
        System.out.println("given input String ==> "+inputString+ " :: length is = "+inputString.length());
        findPermuationsOfString(-1, inputString);
        System.out.println("**************************************");
        System.out.println("total permutation strings ==> "+totalPermutationsCount);
    }


    public  static void findPermuationsOfString(int fixedIndex, String inputString) {
        int currentIndex = fixedIndex +1;

        for (int i = currentIndex; i < inputString.length(); i++) {
            //swap elements and call the findPermuationsOfString()

            char[] carr = inputString.toCharArray();
            char tmp = carr[currentIndex];
            carr[currentIndex] = carr[i];
            carr[i] = tmp;
            inputString =  new String(carr);

            //System.out.println("chat At : current String ==> "+inputString.charAt(currentIndex));
            if(currentIndex == inputString.length()-1) {
                totalPermutationsCount++;
                System.out.println("permuation string ==> "+inputString);
            } else {
                //System.out.println("in else block>>>>");
                findPermuationsOfString(currentIndex, inputString);
                 char[] rarr = inputString.toCharArray();
                    char rtmp = carr[i];
                    carr[i] = carr[currentIndex];
                    carr[currentIndex] = rtmp;
                    inputString =  new String(carr);
            }
        }
    }

}

0
যোগ

সম্ভাব্য স্ট্রিং প্যারামিটেশনগুলি পুনরাবৃত্তিমূলক ফাংশন ব্যবহার করে গণনা করা যেতে পারে। নীচে সম্ভাব্য সমাধান এক।

public static String insertCharAt(String s, int index, char c) {
        StringBuffer sb = new StringBuffer(s);
        StringBuffer sbb = sb.insert(index, c);
        return sbb.toString();
}

public static ArrayList getPerm(String s, int index) {
        ArrayList perm = new ArrayList();

        if (index == s.length()-1) {
            perm.add(String.valueOf(s.charAt(index)));
            return perm;
        }

        ArrayList p = getPerm(s, index+1);
        char c = s.charAt(index);

        for(String pp : p) {
            for (int idx=0; idx perm = getPerm(s,0);
        System.out.println(s+" --> total permutation are :: "+perm.size());
        System.out.println(perm.toString());
}
0
যোগ