Java 查找两个候选字符串列表之间的交集

我编写了以下

Java

代码，以查找

Java

中

字符串的
前缀和
后缀之间的交集

// you can also use imports, for example:
// import java.math.*;
import java.util.*;
class Solution {
    public int max_prefix_suffix(String S) {
        if (S.length() == 0) {
            return 1;
        }
        // prefix candidates
        Vector<String> prefix = new Vector<String>();
        // suffix candidates
        Vector<String> suffix = new Vector<String>();
        // will tell me the difference
        Set<String> set = new HashSet<String>();

        int size = S.length();
        for (int i = 0; i < size; i++) {
            String candidate = getPrefix(S, i);
            // System.out.println( candidate );
            prefix.add(candidate);
        }

        for (int i = size; i >= 0; i--) {
            String candidate = getSuffix(S, i);
            // System.out.println( candidate );
            suffix.add(candidate);
        }

        int p = prefix.size();
        int s = suffix.size();
        for (int i = 0; i < p; i++) {
            set.add(prefix.get(i));
        }
        for (int i = 0; i < s; i++) {
            set.add(suffix.get(i));
        }

        System.out.println("set: " + set.size());
        System.out.println("P: " + p + " S: " + s);
        int max = (p + s) - set.size();
        return max;
    }

    // codility
    // y t i l i d o c
    public String getSuffix(String S, int index) {
        String suffix = "";
        int size = S.length();
        for (int i = size - 1; i >= index; i--) {
            suffix += S.charAt(i);
        }

        return suffix;
    }

    public String getPrefix(String S, int index) {
        String prefix = "";
        for (int i = 0; i <= index; i++) {
            prefix += S.charAt(i);
        }

        return prefix;
    }

    public static void main(String[] args) {
        Solution sol = new Solution();
        String t1 = "";
        String t2 = "abbabba";
        String t3 = "codility";

        System.out.println(sol.max_prefix_suffix(t1));
        System.out.println(sol.max_prefix_suffix(t2));
        System.out.println(sol.max_prefix_suffix(t3));

        System.exit(0);
    }
}

预期值为：

1, 4, 0

我的想法是生成
前缀
候选者并将其推入向量，然后找到
后缀
候选者并将其推入
向量
，最后将两个
向量
推入
集合
，然后计算差值。但是，我得到了
1、7和0
。有人能帮我找出我做错了什么吗？
我会把你的方法写如下：

public int max_prefix_suffix(String s) {
    final int len = s.length();
    if (len == 0) {
        return 1; // there's some dispute about this in the comments to your post
    }
    int count = 0;
    for (int i = 1; i <= len; ++i) {
        final String prefix = s.substring(0, i);
        final String suffix = s.substring(len - i, len);
        if (prefix.equals(suffix)) {
            ++count;
        }
    }
    return count;
}

我看到@ted Hop的代码很好。。
问题指定返回给定字符串的后缀和前缀中匹配字符的最大数量，这是一个适当的子集。因此，此最大值不考虑整个字符串

例如，“abba”，前缀和后缀可以有abba（前4个字符）-abba（后4个字符），因此长度为4
编码能力，前缀（c，co，cod，codi，co…），sufix（y，ty，ity，ty…），它们都不相同。
因此这里的长度是0

通过修改此处的计数

if (prefix.equals(suffix)) {
    ++count;
}

与

我们得到了最大长度。
但这能在O（n）。。string equals的内置函数，我相信将取O（n），因此总体复杂性为O（n2）…
我将使用此代码

public static int max_prefix_suffix(String S)
{
    if (S == null)
        return -1;
    Set<String> set = new HashSet<String>();
    int len = S.length();
    StringBuilder builder = new StringBuilder();
    for (int i = 0; i < len - 1; i++)
    {
        builder.append(S.charAt(i));
        set.add(builder.toString());
    }
    int max = 0;
    for (int i = 1; i < len; i++)
    {
        String suffix = S.substring(i, len);
        if (set.contains(suffix))
        {
            int suffLen = suffix.length();
            if (suffLen > max)
                max = suffLen;
        }
    }
    return max;
}

公共静态int max_前缀_后缀（字符串S）
{
如果（S==null）
返回-1；
Set=newhashset（）；
int len=S.length（）；
StringBuilder=新的StringBuilder（）；
对于（int i=0；imax）
最大值=萨夫伦；
}
}
返回最大值；
}
@ravi.zombie
如果您需要O（n）的长度，则只需更改Ted的代码，如下所示：

int max =0;
for (int i = 1; i <= len-1; ++i) {
    final String prefix = s.substring(0, i);
    final String suffix = s.substring(len - i, len);
    if (prefix.equals(suffix) && max < i) {
        max =i;
}
    return max;
}

int max=0；
对于（int i=1；我有点不相关，但请看：学生和
Vector
？？课程笔记是否更新过？（您永远不应该使用
Vector
-它已损坏！）“Abba”是回文，所以每个前缀都是后缀。为什么期望值不是7？@NullUserException我找到了我的代码的修复方法，但这不是最终的解决方案…而且，你知道Java有一个方法，对吧？而且
Set
确实有一个方法？我看到很多轮子在你的代码中被重新发明…它返回
1,7,0
inst
1,4,0
的ead如果不是4，那么3，即“a”、“abba”和“abba”@Arham你是对的……3是正确的，但是答案返回
1,3,1
@Arham-如果OP想将前缀与后缀的反面进行比较（就像他原来的代码那样），那么答案应该是7。否则，答案应该是3。（如果OP也总是希望将空字符串作为前缀/后缀，则仅为4，但最后一个数字应为1，而不是0。）@philippe；整个字符串既是前缀又是后缀，因此至少有一个匹配项。您可以将其排除在外，这样您就只能有正确的后缀和前缀。请参阅：
if (prefix.equals(suffix)) {
    count = prefix.length();// or suffix.length()
}

public static int max_prefix_suffix(String S)
{
    if (S == null)
        return -1;
    Set<String> set = new HashSet<String>();
    int len = S.length();
    StringBuilder builder = new StringBuilder();
    for (int i = 0; i < len - 1; i++)
    {
        builder.append(S.charAt(i));
        set.add(builder.toString());
    }
    int max = 0;
    for (int i = 1; i < len; i++)
    {
        String suffix = S.substring(i, len);
        if (set.contains(suffix))
        {
            int suffLen = suffix.length();
            if (suffLen > max)
                max = suffLen;
        }
    }
    return max;
}

int max =0;
for (int i = 1; i <= len-1; ++i) {
    final String prefix = s.substring(0, i);
    final String suffix = s.substring(len - i, len);
    if (prefix.equals(suffix) && max < i) {
        max =i;
}
    return max;
}