Question

我是java的新手。我想在输入字符数组中找到最长的顺序相同的字符数组。例如，这个字符数组bddfDDDffkl，最长的是DDD，而这一个：rttttDDddjkl，最长的是tttt。我使用以下代码来处理这个问题。但是，我想改进我的代码，例如，如果有两个相同长度的数组（例如rtttgHHH，有两个最长：ttt和HHH），如何解决这个问题？

提前致谢。

我的以下代码：

public class SeqSameChar {
public static void main (String[] args) {
   int subLength = 0;
   Scanner sc = new Scanner(System.in);
   String[] num = null;
   num = sc.nextLine().split(" ");
   String[] number = new String[num.length];

   for(int i = 0; i< number.length;i++) {
       number[i] = String.valueOf(num[i]);
   }

   subLength =length(number,num.length);  
   System.out.println(subLength);

   for(int i = index; i < index+subLength; i++) {
       System.out.print(number[i]);
   }

   System.out.println(c==c1); 
 }


   public static int index;  
      //to calculate the longest contiguous increasing sequence  
       public static int length(String[] A,int size){  
       if(size<=0)return 0;  
       int res=1;  
       int current=1;  
       for(int i=1;i<size;i++){  
           if(A[i].equals(A[i-1])){  
               current++;  
           }  
           else{  
               if(current>res){  
                   index=i-current;  
                   res=current;  
               }  
               current=1;  
           }  
       }  
      return res;      
     }      
   }

Answer 1

此算法可以完美地适用于您想要开发的内容：

在此之前，让我明确指出，如果您要检查 2个不同字符的重复次数相同，则必须在for loop中运行reverse识别第二个字符。所以if 第二个字符与第一个字符不同，如果它的重复次数相同，那么print < em>两个字符或else，只是print您在第一个for loop找到的单个字符，因为这两个字符< / em>将会是相同的。

public static void main(String[] args) { Scanner sc = new Scanner(System.in); System.out.println("Enter String 1: "); String A1 = sc.nextLine(); MaxRepeat(A1); } public static void MaxRepeat(String A) { int count = 1; int max1 = 1; char mostrepeated1 = ' '; for(int i = 0; i < A.length()-1;i++) { char number = A.charAt(i); if(number == A.charAt(i+1)) { count++; if(count>max1) { max1 = count; mostrepeated1 = number; } continue; } count = 1; } count = 1; int max2 = 1; char mostrepeated2 = ' '; for(int i = A.length()-1; i>0; i--) { char number = A.charAt(i); if(number == A.charAt(i-1)) { count++; if(count>max2) { max2 = count; mostrepeated2 = number; } continue; } count = 1; } if((max1==max2) && (mostrepeated1==mostrepeated2)) { System.out.println("Most Consecutively repeated character is: " + mostrepeated1 + " and is repeated " + max1 + " times."); } else if((max1==max2) && (mostrepeated1!=mostrepeated2)) { System.out.println("Most continously repeated characters are: " + mostrepeated1 + " and " + mostrepeated2 + " and they are repeated " + max1 + " times"); } }

Answer 2

我会为你解决这个问题的Scala实现。

这是自动测试（采用ScalaTest的BDD风格）

import org.scalatest._
class RichStringSpec extends FlatSpec with MustMatchers {
  "A rich string" should "find the longest run of consecutive characters" in {
    import Example._
    "abceedd".longestRun mustBe Set("ee", "dd")
    "aeebceeedd".longestRun mustBe Set("eee")
    "aaaaaaa".longestRun mustBe Set("aaaaaaa")
    "abcdefgh".longestRun mustBe empty
  }
}

以下是命令式样式实现，具有嵌套循环和可变变量，正如您通常在Java或C ++中选择的那样：

object Example {
  implicit class RichString(string: String) {
    def longestRun: Set[String] = {
      val chunks = mutable.Set.empty[String]
      val ilen = string.length
      var gmax = 0
      for ((ch, curr) <- string.zipWithIndex) {
        val chunk = mutable.ListBuffer(ch)
        var next = curr + 1
        while (next < ilen && string(next) == ch) {
          chunk += string(next)
          next = next + 1
        }
        gmax = chunk.length max gmax
        if (gmax > 1) chunks += chunk.mkString
      }
      chunks.toSet.filter( _.length == gmax )
    }
  }
}

以下是一个函数式实现，因此没有变量，没有循环但是带有结果累加器的尾递归和模式匹配将每个字符与下一个字符进行比较（疯狂！不是吗？）：

object Example {
  implicit class RichString(string: String) {
    def longestRun: Set[String] = {
      def recurse(chars: String, chunk: mutable.ListBuffer[Char], chunks: mutable.Set[String]): Set[String] = {
        chars.toList match {
          case List(x, y, _*) if (x == y) =>
            recurse(
              chars.tail, 
              if (chunk.isEmpty) chunk ++= List(x, y) else chunk += y, 
              chunks
            )
          case Nil =>
            // terminate recursion
            chunks.toSet
          case _ => // x != y
            recurse(
              chars.tail,
              chunk = mutable.ListBuffer(), 
              chunks += chunk.mkString
            )
        }
      }
      val chunks = recurse(string, mutable.ListBuffer(), mutable.Set.empty[String])
      val max = chunks.map(_.length).max
      if (max > 0) chunks.filter( _.length == max ) else Set()
    }
  }
}

例如，对于给定的"aeebceeedd"字符串，上述两种实现都将构建以下一组块（重复字符）

Set("ee", "eee", "dd")

并且他们将过滤那些具有最大长度的块（结果为"eee"）。

Java：找到最长的顺序相同的字符数组

2 个答案: