C/Visual C - Ejercicio de C no resuelto :-(

   
Vista:

Ejercicio de C no resuelto :-(

Publicado por Ezequiel (3 intervenciones) el 17/06/2016 15:38:38
Hola como estan ?alguien podria resolver este ejercicio de C? no lo pude hacer y me gustaria verlo resuelto para poderlo analizarlo:


2) Dada la siguiente estructura para información de comidas en un restaurant:

1
2
3
4
5
6
7
struct plato {
	char nombre[40];
	char es_entrada; //0 ó 1 (flag que indica si es entrada)
	char es_plato_ppal; //0 ó 1 (flag que indica si es plato principal)
	char es_postre; //0 ó 1  ((flag que indica si es postre)
	int calorias; // cantidad de calorias
}

Construya una función que reciba un vector de platos e imprima en pantalla todas las combinaciones posibles. La combinación resulta de mostrar una entrada, con un plato y principal y un postre. Además de mostrarse todas las combinaciones, debe informarse cuántas calorías totales tiene cada menú armado.

El prototipo es: void combinaciones(struct plato[], int);

La salida será de este tipo:

1. Entrada: Ensalada, Plato principal: Milanesa, Postre: Helado - Calorias 1111
2. Entrada: Ensalada, Plato principal: Spaghetti, Postre: Helado - Calorias 1130
3. Entrada: Empanada, Plato principal: Milanesa, Postre: Helado - Calorias 2222
4. Entrada: Empanada, Plato principal: Spaghetti, Postre: Helado - Calorias 333
5. Entrada: Ensalada, Plato principal: Milanesa, Postre: Flan - Calorias 4444
6. Entrada: Ensalada, Plato principal: Spaghetti, Postre: Flan - Calorias 5555
7. Entrada: Empanada, Plato principal: Milanesa, Postre: Flan - Calorias 6666
8. Entrada: Empanada, Plato principal: Spaghetti, Postre: Flan - Calorias 7777
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

Ejercicio de C no resuelto :-(

Publicado por agustin (179 intervenciones) el 17/06/2016 15:47:46
¿Y por qué no lo intentas resolver tu? Si al hacerlo se te plantean dudas concretas estaremos encantados de ayudarte pero no pidas que te hagan la tarea.
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

Ejercicio de C no resuelto :-(

Publicado por Ezequiel (3 intervenciones) el 17/06/2016 15:53:18
No es que quiero que me hagan la tarea.. es un ejercicio para practicar, no tengo que entregarlo ni nada, ya lo pense y no se como hacer que me imprima los platos combinados, necestaria que este resuelto para aprender, quiza hay algo que se pueda hacer que no se o lo pase por alto.
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

Ejercicio de C no resuelto :-(

Publicado por Diego (87 intervenciones) el 17/06/2016 16:59:45
Siendo así mostranos el codigo que generaste para este ejercicio y vemos como es que planteaste el ejercicio.
Ahí se verá si el problema está en la interpretación del problema o en la implementación de la solucion.
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

Ejercicio de C no resuelto :-(

Publicado por Ezequiel (3 intervenciones) el 17/06/2016 17:48:32
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
#include<stdio.h> 
#include<string.h>
#define N 6
 
struct plato {
	char nombre[20];
	char es_entrada; //0 ó 1
	char es_plato_ppal; //0 ó 1
	char es_postre; //0 ó 1
	int calorias;
};
void combinaciones(struct plato[], int);
 
struct plato comida[N];
 
 
int main() {                                                                                      \\en el main pregunto los nombres de los platos y cargo
                                                                                                          \\ los flags de que tipo de platos (para probar la funcion
                                                                                                          \\ que me piden)
          int I;
		  for(I=0;I<N;I++)
		  {
		  printf ("\ningrese nombre %d \t",I);
		   gets(&comida[I].nombre[0]);
 
	}
 
		  comida[0].es_entrada=1;
		  comida[0].es_plato_ppal=0;
	      comida[0].es_postre=0;
	      comida[0].calorias=100;
 
 
          comida[1].es_entrada=0;
		  comida[1].es_plato_ppal=1;
	      comida[1].es_postre=0;
	      comida[1].calorias=1000;
 
 
          comida[2].es_entrada=1;
		  comida[2].es_plato_ppal=0;
	      comida[2].es_postre=0;
	      comida[2].calorias=830;
 
 
          comida[3].es_entrada=0;
		  comida[3].es_plato_ppal=0;
	      comida[3].es_postre=1;
	      comida[3].calorias=810;
 
          comida[4].es_entrada=0;
		  comida[4].es_plato_ppal=0;
	      comida[4].es_postre=1;
	      comida[4].calorias=430;
 
		comida[5].es_entrada=0;
		  comida[5].es_plato_ppal=1;
	      comida[5].es_postre=0;
	      comida[5].calorias=430;
 
 
		combinaciones(comida,N);            //llamo a la funcion
 
	}
 
 
 
void combinaciones(struct plato VEC[],int A){           // y aca no se que hacer para que me muestre los datos segun me piden
 
}
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

Ejercicio de C no resuelto :-(

Publicado por Diego (87 intervenciones) el 17/06/2016 19:15:12
Pero ante de empezar el codigo, ¿Sabes como determinar la posibles combinaciones?. Ya que si no sabes eso, será bastante dificil encontrar un codigo.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Entrada Plato_pincipal Postre
2           1               1
 
Combinaciones: 2*1*1 = 2
entrada_1 plato_1 postre_1
entrada_2 plato_1 postre_1
 
 
Entrada Plato_pincipal Postre
2             2             1
 
Combinaciones: 2*2*1 = 4
 
Entrada_1 plato_1 postre_1
Entrada_1 plato_2 postre_1
Entrada_2 plato_1 postre_1
entrada_2 plato_2 postre_1


Si no me equivoco el tema se llama combinatoria en matemática. En tu caso particulas podrías seguir la regla anterior pasa saber las posibles combinaciones.

Cantidad_entradas_distintas * cantidad_platos_pincipales_distintos * cant_postres_distintos = total de combinaciones distintas.


Cada menú tendría 1 entrada 1 plato principal 1 postre. Si el menú es distinto, las reglas ya son otras.

Con esto creo que ya podrías empezar a darte una idea de como escribir tu codigo.
Puede que me haya equivocado con la regla para saber las posibles combinaciones distintas, hice una breve comprobacion y parece funcionar, pero puede que mi regla no sea correcta.
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

Ejercicio de C no resuelto :-(

Publicado por agustin (179 intervenciones) el 17/06/2016 22:46:36
Sinceramente pienso que antes de meterte con el código deberías intentar plasmarlo en un diagrama de flujo para verlo más claro lo que quieres y luego pasarlo a código seria sencillo.
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

Ejercicio de C no resuelto :-(

Publicado por Tom (481 intervenciones) el 18/06/2016 12:15:54
No es la mejor manera de organizar los datos de entrada, ni te lo he resuelto de la mejor manera posible, pero si entiendes esto probablemente aprendas algo:

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
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
 
struct Item {
	char *nombre;
	enum {ENTRANTE, PPAL, POSTRE} tipo;
	unsigned int	cal;
};
 
/* */
int main(int argc, char *argv[]) {
	struct Item platos[] = {
		{"Empanada", ENTRANTE, 2},
		{"Spaghetti", PPAL, 200},
		{"Ensalada", ENTRANTE, 1},
		{"Helado", POSTRE, 1000},
		{"Flan", POSTRE, 2000},
		{"Milanesa", PPAL, 100},
		{NULL, PPAL, 0}
	};
 
	for(int ie = 0, is = 0; platos[ie].nombre; ie++) {
		if(platos[ie].tipo == ENTRANTE) {
			for(int ip = 0; platos[ip].nombre; ip++) {
				if(platos[ip].tipo == PPAL) {
					for(int ipo = 0; platos[ipo].nombre; ipo++) {
						if(platos[ipo].tipo == POSTRE) {
							printf("% 2d: %s + %s + %s (%d cal)\n",
									++is,
									platos[ie].nombre, platos[ip].nombre, platos[ipo].nombre,
									platos[ie].cal + platos[ip].cal + platos[ipo].cal);
						}
					}
				}
			}
		}
	}
}
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

Ejercicio de C no resuelto :-(

Publicado por agustin (179 intervenciones) el 18/06/2016 16:57:21
A mi se me ocurre algo así con esa estructura:

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
#include <stdio.h> 
 
#define nPlatos 5
#define MAX 20
 
typedef char bool;
enum boolean{false, true};
 
typedef struct{
	char nombre[MAX];
	bool primer_plato;
	bool segundo_plato;
	bool postre;
	int calorias;
}Plato;
 
void get_tipo (Plato *p){
	bool salir=false;
	int tipo;
 
    do {
       printf ("Tipo de plato:\n");
       printf ("1-Primer plato.\n");
       printf ("2-Segundo plato.\n");
       printf ("3-Postre.\n\n");
       printf ("Elige un tipo: ");
       scanf ("%d",&tipo);
       p->primer_plato=false;
       p->segundo_plato=false;
       p->postre=false;
 
       switch (tipo){
       	case 1:
               p->primer_plato=true;
               salir=true;
               break;
            case 2:
               p->segundo_plato=true;
               salir=true;
               break;
            case 3:
               p->postre=true;
               salir=true;
               break;
            default:
               printf ("Opcion no valida. Vuelve a intentarlo.\n");
       }
   }while (salir==0);
}
 
void show_combinaciones (Plato p[], int n){
	int i,j,k;
	for (i=0;i <n;i++){
		if (p[i].primer_plato==true){
			for (j=0;j <n;j++){
				if (p[j].segundo_plato==true){
					for (k=0;k <n;k++){
						if (p[k].postre==true){
							printf ("\nPrimer plato: %s\n",p[i].nombre);
							printf ("Segundo plato: %s\n",p[j].nombre);
							printf ("postre: %s\n",p[k].nombre);
							printf ("Total calorias: %d\n",p[i].calorias + p[j].calorias + p[k].calorias);
						}
					}
				}
			}
		}
	}
}
 
int main()
{
	int i;
	Plato platos[nPlatos];
 
	for (i=0;i < nPlatos;i++){
       printf ("Introduce el nombre del plato: ");
       fgets (platos[i].nombre, MAX-1, stdin);
       get_tipo(&platos[i]);
       printf ("Introduce las calorias: ");
       scanf ("%d\n", &platos[i].calorias);
	}
	show_combinaciones(platos,nPlatos);
	return 0;
}
Lo hice en el móvil sin probarlo así que no se si falle en algo.
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

Ejercicio de C no resuelto :-(

Publicado por Tom (481 intervenciones) el 18/06/2016 17:57:55
Lo importante es la idea, creo yo :)
Lo que ocurre en mi caso es que soy un Chef y no permito excentricidades como servir flan de primero, de segundo, y de postre, por mucho que insista el cliente :D
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

Ejercicio de C no resuelto :-(

Publicado por agustin (179 intervenciones) el 18/06/2016 19:03:51
Jajaja realmente es mejor com lo tienes en tu código pienso yo pero no respeta la estructura que el da. Veo un poco fuera de sitio tener 3 variables para indicarle tipo a no ser que vayas a poner un mismo plato en varios tipos cosa que se podría hacer perfectamente usando tu codigo y operadores binarios pero bueno.
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

Ejercicio de C no resuelto :-(

Publicado por chema (187 intervenciones) el 18/06/2016 20:29:31
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
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <time.h>
 
#define ternera    (1 << 0)
#define cerdo      (1 << 1)
#define carne      (1 << 2)
#define pescado    (1 << 3)
#define atun       (1 << 4)
#define lubina     (1 << 5)
#define merluza    (1 << 6)
 
enum {T_ENTRANTE = 0, T_PPAL, T_POSTRE} type;
char *entrante[]=
{"bocata tortilla","olivas","cacahuetes",
"bocata calamares",0X0};
char *principal[]= {
"sopa de ajo", "sopa de pollo","sopa de sobre",
"sopicaldo de col", "lentejas con leche", 0x0
};
char *postre[]= {"lechuga frita", "leche frita", "ajos fritos",
"naranja frita", "peras", "limones" ,0x0
};
 
struct item {
	 char name[40];
	 int cal;
	 int flag;
	 struct item *next;
};
 
typedef struct item Data;
 
typedef struct List{
	Data *first;
	Data *last;
}List;
 
List **head;
 
void IniCarta(){
	int i;
	List **hd;
	hd = malloc(4* sizeof(List));
	for ( i = 0; i < 4; i++){
		hd[i] = malloc( sizeof(Data));
		hd[i]->first = 0x0;
		hd[i]->last = 0x0;
	}
	hd[4] = 0X0;
	head = hd;
 
}
void InsertData(char *name, int cal, int type, int flag){
	List *hd;
	Data *data;
 
	hd= head[type];
 
	data = malloc(sizeof (Data));
	data->next = NULL;
	strcpy(data->name,name);
	data->cal = cal;
	data->flag = flag;
 
	if (hd->first == NULL){
		hd->first = data;
		hd->last = data;
	}else {
		hd->last->next = data;
		hd->last = data ;
	}
}
 
void FreeHead(){
	int i;
	Data *curr, *tmp;
	List *hd;
 
	hd=*head;
 
	for (i = 0; i < 3; i++){
		curr = 	hd->first;
		while (curr != NULL) {
			tmp = curr;
			curr = curr->next;
			free(tmp);
		}
		hd++;
	}
                    free(head);
}
 
void MakeList(){
	char **ptr;
	int flag = 0;
	ptr = postre;
	while(*ptr ){
		InsertData(*ptr,100,T_POSTRE,flag);
		ptr++;
	}
 
	flag = 0;
	flag |= carne | cerdo;
	ptr = principal;
	while(*ptr ){
 
		InsertData(*ptr,200,T_PPAL, flag);
		ptr++;
	}
 
	ptr = entrante;
	flag = 0;
	flag |= pescado | merluza | lubina;
	while(*ptr ){
 
		InsertData(*ptr,300,T_ENTRANTE, flag );
		ptr++;
	}
}
 
void search(int index, int flag){
	Data *curr;
 
	int x;
	curr = head[index]->first;
	while(curr){
		x = curr->flag;
		 if ( (x & flag)  )
			printf("---->%s\n", curr->name);
		curr = curr->next;
	}
 
	printf("=============\n");
}
 
void PrintList(){
	Data *curr;
	List **end;
 
	end = head;
 
	while(*end){
		curr = (*end)->first;
		while(curr){
			printf("%s\n", curr->name);
			curr = curr->next;
		}
		printf("*******\n");
		end++;
	}
}
 
int main(void){
	int a ;
 
	IniCarta();
	MakeList();
 
	a = 0;
	a |= carne | cerdo;
	search(T_PPAL,a );
 
	a = 0;
	a |= lubina;
	search(T_ENTRANTE,a );
 
	PrintList();
	FreeHead();
	return 0;
}
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

Ejercicio de C no resuelto :-(

Publicado por Chema (187 intervenciones) el 18/06/2016 22:46:39
Una simple matriz, basta y sobra para solucionar la cuestión presentada.
El codigo que presentado es totalmente excesivo, la razón de presentarlo es mostrar una "moraleja" muy interesante.
Me explico:

un escenario .
Un fichero de texto del cual se extraen campos y se solicita que se presenten los campos de una manera determinada resolviendo
una pregunta tipo SQL.

Un ejemplo sería un CGI desde el cual se seleccionen desde despegables composiciones tales que puedan resolver preguntas del tipo

entrantes que contengan carne de ternera y pertenezcan a la cocina italiana y etcc....


Esta pregunta desde un CGI entraría con solo 2 para parámetros, T_ENTRANTE, 12345xxxx,
y se resolvería fácilmente

a |= | carne | ternera | cocina italiana | etc....;
search(T_ENTRANTE,a );

Otro detalle interesante es que la lista enlazada es una matriz, lo cual posibilita crear indices dese la
propia matriz.

El código vale muy poco, lo importante es la técnica.
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

Ejercicio de C no resuelto :-(

Publicado por Chema (187 intervenciones) el 19/06/2016 13:33:18
Estimado Agustin , aprecio que "te molan los retos", eso es bueno ( a veces).
Para que tu intelecto disfrute, te muestro una matriz de 4 dimensiones que espero te colmen de felicidad la tarde del domingo.
Si consideras fácil comprender una matriz de 4 dimensiones, me lo comentas y te presento matrices de 6,7,8,9 o más dimensiones.
No te fascines demasiado con este tipo de matrices , no veo utilidad practica, como juego intelectual son simpáticas.

Personalmente nunca he visto un ejemplo de una matriz de 4 dimensiones ni tampoco había realizado ninguna matriz de este tipo, no ha sido difícil, un poco de lógica ha resultado suficiente.

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>
#include <stdlib.h>
 
int main(void) {
	int i;
	int z;
	int j;
	int x;
	int index = 1;
	char *ptr;
	char *page;
	int ****a;
	page = malloc(8192*3);
	ptr = page;
 
	ptr += 10 *sizeof(int****);
	a = (int****)page;
	for( x = 0; x < 10; x++) {
		(*(a +x))  = (int***)ptr;
			ptr += 10 * sizeof(int***);
		for( i = 0; i < 5; i++) {
			*(*(a +x)+i)  = (int**)ptr;
			ptr += 10 * sizeof(int**);
			for( z = 0; z < 5; z++) {
				*(*(*(a +x)+i)+z) = (int*)ptr;
					ptr += 10 * sizeof(int*);
				for( j = 0; j < 5; j++) {
					*(*(*(*(a +x)+i)+z)+j) = index++;
				}
			}
		}
	}
 
	for( x = 0; x < 10; x++) {
		for( i = 0; i < 5; i++) {
			for( z = 0; z < 5; z++) {
				printf("\n");
				for( j = 0; j < 5; j++) {
					printf("%d ",*(*(*(*(a +x)+i)+z)+j)) ;
				}
 
			}
		}
	}
 
	free(page);
 
	return 0;
}
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

Ejercicio de C no resuelto :-(

Publicado por agustin (179 intervenciones) el 20/06/2016 11:02:44
No gracias jajaja. No se a que viene el comentario ni la intención que lleva pero no queroseno malos royos con nadie así que "don't worry, be happy" ;-P
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