Mini-Poker

Resolvi fazer uma pausa nos algoritmos de ordenação para mostrar como podemos usar os conhecimentos já adquiridos de maneira prática. Vamos neste artigo resolver o problema Mini-Poker, que caiu na prova da Programação Nível 2 (categoria para pessoas até 19 anos ou primeiro ano da faculdade) da Olimpíada Brasileira de Informática de 2005.

Esse post ficou gigante, mas é muito simples. Leia com atenção e acho que você não terá problemas… ;)

Objetivos

Com esta resolução de problema, espero treinar com vocês o conceito de:

  • Interpretação do Probema
  • Entrada e Saída
  • Ordenação por Inserção
  • Pseudocódigo

Acho que será legal para pôrmos em prática o que já estudamos sobre algoritmos.

O problema é bem simples, mas é só pra iniciar. Depois vamos resolvendo problemas cada vez mais difíceis… ;)

Enunciado

Mini-Poker é o nome do jogo de cartas que é uma simplificação de Poker, um dos mais famosos jogos de cartas do mundo. Mini-Poker é jogado com um baralho normal de 52 cartas, com quatro naipes (copas, paus, espadas e ouro), cada naipe compreendendo treze cartas (Ás, 2, 3, 4, 5, 6, 7, 8, 9, 10, Valete, Dama, Rei).

No início do jogo, cada jogador recebe cinco cartas. O conjunto de cinco cartas vale um certo número de pontos, de acordo com as regras descritas abaixo. Diferentemente do jogo de Poker normal, em Mini-poker o naipe das cartas é desconsiderado. Assim, para simplificar a descrição do jogo, vamos utilizar os números de 1 a 13 para identificar as cartas do baralho, na ordem dada acima. Uma outra diferença é que pode ocorrer empate entre mais de um vencedor; nesse caso os vencedores dividem o prêmio.

As regras para pontuação em Mini-Poker são as seguintes:

  1. Se as cinco cartas estão em seqüência a partir da carta [tex]x[/tex] (ou seja, os valores das cartas são [tex]x[/tex], [tex]x+1[/tex], [tex]x+2[/tex], [tex]x+3[/tex] e [tex]x+4[/tex]), a pontuação é [tex]x+200[/tex] pontos. Por exemplo, se as cartas recebidas são 10, 9, 8, 11 e 12, a pontuação é 208 pontos.
  2. Se há quatro cartas iguais [tex]x[/tex] (uma quadra, ou seja, os valores das cartas são [tex]x[/tex], [tex]x[/tex], [tex]x[/tex], [tex]x[/tex] e [tex]y[/tex]), a pontuação é [tex]x+180[/tex] pontos. Por exemplo, se as cartas recebidas são 1, 1, 1, 10 e 1, a pontuação é 181 pontos.
  3. Se há três cartas iguais [tex]x[/tex] e outras duas cartas iguais [tex]y[/tex] (uma trinca e um par, ou seja, os valores das cartas são [tex]x[/tex], [tex]x[/tex], [tex]x[/tex], [tex]y[/tex] e [tex]y[/tex]), a pontuação é [tex]x+160[/tex] pontos. Por exemplo, se as cartas recebidas são 10, 4, 4, 10 e 4, a pontuação é 164 pontos.
  4. Se há três cartas iguais [tex]x[/tex] e duas outras cartas diferentes [tex]y[/tex] e [tex]z[/tex] (uma trinca, ou seja, os valores das cartas são [tex]x[/tex], [tex]x[/tex], [tex]x[/tex], [tex]y[/tex] e [tex]z[/tex]), a pontuação é [tex]x+140[/tex] pontos. Por exemplo, se as cartas recebidas são 2, 3, 2, 2 e 13, a pontuação é 142 pontos.
  5. Se há duas cartas iguais [tex]x[/tex], duas outras cartas iguais [tex]y[/tex] ([tex]x \neq{} y[/tex]) e uma outra carta distinta [tex]z[/tex] (dois pares, ou seja, os valores das cartas são [tex]x[/tex], [tex]x[/tex], [tex]y[/tex], [tex]y[/tex] e [tex]z[/tex]), a pontuação é [tex]3 \times{} x + 2 \times{} y + 20[/tex] pontos, em que [tex]x > y[/tex]. Por exemplo, se as cartas recebidas são 12, 7, 12, 8 e 7, a pontuação é 70 pontos.
  6. Se há apenas duas cartas iguais [tex]x[/tex] e as outras são distintas (um par, ou seja, os valores das cartas são [tex]x[/tex], [tex]x[/tex], [tex]y[/tex], [tex]z[/tex] e [tex]t[/tex]), a pontuação é [tex]x[/tex] pontos. Por exemplo, se as cartas recebidas são 12, 13, 5, 8 e 13, a pontuação é 13 pontos.
  7. Se todas as cartas são distintas, não há pontuação.

Tarefa

Escreva um programa que, fornecidas as cartas dadas a um jogador, calcule a pontuação do jogador naquela jogada.

Entrada

A entrada é composta por vários casos de teste, cada um correspondendo a uma jogada. A primeira linha da entrada contém um número inteiro [tex]N[/tex] que indica o número de casos de teste ([tex]1 \leq{} N \leq{} 100[/tex]). Cada uma das [tex]N[/tex] linhas seguintes contém cinco números inteiros [tex]C_{1}[/tex], [tex]C_{2}[/tex], [tex]C_{3}[/tex], [tex]C_{4}[/tex] e [tex]C_{5}[/tex], representando as cinco cartas recebidas por um jogador ([tex]1 \leq{} C_{1}, C_{2}, C_{3}, C_{4}, C_{5} \leq{} 13[/tex]).

A entrada deve ser lida do dispositivo de entrada padrão (normalmente o teclado).

Saída

Para cada caso de teste da entrada, seu programa deve produzir três linhas na saída. A primeira linha deve conter um identificador do caso de teste, no formato “Teste n”, onde n é numerado seqüencialmente a partir de 1. A segunda linha deve conter a pontuação do jogador considerando as cinco cartas recebidas. A terceira linha deve ser deixada em branco. A grafia mostrada no Exemplo de Saída, abaixo, deve ser seguida rigorosamente.

A saída deve ser escrita no dispositivo de saída padrã (normalmente a tela).

Restrições

[tex]1 \leq{} N \leq{} 100[/tex]

[tex]1 \leq{} C_{1}, C_{2}, C_{3}, C_{4}, C_{5} \leq{} 13[/tex]

Exemplo de Entrada

2
12 3 10 3 12
1 2 3 5 4

Saída para o Exemplo de Entrada

Teste 1
62

Teste 2
201

Comentários sobre os problemas de olimpíadas

Todos os problemas passados em competições de programação tem um enunciado parecido com o desse. São especificados todos os limites (restrições), é dito exatamente como será a entrada e como deve ser a saída e geralmente tem uma historinha no começo… :D

Bom… Todos esses dados são fundamentais. Alguns limites nem vamos usar, não tem importância para a nossa solução, mas pode ter importância para outra pessoa que queira implementar um algoritmo diferente. A sintaxe da entrada e da saída são extremamente importantes. Na prova da Seletiva IOI do ano passado, eu quase perdi 60 pontos (6 casos de teste) na solução de um problema simples porque meu programa desprezava um espaço no início de uma frase quando imprimia uma saída. E mesmo a historinha do começo é fundamental. Ela sempre dá boas dicas e algumas vezes até ilustra o problema (às vezes a gente nem lê o enunciado e já sabe que é um problema de grafos!)

Mas vamos a solução deste problema…

Por onde começar?

Com o tempo você pode decidir fazer um caminho diferente, mas eu sugiro começar sempre pelo recebimento da entrada. Aliás, acho que isto é atípico, porque a maioria das pessoas prefere ler bastante o problema e desenvolver todo o algoritmo a mão antes de botar a mão na massa. Eu acho que depois que a gente recebe a entrada, fica bem mais fácil fazer o resto e a gente pode ir pensando enquanto a gente recebe a entrada! Então, depois que lemos o problema e já entendemos tudo o que ele quer, vamos fazer a entrada!

O problema fala que começa nos dando um número N que será o número de casos de teste que teremos que receber depois. Sem dificuldade podemos escrever o pseudocódigo a seguir:

recebe N
para nteste [tex]\leftarrow{}[/tex] 1 até N, faça
fim-para

Já chamo a variável que loopa como nteste, porque já li a saída do problema e sei que vou precisar imprimir o número de caad caso de teste… ;)

Aí o enunciado diz que Cada uma das [tex]N[/tex] linhas seguintes contém cinco números inteiros [tex]C_{1}[/tex], [tex]C_{2}[/tex], [tex]C_{3}[/tex], [tex]C_{4}[/tex] e [tex]C_{5}[/tex], representando as cinco cartas recebidas por um jogador ([tex]1 \leq{} C_{1}, C_{2}, C_{3}, C_{4}, C_{5} \leq{} 13[/tex]). Então, vamos receber os cinco números em cada iteração e colocá-los num vetor, é claro!

recebe N
para nteste [tex]\leftarrow{}[/tex] 1 até N, faça
	recebe [tex]C_{1}, C_{2}, C_{3}, C_{4}, C_{5}[/tex]
fim-para

E a entrada está pronta.

Desenvolvimento

O programa se baseia em encontrarmos valores iguais nos elementos do vetor. O que podemos fazer para facilitar essa tarefa?

Isso mesmo: A ordenação! :D Se os elementos estiverem ordenados, ficará bem mais fácil para procurarmos quatro números iguais, porque eles não poderão ser qualquer uma das possibilidades, mas somente [tex]C_{1}, C_{2}, C_{3}, C_{4}[/tex] ou [tex]C_{2}, C_{3}, C_{4}, C_{5}[/tex].

Aí que algoritmos devemos implementar para ordenar? Isso é uma conclusão que vamos chegar no final de nossa série, mas para este algoritmo não tem solução melhor que a Ordenação por Inserção. É um caso pequeno (n=5) e a Ordenação por Inserção é mais rápida que a por Seleção, porque o seu melhor caso é uma função linear. Então, vamos implementar o Insertion Sort no nosso algoritmo:

recebe N
para nteste [tex]\leftarrow{}[/tex] 1 até N, faça
	recebe [tex]C_{1}, C_{2}, C_{3}, C_{4}, C_{5}[/tex]
	início da ordenação por inserção
	para j [tex]\leftarrow{}[/tex] 2 até 5
		elemento [tex]\leftarrow{}[/tex] [tex]C_{j}[/tex]
		i [tex]\leftarrow{}[/tex] j-1
		enquanto i > 0 e [tex]C_{i}[/tex] > elemento, faça
			[tex]C_{i+1}[/tex] [tex]\leftarrow{}[/tex] [tex]C_{i}[/tex]
			[tex]i[/tex] [tex]\leftarrow{}[/tex] [tex]C_{i-1}[/tex]
		fim-enquanto
		[tex]C_{i+1}[/tex] [tex]\leftarrow{}[/tex] elemento
	fim-para
	fim da ordenação por inserção
fim-para

O bom desses algoritmos de ordenação é que sua lógica é muito simples e por isso é fácil decorá-los… Ao menos o Insertion Sort e o Selection Sort são algoritmos básicos que todo programador deve conhecer bem. Bom… Acredito que vocês não tenham tido dificuldade pra entender até aqui. A cor vermelha no pseudocódigo eu vou usar daqui pra frente para um comentário, que aliás, é uma excelente prática de boa programação.

O resto do problema precisa calcular quantos pontos o cara fez, baseado em suas cartas, agora já ordenadas. Para isto vamos criar uma função para testar vários se e retornar o resultado.

Eu poderia tirar os se aninhados, mas assim fica mais fácil a compreensão.

Como vamos ver com os pseudocódigos a seguir, é fácil testar cada uma das regras com o vetor ordenado:

Primeira Regra – Seqüência

Se as cinco cartas estão em seqüência a partir da carta [tex]x[/tex] (ou seja, os valores das cartas são [tex]x[/tex], [tex]x+1[/tex], [tex]x+2[/tex], [tex]x+3[/tex] e [tex]x+4[/tex]), a pontuação é [tex]x+200[/tex] pontos. Por exemplo, se as cartas recebidas são 10, 9, 8, 11 e 12, a pontuação é 208 pontos.

se [tex]C_{1} = C_{2}-1[/tex] e [tex]C_{2} = C_{3}-1[/tex] e [tex]C_{3}=C_{4}-1[/tex] e [tex]C_{4}=C_{5}-1[/tex], então
 	retorna [tex]C_{1}+200[/tex]
fim-se

Segunda Regra – Quadra

Se há quatro cartas iguais [tex]x[/tex] (uma quadra, ou seja, os valores das cartas são [tex]x[/tex], [tex]x[/tex], [tex]x[/tex], [tex]x[/tex] e [tex]y[/tex]), a pontuação é [tex]x+180[/tex] pontos. Por exemplo, se as cartas recebidas são 1, 1, 1, 10 e 1, a pontuação é 181 pontos.

se [tex]C_{1} = C_{2} = C_{3} = C_{4}[/tex] ou [tex]C_{2} = C_{3} = C_{4} = C_{5}[/tex], então
	retorna [tex]C_{2}+180[/tex]
fim-se

Aqui retornamos [tex]C_{2}[/tex] porque ele será sempre parte da quadra (ela começando em [tex]C_{1}[/tex] ou [tex]C_{2}[/tex]).

Terceira e Quarta Regra – Trinca

Se há três cartas iguais [tex]x[/tex] e outras duas cartas iguais [tex]y[/tex] (uma trinca e um par, ou seja, os valores das cartas são [tex]x[/tex], [tex]x[/tex], [tex]x[/tex], [tex]y[/tex] e [tex]y[/tex]), a pontuação é [tex]x+160[/tex] pontos. Por exemplo, se as cartas recebidas são 10, 4, 4, 10 e 4, a pontuação é 164 pontos.

se [tex]C_{1} = C_{2} = C_{3}[/tex] ou [tex]C_{2} = C_{3} = C_{4}[/tex] ou [tex]C_{3} = C_{4} = C_{5}[/tex], então
	se ( [tex]C_{1} \neq{} C_{3}[/tex] e [tex]C_{1} = C_{2}[/tex] ) ou ( [tex]C_{3} \neq{} C_{5}[/tex] e [tex]C_{4} = C_{5}[/tex] ), então
		retorna [tex]C_{3}+160[/tex]

Se há três cartas iguais [tex]x[/tex] e duas outras cartas diferentes [tex]y[/tex] e [tex]z[/tex] (uma trinca, ou seja, os valores das cartas são [tex]x[/tex], [tex]x[/tex], [tex]x[/tex], [tex]y[/tex] e [tex]z[/tex]), a pontuação é [tex]x+140[/tex] pontos. Por exemplo, se as cartas recebidas são 2, 3, 2, 2 e 13, a pontuação é 142 pontos.

	senão
		retorna [tex]C_{3} + 140[/tex]
	fim-se
fim-se

Note que aqui retornamos [tex]C_{3}[/tex] porque ele será sempre parte da trinca (o mesmo motivo que retornarmos [tex]C_{2}[/tex] para a quadra).

Quinta Regra – Duas Duplas

Se há duas cartas iguais [tex]x[/tex], duas outras cartas iguais [tex]y[/tex] ([tex]x \neq{} y[/tex]) e uma outra carta distinta [tex]z[/tex] (dois pares, ou seja, os valores das cartas são [tex]x[/tex], [tex]x[/tex], [tex]y[/tex], [tex]y[/tex] e [tex]z[/tex]), a pontuação é [tex]3 \times{} x + 2 \times{} y + 20[/tex] pontos, em que [tex]x > y[/tex]. Por exemplo, se as cartas recebidas são 12, 7, 12, 8 e 7, a pontuação é 70 pontos.

se [tex]C_{1} = C_{2}[/tex] ou [tex]C_{2} = C_{3}[/tex], então
	se [tex]C_{3} = C_{4}[/tex] ou [tex]C_{4} = C_{5}[/tex], então
		retorna [tex]3 \times{} C_{4} + 2 \times{} C_{2} +20[/tex]
	fim-se
fim-se

[tex]C_{2}[/tex] será sempre elemento da menor dupla e [tex]C_{4}[/tex] será sempre elemento da maior dupla. Por isso usamos eles como [tex]y[/tex] e [tex]x[/tex], respectivamente.

Sexta Regra – Dupla

Se há apenas duas cartas iguais [tex]x[/tex] e as outras são distintas (um par, ou seja, os valores das cartas são [tex]x[/tex], [tex]x[/tex], [tex]y[/tex], [tex]z[/tex] e [tex]t[/tex]), a pontuação é [tex]x[/tex] pontos. Por exemplo, se as cartas recebidas são 12, 13, 5, 8 e 13, a pontuação é 13 pontos.

se [tex]C_{1} = C_{2}[/tex] ou [tex]C_{2} = C_{3}[/tex], então
	retorna [tex]C_{2}[/tex]
senão se [tex]C_{3} = C_{4}[/tex] ou [tex]C_{4} = C_{5}[/tex],
então
	retorna [tex]C_{4}[/tex]
fim-se

Separei em dois SEs porque senão não saberíamos que valor retornar.

Sétima Regra

Se todas as cartas são distintas, não há pontuação.

retorna 0

Função Inteira

Juntando todos os SEs, temos:

função pontua (C)

primeira regra
se [tex]C_{1} = C_{2}-1[/tex] e [tex]C_{2} = C_{3}-1[/tex] e [tex]C_{3}=C_{4}-1[/tex] e [tex]C_{4}=C_{5}-1[/tex], então
 	retorna [tex]C_{1}+200[/tex]
fim-se

segunda regra
se [tex]C_{1} = C_{2} = C_{3} = C_{4}[/tex] ou [tex]C_{2} = C_{3} = C_{4} = C_{5}[/tex], então
	retorna [tex]C_{2}+180[/tex]
fim-se

terceira e quarta regra
se [tex]C_{1} = C_{2} = C_{3}[/tex] ou [tex]C_{2} = C_{3} = C_{4}[/tex] ou [tex]C_{3} = C_{4} = C_{5}[/tex], então
	se ( [tex]C_{1} \neq{} C_{3}[/tex] e [tex]C_{1} = C_{2}[/tex] ) ou ( [tex]C_{3} \neq{} C_{5}[/tex] e [tex]C_{4} = C_{5}[/tex] ), então
		retorna [tex]C_{3}+160[/tex]
	senão
		retorna [tex]C_{3} + 140[/tex]
	fim-se
fim-se

quinta regra
se [tex]C_{1} = C_{2}[/tex] ou [tex]C_{2} = C_{3}[/tex], então
	se [tex]C_{3} = C_{4}[/tex] ou [tex]C_{4} = C_{5}[/tex], então
		retorna [tex]3 \times{} C_{4} + 2 \times{} C_{2} +20[/tex]
	fim-se
fim-se

sexta regra
se [tex]C_{1} = C_{2}[/tex] ou [tex]C_{2} = C_{3}[/tex], então
	retorna [tex]C_{2}[/tex]
senão se [tex]C_{3} = C_{4}[/tex] ou [tex]C_{4} = C_{5}[/tex],
então
	retorna [tex]C_{4}[/tex]
fim-se

sétima regra
retorna 0

fim-função

Já que a função retorna assim que encontra um resultado, não há risco de ocorrer nada errado (por exemplo, uma quadra é sempre uma trinca, que é sempre uma dupla). Agora basta colocarmos esta função no nosso código e adaptar para a saída ser igual a que o problema pede.

Saída

Para chegar a saída, basta fazermos o programa imprimir Teste nteste e depois o retorno da função pontua. Com isto, temos:

recebe N
para nteste [tex]\leftarrow{}[/tex] 1 até N, faça
	recebe [tex]C_{1}, C_{2}, C_{3}, C_{4}, C_{5}[/tex]
	início da ordenação por inserção
	para j [tex]\leftarrow{}[/tex] 2 até 5
		elemento [tex]\leftarrow{}[/tex] [tex]C_{j}[/tex]
		i [tex]\leftarrow{}[/tex] j-1
		enquanto i > 0 e [tex]C_{i}[/tex] > elemento, faça
			[tex]C_{i+1}[/tex] [tex]\leftarrow{}[/tex] [tex]C_{i}[/tex]
			[tex]i[/tex] [tex]\leftarrow{}[/tex] [tex]C_{i-1}[/tex]
		fim-enquanto
		[tex]C_{i+1}[/tex] [tex]\leftarrow{}[/tex] elemento
	fim-para
	fim da ordenação por inserção

	imprime "Teste "
	imprime linha testen
	imprime linha pontua(C)
	imprime linha
fim-para

Fiz essa saída assim pra se parecer com Pascal, mas para cada linguagem ela pode ser bem diferente… Vejamos dois exemplos…

C

printf("Teste %d\n%d\n\n", nteste, pontua(C));

PHP

echo "Teste ".$nteste."\n".pontua($C)."\n\n";

Programa Completo

função pontua (C)

primeira regra
se [tex]C_{1} = C_{2}-1[/tex] e [tex]C_{2} = C_{3}-1[/tex] e [tex]C_{3}=C_{4}-1[/tex] e [tex]C_{4}=C_{5}-1[/tex], então
 	retorna [tex]C_{1}+200[/tex]
fim-se

segunda regra
se [tex]C_{1} = C_{2} = C_{3} = C_{4}[/tex] ou [tex]C_{2} = C_{3} = C_{4} = C_{5}[/tex], então
	retorna [tex]C_{2}+180[/tex]
fim-se

terceira e quarta regra
se [tex]C_{1} = C_{2} = C_{3}[/tex] ou [tex]C_{2} = C_{3} = C_{4}[/tex] ou [tex]C_{3} = C_{4} = C_{5}[/tex], então
	se ( [tex]C_{1} \neq{} C_{3}[/tex] e [tex]C_{1} = C_{2}[/tex] ) ou ( [tex]C_{3} \neq{} C_{5}[/tex] e [tex]C_{4} = C_{5}[/tex] ), então
		retorna [tex]C_{3}+160[/tex]
	senão
		retorna [tex]C_{3} + 140[/tex]
	fim-se
fim-se

quinta regra
se [tex]C_{1} = C_{2}[/tex] ou [tex]C_{2} = C_{3}[/tex], então
	se [tex]C_{3} = C_{4}[/tex] ou [tex]C_{4} = C_{5}[/tex], então
		retorna [tex]3 \times{} C_{4} + 2 \times{} C_{2} +20[/tex]
	fim-se
fim-se

sexta regra
se [tex]C_{1} = C_{2}[/tex] ou [tex]C_{2} = C_{3}[/tex], então
	retorna [tex]C_{2}[/tex]
senão se [tex]C_{3} = C_{4}[/tex] ou [tex]C_{4} = C_{5}[/tex],
então
	retorna [tex]C_{4}[/tex]
fim-se

sétima regra
retorna 0

fim-função

recebe N
para nteste [tex]\leftarrow{}[/tex] 1 até N, faça
	recebe [tex]C_{1}, C_{2}, C_{3}, C_{4}, C_{5}[/tex]
	início da ordenação por inserção
	para j [tex]\leftarrow{}[/tex] 2 até 5
		elemento [tex]\leftarrow{}[/tex] [tex]C_{j}[/tex]
		i [tex]\leftarrow{}[/tex] j-1
		enquanto i > 0 e [tex]C_{i}[/tex] > elemento, faça
			[tex]C_{i+1}[/tex] [tex]\leftarrow{}[/tex] [tex]C_{i}[/tex]
			[tex]i[/tex] [tex]\leftarrow{}[/tex] [tex]C_{i-1}[/tex]
		fim-enquanto
		[tex]C_{i+1}[/tex] [tex]\leftarrow{}[/tex] elemento
	fim-para
	fim da ordenação por inserção

	imprime "Teste "
	imprime linha testen
	imprime linha pontua(C)
	imprime linha
fim-para

Comentários sobre o problema

Este problema é muito chato. É trivial, mas perdemos um tempo enorme escrevendo ses. Ninguém gosta de um problema como esse, mas quando cai numa olimpíada somos obrigados a resolver… hehehe… Mas, para a felicidade geral de todos, saibam que a maioria dos problemas de olimpíadas não são assim. Exigem mais lógica e menos código. Com o tempo, vamos pegando problemas mais difíceis. Espero só ter cumprido meu objetivo dando uma utilidade pra ordenação, entrada e saída e que vocês tenham entendido tudo.

Espero que tenham gostado da solução. Eu implementei este programa em C há seis meses e se você estiver interessado, sua solução está aqui: poker.c.

Sugiro que quem esteja aprendendo algoritmos com meus artigos e já saiba programar um pouquinho, resolva alguns problemas simples do site da OBI, que separei especialmente pra vocês!

E, gostaria de fixar, mais importante é a interpretação e o seu pensamento… Programar é fácil! :D

Recursão

A recursão é uma das técnicas mais simples e úteis que existem para usarmos em nossos algoritmos. Consiste em uma função (denominada recursiva) chamar a si mesmo, até que o retorno seja trivial. Resolvi abordá-la aqui porque alguns algoritmos que estudaremos mais para frente usam funções recursivas.

Gostaria de, antes de falar sobre o assunto, contar um pouco da minha história com recursão, porque foi meu início no mundo dos algoritmos.

Junho de 2004, tinha eu 13 anos e fui premiado com medalha de ouro na modalidade iniciação da Olimpíada de Informática. Fui convidado para o curso de introdução a programação na UNICAMP e, extremamente geek como eu era (e ainda sou), falei para os professores que já programava em C e então eles sugeriram que eu fosse para o curso de programação avançada.

No entanto, eu ainda achava muito complicado os algoritmos da modalidade de programação da OBI, por isso pedi pra ficar num “meio-termo”. Eles toparam numa boa e com isso passei a ter aulas com um monitor excelente (aluno da UNICAMP) chamado Ribamar. Esse cara foi extremamente importante para minha iniciação na programação de verdade.

Na primeira tarde que tive aula com ele, ele perguntou se eu sabia o que era recursão. Respondi que não e, a partir daquele dia e depois de ele me ensinar também de grafos e programação dinâmica, além de me apresentar o Slackware, me tornei um amante de algoritmos. A recursão, portanto, mesmo sendo algo simples, é um assunto especial pra mim porque representa a mudança de “nível”.

Então, mãos à obra!


Em matemática, o número fatorial de [tex]n[/tex] é igual a: [tex]n \times{} n-1 \times{} n-2 \times{} \ldots{} 2 \times{} 1[/tex].

Logo, por exemplo, [tex]5![/tex] (cinco fatorial) seria igual a: [tex]5 \times{} 4 \times{} 3 \times{} 2 \times{} 1 = 120[/tex].


Um exemplo bom e simples de recursão é um algoritmo para determinar números fatoriais:

1. função fatorial (n)
2.	se [tex]n = 1[/tex], então
3.		retorna [tex]1[/tex]
4.	senão
5.		retorna [tex]n \times{} fatorial(n-1)[/tex]
6.	fim-se
7. fim-função

Domínio de nossa função: [tex]n \in{} \mathbf{N} / n \geq{} 1[/tex].

Qual o custo desse algoritmo?

Vamos abrir um grande parênteses aqui até a próxima linha horizontal para descobrir qual o custo do nosso algoritmo antes de continuar com a conversa sobre recursão e relembrar/reforçar o post sobre Análise de Algoritmos. Vou colocar o número de vezes que cada instrução é executada, usando o esquema que será o padrão para as próximas vezes que veremos custos:

Número da linha: Número de vezes que é executada..

  1. [tex]n[/tex]
  2. [tex]n-1[/tex]
  3. [tex]1[/tex]
  4. [tex]n-1[/tex]
  5. [tex]n-1[/tex]

[tex]T(n) = (n) + (n-1) + (1) + (n-1) + (n-1) = 4n – 2[/tex]

Uma função linear, o tipo de algoritmo mais simples que podemos encontrar, com excessão dos que são uma função constante. Mas o parênteses na verdade não serviu só pra isso. Eu queria aproveitar pra escovar uns bits de nosso código. Você percebeu que o primeiro condicional é executado [tex]n-1[/tex] vezes, mas só entramos nele uma vez? Então vamos inverter nosso condicional.

1. função fatorial (n)
2.	se [tex]n > 1[/tex], então
3.		retorna [tex]n \times{} fatorial(n-1)[/tex]
4.	senão
5.		retorna [tex]1[/tex]
6.	fim-se
7. fim-função

Novo custo

  1. [tex]n[/tex]
  2. [tex]n-1[/tex]
  3. [tex]n-1[/tex]
  4. [tex]1[/tex]
  5. [tex]1[/tex]

[tex]T(n) = (n) + (n-1) + (n-1) + (1) + (1) = 3n[/tex]

Claro que continua uma função linear, não houve nenhuma grande mudança. Os dois continuam com a mesma ordem de crescimento e tal… [tex]4n+2[/tex] comparado com [tex]3n[/tex] é uma diferença pequena, mas essa solução ficou bem mais elegante. ;) Poxa, diminuímos o custo do algoritmo em [tex]\frac{1}{4}[/tex]! Hehehe…

Agora, antes de continuar, só vamos definir a notação assintótica desse nosso novo custo!

A fórmula do [tex]\Theta{}[/tex] é: [tex]0 \leq{} c_{1} g(n) \leq{} f(n) \leq{} c_{2} g(n)[/tex]

Substituindo pela nossa função, temos: [tex]c_{1}n \leq{} 3n \leq{} c_{2}n[/tex]. É trivial, que podemos escolher para as duas constantes [tex]c_{1}=c_{2}=3[/tex] e para [tex]n_{0}=0[/tex]. Com isso pretendi mostrar-lhes uma conclusão óbvia que no outro artigo não tinha mostrado para não complicar muito: uma função reta (linear) pertence sempre a notação [tex]\Theta{}(n)[/tex] e uma função quadrática pertence sempre a notação [tex]\Theta{}(n^{2})[/tex] (ora, façam um gráfico das funções e vejam se isso não é óbvio!). Mas vamos aprendendo mais sobre análise de algoritmos com o tempo…


Bom… Continuando com a recursão… Nossa função cria um loop consigo mesma, ao invés de usar um para (for) ou enquanto (while). Ela se repete diminuindo um de [tex]n[/tex] a cada iteração, até que chegue ao valor mínimo [tex]1[/tex] aonde a resposta é trivial: [tex]1[/tex].

O que é necessário para criarmos uma recursão? Apenas um ponto de parada! Temos que tomar cuidado para não criarmos loops infinitos cuidando sempre com cada entrada que o usuário pode colocar. Nesse caso, eu determinei que o domínio da função é [tex]n \in{} \mathbf{N} / n \geq{} 1[/tex]. Se o cara colocasse [tex]n=0[/tex], minha função iria diminuindo infinitamente… e nunca iria retornar nada!

Para fazer a recursão portanto, precisamos analisar o domínio de nossa função e mais: precisamos conhecer um valor (que vai ser o limite; no caso do fatorial, o valor que sabíamos é que [tex]1! = 1[/tex]).

Acredito que vocês tenham achado tudo simples e que não tenham problema com isso. Funções recursivas vão ser extremamente úteis para nós nos próximos artigos. Vou finalizar mostrando-lhes alguns casos básicos de algoritmos em que podemos usar a recursão:

Números de Fibonacci

1. função fibonacci (n)
2.	se [tex]n \geq{} 3[/tex], então
3.		retorna [tex]fibonacci(n-1) + fibonacci(n-2)[/tex]
4.	senão
5.		retorna [tex]1[/tex]
6.	fim-se
7. fim-função

Domínio de fibonacci(n): [tex]n \in{} N / n \geq{} 1[/tex]

Depois descobriremos como calcular os números de Fibonacci mais rápido, mas por enquanto nosso objetivo é a recursão!

Substituir um loop

Vamos supor que você quer imprimir os números de n a 1 e esqueceu a sintaxe do para:D

1. função imprime_ate (n)
2.	imprima [tex]n[/tex]
3.	se [tex]n>1[/tex], então
4.		imprime_ate(n-1)
5.	fim-se
6. fim-função

Domínio de imprime_ate(n): [tex]n \in{} N / n \geq{} 1[/tex]

Todo loop pode ser uma recursão e tem alguns que ficam bem mais fáceis se forem! Nesse caso, é claro que seria mais simples usarmos um para!

Outros exemplos, para concluir

  • Ordenação por Intercalação (Merge Sort)
  • Busca em Profundidade (Depth-First Search) em Grafos
  • Union/Find
  • … entre vários outros casos!