идентифицировать повторяющиеся/повторяющиеся шаблоны как подмассивы из родительского массива

Вероятно, это не то, что вы хотите, но я еще не знаю, что вы пробовали, поэтому, возможно, это может быть полезно. Вот мой прямой подход, который, вероятно, подпадает под ваши «решения для циклов грубой силы», но я решил попробовать, поскольку никто не опубликовал полный ответ.

В Java:

// use this to not add duplicates to list
static boolean contains (List<String[]> patterns, String[] pattern){
    for(String[] s: patterns)
        if (Arrays.equals(pattern,s)) return true;
    return false;
}


/**
 *
 * @param str String array containing all elements in your set
 * @param start index of subarray
 * @param end index of subarray
 * @return if subarray is a recurring pattern
 */
static boolean search (String[] str,int start,int end) {
    // length of pattern
    int len = end - start + 1;

    // how many times you want pattern to
    // appear in text
    int n = 1;

    // increment m if pattern is matched
    int m = 0;

    // shift pattern down the array
    for (int i = end+1; i <= str.length - len; i++) {
        int j;
        for (j = 0; j < len; j++) {
            if (!str[i + j].equals(str[start + j]))
                break;
        }

        // if pattern is matched at [i to i+len]
        if (j == len) {
            m++;
            if (m == n) return true;
        }
    }
    return false;
}


/**
 *
 * @param str String array containing all elements in your set
 * @return a list of subsets of input set which are a recurring pattern
 */
static List<String[]> g (String[] str) {
    // put patterns in here
    List<String[]> patterns = new ArrayList<>();

    // iterate through all possible subarrays in str
    for(int i = 0; i < str.length-1; i++){
        for(int j = i + 1; j < str.length; j++){

            // if a pattern is found
            if (search(str,i,j)) {
                int len = j-i+1;
                String[] subarray = new String[len];
                System.arraycopy(str,i,subarray,0,len);
                if (!contains(patterns,subarray))
                    patterns.add(subarray);

            }
        }
    }
    return patterns;
}

public static void main(String[] args) {

    String[] str = {"horse", "camel", "horse", "camel", "tiger",
                    "horse", "camel", "horse", "camel"};
    // print out
    List<String[]> patterns = g(str);
    for (String[] s: patterns)
        System.out.println(Arrays.toString(s));
}

Выход:

[horse, camel]
[horse, camel, horse]
[horse, camel, horse, camel]
[camel, horse]
[camel, horse, camel]

Как упоминалось в комментарии, который я опубликовал:

"будет ли [camel, horse] включено в вывод?"

Вывод, который у меня есть, соответствует этому, поскольку есть 2 экземпляра [camel, horse] с индексами [1-2] и [6-7]. Но, может быть, я совершенно неправильно понимаю ваш вопрос и не понимаю ограничений.

Что касается оптимизации, метод search(...), например, представляет собой простой поиск подстроки, есть несколько более оптимизированных способов сделать это, например. Кнут-Моррис-Пратт. Извините, если это было именно то, чего вы не хотели, но, возможно, есть какая-то польза