OBJETIVO 

  
Aplicar el concepto de arreglos en diversas situaciones problemáticas, aprovechando las 
propiedades del recurso a la hora de manejar gran volumen de datos. 
En esta primer parte se introduce el concepto de arreglo y se trabaja con variables de tipo char e  int,
pero siempre manejando cantidades numéricas. En la segunda parte de Arreglos en C, se verá el  trabajo
con cadenas de caracteres. 

CONCEPTO 

A modo sintético, un arreglo en C (array) es un conjunto de variables del mismo tipo y bajo el  mismo
“nombre”, diferenciándose entre ellas por un subíndice. Esto implica que puede generarse  un arreglo o
más, de diversos tipos (char, int, float, etc) en casos de manejar determinados tipos de  datos que
guardan cierta correlación entre ellos. 
Lo “más importante en un arreglo” es que todas las variables que este contiene, se encuentran 
consecutivamente una tras otra en memoria; esto implica que a la hora de acceder a los elementos  del
arreglo, se logra con menos trabajo del procesador de la computadora, pues aritméticamente  solo tiene
que generar un “incremento” o “decremento” para pasar de un valor al siguiente.  

A continuación se listan una serie de actividades para que usted comprenda el concepto y pueda 
aprovecharlo de la mejor manera. 

ACTIVIDADES 

1- Copie en la consola de Code Blocks, el siguiente código ¡PERO NO LO EJECUTE AÚN! 

#include <stdio.h> 
#include <stdlib.h> 

int main() 
{ 
 char num[12]; //Arreglo de doce elementos sin inicializar 
 char i; 
 for(i = 0; i < 12; i++) 
 num[i] = 0; 
 for(i = 0; i < 12; i++) 
 printf("\n Valor del elemento %d del arreglo: %d",i ,num[i]); 
 printf("\n\n"); 
 system("PAUSE"); 
 return 0; }
a- ¿de qué tipo es el arreglo generado? ¿Cuántas variables contiene dicho arreglo? Realice un  esquema
en el cual indique todos los elementos del arreglo, pensando que el lugar de  memoria en que se
almacenan dichas variables es una porción de una hoja, la cual puede  contener filas (renglones) y
columnas. 
Son 12 elementos de arreglo del tipo char

num [0]

num [1]
 num [2]

num [3]

num [4]

num [5]

num [6]

num [7]

num [8]

num [9]

num [10]

num [11]

b- ¿Qué función cumple en este programa el primer ciclo for? 

cumple la funcion de  inicialización automática, es decir barrido e igualar todos lo números
predefinidos por la variable “i” (1,2,3,..11) a “0”.

c- ¿Qué realiza el segundo ciclo for de este programa?

cumple la función de imprimir en la pantalla los valores ingresados por el receptor la cantidad de
veces que se almacenó. 

IMPORTANTE (1): 
 Algo que usted no debe perder de vista, es que si un arreglo tiene un tamaño de  “diez”
por dar un ejemplo, entonces los subíndices de dicho arreglo irán de “0,1,2,….,9”.  Siempre los
elementos de un arreglo comienzan con el subíndice “cero”. Por lo tanto, el  primer elemento de
un arreglo “valor” (esto es un ejemplo valido para cualquier caso), será  valor[0]. 

IMPORTANTE (2): 
 Usted se preguntará: ¿Por qué el arreglo está creado de tipo char, siendo que se  utiliza
para almacenar números en este caso, y luego en el printf se muestra con conversión “%d”?  Respuesta
sencilla: “El tipo de datos char es de 8 bits de largo (256 combinaciones), y el tipo int  tiene 16 (65536).
Esto “NO SIGNIFICA” que un char solo pueda/deba ser utilizado para caracteres,  sino que también
puede ser utilizado para números sin signo no mayores que 255. Por eso mismo,  como en el ejemplo se
utilizan cantidades chicas es que se prefiere como tipo de datos al char y no  al int. Por último, como
nos interesa el valor numérico de los elementos del arreglo, es que en  printf se utiliza la conversión %d,
sin importar que el arreglo sea char”. 

d- Finalmente ejecute el código en el compilador, y verifique su funcionamiento. 

Su funcionamiento es igual al descripto anteriormente haciendo un barrido de todos los valores
de “i” e igualando a “0”.

2- Copie en la consola de Code Blocks, el siguiente código ¡PERO NO LO EJECUTE AÚN! 

int main() 
{ 
  char num[12] = {1,4,6,2,10,56,31,70,12,10,12,16}; //Arreglo de doce elementos  
inicializado 
 char i, a, b; 
 for(i = 0; i < 12; i++) 
 printf("\n Valor del elemento %d del arreglo: %d",i ,num[i]); 
 printf("\n\n"); 
 a = 3; 
 b = 4; 
 printf("Valor: %d", num[a+b]); 
 printf("\n\n"); 
 system("PAUSE"); 
 return 0; 
}

a- Observe como aquí el arreglo es inicializado con valores “aleatorios”. Lo importante es  utilizar
correctamente la sintaxis para inicializarlo (entre llaves y cada valor  separado por “comas”). 
b- ¿Qué función cumple el ciclo for?
 Primero cumple la función de impresión de cada uno de los valores aleatorios almacenados en el
array, luego busca el número correspondiente en el número ingresado por el receptor de
programa.
c- ¿Qué mostrará la línea printf("Valor: %d", num[a+b]); ?  
Mostrará el número 31 ya que es el número que indica el espacio es decir si a es igual a 3 y b es
igual a 4, sumados darán el número del lugar de el espacio, es decir en el lugar 7 estará el número
aleatorio correspondiente al número 31.

3- Genere un programa que posea un arreglo de “diez” elementos de tipo entero, e inicialícelos
con valores que usted desee (evite utilizar cantidad numéricas muy  grandes).
Posteriormente usted deberá calcular el promedio de la suma de todos los  valores del
arreglo.  
Usted debe escribir el código que solucione el problema anterior, y debe en 
consecuencia compilarlo y probar su funcionamiento. 
int main()
{
 int num[10] = {11,10,20,15,32,44,69,92,7,22};
 int i, s = 0;
float d;
 for(i = 0; i < 10; i++)
    s += num[i];
 for(i = 0; i < 10; i++)
    printf("\n Valor del elemento %d del arreglo: %d",i ,num[i]);
 printf("\n\n");
 p=s/10;
 printf ("La suma de todos estos numeros es: %d", s);
  printf("\n\n");
 printf ("El promedio de todos estos numeros es: %f", p);
printf("\n\n");
 system("PAUSE");
 return 0; }
 CONSEJO:  
 Normalmente al trabajar con arreglos que contengan datos como por ejemplo  “notas” de un
curso de alumnos, suele ser necesario trabajar con promedios o cálculos  de esta índole, en la
cual “el número de elementos del arreglo, posee vínculo con algún  parámetro de la
operación a realizar”. Por ejemplo, si se posee un arreglo de cinco elementos que contienen
notas, al calcular un promedio de ellas la operación sería  sumar los elementos y dividir por
“cinco”. También debería considerarse que para sumar  los valores normalmente se realiza un
acumulador con un for, y la cantidad de  iteraciones del ciclo están relacionadas al tamaño del
arreglo (cinco). 
En conclusión, es adecuado utilizar la directiva “define” que sirve para crear constantes  que
durante el tiempo de ejecución del código no pueden ser modificadas. Supongamos  el
ejemplo de un arreglo de “cinco” elementos. En este caso puede resolverse  lo siguiente: 

#define TAM 5 //TAM es nuestra constante de valor “cinco”  

int main() 
{ 
 char num[TAM] = {i1,4,6,2,10 }; //Arreglo de “cinco” elementos  
 for(i = 0;  < TAM; i++)  

. 
. 
. 
. 
Return 0; 
}
4- Genere un programa que pida por teclado las notas de 30 alumnos de un curso, y que  luego
realice las siguientes operaciones: 
a- Cálculo del promedio de las notas. 
b- Contabilizar la cantidad de notas que hay de cada una, considerando que las 
calificaciones van del 1 al 10. Por ejemplo: se registran 2 unos, 1 dos, ….., 10 siete,  etc… 
c- Imprimir un histograma con asteriscos en línea, que haga visible la cantidad de notas  de
cada tipo. Esto sería: 

Cantidad de uno: ** 

Cantidad de dos: * 

 . 

 . 

Cantidad de siete: ********** 

#include <stdio.h>
#include <stdlib.h>

int main()
{
 char notas[30], cant[10]={0};
 int i, j;
 float p;
 for (i=0; i<30; i++)
 {
   printf("Ingrese la nota del estudiante numero %d: ", i+1);
   scanf("%d", & notas[i]);
   if(notas[i]>10 || notas[i]<1)
        {
            while (notas[i]>10 || notas[i]<1)
            {
                printf("Valor fuera de rango, ingresela nuevamente el valor %d: ", i+1);
                scanf ("%d", & notas[i]);
            }
        }
    p+=notas[i];
 }
//ponce gay
 for (i=0; i<30; i++)
{
    if(notas[i]==1)
        cant[0]++;
    else if(notas[i]==2)
        cant[1]++;
    else if(notas[i]==3)
        cant[2]++;
    else if(notas[i]==4)
        cant[3]++;
    else if(notas[i]==5)
        cant[4]++;
    else if(notas[i]==6)
        cant[5]++;
    else if(notas[i]==7)
        cant[6]++;
    else if(notas[i]==8)
        cant[7]++;
    else if(notas[i]==9)
        cant[8]++;
    else if(notas[i]==10)
        cant[9]++;
}
    p/=30;
    system ("cls");
    printf ("El promedio de todos estos numeros es: %.2f \n", p);
    printf("Historial de notas:\n");

    for(i = 0; i < 10; i++)

    {
        printf("Cantidad de %d: ", i+1);
        for(j = 0; j < cant[i]; j++)
        {
            printf("*");
        }
        printf("\n");
    }
     return 0;
}

IMPORTANTE: para resolver este problema utilice dos arreglos. Uno de ellos contendrá  las
calificaciones, y en el otro se deberá almacenar la cantidad de notas que se repiten  de cada
tipo; es decir, el segundo arreglo deberá contabilizar la frecuencia de  recurrencia de cada
nota, de las ingresadas por teclado. Es recomendable que usted  realice un diagrama de flujos
por “rústico” que pueda ser, de modo tal que usted ordene  la idea de como proceder, pues
puede que no resulte intuitiva, y no es adecuado escribir  código en C e ir corrigiendo en base
a los errores de compilación “ASÍ NO SE APRENDE  DEMASIADO”. 

Como último consejo, utilice definiciones “define” para aquellos tipos de datos que sean 
importantes y constantes a lo largo del código, como ya se ha ejemplificado  anteriormente. 

5- Generar la resolución del mismo problema anterior, pero de manera “mucho más  optimizada”.
Probablemente usted utilizó ciclos for e instrucciones if, para contabilizar  la frecuencia con que
cada nota se ha hecho presente. ¡Existe una manera mucho más  eficiente de contabilizar este
tipo de información, utilizando “el valor de un arreglo,  como índice de otro arreglo”. Si no logra
comprender a que refiere esto, o no lo imagina,  luego se resolverá en clases, pero ¡no deje de
intentar pensar en que significa esto! 
#include <stdio.h>
int main() {
    int notas[30], cant[10] = {0};
    int i, j;
    float promedio;
    for(i = 0; i < 30; i++)
    {
        printf("Ingrese la nota del alumno %d: ", i+1);
        scanf("%d", & notas[i]);
        if(notas[i]>10)
        {
            while (notas[i]>10)
            {
                printf("Nota fuera de rango, ingresela nuevamente la nota %d: ", i);
                scanf ("%d", & notas[i]);
            }
        }
        promedio+=notas[i];
    }

    promedio /= 30;
    printf("El promedio de notas es: %.2f\n", promedio);

    for(i = 0; i < 30; i++)

    {
        cant[notas[i] - 1]++;
    }

    printf("Historial de notas:\n");
    for(i = 0; i < 10; i++)
    {
        printf("Cantidad de %d: ", i+1);
        for(j = 0; j < cant[i]; j++)
         {
            printf("*");
        }
        printf("\n");
    }

    return 0;
}

6- Se posee un sistema electrónico que censa la temperatura de un recinto cada una hora,  durante
24hs. Lo que se desea es realizar un algoritmo que pueda determinar al final del  proceso de
sensado diario, cuantas veces dicha temperatura superó los 50ºC, y a qué hora lo hizo. Por lo
usted deberá:
a- Ingresar a modo de prueba por teclado, las 24 mediciones de temperatura realizadas  a lo
largo del día. 
b- Realizar utilizando adecuadamente arreglos, la resolución del ejercicio en cuestión. 
#include <stdio.h>
#define CANTIDAD    24

int main() {
    int i = 0,c = 0,h,acum;
    int medido[CANTIDAD], superar[CANTIDAD];

    for(i = 0; i < CANTIDAD; i++)

        superar[i] = -1;

    for(i = 0; i < CANTIDAD; i++)

    {
        printf("Ingrese la temperatura:");
        scanf("%d", & medido[i]);
        if(medido[i] > 50){
            printf("Oh no! A superado los 50* \nIngrese la hora en la que sucedio: ");
            scanf("%d", & superar[i]);
            c++;
        }
    }
    printf("Historial de temperaturas:\n");
    printf("La cantidad de veces que supero los 50*: %d\n", c);
    for (i = 0; i < CANTIDAD; i++)
    {
        if (superar[i] != -1)
        {
            printf("El horario en el que lo supero fue: %d\n",superar[i]);
        }
    }
    return 0;
}

7- Considere el siguiente arreglo de tipo “char”, ya inicializado para este ejemplo: char  num[5]
= {1,56,31,70,16};. Lo que se desea es ordenarlo de “mayor” a “menor”, sin  perder
información, y haciéndolo en este mismo arreglo. 
 El método de resolución de este tipo de problemáticas se suele denominar “Método de  la
Burbuja”. Lo que se propone es: 
a- Escriba gráficamente en papel al arreglo como una columna con cinco filas, y analice 
pensando en qué podría usted hacer para ir intercambiando los valores dentro del  arreglo,
y con ayuda de alguna variable auxiliar, de modo tal de que todos los valores  queden
ordenados según se pide.                                                                     
b- Una vez propuesta alguna manera de resolución que usted haya logrado, genere un  método
(esto es una actividad cuyo único fin es que usted piense, y observe que esto  es cuestión
pura de razonamiento). 
c- Investigue acerca del método de la burbuja, y compare con lo que usted haya  logrado
realizar. 
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    char  num[5] = {1,56,31,70,16};
    int i, j, a;
    for(i = 0; i < 5; i++)
    {
        for(j = 0; j < 5; j++)
        {
            if (num[j]>num[j+1])
            {
                a=num[j+1];
                num[j+1]=num[j];
                num[j]=a;
            }
        }
    }
    for(j = 0; j < 5; j++)
    {
        printf("%d ", num[j]);
    }
    return 0;
}

8- Considere el ejercicio número 6, en el cual usted ingresaba 24 valores de temperaturas, 

considerando que estos valores se ingresan en orden desde las 00hs hasta las 23hs. En  este
ejercicio se desea ordenar de menor a mayor las temperaturas ingresadas, y luego  mostrarlas
en pantalla en este orden, “sin perder jamás de vista la hora a la cual fue  ingresada cada una”.
Por lo tanto usted debe: 
a- Ingresar aleatoriamente las temperaturas registradas.  
b- Mostrar en pantalla la temperatura, y la hora a la que este fue ingresado, en el orden 
cronológico de ingreso. 
c- Generar el orden requerido según el método de la burbuja, y sin que se borren las 
impresiones de pantalla anterior, imprimir los datos en el nuevo orden.
d- Verificar que las temperaturas y las horas a las cuales fueron ingresadas, no hayan 
dejado de coincidir; esto significa que el proceso ha sido bien realizado. 
#include <stdio.h>
#define CANTIDAD    3
 int main()
{
    int i=0, j=0, med[CANTIDAD][2], a;
    for(i = 0; i < CANTIDAD; i++)
    {
        printf("Ingrese la temperatura de las %02d:00hs: ", i);
        scanf("%d", & med[i][0]);
        med[i][1] = i;
     }
    printf("Historial de temperaturas:\n");
        for(j = 0; j < CANTIDAD; j++)
    {
        printf("%d ", med[j][0]);
        printf("%d \n", med[j][1]);
    }
    printf("Historial de temperaturas ordenadas de menor a mayor:\n");
    for(i = 0; i < CANTIDAD; i++)
    {
        for(j = 0; j < CANTIDAD - 1; j++)
        {
            if (med[j][0] < med[j + 1][0])
            {
                a = med[j + 1][0];
                med[j + 1][0] = med[j][0];
                med[j][0] = a;
                a = med[j + 1][1];
                med[j + 1][1] = med[j][1];
                med[j][1] = a;
            }
        }
    }
    for(j = 0; j < CANTIDAD; j++)
    {
        printf("%d ", med[j][0]);
        printf("%d \n", med[j][1]);
    }
    return 0;
}

9- Utilizando arreglos en C, realizar un programa que sea capaz de recibir por teclado las 
calificaciones de 10 alumnos. Una vez finalizado el pedido de los valores por teclado,  imprima
un mensaje con el valor del promedio. A su vez, genere un ciclo que posibilite  volver a cargar
nuevos valores, o que permite culminar la ejecución. Por ejemplo al  terminar, si el usuario
ingresa “1”, se continúa y si se ingresa “0” se termina el proceso y  se sale del programa. 
#include <stdio.h>
int main() {
    int notas[10];
    int i, j, a=1;
    float promedio;

    while(a==1)
    {
        system ("cls");
        for(i = 0; i < 10; i++)
    {
        printf("Ingrese la nota del alumno %d: ", i+1);
        scanf("%d", & notas[i]);
        if(notas[i]>10 || notas[i]<1)
        {
            while (notas[i]>10 || notas[i]<1)
            {
                printf("Nota fuera de rango, ingresela nuevamente la nota %d: ", i+1);
                scanf ("%d", & notas[i]);
            }
        }
        promedio+=notas[i];
    }

    promedio /= 10;
    printf("El promedio de notas es: %.2f\n", promedio);
    printf("¿Desea volver a ingresar notas? 1 = Si, 0 = No\n");
    scanf("%d", & a);
    }
    return 0;
}
10- Realizar un programa que permita ingresar 20 valores comprendidos entre “0 y 100”, y
efectuar una rutina de cálculo que me indique cuantos, de los valores ingresados, son
mayores a 80. A su vez, deberá imprimirse uno o varios mensajes, indicando en que
posiciones del arreglo se encuentran dichos valores mayores a 80.
#include <stdio.h>
int main() 
{
    int nums[20], mayor[20];
    int i, j;
    for(j = 0; j < 20; j++)
    {
        printf("Ingrese el valor numero %d: ", j+1);
        scanf("%d", & nums[j]);
        if(nums[j]>100 || nums[j]<0)
        {
            while (nums[j]>100 || nums[j]<0)
            {
                printf("Valor fuera de rango, ingresela nuevamente el valor %d: ", j+1);
                scanf ("%d", & nums[j]);
            }
        }
    }
        for(j = 0; j < 20; j++)
        {
            if(nums[j]>80)
            {
                printf("\nNumero mayor a 80 detectado en el valor %d del arreglo. Valor del numero: %d ", j+1,
nums[j]);
            }
        }
    return 0;
}
11- Existen situaciones problemáticas, en las cuales suele ser necesario reordenar valores de  forma
creciente o decreciente, considerando que en su ingreso por teclado (o por  cualquier otro
medio) se han ingresado de manera aleatoria.  
Una técnica para realizar reordenamiento, se denomina “método de la burbuja”. Dicho 
método lo que plantea es, comparar los valores que se desean ordenar (necesariamente 
estos valores deben estar en un arreglo), comenzando por el primero y comparándolo con  su
subsiguiente. Dependiendo como resulte la operación de comparación, dicho valor será 
“permutado” con su subsiguiente. Esto se repite hasta llegar al ante último elemento del 
arreglo. 
Este ciclo de recorrer y comparar los valores del arreglo, debe realizarse “N-1” veces, donde  N
es la cantidad de elementos que dicho arreglo posee. 

Considerando la operación anteriormente descripta, realice un programa que pida 10  valores
por teclado y que los ordene, según se indique en un menú de opciones, de mayor a menor, o
de menor a mayor, utilizando el método de la burbuja.
#include <stdio.h>
int main()
{
    int nums[10];
    int a, b, i, j;

    for(i = 0; i < 10; i++)

    {
        printf("Ingrese el valor numero %d:", i+1);
        scanf("%d", & nums[i]);
    }
        printf("\nDesea ordenar los numeros de menor a mayor o mayor a menor? 1 = menor a mayor, 2 =
mayor a menor\n");
        scanf("%d", & a);
        switch(a)
        {
        case 1:
        for(i = 0; i < 10; i++)
            {
            for(j = 0; j < 10; j++)
                {
                if (nums[j]>nums[j+1])
                    {
                    b=nums[j+1];
                    nums[j+1]=nums[j];
                    nums[j]=b;
                    }
                }
            }
    for(j = 0; j < 10; j++)
    {
        printf("%d ", nums[j]);
    }
    break;
        case 2:
        for(i = 0; i < 10; i++)
            {
            for(j = 0; j < 10; j++)
                {
                if (nums[j]<nums[j+1])
                    {
                    b=nums[j+1];
                    nums[j+1]=nums[j];
                    nums[j]=b;
                    }
                }
            }
    for(j = 0; j < 10; j++)
    {
        printf("%d ", nums[j]);
    }
    break;
        default: printf("No se ha ingresado un valor adecuado\n");
        break;
        }
    return 0;
}