Bueno, todo depende de cómo se ingresa el número.
Si el número se ingresa como un dato de tipo int, entonces tendrá un número acotado de cifras, dado por la implementación (el compilador),
cuyo tamaño puede saberse a ciencia cierta consultando los valores de la librería limits.h.
Entonces no haría falta un array de 1000 cifras.
Para el caso de enteros de 32 bits, daría valores del orden de los 2000 millones, así que un array de 10 cifras bastaría.
El tipo de datos más grande que existe en C, para números enteros positivos, es uintmax_t, que en general coincide con unsigned long long int, que contiene números del orden de \( 2^{64}\approx 1.8\times 10^{19} \), que son unas 19 cifras.
-----------
En cualquier caso, no me parece necesario usar arrays para este problema, a menos que los datos vengan ya en forma de un array de dígitos.
Los pasos a dar serían estos:
* Calcular el número de dígitos decimales del número.
* Obtener la primera y última cifra del número y comparar. Hacer lo mismo con las siguientes hasta llegar al centro del número.
No hace falta seguir más allá de las cifras centrales, porque las cifras correspondientes ya estarían comparadas.f
Para obtener la primera cifra, basta dividir por la potencia de 10 más cercana al número.
Para obtener la última cifra, se toma el resto módulo 10.
Para obtener las siguientes cifras, habría que eliminar estas cifras primera y última, para poder aplicar el mismo método a las cifras restantes.
De hecho, una propiedad invariante de un número capicúa es que, si quitamos la primera y la última cifra, el número que queda es también capicúa.
Pero, más importante, si las primera y última cifra coinciden, y si al quitarlas lo que queda es capicúa, es que el número original era capicúa.
Ejemplo:
17871
La primera y última cifra son iguales a 1, y al quitarlas nos queda el número capicúa 787.
Esto implica que el número original 17871 era ya capicúa.
Con esta propiedad invariante, podemos pensar un algoritmo, así:
/* CAPICUA
Entrada: Un número entero n
Salida: Informar si el número n es capicúa o no.
Método: Iteraciones, sin almacenar las cifras en memoria adicional.
*/
#include <math.h>
#include <stdio.h>
int main(void)
{
int n;
printf("Ingrese un numero entero: ");
scanf("%d", &n);
/* Por defecto, asumiremos que el número es capicua,
a menos que se detecte lo contrario.
La variable capicua será 1 (verdadero) mientras
"todavía no se haya detectado que n no es capicua".
Si al final del proceso sigue siendo 1,
es que n efectivamente era capicúa.
*/
int capicua = 1;
int digitos = log10(n) + 1;
int pow10 = round(pow(10, digitos-1)); /* Potencia de 10 inferior más cercana a n */
int nn = n; /* Copiamos n en nn para modificarlo sin perder valor original */
while (pow10 > 0)
{
/* capicua == 1: El número nn todavía no se ha detectado como no-capicúa */
int primer_cifra = nn / pow10;
int ultima_cifra = nn % 10;
if (primer_cifra != ultima_cifra) /* Se detecta que nn no es capicúa */
{
capicua = 0; /* Valor falso */
break; /* Fin del proceso, no hay nada más que verificar */
}
/* En este punto vale la condición primer_cifra == ultima_cifra */
/* A continuación, quitamos la primer y última cifra, achicando nn */
nn -= primer_cifra * pow10;
nn /= 10; /* La división entera por 10 quita la última cifra */
/* INVARIANTE del proceso:
n es capicua si y sólo si primer_cifra == ultima_cifra y nn es capicúa
*/
/* Como hemos quitado dos cifras, la potencia de 10 más cercana
del siguiente valor de nn será pow10 / 100
*/
pow10 /= 100;
}
printf("El numero %d %s capicua", n, capicua? "es": "no es");
return 0;
}
