只打印给定字符串中的 3 个连续字符

Question

我只想从给定的字符串中打印 3 个相同的连续字符，如下所示 如果输入是：

"aasssfddddvvv"

那么我应该得到输出作为输出：

sss
vvv 
count=2

这是我的要求，请帮助我。

我的代码：

import java.util.Scanner;

class Test {

    public static void main(String args[]) {
        Scanner scan = new Scanner(System.in);
        System.out.println("Enter the String: ");
        char s[] = scan.nextLine().toCharArray();

        for (int i = 0; i < s.length - 1; i++) {

            if (s[i] == s[i + 1] && s[i] == s[i + 2] && s[i] == s[i + 3]) {
                System.out.println(s[i]);

            }
        }
        scan.close();
    }
}

Answer 1

此答案与 OP 中使用的更手动的方法不同。但是，使用 Java 中的正则表达式模式匹配器处理起来相当简单。我们可以匹配模式(.)\\2*，以捕获所有相似字母组。然后，只需打印出仅以 3 出现的组。

String line = "aasssfddddvvv";
String pattern = "((.)\\2*)";
Pattern r = Pattern.compile(pattern);
Matcher m = r.matcher(line);

while (m.find()) {
    if (m.group(1).length() == 3) {
        System.out.println(m.group(1));
    }
}

sss
vvv

Demo

Answer 2

第一个问题是，您尝试在 for 中达到数组的 lenght+2th 索引，这是不可能的。

假设字符串长度为 5

0:  0 1 2
1:  1 2 3
2:  2 3 4
3:  3 4 (5)
4:  4 **(5) (6)**

如您所见，您尝试到达不属于字符串的 5。所以试试

for (int i = 0; i < s.length - 2; i++)

而不是

for (int i = 0; i < s.length - 1; i++)

提示：你可以从错误中得到这个。

线程“主”java.lang.ArrayIndexOutOfBoundsException 中的异常： 13

它说你试图达到你不能达到的索引。

第二个问题你在 if 条件下检查 4 个字符。使用：

if (s[i] == s[i + 1] && s[i] == s[i + 2])

而不是

if (s[i] == s[i + 1] && s[i] == s[i + 2] && s[i] == s[i + 3])

Answer 3

首先遍历您的 char[] 数组。然后，在您的 if 声明中，

• 首先确保数组中剩余的字符超过 2 个。
• 然后将s[i]与下一个字符（s[i+1]）和下一个字符（s[i+2]）进行比较

---

替换这部分代码，

for (int i = 0; i < s.length; i++) {
    if (i < s.length - 2 && s[i] == s[i + 1] && s[i] == s[i + 2]) {
        System.out.println(s[i]);
    }
}

Answer 4

用这个替换你的代码的主要逻辑。 这里我们检查是否有只有 3 个重复字符。通过确保第四个字符不同。

int count=0;
for (int i = 0; i < s.length - 3; i++) {
    if (s[i] == s[i + 1] && s[i] == s[i + 2] && s[i] != s[i + 3]) {
        System.out.println(s[i]+s[i]+s[i]);
        count++;
    }
}
System.out.println("count="+count);

Answer 5

import java.util.Scanner;
class Test {

    public static void main(String args[]) {
        Scanner scan = new Scanner(System.in);
        System.out.println("Enter the String: ");
        char s[] = scan.nextLine().toCharArray();
        int count=0;

        for (int i = 0; i < s.length - 3; i++) {

            if (s[i] == s[i + 1] && s[i] == s[i + 2] && s[i]!=s[i + 3]) {
                System.out.println(s[i]+s[i]+s[i]);
                count++;
            }
        }
        if(s[s.length - 3] == s[s.length - 2] && s[s.length - 3] == s[s.length - 1]){
            System.out.println(s[s.length]+s[s.length]+s[s.length]);
            count++;
        }
        scan.close();
        System.out.println(count);
    }
}

Answer 6

您无法检查.cells i + 2 和 i + 3，因为当您达到 i = 长度 -2 时，您将越过数组边界， 您应该计算序列并检查长度是否足够，如果足够打印，另外，在您的示例中，您正在比较 4 个单元格，因此长度将为 4 而不是 3，在 1 中开始 seq，因为当您读取单个字符时它是 1 的序列：

import java.util.Scanner;

class Test {

    public static void main(String args[]) {
        Scanner scan = new Scanner(System.in);
        System.out.println("Enter the String: ");
        char s[] = scan.nextLine().toCharArray();
        int seqLen = 3;
        int cnt = 1;
        for (int i = 1; i < s.length; i++) {

            if (s[i] == s[i - 1]) {
                cnt++;
             }
            if((cnt==seqLen)&&((s[i] !=s[i - 1] || i == s.length)){
                 if(cnt == seqLen)
                 {
                     for(int j= 0; j<seqLen; j++)
                     {
                         System.out.println(s[i - 1]);
                      }
                 }
                 cnt=1;
            }          
        }
    scan.close();
    }
}

Answer 7

您似乎只需要严格计算 3 个连续字符。如果是这种情况，即使修复了代码中的问题（不改变整体逻辑），它也会打印两次ddd。这是固定代码的输出：

sss 
ddd
ddd
vvv
count=4

我所说的固定代码的意思是处理这些问题

1. 比较过长，修复：删除&& s[i] == s[i + 3]。
2. 条件需要调整为i < s.length - 2
3. 只打印一个字符（可能不是真正的问题）
4. 每次找到匹配项时添加一个计数器

这里是固定代码（记住这仍然不能产生你想要的正确输出）

int occurence_count = 0;
for (int i = 0; i < s.length - 2; i++) {

    if (s[i] == s[i + 1] && s[i] == s[i + 2]) {
        occurence_count++;
        System.out.println(s[i]);
    }
}
System.out.println("count=" + occurence_count);

一个逻辑变化是有一个单独的计数器来计算连续字符和一个变量来记住最后一个字符是什么。

int char_count = 0;
char last_char = '!';  

基本思想是遍历我们的字符串，如果相同则将char_count 加一，如果不同则重置。我们还需要使用您不打算用作输入的字符对其进行初始化，例如!。

由于我们要遍历整个字符串，因此 for 循环条件需要使用 i < s.length 进行到最后。

当我们重置时（当检测到不同的字符时），我们还想检查前一个字符是否有char_count=3。如果匹配，则增加occurence_count。我们还需要在 for 循环之后再执行一次，因为在输入字符串末尾发生的连续检查可能不会发生。代码如下：

    int occurence_count = 0;
    int char_count = 0;
    char last_char = '!';  
    for (int i = 0; i < s.length; i++) {
        if (s[i] != last_char) {                
            if (char_count == 3) {
                occurence_count++;
                System.out.println(""+last_char+last_char+last_char);                   
            }               
            last_char = s[i];
            char_count = 0;
        }

        char_count++;

    }
    if (char_count == 3) {
        occurence_count++;
        System.out.println(""+last_char+last_char+last_char);                   
    }

    System.out.println("count=" + occurence_count);