Hoje teremos a última parte da aula de grafos (foi dividida em 3), sendo também nossa aula final antes da 2ª fase da OBI. Contudo, o curso Programando Melhor não irá terminar, ele continuará presente no blog, com a apresentação futura de tópicos sobre Programação Dinâmica e alguns assuntos interessantes, conforme eu for descobrindo, ok? Além disso, o blog voltará a ter posts sobre assuntos variados, envolvendo a área de TI em geral, não sendo focado apenas para a parte de Programação (contudo a maioria ainda será de programação, por ser minha “especialidade”).

Aula 8 – Grafos III

Conteúdo: Apresentação de mais alguns conceitos da teoria dos grafos, assim como algoritmos para resolução da Árvore Geradora Mínima e do menor caminho em um grafo valorado.

Teoria dos grafos é o estudo das propriedades das estruturas feitas com grafos. Com ela (a teoria) é possível ter uma linguagem comum ao tratar desse assunto, sendo a chave para resolver muitos problemas o fato de identificar esses conceitos fundamentais e implementar algoritmos clássicos para resolvê-los.

Propriedades dos graus

A propriedade mais simples de um vértice é seu grau, ou seja, a quantidade de arestas que incidem sobre ele. Existem diversas propriedades importantes do grau de um vértice, como a soma de todos os graus ser igual ao dobro do número de arestas, pelo fato desta contribuir para o grau de vértices adjacentes. Uma consequência disso é que qualquer grafo possui um número par de vértices com grau ímpar.

Árvores são grafos indiretos que não contém ciclos. Os graus dos vértices são importantes para a análise de árvores. A folha de uma árvore é um vértice com grau 1. Cada grupo de n vértices, contém n-1 arestas, portanto uma árvore possui no mínimo duas folhas. Ao retirar uma folha diminui-se a árvore, sem disconectá-la.

Uma árvore geradora de um grafo G = (V, E) é um subconjunto de arestas E’ contido em E, tal que E’ é uma árvore com os vértices V. Esse tipo de árvore existe para qualquer grafo conexo (com todos os vértices ligados entre si por algum caminho) e é visto pela relação estabelecida no vetor parent[ ], em buscas em largura e profundidade.

Árvore Geradora Mínima

Utilizada em grafos valorados, a árvore geradora mínima consiste em buscar a árvore geradora que possui a menor soma dos valores de suas arestas. São a resposta ao tratarmos de problemas sempre que precisarmos ligar um conjunto de pontos pela menor quantidade de canos, fios, etc.

Há dois algoritmos principais para tratar de árvores geradoras mínimas, o de Kruskal e o de Prim, contudo irei abordar aqui apenas o segundo, por ser mais simples e nos dar uma ótima base para enterder o menor caminho de Dijkstra, a seguir.

Primeiramente, generalizaresmos a estrutura de grafos implantada nas aulas anteriores, para utilizarmos grafos valorados.

typedef struct {

int v;            /* vértice adjacente */

int valor;    /* valor da aresta */

} aresta;

typedef struct {

edge edges[MAXV+1][MAXGRAU];    /* informação de adjacência */

int grau[MAXV+1];                                    /* grau de cada vértice */

int nvertices;                                                /* número de vértices no grafo */

int narestas;                                                  /* número de arestas no grafo */

} grafo;

OBS: lembrando também de ajeitar a inicialização e as buscas apropriadamente, o que não é trabalho complicado.

O algoritmo de Prim começa de um vértice inicial e a cada iteração é adicionado um novo vértice na árvore geradora, ligando sempre o menor valor de um vértice dentro da árvore para um vértice fora. A implementação abaixo mantém todas as arestas dos vértices já inclusos na árvore para vértices não-inclusos, sendo o menor incluído na próxima iteração.

prim (grafo *g, int start)
{
int i;      /* contador */
bool intree[MAXV];           /* esse vértice está na árvore? */
int distance[MAXV];          /* distância do vértice ao start */
int v;                       /* vértice atual para ser processado */
int w;                       /* candidato para próximo vértice */
int weight;                  /* valor da aresta */
int dist;                    /* menor distância atual */

for (i=1; i<g->nvertices; i++)
{
intree[i] = FALSE;
distance[i] = MAXINT;
parent[i] = -1;
}

distance[start] = 0;
v = start;

while (intree[v] == FALSE) {
intree[v] = TRUE;

for (i=0; i<g->nvertices; i++)
{
w = g->edges[v][i].v;
weight = g->edges[v][i].weight;

if ((distance[w] > weight) && (intree[w] == FALSE))
{
distance[w] = weight;
parent[w] = v;
}
}

v = 1;
dist = MAXINT;

for (i=2; i<=g->nvertices; i++)
{
if ((intree[i] == FALSE) && (dist > distance[i]))
{
dist = distance[i];
v = i;
}
}
}
}

Algumas alterações nesse método podem (e normalmente devem) ser feitas, de acordo com a necessidade do problema, como imprimir cada aresta, à medida que são encontradas ou armazenar o valor da soma de todas as arestas da árvore, para retornar no final. Ou seja, foi dado o queijo e a faca para vocês, resta saberem cortá-lo. Algumas variações são, por exemplo, a árvore geradora máxima (sendo preciso apenas deixar os valores das arestas negativos), árvore com menor produto possível das arestas (substituindo o valor da aresta pelo seu logaritmo).

Menor caminho

O problema de encontrar o menor caminho em grafos não-valorados, já foi discutido na aula anterior, sendo apenas necessário o uso de uma busca em largura, no entanto hoje iremos mostrar um algoritmo básico (e eficiente) para tratar desses “novos tipos de grafos”:  Dijkstra.

Floyd-Warshall é outra opção, mas já fora tratado no aula de Revisão para a primeira fase da OBI, nesse blog, com a aplicação no problema Batuíra, da seção pratique do site da Olimpíada Brasileira de Informática e, portanto, não será mais abordado (deem uma olhada no post de Revisão para entender o código).

O algoritmo de Dijkstra é um método para encontrar o menor caminho entre dois vértices de um grafo valorado. Dado um vértice particular s, ele encontrará o menor caminho de s para qualquer outro vértice do grafo, incluindo o seu destino t.

A idéia é praticamente igual a de Prim, na árvore geradora mínima. A diferença entre eles é como comparar se o próximo vértice é o desejável. No menor caminho nós buscamos o vértice em que a distância até o atual MAIS o seu valor será menor do que o comparado, ou seja:

if (distance[w] > (distance[v]+weight)) {

distance[w] = distance[v] + weight;

parent[w] = v;

}

Ao contrário do algoritmo de Prim, Dijkstra não pode trabalhar com valores negativos, porém esse problema é insignificante, já que não há aplicação prática para tais valores. Não se esqueça de exercitar:

• Freckles – Nível 2
• The Necklace – Nível 3
• Fire Station – Nível 2
• Railroads – Nível 3
• War – Nível 3
• Tourist Guide – Nível 3
• The Grand Dinner – Nível 4
• The Problem With the Problem Setter – Nível 3

PS: Todo o conteúdo desse post e de todo o curso “Programando melhor” é baseado no livro Programming Challenges, de autoria de Miguel Revilla e Steve Skiena e foi permitido o “resumo” e tradução do mesmo pelos próprios autores para a criação desse curso. Além disso os exercícios estão todos disponibilizados no site UVa Online Judge.

Com isso, terminamos nossas dicas antes da 2ª fase da OBI, o que posso fazer agora é desejá-los boa prova e que Deus vos abençoe. Atentem principalmente para os assuntos dos posts recomendados a seguir:

Posts interessantes:

• Programando melhor: Revisão
• Programando melhor: Aula 5 – Backtracking
• Programando melhor: Aula 6 – Grafos I
• Programando melhor: Aula 7 – Grafos II

Vamos lá, estamos na reta FINAL! Comentem e tirem suas dúvidas!

Helton de Melo Duarte

“Os preceitos do SENHOR são retos e alegram o coração; o mandamento do SENHOR é puro e alumia os olhos.” Salmos 19.8

Como esperado por muitos, o resultado da OBI saiu completamente ontem. Para o RN o resultado foi bom na categoria iniciação (mais de 100 aprovados), porém deixou a desejar na de Programação, tendo 2 aprovados em Júnior, 1 no nível 1 e 5 no nível 2. Como continuação do nosso preparo para a segunda fase da competição, teremos hoje a segunda aula sobre Grafos!

Aula 7 – Grafos II

Conteúdo: Aprofundamento com as buscas em largura e profundidade em um grafo, além do menor caminho em grafos não-valorados.

A operação básica na maioria dos grafos é percorrê-lo completamente e sistematicamente. É preciso visitar cada vértice e cada aresta exatamente uma vez em uma ordem pré-definida. Existem dois tipos primordiais de algoritmos para realizar essa atividade: Busca em Largura (BFS, do inglês Breadth-First search) e Busca em Profundidade (DFS, do inglês Depth-First search). A diferença entre não é nem percebida em certos problemas, pois eles compartilham uma idéia fundamental: marcar os vértices já explorados para não repetir ações.

Busca em Largura

A Busca em Largura é apropriada se nós não precisarmos de uma ordem específica para a busca ou se nós estamos interessados no menor caminho entre dois vértices para grafos não-valorados. A sua implementação utiliza duas vetores Boolean para manter o conhecimento sobre todos os vértices. Um vértice é descoberto a primeira vez que o visitamos. Um vértice é considerado processado depois de passarmos por todas as arestas provenientes dele.

Uma vez que o vértice é descoberto, ele é colocado em uma fila, sendo processados na ordem de chegada, pois os vértices mais antigos na fila são os mais próximos da raiz (local de partida para a busca). Para não encher o post somente com código, colocarei diversos links falando sobre BFS, para vocês darem uma olhada neles, depois voltarem para a continuação do post.

• Busca em largura – Wikipédia
• Busca em largura – IME/USP
• Busca em largura – IME/USP – outra explicação
• Breadth-first search – Wikipedia

O comportamento exato da BFS depende das funções de processar o vértice e processar a aresta, sendo essa a forma de personalizar a busca, podendo imprimí-los ou contar o número de arestas. Outra forma de personalizar é na função Boolean de validar a aresta, ignorando as não existentes. Ao retornar sempre true, percorreremos todas arestas, sendo uma BFS completa.

Encontrando caminhos

O vetor parent utilizado na bfs( ) é muito útil para encontrar caminhos em um grafo. O vértice que descobriu i é denominado parent[i]. Essa relação define uma árvore de descobertas com o nó inicial como a raiz da árvore.

Pelo fato dos vértices serem descobertos em ordem crescente de distância da raiz, essa árvore tem uma propriedade muito importante. O caminho da raiz até x (um dos vértices) utiliza o menor número de arestas possível para esse caminho.

Ele pode ser reconstruído seguindo os “ancestrais” de x até a raiz, pelo vetor parent[ ], contudo será um caminho do fim para o começo. Nós podemos “consertá-lo” ao guardá-los em uma pilha. É preciso lembrar de dois pontos cruciais na utilização de BFS: só é possível descobrir o menor caminho entre x e y, se x for a raiz do grafo; além disso, essa ação só é realizada com eficiência em grafos não-valorados.

Busca em Profundidade

Busca em profundidade utiliza a mesma idéia do Backtracking, mostrado na Aula 5 desse curso. Ambos envolvem a busca de todas as possibilidades ao avançar quando for possível e recuar quando não houver nada inexplorado à frente, sendo mais facilmente entendíveis como algoritmos recursivos. Essa busca pode ser pensada como BFS com uma pilha ao invés de fila. A parte bela dessa implementação é que a recursividade elimina a existência explícita de uma pilha, contudo não irei mostrar aqui o algoritmo completo, novamente sugerindo sites para vê-lo:

• Busca em Grafos – UFSC
• Busca em profundidade – Wikipédia
• Busca em profundidade – IME/USP
• Busca em Grafos

Com essa abordagem, chegamos ao final de mais uma aula de grafos, faltando apenas a abordagem de algoritmos como o de Dijkstra e da Árvore Geradora Mínima, os quais serão abordados próxima semana. Abaixo estão dispostos os exercícios a respeito das aulas 6 e 7:

• Bicoloring – Nível 1
• Playing With Wheels – Nível 2
• The Tourist Guide – Nível 3
• Slash Maze – Nível 2
• Edit Step Ladders – Nível 3
• Tower of Cubes – Nível 3
• From Dusk Till Dawn – Nível 3
• Hanoi Tower Troubles Again! – Nível 3

PS: Todo o conteúdo desse post e de todo o curso “Programando melhor” é baseado no livro Programming Challenges, de autoria de Miguel Revilla e Steve Skiena e foi permitido o “resumo” e tradução do mesmo pelos próprios autores para a criação desse curso. Além disso os exercícios estão todos disponibilizados no site UVa Online Judge.

Posts interessantes:

• Divulgação OBMEP
• Programando melhor: Aula 6 – Grafos I
• Programando melhor: Aula 5 – Bracktracking
• Programando melhor: Revisão
• Programando melhor: Aula 2 – Estrutura de Dados

Vamos lá pessoal! Essas últimas aulas serão cruciais para a segunda fase da OBI, preparem-se! Qualquer dúvida ou dica, COMENTEM!

Helton de Melo Duarte

“Os céus manifestam a glória de Deus e o firmamento anuncia a obra das suas mãos.” Salmos 19.1

“A lei do SENHOR é perfeita e refrigera a alma; o testemunho do SENHOR é fiel e dá sabedoria aos símplices.” Salmos 19.7

Hoje iniciaremos um assunto pedido a muito tempo por meus conhecidos: os tão temidos grafos! Contudo, eu já posso adiantar que eles não são complicados como vocês pensam, pelo menos o nível cobrado na OBI. Os conceitos principais podem ser vistos em diversos locais, como nos sites da UFSC e USP, sendo essa uma área muito ampla da computação, recebendo muitas vezes uma disciplina completa nos cursos de Ciência e Engenharia da Computação. Para quem gosta de matemática, há também uma oportunidade de estudá-la, como no curso de iniciação científica da OBMEP.

Aula 6 – Grafos I

Conteúdo: introdução aos conceitos, juntamente com as formas de utilizá-los no campo da computação.

Grafos são um dos temas mais interessantes da ciência da computação – uma representação abstrata que descreve a organização de sistemas de transporte, circuitos elétricos, linhas de telecomunicações, etc. Tantas estruturas diferentes podem ser modeladas utilizando esse conceito, tornando-o uma grande fonte de resolução de problemas. Será vistos hoje apenas o elementar dessa teoria, pela sua vasta abrangência, deixando os algoritmos mais específicos para as próximas aulas.

Tipos de Grafos

Um grafo G = (V, A) é definido por um conjunto de vértices V e um conjunto de arestas A, as quais consistem em pares de vértices contidos em V. Há diversas propriedades fundamentais dos grafos que influenciam na escolha de estruturas de dados  utilizadas para representá-los e os algoritmos para analisá-los. Vamos determinar quais são essas propriedades:

• Indireto vs. Direto - Um grafo G = (V, A) é indireto se a aresta (x, y) pertencer a A e isso implicar que (y, x) também pertence. Se não, é tido como grafo direto. Ex: Ligações por estradas entre cidades são tipicamente indiretas, porque as estradas são de mão-dupla.
• Valorado vs. Não-Valorado - Em grafos valorados, cada aresta (ou vértice) de G é assinalada com um valor numérico, ou peso. Uma aplicação típica são estradas, as quais são valoradas com a distância ou o tempo para percorrê-la. A diferença entre esses tipos é basicamente para encontrar o menor “caminho” entre dois vértices.
• Simples vs. Não-Simples – Certos tipos de arestas complicam a tarefa de trabalhar com grafos. Um laço é uma aresta (x, x) envolvendo somente um vértice. Uma aresta (x, y) é múltipla se ocorre mais de uma vez no mesmo grafo. Um grafo que não possui nenhum desses tipos de aresta é chamado Grafo Simples.

Estrutura de Dados para Grafos

Há muitas formas possíveis de representar um grafo, por isso nos focalizaremos nas mais comuns e úteis. Será assumido o grafo G = (V, A) contendo n vértices e m arestas.

• Matriz de adjacência – Nós podemos representar G usando uma matriz M n x n, onde o elemento M[i,j] é 1 se (i, j) é uma aresta de G e 0 (zero) se não for. Isso permite respostas rápidas para a questão “(i,j) está em G?” e atualizações rápidas para inserir ou deletar arestas. Todavia, esse tipo de representação pode usar espaço excessivo na memória, ao ter muitos vértices e poucas arestas.
• Listas de adjacência – Uma forma mais eficiente de representar é usando listas encadeadas para guardar os adjacentes a cada vértice. Esse tipo requer ponteiros mas não tenha medo se já passou por experiências desagradáveis com eles. Listas de adjacência dificulta para saber se (i, j) está em G, contudo é MUITO mais econômico com memória.
• Listas de Adjacência em Matrizes – Listas de adjacências podem estar embutidas em matrizes, eliminando a necessidade de ponteiros. Nós podemos representar a lista em um vetor (ou na linha de uma matriz) mantendo um contador k de quantos elementos há e colocando-os nos primeiros k elementos do vetor. Agora é possível visitar os elementos do primeiro ao último da mesma forma deuma lista, mas incrementando o índice em um loop ao invés de ponteiros. Esse forma é particularmente importante no caso de grafos estáticos, os quais não mudam após sua construção e será sempre utilizada nos exemplos seguintes.

Nós representamos um grafo usando a seguinte estrutura de dados: para cada grafo nós contabilizamos o número de vétices e os assinalamos de 1 a nvertices. As arestas estão em uma matriz MAXV x MAXGRAU, para cada vértice poder ser adjacente a outros MAXGRAU. Podemos definir MAXGRAU como MAXV, contudo isso seria desperdício em casos de grafos com graus baixos.

#define MAXV 100;              /* máximo número de vértices */

#define MAXGRAU 50;       /* máximo grau de um vértice */

typedef struct {

int arestas [MAXV+1][MAXGRAU];       /* informação de adjacência */

int grau[MAXV+1];            /* grau de cada vértice */

int nvertices;                        /* número de vértices no grafo */

int narestas;                        /* número de arestas no grafo */

} grafo;

Para demonstrar o uso dessa estrutura de dados, nós mostraremos como ler um grafo, tendo uma linha inicial o número de vértices e arestas no grafo, seguido por uma lista de arestas com um par de vértices por linha.

ler_grafo (grafo *g, bool direto)

{

int i;          /* contador */

int m;       /* número de arestas */

int x, y;   /* vértices em uma aresta (x, y) */

inicializar_grafo (g);

scanf (“%d %d”, &(g->nvertices), &m);

for (i = 1; i <= m; i++) {

scanf (“%d %d”, &x, &y);

inserir_aresta (g, x, y, direto);

}

}

inicializar_grafo (grafo *g)

{

int i;            /* contador */

g->nvertices = 0;

g->narestas = 0;

for (i = 1; i <= MAXV; i++) g->grau[i] = 0;

}

O método principal é o inserir_aresta. O parâmetro Boolean direto é utilizado para identificar quando é preciso inserir duas cópias de cada aresta ou só uma. Preste atenção no uso da recursão para resolver o problema.

inserir_aresta (grafo *g, int x, int y, bool direto)

{

if (g->grau[i] > MAXGRAU)

printf (“Atenção: a inserção (%d, %d) excede o grau máximo\n”, x, y);

g->arestas[x][g->grau[x]] = y;

g->grau[x] ++;

if (direto == FALSE) inserir_aresta(g, y, x, TRUE)

else g->narestas ++;

}

Agora, a tarefa de imprimir o grafo é um trabalho bem simples:

imprimir_grafo (grafo *g)

{

int i, j;                 /* contadores */

for (i = 1; i <= g->nvertices; i++) {

printf (“%d:  “, i);

for (j = 0; j <= g->grau[i]; j++) {

printf (” %d”, g->arestas[i][j]);

}

printf (“\n”);

}

}

Bem pessoal, por hoje é só. Infelizmente, os algoritmos de manipulação mais específica de um grafo ficarão para a próxima aula, ok? E, como foram dados apenas conceitos, excepicionalmente hoje não haverá seção de exercícios. =(

Posts interessantes:

• Programando melhor: Aula 5 – Backtracking
• Programando melhor: Revisão
• Programando melhor: Aula 4 – Ordenação
• Programando melhora: Aula 3 – Strings

O que vocês acharam de grafos? Qualquer dúvida é só Comentar! Para treinar, façam os exercícios da apostila de grafos da iniciação científica da OBMEP, indicada no início, pois são muito bons. Além do mais, qualquer erro, principalmente na parte de código, porque é frequente o WordPress deixar estranho, é só avisar por comentário, ok?

Helton de Melo Duarte

“A minha alma disse ao SENHOR: Tu és o meu SENHOR; não tenho outro além de ti.” Salmos 16.2

Para quem estava com saudades das aulas do “Programando melhor”, venho anunciar a volta com tudo do curso! Estive parado durante um tempo para resolver a migração do blog, além de estabelecer a parceria com a Hostnet, empresa a qual hospeda esse site. No entanto, tenho a alegria de informá-los que mais uma aula está pronta!

Aula 5 – Backtracking

Conteúdo: Explicação a respeito de algoritmos de Backtracking, técnica facilitadora em casos de problemas pesados.

A força bruta pode ser eficiente na resolução de problemas simples na área de computação, devido ao grande poder já presente nos computadores atuais, com média de 2GHz de clock do processador, ou seja, realizando 2 bilhões de operações por segundo! Contudo, existem casos em que a complexidade da situação exige técnicas mais sofisticadas, sendo uma delas o Backtracking!

Backtracking é um método para iterar (percorrer) todas as possíveis configurações em um espaço qualquer. É um algoritmo geral que poderá ser personalizado para cada tipo de aplicação. De modo geral, a solução será um vetor a = (a1, a2, …, a-n), sendo cada elemento a-i selecionado de um conjunto Si. Os exemplos mais comuns, os quais serão mostrados posteriormente, são a criação de permutações e de subconjuntos.

A cada passo do algoritmo, começa-se com uma solução parcial, diga-se a = (a1, a2, …, a-k), e tenta-se aumentá-la, adicionando outro elemento ao seu fim. Após adicioná-lo, é preciso testar se há uma solução completa – se sim, deve-se imprimí-la, contá-la ou qualquer ação necessária. Se não é necessário checar se essa solução parcial é ainda expansível para alguma completa. Se for, continue testando, se não então apague o último elemento de a e teste outra possibilidade para aquela posição. O código é mostrado abaixo:

bool finished = FALSE;          /* Já encontrou todas as soluções? */

backtrack (int a[], int k, data input)

{

int c[MAXCANDIDATES];       /* Candidatos para a próxima posição */

int ncandidates;                         /* Número de candidatos para a próxima posição */

int i;            /* Contador */

if (is_a_solution(a, k, input))

process_solution(a, k, input);

else {

k = k + 1;

construct_candidates (a, k, input, c, &ncandidates);

for (i = 0; i<ncandidates; i++) {

a[k] = c[i];

backtrack(a, k, input);

if (finished) return;             /* Terminar mais cedo */

}

}

}

As sub-rotinas utilizadas no algoritmo serão especificadas abaixo:

• is_a_solution(a, k, input) – Esse função booleana testa se os primeiros k elementos do vetor a são uma solução completa. O último argumento, input, permite-o utilizar informações proveitosas para essa rotina.
• construct_candidates(a, k, input, c, &ncandidates) – Preenche um vetor c com todos os candidatos possíveis para a k-ésima posição de a, dado o conteúdo das primeiras k-1 posições. O número de candidatos retornado é ncandidates e a variável input é novamente para alguma função auxiliar necessária.
• process_solution(a,k) – Esse método apenas imprime, conta ou faz algo necessário para o determinado problema, quando uma solução completa está pronta. A variável auxiliar, input, é desnecessária nessa situação.

Backtracking assegura o acerto por enumerar todas as possilidades sem visitar nunca o mesmo estado, sendo também eficiente. A recursividade promove a elegância e a fácil implementação desse algoritmo, porque o vetor de novos candidatos, c, é alocado com um procedimento recursivo.

As principais aplicações do backtracking são da criação de todos os subconjuntos de um conjunto S e na criação de todas as suas permutações. Os links foram colocados para o Wikipédia para que o post não fique muito grande, ok?

Abaixo seguem os exercícios para o treinamento do assunto (confesso que estão difíceis dessa vez):

• Little Bishops – Nível 2
• 15-Puzzle Problem – Nível 3
• Queue – Nível 2
• Servicing Stations – Nível 3
• Tug of War – Nível 2
• Garden of Eden – Nível 2
• Color Hash – Nível 3
• Bigger Square Please… – Nível 3

PS: Todo o conteúdo desse post e de todo o curso “Programando melhor” é baseado no livro Programming Challenges, de autoria de Miguel Revilla e Steve Skiena e foi permitido o “resumo” e tradução do mesmo pelos próprios autores para a criação desse curso. Além disso os exercícios estão todos disponibilizados no site UVa Online Judge.

Posts interessantes:

• Programando melhor: Revisão
• Programando melhor: Aula 4 – Ordenação
• OBI vem aí!
• Programando melhor: Aula 3 – Strings

Vamos lá, pessoal! Não desistam porque estamos em preparação para a segunda fase da OBI, agora é pra valer! Comentem sobre o que vocês acharam do post e tirem suas dúvidas!

Helton de Melo Duarte

“O SENHOR prova o justo, mas a sua alma aborree o ímpio e o que ama a violência.” Salmos 11.5

Como a prova da primeira fase da OBI é amanhã resolvi fazer esse post para uma revisão rápida de vocês sobre algumas questões importantes.

Primeiramente, quero avisá-los para termos bastante atenção com a quantidade de loops feitos, pois diversos loops encadeados podem fazer você não passar em alguns dos testes feitos (normalmente passará nos mais simples, contudo não conseguirá a pontuação completa).

Segundo vim trazer mais um assunto possível para a prova, o qual explicarei posteriormente na aula sobre grafos, no entanto colocarei um exemplo de fácil entendimento da seção pratique da OBI, do nível 2, Batuíra (código resolvido abaixo):
#include

#define INF 1000000;

int main()
{
/* Batuíra */
int num = 1; /* Número do teste */
int n, x, y, z; /* Quantidade de pontos e variáveis para distância */
int dist[110][110]; /* Grafo para distância dos pontos */
int i, j, k; /* Contadores para loop for */

/* O Grafo dist[110][110] representa as distâncias entre os pontos de
repouso. Por exemplo, o valor de dist[i][j] é a distância entre os pontos
i e j */

/* Entrada do número de pontos */
scanf (“%d”, &n);

while (n != 0)
{
/* Coloca a distância padrão entre os pontos */
for (i = 1; i <= n; i++)
{
for (j = 1; j <= n; j++)
{
if (i == j)
{
dist[i][j] = 0; /* A distância para o próprio
ponto de repouso é zero */
}
else
{
dist[i][j] = INF; /* Diz que a distância entre os pontos
é “infinita”, ou seja, não há ligação entre eles */
}
}
}

/* Lê os pontos e a distância entre eles */
scanf (“%d %d %d”, &x, &y, &z);
/* A distância do ponto x ao ponto y é igual a z */

while (x != 0) /* Quando qualquer valor for zero é o fim da
entrada dos pontos */
{
/* Coloca as distâncias nas duas direções */
dist[x][y] = z;
dist[y][x] = z;

/* Lê os pontos e a distância entre eles */
scanf (“%d %d %d”, &x, &y, &z);
}

/* Algoritmo de Floyd-Warshall */
for (k = 1; k <= n; k++)
{
for (i = 1; i <= n; i++)
{
for (j = 1; j <= n; j++)
{
/* Se houver um ponto de repouso entre i e j com uma
menor distância, então o valor de pontos[i][j] é
substituído pelo de (dist[i][k] + dist[k][j]) */
if ((dist[i][k] + dist[k][j]) < dist[i][j])
{
dist[i][j] = dist[i][k] + dist[k][j];
dist[j][i] = dist[i][k] + dist[k][j];
}
}
}
}

/* Depois desse laço principal o valor de dist[1][n] é a menor
distância entre o ponto inicial e o final, a qual representa o valor
pedido pelo problema */

/* Saída de dados */
printf (“Teste %d\n%d\n\n”, num, dist[1][n]);

/* Incremento para o próximo caso de teste */
num++;

/* Entrada para o próximo caso de teste */
scanf (“%d”, &n);
}

return (0);
}

Fiquem bem atentos a parte de grafo, além do famoso algoritmo de Floyd-Warshall, o qual é suficientemente eficiente para esse problema.

Serão colocados comentários com dicas para os problemas “The Trip”, em Exercícios 1 (Parte I) e “Jolly Jumpers”, na Aula 2, pois foram resolvidos por mim no site do UVa Online Judge (finalmente).

Por fim, boa sorte a todos os que irão participar da competição amanhã (OBI), tomara que seja uma boa prova! Eu também participarei, esperando um bom resultado, se Deus quiser.

Posts interessantes:

• Programando melhor: Aula 4 – Ordenação
• OBI vem aí!
• Programando melhor: Aula 3 – Strings
• Programando melhor: Aula 1 – Começando

E você, como se preparou para a OBI? Ah, quando a prova terminar, postem suas opiniões aqui e vamos discutir as questões! Comentem!

Helton de Melo Duarte

“Entrega o teu caminho ao Senhor, confia nEle e Ele tudo fará.” Salmos 37.5

“O meu escudo está com Deus, que salva os retos de coração.” Salmos 7.10

Mais uma aula de preparação para a OBI 2009 (principalmente)! Pessoal do IF-RN, preparem-se pesado, porque esse ano precisamos ter alguma medalha! =) A aula de hoje abordará um assunto também bem importante para competidores, visto que otimizar o método de ordenação é um fato muito importante nesse caso (não podemos sempre utilizar o Bubble Sort!).

Aula 4 – Ordenação

Conteúdo: principais aplicações dos algoritmos de ordenação, assim como uma abordagem dos melhores métodos para esse tipo de atividade.

Ordenação é um dos pontos primordias na ciências da computação, estando presente na solução de diversos problemas existentes nas competições e na vida do programador. Muitos algoritmos de ordenação já foram desenvolvidos, sendo necessário saber para que tipo de situação serve cada um (embora já existam muitos os quais não serão mais usados, por haver outros mais otimizados). Nessa aula, procurarei abordar as aplicações mais importantes da ordenação, além de uma teoria a respeito dos principais algoritmos da área.

Aplicações da ordenação:

• Teste de unicidade: Como testar se os elementos de uma coleção S são todos distintos? Ordene-a crencente ou decrescentemente e faça uma varredura testando se S[i] = S[i+1].
• Priorizando eventos: Suponha que existem diversos trabalhos a serem feitos, cada um com seu deadline (data limite). Ordenando-os de acordo com o deadline os  colocará na ordem certa para serem cumpridos.
• Mediana: Se for necessário encontrar o k-ésimo maior item em uma lista S, é preciso apenas ordená-la, tendo o elemento S[k] como o requerido.
• Encontrando o par correto: Como podemos testar se existem dois inteiros x, y em S que x+y = z, onde z é um inteiro qualquer? Ao invés de testar todos os pares possíveis, ordene os números crescentemente. Como S[i] aumenta com o i, o provável parceiro j que tem S[j] = z – S[i] diminui. Com esse método fica bem mais eficiente sua procura.
• Busca eficiente: Para saber se um elemento s encontra-se em S, simplesmente ordena-se e lista e realiza-se uma busca binária na fila, um dos métodos mais comuns de aplicação da ordenação.

Algoritmos de ordenação:

Você já deve ter ouvido muitos algoritmos diferentes para ordenação de dados, no entanto deve estar pensando: para que uma pessoa precisa saber de tantos modos para se fazer a mesma coisa? O real motivo para se estudar todos esses códigos são as ideias por trás dos mesmos, ou seja, o modo como foi desenvolvido certo algoritmo pode ser utilizado para algum problema de uma forma parecida, deu pra entender? Abaixo serão mostrados os três mais interessantes para o estudo da sua teoria:

• Selection Sort – Esse algoritmo divide o vetor de entrada em partes ordenadas e não-ordenadas e a cada varredura pela parte não-ordenada ele encontra o menor elemento e o transfere para o fim da região ordenada. São feitas muitas comparações, todavia é muito eficiente se contarmos o número de troca de posições, pois são apenas n-1, no pior dos casos. Segue no link os códigos em diversas linguagens: Selection Sort.
• Insertion Sort – Esse algoritmo também mantém regiões ordenadas e não-ordenadas. Em cada vez o próximo elemento não-ordenado é movido para a sua posição apropriada na região ordenada. Insertion sort é particularmente eficiente no que diz respeito a quantidade de movimento de dados, pois ele só inverte  um par de elementos para o local já certo, ou seja, em uma lista praticamente ordenada ele pode ser extremamente eficaz. Novamente os códigos seguem com o link: Insertion Sort.
• Quick Sort – É um dos mais eficientes e rápidos, reduzindo o trabalho de ordenar uma grande lista em ordenar duas listas menores. A partição separa o vetor nos elementos menores do que um certo x e os maiores do que o mesmo x. Como nenhum elemento precisará mover-se para fora de sua região, cada vetor menor poderá ser ordenado independentemente. Para facilitar a ordenação o quicksort também recebe como argumentos os índices do começo e fim do sub-vetor. Esse código é muito interessante por diversas razões, pois quando é implementado corretamente consome menos memória do que qualquer outro, além de ser uma das melhores demonstrações do poder da recursividade (uma função que chama ela mesma). Os exemplos em cada linguagem seguem no link: Quick Sort.

Estamos no final da aula, mas não podemos deixar de praticar, não é verdade? Abaixo seguem os exercícios para o treinamento de ordenação:

• Vito’s family – Nível 1
• Stacks of Flapjacks – Nível 2
• Bridge – Nível 3
• Longest Nap – Nível 1
• Shoemaker’s Problem – Nível 2
• CDVII – Nível 2
• ShellSort – Nível 2
• Football (aka Soccer) – Nível 1

PS: Lembrando a todos que o conteúdo desse post e de todo o curso “Programando melhor” é baseado no livro Programming Challenges, de autoria de Miguel Revilla e Steve Skiena e foi permitido o “resumo” e tradução do mesmo pelos próprios autores para a criação desse curso. Além disso os exercícios estão todos disponibilizados no site UVa Online Judge.

Posts interessantes:

• OBI vem aí!
• Programando melhor: Aula 3 – Strings
• Programando melhor: Aula 2 – Estruturas de Dados
• Programando melhor: Aula 1 – Começando
• Cursos grátis na Internet – MIT

Pessoal, mais uma aula completa e dedicação é necessária! Façam sempre os exercícios! Procurarei nas próximas duas semanas, dedicar-me aos exercícios que já foram propostos aqui, colocando dicas para cada um, ok? Além disso, os próprios problemas da seção pratique do site da OBI. Comentem e tirem suas dúvidas! Vamos lá!

Helton de Melo Duarte

“Bem-aventurado o varão que não anda segundo o conselho dos ímpios, nem se detém no caminho dos pecadores, nem se assenta na roda dos escarnecedores.” Salmos 1.1

Para aqueles que estavam ansiosos por mais uma aula preparatória para competições de programação (principalmente OBI, pois já está próxima), venho aqui para isso! A aula de hoje não será tão grande, contudo tem uma importância extrema (quem viu a prova da 2ª fase da OAH 2008 perceberá a importância desse assunto) e, como sempre, virá seguida de exercícios.

Eu sei que muitos podem estar achando os exercícios complicados, e realmente são, mas preciso informá-los que a persistência é o melhor remédio, pois eu estava empacado em um deles a mais de semana, só que ontem consegui receber um “Accepted” no site da UVa Online Judge! =) Vamos, então, à batalha!

Aula 3 – Strings

Conteúdo: visão geral de como tratar strings, desde o modo em que elas aparecem nas diversas linguagens, até os principais métodos para lidar com elas.

Strings são estruturas fundamentais de crescente importância. Vocês verão que os problemas apresentados nessa aula são um pouco mais fáceis do que o passado, todavia eles revelam a forma de como strings e caracteres são representados, além dos melhores algoritmos para manipular esse tipo de dado.

Códigos dos caracteres: Os caracteres são apenas códigos os quais o computador associa a um símbolo, por esse motivo linguagens como C, C++ e Pascal tratam o tipo char como alguma coisa de 1 byte, nada mais do que isso. O American Standard Code for Information Interchange (ASCII), ou Código Padrão Americano para Troca de Informações, representa o caracter por 1 byte, tendo um total de 2^7 = 128 tipos diferentes. Eles não foram ordenados ao acaso, possuindo algumas propriedades interessantes para o programador:

• Todos os caracteres não-imprimíveis possuem os 3 primeiros bits iguais a 0 (zero) ou os 7 menos sigficativos iguais a 1;
• As letras minúsculas e maiúsculas aparecem ambas ordenadas sequencialmente, o que nos permite a criação de loops do primeiro (“a”) ao último (“z”);
• Além do loop, podemos ver qual a posição apenas subtraindo pelo valor do início: “I” – “A” = 8;
• Podemos converter de maiúscula para minúscula com operações simples como: “C” – “A” + “a”. Analogamente uma letra será maiúscula se estiver entre “A” e “Z”;
• Ao ordenar um texto, estaremos simplesmente ordenando o seu código ASCII.

Códigos mais modernos, como Unicode, utilizam 2 ou até 3 bytes para representar um caracter, abrangendo qualquer língua do planeta.

Representando strings: aqui apenas diferenciarei os modos de linguagens básicas tratarem as strings.

• Vetores terminados com NULO: C/C++ tratam strings apenas como vetores de caracteres, terminando com o “” (zero ASCII). A não colocação desse último caracter pode gerar muita confusão no decorrer do programa, pois seria uma string “infinita”. Vantagem: pode-se acessar cada valor apenas indexando-os, assim como vetores.
• Vetor mais tamanho: Outro modo usual é utilizar o primeiro elemento do vetor para o tamanho da string, o que dispensa a utilização do caracter NULO. Essa forma é utilizada internamente pelo Java, apesar de ser mostrado ao programador como um objeto.

Manipulando strings: Para a sua manipulação será necessário o conhecimento de como sua linguagem trata esse dado, contudo para uma simplificação, iremos exemplificar com o suporte feito em C.

• Computando o tamanho de uma String: Varre os caracteres, até encontrar o NULO, com um contador para o cálculo;
• Copiando uma String: Ao menos que sua linguagem de programação suporte igualar dois vetores de uma só vez, você terá que copiar elemento por elemento. OBS: não esqueça de criar o caracter NULO no fim!;
• String ao contrário: Se não for necessário manter a string original é preciso apenas trocar os elementos, num loop até a metade do tamanho. Caso seja preciso a primeira, então copia-se para outra string, só que da direita para a esquerda. OBS: novamente, não esqueça de criar o caracter NULO no fim!;
• Por último, será apresentado um algoritmo, pouco eficaz, diga-se de passagem, mas SIMPLES, para contar quantas vezes alguma string p aparece em outra t.

Bibliotecas de funções para strings: Já estamos no final da aula, mas deixaremos para vocês dicas de algumas bibliotecas já presentes nas linguagens, para o tratamento de strings:

• C => <ctype.h> Manipulação de caracteres; <string.h> Manipulação de strings;
• C++ => as mesmas do C, além de uma classe string, a qual possui algumas funcionalidades interessantes. MAIS;
• Java => A classe String, com diversas operações avançadas em java.text;
• Pascal => Nativo do SysUtils, portanto todas as funções estão a sua disposição. MAIS.

Bem pessoal, o conteúdo era esse, agora vamos praticar! OBS: Novamente eu lembro que todos os exercícios dispostos abaixo estão no UVa Online Judge e eles possuem todos os direitos sobres os problemas.

• WERTYU – Nível 1
• Where’s Waldorf? – Nível 2
• Common Permutation – Nível 1
• Crypt Kicker II – Nível 2
• Automated Judge Script – Nível 1
• File Fragmentation – Nível 2
• Doublets – Nível 3
• Fmt – Nível 2

Posts interessantes:

• Programando melhor: Aula 2 – Estrutura de Dados
• Programando melhor: Aula 1 – Começando
• Cursos grátis na Internet – MIT
• OAH 2008

Nossa primeira batalha está por vir, se preparem, porque a OBI vem aí! Vão treinando com esses exercícios e os da seção pratique da OBI que na prova será moleza! Qualquer dúvida e/ou sugestão postem! Vamos lá! Comentem!

Helton de Melo Duarte

“Sonda-me, ó Deus, e conhece o meu coração; prova-me e conhece os meus pensamentos. E vê se há em mim algum caminho mau e guia-me pelo caminho eterno.” Salmos 139.23,24

Bem pessoal, venho hoje postar a segunda aula do nosso curso “Programando melhor”, como sempre baseado no livro Programming Challenges, de Steven Skiena e Miguel Revilla, falando hoje um pouco sobre Estruturas de Dados, as quais infelizmente eu não vi no curso do CEFET-RN (atual IF-RN), contudo acredito serem essenciais para um bom programador. No final estarei indicando os links de exercícios para vocês praticarem o assunto estudado, blz? Vamos começar!

Aula 2 – Estruturas de Dados

Conteúdo: abordagem das estruturas de dados elementares, assim como mais dicas de como abordar um problema e os métodos para testar/debuggar.

Estruturas de dados são primordiais em qualquer programa robusto, sendo primordial a escolha da estrutura certa para representar o problema, evitando códigos feios e diversos bugs pela frente. ^^

Iremos mostrar as principais estruturas de dados (pilhas, filas e dicionários), com algumas operações básicas para manipulá-las. Para aqueles programadores de C++ e Java já existem bibliotecas prontas para esse controle, contudo é interessante o entendimento de como elas trabalham por dentro. Para C++: stl.h; para Java: java.util.

Pilhas: as pilhas e as filas são estruturas nas quais seus itens são controlados de acordo com a ordem de inserção e não pelo conteúdo armazenado. Ao inserir ou remover um item, fazemos em seu topo. As operações básicas são as seguintes:

Push(x, s) – Insere o item x no topo da pilha s.

Pop(s) – Retorna (e remove) o item do topo da pilha s.

Initialize(s) – Cria uma pilha vazia.

Full(s), Empty(s) – Testa se a pilha pode aceitar mais Push ou Pop, respectivamente.

Obs.: Não há operação para procurar um item na pilha, justamente pelo fato que o conteúdo não importa, somente é vista a ordem de inserção.

Filas: assim como nas pilhas, não importa o conteúdo, apenas a ordem. Nas filas os itens são inseridos em seu final e removidos do início. Um exemplo interessante do uso de filas é quando se trabalha com baralhos de cartas (tente fazer um exemplo para entender melhor XD ). A seguir, as operações:

Enqueue(x,q) – Insere o item x no fim da fila q.

Dequeue(q) – Retorna (e remove) o item da frente da fila q.

Initialize(q), Full(q), Empty(q) – Análogos às operações de pilhas.

Filas precisam de um pouco mais de cuidado, já que acontecem coisas nos dois lados da estrutura. O modo mais simples de implementação é utilizando arrays (vetores), inserindo no final e movendo todos os elementos restantes para preencher o espaço vazio do Dequeue. Contudo, temos que pensar um pouco antes de criar filas com vetores, pois é bastante desperdício esse movimento a cada Dequeue e o fato de filas circulares, ou seja, o primeiro e o último elemento são iguais. Por essas e outras, filas são estruturas mais simples de se trabalhar com listas encadeadas (um pouco sobre ponteiros para os adeptos de Pascal aqui) do que com vetores.

Dicionários: estruturas as quais pode-se trabalhar com o conteúdo dos elementos, tendo como operações primárias:

Insert(x,d) – Insere o item x no dicionário d.

Delete(x,d) – Deleta o item x (ou o item apontado por x) do dicionário d.

Search(k,d) – Retorna o item com a chave k se o mesmo existir no dicionário d.

Nós precisamos, então, saber qual é a melhor maneira de se trabalhar com esse tipo de estrutura e assim segue abaixo cada caso:

Dicionários estáticos => Essas estruturas são criadas uma vez e nunca mais mudadas, precisando então apenas do Search, não mais do Insert ou Delete. O melhor jeito para se trabalhar com eles é na utilização de vetores, sendo então sua preocupação apenas de como mantê-los ordenados, para otimizar suas buscas, contudo isso iremos ver em outras aulas.

Dicionários semi-dinâmicos => São aqueles em que se pode inserir ou pesquisar (Search), porém não pode deletar. Se soubermos o máximo de elementos, é possível a utilização de vetores, contudo sem essa informação será preciso novamente trabalhar com listas encadeadas.

Dicionários dinâmicos => Aqueles em que é permitida qualquer operação. Como muitos já devem ter percebido, a melhor maneira de se implementar esse tipo de estrutura é com a utilização de listas encadeadas, somente, para não tornar nosso código extremamente horroroso.

Finalmente chegamos ao fim dessa abordagem sobre estruturas de dados propriamente dita, esperando ter conseguido relembrar e otimizar o uso delas, além de fazê-lo mais preparado para os problemas que virão. A seguir colocarei mais dicas de resolução de problemas.

Sua solução começa agora

• Leia o programa atentamente – Leia cada linha do problema cuidadosamente e releia quando o juiz online lhe reportar algum. Veja até mesmo a história que você acha não ter importância, no início do problema, porém preste bastante atenção às descrições de entrada/saída, além de seus exemplos.
• Não assuma nada – Esteja atento a instruções de entrada não especificadas, números sem limites, linhas longas de entrada, números negativos, etc. NÃO ESQUEÇA: qualquer situação que não é explicitada como proibida deve ser assumida como possível!
• Não tão rápido – Não se preocupe tanto com eficiência, a menos que você esteja passando por problemas com o juiz (como um conhecido “Time limit exceeded”). Ao conhecer bem as especificações, ou seja, sabendo qual o valor máximo para as entradas, é possível prever quão rápido necessitará ser seu algoritmo. IMPORTANTE: eu não estou incentivando códigos feios e cheios de gambiarras, todavia não é preciso um cuidado excessivo com isso logo no começo do trabalho, deu pra entender?

Testando e “debuggando”

Aprender a evitar erros bestas que podem penalizá-lo em situações de competição é crucial para o sucesso em qualquer lugar, por isso seguem abaixo algumas táticas:

• Mesmo que pareça simples, é importantíssimo o teste feito com as entradas dadas pelo problema, pois lhe dirá qual a maneira de colocar sua saída na tela;
• Se o problema exige determinadas ações ao se colocar entradas inválidas, certifique-se primeiramente que elas estão sendo feitas;
• Crie sempre situações de teste simples, as quais você pode testar no papel e compare as soluções, pois pode ajudar na procura de erros mais comuns;
• Coloque sempre entradas gigantescas (no limite do permitido), para ver como o programa se comporta, ou seja, se ele não fica “doido” com números grandes, comportando-se de maneira inesperada.
• Conheça seu “Debugger” – Qualquer ambiente de desenvolvimento vem agora com um “debugger” (a opção de executar o programa linha por linha) e é preciso que você o conheça claramente. Quanto mais cedo você começar a usá-lo, mais tempo e frustação que você vai evitar ^^;
• No caso de não possuir esse “debugger”, crie pontos no programa para imprimir certos valores importantes, entretanto faça-os com linhas relevantes para ler a saída rapidamente e achar os possíveis erros;
• Faça seus vetores um pouco maiores do que o necessário – precisa comentar? É apenas para garantir que a memória não vai “acabar” durante a execução…

É isso aí! Agora vamos para os exercícios e, como já avisado, apenas colocarei os links para eles no site do UVa Online Judge:

• Jolly Jumpers – Nível 1
  
• Poker Hands – Nível 2
  
• Hartals – Nível 2
  
• Crypt Kicker – Nível 2
  
• Stack ‘em Up – Nível 1
  
• Erdös Numbers – Nível 2
  
• Contest Scoreboard – Nível 1
  
• Yahtzee – Nível 3
  

Posts interessantes:

• Programando melhor: Exercícios 1 (Parte II)
• Programando melhor: Exercícios 1 (Parte I)
• Programando melhor: Aula 1 – Começando
• Cursos grátis na Internet – MIT

Como falei no meu Twitter: Bora lá pessoal, nossa guerra ainda está no começo! Animação! Qualquer dúvida sobre o assunto pode perguntar. Novamente, quando tiver dicas sobre os exercícios postarei e vocês façam o mesmo. Comentem!

Helton de Melo Duarte

“Ainda que a figueira não floresça, nem haja frutos nas vides; ainda que falhe o produto da oliveira, e os campos não produzam mantimento; ainda que o rebanho seja extirpado da malhada e nos currais não haja gado; todavia eu me alegrarei no Senhor, exultarei no Deus da minha salvação.” Habacuque 3.17,18

Hoje não haverá aula nem exercícios não, infelizmente, eu vim aqui apenas para comunicá-los como será a programação do nosso curso durante essa e a próxima semana, pois acontecerão algumas coisas não previstas…=(

Primeiramente, foi detectada o baixo aproveitamento do curso nos posts que traziam apenas exercícios e, por isso, eles não irão acontecer mais. Porém, não fique triste, pois não vou deixá-los na mão sem poder treinar o que aprenderam aqui, é claro, e serão disponibilizados os links para os problemas no próprio post de conteúdo, sendo essa uma forma de estimulá-los até a submeter os problemas para o juiz online, blz? Além disso, no próprio post de conteúdo poderão ser colocados comentários sobre os problemas, assim como dicas (minhas e do público) sobre como melhor resolvê-los, ok?

O outro aviso é a respeito das nossas aulas dessa e da próxima semana: o conteúdo dessa semana será proposto apenas na sexta-feira, porque não houve tempo suficiente para a resolução dos problemas propostos na semana passada e não iremos atolá-los de assunto sem treinamento, não é mesmo? Próxima semana irá ocorrer o carnaval (infelizmente) e essa pessoa que vos fala participará de um evento durante esse período (SECOPE). Portanto, na próxima semana irei apenas me reestruturar após o evento e resolver os exercícios sobre o assunto, para que a partir do dia 03/03/2009, daqui a 15 dias, nós publiquemos a terceira aula do curso “Programando melhor”.

Por fim, gostaria de agradecer a todos os quais contribuíram com comentários durante a primeira semana do curso e me fizeram elogios. Queria apenas dizer que fiquei muito grato por ver a quantidade de pessoas visitando o blog e é esse mesmo meu objetivo: ver os brasileiros com sede de conhecimento e buscando aprender coisas novas.

Posts interessantes:

• Curso de programação – Confirmado!
• Programando melhor: Aula 1 – Começando
• Programando melhor: Exercícios 1 (Parte I)
• Programando melhor: Exercícios 1 (Parte II)

O que você achou das novidades? O que tem achado do nosso curso até agora? Tem vontade de nos ajudar, pois mande um e-mail para hm_duarte@hotmail.com para conversarmos melhor e, se possível, fazermos juntos um post para todos nós. Comente!

Helton de Melo Duarte

“Filho meu, se aceitares as minhas palavras, e entesourares contigo os meus mandamentos, para fazeres atento à sabedoria o teu ouvido, e para inclinares o teu coração ao entendimento; sim, se clamares por discernimento, e por entendimento alçares a tua voz; se o buscares como a prata e o procurares como a tesouros escondidos; então entenderás o temor do Senhor, e acharás o temor de Deus.” Provérbios 2.1-5

Problema 3: LCD Display

UVa ID: 706    ;    Nível: Fácil

Um amigo seu acabou de comprar um novo computador. Antes disso, a máquina mais poderosa que ele havia usado foi uma calculadora de bolso. Ele está um pouco desapontado porque ele gostava do display LCD da sua calculadora mais do que da tela do seu novo computador! Para fazê-lo feliz, escreva um programa que imprima números no estilo de um display LCD.

Entrada

O arquivo de entrada contém diversas linhas, uma para cada número a ser disposto na tela. Cada linha contém inteiros s e n, onde n é o número a ser disposto (0 <= n <= 99.999.999) e s é o tamanho que ele irá aparecer (1 <= s <= 10). A entrada será terminada por uma linha contendo dois zeros, que não deve ser processada.

Saída

Escreva os números especificados no arquivo de entrada em estilo display LCD usando s sinais “-” para os segmentos horizontais e s sinais “|” para os verticais. Cada dígito ocupa exatamente s + 2 colunas e 2s + 3 linhas. Esteja certo de preencher todos os espaços brancos ocupados pelos dígitos com “espaços”, incluindo o último dígito. Deve haver exatamente uma coluna de “espaços” entre dois dígitos.

Coloque uma linha de “espaço” após cada número. Você encontrará um exemplo de cada dígito no Exemplo de saída abaixo.

Exemplo de entrada

2 12345

3 67890

Exemplo de saída

Problema 4: Interpreter (Interpretador)

UVa ID: 10033       ;     Nível: Médio

Um certo computador tem dez registradores e 1000 palavras de RAM. Cada registrador ou local na RAM armazena um inteiro de três dígitos entre 0 (zero) e 999. Intruções são codificadas como inteiros de três dígitos e armazenadas na RAM. Os códigos são os seguintes:

100  | manter

2dn  | armazena no registrador d o valor n (entre 0 e 9)

3dn  | adiciona n ao valor armazenado em d

4dn  | multiplica por n o valor armazenado em d

5ds  | armazena em d o mesmo valor armazenado em s

6ds  | adiciona o valor armazenado em s ao armazenado em d

7ds  | multiplica o valor armazenado em d pelo de s

8da  | armazena em d o valor de RAM que tiver seu endereço armazenado no registrador a

9sa  | armazena na RAM, cujo endereço esteja em a, o valor armazenado no registrador s

0ds  | vai para o local armazenado no registrador d a menos que o registrador s cotenha 0 (zero)

Todos os registradores inicialmente contém 000 (zero). O conteúdo inicial da RAM é lido de uma entrada padrão. A primeira instrução a ser executada é no endereço RAM zero. Todos os resultados são reduzidos módulo 1000.

Entrada

A entrada começa com um único inteiro positivo na linha, indicando o número de casos, cada um descrito abaixo. É seguido por uma linha em branco e haverá uma linha em branco entre cada duas entradas consecutivas.

Cada caso de entrada consiste num inteiro sem sinal de três dígitos, representando os conteúdos de locais consecutivos na RAM, começando pelo zero. Locais de RAM não especificados são inicializados com 000 (zero).

Saída

A saída de cada caso de teste é um único inteiro: o número de instruções executadas acima e incluindo a de “manter”. Você pode assumir que o programa faz o “manter”. Separe a saída de dois casos consecutivos por uma linha em branco.

Exemplo de entrada

1

299

492

495

399

492

495

399

283

279

689

078

100

000

000

000

Exemplo de saída

16

É isso aí pessoal, temos agora a segunda parte da primeira bateria de exercícios proposta como treinamento, ok? Os exeercícios de agora são um pouco mais difíceis (confesso que não entendi nem o que pede o problema 4 de primeira olhada xD ), contudo não desanimem, pois precisamos pegar pesado se queremos alguma coisa.

Posts interessantes:

• Programando melhor: Exercícios 1 (Parte I)
• Programando melhor: Aula 1 – Começando
• Cursos grátis na Internet – MIT
• Top Coder Marathon Matches
• Olimpíadas do Conhecimento

Novamente, qualquer dica para a solução de problemas é extremamente bem vinda e dúvidas serão, à medida do possível, respondidas. Deixe seu comentário falando o que achou dos problemas! E conte também seu caso de sucesso!

Helton de Melo Duarte

“A sabedoria exalta aos que a favorecem, honra aos que a amam, e empresta graça à aparência de uma pessoa, para que esta seja admirada e respeitada por aqueles que a conhecem.” Charles Fritsch