如何在java中返回字符串中最長的字符序列？

Question

以下是我最終做的，但我沒有找到正確的答案。

示例 - 如果序列爲「hellloo」，則輸出爲「lll」。請告訴我什麼是錯的？

public class LongestSequenceOfChar { 
    static String testcase1="hellloo"; 

    public static void main(String[] args) { 
     LongestSequenceOfChar test = new LongestSequenceOfChar(); 
     String result = test.longestSequenceOfChar(testcase1); 
     System.out.println(result); 
    } 
    public String longestSequenceOfChar(String str){ 
     String result=""; 
     for(int i=0;i<str.length();i++){ 
      char ch=str.charAt(i); 
      for(int j=i+1;j<str.length();j++){ 
       char ch1=str.charAt(j); 
       if(ch!=ch1){ 
        continue; 
       } 
       result+=ch; 
      } 
     } 
     return result; 
    } 
} 

Answer 1

如果有三個'l'，你只需要添加兩個，下一步是兩個'l'，然後添加其中一個。然後與兩個'o'一樣，你要添加一個。你只需要清除結果字符串，當你走到下一個字母，並保存結果之前，另一個變量，但只有當它是更長！

public String longestSequenceOfChar(String str){ 
    String interimresult=""; 
    String result="";    //final result 
    for(int i=0;i<str.length();i++){ 
     char ch=str.charAt(i); 
     interimresult += ch;  //add the letter once 
     for(int j=i+1;j<str.length();j++){ 
      char ch1=str.charAt(j); 
      if(ch!=ch1){ 
       break; 
      } 
      interimresult +=ch; 
     } 
     if(interimresult.length()>result.length())//store the result if it is longer 
      result = interimresult; 
     interimresult = "";     //clear to continue with the next letter 
    } 
    return result; 
} 

Answer 2

您應該有一個計數器來計算現在最長的序列號。當找到更長的序列時，應該重置result並相應地更新計數器。

但是，你可以有更好的解決方案：

• 有大小26（英文字母的大小）的數組。現在你迭代字符串，並且在其中每個char你在助手數組的相應單元格中加1。
• 使用HashMap具有char作爲關鍵，它表現爲值數量。如果它是一個新的char，你只需把它與0值，如果它存在，你增加現有的值。

提示：使用調試器，它可以挽救你的生命。

Answer 3

1. Create a HashMap<Character,Integer>.. Integer-->count 
2. Start from the beginning of your String.. For each character, check if it is already present in the hashmap 
    a. If Yes, just increment the count 
    b. if No, then add the character as key to the Map and set its count value to 1. 

Answer 4

這裏是一個解決方案：

public String longestSequenceOfChar(String str) { 
    String result = ""; 

    for (int i = 0; i < str.length(); i++) { 
     int j = i; 
     while(j < str.length() && str.charAt(j) == str.charAt(i)) { 
      j++; 
     } 

     // If this one is longer than previous, then asign it to result. 
     if(j - i > result.length()) { 
      result = str.substring(i, j); 
     } 
    } 
    return result; 
} 

Answer 5

嘗試......

public class HelloWorld { 

    public static void main(String[] args) { 
     System.out.println(maxLen(null)); 
     System.out.println(maxLen("")); 
     System.out.println(maxLen("a")); 
     System.out.println(maxLen("aa")); 
     System.out.println(maxLen("abcddd")); 
     System.out.println(maxLen("abcd")); 
     System.out.println(maxLen("aabbba")); 
    } 

    public static String maxLen(String input) { 
     // Avoid NPEs 
     if (input == null) { 
      return null; 
     } 
     int maxLen = 0; 
     int tempLen = 0; 
     char prevChar = 0; 
     char c = 0; 
     char repeatChar = 0; 
     for (int i = 0; i < input.length(); i++) { 
      c = input.charAt(i); 
      if (c == prevChar) { 
       tempLen++; 
       if (tempLen > maxLen) 
        repeatChar = c; 
      } else { 
       maxLen = (tempLen > maxLen) ? tempLen : maxLen; 
       prevChar = c; 
       tempLen = 1; 
      } 
     } 
     maxLen = (tempLen > maxLen) ? tempLen : maxLen; 
     if (maxLen == 0 || maxLen == 1) 
      return "no sequence found"; 
     else { 
      String str = ""; 
      for (int i = 1; i <= maxLen; i++) 
       str += String.valueOf(repeatChar); 
      return str; 
     } 
    } 
} 

這將通過所有的測試案例。

Answer 6

這可以使用HashMap輕鬆解決。結帳此示例代碼：

import java.util.Collections; 
import java.util.HashMap; 
import java.util.Map; 
import java.util.Map.Entry; 

public class MaximumOccuringCharUsingHashMap { 
    public static void main(String[] args) { 
    String test = "test samples"; 
    MaximumOccuringCharUsingHashMap mc = 
     new MaximumOccuringCharUsingHashMap(); 
    System.out.println(mc.findMaximunOccurenceCharacter(test)); 
} 
    char findMaximunOccurenceCharacter(String input){ 
     Map<Character, Integer> countHash = 
      new HashMap<Character, Integer>(); 
     for(int i=0; i<input.length() ;i++){ 
      char currentChar = input.charAt(i); 
      if(countHash.get(currentChar)==null){ 
       countHash.put(currentChar, 1); 
      }else{ 
       countHash. 
       put(currentChar, countHash.get(currentChar)+1); 
      } 
     } 

     int max = Collections.max(countHash.values()); 

     char maxCharacter =0; 
     for(Entry<Character, Integer> entry :countHash.entrySet()){ 
      if(entry.getValue() == max){ 
       maxCharacter = entry.getKey(); 
      } 
     } 
     return maxCharacter; 
    } 
} 

上面的代碼將打印s作爲輸出，這是發生在給定的字符串中的最大次數。