Java 计数和所有字符都相同的最大字符串的起始索引

在给定的字符串中，我想找出由相同字符组成的最大子字符串的起始索引，并计算该子字符串在主字符串中出现的次数

例如：“aaakkkbkkk” 在这种情况下，子字符串“kkk”的计数为5，起始位置为9

到目前为止，我的代码是：

String str = "aaakkkkbbkkkkk";
int count = 0;
//converting string into character array
char[] vals = str.toCharArray(); 

for(int i=0; i < vals.length; ){

   for(int j=i+1; j<vals.length; j++){
       //if value match then increment counter
       if(vals[i]== str.charAt(j)){
           counter++;
       }
       //else break from inner loop 
       break; //break from inner loop
   }
   //assign the index value of j to the i to start with new substring
   i = vals.indexOf(j);
}

String str=“aaakkkbkk”；
整数计数=0；
//将字符串转换为字符数组
char[]vals=str.toCharArray（）；
对于（int i=0；i对于（int j=i+1；j1），使用单独的变量存储子字符串的第一次出现

2.制作将存储在最后一个序列长度的其他计数器

3.在新序列开始时重置计数器

String str = "aaakkkkbbkkkkk";
int count = 0;
int firstOccurence = 0;
int prevSequenceLength = 0;
//converting string into character array
char[] vals = str.toCharArray(); 

for(int i=0; i < vals.length; ){

   for(int j=i+1; j<vals.length; j++){
       //if value match then increment counter
       if(vals[i]== str.charAt(j)){
           counter++;
       }
       else
      {
       //set the prevSequenceLength to counter value if it is less than counter value
       if(prevSequenceLength<counter)
        {
          prevSequenceLength=counter;
         //make firstOccurence to  j - counter
         firstOccurence = j-counter;
       }

       //first reset the counter to 0;
       counter = 0;

       //else break from inner loop 
       break; //break from inner loop
   }
   //assign the index value of j to the i to start with new substring
   i = vals.indexOf(j);
}

String str=“aaakkkbkk”；
整数计数=0；
int firstoccurrence=0；
int-prevSequenceLength=0；
//将字符串转换为字符数组
char[]vals=str.toCharArray（）；
对于（int i=0；i
class Sample {
    static int max = 0, maxStartPos = -1;

    public static void main(String[] args) {
        search("aaakkkkbbkkkkk".toCharArray());
        System.out.println(String.format("max len: %d, start pos: %d", max, maxStartPos));

        search("xxxxxh".toCharArray());
        System.out.println(String.format("max len: %d, start pos: %d", max, maxStartPos));

        search("hxxxxxhyyyyyyh".toCharArray());
        System.out.println(String.format("max len: %d, start pos: %d", max, maxStartPos));
    }

    private static void search(char[] chars) {
        max = 0; maxStartPos = 0;

        int len = 0, startPos = 0;
        char start = chars[0];
        for (int i = 0; i < chars.length; i++) {
            if (chars[i] == start) {
                len++;
            } else {
                if (len > max) {
                    updateMaxResults(len, startPos);
                }
                startPos = i;
                len = 1;
                start = chars[i];
            }
        }
        if (len > max) {
            updateMaxResults(len, startPos);
        }
    }

    private static void updateMaxResults(int len, int startPos) {
        max = len;
        maxStartPos = startPos;
    }
}

类示例{
静态int max=0，maxStartPos=-1；
公共静态void main（字符串[]args）{
搜索（“aaakkkbkkk.toCharArray（））；
System.out.println（String.format（“max len:%d，start pos:%d”，max，maxStartPos））；
搜索（“xxxxx h”.toCharArray（））；
System.out.println（String.format（“max len:%d，start pos:%d”，max，maxStartPos））；
搜索（“hxxxxxhyyyyyyyh.toCharArray（））；
System.out.println（String.format（“max len:%d，start pos:%d”，max，maxStartPos））；
}
专用静态无效搜索（字符[]字符）{
max=0；maxStartPos=0；
int len=0，startPos=0；
char start=chars[0]；
for（int i=0；i最大值）{
更新MaxResults（len、startPos）；
}
startPos=i；
len=1；
开始=字符[i]；
}
}
如果（长度>最大值）{
更新MaxResults（len、startPos）；
}
}
私有静态void updateMaxResults（int len、int startPos）{
max=len；
maxStartPos=startPos；
}
}
我想这会对你有所帮助，，
我知道它很小，很容易看到每一个人

    public static void main(String[] args) {


        String str = "aaakkkkkkkbbkkkkk";

        char[] var = str.toCharArray();

        for(int i=0; i<var.length;i++)
            System.out.print(" "+var[i]);


        int final_index=0; // this is for final index what we want

        int max_size=0; // for maximum no. of time the same char repeats continiously..
        int size=0; // this for finding size of sub string..
        char pre_char=var[0]; // pre_char is used check with present char in the array where the i position is shifted..



        // here is the loop..
        // we don't need much loops to this
        // while we are reading , the comparison is also done parallely.. 
        for(int i=1;i<var.length;i++) // here i starts from 1 because 0th char is shfted into pre_char 
            //and now comparion is starts from next char ie from 1th position
        {
//          System.out.println("i=="+i+" size "+size+"  prechar== "+pre_char+ "  var[i] ="+var[i]+" max size=="+max_size);
//          System.out.println("..........................");
            if(pre_char==var[i]) // here condition is checking. if its same with previous char, its means same char is occur again..
            {
                size+=1;
            }else{ // else means the sub string is has different char 
                if(max_size<size) // now check for whether any maximum size is occured priviously or not..
                {
                    max_size=size;
                    final_index=i-size;
                }
                size=0;
            }
            pre_char=var[i];
        }

        // now this for final 
        // its means if the max sub string is at the ending position, the above for loop breaks at the last element 
        // in this case we check if the last sub string is max or not..

        if(max_size<size)
        {
            max_size=size;
            final_index=var.length-size;
        }
        // then this is the final what we wana,,,,, 
        System.out.print("Max size is "+(max_size+1)+"  index is "+final_index);



    }

publicstaticvoidmain（字符串[]args）{
String str=“aaakkkkbkkk”；
char[]var=str.toCharArray（）；
对于（int i=0；i此解决方案只找到一个可能的子字符串，可能有几个子字符串具有相同的最大重复字符数。因此，我的解决方案将返回一个列表

代码如下：

导入java.util.List；
导入java.util.ArrayList

公共类子串{

public static void main(String[] args) {

    String a1 = "12311m22n33";

    char[] arrays = (a1+"\n").toCharArray();


    //value is char +"_" +  start
    List<String[]> lists = new ArrayList<>();

    int len = 0;
    int start = -1;
    char prev = '\n';
    int position= -1;
    int maxLen = 0;
    for (char a: arrays) {
        position++;
        if (a != prev) {
            if (len > maxLen ) {
                lists.clear();  
                String[] sq = {prev+"", start+""};
                lists.add(sq);
                maxLen = len;

            } else if ( len == maxLen && len != 0) {
                String[] sq = {prev+"", start+""};
                lists.add(sq);
            }

            prev = a;
            len = 1;
            start = position;

        } else {
            len++;
        }
    }


    for(String[] a: lists) {

        String s = a[0];
        String st = a[1];
        System.out.println("The longest length: " + maxLen + " is char: " + s + " start at : " + st);
    }

}

publicstaticvoidmain（字符串[]args）{
字符串a1=“12311m22n33”；
字符[]数组=（a1+“\n”）.toCharArray（）；
//值为char+“”+start
List lists=新建ArrayList（）；
int len=0；
int start=-1；
char prev='\n'；
int位置=-1；
int maxLen=0；
for（字符a：数组）{
位置++；
如果（a！=上一个）{
如果（len>maxLen）{
lists.clear（）；
字符串[]sq={prev+“”，start+“”}；
列表。添加（sq）；
maxLen=len；
}else如果（len==maxLen&&len！=0）{
字符串[]sq={prev+“”，start+“”}；
列表。添加（sq）；
}
prev=a；
len=1；
开始=位置；
}否则{
len++；
}
}
对于（字符串[]a:列表）{
字符串s=a[0]；
字符串st=a[1]；
System.out.println（“最长长度：“+maxLen+”是字符：“+s+”起始于：“+st”）；
}
}

}

//此示例字符串的输出为：
最长长度：2是字符：1，从：3开始
最长的长度：2是字符：2，从：6开始
最长的长度：2是字符：3从：9开始让我给点时间来分析你的代码。一旦我满意了，我会给你打分。谢谢尼古拉。结果是：max len:5，start pos:9 max len:5，start pos:0 max len:6，start pos:7我只需要：max len:5，start pos:9。这只是一系列测试来证明代码可以处理输入中最长的子串：在输入开始时，在中间开始，在结尾处。谢谢。如果您在上面加上注释，我将非常高兴。我正在学习编程基础。您的注释代码将被添加。好的，我用注释改变我的答案来理解逻辑……@ Devendra Singhi认为评论是超过实际代码..@Devendra Singh