Ayuda recursividad

[JUHC]

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

[avesudra]

¿Y qué llevas hecho?

Un saludo.

[JUHC]

¿Y qué llevas hecho?

Un saludo.

#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);

}

[avesudra]

Empecemos por lo más simple, si necesitas invertir una cadena ¿por qué declaras y defines la función pasando y devolviendo un único carácter?

Código (cpp) [Seleccionar] Expandir

¿char? InversoSimplificado(¿char? c, int tam);

En todo caso sería:

Código (cpp) [Seleccionar] Expandir

char* InversoSimplificado(char* c, int tam);

Por otra parte:

Código (cpp) [Seleccionar] Expandir

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

¿Qué intentas hacer con lo que está entre interrogaciones?

[Yoel Alejandro]

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.

Código (cpp) [Seleccionar] Expandir


#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.

[user-marcos]

Código (cpp) [Seleccionar] Expandir


#include<iostream>
using namespace std;

bool equal(string C, char c)
{
  if(C.length() == 0) return true;

  if(c == C[C.length()-1]) return false;

  return  equal(C.erase(C.length()-1), c);
}


string function (string cadena, string saveCadena)
{
  if(cadena.length() == 0) return saveCadena;

  if(equal(saveCadena, cadena[cadena.length()-1]))
    return function(cadena.erase(cadena.length()-1), saveCadena + cadena[cadena.length()-1]);
  return  function(cadena.erase(cadena.length()-1), saveCadena);
}

int main()
{
  cout << function("aaaabbbbccz", "");
}



[do-while]

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

Código (c) [Seleccionar] Expandir


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...

Código (c) [Seleccionar] Expandir


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.

[Yoel Alejandro]

Supongo que la debo utilizar de esta manera, ¿no?

Código (cpp) [Seleccionar] Expandir


int main(void) {

    char s1[100];

    sprintf( s1, "aaaabbbcccddddee");

    funcion(s1);

    return 0;
}


[Yoel Alejandro]

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

Código (cpp) [Seleccionar] Expandir


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:

Código (cpp) [Seleccionar] Expandir


#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

[JUHC]

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

Código (c) [Seleccionar] Expandir


char funcion(char *s)
{
   if(!(*s))
       return *s;

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

   return *s;
}



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.

Me puedes explicar que es lo que hace ?