Question

我有一个不同短语的arraylist，如“蛋白质”，“蛋白激酶”，“功能性”，“功能蛋白”，“sox5”，“il-6”，现在，如果我给出一个句子作为输入，“功能性蛋白激酶和il-6和sox5”，它必须提供输出，“{功能蛋白}激酶和{il-6}和{sox5}”。必须将句子中的每个单词与短语进行比较。

我所做的代码返回了不同字符串的开始和结束索引，这些字符串与不同短语的arraylist进行了比较。我只需要过滤掉最大且没有任何碰撞的索引。对于例如输入：

[0,7] [8,22] [8,15] [36,43] [23,43] [20,30]

必需的输出：

[0,7] [8,22] [23,43]

例：

在[8,22]和[8,15]之间，[8,22]是最大的，因为22-8 = 14> 15-8 = 7，因此必须选择[8,22]。
在[36,43]，[23,43]和[20,30]之间，36位于[23,43]范围内，30也位于[23,43]范围内，这是碰撞但在这些中碰撞，[23,43]是最大的，必须选择。

为了获得所需的输出，我该怎么做？（比较标准）

我做完了，

ArrayList<ArrayList<Integer>> ListOfList = new ArrayList<ArrayList<Integer>>();
for(int a = 0; a<ListOfList.size();a++)
        {
            if(a == ListOfList.size()-1) break;
            for(int b = a+1; b<ListOfList.size();b++)
            {
                if((ListOfList.get(a).get(0) == ListOfList.get(b).get(0)) && (ListOfList.get(a).get(1) < ListOfList.get(b).get(1)))     
                {
                    startOffset = ListOfList.get(b).get(0);
                    endOffset =  ListOfList.get(b).get(1);
                }
                else
                {
                    startOffset = ListOfList.get(a).get(0);
                    endOffset =  ListOfList.get(a).get(1);
                }
            } 
        }

Answer 1

根据我的理解，您的解决方案是将所有对具有相交索引进行分组，然后找到每个组中具有最大长度的对。这是一些样板代码。如果您需要更多说明，请与我们联系：

静态类对{ public int start，end;

    Pair(int start, int end) {
        this.start = start;
        this.end = end;
    }

    public int weight() {
        return end - start;
    }

    public boolean contains(int point) {
        return start <= point && point <= end;
    }

    public String toString() {
        return String.format("[%d, %d]", start, end);
    }
}

static class Group {
    public List<Pair> pairs = new ArrayList<Pair>();
    public Pair maxWeight;

    Group(Pair start) {
        add(start);
    }

    Group(List<Pair> pairs) {
        for (Pair pair : pairs) {
            add(pair);
        }
    }

    public boolean contains(Pair pair) {
        for (Pair my : pairs) {
            if (my.contains(pair.start) || my.contains(pair.end))
                return true;
        }
        return false;
    }

    public void add(Pair pair) {
        pairs.add(pair);
        if (maxWeight == null || maxWeight.weight() < pair.weight())
            maxWeight = pair;
    }
}

public static void main(String[] args) {
    List<Pair> pairs = new ArrayList<Pair>();
    pairs.add(new Pair(0, 7));
    pairs.add(new Pair(8, 15));
    pairs.add(new Pair(8, 22));
    pairs.add(new Pair(36, 43));
    pairs.add(new Pair(23, 43));
    pairs.add(new Pair(20, 30));
    List<Group> groups = new ArrayList<Group>();

    for (Pair pair : pairs) {
        List<Group> intersects = new ArrayList<Group>();
        for (Group group : groups) {
            if (group.contains(pair)) {
                intersects.add(group);
            }
        }

        if (intersects.isEmpty()) {
            groups.add(new Group(pair));
        } else {
            List<Pair> intervals = new ArrayList<Pair>();
            intervals.add(pair);
            for (Group intersect : intersects) {
                intervals.addAll(intersect.pairs);
            }

            groups.removeAll(intersects);
            groups.add(new Group(intervals));
        }
    }

    for (Group group : groups) {
        System.out.println(group.maxWeight);
    }
}

Answer 2

如果我可以为这个问题建议一种不同的方法，因为如果我是你，你会使用单词，我不会使用索引而是使用实际的单词。

测试第一个单词并查看它是否在短语列表中，如果它没有从测试队列中删除它，如果它是将下一个单词添加到测试并再次测试它继续这样直到你找不到匹配，一旦完成此过程，您就可以进行第一次短语匹配。

使用您的示例

“功能蛋白激酶和il-6和sox5”是测试队列，结果是空的。

第一次测试将是“功能”，它将返回true，这意味着我们需要添加下一个单词并再次测试

第二次测试将是“功能蛋白”，它将返回true，因此我们需要添加单词

第三次测试将是“功能蛋白质kinsae”，它将返回false，现在我们将之前的测试标记为成功并将其从队列移动到结果，所以我们有

结果中的“{functional protein}”和队列中的“kinase and il-6 and sox5”

接下来的测试将是“激酶”，因为我们将“激酶”从队列中移动到结果，现在我们已经

结果中的“{functional protein} kinase”和队列中的“and il-6 and sox5”

保持这种状态，直到队列为空。

我意识到这不是你问题的直接答案，但是看一看这个问题的不同方式对你有帮助。

从Arraylist中过滤出整数（索引）

2 个答案: