// Scrivere in Java un programma (che sfrutti adeguatamente dei metodi statici) 
// che, letto da input un numero intero, sia N, PRIMA stampi il numero speculato 
// di N (ovvero il numero con le stesse cifre di N, ma in posizioni opposte), e POI 
// ne stampi la scomposizione in base 10 di N (unita', decine, centinaia, etc...).
// ESEMPIO: se il numero inserito fosse 
// 
// 	8723
// 
// il programma dovrebbe PRIMA stampare
// 
// 	8723 speculato = 3278
// 
// e POI stampare
// 
// 	8723 = 3*10^0 + 2*10^1 + 7*10^2 + 8*10^3


import java.util.*;

public class ScomposizioneNumero {

	public static Scanner input = new Scanner(System.in);
	
	public static void stampaInverso(int numero) {
		while(numero > 0) {
	        System.out.print(numero % 10);    
	        numero /= 10;
	    }    
	}
	
	public static void stampaScomposizioneBase10(int numero) {
		int exp = 0;  // l'esponente
	    while(numero > 0) {
	        System.out.print( (numero % 10) + "*10^" + exp);
	        numero /= 10;
	        if (numero > 0)
	        	System.out.print(" + ");
	        exp++;
	    }
	}
	
	public static void main(String[] args) {
	    System.out.print("Inserisci un numero intero: ");
	    int numero = input.nextInt();
	    System.out.print("Numero: " + numero + " - il numero inverso e' ");
	    stampaInverso(numero);
	    System.out.println();
	    System.out.print("Numero: " + numero + " - la scomposizione in base 10 e' ");
	    stampaScomposizioneBase10(numero);
	}
}


/////////////////////////////////////////////////////////////////////////////////////////////

// Scrivere in Java un programma (che sfrutti adeguatamente dei metodi statici) con 
// lo scopo di aiutare un alunno della scuola elementare ad imparare le 4 
// operazioni (addizione, sottrazione, moltiplicazione e divisione). Il programma 
// dovrebbe porre all’alunno domande del tipo: "Quanto fa 6 * 7?". L’alunno digita 
// la risposta. Il programma la controlla e, se è corretta visualizza una a caso 
// fra queste 3 frasi: "Bravo!" - "Eccellente!" - "Ottimo Lavoro!", e passa alla 
// domanda successiva. Se la risposta è sbagliata, il programma visualizza una 
// frase tra le seguenti: "No, riprova!" - "Sbagliato. Prova ancora!" - "Non ti 
// arrendere, riprova!", e consente all’alunno di riprovare finché (si spera) non 
// dà la risposta corretta. Le domande da porre all’alunno devono essere 
// completamente casuali, cioè sia gli operandi che gli operatori devono essere 
// scelti in modo random. Gli operandi devono essere interi positivi di una cifra 
// sola. Nel caso in cui l’operatore estratto sia la divisione, l’alunno deve 
// inserire come risultato solo la parte intera. Variante 1: Modificare il 
// programma in modo che dopo 3 risposte sbagliate venga visualizzato il risultato 
// dell’operazione e si passi alla domanda successiva.


import java.util.*;

public class OperazioniAritmetiche {

	public static Scanner input = new Scanner(System.in);
	public static Random generatore = new Random();
	
	public static void main(String[] args) 
	{
		System.out.println(" * Giochiamo con le quattro operazioni *");
		char scelta;
		do {	
			int risultato = FaiDomanda();
			int risposta = input.nextInt();
			
			verificaRisposta(risultato, risposta);
			
			System.out.print(" Vuoi giocare ancora? (s|n) ");
			scelta = input.next().charAt(0);
			}
		while( scelta != 'n' && scelta != 'N');
		System.out.println(" * Grazie per aver giocato con noi... alla prossima! :) ");
	}

	public static int FaiDomanda()
	{
		int n1 = 1 + generatore.nextInt(10);
		int n2 = 1 + generatore.nextInt(10);
		int op = generatore.nextInt(4);
		int risultato;
		char operazione;
		switch(op)
		{
		case 0: 
			operazione = '+';
			risultato = n1 + n2;
			break;
		case 1: 
			operazione = '-';
			risultato = n1 - n2;
			break;
		case 2: 
			operazione = '*';
			risultato = n1 * n2;
			break;
		default: 
			operazione = '/';
			risultato = n1 / n2;
			break;
		}
		System.out.println("Allora... Quanto fa " + n1 + " " + operazione + " " + n2 + " ? ");
		return risultato;
	}

	public static void verificaRisposta(int ris, int risp)
	{
		int cont = 1;
		while ( ris != risp && cont < 10 )
		{
			stampaFraseNegativa();
			risp = input.nextInt();
			cont++;
		}
		if ( ris == risp )
			stampaFrasePositiva(); 
		else
			System.out.println(" Non sei riuscito ad indovinare... :( La risposta corretta era " + ris);	
	}

	public static void stampaFraseNegativa()
	{
		int frase = generatore.nextInt(4);
		String messaggio;
		switch(frase)
		{
		case 0: 
			messaggio = " No, riprova! ";
			break;
		case 1: 
			messaggio = " Sbagliato. Prova ancora! ";
			break;
		case 2: 
			messaggio = " Errore... Non ti arrendere, riprova! ";
			break;
		default: 
			messaggio = " Niente da fare, prova ancora! ";
		}
		System.out.println(messaggio);
	}
		
	public static void stampaFrasePositiva()
	{
		int frase = generatore.nextInt(4);
		String messaggio;
		switch(frase)
		{
		case 0: 
			messaggio = " Bravo! ";
			break;
		case 1: 
			messaggio = " Corretto! Eccellente! ";
			break;
		case 2: 
			messaggio = " Esatto! Continuta così! ";
			break;
		default: 
			messaggio = " Sì! Ottimo lavoro! ";
		}
		System.out.println(messaggio);
	}
}


/////////////////////////////////////////////////////////////////////////////////////////////


// Si scriva un adeguato programma Java che, sfruttando adeguatamente dei metodi statici, 
// operi su due sequenze di numeri interi positivi secondo quanto descritto di seguito. 
// Siano dette A e B due sequenze di numeri interi positivi terminate
// da un tappo negativo, e sia quindi detto x il numero di elementi PARI nella 
// sequenza A. Si intende prima calcolare x, e quindi contare quante volte 
// x è contenuto nella sequenza B. Esempio: per le sequenze 
// 		A = 2 3 4 12 32 65 7 -1  
// 		B = 4 65 23 75 2 4 -1 
// ci sono x=4 numeri pari in A; e il numero 4 è contenuto 2 volte in B.

import java.util.*;

public class ContaPariContaNumero {

	public static Scanner input = new Scanner(System.in);
	
	public static int contaPari() {
		int conta = 0;
		int n = input.nextInt();
		while ( n>=0) {
			if ( n%2 == 0 )
				conta++;
			n = input.nextInt();
		}
		return conta;
	}

	public static int contaOccorrenze(int x) {
		int conta = 0;
		int n = input.nextInt();
		while ( n>=0) {
			if ( n  == x )
				conta++;
			n = input.nextInt();
		}
		return conta;
	}

	
	public static void main(String[] args) {
	    System.out.println("Inserire la PRIMA   sequenza di numeri interi positivi, terminare con un numero negativo.");
	    int x = contaPari(); // x = numero elementi PARI nella sequenza A
	    System.out.println("Inserire la SECONDA sequenza di numeri interi positivi, terminare con un numero negativo.");
	    int c = contaOccorrenze(x); // numero di elementi pari a x nella sequenza B

	    System.out.println("Nella PRIMA   sequenza erano presenti " + x + " numeri pari.");
	    System.out.println("Nella SECONDA sequenza, il numero " + x + " era presente " + c + " volte.");
	   
 	}
}