Arrays. 6.2 Arrays. 6.1 Introdução. Elementos de um array são como as variáveis normais que vocês já conhecem

Transcrição

1 1 2 Arrays.1 Introdução Array Vector Estrutura de elementos relacionados ( do mesmo tipo) Entidade estática tem sempre a mesma dimensão ao longo da execução do programa É um grupo de locais de memória consecutivos que partilham o mesmo nome e tipo Formato: Para nos referirmos a um elemento do vector usamos o nome do vector e o índice da posição que o elemento ocupa no vector - nomedovector[ numerodaposição ] O primeiro elemento está na posição zero n ésimo elemento de um array com nome c é c[ n 1 ] - c[ 0 ], c[ 1 ]...c[ n 1 ] 2007 Pearson Education, Inc. All rights reserved. Adaptado para PROG I por Ana Respício (DIFCUL) Nome do array (todos os elementos têm o mesmo nome c) 3.2 Arrays 4 Elementos de um array são como as variáveis normais que vocês já conhecem - c[ 0 ] = 3; - printf( "%d", c[ 0 ] ); Posição do elemento dentro do array c Podemos fazer operações nos índices. Se x for igual a 3 - c[ x ] é igual a - c[ 3 ] e também igual a - c[ 5-2 ] Fig..1 Elementos do array c.

2 5 Erro comum de programação Operadores Associatividade Tipo [] () parentesis ++ --! (tipo) unario O sétimo elemento do vector é diferente do elemento na posição sete do vector. Os índices dos vectores começam em zero 0. O sétimo elemento do vector tem índice. O elemento na posição sete do vector tem índice 7 e é o oitavo elemento no vector. * / % multiplicativo + - aditivo < <= > >= relacional ==!= igualdade && conjunção lógica dijunção lógica?: condicional = += -= *= /= %= atribuição, vírgula Isto costuma dar confusão!!!! Fig..2 Precedência e associatividade dos operadores..3 Definição de arrays 7.4 Exemplos 8 Quando definimos arrays, especificamos Nome Tipo dos elementos no array Número de elementos - tipo nomearray[ numerodeelementos ]; Exemplos: - int c[ 10 ]; - double myarray[ 3284 ]; Definição de vários arrays do mesmo tipo Formato como nas outras variáveis Exemplo: - int b[ 100 ], x[ 27 ]; Inicializadores - int n[ 5 ] = { 1, 2, 3, 4, 5 }; Se não estão presentes inicializadores em número suficiente, os elementos mais à direita ficam com o valor 0 int n[ 5 ] = { 0 }; - Todososelementosficam0 Se há inicializadores em demasia, há erro de compilação Não há verificação dos limites dos arrays em C Se o tamanho for omitido, são os inicializadores que o determinam - int n[ ] = { 1, 2, 3, 4, 5 }; 5 inicializadores, logo o array vai ter 5 elementos

3 1 /* Fig..3: fig0_03.c initialização de um array 2 * Ligeiramente modificado por Ana Respício */ 4 5 int main( void ) 7 { 8 int meu[ 10 ]; /* meu eh um array com 10 elementos */ 9 int i; /* contador */ /* inicializa elementos do array meu com valor 0 */ 12 for ( i = 0; i < 10; i++ ) { 13 meu[ i ] = 0; /* atribui 0 ao elemento na posicao i */ 14 } /* end for */ 15 1 printf( " Posicao Valor\n" ); /* escreve o conteudo do array meu com aspecto de uma tabela */ 19 for ( i = 0; i < 10; i++ ) { 20 printf( "%7d%13d\n", i, meu[ i ] ); 21 } /* fim do for */ return 0; } /* fim da funcao main */ fig0_03.c (1 de 2 ) Ciclo for inicializa cada elemento do array em separado Ciclo for imprime todos os elementos do array 9 Posicao Valor fig0_03.c (2 de 2 ) 10 1 /* Fig..4: fig0_04.c 2 * Inicializacao de um array com uma lista de inicializadores 3 * Adaptado por Ana Respício */ 4 #include <stdio.h> 5 int main( void ) 7 { 8 /* usa uma lista de inicializadores para inicializar o array meu */ 9 int meu[ 10 ] = { 32, 27, 4, 18, 95, 14, 90, 70, 0, 37 }; 10 int i; /* contador */ printf( " Posicao Valor\n" ); /* imprime o conteudo do array na forma de uma tabela */ 15 for ( i = 0; i < 10; i++ ) { 1 printf( "%7d%13d\n", i, meu[ i ] ); 17 } /* fim do for */ return 0; } /* fim da funcao main */ fig0_04.c (1 de 2 ) A lista de inicializadores inicializa todos os elementos simultaneamente 11 Posicao Valor fig0_04.c (2 de 2 ) 12

4 Erro comum de programação 1. Esquecer de inicializar os elementos de um array cujos elementos devem ser inicializados. 2. Usar mais inicializadores do que o tamanho do array /* Fig..5: fig0_05.c 14 2 * Inicializar os elementos de um array s com os numeros pares 3 * entre 2 e 20 */ 4 #include <stdio.h> A directiva #define diz ao compilador para 5 #define SIZE 10 /* tamanho maximo do array */ substituir todas as ocorrências da palavra SIZE por 10 fig0_05.c 7 int main( void ) 8 { 9 /* a constante simbolica SIZE eh usada para especificar o tamanho do array */ 10 int s[ SIZE ]; /* array s tem SIZE elementos */ 11 int j; /* contador */ for ( j = 0; j < SIZE; j++ ) { /* atribuir os valores */ 14 s[ j ] = * j; 15 } /* fim do for */ 1 17 printf( " Posicao Valor\n" ); /* imprime o conteudo do array em forma de tabela */ 20 for ( j = 0; j < SIZE; j++ ) { 21 printf( "%7d%13d\n", j, s[ j ] ); 22 } /* fim do for */ return 0; 25 2 } /* fim da funcao main */ (1 de 2 ) SIZE é substituída por 10 pelo compilador, o array s tem 10 elementos for inicializa cada elemento do array em separado Posicao Valor fig0_05.c (2 de 2 ) 15 Erro comum de programação Terminar uma directiva de pré-processamento #define ou #include com ; 1 As directivas de pré-processamento em C não são instruções.

5 17 18 Erro comum de programação Observação Atribuir um valor a uma constante simbólica numa instrução é um erro de sintaxe. Uma constante simbólica não é uma variável. Não é reservado espaço em memória para ela pelo compilador como acontece com as variáveis. Definir o tamanho de cada array como uma constante simbólica torna os programas mais fáceis de adaptar (redimensionáveis e expansíveis) Boa Prática de Programação Boa Prática de Programação Usar só letras maiuscúlas para os nomes das constantes simbólicas. Isto evidencia estas constantes e lembra que as constantes não são variáveis. Se precisar de usar várias palavras no nome duma constante simbólica use underscores a separar as palavras para mais fácil leitura.

6 1 /* Fig..: fig0_0.c 2 Calcular a soma dos elementos de um array */ 4 #define SIZE int main( void ) 8 { 9 /* usar lista de inicializadores para inicializar os elementos do array a */ 10 int a[ SIZE ] = { 1, 3, 5, 4, 7, 2, 99, 1, 45, 7, 89, 45 }; 11 int i; /* contador */ 12 int total = 0; /* soma dos elementos */ /* soma os elementos do array a */ 15 for ( i = 0; i < SIZE; i++ ) { 1 total += a[ i ]; 17 } /* fim do for */ printf( "A soma dos elementos do array eh %d\n", total ); return 0; } /* fim da funcao main */ A soma dos elementos do array eh 383 Ciclo for adidiona cada elemento à variável total fig0_0.c 21 Problema: Temos 40 respostas a um inquérito em que cada resposta pode tomar um valor entre 1 e 10 inclusive. Pretendemos encontrar a frequência de cada resposta, isto é, quantas respostas tiveram o valor 1, quantas tiveram o valor 2, etc. 1 /* Fig..7: fig0_07.c 2 calcular as frequencias de respostas (pontuacao) em inqueritos */ 4 #define DIM_RESPOSTAS 40 /* definir tamanhos dos vectores */ 5 #define DIM_FREQUENCIAS int main( void ) 9 { 10 int conta; /* contador para percorrer as respostas */ 11 int pontos; /* contador para percorrer frequencias 1-10 */ 12 int valordaresposta; 13 /* inicializar os contadores de frequencias a 0 */ 14 int frequencia[ DIM_FREQUENCIAS ] = { 0 }; 15 1 /* respostas dos alunos */ 17 int resposta[ DIM_RESPOSTAS ] = { 1, 2,, 4, 8, 5, 9, 7, 8, 10, 18 1,, 3, 8,, 10, 3, 8, 2, 7,, 5, 7,, 8,, 7, 5,,, 19 5,, 7, 5,, 4, 8,, 8, 10 }; /* para cada resposta seleccionar o elemento do array resposta 22 e usar esse valor como indice do array frequencia para determinar 23 a pontuacao cuja frequencia deve ser incrementada */ 24 for ( conta = 0; conta < DIM_RESPOSTAS; conta++ ) { 25 valordaresposta = resposta[ conta ]; 2 ++frequencia[ valordaresposta ]; 27 } /* fim do for */ 28 fig0_07.c (1 de 2 ) frequencia é um array com 11 elementos resposta é um array com 40 elements e é inicializado Indice do array frequencia é dado pelo valor do elemento do array resposta printf("pontuacao Frequencia\n" ); /* output das frequencias num formato tabular */ 32 for ( pontos = 1; pontos < DIM_FREQUENCIAS; pontos++ ) { 33 printf( "%d%17d\n", pontos, frequencia [ pontos ] ); 34 } /* end for */ 35 3 return 0; } /* end main */ Pontuacao Frequencia fig0_07.c (2 de 2 ) 24

7 1 /* Fig..8: fig0_08.c 2 Programa para imprimir um histograma */ 4 #define DIMENSAO int main( void ) 8 { 9 /* usar uma lista de incializadores para inicializar frequencias */ 10 int frequencia [ DIMENSAO ] = { 19, 3, 15, 7, 11, 9, 13, 5, 17, 1 }; 11 int i; /* contador para percorrer os elementos do array */ 12 int j; /* conta o numero de asteriscos em cada barra do histograma */ printf( " Posicao Valor Histograma\n" ); 15 1 /* para cada elemento do vector frequencia escreve uma barra do histograma */ 17 for ( i = 0; i < DIMENSAO; i++ ) { 18 printf( "%7d%13d ", i, frequencia[ i ]) ; for ( j = 1; j <= frequencia[ i ]; j++ ) { /* escreve uma barra */ 21 printf( "* ); 22 } /* fim do for interno */ printf( "\n" ); /* fim duma barra do histograma */ 25 } /* fim do for sobre os elementos do array */ 2 27 return 0; } /* fim da funcao main */ fig0_08.c (1 de 2 ) O ciclo for interno escreve frequencia[ i ] asteriscos na i-ésima linha 25 Posicao Valor Histograma 0 19 ******************* 1 3 *** 2 15 *************** 3 7 ******* 4 11 *********** 5 9 ********* 13 ************* 7 5 ***** 8 17 ***************** 9 1 * fig0_08.c (2 de 2 ) 2.5 Passar vectores para funções 27.5 Passar vectores para funções 28 Para passar um vector como argumento duma função especifica-se o nome do vector sem usar os parêntesis rectos: int meuarray[ 24 ]; passar meuarray como argumento para minhafuncao minhafuncao( meuarray, 24 ); - A dimensão do vector (ou número de elementos a utilizar) também costuma ser passada Os vectores são passados por referência: - O nome do array é o endereço do primeiro elemento - A função fica a saber onde o array está guardado e pode modificar os locais da memória correspondentes Protótipo da função - void minhafuncao( int b[], int dimarray ); Notar que o parâmetro que corresponde a um vector não especifica o tamanho do vector - int b[]

8 1 /* Fig..12: fig0_12.c 2 O nome de um vector é o mesmo que &vector[ 0 ] */ 4 5 /* função main inicia o programa */ int main( void ) 7 { 8 char vectorexemplo[ 5 ]; /* definir um vector com dimensão 5 */ 9 10 printf( " vector = %p\n&vector[0] = %p\n &vector = %p\n", 11 vectorexemplo, &vectorexemplo[ 0 ], &vectorexemplo ); return 0; } /* fim main */ vector = 0012FF78 &vector[0] = 0012FF78 &vector = 0012FF78 fig0_12.c.5 Passar vectores para funções Também é possível passar elementos de um vector como argumentos (escalares) Passagem de um elemento de um vector, ex: int outrafuncaominha( int valor ); int meuarray[ 24 ]; int resultado; resultado = outrafuncaominha( meuarray[ 3 ] ); Um elemento é passado por valor: É indicado como argumento o elemento que está numa posição meuarray[ 3 ] A função outrafuncaominha recebe uma cópia do valor que está em meuarray[ 3 ] A função não fica a saber onde o array está guardado e não modifica o local da memória correspondente 30.5 Passar vectores para funções Se quisermos alterar um dado elemento, temos de passar o array todo, e a posição do elemento a alterar, ex: void modificaelemento( int vector[], int dimensao, int posicao ); int meuarray[ 24 ]; modificaelemento( meuarray, 24, 3 ); É passado por valor: A dimensão (24), a posição (3) É passado por referência: O vector meuarray 31 Boa Prática de Programação Passar vectores por referência faz sentido por uma questão de desempenho. Se os vectores fossem passados por valor, ter-se-ia de passar uma cópia de cada elemento. Para vectores de grande dimensão isso consumiria muito tempo e seria necessário gastar muito espaço de memória para guardar as cópias.

9 1 /* Fig..13: fig0_13.c 2 Passagem de vectores e elementos de vectores para funcoes */ 4 #define DIMENSAO 5 5 /* prototipos */ 7 void modificavector( int vector[], int dimensao ); 8 void modificaelemento( int elem ); 9 10 /* funcao main inicia execucao */ 11 int main( void ) 12 { 13 int meuvector[ DIMENSAO ] = { 0, 1, 2, 3, 4 }; /* inicializa meuvector */ 14 int i; /* contador */ 15 1 printf( "Efeitos de passar um vector por referencia:\n\nthe " 17 "Valores do vector original:\n" ); /* imprimir o vector */ 20 for ( i = 0; i < DIMENSAO; i++ ) { 21 printf( "%3d", meuvector[ i ] ); 22 } printf( "\n" ); 25 2 /* passar vector meuvector para modificavector por referencia */ 27 modificavector( meuvector, DIMENSAO ); printf( "Valores do vector modificado:\n" ); 30 fig0_13.c (1 of 3 ) Array meuvector é passado a modificavector passando só o nome 31 /* imprime vector modificado */ 32 for ( i = 0; i < DIMENSAO; i++ ) { 33 printf( "%3d", meuvector[ i ] ); 34 } 35 3 /* imprime o valor de meuvector[ 3 ] */ 37 printf( "\n\n\nefeito de passar um elemento por valor: " 38 "\n\meuvector[ 3 ] = %d\n", meuvector[ 3 ] ); modificaelemento( meuvector[ 3 ] ); /* passa elemento meuvector[ 3 ] */ /* imprime elemento meuvector[ 3 ] */ 43 printf( "meuvector[ 3 ] apos modificaelemento = %d\n", meuvector[ 3 ] ); return 0; 4 47 } /* na funcao modificavector, vector referencia o vector que for passado 50 pelo seu endereco em memoria */ 51 void modificavector( int vector[], int dimensao ) 52 { 53 int j; /* contador */ /* multiplica cada elemento por 2 */ 5 for ( j = 0; j < dimensao; j++ ) { 57 vector[ j ] *= 2; 58 } 59 0 } /* fim funcao modificavector */ fig0_13.c (2 of 3 ) 1 2 /* na funcao modificaelemento, elem é uma copia local do valor passado 3 a partir da funcao invocadora (neste caso vai ser a main) */ 4 void modificaelemento( int elem ) 5 { elem *= 2; /* multiplica o parametro elem por 2 */ 7 printf( "Valor de elem em modificaelemento = %d\n", elem ); 8 } /* fim da funcao modificaelemento */ Efeitos de passar um vector por referencia: Valores do vector original: Valores do vector modificado: Efeito de passar um elemento por valor: meuvector[ 3 ] = Valor de elem em modificaelemento = 12 meuvector[ 3 ] apos modificaeleemnto = fig0_13.c (3 of 3 ).7 Calcular a média, o máximo e a moda usando vectores Média é a soma dos valores sobre o número de valores Máximo é o maior valor no vector Moda é o valor com maior número de ocorrências maior frequência 1, 1, 1, 2, 3, 3, 4, 5 1 é a moda 3

10 Pesquisar valor num vector.4 Cadeias de Caracteres Procurar num vector um valor chave Cadeias de caracteres (strings) são vectores de caracteres Pesquisa linear Simples Uma cadeia de caracteres "Alegria" é um vector de caracteres, pode ser inicializada usando uma sequência de caracteres entre aspas (um literal). Compara cada elemento do vector com o valor chave Útil em vectores de pequena dimensão e não ordenados char cadeia[] = "Alegria"; É equivalente a char cadeia[] = { 'A', 'l', 'e', 'g', 'r', 'i', 'a', '\0' }; -O carácter null representado por '\0' termina as cadeias de caracteres -O vector cadeia tem 8 elementos Podemos aceder a caracteres individuais cadeia[ 3 ] é o carácter 'g'.4 Cadeias de Caracteres 39.4 Cadeias de Caracteres Nome do array é o endereço do array & não é necessário quando lemos uma cadeia com scanf scanf( "%s", cadeia ); scanf, com argumento cadeia de caracteres, lê caracteres até que seja encontrado um dos seguintes caracteres: space (espaço em branco), tab (marca de tabulação), newline (marca de fim de linha) ou EOF (end-of-file). 0 Exemplo: 'P' 1 'i' char minhastring[ 20 ]; scanf( "%19s", minhastring ); o utilizador introduz Pinto da Costa O que fica guardado no array: 2 'n' 3 't' 4 'o' 5 '\0' Cuidado: não ultrapassar o limite do array pois o C permite isso, mas causa erros. Pode destruir dados. Uma solução possível: char minhastring[ 20 ]; scanf( "%19s", minhastring ); - Imprimindo: printf( "%s", minhastring ); imprime Pinto O printf escreve todos os elementos do vector até encontrar o carácter null. Atenção: a string tem de ter algum elemento '\0' Pearson Education, Inc. All rights reserved. Adaptado para PROG1 por Carlos Ana Lourenço Respício e (DIFCUL) Graça Gaspar (DIFCUL)

11 1 /* Fig..10: fig0_10.c 2 Cadeias de caracteres como vectores */ 4 5 int main( void ) 7 { 8 char cadeia1[ 20 ]; /* reserva 20 caracteres */ 9 char cadeia2[] = "Bom dia alegria!"; /* reserva 17 caracteres */ 10 int i; /* contador */ /* le uma cadeia introduzida pelo utilizador para array cadeia1 */ 13 printf("introduza uma cadeia de caracteres: "); 14 scanf( "%19s", cadeia1 ); /* input acaba com espaco em branco */ 15 1 /* escreve as cadeias */ 17 printf( "cadeia1 = %s\ncadeia2 = %s\n" 18 "cadeia1 com espacos entre os caracteres = \n", 19 cadeia1, cadeia2 ); /* escreve caracteres ate que o caracter null seja encontrado */ 22 for ( i = 0; i < 20 && cadeia1[ i ]!= '\0'; i++ ) { 23 printf( "%c ", cadeia1[ i ] ); 24 } /* fim for */ 25 2 printf( "\n" ); return 0; } /* end main */ fig0_10.c (1 de 2 ) cadeia2 é um array definido com um carácter em cada elemento, são 17 caracteres incluindo o null /0 foi inicializada com o literal Bom dia alegria! for imprime os caracteres de cadeia1 com espaço entre eles Notar a condição de continuação: É o caracter null que sinaliza o fim da string e não a última posição do vector 41 Introduza uma cadeia de caracteres: Alunos, calem-se! cadeia1 = Alunos, cadeia2 = Bom dia alegria! cadeia1 com espacos entre os caracteres = A l u n o s, fig0_10.c (2 de 2 ) Arrays bi-dimensionais int a[ 3 ] [ 4 ]; Arrays com dois índices Tabelas com várias linhas e colunas ( array m por n ) São como matrizes: especificamos linha, depois coluna Declaração int b[ 2 ][ 2 ]; LInha 0 Linha 1 Linha 2 Coluna 0 Coluna 1 Coluna 2 Coluna 3 É um array com 2 linhas e 2 colunas; Referenciar os elementos Índice da coluna Índice da linha Nome do array Especificar a linha e depois a coluna - b[0][1] = 23; - printf( "%d", b[ 0 ][ 1 ] ); Fig..20 Array bi-dimensional com três linhas e quatro colunas.

12 45 4 Erro Comum de Programação.9 Arrays bi-dimensionais Inicialização Referenciar um elemento de um array bi-dimensional por a[ x, y ] em vez de a[x][y]. int b[2][2]={{1,2},{3,4}}; Inicializadores agrupam-se por linha entre chavetas Se não forem suficientes, os não especificados são colocados a zero - int b[2][2]={{1},{3,4}}; O C interpreta a[x,y]como sendo a[ y ] e não causa erro de sintaxe. 1 /* Fig..21: fig0_21.c 2 Inicialização de vectores multi-dimensionais */ 4 5 /* escreve o conteudo do vector a com 3 colunas e n linhas */ void escrevearray( int a[][ 3 ], int n ); 7 8 int main( void ) 9 { 10 /* inicializar array1, array2, array3 */ 11 int array1[ 2 ][ 3 ] = { { 1, 2, 3 }, { 4, 5, } }; 12 int array2[ 2 ][ 3 ] = { 1, 2, 3, 4, 5 }; 13 int array3[ 2 ][ 3 ] = { { 1, 2 }, { 4 } }; printf( "Valores no array1 por linha:\n" ); 1 escrevearray( array1, 2 ); printf( " Valores no array2 por linha:\n" ); 19 escrevearray( array2, 2 ); printf( " Valores no array3 por linha:\n" ); 22 escrevearray( array3, 2 ); return 0; 25 2 } /* fim main */ 27 fig0_21.c (1 de 2 ) todos os elementos de array1 são inicializados array2 e array3 são inicializados parcialmente /* escreve o conteudo do vector a com 3 colunas e n linhas */ 29 void escrevearray( int a[][ 3 ], int n ) 30 { 31 int i; /* contador para as linhas */ 32 int j; /* contador para as colunas */ /* ciclo que percorre as linhas */ 35 for ( i = 0; i < n; i++ ) { 3 37 /* imprime os valores em coluna */ 38 for ( j = 0; j <= 2; j++ ) { 39 printf( "%d ", a[ i ][ j ] ); 40 } /* fim for interno */ printf( "\n" ); /* inicia uma nova linha */ 43 } /* fim for externo */ } /* fim escrevearray */ Valores no array1 por linha: Valores no array2 por linha: Valores no array3 por linha: fig0_21.c (2 de 2 ) 48

13 1 /* Fig..22: fig0_22.c - Vectores bi-dimensionais 2 notas de varios alunos em multiplos exames */ 4 #define DIM_ALUNOS 3 5 #define DIM_EXAMES 4 7 /* prototipos */ 8 int minimo( int notas[][ DIM_EXAMES ], int alunos, int provas ); 9 int maximo( int notas[][ DIM_EXAMES ], int alunos, int provas ); 10 double media( int notas[], int provas ); 11 void escrevearray( int notas[][ DIM_EXAMES ], int alunos, int provas ); int main( void ) 15 { 1 int aluno; /* contador */ /* inicializa notas de tres alunos (linhas) */ 19 int notasalunos[ DIM_ALUNOS ][ DIM_EXAMES ] = 20 { { 14, 12, 1, 12 }, 21 { 19, 18, 18, 17 }, 22 { 10, 17, 17, 15 } }; /* imprimir as notas dos alunos */ 25 printf( "Notas:\n" ); 2 escrevearray(notasalunos, DIM_ALUNOS, DIM_EXAMES ); 27 Cada linha no array corresponde às notas de um aluno fig0_22.c (1 de ) /* determina a nota mais baixa e a nota mais alta */ 29 printf( "\n\nmenor nota: %d\nmaior nota: %d\n", 30 minimo( notasalunos, DIM_ALUNOS, DIM_EXAMES ), 31 maximo( notasalunos, DIM_ALUNOS, DIM_EXAMES) ); /* calcula a media de notas de cada aluno */ 34 for ( aluno = 0; aluno < DIM_ALUNOS; aluno++ ) { 35 printf( "A media das notas do aluno %d eh %.2f\n", 3 aluno, media( notasalunos[ aluno ], DIM_EXAMES ) ); 37 } /* fim for */ return 0; } /* fim main */ 42 fig0_22.c (2 de ) Para a função media passa-se a linha aluno do array notasalunos /* Nota minima no vector notas onde numero de linhas eh alunos */ 44 e numero de colunas eh provas */ 45 int minimo( int notas[][ DIM_EXAMES ], int alunos, int provas ) { 4 int i; /* contador para os alunos */ 47 int j; /* contador para as provas */ 48 int minnota = 20; /* inicializa com o maior valor possivel de nota */ /* percorre as linhas de notas */ 51 for ( i = 0; i < alunos; i++ ) { /* percorre as colunas da linha i */ 54 for ( j = 0; j < provas; j++ ) { 55 5 if ( notas[ i ][ j ] < minnota ) { 57 minnota = notas[ i ][ j ]; 58 } /* fim if */ 59 0 } /* fim for interno */ 1 2 } /* fim for externo */ 3 4 return minnota; /* devolve a nota minima */ 5 } /* fim funcao minimo */ 7 fig0_22.c (3 de ) 51 8 /* Nota maxima no vector notas onde numero de linhas eh alunos 9 e o numero de colunas eh provas */ 70 int maximo( int notas[][ DIM_EXAMES ], int alunos, int provas ) { 71 int i; /* contador para alunos */ 72 int j; /* contador para provas */ 73 int maxnota = 0; /* nota maxima - inicializa com o menor valor possivel */ /* percorre as linhas de notas */ 7 for ( i = 0; i < alunos; i++ ) { /* percorre as colunas de notas na linha i */ 79 for ( j = 0; j < provas; j++ ) { if ( notas[ i ][ j ] > maxnota ) { 82 maxnota = notas[ i ][ j ]; 83 } /* fim if */ } /* fim for interno */ 8 87 } /* fim for externo */ return maxnota; /* devolve a nota maxima */ } /* fim funcao maximo */ 92 fig0_22.c (4 de ) 52

14 93 /* Media das notas de um dado aluno passadas no vector notasdealuno 94 com dimensao provas */ 95 double media( int notasdealuno[], int provas ) { /* escreve as notas no formato de tabela */ 118 for ( i = 0; i < alunos; i++ ) { int i; /* contador de provas */ 120 /* escreve numero do aluno */ 97 int total = 0; /* soma das notas */ 121 printf( "\nnotasdoaluno[%d] ", i ); /* calcula a soma das notas */ 100 for ( i = 0; i < provas; i++ ) { 101 total += notasdealuno[ i ]; fig0_22.c (5 de ) /* escreve as notas do aluno i */ 124 for ( j = 0; j < provas; j++ ) { 125 printf( "%5d", notas[ i ][ j ] ); fig0_22.c ( de ) 102 } /* end for */ 12 } /* fim for interno */ return ( double ) total / provas; /* media */ 128 } /* fim for externo */ } /* fim funcao media */ } /* fim funcao escrevearray */ /* Escreve o array notas com alunos linhas e provas colunas */ 109 void escrevearray( int notas[][ DIM_EXAMES ], int alunos, int provas ) 110 { 111 int i; /* contador para alunos */ 112 int j; /* contador para as provas */ /* escreve o cabecalho das colunas */ 115 printf( " [0] [1] [2] [3]" ); Notas: [0] [1] [2] [3] notasdoaluno[0] notasdoaluno[1] notasdoaluno[2] Menor nota: 10 Maior nota: 19 A media das notas do aluno 0 eh A media das notas do aluno 1 eh A media das notas do aluno 2 eh 14.75