Linguaggio Java: verifica elementi array in ordine crescente

Tema 9

Scrivere un metodo isArrayCrescente che riceve in ingresso un array di interi V e verifica se l’array è crescente.

Ad esempio, sia V l’array così costituito

allora isCrescente (V) = TRUE

 public class tema9 { public static boolean isArrayCrescente (int[] V) { //inizializziamo una variabile boolean impostandola sul valore TRUE, assumendo //che l’array sia crescente boolean crescente = true; // verifichiamo se ogni elemento di V è minore dell'elemento che lo segue for (int i = 0; crescente && i < V.length-1; i++) if (V[i] >= V[i+1]) crescente = false; return crescente; }  /* Applicazione Di Prova: Inizializziamo tre array su cui testare il metodo; il  * primo array sarà crescente, il secondo array sarà non decrescente, il terzo  * array sarà non crescente. */  public static void main(String[] args) { int[] A = { 1, 2, 5, 7 }; System.out.println(isArrayCrescente (A)); // array crecsente System.out.println(); int[] B = { 1, 2, 5, 5, 7 }; // array non decrescente (ma non crescente) System.out.println(isArrayCrescente (B)); System.out.println(); int[] Z = { 1, 2, 5, 3, 7 }; // un array non crescente System.out.println(isArrayCrescente (Z)); } }

Linguaggio Java: stampa il massimo valore in un array

Tema 8

Scrivere un metodo trovaMassimoInArray che riceve in ingresso un array di interi V e stampa a video il valore più alto in esso presente.

Ad esempio, sia V l’array così costituito

Array A
3	5	1	7	9	2	4	6	1

allora trovaMassimoInArray (V) = 9

 public class tema8 { public static int trovaMassimoInArray (int[] V) { //il primo elemento di V viene scelto arbitrariamente come massimo provvisorio int max = V[0]; //effettuiamo una scansione dell'array partendo dal secondo elemento for (int i = 1; i < V.length; i++) { //se durante la scansione incontriamo un elemento più grande del primo, //aggiorniamo il valore di max if (V[i] > max) max = V[i]; } return max; }  /* Applicazione di Prova: Inizializziamo due array su cui testare il metodo; il  * primo array conterrà solo elementi positivi, il secondo array conterrà solo  * elementi negativi. */  public static void main(String[] args) { int[] A={3,5,1,7,9,2,4,6,1}; System.out.println(“Il valore piu’ grande contenuto nell’array A, e’:”); System.out.println(trovaMassimoInArray (A)); System.out.println(); int[] B ={-15,-4,-6}; System.out.println(“Il valore piu’ grande contenuto nell’array B, e’:”); System.out.println(trovaMassimoInArray (B)); } }

Linguaggio Java: scambio degli elementi di due array e loro inversione

Tema 7

Scrivere un metodo scambiaElementiDiDueArrayInOrdineInverso che riceve in ingresso due array di interi A e B e trasferisce gli elementi dall’uno all’altro invertendone l’ordine. Ad esempio, siano A e B due array così costituiti

Array A
2	4	6	8	10

Array B
3	6	9	12	15

allora scambiaElementiArrayInOrdineInverso (A, B) darà

Array A
15	12	9	6	3

Array B
10	8	6	4	2

 public class tema7 { public static void scambiaElementiDiDueArrayInOrdineInverso (int[] A, int[] B) { // impostiamo un ciclo che scorra gli array // fissiamo come limite di scorrimento la dimensione di uno dei due tanto hanno // la stessa dimensione // creiamo un contenitore in cui posizioneremo di volta in volta gli elementi // che dovremo spostare int contenitoreTemporaneo; for (int i = 0; i < A.length; i++) { // iniziamo a posizionare nel contenitore il primo elemento dell'array contenitoreTemporaneo = A[i]; // nella prima posizione dell’array A trasferiamo l'ultimo elemento dell'array B A[i] = B[B.length-1-i]; // analogamente, nell'ultima posizione dell'array B trasferiamo il primo // elemento dell’array A B[B.length-1-i] = contenitoreTemporaneo; } // reiterando questo procedimento alla fine otterremo il risultato voluto } public static void visualizzaArray (int[] V) { for (int i = 0; i < V.length; i++) System.out.print(V[i] + " "); System.out.println(); }  /*Applicazione di Prova*/  public static void main(String[] args) { // inizializziamo due array int[] A = new int[] {1, 2, 3, 4, 5, 6}; int[] B = new int[] {4, 8, 12, 16, 20, 24}; // applichiamo il metodo ai due array scambiaElementiDiDueArrayInOrdineInverso (A, B); // visualizziamo gli elementi dei nostri array dopo l’applicazione del metodo visualizzaArray (A); visualizzaArray (B); } }

Linguaggio Java: inversione degli elementi di un array

Tema 6

Scrivere un metodo invertiArray che riceve in ingresso un array di interi V e ne inverte gli elementi effettuando uno spostamento degli stessi.

Ad esempio, sia V l’array così costituito

Allora invertiArray (V) darà

 public class tema6 { public static int[] invertiArray (int[] V) { // creiamo un contenitore in cui posizioneremo di volta in volta gli elementi // che dovremo spostare int contenitoreTemporaneo; // impostiamo un ciclo che scorra l’array fino a metà della sua dimensione for (int i = 0; i < V.length/2; i++) { // iniziamo a posizionare nel contenitore il primo elemento dell'array contenitoreTemporaneo = V[i]; // nella prima posizione trasferiamo l’ultimo elemento dell’array V[i] = V[V.length-1-i]; // analogamente, nell’ultima posizione dell’array trasferiamo il primo elemento V[V.length-1-i] = contenitoreTemporaneo; } // reiterando questo procedimento alla fine otterremo l’array invertito return V; }  public static void visualizzaArray (int[] V) { for (int i = 0; i < V.length; i++) System.out.print(V[i] + " "); System.out.println(); /* Applicazione di Prova: Facciamo notare che questo metodo non si limita, come  * il precedente, a fare la stampa degli elementi in ordine inverso, ma effettua  * lo spostamento fisico di ciascun elemento da una cella all'altra.*/  public static void main(String[] args) { int[] A = new int[] {1, 2, 3, 4, 5, 6}; int[] B = invertiArray (A); visualizzaArray (B); } }

Linguaggio Java: uguaglianza tra 2 array di interi

Tema 5

Scrivere un metodo verificaSeDueArrayUguali che riceve in ingresso due array A e B di interi e restituisce TRUE se gli array sono uguali; FALSE altrimenti.

 public class tema5 { public static boolean verificaSeDueArraySonoUguali (int[] A, int[] B) { // inizializziamo la variabile boolean uguali sul valore TRUE come se i due // array fossero, di fatto, uguali boolean uguali = true; // preliminarmente verifichiamo che i due array abbiano la stessa dimensione if (A.length != B.length) uguali = false; // nel caso di dimensioni diverse il metodo restituirebbe già da subito FALSE else { // verifichiamo ora che i due array siano uguali elemento per elemento for (int i = 0; uguali && i < A.length; i++) if (A[i] != B[i]) // appena due elementi di posizioni omologhe risultassero diversi il metodo // restituirebbe FALSE uguali = false; } return uguali; }  /* Applicazione di Prova */  public static void main(String[] args) { // verifichiamo il metodo su due array vuoti (il risultato sarà TRUE) System.out.println(verificaSeDueArraySonoUguali (new int[] { }, new int[] { }) ); System.out.println(); // verifichiamo il metodo su due array non vuoti e uguali (il risultato sarà // TRUE) System.out.println(verificaSeDueArraySonoUguali (new int[] { 3, 6, 9, 12 }, new int[] { 3, 6, 9, 12 })); System.out.println(); // verifichiamo il metodo su due array diversi (il risultato sarà FALSE) System.out.println(verificaSeDueArraySonoUguali(new int[] { 20, 30, 40, 50 }, new int[] { 20, 30, 40, 90})); System.out.println(); // verifichiamo il metodo su due array di lunghezza diversa (il risultato sarà // FALSE) System.out.println(verificaSeDueArraySonoUguali (new int[] { 11, 22, 33, 44, 55 }, new int[] { 33, 44 })); } }

Linguaggio Java: somma degli elementi di un array

Tema 4

Scrivere un metodo sommaElementiArray che riceve in ingresso un array di interi V e restituisce il valore della somma di tutti i suoi elementi.

 public class tema4 { public static int sommaElementiArray(int[] V) { //inizializziamo una variabile di tipo intero nella quale confluirà il risultato //finale int somma = 0; for (int i = 0; i < V.length; i++) // ogni elemento dell’array verrà sommato ai precedenti somma += V[i]; return somma; }  /* Applicazione di Prova: Inizializziamo un array su cui testare il metodo. */  public static void main(String[] args) { int[] A = {1,2,3,4}; System.out.println(“La somma degli elementi dell’array A, e’:”); System.out.println(sommaElementiArray (A)); } }

Linguaggio Java: stampa degli elementi positivi di un array

Tema 3

Scrivere un metodo stampaElementiPositivi che riceve in ingresso un array di interi V e stampa a video tutti e solo gli elementi positivi in esso contenuti.

 public class tema3 { public static int[] stampaElementiPositivi (int[] V) { int contaPositivi = 0; // contatore degli elementi positivi di V // inizialmente scorriamo l’array V per sapere quanti sono gli elementi positivi for (int i = 0; i < V.length; i++) if (V[i] > 0) // ogni volta che verrà trovato un elemento positivo sarà incrementata la // variabile che infine rappresenterà la dimensione del nuovo array contaPositivi++; // l'array Positivi avrà dimensione pari al numero di elementi positivi presenti in V int[] Positivi = new int[contaPositivi]; // trascriviamo nell'array Positivi gli elementi positivi di V, nello stesso // ordine in cui occorrono in V int j = 0; // indice per la scansione dell’array Positivi for (int i = 0; i < V.length; i++) if (V[i] > 0) { Positivi[j] = V[i]; j++; } return Positivi; }  public static void visualizzaArray (int[] V) { for (int i = 0; i < V.length; i++) System.out.print(V[i] + " "); System.out.println(); }  /* Applicazione di Prova: Inizializziamo due array su cui testare il metodo; il primo array conterrà solo elementi positivi, il secondo array conterrà anche elementi negativi e nulli. */  public static void main(String[] args) { // array che contiene solo elementi positivi visualizzaArray ( stampaElementiPositivi (new int[] { 1, 2, 3, 5 }) ); System.out.println(); // stampiamo una riga vuota per separare i risultati // array che contiene anche negativi e nulli visualizzaArray ( stampaElementiPositivi (new int[] { 8, -5, 9, 0, 13 })); } }

Nota: In questo caso abbiamo inizializzato i due array direttamente all’interno dell’invocazione del metodo stampaElementiPositivi a sua volta innestato all’interno del metodo visualizza

Linguaggio Java: stampa degli elementi di un array in ordine inverso

Tema 2

Scrivere un metodo stampaArrayCapovolto che riceve in ingresso un array di interi V e stampa a video i suoi elementi in ordine inverso, dall’ultimo valore al primo.

 public class tema2 { public static void stampaArrayCapovolto (int[] V) { // naturalmente questa volta il ciclo partirà dall’ultima posizione e // gradualmente l’indice verrà decrementato for (int i = V.length-1; i >= 0; i--) System.out.print(V[i] + " "); System.out.println(); }  /*Applicazione di Prova: Creiamo un array contenente al suo interno la tabellina del 2 e poi invochiamo il metodo stampaArrayCapovolto per stampare a video il risultato.*/  public static void main(String[] args) { int[] A = new int [10]; for(int i = 0; i < A.length; i++) A[i] = (i+1)*2; stampaArrayCapovolto ( A ); } }

Linguaggio Java: stampa degli elementi di un array

Tema 1

Scrivere un metodo visualizzaArray che riceve in ingresso un array di interi V e ne stampa a video gli elementi.

 public class tema1 { public static void visualizzaArray (int[] V) { // acquisiamo l’array V e impostiamo un ciclo per scorrere tutti i suoi elementi for (int i = 0; i < V.length; i++) System.out.print(V[i] + " "); System.out.println(); }  /*Applicazione di Prova: Creiamo un array contenente al suo interno la tabellina del 2  e poi invochiamo il metodo per stampare a video il risultato.*/  public static void main (String[] args) { int[] A = new int [10]; for (int i = 0; i < A.length; i++) A[i] = (i+1)*2; visualizzaArray ( A ); } }

Nota: Il metodo visualizzaArray sarà spesso utilizzato in altre applicazioni di questo manuale.

Sudoku 060314

Sudoku molto facile per principianti

0 : 0

Usa i tasti freccia o il mouse per spostarti nello schema. I tasti da 1 a 9 per riempire una casella, il tasto 0, Canc oppure Spazio per cancellare.

Numeri fibonacci

Per vedere la successione di Fibonacci clicca sul pulsante play

Regressione polinomiale animazione

Se avete coppie di dati, la regressione polinomiale avvicina i valori con un polinomio in . Mathcad usa una funzione chiamata regress per trovare i coefficienti per la migliore approssimazione polinomiale, qualunque sia il grado da voi scelto.

Ecco l’inizializzazione. Potete usare il foglio di lavoro di Mathcad per i vostri dati introducendoli in due vettori chiamati e . Sceglieremo alcuni dati per illustrare la funzione regress .

Introducete il grado del polinomio che intendete usare:

Mathcad fa il resto con tre equazioni:

Ecco i coefficienti , con il termine noto come primo termine e il coefficiente della potenza pi alta come ultimo termine.

Il polinomio è:

La correlazione per questa approssimazione :

Ora Mathcad rappresenta i dati e la curva di approssimazione :

Seguono gli scarti , che sono i valori attuali dei dati meno i valori previsti dalla funzione approssimante.

Regressione esponenziale

E’ sempre interessante vedere quanto vicino arrivata l’approssimazione ai coefficienti che abbiamo usato per costruire i dati. I coefficienti variavano tra 2 e 6 e noi abbiamo ottenuto per l’approssimazione. nei nostri dati era sempre e per l’approssimazione abbiamo ottenuto . Naturalmente abbiamo aggiunto rumore ai dati, cos che non ci aspettiamo che questi coefficienti dell’approssimazione coincidano esattamente con i coefficienti usati per ottenere i nostri dati.

————————————————————————————————————————-

Ecco la rappresentazione dei dati e la curva che rappresenta la funzione approssimante .

Per vedere l’animazione possiamo cliccare sul grafico seguente

La funzione approssimante con e . Il coefficiente di correlazione per questa approssimazione .

Risultati: l’approssimazione e il grafico

Questo completa la nostra occhiata dentro la scatola nera. Ovviamente ci sarebbe ancora molto da dire, ma siamo pronti per vedere alcuni risultati.

La vostra calcolatrice vi restituir questi valori di prova come la risposta, ma se c’ un po’ di rumore nei vostri dati questi valori potrebbero non essere esattamente i valori che minimizzano la somma degli errori quadratici nell’approssimazione. Cos noi imporremo alla funzione genfit di partire con i nostri valori di prova e di fornirci una risposta pi sicura.

Se osservate gli argomenti in ingresso a genfit vedrete che essi includono i vettori dei dati, i nostri valori di prova per i parametri, e la funzione , che chiaramente ha qualcosa a che fare con la forma della funzione approssimante. Infatti la prima entrata in proprio la nostra funzione con e al posto di e . Se conoscete l’analisi matematica potete notare che gli altri due argomenti in entrata sono le derivate del primo argomento rispetto ai due parametri e . La funzione genfit usa una procedura iterativa che minimizza la somma dei quadrati degli errori nell’approssimazione e ha bisogno di queste derivate per il calcolo. E’ un problema delicato e abbiamo bisogno di iniziare l’iterazione con valori vicini alla risposta finale, ecco perch abbiamo curato la scelta dei valori di prova.

E ora tocca alle equazioni per il calcolo dell’approssimazione. Prima occupiamoci dei valori di prova per i due coefficienti prendendo i logaritmi dei loro valori . Se la vostra calcolatrice pu dare l’approssimazione esponenziale, probabilmente usa questo trucco. Funziona, perch se allora cosicch il logaritmo di una funzione lineare di . Useremo coefficiente angolare e ordinata all’origine della retta che meglio approssima il grafico logaritmico per costruire valori di prova per gli originali parametri esponenziali. L’operatore freccia sopra ci dice che prenderemo i logaritmi di tutti valori dei dati in una volta.

Per essere sicuri che il nostro grafico mostri tutti i dati useremo il max e il min di e per fissare la scala del grafico. Prima troviamo gli intervalli di e e quindi estendiamo un po’ ciascun intervallo. Per rappresentare la funzione approssimante useremo una variabile diversa, .

Prima costruiremo alcuni dati che hanno pressappoco un andamento esponenziale. Sceglieremo alcuni valori per e li sposteremo un po’ a destra e a sinistra. Quindi li passeremo attraverso una funzione esponenziale e li moltiplicheremo per un fattore casuale compreso tra 2 e 6. Ci aggiunge rumore ai nostri dati e la procedura di approssimazione avr un po’ di lavoro da fare.

Dentro la scatola nera

Potete considerare il vostro foglio di lavoro come una scatola nera , come gli ingegneri chiamano un dispositivo di cui si preoccupano unicamente degli input e degli output e non del suo funzionamento. Tutto ci che dovete fare digitare i vostri dati in due vettori chiamati e e andare alla fine del foglio di lavoro per vedere i coefficienti e e costruire un grafico con i dati e la curva approssimante.

Se avete coppie di dati , la regressione esponenziale avvicina i valori con un’espressione della forma . Mathcad pu rapidamente trovare i migliori valori per le costanti e . Esso usa una funzione sofisticata genfit , che rende la somma dei quadrati degli errori nella vostra approssimazione pi piccola possibile.

Regressione esponenziale animata con Mathcad

Carlo Elce

Onde

La somma di due onde in opposizione di fase produce un’onda stazionaria.

Per rendertene conto clicca sul pulsante a lato

equazione di un onda retrograda

equazione di un onda progressiva

variabile temporale

variabile spaziale

Equazione di un’onda: funzione della variabile temporale e della variabile spaziale
con Mathcad (Carlo Elce)

Integrazione trapezi

Per vedere l’animazione in una modalit controllata dal mouse clicca sul grafico seguente

Errore

Calcolo numerico con la formula

dei trapezi

Valore dell’integrale definito da calcolare

Determinazione dei punti su cui valutare
la funzione da integrare

h inizialmente vale 2 perch N vale 2

Ampiezza variabile delle suddivisioni

Numero variabile di suddivisioni dell’intervallo di integrazione

Estremi dell’intervallo di integrazione

Funzione da integrare

Integrazione Numerica con Mathcad mediante il Metodo dei Trapezi

Integrale virgola mobile

>>>>

Calcolo in virgola mobile con Mathcad dell’integrale indicato

(Carlo Elce)

Generalmente, il processore simbolico di Mathcad restituisce i risultati senza tenere conto della precisione numerica, cos i termini non vengono ridotti. Se digiti la parola riservata " float " , oppure se scegli dal menu Symbolics Evaluate Floating Point , o ancora se clicchi su float dal menu View Symbolic float Mathcad restituisce i valori numerici dei risultati con la precisione desiderata.
Inoltre puoi forzare il calcolo dei risultati in virgola mobile usando un parametro k.
Per rendertene conto clicca sul pulsante a lato

Fattoriale

Per vedere il programma in azione clicca sull’icona alla tua destra

Fattoriale di 1

Inizialmente FRAME vale 0 e pertanto n vale 1

Codifica dell’algoritmo di calcolo

Numero intero variabile di cui si vuole calcolare il fattoriale

FRAME variabile incorporata di Mathcad

Programma Mathcad per il calcolo del Fattoriale come funzione Iterativa

Per vedere il programma in azione clicca sull’icona alla tua destra

Fattoriale di 0

Inizialmente FRAME vale 0 e pertanto in questo caaso n vale 1

Codifica dell’algoritmo di calcolo

Numero intero variabile di cui si vuole calcolare il fattoriale

FRAME variabile incorporata di Mathcad

Programma Mathcad per il calcolo del fatt oriale come funzione ricorsiva

Il fattoriale di un numero intero pu essere calcolato con un procedimento ricorsivo o con un procedimento iterativo.

Mathcad consente di usare sia un algoritmo ricorsivo sia un algoritmo iterativo.

Il fattoriale di un numero intero n il prodotto dei primi n numeri interi e si indica con n!

Esso rappresenta il numero delle permutazioni semplici di n oggetti.

Nota
Per inserire del testo con Mathcad basta digitare da tastiera i caratteri che compongono le parole da riportare.
Per le equazioni bisogna avvalersi della Toolbar Calculator e della Evaluation Toolbar, ivece per fare la codifica con Mathcad degli algoritmi di calcolo del fattoriale bisogna servirsi della Programming Toolbar.
Nel file tutto ci che compare di colore marrone o viola testo puro semplice, mentre tutto ci che appare evidenziato in giallo stato digitato mediante le Toolbars di cui sopra.

Calcolo del fattoriale di un numero intero mediante programmazione con Mathcad

( Carlo Elce )

Fattori primi

Per vedere il programma in azione clicca sul pulsante a lato

La routine successiva trova i fattori primi (con i loro esponenti) dell’intero variabile n . Da notare che la routine include, nella lista dei suoi argomenti, il vettore P, determinato precedentemente, dei numeri primi minori o uguali a n .