Java：查找子序列

需要查找此序列中的第一个事件并返回此事件的位置。 我发现。

似乎有效：

// The concept of an infinite sequence is that there is always a next.
abstract static class InfiniteIterator<T> implements Iterator<T> {

    @Override
    public boolean hasNext() {
        return true;
    }

}

// The digits of all decimal numbers concatenated.
static class InfiniteDigits extends InfiniteIterator<Character> {

    // The number we are working on.
    int n = 1;
    // The String version of n
    String s = Integer.toString(n);
    // Where we are in the string.
    int i = 0;

    @Override
    public Character next() {
        if (i >= s.length()) {
            s = Integer.toString(++n);
            i = 0;
        }
        return s.charAt(i++);
    }

}

// Finds a String in a stream of characters.
static class StringFinder {

    // The source of the stream.
    final Iterator<Character> source;
    // Track of the past.
    final StringBuilder traversed = new StringBuilder();

    public StringFinder(Iterator<Character> source) {
        this.source = source;
    }

    public int find(final String find) {
        // How far we've matched.
        int matched = 0;
        // How many characters we've passed.
        int passed = 0;
        // Walk the source until we get a match.
        while (matched < find.length()) {
            Character next = source.next();
            traversed.append(next);
            if (next == find.charAt(matched)) {
                // Still matching!
                matched += 1;
            } else {
                // Mismatch.
                passed += matched + 1;
                matched = 0;
            }
        }
        // Want 1-based position.
        return passed + 1;
    }
}

private void test(String string) {
    StringFinder finder = new StringFinder(new InfiniteDigits());
    System.out.println("'" + string + "' found at " + finder.find(string) + " traversed " + finder.traversed);
}

public void test() {
    test("567");
    test("1112");
    test("765");
}

---

如果第二个序列很短，可以使用naive算法，只取最后n（=长度）符号并与第二个序列进行比较。但是要注意长序列！该算法适用于

O（n*m）

，其中

n

-第二个序列的长度和

m

-第一个序列部分的长度，在到达第一个序列之前，我们必须读取这些长度。出于好奇，您计划如何在java程序中存储第一个序列？？？@apomene当然，应该是某个供应商或类似的SMT。Dmitry Ginzburg:第二个序列可以是任意长度。apomene:例如，对于LazySeq对象。在我计划使用过滤器查找子序列的位置之后，但不确定这是否可行。

'567' found at 5 traversed 1234567
'1112' found at 12 traversed 123456789101112
'765' found at 1619 traversed 1234567891011121314...85695705715725735745755765