Escribí una función para devolver un generador que contiene cada combinación única de sub-cadenas de una longitud dada que contiene más de n elementos de una cadena primaria.

Como una ilustracion:

si tengo 'abcdefghi' y una sonda de longitud de dos, y un umbral de 4 elementos por lista, me gustaría obtener:

<code>['ab', 'cd', 'ef', 'gh']
['ab', 'de', 'fg', 'hi']
['bc', 'de', 'fg', 'hi']
</code>

Mi primer intento en este problema implicó devolver una lista de listas. Esto terminó desbordando la memoria de la computadora. Como una solución secundaria cruda, creé un generador que hace algo similar. El problema es que creé un generador anidado que se llama a sí mismo. Cuando ejecuto esta función, parece que simplemente recorre el bucle interno interno sin volver a llamarse a sí mismo. Pensé que un generador podría preceder hasta el final del agujero de recursión hasta que llegara a la declaración de rendimiento. ¿Alguna pista de lo que está pasando?

<code>def get_next_probe(self, current_probe_list, probes, unit_length):
    if isinstance(current_probe_list, list):
        last_probe=current_probe_list[-1]
        available_probes = [candidate for candidate in probes if candidate.start>last_probe.end]
    else:
        available_probes = [candidate for candidate in probes if candidate.start<unit_length]

    if available_probes:

        max_position=min([probe.end for probe in available_probes])
        available_probes2=[probe for probe in available_probes if max_position+1>probe.start]

        for new_last_probe in available_probes2:
            new_list=list(current_probe_list)
            new_list.append(new_last_probe)
            self.get_next_probe(new_list, probes, unit_length)

    else:
        if len(current_probe_list)>=self.num_units:
            yield current_probe_list
</code>

Si se cambia el rendimiento para imprimir esto funciona bien! Apreciaría cualquier ayuda que pudiera conseguir. Me doy cuenta de que esta no es una implementación óptima de este tipo de problema de búsqueda, parece que devolver una lista de las posiciones encontradas de la última llamada de get_next_probe y filtrar esta lista para los elementos que no se superponen new_last_probe.end sería mucho más eficiente ... pero esto fue mucho más fácil para mí escribir. Cualquier entrada de algoritmo todavía sería apreciada.

¡Gracias!