OJ
17 Número Múltiplo de T
Problema: Para un número natural N que termina en 7, mover su último dígito a la posición más alta y desplazar todos los demás dígitos una posición a la derecha. El nuevo número debe ser T veces el número original. Dado T, encontrar el menor número natural N que cumpla esta condición. Si no se encuentra tal N en el rango [1, 1000000], mostrar "No".
Ejemplo:
Entrada: 5 3 8
Salida: 142857 No No
Resumen personal:
Este problema se resuelve mediante enumeración exhaustiva. En el rango [1-1000000], buscamos números n que terminen en 7 (en cada iteración n += 10). Calculamos el nuevo número newdigit = 7 * 10^digitos(remain) + remain, donde "remain" es el número sin su último dígito. Luego verificamos si newdigit es igual a T * n. Si son iguales, hemos encontrado la solución y salimos del bucle.
Código:
#include <stdio.h>
#include <math.h>
int main() {
int T;
while (scanf("%d", &T) != EOF) {
int encontrado = 0;
int numeroActual = 7;
while (numeroActual <= 1000000) {
int resto = numeroActual / 10; // Número sin el último dígito
int longitud = 0;
int temp = resto;
// Calcular la cantidad de dígitos en 'resto'
while (temp > 0) {
longitud++;
temp /= 10;
}
// Construir el nuevo número
int nuevoNumero = 7 * (int)pow(10, longitud) + resto;
// Verificar si cumple la condición
if (nuevoNumero == T * numeroActual) {
encontrado = 1;
printf("%d\n", numeroActual);
break;
}
numeroActual += 10; // Siguiente número terminado en 7
}
if (!encontrado) {
printf("No\n");
}
}
return 0;
}
19 Procesamiento de Secuencia de Números
Problema: Dada una secuencia de números, encontrar el dígito que aparece consecutivamente más veces. Si varios dígitos tienen la misma cuenta máxima consecutiva, encontrar el que aparece primero con esa cuenta.
Entrada: Cada conjunto de datos de prueba tiene 2 líneas. La primera línea contiene un entero n (1 < n < 100), que indica cuántos números hay en la secuencia. La segunda línea contiene n números separados por espacios.
Salida: Para cada conjunto de datos, mostrar dos enteros: el número que aparece más veces consecutivamente y su cuenta.
Ejemplo:
Entrada: 2 1 2 9 2 2 2 1 1 1 1 2 2
Salida: 1 1 1 4
Resumen personal:
Este problema se resuelve mediante enumeración. Comparamos cada número con los siguientes, incrementando un contador cuando son iguales. Si el contador actual es mayor que el máximo encontrado, actualizamos el máximo. Sin embargo, este método cuenta secuencias repetidamente, como en el caso de "1 1 1 2 2 2", donde tanto el 1 como el 2 se contarían tres veces.
Código:
#include <stdio.h>
int main() {
int longitud;
while (scanf("%d", &longitud) != EOF) {
int secuencia[100];
int i;
// Leer la secuencia de números
for (i = 0; i < longitud; i++) {
scanf("%d", &secuencia[i]);
}
int digitoActual = secuencia[0];
int maximoDigito = digitoActual;
int cuentaActual = 1;
int maximoCuenta = 1;
// Recorrer la secuencia para encontrar la mayor cuenta consecutiva
for (i = 1; i < longitud; i++) {
if (secuencia[i] == digitoActual) {
cuentaActual++;
} else {
// Verificar si la cuenta actual es mayor que la máxima encontrada
if (cuentaActual > maximoCuenta) {
maximoCuenta = cuentaActual;
maximoDigito = digitoActual;
}
// Reiniciar para el nuevo dígito
digitoActual = secuencia[i];
cuentaActual = 1;
}
}
// Verificar la última secuencia de dígitos
if (cuentaActual > maximoCuenta) {
maximoCuenta = cuentaActual;
maximoDigito = digitoActual;
}
printf("%d %d\n", maximoDigito, maximoCuenta);
}
return 0;
}
20 Solución de Ecuación
Problema: Dados dos enteros positivos a y b, encontrar todos los enteros positivos x y y tales que a² + x² = b² + y², donde a, b, x, y son todos ≤ 100. Ordenar las soluciones por x en orden ascendente.
Entrada: Cada conjunto de datos consta de un entero positivo a ≤ 100 seguido de un entero positivo b ≤ 100, separados por un espacio. La entrada termina cuando a y b son ambos 0.
Salida: Para cada conjunto de datos, mostrar pares de enteros x e y (ambos ≤ 100) separados por un espacio. Si hay múltiples soluciones, ordenarlas por x en orden ascendente. Entre conjuntos de resultados, incluir una línea en blanco, excepto después del último conjunto.
Ejemplo:
Entrada: 2 5 3 4 0 0
Salida: 5 2 11 10
4 3
Resumen personal:
Usamos bucles anidados para enumerar todas las combinaciones posibles de x e y. Si cumplen la ecuación, las mostramos. El manejo de las líneas en blanco se controla con una variable de bandera: el primer conjunto no tiene línea en blanco antes, los siguientes sí.
Código:
#include <stdio.h>
int main() {
int a, b;
int primeraLinea = 1; // Controlar la impresión de líneas en blanco
while (scanf("%d %d", &a, &b) == 2) {
if (a == 0 && b == 0) {
break;
}
// Imprimir línea en blanco si no es la primera solución
if (!primeraLinea) {
printf("\n");
} else {
primeraLinea = 0;
}
// Encontrar todas las soluciones
for (int x = 1; x <= 100; x++) {
for (int y = 1; y <= 100; y++) {
if (a * a + x * x == b * b + y * y) {
printf("%d %d\n", x, y);
}
}
}
}
return 0;
}
21 Fórmula de Acumulación
Problema: Dado un entero positivo n, construir una fórmula de acumulación desde 1 hasta n y de vuelta a 1.
Entrada: La entrada contiene múltiples conjuntos de datos, cada uno en una línea con un entero positivo n (1 ≤ n ≤ 10).
Salida: Para cada n, mostrar una fórmula de acumulación desde 1 hasta n y de vuelta a 1, sin espacios.
Ejemplo:
Entrada: 1 5 10
Salida: 1 1+2+3+4+5+4+3+2+1 1+2+3+4+5+6+7+8+9+10+9+8+7+6+5+4+3+2+1
Resumen personal:
La parte izquierda (menor que n) se muestra como "número+", mientras que la parte derecha (de n-1 a 1) se muestra como "+número". Es importante agregar un salto de línea al final del ciclo while.
Código:
#include <stdio.h>
void imprimirAcumulacion(int n) {
// Parte ascendente (1 a n)
for (int i = 1; i <= n; i++) {
printf("%d", i);
if (i < n) {
printf("+");
}
}
// Parte descendente (n-1 a 1)
for (int i = n - 1; i >= 1; i--) {
printf("+%d", i);
}
printf("\n");
}
int main() {
int n;
while (scanf("%d", &n) != EOF) {
imprimirAcumulacion(n);
}
return 0;
}
25 Botellas de Refresco
Problema: Una tienda permite cambiar 3 botellas vacías por 1 refresco lleno. Dadas n botellas vacías, ¿cuántos refrescos se pueden beber como máximo? El truco es que cuando quedan 2 botellas, se puede pedir prestada una a la tienda, beberla, y luego devolverla con las 3 botellas.
Entrada: 1 2 3 4 5 6 0
Salida: 0 1 1 2 2 3
Resumen personal:
Mientras el número de botellas vacías sea al menos 3, podemos cambiarlas por refrescos. La división entera entre 3 nos da el número actual de refrescos (temp). El nuevo número de botellas vacías será n % 3 + temp. Acumulamos el total de refrescos (total). Cuando n < 3, salimos del bucle. Si n = 2, podemos pedir prestada una botella para obtener un refresco más.
Código:
#include <stdio.h>
int calcularRefrescos(int botellas) {
int total = 0;
while (botellas >= 3) {
int nuevosRefrescos = botellas / 3;
total += nuevosRefrescos;
botellas = botellas % 3 + nuevosRefrescos;
}
// Si quedan 2 botellas, podemos pedir prestada una más
if (botellas == 2) {
total++;
}
return total;
}
int main() {
int n;
while (scanf("%d", &n) == 1 && n != 0) {
printf("%d\n", calcularRefrescos(n));
}
return 0;
}
26 Último Dígito No Cero del Factorial
Problema: N factorial (N!) representa el producto de todos los enteros positivos menores o iguales a N. Los factoriales crecen rápidamente, como 13! que requiere un tipo de entero de 32 bits, y 70! que incluso no cabe en un número de punto flotante. Tu tarea es encontrar el último dígito no cero del factorial. Por ejemplo, 5! = 120, así que el último dígito no cero es 2, y 7! = 5040, así que el último dígito no cero es 4.
Entrada: 7
Salida: 4
Resumen personal: Los ceros al final del factorial son producidos por pares de 2*5. Usamos la variable cuenta2 para contar los 2s restantes después de emparejar con los 5s.
Código:
#include <stdio.h>
int ultimoDigitoNoCero(int n) {
int resultado = 1;
int cuentaDos = 0; // Contador para los factores 2
for (int i = 2; i <= n; i++) {
int num = i;
// Eliminar factores 2
while (num % 2 == 0) {
cuentaDos++;
num /= 2;
}
// Eliminar factores 5
while (num % 5 == 0) {
cuentaDos--; // Cada 5 consume un 2
num /= 5;
}
// Multiplicar por la parte restante, manteniendo solo el último dígito
resultado = (resultado * num) % 10;
}
// Añadir los factores 2 restantes
for (int i = 0; i < cuentaDos; i++) {
resultado = (resultado * 2) % 10;
}
return resultado;
}
int main() {
int n;
while (scanf("%d", &n) == 1) {
printf("%d\n", ultimoDigitoNoCero(n));
}
return 0;
}
Inteligencia Artificial
La inteligencia artificial es un campo de la informática centrado en la construcción de máquinas automatizadas que pueden realizar tareas complejas sin intervención humana. Este objetivo requiere que las máquinas puedan percibir y razonar. Estas capacidades pertenecen a una categoría de actividades que, aunque naturales para el pensamiento humano, han demostrado ser difíciles para las máquinas. Como resultado, el trabajo en este campo ha demostrado ser desafiante.
El campo de la inteligencia artificial es vasto e se integra con otras disciplinas como la psicología, la neurología, las matemáticas, la lingüística y la ingeniería electromecánica. Para centrar nuestras ideas, comenzamos por considerar el concepto de agentes y las categorías de comportamientos inteligentes que estos pueden exhibir. De hecho, gran parte de la investigación en inteligencia artificial puede clasificarse a través del comportamiento de los agentes.
Un agente es un dispositivo que responde a estímulos de su entorno. Es natural pensar en un agente como una sola máquina como un robot, aunque los agentes pueden tomar otras formas, como un avión autónomo, un personaje en un videojuego interactivo, o un proceso que se comunica con otros procesos a través de internet (posiblemente un cliente, servidor o par). La mayoría de los agentes tienen sensores para recibir datos de su entorno y actuadores para afectar su entorno. Ejemplos de sensores incluyen micrófonos, cámaras, sensores de alcance y equipos de muestreo de aire o suelo. Ejemplos de actuadores incluyen neumáticos, piernas, alas, pinzas y sintetizadores de voz.
Gran parte de la investigación en inteligencia artificial puede describirse como la construcción de agentes inteligentes, lo que significa que las acciones de los actuadores del agente deben ser una respuesta racional a los datos obtenidos de los sensores. A su vez, podemos clasificar esta investigación considerando diferentes niveles de estas respuestas.
La respuesta más simple es la acción refleja, que es simplemente una reacción predeterminada a los datos de entrada. Obtener un comportamiento más 'inteligente' requiere niveles más altos de respuesta. Por ejemplo, podemos dar a un agente conocimiento sobre su entorno y requerir que el agente ajuste su comportamiento en consecuencia. La acción de lanzar una pelota es en gran medida una acción refleja, pero decidir cómo y dónde lanzar la pelota requiere conocimiento del entorno actual. Cómo almacenar, actualizar, acceder y finalmente aplicar este conocimiento del mundo real en el proceso de toma de decisiones es un problema desafiante en la inteligencia artificial.
Nota: agente traducido como: agente inteligente