/*  * Sviluppate un programma C, che determini se il cliente di un  * grande magazzino abbia superato il limite di credito sul suo  * conto. Per ogni cliente saranno disponibili i seguenti dati:  *     1. Il numero di conto  *     2. Il saldo all'inizio del mese  *     3. Il totale di tutti gli articoli che il cliente ha messo  *        in conto, durante il mese corrente.  *     4. Il totale di tutti i crediti applicati al conto di questo  *        cliente, durante il mese corrente.  *     5. Il limite di credito concesso.  * Il programma dovrà prendere in input tutti questi dati, calcolare  * il nuovo saldo ( = saldo iniziale + articoli messi in conto - crediti)  * e determinare se il nuovo saldo superi il limite di credito del  * cliente.  * Per quei clienti che avranno superato il limite di credito, il  * programma dovrà visualizzare il loro numero di conto, il limite  * di credito, il nuovo saldo e il messaggio "Credit limit exceeded".  *  */ #include <stdio.h> int main(void) { 	int	numero_conto; 	float	saldo_iniziale, saldo_finale, 		totale_articoli, crediti, limite_credito; 	printf("Enter account number (-1 to end): "); 	scanf("%d", &numero_conto); 	/* raccolta dati conto */ 	while (numero_conto != -1) { 		printf("Enter beginning balance: "); 		scanf("%f", &saldo_iniziale); 		printf("Enter total charges: "); 		scanf("%f", &totale_articoli); 		printf("Enter total credits: "); 		scanf("%f", &crediti); 		printf("Enter credit limit: "); 		scanf("%f", &limite_credito); 		saldo_finale = saldo_iniziale + totale_articoli - crediti; 		if (saldo_finale > limite_credito) { 			printf("Account: %d\n", numero_conto); 			printf("Credit limit: %.2f\n", limite_credito); 			printf("Balance: %.2f\n", saldo_finale); 			printf("Credit Limit Exceeded.\n"); 		} 		printf("\nEnter account number (-1 to end): "); 		scanf("%d", &numero_conto); 	} 	return (0); } 

 /*  * Una grande industra chimica retribuisce i propri venditori  * basandosi sulle provvigioni.  * Il venditore riceve $200 la settimana più il 9 per cento  * delle proprie vendite lorde portate a termine durante la  * settimana. Per esempio, un venditore che in una settimana  * venda prodotti chimici per un valore di $5000, riceverà  * $200 più il 9 per cento di $5000, ovverosia un totale di  * $650.  * Scrivere un programma C, che prenda in input le vendite  * lorde di ogni venditore per l'ultima settimana e quindi  * calcoli e visualizzi il salario per ognuno di loro.  * Elaborate i conti di un venditore per volta.  *  */ /*  * SVOLGIMENTO (top-down per raffinamenti successivi)  *  * Top: calcolare e visualizzare il salario di ogni venditore.  *  * R1: finché ci sono ancora dati in ingresso, calcolare il  * salario del venditore, visualizzare il risultato.  *  * R2: inizializzare variabili;  *     finché vendite_lorde in input non è uguale a -1  *         salario = 200 + (vendite_lorde) * 9 / 100;  *         visualizza salario venditore  *  * R3: percentuale = 9.0 / 100; fisso = 200;  *     chiedere in ingresso vendite_lorde;  *     finché vendite_lorde diverso -1  *         salario = fisso + vendite_lorde * percentuale  *         visualizza salario  *     chiedere in ingresso vendite_lorde;  */ #include <stdio.h> int main(void) { 	float percentuale = 9.0 / 100; 	float salario_fisso = 200; 	float vendite_lorde, salario; 	printf("\nEnter sales in dollars (-1 to end): "); 	scanf("%f", &vendite_lorde); 	while (vendite_lorde != -1) { 		salario = salario_fisso + vendite_lorde * percentuale; 		printf("Salary is $%.2f\n", salario); 		printf("\nEnter sales in dollars (-1 to end): "); 		scanf("%f", &vendite_lorde); 	} 	return (0); } 

 /*  * L'interesse semplice su un mutuo è calcolato dalla formula  *	interest = principal * rate * days / 365  * La formula precedente presume che rate sia il tasso di interesse  * annuale e quindi include la divisione per 365 (giorni).  * Sviluppare un programma C che prenda in input principal (capitale),  * rate (tasso) e days (giorni) per diversi mutui e visualizzi l'interesse  * semplice per ogni mutuo utilizzando la formula precedente.  *  */ /*  * Svolgimento (usando processo top-down per raffinamenti successivi)  *  * Top) calcolare e visualizzare l'interesse semplice su diversi mutui  *    dati in ingresso.  *  * R1) chiedere l'inserimento del valore del capitale, del tasso (annuale)  *    e dei numeri di giorni di mutuo; calcolare l'interesse e visualizzarlo  *  * R2) finché il valore del capitale è diverso da -1 (valore sentinella),  *     chiedere l'inserimento dei dati, calcolare l'interesse e visualizzarlo.  */ /*  * Implementazione  *  */ #include <stdio.h> int main(void) { 	int num_giorni; 	float interesse, capitale, tasso; 	printf("\nEnter loan principal: "); 	scanf("%f", &capitale); 	while(capitale != -1) { 		printf("Enter interest rate: "); 		scanf("%f", &tasso); 		printf("Enter term of the loan in days: "); 		scanf("%d", &num_giorni); 		interesse = capitale * tasso * num_giorni / 365; 		printf("The interest charge is $%.2f\n", interesse); 		printf("\nEnter loan principal: "); 		scanf("%f", &capitale); 	} 	return (0); } 

 /*  * Sviluppate un programma C che determini la paga lorda per ognuno  * dei diversi impiegati. L'azienda, per le prime 40 ore lavorate da  * ogni impiegato, paga il "salario  orario di base", mentre per tutte  * le ore lavorate in aggiunta alle 40, elargisce "una volta e mezza il  * salario di base". Vi sono stati forniti: una lista degli impiegati  * dell'azienda, il numero di ore lavorate da ogni impiegato nell'ultima  * settimana e il salario orario di base di ogni impiegato.  * Il vostro programma dovrà prendere in input, per ogni impiegato,  * le suddette informazioni e dovrà quindi determinare e visualizzare  * la paga lorda di ognuno di loro.  *  */ /*  * SVILUPPO programma mediante processo top-down per raffinamenti  * successivi.  *  * Top: calcolare la paga lorda di ogni impiegato in base al numero  *      di ore di lavoro.  *  * R1: richiedere il salario base dell'impiegato, e il numero di  *     ore di lavoro. Se il numero di ore di lavoro è minore o  *     uguale a 40, il salario è uguale a paga_base * ore di lavoro,  *     altrimenti, il salario è uguale alla paga_base * 40 più una  *     volta e mezza il salario base per ogni ora in più  (extra);  *     visualizzare il salario dell'impiegato.  *  * R2: richiedere ore_lavoro;  *     finché ore_lavoro diverso -1:  *         richiedere paga_base  *         se ore_lavoro è minore o uguale 40:  *             salario = ore_lavoro * paga_base  *         altrimenti  *             ore_extra = ore_lavoro - 40  *             salario = (ore_extra * 1.5 + 40) * paga_base  *         visualizzare salario  *         richiedere ore_lavoro  *     fine programma  *  */ /* IMPLEMENTAZIONE */ #include <stdio.h> int main(void) { 	int ore_lavoro, ore_extra; 	float salario, paga_base; 	printf("\nEnter # of hours worked (-1 to end): "); 	scanf("%d", &ore_lavoro); 	while (ore_lavoro != -1) { 		printf("Enter hourly rate of the worker ($00.00): "); 		scanf("%f", &paga_base); 		if (ore_lavoro <= 40) 			salario = ore_lavoro * paga_base; 		else { 			ore_extra = ore_lavoro - 40; 			salario = (ore_extra * 1.5 + 40) * paga_base; 		} 		printf("Salary is $%.2f\n", salario); 		printf("\nEnter # of hours worked (-1 to end): "); 		scanf("%d", &ore_lavoro); 	} 	return (0); } 

 /*  * Sviluppate un programma C che determini la paga lorda per ognuno  * dei diversi impiegati. L'azienda, per le prime 40 ore lavorate da  * ogni impiegato, paga il "salario  orario di base", mentre per tutte  * le ore lavorate in aggiunta alle 40, elargisce "una volta e mezza il  * salario di base". Vi sono stati forniti: una lista degli impiegati  * dell'azienda, il numero di ore lavorate da ogni impiegato nell'ultima  * settimana e il salario orario di base di ogni impiegato.  * Il vostro programma dovrà prendere in input, per ogni impiegato,  * le suddette informazioni e dovrà quindi determinare e visualizzare  * la paga lorda di ognuno di loro.  *  */ /*  * SVILUPPO programma mediante processo top-down per raffinamenti  * successivi.  *  * Top: calcolare la paga lorda di ogni impiegato in base al numero  *      di ore di lavoro.  *  * R1: richiedere il salario base dell'impiegato, e il numero di  *     ore di lavoro. Se il numero di ore di lavoro è minore o  *     uguale a 40, il salario è uguale a paga_base * ore di lavoro,  *     altrimenti, il salario è uguale alla paga_base * 40 più una  *     volta e mezza il salario base per ogni ora in più (extra);  *     visualizzare il salario dell'impiegato.  *  * R2: richiedere ore_lavoro;  *     finché ore_lavoro diverso -1:  *         richiedere paga_base  *         salario = ore_lavoro * paga_base  *         se ore_lavoro maggiore di 40  *             ore_extra = ore_lavoro - 40  *             salario = salario + ore_extra * 0.5 * paga_base  *         visualizzare salario  *         richiedere ore_lavoro  *     fine programma  *  */ /* IMPLEMENTAZIONE */ #include <stdio.h> int main(void) { 	int ore_lavoro, ore_extra; 	float salario, paga_base; 	printf("\nEnter # of hours worked (-1 to end): "); 	scanf("%d", &ore_lavoro); 	while (ore_lavoro != -1) { 		printf("Enter hourly rate of the worker ($00.00): "); 		scanf("%f", &paga_base); 		salario = ore_lavoro * paga_base; 		if (ore_lavoro > 40) { 			ore_extra = ore_lavoro - 40; 			salario = salario + ore_extra * .5 * paga_base; 		} 		printf("Salary is $%.2f\n", salario); 		printf("\nEnter # of hours worked (-1 to end): "); 		scanf("%d", &ore_lavoro); 	} 	return (0); } 

 /*  * Scrivete un programma C che dimostri la differenza tra il  * predecremento e il postdecremento utilizzando l'operatore  * di decremento --.  *  */ #include <stdio.h> int main(void) { 	int integer; 	/* predecremento */ 	integer = 10; 	printf("Valore iniziale: %d\n", integer); 	printf("Risultato applicando il predecremento:\n"); 	while (integer > 0) 		printf("%d   ", --integer); 	printf("\n\n"); 	/* postdecremento */ 	integer = 10; 	printf("Valore iniziale: %d\n", integer); 	printf("Risultato applicando il postdecremento:\n"); 	while (integer > 0) 		printf("%d   ", integer--); 	printf("\n"); 	return 0; } 

 /*  * Scrivete un programma C che utilizzi un ciclo, per visualizzare  * i numeri da 1 a 10 a fianco a fianco sulla stessa riga e con  * tre spazi tra ognuno di essi.  */ #include <stdio.h> int main(void) { 	int integer; 	integer = 0; 	while (integer <= 10) 		printf("%d   ", integer++); 	printf("\n"); 	return 0; } 

 /*  * Scrivete un programma C che utilizzi un ciclo per visualizzare la  * seguente tabella di valori:  *  * N     10*N    100*N   1000*N  *  */ /*  * SVILUPPO TOP-DOWN (per raffinamenti successivi)  *  * TOP) stampare per ogni numero da 1 a n:  *          il numero stesso, il numero per 10, il numero * 100, il numero * 1000  *  * RA1) inizializzare contatore n a 1  *      stampare intestazione su quattro colonne con lunghezza di campo 8  *      finché contatore n è minore o uguale a 10:  *          stampa n, 10*n, 100*n, 1000 * n  *          incrementa n di 1  *      terminare programma  */ #include <stdio.h> int main(void) { 	int n = 1; 	printf("\t%-8s%-8s%-8s%-8s\n\n", "N", "10*N", "100*N", "1000*N"); 	while (n <= 10) { 		printf("\t%-8d%-8d%-8d%-8d\n", n, 10*n, 100*n, 1000*n); 		n = n + 1; 	} 	return (0); } 

 /*  * Scrivete un programma C che utilizzi un ciclo per produrre  * la seguente tabella di valori:  *  * A	A+2	A+4	A+6  *  * 3	5	7	9  * 6	8	10	12  * 9	11	13	15  * 12	14	16	18  * 15	17	19	21  *  * SVILUPPO (top-down per raffinamenti successivi)  *  * TOP) partendo dal valore A = 3 e incrementandolo ogni volta  *      di 3, stampare su una riga il valore A, A+2, A+4, A+6  *  * RA1) inizializzare A a 3  *      stampare intestazione  *      finché A minore o uguale a 15:  *          stampare A, A+2, A+4, A+6  *          incrementare A di 3  */ #include <stdio.h> int main(void) { 	int A = 3; 	/* stampa intestazione */ 	printf("\tA\tA+2\tA+4\tA+6\n\n"); 	/* stampa tabella */ 	while (A <= 15) { 		printf("\t%d\t%d\t%d\t%d\n", A, A+2, A+4, A+6); 		A = A+3; 	} 	return (0); } 

 /*  * Trovate i due numeri maggiori tra 10 valori, usando un approccio  * simile all'Esercizio 3.24. Nota: potrete prendere in input ogni  * valore soltanto una volta.  *  * SVILUPPO (top-down per raffinamenti successivi)  *  * TOP) prendere in input 10 valori, determinare i due maggiori  *  * RA1) inizializzare counter a 1  *      prendere in input il primo valore  *      memorizzarlo in Max, incrementare counter di 1  *      prendere in input il secondo valore  *      memorizzarlo in max, incrementare counter di 1  *      se Max minore di max:  *          memorizzare Max in tmp  *          copiare max in Max, tmp in max  *      finché counter maggiore o uguale a 10:  *          prendere in input un valore  *          se valore maggiore Max:  *              copiare in max Max e in Max il nuovo valore  *          altrimenti se valore maggiore di max:  *              copiare in max il valore  *          incrementare counter di 1  *      stampare Max e max  *      terminare programma  */ #include <stdio.h> int main(void) { 	int counter, Max, max, number; 	counter = 1; 	printf("Enter %dst number: ", counter); 	scanf("%d", &Max); 	counter = counter + 1; 	printf("Enter %dst number: ", counter); 	scanf("%d", &max); 	counter = counter + 1; 	/* scambia i valori (in Max il massimo dei due) */ 	if (Max < max) { 		number = Max; 		Max = max; 		max = number; 	} 	while (counter <= 10) { 		printf("Enter %dst number: ", counter); 		scanf("%d", &number); 		if (number > Max){ 			max = Max; 			Max = number; 		} else if (number > max) 			max = number; 		counter = counter + 1; 	} 	printf("The maximum values are %d and %d\n", Max, max); 	return (0); } 

 /*  * Che cosa visualizzerà il seguente programma?  */ #include <stdio.h> int main(void) { 	int count = 1; 	while (count <= 10) { 		printf("%s\n", count % 2 ? "****" : "++++++++"); 		++count; 	} 	return (0); } /*  * Visualizzerà il seguente output:  *  * ****  * ++++++++  * ****  * ++++++++  * ****  * ++++++++  * ****  * ++++++++  * ****  * ++++++++  */ 

 /*  * Che cosa visualizzerà il seguente programma?  */ #include <stdio.h> int main(void) { 	int row = 10, column; 	while (row >= 1) { 		column = 1; 		while (column <= 10) { 			printf("%s", row % 2 ? "<" : ">"); 			++column; 		} 		--row; 		printf("\n"); 	} 	return (0); } /*  * Visualizzerà il seguente output:  *  * >>>>>>>>>>  * <<<<<<<<<<  * >>>>>>>>>>  * <<<<<<<<<<  * >>>>>>>>>>  * <<<<<<<<<<  * >>>>>>>>>>  * <<<<<<<<<<  * >>>>>>>>>>  * <<<<<<<<<<  */ 

 /*  * Scrivete un programma che legga in input il lato di un  * quadrato e quindi lo disegni utilizzando degli asterischi.  * Il vostro programma dovra' funzionare con tutti i quadrati  * con dimensioni dei lati comprese tra 1 e 20.  *  */ #define LATOMAX 20 #include <stdio.h> int main(void) { 	unsigned int lato, oriz, vert; 	unsigned int invalid_data = 1; 	/* richiede la lunghezza (intera) del lato (max LATOMAX) */ 	while (invalid_data) { 		printf("Inserire il valore del lato (max %d): ", LATOMAX); 		(void) scanf("%u", &lato); 		if (lato <= LATOMAX) 			invalid_data = 0; 		else 			printf("Valore non valido!\n"); 	} 	vert = lato; 	while (vert > 0) { 		oriz = lato; 		while (oriz > 0) { 			printf("* "); 			oriz--; 		} 		printf("\n"); 		vert--; 	} 	return 0; } 

 /*  * Modificate il programma che avete scritto nell'Esercizio  * 3.33 in modo che visualizzi un quadrato vuoto.  *  */ #define LATOMAX 20 #include <stdio.h> int main(void) { 	unsigned int lato, oriz, vert; 	unsigned int invalid_data = 1; 	/* richiede la lunghezza (intera) del lato (max LATOMAX) */ 	while (invalid_data) { 		printf("Inserire il valore del lato (max %d): ", LATOMAX); 		(void) scanf("%u", &lato); 		if (lato <= LATOMAX) 			invalid_data = 0; 		else 			printf("Valore non valido!\n"); 	} 	vert = lato; 	while (vert > 0) { 		oriz = lato; 		while (oriz > 0) { 			if ((vert == 1) || (vert == lato) || 			    (oriz == 1) || (oriz == lato)) 				printf("* "); 			else 				printf("  "); 			oriz--; 		} 		printf("\n"); 		vert--; 	} 	return 0; } 

 /*  * Scrivere un programma che visualizzi 100 asterischi uno per volta.  * Ogni dieci asterischi, il vostro programma dovrà visualizzare un  * carattere newline. (Suggerimento: contate da 1 a 100. Usate  * l'operatore di modulo per individuare tutte le volte che il  * contatore raggiunge un multiplo di 10).  */ /*  * SVILUPPO top-down (per raffinamenti successivi)  *  * TOP: stampare 100 asterischi su 10 righe.  *  * RA1: inizializzare variabili: aster = 1;  *      finché aster è minore o uguale a cento:  *          stampare un asterisco  *          se aster modulo dieci è uguale a zero  *              stampare un carattere di newline  *          incrementare aster di uno  *      terminare programma  *  */ #include <stdio.h> int main(void) { 	int aster = 1; 	while (aster <= 100) { 		printf("*"); 		if (0 == (aster % 10)) 			printf("\n"); 		++aster; 	} 	return (0); } 

 /*  * Scrivete un programma che legga il raggio di un cerchio  * (come un valore di tipo float) e quindi calcoli e visualizzi  * la circonferenza e l'area. Utilizzate il valore 3.14159 per  * pi-greco.  */ /*  * Sviluppo top-down (per raffinamenti successivi)  *  * TOP: dato il raggio, calcolare diametro, circonferenza, area  *      del cerchio.  *  * RA1: prendere in ingresso il raggio (tipo float).  *      calcolare diametro, circonferenza, area, visualizzare  *      risultati.  *  * RA2: prendere in ingresso il raggio (tipo float), verificando  *      che sia un valore non negativo.  *      Calcolare diametro, circonferenza, area, visualizzare i  *      risultati.  *      Terminare programma.  *  * RA3: Inizializzare variabile pi_greco a 3.14159.  *      prendere in ingresso il raggio (tipo float), verificando  *      che sia un valore non negativo.  *      Calcolare diametro, circonferenza, area, visualizzare i  *      risultati.  *      Terminare programma.  *  */ #include <stdio.h> int main(void) { 	float pi_greco = 3.14159; 	float raggio = 0, diametro, circonferenza, area; 	while (raggio <= 0) { 		printf("Inserire un valore (positivo) per il raggio: "); 		scanf("%f", &raggio); 	} 	diametro = 2 * raggio; 	circonferenza = pi_greco * diametro; 	area = pi_greco * raggio * raggio; 	printf("Diametro: %.2f\n", diametro); 	printf("Circonferenza: %.2f\n", circonferenza); 	printf("Area: %.2f\n", area); 	return (0); } 

 /*  * Una azienda vuole trasmettere dei dati sulla linea telefonica,  * ma i suoi responsabili sono preoccupati dal fatto che i propri  * telefoni potrebbero essere spiati. Tutti i loro dati sono  * trasmessi come interi di quattro cifre.  * Vi hanno chiesto di scrivere un programma che crittografi  * i loro dati in modo che possano essere trasmessi con maggior  * sicurezza.  * Il vostro programma dovrà leggere un intero di quattro cifre  * e crittografarlo nel modo seguente: sostituite ogni cifra  * con (la somma di quella cifra + 7) modulo 10. In seguito,  * scambiate la prima cifra con la terza, e scambiate la seconda  * cifra con la quarta. Visualizzate quindi l'intero crittografato.  */ /*  * SVILUPPO PROGRAMMA  * (mediante processo top-down per raffinamenti successivi)  *  * TOP: prendere un intero in ingresso, crittografarlo, stamparlo  *      in output.  *  * RA1: finché intero maggiore 9999 o minore -9999  *          stampare messaggio "L'intero deve essere di 4 cifre"  *          prendere un intero in ingresso  *      cifra_1 = numero / 1000; cifra_1 = (cifra_1 + 7) % 10;  *      numero = numero % 1000;  *      cifra_2 = numero / 100; cifra_2 = (cifra_2 + 7) % 10;  *      numero = numero % 100;  *      cifra_3 = numero / 10; cifra_3 = (cifra_3 + 7) % 10;  *      numero = numero % 10;  *      cifra_4 = numero; cifra_4 = (cifra_4 + 7) % 10;  *      cifra_tmp = cifra_1;  *      cifra_1 = cifra_3; cifra_3 = cifra_tmp;  *      cifra_tmp = cifra_2;  *      cifra_2 = cifra_4; cifra_4 = cifra_tmp;  *      numero = cifra_4 + cifra_3 * 10 + cifra_2 * 100 + cifra_1 * 1000;  *      visualizza numero;  */ /*  * IMPLEMENTAZIONE  */ #include <stdio.h> int main(void) { 	int cifra_1, cifra_2, cifra_3, cifra_4, cifra_tmp; 	int numero = 10000; 	while (numero < 0 || numero > 9999) { 		printf("\nInserire numero da crittografare: (0000 to 9999): "); 		scanf("%d", &numero); 	} 	cifra_1 = numero / 1000; cifra_1 = (cifra_1 + 7) % 10; 	numero %= 1000; 	cifra_2 = numero / 100; cifra_2 = (cifra_2 + 7) % 10; 	numero %= 100; 	cifra_3 = numero / 10; cifra_3 = (cifra_3 + 7) % 10; 	numero %= 10; 	cifra_4 = numero; cifra_4 = (cifra_4 + 7) % 10; 	cifra_tmp = cifra_1; 	cifra_1 = cifra_3; cifra_3 = cifra_tmp; 	cifra_tmp = cifra_2; 	cifra_2 = cifra_4; cifra_4 = cifra_tmp; 	printf("Numero crittografato: %d%d%d%d\n", 	    cifra_1, cifra_2, cifra_3, cifra_4); 	return (0); } 

 /*  * Scrivete un programma a parte che prenda in input un intero  * crittografato di quattro cifre e lo decifri, in modo da formare  * il numero originale.  */ #include <stdio.h> int main(void) { 	int cifra_1, cifra_2, cifra_3, cifra_4, cifra_tmp; 	int numero = 10000; 	while (numero < 0 || numero > 9999) { 		printf("\nInserire numero da decrittografare: (0000 to 9999): "); 		scanf("%d", &numero); 	} 	/* individua ogni cifra */ 	cifra_1 = numero / 1000; 	numero %= 1000; 	cifra_2 = numero / 100; 	numero %= 100; 	cifra_3 = numero / 10; 	numero %= 10; 	cifra_4 = numero; 	/* scambia la prima con la terza, la seconda con la quarta */ 	cifra_tmp = cifra_1; 	cifra_1 = cifra_3; cifra_3 = cifra_tmp; 	cifra_tmp = cifra_2; 	cifra_2 = cifra_4; cifra_4 = cifra_tmp; 	/* trova cifra originale */ 	cifra_1 = (cifra_1 - 7); if (cifra_1 < 0) cifra_1 += 10; 	cifra_2 = (cifra_2 - 7); if (cifra_2 < 0) cifra_2 += 10; 	cifra_3 = (cifra_3 - 7); if (cifra_3 < 0) cifra_3 += 10; 	cifra_4 = (cifra_4 - 7); if (cifra_4 < 0) cifra_4 += 10; 	printf("Numero decrittografato: %d%d%d%d\n", 	    cifra_1, cifra_2, cifra_3, cifra_4); 	return (0); } 

 /*  * Il fattoriale di un intero non negativo n si scrive n! (pronunciato  * fattoriale di n) ed è definito come segue:  *  * n! = n*(n - 1)*(n - 2)*...*1  (per valori di n maggiori o uguali a 1)  *  * e  *  * n! = 1  (per n = 0).  *  * Per esempio, 5! = 5*4*3*2*1 che è 120.  *  * a) Scrivete un programma che legga in input un intero non negativo e  *    quindi visualizzi il suo fattoriale.  */ /*  * Sviluppo top-down (per raffinamenti successivi)  *  * TOP) prendere in ingresso un intero non negativo, visualizzarne il  *      fattoriale.  *  * RA1) inizializzare variabile intero a -1, fattoriale a 1;  *      finché intero è minore di zero:  *          leggere in input un intero e memorizzarlo nella variabile  *          omonima  *      finché intero è positivo:  *          memorizzare in fattoriale, intero * fattoriale  *          decrementare intero  *      visualizzare il valore della variabile fattoriale.  *  */ #include <stdio.h> int main(void) { 	int intero, fattoriale; 	intero = -1; 	fattoriale = 1; 	while (intero < 0) { 		printf("Inserire un intero non negativo: "); 		scanf("%d", &intero); 	} 	while (intero > 0) { 		fattoriale = intero * fattoriale; 		--intero; 	} 	printf("Il fattoriale è %d\n", fattoriale); 	return (0); } 

 /*  * Scrivete un programma che trovi il minore di diversi interi.  * Supponete che il primo valore letto specifichi il numero di  * quelli ancora da leggere.  *  * SVILUPPO  * Leggere il numero di interi da elaborare  * leggere il primo valore che è anche il minimo  * finché non sono stati letti tutti i rimanenti valori:  *    leggi un intero  *    se l'intero letto è minore del minore corrente:  *        memorizzarlo in minore  * stampare il minore trovato  * terminare programma  */ #include <stdio.h> int main(void) { 	int numbers, number, min, i; 	numbers = -1; 	/* legge il numero di interi da processare */ 	while (numbers < 0) { 		printf("Enter number of integers to process: "); 		scanf("%d", &numbers); 	} 	/* memorizza il primo in min */ 	if (numbers != 0) { 		printf("Enter 1° number: "); 		scanf("%d", &min); 		/* legge i rimanenti, e memorizza il più piccolo in min */ 		for (i = 2; i <= numbers; i++) { 			printf("Enter %d° number: ", i); 			scanf("%d", &number); 			if (number < min) 				min = number; 		} 		printf("The minimum is %d.\n", min); 	} 	return (0); } 

 /*  * Scrivete un programma che calcoli e visualizzi la somma  * dei numeri pari da 2 a 30  *  * SVILUPPO  *  * inizializzare somma a zero  * inizializzare counter a due  * finché counter è minore o uguale a trenta:  *    se counter è pari, aggiungerlo a somma  * visualizzare somma  * terminare il programma  */ #include <stdio.h> int main(void) { 	int counter, sum; 	sum = 0; 	for (counter = 2; counter <= 30; counter += 2) 		sum += counter; 	printf("Sum = %d\n", sum); 	return (0); } 

 /*  * Scrivete un programma che calcoli e visualizzi il prodotto  * degli interi dispari da 1 a 15.  *  * SVILUPPO (top-down per raffinamenti successivi)  *  * TOP) moltiplicare tutti gli interi da 1 a 15  *  * RA1) memorizzare in i il primo intero (uno)  *      inizializzare prodotto a uno  *      finché i è minore o uguale a quindici:  *          moltiplicare prodotto per i  *          incrementare i di due  *      visualizzare prodotto  *      terminare programma  *  */ #include <stdio.h> int main(void) { 	int i, prodotto; 	for (i = prodotto = 1; i <= 15; i += 2) 		prodotto *= i; 	printf("Prodotto dei primi 15 interi dispari: %d\n", prodotto); 	return (0); } 

 /*  * Scrivete una funzione che accetti in input l'ora, suddivisa in tre  * argomenti interi (per le ore, i minuti e i secondi), e restituisca  * il numero dei secondi trascorsi dall'ultima volta che l'orologio  * "ha rintoccato le 12".  * Utilizzate questa funzione per calcolare la quantita' di tempo in  * secondi che intercorre tra due orari, entrambi i quali siano compresi  * all'interno di un ciclo di 12 ore dell'orologio.  */ #include <stdio.h> unsigned int pastSeconds(unsigned int, unsigned int, unsigned int); int main(void) { 	unsigned int h1, m1, s1; 	unsigned int h2, m2, s2; 	unsigned int ps1, ps2, diff; 	int invalid_data = 1; 	/* ottiene primo orario (ORE MINUTI SECONDI) */ 	while (invalid_data) { 		printf("Inserire il primo orario (ORE MINUTI SECONDI: "); 		scanf("%u%u%u", &h1, &m1, &s1); 		if ((h1 < 23) && (m1 < 60) && (s1 < 60)) 			invalid_data = 0; 		else 			printf("Orario non valido! Reinserirlo\n\n"); 	} 	invalid_data = 1; 	/* ottiene secondo orario */ 	while (invalid_data) { 		printf("Inserire il secondo orario (ORE MINUTI SECONDI: "); 		scanf("%u%u%u", &h2, &m2, &s2); 		if ((h2 < 24) && (m2 < 60) && (s2 < 60)) { 			/* Gli orari devo essere in uno stesso arco di 12 ore */ 			if ((h1 / 12) != (h2 / 12)) 				printf("Gli orari devono essere in uno stesso arco di 12 ore!\n\n"); 			else 				invalid_data = 0; /* dati validi */ 		} else 			printf("Orario non valido! Reinserirlo\n\n"); 	} 	ps1 = pastSeconds(h1, m1, s1); 	ps2 = pastSeconds(h2, m2, s2); 	if (ps1 > ps2) 		diff = ps1 - ps2; 	else 		diff = ps2 - ps1; 	printf("Tra le ore %.2d:%.2d:%.2d e le ore %.2d:%.2d:%.2d ", h1, m1, s1, 		h2, m2, s2); 	printf("intercorrono %u secondi\n", diff); 	return 0; } unsigned int pastSeconds(unsigned int hour, unsigned int min, unsigned int sec) { 	return (sec + (min * 60) + ((hour % 12) * 60 * 60)); } 

 /*  *  * Il massimo comun divisore (MCD) di due interi è l'intero più grande che  * possa dividere esattamente ognuno dei due numeri. Scrivete una funzione  * gcd che restituisca il massimo comun divisore di due interi.  *  */ #include <stdio.h> #define EUCLALGO		/* usa l'algoritmo di Euclide */ int gcd(int, int); int main(void) { 	int n1, n2; 	/* legge i due numeri interi */ 	printf("Inserire due numeri interi: "); 	scanf("%d%d", &n1, &n2); 	printf("Il massimo comun divisore di %d e %d è %d\n", 	    n1, n2, gcd(n1, n2)); 	return 0; } #ifndef EUCLALGO int gcd(int n1, int n2) { 	int min, mcd, i; 	if (n1 < n2) 		min = n1; 	else 		min = n2; 	i = mcd = 1; 	while (i <= min) { 		if (((n1 % i) == 0) && ((n2 % i) == 0)) 			mcd = i; 		i++; 	} 	return mcd; } #else int gcd(int n1, int n2) { 	/* algoritmo di Euclide */ 	int a, b, mcd = 1; 	if (n1 > n2){ 		a = n1; 		b = n2; 	} else { 		a = n2; 		b = n1; 	} 	if ((a % b) == 0) 		mcd = b; 	else 		mcd = gcd (b, a % b); 	return mcd; } #endif 

 /*  * Scrivete un programma che simuli il lancio di una monetina.  * Per ogni lancio della monetina il programma dovrà visualizzare  * Heads o Tails. Lasciate che il programma lanci la monetina per  * 100 volte e contate il numero di occorrenze per la comparsa di  * ogni faccia della monetina. Visualizzate i risultati.  * Il programma dovrà richiamare una funzione flip, che non riceverà  * argomenti e che restituirà 0 per croce e 1 per testa.  * Nota: qualora il programma simuli realisticamente il lancio di  * una monetina, allora ogni faccia della stessa dovrà apparire  * approssimativamente la metà delle volte, per un totale approssimativo  * di 50 teste e 50 croci.  *  */ #include <stdio.h> #include <stdlib.h> #include <time.h> #define TESTA 1 #define CROCE 0 #define LANCI 1000 unsigned int flip(void); int main(void) { 	int totTesta, totCroce; 	int i, result; 	totTesta = totCroce = 0; 	srand(time(NULL)); 	for (i = 0; i < LANCI; i++) { 		result = flip(); 		if (result == CROCE) { 			printf("Tails\n"); 			totCroce++; 		} else { 			printf("Heads\n"); 			totTesta++; 		} 	} 	printf("Totale croce: %d,\tTotale testa: %d\n", totCroce, totTesta); 	return 0; } unsigned int flip(void) { 	return (rand() % 2); } 

 /*  * I computer giocano un ruolo sempre più importante nell'educazione.  * Scrivete un programma che aiuti uno studente di scuola elementare  * ad apprendere la moltiplicazione.  * Utilizzate rand per produrre due interi positivi di una cifra.  * Dovrete quindi visualizzare una domanda come:  *  *	How much is 6 times 7?  *  * In seguito lo studente digiterà la risposta. Il vostro programma  * controllerà la risposta dello studente. Qualora sia corretta,  * visualizzerete "Very good!" e sottoponete quindi un'altra domanda  * sulla moltiplicazione. Nel caso che la risposta sia sbagliata,  * visualizzate "No, Please try again." e lasciate quindi che lo  * studente provi ancora ripetutamente la stessa domanda, finché  * alla fine non avrà risposto correttamente.  *  */ #include <stdio.h> #include <stdlib.h> #include <time.h> void		printResult(const unsigned int); unsigned int	askAgain(void); unsigned int	askTimes(void); int main(void) { 	unsigned int play, times ,answer, result; 	play = 1;    /* giochiamo... */ 	do { 		times = askTimes(); 		/* leggi risposta */ 		scanf("%u", &answer); 		result = (times == answer)? 1 : 0; 		printResult(result); 		play = askAgain(); 	} while (play == 1); 	return (0); } /*  * Genera due numeri naturali tra 0 e 9 a caso e restituisce il prodotto  *  */ unsigned int askTimes(void) { 	unsigned int n1, n2; 	srandom(time(NULL)); 	n1 = random() % 10; 	n2 = random() % 10; 	printf("How much is %u * %u?\n", n1, n2); 	return n1*n2; } /*  * Stampa un messaggio di risposta corretta/sbagliata  * in base al valore 0/1 dell'argomento  *  */ void printResult(const unsigned int r) { 	if (0 == r) 		printf("\nNo, Please try again.\n"); 	else 		printf("\nVery good!\n"); } /*  * Chiede all'utente se vuole continuare o meno.  * Restituisce 1 in caso affermativo, 0 altrimenti  *  */ unsigned int askAgain(void) { 	char a; 	printf("\nContinue? y/n\n"); 	scanf("%c", &a); 	while (a == '\n') 	    scanf("%c", &a);         if (a == 'y' || a == 'Y')     	    return 1;         else 	    return 0; } 

 /*  * Scrivete la funzione distance() che calcoli la distanza tra due  * punti (x1, y1) e (x2, y2). Tutti i numeri e i valori restituiti  * dovranno essere di tipo float.  *  */ #include <stdio.h> #include <math.h> float distance(float, float, float, float); int main(void) { 	float p1, q1; 	float p2, q2; 	printf("Inserire le coordinate del primo punto: "); 	scanf("%f%f", &p1, &q1); 	printf("Inserire le coordinate del secondo punto: "); 	scanf("%f%f", &p2, &q2); 	/* calcola e stampa la distanza dei due punti */ 	printf("\nLa distanza tra P1(%.2f, %.2f) e P2(%.2f, %.2f) è %.2f\n", 	    p1, q1, p2, q2, distance(p1, q1, p2, q2)); 	return 0; } float distance(float _x1, float _y1, float _x2, float _y2) { 	return sqrt((_x1-_x2)*(_x1-_x2)+(_y1-_y2)*(_y1-_y2)); } 

 /*  * Un garage addebita un importo minimo di $2,00 per un parcheggio  * fino a tre ore.  * Il garage addebita un'addizionale di $0,50 per ogni ora o frazione  * di essa che ecceda le tre di base. L'addebito massimo per ogni dato  * periodo di 24 ore è $10,00.  * Assumete che nessuna auto parcheggi per più di 24 ore per volta.  * Scrivete un programma che calcoli e visualizzi gli addebiti  * per ognuno dei tre clienti che hanno parcheggiato le proprie  * auto in questo garage ieri.  * Dovrete immettere le ore di parcheggio per ogni cliente.  * Il vostro programma dovrà visualizzare i risultati in un formato  * tabulare ordinato e dovrà calcolare e visualizzare il totale delle  * ricevute di ieri. Il programma dovrà utilizzare la funzione  * calculateCharges per determinare l'addebito di ogni cliente.  * I vostri risultati dovranno apparire nel seguente formato:  *  *  Car     Hours     Charge  *  1         1.5       2.00  *  2         4.0       2.50  *  3        24.0      10.00  *  TOTAL    29.5      14.50  */ #include <math.h> #include <stdio.h> float calculateCharges(float); int main(void) { 	float	hours1, hours2, hours3, hoursTotal = 0; 	float	charge1, charge2, charge3, chargesTotal; 	printf("Enter hours for car 1: "); 	scanf("%f", &hours1); 	hoursTotal += hours1; 	charge1 = calculateCharges(hours1); 	printf("Enter hours for car 2: "); 	scanf("%f", &hours2); 	hoursTotal += hours2; 	charge2 = calculateCharges(hours2); 	printf("Enter hours for car 3: "); 	scanf("%f", &hours3); 	hoursTotal += hours3; 	charge3 = calculateCharges(hours3); 	printf("\n%-8s%8s%8s\n", "Car", "Hours", "Charge"); 	printf("%-8d%8.2f%8.2f\n", 1, hours1, charge1); 	printf("%-8d%8.2f%8.2f\n", 2, hours2, charge2); 	printf("%-8d%8.2f%8.2f\n", 3, hours3, charge3); 	chargesTotal = charge1 + charge2 + charge3; 	printf("%-8s%8.2f%8.2f\n\n", "TOTAL", hoursTotal, chargesTotal); 	return (0); } float calculateCharges(float _hours) { 	float charges = 2.00;	/* fixed */ 	if (_hours > 3.00) /* more than 3 hours */ 		charges += 0.50 * ceil(_hours - 3.00); 	if (charges > 10.00) 		charges = 10.00; 	return (charges); } 

 /*  * (Palindromi) Un palindromo è una stringa che si legge allo  * stesso modo da sinistra a destra e da destra a sinistra.  * Alcuni esempi di palindromi sono "radar", "able was i ere  * i saw elba" e "a man a plan a canal panama".  * Scrivete una funzione ricorsiva testPalindrome che restituisca  * 1, qualora la stringa immagazzinata nel vettore sia un palindromo,  * e 0 in caso contrario.  * La funzione dovrà ignorare gli spazi, la punteggiatura  * eventualmente presenti nella stringa.  *  */ #include <stdio.h> int isalfa(char); int testPalindrome(const char[]); #define STRINGA "able was i   ere i saw elba   " int main(void) { 	printf("La stringa \"%s\" ", STRINGA); 	if (!testPalindrome(STRINGA)) 		printf("non "); 	printf("è un palindromo\n"); 	return (0); } int testPalindrome(const char s[]) { 	int left = 0, right = 0; 	/* determina la lunghezza della stringa */ 	while (s[right] != '\0') 		right++; 	while (left <= right) { 	    if (isalfa(s[left])) { 		/* ignora spazi, punteggiatura a destra */ 		right--; 		while (!isalfa(s[right])) 		    right--; 		/* minuscolo != MAIUSCOLO */ 		if (s[left] != s[right]) 			return 0; /* non e' un palindromo */     	    } 	    left++; 	} 	return 1; /* e' un palindromo */ } /* restituisce 1 se un carattere [a-zA-Z], 0 altrimenti */ int isalfa(char c) { 	if ((c != ' ') && (c != ',') && 	    (c != '.') && (c != ';') && 	    (c != ':') && (c != '\t') && 	    (c != '\n')) 		return 1; 	else 		return 0; } 

 /*  * (versione non ricorsiva)  * (Palindromi) Un palindromo è una stringa che si legge allo  * stesso modo da sinistra a destra e da destra a sinistra.  * Alcuni esempi di palindromi sono "radar", "able was i ere  * i saw elba" e "a man a plan a canal panama".  * Scrivete una funzione testPalindrome che restituisca  * 1, qualora la stringa immagazzinata nel vettore sia un palindromo,  * e 0 in caso contrario.  * La funzione dovrà ingorare gli spazi, la punteggiatura  * eventualmente presenti nella stringa.  *  */ #include <stdio.h> int isalfa(char); int testPalindrome(const char[]); #define STRINGA "  r a d  	ar" int main(void) { 	printf("La stringa \"%s\" ", STRINGA); 	if (!testPalindrome(STRINGA)) 		printf("non "); 	printf("è un palindromo\n"); 	return (0); } int testPalindrome(const char s[]) { 	int left = 0, right = 0; 	/* determina la lunghezza della stringa */ 	while (s[right] != '\0') 		right++; 	while (left <= right) { 	    if (isalfa(s[left])) { 		/* ignora spazi, punteggiatura a destra */ 		right--; 		while (!isalfa(s[right])) 		    right--; 		/* minuscolo != MAIUSCOLO */ 		if (s[left] != s[right]) 			return 0;     	    } 	    left++; 	} 	return 1; } /* restituisce 1 se un carattere [a-zA-Z], 0 altrimenti */ int isalfa(char c) { 	if ((c != ' ') && (c != ',') && 	    (c != '.') && (c != ';') && 	    (c != ':') && (c != '\t') && 	    (c != '\n')) 		return 1; 	else 		return 0; } 

 /*  * Scrivete un programma che prenda in input dalla tastiera un carattere  * e lo controlli con ognuna delle funzioni della libreria per la gestione  * dei caratteri.  * Il programma dovrà visualizzare il valore restituito da ogni funzione.  *  */ #include <stdio.h> #include <ctype.h> int main(void) { 	char c; 	/* preleva il carattere dall'input */ 	c = getchar(); 	/* stampa il valore restituito da ogni funzione in ctype.h 	   passando come argomento c */ 	printf("isdigit('%c'): %d\n", c, isdigit(c)); 	printf("isalpha('%c'): %d\n", c, isalpha(c)); 	printf("isalnum('%c'): %d\n", c, isalnum(c)); 	printf("isxdigit('%c'): %d\n", c, isxdigit(c)); 	printf("islower('%c'): %d\n", c, islower(c)); 	printf("isupper('%c'): %d\n", c, isupper(c)); 	printf("tolower('%c'): '%c'\n", c, tolower(c)); 	printf("toupper('%c'): '%c'\n", c, toupper(c)); 	printf("isspace('%c'): %d\n", c, isspace(c)); 	printf("iscntrl('%c'): %d\n", c, iscntrl(c)); 	printf("ispunct('%c'): %d\n", c, ispunct(c)); 	printf("isprint('%c'): %d\n", c, isprint(c)); 	printf("isgraph('%c'): %d\n", c, isgraph(c)); 	return 0; } 

Download sorgente

 /*  * Il seguente programma stampa h numeri n-poligonali  * (Cfr. http://mathworld.wolfram.com/PolygonalNumber.html )  */ #include <stdio.h> unsigned int polynum(unsigned int, unsigned int); int main(void) { 	unsigned int side = 2, numbers, i; 	/* read polygonal side, how much numbers to print */ 	while (side < 3) { 		printf("Enter the polygonal number ( > 2): "); 		scanf("%u", &side); 		if (side < 3) 			printf("Invalid value!\n"); 	} 	printf("How much numbers? "); 	scanf("%u", &numbers); 	for (i = 1; i <= numbers; i++) 		printf("%u, ", polynum(side, i)); 	if (numbers > 0) 		printf("...\n"); 	return 0; } unsigned int polynum(unsigned int n, unsigned int h) { 	if (n < 3) 		return 0; 	return (n - 2) * (h - 1) * h / 2 + h; } 

Il livello dell’acqua di un bacino è controllato tramite uno strumento solitamente molto preciso; tuttavia a causa delle condizioni atmosferiche il valore misurato ogni tanto è inattendibile.

Considerando che il livello dellacqua nel bacino non può subire variazioni improvvise, si definisce accettabile una variazione dell’acqua,tra due misurazioni successive prese a intervallo temporale costante,del più o meno 5 per cento, mentre si devono scartare come errori di misura tutte quelle superiori al 5 per cento in valore assoluto.

Lo strumento memorizza su un file, sotto forma di numeri reali con 3 cifre decimali, un dato per ciascuna riga. Il file ha estensione .WD

Si vuole realizzare un programma per filtrare i dati misurati dallo strumento, eliminando gli errori di misura e sostituendoli con valori interpolati linearmente secondo le regole di seguito descritte:

• Il primo valore riportato nel file si assume sempre corretto.
• Se dopo un valore corretto appare un valore scorretto, cioè con variazione maggiore in valore assoluto del 5 per cento, allore bisogna considerare i valori successivi fino a trovare un valore corretto.
• Una volta trovato il valore corretto successivo,i valori scorretti vanno quindi sostituiti da valori interpolati linearmente tra i due valori corretti agli estremi dellintervallo.
• Se a partire da un certo momento tutti i valori fossero scorretti fino alla fine del file allora tali valori saranno sostituiti con l’ultimo valore corretto.

Il programma riceve come primo argomento della linea di comando il nome del file contente le misure (senza estensione .WD ) e deve generare un file con lo stesso nome e formato ed estensione .WOK. Inoltre al termine dell’esecuzione, il programma deve visualizzare a video il numero dei valori interpolati.

Ad esempio, se il file PROVA.WD contiene:

 1332.230 1331.900 1331.870 1331.652 1783.265 *** 1331.500 1331.470 12.230 *** -236.340 *** 1331.230 

Lanciando il programma con: PROG.EXE PROVA, verrà generato il file PROVA.WOK contenente:

 1332.230 1331.900 1331.870 1331.652 1331.576 *** 1331.500 1331.470 1331.390 *** 1331.310 *** 1331.230 

e il messaggio a video: Interpolate 3 misure non attendibili

NOTA:
Nell’esempio i valori con *** corrispondono alle misure non attendibili nel file PROVA.WD e ai valori interpolati nel file PROVA.WOK
Se chiamiamo $d_{ultimo}$ l’ultimo valore corretto prima di un valore non attendibile, $seq\_non\_att$ il numero di valori non attendibili consecutivi e $d_{primo}$ il primo valore corretto dopo la sequenza di valori non attendibili, il valore interpolato sarà pari a:

$d_{interp} = d_{ultimo} + (((index \cdot (d_{primo} – d_{ultimo}))/(seq\_non\_att + 1)))$

Dove $index$ è la posizione,a partire da 1, del valore non attendibile all’interno della sequenza composta da seq_non_att valori non attendibili.

Riguardo alla correttezza o meno dei dati successivi ad un primo dato scorretto, si deve osservare che il margine di errore con cui si devono fare i confronti per stabilire la correttezza o meno del dato corrente con l’ultimo valore corretto cresce del 5 per cento per il primo dato al 10 per cento per il secondo, al 15 per cento per il terzo, e così via.

Nel nostro esempio, si nota come ci siano due casi in cui si hanno sequenza di valori non attendibili. Nel primo caso d_ultimo è pari a 1331.652, d_primo è 1331.500, seq_non_att è pari a 1 e quindi index potrà valere soltanto 1. Il valore d_interp sarà quindi pari a 1331.576

Soluzione: download sorgente

Scrivere un programma in linguaggio C che, letti da tastiera 10 numeri float, stampi:

• la media dei valori (float)
• ciascun valore con a fianco la sua differenza rispetto alla media, i valori devono essere visualizzati in ordine inverso rispetto a quello di acquisizione

Esempio: se si introducono nell’ordine i valori:

4.1  2.0  2.9  4.8  5.2  2.8  7.3  1.7  9.0  1.5

Il programma deve stampare:

 Media = 4.13 1.5        -2.63 9.0         4.87 1.7        -2.43 ...         ... 4.1        -0.03 

Soluzione (download sorgente)

 #include <stdio.h> #define FNUMS 10 int main(void) { 	int i; 	float media, totale = 0; 	float farray[FNUMS]; 	for (i = 0; i < FNUMS; i++) { 		scanf("%f", &farray[i]); 		totale += farray[i]; 	} 	media = totale * 1.0 / FNUMS; 	printf("Media = %.2f\n\n", media); 	for (i = (FNUMS - 1); i >= 0; i--) 		printf("%.1f\t\t% .2f\n",                         farray[i], farray[i] - media); 	return 0; } 

Download sorgente

 /*  * Prendete in input un intero contenente soltanto  * degli 0 e degli 1, ovvero un intero "binario",  * e visualizzate il suo equivalente decimale.  * (Suggerimento: per prelevare le cifre del numero  * "binario" una per volta da destra a sinistra,  * utilizzate gli operatori di divisione e di modulo.  * Nel sistema numerico decimale, la cifra piu' a  * destra ha un valore posizionale di 1 e quelle che  * si susseguono a sinistra hanno un valore posizionale  * di 10, poi 100, poi 1000, ecc; allo stesso modo,  * nel sistema numerico binario, la cifra piu' a  * destra ha un valore posizionale di 1 e quelle che  * si susseguono a sinistra hanno un valore posizionale  * di 2, poi 4, poi 8, ecc.  * Di conseguenza il numero 234 potra essere  * interpretato come 4 * 1 + 3 * 10 + 2 * 100.  * L'equivalente decimale del binario 1101 sara'  * 1 * 1 + 0 * 2 + 1 * 4 + 1 * 8 ovvero 1 + 0 + 4 + 13  * ovvero 13).  *  */ #include <stdio.h> #define BASE 2 int main(void) {     unsigned int base = BASE;     unsigned int n, nb;     unsigned int cifra;     unsigned int n10 = 0;   /* valore in base 10  */     unsigned int peso = 1;  /* peso della cifra   */     printf("Inserire il numero in base %u: ", base);     scanf("%u", &n);     nb = n;     while (nb > 0) { 	cifra = nb % 10; /* LSB, cifra a destra */ 	/* controllo che la cifra appartenga alla base */ 	if (cifra > BASE - 1) { 	    printf("Numero non in base %u!\n", base); 	    return 1; 	} 	n10 = n10 + cifra * peso; 	peso = peso * base; 	/* scarta la cifra piu' a destra */ 	nb = nb / 10;     }     printf("(%u)_%u = (%u)_10\n", n, base, n10);     return 0; }