Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » Dev - C++ » Cadenas C++

Dev - C++ - Cadenas C++

Volver
Nuevo Tema
<<>>
 
Vista:
sin imagen de perfil
Val: 6
Ha disminuido su posición en 6 puestos en Dev - C++ (en relación al último mes)
Gráfica de Dev - C++

Cadenas C++

Publicado por Luis (5 intervenciones) el 18/01/2018 19:11:54
Programa que después de ingresar una cadena ,ordene las palabras de acuerdo a la cantidad de consonantes que cada una posea, es decir la que tiene menos consonantes debería aparecer primero, o viceversa.
Podrían ayudarme por favor, gracias.
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de vangodp
Val: 73
Ha disminuido 1 puesto en Dev - C++ (en relación al último mes)
Gráfica de Dev - C++

Cadenas C++

Publicado por vangodp (23 intervenciones) el 20/01/2018 10:55:22
Primero reciba el string, y lo guarde en una std::string. Luego una solución es aplicar tokens, usando lo que se explica en este post: https://stackoverflow.com/a/289372. El resultado de aplicar los tokens es el de dividir la frase a palabras, le recomiendo que guardes estas palabras en una matriz de std::string, con eso serás capaz de analizar cada palabra por separado, y hacer un vetor de contadores de consonantes.
Formas de contar consonantes puedes encontrar a montones en internet, como por exemplo esta de aqui:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
int main()
{
	char tmp;
	int vowelCounter = 0;
	int consonantCounter = 0;
	string word = "temporaryword";
 
	for (int i = 0; i < word.size(); i++)
	{
		tmp = toupper(word[i]);
		switch(tmp)
		{
			case 'A' :
			case 'E' :
			case 'I' :
			case 'O' :
			case 'U' :
				vowelCounter++;
				break;
			default:
				consonantCounter++;
		}
	}
	cout << "Total vowels = " << vowelCounter << endl;
	cout << "Total consonants = " << consonantCounter << endl;
 
	return 0;
 
}
Sacado de esta pagina: http://www.cplusplus.com/forum/beginner/68391/

Es evidente que no será la forma más efectiva, pero sí, la más fácil.
Espero ter ayudado, suerte.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
sin imagen de perfil
Val: 661
Bronce
Ha mantenido su posición en Dev - C++ (en relación al último mes)
Gráfica de Dev - C++

Cadenas C++

Publicado por agustin (522 intervenciones) el 21/01/2018 00:57:09
Se me ocurre algo así:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#include <stdio.h>
#include <string.h>
#define MAX_SIZE_FRASE 1024
 
typedef struct{
	char *palabra;
	int nVocales;
}PALABRA;
 
int main()
{
	char frase[MAX_SIZE_FRASE];
	char vocales[]="aeiouAEIOU";
	PALABRA *p,aux;
	int i,j,nPalabras=0;
 
	//obtengo la frase

	printf("Introduce una frase: ");
	fgets(frase,MAX_SIZE_FRASE,stdin);
	frase[strlen(frase)-1]='\0';
 
	// divido la frase en sus palabras y obtengo el numero de vocales de cada una

	p = (PALABRA*)malloc(sizeof(PALABRA));
	p->palabra = strtok (frase," ,.-");
	p->nVocales=strspn(p->palabra,vocales);
	while(p !=NULL){
		nPalabras++;
		p = (PALABRA*) realloc(p,sizeof(PALABRA)*nPalabras);
		p[nPalabras-1].palabra = strtok (NULL," ,.-");
		p->nVocales=strspn(p[nPalabras-1].palabra,vocales);
	}
 
	//ordeno por el numero de vocales

	for(i=0;i<nPalabras-1;i++){
		for(j=i+1;j<nPalabras;j++){
	     	if(p[i].nVocales > p[j].nVocales){
	    		memcpy(&aux,sizeof(PALABRA),&p[i]);
	    		memcpy(&p[i],sizeof(PALABRA),&p[j]);
	    		memcpy(&p[j],sizeof(PALABRA),&aux);
	    	}
		}
	}
 
	//muestro las palabras ordenadas		

	for(i=0;i<nPalabras;i++){
		printf("%s\n",p[i].palabra);
	}
	free(p); //libero la memoria de las palabras

	return 0;
}
No lo he probado así que no se si tiene algún fallo.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
-1
Comentar
sin imagen de perfil
Val: 661
Bronce
Ha mantenido su posición en Dev - C++ (en relación al último mes)
Gráfica de Dev - C++

Cadenas C++

Publicado por agustin (522 intervenciones) el 21/01/2018 20:59:17
sin funciones:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
//---------------------------------------------------------------------------

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
 
#define MAX_SIZE_FRASE 1024
//---------------------------------------------------------------------------

 
typedef struct _PALABRA{
    char *palabra;
    int nVocales;
}PALABRA;
//---------------------------------------------------------------------------

 
int main(int argc, char* argv[])
{
    char frase[MAX_SIZE_FRASE];
    char *pAux;
    PALABRA *p,aux;
    unsigned int i,j,nPalabras=0;
 
    //Obtengo la frase

    printf("Introduce una frase: ");
    fgets(frase,MAX_SIZE_FRASE,stdin);
    frase[strlen(frase)-1]='\0';
 
    //Divido la frase en sus palabras y obtengo el numero de vocales en cada una

    pAux=strtok(frase," ,.-");
    p=(PALABRA*)malloc(sizeof(PALABRA));
    p[0].palabra=pAux;
    p[0].nVocales=0;
    for(i=0;i<strlen(pAux);i++){
        switch(toupper(pAux[i])){
            case 'A': case 'E': case 'I': case 'O': case 'U':
                (p[0].nVocales)++;
            break;
        }
    }
    nPalabras++;
    while(pAux != NULL){
        pAux=strtok(NULL," ,.-");
        if(pAux != NULL){
            nPalabras++;
            p=(PALABRA*)realloc(p,sizeof(PALABRA)*nPalabras);
            p[nPalabras-1].palabra=pAux;
            p[nPalabras-1].nVocales=0;
            for(i=0;i<strlen(pAux);i++){
                switch(toupper(pAux[i])){
                    case 'A': case 'E': case 'I': case 'O': case 'U':
                        (p[nPalabras-1].nVocales)++;
                    break;
                }
            }
        }
    }
 
    //Ordeno por el numero de vocales

    for(i=0;i<nPalabras-1;i++){
        for(j=i+1;j<nPalabras;j++){
            if(p[i].nVocales < p[j].nVocales){
                memcpy(&aux,&p[i],sizeof(PALABRA));
                memcpy(&p[i],&p[j],sizeof(PALABRA));
                memcpy(&p[j],&aux,sizeof(PALABRA));
            }
        }
    }
 
    //Muestro loas palabras ordenadas

    for(i=0;i<nPalabras;i++){
        printf("%s\n",p[i].palabra);
    }
    free(p); //Libero la memoria de las palabras

    getchar();
    return 0;
}
//---------------------------------------------------------------------------

con funciones:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
//---------------------------------------------------------------------------

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#define MAX_SIZE_FRASE 1024
//---------------------------------------------------------------------------

 
enum ordenacion{ascendente,descendente};
 
typedef struct _PALABRA{
    char *palabra;
    int nVocales;
}PALABRA;
//---------------------------------------------------------------------------

 
int GetFrase(char *frase)
{
    int len;
    printf("Introduce una frase: ");
    fgets(frase,MAX_SIZE_FRASE,stdin);
    len=strlen(frase);
    frase[len-1]='\0';
    return len;
}
//---------------------------------------------------------------------------

 
int ContarVocales(char *word)
{
    int i,nVocales=0,len;
    len=strlen(word);
    for(i=0;i<len;i++){
        switch(toupper(word[i])){
            case 'A': case 'E': case 'I': case 'O': case 'U':
                nVocales++;
            break;
        }
    }
    return nVocales;
}
//---------------------------------------------------------------------------

 
void Intercambiar(PALABRA *a,PALABRA *b)
{
    PALABRA aux;
 
    memcpy(&aux,a,sizeof(PALABRA));
    memcpy(a,b,sizeof(PALABRA));
    memcpy(b,&aux,sizeof(PALABRA));
}
//---------------------------------------------------------------------------

 
void OrdenarPalabras(PALABRA *p,int nPalabras,int orden)
{
    int i,j;
    PALABRA aux;
    for(i=0;i<nPalabras-1;i++){
        for(j=i+1;j<nPalabras;j++){
            switch(orden){
                case ascendente:
                    if(p[i].nVocales > p[j].nVocales){
                        Intercambiar(&p[i],&p[j]);
                    }
                    break;
                case descendente:
                    if(p[i].nVocales < p[j].nVocales){
                        Intercambiar(&p[i],&p[j]);
                    }
                    break;
            }
        }
    }
}
//---------------------------------------------------------------------------

 
int ObtenerPalabras(PALABRA **palabras, char *frase, char *token)
{
    int nPalabras=0;
    char *pAux;
    PALABRA *p;
 
    pAux=strtok(frase,token);
    p=(PALABRA*)malloc(sizeof(PALABRA));
    p[0].palabra=pAux;
    p[0].nVocales=ContarVocales(pAux);
    nPalabras++;
 
    while(pAux != NULL){
        pAux=strtok(NULL,token);
        if(pAux != NULL){
            nPalabras++;
            p=(PALABRA*)realloc(p,sizeof(PALABRA)*nPalabras);
            p[nPalabras-1].palabra=pAux;
            p[nPalabras-1].nVocales=ContarVocales(pAux);
        }
    }
    *palabras=p;
    return nPalabras;
}
//---------------------------------------------------------------------------

 
void LiberarPalabras(PALABRA *words)
{
    if(words != NULL)
        free(words);
}
//---------------------------------------------------------------------------

void MostrarPalabras(PALABRA *p,int nPalabras)
{
    int i;
    for(i=0;i<nPalabras;i++){
        printf("%s\n",p[i].palabra);
    }
}
//---------------------------------------------------------------------------

 
int main(int argc, char* argv[])
{
    char frase[MAX_SIZE_FRASE];
    PALABRA *p;
    unsigned int nPalabras;
 
    //Obtengo la frase

    GetFrase(frase);
 
    //Divido la frase en sus palabras y obtengo el numero de vocales en cada una

    nPalabras=ObtenerPalabras(&p,frase," ,.-");
 
    //Ordeno por el numero de vocales

    OrdenarPalabras(p,nPalabras,descendente);
 
    //Muestro loas palabras ordenadas

    MostrarPalabras(p,nPalabras);
 
    //Libero la memoria de las palabras

    LiberarPalabras(p);
 
    getchar();
    return 0;
}
//---------------------------------------------------------------------------

En ambos casos me funciona bien aunque creo que es mejorable y entre otras cosas se podria usar estructuras dinamicas para no tener que reallocar toda la memoria cada vez. Aunque en este caso una frase no creo que suponga ningun problema pero nunca se sabe jejeje.
con funciones:
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar