Esercizi svolti di C++ perfettamente funzionanti, tutto ciò che serve per superare facilmente lo scritto di elementi di programmazione

CONTENENTE LA PAROLA, E INCREMENTO Z

77: PER OGNI LETTERA CORRISPONDENTE IN

SEQUENZA Z E' AUMENTATO DI 1 UNITA' ALLA

FINE DELLA RICERCA DEL CICLO M

78: SE Z E' PROPRIO UGUALE ALLA LUNGHEZZA DEL

VETTORE PAROLA, VUOL DIRE CHE LA PAROLA E'

STATA TROVATA */

79: void ricerca_colonne (char* mat, int* x,

int* y, int* tot, char* par, int* l)

80: {

81: int z=0;

82: int m=0;

83: for (int i=0; i<*x; i++)

84: {

85: for (int j=0; j<*y; j++)

86: {

87: m=0;

88: if (*(mat + i*(*x) + j) ==

*(par+m) && i+*l<*x)

89: {

90: for (m=0;m<*l;m++)

91: {

92: if (tolower(*(mat +

(i+m)*(*x) + j))==tolower(*(par+m)))

93: {

94: z++;

95: }

96: }

97: if(z==*l)

98: {

99: *tot = (*tot+1);

100: }

101: z=0;

102: }

103: }

104: }

105: }

106:

107: void ricerca_diagonali (char* mat, int* x,

int* y, int* tot, char* par, int* l)

108: {

109: int z=0;

110: int m=0;

111: for (int i=0; i<*x; i++)

112: {

113: for (int j=0; j<*y; j++)

114: {

115: m=0;

116: if (*(mat + i*(*x) + j) ==

*(par+m) && j+*l<*y)

117: {

118: for (m=0;m<*l;m++)

119: {

120: if (tolower(*(mat +

(i+m)*(*x) + (j+m)))==tolower(*(par+m)))

121: {

122: z++;

123: }

124: }

125: if(z==*l)

126: {

127: *tot = (*tot+1);

128: }

129: z=0;} }}}

1: //scambio riga con una colonna

2: #include<iostream>

3: using namespace std;

4: int leggi_matrice_e_stampa(int dimensione,

int*matrice);

5: int scambio_matrice(int righe,int colonne,

int dimensione,int*matrice);

6: int stampa_matrice(int dimensione,

int*matrice);

7:

8: int main()

9: {

10: int righe,colonne,dimensione;

11: cout<<"che dimensione vuoi che abbia la

tua matrice?? --->";

12: cin>>dimensione;

13: cout<<endl<<endl;

14: int matrice[righe][colonne];

15: leggi_matrice_e_stampa(dimensione,

&matrice[0][0]);

16: cout<<"inserisci la riga da scambiare --

->";

17: cin>>righe;

18: cout<<endl<<"inserisci la colonna da

cambiare --->";

19: cin>>colonne;

20: cout<<endl<<endl;

21: scambio_matrice(righe,colonne,

dimensione,&matrice[0][0]);

22: stampa_matrice(dimensione,

&matrice[0][0]);

23:

24: system("pause");

25: return 0;

26: }

27:

28: int leggi_matrice_e_stampa(int dimensione,

int*matrice)

29: {

30: for(int i=0;i<dimensione;i++)

31: {

32: for(int j=0;j<dimensione;j++)

33: {

34: cout<<"inserisci l'elemento

nella "<<i+1<<" riga e nella "<<j+1<<

colonna --->";

35: cin>>*(matrice+i*dimensione+j);

36: }

37:

38: }

39: cout<<endl<<endl;

40: for(int i=0;i<dimensione;i++)

41: {

42: for(int j=0;j<dimensione;j++)

43: cout<<*(matrice+i*dimensione+j)<<"\t";

44: cout<<endl<<endl;

45: }

46: return 0;

47: }

48:

49: int scambio_matrice(int righe,int colonne,

int dimensione,int*matrice)

50: {

51: int temp;

52: for(int i=0;i<dimensione;i++)

53: {

54: temp=*(matrice+righe*dimensione+i);

55: *(matrice+righe*dimensione+i)=*(matrice+i*dimensio

56: *(matrice+i*dimensione+colonne)=temp;

57: }

58: return 0;

59:

60: }

61:

62: int stampa_matrice(int dimensione,

int*matrice)

63: {

64: for(int i=0;i<dimensione;i++)

65: {

66: for(int j=0;j<dimensione;j++)

67: cout<<*(matrice+i*dimensione+j)<<"\t";

68: cout<<endl<<endl;

69: }

70: return 0;

71: }

1: /* Il Programma leggerà da schermo una

matrice, calcolerà la riga la cui somma

degli elementi che la compongono è massima

2: e quella la cui somma è minima, per

poi scambiarle tra loro e stampare di

nuovo la matrice con le righe cambiate */

3: #include <iostream>

4: using namespace std;

5:

6: void leggimatrice (int* mat, int r, int

c); /

della matrice

7: void scrivimatrice (int *mat, int r, int

c); /

la marice

8: void scambiarighe (int *mat, int r, int c,

int riga1, int riga2, int *temp);

//Scambia le due righe scelte

9: int sommamax (int *mat, int r, int c);

//Trova la riga con la somma massima

10: int sommamin (int *mat, int r, int c);

//Trova la riga con la somma Minima

11:

12: // rigamax e rigamin sono variabili

GLOBALI, dichiarate fuori da ogni funzione

(sarà possibile utilizzarle in ogni

funzione)

13: int rigamax = 0;

14: int rigamin = 0;

15:

16: int main ()

17: {

18: int r,c;

19: cout<<"***********Matrici***********"<<endl;

20: do {

21: cout<<"Inserisci il numero di

righe della matrice (max 10)"<<endl;

ciclo do while serve a non far inserire

valori non accettabili (<0 o >10)

22: cin>>r;

23: }

24: while (r<0 || r>10);

25:

26: do {

27: cout<<"Inserisci il numero di

colonne della matrice (max 10)"<<endl;

//stesso ragionamento

28: cin>>c;

29: }

30: while (c<0 || c>10);

31:

32: int mat[r][c]; //creo una matrice di

dimensioni date dall'utente

33:

34: leggimatrice (&mat[0][0], r, c); //

Faccio "puntare" il puntatore al primo

elemento della matrice appena creata e

richiamo la funzione leggimatrice

35:

36: cout<<"La matrice inserita e':"<<endl;

37: cout<<endl;

38: scrivimatrice (&mat[0][0], r, c);

39: cout<<endl;

40: sommamax (&mat[0][0], r, c);

41: sommamin (&mat[0][0], r, c);

42: cout<<endl<<"La riga la cui somma e'

minima e' la numero "<<rigamin+1<<endl;

//C++ fa partire gli indici da 0, quindi la

43: cout<<endl<<"La colonna la cui somma

e' massima e' la numero

"<<rigamax+1<<endl;

44: int temp[10]; //creo un vettore per lo

scambio riga colonna. (il procedimento è

simile allo scambio di due variabili)

45: scambiarighe (&mat[0][0], r, c,

rigamax, rigamin, &temp[0]);

funzione scambiarighe

46: cout<<endl;

47: cout<<"La matrice con le righe

scambiate e':"<<endl;

48: scrivimatrice (&mat[0][0], r, c);

//ristampo la nuova matrice

49: }

50:

51: void leggimatrice (int* mat, int r, int c)

52: {

53: for (int i=0; i<r; i++) // i due for

mi gestiscono la lettura della matrice,

indici di riga e di colonna.

54: {

55: for (int j=0; j<c; j++)

56: {

57: cout<<"Inserisci

l'elemento di posto ("<<i<<

"<<j<<")"<<endl;

58: cin>>*(mat + i*c + j);

59: }

60: }

61: }

62:

63: void scrivimatrice (int* mat, int r, int c)

64: {

65: for (int i=0; i<r; i++) //stesso

discorso per la lettura della matrice

66: {

67: cout<<endl;

68: for (int j=0; j<c; j++)

69: {

70: cout<<"\t"<<*(mat +

i*c + j);

71: }

72: }

73: }

74:

75: int sommamax (int *mat, int r, int c)

76: {

77: int somma1=0; // ATTENZIONE: le due

variabili devono essere inizializzate a

zero!

78: int somma2=0; // Es. Se dichiariamo la

variabile somma1 senza inizializzarla

potrebbe esserci dentro già un valore del

tipo: 32030203, invalidando tutte le

operazioni.

79:

80: for (int i=0; i<c; i++)

81: {

82: somma1 = somma1 + *(mat + i);

//sommo i termini della prima riga della ma

83: }

84: for (int j=1; j<r; j++)

85: {

86: for (int i=0; i<c; i++)

87: {

88: somma2 =

somma2 + *(mat + j*c + i);

ciclo, sommando tutti gli elementi delle

righe successive

89: }

90: if (somma2 >

somma1)

la somma delle righe successive è

maggiore di quella già salvata in somma1

entra nel ciclo

91: {

92: somma1

= somma2; //sostituisce somma1 con somma2

93: somma2

= 0;

da poter permettere il controllo sulle

righe successive

94: rigamax = j;

riga) diventa la riga corrispondente alla

nuova riga con la somma maggiore

95: }

96: }

97: return rigamax;

98: }

99:

100: int sommamin (int *mat, int r, int c)

//stesso ragionamento inverso

101: {

102: int somma1=0;

103: int somma2=0;

104:

105: for (int i=0; i<c; i++)

106: {

107: somma1 = somma1 + *(mat +

i);

108: }

109: for (int j=1; j<r; j++)

110: {

111: for (int i=0; i<c; i++)

112: {

113: somma2 = somma2 +

*(mat + j*c + i);

114: }

115: if (somma2 < somma1)

116: {

117: somma1 =

somma2;

118: somma2 = 0;

119: rigamin = j;

120: }

121: }

122:

123: return rigamin;

124: }

125:

126: void scambiarighe (int* mat, int r, int c,

int riga1, int riga2, int *temp)

127: {

128: //la funzione mi scambierà le due

righe

129: for (int j=0; j<c; j++)

130: {

131: *(temp + j) = *(mat + riga1 *

c + j);

rigamax in un vettore puntatore chiamato

temp

132: }

133: for (int i=0; i<c; i++)

134: {

135: *(mat + riga1 *c + i) = *(mat

+ riga2*c + i);

della rigamin nella rigamax

136: }

137: for (int k=0; k<c; k++)

138: {

139: rigamin;

*(mat + riga2*c + k) =

140: }

141: }

1: //somma degli elementi di una matrice

sequenziale

2: #include<iostream>

3: using namespace std;

4:

5: int leggi(int righe,int colonne,int

*matrice);

6: int stampa(int righe,int colonne,int

*matrice);

7: int main()

8: {

9: int righe,colonne;

10: cout<<"quante vuoi che siano le righe? -

-->";

11: cin>>righe;

12: cout<<endl;

13: cout<<"quante vuoi che siano le

colonne? --->";

14: cin>>colonne;

15: cout<<endl<<endl;

16: int matrice[righe] [colonne];

17: leggi(righe,colonne,&matrice[0][0]);

18: stampa(righe,colonne,&matrice[0][0]);

19: cout<<endl<<endl<<endl;

20: int max,min,somma=0;

21: for(int i=0;i<righe;i++)

22: {

23: for(int j=0;j<colonne;j++)

24: {

25: somma=somma+matrice[i][j];

26: cout<<somma<<"\t<<"<<endl<<endl;

27: }

28: }

29: system("pause");

30: return 0;