Pages: [1] 2 3 4   Go Down
Print
Author Topic: Esercizio array Frastagliati  (Read 6429 times)
0 Members e 1 Utente non registrato stanno visualizzando questa discussione.
locked
Matricola
*
Offline Offline

Posts: 26


« on: 30-01-2011, 17:46:55 »

Ciao ragazzi!

Non ho trovato svolto questo esercizio sul forum quindi ho deciso di aprire un nuovo topic visto che mi trovo in difficoltà xD

Sono riuscito ad arrivare almeno in parte alla soluzione, dico solo in parte xkè l'esercizio chiede la parola + lunga nella colonna completa mentre io riesco a trovare la parola + lunga di tutto l'array ma non so come cercare solo nella colonna completa più a destra dell'array(in questo caso la prima e l'unica)!

Ed infine non sono del tutto convinto di aver usato il giusto numero di cicli... si può massimizzare e quindi ridurre i cicli oppure così sono ok?

Ecco il codice:

Code:
/*Scrivere un metodo che prenda in input una matrice bidimensionale frastagliata S di stringhe e
restituisca la parola più lunga presente nella colonna completa
più a destra di S. (Si supponga che ogni riga di S sia non vuota). */
public class Esfrastagliato22
{
public static void main (String [] args)
{
String [][] A = {{"ciao","mortadella"},
     {"salmo","telleeeee","micidi"},
     {"samuelel"},
     {"micidiale","polpettadimanzo"}};

System.out.println (Es(A));

}

public static String Es (String [][] A )
{
String Risultato=""; String temp=""; String temp1="";
for (int r=0; r<A.length; r++)
{
for (int c=0; c<A[r].length; c++)
{
for (int rr=r+1; rr<A.length; rr++)
{
for (int cc=0; cc<A[rr].length; cc++)
{

if (A[r][c].length()>A[rr][cc].length())
{
temp=A[r][c];

}
else
{
temp1=A[rr][cc];
}
}
}
}
}

if (temp.length()>temp1.length())
{
Risultato=temp;
}
else
{
Risultato=temp1;
}
return Risultato;
}
}

Grazie!  ciao
Logged
StephCT
Apprendista Forumista
**
Offline Offline

Gender: Male
Posts: 417



« Reply #1 on: 30-01-2011, 19:32:54 »

Code:
String metodo15(String[][] S)
{
int max=S[0].length;
for(int i=1;i<S.length;i++)
if(S[i].length>max)
max=S[i].length;
boolean trovata=false;
for(int j=max-1;j>=0 && !trovata;j--)
{
byte cont=0;
for(int i=0;i<S.length;i++)
if(j<S[i].length)
cont++;
if(cont==S.length)
{
byte max=S[0][j].length();
byte index=0;
for(int r=1;r<S.length;r++)
if(S[r][j].length()>max)
{
index=r;
max=S[r][j].length();
}
return S[index][j];
}
}
}

prova un pò sto codice, tra un teorema e l'altro di analisi ho tirato fuori questo, sicuramente da migliorare xò il senso è questo: prima trovare la colonna completa più a destra, quando l'ho trovata, cerco quella più lunga e la mando in return


cmq anche il tuo intento di arrivare a trovare la più lunga di tutto l'array è abbastanza "sporco". dovresti usare solo i cicli della r e della c e andare avanti aggiornando una variabile String con la stringa sempre più lunga che trovi, senza doverti ingarbugliare cn due temp e un risultato ecc.
« Last Edit: 30-01-2011, 19:35:11 by StephCT » Logged

"Che la Forza sia con Te"
locked
Matricola
*
Offline Offline

Posts: 26


« Reply #2 on: 30-01-2011, 20:03:40 »

si mi sono reso conto di essermi un tantino ingarbugliato però non vedevo altre vie xD

per quanto riguarda il tuo codice diverse cose non mi sono chiare...se ti è possibile metti un paio di commenti? xD

quando vedo del codice non mio, capire il xkè è una vera impresa anche xkè ancora non sono una cima  evil

grazie 1000 
Logged
Luxandro
Apprendista Forumista
**
Offline Offline

Posts: 307



« Reply #3 on: 30-01-2011, 20:22:35 »

L'esercizio chiede di scrivere un metodo che ritorni la stringa più lunga presente nella colonna completa (supponendo che tutte le righe siano non nulle). 

Il metodo deve tornare la stringa solo quando "incontra" una colonna che ha dimensioni uguali ad S.length.
Sperando ti possa essere d'aiuto posto di seguito una possibile soluzione
Code:
public static String metodo (String [][] S)
{
int maxColonna = 0, max = 0; String p = "";

for (int c = 0; c < S.length; c++)
maxColonna = Math.max (maxColonna, S[c].length);

for (int j = maxColonna - 1; j >= 0; j--)
{
int cont = 0;
for (int i = 0; i < S.length; i++)
{
if (S[i][j].length() > max)
{
max = S[i][j].length();  p = A[i][j];  cont ++;
}
if (cont == S.length)  return p;
}
}
}

calcolo del maxColonna
Code:
for (int c = 0; c < S.length; c++)
maxColonna = Math.max (maxColonna, S[c].length);
poichè l'esercizio specifica che la parola si deve trovare nella nella colonna completa
più a destra di S
, facciamo partire l'indice j del for che gestisce le colonne dalla massima dimensione
Code:
for (int j = maxColonna - 1; j >= 0; j--)
{
inseriamo un contatore che ci permetta di restituire la stringa maggiore solo quando si trova la colonna completa, ovvere solo quando cont == S.length.
Code:
for (int i = 0; i < S.length; i++)
{
if (S[i][j].length() > max)
{
max = S[i][j].length();  p = A[i][j];  cont ++;
}
if (cont == S.length)  return p;
}
}
Logged

"Quando non stai guardando è come un'onda. Quando guardi è come una particella!"
locked
Matricola
*
Offline Offline

Posts: 26


« Reply #4 on: 30-01-2011, 21:15:56 »

Grazie Luxandro!

Penso di aver capito il tuo ragionamento solo che c'è un errore nella parte:

Code:
if (cont == S.length)  return p;

Il compilatore da errore xkè nel momento in cui non entra nel ciclo if non c'è nessuna return... solo che non so come toglierlo visto che seguendo il tuo ragionamento il risultato lo devo avere solo se il contatore è uguale alla lunghezza della colonna!
Logged
StephCT
Apprendista Forumista
**
Offline Offline

Gender: Male
Posts: 417



« Reply #5 on: 31-01-2011, 00:21:06 »

allora diciamo che fino al punto della j di luxandro faccio la stessa cosa, solo che lui memorizza sempre la stringa più lunga che trova e la ritorna se l'ha trovata in una colonna completa. mentre io prima cerco la colonna più completa a destra e poi la scorro per cercare la stringa di lunghezza massima. quando ho finito di scorrere la colonna ritorno la stringa. sull'errore che ti da il compilatore...dovresti postarlo perchè sostanzialmente lo troverei anche nel mio codice dato che il return lo faccio nello stesso momento, cioè quando il cont è uguale alla lunghezza. ti posso consigliare cmq una cosa. togli quel return da li ma utilizza il solito booleano che cambia di significato ed esce dai cicli e il ritorno lo metti fuori da tutto alla fine del metodo. e se segui il mio codice fallo pure li, xkè ora ke lo guardo stavo adottando proprio quell'idea ma poi ho messo il return come un pollo xD
Logged

"Che la Forza sia con Te"
locked
Matricola
*
Offline Offline

Posts: 26


« Reply #6 on: 31-01-2011, 10:39:35 »

Allora l'errore che da di base é:
 
Code:
Esfrastagliato22B.java:50: missing return statement
}

cmq sto cercando di far funzionare quello postato da luxandro che lo vedo un po' + semplice o che cmq si avvicina di + al mio modo di ragionare xD

solo che ovviamente anche se io utilizzo un boolean e metto poi l'if e l'else fuori dai cicli in ogni caso mi va "Out Of Bounds" xD

secondo me potrebbe esserci un errore qui;
Code:
for (int c=0; c<A.length; c++) ------>iniziando tutto l'es. con questo ciclo essendo un array frastagliato come
                                                                   capisce che ci riferiamo alle colonne?
{
maxColonna=Math.max(maxColonna,A[c].length);
                         }
for (int j=maxColonna-1; j>=0; j--)   ----------->il -1 viene messo perchè? non dobbiamo analizzare l'ultima
                                                                                          colonna?

per il resto in teoria dubbi non ne ho anche se cmq non funziona xD
Logged
Luxandro
Apprendista Forumista
**
Offline Offline

Posts: 307



« Reply #7 on: 31-01-2011, 11:12:41 »

Come ha giustamente fatto notare Steph
Quote
togli quel return da li ma utilizza il solito booleano che cambia di significato ed esce dai cicli e il ritorno lo metti fuori da tutto alla fine del metodo
quindi una cosa di questo tipo
Code:
public static String metodo (String [][] S)
{
int maxColonna = 0, max = 0; String p = ""; boolean trovato = false;

for (int c = 0; c < S.length; c++)
maxColonna = Math.max (maxColonna, S[c].length);

for (int j = maxColonna - 1; (j >= 0) && (!trovato); j--)
{
int cont = 0;
for (int i = 0; (i < S.length) && (!trovato); i++)
{
if (S[i][j].length() > max)
{
max = S[i][j].length();  p = A[i][j];  cont ++;
}
if (cont == S.length)  trovato = true;
}
}
return trovato;
}
Per quanto riguarda l'impostazione del ciclo for
Code:
for (int j=maxColonna-1; j>=0; j--)
esso è esattamente l'opposto del ciclo for
Code:
for (int j=0; j<maxColonna;j++)
poichè supponendo, ad esempio, maxColonna = 3
nel primo caso --> for (int j=maxColonna-1; j>=0; j--) il for "ciclerà" da 2 a 0 (3 volte)
nel secondo caso --> for (int j=0; j<maxColonna;j++) il for "ciclerà" da 0 a 2 (3 volte)
Logged

"Quando non stai guardando è come un'onda. Quando guardi è come una particella!"
locked
Matricola
*
Offline Offline

Posts: 26


« Reply #8 on: 31-01-2011, 11:45:23 »

Io devo cmq fare una return della Stringa "p" nel tuo caso e non di un valore boolean... quindi questo vuol dire :

Code:
if (cont==A.length)
{
return Risultato  (p nel tuo caso);

}

alla fine di tutto l'esercizio metto:

Risultato="null";
return Risultato;

perchè in teoria quando si ha una return smette di ciclare
quindi se arriva in fondo vuol dire che non ha trovato una parola lunga
 (il ke mi sa di impossibile visto che può accadere solo in una colonna nulla xò è giusto
 x fare riconoscere la return dentro l'if xD)

però va cmq in out of Bounds xD
« Last Edit: 31-01-2011, 11:55:06 by locked » Logged
Luxandro
Apprendista Forumista
**
Offline Offline

Posts: 307



« Reply #9 on: 31-01-2011, 12:12:51 »

Scusami hai ragione!  testate  errore di distrazione!  ok
Hai provato a mettere il controllo if(j<S.length) subito dentro il for delle righe?
Logged

"Quando non stai guardando è come un'onda. Quando guardi è come una particella!"
StephCT
Apprendista Forumista
**
Offline Offline

Gender: Male
Posts: 417



« Reply #10 on: 31-01-2011, 13:20:27 »

allora locked ricorda che x quanto riguarda le dimensioni degli array, se un array è lungo 10 vuol dire che gli indici vanno da 0 a 9. così vale anche x le stringhe. ora il codice rifatto da luxandro nn da problem, si ovvio correggi il return trovato con return p. però dove c'è l'if:
if (S[j].length() > max)
            {
               max = S[j].length();  p = A[j];  cont ++;
            }
bisogna aggiustarlo con:
if (j<S.length && S[j].length() > max)
            {
               max = S[j].length();  p = A[j];  cont ++;
            }

se nn metti quello è ovvio che ti va in outofbounds perchè tu nn hai controllato se quell'elemento nella colonna realmente esiste. una cosa che ho capito è che il return deve essere certo in un metodo. quindi per evitare problemi in compilazione nn ho più messo dei return dentro degli if o cicli ma un unico punto di uscita fuori da tutto...anche se in realtà prima facevo così, di mettere il return dentro l'if dentro dei controlli annidati e problemi nn me ne dava...
Logged

"Che la Forza sia con Te"
Luxandro
Apprendista Forumista
**
Offline Offline

Posts: 307



« Reply #11 on: 31-01-2011, 13:43:17 »

Già! manca proprio quel controllo   testate
Logged

"Quando non stai guardando è come un'onda. Quando guardi è come una particella!"
locked
Matricola
*
Offline Offline

Posts: 26


« Reply #12 on: 31-01-2011, 13:49:25 »

ok mi sento molto ottuso ma non capisco...

Code:
for (int j=maxColonna-1; (j>=0) ; j--)
{
int cont=0;
for (int r=0; (r < A.length)  ;r++)
{
if (j<A.length && A[r][j].length()>max )  ------->il j<A.length a che serve? sempre minore xkè j
                                                                                                         parte da maxcolonna-1!
{
max=A[r][j].length();
Risultato=A[r][j];
cont++;
}
if (cont==A.length)
{
Risultato=A[r][j];

}

}
}

return Risultato;

il fatto che tu nell'if metti solo[j] xkè? xD

scusate ma ancora non capisco al volo i vari cicli quindi non riesco assolutamente a seguirvi xD
Logged
Luxandro
Apprendista Forumista
**
Offline Offline

Posts: 307



« Reply #13 on: 31-01-2011, 13:52:26 »

if (j < A[ i ].length)  controlla se effettivamente esiste la colonna corrispondente all'indice j
Logged

"Quando non stai guardando è come un'onda. Quando guardi è come una particella!"
StephCT
Apprendista Forumista
**
Offline Offline

Gender: Male
Posts: 417



« Reply #14 on: 31-01-2011, 14:36:37 »

devi mettere A[ i ].length. hai presente quando fai il solito ciclo j=0;j<A[i ].length; j++? ecco fai partire da 0 e deve arrivare al max della lunghezza di quella riga. se la dimensione associata a i=4 è 5, l'indice j può arrivare a 4. in un array frastagliato nn essendo sempre la stessa dimensione potrebbe capitare che la riga più lunga è di 4, ma ti trovi nella riga che invece è lunga 3 quindi dato che, in questo caso, mantieni costante prima l'indice j, cambiando la i, vai a finire in un punto della "matrice" vuoto.
Logged

"Che la Forza sia con Te"
Pages: [1] 2 3 4   Go Up
Print
Jump to: