Prova de Recuperação

Transcrição

1 Programação I Prova de Recuperação 1. (1 ponto) Considere um programa que leia de um arquivo de veículos os seguintes dados: placa de um veículo, ano de fabricação, consumo médio de combústivel, modelo e cor do veículo (uma palavra cada) e quilometragem rodada. Escreva as estruturas de dados para que se possa manipular tais informações. struct carro { char placa[10]; // pelo menos 8 caracteres para acomodar uma placa char cor[15]; char model[15]; int km; float consumo; // real para acomodar décimos de quilometro/litro int anofab; ; // n~ao declarar como global, deixando o cadastro como par^ametro!!! 2. (3 pontos) Considerando as estruturas da questão anterior e os modos corretos para passagem de parâmetros, escreva funções para: (a) Ordenar os veículos pelo ano de fabricação; (b) Ordenar os veículos pela sua placa; (c) Escrever os dados dos veículos em um arquivo; // uma funç~ao apenas para trocar dois elementos do vetor de estruturas void troca(struct carro cad[10000], int i, int j) {struct carro aux; aux = cad[i]; cad[i] = cad[j]; cad[j] = aux; // ordenaç~ao simples, veja algoritmo no material da disciplina!! void ordena_ano(struct carro cad[10000], int n) {int i, j, menor; for (i=0; i<n-1; i++) { menor = i; for (j=i+1; j<n; j++) if (cad[j].anofab < cad[menor].anofab) menor = j; if (menor!= i) troca(cad, i, menor); 1

2 // ordenaç~ao simples, veja algoritmo no material da disciplina!! // aqui apenas muda o campo de comparaç~ao, que passa a ser string void ordena_placa(struct carro cad[10000], int n) {int i, j, menor; for (i=0; i<n-1; i++) { menor = i; for (j=i+1; j<n; j++) if (strcmp(cad[j].placa, cad[menor].placa) < 0) menor = j; if (menor!= i) troca(cad, i, menor); // como é operaç~ao de escrita tem que saber o número de elementos // que ser~ao gravados (n) e faz-se um for escrevendo cada veículo void grava(struct carro cad[10000], int n) {FILE *out; int i; out = fopen("arq_saida.dat","w"); if (out == NULL) { puts("nao foi possível escrever o arquivo de saída"); exit(0); else { for (i=0; i<n; i++) { fprintf(out,"%s %s\n",cad[i].placa, cad[i].model); fprintf(out,"%s\n%d ",cad[i].cor, cad[i].anofab); fprintf(out,"%d %f\n",cad[i].km, cad[i].consumo); // printfs divididos apenas para caber na página :-) fclose(out); 3. (3 pontos) Problemas de caminho em labirintos podem ser tratados através de matrizes em que os obstáculos e paredes do labirinto são representados por um inteiro negativo e os caminhos abertos por zeros. Encontrar o menor caminho entre dois pontos do labirinto pode ser feito, então, marcando o ponto de partida com o valor zero e crescendo esse valor nas casas vizinhas em uma unidade até que se chegue ao ponto de destino, evitando as posições com valores negativos. Escreva um programa (usando modularização e se possível recursão) que leia três inteiros N, M e P, representando o número de linhas (N) e colunas da matriz (M) e o número de posições que representam obstáculos no labirinto (P). Em seguida deve ler P pares de inteiros, que representam 2

3 as coordenadas dos obstáculos. Deve então ler dois pares de inteiros, sendo o primeiro representando as coordenadas do ponto de partida e o segundo as coordenadas do ponto de destino. Após isso, seu programa deve encontrar o menor caminho entre partida e destino, guardando esse caminho num vetor de coordenadas. Deve então imprimir o caminho encontrado. Exemplo de labirinto e como ficaria o mapa do mesmo, considerando os pontos (0,3) como partida e (4,2) como chegada: #include "stdio.h" // essa funç~ao busca, recursivamente, os caminhos possíveis a partir do // ponto inicial, verificando se a casa seguinte pode ser trilhada e // ainda n~ao faz parte de um caminho mais curto void busca(int mat[1000][1000], int i, int j, int k, int n, int m) { // em cada if o primeiro teste verifica se n~ao vai avançar além da // borda, o segundo teste verifica se casa já n~ao foi percorrida e o // terceiro verifica se n~ao é obstáculo. Passando pelo teste, marca-se // a casa e chama a funç~ao recursivamente if ((i-1 >= 0) && (mat[i-1][j] > k) && (mat[i-1][j] > 0)) { mat[i-1][j] = k+1; busca(mat, i-1, j, k+1, n, m); if ((i+1 < n) && (mat[i+1][j] > k) && (mat[i+1][j] > 0)) { mat[i+1][j] = k+1; busca(mat, i+1, j, k+1, n, m); if ((j-1 >= 0) && (mat[i][j-1] > k) && (mat[i][j-1] > 0)) { mat[i][j-1] = k+1; busca(mat, i, j-1, k+1, n, m); if ((j+1 < m) && (mat[i][j+1] > k) && (mat[i][j+1] > 0)) { mat[i][j+1] = k+1; busca(mat, i, j+1, k+1, n, m); 3

4 // esta funç~ao imprime o caminho a ser seguido. Ela parte do ponto de // destino, recursivamente em direç~ao ao ponto de início. Quando chega // nele começa a voltar das recurs~oes imprimindo as coordenadas do // ponto em que está naquele momento. void mostra(int mat[1000][1000], int i, int j, int compr) {int k=i, l=j; if (mat[i][j] > 0) { if (mat[i][j-1] == compr-1) j = j - 1; else if (mat[i][j+1] == compr-1) j = j + 1; else if (mat[i-1][j] == compr-1) i = i - 1; else if (mat[i+1][j] == compr-1) i = i + 1; mostra(mat, i, j, compr-1); printf ("Em (%d, %d)...\n",k,l); // funç~ao para ler os obstáculos no labirinto void le(int mat[1000][1000], int n) {int i, j, k; for (k=0; k<n; k++) { scanf("%d %d",&i, &j); mat[i][j] = -1; main() {int labir[1000][1000], n, m, p, part[2], dest[2], i, j; scanf("%d %d %d",&n, &m, &p); // inicia todas as casas do labirinto com um número alto para // permitir que se busque o caminho curto recursivamente for (i=0; i<n; i++) for (j=0; j<m; j++) labir[i][j] = 99999; le(labir, p); scanf("%d %d", &part[0], &part[1]); scanf("%d %d", &dest[0], &dest[1]); labir[part[0]][part[1]] = 0; // diz que a posiç~ao inicial tem valor 0 busca(labir, part[0], part[1], 0, n, m); mostra(labir, dest[0], dest[1], labir[dest[0]][dest[1]]); 4

5 4. (3 pontos) Escreva uma função que receba um valor em reais (o troco de um pagamento) e retorne ao programa qual a melhor forma de dividi-lo nos valores possíveis de notas e moedas, reduzindo ao máximo o número de notas e moedas a serem retornadas. Considere que as notas e moedas possíveis são: 10, 5 e 2 reais em notas e 1, 0.50, 0.25, 0.10, 0.05 e 0.01 reais em moedas. void troco{float valor, int vet[10], int tipos[10]) // vetor tipos guarda os valores 1000, 500, 200, 100, 50, 25, 10, 5 e 1, // que ser~ao usados para encontrar as quantidades de notas e moedas de // cada valor {int i, quanto, resto; resto = (int)(valor*100); // converte o valor para uma quantidade // inteira de centavos for (i=0; resto > 0; i++) { vet[i] = resto/tipos[i]; resto = resto%tipos[i]; Comentários diversos: 1. Os operadores de resto e divisão inteira funcionam na forma esperada apenas para variáveis inteiras. Não funcionam para floats. 2. USEM parâmetros nas chamadas de funções. Eles resolvem metade dos problemas no tratamento de variáveis 3. USEM funções (modularização) em seus programas. Elas reduzem bastante o tamanho do código 4. USEM vetores quando tiverem que armazenar valores de mesmo tipo que sejam relacionados. Vejam como ficou a questão 4 em relação ao que vocês tentaram fazer. 5. A questão 3 era mais elaborada e demandava solução recursiva para não cair num emaranhado de if-then-else 6. As questões 1, 2 e 3 eram mais simples, sendo que não verdade não deveriam apresentar dificuldade alguma, pois na questão 2 a dificuldade era ordenar um vetor e vimos duas formas diferentes de fazer isso em sala e a questão 4 precisava apenas lembrar que vetores podem ser usados para retornar valores de uma função. 5