Bdtyktl

So, this is a part of a function I'm trying to make.

I don't want the code to be too complicated.

I have a list of words, e.g.

words = ['giraffe', 'elephant', 'ant', 'tiger', 'racoon', 'cat', 'hedgehog', 'mouse']

The idea of the word chain sequence is for the next word to begin with the letter that the last word ended in.

(Edit: Each word cannot be used more than once. Other than that there are no other constraints.)

I want the output to give the longest word chain sequence, which in this case is:

['hedgehog', 'giraffe', 'elephant', 'tiger', 'racoon']

I'm not really sure how to do it, I had different attempts at trying this. One of them...

This code finds the word chain correctly if we start with a specific word from the list, e.g. words[0] (so 'giraffe'):

words = ['giraffe', 'elephant', 'ant', 'tiger', 'racoon', 'cat', 'hedgehog', 'mouse']



word_chain = 



word_chain.append(words[0])



for word in words:

    for char in word[0]:



       if char == word_chain[-1][-1]:

            word_chain.append(word)



print(word_chain)

Output:

['giraffe', 'elephant', 'tiger', 'racoon']

BUT, I want to find the longest possible chain of words (explained above).

My method: So, I tried to use the above working code that I wrote and loop through, using each word from the list as the starting point and finding the word chain for each word[0], word[1], word[2] etc. Then I tried to find the longest word chain by using an if statement and compare the length to the previous longest chain, but I can't get it done properly and I don't really know where this is going.

words = ['giraffe', 'elephant', 'ant', 'tiger', 'racoon', 'cat', 'hedgehog', 'mouse']



word_chain = 

max_length = 0

for starting_word_index in range(len(words) - 1):



    word_chain.append(words[starting_word_index])



    for word in words:

        for char in word[0]:



            if char == word_chain[-1][-1]:

                word_chain.append(word)



    # Not sure



    if len(word_chain) > max_length:

        final_word_chain = word_chain

        longest = len(word_chain)

        word_chain.clear()



print(final_word_chain)

This is my nth attempt, I think this one prints an empty list, I had different attempts before this that failed to clear the word_chain list properly and ended up repeating words over again.

Any help much appreciated. Hopefully I didn't make this too teedious or confusing... Thanks!

You can use recursion to explore every "branch" that emerges when every possible letter containing the proper initial character is added to a running list:

words = ['giraffe', 'elephant', 'ant', 'tiger', 'racoon', 'cat', 'hedgehog', 'mouse']

def get_results(_start, _current, _seen):

  if all(c in _seen for c in words if c[0] == _start[-1]):

    yield _current

  else:

      for i in words:

        if i[0] == _start[-1]:

          yield from get_results(i, _current+[i], _seen+[i])





new_d = [list(get_results(i, [i], ))[0] for i in words]

final_d = max([i for i in new_d if len(i) == len(set(i))], key=len)

Output:

['hedgehog', 'giraffe', 'elephant', 'tiger', 'racoon']

This solution works similar to the breadth-first search, as the function get_resuls will continue to iterate over the entire list as long as the current value has not been called on before. Values that have been seen by the function are added to the _seen list, ultimately ceasing the stream of recursive calls.

This solution will also ignore results with duplicates:

words = ['giraffe', 'elephant', 'ant', 'ning', 'tiger', 'racoon', 'cat', 'hedgehog', 'mouse',]

new_d = [list(get_results(i, [i], ))[0] for i in words]

final_d = max([i for i in new_d if len(i) == len(set(i))], key=len)

Output:

['ant', 'tiger', 'racoon', 'ning', 'giraffe', 'elephant']

I have a new idea, as the figure shows:

We can construct a directed graph by word[0] == word[-1], then the problem is converted to find the maximum length path.

As mentioned by others, the problem is to find the longest path in a directed acyclic graph.

For anything graph related in Python, networkx is your friend.

You just need to initialize the graph, add the nodes, add the edges and launch dag_longest_path:

import networkx as nx

import matplotlib.pyplot as plt



words = ['giraffe', 'elephant', 'ant', 'tiger', 'racoon', 'cat',

         'hedgehog', 'mouse']



G = nx.DiGraph()

G.add_nodes_from(words)



for word1 in words:

    for word2 in words:

        if word1 != word2 and word1[-1] == word2[0]:

            G.add_edge(word1, word2)

nx.draw_networkx(G)

plt.show()

print(nx.algorithms.dag.dag_longest_path(G))

It outputs:

['hedgehog', 'giraffe', 'elephant', 'tiger', 'racoon']

Note : this algorithm only works if there are no cycles (loops) in the graph. It means it will fail with ['ab', 'ba'] because there would be a path of infinite length: ['ab', 'ba', 'ab', 'ba', 'ab', 'ba', ...]

In the spirit of brute force solutions, you can check all permutations of the words list and choose the best continuous starting sequence:

from itertools import permutations



def continuous_starting_sequence(words):

    chain = [words[0]]

    for i in range(1, len(words)):

        if not words[i].startswith(words[i - 1][-1]):

            break

        chain.append(words[i])

    return chain



words = ['giraffe', 'elephant', 'ant', 'tiger', 'racoon', 'cat', 'hedgehog', 'mouse']

best = max((continuous_starting_sequence(seq) for seq in permutations(words)), key=len)



print(best)

# ['hedgehog', 'giraffe', 'elephant', 'tiger', 'racoon']

Since we're considering all permutations, we know that there must be a permutation that starts with the largest word chain.

This, of course, has O(n n!) time complexity :D

This function creates a type of iterator called a generator (see: What does the "yield" keyword do?). It recursively creates further instances of the same generator to explore all possible tail sequences:

words = ['giraffe', 'elephant', 'ant', 'tiger', 'racoon', 'cat', 'hedgehog', 'mouse']



def chains(words, previous_word=None):

    # Consider an empty sequence to be valid (as a "tail" or on its own):

    yield 

    # Remove the previous word, if any, from consideration, both here and in any subcalls:

    words = [word for word in words if word != previous_word]

    # Take each remaining word...

    for each_word in words:

        # ...provided it obeys the chaining rule

        if not previous_word or each_word.startswith(previous_word[-1]):

            # and recurse to consider all possible tail sequences that can follow this particular word:

            for tail in chains(words, previous_word=each_word):

                # Concatenate the word we're considering with each possible tail:

                yield [each_word] + tail  



all_legal_sequences = list(chains(words))  # convert the output (an iterator) to a list

all_legal_sequences.sort(key=len) # sort the list of chains in increasing order of chain length

for seq in all_legal_sequences: print(seq)

# The last line (and hence longest chain) prints as follows:

# ['hedgehog', 'giraffe', 'elephant', 'tiger', 'racoon']

Or, to get straight to the longest chain more efficiently:

print(max(chains(words), key=len)

Finally, here is an alternate version that allows repeated words in the input (i.e. if you include a word N times, you may use it up to N times in the chain):

def chains(words, previous_word_index=None):

    yield 

    if previous_word_index is not None:

        previous_letter = words[previous_word_index][-1]

        words = words[:previous_word_index] + words[previous_word_index + 1:]

    for i, each_word in enumerate( words ):

        if previous_word_index is not None and not each_word.startswith(previous_letter): continue

        for tail in chains(words, previous_word_index=i):

            yield [each_word] + tail