从数组列表中筛选出整数(索引)

Question

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

我所做的代码返回不同字符串的开始和结束索引，并与不同短语的数组列表进行比较。我只需要过滤掉索引，这是最大的，没有任何冲突。例如，为投入：

0、78、15、23、43

所需产出：

0、7 23、43

案例：

• 在8,22和8，15，8，22之间是最大的，因为22-8 = 14 > 15-8 = 7，所以必须选择8，22。
• 在36、43、23、43和20、30和30之间，范围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

据我所知，您的解决方案是将所有具有交叉索引的对分组，然后在每个组中找到最大长度的对。这是一些样板代码。如果您需要更多的澄清，请告诉我：

静态类对{公共int开始，结束；

    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”是测试队列，结果为空。

第一个测试将是"functional“，它将返回true，这意味着我们需要添加下一个单词并再次进行测试。

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

第三个测试将是“功能性蛋白激酶”，它将返回false，现在我们将先前的测试标记为成功，并将其从队列转移到结果，因此我们有

结果中的"{functional }“和队列中的"kinase及il-6和sox5”。

下一个测试将是“激酶”，它是筋膜，所以我们将“激酶”从队列移到结果，现在我们已经有了。

结果中的“{功能性蛋白}激酶”，队列中的“和il-6和sox5”。

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

我知道这并不是对你问题的直接回答，但也许用不同的方式来看待这个问题对你会有帮助。