दिलचस्प पोस्ट
लचीलाशर्क में शार्ड्स और प्रतिकृतियां एक मशीन पर .NET ढाँचा के संस्करणों को वापस करने के लिए PowerShell स्क्रिप्ट? 'आवश्यकता': ऐसे फाइल को लोड नहीं किया जा सकता है – `नौकागिरि \ नाकोगीरी '(लोड एर्रर) जब चल रहा है' रेल सर्वर ' कोणीय UI- राउटर $ urlRouterProvider। जब मैं कार्य नहीं करता <a ui-sref="…"> क्लिक करता हूँ उसी विधानसभा के एकाधिक संस्करण लोड करना सूची दृश्य आइटम नहीं काम करें MySQL ग्रेट सर्किल दूरी (हार्वर्स फॉर्मूला) ट्विटर बूटस्ट्रैप में स्टाइल को कैसे ओवरराइट करें एक PHP स्क्रिप्ट को एक स्टैंड-अलोन विंडोज एक्जिक्यूटिव में कनवर्ट करें क्यों यूआरएल का हॅश हिस्सा सर्वर साइड में नहीं है? आईफ़ोन: एक स्थानीय सूचना के माध्यम से एप्लिकेशन बैज को बढ़ाना उप-वर्ग / मानक कंटेनरों का उत्तराधिकारी? Google Gson – deserialize सूची <class> ऑब्जेक्ट? (सामान्य प्रकार) सी # में विविध कीवर्ड का उपयोग सरणी के लिए अल्पविराम से अलग स्ट्रिंग कन्वर्ट करें

फास्ट क्रमचय -> संख्या -> क्रमचय मानचित्रण एल्गोरिदम

मेरे पास n तत्व हैं एक उदाहरण के लिए, हम कहते हैं, 7 तत्व, 1234567. मुझे पता है कि 7 हैं! इन 7 तत्वों की संभव = 5040 क्रमपरिवर्तन।

मुझे दो फ़ंक्शंस शामिल एक तेज एल्गोरिथ्म चाहिए:

एफ (संख्या) 0 और 5039 के बीच कोई एक अद्वितीय क्रमचय के लिए नक्शे, और

f '(क्रमचय) उस नंबर पर वापस क्रमचय को मैप करता है जिसे इसे से उत्पन्न किया गया था।

मुझे संख्या और क्रमचय के बीच पत्राचार के बारे में परवाह नहीं है, प्रत्येक क्रमचय की अपनी अद्वितीय संख्या है

इसलिए, उदाहरण के लिए, मेरे पास फ़ंक्शन हो सकते हैं जहां

f(0) = '1234567' f'('1234567') = 0 

सबसे तेजी से एल्गोरिदम जो मन में आता है, सभी क्रमपरिवर्तनों को बताने और दोनों दिशाओं में एक लुकअप तालिका बनाने के लिए है, ताकि टेबल तैयार हो जाने के बाद, एफ (0) ओ (1) और एफ ('1234567') होगा स्ट्रिंग पर लुकअप हालांकि, यह भूख लगी स्मृति है, खासकर जब n बड़ी हो जाती है

क्या कोई अन्य एल्गोरिथ्म का प्रस्ताव कर सकता है जो मेमोरी नुकसान के बिना जल्दी और बिना काम करेगा?

वेब के समाधान से एकत्रित समाधान "फास्ट क्रमचय -> संख्या -> क्रमचय मानचित्रण एल्गोरिदम"

एन तत्वों के क्रमचय का वर्णन करने के लिए, आप देख सकते हैं कि उस स्थिति के लिए जिस पर पहला तत्व समाप्त होता है, आपके पास n संभावनाएं हैं, इसलिए आप इसका वर्णन 0 और n-1 के बीच की संख्या के साथ कर सकते हैं। जिस स्थिति के लिए अगले तत्व समाप्त होता है, आपके पास एन -1 शेष संभावनाएं हैं, इसलिए आप इसका वर्णन 0 और एन -2 के बीच की संख्या के साथ कर सकते हैं।
जब तक आपके पास एन नंबर न हो

N = 5 के लिए एक उदाहरण के रूप में, उस क्रमचय पर विचार करें जो caebd को caebd

  • a , पहला तत्व, दूसरे स्थान पर समाप्त होता है, इसलिए हम उसे सूचकांक 1 को आवंटित करते हैं।
  • b चौथे स्थान पर समाप्त होता है, जो सूचकांक 3 होता है, लेकिन यह शेष तीसरा है, इसलिए हम इसे 2 प्रदान करते हैं।
  • c शेष शेष स्थिति में समाप्त होता है, जो हमेशा 0 होता है
  • d अंतिम शेष स्थिति में समाप्त होता है, जो (केवल दो शेष पदों में से) 1 है
  • e केवल शेष स्थिति पर समाप्त होता है, 0 पर अनुक्रमित

तो हमारे पास अनुक्रमणिका अनुक्रम {1, 2, 0, 1, 0} है

अब आप जानते हैं कि उदाहरण के लिए, एक द्विआधारी संख्या में, 'xyz' का अर्थ है Z + 2y + 4x दशमलव संख्या के लिए,
यह Z + 10y + 100x है प्रत्येक अंक को कुछ वजन से गुणा किया जाता है, और परिणामों का सारांश दिया जाता है। वज़न में स्पष्ट पैटर्न यह है कि वजन वैसे है = बी ^ के, बी के साथ संख्या का आधार और कश्मीर अंकों का सूचकांक। (मैं हमेशा सही से अंकों की गणना करता हूं और सहीतम अंक के लिए सूचकांक 0 से शुरू करता हूं। इसी तरह जब मैं 'प्रथम' अंक के बारे में बात करता हूँ तो मेरा मतलब सहीतम होता है।)

अंकों के लिए वजन इस पैटर्न का पालन करने का कारण यह है कि सबसे ज्यादा संख्या जो कि 0 से k के अंकों के द्वारा प्रदर्शित की जा सकती है, सबसे कम संख्या से ठीक 1 कम होनी चाहिए जिसका प्रतिनिधित्व केवल अंक k + 1 के द्वारा किया जा सकता है। बाइनरी में, 0111 1000 से कम होना चाहिए। दशमलव में, 09 99 99 100000 से कम होना चाहिए।

वेरिएबल-बेस के लिए एन्कोडिंग
इसके बाद के नंबरों के बीच अंतर 1 बिल्कुल महत्वपूर्ण नियम है। इसे समझते हुए, हम एक वेरिएबल-बेस नंबर से हमारी इंडेक्स अनुक्रम का प्रतिनिधित्व कर सकते हैं। प्रत्येक अंक का आधार उस अंक के लिए अलग-अलग संभावनाओं की संख्या है। प्रत्येक अंक के दशमलव के लिए 10 संभावनाएं हैं, हमारे सिस्टम के लिए सहीतम अंकों की 1 संभावना होगी और बाईं ओर के पास एन संभावनाएं हैं लेकिन चूंकि सहीतम अंक (हमारे अनुक्रम में अंतिम संख्या) हमेशा 0 है, हम इसे छोड़ देते हैं। इसका मतलब है कि हम 2 से n के आधार पर छोड़े गए हैं। सामान्य तौर पर, के'थी अंकों में आधार b [k] = k + 2 होगा। अंक के लिए अनुमत उच्चतम मूल्य h [k] = b [k] – 1 = k + 1

अंकों के वजन के बारे में हमारा नियम यह है कि एच [i] * w [i] की राशि, जहां मैं i = 0 से i = k से जाता है, 1 * w [k + 1] के बराबर है। वारंवार बताया गया, w [k + 1] = w [k] + h [k] * w [k] = w [k] * (h [k] + 1)। पहला वजन [0] हमेशा होना चाहिए। वहां से शुरू होने पर, हमारे पास निम्न मूल्य हैं:

 kh[k] w[k] 0 1 1 1 2 2 2 3 6 3 4 24 ... ... ... n-1 nn! 

(सामान्य संबंध w [k-1] = k! आसानी से प्रेरण द्वारा साबित किया गया है।)

हमारे अनुक्रम को परिवर्तित करने से प्राप्त संख्या तब होगी जब s [k] * w [k], k से 0 से n-1 तक चलने के साथ। यहां एस [के] अनुक्रम के तत्व (सबसे दाएं, 0 से शुरू होता है) है। एक उदाहरण के रूप में, हमारे {1, 2, 0, 1, 0} ले लो, पहले सबसे ऊपर दिए गए तत्व के रूप में उल्लिखित: {1, 2, 0, 1} । हमारी राशि 1 * 1 + 0 * 2 + 2 * 6 + 1 * 24 = 37 है

ध्यान दें कि यदि हम प्रत्येक सूचकांक के लिए अधिकतम स्थिति लेते हैं, तो हमारे पास {4, 3, 2, 1, 0} होता और जो कि 119 में बदल जाता है। चूंकि हमारी संख्या एन्कोडिंग में वज़न चुना गया था, इसलिए हम कोई भी संख्या, सभी संख्याएं 0 से 119 मान्य हैं। इनमें से ठीक 120 हैं, जो कि एन है! हमारे उदाहरण में एन = 5 के लिए, अलग क्रमांतरों की संख्या ठीक है। तो आप देख सकते हैं कि हमारे एन्कोडेड नंबर पूरी तरह से सभी संभव क्रमपरिवर्तन निर्दिष्ट करते हैं।

वेरिएबल-बेस से डिकोडिंग
डिकोडिंग बाइनरी या दशमलव को परिवर्तित करने के समान है आम एल्गोरिथ्म यह है:

 int number = 42; int base = 2; int[] bits = new int[n]; for (int k = 0; k < bits.Length; k++) { bits[k] = number % base; number = number / base; } 

हमारे चर-आधार संख्या के लिए:

 int n = 5; int number = 37; int[] sequence = new int[n - 1]; int base = 2; for (int k = 0; k < sequence.Length; k++) { sequence[k] = number % base; number = number / base; base++; // b[k+1] = b[k] + 1 } 

यह सही ढंग से हमारे 37 को {1, 2, 0, 1} (इस कोड उदाहरण में sequence होगा {1, 0, 2, 1} , लेकिन जो कुछ भी हो … जब तक आप उचित रूप से सूचकांक हो)। हमारे मूल अनुक्रम {1, 2, 0, 1, 0} को वापस पाने के लिए हमें बस सही अंत में 0 जोड़ना होगा (याद रखें कि आखिरी तत्व को हमेशा अपनी नई स्थिति के लिए एक ही संभावना है)।

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

 int n = 5; int[] sequence = new int[] { 1, 2, 0, 1, 0 }; char[] list = new char[] { 'a', 'b', 'c', 'd', 'e' }; char[] permuted = new char[n]; bool[] set = new bool[n]; for (int i = 0; i < n; i++) { int s = sequence[i]; int remainingPosition = 0; int index; // Find the s'th position in the permuted list that has not been set yet. for (index = 0; index < n; index++) { if (!set[index]) { if (remainingPosition == s) break; remainingPosition++; } } permuted[index] = list[i]; set[index] = true; } 

क्रमपरिवर्तन का सामान्य प्रतिनिधित्व
आम तौर पर आप एक क्रमचय का प्रतिनिधित्व नहीं करेंगे जैसे कि हमने किया है, परन्तु हमारे द्वारा किया है, परन्तु क्रमबद्धता के लागू होने के बाद प्रत्येक तत्व की पूर्ण स्थिति से बस। caebd लिए हमारा उदाहरण {1, 2, 0, 1, 0} आम तौर पर {1, 3, 0, 4, 2} द्वारा दर्शाया गया है। 0 से 4 (या सामान्य रूप में, 0 से n-1) प्रत्येक सूचकांक इस प्रतिनिधित्व में ठीक एक बार होता है।

इस प्रपत्र में क्रमचय को लागू करना आसान है:

 int[] permutation = new int[] { 1, 3, 0, 4, 2 }; char[] list = new char[] { 'a', 'b', 'c', 'd', 'e' }; char[] permuted = new char[n]; for (int i = 0; i < n; i++) { permuted[permutation[i]] = list[i]; } 

इनवर्टिंग को बहुत समान है:

 for (int i = 0; i < n; i++) { list[i] = permuted[permutation[i]]; } 

हमारे प्रतिनिधित्व से आम प्रतिनिधित्व करने के लिए परिवर्तित
ध्यान दें कि यदि हम हमारी अनुक्रमणिका अनुक्रम का उपयोग करके एक सूची को अनुक्रमित करने के लिए अपना एल्गोरिथ्म लेते हैं, और इसे {0, 1, 2, …, n-1} पहचान परिमार्ग पर लागू करते हैं, तो हमें आम रूप में उल्लिखित क्रमबद्धता प्राप्त होती है । (हमारे उदाहरण में {2, 0, 4, 1, 3} )।

गैर इन्वर्टेड प्रतिरूप प्राप्त करने के लिए, हम क्रममातन एल्गोरिदम पर लागू होते हैं जो मैंने अभी दिखाया है:

 int[] identity = new int[] { 0, 1, 2, 3, 4 }; int[] inverted = { 2, 0, 4, 1, 3 }; int[] normal = new int[n]; for (int i = 0; i < n; i++) { normal[identity[i]] = list[i]; } 

या आप सीधे इनवर्स क्रमचय एल्गोरिदम का उपयोग करके, सीधे क्रमचय लागू कर सकते हैं:

 char[] list = new char[] { 'a', 'b', 'c', 'd', 'e' }; char[] permuted = new char[n]; int[] inverted = { 2, 0, 4, 1, 3 }; for (int i = 0; i < n; i++) { permuted[i] = list[inverted[i]]; } 

ध्यान दें कि सामान्य रूप में क्रमपरिवर्तन से निपटने के लिए सभी एल्गोरिदम हैं ओ (एन), जबकि हमारे फॉर्म में क्रमबद्धता को लागू करते हुए हे (एन-एस) है यदि आपको कई बार एक क्रमचय लागू करने की आवश्यकता है, तो पहले इसे आम प्रतिनिधित्व में परिवर्तित करें।

मैंने ओ (एन) में एल्गोरिदम बनाया, आप यहां अपने कार्यों को प्राप्त कर सकते हैं: http://antoinecomeau.blogspot.ca/2014/07/mapping-between-permutations-and.html

 public static int[] perm(int n, int k) { int i, ind, m=k; int[] permuted = new int[n]; int[] elems = new int[n]; for(i=0;i<n;i++) elems[i]=i; for(i=0;i<n;i++) { ind=m%(ni); m=m/(ni); permuted[i]=elems[ind]; elems[ind]=elems[ni-1]; } return permuted; } public static int inv(int[] perm) { int i, k=0, m=1; int n=perm.length; int[] pos = new int[n]; int[] elems = new int[n]; for(i=0;i<n;i++) {pos[i]=i; elems[i]=i;} for(i=0;i<n-1;i++) { k+=m*pos[perm[i]]; m=m*(ni); pos[elems[ni-1]]=pos[perm[i]]; elems[pos[perm[i]]]=elems[ni-1]; } return k; } 

जटिलता को n * लॉग (एन) पर लाया जा सकता है, अनुभाग 10.1.1 देखें ("द लेहमर्स कोड (उलटा तालिका)", पी 3232 एफएफटीबुक की): http://www.jjj.de/fxt/ #fxtbook तेजी से विधि के लिए खंड 10.1.1.1 ("बड़े arrays के साथ कंप्यूटिंग" पृष्ठ .235) पर जाएं। (जीपीएलड, सी ++) कोड एक ही वेब पेज पर है।

प्रत्येक तत्व सात स्थानों में से एक हो सकता है एक तत्व की स्थिति का वर्णन करने के लिए, आपको तीन बिट की आवश्यकता होगी। इसका मतलब है कि आप 32 बिट मूल्य में सभी तत्वों की स्थिति को स्टोर कर सकते हैं। यह कुशल होने से बहुत दूर है, क्योंकि यह प्रतिनिधित्व सभी तत्व समान स्थिति में होने की अनुमति देगा, लेकिन मेरा मानना ​​है कि बिट-मास्किंग को काफी तेज होना चाहिए।

हालांकि, 8 से अधिक पदों के साथ आपको कुछ अधिक निफ्टी की ज़रूरत होगी

यह जे में एक अंतर्निहित फ़ंक्शन होता है:

  A. 1 2 3 4 5 6 7 0 0 A. 1 2 3 4 5 6 7 1 2 3 4 5 6 7 ?!7 5011 5011 A. 1 2 3 4 5 6 7 7 6 4 5 1 3 2 A. 7 6 4 5 1 3 2 5011 

समस्या सुलझ गयी। हालांकि, मुझे यकीन नहीं है कि इन वर्षों के बाद भी आपको समाधान की आवश्यकता है। एलओएल, मैं सिर्फ इस साइट में शामिल हूं, इसलिए … मेरी जावा अनुक्रमण वर्ग की जाँच करें। आप सूचकांक पर एक प्रतीक क्रमबद्धता प्राप्त करने के लिए आधार बना सकते हैं, या एक प्रतीक क्रमबद्धता दें तो सूचकांक प्राप्त करें।

यहाँ मेरी प्रेम-प्रतिष्ठा कक्षा है I

 /** **************************************************************************************************************** * Copyright 2015 Fred Pang fred@pnode.com **************************************************************************************************************** * A complete list of Permutation base on an index. * Algorithm is invented and implemented by Fred Pang fred@pnode.com * Created by Fred Pang on 18/11/2015. **************************************************************************************************************** * LOL this is my first Java project. Therefore, my code is very much like C/C++. The coding itself is not * very professional. but... * * This Permutation Class can be use to generate a complete list of all different permutation of a set of symbols. * nPr will be n!/(nr)! * the user can input n = the number of items, * r = the number of slots for the items, * provided n >= r * and a string of single character symbols * * the program will generate all possible permutation for the condition. * * Say if n = 5, r = 3, and the string is "12345", it will generate sll 60 different permutation of the set * of 3 character strings. * * The algorithm I used is base on a bin slot. * Just like a human or simply myself to generate a permutation. * * if there are 5 symbols to chose from, I'll have 5 bin slot to indicate which symbol is taken. * * Note that, once the Permutation object is initialized, or after the constructor is called, the permutation * table and all entries are defined, including an index. * * eg. if pass in value is 5 chose 3, and say the symbol string is "12345" * then all permutation table is logically defined (not physically to save memory). * It will be a table as follows * index output * 0 123 * 1 124 * 2 125 * 3 132 * 4 134 * 5 135 * 6 143 * 7 145 * : : * 58 542 * 59 543 * * all you need to do is call the "String PermGetString(int iIndex)" or the "int[] PermGetIntArray(int iIndex)" * function or method with an increasing iIndex, starting from 0 to getiMaxIndex() - 1. It will return the string * or the integer array corresponding to the index. * * Also notice that in the input string is "12345" of position 01234, and the output is always in accenting order * this is how the permutation is generated. * * *************************************************************************************************************** * ==== W arning ==== * *************************************************************************************************************** * * There is very limited error checking in this class * * Especially the int PermGetIndex(int[] iInputArray) method * if the input integer array contains invalid index, it WILL crash the system * * the other is the string of symbol pass in when the object is created, not sure what will happen if the * string is invalid. * *************************************************************************************************************** * */ public class Permutation { private boolean bGoodToGo = false; // object status private boolean bNoSymbol = true; private BinSlot slot; // a bin slot of size n (input) private int nTotal; // n number for permutation private int rChose; // r position to chose private String sSymbol; // character string for symbol of each choice private String sOutStr; private int iMaxIndex; // maximum index allowed in the Get index function private int[] iOutPosition; // output array private int[] iDivisorArray; // array to do calculation public Permutation(int inCount, int irCount, String symbol) { if (inCount >= irCount) { // save all input values passed in this.nTotal = inCount; this.rChose = irCount; this.sSymbol = symbol; // some error checking if (inCount < irCount || irCount <= 0) return; // do nothing will not set the bGoodToGo flag if (this.sSymbol.length() >= inCount) { bNoSymbol = false; } // allocate output storage this.iOutPosition = new int[this.rChose]; // initialize the bin slot with the right size this.slot = new BinSlot(this.nTotal); // allocate and initialize divid array this.iDivisorArray = new int[this.rChose]; // calculate default values base on n & r this.iMaxIndex = CalPremFormula(this.nTotal, this.rChose); int i; int j = this.nTotal - 1; int k = this.rChose - 1; for (i = 0; i < this.rChose; i++) { this.iDivisorArray[i] = CalPremFormula(j--, k--); } bGoodToGo = true; // we are ready to go } } public String PermGetString(int iIndex) { if (!this.bGoodToGo) return "Error: Object not initialized Correctly"; if (this.bNoSymbol) return "Error: Invalid symbol string"; if (!this.PermEvaluate(iIndex)) return "Invalid Index"; sOutStr = ""; // convert string back to String output for (int i = 0; i < this.rChose; i++) { String sTempStr = this.sSymbol.substring(this.iOutPosition[i], iOutPosition[i] + 1); this.sOutStr = this.sOutStr.concat(sTempStr); } return this.sOutStr; } public int[] PermGetIntArray(int iIndex) { if (!this.bGoodToGo) return null; if (!this.PermEvaluate(iIndex)) return null ; return this.iOutPosition; } // given an int array, and get the index back. // // ====== WARNING ====== // // there is no error check in the array that pass in // if any invalid value in the input array, it can cause system crash or other unexpected result // // function pass in an int array generated by the PermGetIntArray() method // then return the index value. // // this is the reverse of the PermGetIntArray() // public int PermGetIndex(int[] iInputArray) { if (!this.bGoodToGo) return -1; return PermDoReverse(iInputArray); } public int getiMaxIndex() { return iMaxIndex; } // function to evaluate nPr = n!/(nr)! public int CalPremFormula(int n, int r) { int j = n; int k = 1; for (int i = 0; i < r; i++, j--) { k *= j; } return k; } // PermEvaluate function (method) base on an index input, evaluate the correspond permuted symbol location // then output it to the iOutPosition array. // // In the iOutPosition[], each array element corresponding to the symbol location in the input string symbol. // from location 0 to length of string - 1. private boolean PermEvaluate(int iIndex) { int iCurrentIndex; int iCurrentRemainder; int iCurrentValue = iIndex; int iCurrentOutSlot; int iLoopCount; if (iIndex >= iMaxIndex) return false; this.slot.binReset(); // clear bin content iLoopCount = 0; do { // evaluate the table position iCurrentIndex = iCurrentValue / this.iDivisorArray[iLoopCount]; iCurrentRemainder = iCurrentValue % this.iDivisorArray[iLoopCount]; iCurrentOutSlot = this.slot.FindFreeBin(iCurrentIndex); // find an available slot if (iCurrentOutSlot >= 0) this.iOutPosition[iLoopCount] = iCurrentOutSlot; else return false; // fail to find a slot, quit now this.slot.setStatus(iCurrentOutSlot); // set the slot to be taken iCurrentValue = iCurrentRemainder; // set new value for current value. iLoopCount++; // increase counter } while (iLoopCount < this.rChose); // the output is ready in iOutPosition[] return true; } // // this function is doing the reverse of the permutation // the input is a permutation and will find the correspond index value for that entry // which is doing the opposit of the PermEvaluate() method // private int PermDoReverse(int[] iInputArray) { int iReturnValue = 0; int iLoopIndex; int iCurrentValue; int iBinLocation; this.slot.binReset(); // clear bin content for (iLoopIndex = 0; iLoopIndex < this.rChose; iLoopIndex++) { iCurrentValue = iInputArray[iLoopIndex]; iBinLocation = this.slot.BinCountFree(iCurrentValue); this.slot.setStatus(iCurrentValue); // set the slot to be taken iReturnValue = iReturnValue + iBinLocation * this.iDivisorArray[iLoopIndex]; } return iReturnValue; } /******************************************************************************************************************* ******************************************************************************************************************* * Created by Fred on 18/11/2015. fred@pnode.com * * ***************************************************************************************************************** */ private static class BinSlot { private int iBinSize; // size of array private short[] eStatus; // the status array must have length iBinSize private BinSlot(int iBinSize) { this.iBinSize = iBinSize; // save bin size this.eStatus = new short[iBinSize]; // llocate status array } // reset the bin content. no symbol is in use private void binReset() { // reset the bin's content for (int i = 0; i < this.iBinSize; i++) this.eStatus[i] = 0; } // set the bin position as taken or the number is already used, cannot be use again. private void setStatus(int iIndex) { this.eStatus[iIndex]= 1; } // // to search for the iIndex th unused symbol // this is important to search through the iindex th symbol // because this is how the table is setup. (or the remainder means) // note: iIndex is the remainder of the calculation // // for example: // in a 5 choose 3 permutation symbols "12345", // the index 7 item (count starting from 0) element is "1 4 3" // then comes the index 8, 8/12 result 0 -> 0th symbol in symbol string = '1' // remainder 8. then 8/3 = 2, now we need to scan the Bin and skip 2 unused bins // current the bin looks 0 1 2 3 4 // xoooox -> in use; o -> free only 0 is being used // ss ^ skipped 2 bins (bin 1 and 2), we get to bin 3 // and bin 3 is the bin needed. Thus symbol "4" is pick // in 8/3, there is a remainder 2 comes in this function as 2/1 = 2, now we have to pick the empty slot // for the new 2. // the bin now looks 0 1 2 3 4 // x 0 0 x 0 as bin 3 was used by the last value // ss ^ we skip 2 free bins and the next free bin is bin 4 // therefor the symbol "5" at the symbol array is pick. // // Thus, for index 8 "1 4 5" is the symbols. // // private int FindFreeBin(int iIndex) { int j = iIndex; if (j < 0 || j > this.iBinSize) return -1; // invalid index for (int i = 0; i < this.iBinSize; i++) { if (this.eStatus[i] == 0) // is it used { // found an empty slot if (j == 0) // this is a free one we want? return i; // yes, found and return it. else // we have to skip this one j--; // else, keep looking and count the skipped one } } assert(true); // something is wrong return -1; // fail to find the bin we wanted } // // this function is to help the PermDoReverse() to find out what is the corresponding // value during should be added to the index value. // // it is doing the opposite of int FindFreeBin(int iIndex) method. You need to know how this // FindFreeBin() works before looking into this function. // private int BinCountFree(int iIndex) { int iRetVal = 0; for (int i = iIndex; i > 0; i--) { if (this.eStatus[i-1] == 0) // it is free { iRetVal++; } } return iRetVal; } } } // End of file - Permutation.java 

और क्लास का उपयोग कैसे करें, यह दिखाने के लिए यहां मेरा मुख्य वर्ग है I

 /* * copyright 2015 Fred Pang * * This is the main test program for testing the Permutation Class I created. * It can be use to demonstrate how to use the Permutation Class and its methods to generate a complete * list of a permutation. It also support function to get back the index value as pass in a permutation. * * As you can see my Java is not very good. :) * This is my 1st Java project I created. As I am a C/C++ programmer for years. * * I still have problem with the Scanner class and the System class. * Note that there is only very limited error checking * * */ import java.util.Scanner; public class Main { private static Scanner scanner = new Scanner(System.in); public static void main(String[] args) { Permutation perm; // declear the object String sOutString = ""; int nCount; int rCount; int iMaxIndex; // Get user input System.out.println("Enter n: "); nCount = scanner.nextInt(); System.out.println("Enter r: "); rCount = scanner.nextInt(); System.out.println("Enter Symbol: "); sOutString = scanner.next(); if (sOutString.length() < rCount) { System.out.println("String too short, default to numbers"); sOutString = ""; } // create object with user requirement perm = new Permutation(nCount, rCount, sOutString); // and print the maximum count iMaxIndex = perm.getiMaxIndex(); System.out.println("Max count is:" + iMaxIndex); if (!sOutString.isEmpty()) { for (int i = 0; i < iMaxIndex; i++) { // print out the return permutation symbol string System.out.println(i + " " + perm.PermGetString(i)); } } else { for (int i = 0; i < iMaxIndex; i++) { System.out.print(i + " ->"); // Get the permutation array int[] iTemp = perm.PermGetIntArray(i); // print out the permutation for (int j = 0; j < rCount; j++) { System.out.print(' '); System.out.print(iTemp[j]); } // to verify my PermGetIndex() works. :) if (perm.PermGetIndex(iTemp)== i) { System.out.println(" ."); } else { // oops something is wrong :( System.out.println(" ***************** FAILED *************************"); assert(true); break; } } } } } // // End of file - Main.java 

मज़े करो। 🙂

आप एक पुनरावर्ती एल्गोरिथ्म का उपयोग कर क्रमपरिवर्तन को एन्कोड कर सकते हैं। यदि कोई N- क्रमचय (संख्याओं का कुछ क्रम {0, .., N-1}) फॉर्म {x, …} है, तो इसे एक्स + एन * (एन -1) की एन्कोडिंग के रूप में एन्कोड करें। -मुझे अंक "{1}" – {x} नंबरों पर "…" द्वारा दर्शाया गया है। एक कौर की तरह लगता है, यहां कुछ कोड है:

 // perm[0]..perm[n-1] must contain the numbers in {0,..,n-1} in any order. int permToNumber(int *perm, int n) { // base case if (n == 1) return 0; // fix up perm[1]..perm[n-1] to be a permutation on {0,..,n-2}. for (int i = 1; i < n; i++) { if (perm[i] > perm[0]) perm[i]--; } // recursively compute return perm[0] + n * permToNumber(perm + 1, n - 1); } // number must be >=0, < n! void numberToPerm(int number, int *perm, int n) { if (n == 1) { perm[0] = 0; return; } perm[0] = number % n; numberToPerm(number / n, perm + 1, n - 1); // fix up perm[1] .. perm[n-1] for (int i = 1; i < n; i++) { if (perm[i] >= perm[0]) perm[i]++; } } 

यह एल्गोरिदम ओ (एन ^ 2) है बोनस अंक अगर किसी के पास ओ (एन) एल्गोरिथम है

क्या एक दिलचस्प सवाल है!

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

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

इस बारे में एक पुस्तक लिखी गई है क्षमा करें, लेकिन मुझे उसका नाम याद नहीं है (आप इसे विकिपीडिया से शायद मिल जाएंगे) लेकिन वैसे भी मैंने उस गणन प्रणाली के एक अजगर कार्यान्वयन लिखा था: http://kks.cabal.fi/Kombinaattori इसमें से कुछ फिनिश में है, लेकिन सिर्फ कोड और नाम के चर को कॉपी करें …