Forming a target string using minimal substrings of words from a word list - python-3.x

Question

I have a text file with first names but there are new names added every year.
I need a program in Python that takes parts of names from the text file and finds some combination of substrings of these names that can be concatenated to create a string that matches a user's input.
The program should do this using the fewest possible available names from the text file.
For example, if the text file contains this:
Joppe
Fien
Katrijn
Sven
Kobe
The program asks for a name that isn't already in the text file. For example:
Please fill in a name: Katrien
Then it should print this:
Katri => Katrijn
ien => Fien
Not like this--it builds the name correctly, but there is a better solution that uses fewer words:
K => Kobe
a => Katrijn
tr => Katrijn
ien => Fien
If the text file contains this:
Joppe
Fien
Makatrijn
Sven
Kobe
It could also print this:
Katr => Makatrijn
ien => Fien
I tried this but with no result:
name_input = input('Fill in a name: ')
with open('namen.txt', 'r') as file:
for name in file.readlines():
for letter_name_input in name_input:
for letter in name:
if letter == letter_name_input:
print(letter)

Answer 1

You can use a function that takes a target name and a set of names as input, tries matching a prefix of the target name with each name in the set of names, from the longest to the shortest, and for each matching name, recursively finds the names that would form the target name with the prefix removed, from the set of names with the matching name removed, and yields each of the returning combinations with the current prefix and name prepended as a tuple:
def form_name(target, names):
if target:
for i in range(len(target), 0, -1):
prefix = target[:i]
matching_names = [name for name in names if prefix.lower() in name.lower()]
if matching_names:
for name in matching_names:
for fragments in form_name(target[i:], names - {name}):
yield [(prefix, name), *fragments]
else:
yield []
so that you can use the min function with len as the key function to obtain the combination with the fewest names:
from io import StringIO
file = StringIO('''Joppe
Fien
Katrijn
Sven
Kobe''')
for fragment, name in min(form_name('Katrien', set(file.read().split())), key=len):
print(fragment, '=>', name)
outputs:
Katri => Katrijn
en => Fien
Demo: https://repl.it/repls/IllustriousTrustingIntegrationtesting
Note that both Fien and Sven in your example input would match the en fragment and make for valid answers with the fewest names, so the min function would arbitrarily return one of them (which is fine per your requirement). Also note that you shouldn't expect the fragments of the target name to overlap, so instead of ien the second fragment should be en after the first fragment Katri is removed from the target name Katrien.
If you're interested in seeing all the valid answers, you can calculate the minimum length of all the combinations first and then output all the combinations with the minimum length:
combinations = list(form_name('Katrien', set(file.read().split())))
min_len = min(map(len, combinations))
for combination in combinations:
if len(combination) == min_len:
for fragment, name in combination:
print(fragment, '=>', name)
print()
This outputs:
Katri => Katrijn
en => Sven
Katri => Katrijn
en => Fien
Katr => Katrijn
ien => Fien

Answer 2

Assuming you'd want to stop searching as soon as you find a shortest answer, here's my solution:
First you need a function to break the word into all possible parts starting from the biggest possible set:
def breakWord(word, n):
list = []
for k in range(len(word)):
subword = word[k:]
out = [(subword[i:i+n]) for i in range(0, len(subword), n)]
if(k > 0):
out.append(word[:k])
list.append(out)
return list
Notice that if you use:
breakWord(yourWord, len(yourWord)-1)
It will break the word into all possible sets of two parts.
Then a function to check if a given string is in the list of names:
def isInNames(word):
for name in name_list:
if(word in name):
return true
return false
Finally iterate over the whole possible combination of characters:
def findWordCombination(word):
resultSet = []
resultSize = 50 #Something large to ensure it gets changed
for i in range(len(word)-1, 0, -1): #Will go from max to minimum
testSet = breakWord(word, i)
for set in testSet:
isValid = true #assumes true at first
for part in set:
if(not isInNames(part)):
isValid = false
#Once all parts of the set are checked we find
#If the set is valid. i.e. it is a valid combination.
if(isValid and len(set) < resultSize):
resultSize = len(set)
resultList = set
return resultList
This will return the first set that finds with the minimum possible combination of subwords from your search query. You can tweak it to have it store the words names from the list that yielded the resulting set.

Answer 3

Yet another approach (I upvoted #blhsing's recursive solution already, very elegant, I love it)
import itertools as it
from collections import defaultdict
def get_all_substrings(input_string):
length = len(input_string)
return [input_string[i:j+1] for i in range(length) for j in range(i,length)]
names = ['Joppe', 'Fien', 'Katrijn', 'Sven', 'Kobe']
d = defaultdict(list) # each key is a substring of any of the names and the value is the list of names that contain it
for name in names:
for subname in get_all_substrings(name):
d[subname].append(name)
input_name = 'Katrien'
input_subs = get_all_substrings(input_name)
sub_combs = [it.combinations(input_subs, n) for n in range(1,len(input_name))]
whole_combs = [el for co in sub_combs for el in co if ''.join(el) == input_name] # those combs that can form the input name
saved = [wc for wc in whole_combs if all((c in d for c in wc))] # those whole combinations that actually appear
shortest_comb = min(saved, key=len)
shortest_sub_and_name = [(s, d[s]) for s in shortest_comb]
for s, ns in shortest_sub_and_name:
print(f"{s} => {ns}")
produces
Katr => ['Katrijn']
ien => ['Fien']
Note: as you can see, the output shows all the names that can contribute to each specific substring

Answer 4

you could try:
import difflib
name = input('Please fill in a name: ')
with open('namen.txt', 'r') as file:
file_data = file.readlines()
# either you are looking for
print([i for i in file_data if difflib.SequenceMatcher(a = i,b = name).ratio() >= 0.5])
#or you are looking for
print(difflib.get_close_matches(name,file_data,len(file_data),0.5))
['Katrijn\n', 'Fien\n']