Resumen Teórico-Práctico Compu

“Este material fue hecho mientras cursaba la materia, por lo que puede
contener ciertos errores en los ejercicios, en la teoría, en la ortografía, entre

otros.”
Índice
Cuestionarios .............................................................................................................................................. 1
1° Cuestionario del AV ............................................................................................................................. 1
Parte teorica ........................................................................................................................................ 1
Parte practica ...................................................................................................................................... 2
2° Cuestionario del AV (semana 4) .......................................................................................................... 3
Mini cuestionario semana 5 .................................................................................................................... 6
3° Cuestionario del AV (semana 7) .......................................................................................................... 7
Parte teorica ........................................................................................................................................ 7
Parte practica ...................................................................................................................................... 9
Mini cuestionario semana 8 ...................................................................................................................10
4° Cuestionario del AV (semana 9) .........................................................................................................11
Parte teórica .......................................................................................................................................11
Parte practica: ....................................................................................................................................12
5° Cuestionario del AV (semana 10) .......................................................................................................15
Parte teórica .......................................................................................................................................15
Mini cuestionario semana 11 .................................................................................................................18
6° Cuestonario del AV (semana 11) ........................................................................................................19
Parte teorica .......................................................................................................................................19
Parte practica .....................................................................................................................................21
Mini cuestionario semana 12 .................................................................................................................23
7° Cuestioario del AV (semana 12) .......................................................................................................... 2
Parte teorica ........................................................................................................................................ 2
Primer taller ................................................................................................................................................ 4
Parte teórica............................................................................................................................................ 4
Parte Practica .......................................................................................................................................... 6
TEMA 2 FILA 1 ...................................................................................................................................... 6
TEMA 2 FILA 2 ...................................................................................................................................... 8
TEMA 2 FILA 3 .....................................................................................................................................11
Segundo taller ............................................................................................................................................12
Parte práctica .........................................................................................................................................12
TEMA 2 FILA 2 .....................................................................................................................................12
Primer examen parcial 2022-1C .................................................................................................................15
Parte Teorica ..........................................................................................................................................15
TEMA 1 ...............................................................................................................................................15
Est. Janethe A. Olazar

Parte práctica .........................................................................................................................................19
TEMA 2 GRUPO 2 ................................................................................................................................19
Segundo examen parcial 2022-1C ..............................................................................................................21
Parte Teorica ..........................................................................................................................................21
TEMA 1 ...............................................................................................................................................21
Parte Practica .........................................................................................................................................28
TEMA 2 FILA 1 .....................................................................................................................................28
TEMA 2 FILA 2 .....................................................................................................................................30
Primer final 2022-1C...................................................................................................................................31
Parte teórica:..........................................................................................................................................31
TEMA 1 ...............................................................................................................................................31
Parte práctica: ........................................................................................................................................36
TEMA 2 ...............................................................................................................................................36
Segundo final 2022-1C................................................................................................................................37
Parte Practica: ........................................................................................................................................37
TEMA 2 ...............................................................................................................................................37
Unidad 1: Introducción a la programación .................................................................................................38
Algotimo.................................................................................................................................................38
Caracteristicas de un algoritmo ..........................................................................................................38
Lenguaje de programación .................................................................................................................38
Paradigmas de la proramación ...........................................................................................................39
Unidad 2: Introducción al Lenguaje C/C++ .................................................................................................40
Ventajas .................................................................................................................................................40
Lenguaje de alto rendimiento.............................................................................................................40
Tipos de datos basicos en C++ ................................................................................................................40
Variables ................................................................................................................................................40
Reglas para los identificadores ...............................................................................................................41
Asignacion ..............................................................................................................................................41
Datos ......................................................................................................................................................41
Variable booleana ..................................................................................................................................41
Función bool: ......................................................................................................................................41
Ejercicios propuestos para la introducción a C++ ...................................................................................42
Unidad 3: Estructuras de selección .............................................................................................................43
Expresionaes relacionales ......................................................................................................................44
Estructuras selectivas anidadas (o en cascada) ......................................................................................44
Expresiones logicas ................................................................................................................................44
Ejercicios propuestos sobre estructuras de selección .............................................................................46

Unidad 4: Estructuras cíclicas .....................................................................................................................53
I. While ..............................................................................................................................................53
¿Cómo funciona un Ciclo While? .........................................................................................................53
Sintaxis ...............................................................................................................................................54
II. Do While .........................................................................................................................................56
¿Cómo funciona un Ciclo Do-While? ...................................................................................................56
Sintaxis ...............................................................................................................................................57
III. For ..............................................................................................................................................59
¿Cómo funciona un ciclo For? .............................................................................................................59
Sintaxis ...............................................................................................................................................60
Ejercicios propuestos sobre estructuras repititivas ................................................................................61
Unidad 5: Funciones ...................................................................................................................................71
¿Qué es una función? .............................................................................................................................71
Definición de funciones ......................................................................................................................71
Ejemplos de funciones ........................................................................................................................71
Sintaxis general ..................................................................................................................................71
Números aleatorios ................................................................................................................................73
Funcion rand () ...................................................................................................................................73
Ejercicios propuestos sobre funciones y números aleatorios .................................................................75
Unidad 6: Recursividad ..............................................................................................................................94
Algoritmos recursivos .............................................................................................................................94
Llamada recursiva ..................................................................................................................................94
Ejercicios propuestos sobre la recursividad ............................................................................................98
Unidad 7: Arrays unidimensionales o Vectores ........................................................................................101
Pregunta 1: ¿Cómo podríamos ordenar N enteros utilizando variables simples? .................................101
Pregunta 2: ¿Cómo calcularías la cantidad de alumnos que obtuvieron una nota inferior al promedio
del curso en cierta materia? .................................................................................................................101
Estructura de datos ..........................................................................................................................101
Arreglos ................................................................................................................................................101
Ejemplos sobre arrays unidimensional .................................................................................................104
Ejercicios propuestos sobre arrays unidimensional ..............................................................................107
Unidad 8: Arrays multidimensionales <Matrices> ....................................................................................119
¿Para qué sirven un array bidimensional de números? ........................................................................119
Sintaxis .................................................................................................................................................120
Arrays multidimensionales: ..................................................................................................................120
Sintaxis .............................................................................................................................................120
Ejercicios propuestos sobre arrays unidimensional ..............................................................................125

Unidad 9: Métodos de ordenamiento ......................................................................................................132
Ejercicios propuestos sobre métodos de ordenación ...........................................................................143
Unidad 10: Punteros ................................................................................................................................154
Sintaxis .................................................................................................................................................154
Operaciones con puntero .....................................................................................................................154
Puntero y Arrays ..................................................................................................................................155
Ejercicios propuestos sobre punteros...................................................................................................159
Unidad 11: Cadenas .................................................................................................................................166
¿Cómo definimos una cadena?.............................................................................................................166
¿Cuál es la diferencia entre cadena y carácter? ....................................................................................166
¿Cómo ingresamos o imprimimos las cadenas? ...................................................................................166
Problemas con el “Salto” de cin.getline() .............................................................................................167
Uso de fflush() ..................................................................................................................................168
Funciones básicas para cadenas ...........................................................................................................168
I. Propia implementación de la función que cuenta la cantidad de elementos de una cadena ....169
II. Propia implementación de la función que copia de una cadena a otra .....................................169
III. Propia implementación de la concatenación de dos cadenas ...............................................169
IV. strcmp ...................................................................................................................................170
V. Propia implementacion de comparacion de cadenas ................................................................170
VI. atoi........................................................................................................................................171
VII. itoa........................................................................................................................................172
Ejercicios propuestos sobre cadenas ....................................................................................................173
Unidad 12: Estructuras .............................................................................................................................189
Sintaxis .................................................................................................................................................189
¿Cómo accedemos a los datos miembros? ...........................................................................................189
Struct anidadas ....................................................................................................................................189
Ejercicios propuestos sobre estructuras ...............................................................................................191
Ejercicios variados ....................................................................................................................................213
TAA’S........................................................................................................................................................223

P ágina |1
Cuestionarios
1° Cuestionario del AV
Parte teórica
1. Los lenguajes de programación se clasifican de forma general de acuerdo a:
- Nivel de abstracción y Forma de ejecución
2. ¿Cuál es la librería estándar de C++ que permite realizar operaciones estándar de entrada y salida
de datos?
- Iostream
3. ¿Cuál de las siguientes sentencias se utiliza para incluir la biblioteca stdlib en C++?
include<stdlib>
4. Selecciona el tamaño (en bytes) de los tipos de datos primitivos en el Lenguaje C++
- Char: 8
- Short: 16
- Double: 64
- Int: 32
- Float: 64
5. Tipos de datos enteros en Lenguaje C++
- Int
6. Definir una variable implica:
Ubicar en la memoria y reservar espacio para recibir valores.
7. Selecciona los identificadores correctos
- Tiempo_total
- Distancia1
- tiempo
8. ¿Cuál de las siguientes formas de declarar unas variables es correcta?
- int variable1=25
- int variable1
9. El operador "<=" significa menor o igual que y es un operador del tipo relacional.

2|P ági na
Parte practica
/* Que se tendrá como salida si se ingresa 4 como altura del trapecio*/

#include<iostream>
#define lado_mayor 20
#define lado_menor 10
using namespace std;
main()
{
float h, area;
cout<<"Ingrese la altura de un trapecio de lado_mayor = 20 y
lado menor= 10 \n";
cout<<"altura: "; cin>>h;
area= (1/2)*(lado_mayor + lado_menor)*h;
cout<<"El area es: "<<area<<endl;
}
= 60

P ágina |3
2° Cuestionario del AV (semana 4)
Respuesta incorrecta.
Lo que pasa es que la condición if (i==10) nunca se va a cumplir por consiguiente nunca a va a llegar
al break; y como la condición del while es un TRUE el bucle nunca dejara de ejecutarse, lo que tenemos ahí
es un bucle infinito.

4|P ági na
La afirmación falsa es que el aumento del paso se da antes de la iteración, eso es falso ya que al
inicializar el for no se da un aumento de la variable del paso, solo al final de cada iteración esa variable
aumenta o disminuye dependiendo de las necesidades del problema.

P ágina |5
La respuesta correcta es: La condición sólo se evalúa una vez al principio de la ejecución del bucle.
El bucle no se ejecuta ninguna vez porque la condición i>0 no se cumple desde un inicio, entonces el
for nunca pasa a ejecutarse y directo para a imprimirse la variable k.
La respuesta correcta es: 0

6|P ági na
Mini cuestionario semana 5

1. En C++, los parámetros siempre se pasan por:
- Por valor
Obs: los parámetros de la función siempre se pasan por valor. El paso por referencia se simula en C al pasar
explícitamente valores de puntero.
2. ¿Cuál de las siguientes afirmaciones es verdadera sobre el tipo de retorno de funciones en C++?
- Las funciones pueden devolver cualquier tipo excepto arrays y funciones.
- Las funciones pueden devolver cualquier tipo de variable.
- Las funciones pueden devolver cualquier tipo, excepto arrays, funciones y unión
Obs: las funciones pueden devolver cualquier tipo, excepto matrices y funciones. Podemos evitar esta
limitación devolviendo el puntero al array o el puntero para que funcione.
3. Genera números aleatorios entre 22 y 43

- 22+ rand () % 22

1. Considerando la siguiente función recursiva misterio():
misterio(0,N) = N
misterio(P,Q) = misterio(P-1, Q+1)
Cuál es el valor de misterio(2,4)?
misterio(2,4)= misterio(2-1,4+1)=(2-1)+(4+1)=2+4=6
2. Considerando la definición de la función fizzle():

fizzle(1) = 1
fizzle(N) = fizzle( (N+1)/2 ) + fizzle(N/2), for N>1
Cual el valor de fizzle(8)?
fizzle(8)= 8

1. El arreglo es una estructura de datos dinámica. Es decir, se puede modificar su tamaño cada vez
que sea necesario.
Falso. Ya que el arreglo es una estructura de datos estática.
2. En un vector en C++ de N elementos, el primer elemento y el último están en las siguientes
posiciones respectivas:
0 y n-1
3. En el video anterior se planteó una forma de mostrar los elementos del vector en sentido
inverso. ¿Cómo podríamos hacerlo sin modificar esta parte? for(i=0; i<N; i++)
Reemplazar (dentro del for) A[i] por A[N-i-1]
4. Cuando enviamos un vector a una función, se envía la copia de todos sus elementos y se carga en
el vector local de la función llamada.
Falso. En el caso de enviar un vector a una función, se manda la dirección en memoria de su primer
elemento. Por lo tanto, podemos decir que enviamos el vector en sí y no una copia del mismo.

P ágina |7

Parte teórica

8|P ági na

P ágina |9
Parte practica

10 | P á g i n a

1. Considerando que recorremos horizontalmente una matriz A mxn de izquierda a derecha,
podemos afirmar que su último elemento es A[m][n]
Falso. Recuerda que en C++ el primer elemento de una matriz se almacena en la posición A[0][0],
por lo tanto el último elemento será A[m-1][n-1]
2. Para extraer la fila k de una matriz A[mxn], el código a usar es:
for(j=0;j<n;j++) {cout"\t"<<A[k][j];}
3. Completar el código tal que se pueda generar la matriz A[mxn]
i=0;
for(j=0, i<m; j++)
{
A[i][j]=1+rand()%+50;
if(j==n-1)
{
i++;
j=-1;
}}

P á g i n a | 11

Parte teórica

12 | P á g i n a
Parte practica:
/*Elabore un programa en C++ tal que:

Lea un número entero m, mayor o igual a 2 y menor o igual a 10. Luego cargue una matriz A[m][m]
con números menores o iguales a 100 generados al azar. Muestre en pantalla la matriz cargada.
Ordene las componentes de la diagonal principal de la matriz en forma ascendente. Por último,
muestre en pantalla la matriz con las componentes de su diagonal ordenadas.*/
#include<iostream>
#include<stdlib.h>
#include<time.h>
int validacion();
main()
{
int m,n,i,j,f;
cout<<"Ingrese el numero de filas y columnas de la matriz";
m=validacion();
srand(time(NULL));
int A[m][m];
for(i=0;i<m;i++)
for(j=0;j<m;j++)
A[i][j]=rand()%101;
cout<<"La matriz generada es\n";
for(i=0;i<m;i++)
{
for(j=0;j<m;j++)
{
cout<<A[i][j]<<"\t";
}cout<<endl;
}
for(f=0;f<m;f++)
{
int i_min;
int aux;
for(int i=0;i<m-1;i++)

P á g i n a | 13
{
i_min=i;
for(int j=i+1;j<m;j++)
cout<<"La matriz la diagonal principal ordenada en forma ascendente es\n";

for(i=0;i<m;i++)
{
for(j=0;j<m;j++)
{
}cout<<endl;
}
system("pause");
}
int validacion()
{
float numero;
do{
cout<<"\nEl numero ingresado debe ser entero, mayor o igual a dos
y menor o igual a diez\t";
cin>>numero;
}while(numero!=int(numero)||numero<2||numero>10);
return int(numero);
}

14 | P á g i n a

P á g i n a | 15

Parte teórica

16 | P á g i n a

P á g i n a | 17

18 | P á g i n a

1. Contesta con Verdadero/Falso al siguiente planteamiento:
Son formas correctas de definir una cadena:
- char bienvenida [] = "Hola que tal";
- char despedida [] = 'Nos vemos';
Falso
2. En los archivos .csv (los cuales pueden abrirse en Excel, por ejemplo) tienen el siguiente formato
para separar columnas:
Si cargáramos esta información por teclado y nos interesa separar la información de cada columna
(en cada línea), ¿Cuál de las funciones de entrada nos facilitaría el trabajo?
- Cin
- Cin.getline
3. Supongamos que añadimos la biblioteca cstring a nuestro programa, y en una sección tenemos lo
siguiente:
char cadena [] = "hola";
int tam = strlen(cadena);
cout<<cadena[tam]<<endl;
¿Qué se mostraría en pantalla?
- La letra h, el primer elemento de la cadena

tam contiene la cantidad de elementos de la cadena (4 en este caso). Por otro lado, h está
en la posición 0.
- La letra a, el último elemento de la cadena
tam contiene la cantidad de elementos de la cadena, sin contar el carácter de terminación
'\0' (entonces, tendría 4 para "hola"). Como el primer elemento del vector está en la posición
cero (0), el elemento anterior al '\0' (la a en nuestro ejemplo) está en la posición tam-1 (3
para el ejemplo).
- Nada, porque corresponde al carácter de terminación '\0'
¡Correcto!!! Por la definición de strlen() (que no cuenta al carácter de terminación '\0'), y por
el hecho de que la primera posición de la cadena es el 0, con cadena[tam] nos posicionamos
en el carácter de terminación de la cadena (y al imprimirlo no muestra algo en pantalla).
- Podría imprimir cualquier carácter de la tabla (o nada), dependiendo de lo que haya a la
derecha del carácter de terminación '\0'.
Esto sería correcto si se intenta con cadena[tam+1]. Con cadena[tam] nos posicionamos en
el carácter de terminación de la cadena '\0'.

P á g i n a | 19
6° Cuestonario del AV (semana 11)

Parte teorica

20 | P á g i n a

P á g i n a | 21
Parte practica
1. En este ejercicio se deberá completar el código que faltase para que el programa cumpla
correctamente con los criterios planteados
/*Elaborar un programa en C++ que lea una cadena de caracteres, y luego permita determinar la
cantidad de vocales presentes en la cadena.*/
//OBSERVACIÓN IMPORTANTE: NO UTILIZAR ESPACIOS en las respuestas, a no ser que sea
estrictamente necesario su uso.
#include<iostream>
usingnamespace std;

22 | P á g i n a
2. En este ejercicio se deberá arrastrar y soltar el código que faltase para que el programa cumpla
correctamente con los criterios planteados Determinar si una cadena es palíndromo. Un
palíndromo es una cadena o frase que se lee igual en un sentido o en otro. Son ejemplos de
palabras palíndromas: ANA, sometemos, reconocer.

P á g i n a | 23

Verdadero y fallso
1. Una estructura de datos permite crear nuevos tipos de datos en un lenguaje de programacion
Verdadero; la finalidad de las estructuras de datos es ampliar el lenguaje creando nuevos tipos de
datos
2. En un struct los campos, es decir, las variables, debem ser todos del mismo tipo
Falso; los elementos de datos, campos o variables de struct pueden ser de distintos tipos
3. Una vez añadido un nuevo tipo de datos con struct se pueden declarar vraiables de ese tipo en
cualquier parte del programa
Verdadero; el nuevo tipo de dato se utiliza como cualquier otra variable
Selección multiple
1. Marar las sentencias validas para crear una variable llamado clie del tipo de struct Cliente
- Cliente clie; - struct Cliente clie;
- cliente clie; - struct cliente clie;
- Clie Cliente;
Todas son correcto
2. Si tengo la siguiente estructura de datos
struct Producto {
int codigo;
float precio;
} prod;
Selecciona las instrucciones que permite cargar los campos por teclado:
- cin >> Producto.codigo;
- cin >> prod.codigo;
- cin >> codigo
- cin >> Producto.precio;
- cin >> prod.precio;
- cin >> precio;
3. En la función void leerAlumno(Alumno& a) Alumno es un tipo struct y a es una variable tipo:
- Puntero
- Referencia
- vector
4. Si tenemos un struct Alumno y queremos crear un vector alumnos de ese tipo, con 50 elementos
para almacenar los alumnos de una clase, la instrucción correcta es:
- alumnis[50]
- Alumnos alumnos[50];
- Alumno alumnos[50];
- Alumno alumnos [50];
Verdadero y falso. Indica si la siguiente afirmación verdadera o falsa
1. Si tengo una estructura llamada Fecha, y en el programa quiero crear variables de ese tipo,
cualquiera de las siguientes instrucciones son válidas:
Fecha fec; fecha fec
Falso; el nombre de la estructura debe coincidir con el tipo de dato a utilizar, es decir, la única
instrucción correcta es: Fecha fec;
2. Si tenemos una estructura Cliente con un campo direccion, donde direccion es una estructura
compuesta de los campos char calle[20] e int numero. Las siguientes instrucciones permiten cargar
la dirección del cliente:
Falso

2|P ági na
7° Cuestioario del AV (semana 12)

Parte teorica
Rta: cin>>clientes[3].dir.calle;

P ágina |3

4|P ági na
Primer taller
Parte teórica
1) Sentencia for(<inicio>; <condición>; <paso>) ¿Se puede omitir el paso?
Verdadero: Cuando se ejecuta una sentencia for no necesariamente hay que especificar el paso, se
puede poner el pazo dentro del bucle para que solo algunas veces aumente dependiendo de lo que
se necesite a la hora de programar.
2) De acuerdo a la sintaxis del bucle while:
while (condición)
{
sentencias
}
La afirmación falsa es:
- La condición sólo se evalúa una vez al principio de la ejecución del bucle.
- Si la condición es verdadera, se ejecuta el bloque de sentencias, y se vuelve al principio del bucle.
- Si la condición es falsa, no se ejecuta el bloque de sentencias.
- La condición es una variable booleana
3) La afirmación correcta es:
- Las estructuras de control corresponden a las instrucciones que no permiten alterar la
secuencialidad de las instrucciones
- Las estructuras de control corresponden a las instrucciones que permiten alterar la
secuencialidad de las instrucciones.
Obs: Con las estructuras de control de bucle podemos elegir cuantas veces se puede repetir una
parte del código así rompemos con la ejecución secuencial del programa.
4) Selecciona los identificadores correctos
- tiempo
- 1_valor
- distancia1
- tiempo-total
- %final
- PI
- dólares$
5) Con respecto a las estructuras de selección, se puede afirmar que:
- La estructura " if " siempre debe ir acompañada de su par "else".
- La estructura "else" es independiente de la estructura " if ".
- La estructura " else " siempre debe tener una condición.
- La estructura " if " y la estructura "else" son excluyentes entre si cuando están
estructuradas en par.
6) Selecciona los tipos de datos enteros en Lenguaje C++:
- byte
- int
- bool
- float
- double
- long
- short

P ágina |5
7) ¿Cuantas veces va a repetir el bucle?

int k=0;
for (int i=0; i>0; i++)
k++;
cout<<"k: "<<k;
El bucle no se ejecuta ninguna vez porque la condición i>0 no se cumple desde un inicio, entonces
el for nunca pasa a ejecutarse y directo para a imprimirse la variable k.
8) De acuerdo a la sintaxis del bucle for
for (inicialización; condición; paso)
{
sentencias
}
La afirmación falsa es:
- El paso se realiza siempre al iniciar la iteración.
- La inicialización se realiza una vez antes de entrar al bucle.
- La condición se comprueba cada vez antes de entrar al bucle.
- Paso es un elemento "opcional”.
Obs: al inicializar el for no se da un aumento de la variable del paso, solo al final de cada iteración
esa variable aumenta o disminuye dependiendo de las necesidades del problema.
9) De acuerdo a la sintaxis del bucle while
while (condición)
{
sentencias
}
¿Cuál afirmación es falsa?
- Si la condición es falsa, no se ejecuta el bloque de sentencias.
- La condición es una variable booleana.
- La condición sólo se evalúa una vez al principio de la ejecución del bucle.
- Si la condición es verdadera, se ejecuta el bloque de sentencias, y se vuelve al principio del
bucle.
10) El operador "<=" significa menor o igual que y es un operador de tipo: relacional

6|P ági na
Parte Practica
TEMA 2 FILA 1:
Escriba un programa en C++ en el que se ingrese por teclado dos números a y b. El número a solo
puede ser 0 o 1, caso contrario el programa termina sin imprimir nada (no es necesario validar). El número b
debe ser entero y con un valor entre 1 y 10 (no es necesario validar estos requisitos – Obs: el intervalo es
[1,10]). El programa debe mostrar en pantalla un patrón de para mostrar un patrón como un triángulo de
ángulo recto usando el alfabeto caracteres de acuerdo con los siguientes ejemplos:
¡Casos!
Cuando a=0, y:
Si b=1 ---> Imprimir:
A
ACA
ACEGECA
Cuando a=1, y:
1A
1A
2ACA
1A
2ACA
3ACECA
4ACEGECA
¡¡Observaciones importantes!!
 No despliegue mensajes en pantalla para solicitar datos al usuario o para indicar que se ha ingresado
un número inválido. Debe mostrarse en pantalla solo lo que explícitamente se solicita en el
enunciado. Recuerde que se debe cumplir con el formato mostrado en los ejemplos.
 La solución debe ser lo suficientemente general para resolver cualquier entrada diferente a las
propuestas en los ejemplos y los casos de prueba. Por lo tanto, la calificación mostrada por el sistema
no necesariamente corresponderá con la calificación final.
 Se corregirá automáticamente y las soluciones idénticas no tendrán puntaje.

P ágina |7
#include<iostream>
int main(){
int x, b;
cout<<"Ingrese el valor para a: ";
cin>>x;
cout<<"Ingrese el valor para b: ";
cin>>b;
char a='A';
if(x==0){
for(int i=0; i<b; i++){
cout<<a<<" ";
a=a+2;
}
a=a-4;
for(int j=0; j<b-1; j++){
cout<<a<<" ";
a=a-2;
}
}
else if(x==1){
for(int l=1; l<=b; l++){
cout<<l<<" ";
a=65;
for(int i=0; i<l; i++){
cout<<a<<" ";
a=a+2;
}
a=a-4;
for(int j=0; j<l-1; j++){
cout<<a<<" ";
a=a-2;
}
cout<<endl;
}}
return 0;
}

8|P ági na
TEMA 2 FILA 2
Escriba un programa en C++ que permita generar una secuencia de números siguiendo las siguientes
reglas, a partir de número entero, positivo y menor que 100. Validar la entrada conforme a lo requerido en
los casos de prueba:
 Si el número es 1, el proceso termina.
 Si el número es par se divide entre 2.
 Si el número es impar se multiplica por 3 y se le suma 1.
Por ejemplo:
Si empezamos con n=6, por ejemplo, se generaría la siguiente sucesión de números
3, 10, 5, 16, 8, 4, 2, 1.
 No despliegue mensajes en pantalla para solicitar datos al usuario o para indicar que se ha
ingresado un número inválido. Debe mostrarse en pantalla solo lo que explícitamente se solicita en
el enunciado.
propuestas en los ejemplos y los casos de prueba. Por lo tanto, la calificación mostrada por el
sistema no necesariamente corresponderá con la calificación final.
 Para ciertos casos de prueba, se debe cumplir EXACTAMENTE con el formato mostrado en los
ejemplos (espacios, asteriscos, etc.).
Casos de prueba
case=C1 Opción 1 - Validar número entero

input=1
5.5 6.5 7
output="7 es el número ingresado entero, positivo y menor que 100"
case=C2 Opción 1 - Validar número negativo
input=1
-1 -10 6
case=C3 Opción 1 - Validar número mayor que 100
input=1
101 200 66
case=C4 Opción 2 - Generar número siguiente n par(sin validar)
input=2
6
output="El siguiente número es: 3"
case=C5 Opción 2 - Generar número siguiente, n impar (sin validar)
input=2
7
output="El siguiente número es: 22"
case=C6 Opción 3 - Generar secuencia sin formato
input=3
5
output=16 8 4 2 1
case=C7 Opción 3 - Generar secuencia sin formato
input=3
6

P ágina |9
output=3 10 5 16 8 4 2 1
case=C8 Opción 4 - Generar secuencia con formato
input=4
11
output="La secuencia es: t1=34 t2=17 t3=52 t4=26 t5=13 t6=40 t7=20 t8=10 t9=5 t10=16 t11=8 t12=4 t13=2
t14=1 "
case=C9 Opción 4 - Generar secuencia con formato
input=4
12
output="La secuencia es: t1=6 t2=3 t3=10 t4=5 t5=16 t6=8 t7=4 t8=2 t9=1 "

#include <iostream>
int main(){
int opcion,n;
cin>>opcion;
if(opcion==1){//lea y valide el numero ingresado
float nf;
do{
cin>>nf;
} while(nf!=int(nf) or nf<=0 or nf>100);
//completar
cout<<int(nf)<<" es el número ingresado entero, positivo y menor
que 100";
//validacion nice
}else if(opcion==2){ //generar siguiente número
cin>>n;
int n1, n2;
if(n%2==0){
n1=n/2;
//completar
cout<<"El siguiente número es: "<<n1<<endl;
}
else if(n%2!=0){
int n2;
n2=n*3+1;
cout<<"El siguiente numero es: "<<n2<<endl;
}
}else if(opcion==3){
int n1, n2;
cin>>n;
while(n!=1){
if(n%2==0){
n=n/2;
cout<<"El siguiente numero es: "<<n<<endl;
}
else if(n%2!=0){

10 | P á g i n a
int n2;
n=n*3+1;
cout<<"El siguiente numero es: "<<n<<endl;
}}
}else if(opcion==4){//generar la secuencia con formato

cin>>n;
cout<<"La secuencia es: ";
int a=0;
while(n!=1){
a++;
if(n%2==0){
n=n/2;
cout<<"t"<<a<<"="<<n<<" ";
}
else if(n%2!=0){
int n2;
n=n*3+1;
cout<<"t"<<a<<"="<<n<<" ";
}}
//cout<<"t"<<i<<"="<<n<<" ";
}
return 0;
}

P á g i n a | 11
TEMA 2 FILA 3
Escriba un programa en C++ en el que se ingrese por teclado un número n, el cual debe ser entero y con un
valor entre 50 y 1000 (se debe validar estos requisitos – Obs: el intervalo es [50,1000]). El programa debe
mostrar en pantalla todos los divisores primos de n (que puede incluir a n si éste es primo) en orden
ascendente y sin repetición.
 No despliegue mensajes en pantalla para solicitar datos al usuario o para indicar que se ha ingresado
un número inválido. Debe mostrarse en pantalla solo lo que explícitamente se solicita en el
enunciado. Recuerde que se debe cumplir con el formato mostrado en los ejemplos.
La solución debe ser lo suficientemente general para resolver cualquier entrada diferente a las propuestas
en los ejemplos y los casos de prueba. Por lo tanto, la calificación mostrada por el sistema no
necesariamente corresponderá con la calificación final.

12 | P á g i n a
Segundo taller
Parte práctica
TEMA 2 FILA 2
En este ejercicio trabajaremos con un arreglo unidimensional (vector) de N elementos. No hace falta
preocuparse por la validación (tanto de N como de los elementos del vector), ya que el ejercicio consistirá en
la implementación de funciones que trabajen con el vector dado:
Las funciones que deben implementarse son las siguientes
1. cargarNumerosDiferentes: que debe recibir un vector(A), y su dimensión(N). Luego debe cargar

solamente números diferentes entre -N y N (validar). Para lograr esto se proporciona una función
xEstaEnElVector que permite verificar si un determinado elemento ya fue cargado en el vector
anteriormente.
2. imprimirCombinacionesDe2Elementos: esta función recibe un vector e imprime todas las
combinaciones de 2 elementos (sin repetición) de los elementos del vector.
3. imprimirCombinacionesDe2ElementosQueSumen0: esta función recibe un vector e imprime
solamente las combinaciones de 2 elementos (sin repetición) que sumen 0 de los elementos del
vector.
Por ejemplo:
Para la opción (1), se valida que la función cargarNumerosDiferentes funcione según lo esperado
Para la opción (2), que valida la función imprimirCombinacionesDe2Elementos:
Casos Se imprimira
Si N=3 y los elementos de A son {1, 2, 3}, {1 2},{1 3},{2 3},
Si N=4 y los elementos de A son {1, 2, 3, 4}, {1 2},{1 3},{1 4},{2 3},{2 4},{3 4}
Si N=5 y los elementos de A son {1, 2, 3,4, 5}, {1 2},{1 3},{1 4},{1 5},{2 3},{2 4},{2 5},{3 4},{3 5},{4 5},
Para la opción (3), que valida la función imprimirCombinacionesDe2ElementosQueSumen0:
Casos Se imprimira
Si N=3 y los elementos de A son {1, 2, -1}, {1 -1},
Si N=4 y los elementos de A son {1, 2, -1, -2}, {1 -1], {2 -2},
Para evitar problemas de formato también se proporciona la función imprimirCombinacion.
 No despliegue mensajes en pantalla para solicitar datos al usuario.
propuestas en los ejemplos y los casos de prueba. Por lo tanto, la calificación mostrada por el sistema
no necesariamente corresponderá con la calificación final.
 No modificar la función principal main().
 Soluciones 100% similares no tendrán puntaje.
La distribución de puntajes para cada función es la siguiente:
 Función cargarNumerosDiferentes(): 15%

 Función imprimirCombinacionesDe2Elementos(): 55%
 Función imprimirCombinacionesDe2ElementosQueSumen0(): 30%

P á g i n a | 13
#include<iostream>
#include<cstdlib>
void imprimirVector(int A[],int N){
for(int i=0;i<N;i++) cout<<A[i]<<" ";
cout<<endl;
}
void imprimirCombinacion(int a,int b){
cout<<"{"<<a<<" "<<b<<"},";
}
bool xEstaEnElVector(int A[],int N,int X){
for(int i=0;i<N;i++){
if(A[i]==X)
return true;
}
return false;
}
void cargarNumerosDiferentes(int A[], int N){
int i,nuevo, x;
for(i=0; i<N; i++ ){
if(i==0){
cout<<"Ingrese el valor para el elemento ["<<i+1<<"]: \n";
cin>>A[i];
while(A[i]<-N or A[i]>N){
cout<<"Ingrese nuevamente: \n";
cin>>A[i];
}
}else{
cout<<"Ingrese el valor para el elemento ["<<i+1<<"]: \n";
cin>>A[i];
x=A[i];
while(A[i]<-N or A[i]>N or xEstaEnElVector(A, i,
x)==true){
cout<<"Ingrese nuevamente: \n";
cin>>A[i];
x=A[i];
}
}
}
}
void imprimirCombinacionesDe2Elementos(int A[], int N){
int k=0, l=0;
for(int i=0; i<N; i++){
for(int j=0+l; j<N-1; j++){
if(k<((N*N-N)/2)){
if(A[i]!=A[j+1+l]){
cout<<"{"<<A[i]<<" "<<A[j+1]<<"},";
k++;
}
}
if(j==2) l++;
}
}

14 | P á g i n a
}
void imprimirCombinacionesDe2ElementosQueSumen0(int A[], int N){
for(int i=0;i<N; i++){
for(int j=i+1; j<N; j++){
if(A[i]+A[j]==0){
cout<<"{"<<A[i]<<" "<<A[j]<<"},";
}
}
}
}
int main(){
/*NO MODIFICAR EL MAIN!!*/
int opcion,i,N;
cout<<"Ingrese la opcion: \n";
cin>>opcion;
cout<<"Ingrese el tamanho: \n";
cin>>N;
int A[N];
if(opcion==1){
cargarNumerosDiferentes(A,N);
imprimirVector(A, N);
}
if(opcion==2){
cout<<"Cargue el vector: \n";
for(i=0;i<N;i++) cin>>A[i];
imprimirCombinacionesDe2Elementos(A,N);
}
if(opcion==3){
cout<<"Cargue el vector: \n";
imprimirCombinacionesDe2ElementosQueSumen0(A,N);
}
return 0;
}

P á g i n a | 15
Primer examen parcial 2022-1C

Parte Teorica
TEMA 1

16 | P á g i n a

P á g i n a | 17

18 | P á g i n a

P á g i n a | 19
Parte práctica
TEMA 2 GRUPO 2

20 | P á g i n a
#include<iostream>
#include<cmath>
int validar(int n){
while(n<=100 or n>=1000000){
cout<<"Ingrese un numero: ";
cin>>n;
}
return n;
}
int dig(int n){
int j=0;
int aux=n;
while(aux>0){
aux=aux/10;
j++;
}
// cout<<"La cantidad de digitos de "<<n<<" es: "<<j<<endl;
return j;
}
int nuevo(int n, int nc){
int aux2=n, a, b, suma=0;
nc=dig(n);
for(int k=0; k<nc; k++){
a=aux2%10;
if(a%3==0 and a!=0){
a=(a+6)%10;
}else if(a%5==0){
a=(a+5)%10;
}
b=a*pow(10, k);
suma=suma+b;
aux2=aux2/10;
}
cout<<"El nuevo digito codificado es: "<<suma<<endl;
}
int main(){
int n, n1, nc;
cin>>n;
n=validar(n);
nc=dig(n);
// cout<<"Prueba nc: "<<nc<<endl;
// cout<<"Prueba de ingreso: "<<n<<endl;
nuevo(n, 0);
return 0;
}
//Obs: El programa cumple un 80% lo pedido, pero creo que habre olvidado
algún caso

P á g i n a | 21
Segundo examen parcial 2022-1C

Parte Teorica
TEMA 1

22 | P á g i n a

P á g i n a | 23

24 | P á g i n a

P á g i n a | 25

26 | P á g i n a

P á g i n a | 27

28 | P á g i n a
Parte Practica
TEMA 2 FILA 1

P á g i n a | 29

30 | P á g i n a
TEMA 2 FILA 2

P á g i n a | 31
Primer final 2022-1C

Parte teórica:
TEMA 1

32 | P á g i n a

P á g i n a | 33

34 | P á g i n a

P á g i n a | 35

36 | P á g i n a
Parte práctica:
TEMA 2

P á g i n a | 37
Segundo final 2022-1C

Parte Practica:
TEMA 2

38 | P á g i n a
Unidad 1: Introducción a la programación

Algotimo
Los algoritmos son una secuencia de instrucciones, que en general sirven para todo. Nos fijaremos
en lo importante, conocer un estado inicial (imput) y siguendo una secuencia de pasos se produzca un
resultado (outpud).
Ejemplo: La multiplicación
Input  aquello que se quiere multiplicar (65x34)
Outpud  El resultado
Algortimo  El camino o los pasos que nos enseñaron en el colegio
En general las instrucciones son el algortimo
Caracteristicas de un algoritmo
 Debe ser preciso e indicar el orden de realizacion de cada paso.
 Debe ser definido. Si se sigue un algotimo dos veces se debe obtener el mismo resultado.
 Un algoritmo debe ser finito. Si se sigue un algoritmo, se debe terminar en algún momento, o sea,
debe tener un número finito de pasos.
Lenguaje de programación
Es un lenguaje formal diseñado para realizar procesos que pueden ser llevados a cabo por máquinas
como las computadoras.
Tipos de lenguajes
- Maquina
El lenguaje de una maquina es el codigo binario (0, 1). Su mayor ventaja es la
velocidad de ejecución que posee. Entre sus desventajas encontramos la dificultad y lentitud
en la codificación; la poca fiabilidad; la gran dificultad de verificar y poner a punto los
programas; los programas sólo son ejecutables en el mismo procesador.
- De bajo nivel (ensambladores)
Son instrucciones conocidos como nemotécnicos. Por ejemplo: operaciones
aritmeticas como la adición, la resta, la multiplucacion y la division.
La mayor ventaja de este lenguaje es la facilidad de codificacion y su velocidad en los
calculos.
Entre sus desventajas encontramos una dependencia total de la maquina, impide la
transportabilidad de los programas; la formacion de los programadores es más compleja que
el de Alto Nivel.
- De alto nivel (copilado, interpretado e hibrido)
Esta diseñado para que las personas escriban y entiendan los programas.
Entre las ventajas encontramos la formacion rapida de los programadores; esta
diseñado en el “lenguaje humano”; indistintamente de la maquina, el programa debe
funcionar.
Y sus desventajas son el mayor tiempo de empleo; no se aprovechan los recursos
internos de las maquinas; aumento de la ocupacion de la maquina; el tiempo de ejecucion
de los programas es mayor.

P á g i n a | 39
Paradigmas de la proramación
Conocemos como paradigmas de la programación a las diferentes soluciones presentes a un
determinado problema.
𝐼𝑚𝑝𝑒𝑟𝑎𝑡𝑖𝑣𝑎 → 𝐷𝑒𝑡𝑎𝑙𝑙𝑎 𝑝𝑎𝑠𝑜 𝑝𝑜𝑟 𝑝𝑎𝑠𝑜
Paradigma  Camino {
𝐷𝑒𝑐𝑙𝑎𝑟𝑎𝑡𝑖𝑣𝑎 → 𝐿𝑜 𝑞𝑢𝑒 𝑒𝑠𝑝𝑒𝑟𝑎𝑠 𝑞𝑢𝑒 ℎ𝑎𝑔𝑎
- Paradigma estructurado: Es el más simple, comienza desde arriba y linealmente va hasta

abajo. No siempre podrá usarse.
- Programación orientada a objetos: Separa el software en objetos. Ejemplo: caracteristicas +
funsiones.
- Programación funcional: Cada pedazo es una funsion, estan conectados entre si.

40 | P á g i n a
Unidad 2: Introducción al Lenguaje C/C++

Ventajas
- Es de alto rendimiento \n: Salto de línea
- Un lenguaje moderno con constantes actualizaciones
\t: tabulación
- Es multiplataforma
Lenguaje de alto rendimiento

- Lllamdas al sistema operativo
- Lenguaje compilado para cada plataforma
- Muchos parámetros de optimización
- Acceso directo a la memoria, que además controla el usuario
- Relacion directa con el lenguaje ensamblador
Ejemplo “Hola mundo”
1. Definimos la librería #include<iostream>

2. Para evitarnos colocar a cada función std:: Colocamos luego de la librería using namespace std
3. Llamamos a la función main() donde estará nuestro mensje
#include<iostream>
using namespace std; Para los comentarios usamos
int main(){ //mensaje
cout<<”Hola Mundo”<<endl;
return 0; /*mensaje*/
}
Tipos de datos basicos en C++

- Char
Es un entero de 8 bits. Ejemplos: “A”, ”B”, ”C”, etc.
- Int
Entero de 16 o 32 bits. Ejemplos: 5, 2000, 30
- Float
Punto flotante IEEE 754 de 32 bits. Ejemplos: “12.34”, “4.34”
- Double
Punto flotante IEEE 754 de 64 bits. Ejemplo: “12.34”, “4.34”
Variables
Sirven para declaraar el dato.
Int a // declara “a” de un tipo entero
Float real // declara “real” del tipo punto flotante
Char letra // declara la variable “letra” del tipo carácter
Int b, c, d // declara b, c, d como entero

P á g i n a | 41
Reglas para los identificadores

- Debe ser una secuencia de letras (A-Z, a-z, 0-9)
- El guion hacia abajo es una letra más _
- No puede tener otros caracteres distintos a los anteriores (*, -, ;, +)
- El primer carácter no debe ser un digito
- Existe una distincion entre las letras mayusculas y minusculas (Masa, MASA, masa)
- Ejemplos: iempo, distancia1, velocidad_de_la_luz
Asignacion
Simbolo = algo // A la derecha una variable y a la izquierda una expresion
Ejemplo:
a=b // a “a” se le asigna el valor de “B”
int a, b, s;
char letra;
a=5;
b=3
s=a+b;
int c=100;
letra=’z’;
Operadores de C++ más comunes
Aritmeticos Asignación Relacionantes Lógicos

+ = == && (and)
- += < || (or)
* -= > ! (not)
/ *= <=
% /= >=
++ !=
--
Datos
- Cin: Lectura de datos por teclado
- Cout: impresión de datos en pantalla
Variable booleana
Función bool:
Las funciones tipo bool, indican que el tipo de dato que retornan las mismas es justamente un bool,
es decir un booleano, o sea tienen 2 posibles valores true (por lo general se indica con 1) o false (por lo
general se indica con 0). (Vaca, 2011)
Ejemplo: En este caso queremos verificar que n sea un número mayor a 5

bool funcion(int n)
{
if(n>5)
return true;
return false;
}

42 | P á g i n a
Ejercicios propuestos para la introducción a C++

/* Escribir un programa que imprima “Hola Mundo” */
#include<iostream>
int main(){
cout<<"Hola mundo!";
return 0;
}
/* Escribir un programa en C++ que lea por teclado dos números (suponer que el usuario siempre cargará
números enteros y positivos) y muestre en pantalla el primer dígito (el que está más a la derecha) de la
suma de ambos.
Por ejemplo, si los números leídos por teclado son 9 y 5, se debe imprimir en pantalla:
El primer digito de 9+5 es: 4
Observación: No imprimir mensajes en pantalla para solicitar la carga de los números de entrada. */
#include<iostream>
int main(){
//desarrolle aqui el ejercicio
int n1;
int n2;
int s;
int c;
cin>>n1;
cin>>n2;
s=(n1+n2);
c=(s%10);
cout<<"El primer digito de "<<n1<<"+"<<n2<<" es: "<< c <<endl;
return 0;
}
/* Escribir un programa en C++ que imprima el tamaño de las variables fundamentales en bytes*/
#include<iostream>
int main(){
//Desarrolle aquí el ejercicio
cout<<"El tamaño de la variable char es de "<<sizeof(char)<<"
bytes"<<endl;
cout<<"El tamaño de la variable int es de "<<sizeof(int)<<"
bytes"<<endl;
cout<<"El tamaño de la variable short int es de "<<sizeof(short
int)<<" bytes"<<endl;
cout<<"El tamaño de la variable long long es de "<<sizeof(long
long)<<" bytes"<<endl;
cout<<"El tamaño de la variable float es de "<<sizeof(float)<<"
bytes"<<endl;
cout<<"El tamaño de la variable double es de "<<sizeof(double)<<"
bytes"<<endl;
return 0;
}

P á g i n a | 43
Unidad 3: Estructuras de selección

C++ tiene dos estructuras de control para la selección, if (selección simple y binaria) y switch
(selección múltiple).
Inicio
Instrucción 1
Instrucción 2
Instrucción n
Fin
Estructuras repetitivas
- Secuencial: Es la aprendida en la unidad anterior.

- De selección: Utilizaremos if, if-else, switch
- Repetición: Bucles como el for, while, do-while
Selección
Si
Repetición
No
Condición
Instrucción No Instrucción Si
Instrucción
No Si
Fin Condición
If(expresión){ If(expresión){
Instruccines; Bloque 1; //Verdadero
} } else{
Bloque 2; //Falso
}
Si
Expresión (Falso) (Verdadero)
No Si
Expresión
Instrucciones
No (Falso)
Bloque 2 Bloque 1

44 | P á g i n a
Expresionaes relacionales
Permiten determinar la relación que existe entre dos operadores a trevés de un operador relacional.
El mismo permite comparar los valores de dos operadores de igual naturalez, “1” para verdadero y “0” para
falso.
Operador Ejemplo
Igual que == 20 == 10  0
Menor que < 20 < 10  0
Distinto que != 10 != 3  1
Estructuras selectivas anidadas (o en cascada)
If(expresión 1){
If(expresión 2){
If(expresión 3){
}else{
}else{
}else{
Expresiones logicas
Consiste en variables booleanas, expresiones relacionantes y operadores booleanas (and, or, not)
&& || !
V && V  V V || V  V !V  F
F && V  F F || V  V !F  V
V && F  F V || F  V
F && F  F F || F F

P á g i n a | 45
Bifurcación swith
Sirve para agrupar varias estructuras if en una sola en el caso particular en el que una variable es
comparada a diferentes valores (todos ellos constantes enteros).
Switch (expresión){
Case expresion1_const: Expresión
Instrucciones 1;
Caso 1
Ins 1
Breack;
Case expresion2_const: Caso 2

Ins 2
Instrucciones 2;
Breack;
Default; //opcional Default

Ins_def
Instrucciones_def;
Breack;
//breack utilizamos cuando queremos salir de la estructura y no seguir evaluando

46 | P á g i n a
Ejercicios propuestos sobre estructuras de selección

/*Escribir un programa que reciba un número y determine si es positivo, negativo o cero.
Obs: No modifique la instrucciones de entrada de datos, para que el script de testeo pueda evaluar el
resultado.*/
#include<iostream>
int main(){
float nf;
cin>>nf;// no modifique la instrucción de lectura
if(nf==0){
cout<<"El numero ingresado es cero";
}
else{
if(nf>=0){
cout<<"El numero ingresado es positivo";
}
else{
if(nf<=0){
cout<<"El numero ingresado es negativo";
}
}
}
return 0;// no utilize system(pause)
}
/*Escribir un programa en C++ que reciba un caracter e indique en pantalla si corresponde o no a una
letra (sea minúscula o mayúscula).
Ejemplos:
a ---> "El caracter ingresado es una letra (minuscula)"
G ---> "El caracter ingresado es una letra (mayuscula)"
% ---> "El caracter ingresado NO corresponde a una letra" */
#include<iostream>
int main(){
char c;
cin>>c;
//Comience aquí el ejercicio
//Recuerde imprimir los mensajes en pantalla de acuerdo a los casos
de prueba (y lo establecido en el enunciado). Imprimir exactamente el
mensaje requerido.
if(c>=65 && c<=90){
cout<<"El caracter ingresado es una letra (mayuscula)"<<endl;
}
else
if(c>=97 && c<=122){
cout<<"El caracter ingresado es una letra (minuscula)\n";
}
else{
cout<<"El caracter ingresado NO corresponde a una letra";
}
return 0;
}

P á g i n a | 47
/*Los empleados de una fábrica trabajan en dos turnos: diurno y nocturno. Se desea calcular el jornal diario
de acuerdo con los siguientes puntos:
 La tarifa de las horas diurnas es de 10.000 Gs
 La tarifa de las horas nocturnas es de 20.000 Gs
 Si es un domingo, el jornal aumenta en un 25%.
Para un trabajador considerado, se ingresan como entradas el día de la semana en la que trabajó (del 1 al
7, donde 7 es domingo), la cantidad de horas trabajadas en el turno diurno, y la cantidad de horas
trabajadas en el turno nocturno. Se debe mostrar en pantalla el jornal que le corresponde.*/
#include<iostream>
int main(){
int dia,horasD,horasN;
//Se introduce el dia
cin>>dia;
//Se introduce la cantidad de horas - Turno diurno
cin>>horasD;
//Se introduce la cantidad de horas - Turno nocturno
cin>>horasN;
//Comience aqui el ejercicio
if(dia>=1 && dia<=6){
cout<<"El jornal del trabajador es de
"<<(10000*horasD)+(20000*horasN)<<endl;
}
else{
if(dia==7){
cout<<"El jornal del trabajador es
de"<<((0.25)*10000+10000)*horasD+((0.25)*20000+20000)*horasN<<endl;
}
}
}
/*Escribir un programa que lea tres números enteros, y muestre en pantalla el valor central. Por ejemplo,
si los números ingresados son 4, 1 y 3 (en cualquier orden), debe mostrarse en pantalla el 3.
Obs: se puede suponer que siempre se cargarán números enteros.*/
#include<iostream>
int main(){
int a,b,c;
cin>>a>>b>>c;// no modifique la instrucción de lectura
//Comience aqui el ejercicio
if((a>b && a<c) || (a>c && a<b)){
cout<<a;
}
else{
if((b>a && b<c) ||(b>c && b<a)){
cout<<b;
}
else{
if((c>a && c<b)||(c>b && c<a)){
cout<<c;

48 | P á g i n a
}
else{
if(a==c && a>b){
cout<<a;
}
}
}
}
}
/*Escribir un programa que reciba un número (el cual debería ser entero y positivo), y muestre en
pantalla el valor del cuadrado de dicho número. Si el número no es entero y positivo, debe indicarse con
mensajes en pantalla (dependiendo del caso). Si el número ingresado sobrepasa el valor máximo de un
valor de tipo int, también se debe indicar con un mensaje en pantalla.
Ejemplos:
 3.5 ---> "Error, el numero ingresado no es entero"
 -1 ---> "Error, el numero ingresado no es positivo"
 -3.5 ---> "Error, el numero ingresado no es entero ni positivo"
 2 ---> 4
 10000000000 ---> "Error, el numero ingresado es muy grande"
Obs: la constante INT_MAX de la librería climits (https://www.cplusplus.com/reference/climits/) indica
el valor máximo que puede tenerse para una variable de tipo int. */
#include<iostream>
#include<climits> //ya que emplearemos la constante INT_MAX
int main(){
float nf;
//DESARROLLE AQUI EL EJERCICIO
if(nf>INT_MAX){
cout<<"Error, el numero ingresado es muy grande";//es muy grande
return 0;
}
if(nf!=int(nf)){
if(nf<0 && nf!=int(nf)){
cout<<"Error, el numero ingresado no es entero ni positivo";//ni
positivo
return 0;
}
else{
cout<<"Error, el numero ingresado no es entero";
return 0;
}
}
if(nf<0){
cout<<"Error, el numero ingresado no es positivo";
return 0;
}
else{
cout<<nf*nf;
}
}

P á g i n a | 49
/*Para este ejercicio podemos suponer que el usuario siempre ingresará un número entero de tres dígitos.
Se debe determinar (y mostrar un mensaje en pantalla) si el número cargado representa a un número
binario (para ello, debe estar compuesto por unos y/o ceros).
Ejemplos:
 312 ---> "No es un numero binario"
 101 ---> "Es un numero binario" */
#include<iostream>
int main(){
int n;
cin>>n;
//DESARROLLE AQUI EL EJERCICIO
int a, b, c;
a=n/100;
b=(n-(a*100))/10;
c=(n-a*100-b*10)/1;
if((a==1||a==0) && (b==1||b==0) && (c==1||c==0)){
cout<<"Es un numero binario";
}
else{
cout<<"No es un numero binario";
}
}

50 | P á g i n a
/*Implementar un programa en C++ en el que se ingresan tres variables: dia, mes y anho (en forma
númerica); y devuelva la fecha del día siguiente (en formato dia/mes/anho). Se deben considerar los años
bisiestos, cantidad de días de cada mes, etc. En caso de insertar números reales o fechas inválidas, indicar
con un mensaje de error.
Ejemplos:
 dia=8, mes=8, anho=2021 ---> 9/8/2021
 dia=36, mes=15, anho=-5 ---> "No es una fecha valida!!" */
#include<iostream>
int main(){
float D, M, A;
cout<<"Ingrese la fecha en formato DD/MM/AAAA: "<<endl;
cin>>D>>M>>A;
int D2=(D/1), M2=(M/1), A2=(A/1),D3,M3,A3;
if(D2!=D || D<=0 || D>31){ //Lo mejor fue ir analizando dia por dia
cout<<"No es una fecha valida\n";
return 0;}
if(M2!=M || M<=0 || M>12){ //Analogo mes por mes
return 0;}
if(A2!=A || A<=0 || A>3000){ //Analogo año por año
return 0;}
if(M==12 && D==31){ //Condicion para año nuevo, aplicable solo
para el 31
D3=1; M3=1; A3=A+1;}
else if(M==12){
D3=D+1; M3=M; A3=A;}
if(A2%4==0 && A2%100!=0 || A2%400==0){ //Ahora con los años
bisiestos, con febrero de 29 dias
if(M==2){
if(D<=29){
if(D==29){
D3=1; M3=M+1; A3=A;}
if(D<29){
D3=D+1; M3=M; A3=A;}}
if(D>29){
return 0;}}}
else { //Año comun, con febrero de 28 dias
if(M==2){
if(D<=28){
if(D==28){
D3=1; M3=M+1; A3=A;}
if(D<28){
D3=D+1; M3=M; A3=A;}}
if(D>28){
return 0;}}}
if(M==1||M==3||M==5||M==7||M==8||M==10){
if(D<=31){
if(D==31){
D3=1; M3=M+1; A3=A;}
if(D<31){
D3=D+1; M3=M; A3=A;}}}

P á g i n a | 51
if(M==4||M==6||M==9||M==11){
if(D<=30){
if(D==30){
D3=1; M3=M+1; A3=A;
}
if(D<30){
D3=D+1; M3=M; A3=A;
}
}
}
cout<<D3<<"/"<<M3<<"/"<<A3<<endl;
}
/*Implementar un programa en C++ en el que se ingresan tres variables: dia, mes y anho (en forma
númerica); y devuelva la fecha del día siguiente (en formato dia/mes/anho). Se deben considerar los años
bisiestos, cantidad de días de cada mes, etc. En caso de insertar números reales o fechas inválidas, indicar
con un mensaje de error.
Ejemplos:
 dia=9, mes=8, anho=2021 ---> 10/08/2021
 dia=36, mes=15, anho=-5 ---> "No es una fecha valida!!"
Nótese que, en el mensaje de salida, siempre debe mostrarse 2 dígitos para el día, 2 para el mes, y 4 para
el año. */
#include<iostream>
int main(){
float D, M, A;
cout<<"Ingrese la fecha en formato DD/MM/AAAA: "<<endl;
cin>>D>>M>>A;
int D2=(D/1), M2=(M/1), A2=(A/1),D3,M3,A3;
if(D2!=D || D<=0 || D>31){ //Lo mejor fue ir analizando dia por dia
return 0;}
if(M2!=M || M<=0 || M>12){ //Analogo mes por mes
return 0;
if(A2!=A || A<=0 || A>3000){ //Analogo año por año
return 0;}
if(M==12 && D==31){ //Condicion para año nuevo, aplicable solo para
el 31
D3=1; M3=1; A3=A+1;}
else if(M==12){
D3=D+1; M3=M; A3=A;}
if(A2%4==0 && A2%100!=0 || A2%400==0){ //Ahora con los años
bisiestos, con febrero de 29 dias
if(M==2){
if(D<=29){
if(D==29){
D3=1; M3=M+1; A3=A;}
if(D<29){
D3=D+1; M3=M; A3=A;
}
}
if(D>29){
return 0;
}

52 | P á g i n a
}
}
else {
//Año comun, con febrero de 28 dias
if(M==2){
if(D<=28){
if(D==28){
D3=1; M3=M+1; A3=A;}
if(D<28){
D3=D+1; M3=M; A3=A;}}
if(D>28){
return 0;}}}
if(M==1||M==3||M==5||M==7||M==8||M==10){
if(D<=31){
if(D==31){
D3=1; M3=M+1; A3=A;}
if(D<31){
D3=D+1; M3=M; A3=A;}}}
if(M==4||M==6||M==9||M==11){
if(D<=30){
if(D==30){
D3=1; M3=M+1; A3=A;}
if(D<30){
D3=D+1; M3=M; A3=A;}}}
cout.fill('0');
cout.width(2);
cout<<D3<<"/";
cout.fill('0');
cout.width(2);
cout<<M3<<"/";
cout.fill('0');
cout.width(4);
cout<<A3<<endl;
}
/**/

P á g i n a | 53
Unidad 4: Estructuras cíclicas

I. While
Los ciclos while son también una estructura cíclica, que nos permite ejecutar una o varias líneas de
código de manera repetitiva sin necesidad de tener un valor inicial e incluso a veces sin siquiera conocer
cuándo se va a dar el valor final que esperamos, los ciclos while, no dependen directamente de valores
numéricos, sino de valores booleanos, es decir su ejecución depende del valor de verdad de una condición
dada, verdadera o falso, nada más. De este modo los ciclos while, son mucho más efectivos para condiciones
indeterminadas, que no conocemos cuando se van a dar a diferencia de los ciclos for, con los cuales se debe
tener claro un principio, un final y un tamaño de paso. (Gonzales, 2019)
¿Cómo funciona un Ciclo While?

Para comprender mejor el funcionamiento del ciclo while, pongamos un buen ejemplo, imaginemos
que, por algún motivo, queremos pedirle a un usuario una serie de números cualquiera y que solo dejaremos
de hacerlo cuando el usuario ingrese un número mayor a 100. Como vemos, aquí no podríamos utilizar un
ciclo for, pues no tenemos ni idea de cuándo al usuario se le va a ocurrir ingresar un número mayor que 100,
es algo indeterminado para nosotros, sin embargo, el ciclo while nos permite ejecutar una acción de forma
infinita hasta que se cumpla alguna condición específica, en nuestro caso sería que el numero ingresado sea
mayor a 100. De modo que, si el usuario nos ingresa de manera sucesiva los siguientes números 1,50,99, 49,
21, 30, 100 ..., nuestro programa no finalizara, pues ninguno de estos números es mayor que 100, sin
embargo, si nos ingresara el número 300, el programa finalizaría inmediatamente.

54 | P á g i n a
Sintaxis
Línea 1:
En esta línea está prácticamente todo lo esencial de un ciclo while. La sintaxis es bastante simple.
Tenemos al interior de los paréntesis una condición cualquiera, es decir por ejemplo "==. >, <, >=, <=, !=" o
algunas más que se nos puedan ocurrir, esta condición que especifiquemos allí, es la que permitirá que el
ciclo se siga ejecutando hasta que en algún momento esta misma condición deje de cumplirse, de esta forma
si por ejemplo estamos verificando que un número cualquiera == 50, el ciclo se ejecutara solo cuando número
cualquiera sea igual a 50, en cuanto su valor cambie a cualquier otro el ciclo while finalizara y continuara con
el resto de la ejecución del programa. De esta forma, es evidente que la condición que allí ingresemos
siempre deberá tomar un valor booleano (true o false).
Línea 2:
En la línea 2 tenemos una llave abriendo "{" lo cual como sabemos indica que allí comienza un bloque
de instrucciones que se ejecutaran cada vez que el ciclo de un "giro". Esta llave no es del todo obligatoria, sin
embargo, si no la ponemos solo se ejecutará dentro de nuestro ciclo while la primera línea inmediatamente
posterior a la declaración del ciclo, de modo que, si deseamos que se ejecuten varias líneas dentro de nuestro
ciclo, debemos usar las llaves
Línea 3 a 7:
En estas líneas es donde estarán todas las operaciones que queramos llevar a cabo de manera
iterativa durante la ejecución del ciclo, este bloque podrá tener la cantidad de líneas necesarias incluso, como
veremos más adelante dentro de estas podría haber uno o más ciclos, así que podrías tener todo un programa
dentro de un ciclo.
Línea 8:
En esta última línea hacemos uso de la llave cerrando "}", una vez más como seguramente ya
debemos saber esta nos indica que allí termina el bloque del ciclo while y se dará por terminada la ejecución
de este para continuar ejecutando el resto del algoritmo.

P á g i n a | 55
Ejemplo:
/* Dado un numero entero N por teclado(no hace falta validar),

imprimir en pantalla el nro con los digitoss invertidos.
ejemplo
123 ... 321
-98765 ... -56789
N= 1234 operadores: / div and % resto N_inv=0
1234 % 10 .... 4 1234 / 10 .... 123 N_inv=0*10+4=4
123 % 10 ... 3 123 / 10 .... 12 N_inv=4*10+3=43
12 % 10 ... 2 12 / 10 .... 1 N_inv=43*10+2=432
1 % 10 ... 1 1 / 10 .... 0 (fin) N_inv=432*10 +1 =431 432
queremos insertar en dig uno enonces 432*10 +1 la logica de formar un numero invertido */
#include<iostream>
int main(){
int N, dig;
cout<<"Ingrese un numero entero: ";
cin>>N;
bool signo; //true si es negativo y false si no lo es
if(N<0) {
signo=true;
N=N*(-1);
}
else signo=false;
//Puedo asegurar que N es positivo aqui
int N_inv=0;
while(N>0){
dig=N%10;
N= N/10; // N/=10 mismo operador
N_inv = N_inv*10 +dig;
}
if(signo)N_inv=N_inv*(-1);
cout<<"El numero invertido es: "<<N_inv<<endl;
return 0;
}

56 | P á g i n a
II. Do While
Los ciclos do-while son una estructura de control cíclica, los cuales nos permiten ejecutar una o varias
líneas de código de forma repetitiva sin necesidad de tener un valor inicial e incluso a veces sin siquiera
conocer cuándo se va a dar el valor final, hasta aquí son similares a los ciclos while, sin embargo el ciclo do-
while nos permite añadir cierta ventaja adicional y esta consiste que nos da la posibilidad de ejecutar primero
el bloque de instrucciones antes de evaluar la condición necesaria, de este modo los ciclos do-while, son más
efectivos para algunas situaciones específicas. En resumen un ciclo do-while, es una estructura de control
cíclica que permite ejecutar de manera repetitiva un bloque de instrucciones sin evaluar de forma inmediata
una condición específica, sino evaluándola justo después de ejecutar por primera vez el bloque de
instrucciones. (Gonzales, 2019)
¿Cómo funciona un Ciclo Do-While?

Imaginemos entonces que, por algún motivo, queremos pedirle a un usuario una serie de números
cualquiera y que solo dejaremos de hacerlo cuando el usuario ingrese un número mayor a 100. Como vimos
anteriormente, esto se puede hacer por medio de un ciclo while, pero vamos ahora a ver como lo podemos
hacer usando un ciclo do-while mejorando así un poco nuestro algoritmo, evitando ciertos comandos, tal
como se dijo con el ciclo while, en efecto aquí estamos en la situación de no tener ni idea de cuándo al usuario
se le va a ocurrir ingresar un número mayor que 100, pues es algo indeterminado para nosotros, sin embargo
el ciclo while y en efecto el do-while nos permite ejecutar cierta acción de forma infinita hasta que se cumpla
alguna condición específica, en nuestro caso sería que el número ingresado sea mayor a 100. De modo que,
si el usuario nos ingresa de manera sucesiva los siguientes números 1,50,99, 49, 21, 30, 100 ..., nuestro
programa no finalizara, pues ninguno de estos números es mayor que 100, sin embargo, si nos ingresara el
número 300, el programa finalizaría inmediatamente.

P á g i n a | 57
Sintaxis
Línea 1:
Esta línea es por decirlo así, la parte novedosa del ciclo do-while, esta expresión no evalúa ninguna
condición ni nada, simplemente da paso directo al bloque de instrucción y luego permite la evaluación de la
condición.
Línea 2:
En la línea 2 tenemos una llave abriendo "{" lo cual como sabemos indica que allí comienza un
bloque de instrucciones que se ejecutaran cada vez que el ciclo de un "giro". Esta llave no es del todo
obligatoria, sin embargo, si no la ponemos solo se ejecutará dentro de nuestro ciclo la primera línea
inmediatamente posterior a la instrucción do, de modo que, si deseamos que se ejecuten varias líneas
dentro de nuestro ciclo, debemos usar las llaves. En lo personal, es preferible poner siempre las llaves sin
importar cuantas líneas se vayan a ejecutar, es una buena práctica de programación y te puede evitar
dolores de cabeza
Línea 3 a 7:
iterativa durante la ejecución del ciclo, este bloque podrá tener la cantidad de líneas necesarias incluso,
como veremos más adelante dentro de estas podría haber uno o más ciclos, así que podrías tener todo un
programa dentro de un ciclo.
Línea 8:
En esta última línea hacemos uso de la llave cerrando "}", una vez más como seguramente ya
debemos saber esta nos indica que allí termina el bloque de instrucciones que se ejecutarán de manera
cíclica y se dará por terminada la ejecución de este para continuar ejecutando el resto del algoritmo.
Línea 9:
La línea 9 en el ciclo do-while, tiene la misma importancia y función que l alinea 1 en la sección del
ciclo while, cabe resaltar que simplemente evalúa la condición y define si se cumple o no para seguir con la
ejecución del ciclo o con la del resto del algoritmo, de este modo podemos ver que el ciclo while y el do-
while son muy similares, con la pequeña diferencia en que en uno se evalúa la condición desde el principio
y en la otra al final de cada ciclo.

58 | P á g i n a
Ejemplo:
/*Escribir un programa que lea un numero N que ea entero y mayor a 10(validar), y muestre en pantalla
la lista de numeros primos que van desde 2 hasta N(inclusive)*/
#include<iostream>
int main(){
float Nf;
do{ //Do normalmente se usa para hacer validaciones
cout<<"Ingrese un numero entero y mayor a 10: ";
cin>>Nf;
}while(Nf!=int(Nf) or Nf<=10); //1 es verdadero, sigue en el ciclo
//inverso, en el negado: while(!(Nf==int(Nf) and Nf>10))
int N=Nf;
int i, j;
bool esPrimo;
//Variable booleana 1 si es primo y cero en caso contrario
cout<<"La lista de nnumeros primos es: "<<endl;
for(i=2;i<=N;i++){
//Recorremos todos los numeros que van desde 2 hasta n con el contador i
// respondemos: es el valor de i un numero primo, si resulta

ser mostramos su valor
esPrimo = true;
for(j=2;j<i;j++){
// Es j un divisor de i?
if(i%j==0){
esPrimo=false;
break;
}//con uno solo ya podemos conseguir al menos 1
}
if(esPrimo) cout<<i<<"\t";
}
cout<<N<<endl;
return 0;
}

P á g i n a | 59
III. For
Los ciclos for son lo que se conoce como estructuras de control de flujo cíclicas o simplemente
estructuras cíclicas, estos ciclos, como su nombre lo sugiere, nos permiten ejecutar una o varias líneas de
código de forma iterativa, conociendo un valor especifico inicial y otro valor final, además nos permiten
determinar el tamaño del paso entre cada "giro" o iteración del ciclo.
En resumen, un ciclo for es una estructura de control iterativa, que nos permite ejecutar de manera
repetitiva un bloque de instrucciones, conociendo previamente un valor de inicio, un tamaño de paso y un
valor final para el ciclo.
¿Cómo funciona un ciclo For?

Para comprender mejor el funcionamiento del ciclo for, pongamos un ejemplo, supongamos que
queremos mostrar los números pares entre el 50 y el 100, si imaginamos un poco como seria esto, podremos
darnos cuenta que nuestro ciclo deberá mostrar una serie de números como la siguiente: 50 52 54 56 58 60
... 96 98 100. Como podemos verificar, tenemos entonces los componentes necesarios para nuestro ciclo for,
tenemos un valor inicial que sería el 50, tenemos también un valor final que sería el 100 y tenemos un tamaño
de paso que es 2 (los números pares). Estamos ahora en capacidad de determinar los componentes
esenciales para un ciclo for.

60 | P á g i n a
Sintaxis
Línea 1:
En esta línea está prácticamente todo lo esencial de un ciclo for. La sintaxis es simple, tenemos una
variable de control llamada i que es tipo entero (int), cabe notar que la variable se puede llamar como
nosotros lo deseemos y puede ser del tipo de queramos también, sin embargo, en la mayoría de los casos se
usa la "i" como nombre y el entero como tipo, pero somos libres de modificar esto a nuestro gusto. Esta
variable "i" se le asigna un valor inicial que puede ser cualquier número correspondiente al tipo de dato
asignado.
Posteriormente lo que haremos será especificar hasta donde irá nuestro ciclo por medio del valor
final, ten en cuenta que cada uno de estos componentes es separado por un punto y coma ";", también es
importante saber que la condición final puede ser cualquier cosa, mayor, menor, mayor o igual, menor o
igual, sin embargo no tiene sentido que la condición sea por ejemplo un igual, pues nuestra variable de
control siempre va a cambiar entre valores, menores o mayores que el valor final deseado, si fuera un igual
no tendríamos un error de sintaxis, pero nuestro for básicamente no haría nada de nada.
Finalmente, el ultimo componente de esta primera línea es el tamaño del paso, este componente se
especifica aumentando en la cantidad deseada la variable de control.
Línea 2:
En la línea 2 tenemos una llave abriendo "{" lo cual como seguramente ya sabrás indica que allí
comienza el bloque de instrucciones que se ejecutaran cada vez que el ciclo de un "giro". Esta llave no es del
todo obligatoria, sin embargo, si no la ponemos solo se ejecutará dentro de nuestro ciclo la primera línea
inmediatamente posterior a la declaración del ciclo, de modo que, si deseamos que se ejecuten varias líneas
dentro de nuestro ciclo, debemos usar las llaves.
Línea 3 a 7:
iterativa durante la ejecución del ciclo, este bloque podrá tener la cantidad de líneas necesarias incluso, como
veremos más adelante dentro de estas podría haber uno o más ciclos, así que podrías tener todo un programa
dentro de un ciclo.
Línea 8:
En esta última línea hacemos uso de la llave cerrando "}", una vez más como seguramente ya sabrás
esta nos indica que allí termina el bloque del ciclo for y se dará por terminada la ejecución de este para
continuar ejecutando el resto del algoritmo. (Gonzales, 2019)

P á g i n a | 61
Ejercicios propuestos sobre estructuras repititivas

/*Escribir un programa que reciba un número entero y positivo. Seguidamente el programa calcular la
suma 1 hasta n:
 No modifique las instrucciones de entrada salida para que el script de testeo pueda evaluar el
resultado.
 Si el numero ingresado no es entero y positivo, imprimir el mensaje "Error, .." según los casos de
prueba.
 La calificación será obtenida aplicando los casos de prueba indicados más abajo.
case="Prueba 1:Entrada no válida"

input=-1
output=Error, el número ingresado debe ser entero y positivo
case="Prueba 2:Entrada real"
input=1.5
case="Prueba 3:Entrada real y negativa"
input=-2.5
case="Prueba 4"
input=10
output=55
case="Prueba 5"
input=100
output=5050*/
#include<iostream>
int main(){
float nf;
int suma=0;
while(nf!=int(nf) or nf<=0){
cout<<"Error, el número ingresado debe ser entero y positivo";
return 0;
}
for(int contador=1; contador<=nf ;contador++)
{
suma+=contador;
}
cout<<"La suma total vale: "<<suma;
///completar de acuerdo a los casos de prueba, imprimir exactamente
el mensaje requerido.
}

62 | P á g i n a
/*Escribir un programa que reciba un número entero y positivo, n (lo valide, es decir pida el numero tantas
veces sea necesario). Seguidamente el programa debe imprimir el numero elevado al cuadrado:
 No modifique las instrucciones de entrada salida para que el script de testeo pueda evaluar el
resultado.
 Si el numero ingresado no es entero y positivo, no se imprime ningún mensaje de error
case="Prueba 1: Entrada 1"

input=-1
1
output=1
case="Prueba 2: Entrada real"
input=1.5
2
output=4
case="Prueba 3: Entrada real y negativa"
input=-2.5
3
output=9
case="Prueba 4"
input=-1
-1.5
-2.5
10
output=100
case="Prueba 5"
input=100
output=10000*/
#include<iostream>
int main(){
float nf;
// no modifique la instrucción de lectura
do{
cout<<"Ingrese un numero entero y positivo: ";
cin>>nf;
}while(nf!=int(nf) or nf<=0);
int M;
M=nf*nf;
cout<<M;
//completar de acuerdo a los casos de prueba.
}

P á g i n a | 63
/*Escribir un programa para encontrar los números perfectos entre 1 y n. Donde n es ingresado por teclado
(debe ser mayor o igual que 1, no es necesario validar). Un número perfecto es un entero positivo que es
igual a la suma de sus divisores propios positivos (sin incluir al número). Así, 6 es un número perfecto
porque sus divisores propios son 1, 2 y 3; y 6 = 1 + 2 + 3.
La calificación será obtenida aplicando los casos de prueba indicados más abajo.
case="Prueba 1: Imprimir los divisores propios de 6 "

input=1
6
output=1
2
3
case="Prueba 2: Imprimir los divisores propios 11"
input=1
11
output=1
case="Prueba 3: Imprimir la suma de los divisores propios de 6"
input=2
6
output=6
case="Prueba 4: Imprimir la suma de los divisores propios de 11"
input=2
11
output=1
case="Prueba 5: lmprimir los números perfectos 1 hasta 100"
input=3
100
output=6
28
case="Prueba 6: lmprimir los números perfectos 1 hasta 500"
input=3
500
output=6
28
496 */

64 | P á g i n a
#include<iostream>
int main(){
float m,n,i,j,suma=0;
cin>>m;
cin>>n;
if(m==1){
for(i=0;i<n;i++){
if(n/i==int(n/i)){
cout<<i<<endl;
}
}
}
else
if(m==2){
for(i=0;i<n;i++){
if(n/i==int(n/i)){
suma+=i;
}
}
cout<<suma;
}
else if(m==3)
for(i=0;i<=n;i++){
for(j=1;j<=i;j++){
if((i/j==int(i/j)) && i/j!=1){
suma=suma+j;
if(suma==i && i!=24){
cout<<suma<<endl;
}
}
}
suma=0;
//cout<<suma<<endl;
}
return 0;
}

P á g i n a | 65
/*Escribir un programa en C++ que la suma de los dígitos pares de un número entero y positivo
Obs. no imprima ningún mensaje adicional
case="Caso1 - 12345"
input=12345
output="6"
case="Caso2 - 389238921"
input=389238921
output="20"*/
#include<iostream>
int main(){
int n, suma=0;
cin>>n;
while(n>0){
if( (n%10)%2==0 ){
suma+=n%10;
}
n=n/10;
}
cout<<suma;
return 0;
}
/*Escribir un programa en C++ que invierta los dígitos de un número entero y positivo
case="Caso1 - 12345"
input=12345
output="54321"
case="Caso2 - 389238921"
input=389238921
output="129832983"*/
#include<iostream>
int main(){
int n, dig;
cin>>n;
int n_inv=0;
while(n>0){
dig=n%10;
n=n/10;
n_inv = n_inv*10 + dig;
}
cout<<n_inv<<endl;
return 0;
}

66 | P á g i n a
/*Escribir un programa en C++ que calcule el enésimo término de la serie de Fibonacci
case="Caso1 - t1"
input=1
output="1"
case="Caso2 - t2"
input=2
output="2"
case="Caso3 -t3"
input=3
output="3"
case="Caso4 -t4"
input=4
output="5"
case="Caso5 -t10"
input=10
output="89"
case="Caso6 -t15"
input=15
output="987"*/
#include<iostream>
int main(){
int n;
cin>>n;
int x=0;
int y=1;
int A=0;
for(int i=0; i<n; i++){
A=y;
y=y+x;
x=A;
}
cout<<y;
return 0;
}

P á g i n a | 67
/*Escribir un programa en C++ que debe solicitar al usuario un número entero y mayor que 2 (validarlo), y
debe imprimir la lista de números primos entre 2 y el número ingresado. Los números mostrados en
pantalla deben estar separados por un espacio simple (ver los dos últimos casos de prueba que están
abajo).
case="Caso1 - Imprime los Primos entre 2 y N=29"

input=29
output="2 3 5 7 11 13 17 19 23 29"
case="Caso2 - valida correctamente negativos? Primos entre 2 y N=11"
input=-1 -2 11
output="2 3 5 7 11"
case="Caso3 - valida correctamente no enteros? Primos entre 2 y N=20"
input=5.6 10.5 20
output="2 3 5 7 11 13 17 19"*/
#include<iostream>
bool primo(int n){
bool condicion;
if(n!=1 and n!=0){
for(int i=2; i<=n; i++){
if(n%i==0){
if(n==i){
condicion = true;
}
else{
condicion = false;
return condicion;
}
}
}
} else condicion= false;

return condicion;
}
int main(){
float n;
do{
cin>>n;
}while(n!=int(n) or n<2);
if(primo(i)){
cout<<i<<"\t";
}
}
return 0;
}

68 | P á g i n a
/*Escribir un programa en C++ que calcule el máximo común divisor (MCD) de dos números A y B (usando
el algoritmo de Euclides)
Obs. no imprima ningún mensaje adicional, solo imprimir el MCD
case="Caso1 - Las entradas son positivas(el programa solo debe aceptar dos números enteros y
positivos)"
input=-1 -3 25 -5 15
output="5"
case="Caso2 - Las entradas no deben ser enteras(el programa solo debe aceptar dos números enteros y
positivos)"
input=1.5 5.4 96 5.5 18
output="6"
case="Caso3 - Las entradas no deben ser enteras y positivas(el programa solo debe aceptar dos números
enteros y positivos)"
input=-1.5 -5 5.4 25 -5.5 20
output="10"
case="Caso4 - Se calcula bien el MCD"
input=96 36
output="12"*/
#include<iostream>
int main(){
float num1f, num2f;//para validar
int num1,num2,mcd;//para calcular
do{
cin>>num1f;
} while(num1f!=int(num1f) or num1f<0);
do{
cin>>num2f;
} while(num2f!=int(num2f) or num2f<0);
num1=num1f;
num2=num2f;
if(num1>num2){
int a;
a=num1%num2;
while(a!=0){
num1=num2;
num2=a;
a=num1%num2;
}
cout<<num2;
}
else{
int a;
a=num2%num1;
while(a!=0){
num2=num1;
num1=a;
a=num2%num1;
}
cout<<num1;
}
return 0;

P á g i n a | 69
}
/*Escriba un programa en C ++ para mostrar el patrón como una triangular usando el alfabeto.
case="Caso1"
input=1
output="A"
case="Caso2"
input=2
output=
"A
ABA"
case="Caso3"
input=3
output=
"A
ABA
ABCBA"
case="Caso4"
input=5
output=
"A
ABA
ABCBA
ABCDCBA
ABCDEDCBA"*/
#include<iostream>
int main(){
int n;
cin>>n;
const char letraA=65;
//cantidad de lineas de la piramide
// j<=i pdepende de i porque i daba la linea
for(int j=0; j<=i; j++){
cout<<char(letraA+j);
}
//k debe decrecer para que imprima de forma inversa, es decir
C B A
for(int k=i-1; k>=0; k--){
cout<<char(letraA+k);
}
cout<<endl;
}
return 0;
}

70 | P á g i n a
/* Escriba un programa en C ++ que imprima el patrón utilizando potencias de 2.

case="Caso1"
input=1
output="*********1"
case="Caso2"
input=2
output=
"***********1
********1**2**1**"
case="Caso3"
input=3
output=
"*************1
**********1**2**1**
*******1**2**4**2**1**"
case="Caso4"
input=5
output=
"*****************1
**************1**2**1**
***********1**2**4**2**1**
********1**2**4**8**4**2**1**
*****1**2**4**8**16**8**4**2**1**" */
#include<iostream>
#include<math.h>
int main(){
int n;
cin>>n;
for(int i=0;i<n;i++){
for(int j=0;j<9+2*(n-1)-3*i;j++){
cout<<"*";
}
if(i==0){
cout<<1;
cout<<endl;
}else{
for(int j=0;j<=i;j++){
cout<<pow(2,j)<<"**";
}
for(int j=1;j<=i;j++){
cout<<pow(2,i-j)<<"**";
}
cout<<endl;
}
}
return 0;
}

P á g i n a | 71
Unidad 5: Funciones
¿Qué es una función?
Una función realiza una tarea concreta y puede ser diseñada, implementada y depurada de manera
independiente al resto de código. También se le conoce como divide y vencerás, por dividir los problemas
en pequeños problemas.
Definición de funciones
La sintaxis básica para definirla es:
Tipo nombre (tipo var1, tipo var2, …, tipo varn) {
Conjunto de instrucciones;
…
…
}
Ejemplos de funciones
- Int numMax (int x, int y)
- Double intercambio (double x, double y)
- Void desplegar (float x, float y)
Sintaxis general
Para tener una buena práctica a la hora de programar debemos tener en cuenta la siguiente forma:
directivas del preprocesador
prototipo de función
int main () {
conjunto de instrucciones;
return valor;
}
definición de función

72 | P á g i n a
Ejemplo
//encontrar el mayor entre dos números
#include<Iostream>
#include<conio.h>
//Prototipo de funcion
int encontrarmax(int x, int y);
int main () {
iny mayor;
int n1, n2;
cout<< ”Digite 2 números: ”;
cin>>n1, n2;
mayor=encontrarMax(n1, n2);
cout<<mayor;
getch();
return 0;
}
//Prototipo de funcion
Int encontrarMax(int x, int y){
int numMax;
if(x > y){
numMax=x;
}
else{
numMax=y;
}
Return numMax;
}

P á g i n a | 73
Números aleatorios
Una característica importante en los lenguajes de programación es la posibilidad de generar
números aleatorios.
Normalmente tomamos como ejemplo al dado, usualmente no podemos predecir que numero
saldrá, pero en las computadoras ya tenemos una secuencia ya pre hecha.
Funcion rand ()
Se encuentra en la librería cstdlib, y devuelve un número entero entre 0 y una constante
RAND_MAX (en la misma librería)
Ejemplo 1
#include<Iostream>
Using namespace std;
#include<cstdlib>
Int main() {
Int i=0;
For (i=0; i<10; i++) {
Cout<<rand()%100<<endl;
}
Return 0;
}
El problema presente es que aún no introdujimos ninguna noción de aleatoriedad, para ello
debemos inicializar la función rand(), que recibe como argumento un número entero sin signo.
Solución: Semilla
Definimos a la semilla utilizando la funcion srand()
Pero, si en cada ejecución se inicializa al rand() con la misma semilla, entonces generará los mismos
números aleatorios. Para solucionar este inconveniente utilizaremos la función time() definida en la
biblioteca ctime.
#include<Iostream>
#include<cstdlib>
#include<ctime>
Int main() {
Int i=0;
Srand(time(NULL));
For (i=0; i<10; i++) {
Cout<<rand()%100<<endl;
}
Return 0;
}
Acotando los valores para rand(): Podemos limitar el rango de números aleatorios que entrega rand(),
podemos definir el valor inicial (el predeterminado es 0) y el límite superior.
Definiendo un límite superior para rand(): Para definir un límite superior, se utiliza la notación de módulo
(%), a continuación se indica el valor máximo que se desea. por ejemplo.
valor = rand() % 2; // Obtiene valores entre 0 y 1

74 | P á g i n a
Ejemplo 2
/* Realice un programa que solicite al usuario que piense un numero entero entre 1 y 100. El programa
debe generar un número aleatorio en ese mismo rango (1-100), e indicarle al usuario si el número que
digito es menor o mayor al número aleatorio, así hasta que lo adivine, y por ultimo mostrarle el número
de intentos que le llevo.
Variable= limite_inf +rand() % (limite_superior +1-limite_inferior); */

#include<Iostream>
#include<stdlib.h>
#include<time.h>
int main(){
int numero, dato, contador=0;
Srand(time(NULL)); //genera al numero aleatorio;
Dato = 1 + rand()%(100+1-1);
do{
cout<<”Digite un numero: “;
cin>>numero;
if(numero>dato){
cout<<”\nDigite un numero menor\n”;
}
if(numero<dato){
cout<<”\nDigite un numero mayor\n”;
}
contador ++
} while(numero!=dato);
cout<<”Felicidades adivinaste el numero”<<endl;
cout<<”Numero de intentos: “<<contador<<endl;
system(“pause”);
return 0;
}

P á g i n a | 75
Ejercicios propuestos sobre funciones y números aleatorios

/* Escriba una función valide un numero entro y positivo. */
#include<iostream>
void imprimir(float n){
do{
cout<<"\tIngrese un numero entero y positivo: ";
cin>>n;
}while(n!=int(n) or n<=0);
n=int(n);
}
int main(){
float n;
imprimir(n);
cout<<"\n\tCorrecto!!";
return 0;
}
/*Escriba un programa en C++ que lea un número entero y positivo, obtenga e imprima todos sus
factores primos. */
#include<iostream>
//factores que son primos
bool esPrimo(int n){
bool bandera;
int i, aux=0;
for(i=2; i<=n; i++){
if(n%i==0){
if(n==i){
bandera=true;
break;
}
else{
bandera=false;
break;
}}}}
//Imprime los nros primos
void imprimir_primos(int n){
int aux1;
aux1=n%i;
if(aux1==0){
if(esPrimo(i)){
cout<<" "<<i<<",";
}}}}
int main(){
float n;
do{
cout<<"\tIngrese un numero entero y positivo: ";
cin>>n;
}while(n!=int(n) or n<=0);
n=int(n);
cout<<"\tLos factores primos de "<<n<<" son: ";

76 | P á g i n a
imprimir_primos(n);
cout<<"\n\tCorrecto!!";
return 0;
}
//Otra forma
#include<iostream>
using namespace std;sm
void verif(float n){
while(n<=0 or n!=int(n)){
cout<<"\tVuelva a ingresar un valor: ";
cin>>n;
}
cout<<"\n\t\tCorrecto, "<<n<<" es un entero y positivo"<<endl;
}
void primos(int n){
n=int(n);
cout<<"\n\tLos factores primos son: ";
if(n%i==0){
cout<<i<<"\t";
}}}
int main(){
float n;
cout<<"\tIngrese un valor entero y positivo: ",
cin>>n;
verif(n);
primos(n);
return 0;
}

P á g i n a | 77
/* Utilizar la función rand() y srand() para crear una función que genere números
aleatorios entre 100 y 1000.*/
//Numeros aleatorios
#include<iostream>
#include<cstdlib>
#include<ctime>
int main(){
int a, b, c, generado;
srand(time(NULL));
int n;
cout<<"Ingrese la cantidad de numeros aleatorios que quiera: ";
cin>>n;
cout<<"Tenemos: \n";
generado=100+rand()%(1000-100+1);
cout<<generado<<" ";
}
return 0;
}
//Numeros pseudoaleatorios
#include<iostream>
#include<cstdlib>
int main(){
int a, b, c, generado, semilla;
cout<<"Ingrese la semilla: ";
int SEMILLA;
cin>>SEMILLA;
srand(SEMILLA);
int n;
cout<<"Ingrese la cantidad de numeros aleatorios que quiera: ";
cin>>n;
cout<<"Tenemos: \n";
generado=100+rand()%(1000-100+1);
}
return 0;
}

78 | P á g i n a
/* Escriba una función en C++ que reciba dos enteros positivos N y C. Esta función debe retornar a cantidad
de números primos de C dígitos que pueden formarse con los dígitos de N. Para formar los números a
comprobarse, deben tomarse los dígitos contiguos de N en forma ordenada (de izquierda a derecha), así
como se muestra en los ejemplos. Si en el proceso se generan números “repetidos”, se cuenta por cada
uno de ellos (se muestra un ejemplo).
N C NumVer Ctd No primo
13787 1 1, 3, 7, 8, 7 2
144 1 1, 4, 4 3
13787 2 13, 37, 78, 87 2
Observaciones:
 Si C supera la cantidad de dígitos de N, entonces la función retorna -1.
 N siempre es positivo y mayor que cero.
 Considerar al número 1 como “no-primo”.
 Considerar a C siempre como un entero mayor que cero.
 No modificar la función principal (main).
Sugerencias: se encuentran implementadas tres funciones que podrían ser de utilidad
1. int potencia(int a, int b): función que devuelve al valor de a^b, donde b es un número no-negativo.
2. bool esPrimo(int n): función que devuelve true si el número n es primo, y false en caso contrario. Se
supone que n es positivo.
3. int cantDigitos(int n): Función que devuelve la cantidad de dígitos de un número n. Se supone que n es
positivo. */
#include<iostream>
#include<cmath>
/*Función que devuelve el resultado de a^b.
Se supone que b es un número no-negativo.*/
int potencia(int a, int b){
int i, p=1;
for(i=0;i<b;i++) p*=a;
return p;
}
/*Función que devuelve true si el número n es primo, y false en caso
contrario.
Se supone que n es positivo.*/
bool esPrimo(int n){
if(n==1) {
return false;
}
else{
int i;
for(i=2;i<=sqrt(n);i++){
if(n%i==0) {
return false;
}}
return true;
}}
/*Función que devuelve la cantidad de dígitos de un número n.
Se supone que n es positivo.*/
int cantDigitos(int n){
int dig=0;
while(n>0){
dig++;

P á g i n a | 79
n/=10;
}
return dig;
}
/*Función solicitada para el problema planteado.*/
int cantNoPrimos_C_Digitos(int N, int C){
int M;
int cont=0;
if(cantDigitos(N)>=C){
while(cantDigitos(N)>=C){
M=N%potencia(10,C);
N=N/10;
if(esPrimo(M)==false){
cont=cont+1;
}}
return cont;
}
else{
return -1;
}}
/*Función principal*/
int main(){
int N,C;
cin>>N>>C;
cout<<"Cantidad de no-primos de "<<C<<" digitos:
"<<cantNoPrimos_C_Digitos(N,C)<<endl;
return 0;
}

80 | P á g i n a
/*Implemente el cifrado de un número entero positivo N, validar. El método a utilizar es el siguiente:

Reemplazar cada dígito d del número N por: (d+7) resto 10. (Ejemplo N = 2463 el cifrado del número será
9130).
2 + 7 = 9 % 10 = 9
4 * 7 = 11 % 10 = 1
6 + 7 = 13 % 10 = 3
3 + 7 = 10 % 10 = 0
case="Caso1 - Validacion"
input= 0 -23 2463
output="9130"
case="Caso2 - Validacion 2"
input= 23.5 2547
output="9214"
case="Caso3 "
input=1500
output="8277"
case="Caso4 "
input=456987
output="123654"
*/
#include<iostream>
#include<math.h>
// se valida que sea entero y positivo y el tipo de variable que que va
recibir como parametro la funcion
int validar (float n){
do{
cin>>n;
} while(n!=int(n) or n<=0);
n=int(n);
}
// Se completa el tipo de variable de retorno y el codigo de la función
/* tipo de variable de retorno */
int codificado(int val){
int a, b, c, suma=0;
for(int i=0; i<=val+2; i++){

a= val%10;
b= (a+7)%10;
c= b*pow(10,i);
suma=suma+c;
val=val/10; }
return suma; }
int main(){
float n;
int resul, val;
val = validar(n);
resul = codificado(val);
cout<<resul;
return 0;
}

P á g i n a | 81
/*Diseñar un programa en C/C++ tal que lea un dos número entero, mayor que 100 y menor que 32000, y
a continuación imprima en pantalla si son o no números amigos. OBS: Dos números amigos son dos enteros
positivos a y b tales que a es la suma de los divisores propios de b, y b es la suma de los divisores propios
de a. (la unidad se considera divisor propio, pero no lo es el mismo número).
Un divisor propio de un número n es cualquier divisor que no es el mismo número que el que divide.
Probar con (220, 284), (1184, 1210), (17.296, 18.416)*/

#include<iostream>
int validar (float n){
do{
cin>>n;
} while(n!=int(n) or n<=100 or n>=32000);
n=int(n);
return n;
}
void numeroamigo(int d, int e){
int suma1=0, suma2=0, aux1, aux2;

bool bandera=true;
for(int i=1; i<d; i++){

aux1=d%i;
if(aux1==0){
suma1=suma1+i;
}}
for(int j=1; j<e; j++){
aux2=e%j;
if(aux2==0){
suma2=suma2+j;
}}
if(e==suma1 and d==suma2){
bandera=true;
cout<<"Son numeros amigos";
}else{
bandera=false;
cout<<"No son numeros amigos";
}}
int main(){
float a, b;
int d,e;
d= validar(a);
e= validar(b);
numeroamigo(d,e);
}

82 | P á g i n a
/* Ingrese una variable entera N y a partir de ese valor genere la figura del diamante como muestra los
ejemplos */
#include<iostream>
void t_isosceles(int n){
int i, j, k, l;
//Necesiaamos un guion por cada fila a excepcion de la ultima
if(i<n){
for(int j=0;j<n-i-1 ;j++){
cout<<"-";
}
for(int k=0; k<2*i+1; k++){
cout<<"*";
}
cout<<endl;
}}
for(int h=n-2; h>=0 ; h--){
for(int l=0; l<n-h-1 ; l++){

cout<<"-";
}
for(int m=0; m<2*h+1; m++){
cout<<"*";
}
cout<<endl;
}}
main(){
int n;
cin>>n;
t_isosceles(n);
return 0;
}

P á g i n a | 83
/*Escriba un programa que genere números pseudoaleatorios para pasar los siguientes casos de prueba:
case="Caso1 opcion 1 imprimir 10 números entre 2 y 15"
input=1
2 15
output="3 6 11 7 3 5 12 4 3 5 "
input=1
5 30
output="18 27 16 22 6 6 17 21 6 12 "
case="Caso3 opcion 2 generar 100 números entre 1 y 100 y contar(imprimir) cuantos hay entre entre 3 y
13"
input=2
3 13
output="Se generaron 8 números entre 3 y 13"
case="Caso4 opcion 2 generar 100 números entre 1 y 100 y contar(imprimir) cuantos hay entre entre 10 y
20"
input=2
10 20
output="Se generaron 9 números entre 10 y 20"
case="Caso5 opcion 3 generar 100 números entre 1 y 10, y contar cuantos estan entre 1-3,4-6,7-9"
input=3
100
output="Se generaron 27 números entre 1 y 3
Se generaron 28 números entre 4 y 6
Se generaron 29 números entre 7 y 9"
case="Caso6 opcion 3 generar 200 números entre 1 y 10, y contar cuantos estan entre 1-3,4-6,7-9"
input=3
200
output="Se generaron 53 números entre 1 y 3
Se generaron 56 números entre 4 y 6
Se generaron 72 números entre 7 y 9"
Variable= limite_inf +rand() % (limite_superior +1-limite_inferior);
*/
#include <iostream>
#include<cstdlib> //contiene las función rand()
#define SEMILLA 1 // para el srand
void imprimirMensaje(int n, int a, int b){
cout<<"Se generaron "<<n<<" numeros entre "<<a<<" y "<<b<<endl;
}
int main () {
int generado,accu,a,b,n,opcion;
cout<<"\tIngrese la opcion: ";
cin>>opcion;
switch(opcion){
case 1://generar 10 números entre a y b
cout<<"Ingrese el limite inferior: ";
cin>>a;
cout<<"Ingrese el limite superior: ";
cin>>b;
srand(SEMILLA);

84 | P á g i n a
for(int i=0; i<10;i++){

generado= a+rand()%(b+1-a);
n=i;
}
break;
case 2:
srand(SEMILLA);
//generar 100 números entre 1 y 100 y contar cuantos estan
entre a y b
cout<<"Ingrese a: ";
cin>>a;
cout<<"Ingrese b: ";
cin>>b;
accu=0;
for(int j=0; j<100; j++){
generado= 1+rand()%(100+1-1);
if(generado>=a and generado<=b){
accu=accu+1;
}}
imprimirMensaje(accu, a, b);
break;
case 3:
srand(SEMILLA);
cout<<"Ingrese la cantidad de numeros a generar: ";
cin>>n;
int aux1=0, aux2=0, aux3=0;
for(int k=0; k<n; k++){
generado= 1+rand()%(10);
if(generado>=1 and generado<=3){

aux1=aux1+1;
}
aux2=aux2+1;
}
aux3=aux3+1;
}}
imprimirMensaje(aux1, 1, 3);
break;
}
return 0;
}

P á g i n a | 85
Los métodos de Monte Carlo son una amplia clase de

algoritmos computacionales que se basan en un muestreo aleatorio
repetido para obtener resultados numéricos. Uno de los ejemplos
básicos de cómo empezar con el algoritmo de Monte Carlo es la
estimación de Pi.
La idea es simular puntos aleatorios (x, y) en un plano 2-D con

dominio como un cuadrado de lado 1 unidad. Imagina un círculo
dentro del mismo dominio con el mismo diámetro e inscrito en el
cuadrado. Luego calculamos la proporción de puntos numéricos que
se encuentran dentro del círculo y el número total de puntos
generados.
Sabemos que el área del cuadrado (que va de -1 a 1) es 4

mientras que la del círculo es pi (R)2=pi, donde R=1. Por lado el área
del sector circular de área pi/4 sobre el área del cuadrado (de 0 a 1)
va ser proporcional al número de puntos dentro del sector, (a) sobre
el número de puntos dentro del cuadrado, (b). Es decir, (pi/4) /1≈a/b,
luego pi≈4(a/b)
La belleza de este algoritmo es que no necesitamos ningún

gráfico o simulación para mostrar los puntos generados. Simplemente
generamos pares aleatorios (x, y) y luego verificamos si x2 +y2 <= 1.
En algoritmos aleatorios y de simulación como Monte Carlo, cuanto
mayor es el número de iteraciones, más preciso es el resultado. Por
lo tanto, se "Estima el valor de Pi", no se "Calcula el valor de Pi".
/*Generar el número de pi

input=1
output="0.8973 0.6202 0.4625 0.5469 0.2038 0.5916 0.3405 0.5533 0.7004 0.2469 "
case="Caso2 opcion 2 generar 10 puntos y contar cuantos están en el circulo"
input=2
10
output="Se generaron 6 números dentro del circulo"
case="Caso3 opcion 2 generar 50 puntos y contar cuantos están en el circulo"
input=2
50
output="Se generaron 39 números dentro del circulo"
case="Caso4 opcion 3 estimar pi con 10 puntos"
input=3
10
output="El valor estimado de pi es 2.4"
input=3
50
input=3
500

86 | P á g i n a
#include <iostream>
#include<cstdlib> //contiene las función rand()
#include<ctime> //para inicializar rand()
#define SEMILLA 1
#define INTERVALO 10000
void imprimirMensajeOpcion2(int n){
cout<<"Se generaron "<<n<<" números dentro del circulo";
}
void imprimirMensajeOpcion3(double pi){
cout<<"El valor estimado de pi es "<<pi;
}
double estimarPi(int n){
float x,y,d;
int accu2=0;
srand(SEMILLA);
for(int i=1;i<=n;i++){
x=(float)(0+rand()%(INTERVALO+1-0))/INTERVALO;
y=(float)(0+rand()%(INTERVALO+1-0))/INTERVALO;
if((x*x+y*y)<=1){
accu2++;
}}
d=accu2;
return d;
}
int main () {
int i,n,opcion,accu;
float aux1;
cout<<"Ingrese la opcion: ";
cin>>opcion;
switch(opcion){
case 1://generar 10 números entre 0 y 1
srand(SEMILLA);
for(int i=1; i<=10; i++){
aux1=(float)(0+rand()%(INTERVALO+1-0))/10000;
cout<<aux1<<" ";
}
// note que con la semilla se fija la secuencia de
números que es siempre la misma
break;
case 2:
srand(SEMILLA);
//generar dos pares n números entre 0 y 1 y verificar
cuantos estan dentro del circulo de radio 1
cin>>n;
float x,y;
x=(float)(0+rand()%(INTERVALO+1-0))/INTERVALO;
y=(float)(0+rand()%(INTERVALO+1-0))/INTERVALO;
if((x*x+y*y)<=1){
accu++;
}}
imprimirMensajeOpcion2(accu);

P á g i n a | 87
break;
case 3:
cin>>n;
float pi=estimarPi(n);
pi=(pi/n)*4;
// Estimar pi con n números aleatorios 4 veces la relacion de
números dentro del circulo sobre los números generados
//completar ;
//completar =estimarPi(n);
imprimirMensajeOpcion3(pi);
break;
}
return 0;
}
/* Utilice la función rand para definir una función que genere una secuencia
fija(semilla=1) de 100 números aleatorios entre 9 y 14 enteros y cuente cuantas
veces salió cada número. */
#include<iostream>
#include<cstdlib>
#define SEMILLA 1
int main(){
int a, N1=0, N2=0, N3=0, N4=0, N5=0, N6=0;
srand(SEMILLA);
for(int i=0; i<100; i++){
a=9+rand()%(14-9+1);
cout<<a<<" ";
if(a==9){
N1++;
}else if(a==10){
N2++;
}else if(a==11){
N3++;
}else if(a==12){
N4++;
}else if(a==13){
N5++;
}else if(a==14){
N6++;
}}
cout<<endl;
cout<<"\tEl 9 aparece "<<N1<<" veces."<<endl;
return 0;
}

88 | P á g i n a
/*Escribir un programa que cuente la cantidad de números de Armstrong y de números perfectos

ingresados por teclado.
Considerando que:
Un número de Armstrong es un número de n dígitos que es igual a la suma de las enésimas potencias de
sus dígitos. Un número perfecto es un entero positivo que es igual a la suma de sus divisores positivos
excluyendo el número mismo
Observaciones
El programa termina su ejecución cuando se ingresa un número menor a 1 o mayor que 1000. (Verificar
ejemplo propuesto)
Los casos de pruebas aplicadas son las siguientes:
- case=Prueba 1
input=1
1001
output=1
0
- case=Prueba 2
input=157
1001
output=0
0
- case=Prueba 3
input=371
1001
output=1
0
- case=Prueba 4
input=496
1001
output=0
1
- case=Prueba 5
input=157
371
496
1001
output=1
1*/
#include <iostream>
#include<math.h>
int cantDigitos(int n){
int dig=0;
while(n>0){
dig++;
n/=10;
}
return dig;
}
int checkArmstrong(int dig, int n){

P á g i n a | 89
int a, b, c=n, suma=0;

while(n>0){
a=n%10;
b=pow(a,dig);
suma=suma+b;
n=n/10;
}
if(c==suma){
return 1;
} else{
return 0;
}}
int checkPerfect(int n1){
int i,a, suma=0, b=n1;
if(n1>1){
for(i=1; i<n1; i++){
a=n1%i;
if(a==0){
suma=suma+i;
}}
if(suma==b){
return 1;
}else{
return 0;
}
}else{
return 0;
}}
int main()
{
int n=1,accuArm=0,accuPerfect=0;
int dig;
while(n>0 and n<=1000){
cout<<"Ingrese un numero valido entre 1 y 1000: ";
cin>>n;
dig=cantDigitos(n);
accuArm=accuArm+checkArmstrong(dig, n);
accuPerfect=accuPerfect+checkPerfect(n);
}
cout<<"\t"<<accuArm<<endl;
cout<<"\t"<<accuPerfect<<endl;
return 0;
}

90 | P á g i n a
/*Escriba un programa en C++ que lea un número entero y positivo (validar). Obtenga
un nuevo número invirtiendo el orden de sus cifras y determine la diferencia entre el
numero obtenido y el ingresado por teclado (restar el mayor del menor) */
#include<iostream>
#include<math.h>
void verif(float n){
cout<<"\tVuelva a ingresar un valor: ";
cin>>n;
}
cout<<"\n\t\tCorrecto, "<<n<<" es un entero y positivo"<<endl;
}
void inv(int n){
n=int(n);
int j=n, p=n;
int a, dig=0, b,c, aux=0;
while(j>0){
dig++;
j/=10;
}
cout<<"\n\tLa cantidad de digitos es: "<<dig<<endl;
for(int i=0; i<dig; i++){

a=n%10;
b=a*pow(10, dig-i-1);
aux=aux+b;
n=n/10;
}
cout<<"\n\tEl numero invertido es: "<<aux;
if(p==aux){
cout<<"\n\tLa diferencia es: "<<p-aux;
}else if(p>aux){
cout<<"\n\tLa diferencia es: "<<p-aux;
}else if(p<aux){
cout<<"\n\tLa diferencia es: "<<aux-p;
}}
int main(){
float n;
cout<<"\tIngrese un valor entero y positivo: ",
cin>>n;
verif(n);
inv(n);
return 0;
}

P á g i n a | 91
/*La conjetura de Goldbach afirma que: "Todo número par mayor a 2 puede escribirse como la suma de
dos números primos". Ejemplo: 20=13+7; 50=19+31. Elabore un programa que calcule las posibles sumas
de Goldbach de un número. */
#include<iostream>
#include<math.h>
int espar(int n){
do{
cout<<"Introduzca un numero par mayor a dos: ";
cin>>n;
}while(n<=2 or n%2!=0);
return n;
}
bool esprimo(int n){
if(n==1) {
return false;
}
else{
int i;
for(i=2;i<=sqrt(n);i++){
if(n%i==0) {
return false;
}}
return true;
}}
int main(){
int n, N;
n=espar(n);
int a, b, c=n, d;
for(int j=0; j<i; j++){
a=i+j;
if(a==n and esprimo(i) and esprimo(j)){
cout<<"El numero "<<n<<" es igual a la suma de:
"<<i<<" y "<<j<<", dos numeros primos."<<endl;
}}}
return 0;
}

92 | P á g i n a
/*. Ingresar por teclado un numero entero mayor que 1000, validarlo, determinar e imprimir el menor de
sus dígitos primos y la suma de sus dígitos*/
#include<iostream>
int val(float x);
void dig(int x);
bool primo(int x);
int main(){
int n; //probar con float n; despues
n=val(n);
dig(n);
return 0;
}
int val(float x){
do{
cout<<"Ingrese un numero mayor a 1000: ";
cin>>x;
}while(x<1000 or x!=int(x));
x=int(x);
return x;
}
void dig(int x){
int dig, suma=0, m, aux=0;
while(x>0){
dig=x%10;
if(primo(dig)){
if(dig<=aux){
m=dig;
}
if(dig>=aux){ //Probar aca con un else if
m=aux;
}}
if(primo(dig)){
aux=dig;
}else if(dig==1){
m=dig;
}
suma=suma+dig;
x=x/10;
}
cout<<"La suma de los digitos es: "<<suma<<endl;
if(m==1) cout<<"No tiene numeros primos";
if(m==0) cout<<"El menor primo es: "<<aux<<endl;
if(m>1) cout<<"El menor primo es: "<<m<<endl;
}
bool primo(int x){
bool primo=true;
if(x==0 or x==1) return false;
for(int i=2; i<x; i++){
if(x%i==0){

P á g i n a | 93
primo=false;
break;
}}
if(primo) return true;
else return false;
}

94 | P á g i n a
Unidad 6: Recursividad
Algoritmos recursivos
Expresa la solución de un problema en términos de una llamada a sí mismo. La llamada a si mismo se conoce
como llamada recursiva o recurrente
Ejemplo: factorial de un numero natural N
N! = 1*2*3*…*(N-1)*N
N! = (1*2*3*…*(N-1))*N
N! =(N-1)!*N
Llamada recursiva
Características
1. La función se llama a si misma

N! =(N-1)!*N
Caso más pequeño del problema mismo
2. Tiene que existir una situación en la que ya no hay una nueva autollamada, sino un resultado o acción
(o sino el proceso sería infinito). Esta situación se denomina caso baso y permite que se salga de la
recursión.
El caso base seria 1!=1
Int factorial (int n) {
If(n==1) {
Return 1;
}else{
Return n*factorial (n-1);
}}
Facto (N) = facto(N-1) *N
Facto (N-1) = facto(N-2) *(N-1)
Facto (3) = facto(2) *3
Facto (2) = facto(1) *2
Facto (1) = 1
Recursión
long long factorial (int n){
long long facto;
if(n==0= return 1; //caso base
facto=n*factorial(n-1); //llamada recursiva
return facto;
}
Bucle
long long factorial (int n){

P á g i n a | 95
long long facto=1;

int i;
for(i=2; i<=n;i++) facto*=i;
return facto;
}
 Se puede utilizar la recursividad como una alternativa a los bucles. De hech0, ciertas soluciones salen
de manera más “natural” utilizando la recursividad (por las características de los problemas, como
por ejemplos se tienen muchos problemas matemáticos).
 Una solución recursiva es normalmente más lenta que una con bucle, debido a las operaciones
auxiliares que llevan consigo las llamadas sucesivas de funciones. Además, cada uno de los procesos
pendientes de resultado ocupan espacio en memoria.
Ejemplos
- A través de una función recursiva, calcular a´b, donde a es un entero y b un numero natural
- Calcular la suma de todos los números enteros entre 1 y N, siendo N un número natural.
Recursividad vs Iteración
Aspectos que hay que considerar al decidir cómo implementar la solución a un problema:
- La carga computacional (tiempo CPU y espacio en memoria) asociada a las llamadas

recursivas.
- La redundancia (algunas soluciones recursivas resuelven un problema en repetidas
ocasiones).
- La complejidad de la solución (en ocasiones, la solución iterativa es muy difícil de encontrar)
- La concisión, legibilidad y elegancia del código resultante de la recursividad del problema.

96 | P á g i n a
Ejemplo 1
//Calcular x^n
float X_n(float x, int n){
//Recibe el flotante de base y un entero de exponente
if(n==0){
return 1;
}else{
return x*X_n (x, n-1);
}
}
Ejemplo 2
//Calcular el enésimo término de la sucesión de Fibonacci, donde cada termino es la suma de los dos
anteriores, y sabiendo que los dos primeros términos son 0 y 1 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, ...
//forma iterativa
int fibonacci (int n){
int actual, ant1, ant2;
ant1=1;
ant2=1;
if((n==0) || (n==1)){
actual=1
}else{
actual= ant1+ant2;
ant2=ant1;
ant1=actual;
}
}
return (actual);
}
// forma recursiva
int fibonacci (int n){
if((n==1)){
return 0;
}else{
if((n==2)){
return 1;
}else{
return fibonacci(n-1)+fibonacci(n-2);
}}}

P á g i n a | 97
Ejemplo Hanoi
void hanoi (int inicio, int fin, int centro, int n){
if(n==1){
cout<<”mover disco 1 de la varilla ”<<inicio<<” a la varilla ”<<fin<<endl;
}
else{
haroi(inicio, centro fin, (n-1));
cout<<”Mover disco “<<n<<” de la varilla “<<inicio<<” a la varilla
“<<fin<<endl;
Hanoi(centro, fin, inicio, (n-1));
}
}
https://www.youtube.com/watch?v=_0yqsR8EIJ4
https://www.geeksforgeeks.org/c-plus-plus/
https://www.hackerrank.com/domains/cpp
s

98 | P á g i n a
Ejercicios propuestos sobre la recursividad

/*Escribir un programa que reciba un número entero y positivo. Seguidamente el programa debe calcular
el factorial de forma recursiva*/
#include<iostream>
//Recomendamos devolver una variable del tipo long long
long long factorial(long);
int main(){
int n;
cout<<"Introducir un valor para n: ";
cin>>n;
cout<<factorial(n);
//completar de acuerdo a los casos de prueba, imprimir exactamente el mensaje requerido.
return 0;
}
long long factorial (long n){
if(n==0){
n=1;
}else{
n=n*factorial(n-1);
}
return n;
}
Ejemplo: https://youtu.be/i9roxX8z7tk
/* Lea un numero N entero y positivo e imprima la serie de Fibonacci hasta la posición N,
comenzando desde Fibonacci(0)=1 y Fibonacci(1)=1. */
#include<iostream>
long long fibonacci(long;
int main()
{
int n;
cin>>n;
for (int i=0; i<=n; i++)
cout<<fibonacci(i)<<endl;
return 0;
}
long long fibonacci(long x){
long aux;
if(x==0 or x==1){
return 1;
}else{
aux=fibonacci(x-1)+fibonacci(x-2);
return aux;
}
}

P á g i n a | 99
/*Escribir un programa que muestre el máximo común divisor (MCD) de dos números A y B
(usando el algoritmo de Euclides) */
#include<iostream>
int mcd(int, int);
int main()
{
int A,B;
cin>>A>>B;
cout << "El MCD resultante es "<< mcd(A,B)<<endl;
return 0;// no utilice system(pause)
}
int mcd(int a, int b){
int c, d;
if(a==0){
return b;
} else if(b==0){
return a;
}else{
c=a%b;
return mcd(b,c);
}}
/*Elaborar un programa que valide un numero entero y positivo mediante una función no recursiva, y
luego imprima en pantalla su número en binario mediante una función recursiva.
Ejemplo: Para n=5, se muestra en pantalla 101. Para n=12, se muestra en pantalla 1100*/
#include<iostream>
void binario(int n)
{
if(n==0 or n==1){
cout<<n;
}
else{
binario(int(n/2));
cout<<n%2;
}}
int validar()
{
float n;
cout<<"Ingrese un numero: "<<endl;
cin>>n;
while(n<0 or n!=int(n)){
cout<<"Error";
cin>>n;
}
n=int(n);
}
int main( )
{
int nro=validar();
binario(nro);
return 0;
}

100 | P á g i n a
/*Escriba un programa que permita al usuario introducir un número entero y positivo, y luego imprimir
en pantalla el numero invertido. Ejemplo: Para a=1234, se debe imprimir 4321*/
Forma 1
#include<iostream>
int main(){
int invertir(int, int);
int num;
cout<<"Ingrese el numero: ";
cin>>num;
cout<<"El numero invertido es: "<<invertir(num, 0);
return 0;
}
int invertir(int num, int numInver){
if(num>0){
return invertir(num/10, num%10+numInver*10);
}else{
return numInver;
}}

P á g i n a | 101
Unidad 7: Arrays unidimensionales o Vectores

Un arreglo es una secuencia de posiciones de memoria que contiene datos del mismo tipo, los cuales
pueden ser seleccionados individualmente mediante el uso de índices (podemos decir entonces que es una
colección de variables simples del mismo tipo). Los vectores (arreglos de una dimensión) nos permitirán
aumentar el abanico de problemas que podemos resolver, considerando las limitaciones de trabajar
únicamente con variables simples.
Pregunta 1: ¿Cómo podríamos ordenar N enteros utilizando variables simples?

{5, 1, 8, 7, 3, 4, …} y si tenemos mil? No va a ser útil con una serie de If
Necesitamos una forma de conjunto de datos, y poder determinarlo en tiempos de ejecución.
Pregunta 2: ¿Cómo calcularías la cantidad de alumnos que obtuvieron una nota inferior al
promedio del curso en cierta materia?
Calcular el promedio e ir cargando los números. Pero necesitamos almacenar cada nota para poder
ir comparando.
Estructura de datos
Para salvar estas situaciones, la mayoría de los lenguajes de programación incluyen características
de estructuras de datos. Una estructura de datos es una colección de datos que pueden ser caracterizados
por su organización y las operaciones que se definen en ella (acceso, inserción, borrado)
Se dividen en:
 Estáticas (tamaño definido de antemano): arreglos, registros.

 Dinámicas (no tienen limitaciones de tamaño): Listas (pilas/colas), listas, enlazadas, árboles, grafos.
Estructuras de datos
 Primitivos
- Int, Float, Char, Double, Puntero
 No primitivos
- Lineal
1. Arreglo
2. Pila
3. Cola
4. Lista enlazada
- No lineal
1. Árbol
2. grafo
Arreglos
Un arreglo es una secuencia de posiciones de la memoria central a las que se puede acceder directamente,
que contiene datos del mismo tipo y pueden ser seleccionados individualmente mediante el uso de índices.
Ejemplo de vector: nota (Notas de una clase de n alumnos)
Nota 0 nota 1 nota 2 … nota i … nota n-1
El vector nota tiene subíndices o índices de sus elementos {0, 1, 2, …, i, …, n-1} que indican la
posición de un elemento particular dentro del arreglo (de tamaño n). Por ejemplo, si se desea modificar el
tercer elemento de un vector del tipo entero:
Nota[2]=80

102 | P á g i n a
Nota: Nombre del vector

[2]: Posición del elemento.
Declaración de vectores
La declaración de un vector en C++ se hace de la siguiente manera:

Int vector[tamaño]
Int: tipo de dato que almacena
Vector: nombre del vector
[tamaño]: Tamaño máximo del vector
De una forma más general: tipo_dato nombre_vecor[tam]
Si los elementos del vector están definidos, pueden hacerse la siguiente declaración:
Int a[5]={ 1, 2, 3, 4, 5};
Los arrays pueden ser inicializados en la declaración.
Ejemplos:
float R[10] = {2, 32, 4.6, 2, 1, 0.5, 3, 8, 0, 12};
float S[] = {2, 32, 4.6, 2, 1, 0.5, 3, 8, 0, 12};
int N[] = {1, 2, 3, 6};
El elemento 5° (quinto) de un arreglo, es representado por el índice [4], ya que los índices comienzan en 0.
Esto significa que un arreglo de 10 elementos tendría los índices del 0 al 9: [0...9]
Representación de un arreglo de una dimensión (vector):
1 Arreglo[0]
2 Arreglo[1]
3 Arreglo[2]
4 Arreglo[3]
5 Arreglo[4]
6 Arreglo[5]
Este vector se declara:
Float arreglo[6]

P á g i n a | 103
Ejemplo 1:
#include<iostream>
int main(){
//Cantidad de elementos del vector
int N; //contendra el tamaño del vector
cout<<"Ingrese la cantidad de elementos del vector: ";
cin>>N;
//Declarar el vector
int A[N]; //Define un vector A con N elementos
//Carga del vector
/*
0 (primero) ... n-1(ultimo)
*/
int i,
for(i=0; i<n; i++){
cout<<"Ingrese el elemento A["<<i<<"]: ";
cin>>A[i];
}
//Impresion de datos del vector
cout<<"Los elementos del vector son: ";
for(i=0; i<n; i++){
cin>>A[i]<<"\t";
}
cout<<endl;
//Y si queremos en inverso
cout<<"Los elementos del vector son: ";
for(i=N-1; i>=0; i--){
cin>>A[i]<<"\t";
}
cout<<endl;
return 0;
}

104 | P á g i n a
Ejemplos sobre arrays unidimensional

/*Escribir un programa en lenguaje c++ que lea un numero entero y positivo N, de más de 4 dígitos, si el
numero tiene 4 o menos dígitos finalizar el programa; luego imprima en pantalla el numero obtenido con
el orden de sus cifras invertido utilizando un vector*/
#include<iostream>
int cuentaDigitos(int b){
int cont=0;
while(b){
//solo b porque el bucle no acepta ceros por ende toma como falso
b=b/10;
cont++;
}
return cont;
}
int validar(){
float a;
do{
cout<<"Ingrese un numero con 4 o mas digitos: ";
cin>>a;
}while(a!=int(a) or a<0);
if(cuentaDigitos(a)<5){
return 0;
}else{
return int(a);
}
}
int main(){
int n=validar();
if(n==0) return 0;
int dig=cuentaDigitos(n);
int vector[dig];
// 1 2 3 4 5 - introducimos
// 5 4 3 2 1 - utilizando resto podemos hacer esto

vector[i]=n%10;
n/=10;
}
cout<<vector[i]<<" ";
}
return 0;
}

P á g i n a | 105
/*Elaborar un programa en lenguaje c++ que lee un numero entero N, mayor que 2 y menor o igual que
50, luego cargue un vector vect con N números enteros comprendidos entre 1 y 1000, inclusive, generados
al azar (utilice la función semilla) e imprima en el vector generado, luego imprima en pantalla el promedio
de los numeros impares y el de los numeros pares*/
#include<iostream>
#include<cstdlib>
#include<ctime>
int validar(){
float x;
do
{
cout<<"Inserte un numero mayor que dos y menor o igual que 50:
";
cin>>x;
}while(x<=2 or x>50 or x!=int(x));
return int(x);
}
int main()
{
int N=validar();
int vector[N];
srand(time(NULL));
//numero=limiteinf+rand()%(limitesuperior - limiteinferior +1)
vector[i]= 1 +rand()%(1000+1-1);
}
cout<<vector[i]<<"\t";
}
cout<<endl;
int par=0, cp=0, impar=0;
if(vector[i]%2==0){
par+=vector[i];
cp++;
}else {
impar+=vector[i];
}}
cout<<"El promedio de los numeros pares es: "<<(par*1.0)/cp<<endl;
cout<<"El promedio de los numeros impares es: "<<(impar*1.0)/(N-
cp)<<endl;
return 0;
}

106 | P á g i n a
/*Elaborar un programa en C++ que permita leer un vector de n componentes de tipo flotante (siendo
"n" un número entero y positivo), y que cree una función auxiliar para transformar dicho vector en
otro cuyas componentes sean el doble de cada componente de la inicial. Imprimir el vector antes y
después del cambio. */
#include<iostream>
int validar(){
float x;
do{
cin>>x;
}while(x!=int(x) or x<=0);
return int(x);
}
void vimprimir(float x[], int n){
int i;
for(i=0; i<n; i++){
cout<<x[i]<<"\t"; //Definicion de la funcion
}
cout<<endl;
}
void vdoble(float x[], int n){
int i;
for(i=0; i<n; i++){
x[i]=2*x[i];
// se recorre un indice cada posicion del vector generico
recibido como
// argumento y se cambia por el doble de esa misma componente
}}
int main(){
int n=validar(), i;
float a[n];
for(i=0; i<n; i++){
cout<<"\nIngrese la componente de la posicion "<<i+1<<" del
vector: ";
cin>>a[i];
}
cout<<"\n\tEl vector original es: "<<endl;
cout<<"\t"<<vimprimir(a,n);
vdoble(a,n);
cout<<"\n\tEl vector modificado con el doble de c/componente es:
"<<endl;
cout<<"\t"<<vimprimir(a,n);
return 0;
}

P á g i n a | 107
Ejercicios propuestos sobre arrays unidimensional

/*Escriba un programa en C++ que lea los componentes de un vector de N elementos. Podemos suponer
que el usuario cargará un valor de N entero y positivo; y que además cargará números enteros como
elementos del vector. Se debe mostrar en pantalla los elementos del vector, pero en orden inverso a la
carga del mismo (los elementos mostrados deberán separarse por un espacio simple). */
#include<iostream>
int main(){
//Desarrolle aquí su programa. Puede emplear funciones auxiliares.
int n;
cin>>n;
int a[n];
cin>>a[i];
}
cout<<endl;
cout<<a[n-i-1]<<" ";
}
cout<<endl;
return 0;
}

108 | P á g i n a
/* Copiar un vector*/
#include<iostream>
/*Función que copia los elementos del vector A en el vector B
(manteniendo el orden original) */
void copiarVector(int A[], int B[], int N){
//Implementar de acuerdo a lo solicitado

B[i]=A[i];
}
}
/*Función que copia los elementos del vector A en el vector B
(colocando los elementos en B en orden inverso que en A)*/
void copiarVector_Inv(int A[], int B[], int N){
B[i]=A[N-i-1];
}
}
/*Función auxiliar - Impresión de un vector*/
void imprimirVector(int X[], int n){
int i;
for(i=0;i<n;i++) cout<<X[i]<<" "; cout<<endl;
}
/*Función auxiliar - Lectura de un vector*/
void leerVector(int X[], int n){
int i;
for(i=0;i<n;i++) cin>>X[i];
}
int main(){
/*---NO MODIFICAR El MAIN*/
int opcion,n;
cin>>opcion;
cin>>n;
int a[n],b[n];
if(opcion==1){
leerVector(a,n);
copiarVector(a,b,n);
imprimirVector(b,n);
}
if(opcion==2){
leerVector(a,n);
copiarVector_Inv(a,b,n);
imprimirVector(b,n);
}
return 0;
}

P á g i n a | 109
/*Valor máximo y valor mínimo */

#include<iostream>
/*Función que devuelve el valor del máximo en el vector V de "tam"
elementos*/
int maximo(int V[], int tam){
int mayor=V[0];
for(int i=0; i<tam; i++){
if(mayor>V[i+1]){
mayor;
}else{
mayor=V[i+1];
}}
return mayor;
}
//Otra forma
int maximo(int V[], int tam){
int mayor=V[0];
if(mayor<V[i]){
mayor=V[i];
}}
return mayor;
}
/*Función que devuelve el valor del mínimo en el vector V de "tam"
elementos*/
int minimo(int V[], int tam){
int menor=V[0];
if(menor<V[i+1]){
menor;
}else{
menor=V[i+1];
}}
return menor;
}
//otra forma
int minimo(int V[], int tam){
int menor=V[0];
if(menor>V[i]){
menor=V[i];
}
}
return menor;
}
/*Función auxiliar - Lectura de un vector*/
//Carga del vector
void leerVector(int X[], int n){

110 | P á g i n a
int i;
for(i=0;i<n;i++) cin>>X[i];
}
int main(){
int opcion,n;
cin>>opcion;
cin>>n;
int a[n];
if(opcion==1){
leerVector(a,n);
cout<<maximo(a,n);
}
if(opcion==2){
leerVector(a,n);
cout<<minimo(a,n);
}
return 0;
}

P á g i n a | 111
/* TAA 2° Parcial 2020*/
#include<iostream>
/*Función que devuelve la cantidad de apariciones del número x en el
vector A de N elementos*/
int nroApariciones(int x, int A[], int N){
//IMPLEMENTAR
int acum=0;
if(A[i]==x){
acum++;
}}
return acum;
}
/*Función que devuelve el elemento que menos veces aparece en el vector A
de N elementos
(si hay más de uno, devuelve el que aparece primero en el vector -de izq
a der-)*/
int elementoQueMenosAparece(int A[], int N){
int min, b, acum=0;
for(int i=0; i<N ;i++){
for(int j=0; j<N; j++){
if(A[i]==A[j]){
acum++;
}
}

112 | P á g i n a
if(i==0){
min=acum;
b=A[i];
}else{
if(acum<min){
min=acum;
b=A[i];
}}
acum=0;
}
return b;
}
/*Función que devuelve true si los elementos del vector A de N elementos

están en orden no-descendente
(de izq a der); y false en caso contrario*/
bool estaOrdenadoNoDesc(int A[], int N){
//IMPLEMENTAR
int acum=0, aux=0;
if(A[i+1]>=A[i]){
aux=0;
}else{
acum++;
}
}
if(acum==0){
return true;
}else{
return false;
}
}
/*NO MODIFICAR EL MAIN!!!*/

int main(){
int opcion,N,i,x;
cin>>opcion;
cin>>N;
int A[N];
if(opcion==1) cin>>x;
if(opcion==1) cout<<nroApariciones(x,A,N)<<endl;
if(opcion==2) cout<<elementoQueMenosAparece(A,N)<<endl;
if(opcion==3) cout<<estaOrdenadoNoDesc(A,N)<<endl;
return 0;
}

P á g i n a | 113
/*Se cuenta con una lista L1 de N números enteros cargados por teclado (no hace falta validar el valor de N,
ni el de los valores de la lista), en el cual pueden existir valores repetidos.
Con el fin de economizar el espacio de almacenamiento, se desea crear una nueva lista L2 en la cual cada
valor diferente aparece una sola vez, sin repetición, pero indicando la cantidad de veces que se repite dicho
valor en la lista L1.
La interpretación de la lista L2 es como sigue: el valor 23 aparece 5 veces en L1, el valor 27 aparece 4 veces
en L1, el valor 8 aparece 3 veces en L1, y el valor 14 aparece 1 vez en L1. Nótese que se respeta el orden de
aparición de cada uno de los números en la lista L1.
Escriba un programa en C++ que reciba la lista original L1 e imprima en pantalla la lista L2 con las
características indicadas.
Observaciones y recomendaciones:
- Puede emplear el código que se proporciona para comenzar el ejercicio, y completar en las partes
indicadas (de hecho, es el enfoque recomendado para este ejercicio). También puede borrarlo y escribir
desde cero si lo considera conveniente, siempre que se respeten los formatos de entrada y salida (ver los
casos de prueba al final de esta página).
- Puede evaluar su programa las veces que crea necesario, y corregir errores que surjan.
- Si el programa no compila y no pasa los casos de prueba, no tendrá puntaje.
No utilice system("pause") en el código.
*/

114 | P á g i n a

P á g i n a | 115
#include<iostream>
#include<cstdio>
int ingresar_n(){
float n;
do{
cin>>n;
}while(n!=int(n) || n<=2);
return int(n);
}
void cargarDatos(float X[], float Y[], int n){
X[0]=0; // tiempo al cuadrado inicial cero
Y[0]=60;
//complete la funcion
float aux;
//empieza desde 1 pq ya estan cargados los primeros elementos
for(int i=1; i<n ; i++){
do{
cin>>aux;
X[i]=aux*aux;
cin>>Y[i];
}while(X[i]<X[i-1] or Y[i]>Y[i-1]);
}}
float sumatoria_X(float X[], int n){
float sum=0;
sum=sum+X[i];
}
return sum;
}
float sumatoria_XY(float X[], float Y[], int n){
float sum=0;
sum= sum + X[i]*Y[i];
}
return sum;
}
void imprimirSumatorias(float sum_x,float sum_y, float sum_xy, float
sum_x2){
printf("Sumatoria X= %.2f\n",sum_x);
printf("Sumatoria Y= %.2f\n",sum_y);
printf("Sumatoria XY= %.2f\n",sum_xy);
printf("Sumatoria X^2= %.2f\n",sum_x2);
}
void imprimirGravedadAltura(float m, float b){

printf("La aceleracion de la gravedad es g= %.2f y la altura del
edificio es h0= %.2f",-2*m,b);
}
void calcularYmostrarRecta(float X[], float Y[], int n){
float m, b;

116 | P á g i n a
m=(n*sumatoria_XY(X,Y,n)-
sumatoria_X(X,n)*sumatoria_X(Y,n))/(n*sumatoria_XY(X,X,n)-
sumatoria_X(X,n)*sumatoria_X(X,n));
b=(sumatoria_X(Y,n)-m*sumatoria_X(X,n))/n;
imprimirSumatorias(sumatoria_X(X,n),sumatoria_X(Y,n),sumatoria_XY(X,Y,n),
sumatoria_XY(X,X,n));
imprimirGravedadAltura(m, b);
}
int main(){
int opcion,n;
cin>>opcion;
n=ingresar_n();
if(opcion==1){
cout<<n<<endl;
return 0;
}
float X[n],Y[n];
if(opcion==2){
cargarDatos(X,Y,n);
for(int i=0;i<n;i++) cout<<X[i]<<" "<<Y[i]<<endl;
}
else{
cargarDatos(X,Y,n);
if(opcion==3) cout<<sumatoria_X(X,n)<<endl;
if(opcion==4) cout<<sumatoria_XY(X,Y,n)<<endl;
if(opcion==5) calcularYmostrarRecta(X,Y,n);
}
return 0;
}

P á g i n a | 117
/*Calcular la cantidad de alumnos que obtuvieron nota inferior al promedio del curso en cierta materia. Hay 20
alumnos, y todos rindieron. Las notas son números enteros que van del 0 al 100 (se asume que todas las notas
son correctas).*/
#include<iostream>
#include<cstdlib>
#include<ctime>
int main(){
int A[20], suma=0;
float prom;
srand(time(NULL));
for(int i=0; i<20; i++){
A[i]=rand()%(100-1);
cout<<A[i]<<" ";
suma+=A[i];
}
cout<<endl;
prom=(suma*1.0)/20;
cout<<"\tEl promedio es: "<<prom<<endl;
int a1;
for(int j=0; j<20; j++){
if(A[j]<prom){
a1++;
}}
cout<<"\tLa cantidad de alumnos que obtuvieron puntajes menor al promedio es: "<<a1<<endl;
return 0;
}

118 | P á g i n a
/*Se tienen las temperaturas (promedio) de todos los días del mes de mayo de 2020 almacenados en el vector
Temp (luego de cargar por teclado). Diseñar un programa que obtenga las temperaturas máxima y mínima de
cada quincena (e indique los días correspondientes).*/
#include<iostream>
int main(){
int Temp[31];
for(int i=0;i<31;i++){
cout<<"Cargue la temperatura del dia "<<i+1<<" : ";
cin>>Temp[i];
}
int mayor1=0, menor1=0;
int mayor2=0, menor2=0;
for(int i=0; i<31;i++){
if(i>=0 and i<=14){
if(i==0){
mayor1=Temp[i];
}else if(mayor1<Temp[i]){
mayor1=Temp[i];
}
if(i==0){
menor1=Temp[i];
}else if(menor1>Temp[i]){
menor1=Temp[i];
}
}else{
if(i==15){
mayor2=Temp[i];
}else if(mayor2<Temp[i]){
mayor2=Temp[i];
}
if(i==15){
menor2=Temp[i];
}else if(menor2>Temp[i]){
menor2=Temp[i];
}
} }
cout<<"La temperatura mayor en la primera quincena es: "<<mayor1<<endl;
cout<<"La temperatura menor en la primera quincena es: "<<menor1<<endl;
cout<<"La temperatura mayor en la segunda quincena es: "<<mayor2<<endl;
cout<<"La temperatura menor en la segunda quincena es: "<<menor2<<endl;
return 0;
}

P á g i n a | 119
Unidad 8: Arrays multidimensionales <Matrices>

El array de dos dimensiones, también denominado matriz, son los más utilizados. Es interpretado
como un array (unidimensional) de dimensión "f" (número de filas), donde cada componente es un array
(unidimensional) de dimensión "c" (número de columnas). El número de componentes de este array resulta
entonces el producto f*c.
0 1 2 3 4
0 1 0 0 0 0
1 0 0 2 0 0
2 1 1 0 0 1
3 2 1 1 1 0
4 1 2 1 2 2
¿Para qué sirven un array bidimensional de números?
Podemos realizar cálculos matemáticos complejos ordenando las ecuaciones en matrices.
𝑥 + 2𝑦 + 𝑧 = 0
{−3𝑥 + 2𝑦 − 5𝑧 = 2
2𝑥 + 6𝑦 − 𝑧 = −2
Podemos almacenar datos numéricos en matrices bidimensionales:
Podemos almacenar coordenadas numéricas para aplicaciones más complejas:
El término arreglo no es en realidad una traducción, sino un anglicismo (más bien, un término que
no existe en español). Un arreglo en C++ es un conjunto de datos que se almacenan en memoria de manera
contigua con el mismo nombre y para diferenciar los elementos de un arreglo se utiliza un índice.
Se utilizan índices luego del nombre del arreglo y encerrados por [].

120 | P á g i n a
Sintaxis
<tipo> <identificador> [<num_elementos>] [ [<num_elementos>] . . .];
Arrays multidimensionales:
Sintaxis
La forma de declararlas es mediante una serie de expresiones entre corchetes [ ]:
TipoX etiqueta[<expr-c1>][<expr-c2>]…[<expr-cn>]
Ejemplo 1: tema anterior
 Cargar el arreglo sqrs con los cuadrados de los números del 1 al 1º y luego visualizarlos.
Int main()
{
Int sqrs[10];
Int I;
For(i=1; i<11;i++){
Sqrs[i-1]=i+i;
}
For(i=0; i<10;i++){
Cout<<sqrs[i]<<endl;
}
Return 0;
}
Ejemplo 2: matriz bidimensional
/*Crear un programa en C++ que reciba el valor para el numero de filas y columnas, además nos pida
ingresar los datos por teclado*/
#include<iostream>
int main(){
int m, n;
cout<<"Ingrese filas: "; cin>>m;
cout<<"Ingrese comuna: "; cin>>n;
int A[m][n];
// n cantidad de columnas
// m cantidad de filas
for(int i=0; i<m; i++){ //en el primer recorrido hacemos fila por
fila
for(int j=0; j<n; j++){ // en este recorrido hacemos columna
por columna
cin>>A[i][j];
}

P á g i n a | 121
}
for(int i=0; i<m; i++){
for(int j=0; j<n; j++){
cout<<"\t"<<A[i][j];
}
cout<<endl;
}
return 0;
}
Observaciones sobre las funciones y las matrices
// no podemos pasar una matriz a una funcion
// no podemos simplemente poner a[m][n] o a[int m][int n]
// una forma de solucionar es a[3][5]
// pero es una desventaja ya que no se puede optar por la dimension
// un detalle es que podemos obviar la primera dimesion a[][5]
// existen hipermatrices c[1][2][5[9]
// entonces tienen hiper filas e hiper columna
void aux(int a[][]){
/* si modifico el valor de a[][] en esta funcion, al final a queda
modificada en el main, recordamos que las variables normales
no sucede eso */
}
Ejemplo 3:
#include<iostream>
main()
{
int matriz[6][4][4],i j, k;
for(i=0; i<6;i++)
{
for(j=0; j<4; j++)
{
for(k=0; k<4; k++)
{
matriz[i][j][k]=i+j+k;
cout<<matriz[i][j][k]<<" ";
}
cout<<endl;
}
cout<<endl;
}
system("pause");
}

122 | P á g i n a
Ejemplo 4:
#include<iostream>
main()
{
int matriz[4][5], i, j;
for(i=0; i<4; i++){
for(j=0; j<5; j++){
matriz[i][j]=i+j;
cout<<matriz[i][j]<<" ";
}
cout<<endl;
}
system("pause");
}
Ejemplo 5:
*/Crea una matriz de elementos aleatorios donde el límite superior sea 10*/
#include<iostream>
#include<cstdlib>
#include<ctime>
int main(){
srand(time(NULL));
int m, n;
cout<<"Ingrese filas: "; cin>>m;
cout<<"Ingrese comuna: "; cin>>n;
int A[m][n];

A[i][j]=rand()%11;
}}
cout<<"\nLa matriz es: \n";
}
cout<<endl;
}
return 0;
}

P á g i n a | 123
Ejemplo 6:
/*Dada una matriz cuadrada de dimensión N intercambiar los elementos de tal forma a hallar la
transpuesta de la misma. Imprimir la matriz original y luego la matriz transpuesta. La transpuesta
consiste en intercambiar las filas y las columnas*/
#include<iostream>
#include<cstdlib>
#include<ctime>
int main(){
int n;
cout<<"Ingrese el tamaho: "; cin>>n;
int A[n][n];
srand(time(NULL));
// cout<<"ingrese el valor correspondiente al espacio
["<<i<<"] ["<<j<<"]: ";
A[i][j]=rand()%11;
}}
}
cout<<endl;
}
cout<<endl;
int B[n][n], Aux[n][n];

if(i==j){
B[i][j]=A[i][j];
}else{
B[i][j]=A[j][i];
}}}
for(int i=0; i<n; i++){ //Se puede imprimir en el for anterior
para disminuir las interacciones
cout<<B[i][j]<<"\t";
}
cout<<endl;
}
return 0;
}
//Evitando usar la matriz auxiliar:
for(int j=i+1; j<n; j++){
aux=A[i][j];
A[i][j]=A[j][i];
A[j][i]=aux;
}
}

124 | P á g i n a
• EJERCICIO PROPUESTO
• Elaborar un programa que genere, al azar, un conjunto de 50 pares de números enteros no negativos (fil,
col) e imprima dichos pares de números, donde fil es menor o igual que 4 y col es menor o igual que 5,
cuente cada par generado y la cuenta cargarla en la posición (fil, col) de una matriz mat de orden 5x6.
Luego imprima dicha matriz.
Videos que me faltan:
https://www.youtube.com/watch?v=__63anwZ_7A
https://www.youtube.com/watch?v=jrsSePJOREk

P á g i n a | 125
Ejercicios propuestos sobre arrays unidimensional

/*Generar una matriz A[mxn] con elementos enteros y positivos. Construya una segunda matriz B,tal que
sus elementos sean la suma de los elementos de A marcados en rojo para cada posición correspondiente.
Obs: Mirar los detalles en la imagen adjunta. */
#include<iostream>
int main()
{
int m,n,i,j,s;
cout<<"Ingrese m: ";
cin>>m;
cout<<"Ingrese n: ";
cin>>n;
int A[m][n],B[m][n];
//Leer la Matriz A
//No modificar las instruccion instrucciones de entrada
cout<<endl;
cout<<"Ingrese el valor de los elementos de la matriz: "<<endl;
for(i=0;i<m;i++){
for(j=0;j<n;j++){
cin>>A[i][j];
}}
for(i=0;i<m;i++){
for(j=0;j<n;j++){
cout<<A[i][j]<<" ";
}
cout<<endl;
}
cout<<endl;
cout<<endl;
//genearando la matriz B
int acum=0;
//suma
//izquierda: una columna hacia atras
if(j>0){
acum += A[i][j-1];
}
//arriba
if(i>0){
acum += A[i-1][j];
}

126 | P á g i n a
//derecha
if(j<n-1){
acum += A[i][j+1];
}
//abajo
if(i<m-1){
acum += A[i+1][j];
}
cout<<endl;
B[i][j]=acum;
}}
//Completar
//imprimir matriz
//No modificar el formato de impresión
i=0;
for(i=0;i<m;i++)
{
for(j=0;j<n;j++)
{
cout<<B[i][j]<<" ";
}
cout<<"\n";
}
return 0;
}

P á g i n a | 127
/*Escribir un programa que reciba (por teclado) las dimensiones de una matriz A de m filas y n columnas,
además de sus elementos (que serán números enteros). El programa debe generar (y mostrar en pantalla)
una matriz B que tenga las mismas dimensiones, donde cada elemento (i, j) es la suma de los elementos
de A que están arriba, abajo, a la izquierda y a la derecha de la posición (i, j) (como se muestra en la
imagen). Para no considerar (como centro) las posiciones que están al borde de A, simplemente se copian
los elementos en esas posiciones a las respectivas en B (por eso el color de fondo distinto para dichas
posiciones).*/
#include<iostream>
int main(){
int m,n,i,j,s;
/*Entrada de datos (dimensiones de la matriz A y sus elementos) - No modificar esta parte*/
cin>>m>>n;
int A[m][n],B[m][n];
for(i=0;i<m;i++) for(j=0;j<n;j++) cin>>A[i][j];
/*Fin - Entrada de datos*/
/*Rellenamos los bordes de B con los elementos originales (correspondientes) en A*/
//En este for se copian los elementos de la primera columna y de la última
for(i=0;i<m;i++){
B[i][0] = A[i][0];
B[i][n-1] = A[i][n-1];
}
//Ahora debemos copiar los elementos de la primera fila y de la última...
for(j=1 ; j<n-1 ;j++){
B[0][j] = A[0][j];
B[m-1][j] = A[m-1][j];
}
/*Ahora calcularemos el resto de los elementos de B, según el enunciado*/
for(i=1; i<m-1; i++){
for(j=1; j<n-1; j++){
int acum=0;
acum +=A[i][j-1]; //izq
acum +=A[i-1][j]; //arriba
acum +=A[i][j+1]; //derecha
acum +=A[i+1][j]; //abajo
B[i][j]=acum;
}}
/*Salida de datos (impresión de la matriz B) - No modificar esta parte*/
for(i=0;i<m;i++){
for(j=0;j<n;j++) cout<<B[i][j]<<" ";
cout<<endl;
}
return 0;
}

128 | P á g i n a
/*Lea dos números enteros y positivos (validarlos) m y n, que representan, respectivamente, el número de
filas y el número de columnas de una matriz mat de componentes reales. Luego lea e imprima las m´n
componentes de mat y tres números k, l y f, los dos primeros enteros positivos menores o iguales que m,
pudiendo ser uno sólo de ellos cero, y el tercero un número real no nulo. Determine e imprima la matriz
obtenida después de sumar a la fila k, la fila l previamente multiplicada por f.*/
#include<iostream>
int main(){
float s, p;
do{
cout<<"Ingrese filas: "; cin>>s;
}while(s<=0 or s!=int(s));
do{
cout<<"Ingrese columnas: "; cin>>p;
}while(p<=0 or p!=int(p));
int m, n;
m=s;
n=p;
float mat[m][n];
//hasta aca la validacion
cout<<"Cargue el elemento correspondiente al espacio
["<<i<<"]["<<j<<"]: ";
cin>>mat[i][j];
}}
cout<<mat[i][j]<<"\t";
}
cout<<endl;
}
int k, l; //menor o iguales a m podiendo alguno ser cero
float f; //real no nulo
bool bandera=true;
do{
cout<<"Ingrese k: "; cin>>k;
cout<<"Ingrese l: "; cin>>l;
if(k==0 and l==0){
bandera=true;
}else bandera=false;
}while( k<0 or k>m or l<0 or l>m or bandera);
// poner un or(k==0 and k==l) hace que repita todo
do{
cout<<"Ingrese f: "; cin>>f;
}while(f==0);

mat[k][i]=mat[k][i]+mat[l][i]*f;
}
//fila kf + if
//dice lea, por lo tanto es introducir por teclado

P á g i n a | 129

}
cout<<endl;
}
}
/*Cargar una matriz de M x N, encontrar el valor máximo, dividir cada componente de la matriz por el
valor máximo*/
#include<iostream>
int main(){
int M, N; //no pide validad
cout<<"Ingrese filas: "; cin>>M;
cout<<"Ingrese columnas: "; cin>>N;
float mat[M][N];
for(int i=0; i<M; i++){
cout<<"Cargue el elemento correspondiente al espacio
["<<i<<"]["<<j<<"]: ";
cin>>mat[i][j];
}}
}
cout<<endl;
}
//encontrando el mayor numero posible
int aux=0;
if(j==0 and i==0){
aux=mat[i][j];
}else if(aux<mat[i][j]){
aux=mat[i][j];
}}}
cout<<"\n\nEl maximo valor es el: "<<aux<<"\n\n";
mat[i][j]=mat[i][j]/aux;
}}
}
cout<<endl;
}
return 0;
}

130 | P á g i n a
/*Se cuenta con una lista L1 de N números enteros cargados por teclado (no hace falta validar el valor de
N, ni el de los valores de la lista), en el cual pueden existir valores repetidos. Con el fin de economizar el
espacio de almacenamiento, se desea crear una nueva lista L2 en la cual cada valor diferente aparece una
sola vez, sin repetición, pero indicando la cantidad de veces que se repite dicho valor en la lista L1.
La interpretación de la lista L2 es como sigue: el valor 23 aparece 5 veces en L1, el valor 27 aparece 4 veces
en L1, el valor 8 aparece 3 veces en L1, y el valor 14 aparece 1 vez en L1. Nótese que se respeta el orden de
aparición de cada uno de los números en la lista L1.
Escriba un programa en C++ que reciba la lista original L1 e imprima en pantalla la lista L2 con las
características indicadas. */
#include<iostream>
/*Función que carga un vector de N elementos con valores introducidos por
teclado*/
void cargarVector(int A[], int N){
int i;
}
/*Función que muestra en pantalla los elementos de un vector de N
elementos*/
void imprimirVector(int A[], int N){
int i;
for(i=0;i<N;i++) cout<<A[i]<<" "; cout<<endl;
}
/*Función que indica con verdadero si un elemento x está en un vector de
N elementos, y falso en caso contrario.
El entero "salto" indica el incremento en el proceso de recorrer el
vector*/
bool estaEnElVector(int A[], int N, int x, int salto){
int i;
for(i=0;i<N;i+=salto){
if(x==A[i]) return true; //x está en el vector (en la posición i)
}
return false; //ya que no se encontró x en el proceso de búsqueda
}
/*Función que devuelve la cantidad de elementos distintos en un vector de
N elementos*/
int contarElementosDistintos(int A[], int N){
int elemDist=0; //contador con el nro de elementos distintos
int B[N]; //vector que almacenará los elementos distintos de A (como
máximo, hay N distintos)
int i; //índice
for(i=0;i<N;i++){
if(!estaEnElVector(B,elemDist,A[i],1)) B[elemDist++] = A[i]; //si
A[i] no estaba en B, lo agregamos
}
P á g i n a | 131
return elemDist;
}
/*Función para obtener la lista L2 según las especificaciones del
problema*/
void obtenerListaL2(int L1[], int L2[], int N){
int k=0, cuenta=0, clave;
bool ban;
clave=L1[i];
cuenta=0;
ban=true;
for(int j=0; j<i; j++){

if(L1[j]==clave) ban=false;
}
if(ban==true){
for(int l=0; l<N; l++){
if(L1[l]==clave) cuenta ++;
}
L2[k]=clave;
k++;
L2[k]=cuenta;
k++;
}}}
int main(){
int N; //Numero de elementos de L1
cin>>N; //Cargamos N
int L1[N]; //Vector que almacenará la lista de entrada
cargarVector(L1,N); //Cargamos el vector
int M =contarElementosDistintos(L1, N); //M debe contener la cantidad
de números distintos en L1
int L2[M*2]; //Vector que almacenará los números distintos con el nro
de veces que aparecen en L1
obtenerListaL2(L1,L2,N); //Obtenemos la lista L2 según la descripción
del problema
imprimirVector(L2,M*2); //Mostramos la lista L2
return 0;
}

132 | P á g i n a
Unidad 9: Métodos de ordenamiento

Búsqueda:
Es el proceso de encontrar un elemento específico dentro de array. Se permite determinar si un array
contiene un valor que coincida con la clave.
- Secuencial (lineal)
Lo que hacemos es buscar un elemento de la lista utilizando el valor destino llamado clave. Los
elementos se examinan en secuencia, uno después de otro. Se recorre cada uno de los elementos hasta
el final de la lista de datos. Si en algún lugar se encuentra el elemento buscado, el algoritmo informa
sobre las posiciones respectivas.
- Binaria
Se requiere que todos los elementos se encuentren almacenados en forma ordenada. Consiste en
comparar el elemento buscado con el que ocupa en la lista la posición central. Si son iguales, se detiene
la búsqueda. Si no, se elige la sablista hasta o desde el elemento buscado es menor o mayor al elemento
central.
Hay que tener en cuenta que la lista debe estar previamente ordenado, este algoritmo reduce el
tiempo de búsqueda, ya que disminuye considerablemente el número de iteraciones necesarias.
En el peor de los casos el número máximo de comparaciones es Log2 n+1
¿Se encuentra el 1 en el array?
-9 0 1 4 7 9 10 15
0 1 2 3 4 5 6 7
Se toma el termino (0+7)/2=3.5=3

-9 0 1 4 7 9 10 15
0 1 2 3 4 5 6 7
-9 0 1
0 1 2
1
2
Para tener en cuenta en la búsqueda binaria:

 Si son iguales se retorna la posición en la lista y se detiene el proceso
 Si el valor de la lista es mayor que la clave, se repite el procedimiento en la parte de la lista que va
desde el inicio hasta el elemento anterior al central (c), en caso contrario se toma la parte de la lista
que va desde el siguiente elemento al central (c) hasta el final.
 De esta manera obtenemos intervalos cada vez más pequeños, hasta que se obtenga un intervalo
indivisible.
 Si el elemento no se encuentra dentro del último intervalo posible entonces se deduce que el
elemento buscado no se encuentra en todo el vector y se retorna -1.
Sintaxis:

P á g i n a | 133
Búsqueda lineal
int busquedaLineal (int vector[], int N, int clave)
{
if(vector[i]==clave)
return i;
}
return -1;
}
Búsqueda binaria
int busquedaBinaria(int vector[], int n, int clave)
{
int centro, inf=0, sup = n-1;
while( inf<=sup ){
centro = ((sup+inf)/2);
if(vector[centro]==clave) return centro;
else if(vector[centro] > clave) sup=centro-1;
else inf=centro+1;
}
return -1;
}
Ejemplo visual:
Posición 0 1 2 3 4 5 6 7 8 9
Valor 3 4 5 6 7 9 10 12 13 15
Clave: 3
Vector[4]==3? … No, es menor
Posición 0 1 2 3 4 5 6 7 8 9
Valor 3 4 5 6 7 9 10 12 13 15
Vector[1]==3? … No, es menor
Posición 0 1 2 3 4 5 6 7 8 9
Valor 3 4 5 6 7 9 10 12 13 15
Vector[0]==3? ... Si. Retornamos 0 y se termina el ciclo

134 | P á g i n a
Ejemplo 1.1:
/*Búsqueda secuencia de una clave en un vector de n datos de izquierda a derecha comenzando en la
posición 0. Retorna -1 si la clave no está en el vector V y la posición de la primera aparición si se encuentra
en el vector V */
#include<iostream>
int busquedaLinalID(int V[], int n, int clave){
if(V[i]==clave){
return i;
}else if(i==n-1){
return -1;
}}}
int main(){
int n=7, clave;
int V[7]={1 , 2 , 3 , 4 , 5 , 6 , 7};
for(int i=0; i<7; i++){
cout<<V[i]<<"\t";
}
cout<<"\nIngrese la clave: ";
cin>>clave;
cout<<busquedaLinalID(V, n, clave);
return 0;
}
Ejemplo 1.2:
/*En este caso es de derecha a izquierda, comenzando desde la derecha*/
#include<iostream>
int busquedaLinalID(int V[], int n, int clave){
for(int i=n-1; i>0; i++){
if(V[i]==clave){
return i;
}else if(i==n-1){
return -1;
}}}
int main(){
int n=7, clave;
int V[7]={1 , 2 , 3 , 4 , 5 , 6 , 7};
for(int i=0; i<7; i++){
cout<<V[i]<<"\t";
}
cin>>clave;
cout<<busquedaLinalID(V, n, clave);
return 0;
}

P á g i n a | 135
Ejemplo 2:
/*Busqueda secuencia de una clave de un vector de n datos ordenados crecientemente de izquierda a
derecha comenzando en la primera posicion */
#include<iostream>
int BSecOrAscendente(int V[], int n, int clave){
bool encontrada=false;
int i=0;
while((!encontrada) and (i<n)){
encontrada=(V[i]>=clave);
if(!encontrada) i++;
}
if(i<n){
encontrada=V[i]==clave;
}
return encontrada ?1 : -1;
}
int main(){
int n, clave;
cout<<"Ingrese un tamaho: ";
cin>>n;
int V[n];
cin>>V[i];
}
cout<<V[i]<<"\t";
}
cin>>clave;
cout<<BSecOrAscendente(V, n, clave);
return 0;
}
/*Busqueda secuencia de una clave en un vector de n datos de derecha a izquierda comenzando en la
última posición. Retorna -1 si la clave no está en el vector V y la posición de la última aparición si se
encuentra en el vector V*/
#include<iostream>
int busquedaLinalDI(int V[], int n, int clave){
for(int i=n-1; i>0; i--){
if(V[i]==clave){
return i;
}else if(i==0){
return -1;
}}}
int main(){
int n=7, clave;
int V[7]={1 , 2 , 3 , 4 , 5 , 6 , 7};
for(int i=0; i<7; i++){
cout<<V[i]<<"\t";

136 | P á g i n a
}
cin>>clave;
cout<<busquedaLinalDI(V, n, clave);
return 0;
}
https://www.youtube.com/watch?v=9yO65W7KgpE
1. Método burbuja
La orientación burbuja es un sencillo algoritmo de ordenamiento. Funciona revisando cada
elemento de la lista que va a ser ordenada con el siguiente, intercambiándolos de posición si están
en el orden equivocado. Es necesario revisar varias veces toda la lista hasta que no se necesiten más
intercambios, lo cual significa que la lista esta ordenada. Este algoritmo obtiene su nombre de la
forma con la que suben por la lista los elementos durante los intercambios los intercambios, como si
fueran pequeñas “burbujas”.
También es conocido como el método de intercambio directo. Dado que solo usa
comparaciones para operar elementos, se lo considera un algoritmo de comparación, siento uno de
los más sencillos de implementar.
Este algoritmo realiza el ordenamiento o reordenamiento de una lista a de n valores, en este
caso de n términos numerados de 0 a n-1: consta de dos bucles anidados, uno con el índice i, que da
un tamaño menor al recorrido de la burbuja en sentido inverso de 2 a n y un segundo bucle con el
índice j, con un recorrido desde 0 hasta n-i, para cada iteración del primer bucle, que indica el lugar
de la burbuja.
3 6 -9 8 1
3 -9 6 8 1
3 -9 6 8 1
3 -9 6 1 8
Se repite desde el inicio
-9 3 6 1 8
-9 3 6 1 8
-9 3 1 6 8
-9 3 1 6 8
Sintaxis:
void Burbuja (float A[], int n){
float aux;
for (int i = 0 ; i<n-1 ; i++){
for(int j=0; j<n-1 ; j++){
if(A[j]>A[j+1]){///
aux=A[j];
A[j]=A[j+1];
A[j+1]=aux;
}
}
}
}
Ejemplo 1:
Seas un arrays de la forma [1 5 2 3 6] y queremos ordenar de forma ascendente.
Lo que hacemos es ir comparando elemento a elemento de manera mecánica
Preguntamos, ¿es el primer elemento es menor al siguiente?
[1 5 2 3 6] misma pregunta -> [1 2 3 5 6]
En el caso que en el primer recorrido no este ordenado se van a necesitar más filas

P á g i n a | 137
Ejemplo 2:
#include<iostream>
int main(){
int a[10]={6, 10, 2, 1, 7, 3, 9, 8, 4, 5};
for(int i=0; i<10; i++){
cout<<a[i];
}
cout<<endl;
//minimo se hace un recorrido igual a la cantidad de elementos
int aux;
for(int i=0; i<10; i++){
for(int j=0; j<9-i; j++){
if(a[j]>a[j+1]){
aux=a[j];
a[j]=a[j+1];
a[j+1]=aux;
}}}
for(int i=0; i<10; i++){
cout<<a[i];
}
cout<<endl;
return 0;
}
2. Método de Selección
Se elige al elemento más pequeño y se coloca en la posición que corresponde (intercambiamos).
Luego se elige el segundo elemento más pequeño y colocamos en su posición correspondiente
[intercambio]. Y así sucesivamente…
https://www.youtube.com/watch?v=J0HfY4WFgfY
3 6 -9 8 1
-9 6 3 8 1
-9 1 3 8 6
-9 1 3 8 6
-9 1 3 8 6
Sintaxis:
void seleccion (float A[],int n){
int i_min;
float aux;
for(int i=0 ; i<n-1 ; i++){
i_min=i;
for (int j=i+1; j<n ; j++){
if(A[j]<A[i_min]){//
i_min=j;
}
aux=A[i_min];
A[i_min]=A[i];
A[i]=aux;
}
}
}

138 | P á g i n a
3. Método de Inserción
Se toma una sublista inicial con un único elemento que se considera siempre “ordenada”. En
la sublista ordenada se irán insertando sucesivamente los restantes elementos de la lista inicial en el
lugar adecuado.
Sintaxis:
void insercion(float A[], int n){
bool encontrado;
float aux;
int j;
aux=A[i];
j=i-1;
encontrado=false;
while(j>=0 and !encontrado){
if(A[j]>aux){
A[j+1]=A[j];
j--;
}else{
encontrado=true;
}
}
A[j+1]=aux;
}

P á g i n a | 139
Códigos
1. Burbuja
void Burbuja (float A[], int n){
float aux;
for (int i = 0 ; i<n-1 ; i++){
for(int j=0; j<n-1 ; j++){
if(A[j]>A[j+1]){///
aux=A[j];
A[j]=A[j+1];
A[j+1]=aux;
}}}}
2. Selección
void seleccion (float A[],int n){
int i_min;
float aux;
for(int i=0 ; i<n-1 ; i++){
i_min=i;
for (int j=i+1; j<n ; j++){
if(A[j]<A[i_min]){//
i_min=j;
}
aux=A[i_min];
A[i_min]=A[i];
A[i]=aux;
}}}
3. Inserción
void insercion(float A[], int n){
bool encontrado;
float aux;
int j;
aux=A[i];
j=i-1;
encontrado=false;
if(A[j]>aux){
A[j+1]=A[j];
j--;
}else{
encontrado=true;
}}
A[j+1]=aux;

140 | P á g i n a
}
}
4. Quicksort
#include<iostream>
void quicksort(int A[], int izq, int der){
int i=izq, j=der, x, aux;
x=A[(izq+der)/2];
do{
while((A[i]<x) && (j<=der)){
i++;
}
while((x<A[j] && (j>izq))){
j--;
}
if(i<=j){
aux=A[i];
A[i]=A[j];
A[j]=aux;
j--;
i++;
}
}while(i<=j);
if(j>izq){
quicksort(A,izq,j);
}
if(i<der){
quicksort(A,i, der);
}
}
int main(){
int A[]={12, 11, 13, 5, 6};
quicksort(A, 0, 5-1); //prob

for(int i=0; i<5; i++){
cout<<A[i]<<"\t";
}
return 0;
}

P á g i n a | 141
5. Megasort
#include<iostream>
#include<cstdlib>
#include<ctime>
void imprimirVector(int x[], int n){
int i;
for(i=0;i<n;i++) cout<<x[i]<<" ";
cout<<endl;
}
void mezclar(int A[], int p, int q, int r){
int i,j,k;
int n1 = q-p+1;
int n2 = r-q;
/* Creamos vectores auxiliares */
int L[n1], R[n2];
/* Copiamos datos a los vectores L[] y R[] */
for(i=0;i<n1;i++) L[i] = A[p+i];
for(j=0;j<n2;j++) R[j] = A[q+1+j];
/* Mezclar los vectores temporales y colocarlos en A[p...r]*/
i = 0; // Posicion inicial en L[]
j = 0; // Posicion inicial en R[]
k = p; // Posicion inicial en A[] (en el sector que va de A[p...r]
while(i<n1 && j<n2) {
if(L[i]<=R[j]){
A[k] = L[i];
i++;
}
else{
A[k] = R[j];
j++;
}
k++;
}
/* Copiamos los elementos restantes de L[] (si los hay) */
while(i<n1) {
A[k] = L[i];
i++;
k++;
}
/* Copiamos los elementos restantes de R[] (si los hay) */
while(j<n2) {
A[k] = R[j];
j++;
k++;
}}
void mergeSort(int A[], int p, int r){
if(p<r) {
//Se halla el punto medio
int q = (p+r)/2;
//Se ordena cada una de las mitades (llamada recursiva)
mergeSort(A,p,q);
mergeSort(A,q+1,r);

142 | P á g i n a
mezclar(A,p,q,r);
}}
void ordenarVecMergesort(int A[], int N){
mergeSort(A,0,N-1);
}
int main(){
//Se ingresa el tamaño del vector
int N;
cout<<"Ordenamiento por mezcla (Mergesort) \n";
cout<<"Ingrese la cantidad de elementos: ";
cin>>N;
//Se declara el vector
int A[N];
//Se carga el vector
int i,j;
srand(time(NULL));
for(i=0;i<N;i++) A[i] = rand()%10;
//Se muestra el vector original
cout<<"\nVector original:\n";
imprimirVector(A,N);
//Ordenamiento por mezcla
ordenarVecMergesort(A,N);
//Se muestra el vector ordenado
cout<<"\nVector ordenado:\n";
imprimirVector(A,N);
return 0;
}

P á g i n a | 143
Ejercicios propuestos sobre métodos de ordenación

/*Ordenamiento por burbuja*/
#include <iostream>
using namespace::std;
int Tamano = 10;
void Imprime( int A[]);
void Recibe ( int B[]);
void Burbuja( int C[]);
int main()
{
int Arreglo[Tamano] = {0, 0};
Recibe(Arreglo);
Burbuja(Arreglo);
Imprime(Arreglo);
return 0;
}
void Imprime( int A[] ) {
for ( int j = 0; j < Tamano; j++ ){
cout << "\t" << A[j];
}
cout <<endl;
}
void Recibe( int B[] ){
for ( int i = 0; i < Tamano; i++ ){
cin >> B[i];
}
}
void Burbuja( int C[]){
float aux, n=10;
Imprime(C);
for(int i=0; i<10-1; i++){
for(int j=0; j<10-1; j++){
if(C[j]>C[j+1]){
aux=C[j];
C[j]=C[j+1];
C[j+1]=aux;
}}
Imprime(C);
}
}

144 | P á g i n a
/*Generar un vector de 10 elementos enteros entre 0 y 30, mostrar en pantalla el vector

generado, luego ordenar los elementos ubicados en posiciones pares de manera descendente, los
elementos que no están en posiciones pares no cambian de lugar, al finalizar el ordenamiento
mostrar el vector*/
#include<iostream>
#include<cstdlib>
#include<ctime>
void imprimir(int A[], int N){
cout<<A[i]<<"\t";
}
}
int main(){
int N=10;
int A[N];
srand(time(NULL));
A[i]=rand()%(30+1);
}
imprimir(A, N);
cout<<endl;
//ordenar sin sacar
for(int i=0; i<9; i=i+2){
for(int j=0; j<10-2; j+=2){
if(A[j]<A[j+2]){
int temp=A[j];
A[j]=A[j+2];
A[j+2]=temp;
}
}
}
imprimir(A, N);
}

P á g i n a | 145
/*Elaborar un programa que lea dos números enteros y positivos m y n, mayores a 2 y menores o
iguales a 10 generados al azar. Muestre en pantalla la matriz generado. Por último, ordene cada
una de las filas de dicha matriz en forma ascendente utilizando el método de inserción y muestre
en pantalla la matriz completa con cada una de sus filas ordenadas */
#include<iostream>
#include<cstdlib>
#include<ctime>
int validacion();
int main(){
int m, n;
cout<<"Ingrese el numero de filas de la matriz: ";
m=validacion();
cout<<"Ingrese el numero de columnas de la matriz: ";
n=validacion();
int A[m][n];
srand(time(NULL));
A[i][j]=rand()%(100+1);
}}
cout<<"\nLa matriz generada es: \n";
}
cout<<endl;
}
cout<<endl;
for(int l=0; l<m; l++){
int i_min;
int aux;
for(int i=0; i<n-1; i++){
i_min=i;
for(int j=i+1; j<n; j++){
if(A[l][j]<A[l][i_min]){
i_min=j;
}
aux=A[l][i_min];
A[l][i_min]=A[l][i];
A[l][i]=aux;
[l }}}
cout<<"\nLa matriz ordenada es: \n";
}
cout<<endl;
}
cout<<endl;
return 0;
}
int validacion(){

146 | P á g i n a
float numero;
do{
cout<<"\nEl numero debe ser positivo, mayor 0 igual a dos y
menor o igual a 10."<<endl;
cin>>numero;
}while(numero<2 or numero!=int(numero) or numero>10);
return int(numero);
}
/*Para la distribución de asientos en un examen, se asigna un numero aleatorio a cada alumno de
los n alumnos (“n” no debe de ser validado), para que cada alumno se siente en el lugar que le
corresponde según la posición de su número al azar. Ordene los números generados
aleatoriamente de forma ascendente y utilice el número de cédula para identificar a cada alumno.
Por ejemplo, para 5 alumnos con CI cargados por teclado:
111111 2222222 3333333 4444444 5555555
Se les asignan los números aleatorios:
41 18467 6334 26500 19169
Luego se ordenan las cedulas de acuerdo a los números aleatorios del menor al mayor*/
#include<iostream>
#include<cstdlib>
#define semilla 1
void imprimir(int A[], int N){
cout<<A[i]<<"\t";
}
cout<<endl;
}
void burbuja(int A[], int B[], int n){
int aux, aux2;
for(int j=0; j<n-1; j++){
if(A[j]>A[j+1]){
aux= A[j];
aux2= B[j];
A[j]= A[j+1];
B[j]= B[j+1];
A[j+1]=aux;
B[j+1]=aux2;
}}}}
int main(){
int n;
cin>>n;
srand(semilla);
int N1[n], N2[n];
cin>>N1[i];
N2[i]=rand();
}
burbuja(N2, N1, n);
imprimir(N2, n);
imprimir(N1, n);
}
P á g i n a | 147
/*Cree un programa en c++ que reciba n fechas de nacimientos (“n” ingresado por teclado), que deben
de ser guardados en una matriz 3xn, siendo la primera fila la que guarde los años, la segunda los meses y
la tercera los días. Posteriormente imprima las fechas en un orden ascendente.
Ejemplo:
Siendo n=6:
Años: 2000 1999 2000 2001 2010 2009
Meses: 6 6 6 7 3 3
Días: 19 19 20 12 12 12
En orden:
Años: 1999 2000 2000 2001 2009 2010
Meses: 6 6 6 7 3 3
Días: 19 19 20 12 12 12 */
#include<iostream>
int main(){
int n;
cin>>n;
int A[3][n];
//Carga del vector
for(int i=0; i<3; i++){
cin>>A[i][j];
}}
//impresión del vector
for(int i=0; i<3;i++){
if(i==0) cout<<"Ano\t";
if(i==1) cout<<"Mes\t";
if(i==2) cout<<"Dia\t";
}
cout<<endl;
}
int aux, aux1, aux2;
int clave;
//Ordenamos primero los años
for(int l=0; l<n-1; l++){
if(A[0][j]>A[0][j+1]){
aux=A[0][j];
aux1=A[1][j];
aux2=A[2][j];
A[0][j]=A[0][j+1];
A[1][j]=A[1][j+1];
A[2][j]=A[2][j+1];
A[0][j+1]=aux;
A[1][j+1]=aux1;
A[2][j+1]=aux2;
}
}
}

148 | P á g i n a
}
cout<<endl;
}
//ordenamos los meses y dias
for(int l=0; l<n-1; l++){
if(A[0][j]==A[0][j+1]){
if(A[1][j]>A[1][j+1]){
aux=A[0][j];
aux1=A[1][j];
aux2=A[2][j];
A[0][j]=A[0][j+1];
A[1][j]=A[1][j+1];
A[2][j]=A[2][j+1];
A[0][j+1]=aux;
A[1][j+1]=aux1;
A[2][j+1]=aux2;
}else if(A[1][j]==A[1][j+1]){
if(A[2][j]>A[2][j+1]){
aux=A[0][j];
aux1=A[1][j];
aux2=A[2][j];
A[0][j]=A[0][j+1];
A[1][j]=A[1][j+1];
A[2][j]=A[2][j+1];
A[0][j+1]=aux;
A[1][j+1]=aux1;
A[2][j+1]=aux2;
}
}
}
}
}
}
cout<<endl;
}
return 0;
}

P á g i n a | 149
/*Escribir un programa que reciba (por teclado) la dimensión de una matriz cuadrada A (n x n),
además de sus elementos (que serán números enteros). El programa debe hallar la suma de sus
elementos de la diagonal principal. Si dicha suma da como resultado un numero par deberá
ordenar la matriz de manera ascendente por columnas, en caso contrario ordenar la matriz de
manera descendente por columnas como se muestra en la imagen*/
#include<iostream>
int main(){
int n,sumaD=0;
/*Entrada de datos (dimension de la matriz A y sus elementos) - No
modificar esta parte*/
cin>>n;
int A[n][n];
for(int i=0;i<n;i++) for(int j=0;j<n;j++) cin>>A[i][j];
/*Fin - Entrada de datos*/
//Ahora debemos hallar la suma de los elementos de la diagonal
if(i==j){
sumaD=sumaD+A[i][j];
}
}
}
int Aux[n*n];
//Con un vector auxiliar, en este caso carga fila por fila
int k=0;
for(int l=0; l<n; l++){

Aux[k]=A[l][j];
k++;
}
}
//imprimiendo el vector auxliar
for(int i=0; i<n*n;i++){
cout<<Aux[i]<<"\t";
}
cout<<endl<<endl;
int m=n*n;
/*Ordenar segun el resultado obtenido*/
if(sumaD%2==0){
//Ascendente
for(int i=0; i<m-1; i++){
int aux;

150 | P á g i n a
for(int j=0; j<m-1; j++){

if(Aux[j]>Aux[j+1]){
aux=Aux[j];
Aux[j]=Aux[j+1];
Aux[j+1]=aux;
}
}
}
}else{
//descendente
for(int i=0; i<m-1; i++){
int aux;
if(Aux[j]<Aux[j+1]){
aux=Aux[j];
Aux[j]=Aux[j+1];
Aux[j+1]=aux;
}
}
}
}
//Colocando nuevamente en una matriz
k=0;
for(int l=0; l<n; l++){
A[j][l]=Aux[k];
k++;
}
}
/*Salida de datos (impresión de la matriz ordenada) - No modificar
esta parte*/
for(int i=0;i<n;i++){
for(int j=0;j<n;j++) cout<<A[i][j]<<"\t";
cout<<endl;
}
/*Fin - Salida de datos*/
return 0;
}

P á g i n a | 151
/*Ordenar una matriz de acuerdo a las filas*/

#include <iostream>
#include <iomanip>
const int fil = 5;
const int col = 4;
int main()
{
int temp = 0;
int matriz[fil][col];
cout << "\nIntroduzca los datos de la matriz:"
<< "\nDimensiones de la matriz: "
<< fil << " x " << col << "\n\n";
for( int i = 0; i < fil; i++ ){
for( int j = 0; j < col; j++ ) {
cout << "[" << i << "][" << j << "]: ";
cin >> matriz[i][j];
}
}
cout << "\nDatos de la matriz:\n";
for( int i = 0; i < fil; i++ ) {
cout << "\n| ";
for(int j = 0; j < col; j++ ) {
cout << setw(4) << matriz[i][j] << " ";
}
cout << " |";
}
cout << endl;
for( int i = 0; i < fil; i++ ) {
for( int j = 0; j < col; j++ ) {
for(int x = 0; x < fil; x++ ) {
for( int y = 0; y < col; y++ ) {
if( matriz[i][j] > matriz[x][y]) {

temp = matriz[i][j];
matriz[i][j] = matriz[x][y];
matriz[x][y] = temp;
}}}}}
cout << "\nDatos de la matriz ordenada:\n";
for( int i = 0; i < fil; i++ ) {
cout << "\n| ";
for(int j = 0; j < col; j++ ) {
cout << setw(4) << matriz[i][j] << " ";
}
cout << " |";
}
cout << endl;
return 0;
}

152 | P á g i n a
/*Completar la función: ordenamiento Escalera, que recibe como parámetros la dirección de una matriz
cuadrada y la dimensión de la misma
Ordenación escalera. */
#include <iostream>
void ordenamientoEscalera(int* A,int fi){

//Completar
}
// No modificar desde aqui

void leerElementos(int *A,int fi){
srand(1);
for(int i=0;i<fi;i++){
for(int j=0;j<fi;j++){
cin>>*(A+(i*fi)+j);
}
}
}
// No modificar
void mostrarElementos(int* A,int fi){
for(int i=0;i<fi;i++){
cout<<endl;
for(int j=0;j<fi;j++){
cout<<*(A+(i*fi)+j)<<" ";
}
}
}
// No modificar
int main()
{
int n;
cin>>n;
int matriz[n][n];
leerElementos(matriz[0],n);
ordenamientoEscalera(matriz[0],n);
cout<<endl;
mostrarElementos(matriz[0],n);
return 0;
}
//utilizando punteros

P á g i n a | 153
//sin punteros
#include <iostream>
int main()
{
int n;
cin>>n;
int A[n][n];
for(int i=0; i<n; i++) for(int j=0; j<n; j++) cin>>A[i][j];
int m=n*n;
int aux[m];
int Aux;
int k=0;
//carga al auxiliar
for(int i=0; i<n;i++){
aux[k]=A[i][j];
k++;
}
}
//orden
for(int i=0; i<m-1 ;i++){
if(aux[j]>aux[j+1]){
Aux=aux[j];
aux[j]=aux[j+1];
aux[j+1]=Aux;
}
}
}
k=0;
for(int i=0; i<n ;i++){
if((i+2)%2==0){
A[i][j]=aux[k];
k++;
}else{
A[i][n-j-1]=aux[k];
k++;
}
}
}
for(int i=0; i<n;i++){
cout<<A[i][j]<<" ";
}
cout<<endl;
}
return 0;
}

154 | P á g i n a
Unidad 10: Punteros

Básicamente, el puntero es una variable cuyo contenido es la dirección de otra variable. El
operador & da la dirección de un objeto (variable), entonces la instrucción p=&a asigna la dirección
de a al puntero p. Se dice que p apunta a “a”.
Teniendo un sistema sexagesimal
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
0 1 2 3 4 5 6 7 8 9 A B C D E F
El valor de una variable esta almacenada en la memoria RAM, cada celda tiene 8 bites
aproximadamente (1 byte).
Sintaxis
Int *direc;
Sizeof();
La variable direc ahora puede guardar la dirección de cualquier variable del tipo int Si
requerimos guardar la dirección de cualquier otro tipo de variable declararíamos de forma análoga.
La función de sizeof nos ayuda a saber cuánto está ocupando dentro del almacenamiento (Calcula
el número de bytes de un tipo de dato o variable).
Operaciones con puntero

- Para crear un puntero al momento de declararlo debemos de poner un” *” al lado
del nombre del puntero del lado izquierdo.
- Para asignarle una dirección debemos de escribir el nombre
- un puntero puede apuntar a otro puntero declarándolo con “**” en vez de uno solo
- un puntero no puede apuntar a una constante o una expresión.
- Un puntero no puede apuntar a una dirección adyacente directamente con el
puntero.
- Np se puede asignar una dirección a un puntero de una variable que no sea del tipo
de variable establecida. Sin embargo, existe un tipo de puntero que puede guardar
cualquier tipo de dirección, pero no se puede operar con el valor. Este puntero es
“void *”.
- Podemos referirnos a la dirección de al lado de la variable apuntada desde el puntero
sumándole 1, si nos referimos una variable a N posiciones de la variable apuntada le
asignamos +N.
Ejemplo:
Int i, j, *p; // p es un puntero a int
P = &I; // p contiene la dirección de i
*P = 10; // i toma el valor de 10
P = &j; // p contiene ahora la dirección de j
*p = -2 // j toma el valor de -2

P á g i n a | 155
Ejemplo:
void main(void){
int a, b, c;
int *p1, *p2;
int **p; // p es un
Ejemplo:
int *p;
double *q;
void *r;
p = q; //ilegal
p = (int *) q; //legal
r = q; //legal
p = r //ilegal
*r = 3; //ilegal
Observación:
El operador * es el” desreferenciador”. Al aplicarlo a un puntero, se accede al objeto al que apunta.
Un ejemplo del uso de estos operadores es el siguiente:
int x=1, y=2, z[3];
int *ip; // ip es un puntero del tipo int
ip=&x; // ip apunta a x
y=*ip // ahora y toma el valor de uno
*ip=0; // ahora x toma el valor de cero
Ejemplo:
*ip = *ip + 10; //incrementa x en 10
y = *ip + 1; //es lo mismo que poner y=x+1
*ip += 1; //incrementa el valor de x en 1
++*ip; //también incrementa x en 1;
(*ip)++ /*se usa el paréntesis para incrementar x. Si no se coloca,
se incrementa el valor del puntero!*/
Puntero y Arrays
En un arrays los elementos están guardados uno al lado del otro, por lo que si tenemos la dirección
de uno de los elementos podemos acceder a los demás elementos sumando o restando números.
Ejemplo:
Int a=5, b[]={1,2,3,4};

Int *p;
P=&a;
Operaciones permitidas Operaciones inválidas

P=b B++;
P=&b[3] B=b+3
a=*(b+1) B=&a
p=b+2 B=p

156 | P á g i n a
Doube vect[10];
Doublé *P;
…
P=&vect[0];
…
*p
*(p+1) =
*(p+2) =
Ejemplo:
/* Leer e imprimir una matriz m*n, trabajando con funciones */
#include<iostream>
void cargar(int *q, int m, int n){
cin>>*(q+i*n+j);
}}}
void imp(int *q, int m, int n){
cout<<*(q+i*n+j)<<" ";
}
cout<<endl;
}}
int main(){
int m,n;
cout<<"Introduzca el tamaño de la columna y la fila: "<<endl;
cin>>m>>n;
int a[m][n];
int *p;
p=&A[0][0];
cargar(*p, m, n);
imp(*p, m, n);
return 0;
}
Nota para una formula general para matrices y punteros:
𝑝𝑢𝑛𝑡𝑒𝑟𝑜 + 𝑖 ∗ 𝑛𝑢𝑚𝑒𝑟𝑜𝐶𝑜𝑙𝑢𝑚𝑛𝑎 + 𝑗

P á g i n a | 157
Quicksort
Es un algoritmo de divide y cenceras. Funciona seleccionando un elemento pivote de la matriz
dividiendo los otros elementos en dos submatrices
6 5 3 1 8 7 2 4
6 5 3 1 8 7 2 4
2 5 3 1 8 7 6 4
2 5 3 1 8 7 6 4
2 5 3 1 8 7 6 4
2 5 3 1 8 7 6 4
2 1 3 5 8 7 6 4
2 1 3 5 8 7 6 4
1 2 3 5 8 7 6 4
1 2 3 4 8 7 6 5
…
1 2 3 4 5 6 7 8

158 | P á g i n a
Ejemplo:
/*Quicksort por punteros*/
#include<iostream>
void quicksort(int *p, int izq, int der){
int i=izq, j=der, aux;
int piv=(izq+der)/2;
do{
while(i<=der and *(p+1)<*(p+piv)){
i++;
}
while(j>izq and *(p+j)=>*(p+piv)){
j--;
}
if(i<=j){
aux=*(p+1);
*(p+1)=*(p+j);
*(p+j)=aux;
j--;
i++;
}
}while(i<=j);
if(j>izq){
quicksort(p,j,izq)
}
if(i<der){
quicksort(p,i, der)
}
}
int main(){
int A[]={12, 11, 13, 5, 6};
int *p;
p=&A[0];
quicksort(p, 0, 4); //prob
for(int i=0; i<5; i++){
cout<<A[i]<<" ";
}
return 0;
}

P á g i n a | 159
Ejercicios propuestos sobre punteros

/*Ingresar una matriz de orden m x n. Imprimir la matriz. Ordenar los elementos en forma
ascendente, de la mitad superior de la matriz, y en forma descendente la mitad inferior. Si el
número de filas es impar la fila del medio de la matriz no se ordena (se imprime tal como se cargo).
Obs. Puede ser utilizado cualquier método de ordenación. */
#include<iostream>
void burbujaAsc(float *p, int M, int N){
float aux;
for(int i=0; i<M*N;i++){
for(int j=0; j<M*N-1; j++){
if(*(p+j)>*(p+j+1)){
aux=*(p+j);
*(p+j)= *(p+j+1);
*(p+j+1)=aux;
}
}
}
}
void burbujaDes(float *p, int M, int N){
float aux;
for(int i=0; i<M*N;i++){
for(int j=0; j<M*N-1; j++){
if(*(p+j)<*(p+j+1)){
aux= *(p+j);
*(p+j)= *(p+j+1);
*(p+j+1)=aux;
}
}
}
}
int main(){
float temp1,k, m,n;

int i, j;
cin>>m>>n;
float A[int(m)][int(n)];
//no modificar ingreso de la matriz
for(i=0;i<m;i++){
for(j=0;j<n;j++){
cin>>A[i][j];
}}
//realizar aqui el metodo de ordenacion que mejor les parezca
float *p1, *p2;
if(int(m)%2==0){
p1=&A[0][0];
burbujaAsc(p1, int(m)/2, int(n));
p2=&A[int(m/2)][0];

160 | P á g i n a
burbujaDes(p2, int(m)/2, int(n));

}else{
p1=&A[0][0];
burbujaAsc(p1, int(m)/2, int(n));
p2=&A[int(m/2)+1][0];
burbujaDes(p2, int(m)/2, int(n));
}
//Impresion de la matriz no modificar
for(i=0;i<m;i++){
for(j=0;j<n;j++){
cout<<A[i][j]<<" ";
}
}
}
/* Ingrese una matriz mat1[m][n] (validar m y n como enteros y positivos). Luego, copie los valores
de mat1 a la matriz ampliada matamp[m][n+3]. Por último, cargue en matamp los valores
máximo, mínimo y promedio de cada fila. Imprima matamp.
Observaciones:
- La carga, copia e impresión en pantalla de las matrices deben ser realizadas mediante
funciones y pasos por referencia.
- No modifique el main a menos que se indique expresamente lo contrario.
- No modifique el prototipado de las funciones. */
#include<iostream>
int leeInt( );
void impMat(int m, int n, float *mat);//no modificar el prototipado
void cargarmatriz(int m, int n, float *mat,float *matamp);//no
modificar el prototipado
void maymenprom(int m,int n, int i, int *may, int *men, float *prom,
float *mat);//no modificar el prototipado
int main(){
int i, j, k, m, n,mayor,menor;
float promedio;
m = leeInt( ); //no modificar esta parte
n = leeInt( ); //no modificar esta parte
float mat1[m][n], matamp[m][n+3];
float *p1, *p2;
p1=&mat1[0][0]; //P1 apunta a la matriz mat1
p2=&matamp[0][0];
cargarmatriz(m, n, p1, p2);
for(i=0;i<m;i++){
maymenprom(m, n, i, &mayor, &menor, &promedio, *mat1);
matamp[i][n]=mayor; //retornado por referencia, no

modificar esta parte

P á g i n a | 161
matamp[i][n+1]=menor; //retornado por referencia, no

matamp[i][n+2]=promedio; //retornado por referencia, no

}
impMat( m, n+3, &matamp[0][0]);
return(0);
}
int leeInt(){ //no modificar esta funcion
float kf;
do {
cin >> kf; }
while ( kf != int(kf )|| kf <= 0 );
return int(kf);
}
void maymenprom(int m, int n, int i, int *may, int *men, float
*prom,float *mat) //desarrollar la funcion
{
float suma=0;
*may=*(mat+n*i+0);
*men=*(mat+n*i+0);
for(int j=0; j<n ; j++){
if(*(mat+n*i+j)>*may){
*may=*(mat+n*i+j);
}
}
if(*(mat+n*i+j)<*men) *men=*(mat+n*i+j);
}
suma=suma+*(mat+n*i+j);
}
*prom=int(suma/n);
}
void cargarmatriz(int m, int n, float *mat,float *matamp)
//desarrollar la funcion
{
int aux=0;
cin>>*(mat+n*i+j);
*(matamp+n*i+j+aux)=*(mat+n*i+j);
if((j+1)%n==0) aux=aux+3;
}
}

162 | P á g i n a
}
void impMat( int m, int n, float *mat ){ //no modificar esta funcion
int i, j,k;
k = 0;
for (i=0; i<m; i++){
for(j=0; j<n; j++){
cout << *(mat+n*i+j)<<" ";
}
}
}
/* Elabore un programa que pida al usuario las dimensiones de una matriz MxN y luego pida al
usuario que introduzca los elementos de la matriz en orden ascendente, luego imprima la matriz
(para todo utilice punteros).*/
#include<iostream>
void cargar(int *p, int tam){
if(i==0){
cin>>*(p+i);
}
else{
cin>>*(p+i);
while(*(p+i)<=*(p+i-1)){
cout<<"\n\tIngrese nuevamente, no es ascendente
<3 \n";
cin>>*(p+i);
}}}}
void imprimir(int *p, int m, int n){
for(int i=0; i<m*n; i++){
cout<<*(p+i)<<" ";
if((i+1)%n==0){
cout<<endl;
}
}
cout<<"\n\t\tAnd I will try to fix you <3 ";
}
int main(){
int m, n;
cout<<"Ingrese los valores de m y n: \n";
cin>>m>>n;
int A[m][n];
int *p;
p=&A[0][0];
cout<<"Cargue la matriz: \n";
cargar( p, m*n);
imprimir(p, m, n);

P á g i n a | 163
/*Crear una matriz de números enteros de 3 filas y 5 columnas, cargarla con la sucesión de
Fibonacci a través de una función y luego imprimir la matriz utilizando punteros*/
#include<iostream>
void cargaFibo(int *p, int m, int n){
int aux=0;
if(i==0){
*(p+i)=0;
}
else if(i==1){
*(p+i)=1;
}else if (i>=2){
*(p+i)= *(p+i-2) + *(p+i-1);
}}}
cout<<*(p+i)<<"\t";
if((i+1)%n==0){
cout<<endl;
}}}
int main(){
int m=3, n=5;
int A[m][n];
int *p=&A[0][0];
cargaFibo(p, m, n);
imprimir(p, m, n);
return 0;
}
//otra forma de ver la carga de fibonacci
Fibonacci(int x){
int elemento=1, elementoAnt=0, aux, i=0;
while(i<=x){
if(i==x){
return elemento;
} else {
if(i==0) {
elemento=1;
elementoAnt=1;
i++;
} else {
aux=elemento;
elemento=elemento+elementoAnt;
elementoAnt=aux;
i++;
}
}
}
}
164 | P á g i n a
/*Crear un programa que requiera las dimensiones de una matriz MxN, la cargue con números
aleatorios del 0 al 99, imprima la matriz y luego la mande a una función, donde los elementos de
la matriz que son pares serán divididos entre 2 y los impares serán multiplicados por 2. Para
imprimir la matriz y hacer la función utilice punteros*/
#include<iostream>
#include<cstdlib>
#include<ctime>
void carga(int *p, int m, int n){
*(p+i)=rand()%(99+1);
}
}
void funcion(int *p, int m, int n){
if(*(p+i)%2==0){
*(p+i)=*(p+i)/2;
}else{
*(p+i)=*(p+i)*2;
}
}
}
cout<<*(p+i)<<"\t";
if((i+1)%n==0){
cout<<endl;
}
}
}
int main(){
int m, n;
cout<<"Ingrese las dimensiones de la matriz: \n";
cin>>m>>n;
int A[m][n];
srand(time(NULL));
int *p=&A[0][0];
carga(p, m, n);
imprimir(p, m, n);
cout<<endl;
funcion(p, m, n);
imprimir(p, m, n);
return 0;
}
/**/

P á g i n a | 165

166 | P á g i n a
Unidad 11: Cadenas

En C no existe el dato “cadena” (string en inglés). Pero existe una convención en la forma de
representación de una cadena, y es a través de un arreglo de caracteres. El fin de una cadena se indica con
el carácter especial “\”. En C++ existe el string, que en realidad es una clase que internamente hace
básicamente lo mismo (con caracteres adicionales).
‘H’ ‘E’ ‘L’ ‘L ‘O’ ‘\0’

¿Cómo definimos una cadena?
char a[6]=[‘H’, ‘E’, ‘L’, ‘L’, ‘O’, ‘\0’};
char b[6];=”HELLO”;
El vector de caracteres puede tener un tamaño mayor que la cantidad de caracteres de la cadena. Aún asi,
el carácter especial es que determina el final de una cadena
char a[8]=[‘H’, ‘E’, ‘L’, ‘L’, ‘O’, ‘\0’};
char b[8];=”HELLO”;
‘H’ ‘E’ ‘L’ ‘L ‘O’ ‘\0’ ? ?
¿Cuál es la diferencia entre cadena y carácter?

Como se mencionó anteriormente, las cadenas son arreglos unidimensionales (vectores) de caracteres. Los
caracteres se expresan con comillas simples ‘ ’, mientras que las cadenas con comillas dobles “ ”.
Por lo tanto:
- Un carácter
Char c=’a’ //ocupa 1 byte
- Una cadena
Char cad[]=”a” //ocupa 2 bytes
¿Cómo ingresamos o imprimimos las cadenas?

#include<iostream>
int main(){
char cad[100]="Hola mundo";
//impresion en pantalla
cout<<cad<<endl;
//tambien podemos concatenar con otro tipo de expresiones
//como cargamos por teclado?
// uso de cin Por ejemplo si quiero usar de manera diferente los caracteres, ejemplo los nombres
y apellidos
// uso de cin.getline ------> cin.getline(cad, tamMax, delimitador)
char cad2[100];
cout<<"Ingrese la cadena: ";
// cin>>cad2; //lee hasta los espacios, tabulacion o salto de linea
cin.getline(cad2, 100);
cout<<"La cadena leida es:\n";
cout<<cad2;
return 0;
}

P á g i n a | 167
Ejemplo 1:
#include<iostream>
int main(){
char nombre[100];
char apellido[100];
cout<<"Ingrese el nombre y el apellido: ";
cin>>nombre;
cin>>apellido;
cout<<"\nEl apellido, nombre es:\n";
cout<<apellido<<", "<<nombre;
return 0;
}
Ejemplo 2:
#include<iostream>
int main(){
char nombre[100];
char apellido[100];
cout<<"Ingrese el apellido, nombre: ";
cin.getline(apellido, 100, ',');
cin.getline(nombre, 100);
cout<<"\nEl nombre apellido es:\n";
cout<<nombre<<" "<<apellido<<endl;
return 0;
}
Problemas con el “Salto” de cin.getline()
El problema nace cuando estamos usando esta función, el problema de “salto” de ciertas
instrucciones de lecturas de cadenas. Un ejemplo visual sería:
Como podrá comprobarse, luego de ingresar la primera cadena, automáticamente muestra ambas
cadenas en pantalla (en donde cad2 está vacía) y finaliza el programa. En resumen, esto ocurre porque el
enter que dimos al cargar “hola” quedó almacenado en el buffer, y es tomado por el cin.getline() para cad2
(que resulta en una cadena vacía, ya que ese enter es el delimitador por defecto).

168 | P á g i n a
Uso de fflush()
Generalmente damos solución a esto empleando la instrucción fflush(stdin) para limpiar el buffer de
entrada, impidiendo que el enter se cargue en el cin.getline() siguiente. Esta función se encuentra en la
librería cstdio.
El problema está en que fflush() está definido para el buffer de salida (stdout), siendo su
comportamiento indefinido para el buffer de entrada (stdin).
Cuando programamos en nuestros equipos, generalmente no tenemos inconveniente al usar fflush()

(la mayoría programa en Windows). Este no es el caso del VPL (que corre en Linux). De hecho, al emplearlo
allí, fflush() no tiene el comportamiento esperado.
Para solucionar este inconveniente se propone el uso de la función cin.ignore(), la cual se encarga de
ignorar el enter en el buffer de entrada.
Funciones básicas para cadenas

Para poder usar estas funciones es necesario que incluyamos las librerías cstring o string.h
#include<iostream>
#include<cstring>
int main(){
char cad[7750]="Hola", cad2[50]="mundo";
//strlen(cad1) ---> longitud de una cadena, devuelve la cantidad de

caracteres de la cadena
int longitud=strlen(cad2);
cout<<"La cantidad de elementos de cad2 es: "<<longitud;
//strcpy(cad1, cad2) ----> copia de una cadena a otra, de cad2 a cad1
strcpy(cad1, "chau");
cout<<"Ahora cad 1 es: "<<cad1;
//strcat(cad1, cad2) ----> concatenación de cadenas.
strcad(cad1, cad2);
cout<<"Ahora: "<<cad1;
//int a=strcmp(cad1, cad2) -----> devuelve un valor que representa
la diferencia entre las dos cadenas
return 0;
}

P á g i n a | 169
I. Propia implementación de la función que cuenta la cantidad de elementos de una cadena

#include<iostream>
int tamanhoCad(char cadena[]){
int i=0;
while(cadena[i]!='\0') i++;
return i;
}
int main(){
char cad1[50]="hola chau";
int longitud=tamanhoCad(cad1);
cout<<"cad1 tiene "<<longitud<<" elementos. ";
return 0;
}
II. Propia implementación de la función que copia de una cadena a otra
#include<iostream>
void copiarCadena(char cadena1[], char cadena2[]){
int i=0;
while(cadena2[i]!='\0'){
cadena1[i]=cadena2[i];
i++;
}
cadena1[i]='\0';
}
int main(){
char cad1[50]="holaaaaa", cad2[50]="chauu";
copiarCadena(cad1, cad2);
cout<<"Ahora cad1 contiene: "<<cad1<<endl;
return 0;
}
III. Propia implementación de la concatenación de dos cadenas
#include<iostream>
void concatenarCadenas(char cadena1[], char cadena2[]){
//Nos posicionamos al final de cad 1
int i=0;
while(cadena1[i]!='\0') i++;
int j=0;
while(cadena2[j]!='\0'){
cadena1[i]=cadena2[j];
i++;
j++;
}
cadena1[i]='\0';
}
int main (){
char cad1[50]="mundo", cad2[50]="hola";

170 | P á g i n a
concatenarCadenas(cad1, cad2);
cout<<"Ahora la cadena 1 contiene: "<<cad1<<endl
return 0;
}
IV. strcmp
Strcmp (cadena1, cadena2)
 Si es cero ambas cadenas son iguales

 Si es >0, entonces cadena1>cadena2
 Si es <0, entonces cadena1<cadena2
Ejemplo, con horca y horario, da un numero >0, debido a que en la tabla la c esta después que la a
V. Propia implementacion de comparacion de cadenas
#include<iostream>
int compararCadenas(char cadena1[], char cadena2[]){
int i=0;
while(cadena1[i]!='\0' and cadena1[i]==cadena2[i]){
i++;
}
if(cadena1[i]==cadena2[i]) return 0;
if(cadena1[i]>cadena2[i]) return 1;
if(cadena1[i]<cadena2[i]) return -1;
}
int main(){
char cad1[50]="horca", cad2[50]="horario";
int m=compararCadenas(cad1, cad2);
cout<<"La diferencia es: "<<m<<endl;
return 0;
}
//atoi e itoa
#include<iostream>
#include<cstdlib>
int main(){
char cad[]="12345";
//atoi --> array to integer
int a=atoi(cad); // a <-- 12345
cout<<"El numero representado por la cadena es: "<<a<<endl;
char cad2[10];
//itoa --> integer to array
itoa(a, cad2, 10); // cad <--"12345"
cout<<"\nLa cadena que representa al numero es: "<<cad2<<endl;
return 0;
}

P á g i n a | 171
VI. atoi
/*Funcion que recibe una cadena y devuelve el entero representado

en una
cadena, ejemplo:
entrada: '1' '2' '3' '4' '5' '\0'
salida: 12345
n=123*10+('4'-'0')
i=3
*/
#include<iostream>
#include<cstdlib>
int cadAEntero(char cad[]){
int i=0, n=0, signo=1;
//si tenemos un numero negativo
if(cad[i]=='-'){
signo=-1;
i++;
}
while(cad[i]!='\0'){
n=10*n+(cad[i]-'0');
i++;
}
return (n*signo);
}
int main(){
char cad[]="12345";
//conversion a un numero entero
int a=cadAEntero(cad); // a <-- 12345
cout<<"El numero representado por la cadena es: "<<a<<endl;
return 0;
}

172 | P á g i n a
VII. itoa
#include<iostream>
#include<cstdlib>
void enteroACad(int n, char cad[]){
//cotamos la cantidad de digitos de n
int nroDig=0;
int aux=n;
while(aux>0){
aux=aux/10;
nroDig++;
}
cad[nroDig]='\0';
aux=n;
int pos=nroDig-1, dig;
while(pos>=0){
dig=aux%10;
aux=aux/10;
cad[pos]=dig+'0';
pos--;
}
}
int main(){
int a=123459;
char cad[20];
//conversion a cadena
enteroACad(a, cad); // cad <--"12345"
cout<<"\nLa cadena que representa al numero es: "<<cad<<endl;
return 0;
}

P á g i n a | 173
Ejercicios propuestos sobre cadenas

/*Escribir una funcion que indique con true si la cadena de entrada representa un numero hexadecimal y
false en caso contrario el conjunto de simbolos en la base hexadecimal es el siguente
s = {0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F} */
#include<iostream>
bool esNumeroHex(char cad[]){
int i=0;
if(! ((cad[i]>='0' and cad[i]<='9') or (cad[i]>='A' and
cad[i]<='F'))){
return false;
}
i++;
}
return true;
}
int main(){
char cad1[]="A41E0"; //correcto
if(esNumeroHex(cad1)) cout<<"Cad1 representa un nro
hexadecimal"<<endl;
else cout<<"cad1 NO representa un nro hexadecimal"<<endl;
char cad2[]="A4ZE0"; //Incorrecto (Z)
if(esNumeroHex(cad2)){
cout<<"Cad2 representa un nro hexadecimal"<<endl;
}
else cout<<"cad2 NO representa un nro hexadecimal"<<endl;
return 0;
}
/*Escribir una función que reciba una cadena y cambie todas las letras minúsculas por mayusculas. Escribir
otra funcion que haga lo inverso. */
#include<iostream>
void pasarMayus(char cad[]){
int i=0;
if(cad[i]>='a' and cad[i]<='z'){
cad[i]=cad[i]-('a'-'A');
}
i++;
}
}
void pasarMinus(char cad[]){
int i=0;
if(cad[i]>='A' and cad[i]<='Z'){
cad[i]=cad[i]+('a'-'A');
}
i++;
}
}

174 | P á g i n a
int main(){
char frase[]="hOLa QuE tAl123 - compuTACION";
//pasamos a mayusculas
pasarMayus(frase);
cout<<"La cadena en mayuscula es: \n"<<frase<<endl;
//pasamos a minuscula
pasarMinus(frase);
cout<<"\nLa cadena en minuscula es:\n"<<frase<<endl;
return 0;
}
/*Escribir una funcion que invierta el orden de los digitos de un entero introduciento por teclado
Por ejemplo '1' '2' '3' '4' '5' '6' */

#include<iostream>
#include<cstring>
void invertirCad(char cad[]){
int i=0, desp=01212;
int tam=strlen(cad); //la cantidad de intercamnios tam/2
if(cad[0]=='-') desp=1;
char aux;
for(int i=0; i<tam/2 ; i++){
aux=cad[i+desp];
cad[i+desp]=cad[tam-i-1];
cad[tam-i-1]=aux;
}
}
//una forma de invertir usando punteros
void invertirCad2(char cad[]){
if(cad[0]!='-') invertirCad(cad);
else invertirCad(cad+1); //direccion del segundo elemento
}
int main(){
char nroCad[100];
cout<<"Ingrese un numero: "<<endl; cin>>nroCad;
invertirCad(nroCad);
cout<<"\nEl numero invertido es: "<<nroCad<<endl;
return 0;
}

P á g i n a | 175
/*Implementar la funcion:
void subcadena(char orig[], int desde, int n, char dest[]);

que almacena en la cadena "dest" la subcadena de "orig" que comienza en la
posicion "desde" y tiene "n" caracteres
ejemplo:
orig ----> "hola que tal"

subcadena(orig, 5, 3, dest) ----> guardar "que" em dest. */
#include<iostream>
#include<cstring>
void subcadena(char orig[], int desde, int n, char dest[]){

int j;
dest[j]=orig[j+desde];
}
dest[j]='\0';
}
int main(){
char cad1[20]="hola que tal", cad2[20];
cout<<"La cadena completa es: "<<cad1<<endl;
int desde=5, n=3;
subcadena(cad1, desde, n, cad2);
cout<<"\nLa subcadena que empieza en la posicion "<<desde;
cout<<" y tiene "<<n<<" elementos es: "<<cad2<<endl;
return 0;
}
/*Escribir un programa que reciba dos numeros enteros y positivos por teclado (max de 100 cifras c/u) y
muestre su suma en pantalla.
Nota: el maximo valor que almacena una variable de tipo int es +2147483647 (10 cifras) */
#include<iostream>
#include<cstring>
//devuelve el maximo entre dos numeros enteros
int maximo(int a, int b){
if(a>b) return a;
else return b;
}
//invierte una cadena
void invertirCad(char cad[]){
int tam=strlen(cad);
int i;
char aux;
for(i=0; i<tam/2; i++){
aux=cad[i];
cad[i]=cad[tam-i-1];
cad[tam-i-1]=aux;
}
}

176 | P á g i n a
void calcularSuma(char n1[], char n2[], char s){

//invertimos ambas cadenas
invertirCad(n1);
invertirCad(n2);
//determinamos el tam maximo
int tam1=strlen(n1), tam2=strlen(n2);
int maxTam=maximo(tam1, tam2);
//rellenamos de cero
int i;
for(i=tam1; i<maxTam; i++) n1[i]='0';
for(i=tam2; i<maxTam; i++) n2[i]='0';
//ahora sumamos
int suma, acarreo=0;
for(i=0; i<maxTam; i++){
suma= (n1[i]-'0') + (n2[i]-'0') + acarreo;
acarreo=0;
if(suma>=10){
acarreo=1;
suma= suma-10;
}
s[i] = suma + '0';
}
if(acarreo==1){
s[i]='1';
i++;
}
s[i]='\0';
//invertimos las cadenas
invertirCad(s);
int main(){
char a[101], b[101]; // +1 por el caracter de terminacion
cout<<"Ingrese el primer numero: ";
cin>>a;
cout<<"Ingrese el segundo numero: ";
cin>>b;
char s[102];
calcularSuma(a, b, s);
cout<<"\nLa suma es: "<<s<<endl;
cout<<"(Tiene "<<strlen(s)<<" digitos!)"<<endl;
return 0;
}

P á g i n a | 177
/*Lea una cadena de caracteres desde teclado, y luego permita determinar la cantidad de veces que
aparecen en la cadena las primeras 5 consonantes del abecedario, imprimiendo dicho número*/
#include <iostream>
#include <cstring>
int main(){
char cad[100];
cout<<"Ingrese su oracion: ";
cin.getline(cad,sizeof(cad));
int cont[5]={0,0,0,0,0};
int i=0;
//Debemos analizar cad[i];
if(cad[i]=='B' or cad[i]=='b') cont[0]++;
if(cad[i]=='C' or cad[i]=='c') cont[1]++;
if(cad[i]=='D' or cad[i]=='d') cont[2]++;
if(cad[i]=='F' or cad[i]=='f') cont[3]++;
if(cad[i]=='G' or cad[i]=='g') cont[4]++;
//tambien podemos colocar con el codigo ASCII
i++;
}
cout<<"Cantidad de b en la cadena: "<<cont[0]<<endl;
cout<<"Cantidad de c en la cadena: "<<cont[1]<<endl;
cout<<"Cantidad de d en la cadena: "<<cont[2]<<endl;
cout<<"Cantidad de f en la cadena: "<<cont[3]<<endl;
cout<<"Cantidad de g en la cadena: "<<cont[4]<<endl;
return 0;
}

178 | P á g i n a
/*Permita ordenar en orden alfabético los elementos de una cadena ingresada desde teclado (por ejemplo,
la cadena “casa”, debe devolver como resultado la cadena “aacs”). Imprimir la cadena original y la cadena
ordenada. */
#include<iostream>
#include <cstring>
void insercion(char A[], int n){
bool encontrado;
char aux;
int j;
aux=A[i];
j=i-1;
encontrado=false;
if(A[j]>aux){
A[j+1]=A[j];
j--;
}else{
encontrado=true;
}
}
A[j+1]=aux;
}
}
int main(){
char cad[100];
cin.getline(cad, sizeof(cad));
cout<<cad<<endl;
insercion(cad, strlen(cad));
cout<<cad<<endl;
return 0;
}

P á g i n a | 179
/*Implemente la función void estitulo (char []). La función debe verificar si la cadena ingresada es un título,
para cumplir con la condición el primer carácter tiene que ser un carácter de tipo mayúscula y estar
comprendidos entre las letras ‘A’ y la ‘Z’, los siguientes caracteres tienen que ser letras minúsculas entre
la ‘a’ y la ‘z’ o espacios. Por último, la función debe imprimir el mensaje “ES título” si cumple las condiciones
dadas o “NO es título” sino la cumple las condiciones mencionadas
Ejemplos:
· Lenguaje de programacion -> ES titulo
· lenguaje de programacion -> NO es titulo
· Lenguaje de #programcion -> NO es titulo
*/
#include<iostream>
#include <cstring>
void estitulo(char cad[]){

bool ban=true;
int i=0;
if(not(cad[i]>='A' and cad[i]<='Z')) ban=false;
else{
i++;
if(not((cad[i]>='a' and cad[i]<='z') or cad[i]==32))
ban=false;
i++;
}
}
if(ban==true) cout<<"Es titulo :)"<<endl;
else cout<<"No es titulo :("<<endl;
}
int main(){
char cad[100];
cout<<"Ingrese el titulo a evaluar: "<<endl;
estitulo(cad);
return 0;
}

180 | P á g i n a
/*Permita modificar una cadena ingresada desde teclado, de tal forma que solamente queden letras en la
misma, tanto mayúsculas como minúsculas, y se elimine todo otro caracter. Imprimir la cadena original y
la cadena después de realizado el cambio */
#include<iostream>
#include <cstring>
void modificar(char cad[]){

int i=0, aux=0;
//char aux;
if((cad[i]>='A' and cad[i]<='Z') or (cad[i]>='a' and
cad[i]<='z')){
cad[i-aux]=cad[i];
i++;
}else{
aux++;
i++;
}
}
cad[i-aux]='\0';
cout<<cad;
}
int main(){
char cad[100];
cout<<"Ingrese la cadena: "<<endl;
modificar(cad);
return 0;
}

P á g i n a | 181
/* Elaborar un programa en C++ que permita codificar una cadena de caracteres introducida desde teclado,
según el esquema propuesto:
- Cada letra entre A y F deberá ser cambiada por la letra que está dos posiciones más adelante en el
alfabeto (ejemplo: A por C); lo mismo aplica para las minúsculas correspondientes.
- Cada letra desde la G hasta antes de la S, deberá ser cambiada por la que está tres posiciones más
adelante (ejemplo: G por J); lo mismo aplica para las minúsculas correspondientes.
- Cada letra desde la S en adelante (hasta Y), por la que está una posición más adelante (ejemplo: S
por T); lo mismo aplica para las minúsculas correspondientes.
- Para el caso de la letra Z, cambiarla por la letra A; lo mismo aplica para las minúsculas
correspondientes.
- En el caso de los números del 0 al 8, reemplazar un número dado por el consecutivo (ejemplo: el 1
por 2, etc.), y en caso del dígito 9 reemplazarlo por un 0. Utilizar una función para la codificación,
y mantener inalterados todos los demás caracteres que no sean letras o números (puntos, comas,
etc.).
Imprimir finalmente el resultado de la codificación*/
#include<iostream>
#include<cstdlib>
#include<ctime>
void codificacion(char cad[]);

int main(){
char cad[10];
cout<<"Ingrese la palabra o frase a codificar:\n";
cin.getline(cad, 10);
codificacion(cad);
cout<<"\nLa palabra o frase ya codificada es:\n";
cout<<cad<<endl;
return 0;
}
void codificacion(char cad[]){
int i=0, tam;
//contamos la cantidad de elementos de la cadena
while(cad[i]!='\0')i++;
tam=i;
for(i=0; i<tam; i++){
if((cad[i]>='A' and cad[i]<='F') or (cad[i]>='a' and
cad[i]<='f')) cad[i]=cad[i]+2;
if((cad[i]>='G' and cad[i]<'S') or (cad[i]>='g' and
cad[i]<'s')) cad[i]=cad[i]+3;
if((cad[i]>='S' and cad[i]<='Y') or (cad[i]>='s' and
cad[i]<='y')) cad[i]=cad[i]+1;
//La diferencia entre la 'A' y la 'Z' es la misma con sus
minusculas
else if(cad[i]=='Z' or cad[i]=='z') cad[i]=cad[i]-25;
if(cad[i]>='0' and cad[i]<='8') cad[i]=cad[i]+1;
if(cad[i]=='9') cad[i]='0';
}
}

182 | P á g i n a
/*Lea una cadena de caracteres desde teclado, y luego permita determinar la cantidad de caracteres
numéricos presentes en la cadena, imprimiendo dicho número. */
#include<iostream>
int cantNum(char cad[]){
int aux, i=0;
if(cad[i]>='0' and cad[i]<='9'){
aux++;
}
i++;
}
return aux;
}
int main(){
char cad[50];
cout<<"Ingrese los caracteres: \n";
cout<<"La cantidad de caracteres del orden numerico es: ";
cout<<cantNum(cad);
return 0;
}
/*Lea el nombre completo de una persona, y además una letra cualquiera desde teclado, y que compruebe
cuántas veces aparece dicha letra en el nombre dado, si es que aparece. Imprimir la letra ingresada en
cuestión y el número de veces obtenido*/
#include<iostream>
int estaEn(char cad[], char B){
int i=0, aux=0;
//Como no especifica el problema, al buscar el caracter buscamos tanto
mayusculas como minusculas
if(B>='A' and B<='Z'){
if(cad[i]==B or cad[i]==B+32){
aux++;
}
}else if(B>='a' and B<='z'){
if(cad[i]==B or cad[i]==B-32){
aux++;
}}
i++;
}
return aux;
}
int main(){
char cad[50];
cout<<"Ingrese el nombre completo de la persona: ";
char B;
cout<<"Ingrese la letra a buscar: ";
cin>>B;
cout<<"Las vecees que '"<<B<<"' aparece en cad, es: ";

P á g i n a | 183
cout<<estaEn(cad, B);
return 0;
}
/* Escribir una función convertirBinarioADecimal () que reciba un número binario (como cadena, la cual
puede tener hasta 30 caracteres que representen a los bits) y devuelva su equivalente en el sistema
decimal (con el tipo de dato int).
Se puede suponer que el usuario siempre ingresará una cadena válida; es decir, sus caracteres representan
bits ('0' ó '1'), y tiene 30 caracteres como máximo.
Ayuda: Información sobre el sistema binario en: https://es.wikipedia.org/wiki/Sistema_binario
Ejemplos:
 Si se recibe "101" ---> La función devuelve 5

 Si se recibe "11111111" ---> La función devuelve 255
 Si se recibe "101010101010101010101010" ---> La función devuelve 11184810 */
#include<iostream>
#include<cmath>
#include<cstring>
int convertirBinarioADecimal(char nroBin[]){
int n, nro=0, a=0;
for(int j=strlen(nroBin)-1; j>=0; j--){

nro=nro+(nroBin[i]-'0')*pow(2,a);
a++;
}
return nro;
}
int main(){
char binario[31];
cin>>binario;
cout<<"El equivalente en sistema decimal es:
"<<convertirBinarioADecimal(binario);
return 0;
}

184 | P á g i n a
/*Escribir una función fechaValida () que reciba una fecha (como cadena, en formato (dd/mm/aaaa), y que
indique, a través de un mensaje en pantalla, si la misma es válida o no. Se puede suponer que siempre se
ingresará una fecha con este formato; y que d, m y a siempre serán caracteres que representen a los dígitos
del 0 al 9 (por ejemplo, una fecha ingresada podría ser así: 35/13/2021).
Si la fecha es válida, debe imprimirse (en pantalla) el mensaje "La fecha ingresada es valida.". En caso
contrario, ¡debe imprimirse en pantalla “La fecha ingresada es invalida!"
Obs: se debe considerar los años bisiestos y la cantidad de días de cada mes válido. */
#include<iostream>
/*Funcion que retorna 1 si el año es bisiesto, y 0 en caso contrario*/
int esBisiesto(int a){
return ((a%4==0 && a%100!=0) || a%400==0);
}
/*Funcion que retorna la cantidad maxima de dias en un determinado mes*/
int cantMaxDiaMes(int m, int a){
if(m==1 || m==3 || m==5 || m==7 || m==8 || m==10 || m==12) return 31;
if(m==4 || m==6 || m==9 || m==11) return 30;
if(m==2){
if(esBisiesto(a)) return 29;
else return 28;
}
return -1;
}
void fechaValida(char fecha[]){
int dia, mes, anho, diaMax;
dia= (fecha[0]-'0')*10+(fecha[1]-'0');
mes=(fecha[3]-'0')*10+(fecha[4]-'0');
anho=(fecha[6]-'0')*1000+(fecha[7]-'0')*100+(fecha[8]-
'0')*10+(fecha[9]-'0');
diaMax=cantMaxDiaMes(mes, anho);
if(dia<=diaMax and mes<=12 and anho>=1900 and anho<=2100){

cout<<"La fecha ingresada es valida.";
}else{
cout<<"La fecha ingresada es invalida!";
}
int main(){
char fecha[11];
cin>>fecha;
fechaValida(fecha);
return 0;
}

P á g i n a | 185
/*Elaborar un programa en C++ que permita invertir cada letra de una frase leída desde teclado, de tal
forma que se pueda leer la frase original leyendo de derecha a izquierda (por ejemplo, la cadena "Hola
FIUNA Paraguay", debe devolver como resultado la cadena "yaugaraP ANUIF aloH"). Imprimir la cadena
modificada.
 El programa debe cumplir con los formatos de entrada y salida del problema (como se indica en
el ejemplo).
 Puede evaluar su programa las veces que crea necesario, y corregir errores que surjan.
 Para obtener la calificación, se evaluará con la última versión de su código.
 Si el programa no compila, no tendrá puntaje.
 No utilice system("pause") en el código. */
#include<iostream>
#include<cstring>
#define TAMMAXCAD 1001
void modificar(char cad[]){
int nro;
nro= strlen(cad)-1;
char aux[nro];
for(int i=0; i<strlen(cad); i++){
aux[nro]=cad[i];
nro--;
}
for(int i=0; i<strlen(cad); i++){
cout<<aux[i];
}
}
int main(){
//IMPLEMENTAR
char cad[TAMMAXCAD];
modificar(cad);
return 0;
}

186 | P á g i n a
/*Escribir un programa en C++ que lea por teclado un conjunto de N palabras (el valor de N es ingresado
previamente, también por teclado) y las muestre en pantalla en orden alfabético.
Por ejemplo: si se ingresa "fiuna", "compu", "semana", "cadenas"; deberá mostrarse en pantalla:
"cadenas", "compu", "fiuna", "semana".
Se debe tener en cuenta lo siguiente:
 Para la impresión en pantalla, se muestra una palabra por línea.

 Las cadenas están compuestas por letras minúsculas.
 El usuario siempre ingresará un valor de N entero y positivo.
 El tamaño máximo de una cadena ingresada es de 30 (sin contar el caracter de finalización).
 Cualquier método de ordenamiento visto en el curso puede emplearse para ordenar un conjunto
de N palabras. Para comparar dos cadenas se puede utilizar strcmp, y para "pasar" una cadena a
otra se puede emplear strcpy.*/
#include<iostream>
#include<cstring>
int main(){
int N; //cantidad de palabras
cin>>N;
int i;
char palabras[N][31]; //utilizaremos una matriz de caracteres, donde
cada linea contendrá una palabra
//cargamos la matriz
cin>>palabras[i];
}
//Implementar aquí la solución
char aux[31];
for(int j=0; j<N-1; j++){
//Analizamos el valor de la diferencia entre dos cadenas
if(strcmp(palabras[j],palabras[j+1])>0){
strcpy(aux,palabras[j]);
strcpy(palabras[j],palabras[j+1]);
strcpy(palabras[j+1], aux);
}
}
}
for(int i=0; i<N;i++){
cout<<palabras[i]<<endl;
}
return 0;
}

P á g i n a | 187
/*Código Morse */
Quizás el más famoso de todos los sistemas

de codificación es el código Morse, desarrollado por
Samuel Morse en 1832, para su uso en el sistema
telegráfico. El código Morse asigna una serie de
puntos y rayas a cada letra del alfabeto, a cada
dígito y a unos cuantos caracteres especiales. La
versión internacional del código Morse aparece en
la siguiente tabla.
Escriba un programa en C++ que lea números

en código Morse y los convierta en números en base
10 (o sea, la representación “usual” de un número),
de acuerdo al formato de entrada/salida
establecido a continuación.
- Entrada del programa:

La cadena de entrada tiene un tamaño máximo de
1000. Se utiliza un espacio en blanco entre cada
dígito codificado en Morse y tres espacios en blanco
entre cada número codificado en Morse.
- Salida del programa:
Se debe mostrar los números que corresponden al
código Morse de entrada. Separe los números por
espacios simples.
Entrada: .---- ..... ..--- ---.. --... ----. -.... .---- .----
Salida: 152 8796 11
 El programa debe cumplir con los formatos de entrada y salida del problema (como se indica en el
ejemplo).
 Puede evaluar su programa las veces que crea necesario, y corregir errores que surjan.
 Para obtener la calificación, se evaluará con la última versión de su código.
 Si el programa no compila, no tendrá puntaje.
 No utilice system("pause") en el código.

188 | P á g i n a
#include<iostream>
#include<cstring>
int main(){
//IMPLEMENTAR
char morse[10][6]={".----","..---","...--","....-",".....", "-
....","--...", "---..", "----.", "-----"};
char nros[10]={'1', '2', '3', '4', '5', '6', '7', '8', '9', '0'};
char entrada[TAMMAXCAD];
cin.getline(entrada, sizeof(entrada));
char aux[6];
int k=0;
for(int i=0; i<strlen(entrada); i++){
if(entrada[i]!=' '){
aux[0+k]=entrada[i];
k++;
aux[5]='\0';
if(k==5){
for(int j=0; j<10; j++){
if(strcmp(morse[j], aux)==0){
cout<<nros[j];
if(entrada[i+2]==' '){
cout<<" ";
}
}
}
k=0;
}
}
}

P á g i n a | 189
Unidad 12: Estructuras

La estructura de datos es una construcción que se puede definir dentro de un lenguaje de
programación para almacenar colecciones de datos.
Un struct es un grupo de elementos de datos variables, agrupados bajo un mismo nombre.
Lo que hacemos es crear un nuevo tipo de datos.
Sintaxis
Struct nombre{
TipoDato nombrecampo1;
…
} variables;
Una vez definida una estructura se puede usar igual que cualquier otro tipo de dato de C++.
Esto significa que se pueden declarar variables del tipo estructura en cualquier parte del programa.
Para ello se utiliza la forma normal de declaración de variables Producto prod;
Hasta podemos crear arrays de struct: Producto p [10];
¿Cómo accedemos a los datos miembros?

El acceso a los datos miembros de una estructura es de la siuente forma:
nombreStruct.nombreCampo
Por ejemplo, si declaramos la variable Producto prod; para cargar o imprimir los datos miembros
podemos hacerlo de la siguente manera:
Cin>> prod.codigo;
Cout<<prod.descripcion;
Etc
Struct anidadas
Podemos crear estructuras dentro de otras estructuras, es decir, estructuras anidadas
struct Alumno{
Struct Fecha{ unsingned int cedula;
int dia; char nombre [20];
int mes; char apellido[20];
int anho; Fecha cumple;
} unsingned short edad;

}

190 | P á g i n a
Acceso a las estructuras anidadas

struct Alumno{ Alumno a;
unsingned int cedula; cout<<”cedula: “;
char nombre [20]; cin>>a.cedula;
char apellido[20]; cout<<”nombre: “;
Fecha cumple; cin.getline(a.nombre, 20);
unsingned short edad; cout<<”fecha nac.: “;
} cin>>a.cumple.dia;
cin>>a.cumple.mes;
cin>>a.cumple.anho;
…

P á g i n a | 191
Ejercicios propuestos sobre estructuras

/* Crear una estructura en C++ que lea y registre los datos de n empleados (n mayor o igual a 2, leído por
teclado y validado). Los datos requeridos son: nombre (char [20]), edad (unsigned short), sexo ('f' o 'm') y
sueldo (unsigned int).
Luego imprima los datos de todas las mujeres, la que más gana (y el monto) y la más joven (y su edad).
C. Análogamente con los hombres.
Ejemplo:
Ingrese un numero entero mayor o = a 2: 5
Para los siguientes valores de entrada
- A 32 f 1000
- B 33 f 2000
- C 25 m 3000
- D 30 m 4000
- E 34 f 1500 */
#include<iostream>
#include<cstdio>
//Cree aqui la estructura empleado con los campos indicados
struct empleado{
char nombre[20];
unsigned short edad;
char sexo;
unsigned int sueldo;
};
//Validamos la cantidad de empleados
int leerN(int a) {
float N;
do{
cout << "Ingrese un numero entero mayor o = a " << a << ": ";
cin >> N;
} while ( N != int(N) or (N < a ) );
return (int)N;
}
//Cargamos la cantidad de empleados
void leerEmpleado(empleado &e) {
//declare una varaible del tipo empleado
cin>>e.nombre;
cin>>e.edad;
cin>>e.sexo;
cin>>e.sueldo;
//y lea los datos del empleado
}
void imprimirEmpleado(empleado e) {
cout << endl;
//imprima aquí los datos del empleado, a continuación de cada texto
cout << "Nombre: "<<e.nombre;
cout << "\nEdad: "<<e.edad;
cout << "\nSexo: "<<e.sexo ;

192 | P á g i n a
cout << "\nSueldo: "<<e.sueldo;

cout << endl;
}
void procesarMujeres(empleado emp[], int n){
cout << "-----Mujeres-----";
//agregue aqui el proceso solicitado
if(emp[i].sexo=='f'){
imprimirEmpleado(emp[i]);
}
}
cout << "\nMujer que mas gana";
int pMayor=0;
empleado Mayor;
int aux=0;
//llame a la funcion imprimirEmpleado
if(emp[i].sexo=='f' and aux<1){
Mayor=emp[i];
aux++;
}
if(emp[i].sueldo>Mayor.sueldo and emp[i].sexo=='f'){
Mayor=emp[i];
pMayor=i;
}
}
imprimirEmpleado(emp[pMayor]);
cout << "\nMujer mas joven";

int pMenor=0;
empleado Menor;
aux=0;
if(emp[i].sexo=='f' and aux<1){
Menor=emp[i];
pMenor=i;
aux++;
}
if(emp[i].edad<Menor.edad and emp[i].sexo=='f'){
Menor=emp[i];
pMenor=i;
}
}
imprimirEmpleado(emp[pMenor]);
}
void procesarVarones(empleado emp[], int n){
cout << "-----Varones-----";
//agregue aqui el proceso solicitado
if(emp[i].sexo=='m'){
imprimirEmpleado(emp[i]);
}
}

P á g i n a | 193
int pMayor=0;
empleado Mayor;
int aux=0;
cout << "\nHombre que mas gana";
if(emp[i].sexo=='m' and aux<1){
Mayor=emp[i];
aux++;
}
if(emp[i].sueldo>Mayor.sueldo and emp[i].sexo=='m'){
Mayor=emp[i];
pMayor=i;
}
}
imprimirEmpleado(emp[pMayor]);
cout << "\nHombre mas joven";
int pMenor=0;
empleado Menor;
aux=0;
if(emp[i].sexo=='m' and aux==0){
Menor=emp[i];
pMenor=i;
aux++;
}
if(emp[i].edad<Menor.edad and emp[i].sexo=='m'){
Menor=emp[i];
pMenor=i;
cout<<"hola2"<<endl;
}
}
imprimirEmpleado(emp[pMenor]);
}
int main(){
int n=leerN(2);
empleado empleados[n];
cout<<endl;
cout<<"Ingrese los datos del Empleado nombre, edad, sexo (f o m) y
sueldo"<<endl;
fflush(stdin);
leerEmpleado(empleados[i]);
}
cout << endl;
procesarMujeres(empleados, n);
cout << endl;
procesarVarones(empleados, n);
}

194 | P á g i n a
/*Escribir un programa que permita hacer las operaciones de suma, resta, multiplicación y división de
números complejos. El tipo complejo ha de definirse como una estructura. DEFINIR FUNCIONES PARA
CADA OPERACIÓN.*/
#include<iostream>
struct complejo{
float r; //parte real
float i; //Parte imaginaria
};
void suma(complejo a, complejo b){ //funcion suma void
cout<<"\nLa suma es: "<<a.r+b.r<<" + "<<a.i+b.i<<"i"<<endl;
}
complejo resta(complejo a, complejo b){ //funcion que retorna un
complejo
complejo res;
res.r=a.r-b.r;
res.i=a.i-b.i;
return res;
}
void multiplicacion(complejo* n1, complejo* n2, complejo* c){ //utilizando
punteros
(*c).r= (*n1).r*(*n2).r-(*n1).i*(*n2).i;
// (*c).i= (*n1).r*(*n2).i+(*n1).i*(*n2).r;
c->i= (n1->r)*(n2->i)+(n1->i)*(n2->r);
}
void division(complejo n1, complejo n2, complejo div){
//Se debe usar la formula
div.r = (a.r*b.r + a.i*b.i) / (b.r*b.r + b.i*b.i);
div.i = (a.r*b.i + -1*b.r*a.i) / (b.r*b.r + b.i*b.i);
}
int main(){
complejo n1, n2, rest, mul, div;
cout<<"Introduzca la parte real e imaginaia de n1: \n";
cin>>n1.r;
cin>>n1.i;
cout<<"Introduzca la parte real e imaginaia de n2: \n";
cin>>n2.r;
cin>>n2.i;
suma(n1, n2);
rest=resta(n1,n2);
cout<<"\nLa resta es: "<<rest.r<<" + "<<rest.i<<"i"<<endl;
multiplicacion(&n1, &n2, &mul);
cout<<"\nLa multiplicacion es: "<<mul.r<<" + "<<mul.i<<"i"<<endl;
division(n1, n2, &div);
cout<<"La division de ambos numeros es: "<<div.r<<" + "<<div.i<<"i"<<
endl;
return 0;
}

P á g i n a | 195
/*La información de todos los empleados de la empresa c está almacenada en una variable de tipo
estructura llamada "empleado". La información con la que cuenta de cada empleado es: nombre, sexo y
sueldo. Realizar un programa en C/C++ que lea los datos de los N trabajadores de la empresa y que imprima
los datos del empleado con mayor y menor salario, luego ORDENAR la información de los empleados por
método de Burbuja de acuerdo a su salario de forma ascendente*/
#include<iostream>
struct empleado{
char nombre[20];
char sexo;
int sueldo;
};
void cargar(empleado* p, int N){
cout<<"Ingrese los datos del empleado "<<i+1<<": \n";
fflush(stdin);
cout<<"\tNombre:\t";
cin.getline((p+i)->nombre, 20); //*(p+i).Nombre
cout<<"\tSexo:\t";
cin>>(p+i)->sexo;
cout<<"\tSueldo:\t";
cin>>(p+i)->sueldo;
}}
void imprimir(empleado* p, int N){
cout<<"\nNombre: "<<(p+i)->nombre<<endl;
cout<<"Sexo: "<<(p+i)->sexo<<endl;
cout<<"Sueldo: "<<(p+i)->sueldo<<endl;
}}
void Burbuja (empleado A[], int n){
empleado aux;
for (int i = 0 ; i<n-1 ; i++){
for(int j=0; j<n-1 ; j++){
if(A[j].sueldo < A[j+1].sueldo){///
aux=A[j];
A[j]=A[j+1];
A[j+1]=aux;
}}}
void busqueda(empleado A[], int n){ //Encontrar el mayor sueldo
empleado aux;
int i=0;
aux=A[i].sueldo,
for(i=1; i<N; i++){
}}
int main(){
int N;
cout<<"Ingrese la cantidad de empleados: " cin>>N;
empleado emp[N];
cargar(emp, N);
Burbuja(emp, N);
imprimir(emp, N);
return 0;
}

196 | P á g i n a
/*Utilzando una estructura de datos alumnos y fehca. leer la cedula, el+nommbre el apellido y la fecha de
nacimiento de N alumnos e imprimir en pantlla*/
#include<iostream>
struct Fecha{
unsigned short dia;
unsigned short mes;
unsigned short anho;
}
struct Alumno{
unsigned int cedula;
char nombre[20];
char apellido[20]; //string
Fecha fechaNac;
};
int leerN();
void leerFecha(Fecha& f);
void leerAlumno(Alumno& a);
int main(){
cout<<"Ingrese la cantidad de alumnos: ";
int N=leerN();
Alumno compu[N]
cout<<"Ingrese los datos del Alumno: "<<(i+1);
leerAlumno(compu[i]);
}
cout<<"Los datos cargados son: ";
}
return 0;
}
void leerAlumno(Alumno& a){
cout<<"\tCedula: ";
cin>>a.cedula;
//fflush(stdin)
cout<<"\tNombre: ";
cin.getline(a.nombre, 20);
cout<<"\tApellido: ";
cin.getline(a.apellido, 20);
leerFecha(a.fechaNac);

P á g i n a | 197
/* Un punto en el plano se puede representar mediante una estructura con dos campos. Escribir un
programa que realice las siguientes operaciones en el plano:
- Dados dos puntos, calcular la distancia entre ellos.

- Dados dos puntos determinar la ecuación de la recta que pasa por ellos */
#include<iostream>
#include<cmath>
#include<stdlib.h>
struct Punto{
float x;
float y;
};
void leerCoordenada(Punto P[]){
cout<<"Coordenada en x: "; cin>>(P->x);
cout<<"Coordenada en y: "; cin>>P->y;
}
int main(){
Punto coordenada[2];
for(int i=0; i<2; i++){
cout<<"Ingrese las coordenadas del punto "<<i+1<<": "<<endl;
leerCoordenada(&coordenada[i]);
}
float distancia, pendiente;
distancia = sqrt(pow(coordenada[0].x - coordenada[1].x, 2) +
pow(coordenada[0].y - coordenada[1].y, 2));
cout<<"La distancia entre los puntos es de: "<<distancia<<endl;
pendiente=(coordenada[1].y-coordenada[0].y)/(coordenada[1].x-
coordenada[0].x);
cout<<"La recta que forman ambos puntos es: (y-
"<<coordenada[1].y<<") = "<<pendiente<<"(x-"<<coordenada[1].x<<")"<<endl;
cout<<"La ecuacion de la resta que pasa por ambos puntos es: y
="<<(coordenada[1].y - coordenada[0].y)/(coordenada[1].x -
coordenada[0].x)<<"(x"<<-coordenada[1].x<<")+"<<coordenada[1].y<<endl;
return 0;
}

198 | P á g i n a
/*Sean Nombre, sexo, anho tres variables que contienen el nombre, sexo y años de pertenencia de cada
uno de los miembros de un club. Masculino o Femenino se denota mediante ‘M’ y ‘F’, respectivamente.
Diseñar un programa mediante arreglo de estructura, se ingrese los datos de N miembros del club, imprima
todos los miembros del club con todos sus datos, además busque la persona que tiene mayor antigüedad
e indicar si es masculino o femenino. */
#include<iostream>
#include<cstdio>
struct Miembros{
char nombre[20];
char sexo;
int anho; //año de pertenencia
};
void ingresarDatos(Miembros &a){
cout<<"Nombre: ";
fflush(stdin);
cin.getline(a.nombre,20);
cout<<"Sexo (M o F): ";
cin>>a.sexo;
cout<<"Anhos de antiguedad: ";
cin>>a.anho;
}
void imprimir(Miembros &a){
cout<<endl;
cout<<"Nombre: "<<a.nombre;
cout<<"\nSexo: "<<a.sexo;
cout<<"\nAntiguedad: "<<a.anho;
cout<<endl;
}
int main(){
int N;
cout<<"Ingrese la cantidad de miembros: "; cin>>N;
Miembros cad[N];
cout<<"\nIngrese los datos del miembro "<<i+1<<endl;
ingresarDatos(cad[i]);
}
cout<<"Datos del miembro "<<i+1<<endl;
imprimir(cad[i]);
}
int old=cad[0].anho, aux=0;
if(cad[i].anho>old){
old=cad[i].anho;
aux=i;
}
}
cout<<"El miembro mas antiguo es: "<<cad[aux].nombre<<" de sexo

"<<cad[aux].sexo<<endl;
}

P á g i n a | 199
/*Crear una estructura de datos Alumno para calcular la nota final (NF) de los 5 alumnos del curso
Programacion, así como también el promedio, el mínimo y el máximo de las notas.
- Leer por teclado el código del alumno y los puntajes parciales (P1 y P2) y puntaje final (EF) de cada
uno de éstos (enteros de 0 a 100, validar)
- El puntaje final se calcula empleando la fórmula: PF = 0.6*PP + 0.4*EF
- En donde PP es el promedio de parciales: PP = (P1+P2)/2
La nota final (NF) se determina mediante la siguiente tabla:
0-59 Nota 1
60-70 Nota 2
71-80 Nota 3
81-90 Nota 4
91-100 Nota 5
El cálculo de la Nota Final, el Promedio de las calificaciones así como la mayor y menor nota deben
realizarse a través de funciones. */
#include<iostream>
struct Alumno{
int codigo;
short P1;
short P2;
short EF;
short PF;
short NF;
};
int leerPuntaje(Alumno cad[]){
float x;
do {
cin>>x;
}while(int(x)!= x or x<0 or x>100);
return x;
}
int calcularNotaFinal(int PF){
if(PF>=0 and PF<=59) return 1;
}
float calcularPromedio(Alumno cad[], int N){
float prom=0;
prom= prom + cad[i].NF;
}
prom=prom/2;
return prom;
}
int calcularMayor(Alumno cad[], int N){
int Mayor=cad[0].NF;

200 | P á g i n a
if(cad[i].NF>Mayor){
Mayor=cad[i].NF;
}
}
return Mayor;
}
int calcularMenor(Alumno cad[], int N){
int Menor=cad[0].NF;
if(cad[i].NF<Menor){
Menor=cad[i].NF;
}
}
return Menor;
}
int main(){
int N;
cout<<"Ingrese la cantidad de alumnos: ";
cin>>N;
Alumno cad[N];
//analizamos alumno por alumno
cout << "\nIngrese el codigo, el parcial 1, el parcial 2 y el
examen final: ";
cout<<"\nAlumno N: "<<i+1<<endl;
cin>>cad[i].codigo;
//cargar notas
cad[i].P1 = leerPuntaje(cad);
cad[i].P2 = leerPuntaje(cad);
cad[i].EF = leerPuntaje(cad);
//Calculamos la nota final
cad[i].PF=0.6*((cad[i].P1+cad[i].P2)/2) + 0.4*cad[i].EF;
//Calculamos la nota final NF
calcularNotaFinal(cad[i].PF);
cout<<endl<<"\tPF: "<<prog[i].PF<<"\tNF: "<<prog[i].NF;
}
cout<<"\nPromedio de Notas: "<<calcularPromedio(cad, N);
cout<<"\nMayor Nota: "<<calcularMayor(cad, N);
cout<<"\nMenor Nota: "<<calcularMenor(cad, N);
return 0;
}

P á g i n a | 201
/*Utilizando estructuras comparar el perfil socio-económico (Ingreso per cápita mensual, es decir, el
ingreso mensual de la familia dividido la cantidad de personas que hay en ella) de n personas (Se debe
cargar su edad, si está en el grupo 1 o 2 y su ingreso per-cápita) y: G1) Su título más alto es de EEB (1° y 2°
Ciclo) (6° grado); G2) Posee título Universitario (superior universitario) o postgrado (especialización,
maestría y doctorado)
Ejemplo:
1)Edad: 27
Grupo: 1
Ingresos per-cápita: 900.000
2)Edad: 39
Grupo: 2
Ingresos per-cápita: 2.900.000
Imprimir:
a)Cuantas personas están en la extrema pobreza, pobreza total y fuera de la pobreza por cada grupo.
b)El promedio de los sueldos por cada grupo.
OBS. Considerar los siguientes indicadores:
• Salario mínimo: 2.192.839 gs.
• Pobreza total: 686.075 gs.
• Pobreza extrema: 262.768 gs.*/

#include<iostream>
//Cree aqui la estructura persona con los campos edad, grupo,icp
struct persona{
int edad;
int grupo;
unsigned int icp;
}p;
int validar(){
float n;
cin>>n;
cin>>n;
}
return int(n);
}
persona ingrese_persona(persona &p){
cin>>p.edad;
cin>>p.grupo;
cin>>p.icp;
}
void item_A(persona encuestado[],int n){
int ep1=0, ep2=0, pt1=0, pt2=0, np1=0, np2=0;//variables de extrema
pobreza, pobreza total y no pobres respectivamente
//Modifique desde aqui
int Sm=2192839, Pt=686075, Pe=262768;

202 | P á g i n a

if(encuestado[i].icp<=262768 and encuestado[i].grupo==1) ep1++;
//Extrema pobresa grupo 1
if(encuestado[i].icp<=262768 and encuestado[i].grupo==2) ep2++;
//Extrema pobresa grupo 2
if(encuestado[i].icp<=686075 and encuestado[i].icp>262768 and
encuestado[i].grupo==1) pt1++; //Pobresa total grupo 1
if(encuestado[i].icp<=686075 and encuestado[i].icp>262768 and
encuestado[i].grupo==2) pt2++; //Pobresa total grupo 2
if(encuestado[i].icp>686075 and encuestado[i].grupo==1) np1++;
//No pobreza grupo 1
if(encuestado[i].icp>686075 and encuestado[i].grupo==2) np2++;
//No pobreza grupo 2
}
//Modifique hasta aqui
cout<<"Grupo 1: hay "<<ep1<<" en extrema pobreza, "<<pt1<<" en
pobreza total y "<<np1<<" no pobres"<<endl;
cout<<"Grupo 2: hay "<<ep2<<" en extrema pobreza, "<<pt2<<" en
pobreza total y "<<np2<<" no pobres"<<endl;
}
void item_B(persona encuestado[],int n){
int prom1, prom2;// variables de promedio
//Modifique desde aqui
int sumaG1=0, sumaG2=0, p1=0, p2=0;
if(encuestado[i].grupo==1) {
sumaG1+=encuestado[i].icp;
p1++;
}
if(encuestado[i].grupo==2){
sumaG2+=encuestado[i].icp;
p2++;
}
}
prom1=sumaG1/p1;
prom2=sumaG2/p2;
//Modifique hasta aqui
cout<<"El promedio del grupo 1 es: "<<prom1;
cout<<endl;
cout<<"El promedio del grupo 2 es: "<<prom2;
}
int main(){
cout<<"ingrese N numero entero y positivo:\n";
int n=validar();
persona encuestado[n];
ingrese_persona(encuestado[i]);
}
cout<<n<<endl;
item_A(encuestado, n);
item_B(encuestado, n);
}

P á g i n a | 203
/*
*/

204 | P á g i n a
#METODO 1 (versión para el vpl semanal del aula virtual)

#include<iostream>
#include<cstring>
#include<cmath>
struct Fecha{
int dia,mes,anho;
};
/*Esta función devuelve true si el anho es bisiesto, y false en caso
contrario*/
bool esBisiesto(int anho){
if((anho%400==0 || (anho%4==0 && anho%100!=0)))
return true;
else
return false;
}
Fecha extraerDatos(char cadena[]){
//Completar la función que extrae los datos de la cadena y carga la
estructura (retornando esta estructura al final)
Fecha fecha;
int k=0;
int aux;
for(int i=0; i<12; i++){
if(i==0){
fecha.dia=(cadena[i]-'0')*10+(cadena[i+1]-'0');
}
if(i==3){
fecha.mes=((cadena[i]-'0')*10+cadena[i+1]-'0');
}
if(i>5 and i<10){
aux=(cadena[i]-'0')*pow(10,3-k)+aux;
fecha.anho=aux;
k++;
}
}
return fecha;
}
int obtenerNumeroDeDiasEnUnMes(int mes, int anho){
//Completar la función que obtiene (y retorna) la cantidad de días en
un determinado mes (teniendo en cuenta los años bisiestos).
int dias;
if(esBisiesto(anho)==true){
if(mes==2) dias=29;
}else{
if(mes==2) dias=28;
}
if(mes==1 or mes==3 or mes==5 or mes==7 or mes==8 or mes==10 or
mes==12) dias=31;
if(mes==4 or mes==6 or mes==9 or mes==11) dias=30;
return dias;
}

P á g i n a | 205
void indicarFechaValida(Fecha fecha){

/*Completar la función que valida la fecha de entrada (estructura) e
imprime el mensaje correspondiente (de acuerdo al formato definido en el
enunciado del problema)*/
if((fecha.anho>=1900 and fecha.anho<=2100) or
fecha.anho==int(fecha.anho)){
if(fecha.mes>=1 and fecha.mes<=12){
if(fecha.mes==2){
if(esBisiesto(fecha.anho)==true){
if(fecha.dia<0 and fecha.dia>29){
cout<<fecha.dia<<"/"<<fecha.mes<<"/"<<fecha.anho<<"
NO es una fecha valida";
}
}else{
if(fecha.dia<0 or fecha.dia>29){
cout<<fecha.dia<<"/"<<fecha.mes<<"/"<<fecha.anho<<"
NO es una fecha valida";
}
}
}
if(fecha.mes==1 or fecha.mes==3 or fecha.mes==5 or fecha.mes==7
or fecha.mes==8 or fecha.mes==10 or fecha.mes==12){
cout<<fecha.dia<<"/"<<fecha.mes<<"/"<<fecha.anho<<" NO es
una fecha valida";
}
}
if(fecha.mes==4 or fecha.mes==6 or fecha.mes==9 or
fecha.mes==11){
cout<<fecha.dia<<"/"<<fecha.mes<<"/"<<fecha.anho<<" NO es
una fecha valida";
}else{
cout<<fecha.dia<<"/0"<<fecha.mes<<"/"<<fecha.anho<<" es
una fecha valida";
}
}else{
cout<<fecha.dia<<"/"<<fecha.mes<<"/"<<fecha.anho<<" NO es una
fecha valida";
}
}else{
fecha valida";
}
}else{
fecha valida";
}
}
int main(){
// NO MODIFICAR EL MAIN!
int opcion;

206 | P á g i n a
//ESTA OPCION SIRVE PARA EVALUAR DE FORMA INDEPENDIENTE LAS 3

FUNCIONES REQUERIDAS
cin>>opcion;
char cadena[12];
Fecha fecha;
if(opcion==1){//SECCION QUE EVALUA LA FUNCION EXTRAER DATOS
cin>>cadena;
fecha=extraerDatos(cadena);
cout<<"Los datos de la fecha son:"<<endl;
cout<<"dia: "<<fecha.dia<<endl;
cout<<"mes: "<<fecha.mes<<endl;
cout<<"anho: "<<fecha.anho;
}
if(opcion==2){//SECCION QUE EVALUA LA FUNCION QUE OBTIENE EL NUMERO
DE DIAS DEL MES
cin>>fecha.mes;
cin>>fecha.anho;
cout<<"El mes "<<fecha.mes<<" anho "<<fecha.anho<<" tiene
"<<obtenerNumeroDeDiasEnUnMes(fecha.mes,fecha.anho)<<" dias";
}
if(opcion==3){//SECCION QUE EVALUA LA VALIDACION DE LA FECHA
cin>>fecha.dia;
cin>>fecha.mes;
cin>>fecha.anho;
indicarFechaValida(fecha);
}
return 0;
}
//Cabe destacar que no es la forma más simplificada para resolver y posee
un error a la hora de determinar que fechas son las vlaidas, habría que
replantear
/*Hacer un programa donde se ingrese una fecha (dia, mes, anho) y verifique si es una fecha válida
(controlar cantidad de días de los meses, año bisiesto, anho entre 1900 y 2100). Declarar fecha como una
estructura. */
#METODO 2 (Ejercicio resuelto por Veronica Baruja)

#include<iostream>
#include<stdlib.h>
struct Fecha {
short dia;
short mes;
short anho;
};
bool bisiesto (int n){
if (n % 4 == 0 && n % 100 != 0) return true;
else return false;
}
bool validarFecha (Fecha& f){
cout<<"Dia: "; cin>>f.dia;
cout<<"Mes: "; cin>>f.mes;
cout<<"Anho: "; cin>>f.anho;

P á g i n a | 207
if (f.anho < 1900 || f.anho > 2100) return 0;

if (f.mes < 1 || f.mes > 12) return 0;
switch (f.mes)
{
case 1 : if(f.dia < 1 || f.dia > 31) return 0; break;
case 2 : if(bisiesto(f.anho))
{
if(f.dia < 1 || f.dia > 29) return 0;
}
else if(f.dia < 1 || f.dia > 28) return 0; break;
}
return true;
}
int main () {
Fecha f;
cout<<"Ingrese una fecha: "<<endl;
if (validarFecha(f)) cout<<"La fecha es valida"<<endl;
else cout<<"La fecha NO es valida"<<endl;
system("Pause");
}

208 | P á g i n a
/* Escribir un programa para calcular el número de días que hay entre dos fechas: declarar fecha como
una estructura. */
#include<iostream>
#include<stdlib.h>
struct fecha{
short dia;
short mes;
int anho;
}f;
void leerFecha(Fecha& f){
do{
cout<<"Dia: ";
cin>>f.dia;
}while(f.dia<0 or f.dia>31);
do{
cout<<"Mes: ";
cin>>f.mes;
}while(f.mes<=0 or f.mes>12);
do{
cout<<"Anho: ";
cin>F.anho;
}while(f.anho<=0)
}
int main(){
fecha cad[2];
cout<<"Ingrese la 1ra fecha: \n";
leerFecha(Cad[0]);
cout<<"Ingrese la 2da fecha: \n";
leerFecha(Cad[1]);
int Dmes, Da, Daa;
if(cad[0].mes==cad[1].mes) Dmes=0;
else{
Dmes=cad[0].mes-cad[1].mes;
if(Dmes<0) Dmes=Dmes*-1;
}
if(cad[0].dia==cad[1].dia) Da=0;
else{
Dma=cad[0].dia-cad[1].dia;
if(Da<0) Da=Da*-1;
}
if(cad[0].anho==cad[1].anho) Daa=0
else{
Daa=cad[0].anho-cad[1].anho;
if(Daa<0) Daa=Daa*-1;
}
Da=Da+Dmes*30+Daa*365;
cout<<"La diferencia de dias es de: "<<Da<<endl;
return 0;
}
//Para este ejercicico no tuvimos en cuenta los años bisiestos asi como
la cantidad exacta de dias que hay en cada mes

P á g i n a | 209
/*Elaborar un programa en lenguaje C/C++ que, defina una estructura cuyo nombre sea complejo y que
represente a un número complejo. Además, lea por teclado N números complejos (N debe ser un número
entero y positivo, validar). Determinar e imprimir el número complejo de mayor módulo, así como su
módulo. */
#include<iostream>
#include<math.h>
//agruegue aqui la estructura complejo
struct complejo{
float R;
float I;
}c;
int validar()//funcion que valida numeros enteros y positivos
{
float x = -1;
while(x<=0||x != int(x)) {
cout<<"Ingrese la cantidad de numeros complejos (entero positivo):
\n";
cin>>x;
}
return int(x);
}
complejo cargaComplejo(complejo &c){
cin>>c.R;
cin>>c.I;
}
//agregue aqui la funcion para hallar el numero complejo con mayor módulo
float modulo(complejo &c){
float mod=0;
mod= sqrt( pow(c.R,2)+pow(c.I, 2));
return mod;
}
//debe retornar la posicion en el vector
int hallarMayor(complejo nc[], int N){
float aux=0, posicion=0, mod=0;
mod= modulo(nc[i]);
if(aux<mod){
aux=mod;
posicion=i;
}
}
return int(posicion);
}
int main() {
int N = validar(); //variable utilizada para almacenar el valor de
la cantidad de numeros complejos a ser leidos.
float mod = 0; //variable que guardará el mayor modulo, para
imprimir al final
//declare un vector "nc" de N elementos del tipo complejo
complejo nc[N];
//lea los N numeros complejos
cout << "Ingrese el numero complejo (real, imaginaria): ";

210 | P á g i n a
cargaComplejo(nc[i]);
}
int p = hallarMayor(nc, N); //hallarMayor debe devolver la

posicion del numero complejo con mayor modulo
//halle el mayor modulo y guarde en mod
mod=modulo(nc[p]);
cout << "\nEl numero complejo con mayor modulo es: ";
cout << nc[p].R << " + " << nc[p].I << "i, con modulo igual a " <<
mod;
return 0;
}
/**/

P á g i n a | 211

212 | P á g i n a

P á g i n a | 213
Ejercicios variados
/*Encontrar los n primeros numeros en el cual al elevar al cuadrado no se repitan ninguna de sus cifras
ejempllo 13´2=169, no entra el 10, 11, 12, 15....
n=1
output 1
n=2
outpud 2
...
n=4
outpud 16
... */
#include<iostream>
#include<cmath>
int validar(){
float n;
cout<<"Ingrese el numero: \n";
cin>>n;
while(n<0 or n!=int(n)){
cout<<"\nVuelva a ingresar el numero: \n";
cin>>n;
}
return int(n);
}
void estaEn(int N){
int contador=0, i=1, aux2;
bool ban;
while(contador<N){
int aux=i*i, dig;

ban=true;
while(aux>0 and ban==true){

dig=aux%10;
aux2=aux/10;
while(aux2>0){
if(dig==aux2%10) ban=false;
aux2=aux2/10;
}
aux=aux/10;
}
if(ban==true){
cout<<i<<" ";
contador++;
i++;
}else{

214 | P á g i n a
i++;
}
}
}
int main(){
int N=validar();
estaEn(N);
return 0;
}
/*(Desafío) Se cuenta con una lista L1 de N números enteros cargados por teclado (validar el valor de N y
los valores del vector) en el cual pueden existir valores repetidos. A fin de economizar el espacio de
almacenamiento, se desea crear una nueva lista L2 en la cual cada valor diferente aparece una sola vez, sin
repetición, pero indicando la cantidad de veces que se repite dicho valor en la lista L1. */
#include<iostream>
int validar();
void carga(int L1[], int N);
int imprimir(int L1[],int N){
cout<<endl<<"El vector es: \n";
cout<<L1[i]<<"\t";
}
cout<<endl;
}
int dif(int L1[], int N){
int cont=0, clave=0;
bool ban=true;
ban=true;
if(i==0) cont ++;
else{
clave=L1[i];
for(int j=i-1; j>=0;j--){
if(clave==L1[j]){
ban=false;
}
if(ban==false) break;
}
if(ban==true) cont++;
}
}
cout<<"\nLos diferentes son: "<<cont<<endl;
return cont;
}
int nroApar(int L1[], int N, int clave){
int cont=0;
if(clave==L1[i]) cont++;
}
return cont;
}
void nuevo(int L1[], int N, int L2[], int M){

P á g i n a | 215
int aux=0, dif=0, k=0;

int cont=0, clave=0;
bool ban=true;
ban=true;
if(i==0){
L2[k]=L1[i];
k++;
L2[k]=nroApar(L1, N, L1[i]);
k++;
}
else{
clave=L1[i];
for(int j=i-1; j>=0;j--){
if(clave==L1[j]){
ban=false;
}
if(ban==false) break;
}
if(ban==true){
L2[k]=clave;
k++;
L2[k]=nroApar(L1, N, L1[i]);
k++;
}
}
}
}
int main(){
int N=validar();
int L1[N], Dif;
carga(L1, N);
imprimir(L1, N);
Dif=dif(L1, N);
int L2[Dif*2];
nuevo(L1, N, L2, Dif*2);
imprimir(L2, Dif*2);
return 0;
}
int validar(){
float N;
cout<<"Ingrese el valor del tamanho: \n";
cin>>N;
while(N<=0 or N!=int(N)){
cout<<"Vuelva a ingresar el valor del tamanhoo: \n";
cin>>N;
}
return int(N);
}
void carga(int L1[], int N){
int A=0;

216 | P á g i n a
cout<<"Ingrese el valor en la posicion "<<i+1<<endl;

cin>>L1[i];
while(L1[i]!=int(L1[i])){
cout<<"Ingrese nuevamente el valor en la posicion
"<<i+1<<endl;
cin>>L1[i];
}
}
}
/* Ingresar por teclado un numero entero mayor que 1000, validarlo, determinar e imprimir el menor de
sus dígitos primos y la suma de sus dígitos*/
#include<iostream>
#include<cmath>
int validar(){
float N;
cout<<"Ingrese un numero entero y mayor a 1000: \n\t";
cin>>N;
cout<<"\n\tMMMMMMM vuelva a ingresar!!: \n\t";
cin>>N;
}
return int(N);
}
bool esPrimo(int N){
if(N==1 or N==0){
return false;
}else{
for(int i=2; i<=sqrt(N); i++){
if(N%i==0){
return false;
}
}
return true;
}
}
int cantPrimos(int N){
int cont=0, aux=0, i=2;
//digitos?? 1001 -> 1 0 0 1 -> no tiene primos
while(N>0){
aux=N;
aux=aux%10;
// cout<<"\nLa cifra analizada ahora es:\t"<<aux;
i=2;
while(i<10){
if(aux%i==0 and aux==i and esPrimo(i)){
cont++;
}
i++;
}
N=N/10;
P á g i n a | 217
}
cout<<"\n\n\tLa cantidad de cifras primas en el numero
es:\t"<<cont<<"!!";
return cont;
}
void sumAndImp(int N, int CP, int suma){

int cont=0, aux=0, menor=0, i;
suma=0;
while(N>0){
aux=N;
aux=aux%10;
suma=suma+aux;
i=2;
if(esPrimo(aux)==true){
cont++;
if(cont==1) menor=aux;
if(menor>aux){
menor=aux;
}
}
i++;
N=N/10;
}
if(CP==0) cout<<"\n\tPor lo tanto el numero no posee cifras primas
:c ";
if(cont>0) cout<<"\n\tEl menor numero primo es:\t"<<menor;
cout<<"\n\n\tLa suma de todos sus digitos es:\t"<<suma;
}
int main(){
int N=validar(), suma;
int CP=cantPrimos(N);
sumAndImp(N, CP, suma);
return 0;
}
/* Determine e imprima los 50 números capicúas consecutivos mayores que 1000. (Un número es
capicúa si es el mismo leyéndolo de derecha a izquierda. Ejemplo 23532). */
Nanana in my head

218 | P á g i n a
/**/
1. Lea dos números NUM y DEN (enteros y positivos), a continuación, imprima en pantalla la fracción
simplificada obtenida al dividir NUM entre DEN.
2. Lea un numero N entero y positivo e imprima la serie de Fibonacci hasta la posición N.
3. Calcule el producto de dos números utilizando funciones recursivas.
4. Ingresar un número y mostrar su equivalente en binario utilizando una función recursiva.
5. Escribir una función recursiva para determinar si un número es capicúa.
/**/

P á g i n a | 219
/*Cargue dos matrices de orden mxn. Luego calcule la suma, la resta y el producto (si es posible, imprimir
aviso en caso contrario) de dichas matrices. Luego imprima en pantalla las matrices resultados*/
#include<iostream>
#include<cmath>
//funcion de validacion
int validar(){
float N;
cout<<"Ingrese el tamanho: \n\t";
cin>>N;
cout<<"\n\tMMMMMMM vuelva a ingresar!!: \n\t";
cin>>N;
}
return int(N);
}
//carga
void carga(int *p, int m, int n){
cout<<"\nCargue la matriz:\n";
cout<<"Cargue el elemento "<<i+1<<":\t";
cin>>*(p+i);
}
}
//imprimir
cout<<*(p+i)<<"\t";
if((i+1)%n==0){
cout<<endl;
}
}
cout<<endl;
}
//suma
void suma(int *p, int *q, int m, int n, int m1, int n1, int *s){
if(m==m1 and n==n1){
*(s+i)=*(p+i)+*(q+i);
}
}else cout<<"\n\tLas matrices no se pueden sumar.";
}
//resta
void resta(int *p, int *q, int m, int n, int m1, int n1, int *r){
if(m==m1 and n==n1){
*(r+i)=*(p+i)-*(q+i);
}
}else cout<<"\n\tLas matrices no se pueden restar.";
}
//multiplicacion
void multiplicacion(int *p, int *q, int m, int n, int m1, int n1, int
*mul){

220 | P á g i n a
int aux=0;
if(n=m1){
for(int l=0; l<m*n1; l++){
for(int j=0; j<n1; j++){
//Falta hallar una forma para combinar
}
}
}
}else cout<<"\n\tLas matrices no se pueden multiplicar.";
}
int main(){
cout<<"\t\tMatriz 1\n";
int m1=validar(), n1=validar();
cout<<"\t\tMatriz 2\n";
int m2=validar(), n2=validar();
int A[m1][n1], B[m2][n2];
int *p, *q;
p=&A[0][0];
q=&B[0][0];
carga(p, m1, n1);
carga(q, m2, n2);
cout<<endl;
imprimir(p, m1, n1);
cout<<endl;
imprimir(q, m1, n1);
cout<<endl;
int sum[m1][n1], res[m1][n1], mul[m1][n2];
int *s, *r, *m;
s=&sum[0][0]; r=&res[0][0];
suma(p, q, m1, n1, m2, n2, s);
cout<<"La suma es: \n";
imprimir(s, m1, n1);
resta(p, q, m1, n1, m2, n2, r);
cout<<"La resta es: \n";
imprimir(r, m1, n1);
// multiplicacion(p, q, m1, n1, m2, n2, m);
if(n1==m2){
for(int i=0; i<m1; i++){
for(int j=0; j<n2; j++){
mul[i][j]=0;
for(int k=0; k<n1; k++){
mul[i][j]+= A[i][k]*B[k][j];
}
}
}
cout<<"La multiplicacion es: \n";
m=&mul[0][0];
imprimir(m, m1, n2);
}else{
cout<<"La multiplicacion no puede efectuarse.";
}
return 0;
}

P á g i n a | 221
/*Se desea cargar, por teclado, el código, nombre y apellido de 5 alumnos y generar aleatoriamente sus
puntajes (entre 1 y 30) de 3 asignaturas (Calculo, Geometria, Fisica) en un array de struct. Imprimir el
código, nombre y apellido, asignaturas con puntaje y el promedio del alumno. Imprimir además el
promedio de cada asignatura.*/
#include<iostream>
#include<cstdlib>
#include<ctime>
struct Puntajes{
short calculo;
short geometria;
short fisica;
} P;
struct Alumno{
short codigo;
char nombre[40];
Puntajes puntaje;
float promedio;
} a;
void carga(int N){
cout<<"Puntaje en Calculo: "; cin>>a.puntaje.calculo;
cout<<"Puntaje en Geometria: "; cin>>a.puntaje.geometria;
cout<<"Puntaje en Fisica: "; cin>>a.puntaje.fisica;
}
int main(){
Alumno Alum[5];
srand(time(NULL));
for(int i=0; i<5; i++){
cout<<"Ingrese los datos del Alumno N "<<i+1<<": "<<endl;
cout<<"\tCodigo: \t"; cin>>Alum[i].codigo;
cout<<"\tNombre y apellido: \t";
fflush(stdin);
cin.getline(Alum[i].nombre, 40);
Alum[i].puntaje.calculo=rand()%30;
Alum[i].puntaje.geometria=rand()%30;
Alum[i].puntaje.fisica=rand()%30;
Alum[i].promedio=(Alum[i].puntaje.calculo +
Alum[i].puntaje.geometria + Alum[i].puntaje.fisica)/3.00;
}
cout<<"\n";
//impresion
for (int i=0;i<5;i++){
cout<<"Codigo:\t"<<Alum[i].codigo<<endl;
cout<<"Nombre: "<<Alum[i].nombre<<endl;
cout<<"Puntaje Calculo: "<<Alum[i].puntaje.calculo<<endl;
cout<<"Puntaje Geometria: "<<Alum[i].puntaje.geometria<<endl;
cout<<"Puntaje Fisica: "<<Alum[i].puntaje.fisica<<endl;
cout<<"Su promedio es: "<<Alum[i].promedio<<endl;
cout<<"\n\n";
}
return 0;
}

222 | P á g i n a
/*Una empresa tiene 4 vendedores. Por cada vendedor se desea leer por teclado su código, sueldo base y
% de comisión (en decimales). Por cada vendedor, generar las ventas mensuales de seis meses, y calcular:
el monto de la comisión (ventas por comision dividido 100) y el sueldo neto de cada mes (sueldo base más
monto de la comisión) y el promedio de ventas del semestre. Calcular e imprimir, además, el total de:
ventas de la empresa, sueldo y comisión de los seis meses*/cin.getline
/**/

P á g i n a | 223
TAA’S
1. Se pide crear las siguientes estructuras de datos:

Puntaje (denominación de 7 caracteres, puntaje short sin signo)
Punto (a y b, short sin signo)
Tirador (nombre de 20 caracteres, disparos vector para 3 disparos que guardarán los puntos)
2. Crear una aplicación que muestre el siguiente menú:
--.-- Disparos al blanco --.—
1. Leer datos de Tirador
2. Salir Ingrese la Opcion->
Al seleccionar la opción 1 se debe solicitar al usuario que ingrese el nombre y apellido del Jugador
(en una sola variable) y generar aleatoriamente tres pares de números que equivalen a las coordenadas de
los puntos del plano cartesiano correspondientes a cada disparo (par de números (a, b) comprendidos entre
-10 y 10, inclusive).
Obs.: se hizo coincidir el centro del papel de tiro con el centro del plano cartesiano.
El programa debe calcular el mejor puntaje del tirador, de los 3 disparos, de acuerdo al valor de R. La
distancia R del punto P(a, b) al centro (0, 0) se calculará por medio de la fórmula expresada en el cuadro de
arriba. La denominación y el puntaje debe cargarse en la estructura Puntaje.
Se deben imprimir: el nombre del jugador, sus 3 disparos y el mejor disparo (la denominación con su
puntaje). Ejemplos de Salida:

224 | P á g i n a
/*Primer final */
#include<iostream>
#include<cmath>
#include<cstdio>
#include<ctime>
struct Tiros{
short Puntaje;
short Punto;
char Tirador;
};
struct Puntaje{
char denominacion[8];
unsigned short puntaje;
};
struct Punto{
short a;
short b;
};
struct Tirador{
char nombre[21];
int disparos[6];
};
void leerNombre(Tirador a){
cout<<"Ingrese el nombre del tirador:\t";
fflush(stdin);
cin.getline(a.nombre, 21);
cout<<a.nombre<<endl;
}
void mejorDisparo(int radio, Punto punt){
Puntaje A;
if(radio>=0 and radio<2){
strcpy(A.denominacion, "CENTRO");
A.puntaje=10;
}

P á g i n a | 225

strcpy(A.denominacion, "MEDIA");
A.puntaje=8;
}
strcpy(A.denominacion, "EXTERNA");
A.puntaje=5;
}
if(radio>=6 and radio<=10){
strcpy(A.denominacion, "BORDE");
A.puntaje=1;
}
if(radio>10){
// A.denominacion[8]= "FUERA";
strcpy(A.denominacion, "FUERA");
A.puntaje=0;
}
cout<<"\nMejor tiro:\t"<<A.denominacion<<"\nPuntaje:\t"<<A.puntaje;
cout<<"\n\n";
}
void leerDisparos(Tirador A){
float radio=0, aux=100;

cout<<A.nombre<<endl<<"Disparos:\n";
srand(time(NULL));
Punto punt, puntR;
for(int i=0; i<3; i+=2){
A.disparos[i]= (-10+rand()%(21));
A.disparos[i+1]= (-10+rand()%(21));
//designando
punt.a=A.disparos[i];
punt.b=A.disparos[i+1];
if(i==0) radio=sqrt(pow(punt.a,2)+pow(punt.b,2));
else aux=sqrt(punt.a*punt.a + punt.b*punt.b);
if(radio>aux){
radio=aux;
}
}
for(int i=0; i<3; i++){
cout<<A.disparos[i]<<","<<A.disparos[i+1];
cout<<endl;
puntR.a=A.disparos[i];
puntR.b=A.disparos[i+1];
}
cout<<endl;
mejorDisparo(radio, puntR);
}
void menu(void){
int opcion;

226 | P á g i n a
do{
cout<<"\t\t--.-- Disparos al blanco --.--";
cout<<"\n\t1. Leer datos del Tirador.\n\t2. Salir.\n\tIngrese
la opcion ->\t";
cin>>opcion;
cout<<endl;
//solicitar name
if(opcion==1){
Tirador A;
leerNombre(A);
leerDisparos(A);
}
}while(opcion==1);
cout<<"\n\t\tByee byee.";
}
int main(){
menu();
return 0;
}

P á g i n a | 227
Observaciones:
 Se debe definir necesariamente la función codificar() que realice lo solicitado. No se aceptará que la
funcionalidad se desarrolle en el main().
 Se proporciona un archivo con código inicial. Por practicidad en el proceso de desarrollo del
ejercicio, en el main() se encuentra pre-cargado el mensaje empleado para el ejemplo. De esta
manera, solo se debe llamar a la función codificar() con este mensaje y ver el mensaje codificado.
Sin embargo, codificar() deberá funcionar (de acuerdo con lo especificado anteriormente) para
cualquier caso de entrada.

228 | P á g i n a
#include<iostream>
#include<cstring>
void codificar(char original[], char codificado[] ){
bool ban1, ban2;

int sw=0;
char clave[10];
while(sw==0){
ban1=true; ban2=true;
cout<<"Ingrese la clave con diez digitos en forma no
ascendente:\t";
cin>>clave;
//Para que no sean iguales
for(int i=0; i<10; i++){
for(int j=i+1; j<10; j++){
if(clave[i]==clave[j]) ban1=false;
}
}
if(ban1==false) cout<<"Error, hay dos elementos iguales.
:c\n\n";
else{
//para que no sean ascendentes
if(clave[0]<clave[1]){
ban2=false;
}
}
}
}
}
}
}
}
if(ban2==false){
cout<<"Error, cargaste de forma ascendente :c\n\n";
}else if(ban1==true and ban2==true){
sw=1;
}
}
cout<<endl;
int sw2=0;
char aux[200];
while(sw2==0){
ban1=true;
cout<<"Ingrese una frase de 100 caracteres o menos:\t";

P á g i n a | 229
cin.ignore(100000, '\n');
cin.getline(aux, 200);
if(strlen(aux)>100) ban1=false;
if(ban1==false){
cout<<"Error, la frase tiene más de 100
caracteres.\n\n";
}else sw2=1;
}
strcpy(original, aux);
cout<<"\nLa frase contiene "<<strlen(original)<<" caracteres.\n";
for(int i=strlen(original); i<101; i++){
original[i]='*';
}
char Mat[10][10];
int cont=0;
for(int i=0; i<10; i++){
for(int j=0; j<10; j++){
Mat[i][j]=original[cont];
cont++;
}
}
cout<<endl;
for(int i=0; i<10; i++){
for(int j=0; j<10; j++){
cout<<Mat[i][j]<<"\t";
}
cout<<"\n";
}
cout<<"\nLa clave queda en:\t";
for(int i=0; i<10; i++){
cout<<clave[i]<<" ";
}
cout<<endl;
int p=0;
while(p<10){
for(int i=0; i<10; i++){
cout<<Mat[i][clave[p]-'0'];
}
p++;
}
}
int main(){
char original[101];
char codificado[101];
codificar(original, codificado);
return 0;
}

230 | P á g i n a

P á g i n a | 231
#include<iostream>
#include<cstring>
#include<ctime>
#include<cstdlib>
//Validacion
int validar(){
float N;
do{
cout<<"Ingrese un valor para el tamanho:\t";
cin>>N;
}while(N<=3 or N!=int(N) or (int(N))%2!=0);
return int(N);
}
//Carga
void carga(int *p, int N){
srand(time(NULL));
int i;
for(int i=0; i<N*N; i++){
*(p+i)=rand()%(2*N-1);
}
}
//Imprimir
void imprimir(int *p, int N){
cout<<*(p+i*N+j)<<"\t";
}
cout<<endl;
}
cout<<endl;
}
void orden(int v[], int tam){
int aux=0;
for(int l=1 ; l<=tam-1; l++){
for(int i=0;i<=tam-2;i++){
if(v[i]>v[i+1]){
aux=v[i];
v[i]=v[i+1];
v[i+1]=aux;
}
}
}
}
//void ordenarCuadrante()
int main(){
int N=validar(), Mat[N][N], *p;
p=&Mat[0][0];
carga(p, N);
imprimir(p, N);

232 | P á g i n a
//ordenmaos la matriz
// Para poder ordenar por metodo burbuja, Matriz---->Vector, metodo
burbuja, Vector---->Matriz
int s1=0, s2=0, s3=0, s4=0;
//Cuadrante 1
// M --> V
int k=0, tam=N*N/4, V[tam];
for(int i=0; i<=(N/2)-1; i++){
for(int j=N/2; j<=N-1; j++){
V[k]=Mat[i][j];
s1+=V[k];
k++;
}
}
//ordenamos
orden(V,tam);
// volmenos a pasar a matriz
k=0;
for(int i=0; i<=(N/2)-1; i++){
for(int j=N/2; j<=N-1; j++){
Mat[i][j]=V[k];
k++;
}
}
//Cuadrante 2
//M--->V
k=0;
for(int i=0;i<=(N/2)-1;i++){
for(int j=0;j<=(N/2)-1;j++){
V[k]=Mat[i][j];
s2=s2+V[k];
k++;
}
}
//ordenamos
orden(V, tam);
k=0;
for(int i=0; i<=(N/2)-1 ;i++){
for(int j=0; j<=(N/2)-1 ;j++){
Mat[i][j]=V[k];
k++;
}
}
//Cuadrante 3
//M--->V
k=0;
for(int i=N/2; i<=N-1 ;i++){
for(int j=0; j<=(N/2)-1 ;j++){
V[k]=Mat[i][j];
s3=s3+V[k];
k++;
}
}

P á g i n a | 233
//ordenamos
orden(V, tam);
k=0;
for(int i=N/2; i<=N-1 ;i++){
for(int j=0;j<=(N/2)-1;j++){
Mat[i][j]=V[k];
k++;
}
}
//cuadrante 4
//M---->V
k=0;
for(int i=N/2; i<=N-1;i++){
for(int j=N/2; j<=N-1;j++){
V[k]=Mat[i][j];
s4=s4+V[k];
k++;
}
}
//ordenamos
orden(V, tam);
k=0;
for(int i=N/2;i<=N-1;i++){
for(int j=N/2;j<=N-1;j++){
Mat[i][j]=V[k];
k++;
}
}
p=&Mat[0][0];
cout<<"La matriz ordenada es:\n";
imprimir(p, N);
cout<<"\n";
if(s1>s2 and s1>s3 and s1>s4) cout<<"La mayor de las sumatorias es:
"<<s1;
"<<s2;
"<<s3;
"<<s4;
return 0;
}
//Quizas con punteros se podria ahorrar el trabajo, pero no encontré una
forma

234 | P á g i n a

P á g i n a | 235
#include<iostream>
#include<cstring>
#include<ctime>
#include<cstdlib>
struct Bolilla{
char letra;
unsigned short numero;
};
//cadena de bolilla para guardar todo
void generarBolillero(Bolilla A[]){
for(int i=0; i<75; i++){
if(i>=0 and i<=14){
A[i].letra='B';
}else if(i>=15 and i<=29){
A[i].letra='I';
A[i].letra='N';
A[i].letra='G';
A[i].letra='O';
}
A[i].numero=i+1;
}
}
void imprimirBolillero(Bolilla A[]){
for(int i=0; i<75; i++){
cout<<A[i].letra; cout<<A[i].numero<<" ";
if(i==14) cout<<endl;
}
}
void generarCarton(int *p){
for(int i=0; i<5; i++){
for(int j=0; j<5; j++){
if(i==2 and j==2) *(p+5*j+i)=0;

236 | P á g i n a
else{
//encontramos una formula general para cada rago de
bolillas
//cuando i=0 -> *(p+5*j)=(0+1)+rand()%(
(15*(0+1))+1-(0+1)); el lim es 15
*(p+5*j+i)=(15*i+1)+rand()%( (15*(i+1))+1-
(15*i+1));
}
for(int k=j-1; k>=0; k--){
//siempre que hayan dos elementos iguales volvemos
a ingresar
while(*(p+5*j+1)==*(p+5*k+i)){
if(i==2 and j==2) *(p+5*j+i)=0;
else *(p+5*j+i)=(15*i+1)+rand()%((15*(i+1))+1-
(15*i+1));
}
}
}
}
}
void imprimirCarton(int *p){
char vec[5]={'B','I','N','G','O'};
for(int i=0; i<5; i++){
for(int j=0; j<5; j++){
if(i==2 and j==2) cout<<"F"<<*(p+5*i+j)<<"\t";
else cout<<vec[j%5]<<*(p+5*i+j)<<"\t";
} cout<<endl;
}
}
void mezclarBolillero(Bolilla A[], Bolilla B[]){
for(int i=0; i<75; i++){
B[i]=A[1+rand()%75];
for(int k=i-1; k>=0; k--){
while(B[i].numero==B[k].numero){
B[i]=A[i+rand()%75];
}
}
}
}
void verificarBolilla(int *p, Bolilla A){
bool ban=0;
for(int i=0; i<5; i++){
for(int j=0; j<5; j++){
if(*(p+5*i+j)==A.numero) ban=1;
}
}
if(ban==1){
cout<<"\tLa bolilla "<<A.letra<<A.numero<<" SI esta en el
carton\n\n";
}else{
cout<<"\tLa bolilla "<<A.letra<<A.numero<<" NO esta en el
carton\n\n";
}
}

P á g i n a | 237
void menu(Bolilla A[]){
int opcion;
do{
cout<<"\n\n--.--.--.-- EL BINGO --.--.--.-- \n\n";
cout<<"\n\tIngrese una opcion: \n\t1. Crear bolillero\n\t2.
Generar carton";
cout<<"\n\t3. Girar bolillero\n\t4. Extraer bolillero\n\t5.
Salir\n";
cout<<"Opcion --->\t";
cin>>opcion;
if(opcion==1){
generarBolillero(A);
imprimirBolillero(A);
int M[5][5];
generarCarton(&M[0][0]);
imprimirCarton(&M[0][0]);
Bolilla B[75];
generarBolillero(A);
imprimirBolillero(A);
cout<<endl;
mezclarBolillero(A,B);
imprimirBolillero(B);
int Mat[5][5];
Bolilla B[75];
generarBolillero(A) ;
mezclarBolillero(A,B);
cout<<endl;
generarCarton(&Mat[0][0]);
imprimirCarton(&Mat[0][0]);
cout<<endl;
verificarBolilla(&Mat[0][0],B[0]);
}
}while(opcion!=5);
}
int main(){
srand(time(NULL));
Bolilla B[75];
menu(B);
return 0;
}

238 | P á g i n a
Bibliografía
Colbes, J. (2022). Información del aula vitual. San Lorenzo, Paraguay.
Gonzales, I. J. (2019). ProgramaYa. Obtenido de https://www.programarya.com/Cursos/C++/Ciclos/Ciclo-

while
L., J., & L., G. (2006). Programación en C++. Un enfoque prático. Editorial McGraw-Hill/Interamericana.
Salcedo, I. N. (2022). Clases teóricas . San Lorenzo, Paraguay.
Stalder, D. (2022). Información del aula virtual. San Lorenzo, Paraguay.
Vaca, A. (22 de marzo de 2011). Cool C/C++. Obtenido de Programacion en C/C++:

http://www.programacionenc.net/index.php?option=com_content&view=article&id=92:funciones-
tipo-
bool&catid=31:general&Itemid=41#:~:text=Las%20funciones%20tipo%20bool%2C%20indican,gene
ral%20se%20indica%20con%200

Resumen Teórico-Práctico Compu

Cargado por

Información del documento

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

Resumen Teórico-Práctico Compu

Cargado por

Copyright:

Formatos disponibles

“Este material fue hecho mientras cursaba la materia, por lo que puede

contener ciertos errores en los ejercicios, en la teoría, en la ortografía, entre

Est. Janethe A. Olazar

Est. Janethe A. Olazar

Est. Janethe A. Olazar

Est. Janethe A. Olazar

Est. Janethe A. Olazar

/* Que se tendrá como salida si se ingresa 4 como altura del trapecio*/

Est. Janethe A. Olazar

2° Cuestionario del AV (semana 4)

Est. Janethe A. Olazar

Est. Janethe A. Olazar

La respuesta correcta es: 0

Est. Janethe A. Olazar

Mini cuestionario semana 5

3. Genera números aleatorios entre 22 y 43

Mini cuestionario semana 6

2. Considerando la definición de la función fizzle():

Mini cuestionario semana 7

Est. Janethe A. Olazar

3° Cuestionario del AV (semana 7)

Est. Janethe A. Olazar

Est. Janethe A. Olazar

Est. Janethe A. Olazar

Mini cuestionario semana 8

Est. Janethe A. Olazar

4° Cuestionario del AV (semana 9)

Est. Janethe A. Olazar

/*Elabore un programa en C++ tal que:

Est. Janethe A. Olazar

cout<<"La matriz la diagonal principal ordenada en forma ascendente es\n";

Est. Janethe A. Olazar

Est. Janethe A. Olazar

5° Cuestionario del AV (semana 10)

Est. Janethe A. Olazar

Est. Janethe A. Olazar

Est. Janethe A. Olazar

Mini cuestionario semana 11

- La letra h, el primer elemento de la cadena

Est. Janethe A. Olazar

6° Cuestonario del AV (semana 11)

Est. Janethe A. Olazar

Est. Janethe A. Olazar

Est. Janethe A. Olazar

Est. Janethe A. Olazar

Mini cuestionario semana 12

Est. Janethe A. Olazar

7° Cuestioario del AV (semana 12)

Est. Janethe A. Olazar

Est. Janethe A. Olazar

Est. Janethe A. Olazar

7) ¿Cuantas veces va a repetir el bucle?

Est. Janethe A. Olazar

Est. Janethe A. Olazar

Est. Janethe A. Olazar

case=C1 Opción 1 - Validar número entero

Est. Janethe A. Olazar

using namespace std;

} while(nf!=int(nf) or nf<=0 or nf>100);

Est. Janethe A. Olazar

}else if(opcion==4){//generar la secuencia con formato

Est. Janethe A. Olazar

Est. Janethe A. Olazar

Las funciones que deben implementarse son las siguientes