Esercitazioni di informatica in linguaggio C.

117: V [i+1] = aux;

118: }

119:

120: } //ciclo interno

121: } // ciclo controllore

122: }

1: #include <stdio.h>

2: #include <stdlib.h>

3: #define MAX_N 100

4:

5: int V [MAX_N];

6: int D [MAX_N];

7:

8: void gestioneSequenza (void);

9: int immissione (void);

10: void stampaArray (int);

11: void stampaElemento (int, int);

12: int elementiDispari (int);

13:

14: int main (void) {

15: gestioneSequenza(); //In questo caso il main non fa altro che richiamare la funzione ge

16: }

17:

18: void gestioneSequenza (void) {

19:

20: int scelta = -1; //La variabile scelta è inizializzata a -1 per entrare nel ciclo whil

21: int dimensioneArray;

22: int posizione;

23: int i, k;

24: int dimensioneArraydispari; //Questa variabile contiene la dimensione del vettore cont

25:

26: while (scelta != 0) {

27:

28: printf ("\n *** MENU' ***");

29: printf ("\n 1.Immissione e stampa rovescia.\n");

30: printf ("\n 2.Stampa vettore.\n");

31: printf ("\n 3.Stampa elemento alla posizione...\n");

32: printf ("\n 4.Valori dispari.\n");

33: printf ("\n 0.Esci.\n");

34: printf ("\n *** FINE MENU' ***");

35:

36: printf ("\nScegli un'opzione dal MENU': ");

37: scanf ("%d", &scelta);

38:

39: switch (scelta) {

40:

41: case 1: dimensioneArray = immissione ();

42: printf ("\nAdesso stampo il vettore in maniera inversa.\n");

43: for (i = dimensioneArray - 1; i >= 0; i--) {

44: printf ("\nV[%d]: %d\n", i, V [i]);

45: }

46: break;

47: case 2: stampa (dimensioneArray);

48: break;

49: case 3: printf ("\nInserisci la posizione che desideri stampare: ");

50: scanf ("%d", &posizione);

51: stampaElemento (dimensioneArray, posizione);

52: break;

53: case 4: dimensioneArraydispari = elementiDispari(dimensioneArray);

54: if (dimensioneArraydispari == 0) {

55: printf ("\nNon ci sono numeri dispari in 'V'!\n");

56: }

57: else {

58: printf ("\nCi sono %d numeri dispari.\n", dimensioneArraydispari);

59: printf ("\nFatto! Ora stampo...\n");

60: for ( k = 0; k < dimensioneArraydispari; k++) {

61: printf ("\nElemento dispari n. %d: %d \n", k+1, D [k] );

62: }

63: }

64: break;

65: }//case

66:

67: }//while

68: }

69:

70: int elementiDispari (int dimensioneArray) {

71: int i;

72: int j = 0;

73:

74: for (i = 0; i < dimensioneArray; i++) {

75: if (V [i] %2 != 0) {

76: D [j] = V [i];

77: j++;

78: }

79: }

80: return j;

81: }

82:

83: void stampa (int dimensioneArray) {

84: int i;

85:

86: for (i = 0; i < dimensioneArray; i++) {

87: printf ("\nV [%d]: %d\n", i, V [i]);

88: }

89:

90: }

91:

92: int immissione (void) {

93:

94: int i;

95: int n;

96:

97: do {

98: printf ("\nQuanti elementi desideri inserire? ");

99: scanf ("%d", &n);

100: }

101: while ( n < 1 || n > MAX_N);

102:

103: for ( i = 0; i < n; i++) {

104: printf ("\nInserisci elemento n.%d: ", i);

105: scanf ("%d", &V [i]);

106: }

107:

108: return n;

109: }

110:

111: void stampaElemento (int dimensioneArray, int posizione) {

112: int i;

113:

114: if (posizione >= 0 && posizione <= dimensioneArray) {

115: printf("\nLa posizione %d e' occupata dal numero: %d", posizione, V [posizione]);

116: }

117: else {

118: printf ("\nImmetti una posizione valida!\n");

119: }

120: }

1: #include <stdio.h>

2: #include <stdlib.h>

3: #define MAX_C 30

4: #define MAX_A 100

5:

6: struct data {

7: int giorno;

8: int mese;

9: int anno;

10: };

11:

12: struct studente {

13: char cognome [MAX_C];

14: struct data data_di_nascita;

15: };

16:

17: struct studente alunni [MAX_A];

18:

19:

20: void gestioneSequenza (void);

21: float immissione (void);

22: void stampa (float);

23: void stampaSpecifica (float, int);

24: void natiPrimadel (float);

25: float natiPrimadelRitorno (float);

26: void CreaVettoreEta (float);

27:

28:

29: void gestioneSequenza () {

30:

31: int scelta = -1;

32: float numeroAlunni;

33: int posizione;

34: float numeroAlunniNatiPrima;

35: float divisione;

36:

37: while (scelta != 0) {

38:

39: printf ("\n*** MENU' ***");

40: printf ("\n1. Immissione alunni.\n");

41: printf ("\n2. Stampa elenco alunni.\n");

42: printf ("\n3. Stampa alunno specifico.\n");

43: printf ("\n4. Visualizza numero studenti nati prima del 1998.\n");

44: printf ("\n5. Il numero degli studenti nati prima del 1998 e' maggiore della meta'

45: printf ("\n6. Visualizza elenco eta'.\n");

46: printf ("\n0. Esci.");

47: printf ("\n*** FINE MENU' ***\n");

48: printf ("\nScegli un'opzione dal MENU': ");

49: scanf ("%d", &scelta);

50:

51: switch (scelta) {

52:

53: case 1: numeroAlunni = immissione ();

54: break;

55: case 2: stampa (numeroAlunni);

56: break;

57: case 3: printf ("\nInserisci l'indice dell'array che desideri visualizzare: ")

58: scanf ("%d", &posizione);

59: stampaSpecifica (numeroAlunni, posizione);

60: break;

61: case 4: natiPrimadel (numeroAlunni);

62: break;

63: case 5: numeroAlunniNatiPrima = natiPrimadelRitorno (numeroAlunni);

64: divisione = (numeroAlunni) / 2;

65: if (divisione < numeroAlunniNatiPrima) {

66: printf ("\nSi'!\n");

67: }

68: else {

69: printf ("\nNo!\n");

70: }

71: break;

72: case 6: CreaVettoreEta (numeroAlunni);

73: break;

74: }

75: }

76: }

77:

78: int main(int argc, char *argv[]) {

79: gestioneSequenza();

80: }

81:

82: float immissione () {

83:

84: int n;

85: int i;

86: char invio;

87:

88: do {

89: printf ("\nQuanti studenti desideri inserire? ");

90: scanf ("%d", &n);

91: }

92: while ( n < 1 || n > MAX_A );

93:

94: for ( i = 0; i < n; i++) {

95: printf ("\nInserisci studente n. %d\n", i+1);

96: scanf ("%c", &invio);

97: printf ("\nInserisci il cognome: ");

98: scanf ("%[^\n]", alunni[i].cognome);

99: printf ("\nInserisci la data di nascita\n");

100: printf ("\nGiorno: ");

101: scanf ("%d", &alunni[i].data_di_nascita.giorno);

102: printf ("\nMese: ");

103: scanf ("%d", &alunni[i].data_di_nascita.mese);

104: printf ("\nAnno: ");

105: scanf ("%d", &alunni[i].data_di_nascita.anno);

106: }

107:

108: return(n);

109:

110: }

111:

112: void stampa (float numeroAlunni) {

113:

114: int i;

115:

116: for ( i = 0; i < numeroAlunni; i++) {

117: printf ("\nL'alunno alla posizione %d e' %s nato il %d/%d/%d \n", i+1, alunni[i].co

118: }

119: }

120:

121: void stampaSpecifica (float numeroAlunni, int posizione) {

122:

123: if ( posizione >= 0 & posizione < numeroAlunni) {

124: printf ("\nLa posizione %d e' occupata dall'alunno %s nato il %d/%d/%d \n", posizi

125: }

126: else {

127: printf ("\nLa posizione cercata non esiste!\n");

128: }

129: }

130:

131: void natiPrimadel (float numeroAlunni) {

132:

133: int i;

134: int annoLimite = 1998;

135: int tot = 0;

136:

137: for ( i = 0; i < numeroAlunni; i++) {

138: if (alunni[i].data_di_nascita.anno < annoLimite) {

139: tot++;

140: }

141: }

142: printf ("\nCi sono %d studenti nati prima del %d\n", tot, annoLimite);

143: }

144:

145: float natiPrimadelRitorno (float numeroAlunni) {

146:

147: int i;

148: int annoLimite = 1998;

149: int tot = 0;

150:

151: for ( i = 0; i < numeroAlunni; i++) {

152: if (alunni[i].data_di_nascita.anno < annoLimite) {

153: tot++;

154: }

155: }

156: return tot;

157: }

158:

159: void CreaVettoreEta (float numeroAlunni) {

160: int i;

161: int vettore_anno_nascita [ MAX_A ];

162: int j = 0;

163: int k;

164:

165: for ( i = 0; i < numeroAlunni; i ++) {

166: vettore_anno_nascita[j] = alunni[i].data_di_nascita.anno;

167: j++;

168: }

169:

170: for ( k = 0; k < j; k++) {

171: printf ("\nData di nascita: %d\n", vettore_anno_nascita[k]);

172: }

173: }

#include <stdio.h>

#include <stdlib.h>

#define MAX_NOME 100

#define MAX_COGNOME 100

#define MAX_DOCENTI 100

struct persona {

char nome [MAX_NOME];

char cognome [MAX_COGNOME];

int eta;

};

struct persona docente [MAX_DOCENTI];

int vettore_eta_docenti [MAX_DOCENTI];

void gestioneSequenza (void);

int immissione (void);

void stampa (int);

void stampaSpecifica (int,int);

int docentePiuGrande (int);

void vettoreEtaDocenti (int);

int main(int argc, char *argv[]) {

gestioneSequenza();

}

void gestioneSequenza () {

int scelta = -1;

int dimensioneVettore;

int posizione = 0;

while (scelta != 0) {

printf ("\n***MENU'***");

printf ("\n1. Immissione docenti.\n");

printf ("\n2. Stampa docenti.\n");

printf ("\n3. Stampa docente alla posizione '0'.\ Visualizza docente piu' grande.\n");

printf ("\n4. Trova docente piu' grande.\n");

printf ("\n5. Visualizza eta' docenti.\n");

printf ("\n0. Esci.");

printf ("\n *** FINE MENU' ***\n");

printf ("\nScegli un'opzione dal MENU': ");

scanf ("%d", &scelta);

switch (scelta) {

case 1: dimensioneVettore = immissione ();

break;

case 2: stampa (dimensioneVettore);

break;

case 3: printf ("\nAdesso stampo il docente alla posizione '0'.\n");

stampaSpecifica (dimensioneVettore, posizione);

break;

case 4: printf ("\nAdesso cerco il docente piu' grande di eta'...\n");

posizione = docentePiuGrande (dimensioneVettore);

printf ("\nFatto! Premi '3' per visualizzare!\n");

break;

case 5: vettoreEtaDocenti (dimensioneVettore);

break;

} //case

} //while

}

int immissione () {

int i;

int n;

char invio;