Main.java

//==========================================
//JAVA EXERCISES BY CLAUDE
//==========================================

// BMI CALCULATOR

/*
public class Main {
    public static void main(String[] args) {
        double peso = 111.0;
        double altezza = 1.72;

        double bmi = peso / (altezza * altezza);
        System.out.printf("BMI: %.2f%n", bmi);

        String categoria;
        if (bmi < 18.5)         categoria = "Sottopeso";
        else if (bmi < 25.0)    categoria = "Normopeso";
        else if (bmi < 30)      categoria = "Sovrappeso";
        else                    categoria = "Obesità";

        System.out.println("Categoria: " + categoria);
    }
}
*/

//============================================
// INTERNAL FOOD COST
//============================================
/*
public class Main {
    public static void main(String[] args) {
        double costoIngredienti = 4.50;
        double prezzoDiVendita = 15.00;

        double foodCostPercentage = (costoIngredienti / prezzoDiVendita) * 100;


        System.out.printf("Food cost percentage: %.2f%%%n", foodCostPercentage);

        ________________________________________________________________________________________________________________
        Il metodo System.out.printf() dove f sta per formatted, consente la creazione
        di stringhe complesse senza ricorrere all'operatore +.
        Invece di unire testo e variabili, definisci un template fisso ed indichi al
        compilatore dove e come inserire i dati dinamici usando dei segnaposto chiamati
        SPECIFICATORI DI FORMATO.
        Qui è dove verrà iniettato il valore della variabile foodCostPercentage.
        % : Annuncia al compilatore l'inizio  di uno specificatore di formato (Format Specifier or Conversion Specifier).
        .2: È il flag di precisione (Precision Specifier). Specifica a quanti decimali fermarsi.
                1) Flag: caratteri opzionali che modificano il comportamento dell' OUTPUT.
                2) Precision : È il numero che definisce il livello di dettaglio del dato.
         f : Sta per floating-point. Comunica che il dato che entra è un numero con virgola.
         %% : Serve a stampare un % nel caso specifico di printf.
         %n : È il ritorno a capo universale.
         _______________________________________________________________________________________________________________


        String redditivita;
        if (foodCostPercentage <= 25.0)      redditivita = "Eccellente";
        else if (foodCostPercentage <= 30.0) redditivita = "Standard";
        else if (foodCostPercentage <= 35.0) redditivita = "Margine a rischio";
        else                                redditivita = "Perdita - Rivedere Pricing";

        System.out.println("Stato redditività: "+ redditivita + ".");

    }
}

*/

/*
// ===================================================================================
// THERMAL CONVERTER
// ===================================================================================

// Scanner serve per leggere gli input da tastiera
import java.util.Scanner;

// /** è un commento JavaDoc, commento pensato per documentare il codice e generare automaticamente documentazione.
/**
 * Classe per la conversione di temperature da Celsius a Fahrenheit.
 * Implementazione conforme agli standard ISO/IEC per la qualità del software.
 * * @author BitMan


public class Main {
    // Costanti per il calcolo termico.
    private static final double MOLTIPLICATORE = 1.8;
    private static final double OFFSET = 32.0;
    private static final double SEGNALE_USCITA = -999.0;
    // private Questa variabile è visibile solo dentro la classe Main.
    // static Non appartiene agli oggetti Main / Appartiene alla classe Main / Esiste una sola volta
    //        È condivisa da tutto il programma / Posso usarla anche senza creare oggetti. Si usa nelle costanti
    // final Non può essere cambiata. Una volta assegnato il valore non si può cambiare. Variabile -> Costante


    /**
     * Metodo principale di esecuzione.
     * Gestisce il flusso di input utente e richiama la logica di calcolo.


    // public Il metodo è visibile da qualsiasi altra classe, OBBLIGATORIO per il metodo main, perchè deve essere
    // accessibile dalla JVM
    // static Il metodo appartiene alla classe, non un oggetto. La JVM la chiama senza creare un oggetto Main.
    // void Tipo di ritorno; indica che il metodo non restituisce nessun valore.
    // main Nome del metodo. PUNTO DI INGRESSO DEL PROGRAMMA. La JVM cerca questo metodo per iniziare l'esecuzione.
    // (String[] args) String -> array di stringhe. args -> nome dell'array -> potrebbe essere 'parametri'


    public static void main(String[] args) {
        // Scanner È il nome della classe per leggere gli input da tastiera. -> java.util
        //         Serve per leggere numeri, stringhe, parole, linee intere.
        // scanner È il nome della variabile.
        Scanner scanner = new Scanner(System.in); // new -> crea nuovo oggetto in memoria
                                                  // Scanner(...) -> chiama il costruttore della classe Scanner
                                                  // System.in -> leggi dalla tastiera
                                                        // System CLASSE DELLA LIBRERIA STANDARD JAVA. Viene importato
                                                        // automaticamente.
                                                        // in. variabile della classe System: (.in, .out, .err)
        double temperaturaCelsius;

        System.out.println("--- Convertitore Termico Scientifico ---");
        System.out.println("Inserisci il valore in °C per convertire, o " + SEGNALE_USCITA + " per terminare.");

        while (true) {
            System.out.print("Input (°C): ");

            // Validazione Input base
            if(scanner.hasNextDouble()) {
                temperaturaCelsius = scanner.nextDouble();

                // Verifica segnale di uscita
                if (temperaturaCelsius == SEGNALE_USCITA) {
                    System.out.println("Segnale di uscita ricevuto. Terminazione sessione in corso...");
                    break;
                }

                // Esecuzione calcolo tramite metodo dedicato
                double risultatoFahrenheit = convertitoreCelsiusInFahrenheit(temperaturaCelsius);

                // Output Formattato
                System.out.printf("Risultato: %.2f °F%n", risultatoFahrenheit);
                System.out.println("----------------------------------------");

            } else {
                System.out.println("Errore: input non valido. Inserire un numero.");
                scanner.next(); // Svuota il buffer dell' input non valido
            }
        }
        scanner.close();
        System.out.println("Programma terminato correttamente.");
    }
    /**
     * Metodo per la conversione di temperatura.
     * *@param celsius Il valore della temperatura in gradi Celsius.
     * @return La temperatura convertita in gradi Fahrenheit.


    public static double convertitoreCelsiusInFahrenheit(double celsius) {
        return (celsius * MOLTIPLICATORE) + OFFSET;
    }
}



public class Main {
    public static void main(String[] args) {

        int i = 1;

        while (i < 11) {
            System.out.println(i);
            i++;
        }
    }
}
*/


/*
// Tabellina; ciclo for
public class Main {
    public static void main(String[] args) {
        int numeroBase = 5;

        for (int i = 1; i <= 10; i++) {
            int risultato = numeroBase * i;
            System.out.println(numeroBase + " * " + i + " = " + risultato);
        }

    }
}
*/
/*
// Calcolo del fattoriale (Logica Di Accumulo)

public class Main {
    public static void main(String[] args) {
        int n = 5;
        long fattoriale = 1;
        for (int i = 1; i <= n; i++)  {
            fattoriale *= i;
        }
        System.out.println("Il fattoriale di " + n + " è: " + fattoriale);
    }
}
*/
/*
// SOMMA DEI QUADRATI DEI PRIMI N NUMERI; 1²+ 2² + 3² + 4² + ... + n²

public class Main {
    public static void main(String[] args){
        int n = 3;
        int somma = 0;

        for (int i = 1; i <= n; i++) {
            somma += (i * i); // BUG STORICO: era (i * 1), che somma i numeri, non i quadrati
        }

        System.out.println("La somma dei quadrati è: " + somma + ".");

    }
}
*/
/*
// SOMMA DEI PRIMI N NUMERI NATURALI; 1 + 2 + 3 + 4 + ... + n

public class Main {
    public static void main(String[] args) {

        int n = 1000;
        int somma = 0;

        for (int i = 1; i <= n; i++) {
            somma += i; // BUG STORICO: era (i + 1), che aggiunge 1 di troppo a ogni giro (risultato sbagliato di n)
        }

        System.out.println("La somma dei primi " + n + " numeri è: " + somma + ".");
    }
}
*/
/*
// SOMMA DEI MULTIPLI DI 3 TRA 1 E 1000;

public class Main {
    public static void main(String[] args) {
        int n = 1000;
        int somma = 0;
        for (int i = 1; i <= n; i ++) {
            if (i % 3 == 0) {
                somma += i;
            }
        }
        System.out.println("La somma dei multipli di 3 tra 1 e " + n + " è: " + somma);
    }
}
*/

/*
// SOMMA DEI NUMERI DIVISIBILI PER 7

public class Main {
    public static void main(String[] args) {
        int n = 5000;
        int somma = 0;
        for (int i = 1; i <= n; i++) {
            if (i % 7 == 0) {
                somma += i;
            }
        }
        System.out.println("La somma dei numeri divisibili per 7 tra 1 e " + n + " è: " + somma + ".");

    }
}
*/

// SOMMA DINAMICA DEI MULTIPLI DI 5 O 7
/*

// GAUSS --- S = (n(n + 1)) / 2 --- somme = (long) n * (n + 1) / 2


import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Istanziamo il lettore (Scanner) collegato alla tastiera
        Scanner scanner = new Scanner(System.in);

        // Prompt utente
        System.out.println("Inserisci il limite massimo (N): ");
        int n = scanner.nextInt();

        long somma = 0;
        //Completamento del ciclo for secondo le specifiche JLS.

        for (int i = 1; i <= n; i++) {
            somma += i; // == somma - somma + i;
        }
        // Output del risultato
        System.out.print("La somma dei numeri da 1 a " + n + " è:" + somma);

        // Chiusure dello scanner per liberare le risorse I/O
        scanner.close();
    }
}
*/

// ==============================================================================================
// LA SOMMA DEI NUMERI PARI
// ==============================================================================================
/*
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Istanziamo il lettore (Scanner) collegato alla tastiera.
        Scanner scanner = new Scanner(System.in);
        // Prompt utente
        System.out.print("Inserisci il limite massimo (N): ");
        int n = scanner.nextInt();

        long somma = 0;
        for (int i = 1; i <= n; i++) {
            if (i % 2 == 0) {
                somma += i;
            }

        }
        System.out.println("La somma dei numeri pari compresi tra 1 e " + n + " è: " + somma + ".");
    }

}
*/

// =============================================================================================
// FILTRO MULTIPLI COMBINATI
// =============================================================================================
/*
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Istanziamo il lettore Scanner collegato alla tastiera.
        Scanner scanner = new Scanner(System.in);

        //Prompt utente
        System.out.print("Inserisci il limite massimo (N) compreso: ");
        int n = scanner.nextInt();

        long somma = 0;

        for (int i = 1; i <= n; i++) {
            if (i % 3 == 0 || i % 5 == 0) {
              somma += i;
            }
        }
        System.out.println("La somma dei numeri da 1 a " + n + " compreso è: " + somma + ".");
    }

}
*/

// ======================================================================================================
// TEST DI PRIMALITÀ
// =====================================================================================================

/*
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Inserisci un numero intero positivo: ");
        int n = scanner.nextInt();
        boolean esPrimo = true;

        if (n <= 1) {
            esPrimo = false;
        } else {
            // Ottimizzazione matematica: controllo fino alla radice quadrata di n
            for (int i = 2; i <= Math.sqrt(n); i++) {
                if (n % i == 0) {
                    esPrimo = false;
                    break; // Interruzione anticipata del ciclo (JLS)
                }
            }
        }
        if (esPrimo) {
            System.out.println(n + " è un numero primo.");
        } else {
            System.out.println(n + " non è un numero primo");
        }
        scanner.close();
    }
}
*/

// ==============================================================================================
// VERIFICA NUMERO PERFETTO
// ==============================================================================================

// import java.util.Scanner;
/*
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("Inserisci un numero intero positivo: ");
        int n = scanner.nextInt();

        // Variabile di accumulo per la somma dei divisori propri
        long sommaDivisori = 0;

        // I numeri minori o uguali a 1 non possono essere perfetti per definizione
        if (n <= 1) {
            sommaDivisori = 0;
        } else {
            // Ottimizzazione: ci fermiamo a n / 2 anziché a n - 1
            for (int i = 1; i <= n / 2; i++) {
                if (n % i == 0) {
                    sommaDivisori += i; // Se i è un divisore, lo aggiungiamo alla somma
                }
            }
        }
        // Verifica finale della condizione di perfezione
        if (sommaDivisori == n && n > 1) {
            System.out.println(n + " è un numero perfetto.");
        } else {
            System.out.println(n + " non è un numero perfetto.");
        }
    }
}
*/

// ==============================================================================================
// LEGGERE UN INTERO POSITIVO E CLASSIFICARLO
// ==============================================================================================

/*
public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("Inserisci un numero intero positivo: ");
		long n = scanner.nextLong();
		// Variabile di accumulo per la somma dei divisori propri
		long sommaDivisori = 0;
		
		// I numeri minori o uguali a 1 non possono essere perfetti per definizione
		
		if (n <= 1) {
			sommaDivisori = 0;
		} else {
			// Ottimizzazione: ci fermiamo a n / 2 anzichè n - 1
			for (int i = 1; i <= n / 2; i++)  {
				if (n % i == 0) {
					sommaDivisori += i;
				}
			}
		}
		// Verifica finale della condizione di perfezione
		if (sommaDivisori == n && n > 1) {
			System.out.println(n + " è un numero perfetto.");
		} else {
			System.out.println(n + " NON è un numero perfetto.");
		}
		
	}
}
*/

// =========================================================================================
// PERFECT NUMBERS WITHIN A RANGE
// =========================================================================================	

import java.util.Scanner;


public class Main {
	public static void main(String[] args) {

		Scanner scanner = new Scanner(System.in);

		// Lettura e validazione dell'estremo inferiore n1
		System.out.print("Enter your first positive number (N_1 < N_2): ");
		while (!scanner.hasNextLong()) {
			System.out.print("Invalid input. Try again: ");
			scanner.next(); // Svuota il buffer dall'input non valido
		}
		long n1 = scanner.nextLong();

		// Lettura e validazione dell'estremo superiore n2
		System.out.print("Enter your second positive number (N_2 > N_1): ");
		while (!scanner.hasNextLong()) {
			System.out.print("Invalid input. Try again: ");
			scanner.next(); // Senza questo, il ciclo girerebbe all'infinito
		}
		long n2 = scanner.nextLong();

		// Se l'utente inverte gli estremi, li scambiamo invece di rifiutare l'input
		if (n1 > n2) {
			long temp = n1;
			n1 = n2;
			n2 = temp;
		}

		System.out.println("Perfect numbers between " + n1 + " and " + n2 + ":");
		int contatore = 0;

		// CICLO ESTERNO: scorre ogni candidato dell'intervallo
		for (long candidato = n1; candidato <= n2; candidato++) {

			// I numeri <= 1 non possono essere perfetti per definizione
			if (candidato <= 1) {
				continue; // Salta all'iterazione successiva
			}

			// Variabile di accumulo: va AZZERATA per OGNI candidato.
			// Se la dichiarassi fuori dal ciclo esterno, le somme dei candidati
			// precedenti si sommerebbero alle successive e non troveresti mai nulla.
			// Parte da 1 perché 1 è sempre divisore proprio (per candidato > 1)
			// e il ciclo qui sotto parte da i = 2.
			long sumDivisor = 1;

			// CICLO INTERNO OTTIMIZZATO: i divisori vanno a COPPIE (i, candidato / i).
			// Salendo solo fino alla radice quadrata li troviamo TUTTI: il piccolo
			// direttamente, il grande in regalo come candidato / i.
			// 'i * i <= candidato' invece di 'i <= Math.sqrt(candidato)': una
			// moltiplicazione fra long è molto più veloce di una radice quadrata.
			// Prima era 'i <= candidato / 2': complessità n² sull'intervallo, che
			// su range grandi (100 milioni) significa GIORNI di esecuzione.
			for (long i = 2; i * i <= candidato; i++) {
				if (candidato % i == 0) {
					sumDivisor += i;
					long coppia = candidato / i;
					// Se candidato è un quadrato perfetto (es. 36, con i = 6),
					// i e coppia coincidono: senza il controllo conteremmo 6 due volte.
					if (coppia != i) {
						sumDivisor += coppia;
					}
				}
			}

			// Verifica della condizione di perfezione
			if (sumDivisor == candidato) {
				System.out.println(" -> " + candidato + " is a perfect number.");
				contatore++;
			}
		}

		if (contatore == 0) {
			System.out.println(" -> None found in this range.");
		} else {
			System.out.println("Total found: " + contatore + ".");
		}

		scanner.close();
	}
}