Mele e pere

In questo articolo Hume si occupa di microeconomia: domanda ed offerta di prodotti di consumo. La nozione di curve di domanda e offerta è già stata trattata da Hume e Smith in precedenti articoli di Matematicamente.it (Ragnatela, Monopolio od oligopolio).

 

Non è raro che il mercato offra due o più prodotti tra loro intercambiabili, che definiamo sostituti, ad esempio pane/grissini, oppure vino/birra. Ogni consumatore consuma quantità a piacere dell’uno e/o dell’altro secondo la sua preferenza ma anche tenendo conto del loro prezzo. Per ognuno dei sostituti è dunque possibile tracciare un diagramma che riporta le curve di domanda e offerta, l’incrocio delle quali individua la posizione di equilibrio di mercato. Tuttavia fattori esogeni – vale a dire estranei alla volontà di produttori e consumatori – possono spostare le curve di domanda o di offerta. In tal modo si modifica il mercato, che raggiungerà un nuovo equilibrio, caratterizzato da nuovi prezzi e quantità per ciascun dei sostituti.
L’esempio che riportiamo di seguito ci può aiutare a spiegare come potrebbe evolvere il mercato di due tipi di frutta.

Produzione e consumo di mele e pere

Mare del Nord. In un’isola molto lontana dal continente vive una popolazione semplice e attiva, dedita tradizionalmente alla pesca e all’agricoltura. Il clima è piuttosto freddo e piovoso. In particolare il suolo/clima si presta alla produzione abbondante di mele e pere, entrambe di qualità pregiata, in quantità più che adeguata a soddisfare il fabbisogno degli isolani; la piccola rimanenza (che qui supponiamo trascurabile) viene esportata sul continente. Non ci sono altri tipi di frutta, se non di importazione, ma sono piuttosto cari, anche per i notevoli costi di trasporto. Di fatto gli isolani, di certo non benestanti, si accontentano della frutta locale. Quest’anno una malattia (fattore esogeno) ha danneggiato pesantemente gli alberi da pera dell’isola, riducendone in modo rilevante la produzione.
Desideriamo valutarne l’effetto sulla produzione totale della frutta (lato offerta) e sui consumatori (lato domanda), nell’ipotesi di concorrenza perfetta, vale a dire quando esiste un gran numero di produttori e consumatori, tale che nessuno, singolarmente, può condizionare il mercato. In altre parole vogliamo capire come potrebbero evolvere nel tempo quantità, prezzi, spesa per i due tipi di frutta, a causa della malattia dei peri.

Assumiamo come anno 1 quello che precede la malattia dei peri, anno 2 quello della malattia. Ora tracciamo le curve di domanda (D) e offerta (S) di pere e mele per i due anni. Cominciamo dalle pere (diagramma seguente.)

Diagramma prezzo pere in funzione domanda e offerta

Le curve riportano in ascisse la quantità (domanda e offerta), in ordinate il prezzo. Come sappiamo la curva S è crescente (al crescere del prezzo di mercato i produttori desiderano ad aumentare la produzione) mente la curva D è decrescente (al crescere del prezzo di mercato i consumatori desiderano acquistare una quantità minore). Sappiamo che il punto di equilibrio di mercato si ottiene, anno per anno, incrociando domanda ed offerta di mercato. Notiamo che nel diagramma delle pere vengono riportate due curve di offerta. La prima (S1, in rosso) si riferisce all’anno precedente la malattia, la seconda (S2, in verde) si riferisce all’offerta nell’anno della malattia. La curva S2 si ottiene traslando la curva S1 a sinistra di una quantità pari alla perdita di produzione causata dalla malattia. Mentre esiste una sola curva di domanda, dal momento che l’attitudine dei consumatori all’acquisto di pere non è cambiato, nonostante l’offerta si sia ridotta.

Esaminiamo ora il diagramma analogo per le mele (sotto). Qui vediamo che esiste una sola curva di offerta(S) e due curve di domanda (D1, D2). Perché due curve di domanda? Per il semplice motivo che essendo la mela un sostituto, vale a dire un’alternativa alla pera, a causa del calo di offerta di pere, nell’anno 2 i consumatori tenderanno a richiedere una quantità maggiore di mele. In qualche modo per compensare, almeno parzialmente, la scarsità di pere.

Diagramma prezzo mele in funzione domanda e offerta

Da un punto di vista geometrico diciamo che la curva (blu) di domanda delle mele dell’anno1 è slittata a destra di una certa quantità, diventando in tal modo la curva in rosso. Questo ragionamento intuitivo interpreta il presumibile atteggiamento razionale dei consumatori. E’ questa una caratteristica generale della teoria economica.
Ora, tuttavia, vogliamo passare dal qualitativo al quantitativo. In altre parole desideriamo esprimere quanto detto con formule e numeri. E determinare il punto di incrocio delle curve di domanda e offerta, vale a dire calcolare le quantità effettive ed i prezzi effettivi per i due tipi di frutta in entrambi gli anni.
Qui le cose sembrano meno facili ed è probabile che non si possa dare una risposta univoca.

Cominciamo a considerare domanda e offerta dei due tipi di frutta nell’anno 1. E’ presumibile che il mercato sia rimasto abbastanza stabile anche negli anni precedenti. Ripetute analisi di mercato tra gli isolani hanno permesso di stimare quantitativamente le curve di domanda e offerta per entrambi i tipi di frutta nell’anno 1. Conosciamo, dunque, le seguenti equazioni(rette) – rispettivamente di domanda e offerta- nell’anno 1:

Pere: $p = a – bq$ (domanda) $p = c + dq$ (offerta)
Mele: $P = f – gQ$ (domanda) $P = i + lQ$ (offerta)

dove abbiamo indicato con lettere minuscole prezzo e quantità per le pere, con lettere maiuscole le stesse grandezze per le mele.
Conosciamo inoltre (immaginiamo, idealmente, di aver intervistato tutti i produttori) l’offerta di pere per l’anno 2, a seguito della malattia: $p = e + dq$

Confrontiamo ora le due curve di offerta delle pere:

$p = c +dq$ (anno 1)
$p = e + dq$ (anno 2)

Sono due rette parallele (identico coefficiente angolare d). Con facili considerazioni di geometria analitica si vede che la seconda si ottiene traslando la prima a sinistra della quantità $(e – c)/d$ che rappresenta la perdita di produzione dell’anno 2 rispetto al precedente.
Notiamo che tutte le costanti (a, b, c, d, e, f, g, i, l, parametri delle rette) finora introdotte sono note.

Passiamo ora a tracciare le curve di domanda per le mele per l’anno 2. Essa è rappresentata dall’equazione: $P = h – gQ$ che è parallela alla curva dell’anno precedente. Dove però appare un’incognita, il valore dell’ordinata all’origine, h.
Decidiamo, per il momento, di accantonare il fatto che il parametro h è incognito e troviamo la posizione di equilibrio di mercato negli anni 1 e 2. Tutto questo è molto semplice. Basta risolvere i due seguenti sistemi lineari:

Equilibrio pere, anno 1:

$p = a – bq$
$p = c + dq$

Soluzione: $q1 = (a-c)/(b+d)$    (1)      $p1 = c+d(a-c)/(b+d)$   (2)

Equilibrio mele, anno 1:

$P = f – gQ$
$P = i + lQ$
Soluzione: $Q1 = (f – i)/(g+l)$   (3)      $P1 = f – g(f – i)/(g+l)$ (4)

In questo modo abbiamo determinato in modo semplice e completo la condizione di equilibrio di mercato nell’anno 1.

Facciamo lo stesso per l’anno 2:

Equilibrio pere, anno 2:

$p = a – bq$
$p = e + dq$

Soluzione: $q2 = (a-e)/(b+d)$   (5)      $p2 = a-b(a-e)/(b+d)$   (6)

Equilibrio mele, anno 2:

$P = h – gQ$
$P = i + lQ$

Soluzione: $Q2 = (h– i)/(g+l)$   (7)      $P2 = i + l(h – i)/(g+l)$   (8)

Ci ricordiamo ora che il punto di equilibrio del mercato delle mele per l’anno 2, equazioni (7) e (8), è funzione dell’incognita h. Come possiamo determinare questa incognita? Formulando delle ipotesi ragionevoli sul comportamento dei consumatori.

CASO A

Immaginiamo che i consumatori tendano, più o meno consapevolmente, a mantenere per l’anno 2 lo stesso consumo di frutta dell’anno precedente. Valutiamo questo comportamento come una necessità dietetica: mantenere costante l’apporto nutritivo dei componenti della frutta. Questa condizione si esprime in formule nel seguente modo: $q1 + Q1 = q2 + Q2$

Posto ora: $k1 = q1 + Q1$ si ha: $k1 = q2 + Q2$

Sommiamo ora le (5) e (7):

$q2 +Q2 = (a-e)/(b+d) + (h – i)/(g+l) = k1$

E risolvendo rispetto a h:

$h = i + (g + l)[k1 – (a-e)/(b+d)] = = i + (g + l)[q1 + Q1 – (a-e)/(b+d)]$

Che può essere inserito nelle (7) e (8) per determinare $P2$ e $Q2$.
Il file Excel allegato riporta i dati( su sfondo giallo) ed i risultati dei calcoli. Qui vogliamo solo evidenziare che per mantenere costante il consumo di frutta i consumatori devono aumentare del 41% la spesa complessiva in frutta. Non poco.

CASO B

E’ anche possibile che i consumatori si comportino diversamente dal Caso A, privilegiando il lato economico. Abbiamo detto prima che gli isolani non sono affatto benestanti. Se per mantenere costante la quantità di frutta devono aumentarne la spesa, dovranno ridurre qualche altro genere di consumo o servizio forse più importante. Facciamo dunque l’ipotesi che i consumatori vogliano mantenere costante la spesa per frutta. Questo si traduce nella seguente equazione:

$p1q1 +P1Q1 = p2q2 + P2Q2$

Poniamo $k2 = p1q1 +P1Q1$ e introduciamo a secondo membro le (7) e (8):

$k2 = [a-b(a-e)/(b+d)](a-e)/(b+d) + [i – l(h – i)/(g+l)](h – i)/(g+l)$

Se poniamo $k3 = [a-b(a-e)/(b+d)](a-e)/(b+d)$ otteniamo:

$k2 = k3 + i(h – i)/(g+l) + l[(h – i)/(g+l)]^2$

Ora poniamo $(h – i)/(g+l) = x$ e avremo: $k2 = k3 + ix + lx^2$

Vale a dire: $lx^2 + ix + (k3 – k2) = 0$

L’equazione di 2° grado ha due radici:

$x = [ – i +- sqrt(i^2 – 4l(k3 – k2))]/(2l)$

Dalle quali, in corrispondenza ai due valori di x, si ricavano due valori di h:

$h = i + x(g + l)$

Il già citato file Excel riporta i calcoli. Si ottengono due soluzioni, una positiva, l’altra negativa (priva di significato). Si determinano quindi P2 e Q2. La soluzione così trovata comporta tuttavia una riduzione del consumo di frutta del 14% rispetto all’anno precedente.

CASO C

Esiste infine la possibilità che gli isolani preferiscano mantenere costante il prezzo medio della frutta. Esso è dato dal rapporto tra spesa totale e quantità totale(acquistata).
L’equazione che esprime questa condizione è la seguente:

$(p1q1 +P1Q1)/(q1 + Q1) = (p2q2 + P2Q2)/(q2 + Q2)$

Poniamo:

$PM1 = (p1q1 +P1Q1)/(q1 + Q1)$ (prezzo medio iniziale)

Ora introduciamo nella precedente equazione le (5), (6), (7), (8):

$PM1 = (a-e)/(b+d)[a-b(a-e)/(b+d)] + (h-i)/(g+l)[i +l(h-i)/(g+l)] / [(a-e)/(b+d) + (h-i)/(g+l)]$

Posto: $k4 = (a-e)/(b+d)[a-b(a-e)/(b+d)]$ si ottiene:

$PM1*(a-e)/(b+d) + PM1*(h-i)/(g+l) = k4 + (h-i)/(g+l)[i +l(h-i)/(g+l)]$

Infine poniamo: $k5 = PM1*(a-e)/(b+d)$ ed inoltre: $x = (h-i)/(g+l)$

E l’equazione diventa: $k5 + PM1*x = k4 +x(i + lx)$

Vale a dire l’equazione di 2° grado:

$lx^2 +(i – PM1)x +(k4 – k5) = 0$

Soluzioni: $x = [ – (i – PM1) +- sqrt((i – PM1)^2 – 4l(k4 – k5))]/(2l)$

Che danno luogo a due diversi valori di h:

$h = i + x(g + l)$

Anche qui una sola delle due soluzioni ha significato (la positiva). Si ottiene quindi:

$h = f – x(g +l)$ e da essa P2 e Q2.

Il file Excel riporta i risultati. In questo caso il risultato è un po’ paradossale: per mantenere il prezzo medio costante si avrà una riduzione sia del consumo che della spesa per frutta.

Si può anche immaginare che i tre casi( vale a dire i tre tipi di comportamento dei consumatori) si ripartiscano in egual misura tra la popolazione dell’isola. In tal caso si può calcolare la media, come riportato – in sintesi- in tabella e diagramma. La media è quasi coincidente con il caso B (spesa costante).

Tabella comportamento consumatori di mele e pere


download Mele e pere
Foglio Excel con tutti i dati e i risultati dell’analisi sul comportamento dei consumatori di pere e mele in funzione del prezzo.

Virus e sicurezza informatica: Keylogger, una nuova prospettiva

Cos’è un keylogger? Il keylogger software è un particolare software che ha il compito di catturare e salvare tutti i tasti che l’utente preme sulla tastiera. (Esistono anche keylogger hardware, piccoli dispositivi che si collegano tra computer e tastiera e salvano al loro interno i dati passanti dal cavo).

Il keylogger non è di per sé un malware, ma può diventarlo se viene programmato per funzionare all’insaputa dell’utente e soprattutto se viene utilizzato per raccogliere dati non propri.

Rischi

Se un computer viene infettato con un keylogger programmato in modo da inviare i dati raccolti al creatore del software senza il consenso dell’utente, i danni derivanti dalla violazione della privacy possono essere molto gravi.
Se ad esempio viene infettato il computer di un medico, tutte le informazioni sensibili dei pazienti possono essere violate, ma anche un normale utente che controlla il suo conto bancario online potrebbe consegnare i suoi dati d’accesso al programmatore del software.

Un esempio concreto

Adesso vedremo com’è fatto un keylogger e come funziona su una nuova installazione di Windows 7.

Programmazione di un keylogger

Per questo articolo ho scritto un semplice keylogger in Python.

Python keylogger source code

Questo piccolo keylogger, una volta avviato, non fa altro che salvare nel file “keys_logged.txt” sul desktop tutti i tasti premuti sulla tastiera in qualsiasi altro programma.

Proviamo adesso a navigare in rete con il keylogger attivato per vedere cosa succede

Home page sito Matematicamente.it

Gmail login

Dopo aver visitato Matematicamente.it e GMail vediamo cosa ha raccolto il keylogger: Figura dell'output del keylogger

Esattamente tutto ciò che abbiamo scritto!

Contromisure

Le contromisure sono più o meno le stesse degli altri malware, ovvero antivirus sempre aggiornato e mai scaricare ed eseguire file sospetti.

 

Andrea Carriero | BTBH
/https://btbh.net
/https://codethinker.net
[email protected]

 

DNS Spoofing e Phishing: rischi per WiFi non protetta

Cosa succede quando lasciamo la nostra rete Wifi aperta e senza password? Cosa può fare qualcuno che si connette senza il nostro permesso? Quali pericoli corrono gli utenti della rete locale?

Spesso sento parlare di persone che lasciano la propria rete wireless senza password di protezione giustificando questa scelta con il fatto di avere una tariffa flat, ovvero non a consumo e senza limiti.
Questo ragionamento è sbagliato e potenzialmente dannoso poiché un intruso in una rete wifi può svolgere attività peggiori di quelle che ci si aspetta.

I rischi che si corrono sono davvero tantissimi ma in questo articolo ne analizzeremo uno, a mio parere, molto interessante.
Si tratta di ARP Poisoning e DNS Spoofing in relazione al Phishing. Vedremo ora cosa significa.

 

Cos’è un DNS

Partiamo dall’inizio: quando noi visitiamo un sito web siamo abituati a cercare e a vedere questo con il suo nome di dominio, per esempio google.it o facebook.com.
Ogni sito web si trova su un server che non è altro che un potente computer che custodisce il sito ed i suoi dati.
Ogni computer e server ha un indirizzo chiamato indirizzo IP.
Il sistema che collega il nome di dominio “in lettere” all’indirizzo IP “in cifre” è chiamato DNS.
DNS è un acronimo che sta per Domain Name System ovvero Sistema dei Nomi di Dominio.

Esempio

Troviamo l’indirizzo IP di Google:

Ping IP di Google.it

Visitiamolo come se fosse un normale sito web:

Visita IP di Google.it

Com’è possibile vedere, visitare il sito attraverso il suo nome di dominio o attraverso il suo indirizzo IP porta allo stesso risultato e potete provare anche voi cliccando qui: 173.194.116.47.
Questo è possibile perché i server DNS associano google.it a 173.194.116.47

 

DNS Spoofing

Il DNS Spoofing è una tecnica (derivata dall’ARP Poisoning) che permette a un utente all’interno di una rete locale di “ingannare” i dispositivi presenti con delle associazioni modificate tra nomi di dominio ed indirizzi IP.
Questo vuol dire che ad esempio il nome di dominio facebook.com può essere associato con l’indirizzo IP di un server dannoso senza che l’utente della rete possa accorgersene con conseguenti rischi per la privacy e la sicurezza.

 

Phishing

Il Phishing è una tecnica che permette ad un utente di “clonare” un sito web modificandolo in modo tale da poter ricevere, ad esempio per email, i parametri d’accesso che i visitatori inseriscono.

 

Cosa lega DNS Spoofing, Phishing e una rete non protetta?

Immaginiamo questa situazione: un utente trova una rete Wifi senza protezione, si collega e utilizzando la tecnica di cui ho parlato sopra associa i nomi di domini di webmail (per esempio libero.it, hotmail.it, gmail.com ecc.), banche e social network all’IP del suo server. Tutti gli altri utenti della rete saranno a loro insaputa collegati al server pronto per rubare le credenziali pur continuando a vedere l’URL corretto e “consegneranno” i propri parametri d’accesso al creatore della trappola.

Vediamo ora l’esempio concreto:

Comando ifconfig

Impostiamo la scheda di rete in modo tale da poter ricevere i “pacchetti” di dati di qualsiasi dispositivo.

Record DNS fasulli per Facebook

Prepariamo la nuova associazione tra facebook.com e l’indirizzo IP dannoso (da inviare nella rete) sostituendolo con 192.168.1.70 ovvero quello del computer dell’attaccante.

Avviamo lo strumento che immetterà in rete le false associazioni dominio IP

Comando ettercap

Assicuriamoci che l’operazione sia andata a buon fine:

Falso sito di Facebook

Perfetto, adesso tutti i dispositivi che cercheranno di collegarsi a facebook.com si connetteranno in realtà al nostro computer.

Output comando ettercap

Adesso non rimane che costruire il “sito-trappola” per catturare i dettagli d’accesso degli utenti che si connetteranno a facebook.com all’interno della rete. Per farlo utilizzeremo S.E.T. Social Engineer Toolkit.

Visitiamo il sito apparentemente reale di facebook.com

Come si può notare nella barra degli indirizzi è sempre presente il reale nome di dominio facebook.com mentre il contenuto della pagina è quello presente sul nostro computer, infatti una volta eseguito il login, i dati contenuti nei campi “email” e “password” saranno salvati sul nostro computer senza che l’utente che visita il sito si accorga di nulla.

Email e password di Facebook

Questo è solo un esempio delle centinaia di implicazioni che può avere il lasciare una rete Wi-Fi aperta ma rende perfettamente l’idea di quanto possano essere “potenti” e dannosi per la privacy questi tipi di attacchi. Si pensi allo stesso processo per un sito bancario.

 

Come difendersi

Difendersi da questo tipo di pericoli non è sempre semplice perché ogni giorno vengono scoperti nuovi sistemi per aggirare le protezioni, ma il mio consiglio è quello di proteggere la propria rete con una password molto complessa e di collegarsi sempre ai siti web utilizzando il protocollo https che non può essere compromesso.

 

Andrea Carriero | BTBH
https://btbh.net
https://codethinker.net
[email protected]

Java: test sottomatrice di una matrice

Tema 106

Scrivere un metodo verificaCheUnaMatriceSiaContenutaInUnAltraMatrice che riceve in ingresso due matrici di interi M e Q e restituisce TRUE se la matrice di dimensione minore è interamente contenuta nella matrice di dimensione maggiore. Gli elementi della matrice minore, all’interno della maggiore, devono essere disposti nello stesso ordine e in maniera attigua.

Ad esempio, siano M e Q le matrici così costituite

1 2 3 4
5 6 7 8
4 1 2 9
2 3
6 7

allora verificaCheUnaMatriceSiaContenutaInUnAltraMatrice (M, Q) = TRUE

 public class tema106{ // approntiamo un metodo di supporto per estrarre sottomatrici a partire // dall’elemento  di posizione  x,y // tale metodo ci servirà per isolare momentaneamente dalla matrice di // dimensione maggiore, delle // sottomatrici di dimensione pari alla matrice di dimensione minore, per // confrontarla con gli elementi // di quest’ultima public static int[][] estraiMatrice (int[][] M, int[][] Q, int x, int y){ // questo metodo riceve in ingresso la matrice M in cui bisogna fare la ricerca // la matrice Q che va ricercata all’interno di M // e due interi che rappresenteranno di volta in volta le coordinate // dell’elemento dal quale bisognerà // iniziare a estrarre la sottomatrice // i due interi, cioè le coordinate, saranno acquisiti dagli indici dei cicli // con cui, nel metodo generale // sarà perlustrata la matrice di partenza int [][] N = new int[Q.length][Q[0].length]; int riga = 0; // avendo l’esigenza di estrarre sottomatrici della dimensione di Q, // naturalmente i due cicli non // devranno superare le dimensioni della matrice Q, perciò gli indici non // andranno oltre i valori, // rispettivamente di x+Q.length e y+Q.length for (int i = x; i < x+Q.length; i++){ int col = 0; for (int j = y; j 

Java: sottomatrice con elementi di indici pari o dispari

Tema 105

Scrivere un metodo eliminaUltimaColonnaEdEstraiElementiConIndiciEntrambiPariOdispari che riceve una matrice quadrata di interi M e restituisce una sottomatrice escludendo l’ultima colonna se la dimensione è dispari e contenente solo gli elementi di M i cui indici di riga e di colonna sono entrambi pari oppure entrambi dispari.

Ad esempio, sia M la matrice così costituita

3 18 15 7 2
1 9 11 4 6
7 2 6 3 5
5 1 25 2 1
3 2 33 4 4

allora eliminaUltimaColonnaEdEstraiElementiConIndiciEntrambiPariOdispari (M) darà

3 15
9 4
7 6
1 2
3 33

 public class tema105{ public static int[][]eliminaUltimaColonnaEdEstraiElementiConIndiciEntrambiPariOdispari (int[][] M){ // dichiariamo una nuova matrice con righe pari a quelle di M e colonne pari a // metà di quelle di M int[][] nuovaMatrice = new int[M.length][M.length/2]; // prepariamo un intero che inizializzeremo in modo opportuno per eliminare // l’ultima colonna // nel caso in cui la dimensione di M sia dispari int discriminante; // verifichiamo se la dimensione della matrice è pari o dispari if (M.length % 2 == 1) // nel caso la dimensione sia dispari poniamo il valore del discriminante a 1 discriminante = 1; else discriminante = 0; // iniziamo a scorrere la matrice M riga per riga for (int i = 0; i < M.length; i++){ // inizializziamo un indice per scorrere le colonne della nuova matrice int indice = 0; for (int j = 0; j < M.length-discriminante; j++) // appena sarà trovato un elemento i cui indici siano entrambi pari o entrambi // dispari if (i % 2 == j % 2){ // tale element sarà collocate nella nuova matrice nuovaMatrice[i][indice] = M[i][j]; indice++;} } return nuovaMatrice; }  public static void visualizzaMatrice (int[][] M) { for (int i = 0; i < M.length; i++) { for (int j = 0; j < M[i].length; j++) System.out.print(M[i][j]+ " "); System.out.println();} } /* Applicazione di prova */  public static void main(String[] args){ int[][] M = {{3,18,15,7,2}, {1,9,11,4,6}, {7,2,6,3,5}, {5,1,25,2,1}, {3,2,33,4,4}}; visualizzaMatrice (eliminaUltimaColonnaEdEstraiElementiConIndiciEntrambiPariOdispari (M)); } }     

Java: eliminazione diagonale di una matrice

Tema 104

Scrivere un metodo creaMatriceEscludendoElementiDiagonalePrincipale che riceve una matrice di interi M e restituisce una matrice ottenuta da M eliminando gli elementi che appartengono alla diagonale principale.

Ad esempio, sia M la matrice così costituita

3 18 15 7 2
1 9 11 4 6
7 2 6 3 5
5 1 25 2 1
3 2 33 4 4

allora creaMatriceEscludendoElementiDiagonalePrincipale (M) darà

18 15 7 2
1 11 4 6
7 2 3 5
5 1 25 1
3 2 33 4

 public class tema104{ public static int[][] creaMatriceEscludendoElementiDiagonalePrincipale (int[][] M){ // creiamo una nuova matrice con ugual numero di righe di M e numero di colonne // diminuito di 1 int[][] nuovaMatrice = new int[M.length][M.length-1]; // approntiamo gli indici per scorrere le celle della nuova matrice int r = 0; int c; // avviamo i cicli per scorrere la matrice M riga per riga for(int i = 0; i < M.length; i++){ // inizializziamo l’indice di colonna della nuova matrice c = 0; // accediamo agli elementi di M for(int j = 0; j < M.length; j++) // escludiamo solo gli elementi i cui indici di riga coincidono con gli indici // di colonna if(j != i) { nuovaMatrice[r][c] = M[i][j]; // incrementiamo gli indici della nuova matrice c++;} r++;} return nuovaMatrice; }  public static void visualizzaMatrice (int[][] M) { for (int i = 0; i < M.length; i++) { for (int j = 0; j < M[i].length; j++) System.out.print(M[i][j]+ " "); System.out.println();} }  /* Applicazione di prova */  public static void main(String[] args){ int[][] M = {{3,18,15,7,2}, {1,9,11,4,6}, {7,2,6,3,5}, {5,1,25,2,1}, {3,2,33,4,4}}; visualizzaMatrice (creaMatriceEscludendoElementiDiagonalePrincipale (M)); } }     

Java: eliminazione di colonne con valori non in un intervallo

Tema 103

Scrivere un metodo creaMatriceEscludendoColonneConElementiMinoriOmaggioriDeiParametri che riceve in ingresso una matrice di interi M e due numeri interi min e max, e restituisce una matrice ottenuta eliminando da M tutte le colonne che presentano almeno un valore minore di min o maggiore di max.

Ad esempio, sia M la matrice così costituita

3 18 15 7
1 9 11 4
7 8 6 8
5 60 25 9

allora creaMatriceEscludendoColonneConElementiMinoriOmaggioriDeiParametri (M, 4, 45)

15 7
11 4
6 8
25 9

 public class tema103{ public static int[][]creaMatriceEscludendoColonneConElementiMinoriOmaggioriDeiParametri (int[][] M, int min, int max){ // creiamo una matrice temporanea con dimensione pari alla stessa matrice M, in // cui inseriremo gli elementi // che soddisfano il requisito; la scelta sulla dimensione è data dal fatto che // potrebbe verificarsi // il caso in cui non vada esclusa nessuna colonna int[][] matriceTemporanea = new int[M.length][M.length]; // creiamo un indice per scorrere le colonne della nuova matrice int indiceColonna = 0; // cominciamo a scorrere la matrice M colonna per colonna for (int j = 0; j < M.length; j++){ // ci serviamo di una variabile boolean per stabilire se una colonna è da // rimuovere boolean colonnaDaRimuovere = false; for (int i = 0; i < M.length; i++){ // controlliamo se esistono elementi che soddisfano il requisito if (M[i][j] < min || M[i][j] > max) // in tal caso poniamo il valore della variabile a TRUE colonnaDaRimuovere = true; } // nel caso contrario if (!colonnaDaRimuovere) { // scorriamo le varie colonne for (int i = 0; i < M.length; i++){ // trasferiamo gli elementi di M nella matrice temporanea matriceTemporanea[i][indiceColonna] = M[i][j];} // e incrementiamo l’indiceColonna indiceColonna++; } } // prepariamo adesso la matrice finale con la giusta dimensione int[][] matriceFinale = new int[M.length][indiceColonna]; // scorriamo la matrice for (int i = 0; i < M.length; i++){ for (int j = 0; j < indiceColonna; j++){ // e trasferiamo gli elementi che erano stati collocati nella matrice temporanea // nella matrice finale matriceFinale[i][j] = matriceTemporanea[i][j];} } return matriceFinale; }  public static void visualizzaMatrice (int[][] M) { for (int i = 0; i < M.length; i++) { for (int j = 0; j < M[i].length; j++) System.out.print(M[i][j]+ " "); System.out.println();} }  /* Applicazione di prova */  public static void main(String[] args){ int[][] M = {{3,18,15,7}, {1,9,11,4}, {7,8,6,8}, {5,60,25,9}}; visualizzaMatrice (creaMatriceEscludendoColonneConElementiMinoriOmaggioriDeiParametri (M,4,45)); } }     

Java: elementi comuni riga e colonna di una matrice

Tema 102

Scrivere un metodo creaArrayConElementiComuniInRigaEcolonnaDateDaParametri che riceve una matrice di interi M e due numeri n e k e restituisce un array contenente gli elementi presenti sia nella riga n che nella colonna k.

Ad esempio, sia M la matrice così costituita

3 18 15 7 2
1 9 11 4 6
7 2 6 3 5
5 1 25 2 1
3 2 33 4 4

allora creaArrayConElementiComuniInRigaEinColonnaDateDaParametri (M,1,2)

11 6

 public class tema102{ static int[] creaArrayConElementiComuniInRigaEinColonnaDateDaParametri (int[][] M, int n, int k){ // creiamo un array temporaneo con dimensione pari alla stessa matrice in cui // inseriremo gli elementi // che soddisfano il requisito; la scelta sulla dimensione è data dal fatto che // potrebbe verificarsi // il caso in cui gli elementi della riga siano tutti uguali a quelli della // colonna int[] arrayTemporaneo = new int[M.length]; // inizializziamo un indice per scorrere l'array int indiceArray = 0; for (int i = 0; i < M.length; i++){ for (int j = 0; j < M.length; j++){ if (M[n][i] == M[j][k]){ // ci serviamo di una variabile boolean per stabilire se un elemento è già stato // inserito nell'array boolean giàInserito = false; for (int c = 0; c < arrayTemporaneo.length; c++) { if (arrayTemporaneo[c] == M[n][i]) giàInserito = true; } // se l'elemento in questione non è stato ancora inserito nell'array if (!giàInserito){ // provvediamo a inserirlo arrayTemporaneo[indiceArray] = M[n][i]; // e incrementiamo la dimensione dell’array indiceArray++;}} } } // adesso creiamo l'array finale con la giusta dimensione int[] arrayFinale = new int[indiceArray]; for (int i = 0; i < arrayFinale.length; i++){ // trasferiamo gli elementi dall'array temporaneo all'array finale arrayFinale[i] = arrayTemporaneo[i]; } return arrayFinale; } 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){ int[][] M = {{3,18,15,7,2}, {1,9,11,4,6}, {7,2,6,3,5}, {5,1,25,2,1}, {3,2,33,4,4}}; visualizzaArray (creaArrayConElementiComuniInRigaEinColonnaDateDaParametri (M,1,2)); } }     

Java: test elementi multipli in una matrice

Tema 101

Scrivere un metodo verificaSeNellaMatriceCiSonoElementiMultipliDiAltri che riceve una matrice di interi M e restituisce TRUE se M contiene elementi che sono multipli di altri elementi presenti nella matrice; FALSE altrimenti.

Ad esempio, sia M la matrice così costituita

3 18 15 7 2
1 9 11 4 6
7 2 6 3 5
5 1 25 2 1
3 2 33 4 4

allora verificaSeNellaMatriceCiSonoElementiMultipliDiAltri (A) = TRUE

 public class tema101{ // usiamo un metodo di supporto che verifica se un numero è multiplo di qualche // elemento di una matrice public static boolean isMultiplo (int k, int[][] M){ // prepariamo un contatore che sarà incrementato ogni volta che il numero // risulterà multiplo di un elemento int contatoreMultipli = 0; // scorriamo la matrice riga per riga for (int i = 0; i < M.length; i++){ for (int j = 0; j < M.length; j++){ // effettuiamo il controllo if (k % M[i][j] == 0) // ed eventualmente aggiorniamo il contatore  contatoreMultipli++;} } // se il numero è risultato multiplo di qualche elemento e quindi il contatore // sarà maggiore di 1 // poniamo a TRUE un’opportuna variabile boolean boolean multipli; if (contatoreMultipli > 1) multipli = true; else multipli = false; return multipli; }  public static boolean verificaSeNellaMatriceCiSonoElementiMultipliDiAltri (int[][] M){ boolean multipli = false; // scorriamo la matrice for (int i = 0; i < M.length; i++){ for (int j = 0; j < M.length; j++){ // verifichiamo che qualche element di M sia multiplo di qualche element della // stessa matrice col metodo // definito precedentemente if (isMultiplo (M[i][j], M)) // in caso affermativo ponimo a TRUE  una variabile boolean multipli = true;} } return multipli; } /* Applicazione di prova */  public static void main(String[] args){ int[][] M = {{3,18,15,7,2}, {1,9,11,4,6}, {7,2,6,3,5}, {5,1,25,2,1}, {3,2,33,4,4}}; System.out.println(verificaSeNellaMatriceCiSonoElementiMultipliDiAltri (M));  // il risultato sarà TRUE System.out.println(); int[][] Q = {{31, 2, 3}, {5, 7, 11}, {13, 17, 19}}; System.out.println(verificaSeNellaMatriceCiSonoElementiMultipliDiAltri (Q)); //il risultato sarà FALSE } }     

Java: elemento con maggior frequenza in una matrice

Tema 100

Scrivere un metodo trovaElementoConMaggioreFrequenzaInMatrice che riceve una matrice di interi M e restituisce l’elemento della matrice che compare più volte.

Ad esempio, sia M la matrice così costituita

1 2 3 7
4 5 2 3
4 2 6 1
5 2 4 6
9 5 4 4

allora trovaElementoConMaggioreFrequenzaInMatrice (M) = 4

 public class tema100 { // creiamo un metodo di supporto con cui calcolare la frequenza di ogni elemento public static int calcolaFrequenza (int[][]M, int k) { int cont = 0; for (int i = 0; i < M.length; i++) { for (int j = 0; j < M[0].length; j++) if(M[i][j] == k) cont++; } return cont; } // creiamo il meotodo conclusivo public static int trovaElementoConMaggioreFrequenzaInMatrice (int[][]M) { // dichiariamo una matrice della stessa dimensione di M in cui memorizzare la // frequenza di ciascun elemento int[][] matriceFrequenze = new int[M.length][M[0].length]; for (int i = 0; i < matriceFrequenze.length; i++) { for (int j = 0; j < matriceFrequenze[0].length; j++) // memorizziamo nella matrice le frequenze degli elementi calcolate col metodo // precedente matriceFrequenze[i][j] = calcolaFrequenza (M, M[i][j]); } //inizializziamo una variabile che useremo nella procedura di ricerca del valore //massimo della // matriceFrequenze int max = 0; // inizializziamo una variabile in cui memorizzeremo l’elemento della matrice // associato alla // frequenza più alta int elementoCorrispondente = 0; for (int i = 0; i < matriceFrequenze.length; i++) { for (int j = 0; j < M[0].length; j++) if( matriceFrequenze[i][j] > max) { max = matriceFrequenze[i][j]; elementoCorrispondente = M[i][j]; } } return elementoCorrispondente; }  /* Applicazione di Prova */  public static void main (String[] args) { int[][] Q = {{1, 2, 3, 7}, {4, 5, 2, 3}, { 4, 2, 6, 1 }, { 5, 2, 4, 6}, {9, 5, 4, 4}}; System.out.println (trovaElementoConMaggioreFrequenzaInMatrice (Q)); } }     

Java: estrazione elementi ripetuti p volte in una matrice

Tema 99

Scrivere un metodo creaArrayConElementiRipetutiEsattamentePvolte che riceve in ingresso una matrice M e un intero p e restituisce un array di interi contenente gli elementi presenti esattamente p volte in M.

Ad esempio, sia M la matrice così costituita

3 18 15 7 2
1 9 11 4 6
7 2 6 3 5
5 1 25 2 1
3 2 33 4 4

allora creaArrayConElementiRipetutiEsattamentePvolte (M,2) darà

7 6 5

 public class tema99{ // ci serviamo di un metodo di supporto per calcolare se un elemento è presente // più volte nella matrice public static int presenzaInMatrice (int k, int[][] M){ // inzializziamo un contatore che verrà incrementato ogni volta che un elemento // si ripete int contaPresenze = 0; for (int i = 0; i < M.length; i++){ for (int j = 0; j < M[0].length; j++){ if (M[i][j] == k) contaPresenze++;} } return contaPresenze; } public static int[] creaArrayConElementiRipetutiEsattamentePvolte (int[][] M, int p){ // creiamo un array temporaneo con dimensione massima data dal prodotto delle // due dimensioni // di M, nel caso p fosse uguale a 1 e gli elementi di M fossero tutti distinti int[] arrayTemporaneo = new int[M.length * M[0].length]; // prepariamo un indice per la scansione dell’array finale int indiceArray = 0; // cominciamo a scorrere gli elementi della matrice for (int i = 0; i < M.length; i++){ for (int j = 0; j < M.length; j++){ // verifichiamo con il metodo precedente se un elemento è presente esattamente p // volte if (presenzaInMatrice (M[i][j], M) == p){ // con una variabile boolean  controlliamo che lo stesso elemento non venga // inserito più volte nell’array boolean giàInserito = false; // scorriamo gli elementi dell’array for (int k = 0; k < M.length; k++){ // verifichiamo che nell’array non ci sia già il valore che in quel momento è al // vaglio dei controlli if (arrayTemporaneo[k] == M[i][j]) giàInserito = true;} // nel caso in cui nell’array non ci fosse quell’elemento if (!giàInserito){ // allora lo posizioniamo nella prima cella vuota dell’array arrayTemporaneo[indiceArray] = M[i][j]; // incrementiamo progressivamente l’indice di scansione dell’array indiceArray++;} } } } // creiamo l’array finale che ovviamente avrà dimensione pari al valore // raggiunto dall’indice di scansione int[] arrayFinale = new int[indiceArray]; for (int i = 0; i < arrayFinale.length; i++){ // trasferiamo gli elementi dell’array temporaneo nell’array finale con la // giusta dimensione arrayFinale[i] = arrayTemporaneo[i];} return arrayFinale; }  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){ int[][] M = {{3,18,15,7,2}, {1,9,11,4,6}, {7,2,6,3,5}, {5,1,25,2,1}, {3,2,33,4,4}}; int[]V = creaArrayConElementiRipetutiEsattamentePvolte (M,2); visualizzaArray (V); } }     

Java: scambio di due colonne in una matrice

Tema 98

Scrivere un metodo scambiaDiPostoDueColonne che riceve una matrice di interi M e due numeri C1 e C2 e restituisce la stessa matrice dopo aver effettuato lo scambio tra le colonne C1 ed C2.

Ad esempio, sia M la matrice così costituita

3 18 15 7 2
1 9 11 4 6
7 2 6 3 5
5 1 25 2 1
3 2 33 4 4

allora scambiaDiPostoDueColonne (M,1,3)

3 7 15 18 2
1 4 11 9 6
7 3 6 2 5
5 2 25 1 1
3 4 33 2 4

 public class tema98{ public static int[][] scambiaDiPostoDueColonne (int[][] M, int C1, int C2){ // approntiamo un contenitore che ci servirà per posizionare momentaneamente un // elemento da spostare int contenitoreTemporaneo; // facciamo partire un ciclo che interesserà soltanto le righe visto che le // colonne su cui lavorare sono note for (int i = 0; i < M.length; i++){ // collochiamo il primo elemento della colonna C1 nel contenitore temporaneo contenitoreTemporaneo = M[i][C1]; // la prima cella della colonna C1 adesso è vuota e possiamo metterci il primo // elemento della colonna C2 M[i][C1] = M[i][C2]; // nella prima cella della colonna C2 posizioniamo l'elemento rimosso dalla // colonna C1 e parcheggiato nel // contenitore temporaneo M[i][C2] = contenitoreTemporaneo; } // reiterando le stesse operazioni per tutti gli altri elementi alla fine // otterremo lo scambio di colonne voluto return M; } public static void visualizzaMatrice (int[][] M) { for (int i = 0; i < M.length; i++) { for (int j = 0; j < M[i].length; j++) System.out.print(M[i][j]+ " "); System.out.println();} }  /* Applicazione di prova */  public static void main(String[] args){ int[][] M = {{3,18,15,7,2}, {1,9,11,4,6}, {7,2,6,3,5}, {5,1,25,2,1}, {3,2,33,4,4}}; visualizzaMatrice (M); // la matrice prima dell’applicazione del metodo System.out.println(); visualizzaMatrice (scambiaDiPostoDueColonne (M,1,3)); // la matrice dopo l'applicazione del metodo }}     

Java: scambio di due righe in una matrice

Tema 97

Scrivere un metodo scambiaDiPostoDueRighe che riceve una matrice di interi M e due numeri R1 e R2 e restituisce la stessa matrice dopo aver effettuato lo scambio tra le righe R1 ed R2.

Ad esempio, sia M la matrice così costituita

3 18 15 7 2
1 9 11 4 6
7 2 6 3 5
5 1 25 2 1
3 2 33 4 4

allora scambiaDiPostoDueRighe (M,1,3)

3 18 15 7 2
5 1 25 2 1
7 2 6 3 5
1 9 11 4 6
3 2 33 4 4

 public class tema97{ public static int[][] scambiaDiPostoDueRighe (int[][] M, int R1, int R2){ // approntiamo un contenitore che ci servirà per posizionare momentaneamente un // elemento da spostare int contenitoreTemporaneo; // facciamo partire un ciclo che interesserà soltanto le colonne visto che le // righe su cui lavorare sono note for (int j = 0; j < M[0].length; j++){ // collochiamo il primo elemento della riga R1 nel contenitore temporaneo contenitoreTemporaneo = M[R1][j]; // poiché la prima cella della riga R1 adesso è vuota possiamo metterci il primo // elemento della riga R2 M[R1][j] = M[R2][j]; // nella prima cella della riga R2 posizioniamo l’elemento rimosso dalla riga R1 // e parcheggiato nel // contenitore temporaneo M[R2][j] = contenitoreTemporaneo; // reiterando le stesse operazioni per tutti gli altri elementi alla fine // otterremo lo scambio di righe voluto } return M; }  public static void visualizzaMatrice (int[][] M) { for (int i = 0; i < M.length; i++) { for (int j = 0; j < M[i].length; j++) System.out.print(M[i][j] + " "); System.out.println();} }  /* Applicazione di prova */  public static void main(String[] args){ int[][] M = {{3,18,15,7,2}, {1,9,11,4,6}, {7,2,6,3,5}, {5,1,25,2,1}, {3,2,33,4,4}}; visualizzaMatrice (M); // la matrice prima dell’applicazione del metodo System.out.println(); visualizzaMatrice (scambiaDiPostoDueRighe (M,1,3)); // la matrice dopo l’applicazione del metodo } }     

Java: matrice con una riga e colonna invertite

Tema 96

Scrivere un metodo creaMatriceInvertendoUnaRigaEunaColonna che riceve una matrice quadrata di interi M e due numeri R e C e restituisce una matrice contenente due righe, ottenute invertendo la riga R di M e la colonna C di M.

Ad esempio, sia M la matrice così costituita

3 18 15 7 2
1 9 11 4 6
7 2 6 3 5
5 1 25 2 1
3 2 33 4 4

allora creaMatriceInvertendoUnaRigaEunaColonna (M,1,3)

6 4 11 9 1
4 2 3 4 7

 public class tema96{ public static int[][] creaMatriceInvertendoUnaRigaEunaColonna (int[][] M, int R, int C){ // approntiamo una nuova matrice con numero di righe pari a 2 e numero di // colonne pari a quelle di M int[][] nuovaMatrice = new int[2][M.length]; // scorriamo a ritroso la matrice per la prima operazione di riempimento for (int i = M.length-1; i >= 0; i--){ // riempiamo la prima riga della nuova matrice con gli elementi della riga R in // ordine inverso nuovaMatrice[0][M.length-i-1] = M[R][i];} // scorriamo a ritroso la matrice per la seconda operazione di riempimento for (int i = M.length-1; i >= 0; i--){ // riempiamo la seconda riga della nuova matrice con gli elementi della colonna // C in ordine inverso nuovaMatrice[1][M.length-i-1] = M[i][C];} return nuovaMatrice; }  public static void visualizzaMatrice (int[][] M) { for (int i = 0; i < M.length; i++) { for (int j = 0; j < M[i].length; j++) System.out.print(M[i][j] + " "); System.out.println();} }  /* Applicazione di prova */  public static void main(String[] args){ int[][] M = {{3,18,15,7,2}, {1,9,11,4,6}, {7,2,6,3,5}, {5,1,25,2,1}, {3,2,33,4,4}}; int[][] Q = creaMatriceInvertendoUnaRigaEunaColonna (M,1,3); visualizzaMatrice (Q); } }     

Java: sottomatrice di matrice privata della cornice

Tema 95

Scrivere un metodo estraiMatriceEscludendoLaCornice che riceve in ingresso una matrice di interi M e restituisce la sottomatrice ottenuta escludendo la prima e l’ultima riga e la prima e l’ultima colonna, cioè escludendo la cornice di M.

Ad esempio, sia M la matrice così costituita

3 18 15 7 2
1 9 11 4 1
7 2 6 3 5
5 1 25 2 1
3 2 33 4 4

allora estraiMatriceEscludendoLaCornice (M) darà

9 11 4
2 6 3
1 25 2

 public class tema95{ public static int [][] estraiMatriceEscludendoLaCornice (int [][] M) { // approntiamo una matrice che avrà dimensioni uguali alle dimensione di M ma // diminuite di 2 int [][] Q = new int[M.length-2][M[0].length-2]; // scorriamo la matrice M riga per riga, partendo dalla seconda riga for (int i = 1; i < M.length-1; i++){ // anche le colonne saranno esaminate partendo dalla seconda colonna for (int j = 1; j < M[0].length-1; j++) // trasferiamo nella matrice Q gli elementi che soddisfano il requisito // servendoci dell’indice di riga // appositamente creato e di un opportuno calcolo per l’indice di colonna Q[i-1][j-1] = M[i][j]; } return Q; }  public static void visualizzaMatrice (int[][] M) { for (int i = 0; i < M.length; i++) { for (int j = 0; j < M[i].length; j++) System.out.print(M[i][j] + " "); System.out.println();} }  /* Applicazione di prova */  public static void main(String[] args){ int[][] M = {{3,18,15,7,2}, {1,9,11,4,1}, {7,2,6,3,5}, {5,1,25,2,1}, {3,2,33,4,4}}; visualizzaMatrice (estraiMatriceEscludendoLaCornice (M)); } }     

Java: elementi duplicati in una matrice

Tema 94

Scrivere un metodo verificaSeCiSonoDuplicatiInMatrice che riceve in ingresso una matrice di interi M e restituisce TRUE se M presenta elementi duplicati; FALSE altrimenti.

Ad esempio, sia M la matrice così costituita

3 18 15 7 2
1 9 11 4 1
11 2 6 3 5
5 1 25 2 1
3 2 33 4 4

allora verificaSeCiSonoDuplicatiInMatrice (M) = TRUE

 public class tema94{ // ci serviamo di un metodo di supporto per calcolare se un elemento è presente // più volte nella matrice public static int presenzaInMatrice (int k, int[][] M){ // inzializziamo un contatore che verrà incrementato ogni volta che un elemento // si ripete int contaPresenze = 0; for (int i = 0; i < M.length; i++){ for (int j = 0; j < M.length; j++){ if (M[i][j] == k) contaPresenze++;} } return contaPresenze; }  static boolean verifcaSeCiSonoDuplicatiInMatrice (int[][] M){ boolean esistonoDuplicati = false; // scrorriamo la matrice riga per riga for (int i = 0; i < M.length; i++){ for (int j = 0; j < M.length; j++){ // usiamo il metodo precedente per verificare se la presenza di un elemento è // superiore al valore 1 if (presenzaInMatrice (M[i][j], M) > 1) esistonoDuplicati = true;} } return esistonoDuplicati; }  /* Applicazione di prova */  public static void main(String[] args){ int[][] M = {{3,18,15,7,2}, {1,9,11,4,1}, {11,2,6,3,5}, {5,1,25,2,1}, {3,2,33,4,4}}; System.out.println(verificaSeCiSonoDuplicatiInMatrice (M)); // il risultato sarà TRUE System.out.println(); int[][] Q = {{1,2,3,4}, {5,6,7,8}, {9,10,11,12}, {13,14,15,16}}; System.out.println(verificaSeCiSonoDuplicatiInMatrice (Q)); // il risultato sarà FALSE } }     

Java: azzeramento colonne di una matrice

Tema 93

Scrivere un metodo azzeraColonneCompreseTraParametri che riceve in ingresso una matrice quadrata di interi M e due interi h e k e sostituisce con lo zero il valore di tutti gli elementi delle colonne di indice compreso tra h e k

Ad esempio, sia M la matrice così costituita

3 18 15 7 2
1 9 11 4 1
11 2 6 3 5
5 1 25 2 1
3 2 33 4 4

allora azzeraColonneCompreseTraParametri (M, 1, 4) darà

3 18 0 0 2
1 9 0 0 1
11 2 0 0 5
5 1 0 0 1
3 2 0 0 4

 public class tema93{ public static int[][] azzeraColonneCompreseTraParametri (int[][] M, int h, int k){ // scrorriamo riga per riga la matrice for (int i = 0; i < M.length; i++){ for (int j = 0; j < M.length; j++){ // imponiamo che qualora l’indice di colonna risulti maggiore del parametro h e // minore del parametro k // bisogna azzerare gli elementi corrispondenti nella matrice if (j > h && j < k) M[i][j] = 0;} } return M; }  public static void visualizzaMatrice (int[][] M) { for (int i = 0; i < M.length; i++) { for (int j = 0; j < M[i].length; j++) System.out.print(M[i][j] + " "); System.out.println();} }  /* Applicazione di prova */  public static void main(String[] args){ int[][] M = {{3,18,15,7,2}, {1,9,11,4,1}, {11,2,6,3,5}, {5,1,25,2,1}, {3,2,33,4,4}}; int[][] Q = azzeraColonneCompreseTraParametri (M,1,4); visualizzaMatrice (Q); } }     

Java: righe pari con somma dispari di matrice

Tema 92

Scrivere un metodo creaMatriceEstraendoRighePariConSommaDispari che riceve in ingresso una matrice di interi M e restituisce una matrice di interi contenente tutte le righe di M di indice pari in cui la somma degli elementi sia dispari.

Ad esempio, sia M la matrice così costituita

1 1 1 1 1
2 1 14 2 1
2 2 2 2 2
1 2 24 3 1
5 5 5 5 5

allora creaMatriceEstraendoRighePariConSommaDispari(M) darà

1 1 1 1 1
5 5 5 5 5

 public class tema92{ // prepariamo un metodo di supporto per verificare se la somma degli elementi di // una riga è dispari public static boolean isDispariLaSommaDiQuestaRiga (int[][] M, int indiceRiga){ int somma = 0; for (int j = 0; j < M.length; j++) somma += M[indiceRiga][j]; if (somma %2 == 0) return false; return true; } // ci serviamo di un altro metodo di supporto per calcolare il numero di righe // che soddisfano il requisito public static int calcolaQuanteRigheHannoSommaDispari (int[][] M) { int numeroRighe =0; for (int i = 0; i < M.length; i+=2) if (isDispariLaSommaDiQuestaRiga (M,i)) numeroRighe++; return numeroRighe; } // creiamo il metodo conclusivo public static int[][]creaMatriceEstraendoRighePariConSommaDispari (int[][] M){ // calcoliamo il numero di righe che dovrà avere la nuova matrice con l'apposito // metodo di supporto int numRighe = calcolaQuanteRigheHannoSommaDispari (M); // creiamo una nuova matrice che avrà numero di righe pari al risultato del // metodo precedente e numero di // colonne pari al numero di colonne di M int [][] nuovaMatrice = new int[numRighe][M.length]; // inizializziamo un indice per scorrere le righe della nuova matrice int scorriRiga = 0; // scorriamo la matrice M una riga per volta for (int i = 0; i < M.length ; i += 2){ // su ogni riga effettuiamo un controllo per verificare che la somma dei suoi // elementi sia dispari if (isDispariLaSommaDiQuestaRiga (M,i)){ // in caso affermativo copiamo gli elementi di quella riga nella nuova matrice for (int j = 0; j < M.length; j++) nuovaMatrice[scorriRiga][j] = M[i][j]; // incrementiamo progressivamente l’indice di riga della nuova matrice scorriRiga++;} } return nuovaMatrice; } public static void visualizzaMatrice (int[][] M) { for (int i=0; i

Java: elemento vettore uguale al prodotto/somma della corrispondente riga/colonna di matrice

Tema 91

Scrivere un metodo isIesimoElementoArrayUgualeAprodottoIesimaRigaOsommaIesimaColonna che riceve in ingresso una matrice quadrata di interi M di dimensione e un array di interi V e restituisce TRUE se l’i-esimo elemento di V è uguale al prodotto degli elementi dell’i-esima riga di M oppure è uguale alla somma degli elementi dell’i-esima colonna di M.

Ad esempio, siano M e V rispettivamente la matrice e il vettore così costituiti

9 3 17 7 11
2 1 14 2 1
3 5 6 12 7
1 2 24 3 1
3 13 15 15 7
18 56 76 39 72

allora isIesimoElementoArrayUgualeAprodottoIesimaRigaOppureAsommaIesimaColonna (M,V) = TRUE

 public class tema91{ // approntiamo un metodo di supporto per calcolare la somma di una colonna // il parametro “indiceColonna” sarà passato nel metodo generale ogni volta che // bisognerà // sommare l’i-esima colonna public static int sommaColonna (int[][] M, int indiceColonna) { int somma = 0; for (int i = 0; i < M.length; i++) somma += M[i][indiceColonna]; return somma; } // approntiamo un metodo di supporto per calcolare il prodotto di una riga // il parametro “indiceRiga” sarà passato nel metodo generale ogni volta che // bisognerà // moltiplicare l’i-esima riga public static int prodottoRiga (int[][] M, int indiceRiga) { int prodotto = 1; for (int j = 0; j < M[0].length; j++) prodotto *= M[indiceRiga][j]; return prodotto; }  public static boolean isIesimoElementoArrayUgualeAprodottoIesimaRigaOppureAsommaIesimaColonna (int[][] M, int [] V){ for (int i = 0; i < V.length; i++) // i metodi di supporto riceveranno come parametro, di volta in volta, l’indice // di scansione dell’array if ((V[i] != prodottoRiga (M, i)) && (V[i] != sommaColonna (M,i))) return false; return true; }  /* Applicazione di prova */  public static void main(String args[]){ int[][] M = {{9,3,17,7,11}, {2,1,14,2,1}, {3,5,6,12,7}, {1,2,24,3,1}, {3,13,15,15,7}}; int [] V={18,56,76,39,27}; System.out.println(isIesimoElementoArrayUgualeAprodottoIesimaRigaOppureAsommaIesimaColonna (M,V)); }}     

Java: riga centrale matrice con multipli sulla colonna centrale

Tema 90

Scrivere un metodo isOgniElementoRigaCentraleMultiploDiAlmenoUnElementoColonnaCentrale che riceve in ingresso una matrice quadrata M di interi di dimensione dispari e restituisce TRUE se per ogni elemento presente sulla riga centrale di M esiste un suo multiplo sulla colonna centrale.

Ad esempio, sia M la matrice così costituita

1 3 7 9 6
2 4 12 5 13
14 18 11 1 4
3 1 1 8 2
0 12 25 4 5

allora isOgniElementoRigaCentraleMultiploDiAlmenoUnElementoInColonnaCentrale (M) = TRUE

 public class tema90{ public static boolean isOgniElementoRigaCentraleMultiploDiAlmenoUnElementoColonnaCentrale (int[][] M){ for (int i = 0; i < M.length; i++) { boolean multiplo = false; // effettuiamo il controllo tenendo bloccato sul valore centrale di M l’indice // delle colonne nella prima // scansione della matrice e l’indice delle righe nella seconda scansione della // matrice if (M[M.length/2][i] % M[i][M.length/2] == 0) multiplo = true; if (! multiplo) return false; } return true; }  /* Applicazione di prova */  public static void main (String args[]) { int[][] M = new int[][]{{1,3,7,9,6},{2,4,2,5,13},{14,18,11,1,16},{3,1,1,8,2},{0,12,4,4,5}}; System.out.println( isOgniElementoRigaCentraleMultiploDiAlmenoUnElementoColonnaCentrale(M)); // risultato TRUE System.out.println(); int[][] Q = new int[][]{{1,3,7,9,6},{2,4,12,5,13},{14,18,11,1,4},{3,1,1,8,2},{0,12,25,4,5}}; System.out.println( isOgniElementoRigaCentraleMultiploDiAlmenoUnElementoColonnaCentrale(Q)); // risultato FALSE } }     

Java: matrice con colonne senza duplicati

Tema 89

Scrivere un metodo verificaSeCiSonoDuplicatiInColonne che riceve in ingresso una matrice M e restituisce TRUE se ogni colonna di M non contiene elementi duplicati; FALSE altrimenti.

Ad esempio, sia M la matrice così costituita

1 3 7 9 6
2 4 12 5 13
14 18 11 1 4
3 1 1 8 2
0 12 25 4 5

allora verificaSeCiSonoDuplicatiInColonne(M) = TRUE

 public class tema89{ public static boolean verificaSeCiSonoDuplicatiInColonne (int[][] M) { // impostiamo il ciclo di scansione delle colonne for (int j = 0; j < M[0].length; j++) { // una volta che ci siamo posizionati sulla colonna facciamo partire il ciclo di // scansione delle righe for (int i = 0; i < M.length; i++) { // questo terzo ciclo serve a scorrere tutti gli elementi successivi a quello su // cui ci si trova for (int k = i + 1; k < M.length; k++) { // effettuiamo il confronto tra l'elemento da valutare e tutti quelli che lo // seguono nella stessa colonna if (M[i][j] == M[k][j]) return false; } } } return true; }  /* Applicazione di prova */  public static void main (String[] args) { int[][] M = new int[][]{{1,3,7,9,6},{2,4,12,5,13},{14,18,11,1,4},{3,1,1,8,2},{0,12,25,4,5}}; // il risultato sarà TRUE System.out.println(verificaSeCiSonoDuplicatiInColonne (M)); System.out.println(); int[][] Q = new int[][]{{1,3,7,9,6},{2,4,12,5,13},{14,18,7,1,4},{3,1,1,8,2},{0,12,25,4,5}}; // il risultato sarà FALSE System.out.println(verificaSeCiSonoDuplicatiInColonne (Q)); } }     

Java: sottomatrice di matrice senza colonna e riga centrale

Tema 88

Scrivere un metodo creaArrayConQuattroQuadrantiDellaMatriceEscludendoElementiCentrali che riceve in ingresso una matrice quadrata di interi M di dimensione dispari, e restituisce un array V contenente gli elementi situati nei quadranti che si ottengono da M escludendo la riga centrale e la colonna centrale.

Ad esempio, sia M la matrice così costituita

3 18 15 7 2
1 9 11 4 6
7 2 6 3 5
5 1 25 2 1
3 2 33 4 4

allora creaArrayConQuattroQuadrantiDellaMatriceEscludendoElementiCentrali(M) darà

3 18 1 9 7 2 4 6 5 1 3 2 2 1 4 4

 public class tema88{ public static int[]creaArrayConQuattroQuadrantiDellaMatriceEscludendoElementiCentrali (int[][] M){ // dichiariamo un array la cui dimensione sarà data dal seguente calcolo int[] V = new int[M.length * M.length - 2* M.length + 1]; // poichè l’array dovrà ospitare gli elementi provenienti dai quattro quadranti // della matrice // approntiamo un valore che sarà pari a ogni porzione di array da riempire int porzione = V.length/4; // prepariamo un indice per la scansione dell’array int indice = 0; // cominciamo a scorrere la matrice for(int i = 0; i < M.length /2; i++) for(int j = 0; j < M.length /2; j++){ // da questo momento iniziamo a inserire gli elementi nell’array // con la seguente istruzione riempiamo la prima porzione dell’array V[indice] = M[i][j]; // con la seguente istruzione riempiamo la seconda porzione dell’array che // inizia esattamente alla distanza // di V.length/4 dal primo elemento V[indice + porzione] = M[i][ M.length /2 + 1 + j]; // con la seguente istruzione riempiamo la terza porzione dell’array che inizia // esattamente alla distanza // di 2 volte il valore di V.length/4 dal primo elemento V[indice + 2*porzione] = M[M.length /2 + 1 + i][j]; // con la seguente istruzione riempiamo la quarta porzione dell’array che inizia // esattamente alla distanza // di 3 volte il valore di V.length/4 dal primo elemento V[indice + 3*porzione] = M[M.length /2 + 1 + i][ M.length /2 + 1 + j]; // incrementiamo l’indice indice++;} 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 */  public static void main(String[] args){ int[][] M = {{3,18,15,7,2}, {1,9,11,4,6}, {7,2,6,3,5}, {5,1,25,2,1}, {3,2,33,4,4}}; visualizzaArray (creaArrayConQuattroQuadrantiDellaMatriceEscludendoElementiCentrali (M)); } }     

Java: diagonali di una matrice senza elemento centare

Tema 87

Scrivere un metodo creaMatriceEstraendoDiagonaliEsclusoElementoCentrale che riceve in ingresso una matrice quadrata di interi M di dimensione dispari e restituisce una matrice contenente gli elementi di M presenti sulle diagonali escluso l’elemento centrale.

Ad esempio, sia M la matrice così costituita

1 3 7 9 6
2 4 12 5 13
14 18 11 1 4
3 1 1 8 2
0 12 25 4 5

allora creaMatriceEstrandoDiagonaliEsclusoElementoCentrale (M) darà

1 6
4 5
8 1
5 0

 public class tema87 { public static int[][] creaMatriceEstraendoDiagonaliEsclusoElementoCentrale (int[][] M) { // approntiamo la matrice in cui posizioneremo gli elementi che soddisfano il // requisito // tale matrice avrà un numero di righe pari a quello di M meno 1 e numero di // colonne pari a 2 int[][] nuovaMatrice = new int[M.length - 1][2]; // inizializziamo un intero "delta" che useremo al momento opportuno per saltare // direttamente sugli elementi // giusti con i quali riempiremo la prima colonna // della nuova matrice int delta = 0; // avviamo il ciclo con cui preleveremo gli elementi della diagonale princiaple for(int i = 0; i < nuovaMatrice.length; i++) { // quando l'indice di scansione sarà uguale al valore centrale di M, "delta" // sarà portato al valore 1 if (i == M.length / 2) delta = 1; // e questo ci consentirà di saltare l’elemento in posizione centrale nuovaMatrice[i][0] = M[i + delta][i + delta]; } // inizializziamo un intero "salto" che useremo al momento opportuno per saltare // direttamente sugli elementi // giusti con i quali riempiremo la seconda // colonna della nuova matrice int salto = 0; // avviamo il ciclo con cui preleveremo gli elementi della diagonale secondaria for(int i = 0; i < nuovaMatrice.length; i++) { // quando l'indice di scansione sarà uguale al valore centrale di M, "salto" // sarà portato al valore 1 if (i == M.length / 2) salto = 1; nuovaMatrice[i][1] = M[i + salto][M.length - 1 - i - salto]; } return nuovaMatrice; } public static void visualizzaMatrice (int[][] M) { for (int i = 0; i < M.length; i++) { for (int j = 0; j < M[i].length; j++) System.out.print(M[i][j] + " "); System.out.println();}  /* Applicazione di prova */  public static void main(String[] args) { int[][] M = new int[][]{{1,3,7,9,6},{2,4,12,5,13},{14,18,11,1,4},{3,1,1,8,2},{0,12,25,4,5}}; int[][] Q = creaMatriceEstraendoDiagonaliEsclusoElementoCentrale (M); visualizzaMatrice (Q); } }     

Java: elementi della colonna e riga centrale di una matrice

Tema 86

Scrivere un metodo creaMatriceEstrandoCroceEsclusoElementoCentrale che riceve in ingresso una matrice quadrata di interi M di dimensione dispari e restituisce una matrice contenente gli elementi di M presenti sulla riga e sulla colonna centrali escluso l’elemento centrale.

Ad esempio, sia M la matrice così costituita

1 3 7 9 6
2 4 12 5 13
14 18 11 1 4
3 1 1 8 2
0 12 25 4 5

allora creaMatriceEstraendoCroceEsclusoElementoCentrale(M) darà

14 7
18 12
1 1
4 25

 public class tema86 { public static int[][] creaMatriceEstraendoCroceEsclusoElementoCentrale (int[][] M) { // approntiamo la matrice in cui posizioneremo gli elementi che soddisfano il // requisito // tale matrice avrà un numero di righe pari a quello di M meno 1 e numero di // colonne pari a 2 int[][] nuovaMatrice = new int[M.length - 1][2]; // inizializziamo un intero “delta” che useremo al momento opportuno per saltare // direttamente sugli elementi // giusti con i quali riempiremo la nuova matrice int delta = 0; for (int i = 0; i < nuovaMatrice.length; i++) { // quando l’indice di scansione sarà uguale al valore centrale di M, “delta” // sarà portato al valore 1 if (i == M.length / 2) delta = 1; // questo nuovo valore di “delta” consentirà di saltare l’elemento centrale nuovaMatrice[i][0] = M[M.length / 2][i + delta]; nuovaMatrice[i][1] = M[i + delta][M.length / 2]; } return nuovaMatrice; } public static void visualizzaMatrice (int[][] M) { for (int i = 0; i < M.length; i++) { for (int j = 0; j < M[i].length; j++) System.out.print(M[i][j] + " "); System.out.println();} }  /* Applicazione di prova */  public static void main(String[] args) { int[][] M = new int[][]{{1,3,7,9,6},{2,4,12,5,13},{14,18,11,1,4},{3,1,1,8,2},{0,12,25,4,5}}; int[][] Q = creaMatriceEstraendoCroceEsclusoElementoCentrale (M); visualizzaMatrice (Q);}}     

Java: elementi matrice al di sopra della diagonale

Tema 85

Scrivere un metodo creaArrayConElementiAlDiSopraDiagonalePrincipale che riceve in ingresso una matrice quadrata di interi M e restituisce un array V contenente tutti gli elementi appartenenti al triangolo al di sopra della diagonale principale.

Ad esempio, sia M la matrice così costituita

3 18 15 7 2
1 9 11 4 1
11 2 6 3 5
5 1 25 2 1
3 2 33 4 4

allora creaArrayConElementiAlDiSopraDiagonalePrincipale (M) darà

18 15 7 2 11 4 1 3 5 1

 public class tema85 { public static int[] creaArrayConElementiAlDiSopraDiagonalePrincipale (int[][] M){ // la dimensione dell’array sarà data dal seguente calcolo int dim = (M.length * M.length - M.length) / 2; int[] A = new int[dim]; // prepariamo un indice per l’array int indiceArray = 0; // prepariamo un indice per scorrere in maniera opportuna le colonne della // matrice // inizialmente è ovvio che si comincerà con la seconda colonna cioè di indice 1 int indiceColonna = 1; for (int i = 0; i < M.length; i++){ for (int j = indiceColonna; j < M.length; j++){ A[indiceArray] = M[i][j]; // incrementiamo l’indice dell’array in modo da posizionarci nella successiva // cella indiceArray++;} // incrementiamo l’indiceColonna in modo da far partire le colonne dalla // posizione successiva // a ogni nuovo ciclo indiceColonna++;} return A; }  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){ int[][] M = {{3,18,15,7,2}, {1,9,11,4,1}, {11,2,6,3,5}, {5,1,25,2,1}, {3,2,33,4,4}}; visualizzaArray (creaArrayConElementiAlDiSopraDiagonalePrincipale (M)); } }     

Java: somme righe matrice triangolare superiore

Tema 84

Scrivere un metodo creaArrayConSommeRigheDellaTriangolareSuperiore che riceve in ingresso una matrice quadrata M e restituisce un array in cui l’i-esima posizione conterrà la somma degli elementi appartenenti, di volta in volta, a una riga della parte triangolare superiore della matrice.

Ad esempio, sia M la matrice così costituita

3 18 15 7 2
1 9 11 4 6
7 2 6 3 5
5 1 25 2 1
3 2 33 4 4

allora creaArrayConSommeRigheDellaTriangolareSuperiore (M) darà

45 30 14 3 4

 public class tema84{ public static int[] creaArrayConSommeRigheDellaTriangolareSuperiore (int[][] M){ // approntiamo un array con dimensione pari alla dimensione della matrice M int[] arrayFinale = new int[M.length]; // inizializziamo un indice che ci servirà per indirizzare opportunamente la // ricerca degli elementi int indice = 0; // cominciamo a scorrere la matrice riga per riga for (int i = 0; i < M.length; i++){ // prepariamo un contenitore di tipo intero in cui memorizzare la somma degli // elementi di una riga // posizionandolo a questo punto del programma facciamo in modo che si svuoti // alla fine di ogni ciclo int somma = 0; // l’indice delle colonne partirà da zero e s’incrementerà gradualmente // all’aumentare delle celle dell’array for (int j = indice; j < M.length; j++){ // sommiamo gli elementi di nostro interesse somma += M[i][j];} // collochiamo nell’array il risultato della somma arrayFinale[indice] = somma; // incrementiamo l’indice in modo da raggiungere la successiva colonna di M e la // successiva cella dell’array indice++;} return arrayFinale; }  public static void visualizzaArray (int[] V) { for (int i = 0; i < V.length; i++) System.out.print(V[i] + " "); System.out.println(); }  public static void main(String[] args){ int[][] M = {{3,18,15,7,2}, {1,9,11,4,6}, {7,2,6,3,5}, {5,1,25,2,1}, {3,2,33,4,4}}; visualizzaArray (creaArrayConSommeRigheDellaTriangolareSuperiore (M)); } }     

Java: elementi maggiori di k nelle colonne pari di una matrice

Tema 83

Scrivere un metodo creaArrayConElementiInColonnePariMaggioriDelParametroK che riceve in ingresso una matrice di interi M e un intero k e restituisce un array contenente tutti gli elementi di M strettamente maggiori di k presenti sulle colonne pari. Si consideri la colonna di indice 0 una colonna pari.

Ad esempio, sia M la matrice così costituita

1 3 7 9 6
2 4 12 5 13
14 18 11 1 4
3 1 1 8 2
0 12 25 4 5

allora creaArrayConElementiInColonnePariMaggioriDiK(M, 9) darà

14 12 11 25 13

 public class tema83{ public static int[] creaArrayConElementiInColonnePariMaggioriDiK (int[][] M, int k) { // il numero di colonne pari è esattamente la metà del numero di colonne totali int numeroColonnePari = M[0].length / 2; // ma se la dimensione della matrice è dispari dobbiamo aggiungere un’ulteriore // colonna if (M[0].length % 2 == 1) numeroColonnePari += 1; // approntiamo un array temporaneo che nel caso estremo avrà dimensione pari al // seguente calcolo int[] arrayTemporaneo = new int[M.length * numeroColonnePari]; int indiceArray = 0; for (int j = 0; j < M[0].length; j += 2) for (int i = 0; i < M.length; i++) if (M[i][j] > k) { // collochiamo nell’array temporaneo gli elementi che soddisfano il requisito arrayTemporaneo[indiceArray] = M[i][j]; indiceArray++; } // adesso approntiamo l’array finale con la giusta dimensione int[] arrayFinale = new int[indiceArray]; for (int i = 0; i < arrayFinale.length; i++) // trasferiamo gli elementi dall’array temporaneo all’array finale arrayFinale[i] = arrayTemporaneo[i]; return arrayFinale; } 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) { int[][] M = new int[][]{{1,3,7,9,6},{2,4,12,5,13},{14,18,11,1,4},{3,1,1,8,2},{0,12,25,4,5}}; int[] V = creaArrayConElementiInColonnePariMaggioriDiK (M, 7); visualizzaArray (V); } }     

Java: cancellazione riga e colonna di una matrice

Tema 82

Scrivere un metodo eliminaUnaRigaEunaColonna che riceve in ingresso una matrice quadrata di interi M e due interi R e C e restituisce una matrice Q ottenuta da M eliminando la riga R e la colonna C.

Ad esempio, sia M la matrice così costituita

6 4 11 9 12 2 1 10 7 10 14 21 17 1 4 8 10 13 3 1 10 2 12 10 30

allora eliminaUnaRigaEunaColonna (M,1,2) restituisce la matrice

6 4 9 12
14 21 1 4
8 10 3 1
10 2 10 30

 public class tema82{ public static int[][]  eliminaUnaRigaEunaColonna (int [][] M, int R, int C) { // approntiamo una matrice le cui dimensioni saranno diminuite di 1 rispetto // alla matrice M int [][] Q = new int[M.length-1][M[0].length-1]; // creiamo un indice per le righe della nuova matrice int indiceRiga = 0; // creiamo un indice per le colonne della nuova matrice int indiceColonna; // iniziamo a scorrere le righe della matrice M for (int i = 0; i < M.length; i++) { // ci accertiamo che l’indice di riga non sia uguale al parametro fornito nel // metodo if (i != R) { // in tal caso inzializziamo l’indice per scorrere le colonne della matrice Q indiceColonna = 0; // avviamo un ciclo per le colonne della matrice M for (int j = 0; j < M[0].length; j++) // ci accertiamo che l’indice di colonna non sia uguale al parametro fornito nel // metodo if (j != C) { // se l’elemento ha soddisfatto i requisiti lo collochiamo nella matrice Q Q[indiceRiga][indiceColonna] = M[i][j]; // incrementiamo progressivamente gli indici di Q indiceColonna++; } indiceRiga++; } } return Q; } public static void visualizzaMatrice (int[][] M) { for (int i = 0; i < M.length; i++) { for (int j = 0; j < M[i].length; j++) System.out.print(M[i][j] + " "); System.out.println();} }  /* Applicazione di prova */  public static void main(String[] args) { int[][] M = new int[][]{{6,4,11,9,12},{8,13,10,7,10},{14,21,17,6,4}, {8,10,13,6,7},{10,17,12,10,30}}; int[][] Q = eliminaUnaRigaEunaColonna (M,1,2); visualizzaMatrice (Q); } }     

Java: matrice palindroma

Tema 81

Scrivere un metodo isPalindroma che riceve in ingresso una matrice M e restituisce TRUE se la matrice è palindroma; FALSE altrimenti. Una matrice si dice palindroma se la prima riga è uguale all’ultima riga, la seconda è uguale alla penultima e così via, in modo che le colonne risultino uguali sia che vengano lette dall’alto verso il basso sia che vengano lette dal basso verso l’alto.

Ad esempio, sia M una matrice così costituita

1 3 0 6 9
2 5 7 8 4
9 2 5 7 6
2 5 7 8 4
1 3 0 6 9

allora isPalindroma (M) = TRUE

 public class tema81 { public static boolean isPalindroma (int[][] M) { boolean esito = true; // realizziamo due cicli imponendo che l’indice di scansione delle righe arrivi // fino a metà della dimensione // totale; nel caso di matrici di dimensione dispari non è importante valutare // la riga centrale, essa infatti // risulta ininfluente ai fini della verifica del requisito for (int i = 0; i < M.length / 2 && esito; i++) for (int j = 0; j < M[0].length && esito; j++) // adesso confrontiamo le righe // poiché gli indici delle righe sono ancorati tra loro tramite la variabile // “i”, si comincia col confrontare // la prima con l’ultima, poi la seconda con la penultima e così via man mano // che aumenta il valore di “i” if (M[i][j] != M[M.length –i -1][j]) esito = false; return esito; }  /* Applicazione di prova */  public static void main(String[] args) { int[][] M = new int[][]{{1,3,0,6,9}, {2,5,7,8,4}, {9,2,5,7,6}, {2,5,7,8,4}, {1,3,0,6,9} }; System.out.println(isPalindroma (M)); System.out.println(); // testiamo il metodo sulla matrice Q nella quale abbiamo solo cambato l’ultimo // elemento della prima riga int[][] Q = new int[][]{{1,3,0,6,5}, {2,5,7,8,4}, {9,2,5,7,6}, {2,5,7,8,4}, {1,3,0,6,9} }; System.out.println(isPalindroma (Q)); } }     

Java: dimezzare una matrice e azzerare elementi

Tema 80

Scrivere un metodo dimezzaMatriceEazzeraElementiPresentiInArray che riceve in ingresso una matrice quadrata M e un array V e restituisce la matrice Q ottenuta dalle ultime M.length/2 colonne di M e contenente i corrispondenti elementi di M che non sono presenti nell’array V, 0 altrimenti.

Ad esempio, siano M e V rispettivamente una matrice e un array così costituiti

1 3 0 6
2 1 7 0
4 3 1 2
8 1 1 0
5 2 7 3

allora dimezzaMatriceEazzeraElementiPresentiInArray (M,V) darà

0 6
0 0
1 0
1 0

 public class tema80 { // approntiamo un metodo per verificare la presenza di un elemento in un array public static boolean isPresente (int[] A, int k) { for (int i = 0; i < A.length; i++) if (A[i] == k) return true; return false; }  public static int[][] dimezzaMatriceEazzeraElementiPresentiInArray (int[][] M, int[] V) { // approntiamo una matrice che avrà lo stesso numero di righe di M e un numero // di colonne pari alla metà di // quelle di M int[][] nuovaMatrice = new int[M.length][M.length / 2]; // calcoliamo una quantità “delta” che ci servirà per indirizzare in maniera // opportuna l’indice del ciclo con // cui scorreremo le colonne della matrice M // “delta” è uguale alla differenza tra la dimensione della matrice M e la // dimensione della nuova matrice int delta = M.length - nuovaMatrice[0].length; for (int i = 0; i < nuovaMatrice.length; i++) { for (int j = 0; j < nuovaMatrice[0].length; j++) { if (isPresente(V, M[i][delta + j])) // se un elemento della matrice è presente nell’array nuovaMatrice [i][j] = 0; // poniamo uguale a 0 la corrispondente posizione nella nuova matrice else nuovaMatrice [i][j] = M[i][delta + j]; } } return nuovaMatrice; }  public static void visualizzaMatrice (int[][] M) { for (int i = 0; i < M.length; i++) { for (int j = 0; j < M[i].length; j++) System.out.print(M[i][j] + " "); System.out.println();} }  /* Applicazione di prova */  public static void main(String[] args) { int[][] M = new int[][]{{1,3,0,6},{2,1,7,0},{4,3,1,2},{8,1,1,0}}; int[] V = new int[]{5,2,7,3}; int[][] Q = dimezzaMatriceEazzeraElementiPresentiInArray (M,V); visualizzaMatrice (Q); } }     

Java: elementi non duplicati sotto la diagonale di una matrice

Tema 79

Scrivere un metodo creaArrayConElementiSottoDiagonalePrincipaleNonDuplicati che riceve in ingresso una matrice quadrata M e restituisce un array V contenente gli elementi di M al di sotto della diagonale principale senza duplicati.

Ad esempio, sia M la matrice così costituita

0 1 2 3
4 5 6 7
8 9 10 11
18 21 9 0

allora creaArrayConElementiSottoDiagonalePrincipaleNonDuplicati (M) darà

4 8 9 18 21

 public class tema79 { public static int[] creaArrayConElementiSottoDiagonalePrincipaleNonDuplicati (int[][] M) { // approntiamo un'array temporaneo in cui andremo a inserire gli elementi che // soddisfano il requisito // nell'ipotesi che siano tutti elementi non duplicati avremo bisogno al massimo // della seguente dimensione int[] arrayTemporaneo = new int[(M.length * M.length - M.length) / 2]; // nel nostro caso (4 x 4 - 4) / 2 = 6 // inizializziamo un intero per scorrere l’array int indice = 0; // scorriamo la matrice con opportuni indici in modo da accedere solo agli // elementi richiesti for (int i = 0; i < M.length; i++) for (int j = 0; j < i; j++) { boolean presente = false; // con un ciclo scorriamo l’array spingendoci fino al valore che assume di volta // in volta la variabile indice for (int h = 0; h < indice && !presente; h++) // verifichiamo di non inserire nell'array elementi già caricati if (arrayTemporaneo[h] == M[i][j]) presente = true; // se un elemento non risulta già caricato nell’array provvediamo a inserirlo if (!presente) { arrayTemporaneo[indice] = M[i][j]; indice++; } } // creiamo l'array con la giusta dimensione in cui inserire gli elementi // selezionati int[] arrayFinale = new int[indice]; for (int i = 0; i < arrayFinale.length; i++) arrayFinale[i] = arrayTemporaneo[i]; return arrayFinale; }  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) { int[][] M = new int[][]{{0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11}, {18,21,9,0}}; int[] V = creaArrayConElementiSottoDiagonalePrincipaleNonDuplicati (M); visualizzaArray (V); } }     

Java: estrazione di sottomatrice di dimensioni date

Tema 78

Scrivere un metodo estraiMatriceDalPrimoElementoAquelloConIndiciFornitiDaiParamentri che riceve in ingresso una matrice di interi M e due interi R e C e restituisce la sottomatrice a partire dall’elemento in posizione (0,0) fino all’elemento in posizione (R,C).

Ad esempio, sia M la matrice così costituita

0 1 2 3 4
5 6 7 8 9
4 5 6 7 8
9 10 11 12 0
7 6 5 4 3

allora estraiMatriceDalPrimoElementoAquelloConIndiciiFornitiDaiParamentri (M,1,2) darà

0 1 2
5 6 7

 public class tema78 { public static int[][]estraiMatriceDalPrimoElementoAquelloConIndiciFornitiDaiParamentri (int[][] M, int R, int C){ // effettuiamo un controllo per evitare che i parametri forniti siano maggiori // delle dimensioni della matrice if (R >= M.length || C >= M[0].length) return null; // determiniamo il numero di righe e di colonne della nuova matrice int numeroRighe = R + 1; int numeroColonne = C + 1; // dichiariamo la nuova matrice int[][] Q = new int[numeroRighe][numeroColonne]; // approntiamo dei cicli adeguati alle dimensioni della matrice Q for (int i = 0; i < Q.length; i++) for (int j = 0; j < Q[0].length; j++) Q[i][j] = M[i][j]; return Q; } public static void visualizzaMatrice (int[][] M) { for (int i = 0; i < M.length; i++) { for (int j = 0; j < M[i].length; j++) System.out.print(M[i][j] + " "); System.out.println();} }  /* Applicazione di prova */  public static void main(String[] args){ int[][] M = new int[][]{{0,1,2,3,4,}, {5,6,7,8,9}, {4,5,6,7,8}, {9,10,11,12,0}, {7,6,5,4,3}}; int[][] Q = estraiMatriceDalPrimoElementoAquelloConIndiciiFornitiDaiParamentri (M,1,2); visualizzaMatrice (Q); } }     

Java: sottomatrice di dimensione massima estraibile

Tema 77

Scrivere un metodo estraiMatriceConIndiciInizialiFornitiDaiParametri che riceve in ingresso una matrice di interi M e due interi R e C e restituisce la sottomatrice di dimensione massima estraibile a partire dalla posizione (R,C).

Ad esempio, sia M la matrice così costituita

0 1 2 3 4
5 6 7 8 9
0 1 2 3 4
5 6 7 8 9
0 1 2 3 4

allora estraiMatriceConIndiciInizialiFornitiDaiParametri(M, 3, 2)

7 8 9 2 3 4

 public class tema77 { public static int[][] estraiMatriceConIndiciFornitiDaiParametri (int[][] M, int R, int C){ // effettuiamo un controllo per evitare che i parametri forniti siano maggiori // delle dimensioni della matrice if (R >= M.length || C >= M[0].length) return null; // determiniamo il numero di righe e di colonne della nuova matrice int numeroRighe = M.length - R; int numeroColonne = M[0].length - C; // dichiariamo la nuova matrice int[][] Q = new int[numeroRighe][numeroColonne]; // approntiamo dei cicli adeguati alle dimensioni della matrice Q for (int i = 0; i < Q.length; i++) for (int j = 0; j < Q[0].length; j++) // inseriamo nella matrice Q gli elementi a partire dale coordinate (R+i) e // (C+j) Q[i][j] = M[R+i][C+j]; return Q; } public static void visualizzaMatrice (int[][] M) { for (int i = 0; i < M.length; i++) { for (int j = 0; j < M[i].length; j++) System.out.print(M[i][j] + " "); System.out.println();} }  /* Applicazione di prova */  public static void main(String[] args){ int[][] M = new int[][] {{0, 1, 2, 3, 4}, {5, 6, 7, 8, 9}, {0, 1, 2, 3, 4}, {5, 6, 7, 8, 9}, {0, 1, 2, 3, 4}}; int[][] Q = estraiMatriceConIndiciFornitiDaiParametri (M,3,2); visualizzaMatrice (Q); } }     

Java: eleminti diagonale di una matrice maggiori della media

Tema 76

Scrivere un metodo creaArrayConElementiDellaDiagonalePrincpaleMaggioriDellaMediaDellaDiagonale che riceve in ingresso una matrice quadrata di interi M e restituisce un array V contenente tutti gli elementi della diagonale principale il cui valore è maggiore della media degli elementi della diagonale stessa.

Ad esempio, sia M la matrice così costituita

3 18 15 7 2
1 9 11 4 1
11 2 6 3 5
5 1 25 2 1
3 2 33 4 4

allora creaArrayConElementiDellaDiagonalePrincpaleMaggioriDellaMediaDellaDiagonale(M) darà

9 6

 public class tema76 { public static int[] creaArrayConElementiDellaDiagonalePrincpaleMaggioriDellaMediaDellaDiagonale (int[][] M){ // prepariamo un contenitore somma che ci servirà per il calcolo della media int somma = 0; // iniziamo a scorrere la matrice for (int i = 0; i < M.length; i++){ // sommiamo gli elementi sulla diagonale principale somma += M[i][i]; } // calcoliamo la media dividendo la somma degli elementi per il numero di // elementi double media = somma/M.length; public class tema76 { public static int[] creaArrayConElementiDellaDiagonalePrincpaleMaggioriDellaMediaDellaDiagonale (int[][] M){ // prepariamo un contenitore somma che ci servirà per il calcolo della media int somma = 0; // iniziamo a scorrere la matrice for (int i = 0; i < M.length; i++){ // sommiamo gli elementi sulla diagonale principale somma += M[i][i]; } // calcoliamo la media dividendo la somma degli elementi per il numero di // elementi double media = somma/M.length;     

Java: stampa valori pari righe pari sotto diagonale matrice

Tema 75

Scrivere un metodo stampaElementiPariRighePariSottoDiagonale che riceve in ingresso una matrice quadrata M e crea un array con gli elementi pari appartenenti alle righe pari posti nel triangolo inferiore al di sotto della diagonale principale.

Sia M la matrice così costituita

3 18 15 7 2
1 9 11 4 6
7 2 6 3 5
5 1 25 2 1
3 2 33 4 4

allora stampaElementiPariRighePariSottoDiagonale(M) darà

2 2 4

 public class tema75{ public static void stampaElementiPariRighePariSottoDiagonale (int[][] M){ // scorriamo le righe partendo dalla seconda ed effettuando salti di due per // raggiungere solo le righe pari for (int i = 2; i < M.length; i += 2){ // il limite massimo che può raggiungere l’indice delle colonne è opportunamente // ancorato all’indice i for (int j = 0; j < i; j++){ // verifichiamo che gli elementi siano numeri pari if (M[i][j] %2 == 0) System.out.print(M[i][j]+" "); } } }  /* Applicazione di prova */  public static void main(String[] args){ int[][] M = {{3,18,15,7,2}, {1,9,11,4,6}, {7,2,6,3,5}, {5,1,25,2,1}, {3,2,33,4,4}}; stampaElementiPariRighePariSottoDiagonale (M); } }     

Java: array differenze tra somma riga e somma colonna

Tema 74

Scrivere un metodo creaArrayConDifferenzaTraSommaRigaEsommaColonna che riceve una matrice quadrata di interi M e restituisce un vettore V i cui elementi in posizione i-esima sono dati effettuando la differenza tra la somma degli elementi della riga i-esima e la somma degli elementi della colonna i-esima.

Ad esempio, sia M la matrice così costituita

0 1 -2 3
4 0 2 1
3 3 5 -4
3 -6 1 2

allora creaArrayConDifferenzaTraSommaRigaEsommaColonna(M) darà

-8 9 1 -2

 public class tema74{ public static int[] creaArrayConDifferenzaTraSommaRigaEsommaColonna (int[][] M) { // l’array risultante avrà naturalmente la stessa dimensione della matrice int [] arrayRisultante = new int[M.length]; // iniziamo a scorrere la matrice for (int i = 0; i < M.length; i++) { // ad ogni nuovo ingresso nel ciclo il contenitore calcolo sarà svuotato int calcolo = 0; for (int j = 0; j < M.length; j++) { // effettuiamo la sottrazione tra la somma della riga e la somma della colonna calcolo += M[i][j] - M[j][i]; } // collochiamo il risultato del calcolo nell’array risultante arrayRisultante[i] = calcolo; } return arrayRisultante; }  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[]) { int[][] M = {{0, 1, -2, 3}, {4, 0, 2, 1}, {3, 3, 5, -4}, {3, -6, 1, 2}}; int [] V = creaArrayConDifferenzaTraSommaRigaEsommaColonna (M); visualizzaArray (V); } }     

Java: minimo e media elementi righe di una matrice

Tema 73

Scrivere un metodo creaMatriceConMinimoEconMediaDiOgniRiga che riceve una matrice quadrata di interi M e restituisce una matrice contenente il minimo e la media degli elementi contenuti in ciascuna delle righe di M.

Ad esempio, sia M la matrice così costituita

0 1 2 3
-2 4 1 1
3 0 -5 7
2 1 -4 0

allora creaMatriceConMinimoEconMediaDiOgniRiga(M)

0 1 -2 1 -5 6 -4 2

 public class tema73{ public static int[][] creaMatriceConMinimoEconMediaDiOgniRiga (int[][] M) { // approntiamo la nuova matrice che avrà di certo righe pari a quelle di M e due // colonne int [][] Q = new int [M.length][2]; // iniziamo a scorrere la matrice riga per riga for (int i = 0; i < M.length; i++) { // usiamo il solito procedimento per la ricerca del minimo e tale scopo fissiamo // come valore minimo // provvisorio il primo elemento di ogni riga int minimo = M[i][0]; // inizializziamo anche un contenitore di tipo intero in cui effettuare la somma // delle righe da usare per // il calcolo della media int somma = 0; // iniziamo a scorrere le colonne for (int j = 0; j < M.length; j++) { if (M[i][j] < minimo) // se troviamo qualche elemento più piccolo del minimo provvisorio, aggiorniamo // il valore di minimo minimo = M[i][j]; // intanto procediamo a sommare gli elementi della riga somma += M[i][j]; } // nella prima colonna della nuova matrice inseriamo tutti i minimi trovati Q[i][0] = minimo; // e nella seconda colonna inseriamo i valori della media di ogni riga Q[i][1] = somma / M.length; } // dividendo la somma per M.length otteniamo la media return Q; } public static void visualizzaMatrice (int[][] M) { for (int i = 0; i < M.length; i++) { for (int j = 0; j < M[i].length; j++) System.out.print(M[i][j] + " "); System.out.println();} }  /* Applicazione di prova */  public static void main(String args[]) { int[][] M = {{0, 1, 2, 3}, {-2, 4, 1, 1}, {3, 0, -5, 27}, {12, 1, -4, 0}}; System.out.println("Risultato del metodo:"); int [][] Q = creaMatriceConMinimoEconMediaDiOgniRiga (M); visualizzaMatrice (Q); } }     

Java: somma valori maggiori delle righe pari con quelli minori delle righe dispari

Tema 72

Scrivere un metodo sommaMaggioriDelleRighePariConMinoriDelleRigheDispari che riceve una matrice quadrata di interi M e un intero k e restituisce un intero dato dalla somma degli elementi di M maggiori dell’intero k sulle righe di M di indice pari e minori dell’intero k sulle righe di M di indice dispari;

Ad esempio, sia M la matrice così costituita

1 2 3 4
-2 5 6 0
3 -5 7 2
8 8 -4 1

allora sommaMaggioriDelleRighePariConMinoriDelleRigheDispari (M, 3) = 4 – 2 + 7 – 4 + 1 = 6

 public class tema72{ public static int sommaMaggioriDelleRighePariConMinoriDelleRigheDispari (int[][] M, int k) { // approntiamo un contenitore di tipo intero in cui svolgere le operazioni int risultato = 0; // iniziamo a scorrere la matrice for (int i = 0; i < M.length; i++) for (int j = 0; j < M.length; j++) // quando l’indice di riga è pari if (i % 2 == 0) { // dobbiamo verificare che l’elemento sia maggiore del parametro k if (M[i][j] > k) // e in tal caso lo sommiamo risultato += M[i][j]; } else { // quando l’indice di riga è dispari dobbiamo verificare che l’elemento sia // minore del parametro k if (M[i][j] < k) // e in tal caso continuiamo a sommarlo ai precedenti elementi selezionati risultato += M[i][j]; } return risultato; }  /* Applicazione di prova */  public static void main(String args[]) { int[][] M = {{1, 2, 3, 4}, {-2, 5, 6, 0}, {3, -5, 7, 2}, {8, 8, -4, 1}}; System.out.println(sommaMaggioriDelleRighePariConMinoriDelleRigheDispari (M, 3)); } }     

Java: stampa diagonale escluso elemento centrale

Tema 71

Scrivere un metodo stampaDiagonaliTranneElementoCentrale che riceve in ingresso una matrice quadrata di interi M di dimensione dispari e stampa a video gli elementi di M presenti sulle due diagonali escluso l’elemento centrale.

Ad esempio, sia M la matrice così costituita

1 3 7 9 6
2 4 12 5 13
14 18 11 1 4
3 1 1 8 2
0 12 25 4 5

allora stampaDiagonaliTranneElementoCentrale(M)

 public class tema71{ // sarà un metodo void poiché non restituisce valori su cui effettuare ulteriori // operazioni oltre la stampa public static void estraiDiagonaliTranneElementoCentrale  (int[][] M) { //ci serviamo del procedimento usato nel metodo per estrarre gli elementi della //diagonale principale int i; for(i = 0; i < M.length; i++){ // volendo escludere l’elemento centrale, con l’istruzione “continue”, // obblighiamo il programma a procedere // oltre quando l’indice si troverà esattamente in prossimità di tale elemento if (i == M.length/2) continue; System.out.println(M[i][i]); //ci serviamo del procedimento usato nel metodo per estrarre gli elementi della //diagonale secondaria for(i = 0; i < M.length; i++){ // volendo escludere l’elemento centrale, con l’istruzione “continue”, // obblighiamo il programma a procedere // oltre quando l’indice si troverà esattamente in prossimità di tale elemento if (i == M.length/2) continue; System.out.println(M[i][M[0].length-1-i]); } }  /* Applicazione di prova */  public static void main (String[] args) { int[][] M = new int[][]{{1,3,7,9,6},{2,4,12,5,13},{14,18,11,1,4},{3,1,1,8,2},{0,12,25,4,5}}; estraiDiagonaliTranneElementoCentrale(M); } }     

Java: estrazione righe dispari da una matrice

Tema 70

oScrivere un metodo creaMatriceEstraendoRigheDispari che riceve una matrice di interi M e restituisce una sottomatrice ottenuta da M estraendo le righe di indice dispari.

Ad esempio, sia M la matrice così costituita

0 1 2 3 4
5 6 7 8 9
2 4 6 8 10
3 6 9 12 15
4 8 12 16 20

allora creaMatriceEstraendoRigheDispari (M) darà

5 6 7 8 9
3 6 9 12 15

 public class tema70{ public static int[][] creaMatriceEstraendoRigheDispari (int[][] M){ // il numero di righe della nuova matrice non può che essere dato dal seguente // calcolo int numeroRighe = M.length/2; // quindi approntiamo una nuova matrice con le seguenti dimensioni int[][] Q = new int[numeroRighe][M[0].length]; // approntiamo un indice per scorrere le righe int indiceRiga = 0; // naturalmente facciamo partire l’indice delle righe da 1 e lo incrementiamo // con salti di 2 for (int i = 1; i < M.length; i += 2){ for (int j = 0; j < M[0].length; j++) Q[indiceRiga][j] = M[i][j]; indiceRiga++; } return Q; } public static void visualizzaMatrice (int[][] M) { for (int i = 0; i < M.length; i++) { for (int j = 0; j < M[i].length; j++) System.out.print(M[i][j] + " "); System.out.println();} }  /* Applicazione di prova */  public static void main(String args[]) { int[][] M = {{0, 1, 2, 3, 4}, {5, 6, 7, 8, 9}, {2, 4, 6, 8, 10},{3, 6, 9, 12, 15},{4, 8, 12, 16, 20}}; visualizzaMatrice (estraiRigheDispari (M)); } }     

Java: colonne di indice pari di una matrice

Tema 69

Scrivere un metodo creaMatriceEstraendoColonnePari che riceve una matrice di interi M e restituisce la sottomatrice Q ottenuta da M estraendo le colonne di indice pari. Si cosideri la colonna di indice zero come colonna pari.

Ad esempio, siano M e V rispettivamente una matrice e un vettore così costituiti

1 4 6 2 3
2 1 7 4 6
3 2 8 6 9
4 9 9 8 12
5 4 10 2 15

allora estraiColonnePari (M) darà

1 6 3
2 7 6
3 8 9
4 9 12
5 10 15

 public class tema69{ public static int[][] estraiColonnePari (int[][] M){ // detrmininiamo quante colonne dovrà avere la nuova matrice con il seguente // calcolo int numeroColonne = M[0].length/2 + M[0].length%2; // dichiariamo la nuova matrice con le dimensioni previste int[][] Q = new int [M.length][numeroColonne]; // approntiamo un indice per scorrere le colonne nt indiceColonna = 0; // creiamo un ciclo per le colonne imponendo gli opportuni salti for (int j = 0; j < M[0].length; j+= 2){ // le righe invece saranno scandite tutte for (int i = 0; i < M.length; i++) Q[i][indiceColonna] = M[i][j]; // incrementiamo gradualmente l’indice colonna della matrice Q indiceColonna++; } return Q; } public static void visualizzaMatrice (int[][] M) { for (int i = 0; i < M.length; i++) { for (int j = 0; j < M[i].length; j++) System.out.print(M[i][j] + " "); System.out.println();} }  /* Applicazione di prova */  public static void main(String args[]) { int[][] M = { {1, 4, 6, 2, 3}, {2, 1, 7, 4, 6}, {3, 2, 8, 6, 9}, {4, 9, 9, 8, 12}, {5, 4, 10, 2, 15}}; System.out.println("Matrice di partenza"); visualizzaMatrice (M); System.out.println(); System.out.println("Sottomatrice generata dal metodo"); visualizzaMatrice (estraiColonnePari(M));} }     

Java: elementi vettore maggiori di elementi matrice

Tema 68

Scrivere un metodo isOgniElementoDelVettoreMaggioreDiAlmenoUnElementoDellaMatrice che riceve in ingresso una matrice M e un vettore V e restituisce TRUE se ciascun elemento del vettore è maggiore di almeno un elemento nella matrice; FALSE altrimenti.

Ad esempio, siano M e V rispettivamente una matrice e un vettore così costituiti

2 3 4 5 5
7 8 9 10 8
10 9 8 7 5
7 7 4 6 3
9 7 5 3 7
3 4 7 9

allora isOgniElementoDelVettoreMaggioreDiAlmenoUnElementoDellaMatrice (M,V) = TRUE

 public class tema68{ public static boolean isOgniElementoDelVettoreMaggioreDiAlmenoUnElementoDellaMatrice (int[][] M, int[] V){ // con il solito procedimento individuiamo l’elemento più piccolo nella matrice int min = M[0][0]; for (int i = 0; i < M.length; i++) for (int j = 0; j < M[0].length; j++) if (M[i][j] < min) min = M[i][j]; boolean elementoMaggiore = true; // a questo puntoscorriamo l’array e ci accertiamo che ogni suo element sia // maggiore del minimo trovato // nella matrice for (int k = 0; k < V.length && elementoMaggiore; k++){ if (V[k] <= min) // in caso di esito negativo impostiamo la variabile boolean sul valore FALSE e // questo interromperà il ciclo elementoMaggiore = false;} return elementoMaggiore; }  /* Applicazione di prova */  public static void main(String[] args){ int[][] M = new int[][]{{2,3,4,5,5}, {7,8,9,10,8}, {10,9,8,7,5}, {7,7,4,6,3}, {9,7,5,3,7}}; int[] V = new int[]{3,4,7,9}; System.out.println(isOgniElementoDelVettoreMaggioreDiAlmenoUnElementoDellaMatrice (M,V)); } }     

Java: verifica nessun elemento di un vettore presente in una matrice

Tema 67

Scrivere un metodo verificaCheNessunElementoDelVettoreSiaPresenteNellaMatrice che riceve in ingresso una matrice M ed un vettore V e restituisce TRUE se nessun elemento del vettore è presente nella matrice; FALSE altrimenti.

Ad esempio, siano M e V rispettivamente una matrice e un vettore così costituiti

0 1 2 3
4 5 6 7
8 9 10 11
12 13 14 15
20 30 40 50 60

allora verificaCheNessunElementoDelVettoreSiaPresenteNellaMatrice (M, V) = TRUE

 public class tema67{ public static boolean verificaCheNessunElementoDelVettoreSiaPresenteNellaMatrice (int[][] M, int[] V){ // in questo caso basterà scorrere l’array e la matrice e appena un elemento // dell’array dovesse trovarsi // nella matrice far restituire false for (int k = 0; k < V.length ; k++) for (int i = 0; i < M.length ; i++) for (int j = 0; j < M[0].length ; j++) if (V[k] == M[i][j]) return false; return true; }  /* Applicazione di prova */  public static void main(String args[]) { int[][] M = {{0, 1, 2, 3,}, {4, 5, 6, 7}, {8, 9, 10, 11}, {12, 13, 14, 15}}; int[] V = {20, 30, 40, 50}; System.out.println(verificaCheNessunElementoDelVettoreSiaPresenteNellaMatrice (M,V)); } }     

Linguaggio Java: elementi di un vettore presenti in una matrice

Tema 66

Scrivere un metodo isOgniElementoArrayPresenteInMatrice che riceve in ingresso una matrice di interi M e un vettore di interi V e restituisce TRUE se ciascun elemento del vettore è presente nella matrice; FALSE altrimenti.

Ad esempio, siano M e V rispettivamente una matrice e un vettore così costituiti

1 2 3 4
5 6 15 8
9 11 3 6
21 8 8 7
9 2 6 7

allora isOgniElementoArrayPresenteInMatrice (M, V) = TRUE

 public class tema66{ public static boolean isOgniElementoArrayPresenteInMatrice (int[][] M, int[] V){ // inizializziamo una variabile boolean che ci servirà come condizione d’uscita // dal primo ciclo boolean trovato = true; // dichiariamo una variabile boolean che ci servirà come condizione d’uscita dal // secondo ciclo boolean presente; for (int k = 0; k < V.length && trovato; k++){ presente = false; for (int i = 0; i < M.length && !presente; i++) for (int j = 0; j < M[0].length && !presente; j++) if (M[i][j] == V[k]) presente = true; if (!presente) trovato = false; } return trovato; }  /* Applicazione di prova */  public static void main(String args[]) { int[][] M = { {1, 2, 3, 4}, {5, 6, 7, 8}, {9, 11, 3, 6}, {21, 8, 8, 15}}; int [] V = {9, 2, 6, 7}; System.out.println(isOgniElementoArrayPresenteInMatrice (M,V)); // il risultato sarà TRUE System.out.println(); int [] A = {7, 30, 40, 50}; System.out.println(isOgniElementoArrayPresenteInMatrice (M,A)); // il risultato sarà FALSE } }     

Linguaggio Java: vettore prodotti delle somme riga e colonna

Tema 65

Scrivere un metodo creaArrayMoltiplicandoSommaRigaConSommaColonna che riceve una matrice quadrata di interi M e restituisce un vettore V i cui elementi in posizione i-esima sono ottenuti effettuando prima la somma degli elementi della riga i-esima della matrice M, poi la somma degli elementi della colonna i-esima della stessa matrice e infine moltiplicando i due risultati ottenuti.

Ad esempio, sia M la matrice così costituita

1 0 2 0
0 3 0 1
2 3 4 5
0 3 0 2

allora estraiArrayMoltiplicandoSommaRigaConSommaColonna (M) darà

9 36 84 40

 public class tema65{ public static int[] estraiArrayMoltiplicandoSommaRigaConSommaColonna (int[][] M) { // prepariamo un array di dimensione pari alla dimensione della matrice M int [] V = new int[M.length]; // creiamo un ciclo per scorrere la matrice for (int i = 0; i < M.length; i++) { // posizioniamo prorpio in questo punto l’inizializzazione della sommaRiga e // della sommaColonna // in modo tale che a ogni iterazione del ciclo i due contenitori vengano // svuotati dei risultati precedenti int sommaRiga = 0; int sommaColonna = 0; for (int j = 0; j < M.length; j++) { sommaRiga += M[i][j]; sommaColonna += M[j][i]; } // inseriamo nell’i-esima posizione dell’array il risultato del prodotto sulle // due somme V[i] = sommaRiga * sommaColonna; } 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 */  public static void main(String args[]) { int[][] M = { {1, 0, 2, 0}, {0, 3, 0, 1}, {2, 3, 4, 5}, {0, 3, 0, 2}}; int [] V = estraiArrayMoltiplicandoSommaRigaConSommaColonna (M); visualizzaArray (V); } }     

Linguaggio Java: matrice con massimo e minimo di ogni riga di un altra matrice

Tema 64

Scrivere un metodo creaMatriceEstraendoMinimoMassimoDalleRighe che riceve una matrice quadrata di interi M e restituisce una matrice che in ogni riga conterrà il valore minimo e il valore massimo di ciascuna riga di M.

Ad esempio, se la matrice M è così costituita

20 0 7 2
1 9 3 5
0 14 9 1
7 5 7 8

allora creaMatriceEstraendoMinimoMassimo (M) darà

0 20
1 9
0 14
5 8

 public class tema64{ public static int[][] creaMatriceEstraendoMinimoMassimo (int[][] M) { // approntiamo una matrice che avrà uguale numero di righe di M e soltanto due // colonne int [][] nuovaMatrice = new int[M.length][2]; for (int i = 0; i < M.length; i++) { // usiamo il solito procedimento per cercare il valore minimo (massimo), cioè // assumiamo che il // primo valore della matrice sia quello più basso (più alto) e poi lo // confrontiamo con tutti gli altri int minimo = M[i][0]; int massimo = M[i][0]; for (int j = 0; j < M.length; j++) { if (M[i][j] < minimo) minimo = M[i][j]; if (M[i][j] > massimo) massimo = M[i][j]; } // man mano che saranno individuati i valori minimi e massimi, verranno // collocati rispettivamente // nella prima e nella seconda colonna della nuova matrice nuovaMatrice[i][0] = minimo; nuovaMatrice[i][1] = massimo; } return nuovaMatrice; }  public static void visualizzaMatrice (int[][] M) { for (int i = 0; i < M.length; i++) { for (int j = 0; j < M[i].length; j++) System.out.print(M[i][j] + " "); System.out.println();} }  /* Applicazione di prova */  public static void main(String args[]) { int[][] M = { {20, 0, 7, 2}, {1, 9, 3, 5}, {0, 14, 9, 1}, {7, 5, 7, 8}}; int [][] H = creaMatriceEstraendoMinimoMassimo (M); visualizzaMatrice (H);}}     

Linguaggio Java: somma degli elementi di una matrice multipli di k

Tema 63

Scrivere un metodo sommaMultipliDelParametroK che riceve una matrice quadrata di interi M e un intero k e restituisce la somma degli elementi di M multipli dell’intero k.

Ad esempio, se la matrice M è così costituita

1 2 3 4
0 5 6 0
7 8 9 1
0 11 0 2

allora sommaMultipliDiK (M, 2) = 2+4+6+8+2 = 22

 public class tema63{ public static int sommaMultipliDiK (int[][] M, int k){ // prepariamo un contenitore di tipo intero in cui conservare il risultato int risultato = 0; // scorriamo la matrice  e verifichiamo quali elementi sono multipli di k for (int i = 0; i < M.length; i++) for (int j = 0; j < M.length; j++) if (M[i][j] % k == 0) // i multipli verranno sommati di volta in volta risultato += M[i][j]; return risultato; }  /* Applicazione di prova */  public static void main(String args[]) { int[][] M = { {1, 2, 3, 4}, {0, 5, 6, 0}, {7, 8, 9, 1}, {0, 11, 0, 2}}; System.out.println(); System.out.println("La somma dei multipli del numero indicato e':"+sommaMultipliDiK(M, 2)); } }     

Linguaggio Java: verifica riga centrale uguale colonna centrale di una matrice

Tema 62

Scrivere un metodo isRigaCentraleUgualeColonnaCentrale che riceve in ingresso una matrice quadrata di interi M di dimensione dispari e restituisce TRUE se gli elementi della riga centrale sono uguali agli elementi della colonna centrale; FALSE altrimenti.

Ad esempio, sia M la matrice così costituita

1 2 3
2 5 8
7 8 9

allora isRigaCentraleUgualeColonnaCentrale (M) = TRUE

 public class tema62 { public static boolean isRigaCentraleUgualeColonnaCentrale (int[][] M) { // approntiamo il valore dell’indice centrale della matrice int indicecentrale = M.length/2; // per controllare gli elementi di nostro interesse usiamo un solo ciclo e // invertiamo gli indici for(int i = 0; i < M.length; i++) { if (M[indicecentrale][i] != M[i][indicecentrale]) return false;} return true; }  public static void visualizzaMatrice (int[][] M) { for (int i = 0; i < M.length; i++) { for (int j = 0; j < M[i].length; j++) System.out.print(M[i][j] + " "); System.out.println();} }  /* Applicazione di prova */  public static void main(String[] args) { int[][] M ={ {1, 2, 3} , {2,5,8}, {7,8,9} }; visualizzaMatrice (M); System.out.println(isRigaCentraleUgualeColonnaCentrale(M)); // il risultato sarà TRUE int[][] Q ={ {1, 2, 3} , {4, 5, 6}, {7, 8, 9} }; System.out.println(); visualizzaMatrice (Q); System.out.println(isRigaCentraleUgualeColonnaCentrale(Q)); // il risultato sarà FALSE } }     

Linguaggio Java: somma elementi cornice di una matrice

Tema 61

Scrivere un metodo sommaCornice che riceve in ingresso una matrice M e restituisce la somma degli elementi che si trovano sul perimetro di M.

Ad esempio, sia M la matrice così costituita

1 2 3 4
1 4 5 2
3 5 6 1
1 2 4 2

allora sommaCornice (M) = 26

 public class tema61 { public static int sommaCornice (int[][] M) { int somma = 0; //sommiamo gli elementi di prima e ultima riga for (int j = 0; j < M[0].length; j++) somma += M[0][j] + M[M.length-1][j]; //sommiamo gli elementi di prima e ultima colonna esclusi gli angoli for(int i = 1; i < M.length-1; i++) somma += M[i][0] + M[i][M.length-1]; return somma; }  /* Applicazione di prova */  public static void main(String[] args) { int[][] Q ={{1, 2, 3, 4}, {1, 4, 5, 2}, {3, 5, 6, 1}, {1, 2, 4, 2}}; System.out.println(sommaCornice(Q));} }     

Linguaggio Java: sequenza di numeri in una matrice

Tema 60

Scrivere un metodo verificaSeEsisteSequenzaInMatrice che riceve una matrice di interi M e un intero n, e restituisce TRUE se all’interno di M esiste una sequenza di numeri da 1 fino a n; FALSE altrimenti.

Ad esempio, sia M la matrice così costituita

3 18 15 7 2
1 9 11 4 6
7 8 6 9 5
5 1 25 2 1
8 2 33 4 9

allora verificaSeEsisteSequenzaInMatrice (M,7) = TRUE

 public class tema60{ public static boolean verificaSeEsisteSequenzaInMatrice (int[][] M, int n){ // prepariamo una variabile boolean che useremo durante la verifica boolean trovato; // avviamo un ciclo che parte da 1 e arriva fino al valore k acquisito dal // metodo come parametro for(int k = 1; k < = n; k++){ trovato = false; // facciamo partire i cicli con cui scorreremo gli elementi della matrice for(int i = 0; i < M.length; i++) for(int j = 0; j < M[0].length; j++) // controlliamo che nella matrice esista almeno un elemento uguale al valore // assunto da k if(M[i][j] == k) // in caso affermativo impostiamo il valore della variabile boolean su TRUE trovato = true; // in caso contrario ci facciamo già restituire FALSE if(!trovato) return false; } return true; }  /* Applicazione di prova */  public static void main(String[] args){ int[][] M = {{3,18,15,7,2}, {1,9,11,4,6}, {7,8,6,9,5}, {5,1,25,2,1}, {8,2,33,4,9}}; // in questo caso otterremo TRUE: la sequenza da 1 a 7 è completa System.out.println(verificaSeEsisteSequenzaInMatrice (M,7)); System.out.println(); int[][] Q = {{9,18,15,7,2}, {1,9,11,4,6}, {7,8,6,9,5}, {5,1,25,2,1}, {8,2,33,4,9}}; // in questo caso otterremo FALSE: la sequenza da 1 a 7 è incompleta poichè // manca il 3 System.out.println(verificaSeEsisteSequenzaInMatrice (Q,7)); } }