C++ - Elevare al cubo i valori della seconda diagonale

Nel seguente appunto analizzeremo la risoluzione di un esercizio di programmazione in C++. L'esercizio chiede, data in input una matrice di

righe e colonne, di stampare un'ulteriore matrice (delle stesse dimensioni della matrice di partenza) che elevi al cubo i valori della seconda diagonale. Intenderemo la seconda diagonale come la diagonale che va dalla casella più in basso a sinistra alla casella più in alto a destra.

Funzione caricamento matrice

Scriviamo una funzione void caricamento_matrice che permetta all'utente di inserire i valori della tabella in questione. Per fare inserire i valori desiderati dall'utente, saranno necessari due cicli for, il primo iterato sul numero di righe e il secondo iterato sul numero di colonne. Così facendo riusciremo a inserire tutti i valori desiderati. Scriviamo quindi:
void caricamento_matrice(int m[massimo][massimo], int nr, int nc)
{
for (int x=0; x {
for (int y=0; y {
cout cin>>m[x][y];
}
}
}
Per approfondimenti sulle matrici in C++, vedi anche qua.

Funzione stampa matrice

Questa funzione è necessaria per poter stampare i valori contenuti nella matrice

[math] n \times n [/math]

. Ancora una volta bisogna utilizzare due cicli for, sul numero di righe e sul numero di colonne.
void stampa_matrice(int m[massimo][massimo], int nr, int nc)
{
for (int x=0; x {
for (int y=0; y {
cout }
cout }
}
Così facendo saremo in grado di stampare tutte le celle della tabella (o matrice).

Qual è la funzione per elevare la diagonale 2 al cubo?

Bisogna prima di tutto trovare una proprietà comune a tutte le celle che si trovano sulla diagonale 2.
Occorre quindi che gli indici di riga e colonna di una certa casella sommino al numero di righe (e di colonne) meno 1. Infatti se avessimo le caselle della diagonale 2 coinvolte sarebbero .
Se la somma delle coordinate vale

[math] n - 1 [/math]

, bisogna quindi sostituire il valore attuale della matrice con il suo cubo, cioè sostituire

[math] x [/math]

con

[math] x * x * x [/math]

. void cubo(int m[massimo][massimo], int nr, int nc)
{
for (int x=0; x {
for (int y=0; y {
if (x+y==nr-1)
{
m[x][y]=m[x][y]*m[x][y]*m[x][y];
}
}
}
}

Programma principale

Assembliamo il tutto, invocando le funzioni precedentemente create nell'ordine opportuno. Effettueremo le seguenti operazioni:

• Carichiamo la matrice di partenza, stampandola a fine operazione.
• Effettuiamo i calcoli opportuni elevando al cubo i valori della diagonale due.
• Stampiamo la matrice risultato.

int main()
{
int matrice[massimo][massimo];
int righe=dimensione();
int colonne=righe;
cout caricamento_matrice(matrice, righe, colonne);
cout stampa_matrice(matrice, righe, colonne);
cubo(matrice, righe, colonne);
cout stampa_matrice(matrice, righe, colonne);

return 0;
}

Codice intero

Ora possiamo assemblare il tutto per ottenere il codice idoneo all'esecuzione del nostro programma, completo di funzioni e un main() che le esegua nell'opportuno ordine, come esplicitato prima.

// Elevare al cubo i valori della seconda diagonale (matrice)
#include
using namespace std;

// ----- VARIABILI GLOBALI ----- //
const int massimo=100;
// ----- /VARIABILI GLOBALI ----- //

// ----- PROTOTIPI ----- //
int dimensione();
void caricamento_matrice(int [massimo][massimo], int, int);
void stampa_matrice(int [massimo][massimo], int, int);
void cubo(int [massimo][massimo], int, int);
// ----- /PROTOTIPI ----- //

// ----- FUNZIONI ----- //
int dimensione()
{
int n;
cout cin>>n;
while (n>massimo)
{
cout cin>>n;
}

return n;
}

void caricamento_matrice(int m[massimo][massimo], int nr, int nc)
{
for (int x=0; x {
for (int y=0; y {
cout cin>>m[x][y];
}
}
}

void stampa_matrice(int m[massimo][massimo], int nr, int nc)
{
for (int x=0; x {
for (int y=0; y {
cout }
cout }
}

void cubo(int m[massimo][massimo], int nr, int nc)
{
for (int x=0; x {
for (int y=0; y {
if (x+y==nr-1)
{
m[x][y]=m[x][y]*m[x][y]*m[x][y];
}
}
}
}
// ----- /FUNZIONI ----- //

// ----- PROGRAMMA PRINCIPALE ----- //
int main()
{
int matrice[massimo][massimo];
int righe=dimensione();
int colonne=righe;
cout caricamento_matrice(matrice, righe, colonne);
cout stampa_matrice(matrice, righe, colonne);
cubo(matrice, righe, colonne);
cout stampa_matrice(matrice, righe, colonne);

return 0;
}
// ----- /PROGRAMMA PRINCIPALE ----- //

Per ulteriori approfondimenti sui cicli for, vedi anche qua