Ejercicio con estructuras anidadas

Si eres principiante y tienes alguna consulta entra en este foro.
Responder
Mensaje
Autor
totitaaaa
Mensajes: 4
Registrado: 13/12/2019 8:19 pm

Ejercicio con estructuras anidadas

#1 Mensaje por totitaaaa » 13/12/2019 8:32 pm

Hola, necesitaría ayuda con este ejercicio en c++ (Visual studio). (Dejo abajo la consigna) No logro darme cuenta como saber si el propietario tiene mas de un departamento.. Muchas gracias
Esta función debe calcular cuántos propietarios tienen 2 o más departamentos. Imprima sus apellidos en pantalla y retorne el número de apellidos que imprimió.

Código: Seleccionar todo

int	Repetidos(Departamento	*dtos, int	ndtos, Propietarios	*props, int	nprops);
Un consorcio administra un edificio de 20 pisos y 6 departamento por piso. Para ello registra los datos de los departamentos y los propietarios en 2 arrays separados siguiendo las estructuras siguientes:

Código: Seleccionar todo

struct	departamento
{	int	piso;		//del	0	(planta	baja)	al	20	(último	piso).
	char	dto;	// letra	del	departamento	desde	la	‘A’	hasta	la	‘F’	
	float	m2;	//cantidad	de	metros	cuadrados
	int	codigo;	//código	del	propietario
};
typedef	struct	departamento Departamento;

struct	propietarios
{	int	codigo;	 //código único	del	propietario
	char Apellido[100];	//Apellido del propietario
	char mail[100];	//dirección	de mail	
};
typedef	struct	propietarios	Propietarios;
Ambos arrays se relacionan a través del código del propietario. Puede haber varios departamentos con un mismo propietario. Los arrays no están ordenados.
Última edición por mollok el 13/12/2019 11:32 pm, editado 1 vez en total.
Razón: Los códigos deben ir entre etiquetas 'code', botón </>

Avatar de Usuario
kiko66
Mensajes: 44
Registrado: 11/10/2019 10:51 am

Re: Ejercicio con estructuras anidadas

#2 Mensaje por kiko66 » 14/12/2019 5:43 am

hola totita

que tienes hecho hasta ahora??

donde tienes dudas ??

en principio deberias crear dos bucles anidados uno sobre los propietarios y el
interior sobre los departamentos, de tal manera que en el interior del segundo
bucle compares el codigo de propietario con el codigo de departamento, si
coinciden icrementas una variable y compruebas si es mayor que uno, si es mayor
imprimes el nombre del propietario e incrementas otra variable con los encontrados
que sera el valor a devolver por la funcion

si sabes que codigo se pone cuando el departamento esta vacio, solo con el array
de departamentos podrias hacerlo

es raro que no se tenga en cuenta que puede haber varios propietarios con el mismo
apellido, por ej que sean hermanos

suerte con el programa
para cuando el resaltado de codigo :?:

el pare
Mensajes: 10
Registrado: 04/12/2019 5:40 am

Re: Ejercicio con estructuras anidadas

#3 Mensaje por el pare » 14/12/2019 6:34 am

Hola compañeros:

Estoy empezando a estudiar esto de las estructuras y me he decidido a intentar resolver la duda.

Aqui os dejo el codigo al que he sido capaz de llegar, pero al ir a probarlo, el compilador me da este error.

error: expected expression before 'Propietarios'
if(Propietarios[i.codigo] == Departamento[j.codigo])

¿Me podeis ayudar?

Código: Seleccionar todo

#include<stdio.h>

#define MAX 140

// Programa de practica sobre estructuras <struct>

int main()
{

	struct	departamento
	{
		int	piso;		//del 0	(planta	baja) al 20 (último piso).
		char	dto;		//letra del departamento desde la ‘A’ hasta la ‘F’	
		float	m2;		//cantidad de metros cuadrados
		int	codigo;		//código del propietario
	};
	typedef	struct	departamento Departamento[MAX];	

	struct	propietarios
	{
		int	codigo;	 	//código único del propietario
		char Apellido[100];	//Apellido del propietario
		char mail[100];		//dirección de mail	
	};
	typedef struct propietarios Propietarios[MAX];


	int multipropietarios[MAX];
	int acumulador;
	int i, j;
	
	for(i = 0; i < MAX; i++);		// posicion de cada propietario
	{
		for(j = 0; j < MAX; j++ )	// Posicion de cada departamento
		{
			acumulador = 0;
			if(Propietarios[i.codigo] == Departamento[j.codigo])
			{
				acumulador++;
			}
		}
		multipropietarios[j] = acumulador;
	}
		//  ******************** IMPRESION RESULTADOS ***************************

	for(int i = 0; i < MAX; i++)
	{
		if(multipropietarios[i] > 1)
		{
			printf("El propietario %c con codigo %i tiene %i departamentos\n \
			", Propietarios[i.Apellido], Propietarios[i.codigo], multipropietarios[i] );
		}
	}

	return 0;
}

totitaaaa
Mensajes: 4
Registrado: 13/12/2019 8:19 pm

Re: Ejercicio con estructuras anidadas

#4 Mensaje por totitaaaa » 14/12/2019 8:36 am

hola kiko66, muchas gracias por responder.

aun no me queda del todo claro lo siguiente

si coinciden incrementas una variable y compruebas si es mayor que uno, si es mayor
imprimes el nombre del propietario e incrementas otra variable con los encontrados
que sera el valor a devolver por la funcion

que es lo que tendria que ser mayor que uno???

Código: Seleccionar todo

int	Repetidos(Departamento	*dtos, int	ndtos, Propietarios	*props, int	nprops)
{
	int i, k, cont = 0;

	for (i = 0; i < nprops; i++)
	{
		cont = 0;
		for (k = 0; k < ndtos; k++)
		{
			if (props[k].codigo == dtos[k].codigo)
				cont++;
		}
	}
}

Avatar de Usuario
kiko66
Mensajes: 44
Registrado: 11/10/2019 10:51 am

Re: Ejercicio con estructuras anidadas

#5 Mensaje por kiko66 » 14/12/2019 10:12 am

hola totita

decirte que necesitas dos variables una para saber si tienen mas de un dpto
y otra para llevar la cuenta de los que cumplen la condicion

"que es lo que tendria que ser mayor que uno???"
si, hay que comprobar si el numero de dptos del propietario es mayor a uno,
si es asi cumple la codicion e imprimes sus apellidos, incrementas el numero
de propietarios que cumplen la condicion y pasas a comprobar otro propietario

fijate que en la comparacion tratas las estructuras como si las pasases por
valor y las estas pasando por referencia, con lo que en vez de "." debes utilizar
el operador flecha "->"

quizas podria servirte algo como ...

Código: Seleccionar todo

int repetidos(Departamento *dtos, int ndtos, Propietarios *props, int nprops){

	int cnt_mas_de_uno=0;

	for(int np=0; np<nprops ;np++){
		for(int nd=0, mas_de_uno=0; nd<ndtos ;nd++){
			if(dtos[nd]->codigo==props[np]->codigo) mas_de_uno++;
			if(mas_de_uno>1){
				printf("el propietario %s tiene mas de un departamento", props[np]->Apellido);
				cnt_mas_de_uno++;
				break;
			}
		}
	}

	return cnt_mas_de_uno;
}
no lo he tenido tiempo de probarlo asi que si hay algun fallo hazmelo saber

al escribir el codigo en el foro recuerda seleccionarlo y pulsar el boton </>
para que el editor te mantenga la sanguia

saludos

// ----------------------------------------------

hola pare

veo que no paras de picar codigo eh

bueno en el programa que has hecho has de tener en cuenta que para cada ciclo
del bucle interior el contador se pondra a cero asi que nunca llegara a cumplir
la condicion de tener mas de un dpto

hay que mejorar la menera en que accedes a las estructuras. ahi tienes que repasa

tambien decirte que sacas un MAX con 140 elementos cuando el numero de propietarios
lo recibe la funcion, con nprops, no sera mayor de 21 x 6 = 126 pero si puede ser
menor ya que alguno puede tener mas de un dpto

fijate en el printf que intentas que te imprima el apellido que es una cadena de
caracteres con un %c que saca un solo caracter

la idea de hacer una array con la cantidad de dptos de cada propietario es buena

bueno poco a poco todo llega, no se puede aprender todo en dos dias

saludos

totitaaaa
Mensajes: 4
Registrado: 13/12/2019 8:19 pm

Re: Ejercicio con estructuras anidadas

#6 Mensaje por totitaaaa » 14/12/2019 10:32 am

muchas gracias kiko66!!
saludos

Avatar de Usuario
kiko66
Mensajes: 44
Registrado: 11/10/2019 10:51 am

Re: Ejercicio con estructuras anidadas

#7 Mensaje por kiko66 » 16/12/2019 10:02 am

hola totita

como dije que habia que utilizar el operador flecha y no hace falta, he hecho la funcion que se pedia y
un ejemplo de uso por te sirve de ayuda :wink:

Código: Seleccionar todo

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>

#define PMAX	90		// maximo numero de props, asi habra props con mas de un dpto
#define PISOS	21		// numero de pisos del edificio
#define DEP_X_PISO 6 // dptos por piso
#define TOT_DEP (PISOS*DEP_X_PISO) // total de pisos en el edificio
#define LETRAS 26		// numero de letras para los apellidos, maximo 26
// -----------------------------------------------------------------------------estructuras
typedef struct Departamento
{
	int	piso;		//del 0	(planta	baja) al 20 (último piso).
	char	dto;		//letra del departamento desde la ‘A’ hasta la ‘F’	
	float	m2;		//cantidad de metros cuadrados
	int	codigo;	//código del propietario
} Departamento;

typedef struct Propietarios
{
	int  codigo;	 		//código único del propietario
	char apellido[100];	//Apellido del propietario
	char mail[100];		//dirección de mail	
} Propietarios;
// -----------------------------------------------------------------------------repetidos
int repetidos(Propietarios props[], int nprops, Departamento dtos[], int ndtos){

	int cnt_mas_de_uno=0;
	puts("--------- propietarios con mas de un departamento ---------");
	for(int np=0; np<nprops ;np++)
		for(int nd=0, mas_de_uno=0; nd<ndtos ;nd++)
			if(dtos[nd].codigo==props[np].codigo)
				if(++mas_de_uno>1){
					cnt_mas_de_uno++;					
					printf("\n%02d el propietario %2s tiene mas de un departamento",
							  cnt_mas_de_uno, props[np].apellido);
					if(!(cnt_mas_de_uno%10)) puts("");
					break;
				}
	puts("");
	return cnt_mas_de_uno;
}
// -----------------------------------------------------------------------------rellena_props
void rellena_props(Propietarios props[]){

	for(int i=0, l=0, nl=0, codigo=0; i<PMAX ;i++, l++){
		props[i].codigo=i+1;								// codigo

		if(l>=LETRAS) { l=0; nl++; }					//
		props[i].apellido[0]='A'+l;					//	 apellido	
		if(nl) props[i].apellido[1]='A'+nl-1;		//
		props[i].apellido[nl+1]='\0';					//
																													
		strcpy(props[i].mail,props[i].apellido);	// mail
		strcat(props[i].mail, "@protonmail.com");	//
	}
}
// -----------------------------------------------------------------------------relllena_dptos
void rellena_dptos(Departamento dptos[]){

	srand(time(NULL)); // inicializa el generador de aleatorios

	for(int i=0, cnt_p=0, cnt_d=0; i<TOT_DEP ;i++){
		if(i>0 && !(i%DEP_X_PISO))cnt_d=0, cnt_p++;
		dptos[i].piso=cnt_p;			// numero de piso, 0 es la planta baja
		dptos[i].dto ='A'+cnt_d++;	// letra de la puerta dpto
		dptos[i].m2=90.0;				// todos tiene los mismos m2
		if(i<PMAX) dptos[i].codigo=i+1; // los pmax props tiene almenos un dpto
		else dptos[i].codigo = rand() % PMAX+1; // props al azar con mas de un dpto
	}
}
// -----------------------------------------------------------------------------ver_props
void ver_props(Propietarios props[], int nprops){

	puts("\n----------- listado de propietarios de la finca -----------");
	for(int p; p<nprops ;p++){
		printf("\nepropietario %2s con el mail %17s y codigo %3d"
				  ,props[p].apellido, props[p].mail, props[p].codigo );
		if(!(p%10) && p!=0) puts("");			  
	}
	puts("");
}
// -----------------------------------------------------------------------------ver_dptos
void ver_dptos(Departamento dptos[], int ndptos){

	puts("\n-------- listado de los departamanetos de la finca --------");
	for(int i=0; i<ndptos ;i++){
			printf("\nnumero de piso %2d", dptos[i].piso);		
			printf("\tletra del dpto: %c", dptos[i].dto);		
			printf("\tmetros cuadrados %2.2f", dptos[i].m2);
			printf("\t\tcodigo de propietario: %2d", dptos[i].codigo);
			if(dptos[i].piso<=PISOS && dptos[i].piso!=dptos[i+1].piso) puts("");
	}
	puts("\n");
}
// -----------------------------------------------------------------------------main
int main(){
	
	Departamento dptos[TOT_DEP]; // total de departamentos disponibles
	Propietarios props[TOT_DEP]; // por si cada dpto tiene un propietario diferente 

	rellena_props(props);
	rellena_dptos(dptos);
	ver_props(props, PMAX);
	ver_dptos(dptos, TOT_DEP);
	repetidos(props, PMAX, dptos, TOT_DEP);

	return 0;
}
saludos

el pare
Mensajes: 10
Registrado: 04/12/2019 5:40 am

Re: Ejercicio con estructuras anidadas

#8 Mensaje por el pare » 16/12/2019 2:37 pm

Hola Kiko:

¿ Por si te sirve de ayuda?

Eres un crack. Lo has resuelto tu solito.

De nuevo me has enseñado muchas cosas y todas de golpe.

A trabajar con estructuras.
A utilizar la generación de números aleatorios para rellenar los campos de un vector o matriz.
A controlar el flujo.

etc. etc.

8) 8) 8)

Salu2

PD. Lo único que creo que falla es que el código del propietario no coincide con el código del departamento y en la estructura entiendo que dice que han de ser iguales.

Un saludo.

Avatar de Usuario
kiko66
Mensajes: 44
Registrado: 11/10/2019 10:51 am

Re: Ejercicio con estructuras anidadas

#9 Mensaje por kiko66 » 19/12/2019 9:33 am

hola pare

gracias por el cumplido pero no soy programador, solo que son ejercicios
sencillos y asi practico un poco con algo que me gusta :wink:

yo no he visto el fallo del codigo que dices ¿¿??
tal como yo lo entiendo el codigo une al propietario con su dpto asi el dpto
tendra el codigo de su propietario, es la manera de saber a quien pertenece

los codigos los he hecho de la siguiente manera, para hacer las pruebas
y ver que la funcion iba bien

he rellenado los propietarios con numeros correlativos desde uno a lo que marque
PMAX que como todas las definiciones puedes modificarlas y tendras resultados
distintos

al rellenar los dptos como cada propietario tiene que tener almenos un dpto
si no, no serian propietarios, los PMAX primeros dptos corresponden cada uno
a propietarios distintos y apartir de ahi he asignado los siguientes dptos a
propietarios que ya tenian almenos uno, de forma aleatoria, asi habra
propietarios con mas de un dpto

si compilas el programa y lo ejecutas veras los listados que da y podras comprobar
que el codigo de cada dpto corresponde a un codigo de propietario valido,

:idea: prueba con PMAX (total de propietarios) con 126 que es el total de dptos y
veras que cada propietario tiene un solo departamento y no habra duplicados

saludos
para cuando el resaltado de codigo :?:

el pare
Mensajes: 10
Registrado: 04/12/2019 5:40 am

Re: Ejercicio con estructuras anidadas

#10 Mensaje por el pare » 20/12/2019 3:11 am

Hola Kiko:
Estoy de acuerdo contigo en que el programa funciona bien.
Lo que estoy diciendo es que en la estructura modelo que pone totitaaa pone que el codigo de cada apartamento debe corresponderse con un código de un propietario.
O sea que el código del propietario es único, y que el de los apartamentos no tiene porque serlo, debiendo ser el mismo que el de algún propietario.
Pero entiendo que esto solo es una cuestión de interpretación, por lo que creo que tu programa tiene una lógica y está bien formulado.
Salu2.

Responder

¿Quién está conectado?

Usuarios navegando por este Foro: Majestic-12 [Bot] y 18 invitados