Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » Visual C++ .NET » ¿Alguien sabe resolver estos ejercicios?

Visual C++ .NET - ¿Alguien sabe resolver estos ejercicios?

Volver
Nuevo Tema
<<>>
 
Vista:
sin imagen de perfil

¿Alguien sabe resolver estos ejercicios?

Publicado por Gonzalo (1 intervención) el 19/11/2013 23:35:06
Hola! Soy nuevo en LWP. Es mi primer nota y si está mal o va en otro hilo, sólo díganme, gracias! :)
Tengo que resolver estos ejercicios, son básicos, por lo que muchos de aquí los sabrán resolver fácilmente, me quisieran ayudar?

Los ejercicios son estos:

1- Un cliente le pide un programa que le permita ingresar los lados de un cuadrilátero y luego mostrar su perímetro superficie y cual si es trapecio paralelogramo o trapezoide.

2-haga un programa que le permita contar los escalones de una escalera y mostrar por pantalla la cantidad ingresando solamente la extensión o largo de escalera.

3-construya un programa que le permita mostrar cual es el numero mayor de entre cinco que cargue por teclado.al final debe mostrarse la carga de todos y el mayor.

4-un cliente le pide un programa que calcule el importe a cobrar en una factura que incluya el monto inicial el iva21% descuentos del 10% y el total a cobrar.

5-Haga un programa que cuente los números hasta el mil y que a medida que lo hace muestre solamente los números con doble cero. Al final debo ver la cantidad de números contadas.

6- Construya un programa que le permita contar las fotocopias realizadas, cuántas se rompieron e indique cuando falta papel. Debe comenzar cargando la cantidad de copias a realizar.

7- Realizar tres programas que permitan el ingreso de 5 valores por teclado, imprimir la suma. Emplear en cada caso una estructura repetitiva diferente.

8- Realizar la carga de números por teclado hasta que se ingreso el cero. Luego mostrar el promedio de los valores ingresados. Desarrollarlo con while, otro con do/while y otro con for.

9- Mostrar la serie 13-26-39... hasta 130 con un for.

10- Generar 1000 números aleatorios con valores entre 1 y 60. Indicar cuáles están entre 1 y 20, cuántos en el rango 21-40 y cuántos en 41-60.

11- Desarrollar un menú de opciones en pantalla y solicitar la carga de una opción. Mostrar por pantalla la opción seleccionada.

12- Ingresar por teclado dos valores enteros e indicar cual es mayor poniendo en pantalla "Primero", "Segundo" o "Iguales"

13- Se ingresan por pantalla tres valores, si todos son menores a 10 indicar por pantalla "Todos son inferiores a 10".

14- Confeccionar un programa que permita mostrar por pantalla el contenido de una variable float, entera y de carácter respectivamente.

15- Mostrar en pantalla la tabla del cinco. Mostrar la cantidad de renglones hechas.

16- Desarrollar un programa que me permita ordenar los números 5, 10 y 15 de menor a mayor independientemente del orden como los ingrese el operador.

17- Escribir un programa que lea 10 notas de alumnos y nos informe cuántos tienen notas mayores o iguales a 7 y cuántos menores.

18- Realizar un programa que lea los lados de un triángulo e informar:
a) qué tipo de triángulo es: equilátero (tres lados iguales), isósceles (dos lados iguales) o escaleno (todos distintos)

b) Cantidad de lados iguales y cantidad de lados distintos.
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Alejandro

Resolución de ejercicios

Publicado por Alejandro (265 intervenciones) el 13/02/2024 20:11:21
Resolución del ejercicio 1: Cuadrilátero

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#include <iostream>
 
using namespace std;
 
int main() {
    // Declaración de variables para los lados del cuadrilátero
    double lado1, lado2, lado3, lado4;
 
    // Solicitar al usuario que ingrese los lados del cuadrilátero
    cout << "Ingrese el lado 1: ";
    cin >> lado1;
 
    cout << "Ingrese el lado 2: ";
    cin >> lado2;
 
    cout << "Ingrese el lado 3: ";
    cin >> lado3;
 
    cout << "Ingrese el lado 4: ";
    cin >> lado4;
 
    // Calcular perímetro del cuadrilátero
    double perimetro = lado1 + lado2 + lado3 + lado4;
 
    // Calcular área del cuadrilátero
    double area = 0.5 * (lado1 + lado2) * (lado3 + lado4);
 
    // Determinar el tipo de cuadrilátero
    string tipoCuadrilatero;
 
    if (lado1 == lado2 && lado2 == lado3 && lado3 == lado4) {
        tipoCuadrilatero = "Cuadrado";
    } else if (lado1 == lado3 && lado2 == lado4) {
        tipoCuadrilatero = "Rectángulo";
    } else if (lado1 == lado2 || lado2 == lado3 || lado3 == lado4 || lado4 == lado1) {
        tipoCuadrilatero = "Paralelogramo";
    } else {
        tipoCuadrilatero = "Trapezoide";
    }
 
    // Mostrar resultados
    cout << "Perímetro: " << perimetro << endl;
    cout << "Área: " << area << endl;
    cout << "Tipo de cuadrilátero: " << tipoCuadrilatero << endl;
 
    return 0;
}

Este programa en Visual C++ .NET permite al usuario ingresar los lados de un cuadrilátero, calcula su perímetro y área, y determina si es un cuadrado, rectángulo, paralelogramo o trapecio.

Resolución del ejercicio 2: Contar escalones de una escalera

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <iostream>
 
using namespace std;
 
int main() {
    // Declaración de variables para la extensión o largo de la escalera
    double longitudEscalera;
 
    // Solicitar al usuario que ingrese la longitud de la escalera
    cout << "Ingrese la longitud de la escalera: ";
    cin >> longitudEscalera;
 
    // Definir la altura de cada escalón (puedes ajustar este valor según tu necesidad)
    double alturaEscalon = 0.2;  // Ejemplo: altura de cada escalón es de 20 cm
 
    // Calcular la cantidad de escalones
    int cantidadEscalones = static_cast<int>(longitudEscalera / alturaEscalon);
 
    // Mostrar la cantidad de escalones por pantalla
    cout << "La escalera tiene " << cantidadEscalones << " escalones." << endl;
 
    return 0;
}

Este programa en Visual C++ .NET permite al usuario ingresar la longitud de una escalera y calcula la cantidad de escalones asumiendo una altura fija para cada uno. Puedes ajustar la altura del escalón según tus necesidades en la variable `alturaEscalon`.

Resolución del ejercicio 3: Número mayor entre cinco

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
#include <iostream>
 
using namespace std;
 
int main() {
    // Declaración de variables para almacenar los cinco números
    double numero1, numero2, numero3, numero4, numero5;
 
    // Solicitar al usuario que ingrese los cinco números
    cout << "Ingrese el primer número: ";
    cin >> numero1;
 
    cout << "Ingrese el segundo número: ";
    cin >> numero2;
 
    cout << "Ingrese el tercer número: ";
    cin >> numero3;
 
    cout << "Ingrese el cuarto número: ";
    cin >> numero4;
 
    cout << "Ingrese el quinto número: ";
    cin >> numero5;
 
    // Encontrar el número mayor entre los cinco
    double numeroMayor = numero1;
 
    if (numero2 > numeroMayor) {
        numeroMayor = numero2;
    }
 
    if (numero3 > numeroMayor) {
        numeroMayor = numero3;
    }
 
    if (numero4 > numeroMayor) {
        numeroMayor = numero4;
    }
 
    if (numero5 > numeroMayor) {
        numeroMayor = numero5;
    }
 
    // Mostrar la carga de todos los números y el número mayor
    cout << "Carga de números:" << endl;
    cout << "Número 1: " << numero1 << endl;
    cout << "Número 2: " << numero2 << endl;
    cout << "Número 3: " << numero3 << endl;
    cout << "Número 4: " << numero4 << endl;
    cout << "Número 5: " << numero5 << endl;
 
    cout << "El número mayor es: " << numeroMayor << endl;
 
    return 0;
}

Este programa en Visual C++ .NET permite al usuario ingresar cinco números y luego muestra la carga de todos los números ingresados y el número mayor entre ellos.

Resolución del ejercicio 4: Cálculo de factura con IVA, descuentos y total a cobrar

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <iostream>
 
using namespace std;
 
int main() {
    // Declaración de variables para monto inicial, IVA, descuento y total a cobrar
    double montoInicial, iva, descuento, totalCobrar;
 
    // Solicitar al usuario que ingrese el monto inicial
    cout << "Ingrese el monto inicial de la factura: $";
    cin >> montoInicial;
 
    // Calcular el IVA (21%)
    iva = 0.21 * montoInicial;
 
    // Calcular el descuento (10%)
    descuento = 0.1 * montoInicial;
 
    // Calcular el total a cobrar
    totalCobrar = montoInicial + iva - descuento;
 
    // Mostrar los resultados
    cout << "\nResumen de la factura:\n";
    cout << "Monto inicial: $" << montoInicial << endl;
    cout << "IVA (21%): +$" << iva << endl;
    cout << "Descuento (10%): -$" << descuento << endl;
    cout << "Total a cobrar: $" << totalCobrar << endl;
 
    return 0;
}

Este programa en Visual C++ .NET solicita al usuario ingresar el monto inicial de la factura, calcula el IVA (21%), el descuento (10%), y finalmente muestra el resumen de la factura con el monto inicial, el IVA, el descuento aplicado y el total a cobrar.

Resolución del ejercicio 5: Conteo de números con doble cero hasta mil

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <iostream>
 
using namespace std;
 
int main() {
    // Declaración de variables para contar y almacenar la cantidad de números con doble cero
    int contadorDobleCero = 0;
 
    // Bucle para contar los números hasta el mil y mostrar los que tienen doble cero
    for (int i = 0; i <= 1000; ++i) {
        if (i % 100 == 0) {
            // Mostrar los números con doble cero
            cout << "Número con doble cero: " << i << endl;
 
            // Incrementar el contador de números con doble cero
            contadorDobleCero++;
        }
    }
 
    // Mostrar la cantidad total de números con doble cero
    cout << "La cantidad de números con doble cero hasta el mil es: " << contadorDobleCero << endl;
 
    return 0;
}

Este programa en Visual C++ .NET cuenta los números hasta mil y muestra solo aquellos que tienen doble cero. Al final, muestra la cantidad total de números con doble cero contados.

Resolución del ejercicio 6: Conteo de fotocopias con incidentes y verificación de papel

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#include <iostream>
 
using namespace std;
 
int main() {
    // Declaración de variables para la cantidad de copias, copias rotas y verificación de papel
    int cantidadCopias, copiasRotas = 0;
    bool faltaPapel = false;
 
    // Solicitar al usuario que ingrese la cantidad de copias a realizar
    cout << "Ingrese la cantidad de copias a realizar: ";
    cin >> cantidadCopias;
 
    // Bucle para contar las copias y manejar incidentes
    for (int i = 1; i <= cantidadCopias; ++i) {
        // Simular la posibilidad de copias rotas (puedes ajustar esta lógica según tus necesidades)
        if (i % 20 == 0) {
            cout << "La copia " << i << " se rompió." << endl;
            copiasRotas++;
        }
 
        // Verificar si queda papel para imprimir
        if (i % 100 == 0) {
            // Simular la falta de papel (puedes ajustar esta lógica según tus necesidades)
            faltaPapel = true;
            cout << "¡Falta papel! No se podrán realizar todas las copias." << endl;
            break;  // Salir del bucle si falta papel
        }
    }
 
    // Mostrar resultados al finalizar
    cout << "\nResumen de la tarea de fotocopias:\n";
    cout << "Cantidad total de copias realizadas: " << cantidadCopias << endl;
    cout << "Cantidad de copias rotas: " << copiasRotas << endl;
 
    if (faltaPapel) {
        cout << "¡Atención! No se pudieron realizar todas las copias por falta de papel." << endl;
    } else {
        cout << "¡Todas las copias se realizaron con éxito!" << endl;
    }
 
    return 0;
}

Este programa en Visual C++ .NET permite al usuario ingresar la cantidad de copias a realizar, simula copias rotas y verifica si hay suficiente papel para realizar todas las copias. Al final, muestra un resumen de la tarea de fotocopias, indicando la cantidad total de copias realizadas, las copias rotas y si hubo falta de papel. Puedes ajustar la lógica de la simulación según tus necesidades.

Resolución del ejercicio 7: Programas para sumar 5 valores con estructuras repetitivas diferentes

Programa 1: Uso de for para la suma de 5 valores

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <iostream>
 
using namespace std;
 
int main() {
    // Declaración de variables para la suma y el valor ingresado
    int suma = 0, valor;
 
    // Bucle for para ingresar 5 valores y calcular la suma
    for (int i = 1; i <= 5; ++i) {
        cout << "Ingrese el valor " << i << ": ";
        cin >> valor;
        suma += valor;
    }
 
    // Mostrar la suma al finalizar
    cout << "La suma de los 5 valores es: " << suma << endl;
 
    return 0;
}

Programa 2: Uso de while para la suma de 5 valores

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <iostream>
 
using namespace std;
 
int main() {
    // Declaración de variables para la suma y el valor ingresado
    int suma = 0, valor, contador = 1;
 
    // Bucle while para ingresar 5 valores y calcular la suma
    while (contador <= 5) {
        cout << "Ingrese el valor " << contador << ": ";
        cin >> valor;
        suma += valor;
        contador++;
    }
 
    // Mostrar la suma al finalizar
    cout << "La suma de los 5 valores es: " << suma << endl;
 
    return 0;
}

Programa 3: Uso de do-while para la suma de 5 valores

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <iostream>
 
using namespace std;
 
int main() {
    // Declaración de variables para la suma y el valor ingresado
    int suma = 0, valor, contador = 1;
 
    // Bucle do-while para ingresar 5 valores y calcular la suma
    do {
        cout << "Ingrese el valor " << contador << ": ";
        cin >> valor;
        suma += valor;
        contador++;
    } while (contador <= 5);
 
    // Mostrar la suma al finalizar
    cout << "La suma de los 5 valores es: " << suma << endl;
 
    return 0;
}

Estos tres programas en Visual C++ .NET permiten al usuario ingresar 5 valores por teclado y luego imprimen la suma utilizando diferentes estructuras repetitivas: for, while y do-while.

Resolución del ejercicio 8: Programas para cargar números y calcular promedio con estructuras repetitivas diferentes

Programa 1: Carga de números con while y cálculo del promedio

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include <iostream>
 
using namespace std;
 
int main() {
    // Declaración de variables para la carga de números y cálculo del promedio
    int numero, suma = 0, contador = 0;
    double promedio;
 
    // Bucle while para la carga de números y cálculo de la suma
    while (true) {
        cout << "Ingrese un número (ingrese 0 para finalizar): ";
        cin >> numero;
 
        if (numero == 0) {
            break;  // Salir del bucle si se ingresa el cero
        }
 
        suma += numero;
        contador++;
    }
 
    // Calcular el promedio y mostrar el resultado
    if (contador > 0) {
        promedio = static_cast<double>(suma) / contador;
        cout << "El promedio de los valores ingresados es: " << promedio << endl;
    } else {
        cout << "No se ingresaron valores para calcular el promedio." << endl;
    }
 
    return 0;
}

Programa 2: Carga de números con do-while y cálculo del promedio

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include <iostream>
 
using namespace std;
 
int main() {
    // Declaración de variables para la carga de números y cálculo del promedio
    int numero, suma = 0, contador = 0;
    double promedio;
 
    // Bucle do-while para la carga de números y cálculo de la suma
    do {
        cout << "Ingrese un número (ingrese 0 para finalizar): ";
        cin >> numero;
 
        if (numero == 0) {
            break;  // Salir del bucle si se ingresa el cero
        }
 
        suma += numero;
        contador++;
    } while (true);
 
    // Calcular el promedio y mostrar el resultado
    if (contador > 0) {
        promedio = static_cast<double>(suma) / contador;
        cout << "El promedio de los valores ingresados es: " << promedio << endl;
    } else {
        cout << "No se ingresaron valores para calcular el promedio." << endl;
    }
 
    return 0;
}

Programa 3: Carga de números con for y cálculo del promedio

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include <iostream>
 
using namespace std;
 
int main() {
    // Declaración de variables para la carga de números y cálculo del promedio
    int numero, suma = 0, contador = 0;
    double promedio;
 
    // Bucle for para la carga de números y cálculo de la suma
    for (;;) {
        cout << "Ingrese un número (ingrese 0 para finalizar): ";
        cin >> numero;
 
        if (numero == 0) {
            break;  // Salir del bucle si se ingresa el cero
        }
 
        suma += numero;
        contador++;
    }
 
    // Calcular el promedio y mostrar el resultado
    if (contador > 0) {
        promedio = static_cast<double>(suma) / contador;
        cout << "El promedio de los valores ingresados es: " << promedio << endl;
    } else {
        cout << "No se ingresaron valores para calcular el promedio." << endl;
    }
 
    return 0;
}

Estos tres programas en Visual C++ .NET permiten la carga de números por teclado hasta que se ingresa el cero y luego muestran el promedio de los valores ingresados utilizando estructuras repetitivas diferentes: while, do-while y for.

Resolución del ejercicio 9: Generación de la serie 13-26-39... hasta 130 con for

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <iostream>
 
using namespace std;
 
int main() {
    // Bucle for para generar la serie 13-26-39... hasta 130
    for (int i = 13; i <= 130; i += 13) {
        cout << i;
 
        // Agregar el guion entre los términos de la serie (excepto para el último término)
        if (i + 13 <= 130) {
            cout << "-";
        }
    }
 
    cout << endl;
 
    return 0;
}

Este programa en Visual C++ .NET utiliza un bucle for para generar la serie 13-26-39... hasta 130, imprimiendo cada término y separándolos con un guion (-).

Resolución del ejercicio 10: Generación de números aleatorios y análisis de rangos

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include <iostream>
#include <cstdlib>  // Incluir la biblioteca para funciones de números aleatorios
#include <ctime>    // Incluir la biblioteca para obtener la semilla actual
 
using namespace std;
 
int main() {
    // Inicializar la semilla para números aleatorios
    srand(static_cast<unsigned int>(time(0)));
 
    // Declaración de variables para contar los números en cada rango
    int contadorRango1_20 = 0, contadorRango21_40 = 0, contadorRango41_60 = 0;
 
    // Generar 1000 números aleatorios entre 1 y 60 e analizar los rangos
    for (int i = 0; i < 1000; ++i) {
        int numeroAleatorio = rand() % 60 + 1;  // Generar número aleatorio entre 1 y 60
 
        // Analizar el rango del número generado
        if (numeroAleatorio >= 1 && numeroAleatorio <= 20) {
            contadorRango1_20++;
        } else if (numeroAleatorio >= 21 && numeroAleatorio <= 40) {
            contadorRango21_40++;
        } else if (numeroAleatorio >= 41 && numeroAleatorio <= 60) {
            contadorRango41_60++;
        }
    }
 
    // Mostrar los resultados
    cout << "Cantidad de números en el rango 1-20: " << contadorRango1_20 << endl;
    cout << "Cantidad de números en el rango 21-40: " << contadorRango21_40 << endl;
    cout << "Cantidad de números en el rango 41-60: " << contadorRango41_60 << endl;
 
    return 0;
}

Este programa en Visual C++ .NET genera 1000 números aleatorios entre 1 y 60, cuenta cuántos están en los rangos 1-20, 21-40 y 41-60, y muestra los resultados al finalizar. La función `rand()` se utiliza para generar números aleatorios, y `srand()` se usa para inicializar la semilla basada en el tiempo actual para obtener una secuencia diferente en cada ejecución.

Resolución del ejercicio 11: Menú de opciones con carga y mostrado de opción seleccionada

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#include <iostream>
 
using namespace std;
 
int main() {
    int opcion;
 
    do {
        // Mostrar el menú de opciones
        cout << "Menú de opciones:" << endl;
        cout << "1. Realizar tarea 1" << endl;
        cout << "2. Realizar tarea 2" << endl;
        cout << "3. Realizar tarea 3" << endl;
        cout << "4. Salir" << endl;
 
        // Solicitar al usuario que ingrese una opción
        cout << "Ingrese la opción deseada (1-4): ";
        cin >> opcion;
 
        // Mostrar la opción seleccionada
        switch (opcion) {
            case 1:
                cout << "Ha seleccionado realizar la tarea 1." << endl;
                break;
            case 2:
                cout << "Ha seleccionado realizar la tarea 2." << endl;
                break;
            case 3:
                cout << "Ha seleccionado realizar la tarea 3." << endl;
                break;
            case 4:
                cout << "Saliendo del programa. ¡Hasta luego!" << endl;
                break;
            default:
                cout << "Opción no válida. Por favor, ingrese una opción válida." << endl;
                break;
        }
 
        // Salir del bucle si la opción seleccionada es salir (4)
    } while (opcion != 4);
 
    return 0;
}

Este programa en Visual C++ .NET presenta un menú de opciones en pantalla y solicita al usuario que ingrese una opción. Luego, muestra la opción seleccionada y realiza la tarea correspondiente según la elección del usuario. El bucle do-while se ejecuta hasta que el usuario elige la opción de salir (4).

Resolución del ejercicio 12: Comparación de dos valores enteros

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include <iostream>
 
using namespace std;
 
int main() {
    // Declaración de variables para los dos valores enteros
    int primero, segundo;
 
    // Solicitar al usuario que ingrese los dos valores enteros
    cout << "Ingrese el primer valor entero: ";
    cin >> primero;
 
    cout << "Ingrese el segundo valor entero: ";
    cin >> segundo;
 
    // Comparar los valores e imprimir el resultado
    if (primero > segundo) {
        cout << "El primer valor es mayor." << endl;
    } else if (segundo > primero) {
        cout << "El segundo valor es mayor." << endl;
    } else {
        cout << "Ambos valores son iguales." << endl;
    }
 
    return 0;
}

Este programa en Visual C++ .NET solicita al usuario ingresar dos valores enteros por teclado y luego compara los valores para determinar cuál es mayor o si son iguales. La salida en pantalla indica si el "primero" valor es mayor, el "segundo" valor es mayor o si ambos son "iguales".

Resolución del ejercicio 13: Verificación de tres valores menores a 10

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <iostream>
 
using namespace std;
 
int main() {
    // Declaración de variables para los tres valores
    int valor1, valor2, valor3;
 
    // Solicitar al usuario que ingrese los tres valores
    cout << "Ingrese el primer valor: ";
    cin >> valor1;
 
    cout << "Ingrese el segundo valor: ";
    cin >> valor2;
 
    cout << "Ingrese el tercer valor: ";
    cin >> valor3;
 
    // Verificar si todos los valores son menores a 10
    if (valor1 < 10 && valor2 < 10 && valor3 < 10) {
        cout << "Todos son inferiores a 10." << endl;
    } else {
        cout << "Al menos uno de los valores no es menor a 10." << endl;
    }
 
    return 0;
}

Este programa en Visual C++ .NET solicita al usuario ingresar tres valores por teclado y luego verifica si todos son menores a 10. Si la condición se cumple, muestra en pantalla "Todos son inferiores a 10", de lo contrario, indica que al menos uno de los valores no es menor a 10.

Resolución del ejercicio 14: Mostrar contenido de variables (float, entera, carácter)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <iostream>
 
using namespace std;
 
int main() {
    // Declaración de variables float, int y char
    float variableFloat = 3.14;
    int variableEntera = 42;
    char variableCaracter = 'A';
 
    // Mostrar el contenido de las variables por pantalla
    cout << "Contenido de la variable float: " << variableFloat << endl;
    cout << "Contenido de la variable entera: " << variableEntera << endl;
    cout << "Contenido de la variable caracter: " << variableCaracter << endl;
 
    return 0;
}

Este programa en Visual C++ .NET declara una variable float (`variableFloat`), una variable entera (`variableEntera`), y una variable de carácter (`variableCaracter`). Luego, muestra el contenido de cada variable por pantalla utilizando la función `cout`.

Resolución del ejercicio 15: Mostrar la tabla del cinco con contador de renglones

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <iostream>
 
using namespace std;
 
int main() {
    // Declaración de variables
    const int numeroBase = 5;
    int contadorRenglones = 0;
 
    // Mostrar la tabla del cinco hasta el 50
    for (int i = 1; i <= 10; ++i) {
        int resultado = numeroBase * i;
        cout << numeroBase << " x " << i << " = " << resultado << endl;
        contadorRenglones++;
    }
 
    // Mostrar la cantidad de renglones
    cout << "Cantidad de renglones: " << contadorRenglones << endl;
 
    return 0;
}

Este programa en Visual C++ .NET utiliza un bucle `for` para mostrar la tabla del cinco hasta el 50. Cada renglón de la tabla se imprime, y se incrementa un contador de renglones. Al final, se muestra la cantidad total de renglones en la tabla.

Resolución del ejercicio 16: Ordenar números de menor a mayor

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
```cpp
#include <iostream>
 
using namespace std;
 
int main() {
    // Declaración de variables
    int numero1, numero2, numero3;
 
    // Solicitar al usuario que ingrese tres números
    cout << "Ingrese el primer número: ";
    cin >> numero1;
 
    cout << "Ingrese el segundo número: ";
    cin >> numero2;
 
    cout << "Ingrese el tercer número: ";
    cin >> numero3;
 
    // Ordenar los números de menor a mayor
    if (numero1 > numero2) {
        swap(numero1, numero2);
    }
 
    if (numero2 > numero3) {
        swap(numero2, numero3);
    }
 
    if (numero1 > numero2) {
        swap(numero1, numero2);
    }
 
    // Mostrar los números ordenados
    cout << "Números ordenados de menor a mayor: " << numero1 << ", " << numero2 << ", " << numero3 << endl;
 
    return 0;
}

Este programa en Visual C++ .NET solicita al usuario ingresar tres números y luego los ordena de menor a mayor utilizando una serie de comparaciones y la función `swap()` para intercambiar los valores según sea necesario. Finalmente, muestra los números ordenados por pantalla.

Resolución del ejercicio 17: Informe de notas de alumnos

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <iostream>
 
using namespace std;
 
int main() {
    // Declaración de variables
    const int cantidadNotas = 10;
    int notas[cantidadNotas];
    int contadorMayoresIguales7 = 0, contadorMenores7 = 0;
 
    // Solicitar al usuario que ingrese las 10 notas
    for (int i = 0; i < cantidadNotas; ++i) {
        cout << "Ingrese la nota del alumno " << (i + 1) << ": ";
        cin >> notas[i];
 
        // Verificar si la nota es mayor o igual a 7
        if (notas[i] >= 7) {
            contadorMayoresIguales7++;
        } else {
            contadorMenores7++;
        }
    }
 
    // Mostrar el informe de notas
    cout << "\nInforme de notas:" << endl;
    cout << "Cantidad de alumnos con notas mayores o iguales a 7: " << contadorMayoresIguales7 << endl;
    cout << "Cantidad de alumnos con notas menores a 7: " << contadorMenores7 << endl;
 
    return 0;
}

Este programa en Visual C++ .NET solicita al usuario ingresar las notas de 10 alumnos, y luego informa cuántos tienen notas mayores o iguales a 7 y cuántos tienen notas menores a 7. El informe se muestra por pantalla al finalizar la entrada de notas.

Resolución del ejercicio 18: Clasificación de triángulo y cantidad de lados

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#include <iostream>
 
using namespace std;
 
int main() {
    // Declaración de variables
    int lado1, lado2, lado3;
 
    // Solicitar al usuario que ingrese los lados del triángulo
    cout << "Ingrese el primer lado del triángulo: ";
    cin >> lado1;
 
    cout << "Ingrese el segundo lado del triángulo: ";
    cin >> lado2;
 
    cout << "Ingrese el tercer lado del triángulo: ";
    cin >> lado3;
 
    // Verificar el tipo de triángulo y la cantidad de lados iguales o distintos
    if (lado1 == lado2 && lado2 == lado3) {
        cout << "El triángulo es equilátero, con todos los lados iguales." << endl;
        cout << "Cantidad de lados iguales: 3" << endl;
        cout << "Cantidad de lados distintos: 0" << endl;
    } else if (lado1 == lado2 || lado1 == lado3 || lado2 == lado3) {
        cout << "El triángulo es isósceles, con dos lados iguales." << endl;
        cout << "Cantidad de lados iguales: 2" << endl;
        cout << "Cantidad de lados distintos: 1" << endl;
    } else {
        cout << "El triángulo es escaleno, con todos los lados distintos." << endl;
        cout << "Cantidad de lados iguales: 0" << endl;
        cout << "Cantidad de lados distintos: 3" << endl;
    }
 
    return 0;
}

Este programa en Visual C++ .NET solicita al usuario ingresar los lados de un triángulo y luego clasifica el tipo de triángulo (equilátero, isósceles o escaleno) y proporciona la cantidad de lados iguales y distintos. La información se muestra por pantalla al finalizar.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar