Vibgyor

Since the characters are all distinct, let's use the string $1234567$ instead. Let $G_{n}$ denote the set of good arrangements for a string of distinct characters of length $n$ . For every string in $G_{n}$ , we can form a string in $G_{n+1}$ by adding in a new character $n+1$ anywhere that isn't directly after the character denoted by $n$ , giving $n$ good arrangements in $G_{n+1}$ for every arrangement in $G_{n}$ (for example, in $214365$ we can add a $7$ anywhere except after $6$ ).

However, consider an arrangement of $n$ characters in which there exist only two characters in order. We could place the $n+1th$ character in between these two to create a good arrangement out of a non-good one. For $1 \leq k \leq n-1$ , we can model the triplet $k, n+1, k+1$ as one character, so we reduce $n+1$ characters to $n-1$ characters (for example, $651243$ can be made into $6517243$ , and $172$ can go anywhere except before $3$ ). This allows us to only consider arrangements in $G_{n-1}$ , and create $n-1$ good arrangements from each one.

Then, $|G_{n+1}|$ = $(n)|G_{n}| + (n-1)|G_{n-1}|$ . $|G_{2}|$ and $|G_{3}|$ are easily calculable as $1$ and $3$ , so:

$|G_{4}| = (3)(3) + (2)(1) = 11$

$|G_{5}| = (4)(11) + (3)(3) = 53$

$|G_{6}| = (5)(53) + (4)(11) = 309$

$|G_{7}| = (6)(309) + (5)(53) = \boxed{2119}$

An approach using breadth first search to generate the search space, counting the number of strings with length 7.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

def bfs(beginning, children, goal, iterlimit):
    cause = {beginning:None}
    frontier = [beginning]
    next_frontier = []
    goal_count = 0
    while frontier:
        next_frontier = []
        for member in frontier:
            for child in children(member):
                if child not in cause:
                    cause[child] = member
                    next_frontier.append(child)
                    if goal(child):
                        goal_count += 1
        frontier = next_frontier[:]
        iterlimit -= 1
        if iterlimit == 0:
            print "Iteration limit reached."
            break
    print "Operation completed."
    print "Number of nodes found: {0}".format(len(cause))
    print "Number of goals: {0}".format(goal_count)
    return cause
def substrings(s):
    # returns all substrings of s that
    # have a length of two or more
    answers = set()
    answers.add(s)
    for length in xrange(2,len(s)):
        for sub in xrange(0,len(s)-length+1):
            answers.add(s[sub:sub+length])
    return answers

vibgyor_subs = substrings("vibgyor")
start = ""

def neighbor(x):
    children = []
    for char in "vibgyor":
        if x.count(char) == 0:
            subs = substrings(x+char)
            if len(subs & vibgyor_subs) == 0:
                children.append(x+char)
    return children
def goal(x):
    return len(x) == 7

bfs(start,neighbor,goal,100)

Any letter in the combination must not be followed by its next letter in VIBGYOR. After that just apply inclusion and exclusion principle

D7 + other cases..