Is there a recommended algorithm for compressing multiple specific substrings in a string that resemble DNA?

I am currently in search of a solution that would help me minimize the storage space occupied by specific sets of strings. These individual strings are essentially parts of larger strings.
For example, consider the following strings :

b bc b bcd b b bb abc 

These strings are substrings of the larger string below:

bcde
bbde
abce

I am seeking a solution to encode these specific strings in a manner that would consume minimal memory resources.

The data structure you are looking for is trie. Based on the strings you provided:

b bc b bcd b b bb abc

The outputs should be:

bb
abc
bcd

A very naive implementation of the tree data structure looks like this:

class Tree():
    def __init__(self):
        self.firstletter = {}
    def insert(self, word):
        current = self.firstletter
        for l in word:
            current.setdefault(l, {})
            current = current[l]
            
newtree = Tree()
instr = ['b', 'bc', 'b', 'bcd', 'b', 'b', 'bb', 'abc']
_ = [newtree.insert(word) for word in instr]

And you can get all the 'words' out with a depth search:

def get_words(trie, strname):
    if not trie.keys():
        print(strname)
        return
    for n in trie.keys():
        get_words(trie[n], strname + n)
_ = [get_words(val, n) for n, val in newtrie.firstletter.items()]

which gives you the outputs I listed above.

A nicely implemented trie will compress the data further and make searches faster. There are many nicely implemented tries in different languages. Depending on the task you may also be interested in prefix/suffix arrays and FM-Indexes.

I'm not sure if this is what you're looking for but, assuming there would be several duplicate substrings, you could keep track of their counts in a dictionary.

ss = ['b', 'bc', 'b', 'bcd', 'b', 'b', 'bb', 'abc']
substrings = {k: ss.count(k) for k in set(ss)}
print(substrings)

would give you:

{'bb': 1, 'bc': 1, 'bcd': 1, 'b': 4, 'abc': 1}

You could have a look at the documentation on the subject.

Most of the modules have something like .compress() method that returns bytes object and then .decompress(). They seem to be really easy to use.

So for example if I decide to give lzma compression a go I could try something like this:

from sys import getsizeof
import lzma

dna_string = ("gggtaatggttgctatcccagtaatacccaatgattcaagctgatgagtgaaatgggggg"
              "tttcaacacactggtagctgagatgaagtcattaggaaatttaatggtggataaccgagc"
              "ccatgcgatgtggatcaattggctgtacggaggtagtttattcctgcggtctagacgatc"
              "tatgtacttcgaagctaagtaacgctgaattcgcttcaaatcgttccctaacgcgtagat"
              "catgttgggacgttgtttcagcgccgggttcgagaaaatgaggatacatgattcccgtcc"
              "acgtctacgtacacttagtccgacagagactgtgtgtacgtcgactgcgaacgtggattc"
              "ggtgtaaaataggctattgtgtcttagaacacgaaaaagaagagggttctggtcggcgtc"
              "tagccgctgctctgctggcgtgtgtctctggctattgaaactgactactgccgttaacct"
              "agtgattaccgtatttaaaagcctgcggccttgatacgaactatatatgggatttaggca"
              "gtcccccagaaatcagttctactcacccggaaactgagtattcctcgccaccccttattc"
              "ctcagactagaaaagatgctgggggcgtgctgcatagcgaaattcaggtataatgcaggc"
              "acctgtgatatcccggcattcctaggcttaagaccgttataatcaaatgcatcttcccct"
              "gagtagggagaccccaactcggtccggactacgagctatcgtattatggtaccttattat"
              "gggcatcgggcattcttcggtgcttaacgccacgggaagtgaagaggtcgcgacaggaac"
              "ctattattgatgaattgagtgaattgatttgctcgatgcatagggctctggggtcataac"
              "aacaaagtatgtcggttatcaaacccaatgtagtgctgtcagttgcacatggccgagtgg"
              )         
print(getsizeof(dna_string))

compressed_dna_string = lzma.compress(dna_string.encode("ascii"))
print(getsizeof(compressed_dna_string))

decompressed_dna_string = lzma.decompress(compressed_dna_string).decode("ascii")
print((decompressed_dna_string == dna_string)*"Decompressed result matches original")

and it prints:

1009
485
Decompressed result matches original

So it works and it compresses the data a bit. I suspect the compression ratio could improve with bigger amounts of data.

It shouldn't be too difficult to test what works best for your actual data by trying different algorithms out.