Utilisation de la récursion pour trouver le mot le plus long dans une phrase (Java)

Question

Pour une affectation, je suis censé trouver le mot le plus long dans une phrase en utilisant la récursivité. J'ai écrit une méthode qui prend les deux premiers mots de la phrase, les compare, puis prend le plus long des deux et compare cela au mot suivant dans le reste de la phrase. Ma logique vérifie, mais la méthode ne fonctionne pas correctement. Je pense qu'il y a un coup de chance qui prend des espaces, et c'est pourquoi cela ne fonctionne pas.

public static String longestWord(String sentence) 
{ 
    if (sentence.indexOf(' ') == -1) {  // IF sentence only has one word 
     return sentence; 
    } 

    String word1 =(sentence.indexOf(" ") != -1)? sentence.substring(0, sentence.indexOf(" ")): 
                sentence.substring(0); 
    String temp = sentence.substring(sentence.indexOf(" ")+1); 


    String word2 = null; 
    String rest = null; 
    if (sentence.indexOf(" ") != -1) { 
    word2 = (temp.indexOf(" ") != -1)? temp.substring(0, temp.indexOf(" ")+1): 
              temp.substring(0); 
    rest = temp.substring(temp.indexOf(" ")+1); 
    } 


    if (word1.length() > word2.length()) { 
     return longestWord(word1 + rest); 

    } 

    if (word2.length() > word1.length()) { 
     return longestWord(word2 + rest); 

    } 

    return sentence; 


} 

Answer 1

Vous avez deux problèmes ici, mais je pense que celui qui vous attrape est que vous définissez rest pour ne pas avoir d'espace au début, mais vous concaténer un mot sur le début de celui-ci. Donc "un renard brun rapide" -> "renard rapide".

En plus de cela, cependant, si les deux mots sont la même longueur puis vous retournez la phrase entière - au contraire, vous devriez faire le dernier if statment une déclaration else et retirer la déclaration finale return.

EDIT: Bien que vous ne voulez probablement pas à jeter ce que vous avez, vous pourriez trouver la solution récursive plus simple si vous inversez la mise au point: au lieu de prendre les deux premiers mots à chaque fois, il suffit de prendre la premier mot et le comparer au mot le plus long du reste:

longestWord(String sentence) { 
    if (sentence.indexOf(' ') == -1) {  // IF sentence only has one word 
     return sentence; 
    } 
    String firstWord = getFirstWord(sentence);//how you're doing it now 
    String rest = getRest(sentence);//Just the sentence without the first word (and first space...) 
    String secondWord = longestWord(rest); 
    return firstWord.length >= secondWord.length ? firstWord : secondWord; 
} 

Answer 2

Il y a une façon simple de le faire de façon récursive: diviser la chaîne en mots, puis faire une invocation récurrente de cette méthode, comme ceci:

string longest(string sentence) { 
    return longestRecursive(sentence.Split(' '), 0, ""); 
} 

string longestRecursive(string[] words, int index, string longestSoFar) { 
    // This should be very easy to implement: 
    // If index == words.Length, longestSoFar is your answer 
    // Check words[0] against longestSoFar, and make a recursive invocation 
} 

Answer 3

Si la phrase est Chaîne.

Fractionnez la phrase à l'aide de String.Split ("");

Stockez le résultat dans un tableau de chaînes.

Utilisez la récursion pour trouver la chaîne la plus longue en utilisant .length.

Answer 4

je le ferais comme

public static String longestWord(String sentence) { 
     return longestWord(sentence, ""); 
    } 

    private static String longestWord(String sentence, String longestWord) { 
     int i = sentence.indexOf(' '); 
     if (i == -1) { 
      return sentence.length() > longestWord.length() ? sentence : longestWord; 
     } 
     longestWord = i > longestWord.length() ? sentence.substring(0, i) : longestWord; 
     sentence = sentence.substring(i + 1); 
     return longestWord(sentence, longestWord); 
    } 

Answer 5

Java ne fait pas l'optimisation des appels de queue, donc cela pourrait facilement exploser la pile. Mais vous avez demandé récursif (et dans une langue avec TCO, c'est pile neutre). Notez qu'il ne construit qu'une seule chaîne.

public static String longestWord(String sentence) { 
    return longestWordHelper(sentence, 0, 0, 0, 0); 
} 

String longestWordHelper(String sentence, 
         int best_len, int best_end, 
         int cur_len, int cur) { 
    if (cur == sentence.length()) 
    if (cur_len > best_len) 
     return sentence.substring(cur_end - cur_len, cur_len); 
    else 
     return sentence.substring(best_end - best_len, best_len); 
    if (isSpace(sentence.charAt(cur))) 
    if (cur_len > best_len) 
     return longestWordHelper(sentence, cur_len, cur, 0, cur + 1); 
    else 
     return longestWordHelper(sentence, best_len, best_end, 0, cur + 1); 
    else 
    return longestWordHelper(sentence, best_len, best_end, cur_len + 1, cur + 1); 
} 

Answer 6

package MujeebWorkspace.sampleprograms; 

class javaMujeeb{  
static String actualstring= "Today is a very good day"; 
static String[] splitstring = actualstring.split(" "); 

public static void main(String [] args){ 
    LongWord(); 
    ShortWord(); } 

public static void LongWord() {  
    String longword = ""; 
    for (int i=0; i<=splitstring.length-1; i++){  
    if (longword.length()<splitstring[i].length()) 
     longword = splitstring[i]; } 
    System.out.println(longword); } 

    public static void ShortWord(){ 
     String shortword = " "; 
     for (int i=0; i<=splitstring.length-1; i++){   
     if (splitstring[i].length()<shortword.length()) 
      shortword = splitstring[i];   }  
     System.out.println(shortword);  } 

}