Ooook! ya le he hechado un vistazo al codigo y es !CORRECTO¡, lo unico que los numeros con una base superior a 10 (11-16) tienen numero representados por letras y esos como palindromos no los detecta.

En el ejemplo que te puse antes...
AB1BA es capicua por las letras pero al introducir el numero en base 10 (700858) y luego al hacer el cambio a base 16 el numero que sale es:

  10  11  1  11  10 : no es capicua
   A   B   1   B   A : si es capicua

Entonces este tipo de numero nos los coge. Pero vamos si esto es una practica, el profesor no creo que te la haya tirado por esto ya que solucionar esto es un poco enrevesado. Yo creo que el verdadero motivo por el que te la ha tirado es por que el enunciado dice:

y tu codigo pone:

Cuando en realidad deberia poner:

Ademas de que el codigo no esta comentado y no usas variables con nombres significativos....

Y bueno este es el codigo que yo he hecho para tu programa. Aun asi tiene el mismo fallo que el tuyo de los numeros representados en una base mayor que 10...


Espero haberte servido de ayuda, un saludo!

¡Hola!

El problema que cita soyloqbuskas, que en realidad no es exactamente como lo describe, es un poco más grave, pero aún así no es tan enrevesado a la hora de solucionarlo. Digo que no es exactamente como lo describe porque, por ejemplo, al hacer el cambio de 27 a hexadecimal (sí, sé que no es capicúa en hexadecimal), mediante el bucle que usas no obtendrías N = 111 (es decir, 1 11 junto, que correspondería a 1B), sino que te daría 21 (0+ 11 + 10*1). Doy unas ideas para solucionarlo (no pongo código porque ahora mismo no tengo tiempo, mañana lo detallo un poco más, si puedo):

Lo que puedes hacer es, al realizar la conversión de un número decimal a otra base, guardar cada dígito en una nueva posición de un vector (previo "include <vector>") o array, en lugar de guardarlo como int. Así, en el ejemplo de 700858 (AB1BA), al hacer el cambio a base 16 tendrías un vector así: [10,11,1,11,10] y aquí es donde comparas la primera posición con la última, la segunda con la penúltima, y así sucesivamente (la forma de hacerlo puede ser distinta en función de si usas vector o array... mi consejo: usa vector, te facilita bastante la vida). Evidentemente, para esta solución tienes que cambiar la rutina que realiza el cambio de base y también la rutina que comprueba si un número es capicúa. Bueno, no usas rutinas aparte del main... es una de las cosas que quería comentarte (lo haré más adelante)... Otra solución, más conservadora con lo que tienes, es hacer lo siguiente: si la base es superior a 10, tu variable P (o la variale coef del programa soyloqbuskas) la multiplicas por 100 en vez de por 10, y la comprobación de si es capicúa o no la haces comparando dígitos dos a dos (el primer par con el último par, el segundo par con el penúltimo par y así), y si la base es menor o igual a 10, lo haces tal y como lo haces ahora (digo más conservadora porque seguirías usando un int).

Me suscribo a lo que dice soyloqbuskas. Usa nombre de variables significativos. Lo de la falta de comentarios no lo encuentro tan grave, porque por lo que veo, el problema es uno de estos típicos de los jueces automáticos, a los que les mandas el código, te lo compila, le aplican juegos de prueba y te dicen si el programa cumple con las espectativas o no (vamos, como el de la Universidad de Valladolid, http://uva.onlinejudge.org/, o el de la Universitat Politècnica de Catalunya, https://www.jutge.org/ - te los pongo por si quieres echarles un vistazo también, van muy bien para prácticar y ganar flexibilidad a la hora de programar). O sea, que en realidad no se los mira nadie, ¿no? Y lo que sí ha hecho soyloqbuskas en su código pero no te ha sugerido explicitamente es... usar funciones. ¡Usa funciones! No pongas un pastuño de código en el main. Si usas funciones, puedes probar partes de tu programa individualmente, ir poco a poco. Ya sabes... divide y vencerás.

Bueno, ¡saludos!
Espero haberte ayudado también.

EI: juntando mensajes.

Bueno, tal como prometí que intentaría, vengo con algo de código para intentar ayudar:

#include <iostream>
#define NUMMAXOFDIGITS 17
using namespace std;
 
bool isPalindrome(int* vector) {
 
	int size = vector[0];
	++vector;
 
	bool isPal = true;
	int n = 0;
	while (n < size/2 and isPal) {
		isPal = vector[n] == vector[size-n-1];
		++n;
	}
 
	return isPal;
 
}
 
void dec2basB(int dec, int B, int* result) {
 
	int n = 1;
	while (dec > 0) {
		result[n] = dec%B;
		dec/=B;
		++n;
	}
 
	result[0] = n - 1;
 
}
 
 
int main() {
 
	/*
		...
			*/
 
}

Como ves, sólo he programado las funciones críticas que se utilizan en el programa. No he hecho el main, lo dejo para ti (es sencillo).

Vamos por partes:

• Utilizo arrays. Eso me lleva a utilizar un "formato" o estructura especial para conocer el tamaño "útil" del array (es decir, el número de posiciones con información realmente útil). Lo que he hecho es emplear la primera posición (la 0) para indicar el número de elementos útiles que le siguen.
• Las posiciones de menos peso de los arrays (excepto la 0, que es la que indica el tamaño) la ocupan los dígitos de menos peso de un número. Así, el número 3432, de la forma que lo he montado, se representaría mediante un array así: [4,2,3,4,3]
• Teniendo en cuenta los dos puntos anteriores, no creo que tengas ningún problema en entender las funciones isPalindrome y dec2Bas2. Lo que sí, ten en cuenta, que el array donde guarda dec2Bas el resultado se lo tienes que pasar como parámetro y debe tener como mínimo NUMMAXOFDIGITS (en este caso es 17 porque el número máximo de dígitos sería el del mayor número que puede haber a la entrada en la base menor, o sea, 50000 y 2 respectivamente). Si no es así, ya dirás algo

Por supuesto, ¡esto es sólo una manera de hacerlo! Otra forma sería usar vector, en cuyo caso no necesitarías almacenar el número de elementos al principio de la secuencia ya que el tipo vector ya realiza un seguimiento de los números presentes en la secuencia. O listas. O usar un int de la forma que sugerí en el post anterior (aunque esto último es un poco más farragoso, es factible también).

Bueno, eso es todo. Si tienes dudas, postea.
¡Saludos!

P.S. Ya he probado la función (las 2). El resultado es correcto. De hecho, sirve también para entradas más grandes de 50000.

¡Hola ghastlyX!

Nunca he participado en concursos (y en general, no he participado en ninguna prueba contrarreloj de retos de programación, salvo en exámenes). Suelo programar para jueces online y de vez en cuando visito Topcoder (para resolver retos en modo práctica... nada de competiciones por ahora). En ningún caso podré dar un criterio más fiable que el tuyo pues carezco de la experiencia que tienes tú en el ámbito de los concursos. De todas maneras, la mayoría de las cosas que dices me parecen perfectamente lógicas y aceptables en un evento de competición, coincido en ellas. Lo que no veo tan claro es el tema de ahorrar funciones. ¿Crees que compensa ahorrarse escribir cabeceras de funciones sólo para ganar velocidad? Este problema de los palíndromos es muy fácil, y puedes hacerlo todo en el main a la primera. Pero hay problemas mucho más diabólicos que éste, y si empiezas a hacerlo todo en el main y te equivocas en algo, puede ser mucho más difícil depurar el error. Además, muchas veces es inevitable cuando tienes que usar algoritmos cuya implementación más natural sea la recursiva (por ejemplo, recorridos por árboles). ¿No crees que sería mejor adoptar una postura intermedia? Por ejemplo, usar todas las funciones que hagan falta y, para ahorrarse el paso de parámetros, emplear variables globales.

En fin, son cosas de un enamorado de las funciones, tampoco quiero abrir un debate sobre ese tema >.<

Por cierto, nice code
¡Saludos!

Entonces coincido plenamente 

Es un bucle con una condición doble.  Por un lado, se lee del buffer de entrada, se hace la conversión de caracteres a entero y se guarda en n el resultado. Si falla este proceso en algún punto (se lee EOF - End Of File- , o lo que se lee no se puede convertir a entero) se sale del bucle. Por otro lado, se comprueba si el valor de n es mayor que 0. Si no lo es, se sale del bucle (una entrada de 0 debía producir el fin del programa, según tu enunciado). En C++ las condiciones siempre se leen de izquierda a derecha, por lo que siempre podrás estar seguro de que se lee el valor antes de comprobar si es mayor que 0.

Una forma alternativa de implementarlo es la siguiente:

int n;
cin >> n;
while (n > 0) {
    // CODIGO DEL BUCLE
    cin >> n;
}

De la manera que te propuso ghastlyX queda más compacto.

Saludos