Lógica de Programação

1. Computação Depressão O Portal do Estudante de Computação www.facebook.com/ComputacaoDepressao www.ComputacaoDepressao.com.br Lógica de Programação Linguagem C

2. características • Na linguagem C, o vetor possui um número N de posições, porém ao declararmos, acessamos seus índices que começam em 0 e vão até N-1. Ou seja, a linguagem C tem a característica “0 a N-1” nos seus vetores. • int idades[10]; //10 índices • int idades[35]; //35 índices

3. Declaração • int idade; • int idades[10]; //10 índices • char letra; • char letras[26]; //26 índices ou uma string de 26 (ou 25) posições • char nome[30]; //string de 30 (ou 29) posições • char nomes[50][30]; //50 índices de strings de 30 (ou 29) posições • float notas; • float notas[30]; //30 índices • Toda STRING é um vetor de CHAR!

4. Preenchimento • É possível preencher um vetor índice a índice, como se fossem variáveis isoladas. Assim como é possível utilizar uma estrutura de repetição para auxiliar o preenchimento do vetor. • intmain() { • int idades[10]; • idades[0] = 18; • idades[1] = 25; • ⋮ • idades[9] = 33;

5. Preenchimento • intmain() { • int idades[10]; • printf(“Digite a idade:”); • scanf(“%d”, &idades[0]); • printf(“Digite a idade:”); • scanf(“%d”, &idades[1]); • ⋮ • printf(“Digite a idade:”); • scanf(“%d”, &idades[9]);

6. preenchimento • Se declararmos um vetor, não será possível inserir um dado nele como se fosse uma variável! Por exemplo: • intmain() { • int idades[10]; • idades = 18; • E também não será possível inserir um valor num índice fora da faixa de índices do vetor! Por exemplo: • idades[15] = 34;

7. Preenchimento • intmain() { • int idades[10], contador; • for(contador = 0; contador < 10; contador++) { • printf(“Digite a idade:”); • scanf(“%d”, &idades[contador]); • }

8. preenchimento • intmain() { • intidades[10]; • Na memória do computador teremos algo mais ou menos assim:

9. Preenchimento • Digamos que, após uma rotina para preencher os valores baseada em estrutura de repetição, esses valores foram inseridos nos índices do vetor:

10. leitura • Para lermos e/ou exibirmos os valores em cada índice do vetor, usamos basicamente os mesmos conceitos vistos no preenchimento do vetor. • Digamos que o vetor foi devidamente declarado e preenchido. Podemos ler os valores deles indicando o índice diretamente ou usando uma estrutura de repetição para vários índices. • printf(“%d”, idades[0]); • printf(“%d”, idades[1]); • ⋮ • printf(“%d”, idades[9]);

11. Leitura • intmain() { • int idades[10], contador; • for(contador = 0; contador < 10; contador++) { • printf(“%d\n”, idades[contador]); • }

12. leitura • Podemos realizar operações matemáticas (caso o tipo de dado seja numérico) dos valores do vetor! Por exemplo, calcular a média das idades: • intmain() { • int contador, soma = 0, idades[10]; • float media; • for(contador = 0; contador < 10; contador++) { • soma += idades[contador]; • } • media = (soma / 10); • printf(“Média das idades: %0.2f”, media);

13. Leitura • Assim como os índices podem se tornar elementos de operações condicionais. Por exemplo, mostrar todos os números pares no vetor: • intmain() { • int contador, idades[10]; • for(contador = 0; contador < 10; contador++) { • if((idades[contador] % 2) == 0) { • printf(“%d é par\n”, idades[contador]); • } • }

14. pesquisa sequencial • E se quisermos pesquisar algo num vetor? Para nos certificarmos se algo está lá ou não? Afinal, já que podemos percorrer um vetor para preenchê-lo/lê-lo, por que não para indicar se algo existe lá? • Temos alguns tipos de pesquisa que podem ser feitas, e abordaremos a pesquisa linear (ou sequencial), e será exibida resumidamente a pesquisa binária. • Como procuramos nossas coisas em nossa casa? Primeiro pensamos nos lugares que elas podem estar e depois procuramos nos lugares até achá-las. • No vetor é basicamente a mesma coisa: temos os lugares que elas podem estar (os índices) e procuramos até encontrar um dado.

15. pesquisa sequencial • intmain() { • int contador, item, idades[10], achou = 0; • for(contador = 0; contador < 10; contador++) { • if(idades[contador] == item) { • achou = 1; • } • } • if(achou) { • printf(“Seu item está presente no vetor”); • } else { • printf(“Seu item não está presente no vetor”); • }

16. Pesquisa sequencial • Ele irá percorrer todo o vetor e irá trocar o valor da variável de “0” para “1” quando encontrar o valor que você deseja. • Problemas? Sim! Nesse caso o problema é de performance, visto que o vetor inteiro será percorrido em busca de itens iguais ao que você deseja. E após encontrar o item em algum índice, ele continuará percorrendo o vetor. • Que tal se pararmos a busca caso encontremos o item?

17. Pesquisa sequencial • intmain() { • intcontador = 0, item, idades[10], achou = 0; • while((contador < 10) && !achou) { • if(idades[contador] == item) { • achou = 1; • } else { • contador++; • } • } • if(achou) { • printf(“Seu item está presente no vetor”); • } else { • printf(“ Seu item não está presente no vetor”); • }

18. Pesquisa sequencial • Resolvemos o problema! Agora ele só irá pesquisar no vetor inteiro na pior das hipóteses: quando o item que você quer encontrar estiver na última posição do vetor ou quando o item não existir no vetor. • while((contador < 10) && !achou) { • if(idades[contador] == item) { • achou = true; • } else { • contador++; • } • } • Mas em compensação, ele continuará buscando somente se ele não tiver chegado ao fim do vetor e se não tiver achado.

19. pesquisa binária • Há também outros algoritmos com melhor performance do que o de pesquisa linear. Um deles é o de pesquisa binária. • Ele vai comparando as pontas e o meio do vetor, e dependendo do valor, ele vai “quebrando” na metade, e novamente comparando as pontas e o meio do vetor, para novamente “quebrá-lo” pela metade, e assim sucessivamente. Ele é um algoritmo que usa a técnica “dividir para conquistar”. • Como ele é um algoritmo mais avançado, não o veremos aqui no curso, mas será exibido representativamente. • Primeiramente devemos saber que para uma pesquisa binária ser feita, o vetor tem de estar ordenado.

20. Pesquisa binária

21. ordenação • Assim como podemos preencher, ler e pesquisar num vetor, podemos ordená-lo alfanumericamente. • Após uma rotina de ordenação, ele ficará assim:

22. Ordenação • Como ordenamos um vetor? Percorremos todos os itens, um a um, do começo ao fim. Cada item é comparado com os demais. Se há algum item nos demais que é menor que o que eu estou comparando, eu troco a posição desses dois itens, e então ele passa a estar mais para o começo do vetor. • Para esse exemplo, usaremos um vetor mais simples, com 5 índices: • E no final ele tem de ficar assim:

23. Ordenação • Índice atual: 1. • Comparando 1 com 4, quem é menor? 1. Então continuam onde estão. • Comparando 1 com 3, quem é menor? 1. Então continuam onde estão. • Comparando 1 com 5, quem é menor? 1. Então continuam onde estão. • Comparando 1 com 2, quem é menor? 1. Então continuam onde estão.

24. Ordenação • Índice atual: 2. • Comparando 4 com 3, quem é menor? 3. Então trocam de posições. • Comparando 3 com 5, quem é menor? 3. Então continuam onde estão. • Comparando 3 com 2, quem é menor? 2. Então trocam de posições.

25. Ordenação • Índice atual: 3. • Comparando 4 com 5, quem é menor? 4. Então continuam onde estão. • Comparando 4 com 3, quem é menor? 3. Então trocam de posições.

26. Ordenação • Índice atual: 4. • Comparando 5 com 4, quem é menor? 4. Então trocam de posições.

27. Ordenação • Índice atual: 5. • Comparando 5 com... não tem mais o que comparar! Está ordenado! • Para o aprendizado, esse algoritmo é o mais simples para ser entendido e implementado. Há diversos outros algoritmos para ordenação de vetores e listas. Aí entramos em um assunto chamado “complexidade de algoritmos”, que visa testar e garantir resultados mais eficientes nos algoritmos de ordenação. • E para codificar esse algoritmo... será que é difícil? Não!

28. Ordenação • intmain() { • int a, b, temp, idades[10]; • for(a = 0; a < 9; a++) { • for(b = (a + 1); b < 10; b++) { • if(idades[a] > idades[b]) { • temp = idades[a]; • idades[a] = idades[b]; • idades[b] = temp; • } • } • }

29. Ordenação • E se eu quisesse ordenar decrescentemente? Ou seja, se tenho: • Ficar assim: • Basta na verificação de quem é “menor”, alterar o símbolo para “maior”, ou seja, ele trocará de posição se o item a ser comparado for maior que o outro. Os itens maiores estarão no começo do vetor. • if(idades[a] > idades[b]) { • if(idades[a] <idades[b]) {

30. Ordenação • Este algoritmo de ordenação de vetores funciona com quase todos os tipos básicos vistos: int, float, e char. • No caso do char, como sabemos que uma letra é “menor” que a outra, para podermos ordená-los? Na tabela ASCII, as letras possuem um valor numérico, e a letra A vem antes dos restantes. • Mas e no caso das strings, ou vetores de char?Lembram que foi dito no início da aula que toda string é um vetor de char? Lembram que uma string, a ser declarada, ela sempre irá possuir um espaço a menos por causa do símbolo \0? • Então vamos para a 2ª parte da aula: vetores de caracteres.

31. fflush(stdin); • intmain() { • char letras[10]; • int contador; • for(contador = 0; contador < 10; contador++) { • printf(“Digite um caractere:”); • scanf(“%c”, &letras[contador]); • }

32. fflush(stdin); • Há um problema no preenchimento do vetor de caracteres. O <enter> é tido como um caractere, para o computador. Ou seja, ele irá armazenar o caractere no índice atual, o depois armazenar o <enter> (no caso, um caractere vazio) no próximo. Experimente! • Para resolver isso, usamos um procedimento chamado fflush(stdin);. • Ela limpa o buffer do teclado. Com isso aquele <enter> que normalmente fica armazenado no buffer some do buffer e não segue para a próxima instrução de leitura.

33. fflush(stdin); • intmain() { • char letras[10]; • int contador; • for(contador = 0; contador < 10; contador++) { • printf(“Digite um caractere:”); • scanf(“%c”, &letras[contador]); • fflush(stdin); • }

34. fflush(stdin); • int main() { • char a, b, c; • scanf("%c", &a); • scanf("%c", &b); • scanf("%c", &c); • printf("%c\n", a); • printf("%c\n", b); • printf("%c\n", c); • Ainda no exemplo do fflush(stdin);, se fizermosdessa forma, a variável “a” receberá um valor. A variável “b” automaticamenterecebe o <enter>, e quandoestamosachandoqueestamospreenchendo o valor da variável “b”, elejáestápreenchendo a variável “c” com o valor digitado.

35. fflush(stdin); • int main() { • char a, b, c; • scanf("%c", &a); • fflush(stdin); • scanf("%c", &b); • fflush(stdin); • scanf("%c", &c); • fflush(stdin); • printf("%c\n", a); • printf("%c\n", b); • printf("%c\n", c); • Colocando o fflush(stdin) apóscadaleiturado teclado para armazenarnavariável, elaapaga o buffer do teclado, quearmazenou o <enter>, e preencherá a próximavariável com o que for digitado.

36. \0 • A “barra invertida zero”, ou “backslash zero”, é um caractere invisível, não-imprimível, que indica o fim de uma string. • char nome[15] = “computação”; • Isso é uma string, simplesmente por causa do \0 no final!

37. \0 • char nome[15]; • nome[0] = ‘c’; nome[1] = ‘o’;nome[2] = ‘m’; nome[3] = ‘p’; • nome[4] = ‘u’; nome[5] = ‘t’; nome[6] = ‘a’; nome[7] = ‘c’; • nome[8] = ‘a’; nome[9] = ‘o’; • Isso é um vetor de caracteres, por não ter o \0 no final!

38. \0 • Para manipularmos strings, devemos importar uma biblioteca, como já vimos: • #include <stdio.h> • #include <stdlib.h> • #include <string.h> • E as funções para leitura e escrita: • scanf(“%s”, variável); gets(variável); • printf(“%s”, variável); puts(variável);

39. \0 • Se eu imprimir o vetor dessa forma: • printf(“%s”, nome); • Será impresso isto:

40. \0 • Porque não houve o delimitador \0 para finalizar a string. Ou seja, quando usamos o procedimento printf(), ele imprime o vetor, caractere a caractere, até encontrar o \0. • printf(“%s”, nome); • Será impresso isto:

41. vetores de string • Como já foi dito, um vetor de strings é um vetor de vetor de caracteres. Futuramente veremos que um vetor de vetores é uma matriz, que inclusive é a nossa próxima aula. • char nomes[5][10]; • Um vetor chamado “nomes”, com 5 índices, e em cada índice é possível armazenar 10 caracteres, ou strings de 9 caracteres (sempre lembrando que um está reservado para o \0).

42. preenchendo vetores de strings • intmain() { • char nomes[5][10]; • int contador; • for(contador = 0; contador < 5; contador++) { • printf(“Digite o nome:”); • scanf(“%s”, nomes[contador]); • }

43. Lendo vetores de strings • intmain() { • char nomes[5][10]; • int contador; • for(contador = 0; contador < 5; contador++) { • printf(“%s”, nomes[contador]); • }

44. Pesquisando em vetores de strings • intmain() { • intcontador = 0, nomes[5][10], achou = 0; • char item[10]; • while((contador < 5) && !achou) { • if(strcmp(nomes[contador], item) == 0) { • achou = 1; • } else { • contador++; • } • } • if(achou) { • printf(“Seu item está presente no vetor”); • } else { • printf(“Seu item não está presente no vetor”); • }

45. Ordenando vetores de strings • intmain() { • int, a, b; • char nomes[10], temp[10]; • for(a = 0; a < 4; a++) { • for(b = (a + 1); b < 5; b++) { • if(strcmp(nomes[a], nomes[b]) == 1) { • strcpy(temp, nomes[a]); • strcpy(nomes[a], nomes[b]); • strcpy(nomes[b], temp); • } • } • }