[C] Potete darmi una mano?

[DavidGT]

Originariamente inviato da Barbalbero

Ma new non è una parola riservata?

Cmq devi mettere l'operatore & nella scanf dell'anno

Non funziona nemmeno con la &....

[DavidGT]

Originariamente inviato da DavidGT

Non funziona nemmeno con la &....

Ritiro tutto... che pirla!!!


Eppure mi sembrava di averla messa e non andava lo stesso!!


Vabbè... GRAZIE MILLE!!

[DavidGT]

Sto rifacendo per bene il programma della prima pagina.
Ho un dubbio, perchè nella chiamata ricorsiva della funzione controllonum non devo mettere "&" a num, mentre invece se la invoco nel main si (eccedenti=controllonum(PB3, &pezzi))??

Non dovrebbe esserci in entrambe?

GRAZIE!

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

typedef struct {
	char tipopezzo[15];
	int x;
	int y;
} pezzo;

typedef struct el {
	pezzo pedina;
	struct el *next;
} elemento;

typedef struct {

	int PedoneBianco, PedoneNero, CavalloBianco, CavalloNero, AlfiereBianco,AlfiereNero,TorreBianca,TorreNera,ReginaBianca,ReginaNera,ReBianco,ReNero;

} MaxPezzi;


elemento * controllonum(elemento *head, MaxPezzi *num);
void inizializza ();


void main () {

	MaxPezzi pezzi;
	elemento *PB,*PB2,*PB3,*eccedenti;

	pezzi.PedoneBianco=2;
	pezzi.PedoneNero=8;
	pezzi.CavalloBianco=2;
	pezzi.CavalloNero=2;
	pezzi.AlfiereBianco=2;
	pezzi.AlfiereNero=2;
	pezzi.TorreBianca=2;
	pezzi.TorreNera=2;
	pezzi.ReginaBianca=1;
	pezzi.ReginaNera=1;
	pezzi.ReBianco=1;
	pezzi.ReNero=1;

	inizializza();

	//PROVA//
	PB=(elemento *)malloc(sizeof(elemento));
	strcpy(PB->pedina.tipopezzo,"PedoneBianco");
	PB->next=NULL;

	PB2=(elemento *)malloc(sizeof(elemento));
	strcpy(PB2->pedina.tipopezzo,"PedoneBianco");
	PB2->next=PB;

	PB3=(elemento *)malloc(sizeof(elemento));
	strcpy(PB3->pedina.tipopezzo,"PedoneBianco");
	PB3->next=PB2;

	eccedenti=controllonum(PB3, &pezzi);

	printf("\n%d", pezzi.PedoneBianco);

}

elemento * controllonum(elemento *head, MaxPezzi *num) {

	elemento *eccedenti;

	eccedenti=(elemento *)malloc(sizeof(elemento));
	eccedenti=NULL;

	if (head == NULL)
		return eccedenti;
	if (head != NULL) {
		if (strcmp(head->pedina.tipopezzo, "PedoneBianco")==0)
			num->PedoneBianco=num->PedoneBianco -1;
	return eccedenti=controllonum(head->next, num);
}

	return eccedenti;
}



void inizializza () {

		int i, j;

		printf("Scacchiera vuota\n\n");

	for (i=0;i<8;i++){
		for (j=0;j<8;j++) {
			printf("X ");
		}
		printf("\n");
	}
}

[trallallero]

la "&" sta ad indicare che passi l'indirizzo della variabile e non il contenuto.
Dentro la funzione controllonum "num" é giá un indirizzo (é un puntatore, dichiarato con *)
mentre nel main passi "pezzi" che é una variabile non puntatore (MaxPezzi)
Ciao

[DavidGT]

Piccola soddisfazione personale, alla fine ce l'ho fatta!!!

Ringrazio tutti per l'aiuto, sono passato da esercizi più semplici e grazie ai suggerimenti ho risolto anche questo.

Ora mi invento qualche esercizio, l'esame è mercoledì!! (peccato che sia senza compilatore)

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

typedef struct {
	char tipopezzo[15];
	int x;
	int y;
}
pezzo;

typedef struct el {
	pezzo pedina;
	struct el *next;
}
elemento;

typedef struct {

	int PedoneBianco, PedoneNero, CavalloBianco, CavalloNero, AlfiereBianco,AlfiereNero,TorreBianca,TorreNera,ReginaBianca,ReginaNera,ReBianco,ReNero;

}
MaxPezzi;

typedef struct {

	int matrix[8][8];
}
matrice;


elemento * controllonum(elemento *head, MaxPezzi *num, elemento *eccedenti);
void inizializza ();
void stampalista (elemento *head);
elemento *instesta (elemento *head, pezzo A);
elemento *controllopos (elemento *head, elemento *conf, elemento *lista);


void main () {

	MaxPezzi pezzi;
	elemento *conf;
	elemento *PB,*PB2,*PB3,*eccedenti, *RN, *RN1, *ReB, *ReN, *ReN1;


	eccedenti=(elemento *)malloc(sizeof(elemento));
	eccedenti=NULL;

	pezzi.PedoneBianco=8;
	pezzi.PedoneNero=8;
	pezzi.CavalloBianco=2;
	pezzi.CavalloNero=2;
	pezzi.AlfiereBianco=2;
	pezzi.AlfiereNero=2;
	pezzi.TorreBianca=2;
	pezzi.TorreNera=2;
	pezzi.ReginaBianca=1;
	pezzi.ReginaNera=1;
	pezzi.ReBianco=1;
	pezzi.ReNero=1;

	inizializza();

	//PROVA//
	PB=(elemento *)malloc(sizeof(elemento));
	strcpy(PB->pedina.tipopezzo,"PedoneBianco");
	PB->next=NULL;

	PB2=(elemento *)malloc(sizeof(elemento));
	strcpy(PB2->pedina.tipopezzo,"PedoneBianco");
	PB2->next=PB;
	PB2->pedina.x=3;
	PB2->pedina.y=2;

	PB3=(elemento *)malloc(sizeof(elemento));
	strcpy(PB3->pedina.tipopezzo,"PedoneBianco");
	PB3->next=PB2;
	PB3->pedina.x=5;
	PB3->pedina.y=2;

	RN=(elemento *)malloc(sizeof(elemento));
	strcpy(RN->pedina.tipopezzo,"ReginaNera");
	RN->next=PB3;
	RN->pedina.x=5;
	RN->pedina.y=2;

	RN1=(elemento *)malloc(sizeof(elemento));
	strcpy(RN1->pedina.tipopezzo,"ReginaNera");
	RN1->next=RN;
	RN1->pedina.x=3;
	RN1->pedina.y=0;

	ReB=(elemento *)malloc(sizeof(elemento));
	strcpy(ReB->pedina.tipopezzo,"ReBianco");
	ReB->next=RN1;
	ReB->pedina.x=4;
	ReB->pedina.y=7;

	ReN=(elemento *)malloc(sizeof(elemento));
	strcpy(ReN->pedina.tipopezzo,"ReNero");
	ReN->next=ReB;
	ReN->pedina.x=4;
	ReN->pedina.y=7;

	ReN1=(elemento *)malloc(sizeof(elemento));
	strcpy(ReN1->pedina.tipopezzo,"ReNero");
	ReN1->next=ReN;
	ReN1->pedina.x=3;
	ReN1->pedina.y=4;

	conf=ReN1->next;

	printf("Elementi in gioco:\n");
	stampalista(ReN1);
	eccedenti=controllonum(ReN1, &pezzi, eccedenti);

	ReN1=controllopos(ReN1,conf, ReN1);
	printf("Lista dopo aver eliminato gli elementi occupanti la stessa posizione:\n");
	stampalista(ReN1);
}

elemento * controllonum(elemento *head, MaxPezzi *num, elemento *eccedenti) {

	if (head == NULL) {

		if (eccedenti != NULL) {
			printf("Elementi eccedenti:\n");
			stampalista(eccedenti);
		}

		return eccedenti;
	}

	if (head != NULL) {

		if (strcmp(head->pedina.tipopezzo, "PedoneBianco")==0) {
			num->PedoneBianco=num->PedoneBianco -1;

			if (num->PedoneBianco < 0) {
				eccedenti=instesta(eccedenti, head->pedina);
				num->PedoneBianco=0;
			}
		}

		if (strcmp(head->pedina.tipopezzo, "PedoneNero")==0) {
			num->PedoneNero=num->PedoneNero -1;

			if (num->PedoneNero < 0) {
				eccedenti=instesta(eccedenti, head->pedina);
				num->PedoneNero=0;
			}
		}

		if (strcmp(head->pedina.tipopezzo, "CavalloBianco")==0) {
			num->CavalloBianco=num->CavalloBianco -1;

			if (num->CavalloBianco < 0) {
				eccedenti=instesta(eccedenti, head->pedina);
				num->CavalloBianco=0;
			}
		}

		if (strcmp(head->pedina.tipopezzo, "CavalloNero")==0) {
			num->CavalloNero=num->CavalloNero -1;

			if (num->CavalloNero < 0) {
				eccedenti=instesta(eccedenti, head->pedina);
				num->CavalloNero=0;
			}
		}

		if (strcmp(head->pedina.tipopezzo, "AlfiereBianco")==0) {
			num->AlfiereBianco=num->AlfiereBianco -1;

			if (num->AlfiereBianco < 0) {
				eccedenti=instesta(eccedenti, head->pedina);
				num->AlfiereBianco=0;
			}
		}

		if (strcmp(head->pedina.tipopezzo, "AlfiereNero")==0) {
			num->AlfiereNero=num->AlfiereNero -1;

			if (num->AlfiereNero < 0) {
				eccedenti=instesta(eccedenti, head->pedina);
				num->AlfiereNero=0;
			}
		}

		if (strcmp(head->pedina.tipopezzo, "ReginaBianca")==0) {
			num->ReginaBianca=num->ReginaBianca -1;

			if (num->ReginaBianca < 0) {
				eccedenti=instesta(eccedenti, head->pedina);
				num->ReginaBianca=0;
			}
		}

		if (strcmp(head->pedina.tipopezzo, "ReginaNera")==0) {
			num->ReginaNera=num->ReginaNera -1;

			if (num->ReginaNera < 0) {
				eccedenti=instesta(eccedenti, head->pedina);
				num->ReginaNera=0;
			}
		}

		if (strcmp(head->pedina.tipopezzo, "ReBianco")==0) {
			num->ReBianco=num->ReBianco -1;

			if (num->ReBianco < 0) {
				eccedenti=instesta(eccedenti, head->pedina);
				num->ReBianco=0;
			}
		}

		if (strcmp(head->pedina.tipopezzo, "ReNero")==0) {
			num->ReNero=num->ReNero -1;

			if (num->ReNero < 0) {
				eccedenti=instesta(eccedenti, head->pedina);
				num->ReNero=0;
			}
		}


		return eccedenti=controllonum(head->next, num, eccedenti);
	}
	return eccedenti;
}



void inizializza () {

	int i, j;

	printf("Scacchiera vuota\n\n");

	for (i=0;i<8;i++){
		for (j=0;j<8;j++) {
			printf("X ");
		}
		printf("\n");
	}
}

void stampalista(elemento *head) {

	while (head != NULL) {
		printf("%s\n", head->pedina.tipopezzo);
		head=head->next;
	}
	printf("\n");
}

elemento *instesta(elemento *head, pezzo A) {

	elemento *new;
	new=(elemento *)malloc(sizeof(elemento));

	new->next=head;
	strcpy(new->pedina.tipopezzo,A.tipopezzo);
	return new;
}

elemento *controllopos(elemento *head, elemento *conf, elemento *lista) {

	elemento *temp, *succ;

	if (head->next == NULL)
		return lista;

	if (conf == NULL) {
		temp=head->next;

		return head=controllopos(head->next, temp->next, lista);
	}
	else {
		if (head->pedina.x == conf->pedina.x && head->pedina.y == conf->pedina.y) {

			temp=head;
			temp->next=conf->next;
			free(conf);
			conf=temp->next;
			return head=controllopos(head, conf, lista);
		}

		return head=controllopos(head, conf->next, lista);
	}
}

[Marco Giunio Silano]

Originariamente inviato da DavidGT

(peccato che sia senza compilatore)

Ma, da quanto visto, c'è Trallallero che sta facendo da compilatore umano
Ben tornato trallallero!

[DavidGT]

Originariamente inviato da Marco Giunio Silano

Ma, da quanto visto, c'è Trallallero che sta facendo da compilatore umano
Ben tornato trallallero!

Senza compilatore all'esame....

[trallallero]

Originariamente inviato da Marco Giunio Silano

Ma, da quanto visto, c'è Trallallero che sta facendo da compilatore umano

Segnalato!!!
compilatore lo dici al tuo gatto

Originariamente inviato da Marco Giunio Silano

Ben tornato trallallero!

grazie ma stavo meglio prima

[Marco Giunio Silano]

Originariamente inviato da trallallero

Segnalato!!!
compilatore lo dici al tuo gatto


grazie ma stavo meglio prima

Bè non conosco il prima, ma t'immagino in ferie, quindi meglio.
ok ok, basta OT. Chiedo venia

[DavidGT]

Oggi volevo provare ad ordinare una lista dinamica, e stavo provando un algoritmo tipo bubble sort che usavo per gli array.


il problema è che poniamo io abbia 3 elementi:
(a priori io non so se il primo elemento è più grande del secondo o no)

|3| --> |2| --> |5|

se scambio di posto il primo con il secondo perdo l'indirizzo della testa dell'array e quando vado a stamparlo non funziona.

Come posso fare?!

Avete un algoritmo da propormi che risolva il problema?

Grazie

[trallallero]

devi scambiare di posto il valore non l'indirizzo

[DavidGT]

Originariamente inviato da trallallero

devi scambiare di posto il valore non l'indirizzo

non ci avevo pensato... si vede che sono un pivello!!

[trallallero]

Originariamente inviato da DavidGT

non ci avevo pensato... si vede che sono un pivello!!

mai vantarsi

[DavidGT]

Ho una lista di array, devo fare la media del singolo array e poi la media di tutto.

Perchè non mi prende i decimali?!?!

Anche se metto 17/4, risultato = 4....

ho messo sia double che float...
perchè???

Grazie!

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

typedef struct el {
	int A[5];
	struct el *next;
} elemento;

float mediavect (int array[]);
float sommalista (elemento *head);
int numel (elemento *head);
float medialista (elemento *head);


void main () {

	elemento *lista,*lista1,*lista2,*lista3;
	float media;


	lista=(elemento *)malloc(sizeof(elemento));
	lista->A[0]=4;
	lista->A[1]=2;
	lista->A[2]=3;
	lista->A[3]=8;
	lista->A[4]='\0';


	lista1=(elemento *)malloc(sizeof(elemento));
	lista->next=lista1;
	lista1->A[0]=3;
	lista1->A[1]=1;
	lista1->A[2]=6;
	lista1->A[3]='\0';


	lista2=(elemento *)malloc(sizeof(elemento));
	lista1->next=lista2;
	lista2->A[0]=1;
	lista2->A[1]=1;
	lista2->A[2]='\0';


	lista3=(elemento *)malloc(sizeof(elemento));
	lista2->next=lista3;
	lista3->A[0]=4;
	lista3->A[1]='\0';

	lista3->next=NULL;

	media=medialista(lista);
	media=17/4;

	printf("%f",media);

}

float mediavect (int array[]) {

		int i=0,somma=0;
		float media=0.0;

	while (array[i] != '\0') {
		somma=somma+array[i];
		i=i+1;
	}

	media=somma / i;
	return media;
}

float sommalista (elemento *head) {

		float ris=0.0;

	if (head == NULL)
		return 0.0;
	else
		ris=mediavect(head->A)+sommalista(head->next);
		return ris;
   }

int numel (elemento *head) {

		int num=0;

	if (head == NULL)
		return 0;
	else
		num=1 + numel(head->next);
		return num;
}

float medialista (elemento *head) {

		float media=0.0;

	media=sommalista(head)/numel(head);
	return media;
}

[Paco De Luciaaaaa]

Originariamente inviato da DavidGT

guardate un secondo questo...

perchè non mi prende in modo corretto l'anno??

Grazie!!

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

//Creare un programma che permetta di creare una lista di
//nominativi che contenga una anagrafica con i seguenti dati: nome cognome e data di
//nascita. Le funzionalità richieste sono l’inserimento di nuovi nominativi e la stampa di tutto
//l’archivio.

typedef struct el {
	int anno;
	char nome[10];
	char cognome[10];
	struct el *next;
} elemento;


elemento * inseriscitesta (elemento *head);
void stampa (elemento *head);


void main () {


	int scelta=5;
	elemento *lista;

	lista=NULL;

	while (scelta != 9) {
	printf("Se vuoi inserire un nominativo premi 1 altrimenti premi 0 per stampare la lista || per uscire 9\n\n");
	scanf("%d",&scelta);

	if (scelta == 1) {

		lista=inseriscitesta(lista);
	}

	if (scelta == 2) {

		stampa (lista);

	}
}
}




elemento * inseriscitesta (elemento *head) {

	elemento *new;

	new=(elemento *)malloc(sizeof(elemento));
	new->next=head;

		printf("Inserire il nome\n");
		scanf("%s", new->nome);
		printf("Inserire il cognome\n");
		scanf("%s", new->cognome);
		printf("Inserire anno di nascita\n");
		scanf("%d", new->anno);

	return new;
}

void stampa (elemento *head) {

	while (head != NULL) {

		printf("%s - %s - %d\n", head->nome, head->cognome, head->anno);
		head=head->next;
	}
}

Probabilmente perchè nello stream dopo aver letto la stringa cognome rimane il carattere di spaziatura e/o LF eo '\n'

prova a modificare così:

	scanf("%s%*c", new->cognome);

[Paco De Luciaaaaa]

Originariamente inviato da DavidGT

Ho una lista di array, devo fare la media del singolo array e poi la media di tutto.

Perchè non mi prende i decimali?!?!

Anche se metto 17/4, risultato = 4....

ho messo sia double che float...
perchè???

Grazie!

La divisione di due numeri interi in c restituisce sempre un intero, devi forzare con un cast a float quindi:

media = (float ) 17/4;

P.S. Quando usi la malloc abbi sempre l'accortezza di controllare che l'esito dell'allocazione sia avvenuto correttamente, te l'hanno detto anche sopra.

es.

puntatore = ( cast *) malloc (sizeof(cast));
if (puntatore == NULL){
   fprintf(stdout,"\nErrore di allocazione della memoria.");
   free( ...); // tutti i puntatori a strutture create in precedenza
   exit(-1);
}

[DavidGT]

Perchè in questa funzione ho dovuto mettere un puntatore alla testa della lista (elemento *lista) altrimenti mi perdeva l'indirizzo scorrendo la funzione

elemento *controllopos(elemento *head, elemento *conf, elemento *lista,elemento *prec) {

	elemento *temp, *succ;

	if (head->next == NULL)
		return lista;

	if (conf == NULL) {
		temp=head->next;

		return head=controllopos(head->next, temp->next,lista,head->next);
	}
	else {
		if (head->pedina.x == conf->pedina.x && head->pedina.y == conf->pedina.y) {

			temp=prec;
			temp->next=conf->next;
			free(conf);
			conf=temp->next;
			return head=controllopos(head, conf,lista,prec);
		}

		return head=controllopos(head, conf->next, lista,prec->next);
	}
}

mentre invece in quest'altra funzione alla fine ritorno lo stesso head, che anch'esso è stato incrementato, e punta alla testa iniziale anche senza ricorrere al riferimento in testata come avevo fatto prima?????

elemento * elimina (elemento *head, char cercacogn[10]) {
	elemento *succ;
	succ=head->next;

	if (strcmp(succ->cognome,cercacogn)==0) {

		free(succ);
		head->next=succ->next;
	}

	else
		if(head!=NULL) {
			succ=head->next;
			elimina((head->next), cercacogn);
		}

	return head;
}

Non so se mi sono spiegato bene....

[DavidGT]

UP

[Paco De Luciaaaaa]

Nel primo caso è ovvio: chiami recursivamente la funzione ma devi considerare che in quel caso il puntatore head alla lista lo devi passare by reference e quindi accedervi come doppio puntatore.

Nel secondo caso ci sarà un errore a run time perchè usi la free e poi tenti di accedere al campo succ che è stato eliminato.


Cmq devi ben imparare 2 cose fondamentali:
- La ricorsione è molto elegante ma devi saperla usare. Basta un ciclo while e un puntatore che funge da scorritore
- Il passaggio dei parametri in una funzione e il loro ambiente o scope.

Ciao