2012-10-16 15 views
5

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

यहां तक ​​कि मेरे पास अब तक है।

import java.util.*; 

class MethodAssign2{ 
    static void capitalizer(String a,int b){ 
     if(b==-1){ 
     System.out.println("worked?"); 
     }else{ 
     char[] achars = a.toCharArray(); 
     achars[b] -= 32; 
     String caplet = new String(achars); 
     System.out.println(caplet); 
     System.out.println(a); 
     capitalizer(caplet,b-1); 
     capitalizer(a,b-1); 
     } 
    } 
    public static void main(String[]args){ 
     String word = "ownage"; 
     capitalizer(word,word.length()-1); 
    } 
} 

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

+0

इस साइट में इस तरह के लिए सही जगह नहीं है:

यह संकलन नहीं होगा, लेकिन (मुझे लगता है कि) यहाँ स्यूडोकोड में समाधान है सवाल का कोड समीक्षा साइट आज़माएं। – bmargulies

+8

@bmargulies: मैं असहमत हूं। कोड समीक्षा "मेरे कोड के बारे में अपनी राय दें"। यह सवाल है: "मुझे एक समस्या है, मैंने यही कोशिश की, लेकिन यह असफल रहा - मैं इसे कैसे काम कर सकता हूं?" जो एक वैध एसओ सवाल है। – amit

+2

नहीं, ओप कभी नहीं कहता कि वह असफल रहा है, या कुछ भी गलत है, केवल वे कोड बदसूरत पाते हैं। – bmargulies

उत्तर

4

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

static void capitalizer(String a,int b){ 
    if(b==-1){ 
     System.out.println(a); //CHANGE: printing in the stop clause 
    }else{ 
     char[] achars = a.toCharArray(); 
     achars[b] -= 32; 
     String caplet = new String(achars); 
     //CHANGE: not printing every iteration 
     capitalizer(caplet,b-1); 
     capitalizer(a,b-1); 
    } 
} 

विचार करता है, तो एल्गोरिथ्म है: प्रत्येक चरण में आप "अनुमान" क्या वर्तमान चरित्र है - यह एक ऊपरी या निचली चरित्र है, और छोटे समस्या पर पुनरावर्ती कलन विधि आह्वान (अगले चरित्र के साथ) ।
आप वर्तमान पत्र दोनों के लिए इसे दोहराते हैं और पूंजीकृत नहीं है।


पिछले कोड विफल हो गया क्योंकि आप तार यह हर पत्र परिवर्तन है, जो बहुत अधिक (लगभग दोगुना) में जो परिणाम के बाद उत्पन्न तो सभी 2^n संभव शब्द मुद्रित करने के लिए तरीके छपी।


(1) बोनस: बिल्कुल 2^n संभव तार आप मुद्रित कर सकते हैं, क्योंकि हर चरित्र आप चुनने की जरूरत है के लिए कर रहे हैं: यह बड़ा कर दिया है या नहीं है? आप प्रत्येक प्रश्न के लिए इस प्रश्न को दोहराते हैं, और rule of product से - यह आपको वास्तव में 2^n संभावित स्ट्रिंग देता है।

+0

मुझे लगता है कि मुझे सिर्फ आपके पास कॉपी नहीं करना चाहिए, लेकिन मुझे लगता है कि मैंने काफी कोशिश की है और अब मैं इसे समझता हूं। आपका बहुत बहुत धन्यवाद। –

+1

@cookcook: आप लगभग अपने आप से वहां पहुंचे, ध्यान दें कि आपके कोड में किए गए परिवर्तन बहुत मामूली हैं। अच्छा काम, और शुभकामनाएँ! – amit

1

देखो:

System.out.println(caplet); 
System.out.println(a); 
capitalizer(caplet,b-1); 
capitalizer(a,b-1); 

आप स्ट्रिंग के वर्तमान संस्करण प्रिंट, और फिर उन्हें फिर से संभाला है। हालांकि, जब आगे संभाला जा रहा है, तो ऐसा होगा कि कुछ भी नहीं बदलेगा। फिर भी हर पुनरावृत्ति में, आप अभी भी वही स्ट्रिंग प्रिंट कर रहे हैं।

आप जो करना चाहते हैं वह इन प्रिंटों को हटा दें, और बहुत अंत में प्रिंट जोड़ें (if(b==-1) ब्लॉक में) जहां आप उस बिंदु पर पूरा किए गए पुनरावृत्तियों के विशिष्ट सेट के अंतिम परिणाम को प्रिंट करते हैं।

0

बार-बार सोचते समय, दोहराए गए चरणों के संदर्भ में सोचें।

तो अंतिम अक्षर के बारे में सोच, तुम हो:

Ownage Ownage

वापस एक कदम तुम हो जा रहे हैं:

Ownage Ownage Ownage Ownage

देखते हैं? दूसरे के अंतिम अक्षर के लिए प्रत्येक विकल्प के लिए, आपके पास अंतिम पत्र के लिए वैकल्पिक मान हैं। और इसी तरह।

तो 'अगर मेरे पास पहले एन अक्षरों के सभी विकल्प हैं, तो मैं अगले के आधार पर विकल्प कैसे प्राप्त करूं?

उस समस्या को हल करने के बारे में सोचें, और आपको एक पुनरावर्ती समाधान मिलेगा।

1

आपके रिकर्सिव फ़ंक्शन को दिए गए शब्द के पहले अक्षर में हेरफेर करना चाहिए और शेष अक्षरों में हेरफेर करने के लिए रिकर्सिव कॉल पर भरोसा करना चाहिए। यह एक बहुत ही आम समस्या है जो तब होती है जब आपको एक समग्र वस्तु के सभी संभावित राज्यों पर पुनरावृत्ति करना होता है।

recursion(word){ 

List list = new List(); 

String firstLetter = firstLetter(word); 
String restOfWord = restOfWord(word); 

for(rest : recursion(restOfWord)){ 
list.append(firstLetter.uppercase()+rest); 
list.append(firstLetter.lowercase()+rest); 

return list; 
} 
0
public static void capitalizer(String input) { 
    capitalizer("", input); 
} 

private static void capitalizer(String prefix, String buffer) { 
    if (buffer.isEmpty()) { 
     System.out.println(prefix); 
     return; 
    } 

    char c = buffer.charAt(0); 
    char cup = Character.toUpperCase(c); 

    String p = prefix + c; 
    String pup = prefix + cup; 

    String b = buffer.length() == 0 ? "" : buffer.substring(1, buffer.length()); 

    capitalizer(p, b); 
    capitalizer(pup, b); 
} 

public static void main(String[] args) { 
    capitalizer("ownage"); 
} 

उत्पादन,

ownage 
ownagE 
ownaGe 
ownaGE 
ownAge 
ownAgE 
ownAGe 
ownAGE 
owNage 
owNagE 
owNaGe 
owNaGE 
owNAge 
owNAgE 
owNAGe 
owNAGE 
oWnage 
oWnagE 
oWnaGe 
oWnaGE 
oWnAge 
oWnAgE 
oWnAGe 
oWnAGE 
oWNage 
oWNagE 
oWNaGe 
oWNaGE 
oWNAge 
oWNAgE 
oWNAGe 
oWNAGE 
Ownage 
OwnagE 
OwnaGe 
OwnaGE 
OwnAge 
OwnAgE 
OwnAGe 
OwnAGE 
OwNage 
OwNagE 
OwNaGe 
OwNaGE 
OwNAge 
OwNAgE 
OwNAGe 
OwNAGE 
OWnage 
OWnagE 
OWnaGe 
OWnaGE 
OWnAge 
OWnAgE 
OWnAGe 
OWnAGE 
OWNage 
OWNagE 
OWNaGe 
OWNaGE 
OWNAge 
OWNAgE 
OWNAGe 
OWNAGE 
संबंधित मुद्दे