rinomina esercizi js

javascript/04_Iterazioni/esercizi/conta_pari.js

@@ -0,0 +1,13 @@
+/**
+ * Esercizio: Conta i Pari
+ * 
+ * Descrizione:
+ * Vogliamo calcolare la somma di tutti i numeri PARI compresi tra 0 e 20.
+ * 
+ * Istruzioni:
+ * 1. Crea una variabile `totalePari` inizializzata a 0.
+ * 2. Scrivi un ciclo for che va da 0 a 20.
+ * 3. Usa un `if` dentro il ciclo per controllare se il numero è pari (numero % 2 === 0).
+ * 4. Se è pari, aggiungilo a `totalePari`.
+ * 5. Stampa il risultato finale.
+ */

javascript/04_Iterazioni/esercizi/debug_loop_stringa.js

@@ -0,0 +1,20 @@
+/**
+ * Esercizio (DEBUG): La Stringa Fantasma
+ * 
+ * Descrizione:
+ * Il seguente codice dovrebbe stampare una linea composta da 10 trattini "-".
+ * Dovrebbe dire "Sto aggiungendo un trattino..." dieci volte, una per ogni trattino aggiunto.
+ * Invece stampa una sola volta il messaggio ed un solo trattino alla fine. Perché?
+ * 
+ * Obiettivo:
+ * 1. Analizza l'uso delle parentesi graffe e lo scope delle variabili.
+ * 2. Correggi il codice affinché stampi "----------".
+ */
+
+let linea = "";
+
+for (let i = 0; i < 10; i++);
+    console.log("Sto aggiungendo un trattino...");
+    linea = linea + "-";
+
+console.log("Risultato finale: " + linea);

javascript/04_Iterazioni/esercizi/potenze_due.js

@@ -0,0 +1,14 @@
+/**
+ * Esercizio: Generatore di Potenze
+ * 
+ * Descrizione:
+ * Stampa le potenze di 2 finché il risultato non supera 1000.
+ * (Es: 2, 4, 8, 16, 32...)
+ * 
+ * Istruzioni:
+ * 1. Crea una variabile `numero` inizializzata a 2.
+ * 2. Usa un ciclo `while` con la condizione che `numero` sia minore di 1000.
+ * 3. Dentro il ciclo:
+ * - Stampa `numero`.
+ * - Moltiplica `numero` per 2.
+ */

javascript/04_Iterazioni/extra/debug_nested_reset.js

@@ -0,0 +1,26 @@
+/**
+ * Esercizio Extra (DEBUG): Il Triangolo Fallito
+ * 
+ * Descrizione:
+ * Vogliamo disegnare un triangolo rettangolo di numeri:
+ * 1
+ * 12
+ * 123
+ * 1234
+ * 12345
+ * 
+ * Il codice attuale stampa qualcosa di molto diverso e confuso. Sembra che i numeri continuino a crescere senza ripartire correttamente.
+ * 
+ * Obiettivo:
+ * Trova l'errore logico nella gestione della variabile stringa. 
+ */
+
+let riga = "";
+
+for (let i = 1; i <= 5; i++) {
+    riga += i;
+    for (let j = 1; j <= i; j++) {
+        riga += j;
+    }
+    console.log(riga);
+}

javascript/04_Iterazioni/extra/disegna_quadrato.js

@@ -0,0 +1,22 @@
+/**
+ * Esercizio Extra: Il Quadrato Vuoto
+ * 
+ * Descrizione:
+ * Disegna un quadrato 5x5, ma VUOTO all'interno.
+ * Devi usare cicli annidati e logica condizionale.
+ * 
+ * Output Desiderato:
+ * █████
+ * █   █
+ * █   █
+ * █   █
+ * █████
+ *  
+ * Logica Suggerita:
+ * 1. Ciclo esterno (righe) da 1 a 5.
+ * 2. Ciclo interno (colonne) da 1 a 5.
+ * 3. Se siamo nella prima riga, nell'ultima riga, nella prima colonna o nell'ultima colonna -> stampa "█".
+ * 4. Altrimenti -> stampa " " (spazio).
+ * 5. Costruisci ogni riga in una variabile stringa e stampala alla fine del ciclo interno.
+ * Nota: il carattere "█" può essere copiato oppure generato con ALT+219.
+ */

javascript/04_Iterazioni/extra/sequenza_fibonacci.js

@@ -0,0 +1,17 @@
+/**
+ * Esercizio Extra: Fibonacci (Senza Array)
+ * 
+ * Descrizione:
+ * La sequenza di Fibonacci inizia con 0 e 1. Ogni numero successivo è la somma dei due precedenti.
+ * 0, 1, 1, 2, 3, 5, 8, 13, 21...
+ * 
+ * Obiettivo:
+ * Stampa i primi 15 numeri della sequenza di Fibonacci usando solo variabili e un ciclo.
+ * NON usare array.
+ * 
+ * Ti serviranno 3 variabili:
+ * - `a` (il numero due passi fa)
+ * - `b` (il numero precedente)
+ * - `temp` (per calcolare il nuovo numero)
+ * Ad ogni giro, devi aggiornare `a` e `b` facendo "scorrere" i valori.
+ */

javascript/04_Iterazioni/extra2/calcolo_fattoriale.js

@@ -0,0 +1,14 @@
+/**
+ * Esercizio Intermedio: Il Fattoriale
+ * 
+ * Descrizione:
+ * In matematica, il fattoriale di un numero n è il prodotto di tutti i numeri interi positivi minori o uguali a n.
+ * Esempio: 5! = 5 * 4 * 3 * 2 * 1 = 120.
+ * 
+ * Istruzioni:
+ * 1. Definisci una variabile `numero` (es. 5).
+ * 2. Definisci una variabile `fattoriale` inizializzata a 1.
+ * 3. Usa un ciclo for che va da `numero` fino a 1 (contando all'indietro).
+ * 4. Ad ogni giro, moltiplica `fattoriale` per il contatore del ciclo.
+ * 5. Stampa il risultato finale.
+ */

javascript/04_Iterazioni/extra2/debug_ciclo_infinito.js

@@ -0,0 +1,18 @@
+/**
+ * Esercizio Intermedio (DEBUG): Il Ciclo Infinito
+ * 
+ * Descrizione:
+ * Il seguente codice dovrebbe stampare i numeri da 10 a 15.
+ * Invece, se lo esegui, non si ferma mai (o crasha il browser/terminale).
+ * 
+ * Obiettivo:
+ * 1. Identifica perché la condizione del while rimane sempre vera.
+ * 2. Aggiungi l'istruzione mancante per far avanzare il ciclo.
+ */
+
+let contatore = 10;
+
+while (contatore <= 15) {
+    console.log("Numero: " + contatore);
+    // C'è un errore qui: manca qualcosa!
+}

javascript/04_Iterazioni/extra2/debug_media_voti.js

@@ -0,0 +1,19 @@
+/**
+ * Esercizio Intermedio (DEBUG): Calcolatrice di Media
+ * 
+ * Descrizione:
+ * Vogliamo calcolare la somma dei voti per poi fare la media.
+ * I voti sono simulati: vogliamo sommare i numeri 10, 20, 30.
+ * Il risultato atteso è 60.
+ * 
+ * Il codice attuale restituisce "0102030". Perché?
+ */
+
+let somma = "0";
+
+for (let i = 1; i <= 3; i++) {
+    let voto = i * 10; // Genera 10, 20, 30
+    somma = somma + voto;
+}
+
+console.log("Somma totale: " + somma);

javascript/04_Iterazioni/extra2/piano_risparmio.js

@@ -0,0 +1,17 @@
+/**
+ * Esercizio Intermedio: Il Piano di Risparmio
+ * 
+ * Descrizione:
+ * Vogliamo comprare una console che costa 300 euro.
+ * Partiamo con 0 euro nel salvadanaio.
+ * Ogni settimana riusciamo a mettere da parte 40 euro.
+ * 
+ * Istruzioni:
+ * 1. Crea variabili per `risparmi` (0) e `settimane` (0).
+ * 2. Usa un ciclo `while` che continua finché `risparmi` è minore di 300.
+ * 3. Dentro il ciclo:
+ * - Aggiungi 40 ai `risparmi`.
+ * - Aumenta `settimane` di 1.
+ * - (Opzionale) Stampa lo stato corrente.
+ * 4. Alla fine, stampa quante settimane sono state necessarie.
+ */

javascript/04_Iterazioni/extra2/somma_alternata.js

@@ -0,0 +1,16 @@
+/**
+ * Esercizio Intermedio: La Somma Alternata
+ * 
+ * Descrizione:
+ * Vogliamo calcolare una somma particolare basata su un numero limite (es. 5).
+ * La logica è: 1 - 2 + 3 - 4 + 5...
+ * Se il numero è dispari lo sommiamo, se è pari lo sottraiamo.
+ * 
+ * Istruzioni:
+ * 1. Crea una variabile `limite` impostata a 10.
+ * 2. Crea una variabile `totale` impostata a 0.
+ * 3. Scrivi un ciclo for da 1 a `limite`.
+ * 4. Se il numero `i` è pari (i % 2 === 0), SOTTRAILO a `totale`.
+ * 5. Altrimenti (se è dispari), AGGIUNGILO a `totale`.
+ * 6. Stampa il risultato finale.
+ */

javascript/04_Iterazioni/extra2/somma_intervallo.js

@@ -0,0 +1,13 @@
+/**
+ * Esercizio Intermedio: Somma Intervallo
+ * 
+ * Descrizione:
+ * Calcola la somma di tutti i numeri compresi tra due variabili: `min` e `max`.
+ * 
+ * Istruzioni:
+ * 1. Definisci `min` = 5 e `max` = 10.
+ * 2. Definisci una variabile `somma` a 0.
+ * 3. Usa un ciclo for che parte da `min` e arriva a `max` (incluso).
+ * 4. Aggiungi il valore corrente a `somma`.
+ * 5. Stampa il risultato finale (Dovrebbe fare 5+6+7+8+9+10 = 45).
+ */

javascript/04_Iterazioni/extra3/debug_accumulatore_errato.js

@@ -0,0 +1,19 @@
+/**
+ * Esercizio Extra (DEBUG): Accumulatore Smemorato
+ * 
+ * Descrizione:
+ * Vogliamo calcolare la somma dei numeri da 1 a 3 per 3 volte e stampare il totale complessivo.
+ * Il calcolo dovrebbe essere: (1+2+3) + (1+2+3) + (1+2+3) = 6 + 6 + 6 = 18.
+ */
+
+for (let giro = 1; giro <= 3; giro++) {
+    let sommaTotale = 0;
+
+    console.log("Inizio giro " + giro);
+
+    for (let numero = 1; numero <= 3; numero++) {
+        sommaTotale = sommaTotale + numero;
+    }
+}
+
+console.log("Totale finale: ", sommaTotale);

javascript/04_Iterazioni/extra3/debug_nested_variable.js

@@ -0,0 +1,19 @@
+/**
+ * Esercizio Extra (DEBUG): Conflitto di Variabili
+ * 
+ * Descrizione:
+ * Vogliamo stampare una griglia 3x3 di asterischi.
+ * Il programmatore ha fatto copia-incolla e ora il codice non funziona più come previsto.
+ */
+
+const DIMENSIONE = 3;
+
+for (let i = 0; i < DIMENSIONE; i++) {
+    let riga = "";
+
+    for (i = 0; i < DIMENSIONE; i++) {
+        riga += "*";
+    }
+    
+    console.log(riga);
+}

javascript/04_Iterazioni/extra3/fizzbuzz_semplice.js

@@ -0,0 +1,13 @@
+/**
+ * Esercizio Extra: Il Gioco del 3 e del 5 (FizzBuzz Semplificato)
+ * 
+ * Descrizione:
+ * Scrivi un ciclo che stampi i numeri da 1 a 20.
+ * TUTTAVIA:
+ * - Se il numero è multiplo di 3, stampa "Fizz" AL POSTO del numero.
+ * - Se il numero è multiplo di 5, stampa "Buzz" AL POSTO del numero.
+ * - Altrimenti stampa il numero normale.
+ * 
+ * Suggerimento:
+ * Usa l'operatore modulo (%) per capire se è multiplo.
+ */

javascript/04_Iterazioni/extra3/scacchiera.js

@@ -0,0 +1,18 @@
+/**
+ * Esercizio Extra: La Scacchiera Alternata
+ * 
+ * Descrizione:
+ * Disegna una scacchiera 4x4 dove i simboli si alternano.
+ * 
+ * Output Desiderato:
+ * X O X O
+ * O X O X
+ * X O X O
+ * O X O X
+ * 
+ * Logica Suggerita:
+ * 1. Due cicli annidati (righe e colonne).
+ * 2. La somma degli indici (riga + colonna) ti dice se sei in una casella "pari" o "dispari".
+ * 3. Se (riga + colonna) è pari -> aggiungi "X".
+ * 4. Altrimenti -> aggiungi "O".
+ */

javascript/04_Iterazioni/extra3/triangolo_rettangolo.js

@@ -0,0 +1,19 @@
+/**
+ * Esercizio Extra: Il Triangolo Pieno
+ * 
+ * Descrizione:
+ * Disegna un triangolo rettangolo usando gli asterischi.
+ * 
+ * Output Desiderato (per altezza 5):
+ * *
+ * **
+ * ***
+ * ****
+ * *****
+ * 
+ * Logica:
+ * 1. Ciclo esterno (i) da 1 a 5.
+ * 2. Ciclo interno (j) da 1 a i (nota: il limite dipende da i!).
+ * 3. Accumula gli asterischi in una variabile stringa.
+ * 4. Stampa la riga e resetta la stringa per il prossimo giro.
+ */

javascript/04_Iterazioni/extra3/verifica_numero_primo.js

@@ -0,0 +1,16 @@
+/**
+ * Esercizio Extra: Verifica Numero Primo
+ * 
+ * Descrizione:
+ * Un numero primo è un numero divisibile SOLO per 1 e per se stesso (es. 7, 11, 13).
+ * Vogliamo scoprire se un numero dato è primo o no usando un ciclo.
+ * 
+ * Istruzioni:
+ * 1. Definisci una variabile `numeroDaControllare` (es. 17).
+ * 2. Crea una variabile booleana `ePrimo` impostata su `true` all'inizio.
+ * 3. Scrivi un ciclo for che parte da 2 e arriva fino a `numeroDaControllare - 1`.
+ * 4. Se `numeroDaControllare` è divisibile per il contatore `i` (ovvero il resto è 0):
+ * - Imposta `ePrimo` su `false`.
+ * - Usa `break` per uscire subito dal ciclo (abbiamo trovato un divisore, quindi non è primo).
+ * 5. Alla fine, stampa "È primo? " + ePrimo.
+ */

javascript/04_Iterazioni/tutorial_interattivo.js

@@ -0,0 +1,148 @@
+/**
+ * ===========================================
+ * === 1. Il Ciclo While: Ripetizione Condizionale ===
+ * Il 'while' (finché) è il ciclo più "puro". Funziona esattamente come un 'if',
+ * ma continua a ripetere il blocco di codice finché la condizione rimane VERA (true).
+ * È perfetto quando non sappiamo a priori quanti giri dovremo fare.
+ */
+
+let carburante = 10;
+
+// TODO: Scrivi un ciclo while che continua finché 'carburante' è maggiore di 0.
+// Dentro il ciclo:
+// 1. Stampa "Viaggio... Carburante rimasto: " + carburante
+// 2. Diminuisci 'carburante' di 2 (carburante = carburante - 2)
+// NOTA: Se dimentichi di diminuire il carburante, crei un ciclo infinito!
+
+// OUTPUT ATTESO:
+// Viaggio... Carburante rimasto: 10
+// Viaggio... Carburante rimasto: 8
+// ...
+// Viaggio... Carburante rimasto: 2
+
+
+
+/**
+ * ===========================================
+ * === 2.A Il Ciclo For: Ripetizione Controllata ===
+ * Il ciclo 'for' è una scorciatoia del while usata quando sappiamo ESATTAMENTE
+ * quante volte ripetere un'azione (es. "conta da 1 a 5").
+ *
+ * Sintassi: for (inizializzazione; condizione; incremento) { ... }
+ * Esempio:  for (let i = 1; i <= 5; i++)       { ... }
+ */
+
+// TODO: Scrivi un ciclo for che stampi la frase "Giro numero X" per 5 volte (da 1 a 5).
+// Usa la variabile 'i' come contatore.
+
+// OUTPUT ATTESO:
+// Giro numero 1
+// Giro numero 2
+// Giro numero 3
+// Giro numero 4
+// Giro numero 5
+
+
+
+/**
+ * ===========================================
+ * === 2.B Il Ciclo For: Il Conto alla Rovescia ===
+ * I cicli for non devono per forza contare in avanti (1, 2, 3...).
+ * Possono contare all'indietro usando il decremento (i--).
+ */
+
+// TODO: Scrivi un ciclo for che parte da 5 e arriva a 1 (compreso).
+// La condizione deve essere 'maggiore o uguale a 1'.
+// Ad ogni giro, DECREMENTA la variabile (i--).
+// Stampa il valore di i.
+
+// OUTPUT ATTESO:
+// 5
+// 4
+// 3
+// 2
+// 1
+
+
+
+/**
+ * ===========================================
+ * === 3. Costruire una Stringa (Accumulatore di Testo) ===
+ * I cicli sono utilissimi per costruire risultati complessi un pezzo alla volta.
+ * Qui usiamo una stringa vuota e aggiungiamo pezzi ad ogni giro.
+ */
+
+let scia = "";
+
+// TODO: Scrivi un ciclo for che gira 10 volte.
+// Ad ogni giro, aggiungi un asterisco "*" alla variabile 'scia'.
+// Alla fine del ciclo, stampa 'scia' (una volta sola).
+
+// OUTPUT ATTESO:
+// **********
+
+
+
+/**
+ * ===========================================
+ * === 4. Somma Numerica (Accumulatore Numerico) ===
+ * Come per le stringhe, possiamo accumulare numeri.
+ * Questo è il concetto base per calcolare somme, medie, bilanci, ecc.
+ */
+
+let sommaTotale = 0;
+
+// TODO: Scrivi un ciclo for che va da 1 a 10.
+// Aggiungi il valore del contatore (i) alla variabile 'sommaTotale'.
+// Stampa il risultato SOLO alla fine del ciclo.
+
+// OUTPUT ATTESO:
+// 55  (perché 1+2+3+4+5+6+7+8+9+10 fa 55)
+
+
+
+/**
+ * ===========================================
+ * === 5. Cicli Annidati (Loop dentro Loop) ===
+ * Possiamo mettere un ciclo dentro un altro.
+ * Per ogni SINGOLO giro del ciclo esterno, quello interno viene eseguito TUTTO.
+ * È come l'orologio: per ogni ora (ciclo esterno), i minuti (ciclo interno) fanno un giro completo.
+ */
+
+// TODO: Completa il codice per stampare le coordinate.
+// Usa due cicli for annidati.
+// Il ciclo esterno usa 'x' (da 1 a 2).
+// Il ciclo interno usa 'y' (da 1 a 3).
+// Stampa: "x: " + x + " - y: " + y
+
+// OUTPUT ATTESO:
+// x: 1 - y: 1
+// x: 1 - y: 2
+// x: 1 - y: 3
+// x: 2 - y: 1
+// x: 2 - y: 2
+// x: 2 - y: 3
+
+
+/**
+ * ===========================================
+ * === 6. Break e Continue (Controllo del Flusso) ===
+ * A volte vogliamo alterare il comportamento normale del ciclo:
+ * - 'break': Interrompe il ciclo immediatamente (esce dalle graffe).
+ * - 'continue': Salta SOLO il giro corrente e passa subito al successivo.
+ */
+
+// TODO: Scrivi un ciclo for da 1 a 10.
+// Se il numero è 5, usa 'continue' (saltalo, non stamparlo).
+// Se il numero è 8, usa 'break' (ferma tutto il ciclo).
+// In tutti gli altri casi: Stampa il numero.
+
+// OUTPUT ATTESO:
+// 1
+// 2
+// 3
+// 4
+// 6  <-- nota che manca il 5
+// 7
+// (l'8 e i successivi non ci sono perché abbiamo rotto il ciclo)
+