PROGRAMACION
VECTORES
1- Obtener un programa que permita crear un arreglo unidimensional con un tamaño de 5,
ingresar los datos en el arreglo y mostrarlos por pantalla.
#include <iostream>
using namespace std;
int main() {
int arreglo[5]; // Crear un arreglo de tamaño 5
// Solicitar al usuario que ingrese los datos en el arreglo
cout << "Ingrese 5 numeros para el arreglo:" << endl;
for (int i = 0; i < 5; i++) {
cout << "Numero " << i + 1 << ": ";
cin >> arreglo[i];
// Mostrar los datos del arreglo
cout << "Los numeros en el arreglo son:" << endl;
for (int i = 0; i < 5; i++) {
cout << arreglo[i] << " ";
cout << "" <<endl;
-----------------------------------------------------------------------------------------------------------------------------
2- Obtener un programa que solicite el tamaño de un arreglo unidimensional y un número
entero x. A continuación rellenar el arreglo con los múltiplos de x. Por ejemplo, si el
tamaño es 5 y x es 3, el arreglo contendrá 3, 6, 9, 12, 15. Mostrar por pantalla el arreglo
obtenido.
#include <iostream>
using namespace std;
int main () {
int i,A[100],n,x;;
cout<<indique el tamano del vector"<<endl;
cin>>n;
cout<<"indique el factor"<<endl;
cin>>x;
for(i=0;i<n;i++){
A[i]=(i+1)*x;
cout<< " los elementos son: "<<endl;
for(i=0;i<n;i++){
cout<<A[i]<<",";
------------------------------------------------------------------------------------------------------------------------------
3- Ingresar datos en dos arreglos diferentes de igual tamaño, obtener como resultado un
nuevo arreglo igual a la suma de los ingresados. El vector resultado se calculara como
posición 0 del arreglo 1 + posición 0 del arreglo 2, posición 1 del arreglo 1 + posición 1 del
arreglo 2, etc.
#include <iostream>
using namespace std;
int main() {
int n;
// Solicitar el tamaño de los arreglos
cout << "Ingrese el tamano de los arreglos: ";
cin >> n;
// Declarar los arreglos
int arreglo1[n], arreglo2[n], resultado[n];
// Llenar el primer arreglo
cout << "Ingrese los elementos del primer arreglo:" << endl;
for (int i = 0; i < n; i++) {
cout << "Elemento " << i + 1 << ": ";
cin >> arreglo1[i];
// Llenar el segundo arreglo
cout << "Ingrese los elementos del segundo arreglo:" << endl;
for (int i = 0; i < n; i++) {
cout << "Elemento " << i + 1 << ": ";
cin >> arreglo2[i];
// Calcular el arreglo resultado como la suma de los dos arreglos
for (int i = 0; i < n; i++) {
resultado[i] = arreglo1[i] + arreglo2[i];
// Mostrar el arreglo resultado
cout << "El arreglo resultado es:" << endl;
for (int i = 0; i < n; i++) {
cout << resultado[i] << " ";
cout << " " <<endl;
-----------------------------------------------------------------------------------------------------------------
4- Las notas de un conjunto de N alumnos se guardan en un arreglo unidimensional, Las
notas son valores entre 0 y 10. Obtener un programa que solicite la cantidad N de
alumnos, sucesivamente los datos en el vector y determine la cantidad de estudiantes en
cada categoría según la nota obtenida: Deficientes 0-3 Regulares 4-5 Buenos 6-8
Excelentes 9-10
#include <iostream>
using namespace std;
int main() {
int n;
// Solicitar la cantidad de alumnos
cout << "Ingrese la cantidad de alumnos: ";
cin >> n;
// Declarar un arreglo para las notas
float notas[n];
// Variables para contar las categorías
int deficientes = 0, regulares = 0, buenos = 0, excelentes = 0;
// Leer las notas de los alumnos
cout << "Ingrese las notas de los alumnos (valores entre 0 y 10):" << endl;
for (int i = 0; i < n; i++) {
cout << "Nota del alumno " << i + 1 << ": ";
cin >> notas[i];
// Clasificar la nota en una categoría
if (notas[i] <= 3) {
deficientes++;
} else if (notas[i] <= 5) {
regulares++;
} else if (notas[i] <= 8) {
buenos++;
} else {
excelentes++;
// Mostrar los resultados
cout << "Deficientes (0-3): " << deficientes << endl;
cout << "Regulares (4-5): " << regulares << endl;
cout << "Buenos (6-8): " << buenos << endl;
cout << "Excelentes (9-10): " << excelentes << endl;
------------------------------------------------------------------------------------------------------------------------------
5- Escribir un programa que complete un arreglo con los 10 primeros números pares y calcule
su suma
#include <iostream>
using namespace std;
int main() {
int arreglo[10]; // Declarar un arreglo para 10 números
int suma = 0;
// Llenar el arreglo con los 10 primeros números pares
for (int i = 0; i < 10; i++) {
arreglo[i] = (i + 1) * 2; // Los números pares son 2, 4, 6, ...
suma += arreglo[i]; // Acumular la suma
// Mostrar el arreglo
cout << "Los 10 primeros numeros pares son:" << endl;
for (int i = 0; i < 10; i++) {
cout << arreglo[i] << " ";
cout << endl;
// Mostrar la suma de los números pares
cout << "La suma de los números pares es: " << suma << endl;
-------------------------------------------------------------------------------------------------------------------------
6- Leer los n elementos de un vector y ordenarlo de mayor a menor. Realizar el proceso
mediante funciones que implementen diferentes algoritmos de ordenación (selección,
burbuja, burbuja mejorada)
#include <iostream>
using namespace std;
// Ordenar por selección
int* ordenarSeleccion(int vec[], int n) {
for (int i = 0; i < n - 1; i++) {
for (int j = i + 1; j < n; j++) {
if (vec[j] > vec[i]) {
int temp = vec[i];
vec[i] = vec[j];
vec[j] = temp;
return vec;
}
// Ordenar por burbuja
int* ordenarBurbuja(int vec[], int n) {
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - 1; j++) {
if (vec[j] < vec[j + 1]) {
int temp = vec[j];
vec[j] = vec[j + 1];
vec[j + 1] = temp;
return vec;
// Imprimir el vector
int* imprimirVector(int vec[], int n) {
for (int i = 0; i < n; i++) {
cout << vec[i] << " ";
cout << endl;
return vec;
int main() {
int n;
// Leer tamaño del vector
cout << "Ingrese el tamaño del vector: ";
cin >> n;
int vec[n];
// Leer elementos del vector
cout << "Ingrese los elementos del vector:" << endl;
for (int i = 0; i < n; i++) {
cin >> vec[i];
}
// Mostrar vector original
cout << "Vector original:" << endl;
imprimirVector(vec, n);
// Ordenar por selección
ordenarSeleccion(vec, n);
cout << "Vector ordenado (selección):" << endl;
imprimirVector(vec, n);
// Leer nuevamente para burbuja
cout << "Ingrese nuevamente los elementos para burbuja:" << endl;
for (int i = 0; i < n; i++) {
cin >> vec[i];
ordenarBurbuja(vec, n);
cout << "Vector ordenado (burbuja):" << endl;
imprimirVector(vec, n);
------------------------------------------------------------------------------------------------------------------------------
7- En la carnicería ̈Doña Berta ̈ se atiende a todo tipo de personas con descuentos especiales
según sea el caso. Aunque es una carnicería también se vende pescado y vegetales,
además de pollo y carnes . los clientes son organizados según el tipo, pensionados,
comunes o afiliados. El dueño de la carnicería ha decidido actualizarse y es por eso que lo
contrata a Ud para que le elabore un programa en donde pueda almacenar los siguientes
datos por cada uno de los clientes, nombre, Dni, sexo, tipo de cliente, monto de la compra,
tipo de producto que compro. Supóngase que por día se atiende a 30 clientes. Y al final se
necesita conocer lo siguiente:
1- Cantidad de clientes que compraron mas de 5.000 pesos en carnes
2- 2- % de clientes mujeres
3- 3- Sexo del cliente que menos compro
4- 4- Dni del cliente que hizo la mayor compra
5- 5- % de hombres afiliados que compraron menos de 1500 pesos
#include <iostream>
using namespace std;
int main() {
int numclientes=30;
string
nombres[numclientes],DNI[numclientes],sexo[numclientes],tipoCliente[numclientes],tipoProd
ucto[numclientes];
float montoCompra[numclientes];
int clientesCarnes5000=0;
int totalMujeres=0,totalHombresAfiliados=0,hombresAfiliadosmenos1500=0;
float menorCompra=100000000,mayorCompra=-1;
string sexomin,DNImax;
for(int i=0;i<30;i++){
cout<<"Cliente "<<i+1<<endl;
cout<<"Nombre: "<<endl;
cin>>nombres[i];
cout<<"DNI : "<<endl;
cin>>DNI[i];
cout<<"Sexo (M/F): "<<endl;
cin>>sexo[i];
cout<<"Tipo de cliente(pensionado,comun,afiliado): "<<endl;
cin>>tipoCliente[i];
cout<<"Monto compra: "<<endl;
cin>>montoCompra[i];
cout<<"Tipo de producto(carne,pollo,verduras,pescado): "<<endl;
cin>>tipoProducto[i];
for(int i=0;i<30;i++){
if(tipoProducto[i]=="carnes"&& montoCompra[i]>5000){
clientesCarnes5000++;
}
if(sexo[i]=="F"){
totalMujeres++;
if(montoCompra[i]<menorCompra){
menorCompra=montoCompra[i];
sexomin=sexo[i];
if(montoCompra[i]>mayorCompra){
mayorCompra=montoCompra[i];
DNImax=DNI[i];
if(sexo[i]=="M" && tipoCliente[i]=="afiliado"){
totalHombresAfiliados++;
if(montoCompra[i]<1500){
hombresAfiliadosmenos1500++;
float porcentajeMujeres=(totalMujeres*100.0)/numclientes;
float porcentajeHombresAfiliadosMenos1500=(totalHombresAfiliados*100.0)/numclientes;
cout<<"1- Cantidad de clientes que compraron mas de 5000 en carnes:
"<<clientesCarnes5000<<endl;
cout<<"2- Porcentaje de clientes mujeres: "<<porcentajeMujeres<<"%"<<endl;
cout<<"3- Sexo del cliente que menos compro: "<<sexomin<<endl;
cout<<"4- DNI del cliente que hizo la mayor compra"<<DNImax<<endl;
cout<<"5- Porcentaje de hombres afiliados que compraron menos de 1500:
"<<porcentajeHombresAfiliadosMenos1500<<"%"<<endl;
}
----------------------------------------------------------------------------------------------------------------------
8- Obtener un programa que permita ingresar valores enteros en un vector de N elementos y
luego determine: La suma de los valores positivos La suma de los valores negativos
Imprimir el promedio de los valores Imprimir cuales posiciones contienen valores por
encima del promedio Ordenar el vector de manera descendente (implementarlo con una
función
#include <iostream>
using namespace std;
// Función para ordenar el vector en forma descendente
int* ordenarDescendente(int vec[], int n) {
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (vec[j] < vec[j + 1]) {
int temp = vec[j];
vec[j] = vec[j + 1];
vec[j + 1] = temp;
return vec;
int main() {
int n;
// Solicitar el tamaño del vector
cout << "Ingrese el tamano del vector: ";
cin >> n;
int vec[n];
int sumaPositivos = 0, sumaNegativos = 0;
float sumaTotal = 0;
// Leer valores del vector y calcular sumas
cout << "Ingrese los valores del vector:" << endl;
for (int i = 0; i < n; i++) {
cin >> vec[i];
if (vec[i] > 0) {
sumaPositivos += vec[i];
} else if (vec[i] < 0) {
sumaNegativos += vec[i];
sumaTotal += vec[i];
// Calcular promedio
float promedio = sumaTotal / n;
// Mostrar resultados básicos
cout << "Suma de valores positivos: " << sumaPositivos << endl;
cout << "Suma de valores negativos: " << sumaNegativos << endl;
cout << "Promedio de los valores: " << promedio << endl;
// Mostrar posiciones con valores por encima del promedio
cout << "Posiciones con valores por encima del promedio:" << endl;
for (int i = 0; i < n; i++) {
if (vec[i] > promedio) {
cout << "Posicion " << i + 1 << " (Valor: " << vec[i] << ")" << endl;
// Ordenar el vector en forma descendente
int* vecOrdenado = ordenarDescendente(vec, n);
// Imprimir el vector ordenado
cout << "Vector ordenado de manera descendente:" << endl;
for (int i = 0; i < n; i++) {
cout << vecOrdenado[i] << " ";
cout << " " <<endl;
}
9- Una línea de Hoteles llamada “Iris” tiene hoteles en todo el país.. Dentro de las 5
provincias seleccionadas, tiene 3 sucursales por cada provincia. Por cada hotel se registra
el monto recaudado anualmente. Se pide informar: La sucursal con mayor recaudación
anual (indicar monto y posición) La recaudación total por provincia. La provincia con mayor
recaudación anual. La recaudación total general.
#include <iostream>
using namespace std;
int main() {
int provincias = 5;
int sucursales = 3;
float recaudaciones[provincias * sucursales];
float totalPorProvincia[provincias] = {0};
float totalGeneral = 0;
int mejorProvincia = 0, mejorSucursal = 0;
float mayorRecaudacion = 0;
// Leer las recaudaciones
for (int i = 0; i < provincias; i++) {
cout << "Provincia " << i + 1 << ":" << endl;
for (int j = 0; j < sucursales; j++) {
cout << " Sucursal " << j + 1 << ": ";
cin >> recaudaciones[i * sucursales + j];
// Calcular totales
totalPorProvincia[i] += recaudaciones[i * sucursales + j];
totalGeneral += recaudaciones[i * sucursales + j];
// Determinar la sucursal con mayor recaudación
if (recaudaciones[i * sucursales + j] > mayorRecaudacion) {
mayorRecaudacion = recaudaciones[i * sucursales + j];
mejorProvincia = i;
mejorSucursal = j;
// Determinar la provincia con mayor recaudación
int provinciaMayor = 0;
for (int i = 0; i < provincias; i++) {
if (totalPorProvincia[i] > totalPorProvincia[provinciaMayor]) {
provinciaMayor = i;
cout << "1. Sucursal con mayor recaudacion: Provincia " << mejorProvincia + 1
<< ", Sucursal " << mejorSucursal + 1 << ", Monto: " << mayorRecaudacion << endl;
cout << "2. Recaudacion total por provincia:" << endl;
for (int i = 0; i < provincias; i++) {
cout << " Provincia " << i + 1 << ": " << totalPorProvincia[i] << endl;
cout << "3. Provincia con mayor recaudacion anual: Provincia " << provinciaMayor + 1
<< ", Monto: " << totalPorProvincia[provinciaMayor] << endl;
cout << "4. Recaudacion total general: " << totalGeneral << endl;
------------------------------------------------------------------------------------------------------------------------------
