Esempi JAVA: differenze tra le versioni
(→Altro Esercizio 1) |
|||
Riga 623: | Riga 623: | ||
== Altro Esercizio 1 == | == Altro Esercizio 1 == | ||
+ | '''Traccia''': Algoritmo che, data una matrice A con elementi causali e non ordinati, crea la matrice B con gli stessi elementi della matrice A, ma ordinati in ordine crescente per righe, e infine stampa gli elementi della matrice B in console. | ||
<syntaxhighlight lang="java" line> | <syntaxhighlight lang="java" line> | ||
+ | public class Esercizio1 { | ||
− | + | public static void main(String[] args) { | |
+ | new Esercizio1().run(); | ||
+ | |||
+ | } | ||
+ | |||
+ | public void run() { | ||
+ | |||
+ | // Dichiarazione e inizializzazione della matrice | ||
+ | int[][] mat = {{15, 25, 3, 0, 24}, | ||
+ | {40, 5, 61, 2, 90}, | ||
+ | {16, 26, 4, 99, 100}, | ||
+ | {45, 6, 64, 9, 98}, | ||
+ | {44, 1, 69, 7, 21}}; | ||
+ | |||
+ | int n = 5; | ||
+ | |||
+ | // Stampa della matrice non ordinata | ||
+ | System.out.println("La matrice non ordinata è la seguente: "); | ||
+ | stampaMatrice(mat, n); | ||
+ | |||
+ | // Chiamo la funzione di ordinamento della matrice | ||
+ | ordinaMatrice(mat, n); | ||
+ | |||
+ | // Stampo la matrice ordinata | ||
+ | System.out.println("La matrice ordinata è la seguente: "); | ||
+ | stampaMatrice(mat, n); | ||
+ | |||
+ | } | ||
+ | |||
+ | /** | ||
+ | * Funzione di ordinamento della matrice | ||
+ | * @param mat | ||
+ | * @param dim | ||
+ | */ | ||
+ | public void ordinaMatrice(int[][] mat, int dim) { | ||
+ | |||
+ | /* E' utilizzato un vettore temporaneo il cui scopo e quello | ||
+ | * di contenere tutti gli elementi della matrice | ||
+ | */ | ||
+ | int[] vettTemp = new int[dim*dim]; | ||
+ | int k = 0; | ||
+ | int i = 0; | ||
+ | int j = 0; | ||
+ | |||
+ | // Ciclo per inserire tutti gli elementi della matrice nel vettore. | ||
+ | for (i = 0; i < dim; i++) { | ||
+ | for(j = 0; j < dim; j++) { | ||
+ | vettTemp[k] = mat[i][j]; | ||
+ | k++; | ||
+ | } | ||
+ | } | ||
+ | |||
+ | // Chiamo la funzione di ordinamento del vettore | ||
+ | ordinaVettore(vettTemp, dim*dim); | ||
+ | |||
+ | // Chiamo la funzione per ricostruire la matrice a partire dal vettore | ||
+ | matriceDaVettore(mat, vettTemp, dim); | ||
+ | } | ||
+ | |||
+ | /** | ||
+ | * Funzione che crea una amtrice a partire da un vettore | ||
+ | * @param mat | ||
+ | * @param vett | ||
+ | * @param dim | ||
+ | */ | ||
+ | public void matriceDaVettore(int[][] mat, int[] vett, int dim) { | ||
+ | int i = 0; | ||
+ | int j = 0; | ||
+ | int k = 0; | ||
+ | |||
+ | for (i = 0; i < dim; i++) { | ||
+ | for (j = 0; j < dim; j++) { | ||
+ | mat[i][j] = vett[k]; | ||
+ | k++; | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | |||
+ | /** | ||
+ | * Funzione di ordinamento del vettore con algoritmo Selection Sort | ||
+ | * @param vett | ||
+ | * @param dim | ||
+ | */ | ||
+ | public void ordinaVettore(int[] vett, int dim) { | ||
+ | int i, j, i_min; | ||
+ | |||
+ | for(i = 0; i < dim-1; i++) { | ||
+ | i_min = i; | ||
+ | for (j = i+1; j < dim; j++) { | ||
+ | if(vett[j] < vett[i_min]) | ||
+ | i_min = j; | ||
+ | } | ||
+ | |||
+ | scambiaElementi(vett, i_min, i); | ||
+ | } | ||
+ | } | ||
+ | |||
+ | /** | ||
+ | * Funzione di scambio degli elementi di un vettore | ||
+ | * @param vett | ||
+ | * @param A | ||
+ | * @param B | ||
+ | */ | ||
+ | public void scambiaElementi(int[] vett, int A, int B) { | ||
+ | int temp = vett[A]; | ||
+ | vett[A] = vett[B]; | ||
+ | vett[B] = temp; | ||
+ | } | ||
+ | |||
+ | /** | ||
+ | * Funzione di stampa della matrice | ||
+ | * @param mat | ||
+ | * @param dim | ||
+ | */ | ||
+ | public void stampaMatrice(int[][] mat, int dim) { | ||
+ | int i = 0; | ||
+ | int j = 0; | ||
+ | |||
+ | for (i = 0; i < dim; i++) { | ||
+ | for (j = 0; j < dim; j++) | ||
+ | System.out.print(mat[i][j] + "\t"); | ||
+ | System.out.println(); | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | </syntaxhighlight> | ||
== Altro Esercizio 2 == | == Altro Esercizio 2 == |
Versione delle 11:30, 22 mar 2017
Indice
Hello World
Esercizio introduttivo a JAVA. Il seguente codice mostra a video la stringa "Hello World !"
/* Questo è il primo programma in JAVA
* e inizia con un commento multilinea
*/
// Commento su singola linea
/**
* Uso della javadoc
* Questo programma deve stampare sullo standard output, ovvero la console,
* la stringa "Hello World !"
*
* @author antonio
*
*/
public class Principale {
/**
* Metodo di avvio del programma
* @param args argomenti passati dalla linea di comando
*/
public static void main(String[] args) {
// Standard output
System.out.println("Hello World !");
}
}
Uso delle funzioni: Doppio e Somma
Codice Java per l'introduzione alle funzioni; sono state implementate due funzioni:
- calcolo del doppio di un numero intero;
- calcolo della somma di due numeri interi.
/** Programma per mostrare il funzionamento di:
* 1. Funzione chiamante (main) e funzione chiamata;
* 2. Variabili locali e parametri (valori) attuali;
* 3. Passaggio per Valore;
*
* @author antonio
*
*/
public class Principale {
public static void main(String[] args) {
new Principale().run();
}
public void run() {
// Dichiarazione e inizializzazione delle variabili origin, origin2 e result
int origin = 3;
int origin2 = 5;
int result = 0;
System.out.println("Doppio di una variabile");
// Stampa in console del valore attuale di origin
System.out.println("Il valore di origin è: " + origin);
/* Calcolo il doppio della variabile origin:
* 1. chiamo la funzione doppio
* 2. salvo il risultato nella variabile result
*/
result = doppio(origin);
// Stampa in console il valore di result
System.out.println("Il valore di result è: " + result);
System.out.println("Somma di due variabili");
// Stampa in console del valore attuale di origin e origin2
System.out.println("Il valore di origin è: " + origin);
System.out.println("Il valore di origin2 è: " + origin2);
// Calcolo la somma di origin e origin2
result = somma(origin, origin2);
// Stampa in console il valore di result
System.out.println("Il valore di result è: " + result);
}
/**
* Funzione per calcolare il doppio di un valore
* @param val
* @return
*/
public int doppio(int val) {
// Dichiaro la variabile res per salvare il doppio della variabile val
int res = 0;
res = val * 2;
// Restituzione di res
return res;
}
/**
* Funzione per calcolare la somma di due addendi
* @param add1
* @param add2
* @return
*/
public int somma(int add1, int add2) {
// Codice compatto che fa la somma di add1 e add2 e restituisce il risultato
return add1 + add2;
}
}
Scambio di due elementi all'interno di un vettore
Codice Java che implementa lo scambio di due componenti in un vettore; sono stati implementati due casi:
- caso1: vettore di sole due componenti che vengono scambiate (funzione scambia(...));
- caso2: vettore di dimensione N nel quale sono scambiate le componenti con indice ind1 e ind2 (funzione scambia_componenti(...)).
public class Principale {
public static void main(String[] args) {
new Principale().run();
}
public void run() {
// Vettore formato da due elementi
int[] v = {3,5};
// Stampo il valore delle due variabili prima dello scambio
System.out.println("La prima componente del vettore vale: " + v[0]);
System.out.println("La seconda componente del vettore vale: " + v[1]);
// Effettuo lo scambio
scambia(v);
// Stampo il valore delle due variabili dopo lo scambio
System.out.println("La prima componente del vettore vale: " + v[0]);
System.out.println("La seconda componente del vettore vale: " + v[1]);
// Generalizzazione a vettore formato da N elementi in cui indico le componenti da scambiare
// Vettore formato da N elementi
int N = 10;
int i = 0;
int[] vett = new int[N];
for(i = 0; i < N; i++)
vett[i] = i+1;
int ind1 = 3;
int ind2 = 8;
// Stampo il vettore prima dello scambio
for(i = 0; i < N; i++)
System.out.print(vett[i] + " ");
System.out.println();
// Effettuo lo scambio
scambia_componenti(vett, ind1, ind2);
// Stampo il vettore dopo dello scambio
for(i = 0; i < N; i++)
System.out.print(vett[i] + " ");
System.out.println();
}
/**
* Funzione scambia funzionante
* @param V
*/
public void scambia(int[] V) {
int temp;
temp = V[0];
V[0] = V[1];
V[1] = temp;
}
/**
* Funzione di scambio delle componenti in posizione c1 e c2 del vettore V
* @param V
* @param c1
* @param c2
*/
public void scambia_componenti(int[] V, int c1, int c2) {
int temp;
temp = V[c1];
V[c1] = V[c2];
V[c2] = temp;
}
}
Prodotto tra matrici
Codice Java che implementa il prodotto, righe per colonne, tra due matrici.
public class Principale {
public static void main(String[] args) {
new Principale().run();
}
public void run() {
int r1, c1;
int r2, c2;
int k;
// Affinchè il prodotto tra matrici possa essere eseguito è necessario che c1 = r2;
// Dimensioni prima matrice
r1 = 2;
c1 = 3;
// Dimensioni della seconda matrice
r2 = 3;
c2 = 5;
// Valorizzazzione matrice1 con numeri interi da 0 (r1*c1)-1
k = 0;
int[][] mat1 = new int[r1][c1];
for (int i = 0; i < r1; i++) {
for (int j = 0; j < c1; j++) {
mat1[i][j] = k;
k++;
}
}
// Valorizzazzione matrice1 con numeri interi da 0 (r2*c2)-1
k = 0;
int[][] mat2 = new int[r2][c2];
for (int i = 0; i < r2; i++) {
for (int j = 0; j < c2; j++) {
mat2[i][j] = k;
k++;
}
}
// Stampa delle matrici mat1 e mat2
System.out.println("La prima matrice vale: ");
stampaMatrice(mat1, r1, c1);
System.out.println("La seconda matrice vale: ");
stampaMatrice(mat2, r2, c2);
/* Controllo che le dimensioni delle matrici rispettano r2 == c1
* affinchè sia possibile effettuare il prodotto tra le due matrici
*/
if (r2 != c1) {
System.out.println("Non è possibile fare il prodotto tra matrici");
}
else {
// Dichiarazione della matrice prodotto mat3 di dimensioni r1*c2
int[][] mat3 = new int[r1][c2];
// Il prodotto tra le matrici è effettuato nella relativa funzione
prodottoMatrici(mat1, r1, c1, mat2, r2, c2, mat3);
// Stampa della matrice prodotto mat3
System.out.println("La matrice prodotto vale: ");
stampaMatrice(mat3, r1, c2);
}
}
/**
* Funzione per la stampa della matrice mat note le sue dimensioni r e c
* @param mat
* @param r
* @param c
*/
public void stampaMatrice(int[][] mat, int r, int c) {
int i = 0;
int j = 0;
for (i = 0; i < r; i++) {
for (j = 0; j < c; j++) {
System.out.print(mat[i][j] + "\t");
}
System.out.println();
}
}
/**
* Funzione che effettua il prodotto tra matrici
* @param A prima matrice
* @param r1 numero di righe della prima matrice
* @param c1 numero di colonne della prima matrice
* @param B seconda matrice
* @param r2 numero di righe della seconda matrice
* @param c2 numero di colonne della seconda matrice
* @param C matrice prodotto
*/
public void prodottoMatrici(int[][] A, int r1, int c1, int[][] B, int r2, int c2, int[][] C) {
int i = 0;
int j = 0;
int k = 0;
// Algoritmo per il prodotto tra matrici
for (i = 0; i < r1; i++) {
for (k = 0; k < c2; k++) {
C[i][k] = 0;
for (j = 0; j < c1; j++) {
C[i][k] = C[i][k] + A[i][j] * B[j][k];
}
}
}
}
}
Algoritmo di ordinamento Selection Sort
Codice Java che implementa l'algoritmo di ordinamento Selection Sort.
public class Principale {
public static void main(String[] args) {
new Principale().run();
}
public void run() {
int i = 0;
// Vettore formato da N elementi
int N = 10;
int[] vett = {15, 25, 18, 6, 4, 9, 110, 200, 0, 201};
// Stampo il vettore prima dell'ordinamento
for(i = 0; i < N; i++)
System.out.print(vett[i] + " ");
System.out.println();
// Effettuo l'ordinamento
ordinamentoSelectionSort(vett, N);
// Stampo il vettore dopo l'ordinamento
for(i = 0; i < N; i++)
System.out.print(vett[i] + " ");
System.out.println();
}
/**
* Funzione che implementa l'algoritmo di ordinamento Selection Sort noti il vettore e la sua dimensione
* @param V
* @param dim
*/
public void ordinamentoSelectionSort(int[] V, int dim) {
int i = 0;
int j = 0;
int i_min = 0;
for (i = 0; i < dim -1; i++) {
i_min = i;
for (j = i+1; j < dim; j++ ) {
if (V[j] < V[i_min])
i_min = j;
}
scambia_componenti(V, i, i_min);
}
}
/**
* Funzione di scambio delle componenti in posizione c1 e c2 del vettore V
* @param V
* @param c1
* @param c2
*/
public void scambia_componenti(int[] V, int c1, int c2) {
int temp = V[c1];
V[c1] = V[c2];
V[c2] = temp;
}
}
Algoritmo di fusione Merge Sort
Consideriamo due vettori (U e V) già ordinati con lo stesso criterio e nelle ipotesi che la loro lunghezza non coincida, che ogni vettore non contenga elementi uguali e che non ci sono elementi comuni tra i due vettori. L'algoritmo merge sort crea un terzo vettore ordinato (W) dato dalla fusione dei primi due. La logica alla base dell'algoritmo è quella di far lavorare in un ciclo due indici (i e j), ciascuno su un vettore, scorrendo i quali si aggiunge al vettore fusione volta per volta l'elemento minore a cui fanno riferimento i due indici. Quando uno dei due vettori termina, si aggiungono al vettore fusione i restanti elementi dell'altro vettore.
public class MergeSort {
public static void main(String[] args) {
new MergeSort().run();
}
public void run() {
// Dimensioni dei Vettori U e V
int n = 10;
int m = 20;
// I vettori su cui applicare il merge sort
int[] U = {21, 30, 15, 6, 0, 1, 78, 99, 100, 200};
int[] V = {3, 251, 20, 5, 9, 101, 45, 67, 80, 71, 98, 2, 7, 125, 156, 24, 1010, 4, 8, 2000};
// Applico l'ordinamento su entrambi i vettori con l'algoritmo Selection SOrt
ordinamentoSelectionSort(U, n);
ordinamentoSelectionSort(V, m);
// Ora che i vettori sono entrambi ordinati posso fare il merge sort
int[] W = new int[n+m];
mergeSort(U, n, V, m, W);
// Stampa i tre vettori U,V e W
stampaVettore(U,n);
stampaVettore(V,m);
stampaVettore(W,n+m);
}
/**
* Funzione che implementa l'algoritmo di Merge Sort
* @param v1
* @param dim1
* @param v2
* @param dim2
* @param v3
*/
public void mergeSort(int[] v1, int dim1, int[] v2, int dim2, int[] v3) {
int i = 0;
int j = 0;
int k = 0;
// Utilizzo gli indici i e j che scorrono sui vettori v1 e v2 rispettivamente.
while (i < dim1 && j < dim2) {
if(v1[i] < v2[j]) {
v3[k] = v1[i];
i++;
}
else {
v3[k] = v2[j];
j++;
}
k++;
}
/* Il blocco condizionale if serve a capire qual è il vettore non terminato
* in modo da inserire i sui rimanenti elementi nel vettore fusione v3
*/
if (i < dim1) {
for (i = i; i < dim1; i++) {
v3[k] = v1[i];
k++;
}
}
else {
for (; j < dim2; j++) {
v3[k] = v2[j];
k++;
}
}
}
/**
* Funzione di ordinamento con algoritmo Selection Sort
* @param vett
* @param dim
*/
public void ordinamentoSelectionSort(int[] vett, int dim) {
int i, j, i_min;
for(i = 0; i < dim-1; i++) {
i_min = i;
for (j = i+1; j < dim; j++) {
if(vett[j] < vett[i_min])
i_min = j;
}
scambiaElementi(vett, i_min, i);
}
}
/**
* Funzione di scambio delle componenti in posizione A e B del vettore vett
* @param vett
* @param A
* @param B
*/
public void scambiaElementi(int[] vett, int A, int B) {
int temp = vett[A];
vett[A] = vett[B];
vett[B] = temp;
}
/**
* Funzione di stampa degli elementi del vettore vett
* @param vett
* @param dim
*/
public void stampaVettore(int[] vett, int dim) {
int i = 0;
for (i = 0; i < dim; i++)
System.out.print(vett[i] + " ");
System.out.println();
}
}
Algoritmo di Ricerca Dicotomica
Codice Java che implementa l'algoritmo di ricerca dicotomica.
public class RicercaDicotomica {
public static void main(String[] args) {
new RicercaDicotomica().run();
}
public void run() {
// Il vettore e la sua dimensione
int n = 20;
int[] V = {3, 251, 20, 5, 9, 101, 45, 67, 80, 71, 98, 2, 7, 125, 156, 24, 1010, 4, 8, 2000};
// Ordinamento del vettore con algoritmo Selection Sort
ordinamentoSelectionSort(V, n);
// Stampa del vettore
System.out.print("Il vettore ordinato è il seguente: ");
stampaVettore(V, n);
// Effettuiamo la ricerca dell'elemento x
int x = 20;
// Chiamata alla funzione di ricerca
int ind = ricercaBinaria(V, n, x);
// Stampa dei risultati
if(ind == -1)
System.out.println("L'elemento non è stato trovato");
else
System.out.println("L'elemento " + x + " è stato trovato in posizione " + ind);
}
/**
* Funzione che implementa la ricerca dicotomica
* @param vett Il vettore in cui effettuare la ricerca
* @param dim La dimensione del vettore
* @param ele L'elemento da cercare all'interno del vettore
* @return L'indice dell'elemento ricercato, oppure -1 se l'elemento non è stato trovato
*/
public int ricercaBinaria(int[] vett, int dim, int ele) {
int low = 0;
int high = dim -1;
while(low <= high) {
int mid = (low+high) / 2;
if(vett[mid] == ele) {
return mid;
}
else if(vett[mid] < ele) {
low = mid + 1;
}
else {
high = mid -1;
}
}
return -1;
}
/**
* Funzione di ordinamento Selection Sort
* @param vett
* @param dim
*/
public void ordinamentoSelectionSort(int[] vett, int dim) {
int i, j, i_min;
for(i = 0; i < dim-1; i++) {
i_min = i;
for (j = i+1; j < dim; j++) {
if(vett[j] < vett[i_min])
i_min = j;
}
scambiaElementi(vett, i_min, i);
}
}
/**
* Funzione di scambio
* @param vett
* @param A
* @param B
*/
public void scambiaElementi(int[] vett, int A, int B) {
int temp = vett[A];
vett[A] = vett[B];
vett[B] = temp;
}
/**
* Funzione di stampa del vettore
* @param vett
* @param dim
*/
public void stampaVettore(int[] vett, int dim) {
int i = 0;
for (i = 0; i < dim; i++)
System.out.print(vett[i] + " ");
System.out.println();
}
}
Altro Esercizio 1
Traccia: Algoritmo che, data una matrice A con elementi causali e non ordinati, crea la matrice B con gli stessi elementi della matrice A, ma ordinati in ordine crescente per righe, e infine stampa gli elementi della matrice B in console.
public class Esercizio1 {
public static void main(String[] args) {
new Esercizio1().run();
}
public void run() {
// Dichiarazione e inizializzazione della matrice
int[][] mat = {{15, 25, 3, 0, 24},
{40, 5, 61, 2, 90},
{16, 26, 4, 99, 100},
{45, 6, 64, 9, 98},
{44, 1, 69, 7, 21}};
int n = 5;
// Stampa della matrice non ordinata
System.out.println("La matrice non ordinata è la seguente: ");
stampaMatrice(mat, n);
// Chiamo la funzione di ordinamento della matrice
ordinaMatrice(mat, n);
// Stampo la matrice ordinata
System.out.println("La matrice ordinata è la seguente: ");
stampaMatrice(mat, n);
}
/**
* Funzione di ordinamento della matrice
* @param mat
* @param dim
*/
public void ordinaMatrice(int[][] mat, int dim) {
/* E' utilizzato un vettore temporaneo il cui scopo e quello
* di contenere tutti gli elementi della matrice
*/
int[] vettTemp = new int[dim*dim];
int k = 0;
int i = 0;
int j = 0;
// Ciclo per inserire tutti gli elementi della matrice nel vettore.
for (i = 0; i < dim; i++) {
for(j = 0; j < dim; j++) {
vettTemp[k] = mat[i][j];
k++;
}
}
// Chiamo la funzione di ordinamento del vettore
ordinaVettore(vettTemp, dim*dim);
// Chiamo la funzione per ricostruire la matrice a partire dal vettore
matriceDaVettore(mat, vettTemp, dim);
}
/**
* Funzione che crea una amtrice a partire da un vettore
* @param mat
* @param vett
* @param dim
*/
public void matriceDaVettore(int[][] mat, int[] vett, int dim) {
int i = 0;
int j = 0;
int k = 0;
for (i = 0; i < dim; i++) {
for (j = 0; j < dim; j++) {
mat[i][j] = vett[k];
k++;
}
}
}
/**
* Funzione di ordinamento del vettore con algoritmo Selection Sort
* @param vett
* @param dim
*/
public void ordinaVettore(int[] vett, int dim) {
int i, j, i_min;
for(i = 0; i < dim-1; i++) {
i_min = i;
for (j = i+1; j < dim; j++) {
if(vett[j] < vett[i_min])
i_min = j;
}
scambiaElementi(vett, i_min, i);
}
}
/**
* Funzione di scambio degli elementi di un vettore
* @param vett
* @param A
* @param B
*/
public void scambiaElementi(int[] vett, int A, int B) {
int temp = vett[A];
vett[A] = vett[B];
vett[B] = temp;
}
/**
* Funzione di stampa della matrice
* @param mat
* @param dim
*/
public void stampaMatrice(int[][] mat, int dim) {
int i = 0;
int j = 0;
for (i = 0; i < dim; i++) {
for (j = 0; j < dim; j++)
System.out.print(mat[i][j] + "\t");
System.out.println();
}
}
}