ESERCITAZIONE FONDAMENTI DI INFORMATICA

Risoluzione di una equazione di secondo grado ax^2 + bx + c = 0 CODICE SORGENTE import system.Scanner; import system.System; import system.SystemApplet; public class Equazione_2_grado extends SystemApplet{ public static void main ( String [] args ) { Scanner read = new Scanner(System.in); double a, b, c, x1, x2; System.out.println("Risoluzione equazione di 2^ grado a*x^2 + b*x + c = 0"); System.out.println("Inserisci a"); a = read.nextDouble(); System.out.println("Inserisci b"); b = read.nextDouble(); System.out.println("Inserisci c"); c = read.nextDouble(); if ( a == 0 ) // equazione degenere (cio di primo grado bx+c=0) if ( b == 0 ) if ( c == 0 ) System.out.println("Infinite soluzioni"); else System.out.println("Nessuna soluzione"); else { x1 = -b/c; System.out.print("Una sola soluzione x = "); System.out.println(x1); } else { if ( c == 0 ) { // equazione spuria (cio ax^2+bx=0) System.out.print("Due soluzioni: x1 = 0 e x2 = " ); System.out.println(-b/a ); } else { double D = b*b-4*a*c; // discriminante if ( D < 0 ) System.out.println("Nessuna soluzione reale"); else if ( D == 0 ) { x1 = -b/(2*a); System.out.println("Due soluzioni coincidenti: x1 = x2 = " + x1 ); } else{ double rD = Math.sqrt(D); // radice quadrata del disciminante x1 = (-b-rD)/(2*a); x2 = (-b+rD)/(2*a); System.out.print("Due soluzioni: x1 = " + x1 ); System.out.println(" x2 = " + x2 ); } } } }

Algoritmo di Conversione di un Naturale da Base 10 a Base 2 Stinga di bit invertita (da dx a sx) CODICE SORGENTE import system.Scanner; import system.System; import system.SystemApplet; public class CodificaBase2 extends SystemApplet{ public static void main ( String [] args ) { Scanner read = new Scanner(System.in); int n, c; System.out.println("Inserisci numero decimale non negativo"); n = read.nextInt(); if ( n < 0 ) { System.out.print("Numero negativo - cambiato il segno"); n = -n; // cambio segno }; do { c = n % 2; System.out.print (c); n = n / 2; } while (n > 0); } }

Algoritmo di Codifica di un Numero Relativo in una parola di 16 Bit di cui 1 bit per il segno Stinga di bit invertita (da dx a sx) CODICE SORGENTE import system.Scanner; import system.System; import system.SystemApplet; public class Codifica_16Bit_Segno extends SystemApplet{ public static void main ( String [] args ) { Scanner read = new Scanner(System.in); int n, c, segno; System.out.println("Inserisci numero decimale N"); n = read.nextInt(); if ( n >= -32767 && n <= 32767 ) { if (n < 0 ) { n = -n; segno=1; } else segno=0; int i = 0; do { c = n % 2; System.out.print (c); i = i+1; if ( i%4 == 0 ) System.out.print (" ");

n = n / 2; } while (n > 0); while (i < 15) { System.out.print (0); i = i+1; if ( i%4 == 0 ) System.out.print (" "); } System.out.print (segno); } else if (n < -32767) System.out.println("underflow"); else System.out.println("overflow"); } }

Algoritmo di Codifica di un Numero Relativo in una parola di 16 Bit con complemento a 1 Stinga di bit invertita (da dx a sx) CODICE SORGENTE import system.Scanner; import system.System; import system.SystemApplet; public class Codifica_16Bit_C1 extends SystemApplet{ public static void main ( String [] args ) { Scanner read = new Scanner(System.in); int n, c, segno = 0; System.out.println("Inserisci numero decimale N"); n = read.nextInt(); if ( n >= -32767 && n <= 32767 ) { if (n < 0 ) { n = -n; segno=1; } System.out.println("Codifica con 16 bit con complemento a 1 - leggere da dx a sx"); int i = 0; do { c = n % 2; if ( segno == 0 ) System.out.print (c); else System.out.print (1-c); // se negativo, viene complementato il bit i = i+1; if ( i%4 == 0 ) System.out.print (" "); n = n / 2; } while (n > 0); while (i < 16) { if ( segno == 0 ) System.out.print (0); else System.out.print (1); i = i+1; if ( i%4 == 0 )

System.out.print (" "); } } else if (n < -32767) System.out.println("underflow"); else System.out.println("overflow"); } }

Algoritmo di Codifica di un Numero Relativo in una parola di 16 Bit con complemento a 2 Stinga di bit invertita (da dx a sx) CODICE SORGENTE import system.Scanner; import system.System; import system.SystemApplet; public class Codifica_16Bit_C2 extends SystemApplet{ public static void main ( String [] args ) { Scanner read = new Scanner(System.in); int n, c, segno = 0; System.out.println("Inserisci numero decimale N"); n = read.nextInt(); if ( n >= -32768 && n <= 32767 ) { if (n < 0 ) { n = -n; segno=1; } System.out.println("Codifica con 16 bit con complemento a 2 - leggere da dx a sx"); int i = 0; boolean cambio = false; do { c = n % 2; if ( !cambio ) System.out.print (c); else System.out.print (1-c); // viene complementato il bit if ( segno == 1 && c == 1 ) cambio = true; i = i+1; if ( i%4 == 0 ) System.out.print (" "); n = n / 2; } while (n > 0); while (i < 16) { if (cambio ) System.out.print (1); else System.out.print (0); i = i+1; if ( i%4 == 0 ) System.out.print (" "); } } else if (n < -32768)

System.out.println("underflow"); else System.out.println("overflow"); } }

Algoritmo di Cifratura di Cesare CODIFICA E DECODIFICA CODICE SORGENTE NOTA BENE: Per copiare il sorgente del programma, poiche' tale sorgente potrebbe non essere visualizzato correttamente dal browser Web, conviene effettuare la copia di esso dal file HTML sorgente, cliccando su Visualizza e quindi su "Origine" con Explorer o su "Sorgente Pagina" con Firefox. import system.Scanner; import system.System; import system.SystemApplet;

public class Cesare extends SystemApplet{ public static void main(String [] args){ // Cifrario e Anticifrario di Cesare // tipoCodifica = 'C' o 'c' per codifica e 'D' o altro carattere per decodifica Scanner scanner=new Scanner(System.in); System.out.println("Codifica o Decodifica? (C/D)"); char tipoCodifica = scanner.nextChar(); tipoCodifica = Character.toUpperCase(tipoCodifica); System.out.println("Chiave (un carattere)?"); char chiave = scanner.nextChar(); // la chiaveeventualmente convertita in un carattere maiuscolo chiave = Character.toUpperCase(chiave); int valA = 'A'; // valore numerico del carattere 'A' int n = 26; // numero di caratteri nell'alfabeto considerato int iA = 0; // indice relativo del carattere 'A' int iZ = 25; // indice relativo del carattere 'Z' int iChiave = chiave - valA; // indice relativo della chiave if ( iChiave < iA || iChiave > iZ ) System.out.println("chiave errata "); else { if ( tipoCodifica == 'C' ) System.out.println("INPUT: Testo da Cifrare con Chiave " + chiave); else System.out.println("INPUT: Testo da Decifrare con Chiave " + chiave); String stringa = scanner.next(); System.out.println("OUTPUT:"); for ( int i =0; i = iA && iC <= iZ ) { if ( tipoCodifica == 'C' ) // spostamento a destra con rotazione iC = (iC + iChiave) % n; else { // spostamento a sinistra con rotazione iC = iC - iChiave;

if ( iC < 0 ) iC += n; } // nella stampa trasformazione da int a char (casting) System.out.print( (char) (iC+valA) ); } } } } }

Algoritmo di Cifratura di Vigenere CODIFICA E DECODIFICA CODICE SORGENTE NOTA BENE: Per copiare il sorgente del programma, poiche' tale sorgente potrebbe non essere visualizzato correttamente dal browser Web, conviene effettuare la copia di esso dal file HTML sorgente, cliccando su Visualizza e quindi su "Origine" con Explorer o su "Sorgente Pagina" con Firefox. import system.Scanner; import system.System; import system.SystemApplet;

public class CifrarioVigenere extends SystemApplet { public static void main(String [] args){ // Cifrario e Anticifrario di Vigenere // tipoCodifica = 'C' o 'c' per codifica e 'D' o altro carattere per decodifica Scanner reader=new Scanner(System.in); System.out.println("Codifica o Decodifica? (C/D)"); char tipoCodifica = reader.nextChar(); tipoCodifica = Character.toUpperCase(tipoCodifica); System.out.println("Chiave (una stringa di sole lettere)?"); String chiave = reader.next(); // i caratteri della chiave convertiti in caratteri maiuscoli chiave = chiave.toUpperCase(); int valA = 'A'; // valore numerico del carattere 'A' int n = 26; // numero di caratteri nell'alfabeto considerato int iA = 0; // indice relativo del carattere 'A' int iZ = 25; // indice relativo del carattere 'Z' boolean chiaveCorretta = true; int m = chiave.length(); // lunghezza della chiave int [] iChiave = new int[m]; for ( int i=0; i < m && chiaveCorretta; i++ ) { // indice relativo dell'i-mo carattere della chiave iChiave [i] = chiave.charAt(i) - valA; if ( iChiave[i] < iA || iChiave[i] > iZ ) chiaveCorretta = false; } if ( !chiaveCorretta ) System.out.println("chiave errata "); else { if ( tipoCodifica == 'C' ) System.out.println("INPUT: Testo da Cifrare con Chiave " + chiave); else

System.out.println("INPUT: Testo da Decifrare con Chiave " + chiave); String testo = reader.next(); System.out.println("OUTPUT:"); int jChiave = 0; // indice di chiave corrente for ( int i =0; i = iA && iC <= iZ ) { if ( tipoCodifica == 'C' ) // spostamento a destra con rotazione iC = (iC + iChiave[jChiave]) % n; else { // spostamento a sinistra con rotazione iC = iC - iChiave[jChiave]; if ( iC < 0 ) iC += n; } // nella stampa trasformazione da int a char (casting) System.out.print( (char) (iC+valA) ); jChiave = (jChiave+1) % m; } } } } }

SCRITTURA DI UN EPITAFFIO Algoritmo cen centrare linee di testo N.B. Con font non proporzionali non viene visualizzata la centratura - il programma funziona bene come applicazione Java. CODICE SORGENTE NOTA BENE: Per copiare il sorgente del programma, poiche' tale sorgente potrebbe non essere visualizzato correttamente dal browser Web, conviene effettuare la copia di esso dal file HTML sorgente, cliccando su Visualizza e quindi su "Origine" con Explorer o su "Sorgente Pagina" con Firefox.

import system.Scanner; import system.System; import system.SystemApplet; public class Epitaffio extends SystemApplet { public static void main(String [] args){ Scanner reader = new Scanner(System.in); int nColonne = 40; System.out.println("Numero di Colonne dell'Epitaffio = " + nColonne); System.out.println("Numero di Righe dell'Epitaffio?"); int nRighe = reader.nextInt(); String [] riga = new String [nRighe]; for ( int i=0; i < nRighe; i++ ) { System.out.println("Inserisci Riga " + (i+1)); riga [i] = reader.next(); } System.out.println("EPITAFFIO");

System.out.print("+"); for ( int i =0; i < nColonne; i++ ) System.out.print("-"); System.out.println("+"); for ( int i=0; i < nRighe; i++ ) { System.out.print("|"); int nSpaziIniziali = (nColonne - riga[i].length())/2; for ( int j = 0; j < nSpaziIniziali; j++ ) System.out.print(" "); if ( riga[i].length() <= nColonne ) System.out.print(riga[i]); else System.out.print(riga[i].substring(0,nColonne)); for ( int j = nSpaziIniziali + riga[i].length(); j < nColonne; j++ ) System.out.print(" "); System.out.println("|"); } System.out.print("+"); for ( int i =0; i < nColonne; i++ ) System.out.print("-"); System.out.println("+"); } }

GIUSTIFICAZIONE DI UN TESTO Algoritmo per giustificare linee di testo N.B. Con font non proporzionali non viene ben visualizzata la giustificatura - il programma funziona bene come applicazione Java. CODICE SORGENTE NOTA BENE: Per copiare il sorgente del programma, poiche' tale sorgente potrebbe non essere visualizzato correttamente dal browser Web, conviene effettuare la copia di esso dal file HTML sorgente, cliccando su Visualizza e quindi su "Origine" con Explorer o su "Sorgente Pagina" con Firefox.

import system.Scanner; import system.System; import system.SystemApplet; public class GiustificaTesto_2010 extends SystemApplet { public static void main(String [] args){ Scanner reader = new Scanner(System.in); int nColonne = 40; System.out.println("Numero di Colonne del testo = " + nColonne); System.out.println("Numero di Righe del testo?"); int nRighe = reader.nextInt(); String [] riga = new String [nRighe]; for ( int i=0; i < nRighe; i++ ) { System.out.println("Inserisci Riga " + (i+1)); riga [i] = reader.next(); } System.out.println("TESTO GIUSTIFICATO"); System.out.print("+"); for ( int i =0; i < nColonne; i++ ) System.out.print("-");

System.out.println("+"); for ( int i=0; i < nRighe; i++ ) { int m = riga[i].length(); if ( m > 0 ) { // stampa della riga solo se non vuota System.out.print("|"); int nSpaziIniziali = 0, nSpaziIntermedi = 0, nSpaziFinali = 0; boolean fineSpaziIniziali=false; for ( int j= 0; j < riga[i].length(); j++ ) if ( riga[i].charAt(j) == ' ' ) if ( !fineSpaziIniziali ) nSpaziIniziali++; else nSpaziFinali++; else { fineSpaziIniziali=true; nSpaziIntermedi += nSpaziFinali; nSpaziFinali=0; } String riga_out = riga[i].substring(nSpaziIniziali, m-nSpaziFinali); int m_out = riga_out.length(); if ( nSpaziIntermedi == 0 || m_out > nColonne ) // una sola parola nella riga o riga troppo lunga System.out.print(riga_out); else { int nSpaziAggiuntivi = nColonne m_out; int extraSpazio; for ( int k = 0; k < m_out; k ++) { System.out.print(riga_out.charAt(k)); if ( riga_out.charAt(k) == ' ' ) { extraSpazio = (int) Math.floor( (double) nSpaziAggiuntivi / nSpaziIntermedi); nSpaziIntermedi--; nSpaziAggiuntivi -= extraSpazio; for ( int p = 0; p < extraSpazio; p++ ) System.out.print(" "); } } } System.out.println("|"); } }; System.out.print("+"); for ( int p =0; p < nColonne; p++ ) System.out.print("-"); System.out.println("+"); } }

CODIFICA DI UN INTERO RELATIVO IN BINARIO CON COMPLEMENTO A 2 Utilizzo di array per invertire i bit CODICE SORGENTE NOTA BENE: Per copiare il sorgente del programma, poiche' tale sorgente potrebbe non essere visualizzato correttamente dal browser Web, conviene effettuare la copia di esso dal file HTML sorgente, cliccando su Visualizza e quindi su "Origine" con Explorer o su "Sorgente Pagina" con Firefox.

import import import public

system.Scanner; system.System; system.SystemApplet; class Cod16BitC2 extends SystemApplet{ public static void main ( String [] args ) { Scanner read = new Scanner(System.in); int n; System.out.println("Inserisci numero decimale N"); n = read.nextInt(); if ( n >= -32768 && n <= 32767 ) { int c; boolean negativo = false; if (n < 0 ) { n = -n; negativo=true; } int [] array_bit = new int[16]; int i = 0; boolean cambio = false; do { c = n % 2; if ( !cambio ) array_bit[i] = c; else array_bit[i] = 1-c; // viene complementato if ( negativo && c == 1 ) cambio = true; i = i+1; n = n / 2; } while (n > 0); for ( ; i < 16; i++) if (cambio ) array_bit[i] = 1; else array_bit[i] = 0; System.out.print("Codifica con 16 bit con complemento a 2

il bit

- "); System.out.println("leggere normalmente da sx a dx"); for ( i=15; i >= 0; i-- ){ System.out.print (array_bit[i]); if ( i%4 == 0 ) System.out.print (" "); } } else if (n < -32768) System.out.println("underflow"); else System.out.println("overflow"); } }

Algoritmo per Contare i caratteri in un testo CODICE SORGENTE NOTA BENE: Per copiare il sorgente del programma, poiche' tale sorgente potrebbe non essere visualizzato correttamente dal browser Web, conviene effettuare la copia di esso dal file HTML sorgente, cliccando su Visualizza e quindi su "Origine" con Explorer o su "Sorgente Pagina" con Firefox. import system.Scanner; import system.System; import system.SystemApplet;

public class ContaCaratteri extends SystemApplet { static Scanner reader=new Scanner(System.in); public static void main(String [] args){ System.out.println("Introduci il testo"); String testo = reader.next(); int n = testo.length(); char [] elencoCar = new char [n]; int [] freqCar = new int [n]; int m = 0; // inizialmente m caratteri diversi in testo for ( int i = 0; i < n; i++ ) { char carCorr = testo.charAt(i); // carattere i-mo in testo // verifica se carCorr gi in elencoCar o va inserito boolean trovatoCar = false; for ( int j = 0; j < m && !trovatoCar; j++ ) if ( carCorr == elencoCar[j] ) { trovatoCar = true; // carCorr in elencoCar: fa incrementata la frequenza elencoCar [j] = carCorr; freqCar[j]++; } if ( !trovatoCar ) { elencoCar [m] = carCorr; // carCorr non era in elencoCar: va inserito freqCar[m]=1; m++; } }; System.out.println("Frequenze dei caratteri"); for ( int i = 0; i < m; i++ ) { System.out.print("Carattere <" + elencoCar[i]+">: "); System.out.println(freqCar[i]); }; char comando; do { // sessione interattiva con l'utilizzatore System.out.println("Frequenza di un Carattere o Caratteri pi Frequenti o Fine? (A/B/C)"); comando = reader.nextChar(); if ( comando == 'A' || comando == 'a') trovaFrequenzaCar(elencoCar,freqCar,m); else if ( comando == 'B' || comando == 'b') trovaCarFrequenti (elencoCar,freqCar,m); } while ( comando != 'C' && comando != 'c' ); System.out.println("Bye"); } static void trovaFrequenzaCar ( char[] C, int [] F, int m) {

// dato un carattere, viene verificato se presente nell'elenco C // se presente ne viene stampata la frequenza System.out.println("Carattere?"); char car= reader.nextChar(); boolean trovato = false; for (int i =0; i < m && !trovato; i++ ) { if ( C[i] == car ) { trovato = true; System.out.println("Carattere <" + C[i]+">: "+F[i]); } }; if (!trovato ) System.out.println("Carattere <" + car+"> non presente."); } static void trovaCarFrequenti (char[] C, int [] F, int m) { // data una frequenza minima fMin, vengono individuati tutti i caratteri nell'elenco // che abbiano una frequenza di almeno fMin System.out.println("Frequenza minima?"); int fMin = reader.nextInt(); for (int i =0; i < m; i++ ) if ( F[i] >= fMin ) System.out.println("Carattere <" + C[i]+">: "+F[i]); } }

Calcola fattoriale o numero di Fibonacci di un intero CODICE SORGENTE NOTA BENE: Per copiare il sorgente del programma, poiche' tale sorgente potrebbe non essere visualizzato correttamente dal browser Web, conviene effettuare la copia di esso dal file HTML sorgente, cliccando su Visualizza e quindi su "Origine" con Explorer o su "Sorgente Pagina" con Firefox. import system.Scanner; import system.System; import system.SystemApplet; public class CalcolaFF extends SystemApplet { public static void main(String[] args) { Scanner reader = new Scanner(System.in); System.out.println("Inserisci A per calcolare fattoriale, B per fibonacci e C per finire [A/B/C]?"); char comando = Character.toUpperCase(reader.nextChar()); while ( comando == 'A' || comando == 'B' ) { System.out.println("Inserisci n "); int n = reader.nextInt(); if (comando =='A') { System.out.print("Fattoriale = "); System.out.println(fattoriale(n)); } else { System.out.print("Fibonacci = "); System.out.println(fibonacci(n)); } System.out.println("Inserisci A per calcolare fattoriale, B per fibonacci e C per finire [A/B/C]?");

comando = Character.toUpperCase(reader.nextChar()); } System.out.println("bye"); } static int fattoriale ( int n ) { if (n < 2 ) return 1; else { int ris = 2; for (int i= 3; i <= n; i++ ) ris = ris*i; return ris; } } static int fibonacci ( int n ) { if (n < 2 ) return n; else { int F1 = 1, F2=0, F=1; for (int i= 3; i <= n; i++ ){ F2=F1; F1=F; F=F1+F2; } return F; } } }

Calcolo della potenza k-ma di un numero double Vengono effettuate log k moltiplicazioni invece di k-1 CODICE SORGENTE NOTA BENE: Per copiare il sorgente del programma, poiche' tale sorgente potrebbe non essere visualizzato correttamente dal browser Web, conviene effettuare la copia di esso dal file HTML sorgente, cliccando su Visualizza e quindi su "Origine" con Explorer o su "Sorgente Pagina" con Firefox. import import import public system.Scanner; system.System; system.SystemApplet; class PotenzaK extends SystemApplet{ public static void main ( String [] args ) { System.out.println("POTENZA K-MA DI UN DECIMALE"); Scanner read = new Scanner(System.in); System.out.println("Inserisci la base: numero decimale positvo"); double a; do { a = read.nextDouble(); if ( a <= 0) System.out.println("Errore: la base deve essere positiva"); } while (a <= 0); System.out.println("Inserisci esponente: numero intero positivo"); int k;

do { k = read.nextInt(); if ( k <= 0) System.out.println("Errore: l'esponente deve essere positivo"); } while (k <= 0); int [] digit = base2(k); double ris = 1; double potenza=a; if ( digit[0] == 1 ) ris = potenza; else ris=1; for ( int i = 1; i < digit.length; i++ ) { potenza = potenza*potenza; if ( digit[i] == 1 ) ris = potenza*ris; } System.out.println("RISULTATO: " + a + "^" + k + " = "+ ris); System.out.println("RISCONTRO: " + a + "^" + k + " = "+ Math.pow(a,k)); } static int [] base2 ( int n ) { // Math.ceil calcola l'approssimazione per eccesso di un double int [] c = new int [(int) Math.ceil(Math.log(n)/Math.log(2))+1]; int i = 0; do { c[i]= n % 2; n = n / 2; i++; } while (n > 0); return c; } }

Esecuzione di operazioni su matrici: somma, sottrazione e prodotto scalare CODICE SORGENTE NOTA BENE: Per copiare il sorgente del programma, poiche' tale sorgente potrebbe non essere visualizzato correttamente dal browser Web, conviene effettuare la copia di esso dal file HTML sorgente, cliccando su Visualizza e quindi su "Origine" con Explorer o su "Sorgente Pagina" con Firefox. import system.Scanner; import system.System; import system.SystemApplet; public class OperazioniMatrici extends SystemApplet{ static Scanner read = new Scanner(System.in); public static void main ( String [] args ) { System.out.println("OPERAZIONI SU MATRICI"); System.out.println("Numero Righe?"); int n = read.nextInt(); System.out.println("Numero Colonne?"); int m = read.nextInt(); System.out.println("Lettura Matrice A"); double [] [] A = new double [n][m]; leggiMatrice(A);

System.out.println("MATRICE A ="); scriviMatrice(A); System.out.println("Lettura Matrice B"); double [] [] B = new double [n][m]; leggiMatrice(B); System.out.println("MATRICE B ="); scriviMatrice(B); double [] [] C = new double [n][m]; // somma di matrici: C = A + B if ( sommaMatrici(A,B,C) ) { System.out.println("SOMMA: A + B ="); scriviMatrice(C); } else System.out.println("Matrici non compatibili per la somma"); // sottrazione di matrici: C = A - B if ( sottraiMatrici(A,B,C) ) { System.out.println("SOTTRAZIONE: A - B ="); scriviMatrice(C); } else System.out.println("Matrici non compatibili per la sottrazione"); // BT la trasposta di B double [] [] BT = trasposta(B); System.out.println("BT - TRASPOSTA DI B ="); scriviMatrice(BT); // prodotto cartesiano di matrici: D = A * BT double [] [] D = new double [A.length][BT[0].length]; if ( moltiplicaMatrici(A,BT,D) ) { System.out.println("PRODOTTO SCALARE: A * BT ="); scriviMatrice(D); } else System.out.println("Matrici non compatibili per il prodotto scalare"); } static void leggiMatrice( double[] [] M) { // lettura di una matrice for ( int i = 0; i < M.length; i++) // scansione delle righe for ( int j =0; j < M[i].length; j++ ) { // scansione delle colonne System.out.println("Elemento ["+i+"] [" + j +"]:"); M[i][j]=read.nextDouble(); } } static void scriviMatrice( double[] [] M) { // scrittura di una matrice for ( int i = 0; i < M.length; i++) {// scansione delle righe System.out.print("Riga ["+i+"]: "); for ( int j =0; j < M[0].length; j++ ) // scansione delle colonne System.out.print(" - " + M[i][j]); System.out.println(" - "); } } static boolean sommaMatrici( double[] [] A, double [][] B, double [][] C) { // somma di due matrici: C = A+B // Le 3 matrici devono essere conformi (stesse dimensioni) if ( A.length != B.length || A[0].length != B[0].length ||

A.length != C.length || A[0].length != C[0].length ) return false; // matrici non conformi for ( int i = 0; i < A.length; i++) for ( int j =0; j < A[0].length; j++ ) C[i][j] = A[i][j]+B[i][j]; return true; } static boolean sottraiMatrici( double[] [] A, double [][] B, double [][] C) { // sottrazione di due matrici: C = A-B if ( A.length != B.length || A[0].length != B[0].length || A.length != C.length || A[0].length != C[0].length ) return false; // matrici non conformi for ( int i = 0; i < A.length; i++) for ( int j =0; j < A[0].length; j++ ) C[i][j] = A[i][j]-B[i][j]; return true; } static double [] [] trasposta ( double [][] M) { // MT la trasposta della matrice M double [][] MT = new double [M[0].length][M.length]; for ( int i = 0; i < M.length; i++ ) for ( int j = 0; j < M[0].length; j++ ) MT[j][i] = M[i][j]; return MT; } static boolean moltiplicaMatrici( double[] [] A, double [][] B, double [][] C) { // prodotto scalare di due matrici: C = A * B // Le 3 matrici devono essere conformi: // (1) numero di colonne di A uguale al numero di righe di B // (2) numero di righe di C uguale al numero di righe di A // (3) numero di colonne di C uguale al numero di colonne di B if ( A[0].length != B.length || // numero di colonne di A diverso da numero colonne di B A.length != C.length || B[0].length != C[0].length ) // dimensioni di C errate return false; // matrici non conformi for ( int i = 0; i < C.length; i++) for ( int j =0; j < C[i].length; j++ ) { C[i][j] = 0; for ( int k = 0; k < A[0].length; k++ ) C[i][j] += A[i][k]*B[k][j]; } return true; } }

Animazione di algoritmi di ricerca e ordinamento - ricerca in un vettore non ordinato - ricerca binaria in un vettore ordinato - ordinamento per selezione - ordinamento a bolle - ordinamento per inserzione CODICE SORGENTE NOTA BENE: Per copiare il sorgente del programma, poiche' tale sorgente potrebbe non essere visualizzato correttamente dal browser Web, conviene effettuare la copia di esso dal file HTML sorgente, cliccando su Visualizza e quindi su "Origine" con Explorer o su "Sorgente Pagina" con Firefox. import java.awt.Color; import system.Scanner; import system.SystemApplet; import system.System;

public class DisegnaRicercaOrdina extends SystemApplet{ // variabili globali statiche (visibili da tutti i metodi) static int dimX = System.graphics.getDimX(); // numero di punti nella direzione X static int dimY = System.graphics.getDimY();; // numero di punti nella direzione Y static int margineSup0 = 20; static int margineSup = 50; static int margineSX = 30; static int altezzaRett = 15; static int larghezzaRett = 60; static int numMaxRettangoli = 15; static int nElem; // numero di elementi del vettore (max 18) static Scanner reader = new Scanner(System.in); public static void main(String[] args) { int [] V = new int[numMaxRettangoli], W = new int[numMaxRettangoli]; int nElem; // numero di elementi del vettore (max 18) nElem=letturaVettore(V); System.out.println("RICERCA IN VETTORE NON ORDINATO"); sessioneRicercaNonOrdinata(V,nElem); copiaVettore(V,W,nElem); System.out.println("SELECTION SORT"); selectionSort(W,0,nElem-1); copiaVettore(V,W,nElem); System.out.println("BUBBLE SORT"); bubbleSort(W,0,nElem-1); copiaVettore(V,W,nElem); System.out.println("INSERTION SORT"); insertionSort(W,0,nElem-1); System.out.println("RICERCA BINARIA IN VETTORE ORDINATO"); sessioneRicercaOrdinata(W,nElem); System.out.println("bye"); } static int letturaVettore ( int [] V ) { int nElem; do { System.out.println("Inserisci la dimensione del vettore (max " + numMaxRettangoli+")"); nElem = reader.nextInt();

if( nElem< 0 || nElem > numMaxRettangoli) System.out.println("Errore, la dimensione deve essere compresa tra 1 e "+numMaxRettangoli); }while(nElem<0 || nElem>numMaxRettangoli); for ( int i = 0; i < nElem; i++) { System.out.println("Elemento "+i + ": "); V[i]=reader.nextInt(); } return nElem; } static void sessioneRicercaNonOrdinata( int [] V, int nElem) { System.out.print("Vuoi ricercare un elemento [s/n]?"); char comando = Character.toUpperCase(reader.nextChar()); while ( comando == 'S' ) { System.out.print("Elemento?"); int elem = reader.nextInt(); int ris = ricercaNonOrdinata(V,0, nElem-1, elem); if ( ris >= 0 && ris < nElem) System.out.println("Elemento "+elem + " trovato in posizione "+ris); else System.out.println("Elemento non trovato"); System.out.println("Vuoi ricercare un altro elemento [s/n]?"); comando = Character.toUpperCase(reader.nextChar()); }; } static int ricercaNonOrdinata ( int [] V, int inizio, int fine, int target ) { disegnaVettore(V,inizio,fine); System.graphics.setColor(Color.black); System.graphics.drawString("RICERCA NON ORDINATA", margineSX+60, margineSup0+12); System.graphics.setColor(Color.red); int ris = inizio-1; for ( int i = 0; i <= fine && ris <="" inizio)="" pausa(2000);="" disegnavettore(v,inizio,fine);="" system.graphics.setcolor(color.black);="" system.graphics.drawstring("ricerca="" non="" ordinata",="" marginesx+60,="" 12);="" system.graphics.setcolor(color.red);="" system.graphics.drawstring("non="" trovato",="" marginesx+80,="" marginesup+altezzarett*inizio+12);="" return="" ris;="" static="" void="" pausa="" (int="" k="" try="" thread.sleep(k);="" catch="" (interruptedexception="" e)="" disegnavettore(int="" []="" vt,="" int="" inizio,="" fine)="" system.graphics.clear();="" system.graphics.setcolor(color.blue);="" posrett="margineSup;" for="" j="inizio;" j++="" system.graphics.drawroundrect(marginesx,="" posrett,="" larghezzarett,="" altezzarett,="" 0,="" 0);="" system.graphics.drawstring(integer.tostring(j),="" marginesx-20,="" posrett+12);="" system.graphics.drawstring(integer.tostring(vt[j]),="" marginesx+10,="" +="altezzaRett;" copiavettore(int="" v,="" w,="" nelem)="" nelem;="" i++)="" w[i]="V[i];" selectionsort(int="" fine;="" 2000);="" disegnavettore(w,inizio,fine);="" system.graphics.drawstring("selection="" sort",="" marginesup0+12);="" system.graphics.drawstring("***="" **="" jmin=" + i, margineSX+80, margineSup+altezzaRett*i+12); for ( int j = i+1; j <=fine; j++) if ( W[j] < W[jmin]) { pausa(2000); System.graphics.drawString(" *="" ",="" marginesup+altezzarett*j+12);="" !="i" scambio="" "="" w[jmin],="" system.graphics.drawstring("**="" w[i],="" marginesup+altezzarett*jmin+12);=""

temp="W[i];" w[jmin]="temp;" niente="" marginesup+altezzarett*(fine+1)+12);="" pausa(3000);="" system.graphics.drawstring("fine="" selection="" bubblesort(int="" iter="-1;" limite="fine;" while="" inizio="" iter++;="" system.graphics.drawstring("bubble="" bubble="" w[j+1],="" w[j],="" marginesup+altezzarett*(j+1)+12);="" w[j]="W[j+1];" w[j+1]="temp;" indiceultimoscambio="j;" insertionsort(int="" system.graphics.drawstring("insertion="" "+temp,="" marginesx+200,="" boolean="" trovataposizione="false;">=inizio && !trovataPosizione; j--) if ( W[j] > temp ) { pausa(2000); System.graphics.drawString("** spostato in basso ", margineSX+80, margineSup+altezzaRett*j+12); W[j+1]=W[j]; pausa(2000); disegnaVettore(W,inizio,fine); System.graphics.setColor(Color.black); System.graphics.drawString("INSERTION SORT", margineSX+60, margineSup0+12); System.graphics.drawString("*** i= " + i, margineSX+200, margineSup+altezzaRett*(fine+1)+12); System.graphics.setColor(Color.red); System.graphics.drawString("** "+temp, margineSX+200, margineSup+altezzaRett*i+12); } else { trovataPosizione = true; pausa(2000); if ( j+1 != i ) { W[j+1]=temp; System.graphics.drawString("** va inserito qui", margineSX+80, margineSup+altezzaRett*(j+1)+12); } else System.graphics.drawString("** rimane qui", margineSX+80, margineSup+altezzaRett*(j+1)+12);; } if ( !trovataPosizione ) { pausa(2000); W[inizio]=temp; System.graphics.drawString("** va inserito qui", margineSX+80, margineSup+altezzaRett*(inizio)+12); } } pausa(3000); disegnaVettore(W,inizio,fine); System.graphics.setColor(Color.black); System.graphics.drawString("FINE INSERTION SORT", margineSX+60, margineSup0+12); } static void sessioneRicercaOrdinata ( int [] W, int nElem) { System.out.print("Vuoi ricercare un elemento [s/n]?"); char comando = Character.toUpperCase(reader.nextChar()); while ( comando == 'S' ) { System.out.print("Elemento?"); int elem = reader.nextInt(); int ris = ricercaBinaria(W,0, nElem-1, elem); if ( ris >= 0 && ris < nElem) System.out.println("Elemento "+elem + " trovato in posizione "+ris); else System.out.println("Elemento non trovato");

System.out.println("Vuoi ricercare un altro elemento [s/n]?"); comando = Character.toUpperCase(reader.nextChar()); } } static int ricercaBinaria ( int [] V, int inizio, int fine, int target ) { int ris = inizio-1; int in = inizio, fin = fine; while ( in <= fin && ris < inizio ) { pausa(2000); disegnaVettore(V,inizio,fine); System.graphics.setColor(Color.black); System.graphics.drawString("RICERCA BINARIA", margineSX+60, margineSup0+12); System.graphics.setColor(Color.red); System.graphics.drawString("vvv", margineSX+200, margineSup+altezzaRett*in+12); System.graphics.drawString("^^^", margineSX+220, margineSup+altezzaRett*fin+12); System.graphics.setColor(Color.red); int medio = (in+fin)/2; pausa( 1000 ); System.graphics.drawString("***", margineSX+80, margineSup+altezzaRett*medio+12); if ( V[medio]==target ) { ris = medio; System.graphics.drawString("TROVATO!!", margineSX+120, margineSup+altezzaRett*medio+12); } else if ( V[medio] > target) { fin = medio-1; System.graphics.drawString("SU", margineSX+120, margineSup+altezzaRett*medio+12); } else { in = medio+1; System.graphics.drawString("GIU'", margineSX+120, margineSup+altezzaRett*medio+12); } } if ( ris < inizio) { pausa(2000); disegnaVettore(V,inizio,fine); System.graphics.setColor(Color.black); System.graphics.drawString("RICERCA BINARIA", margineSX+60, margineSup0+12); System.graphics.setColor(Color.red); System.graphics.drawString("NON TROVATO", margineSX+80, margineSup+altezzaRett*inizio+12); } return ris; } }

Disegna una Parabola CODICE SORGENTE NOTA BENE: Per copiare il sorgente del programma, poiche' tale sorgente potrebbe non essere visualizzato correttamente dal browser Web, conviene effettuare la copia di esso dal file HTML sorgente, cliccando su Visualizza e quindi su "Origine" con Explorer o su "Sorgente Pagina" con Firefox. import java.awt.Color; import system.Scanner; import system.SystemApplet; import system.System;

public class Parabola extends SystemApplet{ static int dimX, dimY, static double a, b, c; static double scaleFactorX, scaleFactorY; static int delta; public static void main(String[] args) { Scanner read = new Scanner(System.in); while(true){ dimX = System.graphics.getDimX(); dimY = System.graphics.getDimY(); xOrigine = approx((double)dimX/2.0); yOrigine = approx((double)dimY/2.0); disegnaAssi(); //lettura parametri parabola, fattori di scala e delta System.out.println("Inserisci a: "); a = read.nextDouble(); System.out.println("Inserisci b: "); b = read.nextDouble(); System.out.println("Inserisci c: "); c = read.nextDouble(); System.out.println("Inserisci delta: "); delta = read.nextInt(); while(delta<=0){ System.out.println("valore errato"); System.out.println("Inserisci delta: "); scaleFactorX = read.nextDouble(); } System.out.println("Inserisci fattore di scala per asse x: "); scaleFactorX = read.nextDouble(); while(scaleFactorX<=0){ System.out.println("valore errato"); System.out.println("Inserisci fattore di scala per asse x: "); scaleFactorX = read.nextDouble(); } System.out.println("Inserisci fattore di scala per asse y: "); scaleFactorY = read.nextDouble(); while(scaleFactorY<=0){ System.out.println("valore errato"); System.out.println("Inserisci fattore di scala per asse y: "); xOrigine, yOrigine;

scaleFactorY = read.nextDouble(); } //Disegna int range=dimX/delta; int[] vectorX=new int[range+1]; int[] vectorY=new int[range+1]; for(int i=0;i<=range;i++){ vectorX[i]=i*delta; vectorY[i]=traslaY(scaleY(getOrdinata(inverseScale(vectorX[i]xOrigine)))); } int n=0; for(int i=0;i<=range;i++){ if(0<=vectorY[i] && vectorY[i]<=dimY) n++; } int[] vectorX1=new int[n]; int[] vectorY1=new int[n]; int u=0; for(int i=0;i<=range;i++){ if(0<=vectorY[i] && vectorY[i]<=dimY){ vectorX1[u]=vectorX[i]; vectorY1[u]=vectorY[i]; u++; } } vectorX=null; vectorY=null; disegna(vectorX1,vectorY1); System.out.println("Vuoi disegnare un altra retta [s/n] ?"); if(!read.next().toLowerCase().equals("s") ){ return; } System.graphics.clear(); } } public static void disegnaAssi() { System.graphics.setColor(Color.black); //Asse Y System.graphics.drawLine(xOrigine, 0, xOrigine, dimY); //Asse X System.graphics.drawLine(0, yOrigine, dimX, yOrigine); }

public static double getOrdinata (double ascissa) { return a*Math.pow(ascissa, 2)+b*ascissa+c; } public static int traslaY(int y) { return yOrigine-y; } public static double inverseScale(int x){ return ((double) x)/scaleFactorX; }

public static int approx(double b){ int value= (int)(b); double f=b-((double)value); if(f>=0.5) value+=1; return value; } public static int scaleY(double y) { return approx(scaleFactorY*y); }

//example public static void disegna(int x1[], int y1[]) { System.graphics.setColor(Color.red); if(x1.length>1){ int x=x1[0]; int y=y1[0]; for(int i=1;i<="" pre="">

Disegno di una iperbole con asintoti paralleli agli assi in un range dell'asse X CODICE SORGENTE NOTA BENE: Per copiare il sorgente del programma, poiche' tale sorgente potrebbe non essere visualizzato correttamente dal browser Web, conviene effettuare la copia di esso dal file HTML sorgente, cliccando su Visualizza e quindi su "Origine" con Explorer o su "Sorgente Pagina" con Firefox. import java.awt.Color; import system.Scanner; import system.SystemApplet; import system.System;

public class Iperbole extends SystemApplet{ // variabili globali statiche (visibili da tutti i metodi) static int dimX, dimY; // numero di punti nelle due direzioni static int iX_asintoto_verticale; // indice nella direzione X dell'ascissa dell'asintoto verticale static double deltaX; // passo nella direzione X static double X_CS, Y_CS; // coordinate del centro di simmetria static double a, b, c, d; // coefficiente dell'equazione dell'iperbole con asintoti paralleli agli assi static double [] rangeX = new double[2]; // range (valori min e max) nella direzione X static double [] rangeY = new double[2]; // range (valori min e max) nella direzione Y static double scaleFactorX, scaleFactorY; // fattori di scala nelle due direzioni static double [] vectorY; // valori di Y per ogni punto X

static Scanner reader = new Scanner(System.in); public static void main(String[] args) System.out.println("Disegno di //lettura parametri a, b, c, d letturaIperbole(); //scrittura centro simmetria e assi scritturaIperbole(); //sessione interattiva per il disegno della parabola System.out.print("Vuoi disegnare l'iperbole [s/n]?"); char comando = Character.toUpperCase(reader.nextChar()); boolean inizio = true; while ( comando == 'S' ) { if (inizio ) { dimX = System.graphics.getDimX(); dimY = System.graphics.getDimY(); vectorY = new double[dimX+1]; // un valore di Y per ogni punto di X } inizio = false; // Lettura area di disegno: Xmin e Xmax letturaRangeX (); discretizzaPuntiIperbole(); disegnaAssi(); disegnaAsintoti(); disegnaIperbole(); System.out.print("Vuoi disegnare un'altra porzione della parabola [s/n]?"); comando = Character.toUpperCase(reader.nextChar()); } System.out.println("bye"); } static void letturaIperbole() { do { System.out.println("N.B. Il coefficiente c non pu essere 0"); System.out.println("N.B. Inoltre a*d deve essere diverso da b*c"); System.out.println("Inserisci a: "); a = reader.nextDouble(); System.out.println("Inserisci b: "); b = reader.nextDouble(); System.out.println("Inserisci c: "); c = reader.nextDouble(); System.out.println("Inserisci d: "); d = reader.nextDouble(); if ( c== 0 ) System.out.println("Errore: c uguale a 0"); if ( a*d== b*c ) System.out.println("Errore: a*d = b*c"); } while ( c == 0 || a*d== b*c ); } static void scritturaIperbole() { System.out.println("Coordinate del Centro di Simmetria"); X_CS = -d/c; Y_CS = a/c; System.out.print("X = " + X_CS); System.out.println("; Y = " + Y_CS); if ( a == 0 ) System.out.println("Nessuna intersezione con asse X"); { una iperbole y = (ax+b)/(cx+d)"); dell'iperbole intersezione dell'iperbole con gli

else { System.out.println("Intersezione con asse X"); System.out.println("X = " + -b/a ); } if ( d == 0 ) System.out.println("Nessuna intersezione con asse Y"); else { System.out.println("Intersezione con asse Y"); System.out.println("Y = " + b/d ); } } static void letturaRangeX ( ) { System.out.println("Lettura area di disegno: Xmin e Xmax"); do { System.out.println("Inserisci Xmin: "); rangeX[0] = reader.nextDouble(); System.out.println("Inserisci Xmax: "); rangeX[1] = reader.nextDouble(); if ( rangeX[1]<= rangeX[0]) System.out.println("Errore: Xmax <= Xmin"); } while ( rangeX[1] <= rangeX[0] ); } static void discretizzaPuntiIperbole() { deltaX= (rangeX[1]-rangeX[0])/(dimX); scaleFactorX = ( rangeX[1] - rangeX[0])/dimX; vectorY[0]=getOrdinata(rangeX[0]); vectorY[dimX]=getOrdinata(rangeX[1]); for (int i=1; i < dimX; i++ ) vectorY[i]=getOrdinata(rangeX[0]+deltaX*i); rangeY[0]=trovaMinimo(vectorY); if ( Y_CS < rangeY[0] ) rangeY[0] = Y_CS; rangeY[1]=trovaMassimo(vectorY); if ( Y_CS > rangeY[1] ) rangeY[1] = Y_CS; scaleFactorY = ( rangeY[1] - rangeY[0])/dimY; } static double trovaMinimo ( double [] V ) { double minimo = V[0]; for ( int i = 1; i < V.length; i++ ) if ( V[i] < minimo ) minimo = V[i]; return minimo; } static double trovaMassimo ( double [] V ) { double massimo = V[0]; for ( int i = 1; i < V.length; i++ ) if ( V[i] > massimo ) massimo = V[i]; return massimo; } public static void disegnaAssi() { System.graphics.clear(); System.graphics.setColor(Color.black); //Asse Y if ( rangeX[0] <= 0 && rangeX[1]>=0 )

System.graphics.drawLine(getPuntoAscissa(0), 0, getPuntoAscissa(0), dimY); //Asse X if ( rangeY[0] <= 0 && rangeY[1]>=0 ) System.graphics.drawLine(0, getPuntoOrdinata(0), dimX, getPuntoOrdinata(0)); } public static void disegnaAsintoti() { System.graphics.setColor(Color.blue); // Asintoto verticale iX_asintoto_verticale = getPuntoAscissa(X_CS); if ( rangeX[0] <= X_CS && rangeX[1]>=X_CS ) System.graphics.drawLine(iX_asintoto_verticale, 0, iX_asintoto_verticale, dimY); // Asintoto orizzontale if ( rangeY[0] <= Y_CS && rangeY[1]>=Y_CS ) System.graphics.drawLine(0, getPuntoOrdinata(Y_CS), dimX, getPuntoOrdinata(Y_CS)); }

public static double getOrdinata (double ascissa) { if ( ascissa <= X_CS && ascissa > X_CS-deltaX/2) ascissa = ascissa -deltaX/2; else if ( ascissa > X_CS && ascissa < X_CS+deltaX/2) ascissa = ascissa +deltaX/2; return (a*ascissa+b)/(c*ascissa+d); } public static void disegnaIperbole( ) { System.graphics.setColor(Color.red); for(int i=0;i< dimX-1;i++){ if ( i != iX_asintoto_verticale && i+1 != iX_asintoto_verticale ) System.graphics.drawLine(i, getPuntoOrdinata(vectorY[i]), i+1, getPuntoOrdinata(vectorY[i+1])); } } public static int getPuntoOrdinata ( double v ) { return dimY - (int) Math.round((v-rangeY[0])/scaleFactorY); } public static int getPuntoAscissa ( double v ) { return (int) Math.round((v-rangeX[0])/scaleFactorX); } }

Disegno dei diagrammi dei momenti e dei tagli in una trave poggiata con carico distribuito CODICE SORGENTE NOTA BENE: Per copiare il sorgente del programma, poiche' tale sorgente potrebbe non essere visualizzato correttamente dal browser Web, conviene effettuare la copia di esso dal file HTML sorgente, cliccando su Visualizza e quindi su "Origine" con Explorer o su "Sorgente Pagina" con Firefox. import java.awt.Color; import system.Scanner; import system.SystemApplet; import system.System;

public class Trave extends SystemApplet{ // variabili globali statiche (visibili da tutti i metodi) static int dimX, dimY; // numero di punti nelle due direzioni static double a, b, c; // coefficienti dell'equazione del momento static double d, e; // coefficienti dell'equazione del taglio static double l, q; //lunghezza e carico static double [] rangeX=new double[2]; // range (valori min e max) nella direzione X static double [] rangeY_M=new double[2]; // range (valori min e max) per il momento nella direzione Y static double [] rangeY_T=new double[2]; // range (valori min e max) per il taglio nella direzione Y static double scaleFactorX; // fattore di scala nella direzione X static double scaleFactorY_M, scaleFactorY_T; // fattori di scala per momento e taglio nella direzione Y static double [] vectorY_M, vectorY_T; // valori di momento e taglio per ogni punto X static Scanner reader = new Scanner(System.in); public static void main(String[] args) { System.out.println("Disegno del diagramma dei momenti e dei tagli di una trave poggiata"); // lettura lunghezza e carico distribuito della trave letturaTrave(); // scrittura reazioni agli appoggi, momento massimo e equazioni di taglio e momento scritturaMomentoTaglio(); dimX = System.graphics.getDimX(); dimY = System.graphics.getDimY(); vectorY_M = new double[dimX+1]; // un valore del momento per ogni punto di X vectorY_T = new double[dimX+1]; // un valore del taglio per ogni punto di X // disegno dei diagrammi dei momenti e dei tagli System.graphics.clear(); disegnaTrave(); discretizzaPuntiMomentiTagli(); disegnaMomento(); disegnaAsseTaglio(); disegnaTaglio(); //sessione interattiva per il calcolo del momento e taglio in un punto System.out.print("Momento e taglio in un punto [s/n]?"); char comando = Character.toUpperCase(reader.nextChar()); boolean inizio=true; while ( comando == 'S' ) {

if ( !inizio ) { System.graphics.clear(); disegnaTrave(); discretizzaPuntiMomentiTagli(); disegnaMomento(); disegnaAsseTaglio(); disegnaTaglio(); }; inizio=false; double x = leggiAscissaPunto(); calcolaMomentoTaglioPunto(x); disegnaAssePunto(x); System.out.print("Momento e taglio in un altro punto [s/n]?"); comando = Character.toUpperCase(reader.nextChar()); }; System.out.println("bye"); } static void letturaTrave ( ) { System.out.println("Lettura parametri della trave: lunghezza l della trave in metri"); do { System.out.println("Inserisci l: "); l = reader.nextDouble(); if ( l <=0 ) System.out.println("Errore: l <= 0"); } while ( l <=0 ); rangeX[0] = 0; rangeX[1] = l; System.out.println("Lettura parametri del carico: carico distribuito q in kg/m "); do { System.out.println("Inserisci q: "); q = reader.nextDouble(); if ( q <= 0) System.out.println("Errore: q <= 0"); } while (q <= 0); } static void scritturaMomentoTaglio() { System.out.println("La reazione a ciascuno dei due estremi vale: "+q*l/2 +" kg"); System.out.println("Il momento massimo vale: "+(q*l*l/8) + " kg x m"); //settaggio parametri parabola a= -q/2; b= q*l/2; c= 0; System.out.println("L'equazione dei momenti M(X)=Q*L*X/2 Q*X^2/2 vale: M(X)= "+b+"* x "+a+"* x^2"); d = -q; e = q*l/2; System.out.println("L'equazione di taglio T(X)= -Q*X+Q*L/2 vale: T(X)= "+ d +"* x + "+e); } static void calcolaMomentoTaglioPunto(double x) {

System.out.println("Il momento nel punto "+x+" vale: "+getOrdinata(a,b,c,x) + " kg x m"); System.out.println("Il taglio nel punto "+x+" vale: "+getOrdinata(0,d,e,x) + " kg"); }

static void disegnaAssePunto(double x) { System.graphics.setColor(Color.green); System.graphics.drawLine( getPuntoAscissa(x), 10, getPuntoAscissa(x), dimY); } static void disegnaAsseTaglio() { System.graphics.setColor(Color.blue); System.graphics.drawLine(10, getPuntoOrdinataT(getOrdinata(0,d,e,l/2))+dimY/2, dimX-10, getPuntoOrdinataT(getOrdinata(0,d,e,l/2))+dimY/2); } static double leggiAscissaPunto() { double x; do { System.out.println("Inserisci il valore in metri di x di cui vuoi conoscere il momento e il taglio"); x = reader.nextDouble(); if(x< 0 || x > l) System.out.println("Errore, x deve essere compreso tra 0 e "+l); }while(x<0 || x>l); return x; } static void discretizzaPuntiMomentiTagli () { double deltaX= (rangeX[1]-rangeX[0])/(dimX); scaleFactorX = ( rangeX[1] - rangeX[0])/(dimX); vectorY_M[0]=getOrdinata(a,b,c,rangeX[0]); vectorY_T[dimX]=getOrdinata(0,d,e,rangeX[1]); for (int i=1; i < dimX; i++ ) { vectorY_M[i]=getOrdinata(a,b,c,rangeX[0]+deltaX*i); vectorY_T[i]=getOrdinata(0,d,e,rangeX[0]+deltaX*i); } rangeY_M[0]=trovaMinimo(vectorY_M); rangeY_M[1]=trovaMassimo(vectorY_M); rangeY_T[0]=trovaMinimo(vectorY_T); rangeY_T[1]=trovaMassimo(vectorY_T); scaleFactorY_M = ( rangeY_M[1] - rangeY_M[0])/(dimY/2); scaleFactorY_T = ( rangeY_T[1] - rangeY_T[0])/(dimY/2); } static double trovaMinimo ( double [] V ) { double minimo = V[0]; for ( int i = 1; i < V.length; i++ ) if ( V[i] < minimo ) minimo = V[i]; return minimo; }

static double trovaMassimo ( double [] V ) { double massimo = V[0]; for ( int i = 1; i < V.length; i++ ) if ( V[i] > massimo ) massimo = V[i]; return massimo; } public static void disegnaTrave() { System.graphics.setColor(Color.blue); System.graphics.fillRect(10, 18, dimX-20, 18); }

public static double getOrdinata (double a, double b, double c, double ascissa) { return a*ascissa*ascissa+b*ascissa+c; } public static void disegnaTaglio( ) { System.graphics.setColor(Color.black); System.graphics.drawLine(10, getPuntoOrdinataT(getOrdinata(0,d,e,l/2))+dimY/2, 10, dimY-getPuntoOrdinataT(vectorY_T[10])); System.graphics.drawLine(dimX-9, getPuntoOrdinataT(getOrdinata(0,d,e,l/2))+dimY/2, dimX-9, dimY-getPuntoOrdinataT(vectorY_T[dimX-9])); System.graphics.setColor(Color.red); //for a partire da 10 e fino a dimX-10 per arrivare a filo degli estremi della trave for(int i=10;i< dimX-10;i++){ System.graphics.drawLine(i, dimYgetPuntoOrdinataT(vectorY_T[i]), i+1, dimYgetPuntoOrdinataT(vectorY_T[i+1])); } } public static void disegnaMomento( ) { System.graphics.setColor(Color.black); System.graphics.drawLine(10, getPuntoOrdinataM(vectorY_M[10]), dimX-10, getPuntoOrdinataM(vectorY_M[10])); System.graphics.setColor(Color.red); //for a partire da 10 e fino a dimX-10 per arrivare al pari della trave for(int i=10;i< dimX-10;i++){ System.graphics.drawLine(i, getPuntoOrdinataM(vectorY_M[i]), i+1, getPuntoOrdinataM(vectorY_M[i+1])); } }

public static int getPuntoOrdinataM ( double v ) { return (int) Math.round((v-rangeY_M[0])/scaleFactorY_M); } public static int getPuntoOrdinataT ( double v ) { return (int) Math.round((v-rangeY_T[0])/scaleFactorY_T);

} public static int getPuntoAscissa ( double v ) { return (int) Math.round((v-rangeX[0])/scaleFactorX); } }

Verifica se una matrice quadrata triangolare o diagonale e nel caso risoluzione di un sistema di equazioni lineari CODICE SORGENTE NOTA BENE: Per copiare il sorgente del programma, poiche' tale sorgente potrebbe non essere visualizzato correttamente dal browser Web, conviene effettuare la copia di esso dal file HTML sorgente, cliccando su Visualizza e quindi su "Origine" con Explorer o su "Sorgente Pagina" con Firefox. import system.Scanner; import system.System; import system.SystemApplet; public class MatriciTriangolari extends SystemApplet{ static Scanner read = new Scanner(System.in); public static void main ( String [] args ) { System.out.println("PROPRIETA' DI MATRICE QUADRATA"); System.out.println("VERIFICA SE DIAGONALE E TRIANGOLARE"); System.out.println("RISOLUZIONE DI SISTEMA DI EQUAZIONI LINEARI SE DIAGONALE E TRIANGOLARE"); System.out.println("Dimensione?"); int n = read.nextInt(); System.out.println("Lettura Matrice A"); double [] [] A = new double [n][n]; leggiMatrice(A); System.out.println("MATRICE A ="); scriviMatrice(A); System.out.println("** VERIFICA SIMMETRIA"); if ( eSimmetrica(A) ) System.out.println("La Matrice A e' simmetrica"); else System.out.println("La Matrice A non e' simmetrica"); if ( eDiagonale(A) ) { System.out.println("La Matrice A e' diagonale"); System.out.println("Vettore dei coefficienti del sistema di equazioni"); double [] B = leggiCoefficienti(A.length); double [] X = new double [A.length]; if ( risolviSistemaDiagonale(A,B,X) ) scriviSoluzione(X); else System.out.println("Sistema di equazioni non risolvibile"); } else { System.out.println("La Matrice A non e' diagonale"); if ( eTriangolareSuperiore(A) ) { System.out.println("La Matrice A e' triangolare superiore"); System.out.println("Vettore dei coefficienti del sistema di equazioni"); double [] B = leggiCoefficienti(A.length);

double [] X = new double [A.length]; if ( risolviSistemaTriangolareSuperiore(A,B,X) ) scriviSoluzione(X); else System.out.println("Sistema non risolvibile"); } else { System.out.println("La Matrice A non e' triangolare superiore"); if ( eTriangolareInferiore(A) ) { System.out.println("La Matrice A e' triangolare inferiore"); System.out.println("Vettore dei coefficienti del sistema di equazioni"); double [] B = leggiCoefficienti(A.length); double [] X = new double [A.length]; if ( risolviSistemaTriangolareInferiore(A,B,X) ) scriviSoluzione(X); else System.out.println("Sistema non risolvibile"); } else System.out.println("La Matrice A non e' triangolare inferiore"); } } } static void leggiMatrice( double[] [] M) { for ( int i = 0; i < M.length; i++) for ( int j =0; j < M[i].length; j++ ) { System.out.println("Elemento ["+i+"] [" + j +"]:"); M[i][j]=read.nextDouble(); } } static void scriviMatrice( double[] [] M) { for ( int i = 0; i < M.length; i++) { System.out.print("Riga ["+i+"]: "); for ( int j =0; j < M[0].length; j++ ) System.out.print(" * " + M[i][j]); System.out.println(" * "); } } static boolean eSimmetrica( double [] [] A ) { boolean verificato = true; for ( int i = 0; i < A.length && verificato; i++ ) for ( int j =i+1; j < A[0].length; j++) verificato = A[i][j] == A[j][i]; return verificato; } static boolean eDiagonale( double [] [] A ) { boolean verificato = true; for ( int i = 0; i < A.length && verificato; i++ ) for ( int j = i+1; j < A[0].length && verificato; j++) verificato = A[i][j] == 0 && A[j][i] == 0; return verificato; } static boolean eTriangolareSuperiore( double [] [] A ) { boolean verificato = true;

for ( int i = 0; i < A.length && verificato; i++ ) for ( int j = 0; j < i && verificato; j++) verificato = A[i][j] == 0; return verificato; } static boolean eTriangolareInferiore( double [] [] A ) { boolean verificato = true; for ( int i = 0; i < A.length && verificato; i++ ) for ( int j = i+1; j < A[0].length && verificato; j++) verificato = A[i][j] == 0; return verificato; } static double [] leggiCoefficienti( int n ) { double [] B = new double [n]; System.out.println("Inserisci vettore B dei termini noti del sistema di equazioni"); for ( int i = 0; i < n; i++) { System.out.println("B ["+i+"]:"); B[i]=read.nextDouble(); } return B; } static boolean diagonaleConZero( double [] [] A ) { boolean esisteZero = false; for ( int i = 0; i < A.length && !esisteZero; i++ ) esisteZero = A[i][i] == 0; return esisteZero; } static boolean risolviSistemaDiagonale( double [] [] A, double [] B, double [] X ) { if ( diagonaleConZero(A) ) return false; for ( int i = 0; i < X.length ; i++ ) X[i] = B[i]/A[i][i]; return true; } static boolean risolviSistemaTriangolareInferiore( double [] [] A, double [] B, double [] X ) { if ( diagonaleConZero(A) ) return false; // Si incomincia a risolvere X[0] usando l'equazione 0 // Poi si passa a risolvere le altre X[i] utilizzando le equazioni successive for ( int i = 0; i < X.length ; i++ ) { X[i] = B[i]; for ( int j=0; j < i; j++) X[i] -= X[j]*A[i][j]; X[i] = X[i]/A[i][i]; } return true; } static boolean risolviSistemaTriangolareSuperiore( double [] [] A, double [] B, double [] X ) { if ( diagonaleConZero(A) ) return false; // Si incomincia a risolvere X[n] usando l'equazione n // Poi si passa a risolvere le altre X[i] utilizzando le equazioni precedenti for ( int i = X.length-1; i >= 0 ; i-- ) { X[i] = B[i]; for ( int j=i+1; j < A[0].length; j++)

X[i] -= X[j]*A[i][j]; X[i] = X[i]/A[i][i]; } return true; } static void scriviSoluzione( double[] X) { System.out.println("SOLUZIONE DEL SISTEMA DI EQUAZIONI"); for ( int i = 0; i < X.length; i++) System.out.println("X [" + i + "] = " + X[i]); } }

Risoluzione di un sistema di equazioni lineari con il metodo di Gauss CODICE SORGENTE NOTA BENE: Per copiare il sorgente del programma, poiche' tale sorgente potrebbe non essere visualizzato correttamente dal browser Web, conviene effettuare la copia di esso dal file HTML sorgente, cliccando su Visualizza e quindi su "Origine" con Explorer o su "Sorgente Pagina" con Firefox. import system.Scanner; import system.System; import system.SystemApplet; public class RisGauss extends SystemApplet{ static Scanner read = new Scanner(System.in); public static void main ( String [] args ) { System.out.println("**RISOLUZIONE DI UN SISTEMA DI EQUAZIONI LINEARI**"); System.out.println("METODO DI ELIMINAZIONE DI GAUSS"); System.out.println("Numero di incognite?"); int n = read.nextInt(); System.out.println("Lettura della Matrice dei coefficienti A"); double [] [] A = new double [n][n]; leggiMatrice(A); System.out.println("Lettura del Vettore dei Termini Noti B"); double [] B = leggiVettore(n); System.out.println("\nSISTEMA DI EQUAZIONI LINEARI"); scriviSistema(A,B); // dimensionamento del vettore delle soluzioni X double [] X = new double [n]; if ( risSistemaEquazioni(A,B,X) ) scriviSoluzione(X); else System.out.println("Sistema di equazioni non risolvibile"); System.out.println("\nBye"); } static void leggiMatrice( double[] [] M) { System.out.println("Lettura di una riga per volta"); for ( int i = 0; i < M.length; i++){ System.out.println("Riga "+i+":"); for ( int j =0; j < M[i].length; j++ ) { System.out.println("["+j+"]:"); M[i][j]=read.nextDouble(); } } } static void scriviSistema( double[] [] A, double [] B) { for ( int i = 0; i < A.length; i++) { System.out.print("Eq ["+i+"]: ");

System.out.print(A[i][0]+" x[0]"); for ( int j =1; j < A[0].length; j++ ) if (A[i][j]>=0) System.out.print(" + " + A[i][j]+" x["+j+"]" ); else System.out.print(" " + A[i][j]+" x["+j+"]" ); System.out.println(" = " + B[i]); } } static double [] leggiVettore( int n ) { double [] B = new double [n]; System.out.println("Inserisci vettore B dei termini noti del sistema di equazioni"); for ( int i = 0; i < n; i++) { System.out.println("B ["+i+"]:"); B[i]=read.nextDouble(); } return B; } static boolean risSistemaEquazioni ( double [][] A, double [] B, double [] X) { boolean singolare = false; for ( int i = 0; i < A.length && !singolare; i++ ) { if ( A[i][i] == 0 ) if ( i < A.length-1 ) singolare = !scambiaRiga(A,B,i); else singolare = true; for ( int j = i+1; j < A.length && !singolare; j++ ) { double d = A[j][i]/A[i][i]; for ( int k = i+1; k < A.length; k++ ) A[j][k] -= d*A[i][k]; B[j] -= d*B[i]; } } if ( !singolare ) risSistemaTriangSup(A,B,X); return !singolare; } static boolean scambiaRiga( double [] [] A, double [] B, int i ) { boolean trovatoNonZero = false; for ( int j = i+1; j < A.length && !trovatoNonZero; j++ ) if ( A[j][i] != 0 ) { trovatoNonZero=true; double temp = B[i]; B[i]=B[j]; B[j]=temp; for (int k = i; k < A.length; k++) { temp = A[i][k]; A[i][k]=A[j][k]; A[j][k]=temp; } } return trovatoNonZero; } static void risSistemaTriangSup( double [] [] A, double [] B, double [] X ) { // Si incomincia a risolvere X[n] usando l'equazione n // Poi si passa a risolvere le altre X[i] utilizzando le equazioni precedenti for ( int i = X.length-1; i >= 0 ; i-- ) { X[i] = B[i]; for ( int j=i+1; j < A[0].length; j++) X[i] -= X[j]*A[i][j]; X[i] = X[i]/A[i][i];

} } static void scriviSoluzione( double[] X) { System.out.println("\n**\nSOLUZIONE DEL SISTEMA DI EQUAZIONI"); for ( int i = 0; i < X.length; i++) System.out.println("X [" + i + "] = " + X[i]); } }

Compressione di una matrice CODICE SORGENTE NOTA BENE: Per copiare il sorgente del programma, poiche' tale sorgente potrebbe non essere visualizzato correttamente dal browser Web, conviene effettuare la copia di esso dal file HTML sorgente, cliccando su Visualizza e quindi su "Origine" con Explorer o su "Sorgente Pagina" con Firefox. import system.Scanner; import system.System; import system.SystemApplet; public class ComprimiMatrice extends SystemApplet{ static Scanner read = new Scanner(System.in); public static void main ( String [] args ) { System.out.println("**COMPRESSIONE DI UNA MATRICE**"); System.out.println("Numero di righe?"); int n = read.nextInt(); System.out.println("Numero di colonne?"); int m = read.nextInt(); System.out.println("Lettura della Matrice dei valori A"); double [] [] A = new double [n][m]; leggiMatrice(A); System.out.println("Matrice dei valori A"); scriviMatrice(A); char continua; do { System.out.println("Somma o Media (S/M)"); char S_M = Character.toUpperCase(read.nextChar()); System.out.println("Fattore di compressione (intero >1)"); int fCompr = read.nextInt(); while (fCompr <= 1 ) { System.out.println("Fattore di compressione errato reintroduci il valore (>1)"); fCompr = read.nextInt(); } double [][] B = compressione(A,fCompr,S_M); System.out.println("Matrice compressa B"); System.out.println("Numero di righe = "+B.length); System.out.println("Numero di colonne = "+B[0].length); scriviMatrice(B); System.out.println("Altra compressione (S/N)?"); continua = Character.toUpperCase(read.nextChar()); } while ( continua =='S'); } static void leggiMatrice( double[] [] M) { System.out.println("Lettura per righe"); for ( int i = 0; i < M.length; i++){ System.out.println("Riga "+i+":"); for ( int j =0; j < M[0].length; j++ ) { System.out.println("["+j+"]:");

M[i][j]=read.nextDouble(); } } } static void scriviMatrice( double[] [] M) { for ( int i = 0; i < M.length; i++) { System.out.println("Riga ["+i+"]: "); for ( int j =0; j < M[0].length; j++ ) System.out.print(" * " + M[i][j] ); System.out.println(" * "); } } static double [][] compressione ( double [][] A, int fC, char S_M ) { int n = A.length; int m = A[0].length; int nc = (int) Math.ceil(n / (double) fC); int mc = (int) Math.ceil(m / (double) fC); double [][] B = new double[nc][mc]; for ( int i = 0; i < nc; i++ ) for ( int j = 0; j < mc; j++ ) B[i][j]=aggregazione(A,i*fC,j*fC, fC, S_M); return B; } static double aggregazione ( double[][] A, int i, int j, int k, char S_M) { double somma =0; int nElem = 0; for ( int ic=i; ic<="" i+k;="" ic++)="" for="" (="" int="" jc="j;" jc

Calcolo dei punti di sella di una matrice CODICE SORGENTE NOTA BENE: Per copiare il sorgente del programma, poiche' tale sorgente potrebbe non essere visualizzato correttamente dal browser Web, conviene effettuare la copia di esso dal file HTML sorgente, cliccando su Visualizza e quindi su "Origine" con Explorer o su "Sorgente Pagina" con Firefox. import system.Scanner; import system.System; import system.SystemApplet; public class PuntoSella extends SystemApplet{ static Scanner read = new Scanner(System.in); public static void main ( String [] args ) { System.out.println("**PUNTO DI SELLA DI UNA MATRICE**"); System.out.println("Numero di righe?"); int n = read.nextInt(); System.out.println("Numero di colonne?"); int m = read.nextInt(); System.out.println("Lettura della Matrice M"); double [] [] M = new double [n][m]; leggiMatrice(M); System.out.println("Matrice"); scriviMatrice(M); int [] iPuntiSella = new int [n*m]; int [] jPuntiSella = new int [n*m]; int nPuntiSella = calcoloPuntiSella(M,iPuntiSella,jPuntiSella); scriviPuntiSella(M,nPuntiSella,iPuntiSella,jPuntiSella); } static void leggiMatrice( double[] [] M) {

System.out.println("Lettura per righe"); for ( int i = 0; i < M.length; i++){ System.out.println("Riga "+i+":"); for ( int j =0; j < M[0].length; j++ ) { System.out.println("["+j+"]:"); M[i][j]=read.nextDouble(); } } } static void scriviMatrice( double[] [] M) { for ( int i = 0; i < M.length; i++) { System.out.println("Riga ["+i+"]: "); for ( int j =0; j < M[0].length; j++ ) System.out.print(" * " + M[i][j] ); System.out.println(" * "); } } static void scriviPuntiSella( double[][] M, int nPuntiSella, int [] iPuntiSella, int [] jPuntiSella ) { System.out.println("Numero di punti di sella =" + nPuntiSella); for ( int k = 0; k < nPuntiSella; k++) { System.out.println("*"+(k+1) + "* M["+iPuntiSella[k]+"]["+jPuntiSella[k]+"] = " + M[iPuntiSella[k]][jPuntiSella[k]]); } } static int calcoloPuntiSella ( double [][] M, int [] iPuntiSella, int [] jPuntiSella ) { int n = M.length; int m = M[0].length; double [] minRiga = new double[n]; for ( int i=0; i < n; i++) minRiga[i]=minimoRiga(M,i); double [] maxColonna = new double [m]; for ( int j=0; j < m; j++) maxColonna[j]=massimoColonna(M,j); int nPuntiSella = 0; for ( int i = 0; i < n; i++) for (int j =0; j < m; j++) if ( M[i][j] == minRiga[i] && M[i][j] == maxColonna[j]) { iPuntiSella[nPuntiSella]=i;jPuntiSella[nPuntiSella]=j; nPuntiSella++; } return nPuntiSella; } static double minimoRiga ( double[][] M, int i ) { double minimo =M[i][0]; for ( int j=1; jmassimo) massimo = M[i][j]; return massimo; } }

Gioco della Torre di Hanoi Vengono calcolate tutte le mosse per spostare n dischi da un perno A a un perno C utilizzando come intermendio un perno B CODICE SORGENTE NOTA BENE: Per copiare il sorgente del programma, poiche' tale sorgente potrebbe non essere visualizzato correttamente dal browser Web, conviene effettuare la copia di esso dal file HTML sorgente, cliccando su Visualizza e quindi su "Origine" con Explorer o su "Sorgente Pagina" con Firefox. import import import public system.Scanner; system.System; system.SystemApplet; class TorreHanoi extends SystemApplet{ public static void main ( String [] args ) { System.out.println("TORRE DI HANOI"); Scanner read = new Scanner(System.in); System.out.println("Inserisci numero di dischi"); int n; do { n = read.nextInt(); if ( n <= 0) System.out.println("Errore: il numero di dischi deve essere positivo"); } while (n <= 0); // viene richiamato il metodo ricorsivo sposta Dischi per spostare n dischi // dal perno A al C utilizzando il B come sostegno spostaDischi(n,'A','C','B'); } static void spostaDischi ( int n, char pernoA, char pernoC, char pernoB ) { if ( n == 1 ) // spostato direttamente 1 disco da A a C sposta1disco(pernoA,pernoC); else { // spostati n-1 dischi da A a B utilizzando C come sostegno spostaDischi(n-1,pernoA,pernoB,pernoC); // spostato 1 disco direttamente da A a C sposta1disco(pernoA,pernoC); // spostati n-1 dischi da B a C utilizzando A come sostegno spostaDischi(n-1,pernoB,pernoC,pernoA); } } static void sposta1disco ( char pernoA, char pernoB ) { System.out.println("** Spostato 1 disco dal perno " + pernoA + " al perno " + pernoB); } }

Gioco della Torre di Hanoi Vengono visualizzate tutte le mosse per spostare n dischi da un perno A a un perno C utilizzando come intermendio un perno B CODICE SORGENTE NOTA BENE: Per copiare il sorgente del programma, poiche' tale sorgente potrebbe non essere visualizzato correttamente dal browser Web, conviene effettuare la copia di esso dal file HTML sorgente, cliccando su Visualizza e quindi su "Origine" con Explorer o su "Sorgente Pagina" con Firefox. import import import import java.awt.Color; system.SystemApplet; system.Scanner; system.System;

public class AnimaTorreHanoi extends SystemApplet { static int nDischi; static Scanner read = new Scanner(System.in); // arrray che memorizzano i dischi contenuti in ogni torre static int [] torreSinistra, torreCentrale, torreDestra; //indici che puntano alla cima di ogni torre static int iTorreSX, iTorreC, iTorreDX; //variabili "final" che identificano le tre torri final static int sinistra = 0, centro =1, destra =2; //posizioni sull'asse X delle tre torri static int xTorreSinistra, xTorreCentro, xTorreDestra; // dimensioni del panello static int dimX, dimY; // altezza dei dischi static int altezzaDisco; public static void main(String[] args) { leggiParametri(); inizializzaTorri(); disegnaTorri(); spostaDischi(nDischi, sinistra, centro, destra); } private static void spostaDischi(int nDischi, int torreSorgente, int torreAusiliaria, int torreDestinazione) { if(nDischi==1) sposta1Disco(torreSorgente, torreDestinazione); else { spostaDischi(nDischi-1, torreSorgente, torreDestinazione, torreAusiliaria); sposta1Disco(torreSorgente, torreDestinazione); spostaDischi(nDischi-1, torreAusiliaria, torreSorgente, torreDestinazione); } } private static void leggiParametri() { do { System.out.println("Inserisci il numero di dischi: "); nDischi = read.nextInt(); if(nDischi <= 0) System.out.println("Errore, numero dischi <= 0 !"); }while(nDischi <=0 ); }

private static void inizializzaTorri() { //tutti i dischi vengono caricati sulla torre di sinistra //le altre torri sono vuote // gli n dischi sono numerati da 1 (disco pi piccolo) a n (disco pi piccolo) // -1 indica assenza di disco torreSinistra= new int[nDischi]; torreCentrale= new int[nDischi]; torreDestra= new int[nDischi]; for(int i=0; i0){ System.graphics.setColor(new Color(torreSinistra[i]*255/(nDischi), 0, 0)); int larghezzaDisco =(int) ((dimX/310)*(torreSinistra[i]/(double) nDischi)); System.graphics.fillRect(xTorreSinistralarghezzaDisco/2, dimY-altezzaDisco*(i+1), larghezzaDisco, altezzaDisco); } if(torreCentrale[i]>0) { System.graphics.setColor(new Color(torreCentrale[i]*255/(nDischi), 0, 0)); int larghezzaDisco =(int) ((dimX/310)*(torreCentrale[i]/(double) nDischi)); System.graphics.fillRect(xTorreCentrolarghezzaDisco/2, dimY-altezzaDisco*(i+1), larghezzaDisco, altezzaDisco); } if(torreDestra[i]>0) { System.graphics.setColor(new Color(torreDestra[i]*255/(nDischi),0, 0)); int larghezzaDisco =(int) ((dimX/310)*(torreDestra[i]/(double) nDischi)); System.graphics.fillRect(xTorreDestralarghezzaDisco/2, dimY-altezzaDisco*(i+1), larghezzaDisco, altezzaDisco); } } try { // pausa tra un passo e l'altro Thread.sleep(1000); }catch(Exception e){e.printStackTrace();} } }

Calcolo del numero di scambi e di confronti effettuati da selection sort, bubble sort, insertion sort e merge sort Il vettore da ordinare pu o essere letto da input o generato in maniera random CODICE SORGENTE NOTA BENE: Per copiare il sorgente del programma, poiche' tale sorgente potrebbe non essere visualizzato correttamente dal browser Web, conviene effettuare la copia di esso dal file HTML sorgente, cliccando su Visualizza e quindi su "Origine" con Explorer o su "Sorgente Pagina" con Firefox. import java.util.Calendar; import java.util.Random; import system.Scanner; import system.SystemApplet; import system.System;

public class ComplessitaOrdinamenti extends SystemApplet{ // variabili globali statiche (visibili da tutti i metodi) // numero di confronti e di scambi per i 3 ordinamenti: // posizione 0 per selection sort // posizione 1 per bubble sort // posizione 2 per insertion sort // posizione 3 per merge sort // posizione 4 per merge sort con selection sort // posizione 5 per radix sort static int [] nConfronti = new int [6]; static int [] nScambi = new int [6]; static long [] tempo = new long[6]; static Scanner reader = new Scanner(System.in); public static void main(String[] args) { int [] V = letturaVettore(); int [] W = new int [V.length]; System.out.println("STAMPA VETTORE INIZIALE"); stampaVettore(V); System.out.println("EFFETTUO SELECTION SORT"); copiaVettore(V,W); nScambi[0] = 0; nConfronti[0] = 0; long inizio=Calendar.getInstance().getTimeInMillis() ; selectionSort(W,0,W.length-1,0); long fine=Calendar.getInstance().getTimeInMillis(); System.out.println("EFFETTUO BUBBLE SORT"); tempo[0]=fine-inizio; copiaVettore(V,W); inizio=Calendar.getInstance().getTimeInMillis() ; bubbleSort(W,0,W.length-1); fine=Calendar.getInstance().getTimeInMillis(); tempo[1]=fine-inizio; System.out.println("EFFETTUO INSERTION SORT"); copiaVettore(V,W); inizio=Calendar.getInstance().getTimeInMillis() ; insertionSort(W,0,W.length-1); fine=Calendar.getInstance().getTimeInMillis(); tempo[2]=fine-inizio; System.out.println("EFFETTUO MERGE SORT"); copiaVettore(V,W); // A un array di lavoro per merge sort int [] A = new int[W.length]; nScambi[3] = 0; nConfronti[3] = 0; inizio=Calendar.getInstance().getTimeInMillis() ; mergeSort(W,0,W.length-1,A); fine=Calendar.getInstance().getTimeInMillis(); tempo[3]=fine-inizio; System.out.println("EFFETTUO MERGE SORT CON SELECTION SORT"); copiaVettore(V,W); nScambi[4] = 0; nConfronti[4] = 0; inizio=Calendar.getInstance().getTimeInMillis() ; mergeSortSel(W,0,W.length-1,A); fine=Calendar.getInstance().getTimeInMillis(); tempo[4]=fine-inizio; System.out.println("EFFETTUO RADIX SORT"); copiaVettore(V,W); inizio=Calendar.getInstance().getTimeInMillis() ; radixSort(W,0,W.length-1); fine=Calendar.getInstance().getTimeInMillis(); tempo[5]=fine-inizio;

System.out.println("STAMPA VETTORE ORDINATO"); stampaVettore(W); calcoloComplessita(W.length); System.out.println("bye"); } static int [] letturaVettore ( ) { int nElem; do { System.out.println("Inserisci la dimensione del vettore:"); nElem = reader.nextInt(); if( nElem< 0 ) System.out.println("Errore, la dimensione deve essere maggiore di 0"); }while( nElem<0 ); int [] V = new int [nElem]; System.out.println("Vuoi introdurre gli elementi del vettore o farli generare [I/G]"); if ( Character.toUpperCase(reader.nextChar()) == 'I' ) for ( int i = 0; i < nElem; i++) { System.out.println("V["+i + "]: "); V[i]=reader.nextInt(); } else generaElementi(V); return V; } static void generaElementi (int [] V ) { System.out.println("Lettura valore mimimo e valore massimo degli elementi"); int vmin, vmax; do { System.out.println("Inserisci valore minimo (non negativo): "); vmin = reader.nextInt(); System.out.println("Inserisci valore massimo (non negativo: "); vmax = reader.nextInt(); if ( vmax <= vmin || vmin < 0) System.out.println("Errore: vmax <= vmin o vmin < 0"); } while ( vmax <= vmin ); // viene creato un oggetto che genera numeri double pseudocausali compresi tra 0 e 1 Random random = new Random(); for (int i = 0; i < V.length; i++ ) // i numeri causali sono moltiplicati per il range dei valori V[i] = (int) ( random.nextDouble() * (vmax-vmin)) + vmin; } static void stampaVettore ( int [] A ) { for (int i = 0; i < A.length; i++ ) System.out.println("A["+i + "] = " + A[i]); } static void copiaVettore(int [] V, int [] W ) { for ( int i=0; i < V.length; i++) W[i]=V[i];

} static void selectionSort(int [] W, int inizio, int fine, int kTipo) { for (int i = inizio; i < fine; i++ ) { int jmin = i; for ( int j = i+1; j <=fine; j++) { nConfronti[kTipo]++; if ( W[j] < W[jmin]) jmin = j; } if ( jmin != i ) { nScambi[kTipo]++; int temp = W[i]; W[i]=W[jmin]; W[jmin]=temp; } } } static void bubbleSort(int [] W, int inizio, int fine) { nScambi[1] = 0; nConfronti[1] = 0; int limite = fine; while ( inizio < limite ) { int indiceUltimoScambio = inizio; for ( int j = inizio; j <=limite-1; j++) { nConfronti[1]++; if ( W[j] > W[j+1]) { nScambi[1]++; int temp = W[j]; W[j]=W[j+1]; W[j+1]=temp; indiceUltimoScambio = j; } } limite = indiceUltimoScambio; } } static void insertionSort(int [] W, int inizio, int fine) { nScambi[2] = 0; nConfronti[2] = 0; for (int i = inizio+1; i <= fine; i++ ) { int temp = W[i]; boolean trovataPosizione = false; for ( int j = i-1; j >=inizio && !trovataPosizione; j--) { nConfronti[2]++; if ( W[j] > temp ) { nScambi[2]++; W[j+1]=W[j]; } else { trovataPosizione = true; if ( j+1 != i ) { nScambi[2]++; W[j+1]=temp; } } } if ( !trovataPosizione ) { nScambi[2]++; W[inizio]=temp; } }

} static void mergeSort(int [] W, int inizio, int fine, int [] A if ( inizio < fine ) { int medio = (inizio+fine)/2; mergeSort(W,inizio,medio, A); mergeSort(W,medio+1,fine, A); merge(W,inizio,fine,medio, A,3); } } ) {

static void merge ( int [] W, int inizio, int fine, int medio, int[] A, int kTipo ) { int i1 = inizio; int i2 = medio+1; int iA =0; while ( i1 <= medio && i2 <= fine ) { nConfronti[kTipo]++; if ( W[i1] <= W[i2] ) { nScambi[kTipo]++; A[iA] = W[i1]; iA++; i1++; } else { nScambi[kTipo]++; A[iA] = W[i2]; iA++; i2++; } } for ( ; i1 <= medio; i1++ ) { nScambi[kTipo]++; A[iA] = W[i1]; iA++; } for ( ; i2 <= fine; i2++ ) { nScambi[kTipo]++; A[iA] = W[i2]; iA++; } for ( iA = 0, i1=inizio; i1 <= fine; i1++, iA++ ) { nScambi[kTipo]++; W[i1] = A[iA]; } } static void mergeSortSel(int [] W, int inizio, int fine, int [] A if ( inizio+20 > fine ) selectionSort(W,inizio,fine,4); else { int medio = (inizio+fine)/2; mergeSortSel(W,inizio,medio, A); mergeSortSel(W,medio+1,fine, A); merge(W,inizio,fine,medio, A,4); } } ) {

static void radixSort(int [] V, int inizio, int fine ) { nScambi[5]=0; nConfronti[5]=0; // trasformazione di interi in stringhe binarie String [] Vbin = new String[fine-inizio+1]; int m =0; // dimensione massima delle stringhe for ( int iV = inizio, iVbin=0; iV <= fine; iV++, iVbin++ ) { nScambi[5]++;

Vbin[iVbin]=Integer.toBinaryString(V[iV]); if ( m < Vbin[iVbin].length() ) m = Vbin[iVbin].length(); } String [] V0 = new String [fine-inizio+1]; String [] V1 = new String [fine-inizio+1]; for ( int j =0; j<="" vbin.length;="" i++)="" nscambi[5]++;="" jj="Vbin[i].length()-j-1;" if="">=0 && Vbin[i].charAt(jj)=='1') { V1[n1]=Vbin[i]; n1++; } else { V0[n0]=Vbin[i]; n0++; } } int i = 0; for (int j0 = 0; j0 < n0; j0++) { nScambi[5]++; Vbin[i]=V0[j0]; i++; } for (int j1 = 0; j1 < n1; j1++) { Vbin[i]=V1[j1]; i++; nScambi[5]++; } } // trasformazione di stringhe binarie in interi for ( int iV = inizio, iVbin=0; iV <= fine; iV++, iVbin++ ){ nScambi[5]++; V[iV]=Integer.parseInt(Vbin[iVbin],2); } } static void calcoloComplessita ( int n ) { System.out.println("****"); System.out.println("VALORE DI n = " + n); double nlogn = (int) (n*Math.log(n)/Math.log(2)); System.out.println("VALORE DI n log n = " + nlogn); double n2 = n*n; System.out.println("VALORE DI n^2 = " + n2); System.out.println("****"); System.out.println("NUMERO DI CONFRONTI"); System.out.print("Selection Sort: " + nConfronti[0]); System.out.println(" pari a " + nConfronti[0]/ n2 + " * n^2"); System.out.print("Bubble Sort: " + nConfronti[1]); System.out.println(" pari a " + nConfronti[1]/n2 + " * ^ n^2"); System.out.print("Insertion Sort: " + nConfronti[2]); System.out.println(" pari a " + nConfronti[2]/n2 + " * n^2"); System.out.print("Merge Sort: " + nConfronti[3]); System.out.println(" pari a " + nConfronti[3]/nlogn + " * n log n"); System.out.print("Merge Sort con Selection Sort: " + nConfronti[4]); System.out.println(" pari a " + nConfronti[4]/nlogn + " * n log n"); System.out.println("Radix Sort: " + nConfronti[5]); System.out.println("****"); System.out.println("NUMERO DI SCAMBI"); System.out.print("Selection Sort: " + nScambi[0]); System.out.println(" pari a " + nScambi[0]/(double) n + " * n"); System.out.print("Bubble Sort: " + nScambi[1]); System.out.println(" pari a " + nScambi[1]/n2 + " * n^2"); System.out.print("Insertion Sort: " + nScambi[2]); System.out.println(" pari a " + nScambi[2]/n2 + " * n^2"); System.out.print("Merge Sort: " + nScambi[3]);

System.out.println(" pari a " + nScambi[3]/nlogn + " * n log n"); System.out.print("Merge Sort con Selection Sort: " + nScambi[4]); System.out.println(" pari a " + nScambi[4]/nlogn + " * n log n"); System.out.print("Radix Sort: " + nScambi[5]); System.out.println(" pari a " + nScambi[5]/nlogn + " * n log n"); System.out.println("TEMPO DI ESECUZIONE IN MILLISECONDI"); System.out.println("Selection Sort: " + tempo[0] + " ms"); System.out.println("Bubble Sort: " + tempo[1] + " ms"); System.out.println("Insertion Sort: " + tempo[2] + " ms"); System.out.println("Merge Sort: " + tempo[3] + " ms"); System.out.println("Merge Sort con Selection Sort: " + tempo[4] + " ms"); System.out.println("Radix Sort: " + tempo[5] + " ms"); } }

Calcolo del numero di scambi e di confronti effettuati da ricerca lineare, ricerca lineare ordinata e ricerca binaria Il vettore da ordinare pu o essere letto da input o generato in maniera random CODICE SORGENTE NOTA BENE: Per copiare il sorgente del programma, poiche' tale sorgente potrebbe non essere visualizzato correttamente dal browser Web, conviene effettuare la copia di esso dal file HTML sorgente, cliccando su Visualizza e quindi su "Origine" con Explorer o su "Sorgente Pagina" con Firefox. import java.util.Calendar; import java.util.Random; import system.Scanner; import system.SystemApplet; import system.System;

public class ComplessitaRicerca extends SystemApplet{ // variabili globali statiche (visibili da tutti i metodi) static int nConfronti; static Scanner reader = new Scanner(System.in); public static void main(String[] args) { String [] V = letturaVettore(); System.out.println("** STAMPA VETTORE INIZIALE"); stampaVettore(V); System.out.println("** EFFETTUO ORDINAMENTO"); String [] W = copiaVettore(V); String [] A = new String[V.length]; mergeSort(W,0,W.length-1,A); System.out.println("** STAMPA VETTORE ORDINATO"); stampaVettore(W); System.out.println("** RICERCA IN VETTORE ORDINATO E NON"); sessioneRicerca(V,W); System.out.println("bye"); } static String [] letturaVettore ( int nElem; do ) {

{ System.out.println("Inserisci la dimensione del vettore:"); nElem = reader.nextInt(); if( nElem< 0 ) System.out.println("Errore, la dimensione deve essere maggiore di 0"); }while( nElem<0 ); String [] V = new String [nElem]; System.out.println("Vuoi introdurre gli elementi del vettore o farli generare [I/G]"); if ( Character.toUpperCase(reader.nextChar()) == 'I' ) for ( int i = 0; i < nElem; i++) { System.out.println("V["+i + "]: "); V[i]=reader.next(); } else generaElementi(V); return V; } static void generaElementi (String [] V ) { System.out.println("Lettura lunghezza delle stringhe"); int lString; do { System.out.println("Inserisci lunghezza delle stringhe: "); lString = reader.nextInt(); if ( lString < 1) System.out.println("Errore: lunghezza < 1"); } while ( lString < 1 ); // viene creato un oggetto che genera numeri double pseudocausali compresi tra 0 e 1 Random random = new Random(); int vmin = 'A'; int vmax = 'Z'; for (int i = 0; i < V.length; i++ ) { V[i]=""; for (int j = 0; j < lString; j++ ) { // i numeri causali sono moltiplicati per il range dei valori int C = (int) ( random.nextDouble() * (vmaxvmin)) + vmin; V[i] +=(char)C; } } } static void stampaVettore ( String [] A ) { for (int i = 0; i < A.length; i++ ) System.out.println("A["+i + "] = " + A[i]); } static String [] copiaVettore(String [] V ) { String [] W = new String[V.length]; for ( int i=0; i < V.length; i++) W[i]=V[i]; return W; } static void selectionSort(String [] W, int inizio, int fine ) { for (int i = inizio; i < fine; i++ ) { int jmin = i;

for ( int j = i+1; j <=fine; j++) { if ( W[j].compareTo(W[jmin]) < 0 ) jmin = j; } if ( jmin != i ) { String temp = W[i]; W[i]=W[jmin]; W[jmin]=temp; } } } static void mergeSort(String [] W, int inizio, int fine, String [] A { if ( inizio+20 > fine ) selectionSort(W,inizio,fine); else { int medio = (inizio+fine)/2; mergeSort(W,inizio,medio, A); mergeSort(W,medio+1,fine, A); merge(W,inizio,fine,medio, A); } } static void merge ( String [] W, int inizio, int fine, int medio, String[] A ) { int i1 = inizio; int i2 = medio+1; int iA =0; while ( i1 <= medio && i2 <= fine ) if ( W[i1].compareTo(W[i2]) < 0 ) { A[iA] = W[i1]; iA++; i1++; } else { A[iA] = W[i2]; iA++; i2++; } for ( ; i1 <= medio; i1++ ) { A[iA] = W[i1]; iA++; } for ( ; i2 <= fine; i2++ ) { A[iA] = W[i2]; iA++; } for ( iA = 0, i1=inizio; i1 <= fine; i1++, iA++ ) W[i1] = A[iA]; } static void sessioneRicerca( String [] V, String [] W ) { System.out.print("Vuoi ricercare un elemento [s/n]?"); char comando = Character.toUpperCase(reader.nextChar()); while ( comando == 'S' ) { System.out.print("Elemento?"); String elem = reader.next(); System.out.println("RICERCA LINEARE NON ORDINATA"); nConfronti=0; long tInizio=Calendar.getInstance().getTimeInMillis() ; int ris = ricercaNonOrdinataLineare(V,0, V.length-1, elem); long tFine=Calendar.getInstance().getTimeInMillis(); if ( ris >= 0 && ris < V.length ) System.out.println("Elemento "+elem + " trovato in posizione "+ris); )

else System.out.println("Elemento non trovato"); System.out.print("Numero di confronti = "+ nConfronti); System.out.println(" pari a " + nConfronti/ (double) V.length + " * n"); System.out.println("Tempo in millisecondi = " + (tFinetInizio)); System.out.println("RICERCA LINEARE ORDINATA"); nConfronti=0; tInizio=Calendar.getInstance().getTimeInMillis() ; ris = ricercaOrdinataLineare(W,0, W.length-1, elem); tFine=Calendar.getInstance().getTimeInMillis(); if ( ris >= 0 && ris < W.length ) System.out.println("Elemento "+elem + " trovato in posizione "+ris); else System.out.println("Elemento non trovato"); System.out.print("Numero di confronti = "+ nConfronti); System.out.println(" pari a " + nConfronti/ (double) W.length + " * n"); System.out.println("Tempo in millisecondi = " + (tFinetInizio)); System.out.println("RICERCA BINARIA"); nConfronti=0; tInizio=Calendar.getInstance().getTimeInMillis() ; ris = ricercaBinaria(W,0, W.length-1, elem); tFine=Calendar.getInstance().getTimeInMillis(); if ( ris >= 0 && ris < W.length ) System.out.println("Elemento "+elem + " trovato in posizione "+ris); else System.out.println("Elemento non trovato"); System.out.print("Numero di confronti = "+ nConfronti); System.out.println(" pari a " + nConfronti/ (Math.log(W.length)/Math.log(2)) + " * log n"); System.out.println("Tempo in millisecondi = " + (tFinetInizio)); System.out.println("Vuoi ricercare un altro elemento [s/n]?"); comando = Character.toUpperCase(reader.nextChar()); }; }

static int ricercaNonOrdinataLineare ( String [] V, int inizio, int fine, String target ) { int ris = inizio-1; for ( int i = 0; i <= fine && ris <="fine" &&="" 0 ) introvabile = true; } } return ris; } static int ricercaBinaria ( String [] V, int inizio, int fine, String target ) { int ris = inizio-1; int in = inizio, fin = fine; while ( in <= fin && ris < inizio ) { int medio = (in+fin)/2; nConfronti++; if ( V[medio].equals(target) ) ris = medio;

else { nConfronti++; if ( V[medio].compareTo(target) > 0 ) fin = medio-1; else in = medio+1; } } return ris; } }