दिलचस्प पोस्ट
एजेक्स अनुरोधों को अनुक्रमित करना क्या jQuery के लिए एक हैंडल है। Delegate ('hover')? हुकोप में नौकरियों को बदलना किसी क्वेरी में छोड़कर उपयोग करते समय त्रुटि SQL सर्वर के टाइमस्टैम्प कॉलम को डेटटाईम प्रारूप में कनवर्ट करने के लिए कैसे करें सी # में अनाम प्रतिनिधियों को सीरियल करना ल्यूसीन का उपयोग करके सटीक वाक्यांश खोज? स्काला में तर्क के रूप में मल्टीलाइन फ़ंक्शन शाब्दिक PHP का उपयोग करते हुए फोन नंबर को कैसे मान्य करना है? टाइल्स ड्रॉएबल कभी-कभी फैलता है रीडायरेक्ट टाईएक्शन के साथ मैं एक मॉडल कैसे शामिल करूं? एक जार के भीतर जेआर सहित कक्षापथ कैसे एक स्ट्रिंग "StartsWith" एक और स्ट्रिंग की जांच करने के लिए? कैसे PHP कोड अतुल्यकालिक चलाने के लिए कैसे matplotlib mplot3d या समान में एक 3 डी सरणी isosurface के एक 3 डी भूखंड प्रदर्शित करने के लिए?

क्रमांतरण – संख्याओं के सभी संभव सेट

मेरे पास संख्या 0 से 8 तक है। मैं नतीजा चाहूंगा, उन सभी अंकों के सभी संभव सेट, प्रत्येक सेट को सभी नंबरों का उपयोग करना चाहिए, प्रत्येक संख्या एक सेट में केवल एक बार हो सकती है।

मैं PHP में किए गए समाधान देखना चाहूंगा जो परिणाम को प्रिंट कर सकता है। या, कम से कम, मुझे संयोजक के सिद्धांत में कुछ जलपान करना पसंद है, क्योंकि मैं इसे बहुत याद रख रहा हूं। कितने क्रमपरिवर्तनों की गणना करने के लिए सूत्र क्या है?

उदाहरण सेट:

  • 0-1-2-3-4-5-6-7-8
  • 0-1-2-3-4-5-6-8-7
  • 0-1-2-3-4-5-8-6-7
  • 0-1-2-3-4-8-5-6-7
  • 0-1-2-3-8-4-5-6-7
  • 0-1-2-8-3-4-5-6-7
  • और इसी तरह…

Solutions Collecting From Web of "क्रमांतरण – संख्याओं के सभी संभव सेट"

आप रूपरेखा सूत्र खोज रहे हैं:

nPk = n!/(nk)! 

आपके मामले में, आपके पास 9 प्रविष्टियाँ हैं और आप उन सभी को चुनना चाहते हैं, जो कि 9 पी 9 = 9 है! = 362880

आप O'Reilly के "PHP cookbook" के नुस्खा 4.26 में permutate के लिए एक PHP एल्गोरिथ्म पा सकते हैं।

 pc_permute(array(0, 1, 2, 3, 4, 5, 7, 8)); 

O'Reilly में कॉपी किया गया:

 function pc_permute($items, $perms = array( )) { if (empty($items)) { print join(' ', $perms) . "\n"; } 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); } } } 

चूंकि यह प्रश्न Google खोज परिणामों में अक्सर आता है, यहां स्वीकार किए गए उत्तर का एक संशोधित संस्करण है जो एक सरणी में सभी संयोजन देता है और फ़ंक्शन के रिटर्न मान के रूप में उन्हें पास करता है।

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

काम में लाना:

 $value = array('1', '2', '3'); print_r(pc_permute($value)); 

PHP 5.5 से आप जेनरेटर का उपयोग कर सकते हैं। जनरेटर बहुत सी मेमोरी को बचाते हैं और तेजी से तेज़ होते हैं ( pc_permute () की तुलना में आधे से अधिक इसलिए यदि आपके पास PHP 5.5 स्थापित होने का कोई मौका है, तो आप निश्चित रूप से जेनरेटर चाहते हैं। इस स्निप को पायथन से पोर्ट किया गया है: https://stackoverflow.com/a/104436/3745311

 function permutations(array $elements) { if (count($elements) <= 1) { yield $elements; } else { foreach (permutations(array_slice($elements, 1)) as $permutation) { foreach (range(0, count($elements) - 1) as $i) { yield array_merge( array_slice($permutation, 0, $i), [$elements[0]], array_slice($permutation, $i) ); } } } } 

नमूना उपयोग:

 $list = ['a', 'b', 'c']; foreach (permutations($list) as $permutation) { echo implode(',', $permutation) . PHP_EOL; } 

आउटपुट:

 a,b,c b,a,c b,c,a a,c,bc,a,b c,b,a 

मेरे पास कुछ है जिसे आप पसंद कर सकते हैं

 function combination_number($k,$n){ $n = intval($n); $k = intval($k); if ($k > $n){ return 0; } elseif ($n == $k) { return 1; } else { if ($k >= $n - $k){ $l = $k+1; for ($i = $l+1 ; $i <= $n ; $i++) $l *= $i; $m = 1; for ($i = 2 ; $i <= $n-$k ; $i++) $m *= $i; } else { $l = ($n-$k) + 1; for ($i = $l+1 ; $i <= $n ; $i++) $l *= $i; $m = 1; for ($i = 2 ; $i <= $k ; $i++) $m *= $i; } } return $l/$m; } function array_combination($le, $set){ $lk = combination_number($le, count($set)); $ret = array_fill(0, $lk, array_fill(0, $le, '') ); $temp = array(); for ($i = 0 ; $i < $le ; $i++) $temp[$i] = $i; $ret[0] = $temp; for ($i = 1 ; $i < $lk ; $i++){ if ($temp[$le-1] != count($set)-1){ $temp[$le-1]++; } else { $od = -1; for ($j = $le-2 ; $j >= 0 ; $j--) if ($temp[$j]+1 != $temp[$j+1]){ $od = $j; break; } if ($od == -1) break; $temp[$od]++; for ($j = $od+1 ; $j < $le ; $j++) $temp[$j] = $temp[$od]+$j-$od; } $ret[$i] = $temp; } for ($i = 0 ; $i < $lk ; $i++) for ($j = 0 ; $j < $le ; $j++) $ret[$i][$j] = $set[$ret[$i][$j]]; return $ret; } 

यहां इसका उपयोग कैसे किया जाता है:

संयोजनों की संख्या प्राप्त करने के लिए:

 combination_number(3,10); // returns number of combinations of ten-elements set. 

सभी संभव संयोजन प्राप्त करने के लिए:

 $mySet = array("A","B","C","D","E","F"); array_combination(3, $mySet); // returns all possible combinations of 3 elements of six-elements set. 

आशा है कि आप उस का उपयोग करते हैं।

यह कक्षा का मेरा संस्करण है यह वर्ग परिणामस्वरूप के रूप में क्रमबद्ध सरणी बनाता है और देता है

 class Permutation { private $result; public function getResult() { return $this->result; } public function permute($source, $permutated=array()) { if (empty($permutated)){ $this->result = array(); } if (empty($source)){ $this->result[] = $permutated; } else { for($i=0; $i<count($source); $i++){ $new_permutated = $permutated; $new_permutated[] = $source[$i]; $new_source = array_merge(array_slice($source,0,$i),array_slice($source,$i+1)); $this->permute($new_source, $new_permutated); } } return $this; } } $arr = array(1,2,3,4,5); $p = new Permutation(); print_r($p->permute($arr)->getResult()); 

मेरी कक्षा का परीक्षण करने के लिए अंतिम तीन पंक्तियाँ

यह एक साधारण पुनरावर्ती समारोह है जो सभी क्रमपरिवर्तनों को छपाता है (छद्मोकोड में लिखा हुआ है)

 function rec(n, k) { if (k == n) { for i = 0 to n-1 print(perm[i], ' '); print('\n'); } else { for i = 0 to n-1 { if (not used[i]) { used[i] = true; perm[k] = i; rec(n, k+1); used[i] = false; } } } } 

और इसे इस तरह कहा जाता है:

 rec(9, 0); 

शब्दकोषीय क्रम कोई पुनरावृत्ति नहीं है सरणी लंबाई के लिए लगभग कोई सीमा नहीं कोई सॉर्ट नहीं है यह तेजी से चल रहा है यह समझना आसान है ऋण: यह एक नोटिस देता है, लेकिन आप दूसरे तत्व या error_reporting (0) के साथ तुलना शुरू करने के लिए एक शर्त जोड़ सकते हैं।

 $a = array( 1, 2, 3, 4, 5 ); $b = array_reverse($a); print_r($a); //here need "br" while ($a != $b) { foreach(array_reverse($a, true) as $k => $v) { if ($v < $a[$k + 1]) { foreach(array_reverse($a, true) as $ka => $val) { if ($val > $v) break; } $ch = $a[$k]; $a[$k] = $a[$ka]; $a[$ka] = $ch; $c = array_slice($a, 0, $k + 1); print_r($a = array_merge($c, array_reverse(array_slice($a, $k + 1)))); //here need "br" break; } } } 

आप मूल रूप से क्रमपरिवर्तनों के बारे में बात कर रहे हैं जहां दोनों n और k 9 हैं ताकि आपके पास 9! हो जाएंगे 9! भिन्न क्रमपरिवर्तन; इसे देखें: http://en.wikipedia.org/wiki/Permutation

यह मेरा प्रस्ताव है, स्वीकार्य उत्तर की अपेक्षा थोड़ा सा स्पष्ट है।

  function permutate($elements, $perm = array(), &$permArray = array()) { if(empty($elements)) { array_push($permArray,$perm); return; } for($i=0;$i<=count($elements)-1;$i++) { array_push($perm,$elements[$i]); $tmp = $elements; array_splice($tmp,$i,1); permutate($tmp,$perm,$permArray); array_pop($perm); } return $permArray; } 

और उपयोग:

 $p = permutate(array('a','b','c')); foreach($p as $perm) print join(",",$perm)."|\n"; 

इसे इस्तेमाल करे…

 //function to generate and print all N! permutations of $str. (N = strlen($str)) function permute($str,$i,$n) { if ($i == $n) print "$str\n"; else { for ($j = $i; $j < $n; $j++) { swap($str,$i,$j); permute($str, $i+1, $n); swap($str,$i,$j); // backtrack. } } } // function to swap the char at pos $i and $j of $str. function swap(&$str,$i,$j) { $temp = $str[$i]; $str[$i] = $str[$j]; $str[$j] = $temp; } $str = "0123"; permute($str,0,strlen($str)); // call the function. 

मैंने यहां सूचीबद्ध पायथन आईटीरटोल्स कोड को पोर्ट किया है (जेनरेटर का उपयोग कर) अब तक के समाधानों पर लाभ यह है कि यह आपको आर (क्रमचय आकार) को निर्दिष्ट करने की अनुमति देता है।

 function permutations($pool, $r = null) { $n = count($pool); if ($r == null) { $r = $n; } if ($r > $n) { return; } $indices = range(0, $n - 1); $cycles = range($n, $n - $r + 1, -1); // count down yield array_slice($pool, 0, $r); if ($n <= 0) { return; } while (true) { $exit_early = false; for ($i = $r;$i--;$i >= 0) { $cycles[$i]-= 1; if ($cycles[$i] == 0) { // Push whatever is at index $i to the end, move everything back if ($i < count($indices)) { $removed = array_splice($indices, $i, 1); array_push($indices, $removed[0]); } $cycles[$i] = $n - $i; } else { $j = $cycles[$i]; // Swap indices $i & -$j. $i_val = $indices[$i]; $neg_j_val = $indices[count($indices) - $j]; $indices[$i] = $neg_j_val; $indices[count($indices) - $j] = $i_val; $result = []; $counter = 0; foreach ($indices as $indx) { array_push($result, $pool[$indx]); $counter++; if ($counter == $r) break; } yield $result; $exit_early = true; break; } } if (!$exit_early) { break; // Outer while loop } } } 

यह मेरे लिए काम करता है, लेकिन कोई वादा नहीं! उदाहरण उपयोग:

 $result = iterator_to_array(permutations([1, 2, 3, 4], 3)); foreach ($result as $row) { print implode(", ", $row) . "\n"; }