Extraordinaria Progra

EJEMPLO 1
Qué es un programa?
Programa: Conjunto de instrucciones que entiende una computadora para realizar una
actividad.
Todo programa tiene un objetivo bien definido: un procesador de texto es un programa que
permite cargar, modificar e imprimir textos, un programa de ajedrez permite jugar al ajedrez
contra el ordenador u otro contrincante humano.
La actividad fundamental del programador es resolver problemas empleando el ordenador

como herramienta fundamental.
Para la resolución de un problema hay que plantear un algoritmo.
Algoritmo: Son los pasos a seguir para resolver un problema.
Diagrama de flujo
Un diagrama de flujo es la representación gráfica de un ALGORITMO.
Los símbolos gráficos a utilizar para el planteo de diagramas de flujo

PLAMTEO DE UN PROLEMA UTILIZANDO DIAGRAMAS DE FLUJO
Podemos identificar:
Datos conocidos:
Horas trabajadas en el mes.
Pago por hora.
Proceso:
Cálculo del sueldo multiplicando la cantidad de horas por el pago por hora.
Información resultante:
Sueldo mensual.
EJERCICIO2
APLICACIÓN PARA PROGRAMACION
Existen muchos compiladores de C++, tanto para Windows, Mac, Linux etc, nosotros
utilizaremos el Visual C++ de Microsoft
Cuando procedamos a instalar debemos seleccionar como mínimo "Desarrollo para el

escritorio con C++
Conceptos básicos para codificar un programa.
Variable: Es un depósito donde hay un valor. Consta de un nombre y pertenece a un tipo.
Para el ejemplo planteado la variable horasTrabajadas almacena la cantidad de horas

trabajadas por el operario
Pasos
1 - Ingresemos al "Microsoft Studio Community 2019
Aparece un diálogo donde tenemos distintas opciones para abrir proyectos anteriores, clonar
proyectos almacenados en GitHub etc, nosotros elegiremos la opción de 'Continuar sin código'
para conocer el entorno de Visual Studio 2019
2 - Creación del proyecto. Para esto seleccionamos desde el menú la opción "Archivo" ->
"Nuevo" -> "Proyecto
Aparece un diálogo donde debemos seleccionar "Proyecto vacío" para el lenguaje C++
Windows Consola
El diálogo siguiente nos solicita ingresar el "Nombre del proyecto", la "ubicación", y "nombre
de la solución" (podemos usar el mismo texto para el "nombre de la solución" y "nombre del
proyecto
Como hemos creado un proyecto vacío debemos crear un archivo donde codificaremos
nuestro programa, para esto tipeamos el botón derecho del mouse sobre el nombre del
proyecto
Aparece un diálogo donde debemos seleccionar la opción de "Archivo C++" y definir el nombre
del archivo
En este momento tenemos todo listo para comenzar a codificar nuestro primer programa
Acotaciones : con Visual Studio .Net 2017
El diálogo para crear un proyecto en Visual Studio .Net 2017 varía un poco con respecto al
actual. Al crear un proyecto debemos seleccionar
Ejercicio 3
#include<iostream>
using namespace std;
int main()
int horasTrabajadas;
float costoHora;
float sueldo;
cout <<"Ingrese Horas trabajadas por el operario:";
cin >>horasTrabajadas;
cout <<"Ingrese el pago por hora:";
cin >>costoHora;
sueldo = horasTrabajadas * costoHora;
cout <<"El sueldo total del operario es:";
cout <<sueldo;
return 0;
}
#include<iostream>
int main()
int horasTrabajadas;
float costoHora;
float sueldo;
cout <<"Ingrese Horas trabajadas por el operario:";
cin >>horasTrabajadas;
cout <<"Ingrese el pago por hora:";
cin >>costoHora;
sueldo = horasTrabajadas * costoHora;
cout <<"El sueldo total del operario es:";
cout <<sueldo;
cin.get();
cin.get();
return 0;
Ejercicio4
diagrama de flujo
#include<iostream>
int main()
int lado;
int superficie;
cout <<"Ingrese el valor del lado del cuadrado:";
cin >>lado;
superficie = lado * lado;
cout <<"La superficie del cuadrado es:";
cout <<superficie;
return 0;
#include<iostream>
int main()
int lado;
int superficie;
cout <<"Ingrese el valor del lado del cuadrado:";
cin >>lado;
superficie = lado * lado * lado;
cout <<"La superficie del cuadrado es:";
cout <<superficie;
return 0;
}
Ejercicio5
#include<iostream> diagrama de flujo
int main()
int num1, num2, suma, producto;
cout <<"Ingrese primer valor:";
cin >>num1;
cout <<"Ingrese segundo valor:";
cin >>num2;
suma = num1 + num2;
producto = num1 * num2;
cout <<"La suma de los dos valores es:";
cout <<suma;
cout <<"\n";
cout <<"El producto de los dos valores es:";
cout <<producto;
return 0;
ejercicio6
Estructura condicional simple Diagrama de flujo

#include<iostream>
int main()
float sueldo;
cout <<"Ingrese el sueldo:";
cin >>sueldo;
if (sueldo>3000)
cout <<"Esta persona debe abonar impuestos";
return 0;
#include<iostream>
int main()
int num1, num2;
cin >>num1;
cin >>num2;
if (num1 > num2)
cout <<num1;
else
cout <<num2;
}
return 0;
ejercicio7
#include<iostream>
int main()
int nota1,nota2,nota3;
cout <<"Ingrese primer nota:";
cin >>nota1;
cout <<"Ingrese segunda nota:";
cin >>nota2;
cout <<"Ingrese tercer nota:";
cin >>nota3;
int promedio=(nota1 + nota2 + nota3) / 3;
if (promedio >= 7)
cout <<"Promocionado";
else
if (promedio >= 4)
cout <<"Regular";
else
cout <<"Reprobado";
return 0;
}
Ejercicio8
#include<iostream>
int main()
int num1,num2,num3;
cin >>num1;
cin >>num2;
cout <<"Ingrese tercer valor:";
cin >>num3;
if (num1 > num2 && num1 > num3)
cout <<num1;
else
if (num2 > num3)
cout <<num2;
else
cout <<num3;
return 0;
}
#include<iostream>
int main()
int dia,mes,año;
cout <<"Ingrese nro de día:";
cin >>dia;
cout <<"Ingrese nro de mes:";
cin >>mes;
cout <<"Ingrese nro de año:";
cin >>año;
if (mes==1 || mes==2 || mes==3)
cout <<"Corresponde al primer trimestre";
return 0;
Ejecicio9
#include<iostream>
int main()
int x;
x = 1;
while (x <= 100)
cout <<x;
cout <<" - ";
x = x + 1;
return 0;
#include<iostream>
int main()
int n,x;
cout <<"Ingrese el valor final:";
cin >>n;
x=1;
while (x <= n)
cout <<x;
cout <<" - ";
x = x + 1;
}
return 0;
#include<iostream>
int main()
int x,suma,valor,promedio;
x=1;
suma=0;
while ( x <= 10)
cout <<"Ingrese un valor:";
cin >>valor;
suma=suma+valor;
x=x+1;
promedio=suma/10;
cout <<"La suma de los 10 valores es:";
cout <<suma;
cout <<"\n";
cout <<"El promedio es:";
cout <<promedio;
return 0;
Ejercicio10
#include<iostream>
int main()
{
int f;
for(f=1; f <= 100 ;f++)
{
cout <<f;
cout <<"-";
}
return 0;
}
#include<iostream>
int main()
{
int suma,f,valor,promedio;
suma=0;
for(f=1; f <= 10;f++)
{
cout <<"Ingrese valor:";
cin >>valor;
suma=suma+valor;
}
cout <<"La suma es:";
cout <<suma;
cout <<"\n";
promedio=suma/10;
cout <<"El promedio es:";
cout <<promedio;
return 0;
}
#include<iostream>
int main()
{
int aprobados,reprobados,f,nota;
aprobados=0;
reprobados=0;
for(f=1; f <= 10 ;f++)
{
cout <<"Ingrese la nota:";
cin >>nota;
if (nota >= 7)
{
aprobados=aprobados+1;
}
else
{
reprobados=reprobados+1;
}
}
cout <<"Cantidad de aprobados:";
cout <<aprobados;
cout <<"\n";
cout <<"Cantidad de reprobados:";
cout <<reprobados;
return 0;
}
#include<iostream>
int main()
{
int mul3,mul5,valor,f;
mul3=0;
mul5=0;
for(f=1; f <= 10 ;f++)
{
cout <<"Ingrese un valor:";
cin >>valor;
if (valor%3 == 0)
{
mul3=mul3+1;
}
if (valor%5 == 0)
{
mul5=mul5+1;
}
}
cout <<"Cantidad de valores ingresados múltiplos de 3:";
cout <<mul3;
cout <<"\n";
cout <<"Cantidad de valores ingresados múltiplos de 5:";
cout <<mul5;
return 0;
}
#include<iostream>
int main()
{
int cantidad,n,f,valor;
cantidad=0;
cout <<"Cuantos valores ingresará:";
cin >>n;
for(f=1; f <= n ;f++)
{
cout <<"Ingrese el valor:";
cin >>valor;
if (valor >= 1000)
{
cantidad=cantidad+1;
}
}
cout <<"La cantidad de valores ingresados mayores o iguales a 1000
son:";
cout <<cantidad;
return 0;
}
Ejercicio11
#include<iostream>
int main()
{
int valor;
do {
cout <<"Ingrese un valor entre 0 y 999 (0 finaliza):";
cin >>valor;
if (valor >= 100)
{
cout <<"Tiene 3 dígitos.";
}
else
{
if (valor >= 10)
{
cout <<"Tiene 2 dígitos.";
}
else
{
cout <<"Tiene 1 dígito.";
}
}
cout <<"\n";
} while (valor != 0);
return 0;
}
#include<iostream>
int main()
{
int suma,cant,valor,promedio;
suma=0;
cant=0;
do {
cout <<"Ingrese un valor (0 para finalizar):";
cin >>valor;
if (valor !=0 )
{
suma=suma+valor;
cant++;
}
} while (valor != 0);
if (cant !=0 )
{
promedio=suma/cant;
cout <<"El promedio de los valores ingresados es:";
cout <<promedio;
}
else
{
cout <<"No se ingresaron valores.";
}
return 0;
}
#include<iostream>
int main()
{
int cant1,cant2,cant3,suma;
float peso;
cant1=0;
cant2=0;
cant3=0;
do {
cout <<"Ingrese el peso de la pieza (0 pera finalizar):";
cin >>peso;
if (peso > 10.2)
{
cant1++;
}
else
{
if (peso >= 9.8)
{
cant2++;
}
else
{
if (peso > 0)
{
cant3++;
}
}
}
} while(peso!=0);
suma=cant1+cant2+cant3;
cout <<"Piezas aptas:";
cout <<cant2;
cout <<"\n";
cout <<"Piezas con un peso superior a 10.2:";
cout <<cant1;
cout <<"\n";
cout <<"Piezas con un peso inferior a 9.8:";
cout <<cant3;
return 0;
}
Ejercicio12
#include<iostream>
int main()
{
char mes1[20]="enero";
char mes2[20]="febrero";
cout <<mes1;
cout <<"\n";
cout <<mes2;
return 0;
}
#include <iostream>
int main()
{
char nombre[40];
cout <<"Ingrese su nombre:";
cin.getline(nombre,40);
cout <<"El nombre ingresado es:";
cout <<nombre;
return 0;
}
#include<iostream>
int main()
{
char cadena1[50];
char cadena2[50];
cout <<"Ingrese la primer cadena:";
cin.getline(cadena1,50);
cout <<"Ingrese la segunda cadena:";
cin.getline(cadena2,50);
if (strcmp(cadena1,cadena2)==0)
{
cout <<"son iguales";
}
else
{
if (strcmp(cadena1,cadena2)>0)
{
cout <<"la primer cadena ingresada es mayor alfabeticamente";
}
else
{
cout <<"la segunda cadena ingresada es mayor alfabéticamente";
}
}
return 0;
}
Ejercicio13
#include <iostream>
int main()
{
char nombre[40];
int edad;
cout <<"Ingrese nombre:";
cout <<"Ingrese edad:";
cin >>edad;
cout <<"Nombre:";
cout <<nombre;
cout <<"\n";
cout <<"Edad:";
cout <<edad;
cout <<"\n";
if (edad>=18)
{
cout <<"Es mayor de edad.";
}
else
{
cout <<"No es mayor de edad.";
}
return 0;
}
#include <iostream>
class Persona {
private:
char nombre[40];
int edad;
public:
void inicializar();
void imprimir();
void esMayorEdad();
};
void Persona::inicializar()
{
cin >>edad;
}
void Persona::imprimir()
{
cout <<"Nombre:";
cout <<nombre;
cout <<"\n";
cout <<"Edad:";
cout <<edad;
cout <<"\n";
}
void Persona::esMayorEdad()
{
if (edad>=18)
{
}
else
{
}
cin.get();
cin.get();
}
int main()
{
Persona persona1;
persona1.inicializar();
persona1.imprimir();
persona1.esMayorEdad();
return 0;
}
#include <iostream>
class Persona {
private:
char nombre[40];
int edad;
public:
void inicializar();
void imprimir();
void esMayorEdad();
};
{
cin >>edad;
}
{
cout <<"Nombre:";
cout <<nombre;
cout <<"\n";
cout <<"Edad:";
cout <<edad;
cout <<"\n";
}
{
if (edad>=18)
{
}
else
{
}
cout <<"\n";
}
int main()
{
Persona persona1;
Persona persona2;
cin.get();
return 0;
}
#include<iostream>
class Triangulo {
private:
int lado1,lado2,lado3;
public:
void inicializar();
void ladoMayor();
void esEquilatero();
};
void Triangulo::inicializar()
{
cout <<"Ingrese primer lado:";
cin >>lado1;
cout <<"Ingrese segundo lado:";
cin >>lado2;
cout <<"Ingrese tercer lado:";
cin >>lado3;
}
void Triangulo::ladoMayor()
{
cout <<"Lado mayor:";
if (lado1 > lado2 && lado1 > lado3)
{
cout <<lado1;
}
else
{
if (lado2 > lado3)
{
cout <<lado2;
}
else
{
cout <<lado3;
}
}
cout <<"\n";
}
void Triangulo::esEquilatero()
{
if (lado1==lado2 && lado1==lado3)
{
cout <<"Es un triangulo equilatero";
}
else
{
cout <<"No es un triangulo equilatero";
}
cin.get();
cin.get();
}
int main()
{
Triangulo triangulo1;
triangulo1.inicializar();
triangulo1.ladoMayor();
triangulo1.esEquilatero();
return 0;
}
#include<iostream>
class Punto {
private:
int x,y;
public:
void inicializar();
void imprimirCuadrante();
};
void Punto::inicializar()
{
cout <<"Ingrese coordenada x :";
cin >>x;
cout <<"Ingrese coordenada y :";
cin >>y;
}
void Punto::imprimirCuadrante()
{
if (x>0 && y>0)
{
cout <<"Se encuentra en el primer cuadrante.";
}
else
{
if (x<0 && y>0)
{
cout <<"Se encuentra en el segundo cuadrante.";
}
else
{
if (x<0 && y<0)
{
cout <<"Se encuentra en el tercer cuadrante.";
}
else
{
if (x>0 && y<0)
{
cout <<"Se encuentra en el cuarto cuadrante.";
}
else
{
cout <<"El punto no está en un cuadrante.";
}
}
}
}
cin.get();
cin.get();
}
int main()
{
Punto punto1;
punto1.inicializar();
punto1.imprimirCuadrante();
return 0;
}
#include<iostream>
class Cuadrado {
private:
int lado;
public:
void inicializar();
void imprimirPerimetro();
void imprimirSuperficie();
};
void Cuadrado::inicializar()
{
cout <<"Ingrese el valor del lado:";
cin >>lado;
}
void Cuadrado::imprimirPerimetro()
{
int perimetro;
perimetro=lado*4;
cout <<"El perimetro es ";
cout <<perimetro;
cout <<"\n";
}
void Cuadrado::imprimirSuperficie()
{
int superficie;
superficie=lado*lado;
cout <<"La superficie es ";
cout <<superficie;
}
int main()
{
Cuadrado cuadrado1;
cuadrado1.inicializar();
cuadrado1.imprimirPerimetro();
cuadrado1.imprimirSuperficie();
return 0;
}
Ejercicio14
#include<iostream>
class TablaMultiplicar {
private:
void calcular(int v);
public:
void cargarValor();
};
void TablaMultiplicar::calcular(int v)
{
for(int f=v;f<=v*10;f=f+v)
{
cout <<f;
cout <<"-";
}
cout <<"\n";
}
void TablaMultiplicar::cargarValor()
{
int valor;
do
{
cout <<"Ingrese un valor (-1 para finalizar):";
cin >>valor;
if (valor != -1)
{
calcular(valor);
}
} while (valor != -1);
}
int main()
{
TablaMultiplicar tabla1;
tabla1.cargarValor();
return 0;
}
#include<iostream>
class MayorMenor {
private:
int calcularMayor(int v1,int v2,int v3);
int calcularMenor(int v1,int v2,int v3);
public:
void cargarValores();
};
int MayorMenor::calcularMayor(int v1,int v2,int v3)

{
int m;
if (v1 > v2 && v1 > v3)
{
m = v1;
}
else
{
if (v2 > v3)
{
m = v2;
}
else
{
m = v3;
}
}
return m;
}
int MayorMenor::calcularMenor(int v1,int v2,int v3)

{
int m;
if (v1 < v2 && v1 < v3)
{
m = v1;
}
else
{
if (v2 < v3)
{
m = v2;
}
else
{
m = v3;
}
}
return m;
}
void MayorMenor::cargarValores()
{
int valor1,valor2,valor3;
cin >>valor1;
cin >>valor2;
cout <<"Ingrese tercer valor:";
cin >>valor3;
int mayor, menor;
mayor = calcularMayor(valor1, valor2, valor3);
menor = calcularMenor(valor1, valor2, valor3);
cout <<"El valor mayor de los tres es:";
cout <<mayor;
cout <<"\n";
cout <<"El valor menor de los tres es:";
cout <<menor;
cin.get();
cin.get();
}
int main()
{
MayorMenor mayormenor1;
mayormenor1.cargarValores();
return 0;
}
Ejercicio15
#include<iostream>
class PruebaVector1 {
private:
int sueldos[5];
public:
void cargar();
void imprimir();
};
void PruebaVector1::cargar()
{
for (int f = 0; f < 5; f++)
{
cout <<"Ingrese valor del sueldo:";
cin >>sueldos[f];
}
}
void PruebaVector1::imprimir()
{
cout <<"Listado de sueldos.";
cout <<"\n";
for(int f = 0; f < 5; f++)
{
cout <<sueldos[f];
cout <<"\n";
}
cin.get();
cin.get();
}
int main()
{
PruebaVector1 pv1;
pv1.cargar();
pv1.imprimir();
return 0;
}
#include<iostream>
class PruebaVector2 {
private:
float alturas[5];
float promedio;
public:
void cargar();
void calcularPromedio();
void mayoresMenores();
};
{
for (int f = 0; f < 5; f++)
{
cout <<"Ingrese la altura de la persona:";
cin >>alturas[f];
}
}
void PruebaVector2::calcularPromedio()
{
float suma;
suma=0;
for(int f=0; f < 5; f++)
{
suma=suma+alturas[f];
}
promedio=suma/5;
cout <<"Promedio de alturas:";
cout <<promedio;
cout <<"\n";
}
void PruebaVector2::mayoresMenores()
{
int may,men;
may=0;
men=0;
for(int f = 0; f < 5; f++)
{
if (alturas[f] > promedio)
{
may++;
}
else
{
if (alturas[f] < promedio)
{
men++;
}
}
}
cout <<"Cantidad de personas mayores al promedio:";
cout <<may;
cout <<"\n";
cout <<"Cantidad de personas menores al promedio:";
cout <<men;
cin.get();
cin.get();
}
int main()
{
PruebaVector2 pv2;
pv2.cargar();
pv2.calcularPromedio();
pv2.mayoresMenores();
return 0;
}
#include<iostream>
class PruebaVector3{
private:
float turnoMan[4];
float turnoTar[4];
public:
void cargar();
void calcularGastos();
};
{
cout <<"Sueldos de empleados del turno de la mañana.";
cout <<"\n";
for(int f = 0; f < 4; f++)
{
cout <<"Ingrese sueldo:";
cin >>turnoMan[f];
}
cout <<"Sueldos de empleados del turno de la tarde.";
cout <<"\n";
for(int f = 0; f < 4; f++)
{
cin >>turnoTar[f];
}
}
void PruebaVector3::calcularGastos()
{
float man=0;
float tar=0;
for(int f = 0; f < 4; f++)
{
man=man+turnoMan[f];
tar=tar+turnoTar[f];
}
cout <<"Total de gastos del turno de la mañana:";
cout <<man;
cout <<"\n";
cout <<"Total de gastos del turno de la tarde:";
cout <<tar;
cin.get();
cin.get();
}
int main()
{
PruebaVector3 pv3;
pv3.cargar();
pv3.calcularGastos();
return 0;
}
Ejercicio16
#include<iostream>
class PersonasEdades {
private:
char nombres[5][40];
int edades[5];
public:
void cargar();
void mayoresEdad();
};
void PersonasEdades::cargar()
{
for(int f=0;f < 5;f++)
{
cin.getline(nombres[f],40);
cin >>edades[f];
cin.get();
}
}
void PersonasEdades::mayoresEdad()
{
cout <<"Personas mayores de edad.";
cout <<"\n";
{
if (edades[f] >= 18)
{
cout <<nombres[f];
cout <<"\n";
}
}
cin.get();
}
int main()
{
PersonasEdades pe;
pe.cargar();
pe.mayoresEdad();
return 0;
}
Ejercicio17
#include<iostream>
class SueldoOperarios {
private:
float sueldos[5];
public:
void cargar();
void mayorSueldo();
};
void SueldoOperarios::cargar()
{
{
cout <<"Ingrese el nombre del empleado:";
cin >>sueldos[f];
cin.get();
}
}
void SueldoOperarios::mayorSueldo()
{
float mayor;
int pos;
mayor=sueldos[0];
pos=0;
{
if (sueldos[f] > mayor)
{
mayor=sueldos[f];
pos=f;
}
}
cout <<"El empleado con sueldo mayor es ";
cout <<nombres[pos];
cout <<"\n";
cout <<"Tiene un sueldo:";
cout <<mayor;
cin.get();
}
int main()
{
SueldoOperarios so;
so.cargar();
so.mayorSueldo();
return 0;
}
Ejercicio18
#include<iostream>
class OrdenamientoSueldos {
private:
int sueldos[5];
public:
void cargar();
void ordenar();
void imprimir();
};
void OrdenamientoSueldos::cargar()
{
{
cin >>sueldos[f];
}
}
void OrdenamientoSueldos::ordenar()
{
for (int k = 0; k < 4; k++)
{
for (int f = 0; f < 4 - k; f++)
{
if (sueldos[f] > sueldos[f + 1])
{
int aux;
aux = sueldos[f];
sueldos[f] = sueldos[f + 1];
sueldos[f + 1] = aux;
}
}
}
}
void OrdenamientoSueldos::imprimir()
{
cout <<"Sueldos ordenados de menor a mayor.";
cout <<"\n";
{
cout <<sueldos[f];
cout <<"\n";
}
cin.get();
cin.get();
}
int main()
{
OrdenamientoSueldos os;
os.cargar();
os.ordenar();
os.imprimir();
return 0;
}
#include<iostream>
class OrdenamientoPaises{
private:
char paises[5][40];
public:
void cargar();
void ordenar();
void imprimir();
};
void OrdenamientoPaises::cargar()
{
{
cout <<"Ingrese el nombre del pais:";
cin.getline(paises[f],40);;
}
}
void OrdenamientoPaises::ordenar()
{
for (int k = 0; k < 4; k++)
{
for (int f = 0; f < 4 - k; f++)
{
if (strcmp(paises[f],paises[f + 1])>0)
{
char aux[40];
strcpy_s(aux, 40, paises[f]);
strcpy_s(paises[f],40, paises[f + 1]);
strcpy_s(paises[f + 1],40, aux);
}
}
}
}
void OrdenamientoPaises::imprimir()
{
cout <<"Paises ordenados en forma alfabética:";
cout <<"\n";
{
cout <<paises[f];
cout <<"\n";
}
cin.get();
}
int main()
{
OrdenamientoPaises op;
op.cargar();
op.ordenar();
op.imprimir();
return 0;
}
Ejercicio19
#include<iostream>
class NotaAlumnos {
private:
int notas[5];
public:
void cargar();
void ordenar();
void imprimir();
};
void NotaAlumnos::cargar()
{
cout <<"Carga de nombres y notas"<<"\n";
{
cout <<"Ingese el nombre del alumno:";
cout <<"Ingrese la nota del alumno:";
cin >>notas[f];
cin.get();
}
}
void NotaAlumnos::ordenar()
{
for (int k = 0; k < 5; k++)
{
for (int f = 0; f < 4 - k; f++)
{
if (notas[f] < notas[f + 1])
{
int auxnota;
auxnota = notas[f];
notas[f] = notas[f + 1];
notas[f + 1] = auxnota;
char auxnombre[40];
strcpy_s(auxnombre,40, nombres[f]);
strcpy_s(nombres[f],40, nombres[f + 1]);
strcpy_s(nombres[f + 1],40, auxnombre);
}
}
}
}
void NotaAlumnos::imprimir()
{
cout <<"Nombres de alumnos y notas de mayor a menor"<<"\n";
{
cout <<nombres[f] <<" - " <<notas[f] <<"\n";
}
cin.get();
}
int main()
{
NotaAlumnos na;
na.cargar();
na.ordenar();
na.imprimir();
return 0;
}
Ejecicio20
#include<iostream>
class Matriz1 {
private:
int mat[3][5];
public:
void cargar();
void imprimir();
};
void Matriz1::cargar()
{
for(int f = 0;f < 3;f++)
{
for(int c = 0;c < 5;c++)
{
cout <<"Ingrese componente:";
cin >>mat[f][c];
}
}
}
void Matriz1::imprimir()
{
for(int f = 0;f < 3;f++)
{
for(int c = 0;c < 5;c++)
{
cout <<mat[f][c] <<" ";
}
cout <<"\n";;
}
cin.get();
cin.get();
}
int main()
{
Matriz1 m;
m.cargar();
m.imprimir();
return 0;
}
#include<iostream>
class Matriz2 {
private:
int mat[4][4];
public:
void cargar();
void imprimirDiagonalPrincipal();
};
{
for(int f = 0; f < 4; f++)
{
for(int c = 0; c<4; c++)
{
cin >>mat[f][c];
}
}
}
void Matriz2::imprimirDiagonalPrincipal()
{
for(int k = 0; k < 4; k++)
{
cout <<mat[k][k] <<" ";
}
cin.get();
cin.get();
}
int main()
{
Matriz2 m;
m.cargar();
m.imprimirDiagonalPrincipal();
return 0;
}
#include<iostream>

class Matriz3 {
private:
int mat[3][4];
public:
void cargar();
void primerFila();
void ultimaFila();
void primerColumna();
};
{
for(int f = 0; f < 3; f++)
{
for(int c = 0; c < 4; c++)
{
cin >>mat[f][c];
}
}
}
void Matriz3::primerFila()
{
cout <<"Primer fila de la matriz:" <<"\n";
for(int c = 0; c < 4; c++)
{
cout <<mat[0][c] <<"\n";
}
}
void Matriz3::ultimaFila()
{
cout <<"Ultima fila de la matriz:" <<"\n";
for(int c = 0; c < 4; c++)
{
cout <<mat[2][c] <<"\n";
}
}
void Matriz3::primerColumna()
{
cout <<"Primer columna:" <<"\n";
for(int f = 0; f < 3; f++)
{
cout <<mat[f][0] <<"\n";
}
}
int main()
{
Matriz3 m;
m.cargar();
m.primerFila();
m.ultimaFila();
m.primerColumna();
return 0;
}
Ejercicio21
#include<iostream>
class SueldoEmpleados {
private:
char empleados[4][40];
int sueldos[4][3];
int sueldostot[4];
public:
void cargar();
void calcularSumaSueldos();
void imprimirTotalPagado();
void empleadoMayorSueldo();
};
void SueldoEmpleados::cargar()
{
for(int f = 0; f < 4; f++)
{
cout <<"Ingrese el nombre del empleado:";
cin.get(empleados[f],40);
for(int c = 0; c < 3; c++)
{
cin >>sueldos[f][c];
cin.get();
}
}
}
void SueldoEmpleados::calcularSumaSueldos()
{
for (int f = 0; f < 4; f++)
{
int suma = 0;
for (int c = 0; c < 3; c++)
{
suma = suma + sueldos[f][c];
}
sueldostot[f] = suma;
}
}
void SueldoEmpleados::imprimirTotalPagado()
{
cout <<"Total de sueldos pagados por empleado." <<"\n";
for(int f = 0; f < 4; f++)
{
cout <<empleados[f] <<" - " <<sueldostot[f] <<"\n";
}
}
void SueldoEmpleados::empleadoMayorSueldo()
{
int may=sueldostot[0];
char nom[40];
strcpy_s(nom,40,empleados[0]);
for(int f = 0; f < 4; f++)
{
if (sueldostot[f] > may)
{
may=sueldostot[f];
strcpy_s(nom,40,empleados[f]);
}
}
cout <<"El empleado con mayor sueldo es " <<nom <<" que tiene un
sueldo acumulado de " <<may;
cin.get();
}
int main()
{
SueldoEmpleados se;
se.cargar();
se.calcularSumaSueldos();
se.imprimirTotalPagado();
se.empleadoMayorSueldo();
return 0;
}
Ejercicio22
#include<iostream>
class Operarios {
private:
float sueldos[5];
public:
Operarios();
void imprimir();
};
Operarios::Operarios()
{
cout <<"Carga de sueldos." <<"\n";
{
cin >>sueldos[f];
}
}
void Operarios::imprimir()
{
for(int f = 0; f < 5; f++)
{
cout <<sueldos[f] <<"\n";;
}
cin.get();
cin.get();
}
int main()
{
Operarios op;
op.imprimir();
return 0;
}
#include<iostream>
class Alumno {
private:
char nombre[40];
int edad;
public:
Alumno();
void imprimir();
void esMayorEdad();
};
Alumno::Alumno()
{
cout <<"Ingrese la edad:";
cin >>edad;
}
void Alumno::imprimir()
{
cout <<"Nombre:" <<nombre <<"\n";
cout <<"Edad:" <<edad <<"\n";
}
void Alumno::esMayorEdad()
{
if (edad >= 18)
{
cout <<"es mayor de edad.";
}
else
{
cout <<"no es mayor de edad.";
}
cin.get();
cin.get();
}
int main()
{
Alumno alumno1;
alumno1.imprimir();
alumno1.esMayorEdad();
return 0;
}
#include<iostream>

class Moneda {
private:
int valor;
public:
Moneda(int v);
void imprimir();
};
Moneda::Moneda(int v)
{
valor=v;
}
void Moneda::imprimir()
{
cout <<"Valor de la moneda:" <<valor <<"\n";
}
int main()
{
Moneda moneda1(5);
Moneda moneda2(50);
moneda1.imprimir();
moneda2.imprimir();
return 0;
}
Ejercicio23
#include<iostream>
class Tabla {
private:
int valor;
public:
Tabla();
void imprimir();
~Tabla();
};
Tabla::Tabla()
{
cout << "Ingrese un valor:";
cin >> valor;
}
void Tabla::imprimir()
{
for (int f = valor; f <= valor * 10; f = f + valor)
{
cout << f << "-";
}
cout << "\n";
}
Tabla::~Tabla()
{
cout << "Gracias por utilizar este programa.";
cin.get();
cin.get();
}
int main()
{
Tabla tabla1;
tabla1.imprimir();
return 0;
}
Ejercicio24
#include<iostream>
#include<cstdlib>
#include<ctime>
class Dado {
private:
int valor;
void separador();
public:
void tirar();
void imprimir();
};
void Dado::separador()
{
cout<<"********************";
cout<<"\n";
}
void Dado::tirar()
{
srand (time(NULL));
valor = rand() % 6 + 1;
}
void Dado::imprimir()
{
separador();
cout<<valor;
cout<<"\n";
separador();
}
int main()
{
Dado d;
d.tirar();
d.imprimir();
return 0;
}
Ejercicio25
#include<iostream>
class Matematica {
public:
int mayor(int x1,int x2);
int mayor(int x1,int x2,int x3);
float mayor(float x1,float x2);
float mayor(float x1,float x2,float x3);
};
int Matematica::mayor(int x1,int x2)

{
if (x1>x2)
return x1;
else
return x2;
}
int Matematica::mayor(int x1,int x2,int x3)

{
if (x1>x2 && x1>x3)
return x1;
else
if (x2>x3)
return x2;
else
return x3;
}
float Matematica::mayor(float x1,float x2)

{
if (x1>x2)
return x1;
else
return x2;
}
float Matematica::mayor(float x1,float x2,float x3)

{
if (x1>x2 && x1>x3)
return x1;
else
if (x2>x3)
return x2;
else
return x3;
}
int main()
{
Matematica m1;
cout<<"Mayor entre 6 y 8 : ";
cout<<m1.mayor(6,8);
cout <<"\n";
cout<<"Mayor entre 10, 40 y 5 : ";
cout<<m1.mayor(10,40,5);
cout <<"\n";
cout<<"Mayor entre 6.2 y 9.3 : ";
cout<<m1.mayor(6.2f,9.3f);
cout <<"\n";
cout<<"Mayor entre 7 , 12.5 y 4.2 : ";
cout<<m1.mayor(7.0f,12.5f,4.2f);
cout <<"\n";
return 0;
}
#include<iostream>
class EstructuraVector {
int vec[5];
public:
EstructuraVector();
EstructuraVector(int valor);
void imprimir();
};
EstructuraVector::EstructuraVector()
{
for(int f=0;f<5;f++)
vec[f]=0;
}
EstructuraVector::EstructuraVector(int valor)
{
vec[f]=valor;
}
void EstructuraVector::imprimir()
{
{
cout <<vec[f];
cout <<"-";
}
cout<<"\n\n";
}
int main()
{
EstructuraVector v1;
v1.imprimir();
EstructuraVector v2(12);
v2.imprimir();
return 0;
}
Ejercicio26
#include<iostream>
class Cliente {
char nombre[40];
float monto;
public:
Cliente(const char nom[40]);
void depositar(int m);
void extraer(int m);
float retornarMonto();
void imprimir();
};
class Banco {
Cliente cliente1, cliente2, cliente3;
public:
Banco();
void operar();
void depositiosTotales();
};
Cliente::Cliente(const char nom[40])

{
strcpy_s(nombre, nom);
monto = 0;
}
void Cliente::depositar(int m)
{
monto = monto + m;
}
void Cliente::extraer(int m)
{
monto = monto - m;
}
float Cliente::retornarMonto()
{
return monto;
}
void Cliente::imprimir()
{
cout << "Nombre:" << nombre << " Monto:" << monto << "\n\
n";
}
Banco::Banco() :cliente1("juan"), cliente2("pedro"), cliente3("luis")

{
}
void Banco::operar()
{
cliente1.depositar(100);
cliente3.extraer(150);
}
void Banco::depositiosTotales()
{
float t = cliente1.retornarMonto() + cliente2.retornarMonto() +
cliente3.retornarMonto();
cout << "El total de dinero en el banco es:" << t << "\n\n";
cliente1.imprimir();
}
int main()
{
Banco banco1;
banco1.operar();
banco1.depositiosTotales();
return 0;
}
#include<iostream>
#include<cstdlib>
#include<ctime>
class Dado {
int valor;
public:
void tirar();
void imprimir();
int retornarValor();
};
class JuegoDeDados {
Dado dado1, dado2, dado3;
public:
void jugar();
};
void Dado::tirar()
{
valor = rand() % 6 + 1;
}
void Dado::imprimir()
{
cout << "Valor del Dado:" << valor << "\n";
}
int Dado::retornarValor()
{
return valor;
}
void JuegoDeDados::jugar()
{
dado1.tirar();
dado1.imprimir();
dado2.tirar();
dado2.imprimir();
dado3.tirar();
dado3.imprimir();
if (dado1.retornarValor() == dado2.retornarValor() &&
dado1.retornarValor() == dado3.retornarValor())
{
cout<<"Gano";
}
else
{
cout<<"Perdio";
}
}
int main()
{
srand(time(NULL));
JuegoDeDados juego1;
juego1.jugar();
return 0;
}
Ejercicio27
#include<iostream>
class Operacion {
protected:
int valor1;
int valor2;
int resultado;
public:
void cargar1();
void cargar2();
void mostrarResultado();
};
class Suma: public Operacion{

public:
void operar();
};
class Resta : public Operacion {

public:
void operar();
};
void Operacion::cargar1()
{
cout << "Ingrese primer valor:";
cin >> valor1;
}
void Operacion::cargar2()
{
cout << "Ingrese segundo valor:";
cin >> valor2;
}
void Operacion::mostrarResultado()
{
cout <<resultado<<"\n";
}
void Suma::operar()
{
resultado = valor1 + valor2;
}
void Resta::operar()
{
resultado = valor1 - valor2;
}
int main()
{
Suma suma1;
suma1.cargar1();
suma1.cargar2();
suma1.operar();
cout << "La suma de los dos valores es:";
suma1.mostrarResultado();
Resta resta1;
resta1.cargar1();
resta1.cargar2();
resta1.operar();
cout << "La diferencia de los dos valores es:";
resta1.mostrarResultado();
return 0;
}
Ejercicio28
#include <iostream>
int main()
{
int x = 10;
int *pe;
pe = &x;
cout << x; // 10
cout << "\n";
cout << *pe; // imprime lo apuntado por pe: 10
cout << "\n";
*pe = 5; //asignamos 5 a lo apuntado por pe
cout << x; // 5
cout << "\n";
float valor = 10.9;
float *pf;
pf = &valor;
cout << *pf; //imprimime lo apuntado por pf: 10.9
return 0;
}
Ejercicio29
#include<iostream>
class Vector {
int vec[5];
public:
void cargar();
void retornarMayorMenor(int *pmay, int *pmen);
};
void Vector::cargar()
{
for (int f = 0; f < 5; f++)
{
cout << "Ingrese componente:";
cin >> vec[f];
}
}
void Vector::retornarMayorMenor(int *pmay, int *pmen)

{
*pmay = vec[0];
*pmen = vec[0];
for (int f = 1; f < 5; f++)
{
if (vec[f]>*pmay)
{
*pmay = vec[f];
}
else
{
if (vec[f]<*pmen)
{
*pmen = vec[f];
}
}
}
}
int main()
{
Vector vector1;
vector1.cargar();
int ma, me;
vector1.retornarMayorMenor(&ma, &me);
cout << "El elemento mayor del vector es:" << ma << "\n";
cout << "El elemento menor del vector es:" << me << "\n";
return 0;
}
Ejercicio30
char cad[10];
strcpy_s(cad,10,"Sol");
char *pc;
pc=cad;
cout<<pc;
Seguimiento del ejemplo:
- Definimos un vector de caracteres: char cad[10];
Dir. de Mem. Contenido Nombre de variable
1000 1004 cad
1004 [0]
1005 [1]
1006 [2]
1007 [3]
1008 [4]
1009 [5]
1010 [6]
1011 [7]
1012 [8]
1013 [9]
- Cargamos el vector: strcpy_s(cad,10,"Sol");
1000 1004 cad
1004 'S' [0]
1005 'o' [1]
1006 'l' [2]
1007 '\0' [3]
1008 [4]
1009 [5]
1010 [6]
1011 [7]
1012 [8]
1013 [9]
- Definimos un puntero a char: char *pc;
1000 1004 cad
1004 'S' [0]
1005 'o' [1]
1006 'l' [2]
1007 '\0' [3]
1008 [4]
1009 [5]
1010 [6]
1011 [7]
1012 [8]
1013 [9]
1014 pc
- Asignamos al puntero pc la cadena: pc=cad;
1000 1004 cad
1004 'S' [0]
1005 'o' [1]
1006 'l' [2]
1007 '\0' [3]
1008 [4]
1009 [5]
1010 [6]
1011 [7]
1012 [8]
1013 [9]
1014 1004 pc
Ejercicio31
#include<iostream>
int main()
{
char cad[5];
strcpy_s(cad, 5, "Sol");
char *pc;
pc = cad;
cout << pc; //imprime Sol
cout << "\n";
pc++;
cout << pc; //imprime ol
cout << "\n";
pc++;
cout << pc; //imprime l
cout << "\n";
pc--;
cout << pc; //imprime ol
cout << "\n";
int x[5] = { 10, 50, 100, 99, 33 };
int *pe;
pe = &x[3];
cout << *pe; //imprime 99
cout << "\n";
pe--;
cout << *pe; //imprime 100
return 0;
}
- Definimos una cadena:
char cad[5];
1000 1004 cad
1004 [0]
1005 [1]
1006 [2]
1007 [3]
1008 [4]
- Cargamos la cadena:
strcpy_s (cad, 5, "Sol");
1000 1004 cad
1004 'S' [0]
1005 'o' [1]
1006 'l' [2]
1007 '\0' [3]
1008 [4]
- Definimos un puntero a char:

char *pc;
1000 1004 cad
1004 'S' [0]
1005 'o' [1]
1006 'l' [2]
1007 '\0' [3]
1008 [4]
1009 pc
- Le asignamos al puntero el contenido de la cadena:

pc=cad;
1000 1004 cad
1004 'S' [0]
1005 'o' [1]
1006 'l' [2]
1007 '\0' [3]
1008 [4]
1009 1004 pc
- Imprimimos donde apunta el puntero:
cout<<pc; //imprime Sol
Imprime desde la dirección 1004 hasta encontrar el
terminador de cadena.
- Incrementamos el puntero:
pc++;
La dirección se incrementa en 1.
1000 1004 cad
1004 'S' [0]
1005 'o' [1]
1006 'l' [2]
1007 '\0' [3]
1008 [4]
1009 1005 pc

cout<<pc; //imprime ol
- Incrementamos el puntero:
pc++;
La dirección se incrementa en 1.

1000 1004 cad
1004 'S' [0]
1005 'o' [1]
1006 'l' [2]
1007 '\0' [3]
1008 [4]
1009 1006 pc

cout <<pc; //imprime l
- Decrementamos el puntero:
pc--;
La dirección se decrementa en 1.

1000 1004 cad
1004 'S' [0]
1005 'o' [1]
1006 'l' [2]
1007 '\0' [3]
1008 [4]
1009 1005 pc

cout <<pc; //imprime ol
- Definimos e inicializamos un vector de enteros:

int x[5] ={10,50,100,99,33};

1000 1004 cad
1004 'S' [0]
1005 'o' [1]
1006 'l' [2]
1007 '\0' [3]
1008 [4]
1009 1005 pc
1013 1017 x
1017 10 [0]
1021 50 [1]
1025 100 [2]
1029 99 [3]
1033 33 [4]
- Definimos un puntero a entero:

int *pe;
1000 1004 cad
1004 'S' [0]
1005 'o' [1]
1006 'l' [2]
1007 '\0' [3]
1008 [4]
1009 1005 pc
1013 1017 x
1017 10 [0]
1021 50 [1]
1025 100 [2]
1029 99 [3]
1033 33 [4]
1037 pe
- Le asignamos al puntero la dirección de la cuarta
componente del vector:
pe = &x[3];
1000 1004 cad
1004 'S' [0]
1005 'o' [1]
1006 'l' [2]
1007 '\0' [3]
1008 [4]
1009 1005 pc
1013 1017 x
1017 10 [0]
1021 50 [1]
1025 100 [2]
1029 99 [3]
1033 33 [4]
1037 1029 pe

cout<<*pe; //99
- Decrementamos el puntero:
pc--;
La dirección se decrementa en 4.
1000 1004 cad
1004 'S' [0]
1005 'o' [1]
1006 'l' [2]
1007 '\0' [3]
1008 [4]
1009 1005 pc
1013 1017 x
1017 10 [0]
1021 50 [1]
1025 100 [2]
1029 99 [3]
1033 33 [4]
1037 1025 pe
Ejercicio32
#include<iostream>
int main ()
{
int *p;
p=new int[5];
{
cout <<"Ingrese elemento:";
cin >>p[f];
}
cout <<"contenido del vector:";
{
cout<<p[f]<<"-";
}
delete []p;
return 0;
}
#include<iostream>
class Vector {
int *p;
int tamano;
public:
Vector();
void cargar();
void imprimir();
~Vector();
};
Vector::Vector()
{
cout <<"Cuantos elementos tendra el vector:";
cin >>tamano;
p=new int[tamano];
}
{
for(int f=0;f<tamano;f++)
{
cin>>p[f];
}
}
void Vector::imprimir()
{
{
cout<<p[f];
cout<<"-";
}
}
Vector::~Vector()
{
delete []p;
}
int main()
{
Vector vector1;
vector1.cargar();
vector1.imprimir();
return 0;
}
Ejercicio33
#include <iostream>
class Persona {
private:
char nombre[40];
int edad;
public:
void inicializar();
void imprimir();
void esMayorEdad();
};
{
cin >>edad;
}
{
cout <<"Nombre:";
cout <<nombre;
cout <<"\n";
cout <<"Edad:";
cout <<edad;
cout <<"\n";
}
{
if (edad>=18)
{
}
else
{
}
cin.get();
cin.get();
}
int main()
{
Persona *persona1;
persona1 = new Persona();
persona1->inicializar();
persona1->imprimir();
persona1->esMayorEdad();
delete persona1;
return 0;
}
Ejercicio35
Ejercicio36
#include <iostream>
class Pila {
private:
class Nodo {
public:
int info;
Nodo *sig;
};
Nodo *raiz;
public:
Pila();
~Pila();
void insertar(int x);
int extraer();
void imprimir();
};
Pila::Pila()
{
raiz = NULL;
}
void Pila::insertar(int x)
{
Nodo *nuevo;
nuevo = new Nodo();
nuevo->info = x;
if (raiz == NULL)
{
raiz = nuevo;
nuevo->sig = NULL;
}
else
{
nuevo->sig = raiz;
raiz = nuevo;
}
}
void Pila::imprimir()
{
Nodo *reco = raiz;
cout << "Listado de todos los elementos de la pila.\n";
while (reco != NULL)
{
cout << reco->info << "-";
reco = reco->sig;
}
cout << "\n";
}
int Pila::extraer()
{
if (raiz != NULL)
{
int informacion = raiz->info;
Nodo *bor = raiz;
raiz = raiz->sig;
delete bor;
return informacion;
}
else
{
return -1;
}
}
Pila::~Pila()
{
Nodo *reco = raiz;
Nodo *bor;
{
bor = reco;
reco = reco->sig;
delete bor;
}
}
int main()
{
Pila *pila1;
pila1= new Pila();
pila1->insertar(10);
pila1->insertar(3);
pila1->imprimir();
cout<<"Extraemos de la pila:" <<pila1->extraer()<<"\n";
pila1->imprimir();
delete pila1;
return 0;
}
#include <iostream>
class Pila {
private:
class Nodo {
public:
int info;
Nodo *sig;
};
Nodo *raiz;
public:
Pila();
~Pila();
int extraer();
void imprimir();
int cantidad();
bool vacia();
};
Pila::Pila()
{
raiz = NULL;
}
void Pila::insertar(int x)
{
Nodo *nuevo;
nuevo = new Nodo();
nuevo->info = x;
if (raiz == NULL)
{
raiz = nuevo;
nuevo->sig = NULL;
}
else
{
nuevo->sig = raiz;
raiz = nuevo;
}
}
void Pila::imprimir()
{
Nodo *reco = raiz;
cout << "Listado de todos los elementos de la pila.\n";
{
reco = reco->sig;
}
cout << "\n";
}
int Pila::extraer()
{
if (raiz != NULL)
{
Nodo *bor = raiz;
raiz = raiz->sig;
delete bor;
return informacion;
}
else
{
return -1;
}
}
Pila::~Pila()
{
Nodo *reco = raiz;
Nodo *bor;
{
bor = reco;
reco = reco->sig;
delete bor;
}
}
int Pila::cantidad()
{
Nodo *reco = raiz;
int cant = 0;
{
cant++;
reco = reco->sig;
}
return cant;
}
bool Pila::vacia()
{
if (raiz == NULL)
return true;
else
return false;
}
int main()
{
Pila *pila1;
pila1 = new Pila();
pila1->insertar(3);
pila1->imprimir();
cout << "La cantidad de nodos de la pila es:" << pila1->cantidad() <<
"\n";
while (pila1->vacia() == false)
{
cout << "Extraemos de la pila:" << pila1->extraer() << "\n";
}
delete pila1;
return 0;
}
EJERCICIO37
#include <iostream>
class Pila {
private:
class Nodo {
public:
char simbolo;
Nodo *sig;
};
Nodo *raiz;
public:
Pila();
~Pila();
void insertar(char x);
char extraer();
bool vacia();
};
Pila::Pila()
{
raiz = NULL;
}
void Pila::insertar(char x)
{
Nodo *nuevo;
nuevo = new Nodo();
nuevo->simbolo = x;
if (raiz == NULL)
{
raiz = nuevo;
nuevo->sig = NULL;
}
else
{
nuevo->sig = raiz;
raiz = nuevo;
}
}
char Pila::extraer()
{
if (raiz != NULL)
{
char informacion = raiz->simbolo;
Nodo *bor = raiz;
raiz = raiz->sig;
delete bor;
return informacion;
}
else
{
return ' ';
}
}
bool Pila::vacia()
{
if (raiz == NULL)
return true;
else
return false;
}
Pila::~Pila()
{
Nodo *reco = raiz;
Nodo *bor;
{
bor = reco;
reco = reco->sig;
delete bor;
}
}
class Formula {
char cadena[100];
public:
Formula();
bool balanceada();
};
Formula::Formula()
{
cout << "Ingrese una formula con parentesis, corchetes y llaves:";
cin.getline(cadena, 100);
}
bool Formula::balanceada()
{
Pila *pila1;
pila1 = new Pila();
for (int f = 0; f < strlen(cadena); f++)
{
if (cadena[f] == '(' || cadena[f] == '[' || cadena[f] == '{')
{
pila1->insertar(cadena[f]);
}
else
{
if (cadena[f] == ')')
{
if (pila1->extraer() != '(')
{
return false;
}
}
else
{
if (cadena[f] == ']')
{
if (pila1->extraer() != '[')
{
return false;
}
}
else
{
if (cadena[f] == '}')
{
if (pila1->extraer() != '{')
{
return false;
}
}
}
}
}
}
if (pila1->vacia())
{
return true;
}
else
{
return false;
}
}
int main()
{
Formula *formula1;
formula1 = new Formula();
if (formula1->balanceada() == true)
{
cout << "La formula esta correctamente balanceada";
}
else
{
cout << "La formula no esta correctamente balanceada";
}
delete formula1;
return 0;
}
Ejercicio38
#include <iostream>
class Cola {
private:
class Nodo {
public:
int info;
Nodo *sig;
};
Nodo *raiz;
Nodo *fondo;
public:
Cola();
~Cola();
int extraer();
void imprimir();
bool vacia();
};
Cola::Cola()
{
raiz = NULL;
fondo = NULL;
}
Cola::~Cola()
{
Nodo *reco = raiz;
Nodo *bor;
{
bor = reco;
reco = reco->sig;
delete bor;
}
}
void Cola::insertar(int x)
{
Nodo *nuevo;
nuevo = new Nodo();
nuevo->info = x;
nuevo->sig = NULL;
if (vacia())
{
raiz = nuevo;
fondo = nuevo;
}
else {
fondo->sig = nuevo;
fondo = nuevo;
}
}
int Cola::extraer()
{
if (!vacia())
{
Nodo *bor = raiz;
if (raiz == fondo)
{
raiz = NULL;
fondo = NULL;
}
else
{
raiz = raiz->sig;
}
delete bor;
return informacion;
}
else
return -1;
}
void Cola::imprimir()
{
Nodo *reco = raiz;
cout << "Listado de todos los elementos de la cola.\n";
{
reco = reco->sig;
}
cout << "\n";
}
bool Cola::vacia()
{
if (raiz == NULL)
return true;
else
return false;
}
int main()
{
Cola *cola1 = new Cola();
cola1->insertar(5);
cola1->insertar(10);
cola1->insertar(50);
cola1->imprimir();
cout <<"Extraemos uno de la cola:" <<cola1->extraer()<<"\n";
cola1->imprimir();
delete cola1;
return 0;
}
Ejercicio39
#include <iostream>
#include<cstdlib>
#include<ctime>
class Cola {
private:
class Nodo {
public:
int info;
Nodo *sig;
};
Nodo *raiz;
Nodo *fondo;
public:
Cola();
~Cola();
int extraer();
bool vacia();
int cantidad();
};
Cola::Cola()
{
raiz = NULL;
fondo = NULL;
}
Cola::~Cola()
{
Nodo *reco = raiz;
Nodo *bor;
{
bor = reco;
reco = reco->sig;
delete bor;
}
}
void Cola::insertar(int x)
{
Nodo *nuevo;
nuevo = new Nodo();
nuevo->info = x;
nuevo->sig = NULL;
if (vacia())
{
raiz = nuevo;
fondo = nuevo;
}
else
{
fondo->sig = nuevo;
fondo = nuevo;
}
}
int Cola::extraer()
{
if (!vacia())
{
Nodo *bor = raiz;
if (raiz == fondo)
{
raiz = NULL;
fondo = NULL;
}
else
{
raiz = raiz->sig;
}
delete bor;
return informacion;
}
else
return -1;
}
bool Cola::vacia()
{
if (raiz == NULL)
return true;
else
return false;
}
int Cola::cantidad()
{
Nodo *reco = raiz;
int cant = 0;
{
cant++;
reco = reco->sig;
}
return cant;
}
class CajeroAutomatico {
public:
void simulacion();
};
void CajeroAutomatico::simulacion()
{
srand(time(NULL));
int estado = 0;
int llegada = rand() % 2 + 2;
int salida = -1;
int cantAtendidas = 0;
Cola *cola = new Cola();
for (int minuto = 0; minuto < 600; minuto++)
{
if (llegada == minuto)
{
if (estado == 0)
{
estado = 1;
salida = minuto + 2 + rand() % 3;
}
else
{
cola->insertar(minuto);
}
llegada = minuto + 2 + rand() % 2;
}
if (salida == minuto)
{
estado = 0;
cantAtendidas++;
if (!cola->vacia())
{
cola->extraer();
estado = 1;
salida = minuto + 2 + rand() % 3;
}
}
}
cout <<"Atendidos:" <<cantAtendidas <<"\n";
cout <<"En cola:" <<cola->cantidad() <<"\n";
cout <<"Minuto llegada:" <<cola->extraer();
}
int main()
{
CajeroAutomatico *cajero1 = new CajeroAutomatico();
cajero1->simulacion();
delete cajero1;
return 0;
}
Ejercicio40
#include <iostream>
class ListaGenerica {
private:
class Nodo {
public:
int info;
Nodo *sig;
};
Nodo *raiz;
public:
ListaGenerica();
~ListaGenerica();
int cantidad();
void insertar(int pos, int x);
int extraer(int pos);
void borrar(int pos);
void intercambiar(int pos1, int pos2);
bool vacia();
int mayor();
void imprimir();
int posMayor();
bool ordenada();
bool existe(int x);
};
ListaGenerica::ListaGenerica()
{
raiz = NULL;
}
ListaGenerica::~ListaGenerica()
{
Nodo *reco = raiz;
Nodo *bor;
{
bor = reco;
reco = reco->sig;
delete bor;
}
}
int ListaGenerica::cantidad()
{
Nodo *reco = raiz;
int cant = 0;
{
cant++;
reco = reco->sig;
}
return cant;
}
void ListaGenerica::insertar(int pos, int x)

{
if (pos <= cantidad() + 1)
{
Nodo *nuevo = new Nodo();
nuevo->info = x;
if (pos == 1)
{
nuevo->sig = raiz;
raiz = nuevo;
}
else
if (pos == cantidad() + 1)
{
Nodo *reco = raiz;
while (reco->sig != NULL)
{
reco = reco->sig;
}
reco->sig = nuevo;
nuevo->sig = NULL;
}
else
{
Nodo *reco = raiz;
for (int f = 1; f <= pos - 2; f++)
{
reco = reco->sig;
}
Nodo *siguiente = reco->sig;
reco->sig = nuevo;
nuevo->sig = siguiente;
}
}
}
int ListaGenerica::extraer(int pos)

{
if (pos <= cantidad())
{
int informacion;
Nodo *bor;
if (pos == 1)
{
informacion = raiz->info;
bor = raiz;
raiz = raiz->sig;
}
else
{
Nodo *reco;
reco = raiz;
for (int f = 1; f <= pos - 2; f++)
{
reco = reco->sig;
}
Nodo *prox = reco->sig;
reco->sig = prox->sig;
informacion = prox->info;
bor = prox;
}
delete bor;
return informacion;
}
else
return -1;
}
void ListaGenerica::borrar(int pos)

{
{
Nodo *bor;
if (pos == 1)
{
bor = raiz;
raiz = raiz->sig;
}
else {
Nodo *reco;
reco = raiz;
for (int f = 1; f <= pos - 2; f++)
{
reco = reco->sig;
}
bor = prox;
}
delete bor;
}
}
void ListaGenerica::intercambiar(int pos1, int pos2)

{
if (pos1 <= cantidad() && pos2 <= cantidad())
{
Nodo *reco1 = raiz;
for (int f = 1; f < pos1; f++)
{
reco1 = reco1->sig;
}
Nodo *reco2 = raiz;
{
reco2 = reco2->sig;
}
int aux = reco1->info;
reco1->info = reco2->info;
reco2->info = aux;
}
}
bool ListaGenerica::vacia()
{
if (raiz == NULL)
return true;
else
return false;
}
int ListaGenerica::mayor()
{
if (!vacia())
{
int may = raiz->info;
Nodo *reco = raiz->sig;
{
if (reco->info > may)
{
may = reco->info;
}
reco = reco->sig;
}
return may;
}
else
return -1;
}
void ListaGenerica::imprimir()
{
Nodo *reco = raiz;
cout << "Listado completo.\n";
{
reco = reco->sig;
}
cout << "\n";
}
int ListaGenerica::posMayor()
{
if (!vacia())
{
int x = 1;
int pos = x;
{
{
may = reco->info;
pos = x;
}
reco = reco->sig;
x++;
}
return pos;
}
else
return -1;
}
bool ListaGenerica::ordenada()
{
if (cantidad()>1)
{
Nodo *reco1 = raiz;
Nodo *reco2 = raiz->sig;
while (reco2 != NULL)
{
if (reco2->info<reco1->info)
{
return false;
}
reco2 = reco2->sig;
reco1 = reco1->sig;
}
}
return true;
}
bool ListaGenerica::existe(int x)
{
Nodo *reco = raiz;
{
if (reco->info == x)
return true;
reco = reco->sig;
}
return false;
}
int main()
{
ListaGenerica *lg = new ListaGenerica();
lg->insertar(1, 10);
lg->imprimir();
cout <<"Luego de Borrar el primero\n";
lg->borrar(1);
lg->imprimir();
cout<<"Luego de Extraer el segundo\n";
lg->extraer(2);
lg->imprimir();
cout<<"Luego de Intercambiar el primero con el tercero\n";
lg->intercambiar(1, 3);
lg->imprimir();
if (lg->existe(20))
cout<<"Se encuentra el 20 en la lista\n";
else
cout<<"No se encuentra el 20 en la lista\n";
cout <<"La posición del mayor es:" <<lg->posMayor() <<"\n";
if (lg->ordenada())
cout<<"La lista esta ordenada de menor a mayor\n";
else
cout<<"La lista no esta ordenada de menor a mayor\n";
delete lg;
return 0;
}
Ejercicio41
#include <iostream>
class ListaGenericaOrdenada {
private:
class Nodo {
public:
int info;
Nodo *sig;
};
Nodo *raiz;
public:
ListaGenericaOrdenada();
~ListaGenericaOrdenada();
void imprimir();
};
ListaGenericaOrdenada::ListaGenericaOrdenada()
{
raiz = NULL;
}
ListaGenericaOrdenada::~ListaGenericaOrdenada()
{
Nodo *reco = raiz;
Nodo *bor;
{
bor = reco;
reco = reco->sig;
delete bor;
}
}
void ListaGenericaOrdenada::insertar(int x)
{
nuevo->info = x;
if (raiz == NULL)
{
raiz = nuevo;
}
else
{
if (x<raiz->info)
{
nuevo->sig = raiz;
raiz = nuevo;
}
else
{
Nodo *reco = raiz;
Nodo *atras = raiz;
while (x >= reco->info && reco->sig != NULL)
{
atras = reco;
reco = reco->sig;
}
if (x >= reco->info)
{
reco->sig = nuevo;
}
else
{
nuevo->sig = reco;
atras->sig = nuevo;
}
}
}
}
void ListaGenericaOrdenada::imprimir()
{
Nodo *reco = raiz;
{
reco = reco->sig;
}
cout << "\n";
}
int main()
{
ListaGenericaOrdenada *lista = new ListaGenericaOrdenada();
lista->insertar(10);
lista->insertar(5);
lista->insertar(7);
lista->insertar(50);
lista->imprimir();
delete lista;
return 0;
}
Ejercicio42
#include <iostream>
class ListaGenericaDoble {
private:
class Nodo {
public:
int info;
Nodo *sig;
Nodo *ant;
};
Nodo *raiz;
public:
ListaGenericaDoble();
~ListaGenericaDoble();
int cantidad();
void insertar(int pos, int x);
int extraer(int pos);
void intercambiar(int pos1, int pos2);
bool vacia();
int mayor();
void imprimir();
int posMayor();
bool ordenada();
bool existe(int x);
};
ListaGenericaDoble::ListaGenericaDoble()
{
raiz = NULL;
}
ListaGenericaDoble::~ListaGenericaDoble()
{
Nodo *reco = raiz;
Nodo *bor;
{
bor = reco;
reco = reco->sig;
delete bor;
}
}
int ListaGenericaDoble::cantidad()
{
Nodo *reco = raiz;
int cant = 0;
{
cant++;
reco = reco->sig;
}
return cant;
}
void ListaGenericaDoble::insertar(int pos, int x)

{
if (pos <= cantidad() + 1)
{
nuevo->info = x;
if (pos == 1)
{
nuevo->sig = raiz;
if (raiz != NULL)
raiz->ant = nuevo;
raiz = nuevo;
}
else
if (pos == cantidad() + 1)
{
Nodo *reco = raiz;
while (reco->sig != NULL)
{
reco = reco->sig;
}
reco->sig = nuevo;
nuevo->ant = reco;
nuevo->sig = NULL;
}
else
{
Nodo *reco = raiz;
for (int f = 1; f <= pos - 2; f++)
reco = reco->sig;
Nodo *siguiente = reco->sig;
reco->sig = nuevo;
nuevo->ant = reco;
nuevo->sig = siguiente;
siguiente->ant = nuevo;
}
}
}
int ListaGenericaDoble::extraer(int pos)

{
{
int informacion;
Nodo *bor;
if (pos == 1)
{
informacion = raiz->info;
bor = raiz;
raiz = raiz->sig;
if ((raiz != NULL))
raiz->ant = NULL;
}
else
{
Nodo *reco;
reco = raiz;
for (int f = 1; f <= pos - 2; f++)
reco = reco->sig;
bor = prox;
Nodo *siguiente = prox->sig;
if (siguiente != NULL)
siguiente->ant = reco;
informacion = prox->info;
}
delete bor;
return informacion;
}
else
return -1;
}
void ListaGenericaDoble::borrar(int pos)

{
{
Nodo *bor;
if (pos == 1)
{
bor = raiz;
raiz = raiz->sig;
if (raiz != NULL)
raiz->ant = NULL;
}
else
{
Nodo *reco;
reco = raiz;
for (int f = 1; f <= pos - 2; f++)
reco = reco->sig;
bor = prox;
Nodo *siguiente = prox->sig;
if (siguiente != NULL)
siguiente->ant = reco;
}
delete bor;
}
}
void ListaGenericaDoble::intercambiar(int pos1, int pos2)

{
if (pos1 <= cantidad() && pos2 <= cantidad())
{
Nodo *reco1 = raiz;
{
reco1 = reco1->sig;
}
Nodo *reco2 = raiz;
{
reco2 = reco2->sig;
}
int aux = reco1->info;
reco1->info = reco2->info;
reco2->info = aux;
}
}
bool ListaGenericaDoble::vacia()
{
if (raiz == NULL)
return true;
else
return false;
}
int ListaGenericaDoble::mayor()
{
if (!vacia())
{
{
{
may = reco->info;
}
reco = reco->sig;
}
return may;
}
else
return -1;
}
void ListaGenericaDoble::imprimir()
{
Nodo *reco = raiz;
{
reco = reco->sig;
}
cout << "\n";
}
int ListaGenericaDoble::posMayor()
{
if (!vacia())
{
int x = 1;
int pos = x;
{
{
may = reco->info;
pos = x;
}
reco = reco->sig;
x++;
}
return pos;
}
else
return -1;
}
bool ListaGenericaDoble::ordenada()
{
if (cantidad()>1)
{
Nodo *reco1 = raiz;
Nodo *reco2 = raiz->sig;
while (reco2 != NULL)
{
if (reco2->info<reco1->info)
{
return false;
}
reco2 = reco2->sig;
reco1 = reco1->sig;
}
}
return true;
}
bool ListaGenericaDoble::existe(int x)
{
Nodo *reco = raiz;
{
if (reco->info == x)
return true;
reco = reco->sig;
}
return false;
}
int main()
{
ListaGenericaDoble *lg = new ListaGenericaDoble();
lg->imprimir();
cout << "Luego de Borrar el primero\n";
lg->borrar(1);
lg->imprimir();
cout << "Luego de Extraer el segundo\n";
lg->extraer(2);
lg->imprimir();
cout << "Luego de Intercambiar el primero con el tercero\n";
lg->intercambiar(1, 3);
lg->imprimir();
if (lg->existe(20))
cout << "Se encuentra el 20 en la lista\n";
else
cout << "No se encuentra el 20 en la lista\n";
cout << "La posición del mayor es:" << lg->posMayor() << "\n";
if (lg->ordenada())
cout << "La lista esta ordenada de menor a mayor\n";
else
cout << "La lista no esta ordenada de menor a mayor\n";
delete lg;
return 0;
}
Ejercicio43
#include <iostream>
class ListaCircular {
private:
class Nodo {
public:
int info;
Nodo *sig;
Nodo *ant;
};
Nodo *raiz;
public:
ListaCircular();
~ListaCircular();
void insertarPrimero(int x);
void insertarUltimo(int x);
bool vacia();
void imprimir();
int cantidad();
};
ListaCircular::ListaCircular()
{
raiz = NULL;
}
ListaCircular::~ListaCircular()
{
if (raiz != NULL) {
Nodo *bor;
while (reco != raiz)
{
bor = reco;
reco = reco->sig;
delete bor;
}
delete raiz;
}
}
void ListaCircular::insertarPrimero(int x)
{
nuevo->info = x;
if (raiz == NULL)
{
nuevo->sig = nuevo;
nuevo->ant = nuevo;
raiz = nuevo;
}
else
{
Nodo *ultimo = raiz->ant;
nuevo->sig = raiz;
nuevo->ant = ultimo;
raiz->ant = nuevo;
ultimo->sig = nuevo;
raiz = nuevo;
}
}
void ListaCircular::insertarUltimo(int x)
{
nuevo->info = x;
if (raiz == NULL)
{
nuevo->sig = nuevo;
nuevo->ant = nuevo;
raiz = nuevo;
}
else
{
nuevo->sig = raiz;
nuevo->ant = ultimo;
raiz->ant = nuevo;
ultimo->sig = nuevo;
}
}
bool ListaCircular::vacia()
{
if (raiz == NULL)
return true;
else
return false;
}
void ListaCircular::imprimir()
{
if (!vacia()) {
Nodo *reco = raiz;
do {
cout<<reco->info <<"-";
reco = reco->sig;
} while (reco != raiz);
cout << "\n";
}
}
int ListaCircular::cantidad()
{
int cant = 0;
if (!vacia())
{
Nodo *reco = raiz;
do {
cant++;
reco = reco->sig;
} while (reco != raiz);
}
return cant;
}
void ListaCircular::borrar(int pos)

{
{
if (pos == 1)
{
if (cantidad() == 1)
{
delete raiz;
raiz = NULL;
}
else
{
Nodo *bor = raiz;
raiz = raiz->sig;
ultimo->sig = raiz;
raiz->ant = ultimo;
delete bor;
}
}
else {
Nodo *reco = raiz;
for (int f = 1; f <= pos - 1; f++)
reco = reco->sig;
Nodo *bor = reco;
Nodo *anterior = reco->ant;
reco = reco->sig;
anterior->sig = reco;
reco->ant = anterior;
delete bor;
}
}
}
int main()
{
ListaCircular *lc = new ListaCircular();
lc->insertarPrimero(100);
cout <<"Luego de insertar 4 nodos al principio\n";
lc->imprimir();
lc->insertarUltimo(250);
lc->insertarUltimo(7);
cout<<"Luego de insertar 2 nodos al final\n";
lc->imprimir();
cout<<"Cantidad de nodos:" <<lc->cantidad() <<"\n";
cout <<"Luego de borrar el de la primer posición:\n";
lc->borrar(1);
lc->imprimir();
cout << "Luego de borrar el de la cuarta posición:\n";
lc->borrar(4);
lc->imprimir();
delete lc;
return 0;
}
Ejercicio44
#include <iostream>
class Recursividad {
public:
void repetir();
};
void Recursividad::repetir()
{
repetir();
}
int main()
{
Recursividad *recu = new Recursividad();
recu->repetir();
delete recu;
return 0;
}
#include <iostream>
public:
void imprimir(int x);
};
void Recursividad::imprimir(int x)
{
cout<<x<<"-";
imprimir(x - 1);
}
int main()
{
recu->imprimir(5);
delete recu;
return 0;
}
#include <iostream>
public:
};
{
if (x > 0)
{
cout << x << "-";
imprimir(x - 1);
}
}
int main()
{
recu->imprimir(5);
delete recu;
return 0;
}
#include <iostream>
public:
};
{
if (x > 0)
{
imprimir(x - 1);
cout << x << "-";
}
}
int main()
{
recu->imprimir(5);
delete recu;
return 0;
}
#include<iostream>
public:
int factorial(int fact);
};
int Recursividad::factorial(int fact)

{
if (fact>0) {
int valor = fact * factorial(fact - 1);
return valor;
}
else
return 1;
}
int main()
{
cout << "El factorial de 4 es " << recu->factorial(4);
delete recu;
return 0;
}
#include<iostream>
int vec[5];
void ordenar(int cant);
public:
void cargar();
void ordenar();
void imprimir();
};
void Recursividad::cargar()
{
for (int f = 0; f < 5; f++)
{
cin >> vec[f];
}
}
void Recursividad::ordenar(int cant)

{
if (cant > 1)
{
for (int f = 0; f < cant - 1; f++)
{
if (vec[f] > vec[f + 1])
{
int aux = vec[f];
vec[f] = vec[f + 1];
vec[f + 1] = aux;
}
}
ordenar(cant - 1);
}
}
void Recursividad::ordenar()
{
ordenar(5);
}
void Recursividad::imprimir()
{
for (int f = 0; f < 5; f++)
{
cout << vec[f] << "-";
}
}
int main()
{
recu->cargar();
recu->ordenar();
recu->imprimir();
delete recu;
return 0;
}
Ejercicio45
#include <iostream>
class Nodo {
public:
int info;
Nodo *sig;
};
Nodo *raiz;
void imprimir(Nodo *reco);
public:
ListaGenerica();
~ListaGenerica();
void imprimir();
};
{
raiz = NULL;
}
{
Nodo *reco = raiz;
Nodo *bor;
{
bor = reco;
reco = reco->sig;
delete bor;
}
}
void ListaGenerica::insertarPrimero(int x)
{
nuevo->info = x;
nuevo->sig = raiz;
raiz = nuevo;
}
{
imprimir(raiz);
}
void ListaGenerica::imprimir(Nodo *reco)

{
if (reco != NULL)
{
imprimir(reco->sig);
cout<<reco->info << "-";
}
}
int main()
{
ListaGenerica *lg = new ListaGenerica();
lg->insertarPrimero(10);
lg->imprimir();
delete lg;
return 0;
}
Ejercicio48
#include <iostream>
class ArbolBinario {
private:
class Nodo {
public:
int info;
Nodo *izq;
Nodo *der;
};
Nodo *raiz;
void borrar(Nodo *reco);
void imprimirPre(Nodo *reco);
void imprimirEntre(Nodo *reco);
void imprimirPost(Nodo *reco);
public:
ArbolBinario();
~ArbolBinario();
void imprimirPre();
void imprimirEntre();
void imprimirPost();
};
ArbolBinario::ArbolBinario()
{
raiz = NULL;
}
ArbolBinario::~ArbolBinario()
{
borrar(raiz);
}
void ArbolBinario::borrar(Nodo *reco)

{
if (reco != NULL)
{
borrar(reco->izq);
borrar(reco->der);
delete reco;
}
}
void ArbolBinario::insertar(int x)
{
Nodo *nuevo;
nuevo = new Nodo();
nuevo->info = x;
nuevo->izq = NULL;
nuevo->der = NULL;
if (raiz == NULL)
raiz = nuevo;
else
{
Nodo *anterior, *reco;
anterior = NULL;
reco = raiz;
{
anterior = reco;
if (x < reco->info)
reco = reco->izq;
else
reco = reco->der;
}
if (x < anterior->info)
anterior->izq = nuevo;
else
anterior->der = nuevo;
}
}
void ArbolBinario::imprimirPre()
{
imprimirPre(raiz);
cout << "\n";
}
void ArbolBinario::imprimirPre(Nodo *reco)

{
if (reco != NULL)
{
imprimirPre(reco->izq);
imprimirPre(reco->der);
}
}
void ArbolBinario::imprimirEntre()
{
imprimirEntre(raiz);
cout << "\n";
}
void ArbolBinario::imprimirEntre(Nodo *reco)

{
if (reco != NULL)
{
imprimirEntre(reco->izq);
imprimirEntre(reco->der);
}
}
void ArbolBinario::imprimirPost()
{
imprimirPost(raiz);
cout << "\n";
}
void ArbolBinario::imprimirPost(Nodo *reco)

{
if (reco != NULL)
{
imprimirPost(reco->izq);
imprimirPost(reco->der);
}
}
int main()
{
ArbolBinario *arbol = new ArbolBinario();
arbol->insertar(100);
cout<<"Impresion preorden: ";
arbol->imprimirPre();
cout<<"Impresion entreorden: ";
arbol->imprimirEntre();
cout<<"Impresion postorden: ";
arbol->imprimirPost();
delete arbol;
return 0;
}
Ejercicio49
#include <iostream>
class ArbolBinario {
private:
class Nodo {
public:
int info;
Nodo *izq;
Nodo *der;
};
Nodo *raiz;
int cant;
int altura;
void borrar(Nodo *reco);
void imprimirEntre(Nodo *reco);
void cantidad(Nodo *reco);
void cantidadNodosHoja(Nodo *reco);
void imprimirEntreConNivel(Nodo *reco, int nivel);
void retornarAltura(Nodo *reco, int nivel);
public:
ArbolBinario();
~ArbolBinario();
bool existe(int x);
void imprimirEntre();
int cantidad();
int cantidadNodosHoja();
void imprimirEntreConNivel();
int retornarAltura();
void mayorValor();
void borrarMenor();
};
ArbolBinario::ArbolBinario()
{
raiz = NULL;
}
ArbolBinario::~ArbolBinario()
{
borrar(raiz);
}
void ArbolBinario::borrar(Nodo *reco)

{
if (reco != NULL)
{
borrar(reco->izq);
borrar(reco->der);
delete reco;
}
}
void ArbolBinario::insertar(int x)
{
if (!existe(x))
{
Nodo *nuevo;
nuevo = new Nodo();
nuevo->info = x;
nuevo->izq = NULL;
nuevo->der = NULL;
if (raiz == NULL)
raiz = nuevo;
else
{
Nodo *anterior, *reco;
anterior = NULL;
reco = raiz;
{
anterior = reco;
if (x < reco->info)
reco = reco->izq;
else
reco = reco->der;
}
if (x < anterior->info)
anterior->izq = nuevo;
else
anterior->der = nuevo;
}
}
}
bool ArbolBinario::existe(int x)
{
Nodo *reco = raiz;
{
if (x == reco->info)
return true;
else
if (x>reco->info)
reco = reco->der;
else
reco = reco->izq;
}
return false;
}
int ArbolBinario::cantidad()
{
cant = 0;
cantidad(raiz);
return cant;
}
void ArbolBinario::cantidad(Nodo *reco)
{
if (reco != NULL)
{
cant++;
cantidad(reco->izq);
cantidad(reco->der);
}
}
int ArbolBinario::cantidadNodosHoja()
{
cant = 0;
cantidadNodosHoja(raiz);
return cant;
}
void ArbolBinario::cantidadNodosHoja(Nodo *reco)

{
if (reco != NULL) {
if (reco->izq == NULL && reco->der == NULL)
cant++;
cantidadNodosHoja(reco->izq);
cantidadNodosHoja(reco->der);
}
}
void ArbolBinario::imprimirEntreConNivel()
{
imprimirEntreConNivel(raiz, 1);
cout << "\n";
}
void ArbolBinario::imprimirEntreConNivel(Nodo *reco, int nivel)

{
if (reco != NULL) {
imprimirEntreConNivel(reco->izq, nivel + 1);
cout<<reco->info <<"(" <<nivel <<") - ";
imprimirEntreConNivel(reco->der, nivel + 1);
}
}
int ArbolBinario::retornarAltura()
{
altura = 0;
retornarAltura(raiz, 1);
return altura;
}
void ArbolBinario::retornarAltura(Nodo *reco, int nivel)

{
if (reco != NULL)
{
retornarAltura(reco->izq, nivel + 1);
if (nivel>altura)
altura = nivel;
retornarAltura(reco->der, nivel + 1);
}
}
void ArbolBinario::mayorValor()
{
if (raiz != NULL)
{
Nodo *reco = raiz;
while (reco->der != NULL)
reco = reco->der;
cout<<"Mayor valor del árbol:" <<reco->info;
}
}
void ArbolBinario::borrarMenor()
{
if (raiz != NULL) {
Nodo *bor;
if (raiz->izq == NULL)
{
bor = raiz;
raiz = raiz->der;
delete bor;
}
else {
Nodo *atras = raiz;
Nodo *reco = raiz->izq;
while (reco->izq != NULL)
{
atras = reco;
reco = reco->izq;
}
atras->izq = reco->der;
delete reco;
}
}
}
void ArbolBinario::imprimirEntre()
{
imprimirEntre(raiz);
cout << "\n";
}
void ArbolBinario::imprimirEntre(Nodo *reco)

{
if (reco != NULL)
{
imprimirEntre(reco->izq);
imprimirEntre(reco->der);
}
}
int main()
{
ArbolBinario *arbol1 = new ArbolBinario();
arbol1->insertar(100);
cout<<"Impresion entreorden: ";
arbol1->imprimirEntre();
cout<<"Cantidad de nodos del árbol:" <<arbol1->cantidad() <<"\n";
cout<<"Cantidad de nodos hoja:" <<arbol1-
>cantidadNodosHoja()<<"\n";
cout<<"Impresion en entre orden junto al nivel del nodo:";
arbol1->imprimirEntreConNivel();
cout<<"Artura del arbol:";
cout << arbol1->retornarAltura();
cout << "\n";
arbol1->mayorValor();
cout << "\n";
arbol1->borrarMenor();
cout<<"Luego de borrar el menor:";
arbol1->imprimirEntre();
delete arbol1;
return 0;
}
Ejercicio49
#include<iostream>
class Temperatura {
int minima;
int maxima;
int actual;
public:
Temperatura(int min, int max, int act);
int rango()
{
int valor = maxima - minima;
return valor;
}
void imprimir();
};
Temperatura::Temperatura(int min, int max, int act)

{
minima = min;
maxima = max;
actual = act;
}
void Temperatura::imprimir()
{
cout << "Minima:" << minima << "\n";
cout << "Maxima:" << maxima << "\n";
cout << "Actual:" << actual << "\n";
}
int main()
{
Temperatura temperatura1(5,25,17);
cout << "Rango de variacion de temperaturas:" <<
temperatura1.rango()<<"\n\n";
temperatura1.imprimir();
return 0;
}
Ejercicio50
#include<iostream>
class Temperatura {
int minima, maxima, actual;
public:
Temperatura(int min, int max, int act){ minima = min; maxima =
max; actual = act; }
friend int temperaturaMedia(Temperatura t1, Temperatura t2);
};
int temperaturaMedia(Temperatura t1, Temperatura t2)

{
int pro =(t1.actual + t2.actual)/2;
return pro;
}
int main()
{
Temperatura temperatura1(10, 20, 15);
cout << "La temperatura promedio de las temperaturas actuales es:";
cout << temperaturaMedia(temperatura1, temperatura2);
return 0;
}
Ejercicio51
#include<iostream>
class Nodo {
int info;
Nodo *ant, *sig;
public:
Nodo(int x){ info = x; };
friend class ListaGenerica;
};
Nodo *raiz;
public:
ListaGenerica() { raiz = NULL; };
~ListaGenerica();
void imprimir();
};
{
Nodo *reco = raiz;
Nodo *bor;
{
bor = reco;
reco = reco->sig;
delete bor;
}
}
{
Nodo *nuevo = new Nodo(x);
nuevo->ant = NULL;
if (raiz == NULL)
{
nuevo->sig = NULL;
raiz = nuevo;
}
else
{
nuevo->sig = raiz;
raiz->ant = raiz;
raiz = nuevo;
}
}
{
Nodo *reco = raiz;
{
reco = reco->sig;
}
cout << "\n";
}
int main()
{
ListaGenerica *lista1 = new ListaGenerica();
lista1->insertarPrimero(10);
lista1->imprimir();
delete lista1;
return 0;
}
Ejercicio52
#include<iostream>
class Prueba {
int x1;
static int x2;
public:
Prueba(int v1, int v2) { x1 = v1; x2 = v2; };
void imprimir();
};
int Prueba::x2;
void Prueba::imprimir()
{
cout << x1 << "-" << x2 << "\n";
}
int main()
{
Prueba prueba1(1, 1);
prueba1.imprimir(); // 1 1
Prueba prueba2(20, 20);
prueba1.imprimir(); // 1 20
return 0;
}
#include<iostream>
class Cuenta {
float saldo;
static int cantidad;
public:
Cuenta(float sal) { saldo = sal; cantidad++; };
int retornarCantidad() { return cantidad; };
};
int Cuenta::cantidad = 0;
class Banco {
Cuenta *cuenta1, *cuenta2, *cuenta3;
public:
Banco();
~Banco();
void cantidadClientes();
};
Banco::Banco()
{
cuenta1 = new Cuenta(1000);
}
Banco::~Banco()
{
delete cuenta1;
delete cuenta2;
delete cuenta3;
}
void Banco::cantidadClientes()
{
cout << cuenta1->retornarCantidad();
}
int main()
{
Banco *banco1 = new Banco();
banco1->cantidadClientes();
delete banco1;
return 0;
}
Ejercicio53
#include<iostream>
class Prueba {
static int x1;
public:
static int retornarX();
};
int Prueba::x1 = 20;
int Prueba::retornarX()
{
return x1;
}
int main()
{
cout << Prueba::retornarX(); // 20
return 0;
}
#include<iostream>
class Cuenta {
float saldo;
static int cantidad;
public:
Cuenta(float sal) { saldo = sal; cantidad++; };
static int retornarCantidad() { return cantidad; };
};
int Cuenta::cantidad = 0;
class Banco {
Cuenta *cuenta1, *cuenta2, *cuenta3;
public:
Banco();
~Banco();
void cantidadClientes();
};
Banco::Banco()
{
}
Banco::~Banco()
{
delete cuenta1;
delete cuenta2;
delete cuenta3;
}
void Banco::cantidadClientes()
{
cout << Cuenta::retornarCantidad();
}
int main()
{
Banco *banco1 = new Banco();
banco1->cantidadClientes();
delete banco1;
return 0;
}
Ejercicio54
#include<iostream>
class Temperatura {
int minima;
int maxima;
int actual;
void imprimir();
public:
Temperatura(int min, int max, int actual);
};
Temperatura::Temperatura(int min, int max, int act)

{
this->minima = min;
this->maxima = max;
this->actual = act;
this->imprimir();
}
{
cout << this->minima << " " << this->actual << " " << this->maxima
<< "\n";
}
int main()
{
return 0;
}
#include<iostream>
class Temperatura {
int minima;
int maxima;
int actual;
void imprimir();
public:
Temperatura(int min, int max, int actual);
};
Temperatura::Temperatura(int minima, int maxima, int actual)

{
this->minima = minima;
this->maxima = maxima;
this->actual = actual;
imprimir();
}
{
cout << minima << " " << actual << " " << maxima << "\n";
}
int main()
{
return 0;
}
Ejercicio55
#include<iostream>
#define TAMANO 5
#define MENSAJEFIN "Presione una tecla para finalizar\n"
#define DETENER cin.get();cin.get();
int main()
{
int vec[TAMANO];
for(int f=0;f<TAMANO;f++)
{
cin >>vec[f];
}
for(int f=0;f<TAMANO;f++)
{
cout << vec[f] << "-";
}
cout <<"\n";
cout <<MENSAJEFIN;
DETENER
return 0;
}
Ejercicio56
#include<iostream>
const int inicio=1;

const float altura=1.92f;
const char mensaje1[]="Bienvenido al programa";
int main()
{
cout << "Constante entera:" << inicio << "\n";
cout << "Constante flotante:" << altura << "\n";
cout << "Constante de tipo cadena de caracteres:" << mensaje1 << "\
n";
const int fin=10;
cout << "Constante local:" << fin;
return 0;
}
#include<iostream>
class Vector {
static const int tamano=5;
int vec[tamano];
public:
void cargar();
void imprimir();
};
{
{
cout << "Ingrese elemento:";
cin >> vec[f];
}
}
{
{
cout << vec[f] << "-";
}
}
int main()
{
Vector vec1;
vec1.cargar();
vec1.imprimir();
return 0;
}
#include<iostream>
class Temperatura {
const int media;
int minima,maxima;
public:
Temperatura(int min,int max,int me);
void imprimir();
};
Temperatura::Temperatura(int min,int max,int me):media(me)

{
minima=min;
maxima=max;
}
{
cout <<minima <<" " <<maxima <<" " << media << "\n";
}
int main()
{
Temperatura t1(10,20,14);
t1.imprimir();
Temperatura t2(5,9,7);
t2.imprimir();
return 0;
}
Ejercicio57
#include <iostream>
private:
class Nodo {
public:
int info;
Nodo *sig;
};
Nodo *raiz;
public:
ListaGenerica();
~ListaGenerica();
void imprimir();
bool iguales(const ListaGenerica *lista2);
};
{
raiz = NULL;
}
{
Nodo *reco = raiz;
Nodo *bor;
{
bor = reco;
reco = reco->sig;
delete bor;
}
}
{
nuevo->info = x;
nuevo->sig = raiz;
raiz = nuevo;
}
{
Nodo *reco = raiz;
{
reco = reco->sig;
}
cout << "\n";
}
bool ListaGenerica::iguales(const ListaGenerica *lista2)

{
bool iguales = true;
Nodo *reco1 = raiz;
Nodo *reco2 = lista2->raiz;
while (reco1 != NULL && reco2 != NULL)
{
if (reco1->info != reco2->info)
{
iguales = false;
break; //salimos del while
}
reco1 = reco1->sig;
reco2 = reco2->sig;
}
if (iguales == true && reco1 == NULL && reco2 == NULL)
return true;
else
return false;
}
int main()
{
ListaGenerica *lg1 = new ListaGenerica();
lg1->insertarPrimero(10);
lg1->imprimir();

lg2->imprimir();
if (lg1->iguales(lg2))
cout << "Las dos listas son iguales\n";
else
cout << "Las dos listas no son iguales\n";
delete lg1;
delete lg2;
return 0;
}
Ejercicio58
#include <iostream>
private:
class Nodo {
public:
int info;
Nodo *sig;
};
Nodo *raiz;
public:
ListaGenerica();
~ListaGenerica();
void imprimir() const;
bool iguales(const ListaGenerica *lista2) const;
};
{
raiz = NULL;
}
{
Nodo *reco = raiz;
Nodo *bor;
{
bor = reco;
reco = reco->sig;
delete bor;
}
}
{
nuevo->info = x;
nuevo->sig = raiz;
raiz = nuevo;
}
void ListaGenerica::imprimir() const

{
Nodo *reco = raiz;
{
reco = reco->sig;
}
cout << "\n";
}
bool ListaGenerica::iguales(const ListaGenerica *lista2) const

{
bool iguales = true;
Nodo *reco1 = raiz;
Nodo *reco2 = lista2->raiz;
while (reco1 != NULL && reco2 != NULL)
{
if (reco1->info != reco2->info)
{
iguales = false;
break; //salimos del while
}
reco1 = reco1->sig;
reco2 = reco2->sig;
}
if (iguales == true && reco1 == NULL && reco2 == NULL)
return true;
else
return false;
}
int main()
{
lg1->imprimir();

lg2->imprimir();
if (lg1->iguales(lg2))
cout << "Las dos listas son iguales\n";
else
cout << "Las dos listas no son iguales\n";
delete lg1;
delete lg2;
return 0;
}
Ejercicio59
#include<iostream>
class Prueba {
public:
void cambiar1(int z);
void cambiar2(int &z);
};
void Prueba::cambiar1(int z)
{
z = 0;
}
void Prueba::cambiar2(int &z)

{
z = 0;
}
int main()
{
Prueba prueba1;
int num = 10;
cout << "Valor de la variable num:" << num << "\n";
prueba1.cambiar1(num);
cout << "Valor de la variable num luego de enviarla por valor:" <<
num << "\n";
prueba1.cambiar2(num);
cout << "Valor de la variable num luego de enviarla por referencia:"
<< num << "\n";
return 0;
}
#include <iostream>
class Vector {
int vec[5];
public:
void cargar();
void imprimir();
void mayorMenor(int &may, int &men);
};
{
for (int f = 0; f < 5; f++)
{
cout << "Ingrese elemento:";
cin >> vec[f];
}
}
{
for (int f = 0; f < 5; f++)
{
cout << vec[f] << "-";
}
cout << "\n";
}
void Vector::mayorMenor(int &may, int &men)

{
may = vec[0];
men = vec[0];
for (int f = 1; f < 5; f++)
{
if (vec[f]>may)
may = vec[f];
else
if (vec[f] < men)
men = vec[f];
}
}
int main()
{
Vector vector1;
vector1.cargar();
vector1.imprimir();
int mayor, menor;
vector1.mayorMenor(mayor, menor);
cout << "Mayor elemento del vector:" << mayor << "\n";
cout << "Menor elemento del vector:" << menor << "\n";
return 0;
}
Ejercicio60
#include<iostream>
class Reloj {
int hora;
int minuto;
int segundo;
public:
Reloj(int hora, int minuto, int segundo) { this->hora = hora; this-
>minuto = minuto; this->segundo = segundo; };
void imprimir();
void intentoCambiar(Reloj r);
};
void Reloj::imprimir()
{
cout << hora << ":" << minuto << ":" << segundo << "\n";
}
void Reloj::intentoCambiar(Reloj r)
{
r.hora = 1;
r.minuto = 0;
r.segundo = 0;
}
int main()
{
Reloj reloj1(10, 10, 10);
reloj1.intentoCambiar(reloj2);
reloj1.imprimir(); // imprime: 10:10:10
return 0;
}
#include<iostream>
class Reloj {
int hora;
int minuto;
int segundo;
public:
Reloj(int hora, int minuto, int segundo) { this->hora = hora; this-
>minuto = minuto; this->segundo = segundo; };
void imprimir();
void intentoCambiar(Reloj &r);
};
void Reloj::imprimir()
{
cout << hora << ":" << minuto << ":" << segundo << "\n";
}
void Reloj::intentoCambiar(Reloj &r)

{
r.hora = 1;
r.minuto = 0;
r.segundo = 0;
}
int main()
{
reloj1.intentoCambiar(reloj2);
return 0;
}
Ejercicio61
#include<string>
#include<iostream>
int main()
{
string cadena1 = "Hola mundo";
string cadena2;
cout << "Ingrese una cadena de caracteres sin espacios en blanco:";
cin >> cadena2;
cin.get();
cout << "Primer string:" << cadena1 << "\n";
cout << "Segundo string:" << cadena2;
return 0;
}
#include<string>
#include<iostream>
int main()
{
string cadena1 = "Hola mundo";
string cadena2;
cout << "Ingrese una cadena de caracteres:";
getline(cin, cadena2);
cout << "Primer string:" << cadena1 << "\n";
cout << "Segundo string:" << cadena2;
return 0;
}
#include<string>
#include<iostream>
int main()
{
string s1;
string s2;
cout << "Primer cadena:";
getline(cin, s1);
cout << "Segundo cadena:";
getline(cin, s2);
if (s1>s2)
{
cout << s1 << " es el mayor alfabeticamente.";
}
else
{
if (s2>s1)
{
cout << s2 << " es el mayor alfabeticamente";
}
else
{
cout << "Se cargaron dos cadenas iguales";
}
}
return 0;
}
#include<string>
#include<iostream>
int main()
{
string s1;
string s2;
cout << "Primer cadena:";
getline(cin, s1);
cout << "Segundo cadena:";
getline(cin, s2);
string s3 = s1 + "-" + s2;
cout << "string que resulta de la concatenacion de los dos anteriores:"
<< s3;
return 0;
}
#include<string>
#include<iostream>
int main()
{
string cadena1 = "Hola";
cout << cadena1[0];
cout << "\n";
cout << cadena1[3];
return 0;
}
Ejercicio62
#include<string>
#include<iostream>
int main()
{
string cadena1 = "Hola";
cout << "cadena:" << cadena1;
cout << "\n";
cout << cadena1.size();
cout << "\n";
cout << cadena1.length();
return 0;
}
#include<string>
#include<iostream>
int main()
{
string cadena;
cout << "Ingrese una cadena:";
getline(cin, cadena);
if (cadena.empty())
{
cout << "No se ingresaron caracteres por teclado.";
}
else
{
cout << "La cadena tiene una longitud de:" << cadena.length();
}
return 0;
}
#include<string>
#include<iostream>
int main()
{
string cadena;
cout << "Ingrese un palabra:";
getline(cin, cadena);
for (int f = 0; f < cadena.length(); f++)
{
cout << cadena.at(f)<<"-";
}
return 0;
}
Ejercicio63
#include<iostream>
#include<string>
int main()
{
string cad = "uno tres";
cout << "Cadena original:" << cad << "\n";
cad.append(" cuatro");
cout << "Cadena despues de llamar a append:" << cad << "\n";
cad.insert(3, " dos");
cout << "Cadena despues de llamar a insert:" << cad << "\n";
cad.erase(0, 4);
cout << "Cadena despues de llamar a erase:" << cad << "\n";
return 0;
}

Extraordinaria Progra

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Extraordinaria Progra

Cargado por

Copyright:

Formatos disponibles

EJEMPLO 1

La actividad fundamental del programador es resolver problemas empleando el ordenador

Para la resolución de un problema hay que plantear un algoritmo.

Algoritmo: Son los pasos a seguir para resolver un problema.

Un diagrama de flujo es la representación gráfica de un ALGORITMO.

Los símbolos gráficos a utilizar para el planteo de diagramas de flujo

Horas trabajadas en el mes.

Pago por hora.

APLICACIÓN PARA PROGRAMACION

Cuando procedamos a instalar debemos seleccionar como mínimo "Desarrollo para el

Variable: Es un depósito donde hay un valor. Consta de un nombre y pertenece a un tipo.

Para el ejemplo planteado la variable horasTrabajadas almacena la cantidad de horas

1 - Ingresemos al "Microsoft Studio Community 2019

Acotaciones : con Visual Studio .Net 2017

using namespace std;

cout <<"Ingrese Horas trabajadas por el operario:";

cout <<"Ingrese el pago por hora:";

sueldo = horasTrabajadas * costoHora;

cout <<"El sueldo total del operario es:";

using namespace std;

cout <<"Ingrese Horas trabajadas por el operario:";

cout <<"Ingrese el pago por hora:";

sueldo = horasTrabajadas * costoHora;

cout <<"El sueldo total del operario es:";

using namespace std;

cout <<"Ingrese el valor del lado del cuadrado:";

superficie = lado * lado;

cout <<"La superficie del cuadrado es:";

using namespace std;

cout <<"Ingrese el valor del lado del cuadrado:";

superficie = lado * lado * lado;

cout <<"La superficie del cuadrado es:";

#include<iostream> diagrama de flujo

using namespace std;

int num1, num2, suma, producto;

cout <<"Ingrese primer valor:";

cout <<"Ingrese segundo valor:";

suma = num1 + num2;

producto = num1 * num2;

cout <<"La suma de los dos valores es:";

cout <<"El producto de los dos valores es:";

Estructura condicional simple Diagrama de flujo

using namespace std;

cout <<"Ingrese el sueldo:";

cout <<"Esta persona debe abonar impuestos";

using namespace std;

int num1, num2;

cout <<"Ingrese primer valor:";

cout <<"Ingrese segundo valor:";

if (num1 > num2)

using namespace std;

cout <<"Ingrese primer nota:";

cout <<"Ingrese segunda nota:";

cout <<"Ingrese tercer nota:";

int promedio=(nota1 + nota2 + nota3) / 3;

using namespace std;

cout <<"Ingrese primer valor:";

cout <<"Ingrese segundo valor:";

cout <<"Ingrese tercer valor:";

if (num1 > num2 && num1 > num3)

if (num2 > num3)

using namespace std;

cout <<"Ingrese nro de día:";

void Vector::retornarMayorMenor(int pmay, int pmen)