स्ट्रिंग के सभी संभावित क्रमिक क्रमों की सूची बनाएं

एक्स और वाई अक्षरों के बीच एक स्ट्रिंग के सभी संभावित क्रमिक क्रमों की सूची बनाने के बारे में मैं कैसे वर्णित करूंगा, जिसमें अक्षरों की एक चर सूची शामिल है।

कोई भी भाषा काम करेगी, लेकिन यह पोर्टेबल होना चाहिए।

0
जोड़ा संपादित
विचारों: 3

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.

IS एक प्लगइन WP सक्रिय प्लगइन्स डेटा नामक प्लगइन का पालन करता है जो किसी भी प्लगइन को सक्रिय होने पर सभी सक्रिय प्लगइन के लिए हेडर मेटाडेटा को पार करता है और यह प्रत्येक प्लगइन के लिए सभी मेटाडेटा को सरणी में संग्रहीत करता है wp_options में विकल्प। मैंने इसे नियमित वर्डप्रेस प्लगइन्स और मल्टीसाइट साइट-व्यापी प्लगइन दोनों के लिए डिज़ाइन किया है। आप इसे यहां से डाउनलोड कर सकते हैं लेकिन मैंने आपकी समीक्षा के लिए कोड भी कॉपी किया है:

<?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 ) की जड़ में छोड़ सकते हैं। सुनिश्चित करें कि आपके पास यह प्लगइन और अकिस्मेट दोनों परीक्षण करने से पहले सक्रिय हैं।

<?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। अच्छा काम, माइक। मुझे आश्चर्य है कि इस स्टैक एक्सचेंज से कितने प्लगइन आएंगे। :)
जोड़ा लेखक Annika Backstrom, स्रोत
धन्यवाद। दरअसल, मैं बहुत उम्मीद कर रहा हूं लेकिन मैं यह भी उम्मीद कर रहा हूं कि केवल सर्वश्रेष्ठ ही भंडार में अपना रास्ता बनाये। अभी वहां बहुत अधिक कचरा है!
जोड़ा लेखक MikeSchinkel, स्रोत

आप अपने प्लगइन के मेटा डेटा (फ़ाइल के शीर्ष पर वह सामान) पार्स कर सकते हैं, लेकिन प्रदर्शन के लिए यह बेहतर है यदि आप अपने स्वयं के PHP चर को एक मिलान संस्करण संख्या के साथ सेट करते हैं। जब आप प्लगइन अपडेट करते हैं, तो बस दोनों संस्करण संख्याओं को अपडेट करें।

यह अल्पावधि में आपके लिए थोड़ा और अधिक काम है, लेकिन लंबी अवधि में बहुत बेहतर है।

2
जोड़ा
प्रदर्शन के लिए यह एक चर परिभाषित करने के लिए बेहतर हो सकता है लेकिन संस्करण संख्या को 2 स्थानों पर बदलने के लिए भी बहुत अच्छा नहीं है। विषयों के लिए, एक समान कार्य wp_get_theme है जिसका प्रयोग उदाहरणों में भी किया जाता है: codex.wordpress.org/Child_Themes यह वर्डप्रेस में एक खराब डिज़ाइन की तरह दिखता है, यह बेहतर होगा अगर हम एक चर के माध्यम से प्लगइन संस्करण सेट कर सकते हैं और फिर वैरिएबल को wp_enqueue_style और wp_enqueue_script फ़ंक्शंस के साथ पुन: उपयोग कर सकते हैं।
जोड़ा लेखक baptx, स्रोत

व्यवस्थापक स्क्रीन में है: get_plugin_data() । टेम्पलेट्स में, मुझे लगता है कि आपको PHP में उस डेटा को पकड़ने के लिए प्लगइन की आवश्यकता होगी, उदाहरण के लिए, निरंतर या वैश्विक या कुछ सेट करें, और उस मान को प्लगइन हेडर संस्करण संख्या के साथ सिंक्रनाइज़ रखें।

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
जोड़ा

मैंने बस रूबी में इसे तुरंत मार दिया:

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

आप क्रमपरिवर्तन प्रकार कार्यों में निर्मित के लिए भाषा एपीआई देख सकते हैं, और आप अधिक अनुकूलित कोड लिखने में सक्षम हो सकते हैं, लेकिन यदि संख्याएं उच्च हैं, तो मुझे यकीन नहीं है कि बहुत सारे परिणाम होने के आसपास बहुत कुछ है ।

वैसे भी, कोड के पीछे विचार लंबाई 0 की स्ट्रिंग के साथ शुरू होता है, फिर लंबाई जेड के सभी तारों का ट्रैक रखें जहां ज़ेड पुनरावृत्ति में वर्तमान आकार है। फिर, प्रत्येक स्ट्रिंग के माध्यम से जाएं और प्रत्येक स्ट्रिंग को प्रत्येक स्ट्रिंग पर संलग्न करें। अंत में अंत में, एक्स थ्रेसहोल्ड के नीचे वाले किसी भी को हटा दें और परिणाम वापस कर दें।

मैंने इसे संभावित अर्थहीन इनपुट (शून्य वर्ण सूची, एक्स और वाई, आदि के अजीब मूल्यों) के साथ परीक्षण नहीं किया।

0
जोड़ा
यह कोड गलत है। यह अमान्य क्रमिकरण उत्पन्न करेगा, जैसे दोहराए गए वर्ण वाले। उदाहरण के लिए, स्ट्रिंग "एबीसी" के लिए, यह आकार 3: ["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.

इन्हें उत्पन्न करने का सबसे अच्छा तरीका निम्नलिखित नहीं है, लेकिन यह एक दिलचस्प है, कम-से-कम नहीं।

Knuth (वॉल्यूम 4, fascicle 2, 7.2.1.3) हमें बताता है कि (एस, टी) -कंपनीकरण दोहराए गए समय के साथ एस + 1 चीजों के बराबर है - एक (एस, टी) -कंपिनेशन नोटेशन द्वारा उपयोग किया जाता है 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 से 2, शब्द 2 से 3, शब्द 0 से 4 वें ... और आपको ... "joofle" मिलता है।

यदि आप सभी क्रमपरिवर्तन चाहते थे, तो बस 0 से 728 तक लूप करें। बेशक, यदि आप केवल एक यादृच्छिक मान चुन रहे हैं, तो बहुत अधिक <�स्ट्राइक> सरल कम भ्रमित तरीका अक्षरों पर लूप होगा। यह विधि आपको रिकर्सन से बचने देती है, क्या आपको सभी क्रमपरिवर्तन चाहिए, साथ ही यह आपको गणित (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" से "ए" और "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 तत्वों के इनपुट सरणी के लिए इसकी शुद्धता की पुष्टि की है।

एक त्वरित अनुकूलन out सरणी को पूर्व-उड़ान भरने और push() से परहेज करेगा।

मूल विचार यह है:

  1. एक एकल स्रोत सरणी को देखते हुए, एरे का पहला नया सेट जेनरेट करें जो प्रत्येक तत्व को प्रत्येक तत्व के साथ पहले तत्व को स्वैप करता है, प्रत्येक बार अन्य तत्वों को बिना छेड़छाड़ छोड़ देता है। उदाहरण: 1234 दिए गए, 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
जोड़ा

आप " एक सेट के सब्सक्रिप्शन की कुशलतापूर्वक गणना करना देख सकते हैं", जो भाग लेने के लिए एल्गोरिदम का वर्णन करता है आप जो चाहते हैं - जल्दी से एन अक्षरों के सभी सबसेट्स को लंबाई x से y तक उत्पन्न करें। इसमें सी में एक कार्यान्वयन शामिल है।

प्रत्येक सबसेट के लिए, आपको अभी भी सभी क्रमिक क्रम उत्पन्न करना होगा। उदाहरण के लिए यदि आप "abcde" से 3 वर्ण चाहते थे, तो यह एल्गोरिदम आपको "एबीसी", "abd", "abe" देगा ... लेकिन आपको प्रत्येक को "एसीबी", "बीएसी", "बीसीए" आदि प्राप्त करने की अनुमति देनी होगी।

0
जोड़ा

यहां बहुत सारे अच्छे उत्तर हैं। मैं सी ++ में एक बहुत ही सरल पुनरावर्ती समाधान का भी सुझाव देता हूं।

#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
जोड़ा

Knuth के अनुसार गैर पुनरावर्ती समाधान, पायथन उदाहरण:

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() स्टेटलेस है? यह केवल क्रमशः इनपुट को लेता है और अनुक्रम से पुनरावृत्ति से अनुक्रमित नहीं किया जाता है। यह मानकर यह करने में सक्षम है कि ऑर्डरिंग को बनाए रखने के आधार पर आरंभिक इनपुट को सॉर्ट किया गया था और इंडेक्स ( 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 (originalString) प्रविष्टियां होंगी।

0
जोड़ा
पहले तत्वों की सूची क्यों संग्रहीत करें, और फिर इसे साफ़ करें? (छद्म कोड में लाइन 1 और 3 का जिक्र करते हुए)।
जोड़ा लेखक Håvard Geithus, स्रोत
वाई क्या है (लाइन 4)?
जोड़ा लेखक Jaseem, स्रोत
@Jaseem प्रश्न से: "एक्स और <�बी> वाई अक्षरों के बीच एक स्ट्रिंग के सभी संभावित क्रमिकता लंबाई में"
जोड़ा लेखक cksubs, स्रोत

मुझे यकीन नहीं है कि आप इसे पहले स्थान पर क्यों करना चाहते हैं। एक्स और वाई के किसी भी मामूली बड़े मूल्यों के लिए परिणामस्वरूप सेट बहुत बड़ा होगा, और एक्स और / या वाई बड़े होने के कारण तेजी से बढ़ेगा।

आइए कहें कि संभव वर्णों का आपका सेट वर्णमाला के 26 लोअरकेस अक्षर हैं, और आप अपने आवेदन को सभी क्रमिकताओं को उत्पन्न करने के लिए कहते हैं जहां लंबाई = 5. मान लीजिए कि आप स्मृति से बाहर नहीं हैं, आपको 11,881,376 (यानी 26 शक्ति 5) स्ट्रिंग्स वापस। उस लंबाई को 6 तक बढ़ाएं, और आपको 308,915,776 स्ट्रिंग वापस मिल जाएंगी। ये संख्या दर्दनाक रूप से बड़ी, बहुत जल्दी मिलती है।

जावा में एक साथ रखा गया एक समाधान यहां दिया गया है। आपको दो रनटाइम तर्क (एक्स और वाई के अनुरूप) प्रदान करने की आवश्यकता होगी। मज़े करो।

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, स्रोत

सी ++ में रिकर्सिव समाधान

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
जोड़ा
@ सर्प सेंटेल: क्या यह कोड सी ++ में काम करता है? << कोड> स्ट्रिंग </ कोड >>
जोड़ा लेखक Lazer, स्रोत

यहां एक सरल शब्द सी # रिकर्सिव समाधान है:

विधि:

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
जोड़ा

यहां सी # में एक सरल समाधान है।

यह केवल एक दिए गए स्ट्रिंग के विशिष्ट क्रमिक क्रम उत्पन्न करता है।

    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
जोड़ा

पाइथन में यह कोड, जब allow_characters [0,1] और 4 वर्ण अधिकतम पर सेट किया जाता है, 2 ^ 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
जोड़ा
यह क्रमपरिवर्तन नहीं है लेकिन सबसेट चयन, यानी एबीसी और 001 = सी जबकि वैध क्रमपरिवर्तन में सभी तीन वर्ण होना चाहिए।
जोड़ा लेखक Schultz9999, स्रोत
उह? क्षमा करें मैं समझ नहीं पा रहा हूं कि आप क्या कहते हैं। यदि आप इसे ठीक करते हैं तो एक निश्चित संस्करण छोड़ दें, मैं समुदाय को विकी बना दूंगा
जोड़ा लेखक droope, स्रोत

मुझे आज इसकी ज़रूरत थी, और हालांकि पहले से दिए गए उत्तरों ने मुझे सही दिशा में इंगित किया था, लेकिन वे काफी नहीं थे जो मैं चाहता था।

हेप की विधि का उपयोग करके एक कार्यान्वयन यहां दिया गया है। सरणी की लंबाई कम से कम 3 होनी चाहिए और व्यावहारिक विचारों के लिए 10 या उससे भी बड़ा नहीं होना चाहिए, जो आप करना चाहते हैं, धैर्य और घड़ी की गति के आधार पर।

अपने लूप को दर्ज करने से पहले, पहले क्रमपरिवर्तन के साथ पर्म (1 से एन) प्रारंभ करें, स्टैक (3 से एन) शून्य के साथ *, और स्तर </कोड > 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

विभिन्न विधियों द्वारा अन्य विधियों का वर्णन किया गया है। Knuth दो का वर्णन करता है, एक लेक्सिकल आदेश देता है, लेकिन जटिल और धीमी है, दूसरे को सादे परिवर्तन की विधि के रूप में जाना जाता है। जी गाओ और डियानजुन वांग ने भी एक दिलचस्प पत्र लिखा था।

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
जोड़ा
सबसे अच्छा समाधान everrrrrrrrrrrrrrrrrrrrrr
जोड़ा लेखक 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);
    }
}

उपरोक्त "परमिट" विधि का अद्यतन संस्करण निम्नलिखित है जो एन बनाता है! (एन फैक्टोरियल) उपर्युक्त विधि की तुलना में कम रिकर्सिव कॉल

//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
जोड़ा
@ ताओज़हांग पूरक के लिए धन्यवाद, मैंने इसे कहीं से भी कॉपी नहीं किया है, हालांकि यह संभव है कि किसी ने भी इसी तरह का अहंकार बनाया हो। वैसे भी मैंने उपरोक्त कोड को कम रिकर्सिव कॉल के लिए अपडेट किया है
जोड़ा लेखक Ramy, स्रोत
यह सबसे साफ समाधान है, और मेरा मानना ​​है कि मैंने इसे "कोडिंग साक्षात्कार क्रैकिंग" पुस्तक में पहले देखा है।
जोड़ा लेखक Tao Zhang, स्रोत

अजगर में एक पुनरावर्ती समाधान। इस कोड के बारे में अच्छी बात यह है कि यह एक शब्दकोश निर्यात करता है, कुंजियों के रूप में कुंजी और मूल्यों के रूप में सभी संभावित क्रमिकताएं। सभी संभावित स्ट्रिंग लंबाई शामिल हैं, इसलिए असल में, आप एक सुपरसेट बना रहे हैं।

यदि आपको केवल अंतिम क्रमिक आवश्यकताएं हैं, तो आप शब्दकोश से अन्य कुंजी हटा सकते हैं।

इस कोड में, क्रमपरिवर्तन का शब्दकोश वैश्विक है।

आधारभूत स्थिति में, मैं मूल्य को सूची में दोनों संभावनाओं के रूप में संग्रहीत करता हूं। <�कोड> परमिट ['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
जोड़ा

खैर यहाँ एक सुरुचिपूर्ण, गैर-पुनरावर्ती, ओ (एन!) समाधान है:

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
जोड़ा