在获取两个给定字符串之间最小可整除字符串的长度时，如何降低时间复杂度？

Question

s='bcdbcdbcdbcdcd't='bcdbcd'

如果string''被串联两次，则结果为'bcdbcdbcdbcd'='s'。字符串“%s”可被字符串“t”整除。可以级联以创建字符串's'和't'的最小字符串'x'是'bcd'。它的长度是3。

//My Code:
String smallest = Arrays.stream(s.split(regex(""))
.collect(Collectors.groupingBy(
    x -> firstRepeating(t, x) ? x + x : x, 
    LinkedHashMap::new, 
    Collectors.counting()))
    .keySet().stream().collect(Collectors.joining());

     if((s.length() % t.length()) == 0){
        System.out.printf("%s is divisible by %s%n", s, t);
       }

  System.out.println("The smallest string is " + small);

Answer 1

基于我的理解，这里是我想出来的。也可以代入自己的数据进行测试。

假设：

1. 两个字符串都是同一个较小子字符串的串联。
2. 因此，如果剩余(%)运算符在除以它们的长度时返回零，则一个将除以另一个。

    static Random r = new Random();
    public static void main(String[] args) {

        for (int i = 0; i < 10; i++) {
            int seed = r.nextInt();
            String t = generate(3,7,seed);
            String s = generate(7,11,seed);

            int index = 0;
            for (int i = 1; i < s.length()/2; i++) {
               if (s.regionMatches(0,s,i,i)) {
                  index = i;
               }
            }
            int index = 0;
            for (int idx = 1; idx < s.length()/2; idx++) {
              if (s.regionMatches(0,s,idx,idx)) {
                index = idx;
              }
            }
            String small = s.substring(0,index);

            // Check to make certain this isn't just a repeated character.
            small = small.replaceAll("^(.)\\1+$", "$1"); 
            boolean isDivisible = s.length() % t.length() == 0;
            System.out.printf("%s is " + ((isDivisible) ? "" : "NOT") 
                 + " divisible by %s%n",
                        s, t);

            System.out.println(
                    "The smallest string is " + small + "\n");
        }

    }

    static String alphabet = "abcdefghijklmnopqrstuvwxyz";

    public static String generate(int s, int e, int seed) {
        r.setSeed(seed);
        String stem = IntStream.range(3, 8).mapToObj(i -> {
            int len = r.nextInt(26);
            return alphabet.substring(len, len + 1);
        }).collect(Collectors.joining());
        return stem.repeat(r.nextInt(e)+s);
    }