Seja o seguinte programa Python: Admita que o módulo ...

Estou sentindo falta de comentários dos professores de TI! Atenção qconcursos !!!! Precisamos de comentários dos professores para TI! Senão não tem sentindo fazer a assinatura!!!!

Vamos lá:

O que você precisa saber para resolver essa questão: recursividade, um pouco de pilha E fatiamento de string.

Em resumo: recursividade é quando uma função chama ela mesma, criando um loop. E sobre pilha você tem que saber que o último a entrar é o primeiro a sair, pense numa pilha de pratos, se tirar o mais antigo vai quebrar tudo, mas se você for tirando do topo tudo ficará bem.

Fatiamento de string é você ter uma string e delimitar o que você quer dela. Como string[inicio(inclusivo):fim(exclusivo):passo(padrão 1)]

Além disso, saber que 'push' quer dizer inserir e 'pop' retirar. Agora fica mais claro. 'push' irá colocar no TOPO e 'pop' irá retirar do TOPO.

O programa começa de fato em:

list=[23,80,76,45,8]

pil=[]

reparte(list,pil)

No qual temos a primeira chamada a função reparte.

Aqui será passado reparte( [23,80,76,45,8] , [] ). Notem, a pilha está vazia.

def reparte(list, pil):

    tam=len(list) -> Terá tamanho 5

    if tam==0: -> Falso

        return

    if tam==1: -> Falso

        push(pil, list[0])

        return

    centro=tam//2 -> O // é usado para divisão inteiras, logo, centro = 2

    push(pil,list[centro]) -> O push vai colocar o elemento list[2] na pilha pil. list[2] == 76 (Opa! Já temos o primeiro elemento, mas como teremos mais elementos inseridos podemos dizer com 100% de ctz que esse 76 está na base da "pilha de pratos", portanto, aqui primeiro, mas no final do programa será o último)

    reparte(list[centro+1:tam], pil) -> Recursividade, chama reparte( list [ 3 : 5 ] , [ 76 ]). Leia [ 3 : 5] como do índice 3 ao 4 -> reparte([45 8] , [76]). Tudo de novo.

   tam=len(list) -> Terá tamanho 2

    if tam==0: -> Falso

        return

    if tam==1: -> Falso

        push(pil, list[0])

        return

    centro=tam//2 -> centro = 1

    push(pil,list[centro]) -> push([76], [8]), logo o 8 é o segundo a ser inserido e estará na frente do 76. A partir disso já dá para afirmar que é a letra C.

while bool(pil):

    print(pop(pil),end='')

Isso aqui é só para imprimir o conteúdo da lista que chamamos de pil. O pop remove o último elemento a ser colocado, portanto, retorna um inteiro que será impresso pelo print. O end='' é para dizer ao print para não quebrar a linha.

Na segunda iteração já da pra saber qual a resposta.

Uma forma meio biruteteia de explicar recursividade é que imagine que a função Reparte() seja uma pessoa. Essa pessoa precisa de uma resposta que não consegue calcular pois é muito complexa, então ela para o tempo e abre um portal para outra dimensão para perguntar uma versão mais simples da pergunta para seu doppelganger. O doppelganger por sua vez também não sabe responder a pergunta e faz o mesmo, até que a pergunta seja simples o suficiente para ser respondida.

A partir do momento que a primeira pergunta é respondida (ou seja, a função retorna), a cadeia de doppelgangers vai passando a resposta para o de cima até a pergunta original poder ser respondida.

Uma coisa importante de ser notar é que os valores de pil se mantém depois dos returns das funções recursivas, de modo que, depois que a primeira recursão em reparte acaba, pil vai continuar com os valores [76, 8, 45] e adicionar os valores da segunda recursão.