Escribir una funcion recursiva en c++ que a partir de una cadena de caracteres me muestre la cadena inversa y elimine las letras repetidas. Por ejemplo si introduzco : aacbbd, deberia de mostrar :dbca

#include <iostream>
#include <string.h>
#include<string>

using namespace std;
char InversoSimplificado(char c, int tam);
int main()
{
    char c[20];
    int tam;

    cout << "Introduce una cadena: ";
    cin>>c;

    tam=strlen(c);  //TAMAÑO DE LA CADENA

    cout<<endl<<endl;
    cout<< "La cadena invertida y sin repeticiones es: "<< InversoSimplificado(c,tam);
    return 0;
}

char InversoSimplificado (char c ,int tam){


// CONDICION DE PARADA PARA INVERTIR PALABRA:

if (tam==1)




// LLAMADA RECURSIVA PARA INVERTIR PALABRA:

return InversoSimplificado (c, tam-1) + (c, 1);

}

Hola avesudra. Bueno, ya que piden resolverlo con recursividad, se me ocurre crear dos funciones, una para eliminar los caracteres repetidos, y otra para invertir la cadena.

Por ejemplo, sea la cadena "aaaabbbcccddddeee", entonces la idea es que cada vez que llamemos la función se elimina una repetición. La función compara el primer carácter de la cadena con el segundo, si son iguales elimina la repetición de este carácter y se vuelve a llamar a sí misma. Tras esto, compara el segundo con el tercero y así sucesivamente. Entonces tras la primera ejecución devuelve "abbbcccddddeee", tras la segunda devuelve "abcccddddeee", y así sucesivamente. La función se ha codificado de manera que imprima los resultados parciales y así se pueda ver cómo va trabajando.

En cuánto a la parte de invertir la cadena, lo que hacemos es intercambiar los caracteres opuestos con respecto al centro, desde afuera hacia adentro. Por ejemplo, dada la cadena "abcde", intercambiamos 1º y 5º, luego 2º y 4º y así sucesivamente. El proceso se detiene cuando la cantidad de reordenamientos supera la mitad de la longitud de la cadena.

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
 
using namespace std;
 
void elimina_repetido( char *s );
int invertir_cadena( char *s );
 
int main(void) {
 
	char s1[100];
 
	sprintf( s1, "aaaabbbcccddddee");
 
	cout << "Eliminando repetidos" << endl 
		 << "==============================" << endl;
	elimina_repetido ( s1 );
 
	cout << "Invirtiendo cadena" << endl 
		 << "==============================" << endl;
	invertir_cadena( s1 );
 
	return 0;
}
 
/* Devuelve cero cuando se termine de analizar toda la 
 * cadena, y 1 si falta por analizar.
 * La cadena transformada queda almacenada en el mismo
 * argumento s.
 * La función almacena la posición del último carácter leído
 * (usando variables internas estáticas)
 */
void elimina_repetido( char* s )
{
	static int pos = 0;
	int k;		/* indice auxiliar */
	int count;	/* cuantos caracteres repetidos */
	char c1;
 
	c1 = s[pos];
	if ( c1 == '\0' ) return;		/* terminó de analizar la cadena*/
 
	k = pos + 1;
	if ( s[k] == c1 ) {
		while ( s[k] == c1 && s[k] != '\0' ) {
			k++;
		}
		count = k - ( pos + 1 );	/* cantidad de caracteres repetidos, después de c1 */
 
		/* Ahora s[k] es el primer carácter posterior a s[pos] distinto
		 * de c1. Vamos a mover hacia atrás los restantes caracteres, 
		 * un total de <count> posiciones
		 */
		while ( s[k] != '\0' ) {
			s[k - count] = s[k];
			k++;
		}
		s[k - count] = '\0';
	}
 
	/* mostrar la cadena */
	cout << "   " << s << endl;
 
	/* preparar para el próximo llamado de la función */	
	pos++;
	elimina_repetido( s );
}
 
/* Reordena la cadena, intercambiando los caracteres en posiciones
 * opuestas respecto al centro, desde afuera hacia adentro.
 * El proceso termina cuando el número de reordenamientos
 * supera la mitad de la longitud de la cadena.
 */
int invertir_cadena( char *s )
{
	static int count = 0;
	int k, N;
	char c;
 
	N = strlen(s);
	if ( count == N || N == 0 ) return 0;
 
	/* intercambia las posiciones */
	c = s[count];
	s[count] = s[N - count - 1];
	s[N - count - 1] = c;
 
	cout << "   " << s << endl;
 
	count++;
	if  ( count < N / 2 ) invertir_cadena( s );
}

Aquí podemos ver el resultado:

Eliminando repetidos
==============================
   abbbcccddddee
   abcccddddee
   abcddddee
   abcdee
   abcde
Invirtiendo cadena
==============================
   ebcda
   edcba


Un saludo, Yoel.

¿Y no es más fácil hacer lo siguiente?

char funcion(char *s)
{
    if(!(*s))
        return *s;
 
    if(*s != funcion(s + 1))
        printf("%c",*s);
 
    return *s;
}
 

O si lo preferís con subindices...

char funcion(char *s)
{
    if(!(s[0]))
        return s[0];
 
    if(s[0] != funcion(&s[1]))
        printf("%c",s[0]);
 
    return s[0];
}
 

A fin de cuentas lo que le piden es una función recursiva que muestre la cadena invertida y sin repeticiones. Que la muestre. No que la almacene en ningún lado.

La idea de do-while es interesante, yo la adapté de la siguiente manera para crear un código más breve. La idea es empezar por el último carácter (no nulo) de la cadena y comparar con el siguiente. Si son diferentes, imprimir, sino, retroceder un carácter. En la función

void elimina_repetido2( char *start, char *c_ptr )
{
 
    static char c = '\0';
 
    if ( c_ptr == start || *c_ptr == '\0' )
        return;
    else {
        if ( *c_ptr != c ) printf( "%c", *c_ptr );
        c = *c_ptr;
        c_ptr--;
        elimina_repetido2( start, c_ptr );
    }
}
 

start es un apuntador al inicio de la cadena (para saber cuando detenernos al retroceder), c_ptr es un apuntador al carácter actualmente analizado (empezando por el último). La variable interna c funciona como auxiliar para almacenar el valor del carácter siguiente al apuntado por c_ptr.

Programa principal:

#include <cstdio>
#include <cstring>
#include <iostream>
 
int main(void) {
 
    char s1[100];
 
    cout << "Intro cadena: ";
    cin >> s1;
 
    cout << endl << "Salida:";
    elimina_repetido2( s1, s1 + strlen(s1) - 1 );
    cout << endl;
 
    return 0;
}

Salida en pantalla:

Intro cadena: aaabbbccdddeeee

Salida:edcba