Recursão sem fatorial, números de Fibonacci, etc.

Quase todos os artigos que posso encontrar sobre recursão incluem exemplos de números fatoriais ou de Fibonacci, que são:

1. Matemática
2. Inútil na vida real

Existem alguns exemplos de códigos não matemáticos interessantes para ensinar recursão?

Estou pensando em algoritmos de dividir e conquistar, mas eles geralmente envolvem estruturas de dados complexas.

As estruturas de diretório / arquivo são o melhor exemplo de uso para recursão, porque todo mundo as entende antes de iniciar, mas qualquer coisa que envolva estruturas semelhantes a árvores serve.

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;
}

Procure por coisas que envolvam estruturas de árvores. Uma árvore é relativamente fácil de entender, e a beleza de uma solução recursiva se torna aparente muito mais cedo do que com estruturas de dados lineares, como listas.

Coisas para pensar:

• sistemas de arquivos - são basicamente árvores; uma boa tarefa de programação seria buscar todas as imagens .jpg em um determinado diretório e todos os seus subdiretórios
• ancestral - dada uma árvore genealógica, encontre o número de gerações que você precisa percorrer para encontrar um ancestral comum; ou verifique se duas pessoas na árvore pertencem à mesma geração; ou verifique se duas pessoas na árvore podem se casar legalmente (depende da jurisdição :)
• Documentos do tipo HTML - converte entre a representação serial (texto) de um documento e uma árvore DOM; executar operações em subconjuntos de um DOM (talvez até implemente um subconjunto de xpath?); ...

Todos eles estão relacionados aos cenários reais do mundo real e podem ser usados ​​em aplicativos com significado no mundo real.

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

• modelando uma infecção contagiosa
• geometria geradora
• gerenciamento de diretório
• Ordenação

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

• raytracing
• xadrez
• analisando o código fonte (gramática do idioma)

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

• Pesquisa BST
• Torres de Hanói
• pesquisa palíndromo

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

• Dá uma bela história em inglês que ilustra a recursão de uma história de ninar.

Aqui estão alguns problemas mais práticos que me vêm à mente:

• Mesclar Classificação
• Pesquisa binária
• Transversal, Inserção e Remoção em Árvores (amplamente utilizado em aplicativos de banco de dados)
• Gerador de permutações
• Solver de Sudoku (com retorno)
• Verificação ortográfica (novamente com retorno)
• Análise de sintaxe (.eg, um programa que converte prefixo em notação postfix)

O QuickSort seria o primeiro a se lembrar. A pesquisa binária também é um problema recursivo. Além disso, existem classes inteiras de problemas, cujas soluções caem quase de graça quando você começa a trabalhar com recursão.

Sort, definido recursivamente em 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 )

Mesclar, definido recursivamente.

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:]) 

Pesquisa linear, definida recursivamente.

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

Pesquisa binária, 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:] )

Em certo sentido, recursão é dividir e conquistar soluções, que está elevando o espaço do problema para um menor, para ajudar a encontrar a solução para um problema simples e, em seguida, geralmente reconstruindo o problema original para compor a resposta certa.

Alguns exemplos que não envolvem matemática para ensinar recursão (pelo menos aqueles problemas que eu lembro dos meus anos de universidade):

• Torres de Hanói
• Oito rainhas

Estes são exemplos de como usar o Backtracking para resolver o problema.

Outros problemas são clássicos do domínio de Inteligência Artificial: Usando a Pesquisa em Profundidade Primeira, busca de caminhos, planejamento.

Todos esses problemas envolvem algum tipo de estrutura de dados "complexa", mas se você não deseja ensiná-lo com matemática (números), suas escolhas podem ser mais limitadas. Você pode querer começar a ensinar com uma estrutura de dados básica, como uma Lista vinculada. Por exemplo, representando os números naturais usando uma Lista:

0 = lista vazia 1 = lista com um nó. 2 = lista com 2 nós. ...

defina a soma de dois números em termos dessa estrutura de dados, da seguinte maneira: Vazio + N = N Nó (X) + N = Nó (X + N)

As torres de Hanói são boas para ajudar a aprender a recursão.

Existem muitas soluções para ele na web em vários idiomas diferentes.

Um detector Palindrome:

Comece com uma string: "ABCDEEDCBA" Se os caracteres iniciais e finais forem iguais, execute novamente e marque "BCDEEDCB", etc ...

Um algoritmo de pesquisa binária soa como o que você deseja.

Nas linguagens de programação funcional, quando não há funções de ordem superior disponíveis, a recursão é usada em vez de loops imperativos para evitar o estado mutável.

F # é uma linguagem funcional impura que permite os dois estilos, por isso vou comparar os dois aqui. A seguir soma todos os números em uma lista.

Loop imperativo com variável mutável

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

Loop recursivo sem estado mutável

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

Note-se que este tipo de agregação é capturado na função de ordem superior List.folde poderia ser escrita como List.fold (+) 0 xlistou mesmo ainda mais simples com a função de conveniência List.sumcomo apenas List.sum xlist.

Eu usei a recursão fortemente no jogo jogando AI. Escrevendo em C ++, fiz uso de uma série de cerca de 7 funções que se chamam em ordem (com a primeira função tendo a opção de ignorar todas elas e chamar uma cadeia de mais 2 funções). A função final em qualquer cadeia chamou a primeira função novamente até que a profundidade restante que eu desejasse pesquisar fosse 0, nesse caso a função final chamaria minha função de avaliação e retornaria a pontuação da posição.

As múltiplas funções permitiram-me ramificar facilmente com base nas decisões dos jogadores ou em eventos aleatórios no jogo. Eu usava passagem por referência sempre que podia, porque estava passando por estruturas de dados muito grandes, mas devido à forma como o jogo foi estruturado, era muito difícil ter um "desfazer" na minha pesquisa, então Eu usaria a passagem por valor em algumas funções para manter meus dados originais inalterados. Por isso, mudar para uma abordagem baseada em loop, em vez de uma abordagem recursiva, se mostrou muito difícil.

Você pode ver um esboço muito básico desse tipo de programa, consulte https://secure.wikimedia.org/wikipedia/en/wiki/Minimax#Pseudocode

Um bom exemplo da vida real nos negócios é algo chamado "Lista de materiais". Esses são os dados que representam todos os componentes que compõem um produto acabado. Por exemplo, vamos usar uma bicicleta. Uma bicicleta possui guidão, rodas, estrutura, etc. E cada um desses componentes pode ter subcomponentes. por exemplo, a roda pode ter raios, uma haste de válvula etc. Então, normalmente, estes são representados em uma estrutura de árvore.

Agora, para consultar qualquer informação agregada sobre a lista técnica ou para alterar elementos em uma lista técnica, muitas vezes você recorre à recursão.

    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>();
    }

E uma amostra de chamada 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, a Classe BomPart teria muitos outros campos. Talvez você precise descobrir quantos componentes plásticos você tem, quanto trabalho é necessário para construir uma peça completa, etc. Tudo isso volta à utilidade da Recursão em uma estrutura de árvore.

As relações familiares são bons exemplos, porque todo mundo as entende intuitivamente:

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

Um funcionamento interno bastante inútil, mas mostrando recursão, é recursivo strlen():

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

Sem matemática - uma função muito simples. É claro que você não o implementa recursivamente na vida real, mas é uma boa demonstração de recursão.

Outro problema de recursão do mundo real com o qual os alunos podem se relacionar é criar seu próprio rastreador da Web, que extrai informações de um site e segue todos os links desse site (e todos os links desses links, etc.).

Resolvi um problema com um padrão de cavaleiro (em um tabuleiro de xadrez) usando um programa recursivo. Você deveria mover o cavaleiro para que ele tocasse todos os quadrados, exceto alguns quadrados marcados.

Você simplesmente:

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.    

Muitos tipos de cenários de "pensamento antecipado" podem ser trabalhados testando possibilidades futuras em uma árvore como esta.