Lexicographic ordering with no consecutive repetition

Question

I know algorithm of lexicographic order but in this question we can have repetition of character non-consecutively.And this make me confused.

A good string s is the one which:

contains only these letters of the set: [a,b,c]
s[i] != s[i+1] string aba, bca,cbc is valid but aaa, abb, aab not valid.

Order of set:[a, b, c]

["aba", "abc", "aca", "acb", "bab", "bac", "bca", "bcb", "cab", "cac", "cba", "cbc"].

Can you help me out with its algorithm.

How is it determined how long a single string should be? For instance, why is "abac" not in the results? — trincot, Jun 14 '20 at 20:27
The input set contain three elements. So all output sets should also have exact three elements. — Aditya Ojha, Jun 15 '20 at 14:45

score 0 · Answer 1 · answered Jun 14 '20 at 20:10

It sounds like what you wanna do is to order using Lexicographic order and then filter out the results that you consider invalid.

In your example step 1 will be:

["aaa", "aab", "aac", ...]

then remove what is not valid, and you will get:

["aba", "abc", "aca", ...]

score 0 · Answer 2 · answered Jun 14 '20 at 20:37

You can just sort your list of strings lexicographically. These would contain strings that are having same consecutive characters. So, before return the result, you could just make another list and loop over the original list while only including the strings that match the above criteria into the new list. Once you iterate the whole list, just return it and that would be your final answer.

For eg. Consider a list -

 ["cab", "abc", "aca", "acc", "abb", "bbc", "caa", "aab"]

After you sort it -

['aab', 'abb', 'abc', 'aca', 'acc', 'bbc', 'caa', 'cab']

Now you can just loop over this list and only pick the elements that match your criteria. So the final list will be -

['abc', 'aca', 'cab']

Hope your understood the approach.

trincot · Accepted Answer · 2020-06-15T15:35:05.473

You can use a recursive algorithm where you pass the last used letter as a forbidden letter for the next selection. The recursive function gets a size argument so it knows how long the strings should be that it should produce. It then iterates every possible character, but excludes the forbidden one, and calls the function recursively, but with the size reduced. The current character now becomes the forbidden character for the recursive call. When that call comes back with results, it prefixes each of those results with the current character, so that effectively they all increase in size by one character. This is repeated for all other characters that are iterated (except the forbidden one). And all these results are collected into one result set (array), and returned.

I assume the set of characters is provided in lexicographic order (otherwise sort it before using the below algorithm), and that the size of the produced strings is also a parameter given to the algorithm.

Here is a simple JavaScript implementation of that idea:

function combis(chars, size, forbidden="") {
    if (size == 0) { // base case
        return [""];
    }
    let results = [];
    for (let chr of chars) {
        if (chr != forbidden) { // Avoid repetition
            for (let combi of combis(chars, size-1, chr)) {
                results.push(chr + combi); // prefix the returned string
            }
        }
    }
    return results;
}

console.log(combis("abc", 3));

Thanks for answer. But it will be helpful if you explain in more detail. (Recursion part !). — Aditya Ojha, Jun 15 '20 at 15:05

Lexicographic ordering with no consecutive repetition

3 Answers3