Segunda Fase da OBI2006

Sábado foi a OBI em Blumenau. A prova estava cansativa e difícil pra caramba… Na minha opinião, o nível de dificuldade foi semelhante a da Seletiva para IOI do ano passado.

Fui muito mal, mas pelos comentários parece que ninguém foi muito bem. Essa espera pelo resultado vai ser longa… Hehehe… Teve gente que não me interpretou direito, então vou falar de outra maneira: Estou ansioso pelo resultado, por isso as duas semanas vão demorar pra passar.

Resposta à Veja

Não posso deixar de linkar esse ótimo artigo do Falcon Dark (assinem o feed desse cara… tudo que ele escreve é excelente!): Para o público e o privado sem ideologismo. Ele comenta sobre a reportagem da Revista Veja de 17 de maio de 2006, página 68, O grátis saiu mais caro.

O Laptop do Reinaldo

Instalei GNU/Linux (Slackware) no laptop do Reinaldo. Um Pentium 3 900mhz, 128 mb ram, 6 gb de HD; que tá com uma performance legal agora, sem o Windows XP que possuía (ou melhor, que o possuía).

O legal é que a placa de rede do laptop era PCMCIA e o CD e o disquete não funcionavam direito! Foi uma experiência única e desesperadora… :) Hehehe…

Consegui bootar por um CD velho do Slackware 10.0 (o drive de CD só conseguiu ler esse CD de todos que eu tinha aqui) e só deu pra instalar a série A (os pacotes mais básicos). O resultado foi um sistema sem absolutamente nada (andei até perguntando pro Lorn se tinha como configurar rede sem ifconfig… hehehe). Depois de dois dias, quando quase estava indo entregar para o Reinaldo o laptop destruído (sem sistema operacional), lembrei que tinha um velho zip-drive externo USB aqui em casa. Pluguei, montei e funcionou! Aí consegui instalar a série N (Network) e a AP (aplicações básicas) para conseguir ver o meu computador na rede e copiar o Slackware 10.2 inteiro.

Finalizado esse passo, reiniciei o computador bootando pelo CD do Slackware 10.0, deletei tudo do HD (com excessão exceção do CD do Slackware 10.2 que eu tinha copiado) e consegui fazer a instalação. O computador tá excelente agora, com uma performance impecável! :D (usando XFCE como gerenciador de janelas)

Desafio Nacional Acadêmico

Esse ano vai acontecer pela primeira vez o DNA. É um dia com várias provas (segundo eles, quase impossíveis) solucionadas pela internet por equipes de cinco componentes. Tem prêmios para os três melhores colocados e já inscrevi minha equipe. A inscrição custa R$ 50,00. Quem puder, participe! É uma oportunidade legal…

OBI2006 em fase de correção…

As tarefas da modalidade Programação estão sendo corrigidas. Os gabaritos das provas da modalidade iniciação estão disponíveis, por enquanto apenas para professores (algumas escolas atrasaram a realização da prova, por isso a demora na divulgação do gabarito). Solicitamos os professores que consultem a área de acesso restrito para informações de como proceder para enviar os resultados de sua escola. (retirado do site da OBI)

O pessoal da Iniciação já sabe como foram por aqui… Meu colégio até que teve um resultado legal: dois alunos da iniciação 1 (meu irmão é um deles) fizeram 12 de 16 e três alunos da iniciação 2 fizeram 19 de 22. Provavelmente esses vão pra segunda fase.

E por falar em ir pra segunda fase…

Pensando um pouco, cheguei a conclusão de que todo competidor que acertou mais de uma questão (ou talvez até menos que isso) já deve estar na segunda fase.

Uns 20 competidores devem ir para Campinas (medalha de ouro). Outros 20 devem conseguir medalhas de prata, mais 30 medalhas de bronze e 30 menções honrosas. Então, no mínimo 100 precisam fazer a segunda fase.

Neste ano, 520 pessoas participaram da modalidade Programação 2. Grande parte desses falta na prova ou zera (digamos que seja metade). Dessa forma, sobram 260.

Já que essa prova de primeira fase foi só para acabar com os casos de cola (tanto que a pontuação dela nem soma com a da segunda fase para dar a nota final e decidir se o competidor vai ao curso de programação em Campinas), acho bem razoável que esses 260 participem da segunda fase para no fim ficarem os 100 melhores.

Mas é só um palpite…

Meus códigos-fonte

Já que não é mais possível submeter resultados (as tarefas já estão sendo corrigidas), agora publiquei meus códigos-fonte na seção de scripts do meu site.

• Truco
• Colheita de Caju
• Museu
• Jogo de Cartas
• Escada Perfeita

Colheita de Caju

Como vocês podem ver nos links aí em cima, a minha pior solução foi para o problema Colheita de Caju. A complexidade ficou um pouco (na verdade bastante) alta: O(L.C.(L-M).(C-N)). É a solução força bruta do negócio, bem simples de implementar e que com certeza funciona, mas para um caso com [L=1000, C=1000, M=1, N=1], ela demora um tempo no mínimo razoável… Mas tudo bem, os outros acho que passam talvez até com a pontuação máxima.

A solução ótima seria usando programação dinâmica; um algoritmo que depois eu comento melhor.

Nota esperada

Quase duas semanas depois da prova, meu chute para a nota da primeira fase é 420/500. Mas nunca se sabe… :)

Ontem, no período da tarde, foi aplicada a prova da primeira fase da OBI2006, modalidade Programação Nível 2. Já que nem todos os colégios submeteram as soluções de seus alunos, ainda não vou publicar os meus códigos nem o enunciado dos problemas, mas apenas escrever sobre o que achei da prova (assuntos separados em tópicos).

Tempo de Prova

O caderno foi composto por cinco questões, para serem resolvidas em cinco horas. Na minha opinião, foi tempo até demais para o nível dos problemas. Acabei a prova em pouco mais de três horas (depois de criar outros casos de teste, ver a complexidade dos algoritmos e tudo…).

Dificuldade da Prova

Embora no começo eu sempre leve um susto, no fim achei a prova fácil. Fiz as cinco questões, acho que acertei todas e a complexidade de nenhum dos meus algoritmos ficou muito pesada (mas também nunca se sabe…). Espero tirar uma nota superior a 400 (de 500) e acho que é possível até eu ter gabaritado.

Complexidade

Neste ano, o pessoal deixou a parte de tempo bem fácil. Ao invés de ser um conjunto de teste em cada entrada, foi apenas um teste por entrada. A conseqüência é que, além da questão de tempo ficar mais fácil, também não precisamos nos preocupar em zerar as variáveis a cada loop.

Problema mais difícil

O melhor problema da prova foi, na minha opinião, o Escada Perfeita. Infelizmente, não posso comentar muito a respeito dele até todos submeterem suas soluções, mas esse problema foi muito bom.

No meio de um problema de grafos (Museu), dois de coisas básicas tipo entrada/saída (Truco e Jogo de Cartas) e um problema para mostrar que sabemos mexer com matrizes (Colheita de Caju); o sistema de equações que dava pra montar neste problema (Escada Perfeita) baseado na fórmula de soma de PAs (aquela lenda do Gauss quando tinha cinco anos…) e depois um algoritmo guloso, fizeram com que eu ficasse mais de uma hora tentando encontrar a solução (que ficou com complexidade O(n)). Depois crio um post para comentar mais a respeito!

Enfim… Não posso entrar em muitos detalhes por enquanto e nem tenho certeza de como fui. A fase pós-prova/pré-nota é sempre complicada… Mas, se não cometi erros que [se existirem] devo perceber e comentar nos próximos artigos, rumo a segunda fase!

Pessoal que participou também, comentem aí dizendo como foram!

Anunciada a OBI2006! E temos novidades…

Copiado de: Site da OBI

Vamos participar, né? Estou ensinando meu amigo Ivo a programar e estou disposto a ajudar a quem quiser; para mim é um prazer ensinar coisas que eu gosto a quem está disposto a aprender.

E sobre a IOI…

Fiquei mais de um mês sem postar (ando sem inspiração). Desculpem-me por deixar a Série Algoritmos parada e não noticiar alguns fatos legais que aconteceram enquanto eu não postei (eu parei de escrever, mas comecei a ler mais). Vou voltar de leve agora…

Tenho estudado bastante matemática e física… pras olimpíadas, pro vestibular do ITA, pra desenvolver minha mente, etc. No fundo, é só porque eu gosto mesmo! :) Além disso, o ano letivo começou. Estou com um monte de coisa pra fazer (ainda não estou acostumado com o ritmo), mas vou voltar a postar ativamente.

De qualquer maneira, a pausa foi boa para uma reflexão pessoal e político-filosófica. Essas mudanças meus leitores provavelmente perceberão nos próximos artigos [ou talvez não].

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.

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 $x$ (ou seja, os valores das cartas são $x$, $x+1$, $x+2$, $x+3$ e $x+4$), a pontuação é $x+200$ 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 $x$ (uma quadra, ou seja, os valores das cartas são $x$, $x$, $x$, $x$ e $y$), a pontuação é $x+180$ 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 $x$ e outras duas cartas iguais $y$ (uma trinca e um par, ou seja, os valores das cartas são $x$, $x$, $x$, $y$ e $y$), a pontuação é $x+160$ 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 $x$ e duas outras cartas diferentes $y$ e $z$ (uma trinca, ou seja, os valores das cartas são $x$, $x$, $x$, $y$ e $z$), a pontuação é $x+140$ 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 $x$, duas outras cartas iguais $y$ ($x \neq{} y$) e uma outra carta distinta $z$ (dois pares, ou seja, os valores das cartas são $x$, $x$, $y$, $y$ e $z$), a pontuação é $3 \times{} x + 2 \times{} y + 20$ pontos, em que $x > y$. 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 $x$ e as outras são distintas (um par, ou seja, os valores das cartas são $x$, $x$, $y$, $z$ e $t$), a pontuação é $x$ 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 $N$ que indica o número de casos de teste ($1 \leq{} N \leq{} 100$). Cada uma das $N$ linhas seguintes contém cinco números inteiros $C\_{1}$, $C\_{2}$, $C\_{3}$, $C\_{4}$ e $C\_{5}$, representando as cinco cartas recebidas por um jogador ($1 \leq{} C\_{1}, C\_{2}, C\_{3}, C\_{4}, C\_{5} \leq{} 13$).

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

$1 \leq{} N \leq{} 100$ $1 \leq{} C\_{1}, C\_{2}, C\_{3}, C\_{4}, C\_{5} \leq{} 13$

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 _pseudo_código a seguir:

recebe N
para nteste $\leftarrow{}$ 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 $N$ linhas seguintes contém cinco números inteiros $C\_{1}$, $C\_{2}$, $C\_{3}$, $C\_{4}$ e $C\_{5}$, representando as cinco cartas recebidas por um jogador ($1 \leq{} C\_{1}, C\_{2}, C\_{3}, C\_{4}, C\_{5} \leq{} 13$). Então, vamos receber os cinco números em cada iteração e colocá-los num vetor, é claro!

recebe N
para nteste $\leftarrow{}$ 1 até N, faça
 recebe $C_{1}, C_{2}, C_{3}, C_{4}, C_{5}$
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 $C_{1}, C_{2}, C_{3}, C_{4}$ ou $C_{2}, C_{3}, C_{4}, C_{5}$.

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 $\leftarrow{}$ 1 até N, faça
 recebe $C_{1}, C_{2}, C_{3}, C_{4}, C_{5}$
 // início da ordenação por inserção
 para j $\leftarrow{}$ 2 até 5
  elemento $\leftarrow{}$ $C_{j}$
  i $\leftarrow{}$ j-1
  enquanto i > 0 e $C_{i}$ > elemento, faça
   $C_{i+1}$ $\leftarrow{}$ $C_{i}$
   $i$ $\leftarrow{}$ $C_{i-1}$
  fim-enquanto
  $C_{i+1}$ $\leftarrow{}$ 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 $x$(ou seja, os valores das cartas são $x$, $x+1$, $x+2$, $x+3$ e $x+4$), a pontuação é $x+200$ pontos. Por exemplo, se as cartas recebidas são 10, 9, 8, 11 e 12, a pontuação é 208 pontos.

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

Segunda Regra – Quadra

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

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

Aqui retornamos $C\_{2}$ porque ele será sempre parte da quadra (ela começando em $C\_{1}$ ou $C\_{2}$).

Terceira e Quarta Regra – Trinca

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

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

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

 senão
  retorna $C_{3} + 140$
 fim-se
fim-se

Note que aqui retornamos $C\_{3}$ porque ele será sempre parte da trinca (o mesmo motivo que retornarmos $C\_{2}$ para a quadra).

Quinta Regra – Duas Duplas

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

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

$C\_{2}$ será sempre elemento da menor dupla e $C\_{4}$ será sempre elemento da maior dupla. Por isso usamos eles como $y$ e $x$, respectivamente.

Sexta Regra – Dupla

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

se $C_{1} = C_{2}$ ou $C_{2} = C_{3}$, então
 retorna $C_{2}$
senão se $C_{3} = C_{4}$ ou $C_{4} = C_{5}$, então
 retorna $C_{4}$
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 $C_{1} = C_{2}-1$ e $C_{2} = C_{3}-1$ e $C_{3}=C_{4}-1$ e $C_{4}=C_{5}-1$, então
  retorna $C_{1}+200$
 fim-se
 
 // segunda regra
 se $C_{1} = C_{2} = C_{3} = C_{4}$ ou $C_{2} = C_{3} = C_{4} = C_{5}$, então
  retorna $C_{2}+180$
 fim-se
 
 //terceira e quarta regra
 se $C_{1} = C_{2} = C_{3}$ ou $C_{2} = C_{3} = C_{4}$ ou $C_{3} = C_{4} = C_{5}$, então
  se ( $C_{1} \neq{} C_{3}$ e $C_{1} = C_{2}$ ) ou ( $C_{3} \neq{} C_{5}$ e $C_{4} = C_{5}$ ), então
   retorna $C_{3}+160$
  senão
   retorna $C_{3} + 140$
  fim-se
 fim-se
 
 // quinta regra
 se $C_{1} = C_{2}$ ou $C_{2} = C_{3}$, então
  se $C_{3} = C_{4}$ ou $C_{4} = C_{5}$, então
   retorna $3 \times{} C_{4} + 2 \times{} C_{2} + 20$
  fim-se
 fim-se
 
 // sexta regra
 se $C_{1} = C_{2}$ ou $C_{2} = C_{3}$, então
  retorna $C_{2}$
 senão se $C_{3} = C_{4}$ ou $C_{4} = C_{5}$,
 então
  retorna $C_{4}$
 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 $\leftarrow{}$ 1 até N, faça
 recebe $C_{1}, C_{2}, C_{3}, C_{4}, C_{5}$
 // início da ordenação por inserção
 para j $\leftarrow{}$ 2 até 5
  elemento $\leftarrow{}$ $C_{j}$
  i $\leftarrow{}$ j-1
  enquanto i > 0 e $C_{i}$ > elemento, faça
   $C_{i+1}$ $\leftarrow{}$ $C_{i}$
   $i$ $\leftarrow{}$ $C_{i-1}$
  fim-enquanto
  $C_{i+1}$ $\leftarrow{}$ 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";

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.

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!

• Bits Trocados
• Calculando
• Cofrinhos da Vó Vitória
• Quermesse

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