लूप के लिए नेस्टेड की परिवर्तनीय संख्या

Question

मैं जावा में एक शब्द unscrambler बना रहा हूँ। अभी मेरे पास एक ऐसा प्रोग्राम है जो 3 या उससे अधिक अक्षरों वाले शब्द से चुने गए 3 अक्षरों के सभी पुनर्गठन मुद्रित कर सकता है (कोई दोहराना नहीं)।

[[एबीसी, अब्द, एसीबी, एसीडी, एशियाई विकास बैंक, एडीसी, बक, बुरा, बीसीए, बीसीडी, बीडीए, बीडीसी, टैक्सी, सीएडी: तो उदाहरण के लिए, यदि पैरामीटर ABCD है, यह इस प्रिंट होगा , सीबीए, सीबीआई, सीडीए, सीडीबी, डैब, डीएसी, डीबीए, डीबीसी, डीसीए, डीसीबी]]

मैं क्रमपरिवर्तन के साथ 2 डी सरणी सूची भर रहा हूं। अभी 2 डी सरणी के अंदर केवल एक सरणी है, जिसमें 3 अक्षरों के लिए क्रमपरिवर्तन शामिल हैं। मैं चाहता हूं कि 2 डी सरणी में शब्द की लंबाई पर रोककर 1 अक्षर, 2 अक्षरों, 3 अक्षरों, और इसी तरह की अनुमति के लिए सरणी हों। समस्या यह है कि मुझे इसे पूरा करने के लिए लूप के लिए नेस्टेड की एक चर संख्या की आवश्यकता है। 3 अक्षर क्रमपरिवर्तनों के लिए, मेरे पास 3 लूप के लिए घोंसला है। पैरामीटर में अक्षरों के माध्यम से प्रत्येक चक्र।

public static void printAllPermuations(String word) 
{ 
    int len = word.length(); 
    ArrayList<String> lets = new ArrayList<String>(); 
    //this array of letters allows for easier access 
    //so I don't have to keep substringing 
    for (int i = 0; i < len; i++) 
    { 
     lets.add(word.substring(i, i + 1)); 
    } 

    ArrayList<ArrayList<String>> newWords = new ArrayList<ArrayList<String>>(); 
    newWords.add(new ArrayList<String>()); 
    for (int i = 0; i < len; i++) 
    { 
     for (int j = 0; j < len; j++) 
     { 
      for (int k = 0; k < len; k++) 
      { 
       if (i != j && i != k && j != k) 
       //prevents repeats by making sure all indices are different 
       { 
        newWords.get(0).add(lets.get(i) + lets.get(j) + lets.get(k)); 
       } 
      } 
     } 
    } 
    System.out.println(newWords); 
} 

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

Answer 1

रिकर्सिव विधि के साथ आप फ़ंक्शन में अपनी लूपिंग को उस फ़ंक्शन पर लूप पैरामीटर पास कर देंगे। फिर फ़ंक्शन के लूप के भीतर से, यह इसे एक और लूप घोंसला कहता है।

void loopFunction(ArrayList<ArrayList<String>> newWords, int level) { 
    if (level == 0) { // terminating condition 
     if (/* compare the indices by for example passing down a list with them in */) 
     { 
      newWords.get(...).add(...); 
     } 
    } else {// inductive condition 
     for (int i = 0; i < len; i++) { 
      loopFunction(newWords, level-1); 
     } 
    } 
} 

तो अपने उदाहरण के लिए आप प्रत्यावर्तन के 3 स्तरों की जरूरत है ताकि आप के साथ प्रत्यावर्तन शुरू होगा:

loopFunction(newWords, 3); 

संपादित

जब से तुम मुसीबत यहाँ होने दिया है एक काम संस्करण है । यह तुलना करने के लिए सूचकांक की एक सूची रखता है और यह स्ट्रिंग को बनाता है जैसा कि यह जाता है। शब्दों की सभी लंबाई प्राप्त करने के लिए पुन: व्यवस्थित शब्दों को प्रत्येक स्तर पर 2 डी सरणी में जोड़ा जाता है। रिकर्सन के साथ कार्यात्मक रूप से सोचना और परिवर्तन नहीं करना और चर को अपरिवर्तनीय (अपरिवर्तनीय) रखना सबसे आसान है। यह कोड ज्यादातर करता है हालांकि मैं सुविधा के लिए एक नई प्रति बनाने के बजाय indices अद्यतन करता हूं।

void loopFunction(ArrayList<String> lets, ArrayList<ArrayList<String>> newWords, int level, ArrayList<Integer> indices, String word) { 
    if (level == 0) { // terminating condition 
     return; 
    } else { // inductive condition 
     for (int i = 0; i < lets.size(); i++) { 
      if (!indices.contains(i)) { // Make sure no index is equal 
       int nextLevel = level-1; 
       String nextWord = word+lets.get(i); 

       newWords.get(level-1).add(nextWord); 

       indices.add(i); 
       loopFunction(lets, newWords, nextLevel, indices, nextWord); 
       indices.remove((Integer) i); 
      } 
     } 
    } 
} 

Answer 2

मैं तुम्हें वास्तविक कोड नहीं देंगे, लेकिन यह आप विचार प्रत्यावर्तन की तरह लग सकता है कि (मेरा मानना ​​है कि दूसरा रास्ता यह रिकर्सिवली करने के लिए देखते हैं: पी) देना चाहिए

void findAllCombination(String tmpResult, 
         String rawString, 
         int noOfChar, 
         List<String> allCombinations) { 
    if (tmpResult.size() == noOfChar) { 
    allCombinations.add(tmpResult); 
    } else { 
    for (i in 0 to rawString.size()) { 
     findAllCombination(tmpResult + rawString[i], 
         rawString.removeCharAt(i), 
         noOfChar, 
         allCombinations); 
    } 
    } 
} 

List<String> foo(String input, int level) { 
    List<String> allResults = ...; 
    findAllCombination("", input, level, allResults); 
    return allResults; 
} 

मुख्य रिकर्सन भाग findAllCombination है। विचार सख्त आगे है। सभी क्रमपरिवर्तन खोजने के लिए, हमारे पास कच्चे स्ट्रिंग इनपुट के लिए, हम चरित्र को एक-एक करके लेते हैं, और पहले पाए गए tmpResult में शामिल होते हैं, और उस प्रसंस्करण के लिए उस tmpResult का उपयोग करते हैं। एक बार जब हम इस बिंदु को दबाते हैं कि tmpResult काफी लंबा है, तो हम परिणाम allCombinations सूची में tmpResult डाल दिया।

Answer 3

:

(पी कोड्स है कि वास्तव में काम करता है करते हैं, केवल 6 लाइनों है केवल कोष्ठक और अनदेखी लाइनों है कि मैं बेहतर पठनीयता के लिए जानबूझकर तोड़ के साथ लाइनों को छोड़कर foo() विधि सिर्फ अपने मंगलाचरण आसान बनाने के लिए यहाँ है) क्या @DrYap कहा के आधार पर मैंने लिखा था इस (यह अपने से थोड़ा अलग है):

for(int i = 1; i <= len; i++) 
{ 
    newWords.add(new ArrayList<String>()); 
    loop(i); 
} 

यहाँ पाश विधि है:

यहाँ यह शुरू करने के लिए कोड है। इसलिए मैं उन्हें पैरामीटर में पारित करने के लिए की जरूरत नहीं है चर का एक बहुत उदाहरण चर के रूप में घोषित किया गया: (!! i = j && मैं = k && j = k)

public static void loop(int level) 
{ 
    if (level == 0) 
    { 
     int pos = indices.size() - 1; 
     int pos2 = newWords.get(pos).size(); 
     newWords.get(pos).add(""); 
     for (Integer letIndex : indices) 
     { 
      String previous = newWords.get(pos).get(pos2); 
      newWords.get(pos).set(pos2, previous + lets.get(letIndex)); 
     } 
    } 
    else 
    { 
     for (int i = 0; i < len; i++) 
     { 
      if (!indices.contains(i)) 
      { 
       int indicesIndex = indices.size(); 

       indices.add((Integer) i); 
       loop(level - 1); 
       indices.remove(indicesIndex); 
      } 
     } 
    } 
}