दिलचस्प पोस्ट
जेसीई प्रदाता ईसी में जावा स्विंग एप्लिकेशन को प्रमाणित नहीं कर सकता है कोनेरी नियंत्रकों के अंदर अंडरस्कोर का उपयोग करें आईई फ़ाइल डाउनलोड सुरक्षा नियमों के आसपास क्या तकनीकें हैं? ओएलईडीबी कनेक्शन स्ट्रिंग में आईएमएक्स क्या है? कौन सी प्रतिबद्धता है इस ब्लॉब? MinGW में प्रयोगात्मक C ++ 11 संगामिति सुविधाओं को कैसे सक्षम करें? JSF क्रॉस फील्ड प्रमाणीकरण का समर्थन नहीं करता है, क्या कोई वैकल्पिक उपाय है? JSON नामकरण कन्वेंशन Django – CSRF सत्यापन विफल एक सरणी में सभी संभावित सबसेट कोम्बो खोजें? HTML5 कैनवास बनाम एसवीजी बनाम डिवेल लिंकर इनलाइन कार्य कर सकते हैं? क्या LINQ के साथ पूर्ण पाठ खोज (एफटीएस) का उपयोग संभव है? आर्क के बाहर लेबल (पाई चार्ट) d3.js अजगर का उपयोग कर स्ट्रिंग से एक चरित्र को कैसे हटाया जाए?

PHP सरणी के सभी क्रमपरिवर्तन प्राप्त करें?

स्ट्रिंग की एक PHP सरणी को देखते हुए, उदाहरण के लिए:

['peter', 'paul', 'mary'] 

इस सरणी के तत्वों के सभी संभावित क्रमांतरों को कैसे उत्पन्न किया जाए? अर्थात:

 peter-paul-mary peter-mary-paul paul-peter-mary paul-mary-peter mary-peter-paul mary-paul-peter 

Solutions Collecting From Web of "PHP सरणी के सभी क्रमपरिवर्तन प्राप्त करें?"

 function pc_permute($items, $perms = array()) { if (empty($items)) { echo join(' ', $perms) . "<br />"; } else { for ($i = count($items) - 1; $i >= 0; --$i) { $newitems = $items; $newperms = $perms; list($foo) = array_splice($newitems, $i, 1); array_unshift($newperms, $foo); pc_permute($newitems, $newperms); } } } $arr = array('peter', 'paul', 'mary'); pc_permute($arr); 

या

 function pc_next_permutation($p, $size) { // slide down the array looking for where we're smaller than the next guy for ($i = $size - 1; $p[$i] >= $p[$i+1]; --$i) { } // if this doesn't occur, we've finished our permutations // the array is reversed: (1, 2, 3, 4) => (4, 3, 2, 1) if ($i == -1) { return false; } // slide down the array looking for a bigger number than what we found before for ($j = $size; $p[$j] <= $p[$i]; --$j) { } // swap them $tmp = $p[$i]; $p[$i] = $p[$j]; $p[$j] = $tmp; // now reverse the elements in between by swapping the ends for (++$i, $j = $size; $i < $j; ++$i, --$j) { $tmp = $p[$i]; $p[$i] = $p[$j]; $p[$j] = $tmp; } return $p; } $set = split(' ', 'she sells seashells'); // like array('she', 'sells', 'seashells') $size = count($set) - 1; $perm = range(0, $size); $j = 0; do { foreach ($perm as $i) { $perms[$j][] = $set[$i]; } } while ($perm = pc_next_permutation($perm, $size) and ++$j); foreach ($perms as $p) { print join(' ', $p) . "\n"; } 

http://docstore.mik.ua/orelly/webprog/pcook/ch04_26.htm

मुझे कुछ इसी तरह की आवश्यकता है और मैं देख रहा हूं कि इस पोस्ट को मिला है। जो काम करता है वह निम्नलिखित लिखता है।

8 मदों के साथ यह बहुत तेजी से काम करता है (उदाहरणों के लिए जो ऑनलाइन मैंने पाया था) की तुलना में थोड़ी तेज़ी से काम करता है, लेकिन उस से आगे और रन टाइम रैंप तेजी से बढ़ जाता है यदि आपको केवल परिणामों को आउटपुट करने की आवश्यकता होती है तो इसे तेज किया जा सकता है और मेमोरी का उपयोग बड़े पैमाने पर कम हो जाता है

 print_r(AllPermutations(array('peter', 'paul', 'mary'))); function AllPermutations($InArray, $InProcessedArray = array()) { $ReturnArray = array(); foreach($InArray as $Key=>$value) { $CopyArray = $InProcessedArray; $CopyArray[$Key] = $value; $TempArray = array_diff_key($InArray, $CopyArray); if (count($TempArray) == 0) { $ReturnArray[] = $CopyArray; } else { $ReturnArray = array_merge($ReturnArray, AllPermutations($TempArray, $CopyArray)); } } return $ReturnArray; } 

नोट करें कि क्रमरेखाओं की संख्या सरणी में वस्तुओं की संख्या का वास्तविक कारण है। 3 वस्तुओं के लिए 6 क्रमपरिवर्तन हैं, 4 के लिए 24, 5 के लिए 120, 6 के लिए 720 हैं, आदि।

किसी भी अतिरिक्त मेमोरी को आवंटित किए बिना, आपको इसकी आवश्यकता होती है, यानी जगह में। यह परिणामी क्रमपरिवर्तनों को $ परिणाम सरणी संग्रहीत करता है। मुझे पूरा विश्वास है कि यह काम को हल करने का उपवास तरीका है।

 <?php function computePermutations($array) { $result = []; $recurse = function($array, $start_i = 0) use (&$result, &$recurse) { if ($start_i === count($array)-1) { array_push($result, $array); } for ($i = $start_i; $i < count($array); $i++) { //Swap array value at $i and $start_i $t = $array[$i]; $array[$i] = $array[$start_i]; $array[$start_i] = $t; //Recurse $recurse($array, $start_i + 1); //Restore old order $t = $array[$i]; $array[$i] = $array[$start_i]; $array[$start_i] = $t; } }; $recurse($array); return $result; } $results = computePermutations(array('foo', 'bar', 'baz')); print_r($results); 

यह PHP में काम करता है> 5.4 मुख्य फ़ंक्शन के इंटरफेस को साफ रखने के लिए मैं पुनरावर्ती के लिए एक अनाम फ़ंक्शन का उपयोग किया था

मैंने जैक के उत्तर पर थोड़ा विस्तार किया

 function pc_permute($items, $perms = [],&$ret = []) { if (empty($items)) { $ret[] = $perms; } else { for ($i = count($items) - 1; $i >= 0; --$i) { $newitems = $items; $newperms = $perms; list($foo) = array_splice($newitems, $i, 1); array_unshift($newperms, $foo); $this->pc_permute($newitems, $newperms,$ret); } } return $ret; } 

यह वास्तव में सभी संभव क्रमपरिवर्तनों के साथ एक सरणी वापस करेगा।

 $options = ['startx','starty','startz','endx','endy','endz']; $x = $this->pc_permute($options); var_dump($x); [0]=> array(6) { [0]=> string(6) "startx" [1]=> string(6) "starty" [2]=> string(6) "startz" [3]=> string(4) "endx" [4]=> string(4) "endy" [5]=> string(4) "endz" } [1]=> array(6) { [0]=> string(6) "starty" [1]=> string(6) "startx" [2]=> string(6) "startz" [3]=> string(4) "endx" [4]=> string(4) "endy" [5]=> string(4) "endz" } [2]=> array(6) { [0]=> string(6) "startx" [1]=> string(6) "startz" [2]=> string(6) "starty" [3]=> string(4) "endx" [4]=> string(4) "endy" [5]=> string(4) "endz" } [3]=> array(6) { [0]=> string(6) "startz" [1]=> string(6) "startx" [2]=> string(6) "starty" [3]=> string(4) "endx" [4]=> string(4) "endy" [5]=> string(4) "endz" } [4]=> array(6) { [0]=> string(6) "starty" [1]=> string(6) "startz" [2]=> string(6) "startx" [3]=> string(4) "endx" [4]=> string(4) "endy" [5]=> string(4) "endz" } [5]=> array(6) { [0]=> string(6) "startz" [1]=> string(6) "starty" [2]=> string(6) "startx" [3]=> string(4) "endx" [4]=> string(4) "endy" [5]=> string(4) "endz" } [6]=> ................ a lot more 

मुझे स्ट्रिंग के बजाय सरणी वापस लाने के लिए इसे थोड़ा अधिक उपयोगी मिला। फिर यह प्रयोग करने वाले आवेदन पर निर्भर है कि कैसे रिट्ल्ट को संभालना है (उन्हें शामिल करने के लिए, या कुछ और)

रिकर्सन और कोई कृत्रिम अतिरिक्त तर्क के साथ सरल संस्करण:

 function permuteArray(array $input) { $input = array_values($input); // permutation of 1 value is the same value if (count($input) === 1) { return array($input); } // to permute multiple values, pick a value to put in the front and // permute the rest; repeat this with all values of the original array $result = []; for ($i = 0; $i < count($input); $i++) { $copy = $input; $value = array_splice($copy, $i, 1); foreach (permuteArray($copy) as $permutation) { array_unshift($permutation, $value[0]); $result[] = $permutation; } } return $result; } 

यह एल्गोरिदम अच्छा और शिक्षाप्रद है कि आप इसे कागज पर कैसे करेंगे, लेकिन अन्यथा बहुत अक्षम हैं क्योंकि यह एक ही क्रमांतर कई बार गणना करता है। ऐसा नहीं कहने के लिए कि बड़े सरणियों के क्रमपरिवर्तन की गणना करने के लिए यह बहुत अव्यावहारिक है क्योंकि अंतरिक्ष और गणना की संख्या तेजी से बढ़ती है