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
¿Y qué llevas hecho?
Un saludo.
Cita de: avesudra en 28 Julio 2016, 11:53 AM
¿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);
}
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?
¿char? InversoSimplificado(¿char? c, int tam);
En todo caso sería:
char* InversoSimplificado(char* c, int tam);
Por otra parte:
return InversoSimplificado (c, tam-1) + ¿(c, 1)?;
¿Qué intentas hacer con lo que está entre interrogaciones?
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.
#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", "");
}
¿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.
Supongo que la debo utilizar de esta manera, ¿no?
int main(void) {
char s1[100];
sprintf( s1, "aaaabbbcccddddee");
funcion(s1);
return 0;
}
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
Cita de: do-while en 6 Agosto 2016, 01:57 AM
¿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;
}
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 ? :)
Dejo los comentarios de que hace entre comillas, el codigo es del usuario do-while
#include<stdio.h>
int main(void) {
char *s1 = "aaaabbbcccddddee";
funcion(s1); //Mandamos la candena de s1 a la "funcion"
return 0;
}
char funcion(char *s) //Se recive como parametro un apuntador a una Cadena X
{
if(!(*s)) //Evaluamos si la posicion 0 de la cadena X "Actual" es 0, en caso de que lo sea se termina esta funcion por el return
return *s;
if(*s != funcion(s + 1)) //Enviamos la cadena actual a la funcion, pero... pero.. la enviamos apartir de la posicion 1, esto es la posicion 0 (Inicial) se omite se manda la posicion 1 ejemplo si la cadena "Actual" es "ABCDE\0" se manda la funcion recursiva "BCDE\0"
printf("%c",*s); //Y en el if evaluamos si el caracter en su posicion 0 y el caracter en su posision 1 son caracteres distintos entonces imprimimos el caracter actual
return *s;
}
/*
Entontes la funcion dejara de llamarse a si misma cuando llegua al caracter nulo, apartir de ahi se imprimiran primero los ultimos caracteres llamados, esto es, la ultima funcion valida llamada tiene el ultimo caracter y ese es el primer printf que se ejecuta una vez que aplique el return se ejecutaran los printf de las funciones anteriores
*/
Y solo me queda comentar que el código proporcionado por el usuario do-while es, a mi punto de vista una verdadera pieza maestra!!!
Muestra un gran nivel del uso del lenguaje ;-) ;-) ;-) ;-) ;-)
Saludos!