L1-012 Cálculo de Potencias

Este problema consiste en calcular 2n, donde 'n' es un entero positivo no mayor a 10. Se debe leer el valor de 'n' y mostrar el resultado en el formato "2^n = resultado".

Entrada

Un entero positivo n (0 < n ≤ 10).

Salida

El rseultado del cálculo en el formato "2^n = resultado".

Ejemplo

Entrada:

5

Salida:

2^5 = 32

Solución en C++

Se utiliza la función pow de la librería cmath para calcular la potencia. Los literales de cadena se imprimen tal cual, mientras que las variables imprimen su valor.

#include <iostream>
#include <cmath>

int main() {
   int exponente;
   std::cin >> exponente;
   int resultado = static_cast<int>(std::pow(2, exponente));
   std::cout << "2^" << exponente << " = " << resultado << std::endl;
   return 0;
}

L1-013 Suma de Factoriales

El objetivo es calcular la suma S = 1! + 2! + 3! + ... + N!, donde N es un entero positivo no mayor a 10. El factorial de un número 'k' (k!) se calcula como 1 * 2 * ... * k.

Entrada

Un entero positivo N (0 < N ≤ 10).

Salida

El valor de S.

Ejemplo

Entrada:

3

Salida:

9

Solución en C++

Se itera desde 1 hasta N, calculando el factorial de cada número y acumulándolo en una suma total. Se optimiza el cálculo del factorial, ya que el factorial de 'i' se puede obtener multiplicando el factorial de 'i-1' por 'i'.

#include <iostream>

int main() {
   int limite;
   std::cin >> limite;
   
   int suma_factoriales = 0;
   int factorial_actual = 1;
   
   for(int i = 1; i <= limite; ++i) {
       factorial_actual *= i; // Calcula i! usando el factorial anterior
       suma_factoriales += factorial_actual;
   }
   
   std::cout << suma_factoriales << std::endl;
   return 0;
}

L1-014 Problema Sencillo

Este es un ejercicio básico que requiere imprimir una cadena de texto específica sin necesidad de ninguna entrada.

Entrada

Ninguna.

Salida

This is a simple problem.

Solución en C++

Simplemente se imprime la cadena requerida.

#include <iostream>

int main() {
   std::cout << "This is a simple problem." << std::endl;
   return 0;
}

L1-015 Dibujando Cuadrados con Caracteres

Dada una longitud de lado 'N' y un carácter 'C', se debe imprmiir un cuadrado formado por 'C'. El número de filas debe ser la mitad de 'N', redondeado al entero más cercano (redondeo a la mitad superior).

Entrada

Dos valores en una línea: un entero N (3 ≤ N ≤ 21) y un carácter C, separados por un espacio.

Salida

El cuadrado formado por el carácter 'C'.

Ejemplo

Entrada:

10 a

Salida:

aaaaaaaaaa
 aaaaaaaaaa
 aaaaaaaaaa
 aaaaaaaaaa
 aaaaaaaaaa

Solución en C++

Se calcula el número de filas dividiendo (N + 1) entre 2 para lograr el redondeo deseado. Luego, se utilizan bucles anidados: el exterior controla las filas y el interior imprime el carácter 'C' repetidamente para formar cada fila.

#include <iostream>

int main() {
   int lado;
   char caracter;
   std::cin >> lado >> caracter;
   
   // Calcula el número de filas con redondeo (N+1)/2
   int num_filas = (lado + 1) / 2;
   
   for(int i = 0; i < num_filas; ++i) {
       for(int j = 0; j < lado; ++j) {
           std::cout << caracter;
       }
       std::cout << std::endl;
   }
   
   return 0;
}

L1-016 Verificación de Identificación

Se deben validar números de identificación de 18 dígitos. La validación consta de dos partes: las primeras 17 posiciones deben ser dígitos, y el último dígito (dígito de control) debe coincidir con el calculado según una fórmula específica.

Entrada

La primera línea contiene un entero N, que indica la cantidad de números de identificación a verificar. Las siguientes N líneas contienen cada número de identificación.

Salida

Para cada número de identificación inválido, se imprime el número completo. Si todos son válidos, se imprime "All passed".

Fórmula de Validación

Se utilizan pesos específicos para los primeros 17 dígitos (7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2). La suma ponderada se divide entre 11, y el residuo (Z) se mapea a un dígito de control (M) usando la correspondencia: 0->1, 1->0, 2->X, 3->9, ..., 10->2. El último dígito del ID debe coincidir con este M calculado.

Solución en C++

Se definen arreglos para los pesos y los posibles dígitos de control. Se itera sobre cada ID, verificando primero que los 17 caracteres iniciales sean numéricos. Luego, se calcula la suma ponderada, se obtiene el residuo módulo 11 y se compara con el último carácter del ID usando el mapeo de verificación.

#include <iostream>
#include <string>
#include <vector>
#include <cctype>

int main() {
   // Pesos para los primeros 17 dígitos
   std::vector<int> pesos = {7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2};
   // Mapeo del residuo a dígito de control
   std::vector<char> digitos_control = {'1', '0', 'X', '9', '8', '7', '6', '5', '4', '3', '2'};

   int cantidad_ids;
   std::cin >> cantidad_ids;
   
   bool todos_validos = true;

   for (int i = 0; i < cantidad_ids; ++i) {
       std::string id;
       std::cin >> id;
       bool id_valido = true;

       // 1. Verificar que los primeros 17 caracteres sean dígitos
       for (int j = 0; j < 17; ++j) {
           if (!std::isdigit(id[j])) {
               id_valido = false;
               break;
           }
       }

       // 2. Si los 17 primeros son válidos, calcular y verificar el dígito de control
       if (id_valido) {
           int suma_ponderada = 0;
           for (int j = 0; j < 17; ++j) {
               // Convertir el caracter dígito a entero
               suma_ponderada += (id[j] - '0') * pesos[j];
           }
           int residuo = suma_ponderada % 11;
           // Comparar el dígito de control calculado con el proporcionado
           if (id[17] != digitos_control[residuo]) {
               id_valido = false;
           }
       }

       // Si el ID no es válido, imprimirlo y marcar que no todos son válidos
       if (!id_valido) {
           std::cout << id << std::endl;
           todos_validos = false;
       }
   }

   // Si todos los IDs fueron válidos, imprimir el mensaje final
   if (todos_validos) {
       std::cout << "All passed" << std::endl;
   }

   return 0;
}