Forum Informatica Unict

LAUREA TRIENNALE (D.M. 270/04) => Programmazione 1, 9 CFU => Topic started by: locked on 30-01-2011, 17:46:55



Title: Esercizio array Frastagliati
Post by: locked 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


Title: Re:Esercizio array Frastagliati
Post by: StephCT 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.


Title: Re:Esercizio array Frastagliati
Post by: locked 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  >:)

grazie 1000  .wink


Title: Re:Esercizio array Frastagliati
Post by: Luxandro 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;
}
}


Title: Re:Esercizio array Frastagliati
Post by: locked 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!


Title: Re:Esercizio array Frastagliati
Post by: StephCT 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


Title: Re:Esercizio array Frastagliati
Post by: locked 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


Title: Re:Esercizio array Frastagliati
Post by: Luxandro 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)


Title: Re:Esercizio array Frastagliati
Post by: locked 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


Title: Re:Esercizio array Frastagliati
Post by: Luxandro on 31-01-2011, 12:12:51
Scusami hai ragione!  :-)|  errore di distrazione!  :-OK
Hai provato a mettere il controllo if(j<S.length) subito dentro il for delle righe?


Title: Re:Esercizio array Frastagliati
Post by: StephCT 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...


Title: Re:Esercizio array Frastagliati
Post by: Luxandro on 31-01-2011, 13:43:17
Già! manca proprio quel controllo   :-)|


Title: Re:Esercizio array Frastagliati
Post by: locked 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


Title: Re:Esercizio array Frastagliati
Post by: Luxandro on 31-01-2011, 13:52:26
if (j < A[ i ].length)  controlla se effettivamente esiste la colonna corrispondente all'indice j


Title: Re:Esercizio array Frastagliati
Post by: StephCT 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.


Title: Re:Esercizio array Frastagliati
Post by: locked on 31-01-2011, 14:38:57
ok allora ipotizzando che io abbia capito mi sfugge ancora un ultimo dettaglio che in teoria dovrebbe essere l'ultimo xD

Code:
for (int j=maxColonna-1; (j>=0) ; j--)
{
int cont=0;
for (int r=0; r < A.length  ;r++)
{
if (j<A[r].length && A[r][j].length()>max ) ------->ok capito il significato di j<A[r].length xD
{
if (cont==A.length)
{
max=A[r][j].length();
Risultato=A[r][j];
cont++;
}
}
if (cont==A.length)
{
Dentro questo ciclo io in teoria dovrei confermare che il valore associato alla stringa
                                         Risultato sia corretto quindi controllo se la colonna è completa... ma che istruzione metto
                                         qui?
}


}
}

return Risultato;


Title: Re:Esercizio array Frastagliati
Post by: Luxandro on 31-01-2011, 14:48:34
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) && (j < S[i].length))
{
max = S[i][j].length();  p = S[i][j];  cont ++;  
}
if (cont == S.length)  trovato = true;  
}
}
return p;
}
if (cont == S.length)  trovato = true;  ----> solo quando si troverà la colonna completa si potrà uscire dai for e ritornare la stringa dalla lunghezza maggiore della colonna in questione


Title: Re:Esercizio array Frastagliati
Post by: StephCT on 31-01-2011, 14:51:28
if (j<A[r].length && A[r][j].length()>max )
            {
               if (cont==A.length)      <----questo è da eliminare
               {
               max=A[r][j].length();
               Risultato=A[r][j];
               cont++;
               }
            }


Title: Re:Esercizio array Frastagliati
Post by: locked on 31-01-2011, 14:56:36
ok ma curiosità.. a voi funziona? xD

A me ritorna la parola + lunga ma non considerando la colonna completa!

Se capita un esercizio tipo questo alla prova sono spacciato   :boh


Title: Re:Esercizio array Frastagliati
Post by: StephCT on 31-01-2011, 14:58:12
sinceramente nn sto compilando, xkè mi immedesimo nella prova...ho sentito di ragazzi ke hanno passato l'esame pur avendo scritto programmi che avevano errori, o in compilazione o in esecuzione. deve funzionare "ideologicamente"

ti ritorna la parola più lunga della colonna più a destra?


Title: Re:Esercizio array Frastagliati
Post by: Luxandro on 31-01-2011, 15:00:00
A me da il solito errore ---> ArrayIndexOutOfBoundsException    Dove sbaglio?  .penso
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 Frast1
{
public static void main (String [] args)
{
String [][] S = {{"alessandro","ivan","andrea"},{"ale"},{"viola","gigi"},{"sandro","marco","flora","giuseppe"},{"pippo","fra"}};
System.out.println(metodo(S));
}

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) && (j < S[i].length))
{
max = S[i][j].length();  p = S[i][j];  cont ++;
}
if (cont == S.length)  trovato = true;
}
}
return p;
}
}


Title: Re:Esercizio array Frastagliati
Post by: StephCT on 31-01-2011, 15:03:53
(S[i ][j].length() > max) && (j < S[i ].length)

l'errore dovrebbe stare qui. praticamente l'&& operatore è cortocircuitato, se la prima è falsa nn controlla la seconda, altrimenti la controlla. ci siamo? quindi praticamente cerca di controllare la lunghezza senza aver verificato che l'elemento esiste. sembra banale ma l'and funziona per ordine da sinistra a destra


Title: Re:Esercizio array Frastagliati
Post by: Luxandro on 31-01-2011, 15:06:01
(S[i ][j].length() > max) && (j < S[i ].length)

l'errore dovrebbe stare qui. praticamente l'&& operatore è cortocircuitato, se la prima è falsa nn controlla la seconda, altrimenti la controlla. ci siamo? quindi praticamente cerca di controllare la lunghezza senza aver verificato che l'elemento esiste. sembra banale ma l'and funziona per ordine da sinistra a destra

Hai ragione, thx  :[Emoticon] Asd:


Title: Re:Esercizio array Frastagliati
Post by: locked on 31-01-2011, 15:06:41
no mi da solo la stringa più lunga di tutta la matrice frastagliata... di guardare quelle a destra non ne ha proprio intenzione xD


Title: Re:Esercizio array Frastagliati
Post by: StephCT on 31-01-2011, 15:09:29
perdonami se allungo il brodo ma riposta il codice che stai usando corretto così vediamo


Title: Re:Esercizio array Frastagliati
Post by: Luxandro on 31-01-2011, 15:22:12
Nell'attesa di risolvere l'esercizio ne posto di seguito un altro
Code:
/* Scrivere un metodo che prenda in input un array bidimensionale frastagliato A di stringhe, e
restituisca un boolean che indichi se esistono due righe compatibili in A. Due righe r1 e r2 si dicono
compatibili se esiste una stringa in r1 e contemporaneamente la sua inversa in r2 */

public static boolean metodo (String [][] A)
{
int maxColonna = 0, y;
for (int g = 0; g < A.length; g++)
            maxColonna = Math.max (maxColonna, A [g].length);

for (int i = 0; i < A.length; i++)
for (int j = 0; j < maxColonna; j++)
{
if ((j < A[i].length) && (A[i + 1][j] != null))
for (int a = i + 1; a < A.length; a++)
{
for (int b = 0; b < A [i].length; b++)
{
y = A [a][b].length();   char [] c = A [a][b].toCharArray();  System.out.println(c);  String x = "";
for (int k = y - 1; k >= 0; k--)     x += c [k];
if (A [i][j].equals(x))   return true;
}
}
}
return false;
}
Ps.: solito errore ---> java.lang.ArrayIndexOutOfBoundsException
Probabilmente sbaglio quando inizializzo a = i + 1, poichè quando la dimensione successiva ad i non è presente, vado fuori dall'array...


Title: Re:Esercizio array Frastagliati
Post by: StephCT on 31-01-2011, 15:28:10
secondo me poteva tradurre questa richiesta semplicemente nel cercare una stringa e la sua inversa in un'altra riga diversa dalla prima. in questo caso nn devi scorrere per colonne, nn hai bisogno di cercare la maxcolonna. quindi nel ciclo della j metti semplicemente j<A[i ].length e togli quell'if subito sotto. il tochararray è un metodo che sinceramente nn uso, nn capisco a cosa serva la print, però credo che in teoria funzioni con quel piccolo ritocco...


Title: Re:Esercizio array Frastagliati
Post by: locked on 31-01-2011, 15:28:52
eccolo:
Code:
public static String Es (String [][] A )
{
int maxColonna=0;
String Risultato="";
int max=0;
boolean trovato=false;

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



for (int j=maxColonna-1; (j>=0) && (!trovato) ; j--)
{
int cont=0;
for (int r=0; (r < A.length) && (!trovato)  ;r++)
{
if ((j<A[r].length) && (A[r][j].length())>max )
{

max=A[r][j].length();
Risultato=A[r][j];
cont++;

}
if (cont == A.length)
{
trovato=true;
}



}
}

return Risultato;

}
}


Title: Re:Esercizio array Frastagliati
Post by: Luxandro on 31-01-2011, 15:31:42
secondo me poteva tradurre questa richiesta semplicemente nel cercare una stringa e la sua inversa in un'altra riga diversa dalla prima. in questo caso nn devi scorrere per colonne, nn hai bisogno di cercare la maxcolonna. quindi nel ciclo della j metti semplicemente j<A[i ].length e togli quell'if subito sotto. il tochararray è un metodo che sinceramente nn uso, nn capisco a cosa serva la print, però credo che in teoria funzioni con quel piccolo ritocco...

La print era solo di verifica  :[Emoticon] Asd:

cmq si, bisogna interpretare bene l'esercizio, in fondo la difficoltà della prima prova sta quasi tutta li.....


Title: Re:Esercizio array Frastagliati
Post by: StephCT on 31-01-2011, 15:32:54
Code:
for (int j=maxColonna-1; (j>=0) && (!trovato) ; j--)
{
                       max=0;           <----- :yoh scoperto l'inghippo! devi resettare la lunghezza max al cambio di colonna. dovrebbe essere questa la cosa per far funzionare il codice
int cont=0;
for (int r=0; (r < A.length) && (!trovato)  ;r++)

x questo pensavo che il mio codice fosse leggermente meglio. xkè sei sicuro che vai a cercare la stringa più lunga solo nella colonna completa più a destra precedentemente


Title: Re:Esercizio array Frastagliati
Post by: locked on 31-01-2011, 15:35:21
ahaha vero xD basta finalmente risulta!

certo io non avrei mai fatto questo tipo di ragionamento! troppo casinoo! spero solo che alla prova siano + semplici xD

cmq grazie x l'aiuto ragazzi!  almeno posso passare a qualche altro esercizio!  :-OK


Title: Re:Esercizio array Frastagliati
Post by: Luxandro on 31-01-2011, 15:46:43
Code:
public static boolean metodo (String [][] A)
{
for (int i = 0; i < A.length; i++)
for (int j = 0; j < A[i].length; j++)
for (int a = i + 1; a < A.length; a++)
for (int b = 0; b < A [i].length; b++)
{
int y = A [a][b].length();  char [] c = A [a][b].toCharArray();  String x = "";
for (int k = y - 1; k >= 0; k--)     x += c [k];
if (A [i][j].equals(x))   return true;
}
return false;
}
L'ho corretto ma da sempre lo stesso errore...il problema credo sia nel
Code:
for (int a = i + 1; a < A.length; a++)


Title: Re:Esercizio array Frastagliati
Post by: StephCT on 31-01-2011, 16:01:05
nn credo sia quello il problema xkè anche se l'indice i arriva a rappresentare l'ultima riga, assegnando la a i+1, controlla la condizione e nn ci entra quindi....se fosse quello il problema lo potresti risolvere facendo la condizione della i come i<A.length-1. poi nn so esattamente quale potrebbe essere il problema, mi pare tutto corretto. sicuramente puoi sistemare il codice con il solito booleano per avere un unico punto di ritorno, poi invece di dichiarare la y, puoi fare nel ciclo k = c.length-1...se ti dovesse dare problemi ancora, allora prova questa mia soluzione:
Code:
public static boolean metodo (String [][] A)
{
boolean trovata=false;
for (int i = 0; i < A.length-1 && !trovata; i++)
for (int j = 0; j < A[i].length && !trovata; j++)
for (int a = i + 1; a < A.length && !trovata; a++)
for (int b = 0; b < A [i].length && !trovata; b++)
{
boolean diverse=false;
if(A[i][j].length()==A[a][b].length())
for(int k=0;k<A[i][j].length() && !diverse;k++)
if(A[i][j].charAt(k)!=A[a][b].charAt(A[a][b].length()-1-k))
diverse=true;
if(!diverse)
trovata=true;
}
return trovata;
}

in pratica prima vede se le lunghezze sono le stesse, poi entra nel ciclo e se sono l'una l'inversa dell'altra allora si esce fuori e si ritorna


Title: Re:Esercizio array Frastagliati
Post by: Luxandro on 31-01-2011, 16:09:48
Mi da errore anche con il tuo codice e la cosa assurda è che ho questo tipo di problema quasi in ogni metodo in cui si deve inizializzare un indice al successivo di un altro ---> int a = i + 1

questo codice ne è un esempio

Code:
/* Scrivere un metodo che prenda in input un array bidimensionale frastagliato A di Stringhe e
restituisca un boolean che indichi se esiste in A una colonna contenente una stringa e la sua
proiezione.(Attenzione alle stringhe mancanti!). La proiezione di una stringa s e' la stringa s1
ottenuta sostituendo ogni carattere in s con il carattere successivo o precedente.
Es.: s = "depg"  s1 = "cdof". */

public static boolean metodo (String [][] A)
{
int maxColonna = 0;

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

for (int j = 0; j < maxColonna; j++)
for (int i = 0; i < A.length; i++)
if (j < A[i].length)
{
char [] x = A[i][j].toCharArray();  String s1 = ""; String s2 = "";
for (int w = 0; w < x.length; w++)
{
s1 += (x[w] + 1);  s2 += (x[w] - 1);
}
for (int r = i + 1; r < A.length; r++)
if (A[r][j].length() == A[i][j].length())
if ((A[r][j].equals(s1)) || (A[r][j].equals(s2))) return true;
}
return false;
}

ps.: non capisco proprio in cosa sbaglio  :-)|  (ho provato anche con r < A.length - 1 )


Title: Re:Esercizio array Frastagliati
Post by: StephCT on 31-01-2011, 16:16:47
for (int i = 0; i < A.length; i++)
      for (int j = 0; j < A[i ].length; j++)
         for (int a = i + 1; a < A.length; a++)
            for (int b = 0; b < A [i ].length; b++)


è affettuoso perdonami xD tu sei #@!!01Z#@!!@$^ e io più di te  :yoh
b deve essere minore di A[a].length non di A[i ].length XD ovvio che fa fuori dalle dimensioni perchè si associa sempre alla prima dimensione. infatti anche nel nuovo codice che hai postato

for (int r = i + 1; r < A.length; r++)
                  if (A[r][j].length() == A[i ][j].length())

qui devi controllare che l'elemento A[r][j] esista con if(j<A[r].length)


Title: Re:Esercizio array Frastagliati
Post by: Luxandro on 31-01-2011, 16:21:33
STATO D'ANIMO SUCCESSIVO ALLA SCOPERTA DELL'ERRORE --->  :-)| :-)| :-)| :-)| :-)| :-)| :-)| :-)| :-)| :-)| :-)| :-)| :-)| :-)| :-)| :-)| :-)| :-)| :-)| :-)| :-)| :-)| :-)| :-)| :-)| :-)| :-)| :-)| :-)| :-)| :-)| :-)| :-)| :-)| :-)| :-)| :-)| :-)|


Title: Re:Esercizio array Frastagliati
Post by: Luxandro on 31-01-2011, 16:28:12
Altro errore nell'esercizio della "proiezione", il casting a char nella creazione delle stringhe s1 e s2  .smile
Code:
s1 += (char)(x[w] + 1);  s2 += (char)(x[w] - 1);


Title: Re:Esercizio array Frastagliati
Post by: StephCT on 31-01-2011, 16:36:39
allora in maniera compatta così come fai te nn saprei come castarla in maniera corretta quindi per risolvere in maniera sicura la cosa, fai una variabile char in cui ci metti il carattere e poi questa variabile la concateni alla stringa che è un operazione sicuramenta valida


Title: Re:Esercizio array Frastagliati
Post by: Luxandro on 31-01-2011, 16:38:26
allora in maniera compatta così come fai te nn saprei come castarla in maniera corretta quindi per risolvere in maniera sicura la cosa, fai una variabile char in cui ci metti il carattere e poi questa variabile la concateni alla stringa che è un operazione sicuramenta valida

Ho provato e in output da esito positivo!   :yoh


Title: Re:Esercizio array Frastagliati
Post by: Jack&Daxter on 31-01-2011, 20:49:33
Ragazzi ma mi spiegate perche nell'esercizio precedente (quello della stringa + grande nella colonna completa a dx) avete messo cont++ ? nn ho cpt più che altro perchè il cont++ sta dentro l'if : if(A[i ][j].length()>max && j<A[i ].length) e non fuori...Secondo me dovrebbe stare fuori perchè cont++ si deve aggiornare A.length volte e non solo quando entra dentro l'if , non so se mi spiego....GRAZIE .wink


Title: Re:Esercizio array Frastagliati
Post by: Chuck_son on 31-01-2011, 21:02:34
cosa si intende per colonna completa? .arrossisco


Title: Re:Esercizio array Frastagliati
Post by: StephCT on 31-01-2011, 21:12:15
cosa si intende per colonna completa? .arrossisco

si intende la colonna dove sono presenti tutti gli elementi, cn gli array frastagliati capita che le righe non abbiano tutte la stessa lunghezza, quindi capita di trovare un elemento e scorrendo la riga quello sotto nn c'è, poi sotto ancora ritroviamo un elemento ecc...


Ragazzi ma mi spiegate perche nell'esercizio precedente (quello della stringa + grande nella colonna completa a dx) avete messo cont++ ? nn ho cpt più che altro perchè il cont++ sta dentro l'if : if(A[i ][j].length()>max && j<A[i ].length) e non fuori...Secondo me dovrebbe stare fuori perchè cont++ si deve aggiornare A.length volte e non solo quando entra dentro l'if , non so se mi spiego....GRAZIE .wink

il cont serve a dirci se la colonna è completa xkè se è uguale alla lunghezza di una colonna completa in quella matrice allora è la famosa colonna completa più a destra. in effetti dovrebbe stare in mezzo ai due controlli, cioè se j<A[i ].length è vera il contatore sale xkè esiste l'elemento nella colonna, poi si controlla la lunghezza della stringa


Title: Re:Esercizio array Frastagliati
Post by: Jack&Daxter on 31-01-2011, 21:21:46
non dovrebbe essere cosi ?? l'ho fatto in maniera approssimativa senza il contenuto del for
Code:
for(colonne)
   cont=0;
     {
        for(righe)
           {
               if(A[i][j].length()>max && j<A[i].length)
                 {
                     max=A[i][j].length();
                     p=A[i][j];
                  }

                 cont++;

                 if(cont==A.length)
                 return p;
             }
         }


Title: Re:Esercizio array Frastagliati
Post by: Chuck_son on 31-01-2011, 21:27:13
quindi se ho
int [][] a= new int [5][];

a[0]=new int [5]   sarebbe questa la colonna completa? cioe quella che ha colonne uguali alle righe?


Title: Re:Esercizio array Frastagliati
Post by: StephCT on 01-02-2011, 00:54:26
no però se:
int [][] a= new int [5][];
A[0]=new int[4];
A[1]=new int[5];
A[2]=new int[3];
A[3]=new int[4];
A[4]=new int[2];

le colonne complete sono quelle in cui usando l'indice j, vanno da 0 a 2, cioè le prima tre colonne. andando avanti vedi che l'ultima riga è meno lunga delle altre, anche se in realtà sn tutte diverse...è più chiaro ora?


Title: Re:Esercizio array Frastagliati
Post by: locked on 01-02-2011, 10:52:49
Buon dì! Vi posto un esercizio che risulta senza problemi solo che ho un piccolo dubbio  8-|

Code:
/*Scrivere un metodo che prenda in input una scacchiera quadrata A, e restituisca il numero di salti
che una palla pazza effettua sulla scacchiera partendo dalla posizione in alto a sinistra, applicando
la seguente regola. Se la palla si trova nella posizione (i,j)e A[i][j]>5, allora la palla salterà in una
posizione casuale nella stessa riga; se A[i][j]<5, allora la palla salterà in una posizione casuale
nella stessa colonna. La palla termina di saltare se A[i][j]=5. Non è possibile utilizzare “return”
all’interno di cicli. */
public class Esfrastagliato27
{
public static void main (String []args)
{
int [][] A = {{7,9,3,7},
 {2,6,6,8},
 {5,6,3,8}};
 
 
System.out.println (Es(A));

}

public static String Es (int [][] A)
{
String risultato="";
int r=0;
int c=0;
int salti=0;
int palla=0;

while(palla!=5)
{
palla= A[r][c];
if(palla>5)
{
c=((int)(Math.random()*A.length));
System.out.println(A[r][c]);
palla=A[r][c];
salti++;
}
else
{
r=((int)(Math.random()*A.length));
System.out.println(A[r][c]);
palla=A[r][c];
salti++;
}

if (palla==5)
{
risultato=" La palla ha fatto "+salti+ " "+"salti";   -----> Ho Fatto diverse prove fino ad
                                                
                                                 aggiungere il terzo "+" e diverse virgolette x farlo funzionare! ma non ho capito
                                                  perchè ci vuole! In teoria non dovrebbe bastare: "La palla ha fatto"+salti+"salti";
                                                  non capisco il motivo xD
}
}
return risultato;
}
}

Code:
if (palla==5)
{
risultato=" La palla ha fatto "+salti+ " "+"salti";   -----> Ho Fatto diverse prove fino ad
                                               
                                                 aggiungere il terzo "+" e diverse virgolette x farlo funzionare! ma non ho capito
                                                  perchè ci vuole! In teoria non dovrebbe bastare: "La palla ha fatto"+salti+"salti";
                                                  non capisco il motivo xD


Title: Re:Esercizio array Frastagliati
Post by: StephCT on 01-02-2011, 11:52:18
tecnicamente è sbagliato il return. xkè devi restituire i salti, il numero, non una stringa dove c'è scritto che sn stati fatti "tot" salti. quindi si presuppone che quando viene invocato, al chiamante interessa il numero per fare delle operazioni o chissà che.. per il resto è corretto. io quando l'avevo fatto mi muovevo anche senza la variabile palla ma semplicemente controllando il contenuto.


Title: Re:Esercizio array Frastagliati
Post by: locked on 01-02-2011, 12:13:06
era solo x renderlo + leggibile! con una return di un int non dava nessun problema! :-OK


Title: Re:Esercizio array Frastagliati
Post by: StephCT on 01-02-2011, 12:45:20
visto con cosa abbiamo a che fare all'esame, la pignoleria non è mai troppa  .smile


Title: Re:Esercizio array Frastagliati
Post by: locked on 01-02-2011, 12:54:53
essì! io ormai sto impazzendo dietro decine di esercizi xD

te ne posto altri 2 belli belli! ti scrivo anke dove penso ci sia l'errore ma non capisco come correggerlo -.-

Code:
/*Scrivere un metodo che prenda in input un array bidimensionale frastagliato S di stringhe, e
restituisca un boolean che indichi se esiste una stringa in S con i primi due caratteri uguali e
contemporaneamente con gli ultimi due caratteri uguali (primo ed ultimo possono differire). */
public class EsFrastagliato34
{
public static void main (String [] args)
{
String [][] A = {{"ciao","salmone"},
                    {"tuma","monitor","desktop"},
    {"bottigliabo","telecomando"}};

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

public static boolean Es(String [][] A)
{
boolean trovato=false;

for(int r=0; r<A.length; r++)
{
for (int c=0; c<A[r].length; c++)
{
if ((A[r][c].substring(0,2)) == (A[r][c].substring(A[r][c].length()-2,A[r][c].length())))
{

trovato=true;
}
}
}
return trovato;
}
}
qui l'errore suppongo sia nell'if visto che non ci entra mai e quindi mi sa che non ho be capito come usa il substring xD

Code:
/*Scrivere un metodo che prenda in input un array bidimensionale frastagliato S di stringhe, e
restituisca un boolean che indichi se esiste una riga di S contenente due stringhe che terminano con
la stessa coppia di caratteri.
*/
public class Esfrastagliato36B
{
public static void main (String[]args)
{
String [][] A = {{"ciao","salmone"},
                     {"tumbo","monitor","desktopbo"},
     {"bottigli","telecoman"}};

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

public static boolean Es (String [][] A)
{
boolean trovato = false;

for (int r=0; r<A.length; r++)
{
for (int c=0; c<A[r].length; c++)
{
for (int cc=c+1; cc<A[r].length; cc++)
{
if ((A[r][c].substring(A[r][c].length()-2,A[r][c].length()))==(A[r][cc].substring(A[r][cc].length()-2,A[r][cc].length())))
{
trovato = true;
}
}
}
}
return trovato;
}
}

anche qui l'errore sta nell 'if perchè non ci entra mai...eppure ci sono 2 stringhe con la stessa coppia di caratteri
uguali nella stessa riga... dove sta l'inghippo?  :boh


Title: Re:Esercizio array Frastagliati
Post by: locked on 02-02-2011, 10:45:56
up!  :-ciao


Title: Re:Esercizio array Frastagliati
Post by: Impact on 02-02-2011, 12:30:23
Ecco qua la mia soluzione:

Code:
/*
Scrivere un metodo che prenda in input un array bidimensionale frastagliato S di stringhe, e
restituisca un boolean che indichi se esiste una riga di S contenente due stringhe che terminano con
la stessa coppia di caratteri.
*/
public class Esfrastagliato36B
{
public static void main (String[]args)
{
String [][] A = {{"ciao","salmone"},{"tumbo","monitor","desktopbo"},{"bottigli","telecoman"}};
boolean output = metodo(A);
System.out.println(output);
}

public static boolean metodo (String [][] A)
{
for (int i=0;i<A.length;i++)
{
for (int j=0;j<A[i].length;j++)
{
for (int l=j+1;l<A[i].length;l++)
{
if (A[i][j].substring(A[i][j].length()-2,A[i][j].length()).equals(A[i][l].substring(A[i][l].length()-2,A[i][l].length())))
return true;
}
}
}
return false;
}
}


Title: Re:Esercizio array Frastagliati
Post by: Impact on 02-02-2011, 12:33:03
Stai confrontando due sottostringhe... quindi devi usare il metodo equals e non i due == in quanto senò ti da errore.


Title: Re:Esercizio array Frastagliati
Post by: locked on 02-02-2011, 12:41:32
ahahaa mannaggia hai ragione xD ecco a cosa serve l'equals   :-K

Stavo impazzendo xkè era scritto x forza giusto quindi non capivo! grazie x l'illuminazione  :-OK


Title: Re:Esercizio array Frastagliati
Post by: Impact on 02-02-2011, 12:47:09
Per quanto riguarda il primo esercizio, il testo dice di trovare una stringa con i primi due caratteri uguali e con gli ultimi due uguali.. primo e ultimo possono differire.. Nel tuo caso restituisce false perchè: "bottigliabo" non rispetta ciò che dice il testo. Due caratteri uguali iniziali e due uguali finali.. quindi può essere qualcosa del tipo: "bbottigliabb" oppure "bbottigliaa" ecc...


Title: Re:Esercizio array Frastagliati
Post by: locked on 02-02-2011, 12:50:55
no no con l'equals funziona anche quello  :yoh

In pratica penso che utilizzando l'equals lui confronta semplicemente la coppia che io gli dico e la vede uguale anche se il primo e l'ultimo differiscono lui si sofferma su 2 caratteri insieme e quindi funziona xD

i due esercizi sono identici con la differenza che nel primo devo fare il controllo nella stessa stringa nel secondo devo controllare 2 stringhe diverse ma il tipo di codice è identico xD