ARREGLOS

Un arreglo es un conjunto de datos del mismo tipo, almacenados en la

memoria en forma contigua, y referenciados por una misma variable. Cada
dato del arreglo se denomina elemento, y se distingue de los demás
mediante su índice, es decir, la posición relativa que ocupa ese dato
dentro del arreglo. Los índices se expresan como números enteros,
comenzando con 0.

Definición y declaración

tipo nombre[tamaño];

Ejemplo: int Datos[10];

Declara a Datos como un arreglo de 10 elementos de tipo int.

Los índices se numeran desde 0 hasta tamaño – 1. Gráficamente

podemos representar este arreglo así:

Datos
25 10 15 8 5 20 7 1 12 18
0 1 2 3 4 5 6 7 8 9

Para referenciar a un elemento del arreglo, se escribe de esta manera:

variable[índice]

Ejemplo: Datos[5]

se refiere al elemento que ocupa la posición 5 (que vale 20).

Otros ejemplos:

// asigna 30 al elemento de índice 5

Datos[5] = 30;

// escribe el valor del elemento con índice 8

printf(“%d”, Datos[8]);

// Asignar un valor dado n a todos los elementos del arreglo:

for (int i = 0; i < 10; i++)
Datos[i] = n);
// Ingresar los valores a todos los elementos del arreglo:

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

printf(“Datos[%d] = “, i);
scanf(“%d”, &Datos[i]);
}

// Escribir todos los elementos del arreglo:

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

printf(“Datos[%d] = %d\n“, i, Datos[i]);

// Hallar la suma de los elementos del arreglo:

Suma = 0;
for (int i = 0; i < 10; i++)
Suma += Datos[i];
printf(“La suma del arreglo es %d”, Suma);

// Hallar el elemento con el valor más grande del arreglo:

Max = Datos[0];
for (int i = 1; i < 10; i++)
if (Datos[i] > Max)
Max = Datos[i];
printf(“El valor más grande del arreglo es %d”, Max);

// Buscar un valor x en el arreglo, indicando su índice, Si no se halla ese

// valor, entonces la posición es -1:

Pos = -1;
for (int i = 1; i < 10; i++) {
if (Datos[i] == x) {
Pos = i;
break;
}
if (Pos >= 0)
printf(“El valor %d ocupa la posición %d en el arreglo”, x, Pos);
else
printf(“El valor %d no está en el arreglo”, x);
Números aleatorios

En el lenguaje C se pueden generar números aleatorios mediante

funciones especiales, las cuales requieren de los archivos de la
biblioteca <stdlib.h> y <time.h>. Dichas funciones son las
siguientes:

srand(semilla)

donde semilla es un número entero que se ingresa a la función para

inicializar la secuencia de valores aleatorios, y que generalmente se
utiliza la función time(NULL) que permite obtener la hora actual del
sistema, la cual se expresa como un entero, que representa el año,
el mes, el día, la hora, los minutos, los segundos y las centésimas
de segundos. Esto quiere decir que dicho número entero se
actualiza cada centésima de segundo, que para efectos prácticos
sería en sí mismo un valor aleatorio. Queda claro, entonces que de
por sí misma la función sran() no genera un número aleatorio
propiamente dicho, sino que es la semilla, en este caso la hora
actual del sistema, lo que viene siendo las veces de esa
aleatoriedad. Por esa razón se las llama funciones pseudoaleatorias.

La otra función que utiliza es que la en verdad calcula un valor

pseudoaleatorio determinado, y es la siguiente:

rand()

El número generado es un entero muy grande, pero lo podemos

delimitar mediante el operador de resíduo (%). Veamos el siente
ejemplo:

#include <stdlib.h>
#include <time.h>

int n, num;
…
printf(“Ingrese el maximo: “);
scanf(“%d”, &n);
srand(time(NULL));
num = rand() % n;

num tendrá un valor entre 0 y n – 1;

Ahora veamos como rellenar un arreglo de números enteros con
valores aleatoios:

const int MAX = 1000; // Límite para los números aleatorios

const int N = 100; // Número de elementos del arreglo

int A[MAX], k;

srand(time(NULL)); // Se debe utilizar una sola vez

for (k = 0; k < N; k++)
A[k] = rand() % MAX;

El arreglo tendrá 100 valores entre 0 y 999, algunos quizás

repetidos.

Podríamos implementar un algoritmo para evitar precisamente esos

valores repetidos, mediante el uso de una variable bandera o
centinela. Este es el código:

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

const int MAX = 1000; // Límite para los números aleatorios

const int N = 100; // Número de elementos del arreglo
int A[MAX], i, j, k, flag;

main() {
srand(time(NULL)); // Se siembra la semilla
for (i = 0; i < N; i++) {
do {
flag = 0;
k = rand() % MAX;
for (j = 0; j < i; j++)
if A[j] == k
flag = 1;
} while (flag); // Si vale 1, ya existe. Se prueba otro
A[i] = k;
}
// se escriben los elementos
for (i = 0; i < N; i++)
printf(“%5d”, A[i]);
system(“pause”);
}
Si se desea general un número aleatorio entre dos valores a y b se
puede proceder de la siguiente manera:

num = rand() % (b – a + 1) + a;

- Simular el lanzamiento de un dado (valores entre 1 y 6

num = rand() % 6 + 1;

- Simular el sorteo de una tabla de bingo

- Para la columna B (del 1 al 15) num = rand() % 15 + 1;

- Para la columna I (del 16 al 30) num = rand() % 15 + 16
- Para la columna N (del 31 al 45) num = rand() % 15 + 31
- Para la columna G (del 46 al 60) num = rand() % 15 + 46
- Para la columna O (del 61 al 75) num = rand() % 15 + 61

Generalizando para las columnas desde 0 hasta 4

num = ran() % 15 + columna * 15 + 1;

Ejercicios

1,- Hacer un programa que procese una serie de números reales

(float), y calcule la suma, el promedio, la moda (valor que más se
repite), la mediana y el elemento más cercano al promedio, por
defecto y por exceso.

2,- Al lanzar un dado la probabilidad de salida de cada número es

de 1/6, y se ha demostrado que entre más pruebas (lanzamientos
en este caso) se hacen la frecuencia de cada valor se acerca más a
dicha probabilidad. Hacer un programa que simule el lanzamiento
de un dado 1000 veces, y calcule la frecuencia de cada uno valor,
en número y porcentaje, comprobando lo expresado arriba. Pruebe
con mayor número de lanzamiento. Guardar los resultados en
arreglos para facilitar su manipulación.

3,- Una liga de fútbol cuenta con 10 equipos, cada uno de los cuales
tiene un número, y valores para los juegos ganados, perdidos y
empatados, así como los puntos acumulados, que serían 3 puntos
por cada juego ganado, 1 punto cada empatado y 0 por los
perdidos. Hacer un programa que guarde en arreglos estos datos, y
simule la realización de los juegos (todos contra todos, dos veces
con cada contrario, uno de ida y otro de vuelta), generando los
goles de cada equipo aleatoiamente (entre 0 y 5) y asignando los
respectivos puntos. Escribir al final la tabla de los equipos (sin
ordenar porque ese es otro punto que se verá posteriormente).
Nota: no se asigna nombres a los equipos porque posteriormente se
estudiarán las cadenas alfanuméricas en profundidad

4,- Hacer un programa que guarde en arreglos los números de

cuenta y los saldos de 10 cuentas bancarias, y realice las siguientes
operaciones:
- Ingresar los datos a los arreglos
- Mostrar los datos de los arreglos en columnas
- Hallar el saldo más alto y su correspondiente número de cuenta
- Hallar el promedio de saldo de tos las cuentas
- Buscar el saldo de una cuenta sabiendo cual es su respectivo
número de cuenta.

5.- Se tienen los datos de los productos vendidos por una tienda
(Código, Precio y Existencia) y las ventas realizadas durante un día (Código,
Cantidad). Hacer un programa que realice las siguientes operaciones:
- Ingresar los datos de los productos (mínimo 10)
- Ingresar los datos de las ventas ( mínimo 25)
- Procesar las ventas registradas en el arreglo, con los siguientes pasos:
- Tomar el código del arreglo de ventas
- Buscar el código en el arreglo de productos
- Si lo halla,
- Tomar el precio correspondiente al producto
- Tomar la cantidad correspondiente a la venta
- Calcular costo de la venta (Precio * Cantidad) y mostrarla
- Restar la cantidad vendida a la existencia del producto
- Sumar costo al total vendido
- sino
- Mostrar mensaje “Código no hallado”
- Pasar a la otra venta
- Mostrar Total vendido
- Mostrar el arreglo de productos actualizado