Java 查找数组中是否存在多个非连续重复项

[c、a、a、b、b、d]、[c、a、b、d、d、a]或[a、a、b、b、c、d、d]应返回false，而[a、a、c、d、b、b]或[a、a、c、b、b、d]应返回true，因为重复项不是连续的

public boolean findNSeqDup(String[] arr) {
    if(arr.length < 4){
        return false;
    }

    boolean isPrevDup = false;
    String prevString = "";
    for (int i = 0; i < arr.length; i++){
        if(arr[i].equals(prevString) && isPrevDup==true){
            System.out.println("true");
            return true;
        }
        else if(arr[i].equals(prevString) && isPrevDup==false){
            isPrevDup = true;
            prevString = "";
        }
        else if(!prevString.equals("") && !arr[i].equals(prevString)){
            prevString = "";
        }
        // for the first condition if the previous string is empty
        else {
            prevString = "";
        }
        prevString = arr[i];
    }
    System.out.println("false");
    return false;
}

public boolean findNSeqDup（字符串[]arr）{
如果（arr.length<4）{
返回false；
}
布尔值isPrevDup=false；
字符串prevString=“”；
对于（int i=0；i

---

上述代码在所有条件下返回true，在这些条件下，它应该返回false（[c，a，a，b，b，d]，[c，a，b，b，d，d，a]或[a，a，b，b，c，d，d]）。我做错了什么？如果使用堆栈或类似的数据结构，这会更容易吗？

您好，您的代码存在多个问题

第一：所有的

prevString=“”赋值被视为无用，因为它们在for块的最后一行被覆盖：
prevString=arr[i]
您应该尝试使用另一个布尔变量来存储最后一个字符是否也是重复的

这里有一个更简单的方法，为什么不从第4个元素开始，将第n个元素与
n-1
th进行比较，将
n-2
th与
n-3
th元素进行比较：

  public boolean findNonConsDup(String[] arr) {
    if(arr.length < 4){
      return false;
    }

    for (int i = 3; i < arr.length; i++) {
      if (arr[i].equals(arr[i-1]) && arr[i-2].equals(arr[i-3])) {
        return true;
      }
    }
    return false;
  }

public boolean findNonConsDup（字符串[]arr）{
如果（arr.length<4）{
返回false；
}
对于（int i=3；i
似乎使用stack/deque来收集连续重复和单个的计数可以帮助解决此任务：

公共静态布尔findNonConsDup（字符串…arr）{
int n=阵列长度；
if（n<4）{
返回false；
}
System.out.println（Arrays.toString（arr）+“：”；//调试打印
Deque freqs=新的ArrayDeque（）；
字符串prev=arr[0]；
int-cnt=1；
intprevfreq；
对于（int i=1；i1 | | cnt>1&&prevFreq==1）{
频率推送（cnt）；
//非连续重复的早期检测
如果（频率大小（）>2）{
int p1=freqs.pop（）；
int p2=freqs.pop（）；
int p3=freqs.pop（）；
//找到的模式：两个副本之间至少有一个分隔符
如果（p1>1&&p2==1&&p3>1）{
返回true；
}else{//还原队列
频率推送（p3）；
频率推送（p2）；
频率推送（p1）；
}
}
}
}
cnt=1；
}否则{
cnt++；
}
prev=arr[i]；
}
prevFreq=freqs.peek（）；
如果（cnt==1&&prevFreq>1 | | cnt>1&&prevFreq==1）{
频率推送（cnt）；
}
System.out.print（freqs+“->”；//调试打印
返回freqs.size（）>2&&freqs.pop（）>1&&freqs.pop（）==1&&freqs.pop（）>1；
}

测试：

publicstaticvoidmain（字符串参数[]）{
系统输出打印LN（findNonConsDup（“c”、“a”、“b”、“d”、“a”、“d”））；
系统输出打印LN（findNonConsDup（“c”、“a”、“b”、“b”、“a”、“d”））；
系统输出打印LN（findNonConsDup（“c”、“a”、“b”、“b”、“b”、“a”、“d”、“d”））；
系统输出打印LN（findNonConsDup（“c”、“a”、“a”、“b”、“b”、“d”））；
系统输出打印LN（findNonConsDup（“c”、“a”、“b”、“b”、“d”、“d”、“a”））；
系统输出打印LN（findNonConsDup（“a”、“a”、“b”、“b”、“c”、“d”、“d”））；
系统输出打印LN（findNonConsDup（“c”、“a”、“a”、“c”、“d”、“b”、“d”、“d”））；
系统输出打印LN（findNonConsDup（“a”、“a”、“c”、“d”、“b”、“d”、“d”））；
系统输出打印LN（findNonConsDup（“a”、“a”、“c”、“b”、“b”、“d”、“d”））；
}

输出

[c, a, b, d, a, d]: [1] -> false
[c, a, b, b, a, d]: [1, 2, 1] -> false
[c, a, b, b, b, a, d, d]: [2, 1, 3, 1] -> true
[c, a, a, b, b, d]: [1, 2, 1] -> false
[c, a, b, b, d, d, a]: [1, 2, 1] -> false
[a, a, b, b, c, d, d]: [2, 1, 2] -> true
[c, a, a, c, d, b, d, d]: [2, 1, 2, 1] -> true
[a, a, c, d, b, d, d]: [2, 1, 2] -> true
[a, a, c, b, b, d, d]: true

嗯<代码>[a，a，c，d，b，b]

有两个重复项（a

a

和a

b

），都与原始项连续，为什么它要返回

true

<代码>[a，b，c，d，a，b]有两个相同的副本，现在是非连续的，因此应该是

真的

，但不是第一个。这当然让我相信我误解了这个要求，但是怎么做呢？请编辑问题并澄清“多个非连续副本”的实际含义。

[a，b，c，d，e，f]或[a，a，b，c，d，e]或[a，a，a，b，c，c]

？在[a，a，c，d，b]中，副本指一对。因此，[a，a，c，d，b，b]返回true，因为重复对a，a后面没有另一个重复对。因此[a，a，c，d，b，b]或[a，a，c，b，b，d]应该返回true。而[c，a，a，b，b，d]中的双复制对a，a后面紧跟着b，b应该返回false。希望这能让事情变得更清楚。@Eritrean[a，b，c，d，e，f]应该返回false，因为没有重复项存在，[a，a，b，c，d，e]应该返回false，因为问题要求存在多个连续的重复项（其中重复项表示一对字母）。[a，a，a，b，c，c]将返回true，因为a，a是重复对，c，c也是重复对，它们不是连续的。@SiddheshPatil下面是我的答案