7.1. Arreglos unidimensionales (listas) y multidimensionales (tablas)

Ejemplos de uso de arreglos
A continuación se muestra un programa sencillo donde se declara un arreglo de diez elementos, se recorre el arreglo para iniciar todos los elementos en 0, y posteriormente se imprimen los valores de los elementos con su subíndice correspondiente.


#include (stdio.h)
#include (conio.h)
main( )
{
int n[10], i; /*declaración del arreglo n y la variable entera i */

for (i=0; i<=9; i++) /* ciclo de inicialización del arreglo */
n[i]=0;
printf("%8s%13s\n", "Elemento", "Valor");

for (i=0; i<=9; i++) /* ciclo para mostrar los valores del arreglo */
printf("%8d%13d\n", i, n[i]);
getch ( );
return 0;
}

Los elementos de un arreglo también pueden ser inicializados en la misma declaración del arreglo, siguiendo al nombre del arreglo con un signo igual y una lista de valores separados por coma y encerrados entre llaves. Si el número de valores indicado es menor al número de elementos en el arreglo, los elementos restantes se inicializan automáticamente en cero. Sin embargo si el número de valores inicializadores es mayor al número de elementos en el arreglo se genera un error.

El siguiente ejemplo muestra una inicialización en la declaración:

/* Inicializacion de un arreglo dentro de la declaracion */
#include (stdio.h)
#include (conio.h)
main( )
{
/*declaracion e inicializacion del arreglo n */
int n[10] = {32,27,64,18,95,14,90,70,60,37};
int i;

printf("%8s%13s\n", "Elemento", "Valor");
for (i=0; i<=9; i++) /* ciclo para mostrar los valores del arreglo */
printf("%8d%13d\n", i, n[i]);
getch ( );
return 0;
}

Si de una declaración con una lista inicializadora se omite el tamaño del arreglo, el número de elementos en el arreglo será el número de elementos incluidos en la lista inicializadora. Por ejemplo:

int n[]={2,4,6,8};

se reserva memoria para 4 elementos del arreglo n (del elemento 0 al 3).

En el ejemplo siguiente la línea:
#define TAMANO 12
define una constante simbólica TAMANO cuyo valor es 12. Una constante simbólica es un valor que se reemplaza con texto de reemplazo en el preprocesador C, antes de que el programa sea compilado. Cuando el programa es preprocesado, todas las instancias de la constante simbólica TAMANO serán remplazadas por el texto de reemplazo 12. Esa es la función de la directiva del preprocesador #define.

/* Calcular la suma de los elementos de un arreglo */
#include (stdio.h)
#include (conio.h)
#define TAMANO 12
main( )
{
int a[TAMANO] = {10,8,7,52,42,27,18,95,14,70,60,37}, i, total=0;
for (i=0; i<=TAMANO -1; i++) /*ciclo para acumulación de valores*/
total+=a[i];
printf("La suma de los elementos del arreglo es %d\n", total);
getch ( );
return 0;
}

En el siguiente ejemplo se utilizan dos arreglos para la determinación de frecuencias de respuesta en una encuesta. También se utiliza la directiva del preprocesador #define.

/* Programa de frecuencias */
#include (stdio.h)
#include (conio.h)
#define NUMERO_RESPUESTAS 40
#define NUMERO_FRECUENCIAS 11

main()
{
int respuesta, numero;
int respuestas[NUMERO_RESPUESTAS] = {1,2,5,6,3,4,7,8,10,2,5,
8,10,9,1,4,5,7,5,1,4,5,8,7,8,2,1,8,10,10,10,9,8,5,6,7,5,6,5,6};
int frecuencia[NUMERO_FRECUENCIAS]={0}; /* Inicialización en cero */
/* Con el siguiente ciclo se recorre el arreglo de respuestas y se
incrementa el arreglo de frecuencias en su elemento correspondiente */
for (respuesta=0; respuesta <= NUMERO_RESPUESTAS -1; respuesta++)
++frecuencia[respuestas[respuesta]];
printf("%8s%13s\n", "Número", "Frecuencia");

/* Ciclo de impresión de frecuencias */
for (numero=1; numero<=10; numero++)
printf("%8d%13d\n", numero, frecuencia[numero]);
getch ( );
return 0;
}

En el siguiente ejemplo se utilizan arreglos para la impresión de un histograma.

/* Impresión de histogramas */
#include (stdio.h)
#include (conio.h)
#define TAMANO 10
main( )
{
int n[TAMANO] = {10,8,7,18,14,6,10,15,4,2};
int i, j;
printf("%15s%15s%s%-20s\n","Elemento","Valor"," ","Histograma");
/*Ciclo para la impresión de cada valor */
for (i=0; i<=TAMANO -1; i++)
{
printf("%15d%15d%s",i, n[i]," ");
/* ciclo para la impresión de cada asterisco (de 1 hasta el
valor de n[i], es decir el valor del elemento */
for (j=1; j<=n[i]; j++)
printf("%c",'*');
printf("\n");
}
getch ( );
return 0;
}

En C una cadena de caracteres es un arreglo de caracteres individuales. Los arreglos de caracteres tienen varias características únicas. Un arreglo de caracteres puede ser inicializado utilizando una literal de cadena. Por ejemplo:

char string1[] = “primero”;

inicializa los elementos de la cadena o arreglo de caracteres string1 a los caracteres individuales de la cadena “primero”. El tamaño del arreglo queda determinado por el compilador, basado en la longitud de la cadena. La cadena “primero” contiene 7 caracteres más un caracter especial de terminación de cadena, conocido como caracter nulo. Entonces el arreglo string1 contiene 8 elementos. La representación del caracter nulo es ‘\0’. En C todas las cadenas terminan con este caracter. Un arreglo de caracteres que represente una cadena, debe declararse siempre lo suficientemente grande para contener el número de caracteres de la cadena incluyendo el caracter nulo de terminación.

La declaración anterior es equivalente a:

char string1[]={‘p’,’r’,’i’,’m’,’e’,’r’,’o’,’\0’};

Dado que la cadena es una arreglo se puede referenciar un caracter en particular utilizando el subíndice. Por ejemplo string1[0] es ‘p’, y string1[4] es la ‘m’.

Se puede leer desde teclado una cadena de caracteres con scanf de la siguiente forma:

char string2[20]; /* declaración del arreglo de 19 caracteres y el nulo */
scanf(“%s”, string2); /*lectura de teclado de una cadena y asignación a string2 */

en este caso no se utiliza el operador de dirección &, puesto que un arreglo es ya de por sí la dirección en memoria del inicio del arreglo.

La función scanf lee caracteres de teclado hasta que se encuentra el primer caracter de espacio en blanco sin importar el tamaño.

Es posible imprimir una cadena de caracteres con printf de la siguiente forma:

printf(“%s”, string2);

En el siguiente ejemplo se analiza el manejo de arreglos de tipo char.

/* Manejo de arreglos de tipo char */
#include (stdio.h)
#include (conio.h)
main( )
{
char string1[20], string2[]="Cadena de Caracteres";
int i;

printf("Introduzca un string: ");
scanf("%s", string1);
printf("El string1 es: %s\n",string1);
printf("El string2 es: %s\n",string2);
printf("El string1 con espacios es: \n");
/* impresion con un espacio despues de cada caracter*/
for (i=0; string1[i] != '\0'; i++)

if (string1[i]>='a' && string1[i]<='z')
/* si es una letra minuscula hacerla mayuscula */
printf("%c ", string1[i]-32);
else
/* si no es letra minuscula imprimir tal cual */
printf("%c ", string1[i]);
printf("\n");
getch ( );
return 0;
}

Paso de arreglos como parámetros a funciones.
Para pasar como argumento un arreglo a una función, se especifica el nombre del arreglo, sin corchetes, por ejemplo, para pasar a una función imprimePresion el arreglo PresionDiaria se realiza de la siguiente manera:

imprimePresion(PresionDiaria, 7);

en este ejemplo se pasa también como parámetro la longitud del arreglo, esto se hace normalmente para que las funciones puedan procesar todos los elementos del arreglo sin tratar de acceder a elementos inexistentes.

C pasa de forma automática los arreglos a las funciones utilizando simulación de llamadas por referencia, es decir, las funciones llamadas pueden modificar los valores de los elementos en los arreglos originales de los llamadores. Esto se debe a que la función llamada no realiza una copia como lo hace con las variables normales, sino que recibe la dirección de memoria del inicio del arreglo, por tanto, donde se hacen las posibles asignaciones dentro de las funciones es en los espacios originales que ocupa el arreglo en memoria.

Para que una función reciba un arreglo a través de una llamada de función, la lista de parámetros de la función debe especificar que se va a recibir un arreglo. Por ejemplo, el encabezado de función para la función modificarArreglo puede ser escrito como:

void modificarArreglo(int b[], int size)

A continuación se presenta un ejemplo utilizando llamadas a funciones con paso de arreglos como parámetros.

/* Pasando arreglos y elementos individuales de arreglo a funciones */
#include (stdio.h)
#include (conio.h)
#define SIZE 5
void modificarArreglo( int [], int); /*prototipos de funcion*/
void modificarElemento(int);
main( )
{
int a[SIZE] = {4,3,2,1,0};
int i;
printf("Efecto de pasar un arreglo a una funcion\n");
printf("Los valores originales son:\n");
for (i=0; i<=SIZE-1; i++)
printf("%3d", a[i]);
printf("\n");
modificarArreglo(a, SIZE);
printf("Los valores modificados son:\n");
for (i=0; i<=SIZE-1; i++)
printf("%3d", a[i]);
printf("\n\nEfecto de pasar un solo elemento por valor\n");
printf("El valor de a[3] es: %d\n", a[3]);
modificarElemento(a[3]);
printf("El valor de a[3] es: %d\n", a[3]);
getch ( );
return 0;
}
/* función que modifica los valores del arreglo */
void modificarArreglo(int c[], int size)
{
int j;
for (j=0; j<=size-1; j ++)
c[j] *= 2;
}
/* función que modifica un entero, en este caso un elemento del arreglo */
void modificarElemento(int elemento)
{
printf("El valor en modificarElemento es: %d\n", elemento *= 2);
}

Existen situaciones en las que no se desea que el arreglo original sea modificado por una función. En estos casos es necesario utilizar el calificador especial const, calificando al arreglo tanto en el prototipo como en el encabezado de la función, cuando se hace esto el arreglo se recibe como constante, y cualquier modificación que se intente hacer sobre él, causará un error. El siguiente programa es un ejemplo de ello:

/* Demostracion del calificador de tipo const */
#include (stdio.h)
#include (conio.h)
void tratarDeModificarArreglo(const int []);
main( )
{
int a[]= {10,20,30};
tratarDeModificarArreglo(a);
printf("%d %d %d\n", a[0], a[1], a[2]);
return 0;
}

void tratarDeModificarArreglo(const int b[])
{
/*Generan error: No se puede modificar un objeto constante */
b[0] /= 2;
b[1] /= 2;
b[2] /= 2;
}


Ordenamiento de arreglos.
La mayoría de las aplicaciones de cómputo requieren tener datos ordenados En el siguiente ejemplo se realiza uno de los métodos de ordenación más simples conocido como método de burbuja u ordenación por hundimiento. La técnica consiste en llevar a cabo varias pasadas a través del arreglo, en cada pasada se comparan pares sucesivos de elementos. Si un par está en orden creciente (o son valores idénticos), los valores se quedan tal como están. Si un par aparece en orden decreciente sus valores se intercambian de lugar, utilizando una variable que almacenará temporalmente el valor del primer elemento, éste tomará el valor del segundo elemento del par, y por último el segundo tomará el valor temporal que correspondía al primer elemento.

/* Ordenamiento de arreglo por método de burbuja */
#include (stdio.h)
#include (conio.h)
#define SIZE 10
main( )
{
int a[SIZE]= {12,35,6,48,8,27,32,87,52,75};
int i, temporal, ciclo;
printf("Los valores en el orden original son: \n");
for (i=0; i<= SIZE -1; i++)
printf("%4d", a[i]);
/* Ordenamiento */
for (ciclo=1; ciclo<=SIZE -1; ciclo++)
for (i=0; i<=SIZE-1-ciclo; i++)
/*Intercambio de valores en caso de no estar en orden */
if (a[i] > a[i+1])
{
temporal = a[i];
a[i] = a[i+1];
a[i+1]= temporal;
}
/*Impresion de valores ordenados */ printf("\nLos valores ordenados son: \n");
for (i=0; i<= SIZE -1; i++)
printf("%4d", a[i]);
getch ( );
return 0;
}

Existen otros métodos de ordenamiento más complejos en cuanto a su implementación, pero más eficientes en el número total de comparaciones que realizan, ocupando menor tiempo (en términos computacionales) en ordenar el arreglo.

Búsqueda de arreglos
Existen también varios métodos para buscar un elemento en un arreglo, sin embargo, el buen funcionamiento de algunos depende de que los elementos del arreglo estén ordenados de alguna manera. El método para buscar un elemento en un arreglo que no se encuentre ordenado (también funciona para arreglos ordenados), es la búsqueda lineal, que consiste en comparar cada elemento del arreglo (comenzando por el primero) con el valor buscado, y cuando se encuentre uno igual, señalar el índice del elemento correspondiente.

El siguiente ejemplo muestra una función que realiza la búsqueda lineal de un elemento.

/* Busqueda lineal en un arreglo */
#include (stdio.h)
#include (conio.h)
#define SIZE 10
int BusquedaLineal(int [], int,int);
main()
{
int a[SIZE]= {12,35,6,48,8,27,32,87,52,75};
int valorBuscado, indiceValor, i;
clrscr();
printf("Introduzca el valor a buscar en el arreglo: ");
scanf("%d", &valorBuscado);
indiceValor= BusquedaLineal(a,valorBuscado, SIZE);
if (indiceValor != -1)
printf("%d corresponde al elemento %d", valorBuscado, indiceValor);
else
printf("No se encontro %d en el arreglo",valorBuscado);
return 0;
}

int BusquedaLineal(int arreglo[], int valor, int size)
{
int j;
/*Compara todos los elementos */
for (j=0; j<=size-1;j++)
if (arreglo[j]==valor)
return j; /* Valor regresado en cuanto lo encuentra*/
return -1; /* regresa -1 cuando no encuentra el valor */
}

Para arreglos ordenados es muy utilizado el método de búsqueda binaria, que consiste en irse directamente al elemento de central (posición de en medio) del arreglo, si el valor buscado es menor la primera mitad del arreglo se desecha, y si es mayor la se desecha la segunda. Se hace lo mismo con la parte que quedo del arreglo buscando el punto medio, y así sucesivamente. El mayor número de comparaciones posibles es igual a la mitad del tamaño del arreglo.

/* Busqueda binaria en un arreglo */
#include (stdio.h)
#include (conio.h)
#define SIZE 10
void OrdenaArreglo(int[] , int );
int BusquedaBinaria(int [], int , int );
main( )
{
int b[SIZE]= {12,35,6,48,8,27,32,87,52,75};
int valorBuscado, elemento, i;
clrscr();
OrdenaArreglo (b, SIZE);
printf("Los valores del arreglo son: \n");
for (i=0; i<= SIZE -1; i++)
printf("%4d", b[i]);
printf("\n\nIntroduzca el valor a buscar en el arreglo: ");
scanf("%d", &valorBuscado);
elemento = BusquedaBinaria(b, valorBuscado, SIZE);
if (elemento != -1)
printf("%d es el elemento %d", valorBuscado, elemento);
else
printf("No se encontro %d en el arreglo", valorBuscado);
getch ( );
return 0;
}
/* Ordenamiento */
void OrdenaArreglo(int a[], int size)
{
int ciclo, temporal,i;
for (ciclo=1; ciclo<=size -1; ciclo++)
for (i=0; i<=size-1-ciclo; i++)
if (a[i] > a[i+1])
{
temporal = a[i];
a[i] = a[i+1];
a[i+1]= temporal;
}
}
/*Busqueda binaria */
int BusquedaBinaria(int arreglo[], int valor, int size)
{
int medio, primero=0, ultimo=size -1;
while (primero <= ultimo)
{
medio= (primero + ultimo) / 2;
if (valor == arreglo [medio])
return medio;
else
if (valor < arreglo [medio])
ultimo = medio - 1;
else
primero = medio + 1;
}
return -1;
}

Arreglos bidimensionales
En algunos lenguajes de programación, y es el caso de C, se permiten arreglos de varios subíndices, es decir, arreglos multidimensionales. Generalmente estos arreglos se utilizan para representar tablas de valores con renglones y columnas, donde el primer subíndice representa el renglón y el segundo la columna. Para referenciar cualquier elemento del arreglo se deben indicar los dos subíndices.

Un arreglo de múltiple subíndice puede ser inicializado en su declaración en forma similar a un arreglo de un subíndice. Por ejemplo, un arreglo de doble subíndice b[2][2] puede ser inicializado con

int b[2][2] = {{ 1, 2}, {3, 4}};

Los valores se agrupan por renglones entre llaves. Por lo tanto, 1 y 2 inicializan b[0][0] y b[0][1], 3 y 4 inicializan b[1][0] y b[1][1]. Si para un renglón dado no se proporcionan suficientes inicializadores, los elementos restantes de dicho renglón se inicializarán a 0. Por ejemplo:

int b[2][2] = {{ 1}, {3, 4}};

inicializaría b[0][0] en 1 y b[0][1] en 0, b[1][0] en 3 y b[1][1] en 4.

En la tabla siguiente se muestra la representación gráfica de un arreglo con tres renglones y cuatro columnas.

                     Columna0   Columna1  Columna2  Columna 3
Renglón0    a[0][0]        a[0][1]       a[0][2]       a[0][3]
Renglón1     a[1][0]        a[1][1]       a[1][2]        a[1][3]
Renglón2    a[2][0]        a[2][1]       a[2][2]        a[2][3]

El recorrido de un arreglo de dos dimensiones para impresión o para cualquier procesamiento deberá hacerse con dos ciclos for anidados, de tal modo que el más exterior recorra todos los renglones, y para cada renglón (el ciclo for interior) recorra todas las columnas del arreglo, de tal forma que cada elemento sea referenciado en los ciclos anidados. A continuación se muestra un ejemplo simple para impresión de un arreglo bidimensional.

/* Inicialización de arreglos bidimensionales */
#include (stdio.h)
#include (conio.h)
void imprimeArreglo(int [][3]);
main( )
{
int arreglo1[2][3] = { {1,2,3}, {4,5,6}},
arreglo2[2][3] = { 1,2,3,4,5},
arreglo3[2][3] = { {1,2}, {4}};
clrscr();
printf("Los valores en arreglo1 por renglón son: \n");
imprimeArreglo(arreglo1);
printf("Los valores en arreglo2 por renglón son: \n");
imprimeArreglo(arreglo2);
printf("Los valores en arreglo3 por renglón son: \n");
imprimeArreglo(arreglo3);
getch ( );
return 0;
}
void imprimeArreglo(int arreglo[][3])
{
int i,j;
for (i=0; i<=1; i++)
{
for (j=0; j<=2; j++)
printf("%5d", arreglo[i][j]);
printf("\n");
}
}

PRACTICA DE ARREGLOS.
En un grupo existen cinco alumnos, los cuales presentaron tres exámenes cada uno obteniendo las siguientes calificaciones:

CALIFICACIONES
ALUMNOS  Examen0  Examen1  Examen2
Alumno0      77               74              84
Alumno1      96               85              76
Alumno2      70               69              88
Alumno3      58               86              90
Alumno4      75               91              72

Se desea obtener la tabla de calificaciones (semejante a la mostrada), la calificación más baja, la calificación más alta y el promedio por cada alumno.

El problema se resuelve de la siguiente forma:

Como se conoce el número de alumnos y el número de calificaciones se definirán dos constantes simbólicas ALUMNOS y EXAMENES de 5 y 3 respectivamente.

/* Ejemplo de arreglos bidimensionales */
#include (stdio.h)
#include (conio.h)
#define ALUMNOS 5
#define EXAMENES 3

Debido a que se utilizarán funciones para imprimir los valores, encontrar la calificación mínima, la máxima y el promedio por alumno, es necesario comenzar a trabajar con dichas funciones. La función mínima debe encontrar la calificación más baja entre todos los elementos del arreglo, por tanto será necesario que reciba como parámetros el mismo arreglo, el número de filas (o alumnos) y el número de columnas (calificaciones), esto debido a que la función no debe ignorar elementos, ni tampoco tratar de acceder a elementos que no existen en el arreglo. La manera de encontrar la calificación mínima es suponer una mínima seguramente mayor a todas, como 100 (para que sea sustituida rápidamente por el primer elemento del arreglo). Todas los elementos se compararán con la calificación mínima registrada hasta el momento, y de ser menor, este valor será asignado a la variable minimo, de tal forma que al término del recorrido de todo el arreglo, la variable minimo contenga el valor de la calificación más baja.

/*Calificación mínima */
int minima (int calificaciones[][EXAMENES], int alum, int prueba)
{
int i, j, minimo = 100;
for (i=0;i<=alum-1; i++)
for (j=0; j<=prueba-1; j++)
if (calificaciones[i][j] < minimo)
minimo = calificaciones[i][j];
return minimo;
}

De la misma forma que la función minima, deberá plantearse la función maxima, que encontrará la calificación más alta. En este caso la variable maximo es iniciada en 0 para ser sustituida por cualquier elemento mayor. Posteriormente se recorre el arreglo y se va guardando el valor mayor en la variable maximo.

/* Calificación máxima */
int maxima (int calificaciones[][EXAMENES], int alum, int prueba)
{
int i, j, maximo = 0;
for (i=0;i<=alum-1; i++)
for (j=0; j<=prueba-1; j++)
if (calificaciones[i][j] > maximo)
maximo = calificaciones[i][j];
return maximo;
}

La función para imprimir el arreglo, simplemente hace un recorrido en un primer ciclo for, de todos los renglones (alumnos) en el arreglo, y en un for anidado recorre cada una de las columnas de cada fila (calificaciones), imprimiendo renglón por renglón.

/* imprime el arreglo */
void imprimeArreglo(int calificaciones[][EXAMENES], int estudiante, int pruebas)
{
int i,j;
printf("\n%-20s%-30s\n"," ", "CALIFICACIONES");
printf("%-20s%6s%6s%6s", "ALUMNO","[0]","[1]","[2]","[3]");
for (i=0; i<= estudiante-1; i++)
{
printf("\nAlumno %d ", i);
for(j=0; j<=pruebas-1; j++)
printf("%6d", calificaciones[i][j]);
}
}

Para determinar el promedio por alumno se hará otra función, que devuelve un tipo float (el promedio) y que recibe únicamente dos parámetros, un arreglo de una sola dimensión y el tamaño de este arreglo (el número de calificaciones). El arreglo sencillo corresponde a las tres calificaciones del alumno en cuestión. La función acumula mediante un ciclo todos los valores para posteriormente dividirlo entre el total de calificaciones (la variable pruebas).

/*Promedio */
float promedio(int calif[], int pruebas)
{
int i, total=0;
for (i=0; i<=pruebas-1; i++)
total += calif[i];
return total/pruebas;
}

En la función main (programa principal) se declararán dos variables enteras, una representando el arreglo de calificaciones, donde tendremos 5 renglones (de alumnos) y 3 columnas (de calificaciones), que se inicializará en la misma declaración. La otra variable entera ialumno, servirá para recorrer el arreglo en todas sus filas, es decir, alumno por alumno. Una vez hecho esto deben mandar llamarse las funciones creadas de la forma correcta para obtener los resultados deseados.

main()
{
int ialumno, alumCalif[ALUMNOS][EXAMENES] = {{77,74,84},{96,85,96},
70,69,88},{58,86,90},{75,91,72}};
clrscr();
printf("El arreglo es: \n");
imprimeArreglo(alumCalif, ALUMNOS, EXAMENES);
printf("\n\nCalificación más baja: %d\n", minima(alumCalif,(ALUMNOS,EXAMENES));
printf("Calificación más alta: %d\n", maxima(alumCalif,ALUMNOS,EXAMENES));
for (ialumno=0; ialumno<=ALUMNOS - 1; ialumno ++)
printf("\nEl promedio para el alumno %d es: %.2f\n", ialumno,
promedio(alumCalif[ialumno], EXAMENES));
getch ( );
return 0;
}

No hay que olvidar que las definiciones de las funciones deben ubicarse después de main y que antes de main debe existir un prototipo. De este modo el programa completo queda de la siguiente manera:

/* Ejemplo de arreglos bidimensionales */
#include (stdio.h)
#include (conio.h)
#define ALUMNOS 5
#define EXAMENES 3
int minima(int [][EXAMENES], int, int);
int maxima(int [][EXAMENES], int, int);
float promedio(int [], int);
void imprimeArreglo( int [][EXAMENES], int, int);

main( )
{
int ialumno,
alumCalif[ALUMNOS][EXAMENES] = {{77,74,84},{96,85,96},
{70,69,88},{58,86,90},{75,91,72}};
clrscr();
printf("El arreglo es: \n");
imprimeArreglo(alumCalif, ALUMNOS, EXAMENES);
printf("\n\nCalificación más baja: %d\n", minima(alumCalif, ALUMNOS,EXAMENES));
printf("Calificación más alta: %d\n", maxima(alumCalif, ALUMNOS,EXAMENES));
for (ialumno=0; ialumno<=ALUMNOS - 1; ialumno ++)
printf("\nEl promedio para el alumno %d es: %.2f\n", ialumno,
promedio(alumCalif[ialumno], EXAMENES));
return 0;
}

/*imprime el arreglo */
void imprimeArreglo(int calificaciones[][EXAMENES], int estudiante, int pruebas)
{
int i,j;
printf("\n%-20s%-30s\n"," ", "CALIFICACIONES");
printf("%-20s%6s%6s%6s", "ALUMNO","[0]","[1]","[2]","[3]");
for (i=0; i<= estudiante-1; i++)
{
printf("\nAlumno %d ", i);
for(j=0; j<=pruebas-1; j++)
printf("%6d", calificaciones[i][j]);
}
}

/*Calificación mínima */
int minima (int calificaciones[][EXAMENES], int alum, int prueba)
{
int i, j, minimo = 100;
for (i=0;i<=alum-1; i++)
for (j=0; j<=prueba-1; j++)
if (calificaciones[i][j] < minimo)
minimo = calificaciones[i][j];
return minimo;
}

/*Calificación máxima */
int maxima (int calificaciones[][EXAMENES], int alum, int prueba)
{
int i, j, maximo = 0;
for (i=0;i<=alum-1; i++)
for (j=0; j<=prueba-1; j++)
if (calificaciones[i][j] > maximo)
maximo = calificaciones[i][j];
return maximo;
}

/*Promedio */
float promedio(int calif[], int pruebas)
{
int i, total=0;
for (i=0; i<=pruebas-1; i++)
total += calif[i];
return total/pruebas;
}