如何从Python的字符串列表中创建所有可能的长度为100个字符的句子

Question

I am trying to create a sentence of length 100 characters from a given list of strings. The length has to be exactly one hundred characters. We also have to find all possible sentences using permutation. There has to be a space between each word, and duplicate words are not allowed. The list is given below:

['saintliness', 'wearyingly', 'shampoo', 'headstone', 'dripdry', 'elapse', 'redaction', 'allegiance', 'expressionless', 'awesomeness', 'hearkened', 'aloneness', 'beheld', 'courtship', 'swoops', 'memphis', 'attentional', 'pintsized', 'rustics', 'hermeneutics', 'dismissive', 'delimiting', 'proposes', 'between', 'postilion', 'repress', 'racecourse', 'matures', 'directions', 'bloodline', 'despairing', 'syrian', 'guttering', 'unsung', 'suspends', 'coachmen', 'usurpation', 'convenience', 'portal', 'deferentially', 'tarmacadam', 'underlay', 'lifetime', 'nudeness', 'influences', 'unicyclists', 'endangers', 'unbridled', 'kennedy', 'indian', 'reminiscent', 'ravish', 'republics', 'nucleic', 'acacia', 'redoubled', 'minnows', 'bucklers', 'decays', 'garnered', 'aussies', 'harshen', 'monogram', 'consignments', 'continuum', 'pinion', 'inception', 'immoderate', 'reiterated', 'hipster', 'stridently', 'relinquished', 'microphones', 'righthanders', 'ethereally', 'glutted', 'dandies', 'entangle', 'selfdestructive', 'selfrighteous', 'rudiments', 'spotlessly', 'comradeinarms', 'shoves', 'presidential', 'amusingly', 'schoolboys', 'phlogiston', 'teachable', 'letting', 'remittances', 'armchairs', 'besieged', 'monophthongs', 'mountainside', 'aweless', 'redialling', 'licked', 'shamming', 'eigenstate']

Approach:

My first approach is to use backtracking and permutations to generate all sentences. But I think the complexity will be too high since my list is so big.

Is there any other method I can use here or some inbuilt functions/packages I can use here? What will be best way in python to do this? Any pointers will be helpful here.

Answer 1

This problem is similar to the problem of partitioning in number theory .

The complexity of the problem can (presumably) be reduced using some of the constraints that are encoded in the problem statement:

1. The lengths of the words in the words list.
2. Repeats of word lengths: for example a word of length 8 is repeated X times.

Here's a possible general approach (would take some refining):

• Find all partitions for the number 100 using only the lengths of the words in the words list. (You would start with word lengths and their repeats, and not by brute forcing all possible partitions.)

• Filter out partitions that have repeat length values exceeding repeat length values for words in the list.

• Apply combinations of words onto the partitions. A set of words of equal length will be mapped to length values in a partition. Say for example you have the partition (15+15+15+10+10+10+10+5+5+5) then you would generate combinations for all length 15 words over 3, length 10 words over 4, and length 5 words over 3. (I'm ignoring the space separation issue here).

• Generate permutations of all the combinations over all the partitions.

Answer 2

You can't do it.

Think about it: even for selecting 4 words you already have 100 × 99 × 98 × 97 possibilities, almost 100 million.

Given the length of your words at least 8 of them will fit in the sentence. There is 100 × 99 × 98 … × 93 possibilities. That's approximately 7×10^15, a totally infeasible number.

Answer 3

Simplify a bit: Change all the strings from "xxx" to "xxx ". Then set the sentence length to 101. This allows you to use len(x) instead of len(x)+1 and eliminates the edge case for the last word in the sentence. As you traverse, and build the sentence left to right, you can eliminate words that would overflow the length, based on the sentence you've just constructed.

UPDATE:

Consider this to be a base n number problem where n is the number of words you have. Create a vector initialized with 0 [NOTE: it's only fixed size to illustrate]:

acc = [0, 0, 0, 0]

This is your "accumulator".

Now construct your sentence:

dict[acc[0]] + dict[acc[1]] + dict[acc[2]] + dict[acc[3]]

So, you get able able able able

Now increment the most significant "digit" in the acc. This is denoted by "curpos". Here curpos is 3.

[0, 0, 0, 1]

Now you get able able able baker

You keep bumping acc[curpos] until you hit [0, 0, 0, n] Now you've got a "carry out". "Go left" by decrementing curpos to 2. increment acc[curpos]. If it doesn't "carry out", "go right" by incrementing curpos and set acc[curpos] = 0. If you had gotten a carry out, you'd do a "go left" by decrementing curpos to 1.

This is a form of backtracking (eg the "go left"), but you don't need a tree. Just this acc vector and a state machine with three states: goleft, goright, test/trunc/output/inc.

After the "go right" curpos will be back to the "most significant" position. That is, the sentence length constructed from acc[0 to curpos - 1] (the length without adding the final word) is less than 100. If it's too long (eg it's already over 100), do a "go left". If it's too short (eg you've got to add another word to get near [enough] to 100), do a "go right"

When you get a carry out and curpos==0, you're done

I recently devised this as a solution to the "vampire number challenge" and the traversal you need is very similar.

Answer 4

Your problem size is way too large, but if 1) your actual problem is much smaller in scope, and/or 2) you have a lot of time and a very fast computer, you can generate these permutations using a recursive generator.

def f(string, list1):
    for word in list1:
        new_string = string + (' ' if string else '') + word
        # If there are other constraints that will allow you to prune branches,
        # you can add those conditions here and break out of the for loop
        if len(new_string) >= 100:
            yield new_string[:100]
        else:
            list2 = list1[:]
            list2.remove(word)
            for item in f(new_string, list2):
                yield item

x = f('', list1)
for sentence in x:
    check(sentence)

One caveat is that this may produce identical sentences if two words at the end get truncated to look the same.

Answer 5

I am not going to provide a complete solution, but I'll walk through my thinking.

Constraints:

• A permutation of your complete list that exceeds 100 characters can be immediately thrown out. (Ok, 99 + len(longest_word)) .)
• You are essentially dealing with a subset of the power set of elements in your list.

Given that:

• Build the power set, but discard any sentences that exceed your maximum
• Filter the final set for sentences that exactly match your needs

So you can have the following:

def construct_sentences(dictionary: list, length: int) -> list:
    if not dictionary:
        return [(0, [])]
    else:
        word = dictionary[0]
        word_length = len(word) + 1
        subset_length = length - word_length
        sentence_subset = construct_sentences(dictionary[1:], subset_length)
        new_sentences = []
        for sentence_length, sentence in sentence_subset:
            if sentence_length + word_length <= length:
                new_sentences = new_sentences + [(sentence_length + word_length, sentence + [word])]
        return new_sentences + sentence_subset

I'm using tuples to write-aside the length of the list and make it easily available for comparison. The result of the above function will give you a list of sentences that are all less than the length (which is key when considering potential permutations: 100 is fairly short so there is a vast number of permutations that can be readily discarded). The next step would be to simply filter any sentence that isn't long enough (ie 100 characters).

Note that at this point you have every possible list filtering your criteria, but that list may be reordered 2^n ways. Still, that becomes a more manageable situation. With a list of 100 words, averaging under 9 characters a word, you have a average number of words in a sentence equal to 10. 2^10 isn't the worst situation in the world...

You'll have to modify it for your truncation case, of course, but this gets you in the ballpark. Unless I completely missed something, which is always possible. I doubly think something is wrong because running this produces a surprisingly short list.