Question

我目前正在编写有趣的编码问题，我刚刚解决了这个问题。

＆＃34;给定一个字符串，考虑由字符串的前N个字符组成的前缀字符串。该前缀字符串是否出现在字符串中的其他位置？假设字符串不为空且N在1..str.length（）范围内。 prefixAgain（＆＃34; abXYabc＆＃34;，1）→true prefixAgain（＆＃34; abXYabc＆＃34;，2）→true prefixAgain（＆＃34; abXYabc＆＃34;， 3）→false＆＃34; http://codingbat.com/prob/p136417

我的解决方案是：

public boolean prefixAgain(String str, int n) {
    return (str.replaceFirst(Character.toString(str.charAt(n-1)),"").contains(Character.toString(str.charAt(n-1))));
}

现在，我在写这段代码时并没有真正理解这个问题而且我只想找到指定索引的字符的出现和使用.contains（）方法忽略它之前的字符。所以我真的没有找到问题所指示的前缀。我提交后发现了我的错误。但是，这个解决方案通过了练习。当我用自己的输入测试它时，例如

prefixAgain("abcccccbx", 2);

它返回true而不是false。所以我错过了为什么codingbat接受了我的解决方案，尽管它完全错了？

Answer 1

public boolean prefixAgain(String str, int n)    
    String prefix = str.substring(0, n);
    int length = str.length();

    for (int i = n; i <= length - n; i++) {
        if (prefix.equals(str.substring(i, i + n))) {
            return true;
        }
    }
    return false;
}

Answer 2

重述您的策略（算法）：字符串中的前N个字符是否出现在字符串中的任何其他位置？最简单的解决方案是在原始字符串的第2个字符到最后字符中查找该字符串。如下所示（即使有人给你一个假设，也要检查！）

public boolean prefixAgain(String str, int n) {
    boolean result = false;
    if (n < str.length() && 
            (str.substring(1)).indexOf(str.substring(0,n)) > -1
            ) {
        result = true;
    }
    return result;
}

Answer 3

也许我错过了一些东西，但这似乎是正确和优雅的：

public boolean prefixAgain(String str, int n) {
    if(str.substring(n).contains(str.substring(0, n))) return true;

    return false;
}

如果n> str.length（）返回false。

Answer 4

public boolean prefixAgain(String str, int n) {
  int l= str.length();
  String test = str.substring(0,n);
  boolean flag = false;
  str = str.substring(1);
  l= str.length();
  for(int i=0;i<l;i++){
    if((i+n <= l)){
      if((str.substring(i,n+i).equals(test)))
      return true;
    }
  }
  return flag;
}

Answer 5

这是我的（考虑到尚未引入indexOf（））：

public boolean prefixAgain(String str, int n) {
  for (int i=1; i <= str.length()-n; i++)
    if (str.substring(i, i+n).equals(str.substring(0, n)))
      return true;
  return false;
}

但我发现这个解决方案到目前为止最优雅：

public boolean prefixAgain(String str, int n) {
  return (str.indexOf(str.substring(0, n), 1) != -1);
}

Answer 6

public boolean prefixAgain(String str, int n) {
  return str.substring(n).contains(str.substring(0,n));
}

只查看str的子字符串中的prefix(str.substring(0,n))而没有前缀，这意味着从n开始，即（str.substring（n））。

Answer 7

public boolean prefixAgain（String str，int n）{

return（str.substring（n）.contains（str.substring（0，n）））; }

Answer 8

这已经基本上发布了，但是我稍微修改了它，使它非常容易阅读，而不是去一个班轮。

public boolean prefixAgain(String str, int n) {
  String prefix = str.substring(0, n);
  String afterPrefix = str.substring(n);
  return afterPrefix.contains(prefix);
}

首先，我们获取前缀，该前缀将从索引零开始，并且不包括n。 afterPrefix只是从n开始的字符串的其余部分。最后，返回前缀后面的所有内容是否都包含前缀。

Answer 9

public boolean prefixAgain(String str, int n) {
    String pre = str.substring(0, n);

    for (int i=n; i<str.length()-n+1; i++)
    {
        if (str.substring(i, i+n).equals(pre))
           return true;
    }

    return false;
}

Answer 10

解决方案，不是最快但很明确。

public boolean prefixAgain(String str, int n) {
  String prefix = str.substring(0,n); // prefix String
  int index = str.indexOf(prefix); //first loc of prefix
  if(str.lastIndexOf(prefix) > index){ //see if it appears again
  return true; 
  }
  else return false; //if we get here, doesn't appear again, false
}

编码中的PrefixAgain解决方案

10 个答案: