VICERRECTORADO DOCENTE Código: GUIA-PRL-001

CONSEJO ACADÉMICO Aprobación: 2016/04/06

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

FORMATO DE GUÍA DE PRÁCTICA DE LABORATORIO / TALLERES / CENTROS DE SIMULACIÓN PARA DOCENTES

CARRERA:COMPUTACIÓN ASIGNATURA: PROGRAMACIÓN NOMBRE: ANDRES CHILUISA

PRACTICA: 05 TÍTULO: EXPRESIONES Y SENTENCIAS OBJETIVO:
• Conocer y configurar las herramientas para desarrollar programas con el lenguaje C++ PRE
REQUISITOS:
a) Computador con un IDE para C++ instalado y configurado
b) Conexión a Internet
INSTRUCCIONES: 1. Verificar que se disponga de todos los pre requisitos
2. Desarrollar todas las actividades propuestas en el laboratorio
3. Realizar un informe de la práctica realizada
ACTIVIDADES A DESARROLLAR:

1. PRG-3
Escriba un programa que encuentre los valores mínimo y máximo para un float y un double en tu
computadora

/******************************************************************************
*Practica 5: ejercicio1 PRG-3 *
*Autor: Andrés Chiluisa *
*Fecha: 27-11-2023 *
******************************************************************************/

#include <iostream>
#include <limits>
int main() {
// Encontrar los valores mínimo y máximo para float y double
float float_min = std::numeric_limits<float>::min();
float float_max = std::numeric_limits<float>::max();
double double_min = std::numeric_limits<double>::min();
double double_max = std::numeric_limits<double>::max();
// Mostrar los resultados
std::cout << "Valor mínimo para float: " << float_min << std::endl;
std::cout << "Valor máximo para float: " << float_max << std::endl;
std::cout << "Valor mínimo para double: " << double_min << std::endl;
std::cout << "Valor máximo para double: " << double_max << std::endl;
return 0;
}
 Valor mínimo para float: 1.17549e-038
Valor máximo para float: 3.40282e+038
Valor mínimo para double: 2.22507e-308
Valor máximo para double: 1.79769e+308

CONCLUSION: Para poder encontrar los valores mínimos y máximos de float y double, es necesario agregar numeric
para que el programa empiece a lanzar datos de lo que estamos pidiendo en este caso el valor mínimo y máximo para
float, valor mínimo y máximo para double seguido de //mostrar los resultados.

2. PRG-6
Escriba un programa que, dado un entero de tres dígitos, construya e imprima otro entero cuyos dígitos
estén en orden inverso al dado. Por ejemplo, dado 372, el programa imprime 273.

/******************************************************************************
*Practica 5: ejercicio2 PRG-6 *
*Autor: Andrés Chiluisa *
*Fecha: 27-11-2023 *
******************************************************************************/

#include <iostream>
int main() {
// Solicitar al usuario ingresar un número de tres dígitos
int numero_original;
std : : cout << "Ingrese un número entero de tres dígitos: ";
std : :cin >> numero_original;

// Verificar que el número tenga tres dígitos

if (numero_original >= 100 && numero_original <= 999) {
// Extraer los dígitos individualmente
int digito_cientos = numero_original / 100;
int digito_decenas = (numero_original % 100) / 10;
int digito_unidades = numero_original % 10;
// Construir el número invertido
int numero_invertido = digito_unidades * 100 + digito_decenas * 10 + digito_cientos;
// Imprimir el resultado
std : : cout << "Número original: " << numero_original << std : : endl;
std : : cout << "Número invertido: " << numero_invertido << std : : endl;
} else {
std : : cout << "Por favor, ingrese un número de tres dígitos." << std : : endl;
}
return 0;
}
 Ingrese un número entero de tres dígitos: 324
Número original: 324
Número invertido: 423

CONCLUSION: Solicitamos al usuario ingresar un numero de tres dígitos en este caso el numero debe ser entero,
debemos verificar que el numero tenga tres dígitos, extraer los dígitos individualmente (debe estar en cientos,
decenas, unidades). Construir el numero invertido por último imprimimos el resultado del numero original y el
numero invertido

3. PRG-7
Escriba un programa que, dado un número de horas, calcule el número de semanas, días y horas incluidas en
ese número.

/******************************************************************************
*Practica 5: ejercicio3 PRG-7 *
*Autor: Andrés Chiluisa *
*Fecha: 27-11-2023 *
******************************************************************************/

#include <iostream>

int main() {
// Solicitar al usuario ingresar el número de horas
int horas;
std : : cout << "Ingrese el número de horas: ";
std : : cin >> horas;
// Calcular semanas, días y horas
int semanas = horas / (7 * 24);
int dias = (horas % (7 * 24)) / 24;
int horas_restantes = horas % 24;
// Imprimir el resultado
std : : cout << horas << " horas son equivalentes a:" << std : : endl;
std : : cout << "Semanas: " << semanas << std : : endl;
std : : cout << "Días: " << dias << std : : endl;
std : : cout << "Horas: " << horas_restantes << std : : endl;
return 0;
}
Ingrese el número de horas: 16:00
16 horas son equivalentes a:
Semanas: 0
Días: 0
Horas: 16

CONCLUSION: Solicitar al usuario ingresar el numero de horas (“Ingrese el numero de horas”), calcular semanas,
dias y horas (7*24), imprimimos el resultado (horas son equivalentes, “semanas”, “dias”, “horas”). Siguiendo la
secuencia el programa nos da el terminal.
4. PRG-9
Escriba un programa que ingrese el número de segundos (un valor largo) y lo cambie a días, horas, minutos y
segundos.

/******************************************************************************
*Practica 5: ejercicio4 PRG-9 *
*Autor: Andrés Chiluisa *
*Fecha: 27-11-2023 *
******************************************************************************/

#include <iostream>
int main() {
// Solicitar al usuario ingresar el número de segundos
long long segundos;
std : : cout << "Ingrese el número de segundos (un valor largo): ";
std : : cin >> segundos;
// Calcular días, horas, minutos y segundos
long long dias = segundos / (24 * 3600);
long long horas = (segundos % (24 * 3600)) / 3600;
long long minutos = (segundos % 3600) / 60;
long long segundos_restantes = segundos % 60;
// Imprimir el resultado
std : : cout << segundos << " segundos son equivalentes a:" << std : : endl;
std : : cout << "Días: " << dias << std : : endl;
std : : cout << "Horas: " << horas << std : : endl;
std : : cout << "Minutos: " << minutos << std : : endl;
std : : cout << "Segundos: " << segundos_restantes << std : : endl;
return 0;
}

Ingrese el número de segundos (un valor largo): 32468852112

32468852112 segundos son equivalentes a:
Días: 375796
Horas: 21
Minutos: 35
Segundos: 12
CONCLUSION: Solicitamos al usuario ingresar el numero en segundos (Ingrese el número de segundos (un valor
largo), calcular (dias, horas, minutos y segundos). Imprimimos el resultado (segundos son equivalentes, dias, horas,
minutos y segundos). Finalizando el programa nos dará los datos que necesitábamos.

5. PRG-11
Escriba un programa que ayude al cajero de una tienda a encontrar el valor de cambio, dada la cantidad
de una compra en dólares y centavos, y la cantidad de dólares y centavos dada por el cliente. La respuesta
debe estar en dólares, cuartos, diez centavos, cinco centavos y centavos.

/******************************************************************************
*Practica 5: ejercicio5 PRG-11 *
*Autor: Andrés Chiluisa *
*Fecha: 27-11-2023 *
******************************************************************************/

#include <iostream>
#include <cmath>
int main() {
// Solicitar al usuario ingresar el costo de la compra y la cantidad dada por el cliente
double costo_compra;
double cantidad_dada;
std : : cout << "Ingrese el costo de la compra en dólares y centavos: $";
std : : cin >> costo_compra;
std : : cout << "Ingrese la cantidad dada por el cliente en dólares y centavos: $";
std : : cin >> cantidad_dada;
// Calcular el cambio
double cambio = cantidad_dada - costo_compra;
// Convertir el cambio a centavos para facilitar los cálculos
int cambio_centavos = static_cast<int>(cambio * 100);
// Calcular la cantidad de dólares, cuartos, diez centavos, cinco centavos y centavos
int dolares = cambio_centavos / 100;
int cuartos = (cambio_centavos % 100) / 25;
int diez_centavos = ((cambio_centavos % 100) % 25) / 10;
int cinco_centavos = (((cambio_centavos % 100) % 25) % 10) / 5;
int centavos = (((cambio_centavos % 100) % 25) % 10) % 5;
// Imprimir el resultado
std : : cout << "Cambio: $" << cambio << std : : endl;
std : : cout << "Dólares: " << dolares << std : : endl;
std : : cout << "Cuartos: " << cuartos << std : : endl;
std : : cout << "Diez centavos: " << diez_centavos << std : : endl;
std : : cout << "Cinco centavos: " << cinco_centavos << std : : endl;
std : : cout << "Centavos: " << centavos << std : : endl;
return 0;
}
Ingrese el costo de la compra en dólares y centavos: $2300
Ingrese la cantidad dada por el cliente en dólares y centavos: $14
Cambio: $-2286
Dólares: -2286
Cuartos: 0
Diez centavos: 0
Cinco centavos: 0
Centavos: 0

CONCLUSION: Solicitamos al usuario ingresar el costo de la compra y la cantidad dada por el cliente ( el costo de la
compra debe estar en dolares y centavos, incluyendo la cantidad dada por el cliente en dolares y en centavos),
calcular el cambio, convertir el cambio a centavos para facilitar los cálculos, calculamos la cantidad de dólares,
cuartos, diez centavos, cinco centavos y centavos por ultimo imprimimos el resultado.

6. PRG-13
Escriba un programa que, dada una temperatura en Fahrenheit, calcule e imprima la temperatura en
Centígrados usando la fórmula C = (F − 32) * 5/9

/******************************************************************************
*Practica 5: ejercicio6 PRG-13 *
*Autor: Andrés Chiluisa *
*Fecha: 27-11-2023 *
******************************************************************************/

#include <iostream>
int main() {
// Solicitar al usuario ingresar la temperatura en Fahrenheit
double temperatura_fahrenheit;
std : : cout << "Ingrese la temperatura en Fahrenheit: ";
std : : cin >> temperatura_fahrenheit;
// Calcular la temperatura en Celsius
double temperatura_celsius = (temperatura_fahrenheit - 32) * 5.0 / 9.0;
// Imprimir el resultado
Std : : cout << "La temperatura en Celsius es: " << temperatura_celsius << " grados Celsius" << std : : endl;
return 0;
}

Ingrese la temperatura en Fahrenheit: 45

La temperatura en Celsius es: 7.22222 grados Celsius
CONCLUSION: Solicitamos al usuario ingresar la temperatura en Fahrenheit (“Ingrese la temperatura en Fahrenheit),
calculamos la temperatura en Celsius por último imprimimos el resultado (“La temperatura en Celsius)

7. PRG-14
Suponga que un grupo de tres familias cena en un restaurante. La primera familia tiene dos hijos. Cada una
de las otras familias tiene un hijo. Escriba un programa que divida la factura entre cada familia si a un niño
se le cobra 3/4 de la parte de un adulto. El cargo total (antes de impuestos) se proporciona como entrada. El
impuesto es del 9,5 por ciento, y se debe agregar el 8 por ciento por el servicio.

/******************************************************************************
*Practica 5: ejercicio7 PRG-14 *
*Autor: Andrés Chiluisa *
*Fecha: 27-11-2023 *
******************************************************************************/

#include <iostream>
#include <iomanip>
int main() {
// Solicitar al usuario ingresar el cargo total antes de impuestos
double cargo_total;
std : : cout << "Ingrese el cargo total antes de impuestos: $";
std : : cin >> cargo_total;
// Calcular el impuesto y el cargo por servicio
const double impuesto_porcentaje = 9.5;
const double servicio_porcentaje = 8.0;
double impuesto = (cargo_total * impuesto_porcentaje) / 100.0;
double cargo_servicio = (cargo_total * servicio_porcentaje) / 100.0;
// Calcular el cargo total después de impuestos y servicio
double total_con_impuestos = cargo_total + impuesto + cargo_servicio;
// Calcular la parte que paga un niño (3/4 de la parte de un adulto)
double parte_nino = (3.0 / 4.0) * (total_con_impuestos / 4.0);
// Calcular la parte que paga un adulto
double parte_adulto = total_con_impuestos / 4.0;
// Imprimir el resultado
std : : cout << std::fixed << std::setprecision(2);
std : : cout << "Cargo total antes de impuestos: $" << cargo_total << std : : endl;
std : : cout << "Impuesto (" << impuesto_porcentaje << "%) : $" << impuesto << std : : endl;
std : : cout << "Cargo por servicio (" << servicio_porcentaje << "%) : $" << cargo_servicio << std : : endl;
std : : cout << "Total con impuestos y servicio: $" << total_con_impuestos << std : : endl;
std : : cout << "Cada familia debe pagar:" << std::endl;
std : : cout << "Familia 1 (2 hijos): $" << parte_adulto + 2 * parte_nino << std : : endl;
std : : cout << "Familia 2 (1 hijo): $" << parte_adulto + parte_nino << std : : endl;
std : : cout << "Familia 3 (1 hijo): $" << parte_adulto + parte_nino << std : : endl;
return 0;
}
Ingrese el cargo total antes de impuestos: $3675
Cargo total antes de impuestos: $3675.00
Impuesto (9.50%): $349.12
Cargo por servicio (8.00%): $294.00
Total, con impuestos y servicio: $4318.12
Cada familia debe pagar:
Familia 1 (2 hijos): $2698.83
Familia 2 (1 hijo): $1889.18
Familia 3 (1 hijo): $1889.18

CONCLUSION: Solicitamos al usuario ingresar el cargo total antes de impuestos, calculamos el impuesto y el cargo
por servicio seguido calculamos el cargo total después de impuestos y servicios. Calcular la parte que paga un niño
(3/4 de la parte de un adulto), calcular la parte que paga un adulto y para finalizar imprimimos el resultado.

8. PRG-15
Un empleado por hora recibe un pago regular por hora durante 40 horas a la semana. Se le pagará un 60 por
ciento más por cada hora extra que trabaje más de sus 40 horas. Escriba un programa que le pida a un
empleado que ingrese el número de horas extras trabajadas la semana pasada, la tarifa semanal y luego
calcule e imprima el pago total

/******************************************************************************
*Practica 5: ejercicio8 PRG-15 *
*Autor: Andrés Chiluisa *
*Fecha: 27-11-2023 *
******************************************************************************/

#include <iostream>
int main() {
// Solicitar al usuario ingresar el número de horas extras trabajadas y la tarifa semanal
int horas_extras;
double tarifa_semanal;
std : : cout << "Ingrese el número de horas extras trabajadas la semana pasada: ";
std : : cin >> horas_extras;
std : : cout << "Ingrese la tarifa semanal del empleado por hora: $";
std : : cin >> tarifa_semanal;
// Definir el límite de horas regulares (40 horas)
const int horas_regulares = 40;
// Calcular el pago total
double pago_regulares = horas_regulares * tarifa_semanal;
double pago_horas_extras = horas_extras * (1.6 * tarifa_semanal); // Se paga un 60% más por hora extra
double pago_total = pago_regulares + pago_horas_extras;
// Imprimir el resultado
std : : cout << "Pago por horas regulares (40 horas): $" << pago_regulares << std : : endl;
std : : cout << "Pago por horas extras: $" << pago_horas_extras << std : : endl;
std : : cout << "Pago total: $" << pago_total << std : : endl;
return 0;
}
Ingrese el número de horas extras trabajadas la semana pasada: 35
Ingrese la tarifa semanal del empleado por hora: $345
Pago por horas regulares (40 horas): $13800
Pago por horas extras: $19320
Pago total: $33120

CONCLUSION: Solicitamos al usuario ingresar el número de horas extras trabajadas y la tarifa semanal, definimos el
límite de horas regulares (40 horas), calculamos el pago total (se paga un 60% más por hora extra) por último
imprimimos el resultado.

9. PRG-16
Escriba un programa para crear una factura de cliente para una empresa. La empresa vende solo tres
productos: televisores, reproductores de DVD y controles remotos. Los precios unitarios son $1400,00,
$220,00 y $35,20, respectivamente. El programa debe leer del teclado la cantidad de cada equipo
comprado. Luego calcula el costo de cada artículo, el subtotal y el costo total después de un impuesto a las
ventas del 8,25 por ciento. Utilizar formato de datos a la salida para que la respuesta se muestre como el
siguiente ejemplo
/******************************************************************************
*Practica 5: ejercicio9 PRG-16 *
*Autor: Andrés Chiluisa *
*Fecha: 27-11-2023 *
******************************************************************************/

#include <iostream>
#include <iomanip>
int main() {
// Definir los precios unitarios de los productos
const double precio_tv = 1400.00;
const double precio_dvd = 220.00;
const double precio_control_remoto = 35.20;
// Solicitar al usuario ingresar la cantidad de cada producto comprado
int cantidad_tv, cantidad_dvd, cantidad_control_remoto;
std : : cout << "Ingrese la cantidad de televisores comprados: ";
std : : cin >> cantidad_tv;
std : : cout << "Ingrese la cantidad de reproductores de DVD comprados: ";
std : : cin >> cantidad_dvd;
std : : cout << "Ingrese la cantidad de controles remotos comprados: ";
std : : cin >> cantidad_control_remoto;
// Calcular el costo de cada artículo
double costo_tv = cantidad_tv * precio_tv;
double costo_dvd = cantidad_dvd * precio_dvd;
double costo_control_remoto = cantidad_control_remoto * precio_control_remoto;
// Calcular el subtotal
double subtotal = costo_tv + costo_dvd + costo_control_remoto;
// Definir el porcentaje de impuesto a las ventas
const double impuesto_porcentaje = 8.25;
// Calcular el impuesto
double impuesto = (subtotal * impuesto_porcentaje) / 100.0;
// Calcular el costo total después del impuesto
double total = subtotal + impuesto;
// Imprimir la factura
std : : cout << std : : fixed << std : : setprecision(2);
std : : cout << "Factura del cliente:" << std : : endl;
std : : cout << "Televisores (cantidad " << cantidad_tv << "): $" << costo_tv << std : : endl;
std : : cout << "Reproductores de DVD (cantidad " << cantidad_dvd << "): $" << costo_dvd << std : : endl;
std : : cout << "Controles remotos (cantidad " << cantidad_control_remoto << "): $" << costo_control_remoto << std : : endl;
std : : cout << "Subtotal: $" << subtotal << std : : endl;
std : : cout << "Impuesto a las ventas (" << impuesto_porcentaje << "%): $" << impuesto << std : : endl;
std : : cout << "Total: $" << total << std : : endl;
return 0;
}
 Ingrese la cantidad de televisores comprados: 34
Ingrese la cantidad de reproductores de DVD comprados: 56
Ingrese la cantidad de controles remotos comprados: 67
Factura del cliente:
Televisores (cantidad 34): $47600.00
Reproductores de DVD (cantidad 56): $12320.00
Controles remotos (cantidad 67): $2358.40
Subtotal: $62278.40
Impuesto a las ventas (8.25%): $5137.97
Total: $67416.37

CONCLUSION: Definimos los precios unitarios de los productos, solicitamos al usuario ingresar la cantidad de cada
producto comprado, calculamos el costo de cada artículo, calcular el subtotal, definimos el porcentaje de impuesto a
las ventas, calcular el impuesto y por último imprimimos la factura.

TRABAJO AUTÓNOMO:
Ninguno
RESULTADOS OBTENIDOS:
1. El estudiante experimenta con la sintaxis básica de un lenguaje de programación
CONCLUSIONES:
1. En esta práctica me ayudo a entender como puedo programar una contabilidad o como puedo obtener
valores de impuestos, facturas, sacar porcentaje, unidades, centésimas, ente otros.
2. También me ayuda mucho a entender los diferentes códigos que se necesita para realizar el ejercicio y sobre
todo para obtener lo que me pide el ejercicio sin dejar nada de lado.
REFERENCIAS:
[1] Programiz, “C++ Online Compiler”, programiz.com, https://www.programiz.com/cpp-programming/online-
compiler/ (accedido Sep. 9, 2022)

Ing. Rodrigo Tufiño, MSc.

Firma: ___________________

Resolución CS N° 076-04-2016-04-20