Recursión sin factorial, números de Fibonacci, etc.

Casi todos los artículos que puedo encontrar sobre la recursividad incluyen ejemplos de números factoriales o de Fibonacci, que son:

1. Matemáticas
2. Inútil en la vida real

¿Hay algunos ejemplos interesantes de códigos no matemáticos para enseñar la recursividad?

Estoy pensando en algoritmos de divide y vencerás, pero generalmente involucran estructuras de datos complejas.

Las estructuras de directorio / archivo son el mejor ejemplo de uso para la recursividad, porque todos las entienden antes de comenzar, pero cualquier cosa que involucre estructuras en forma de árbol servirá.

void GetAllFilePaths(Directory dir, List<string> paths)
{
    foreach(File file in dir.Files)
    {
        paths.Add(file.Path);
    }

    foreach(Directory subdir in dir.Directories)
    {
        GetAllFilePaths(subdir, paths)
    }
}

List<string> GetAllFilePaths(Directory dir)
{
    List<string> paths = new List<string>();
    GetAllFilePaths(dir, paths);
    return paths;
}

Busque cosas que involucren estructuras de árboles. Un árbol es relativamente fácil de entender, y la belleza de una solución recursiva se hace evidente mucho antes que con estructuras de datos lineales como las listas.

Cosas para pensar:

• sistemas de archivos: esos son básicamente árboles; una buena tarea de programación sería buscar todas las imágenes .jpg en un determinado directorio y todos sus subdirectorios
• ancestral: dado un árbol genealógico, encuentre el número de generaciones que tiene que caminar para encontrar un antepasado común; o verifique si dos personas en el árbol pertenecen a la misma generación; o verifique si dos personas en el árbol pueden casarse legalmente (depende de la jurisdicción :)
• Documentos tipo HTML: convierta entre la representación en serie (texto) de un documento y un árbol DOM; realizar operaciones en subconjuntos de un DOM (¿tal vez incluso implementar un subconjunto de xpath?); ...

Todos estos están relacionados con escenarios reales del mundo real, y todos pueden usarse en aplicaciones de importancia real.

https://stackoverflow.com/questions/105838/real-world-examples-of-recursion

• modelando una infección contagiosa
• generando geometría
• gestión de directorios
• clasificación

https://stackoverflow.com/questions/2085834/how-did-you-practically-use-recursion

• trazado de rayos
• ajedrez
• análisis del código fuente (gramática del lenguaje)

https://stackoverflow.com/questions/4945128/what-is-a-good-example-of-recursion-other-than-generating-a-fibonacci-sequence

• Búsqueda BST
• Torres de Hanoi
• búsqueda de palíndromo

https://stackoverflow.com/questions/126756/examples-of-recursive-functions

• Da una bonita historia en inglés que ilustra la recurrencia de un cuento antes de dormir.

Aquí hay algunos problemas más prácticos que me vienen a la mente:

• Ordenar fusión
• Búsqueda binaria
• Recorrido, inserción y eliminación en árboles (ampliamente utilizado en aplicaciones de bases de datos)
• Generador de permutaciones
• Solucionador de Sudoku (con retroceso)
• Corrector ortográfico (de nuevo con retroceso)
• Análisis de sintaxis (.eg, un programa que convierte el prefijo a notación postfix)

QuickSort sería el primero que salta a la mente. La búsqueda binaria también es un problema recursivo. Más allá de eso, hay toda una serie de problemas por los que las soluciones se caen casi gratis cuando comienzas a trabajar con la recursividad.

Ordenar, definido recursivamente en Python.

def sort( a ):
    if len(a) == 1: return a
    part1= sort( a[:len(a)//2] )
    part2= sort( a[len(a)//2:] )
    return merge( part1, part2 )

Fusionar, definido de forma recursiva.

def merge( a, b ):
    if len(b) == 0: return a
    if len(a) == 0: return b
    if a[0] < b[0]:
        return [ a[0] ] + merge(a[1:], b)
    else:
        return [ b[0] ] + merge(a, b[1:]) 

Búsqueda lineal, definida recursivamente.

def find( element, sequence ):
    if len(sequence) == 0: return False
    if element == sequence[0]: return True
    return find( element, sequence[1:] )

Búsqueda binaria, definida recursivamente.

def binsearch( element, sequence ):
    if len(sequence) == 0: return False
    mid = len(sequence)//2
    if element < mid: 
        return binsearch( element, sequence[:mid] )
    else:
        return binsearch( element, sequence[mid:] )

En cierto sentido, la recursión se trata de dividir y conquistar soluciones, es decir, dividir el espacio del problema en uno más pequeño para ayudar a encontrar la solución para un problema simple, y luego volver a reconstruir el problema original para componer la respuesta correcta.

Algunos ejemplos que no involucran matemáticas para enseñar la recursividad (al menos esos problemas que recuerdo de mis años universitarios):

• Torres de Hanoi
• Ocho reinas

Estos son ejemplos del uso de Backtracking para resolver el problema.

Otros problemas son los clásicos del dominio de Inteligencia Artificial: uso de la búsqueda en profundidad, búsqueda de caminos, planificación.

Todos esos problemas involucran algún tipo de estructura de datos "compleja", pero si no desea enseñarla con matemáticas (números), entonces sus opciones pueden ser más limitadas. Es posible que desee comenzar a enseñar con una estructura de datos básica, como una Lista vinculada. Por ejemplo representando los números naturales usando una Lista:

0 = lista vacía 1 = lista con un nodo. 2 = lista con 2 nodos. ...

luego defina la suma de dos números en términos de esta estructura de datos como esta: Vacío + N = N Nodo (X) + N = Nodo (X + N)

Towers of Hanoi es bueno para ayudar a aprender la recursividad.

Hay muchas soluciones en la web en muchos idiomas diferentes.

Un detector de palíndromo:

Comience con una cadena: "ABCDEEDCBA" Si los caracteres iniciales y finales son iguales, luego repita y marque "BCDEEDCB", etc.

Un algoritmo de búsqueda binaria suena como lo que quieres.

En los lenguajes de programación funcionales, cuando no hay funciones de orden superior disponibles, se utiliza la recursión en lugar de los bucles imperativos para evitar el estado mutable.

F # es un lenguaje funcional impuro que permite ambos estilos, así que compararé ambos aquí. La siguiente suma todos los números en una lista.

Bucle imperativo con variable mutable

let xlist = [1;2;3;4;5;6;7;8;9;10]
let mutable sum = 0
for x in xlist do
    sum <- sum + x

Bucle recursivo sin estado mutable

let xlist = [1;2;3;4;5;6;7;8;9;10]
let rec loop sum xlist = 
    match xlist with
    | [] -> sum
    | x::xlist -> loop (sum + x) xlist
let sum = loop 0 xlist

Tenga en cuenta que este tipo de agregación se captura en la función de orden superior List.foldy podría escribirse como, List.fold (+) 0 xlisto incluso más, simplemente con la función de conveniencia List.sumcomo tal List.sum xlist.

He usado mucho la recursividad en el juego de IA. Escribiendo en C ++, hice uso de una serie de aproximadamente 7 funciones que se llaman entre sí en orden (con la primera función que tiene una opción para omitirlas y llamar a una cadena de 2 funciones más). La función final en cualquiera de las cadenas llamó a la primera función nuevamente hasta que la profundidad restante que quería buscar fue a 0, en cuyo caso la función final llamaría a mi función de evaluación y devolvería el puntaje de la posición.

Las múltiples funciones me permitieron ramificar fácilmente en función de las decisiones del jugador o eventos aleatorios en el juego. Hacía uso de pasar por referencia cada vez que podía, porque estaba pasando estructuras de datos muy grandes, pero debido a cómo estaba estructurado el juego, era muy difícil tener un "movimiento de deshacer" en mi búsqueda, así que Usaría el paso por valor en algunas funciones para mantener mis datos originales sin cambios. Debido a esto, cambiar a un enfoque basado en bucles en lugar de un enfoque recursivo resultó demasiado difícil.

Puede ver un resumen muy básico de este tipo de programa, consulte https://secure.wikimedia.org/wikipedia/en/wiki/Minimax#Pseudocode

Un buen ejemplo de la vida real en los negocios es algo llamado "Lista de materiales". Estos son los datos que representan todos los componentes que conforman un producto terminado. Por ejemplo, usemos una bicicleta. Una bicicleta tiene manubrios, ruedas, un cuadro, etc. Y cada uno de esos componentes puede tener subcomponentes. por ejemplo, la rueda puede tener radios, un vástago de válvula, etc. Por lo general, estos se representan en una estructura de árbol.

Ahora, para consultar cualquier información agregada sobre la lista de materiales o para cambiar elementos en una lista de materiales, a menudo recurre a la recursividad.

    class BomPart
    {
        public string PartNumber { get; set; }
        public string Desription { get; set; }
        public int Quantity { get; set; }
        public bool Plastic { get; set; }
        public List<BomPart> Components = new List<BomPart>();
    }

Y una muestra de llamada recursiva ...

    static int ComponentCount(BomPart part)
    {
        int subCount = 0;
        foreach(BomPart p in part.Components)
            subCount += ComponentCount(p);
        return part.Quantity * Math.Max(1,subCount);

    }

Obviamente, la clase BomPart tendría muchos más campos. Es posible que necesite averiguar cuántos componentes plásticos tiene, cuánto trabajo se necesita para construir una pieza completa, etc. Sin embargo, todo esto vuelve a la utilidad de Recursion en una estructura de árbol.

Las relaciones familiares son buenos ejemplos porque todos las entienden intuitivamente:

ancestor(joe, me) = (joe == me) 
                    OR ancestor(joe, me.father) 
                    OR ancestor(joe, me.mother);

Una recursividad bastante inútil pero que muestra un buen funcionamiento interno es recursivo strlen():

size_t strlen( const char* str )
{
    if( *str == 0 ) {
       return 0;
    }
    return 1 + strlen( str + 1 );
}

Sin matemáticas: una función muy simple. Por supuesto, no lo implementa de manera recursiva en la vida real, pero es una buena demostración de recursividad.

Otro problema de recursión del mundo real con el que los estudiantes pueden relacionarse es crear su propio rastreador web que extraiga información de un sitio web y siga todos los enlaces dentro de ese sitio (y todos los enlaces de esos enlaces, etc.).

Resolví un problema con un patrón de caballero (en un tablero de ajedrez) usando un programa recursivo. Se suponía que debías mover al caballero para que tocara cada cuadro, excepto unos pocos cuadros marcados.

Tu simplemente:

mark your "Current" square
gather a list of free squares that are valid moves
are there no valid moves?
    are all squares marked?
        you win!
for each free square
    recurse!
clear the mark on your current square.
return.    

Se pueden trabajar muchos tipos de escenarios de "anticipación" probando las posibilidades futuras en un árbol como este.