This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
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 )
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)
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 system.Scanner; import system.System; import system.SystemApplet; public 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 il bit 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 - "); 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 system.Scanner; import system.System; import system.SystemApplet; public 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, xOrigine, yOrigine; 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: ");
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 una iperbole y = (ax+b)/(cx+d)"); //lettura parametri a, b, c, d dell'iperbole letturaIperbole(); //scrittura centro simmetria e intersezione dell'iperbole con gli 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");
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, dimY-getPuntoOrdinataT(vectorY_T[i]), i+1, dimY-getPuntoOrdinataT(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 system.Scanner; import system.System; import system.SystemApplet; public 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 java.awt.Color; import system.SystemApplet; import system.Scanner; import 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/3-10)*(torreSinistra[i]/(double) nDischi)); System.graphics.fillRect(xTorreSinistra-larghezzaDisco/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/3-10)*(torreCentrale[i]/(double) nDischi)); System.graphics.fillRect(xTorreCentro-larghezzaDisco/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/3-10)*(torreDestra[i]/(double) nDischi)); System.graphics.fillRect(xTorreDestra-larghezzaDisco/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.
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 pseudo-causali 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 pseudo-causali 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() * (vmax-vmin)) + 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 = " + (tFine-tInizio)); 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 = " + (tFine-tInizio)); 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 = " + (tFine-tInizio)); 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; } }