10 esercizi strutturati in ordine di difficoltà crescente, focalizzati sulla manipolazione di variabili, array e matrici (array 2D).

In due linguaggi diversi.

In sintesi, C++ e JavaScript differiscono profondamente per tipologia, esecuzione e gestione della memoria: il C++ è un linguaggio compilato, a tipizzazione statica (il tipo di variabile deve essere dichiarato a priori), che offre un controllo manuale e a basso livello della memoria (tramite puntatori) ed è progettato per applicazioni di sistema ad altissime prestazioni; JavaScript, al contrario, è un linguaggio interpretato (o compilato JIT, Just In Time) a tipizzazione dinamica (una variabile può cambiare tipo durante l'esecuzione), nato originariamente per il web, che gestisce la memoria in modo automatico tramite un garbage collector, garantendo così un'estrema flessibilità e facilità di scrittura a discapito del controllo granulare sull'hardware.

PS: nessuno di questi frammenti di codice funziona con il semplice copia-incolla. Manca il contesto, in entrambi i linguaggi: come posso costruire un "template" per farli funzionare?

---

Esercizio 1: Lo Scambio (Swap) di Variabili

• Task specifico: Scambiare il valore di due variabili scalari.
• Gestione variabili: L'accento è sull'uso di una variabile temporanea d'appoggio (temp) per non perdere il dato originale durante la sovrascrittura.

C++

void swapVariables() {
    int a = 5;
    int b = 10;
    
    int temp = a; // Salviamo il valore di 'a'
    a = b;        // Sovrascriviamo 'a'
    b = temp;     // Assegniamo a 'b' il valore salvato
}

JavaScript

function swapVariables() {
    let a = 5;
    let b = 10;
    
    let temp = a; 
    a = b;        
    b = temp;     
    // Nota JS moderna: si può fare anche con destrutturazione: [a, b] = [b, a];
}

---

Esercizio 2: L'Accumulatore (Somma Array)

• Task specifico: Calcolare la somma di tutti gli elementi di un array monodimensionale.
• Gestione variabili: Focus sulla variabile "accumulatore" (somma), che deve essere rigorosamente inizializzata a 0 prima di entrare nel ciclo.

C++

int sommaArray(int arr[], int size) {
    int somma = 0; // Inizializzazione fondamentale
    for(int i = 0; i < size; i++) {
        somma += arr[i]; // Accumulo progressivo
    }
    return somma;
}

JavaScript

function sommaArray(arr) {
    let somma = 0; // Variabile accumulatore
    for(let i = 0; i < arr.length; i++) {
        somma += arr[i];
    }
    return somma;
}

---

Esercizio 3: Tracker di Stato (Min e Max in Array)

• Task specifico: Trovare il valore minimo e massimo in un array.
• Gestione variabili: Le variabili di stato (min e max) non vanno inizializzate a 0, ma al primo elemento dell'array per evitare bug con array di numeri interamente negativi.

C++

void trovaMinMax(int arr[], int size) {
    int min = arr[0]; // Tracking basato sul primo elemento
    int max = arr[0];

    for(int i = 1; i < size; i++) {
        if(arr[i] < min) min = arr[i];
        if(arr[i] > max) max = arr[i];
    }
}

JavaScript

function trovaMinMax(arr) {
    let min = arr[0];
    let max = arr[0];

    for(let i = 1; i < arr.length; i++) {
        if(arr[i] < min) min = arr[i];
        if(arr[i] > max) max = arr[i];
    }
}

---

Esercizio 4: Convergenza (Inversione Array In-Place)

• Task specifico: Invertire l'ordine degli elementi di un array senza crearne uno nuovo (in-place).
• Gestione variabili: Gestione simultanea di due variabili indice (left e right) che convergono verso il centro dell'array.

C++

void reverseArray(int arr[], int size) {
    int left = 0;
    int right = size - 1;
    
    while(left < right) {
        // Swap usando variabile temp
        int temp = arr[left];
        arr[left] = arr[right];
        arr[right] = temp;
        
        left++;  // Avanza
        right--; // Indietreggia
    }
}

JavaScript

function reverseArray(arr) {
    let left = 0;
    let right = arr.length - 1;
    
    while(left < right) {
        let temp = arr[left];
        arr[left] = arr[right];
        arr[right] = temp;
        
        left++;
        right--;
    }
}

---

Esercizio 5: Ottimizzazione Indici (Diagonale Matrice)

• Task specifico: Sommare gli elementi sulla diagonale principale di una matrice quadrata.
• Gestione variabili: Invece di usare due cicli annidati, si usa una singola variabile indice i sia per la riga che per la colonna (matrice[i][i]), ottimizzando le variabili in memoria.

C++

int sommaDiagonale(int matrice[][3], int size) {
    int somma = 0;
    for(int i = 0; i < size; i++) {
        somma += matrice[i][i]; // Unico indice per riga e colonna
    }
    return somma;
}

JavaScript

function sommaDiagonale(matrice) {
    let somma = 0;
    for(let i = 0; i < matrice.length; i++) {
        somma += matrice[i][i];
    }
    return somma;
}

Esercizio 6: Trasposizione Semplice

• Task specifico: Scambiare righe con colonne.
• Gestione variabili: Creazione di una nuova matrice con indici invertiti rispetto alla sorgente.

C++

int mat[2][2] = {{1,2},{3,4}}, trasposta[2][2];
for(int i=0; i<2; i++)
    for(int j=0; j<2; j++) trasposta[j][i] = mat[i][j];

JavaScript

let mat = [[1,2], [3,4]], trasposta = [[0,0], [0,0]];
for(let i=0; i<2; i++)
    for(let j=0; j<2; j++) trasposta[j][i] = mat[i][j];

---

Esercizio 7: Contatori Indipendenti (Pari/Dispari)

• Task specifico: Dividere i numeri di una matrice in due array.
• Gestione variabili: Due contatori (p e d) per tenere traccia della posizione nei due array di destinazione.

C++

int mat[2][2] = {{1,2},{3,4}}, pari[4], dispari[4], p=0, d=0;
for(int i=0; i<2; i++) {
    for(int j=0; j<2; j++) {
        if(mat[i][j] % 2 == 0) pari[p++] = mat[i][j];
        else dispari[d++] = mat[i][j];
    }
}

JavaScript

let mat = [[1,2], [3,4]], pari = [], dispari = [];
mat.flat().forEach(v => v % 2 === 0 ? pari.push(v) : dispari.push(v));

---

Esercizio 8: Ricerca con Flag

• Task specifico: Trovare un numero in una matrice e fermarsi subito.
• Gestione variabili: Variabile booleana trovato per interrompere l'esecuzione dei cicli annidati.

C++

int mat[2][2] = {{5,8},{3,6}}, target = 8;
bool trovato = false;
for(int i=0; i<2 && !trovato; i++)
    for(int j=0; j<2 && !trovato; j++)
        if(mat[i][j] == target) trovato = true;

JavaScript

let mat = [[5,8], [3,6]], target = 8, trovato = false;
for(let r of mat) {
    if(r.includes(target)) { trovato = true; break; }
}

---

Esercizio 9: Moltiplicazione (Prodotto Scalare)

• Task specifico: Moltiplicare due matrici 2x2.
• Gestione variabili: Un accumulatore somma che viene azzerato per ogni cella della matrice risultante.

C++

int A[2][2] = {{1,2},{3,4}}, B[2][2] = {{5,6},{7,8}}, C[2][2];
for(int i=0; i<2; i++) {
    for(int j=0; j<2; j++) {
        int somma = 0;
        for(int k=0; k<2; k++) somma += A[i][k] * B[k][j];
        C[i][j] = somma;
    }
}

JavaScript

let A = [[1,2],[3,4]], B = [[5,6],[7,8]], C = [[0,0],[0,0]];
for(let i=0; i<2; i++) {
    for(let j=0; j<2; j++) {
        for(let k=0; k<2; k++) C[i][j] += A[i][k] * B[k][j];
    }
}

---

Esercizio 10: Punto di Sella (Complesso + Colore)

• Task specifico: Trovare il minimo di una riga che è anche il massimo della sua colonna.
• Gestione variabili: Salvataggio dell'indice di colonna del minimo riga per il controllo verticale.

C++ (Uso dei codici ANSI per il colore nel terminale)

#include <iostream>
int m[2][2] = {{5, 8}, {3, 6}}; // 5 è minimo riga, ma non massimo colonna.
for(int i=0; i<2; i++) {
    int minR = m[i][0], col = 0;
    for(int j=1; j<2; j++) if(m[i][j] < minR) { minR = m[i][j]; col = j; }
    
    bool sella = true;
    for(int k=0; k<2; k++) if(m[k][col] > minR) sella = false;
    
    if(sella) // \033[32m è il verde, \033[0m resetta
        std::cout << "\033[32mSella: " << minR << "\033[0m" << std::endl;
}

JavaScript (Uso dello stile CSS nel log del browser)

let m = [[5, 8], [3, 6]];
for(let i=0; i<2; i++) {
    let minR = Math.min(...m[i]), col = m[i].indexOf(minR);
    let sella = m.every(r => r[col] <= minR);
    
    if(sella) // %c applica lo stile passato come secondo argomento
        console.log("%cSella: " + minR, "color: green; font-weight: bold;");
}

---

Spiegazione passaggi chiave

1. Inizializzazione: Creazione dello spazio in memoria.
2. Scansione: Ciclo attraverso gli indici per leggere i dati.
3. Logica di Controllo: Uso di if per decidere se la variabile deve essere aggiornata.
4. Output: Restituzione del risultato con formattazione visiva (colore).