UNIDAD 3

ARREGLOS
Contenido
Definición de arreglos ................................................................................................................... 3
Índices de un array ........................................................................................................................ 3
Un arreglo en C++.......................................................................................................................... 4
Dimensiones .................................................................................................................................. 4
Sintaxis .......................................................................................................................................... 4
Asignación de un arreglo ............................................................................................................... 4
Tipos de arreglos. .......................................................................................................................... 5
Cantidad de elementos en un arreglo ........................................................................................... 6
Arreglos de una dimensión ........................................................................................................... 6
Arreglo de dos dimensiones .......................................................................................................... 7
Ejemplos de arreglos de dos dimensiones: ................................................................................. 10
Declaración de una matriz con sus correspondientes elementos: ............................................. 12
Recorrer una matriz 2D en C++ ................................................................................................... 13
Arreglo de tres dimensiones. - .................................................................................................... 14
EJERCICIOS ARREGLOS DE UNA DIMENSION: ............................................................................. 18
EJERCICIOS ARREGLOS DE DOS DIMENSIONES: .......................................................................... 32
EJERCICIOS CON ARREGLOS DE TRES DIMENSIONES: ................................................................. 48
APLICACIONES. ............................................................................................................................ 58
PROBLEMAS PROPUESTOS.- ........................................................................................................ 58
BIBLIOGRAFIA Y WEBGRAFIA ...................................................................................................... 59
 UNIDAD 3 ARREGLOS

Definición de arreglos

Un array (o Arreglo) es un conjunto de datos del mismo tipo ordenados de forma

lineal uno después de otro. Los componentes de un array se han de referenciar
por medio del nombre del array y un índice de desplazamiento para indicar el
elemento deseado.

Los arreglos (arrays) permiten almacenar vectores y matrices. Los arreglos

unidimensionales sirven para manejar vectores y los arreglos bidimensionales
para matrices.

Los arrays, arreglos forman parte de la amplia variedad de estructuras de datos

que nos ofrece C++, siendo además una de las principales y más útiles
estructuras que podremos tener como herramienta de programación. Los arrays,
arreglos o vectores (como los quieras llamar), son utilizados para almacenar
múltiples valores en una única variable. En un aspecto más profundo, los arrays,
permiten almacenar muchos valores en posiciones de memoria continuas, lo cual
permite acceder a un valor u otro de manera rápida y sencilla. Estos valores
pueden ser números, letras o cualquier tipo de variable que deseemos incluso
tipos de datos propios.

En múltiples ocasiones es necesario almacenar gran cantidad de información en

una variable y a menudo sucede que no conocemos con exactitud la cantidad de
datos que debemos almacenar, pero sabemos que sí sería más de uno, como
por ejemplo almacenar las identificaciones de las personas ingresadas al
sistema. Los arrays, arreglos o vectores son una estructura que nos permite
solucionar este tipo de problemas

Índices de un array

Los índices son números que se utilizan para identificar a cada uno de los
componentes de un array. A modo de ejemplo, podemos pensar que los índices
son como los números de habitaciones de un hotel, es decir, para poder
dirigirnos a un hotel específico es necesario saber el nombre del mismo, luego,
si queremos llegar a una habitación específica de dicho hotel necesitaremos,
además del nombre del hotel, el número de habitación deseado.

Un arreglo en C++

● Un arreglo es una colección ordenada de variables del mismo tipo.

● Las variables que pertenecen a un arreglo se conocen por el nombre de

elementos.

● El termino ordenado significa que en la colección hay un primer elemento,

un segundo elemento, un tercer elemento, y así sucesivamente. Además,
los elementos pueden a su vez organizarse en subgrupos llamadas
dimensiones.

Dimensiones

El subgrupo más pequeño posible se conoce como un arreglo de una dimensión.

Un arreglo de dos dimensiones se subdivide en arreglos de una dimensión. Un
arreglo de tres dimensiones se subdivide en arreglos de dos dimensiones los
cuales a su vez se dividen en arreglos de una dimensión. Un arreglo de cuatro
dimensiones se subdivide en arreglos de tres dimensiones los cuales a su vez
se dividen en arreglos de dos dimensiones los cuales a su vez se dividen en
arreglos de una dimensión. La misma idea se aplica en arreglos de más
dimensiones.

Sintaxis

<tipo> nombre_variable[longitud];

Con esto diremos que nombre variable es un arreglo de longitud elementos del
tipo <tipo> . Cabe destacar que longitud debe ser cualquier expresión entera
constante mayor que cero.

Asignación de un arreglo

nombre_variable[índice] = expresión del tipo <tipo>

Esta instrucción asigna el valor asociado de la expresión a la posición índice del
arreglo nombre variable. El índice debe ser una expresión del tipo entero en el
rango [0, longitud-1]. Cabe destacar que C++ no chequea que el valor de la
expresión sea menor a longitud, simplemente asigna el valor a esa posición de
memoria como si formara parte del arreglo, pisando, de esta manera, otros datos
que no forman parte del mismo, con lo que finalmente el programa no funciona
correctamente.

En resumen, un arreglo:

● No es una variable; “es un grupo de variables conocidas como

elementos”

● Cada elemento ocupa una posición dentro del grupo

● Todos los elementos son del mismo tipo

● Los arreglos se clasifican de acuerdo a las dimensiones que tengan

● Las dimensiones no tienen relación con el plano Cartesiano;

● Las dimensiones indican como están organizados los elementos dentro

del grupo

● Los arreglos de dos dimensiones pueden visualizarse como tablas

● Los valores que se guarden en el arreglo se almacenan en los

elementos ya que los elementos son las variables.

Tipos de arreglos.

Según el número de dimensiones

Unidimensionales

Multidimensionales

Para crear un arreglo de una dimensión, el formato es el siguiente:

<tipo de los elementos> <nombre del arreglo> [ <tamaño primera dimensión> ]

Cantidad de elementos en un arreglo

Para determinar la cantidad de elementos en un arreglo, hay que multiplicar el

tamaño de cada una de las dimensiones indicados en la declaración. El tamaño
debe ser un literal de tipo entero o el nombre de una constante de tipo entero.

Observaciones

Para nombrar un elemento en un arreglo hay que indicar el nombre del arreglo,
seguido de tantas parejas de corchetes [ ] como dimensiones declaradas. Dentro
de cada pareja de corchetes tiene que haber un índice. La combinación de los
índices indica la posición del elemento dentro del grupo. El valor mínimo para un
índice es 0. El valor máximo es uno menos que el tamaño de la dimensión
correspondiente en la declaración del arreglo.

Arreglos de una dimensión

Declaración:

int a[3]; // forma una secuencia de tres elementos

Nombre del grupo:

Nombre de los elementos:

a[0] -> primer elemento

a[1] -> segundo elemento

a[2] -> tercer elemento

Ejemplos de arreglos unidimensionales

El siguiente ejemplo muestra la definición de tres arreglos, uno de 80 elementos

doble precisión, otro de 30 elementos enteros y uno de 20 elementos tipo
carácter.
 double x[80];

int factores[30];

char codSexo[20];

Los nombres deben cumplir con las normas para los identificadores. La primera
línea indica que se han reservado 80 posiciones para números doble precisión.
Estas posiciones son contiguas. Es importante recalcar que en C, a diferencia
de otros lenguajes, el primer elemento es x[0], el segundo es x[1], el tercero es
x[2], y así sucesivamente; el último elemento es x[79]. En x hay espacio
reservado para 80 elementos, pero esto no obliga a trabajar con los 80; el
programa puede utilizar menos de 80 elementos. La segunda línea indica que se
han reservado 30 posiciones para números enteros, y la tercera línea indica que
se han reservado 20 posiciones de tipo caracter.

Arreglo de dos dimensiones

Los arreglos de dos dimensiones también son conocidos como matrices o como
"arreglos multidimensionales" son una estructura de datos bastante similar a los
vectores o arreglos. De hecho, una matriz no es más que una serie de vectores
contenidos uno en el otro (u otros), es decir, una matriz es un vector cuyas
posiciones son otros vectores.

En términos generales, una matriz es una estructura conformada por filas y

columnas, idealmente más de dos filas y columnas, de hecho, podemos decir
que, si una "matriz" tiene una única fila o una única columna, entonces estamos
hablando de un vector y no una matriz como tal.

Ahora, un vector posee una única fila y de este modo un grupo de vectores
unidos conforman una matriz. Viéndolo desde el punto de vista de la
programación, una matriz es un vector cuyas posiciones (de la cero a la n) son,
cada una de ellas, otro vector.

Declarar una matriz en C++ es muy similar a la de un vector, se deben seguir las
mismas normas para declarar una variable, pero una vez más con un pequeño
cambio en la sintaxis. Primero necesitaremos saber el tipo de los datos que irán
al interior de este (números, decimales o cadenas de texto, etc.) necesitamos
también, como siempre, un nombre para la matriz y un tamaño máximo tanto
para las filas como para las columnas. La sintaxis para declarar una matriz en
C++ es la siguiente:

tipoDato nombreMatriz[filas][columnas];

Matriz de n filas por n columnas (n x n)

Matriz de 3 filas por 4 columnas

Nota: En C++, no es posible crear de una manera sencilla un vector (y por ende
tampoco una matriz) capaz de almacenar una cantidad de información indefinida,
es necesario ingresar con antelación la cantidad de datos (filas y columnas) que
la matriz tendrá.

Tenemos entonces, que la sintaxis es casi la misma excepto que ahora se tiene
dos pares de corchetes "[][]" y al interior de éstos debemos poner el número de
filas y columnas máximas de la matriz, respectivamente.

Declaración:
 char m[2][3]; // forma una tabla de dos filas y tres
columnas con cada elemento de tipo carácter.

Por ejemplo:

// cada fila es un arreglo de una dimensión

// la declaración indica que hay dos arreglos de una

dimensión

Nombre del grupo:

m // indica la localización del grupo en la memoria

Nombre de las filas

m[0] // primera fila -> indica la localización de la

fila dentro del grupo

m[1] // segunda fila -> indica la localización de la

fila dentro del grupo

Nombre de los elementos

m[0][0] // primer elemento

m[0][1] // segundo elemento

m[0][2] // tercer elemento

m[1][0] // cuarto elemento

m[1][1] // quinto elemento

m[1][2] // sexto elemento

Nombre de los elementos

m[0][0] // primer elemento

m[0][1] // segundo elemento

 m[0][2] // tercer elemento

m[1][0] // cuarto elemento

m[1][1] // quinto elemento

m[1][2] // sexto elemento

Valores asignados según el ejemplo:

m[0][0] = “a”

m[0][1] = “b”

m[0][2] = “c”

m[1][0] = “d”

m[1][1] = “e”

m[1][2] = “f”

Ejemplos de arreglos de dos dimensiones:

int miMatriz[10][5];

float miMatriz2 [5][10];

string miMatriz3 [15][15];

bool miMatriz4 [1000][3];

La primera definición:

int miMatriz[10][5];

define una matriz que tendrá 10 filas y 5 columnas y cada una de las 50 casillas
tendrá datos de tipo entero.

Por ejemplo:
 Matriz de 10 x 5 con datos enteros cualquiera

La segunda:

float miMatriz2[5][10];

que tendrá 5 filas y 10 columnas y cada una de las 50 casillas tendrá datos de
tipo flotante. Por ejemplo:

La tercera:

string miMatriz3 [15][15];

Mimatriz3 que tendrá 15 filas y 15 columnas (una matriz cuadrada) y cada una
de las 225 casillas tendrá datos de tipo string (cadena).

La cuarta:
 bool miMatriz4 [1000][3];

Esta línea contiene la declaración de una matriz llamada miMatriz4 que tendrá
1000 filas y 3 columnas y cada una de las 3000 casillas tendrá datos de tipo
booleano.

Declaración de una matriz con sus correspondientes elementos:

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

Aquí hemos declarado una matriz de tipo int de dos filas y dos columnas y la
hemos inicializado con diferentes valores. El valor inicial corresponde a la casilla
0,0 (fila cero, columna cero) y tiene el valor de 1, en la fila cero, columna uno
tenemos el valor de 2, en la fila uno columna cero el valor de 3 y finalmente en
la fila uno columna uno el valor de 4. Es importante notar que el primer tanto la
fila como la columna comienzan desde cero y no desde uno, por esto la primera
casilla corresponde a la fila y columna cero.

Obtener el valor de una casilla específica

Para acceder al valor de una casilla nuevamente haremos uso de los corchetes,
pero esta vez no para declarar tamaños (porque eso ya lo hicimos) sino para
indicar posiciones (fila y columna).

int Mimatriz1[2][2] = {{1,2},{1,1}}; //Matriz con 4

elementos

int fila1Casilla1 = miMatriz1[1][1]; //Para acceder a

la casilla 1,1 se usan dichos índices
 int primerNumero = Mimatriz1 [0][0]; //La primera
casilla siempre será la de la fila 0 columna 0

Recorrer una matriz 2D en C++

Para obtener todos los datos que se encuentran al interior de una matriz,
debemos acceder a cada posición y esto se hace fácilmente con dos ciclos for
(anidados). La lógica de este procedimiento es la siguiente, el primer ciclo for
comenzará desde cero e ira hasta el número de filas, de modo que la variable de
control que generalmente llamamos "i", será la que va a ir variando entre cero y
el tamaño del array, de esta forma al poner la i al interior de los corchetes,
estaremos accediendo al valor de cada fila y el segundo ciclo irá de cero al
número de columnas y normalmente se usa la variable llamada j para acceder a
cada columna, veamos:

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

for (int j = 0; j < columnas; j++)

cout<<edades[i][j]<<endl;

}
Arreglo de tres dimensiones. -

Las matrices que tienen tres dimensiones, se ven como los valores de un espacio
tridimensional. Este tipo de matriz utiliza tres índices que, en este caso,
representan las coordenadas x, y, z del espacio físico:

Para almacenar datos en una ubicación dentro de la matriz de tres dimensiones

debemos acceder a la intersección de los tres índices x, y, z. Al ser tridimensional
podemos tomar los índices como coordenadas que nos dan un punto fijo, y es
ese punto el que se va a reconocer como una posición de la matriz.

Por ejemplo, podemos definir una matriz W como una matriz de asientos,
supongamos que tenemos 6 salones, cada salón tiene 5 filas de 8 asientos por
cada fila, la matriz se vería como sigue, donde cada salón estaría representado
como un eje o tabla:
Declaración

String w[6][5][8]; // forma seis tablas de cinco filas

y ocho columnas cada una.

// cada fila es una secuencia de ocho elementos

// cada fila es un arreglo de una dimensión

// la declaración indica que hay seis arreglos de dos

dimensiones.

// los arreglos de dos dimensiones tienen a su vez

cinco arreglos de una dimensión.

Nombre del grupo

w // indica la localización del grupo en la memoria

Nombre de las tablas

w[0] // primera tabla // indica la localización de la

tabla dentro del grupo

w[1] // segunda tabla. indica la localización de la

tabla dentro del grupo
Nombre de las filas

w[0][0] // primera tabla, primera fila

w[0][1] // primera tabla, segunda fila

w[1][0] // segunda tabla, primera fila

w[1][1] // segunda tabla, segunda fila

Nombre de los elementos

w[0][0][0] // primer elemento

w[0][0][1] // segundo elemento

w[0][0][2] // tercer elemento

w[0][1][0] // cuarto elemento

w[0][1][1] // quinto elemento

w[0][1][2] // sexto elemento

w[1][0][0] // séptimo elemento

w[1][0][1] // octavo elemento

w[1][0][2] // noveno elemento

w[1][1][0] // decimo elemento

w[1][1][1] // undécimo elemento

w[1][1][2] // duodécimo elemento

es usual también identificar a cada uno de los ejes o tablas mostrados

anteriormente, como páginas, es decir que la matriz de tres dimensiones podría
verse como un conjunto de páginas donde cada página es una matriz de dos
dimensiones como se muestra a continuación:
Inicializando un array tri dimensional:

La inicialización de un array de tres dimensiones puede ser de dos formas:

Primera forma:

int M[3][3][3] = {111, 112, 113, 121, 122, 123, 131, 132,
133, 211, 212, 213, 221, 222, 223, 231, 232, 233, 311,
312, 313, 321, 322, 323, 331, 332, 333 ;

// Inicialización del array M de enteros, tamaño, 2*3*4

Segunda forma (Mejor forma)

int M[3][3][3] =

{ 111, 112, 113 },

{ 121, 122, 123 },

{ 131, 132, 133 }

},

{ 211, 212, 213 },

{ 221, 222, 223 },

{ 231, 232, 233 }

},
 },

{ 311, 312, 313 },

{ 321, 322, 323 },

{ 331, 332, 333 }

};

Al incrementarse las dimensiones la complejidad se incrementa tremendamente sin

embargo el concepto es similar

EJERCICIOS ARREGLOS DE UNA DIMENSION:

Ejercicio 1.- Crear un arreglo con 5 elementos e imprimir en pantalla todos los
elementos del arreglo.
Definición:

int A [5]; //Arreglo de nombre A, con 5 elementos tipo

entero.

NOTA: El campo de elementos entre corchetes [], que representa el número de

elementos del array, debe ser una expresión constante, ya que los arrays son
bloques de memoria estática cuyo tamaño debe determinarse en el momento de
la compilación, antes de que se ejecute el programa.

Inicializamos el array:

int A [5] = {16, 2, 77, 40, 12071};

Dicha instrucción declara un arreglo que puede ser representado como sigue:

Sin embargo, el número de valores entre llaves {} no debe ser mayor que el
número de elementos en el array. Por ejemplo, en el ejemplo anterior, A se
declaró con 5 elementos (según lo especificado por el número entre corchetes,
[]), y las llaves {} contenían exactamente 5 valores, uno para cada elemento. Si
se declara con menos, los elementos restantes se establecen en sus valores
predeterminados (que para los tipos fundamentales significa que están llenos
con ceros), por ejemplo:

int A [5] = {10, 20, 30}

en ese caso el arreglo se crearía así:

Al inicializar incluso puede no especificarse valor entre corchetes, solo las llaves:
int A [5] = { }; //Se crea un array con cinco valores
enteros, cada uno inicializado con un valor de cero.

C ++ permite la posibilidad de dejar los corchetes vacíos []. En este caso, el

compilador asumirá automáticamente un tamaño para la matriz que coincida con
el número de valores incluidos entre las llaves {}:

int A [] = {16, 2, 77, 40, 12071};

Después de esta declaración, la matriz A tendría 5 enteros de largo, ya que

hemos proporcionado 5 valores de inicialización.

Finalmente, la evolución de C ++ ha llevado a la adopción de la inicialización

universal también para arreglos. Por lo tanto, ya no es necesario el signo igual
entre la declaración y el inicializador. Ambas declaraciones son equivalentes:

int A[] = { 10, 20, 30 };

int A[] { 10, 20, 30 };

Las matrices estáticas, y aquellas declaradas directamente en un espacio de

nombres (fuera de cualquier función), siempre se inicializan. Si no se especifica
un inicializador explícito, todos los elementos son inicializados por defecto (con
ceros, para los tipos fundamentales).

Se puede acceder a los valores de cualquiera de los elementos de un array al

igual que al valor de una variable del mismo tipo. La sintaxis es:

Nombre[índice]

Siguiendo el ejemplo anterior en el cual el array A tiene 5 elementos y cada uno

de ellos es de tipo entero, la forma que es usada para referir a cada elemento
es como sigue:
Por ejemplo, la siguiente instrucción almacena el valor de 75 en el tercer
elemento del array A:

A[2]=75;

Y, por ejemplo, la siguiente copia el valor del tercer elemento de A a la variable

x:

X=A[2];

Por lo tanto, la expresión A [2] es en sí misma una variable de tipo int.

Observe que el tercer elemento de A es especificado por A[2], ya que el primero

el A[0], el segundo es A[1], y de la misma forma, el tercero es A[2]. Esta es la
razón por la que el último elemento es A[4]. Por lo tanto, si escribimos A [5],
estaríamos accediendo al sexto elemento de A y, por lo tanto, excederíamos el
tamaño del array.

En C ++, es sintácticamente correcto superar el rango válido de índices para una

matriz. Esto puede crear problemas, ya que el acceso a elementos fuera de
rango no causa errores en la compilación, pero puede causar errores en tiempo
de ejecución. La razón para que esto se permita se verá posteriormente cuando
el estudiante lleve punteros.

En este punto, es importante distinguir claramente los dos usos de los corchetes[]
relacionados a los arreglos. Ellos desempeñan dos tareas diferentes: una es
especificar el tamaño de los arreglos cuando son declarados; y la segunda es
especificar los índices para elementos concretos del arreglo para acceder a estos
elementos. No confundir entre estos dos posibles usos de los corchetes:

int A[5]; // declaración de un Nuevo array

A[2] = 75; // acceso a un elemento del arreglo.

La principal diferencia es que a la declaración precede el tipo de los elementos

del arreglo, mientras que cuando se accede no precede el tipo.
Recorrer el array o Vector:

Para obtener todos los datos que se encuentran al interior de un vector, es

necesario recorrer el array o vector, para recorrerlo, se usa casi siempre un ciclo
for, en algunos casos más específicos un ciclo while, pero generalmente el ciclo
for es el ideal para esto, dado que normalmente conocemos el tamaño del array.
La lógica de este procedimiento es la siguiente, el ciclo for comenzara desde
cero e ira hasta el tamaño del vector, de modo que la variable de control que
generalmente llamamos "i", será la que va a ir variando entre cero y el tamaño
del array, de esta forma al poner la i al interior de los corchetes, estaremos
accediendo al valor de cada casilla del vector y podremos hacer lo que sea
necesario con dicho valor, veamos:

Por tanto, después de definir el arreglo y llenar sus datos realizamos las
siguientes instrucciones para recorrer el array y mostrar sus elementos en
pantalla:

for ( n=0 ; n<5 ; ++n )

cout <<A[n]<<endl;

En codeblocks el código quedaría de la siguiente forma:

Algunas otras operaciones validas con arreglos:

A[0] = a;

A[a] = 75;
 b = A [a+2];

A[A[a]] = A[2] + 5;

Ejemplo 2.- Definir un array unidimensional de nombre “foo” con 5 elementos y

posteriormente sumar sus elementos para mostrar el resultado de la suma en
pantalla:

Definimos el array foo con sus correspondientes valores:

int foo[] = {16,2,77,40,12071}

es necesario crear un bucle repetitivo para por cada iteración acumular un

elemento diferente del array foo, la siguiente línea permite acumular en result el
valor del elemento que se encuentra en foo en la posición n:

result+=foo[n]

El programa quedaría de la siguiente forma:

Ejemplos 3. – Definiremos un arreglo unidimensional para 10 elementos que

contendrá edades tipo entero:

Nombre: Edades

Tipo de Datos: Entero

Tamaño: 10 elementos
Definimos el arreglo Edades:

int Edades [10] = {18, 21,18,23,21,25,18,21,20,19};

Mostramos en pantalla un mensaje al que concatenamos el dato del primer

elemento del arreglo que se encuentra en posición (o índice) cero:

cout <<"La edad del primer alumno es:"<<Edades[0]<<endl;

Mostramos en pantalla un mensaje al que concatenamos el dato del último

elemento del arreglo que se encuentra en posición (o índice) 9:

cout <<"La edad del ultimo alumno es:"<<Edades[9]<<endl;

El código quedaría de la siguiente forma:

Ejemplos 4. – Sobre el arreglo de Edades creado en el ejemplo anterior, buscar

el alumno de mayor edad:

Se deberá incluir un bucle repetitivo para recorrer el array desde la primera

posición 0 hasta la ultima 9, para cada iteración del bucle comparar el elemento
del array con una variable definida como mayor, que inicialmente tenga valor de
0 y que vaya tomando el valor del mayor encontrado en cada iteración, al final la
variable mayor tendrá el mayor encontrado en cualquiera de las posiciones del
arreglo:
 for(i=0; i<10;i++){

if(Edades[i]>mayor){

mayor=Edades[i];

El código quedaría de la siguiente forma:

Ejemplo 5.- Escriba un programa que llene un vector como arreglo

unidimensional de nombre “Vocal” con las “vocales” desde la “a” hasta la “u” este
será un arreglo de tipo char (caracter), posteriormente pedir al usuario una
posición, el programa deberá mostrar la vocal que se encuentre en la posición
ingresada:

Definición del arreglo :

char vocal[5] = {"a", "e", "i", "o", "u"};

Para mostrar la posición ingresada y la vocal en dicha posición escribiremos una

salida en pantalla como sigue:

cout <<"En posicion :"<<p<<"la vocal es: "<<vocal[p]<<endl;

Y el programa quedaría de la siguiente forma:

Salida:

Ejemplo 6.- Escriba un programa que un vector de nombres de libros y otro de

autores de los libros, mediante la solicitud por teclado al usuario de estos datos:

Definición de dos arreglos unidimensionales:

string titulos[5];

string autores[5];

Creamos un bucle repetitivo para poder solicitar al usuario los datos para cada
una de las posiciones de los vectores tanto de libros como de autores, tomando
en cuenta que, para cualquiera de las posiciones del vector de libros, el autor se
guardará en la misma posición, pero del vector de autores:

For (int i = 0; i < 5; i++)

cout << "\n******* Libro " << i + 1 <<"********:\n";

cout << "Titulo: ";

cin >> titulos[i];

cout << "Autor: ";

cin >> autores[i];

 }

El código finalmente quedaría de la siguiente forma:

Sin embargo, tenemos un problema, y es que cuando ingresamos el título del

libro o el autor de este con espacios, es decir, más de una palabra, el objeto cin
interpreta esto como un fin de línea y no nos solicita el siguiente valor. Para
solucionar esto haremos uso de la función getline que nos permite solucionar
este tipo de problemas:

Por tanto, se ha reemplazado las líneas que usaban cin para leer los datos por
la función getline(...) que recibe como primer argumento el flujo de entrada de cin
y como segundo argumento la variable en la que queremos poner el valor.

Una vez guardados los datos en el array podemos hacer un segundo recorrido
por las posiciones del array para mostrar los elementos en pantalla:
La instrucción:

titulos[i]

autores[i]

nos permite acceder al elemento en la posición i del array títulos y del array
autores respectivamente para mostrarlo junto al mensaje de salida.

EJEMPLO 7.- Crear un programa para llenar el array unidimensional números

con 5 elementos enteros ingresados por teclado, y sumar todos los elementos
para finalmente mostrar el resultado de la sumatoria en pantalla:

Definir el array:

int numeros[5];

pedimos valores por teclado:

cout << "Ingrese 5 numeros: "<<endl;

creamos un bucle repetitivo para capturar cada uno de esos 5 valores y

guardarlos en una posición consecutiva el array:

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

cin >> numeros[i

sum += numeros[i];

Al finalizar el bucle repetitive for tendremos en la variable sum la suma total de

los elementos del array y mostramos en pantalla:

cout << "Suma = " << sum << endl;

El programa quedaría de la siguiente forma:

Al hacer correr ingresamos los datos y se muestra la suma por ejemplo así:

EJEMPLO 8.- Llenar un array con palabras ingresadas por teclado, a

continuación, pedir al usuario que ingrese una palabra a buscar, luego verificar
si la palabra existe en el arreglo o no existe. Si existe indicar cuantas veces
aparece.

Definimos el arreglo como un conjunto de elementos tipo cadena:

string palabras[N];

Capturamos mediante un bucle repetitivo cada uno de los valores del arreglo:

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

cout << "Ingrese palabra para la posicion : "<<i+1

<<" del array"<<endl;

cin >> palabras[i];///Capturamos el datos ingresado

y lo asignamos a la posicion i del array

Solicitamos al usuario la palabra que desea buscar:

 cout<<"Ingrese palabra que desea buscar"<<endl;

cin>>buscar;

comenzamos la búsqueda, comparando repetidas veces la palabra a buscar con

cada elemento del array, e incrementamos el contador existe en caso de que la
coincidencia sea verdadera:

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

if(buscar==palabras[i]){

existe++;

A continuación, mostramos resultado de la búsqueda, el contador existe tiene el

número de coincidencias, pero si no se encontró coincidencias se queda con
valor 0 (el valor inicial de la variable existe deberá ser 0):

if (existe>0)

cout << "Existe " << existe <<"veces"<< endl;

else

cout<< "No existe"<<endl;

el programa entonces quedaría de la siguiente forma:

EJEMPLO 9.- Considerar el array unidimensional como un vector A de números
tipo double, llenarlo con N elementos por teclado, donde N sea un numero
ingresado por teclado también, a continuación, pedir al usuario un valor X, que
sumaremos al Vector. Por ejemplo:

A={2,4,6,5,1}

X=10

Entonces al sumar X con A, el vector Resultante sería:

A= {12,14,16,15,11}

Definimos el array de elementos tipo double:

double VectorA[N];

Llenamos el vector con elementos por teclado:

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

cout << "Ingrese valor para la posicion : "<<i+1 <<"

del array"<<endl;

cin >> VectorA[i];///Capturamos el datos ingresado y

lo asignamos a la posicion i del array

}
Solicitamos el valor de X:

cout<<"Ingrese valor de X"<<endl;

cin>>X;

Comenzamos a sumar cada elemento del vector con X en un bucle repetitivo, y

actualizamos el valor del elemento en VectorA:

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

VectorA[i]=VectorA[i]+X;

mostramos VectorA resultante, en una línea con separaciones de un espacio

entre elementos:

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

cout<<VectorA[i]<<" ";

El código resultante sería el siguiente:

EJERCICIOS ARREGLOS DE DOS DIMENSIONES:

Un arreglo de una dimensión es usado para representar elementos en una lista

o secuencia de valores. En algunos casos la relación entre elementos del arreglo
no puede representarse en forma de lista. Un arreglo de 2 dimensiones es usado
para representar elementos en una tabla con columnas y filas, se puede acceder
a cualquier elemento dentro del arreglo indicando el índice de la columna y la fila
del arreglo.
El siguiente ejemplo muestra un arreglo con 4 filas y 4 columnas. Las filas se
acceden integrando un rango desde 0 hasta el 3 y las columnas con un rango
del 0 al 3. Un arreglo bi-dimensional se declara de la misma manera que un
arreglo unidimensional, exceptuando que su tamaño debe ser declarado.

const int NUMFIL=4; //número de filas

const int NUMCOL=4; //número de columnas

float caja[NUMFIL][NUMCOL] //arreglo creado con las

constantes anteriores,
[NUMFIL]=primera dimensión.
[NUMCOL] =segunda
dimensión.

Un array en dos dimensiones suele llamarse también matriz.

Ejemplo 10.- Llenaremos una matriz X de 3 filas y 2 columnas (3x2=6 datos)

con elementos tipo entero y luego recorreremos la matriz para mostrar los
elementos en pantalla.

Existen dos maneras de llenar de datos un array bidimensional

primera forma:

int x[3][2] = {0, 1 ,2 ,3 ,4 , 5}

El arreglo anterior se llama ‘x’ y sus elementos se definen tipo entero, tiene 3
filas y 2 columnas. Los elementos entre llaves desde la izquierda hacia la
derecha son almacenados en el arreglo también de izquierda a derecha. Los
elementos serán llenados en el array en el orden, los primeros dos elementos de
la izquierda en la primera fila, los siguientes dos en la segunda fila y así
sucesivamente.

0 1

2 3
 4 5

Mejor forma:

int x[3][2] = {{0,1}, {2,3}, {4,5}};

Para la salida de los elementos de un arreglo bidimensional necesitamos usar

bucles anidados for. Se requieren dos bucles, uno para recorrer las filas y otro
para recorrer las columnas.

for (int i = 0; i < 3; i++)//bucle para filas

for (int j = 0; j < 2; j++)// bucle para columnas

cout << "Elemento en x[" << i

<< "][" << j << "]: ";

cout << x[i][j]<<endl;

El programa quedaría de la siguiente forma y su salida en pantalla:

Ejemplo 11.-
En el siguiente ejemplo pediremos al usuario que ingrese el número de filas y
columnas del array, luego le pediremos que ingrese los elementos del array y
luego el programa desplegara los elementos del array de dos dimensiones:

Definimos el array de 10 filas x 10 columnas (10x10= 100 elementos tipo entero):

int arr[10][10]

Pero a continuación pedimos al usuario ingrese los valores para número de filas
y columnas y reemplazamos a los anteriores:

cout<<"Ingrese el número de filas (max 10): ";

cin>>fila;

cout<<"Ingrese el número de columnas (max 10): ";

cin>>columna;

Posteriormente recorremos el array pidiendo al usuario por cada posición que

ingrese el valor del elemento:

cout<<"Ingrese "<<fila<<"*"<<col<<" elementos del array: ";

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

for(j=0; j<columna; j++)

cin>>arr[i][j];

Iteramos nuevamente con dos bucles repetitivos ahora para mostrar los
elementos del arreglo:

cout<<” El arreglo es :\n";

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

{
 for(j=0; j<columna; j++)

cout<<arr[i][j]<<" ";

cout<<"\n";

El programa quedaría de la siguiente forma:

Ejemplo 12.- Inicialización de un array M de dos dimensiones con números

reales. El tamaño de la matriz es de 3x4.

float M[3][4] =

{ 0.5, -2.8, -1.0, 23.45 },

{ -2.3, 0.4, 10.5, 0.8 },

{ 12.5, 10.4, 5.4, 3.56 }

};

Si el listado de elementos no incluye todos los elementos del grupo, los faltantes
serán reemplazados por el valor cero automáticamente.
 Figura que muestra el arreglo rellenado con ceros

Ejemplo 13.- En el siguiente ejemplo veremos la creación de un arreglo B de

dos dimensiones, pero donde no se especifica el número de filas:

int B[][4] =

{ 2, -8 },

{ -3 },

{ 11, 25, -30, 4 }

};

Figura que muestra el arreglo B rellenado con ceros

Otros aspectos a considerar cuando inicializamos un arreglo 2D

Como ya sabemos, cuando inicializamos un vector durante la declaración no

necesitamos especificar el tamaño del mismo. Sin embargo, no es el caso de los
arrays 2D, se debe siempre especificar la segunda dimensión incluso si se
especifica los elementos durante la declaración. Entenderemos mejor con los
siguientes ejemplos:

/* declaración valida*/

int abc[2][2] = {1, 2, 3 ,4 }

/* declaración valida */

int abc[][2] = {1, 2, 3 ,4 }

/* declaración no valida – se debe especificar la segunda
dimension*/

int abc[][] = {1, 2, 3 ,4 }

/* declaración no valida por la razon mensionada arriba*/

int abc[2][] = {1, 2, 3 ,4 }

Ejemplo 14.-

Considere un array de 5x5 de booleanos y se desea contar cuantos valores

verdaderos existen.

Creación de un arreglo bidimensional de valores booleanos:

bool B[5][5] =

{ true, false, true, false , true },

{ false, true, false , true, false },

{ true, false, true, false , true },

{ false, true, false , true, false },

{ true, false, true, false , true },

};

La matriz seria la siguiente:

Recorrido del arreglo con dos bucles for anidados para buscar en todas las filas
y columnas comparando si el valor en cada posición es igual a true:
for (int i=0; i<5; i++){

for (int j=0; j<5; j++){

if (B[i][j]==true)

contador++;

Luego de completar el recorrido, es decir al terminar los dos bucles anidados mostramos
el valor del contador que ha ido incrementando en tanto se ha contrado valores true, por
tanto, el contador tiene el total de valores verdaderos:

cout << "Total de valores verdaderos " <<contador<< endl;

Por lo cual el código quedaría de la siguiente forma:

Ejemplo 15.-

Considere para el ejemplo anterior que también se desea contar los valores
falsos, es decir un array de 5x5 de booleanos y se desea contar cuantos valores
verdaderos existen, cuantos falsos y cuantos contados entre falsos y verdaderos
en total (este último total deberá coincidir con el tamaño de la matriz).

Inicializar dos contadores : contadorVerdad y contadorFalso cada uno tipo entero

inicilizados en cero:
 int contadorVerdad=0, contadorFalso=0;

Creación de un arreglo bidimensional de valores booleanos:

bool B[5][5] =

{ true, false, true, false , true },

{ false, true, false , true, false },

{ true, false, true, false , true },

{ false, true, false , true, false },

{ true, false, true, false , true },

};

Recorrido del arreglo con dos bucles for anidados para buscar en todas las filas
y columnas comparando si el valor en cada posición es igual a true y comparando
si es igual a false (en este caso el valor true es representado también por 1 y
falso por 0):

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

for (int j=0; j<5; j++){

if (B[i][j]==1)

contadorVerdad++;

if (B[i][j]==0)

contadorFalso++;

Luego de completar el recorrido, es decir al terminar los dos bucles anidados

mostramos los valores de los contadores como también la suma de ambos:

cout << "Total de valores verdaderos " <<contadorVerdad<<

endl;

cout << "Total de valores falsos " <<contadorFalso<< endl;

cout << "Total de valores " <<contadorFalso + contadorVerdad
<< endl;

Por lo cual el código quedaría de la siguiente forma:

Ejercicio 16: generar una matriz identidad:

La matriz identidad es una matriz cuadrada (número de filas = número de

columnas), contiene unos y ceros, la diagonal principal formada por unos y los
demás elementos serán ceros.

Por ejemplo, la siguiente es una matriz identidad de 3 x 3:

1 0 0
0 1 0
0 0 13𝑥3

Comenzamos definiendo la matriz con números enteros y definiendo variables

para número de filas y de columnas:

int fil, col, i, j;

int I[5][5];

cout << "Ingrese n que será la dimensión de la matriz

cuadrada identidad: ";
cin >> fil;

col=fil;

Para llenar los valores a la matriz identidad I podemos considerar que las
coordenadas para cada elemento de la matriz son las siguientes:

[𝟎][𝟎] [0][1] [0][2]

[1][0] [𝟏][𝟏] [1][2]
[2][0] [2][1] [𝟐][𝟐]

Podemos observar que la diagonal principal está marcada de color rojo y las
coordenadas de la diagonal principal tienen los valores de fila y columna iguales

Por lo tanto, al momento de cargar los datos para la matriz identidad solo
tendremos recorrer con dos ciclos for para filas y columnas con los
correspondientes i y j los cuales verificamos que si tienen el mismo valor
asignamos 1 en esa posición caso contrario asignamos 0:

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

for (j = 0; j < col; j++)

if (i==j)

I[i][j]= 1;

else

I[i][j]= 0;

Y luego mostramos la matriz Identidad en pantalla elemento por elemento:

cout << "Matriz Identidad: \n";

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

for (j = 0; j < col; j++)

cout << I[i][j] << " ";

cout << "\n";

 }

Salida en pantalla:

Ejercicio 17: generar una matriz traspuesta de una matriz:

La matriz traspuesta de una matriz es una matriz en la cual se han cambiado

filas por columnas de la matriz original, por ejemplo:

1 2 3
Si A= [4 5 6]
7 8 9 3𝑥3

Entonces la traspuesta de A seria:

𝟏 4 7
𝑡
𝐴 = [2 𝟓 8]
3 6 𝟗 3𝑥3

Podemos observar que la diagonal principal no se ha modificado.

Hallaremos la traspuesta de una matriz mediante una función a la que vamos a

pasar la matriz como argumento de función.

#include <iostream>

using namespace std;

void traspuesta (int m [3][3]) {

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

for (int j=0;j<=2;j++){

//se cambian filas por columnas:

 cout <<m[j][i]<<" ";

cout<<endl;

Mediante otro método vamos a imprimir una matriz 3x3:

void imprimirmatriz (int m[3][3]){

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

for (int j=0;j<=2;j++){

cout <<m[i][j]<<" ";

cout<<endl;

Declaramos una matriz 3x3 y le asignamos los valores, luego imprimimos la

matriz y a continuación hallamos su traspuesta, para lo cual usamos los
métodos arriba mencionados:

int main()

int matriz [3][3]={{1,2,3},{4,5,6},{7,8,9}};

imprimirmatriz(matriz);

traspuesta(matriz);

return 0;

Ejercicio 18: Multiplicación de dos matrices bidimensionales. –

Solo puede multiplicar dos matrices si sus dimensiones son compatibles, lo que
significa que el número de columnas en la primera matriz es igual al número de
renglones (filas) en la segunda matriz. Si A es una matriz a × b y B es una
matriz b × c, el producto AB es una matriz a × c.

Por ejemplo:

1 3 2 4 6
Si matriz A =[ ] y matriz B = [ ]
5 7 2𝑥2 8 10 12 2𝑥3

Es posible la multiplicación por que el número de columnas de A es 2 y el número de

filas de B también es 2, por tanto, se cumple la igualdad y la matriz resultante será 2 x
3.

La multiplicación se consideraría de la siguiente forma:

1 3 2 4 6
A x B =[ ] x[ ]
5 7 2𝑥2 8 10 12 2𝑥3

El programa deberá realizar las siguientes operaciones:

1.- multiplicar la primera fila por la primera columna y ese resultado será el primer
elemento de la matriz resultante:

luego multiplicar la primera fila de A por la segunda columna de B para conformar el

segundo elemento de la matriz resultante y luego la primera fila A por la tercera columna
de B. De esta forma obtenemos la primera fila de la matriz resultante C:

Y proceder de la misma forma con la segunda fila de A multiplicando por las

correspondientes columnas de B para obtener la segunda fila de matriz C:

Y realizando las operaciones la matriz resultante quedaría con los siguientes valores:
Una vez claro el procedimiento pedimos al usuario las dimensiones de las matrices que
desea multiplicar:

int f1, c1, f2, c2, i, j, k;

int A[5][5], B[5][5], C[5][5];

cout<<"Ingrese el número de filas y columnas de matriz A

:";

cin>>f1>>c1;

cout << "Ingrese el número de filas y columnas de matriz B

: ";

cin >> f2 >> c2;

Después de pedir las dimensiones de ambas matrices a multiplicar se verificará si es

posible la multiplicación y si es el caso se procede a pedir los datos para las matrices,
de la siguiente forma:

if (c1 == f2)

cout << "Ingrese elementos de matriz A : ";

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

for (j = 0; j < c1; j++)

cin >> A[i][j];

cout << "Ingrese elementos de matriz B : ";

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

for (j = 0; j < c2; j++)

cin >> B[i][j];

Se iterará nuevamente para recorrer ambas matrices e ir simultáneamente insertando

los resultados en la matriz resultante C:

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

for (j = 0; j < c2; j++)

 {

C[i][j] = 0;

for (k = 0; k < f2; k++)

//la siguiente línea acumula los productos en

//C[i][j]:

C[i][j] += A[i][k] * B[k][j];

Al finalizar el recorrido tendremos la matriz resultante C con sus valores asignados y la

mostramos en pantalla:

cout << "Producto de matrices\n";

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

for (j = 0; j < c2; j++)

cout << C[i][j] << " ";

cout << "\n";

else

cout << "Matrices no pueden ser multiplicadas!";

De tal forma que la salida en pantalla debe ser por ejemplo así:
EJERCICIOS CON ARREGLOS DE TRES DIMENSIONES:

Ejercicio 19. - Escribir un programa que almacene valores ingresados por el

usuario a un arreglo tridimensional y luego mostrar el arreglo:

Definimos un arreglo de enteros con el nombre de test, con 2 tablas de 3 filas

por 2 columnas cada una:

#include <iostream>

using namespace std;

int main()

//Este arreglo almacena hasta 12 elementos (2x3x2)

int test[2][3][2];

Solicitamos al usuario que ingrese los valores para ingresarlos a la matriz:

cout << "Ingrese 12 valores: \n";

// Insertando los valores dentro del arreglo

// Son necesarios 3 bucles repetitivos anidados.

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

for (int j = 0; j < 3; ++j)

for(int k = 0; k < 2; ++k )

cin >> test[i][j][k];

Por ultimo recorremos nuevamente por cada posición del arreglo imprimiendo
los valores:
cout<<"\n Despliegue de los valores almacenados:"<<endl;

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

{
for (int j = 0; j < 3; ++j)
{
for(int k = 0; k < 2; ++k)
{
cout << "test[" << i << "][" << j << "]["
<< k << "] = " << test[i][j][k] << endl;
}
}
}return 0;
}
Salida en consola:

Ejercicio 20.- Considerar las ventas de un restaurante donde se quiere registrar

las ventas para tres meses consecutivos, cada mes con 4 semanas y para cada
semana 7 días, se registrarán las ventas diarias de la siguiente forma (datos de
ejemplo):
Primer mes:

Segundo mes:

Tercer mes:

a) Se desea mostrar el promedio de ventas de cada uno de los meses y

determinar cuál es el mes que más ventas tuvo.
b) Se desea hallar promedios de ventas de acuerdo al día, es decir un
promedio de todas las ventas realizadas en lunes, otro promedio
correspondiente a los días martes, y así sucesivamente, de manera que
al final se pueda determinar cuál es el día de la semana que más se
vendió en esos tres meses.

Resolviendo:

a) Llenaremos los datos de las ventas en una matriz tridimensional donde

cada tabla representará un mes de ventas, cada tabla tendrá 4 semanas
 con 7 días cada una. Por tanto, la matriz Ventas seria de dimensión 3x4x7,
es decir 84 valores de ventas realizadas.
Consideraremos la sumatoria de ventas por cada mes en las variables
suma_mensual1, suma_mensual2, suma_mensual3.

#include <iostream>
using namespace std;
int main()
{
int meses=4,semanas=4,dias=7;
int suma_mensual1=0,suma_mensual2=0,suma_mensual3=0;
int Ventas[meses][semanas][dias];

Solicitamos al usuario el ingreso de los valores de las ventas realizadas:

cout << "Ingrese "<<meses*semanas*dias<<" valores: \n";

// Insertando los valores dentro del arreglo
// Son necesarios 3 bucles repetitivos anidados.
for(int i = 0; i < meses; ++i)
{
for (int j = 0; j < semanas; ++j)
{
for(int k = 0; k < dias; ++k )
{
cin >> Ventas[i][j][k];
}
}
}

Mostramos la matriz tridimensional indicando el mes correspondiente:

cout<<"\n matriz Ventas:"<<endl;

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

{
cout<<"\n mes:"<<i<<endl;
 for (int j = 0; j < semanas; ++j)
{
for(int k = 0; k < dias; ++k)
{
cout<<Ventas[i][j][k]<<" ";
}
cout<<endl;
}
}
Volvemos a recorrer el arreglo para calcular las sumas de las ventas
mensuales y posteriormente hallar el promedio:

cout<<"\n Promedios mensuales:"<<endl;

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

{
for (int j = 0; j < semanas; ++j)
{
for(int k = 0; k < dias; ++k)
{
if (i==0){//primer mes
suma_mensual1 = suma_mensual1 +
Ventas[i][j][k];
cout<<"suma acumulada mes1 : " <<
suma_mensual1 << endl;
}
if (i==1){//segundo mes

suma_mensual2=suma_mensual2+Ventas[i][j][k];
cout<<"suma acumulada mes2 : " <<
suma_mensual2 <<endl;
}

if (i==2){ //tercer mes

suma_mensual3=suma_mensual3+Ventas[i][j][k];
cout<<"suma acumulada mes3 :" <<
suma_mensual3 << endl;
}
 }
}
}
Se calculan y despliegan en pantalla los promedios:

cout<<"\n Promedio primer mes : " <<

(float)suma_mensual1/ (dias*semanas) << endl;
cout<<"\n Promedio segundo mes :"
<<(float)suma_mensual2/(dias*semanas) << endl;
cout<<"\n Promedio tercer mes :"
<<(float)suma_mensual3/(dias*semanas)<<endl;
comparar para determinar cuál es el mes que más ventas tuvo:
if (suma_mensual1>=suma_mensual2){
if (suma_mensual1>=suma_mensual3)
cout<<"Mayor: Primer mes. "<<endl;
else
cout<<"Mayor: Tercer mes. "<<endl;
}
else {
if (suma_mensual2>=suma_mensual3)
cout<<"Mayor: segundo mes. "<<endl;
else
cout<<"Mayor: Tercer mes. "<<endl;
}
b) Se desea hallar promedios de ventas de acuerdo al día, es decir un promedio
de todas las ventas realizadas en lunes, otro promedio correspondiente a los
días martes, y así sucesivamente, de manera que al final se pueda
determinar cuál es el día de la semana que en general más ventas se ha
realizado durante los tres meses:

Definimos un método “diademasVenta()” que reciba la matriz tridimensional con

las ventas, para realizar el proceso de promediar las ventas que ocurran todos
los lunes, todos los martes, etc. Durante los tres meses:

void diademasVenta(int V[3][4][7]){

int ventasLunes =0;//acumulador de ventas para el dia lunes
int ventasMartes =0;
int ventasMiercoles =0;
int ventasJueves =0;
int ventasViernes =0;
int ventasSabado =0;
int ventasDomingo =0;
Debemos recorrer el arreglo mediante tres bucles repetitivos anidados y por
cada elemento verficar si la columna es la primera (en ese caso corresponde a
lunes), o la segunda columna (en ese caso corresponde a un martes), y asi
sucesivamente para acumular la venta en el acumulador que corresponda a ese
dia.

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

{
for (int j = 0; j < 4; ++j)
{
for(int k = 0; k < 7; ++k)
{
if (k==0)
ventasLunes+= V[i][j][k];
else if (k==1)
ventasMartes+= V[i][j][k];
else if (k==2)
ventasMiercoles+= V[i][j][k];
else if (k==3)
ventasJueves+= V[i][j][k];
else if (k==4)
ventasViernes+= V[i][j][k];
else if (k==5)
ventasSabado+= V[i][j][k];
else if (k==6)
ventasDomingo+= V[i][j][k];
}
}
}
Se calculan los promedios correspondientes según las ventas acumuladas para cada día,
entre las semanas transcurridas durante los tres meses:
int totalSemanas=4*3;//son 4 semanas x 3 meses = 12 semanas
(12 lunes)
float promLunes=(float) ventasLunes/totalSemanas;
float promMartes=(float)ventasMartes/totalSemanas;
float promMiercoles=(float) ventasMiercoles/totalSemanas;
float promJueves=(float)ventasJueves/totalSemanas;
float promViernes=(float)ventasViernes/totalSemanas;
float promSabado=(float)ventasSabado/totalSemanas;
float promDomingo=(float)ventasDomingo/totalSemanas;
cout<<" PROMEDIOS: "<<endl;
cout<<" promedio de los lunes: "<<promLunes<<endl;
cout<<" promedio de los Martes: "<<promMartes<<endl;
cout<<" promedio de los Miercoles: "<<promMiercoles<<endl;
cout<<" promedio de los Jueves: "<<promJueves<<endl;
cout<<" promedio de los Viernes: "<<promViernes<<endl;
cout<<" promedio de los Sabado: "<<promSabado<<endl;
cout<<" promedio de los Domingo: "<<promDomingo<<endl;
Teniendo los promedios procedemos a hallar el mayor de los 7 promedios, para esto
podemos usar un vector adicional, guardar los promedios ahí y llamar a un método que
imprima el mayor elemento del vector, verificando además a que dia de la semana
corresponde.
float vec[7]={promLunes, promMartes,promMiercoles,
promJueves, promViernes, promSabado, promDomingo};

mayor(vec);//este método busca el mayor existente en vector

}// aquí finaliza el método “diademasVenta”.

El método mayor() deberá recibir un vector con 7 elementos (los 7 promedios de los
días de la semana) y buscar el mayor de ellos, según la posición del mayor se verificará
si corresponde a día lunes, o día martes, o miércoles, etc.:

void mayor (float v[7]){

float posm=0, mayor =0;

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

if (v[i]>=mayor){

mayor=v[i];//elemento mayor

posm=i; // posición del mayor

if (posm==0)//si la posición del mayor es 0, corresponde a

lunes

cout<<"Día de más ventas: Lunes";

else if (posm==1)// si 1, corresponde a martes

cout<<"Dia de mas ventas: Martes";

else if (posm==2)

cout<<"Dia de mas ventas: Miercoles";

else if (posm==3)

cout<<"Dia de mas ventas: Jueves";

else if (posm==4)

cout<<"Dia de mas ventas:Viernes ";

else if (posm==5)
 cout<<"Dia de mas ventas: Sabado";

else if (posm==6)

cout<<"Dia de mas ventas: Domingo";

cout <<" con "<< mayor<<" ventas"<<endl;

La salida en pantalla deberá incluir el ingreso de las ventas, el despliegue en pantalla de

las matrices (como fue realizado en el inciso a)) y luego a continuación la llamada a la
función diademasVentas()

diademasVenta(Ventas);

La salida en pantalla sería similar a:

APLICACIONES.

Los arrays son usados extensamente por los programadores para contener listas
de datos en la memoria, por ejemplo, los datos almacenados en un disco suelen
leerse y ponerse dentro de un array con el objetivo de facilitar la manipulación
de dichos datos, ya que los datos en memoria pueden ser modificados,
clasificados, marcados para su eliminación, etc. para luego ser reescritos al
disco. Otro ejemplo podría ser el de un menú de opciones que se desplegarán
dentro de una ventana para que el usuario pueda elegir una de éstas, en tales
casos y cuando las opciones son numerosas, solamente se ponen unas cuantas,
de ellas dentro de la ventana, pero se le da al usuario la oportunidad de poder
subir y bajar a su antojo para ver el resto de opciones que, aunque no se vean
en la ventana, forman parte del menú o array de opciones.

PROBLEMAS PROPUESTOS.-

1. Hacer un programa que lea diez valores enteros en un vector desde el

teclado y calcule y muestre: la suma, el valor promedio, el mayor y el
menor.

2. Realizar un programa que encuentre: la suma, el promedio, el mayor y el

menor en una matriz n x m.

3. Hacer un programa que lea diez valores enteros en un array y los muestre
en pantalla. Después que los ordene de menor a mayor y los vuelva a
mostrar. Y finalmente que los ordene de mayor a menor y los muestre por
tercera vez. Para ordenar la lista usar una función que implemente el
método de la burbuja y que tenga como parámetro de entrada el tipo de
ordenación, de mayor a menor o de menor a mayor. Para el array usar
una variable global.

4. Hacer un programa que lea 25 valores enteros en una tabla de 5 por 5, y

que después muestre la tabla y las sumas de cada fila y de cada columna.
Procura que la salida sea clara, no te limites a los números obtenidos.
 5. Hacer un programa que contenga una función con el prototipo bool
Palindromo(char palabra[40]);. La función debe devolver true si la palabra
es un palíndromo, y false si no lo es.

6. Una palabra es un palíndromo si cuando se lee desde el final al principio

es igual que leyendo desde el principio, por ejemplo: "Otto", o con varias
palabras "Anita lava la tina", "Dábale arroz a la zorra el abad". En estos
casos debemos ignorar los acentos y los espacios, pero no es necesario
que tu función haga eso, bastará con probar cadenas como
"anitalavalatina", o "dabalearrozalazorraelabad".

7. Dada una matriz A y una matriz B, verificar si son iguales y mostrar como
resultado: “iguales” caso contrario mostrar: “distintas”.

8. Dadas dos matrices A y B, sumarlas y el resultado ponerlo en una matriz

C.

BIBLIOGRAFIA Y WEBGRAFIA

Programming Principles and Practice Using C++, Bjarne Stroustrup.

http://www.codeblocks.org

http://www.wxwidgets.org (O’Reilly) Practical C Programming (3rd Edition)