Pages: 1 [2]   Go Down
Print
Author Topic: come non eccedere i limiti dell'array???  (Read 2297 times)
0 Members e 1 Utente non registrato stanno visualizzando questa discussione.
thompson
Matricola
*
Offline Offline

Posts: 40



« Reply #15 on: 06-07-2010, 17:20:36 »



Code:
if(k<A[j].length-1)

ho fatto inversione tra k e j senza il -1 e funziona
 

grazie mille yoh sei un grande
Logged

I computer sono incredibilmente veloci, accurati e stupidi. Gli uomini sono incredibilmente lenti, inaccurati e intelligenti. Insieme sono una potenza che supera l'immaginazione.
Seferex
Matricola
*
Offline Offline

Gender: Male
Posts: 34



« Reply #16 on: 06-07-2010, 17:22:37 »

ahahah ok, quindi dov'è che ho sbagliato cmq?
Dove si deve invertire la j con la k?
Logged
thompson
Matricola
*
Offline Offline

Posts: 40



« Reply #17 on: 06-07-2010, 17:28:01 »

Code:
public class Metodo1del20aprile
{
  public static boolean metodo(byte[][]A,int[]S)
  {
    boolean cntr=false;
   
    for(int i=0;i<A[0].length;i++)
      {       
        int l=0;
        for(int j=0;j<A.length;j++)
        {
          if(i<A[j].length)
          {
          l=l+A[j][i];
        System.out.println(l);
          }
        }   
      for(int h=0;h<S.length;h++)
      {
        if(l==S[h]){
          cntr=true;
        }
      }
    }return cntr;
  }
public static void main(String[]args)
{
  byte[][]A={{9,5,2,1},
             {4},
             {5,8}};
  int S[]={1,2,6,8};
  boolean cntr=metodo(A,S);
  System.out.println(cntr);
  }
}
ho provato nel codice che avevo scritto io
l'inversione l'ho fatta nell'unico if che c'è nel codice
credo che funzioni anche nel tuo pray yoh
Logged

I computer sono incredibilmente veloci, accurati e stupidi. Gli uomini sono incredibilmente lenti, inaccurati e intelligenti. Insieme sono una potenza che supera l'immaginazione.
Seferex
Matricola
*
Offline Offline

Gender: Male
Posts: 34



« Reply #18 on: 06-07-2010, 17:45:48 »

Purtroppo io non riesco a risolvere  testate
tanto ci sbatto la testa contro che prima o poi ci arrivo anche io  yoh

EDIT: mmmmm mi sono accorto solo ora che nel mio esercizio quell'if non ha senso di esistere ^^"

Svelato il mistero del perchè non mi risultava xD
Scandivo la matrice orizzontalmente invece di verticalmente... Di conseguenza facevo un casino ahahahah
Bè in un modo o nell'altro almeno la mia intuizione era corretta xD

Code:
class aaaaa
{
public static boolean metodo (byte [][]A, int []S)
{
int i,j,y;
boolean trovato=false;
for (i=0;i<A[0].length;i++)
{
byte somma=0;
for (j=0;j<A.length;j++)
if(i<A[j].length)
{
somma+=A[j][i];
System.out.println(somma);
}
for (y=0;y<S.length;y++)
if(somma==S[y])
trovato=true;

}

if(trovato==true)
return true;
else return false;
}

public static void main(String[]args)
{
  byte[][]A={{9,5,2,3},
  {1,1,1},
          {5,8,1,2}};
  
    int S[]={1,1,1,15};
  boolean cntr=metodo(A,S);
  System.out.println(cntr);
  }
}

il secondo invece l'ho fatto cosi:

Code:
/* Esercizio 2
Scrivere un metodo che prenda in input ua array bidimensionale frastagliato S di stringhe,
e restituisca un boolean che indichi se esiste una coppia di stringhe in S l'una inversa dell'altra.
*/

class esercizio_2
{
public boolean metodo (String [][]S)
{
int i,j,k,z,y;
boolean trovato=false;
for (i=0;i<S.length;i++)
for(j=0;j<S[i].length;j++)
for (k=i;k<S.length;k++)
for (z=j+1;z<S[k].length;z++)
{
String stringa=" ";
for(y=S[k][z].length();y==0;y--)
stringa+=S[k][z].charAt(y);
if(S[i][j].equals(stringa))
trovato=true;
}
if(trovato==true)
return true;
else return false;
}
}

Ma in questo non dovrebbero esserci problemi di dimensione array
« Last Edit: 06-07-2010, 18:43:03 by Seferex » Logged
Mari_C
Apprendista Forumista
**
Offline Offline

Posts: 240


"SmiiiiLe"


« Reply #19 on: 06-07-2010, 18:50:33 »

Questo post è servito anche a me a migliorare il mio codice e a capire come non andare fuori 

Code:
/* Scrivere un metodo che prenda in input un array bid frastagliato A di byte
ed un array S di interi, e restituisca un boolean che indichi se esiste in S un valore pari alla
somma degli elementi di una qualche colonna di A.(La somma degli elementi di ogni colonna
deve essere calcolata una sola volta.Non si possono usare array ausiliari.Attenzione agli elementi mancanti!)*/

class primoesercizio{
  public static boolean metodo(byte[][]A, int []S){
   boolean trovato =false;
    int somma=0;
    for(int  j=0; j<A[0].length; j++){    
      for(int  i=0; i<A[j].length; i++){
        if( i < A[j].length) //------------------------IF DI CONTROLLO!
        somma+=A[i][j];              
      }                              
      for(int  k=0; k<S.length; k++){
        if(somma == S[k]){
          System.out.println(somma+" "+ S[k]);
          trovato=true;
        }
      }
    }
    return trovato;
  }
   public static void main(String[]args){
    byte A[][]={{1,5,10,20},
                {5,1,0},
                {1,89},
                {1,}};
    int S[]={7,8,2};
    System.out.println(metodo(A,S));
  }
}
//8-8 TRUE

Come faceva notare reversengineer (che ringrazio) nell'if di controllo stiamo appunto controllando l'indice più interno (nel mio caso i) rispetto a A[j].length (essendo j quello più esterno).. Penso proprio sia cosi! 

Infine Seferex penso anch'io che per quanto riguarda il secondo esercizio non dovrebbero esserci problemi di dimensione dell'array!

 
« Last Edit: 06-07-2010, 19:39:30 by Mari_C » Logged
thompson
Matricola
*
Offline Offline

Posts: 40



« Reply #20 on: 06-07-2010, 20:54:18 »

da ciò che ho capito(e spero sia corretto) se scandiamo l'array VERTICALMENTE occorre controllare che non esca dall'array stesso... mentre se scorriamo l'array ORIZZONTALMENTE non occorre fare un controllo

colgo l'occasione per ringraziare tutti della grandissima disponibilità e celerità delle risposte yoh
grazie mille a tutti pray pc
« Last Edit: 06-07-2010, 21:02:21 by thompson » Logged

I computer sono incredibilmente veloci, accurati e stupidi. Gli uomini sono incredibilmente lenti, inaccurati e intelligenti. Insieme sono una potenza che supera l'immaginazione.
Pages: 1 [2]   Go Up
Print
Jump to: