[java] altro problema stupido

[michelev83]

class es78 {
public static void main(String []args) {

int i;
double[] a=new double[10];

for (i=0; i<=a.length-1; i++)
a[i]= Leggi.unDouble();
System.out.println(a[i]);
}
}


con questo prpgrama con javac nn mi da errore ma eseguendolo. dopo aver iserito i valori mi da questo errore:


Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 10 at es78.main(es78.java:9)


:muro:

[Mazza2]

ma le parentesi del for?? :sofico: metticele e funzia tutto :P



class es78 {
public static void main(String []args) {

int i;
double[] a=new double[10];

for (i=0; i<=a.length-1; i++) {
a[i]= Leggi.unDouble();
System.out.println(a[i]);
}
}
}

[michelev83]

gia provato!:muro:

[michelev83]

forsenn mi sono spiefato bene....devo prima inserirli tutti e poi stamparli tutti... :muro:

[michelev83]

:cry:

[Mazza2]

il codice qui sotto funzia alla perfezione. Anche quello che ti ho postato prima funzionava benissimo. L'unico errore puo' essere in Leggi.unDouble(); che non fa il suo dovere tutto qui.
al limite posta la classe Leggi... ciao ;)



class es78 {
public static void main(String []args) {

int i;
double[] a=new double[10];

for (i=0; i<a.length; i++) {
a[i] = Leggi.unDouble();
}

for(int k=0;k<a.length;k++){
System.out.println(a[k]);
}
}
}

[PGI]

Nel codice postato inizialmente da michelev83 il problema è nella linea

System.out.println(a[i]);

Il ciclo for infatti aumenta il valore di "i" partendo a 0 e arriva fino a 10.

Quando arriva a 10 la condizione del ciclo (i <= a.length -1) risulta "false" e il ciclo viene interrotto con i che vale 10.

La linea successiva al blocco for richiede l'accesso all'elemento di indice i ( = 10) di un array che ha 10 elementi (indice max = 9) e frappete, va tutto a schifio.

Ciao.

[michelev83]

si e qual e la solozione :confused:

grazie!

[michelev83]

questo e il testo dell esercizio

Scrivete un programma che legge in input 10 valori di tipo double, li memorizza in un array e li visualizza. Usate il ciclo for e il ".length".
Modificate il programma usando il while invece del for.

[PGI]

Il secondo post di mazza2 mi sembra corrispondere alla soluzione dell'esercizio (in versione for). Il primo ciclo legge, il secondo stampa.

Tenendo conto che il while è un for senza inizializzazione ed incremento, che l'inizializzazione deve essere fatta una sola volta, prima del primo uso e l'incremento dopo la verifica, una volta per ogni passaggio nel ciclo, dovresti risolvere con poche modifiche anche la richiesta di usare while al posto di for.

Ciao.

[michelev83]

grazie ora prvo ! nn avevo notato quel post!

coem farei senza di voi ! :vicini:

[michelev83]

Scrivete un programma che legge in input 10 valori di tipo double, li memorizza in un array e li visualizza in ordine invertito (dall'ultimo al primo).

Scrivete un programma che ha lo stesso effetto del precedente, ma i valori vanno memorizzati nell'array a partire dall'ultima posizione (e visualizzati sempre in ordine invertito dall'ultimo letto al primo).


come si fannoo :cry: :cry: :cry: :cry: :cry: :cry:

nn hocapito niente dei for anndati :cry: :cry: :cry: :cry: :cry: :cry:

[PGI]

Stando al testo non devi usare dei cicli annidati (un ciclo dichiarato all'interno del corpo di un altro ciclo), semmai usi due cicli in successione (uno per leggere e memorizzare, uno per stampare). Si tratta in buona sostanza di un esercizio sugli indici degli array.

dichiari e inizializzi un array di 10 double;
for(int i = 0; i < 10;i++) -> leggi un double e lo infili nell'array in posizione i;
//un altro for, non annidato
for(int i = 9; i >= 0; i--) -> stampa a video array[i];

Il secondo è identico, solo che il primo ciclo deve comportarsi come l'ultimo (cioè andare da 9 a 0 incluso).

Ciao.

[michelev83]

si sto capendo! grasie!:muro:

[PGI]

Non ho capito se la risposta sia sarcastica o se tu stia capendo davvero.

[michelev83]

no no sto capendo davvero! davvero graziwe! :mano:

[michelev83]

altro probelmino devo fare un rpgrammino che dice se due array char sono uguali
class es711{

public static void main(String[]ags){
int i;
int k;
int j;
System.out.println("inserisci dimesione array");
i= Leggi.unInt();
char[] a= new char[i];
char[] b= new char [i];
System.out.println("inserisci array 1");
for (k=0; k<=a.length-1; k++)
a[k]= (char) Leggi.unChar();
System.out.println("inserisci array 2");
for (j=0; j<=a.length-1; j++)
b[j]= (char) Leggi.unChar();

if ((a[k])==(b[j]))
System.out.println("uguali");
else
System.out.println("diversi");


}
}


ecco al javac mi da che e esatto quando lo eseguo inserisco gli array e dopo mi da l erroee

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 2 at es711.main(es711.java:18)


grazie di nuovo a tutti quelli che mi aiutano :)

[PGI]

Nelle espressioni di accesso agli elementi di un array Java la validità dell'indice è valutata a tempo di esecuzione. Potresti scrivere array[-1000] e javac non farebbe una piega.

Il problema è qui.

if ((a[k])==(b[j]))

Quando termina il ciclo k vale a.length, ma l'indice massimo di un array è array.length - 1. Lo stesso per j.

Non so perchè ma hai il vizietto di riciclare gli indici dei cicli :D.

In condizioni normali (quindi, salvo speciali esigenze, che qui non ci sono) un for include dichiarazione ed inizializzazione dell'indice (nel tuo codice dichiari l'indice all'esterno, lo inizializzi nel for e poi lo ricicli nell'istruzione che ho riportato sopra). Dovresti seguire la forma standard che tra l'altro migliora la leggibilità.

for(int k = 0; k < a.length; k++) {
ecc. ecc.
}


Dovendo poi verificare che gli array a e b contengano gli stessi elementi, dovresti controllarli elemento per elemento. Di vuole un altro ciclo. a e b hanno la stessa lunghezza, quindi:

for(da 0 ad a.length -1) -> se a[i] è diverso da b[i] -> gli array non contengono gli stessi elementi -> esci dal ciclo (basta un elemento diverso a rendere diversi gli array).

Per sapere, una volta terminato il ciclo, se la serie di confronti abbia dato esito positivo o negativo dovresti usare un valore di controllo che inizializzi prima di entrare nel ciclo. Ad esempio:

boolean sonoUguali = true;
for(...) se a[i] è diverso da b[i] -> sonoUguali = false -> break;

terminato il ciclo se "sonoUguali" è "true" allora il ciclo si è "estinto" naturalmente, quindi tutti gli elementi sono uguali.

se vale "false" è perchè, incontrando un elemento diverso, ha eseguito la tua istruzione condizionale che diceva "se incontri due elementi diversi imposta sonoUguali a false ed esci".

Ciao.

[michelev83]

questonn ho capito molto...:muro:

mo lo rileggo uan decian di volte...

[michelev83]

[QUOTE]Originariamente inviato da PGI

Quando termina il ciclo k vale a.length, ma l'indice massimo di un array è array.length - 1. Lo stesso per j.

Non so perchè ma hai il vizietto di riciclare gli indici dei cicli :D.

In condizioni normali (quindi, salvo speciali esigenze, che qui non ci sono) un for include dichiarazione ed inizializzazione dell'indice (nel tuo codice dichiari l'indice all'esterno, lo inizializzi nel for e poi lo ricicli nell'istruzione che ho riportato sopra). Dovresti seguire la forma standard che tra l'altro migliora la leggibilità.

for(int k = 0; k < a.length; k++) {
ecc. ecc.
}


ok fin qua ho cpaito...e cheil prof c diceva di usare cosi perhce epiu capible...vabbe le robe che n capisco io son altre ma lui le da per scontate...

[PGI]

L'ultima parte di cui parlavo nella mia risposta è questa:


if ((a[k])==(b[j]))
System.out.println("uguali");
else
System.out.println("diversi");


Secondo l'esercizio devi valutare se due array di char siano uguali. Dando per scontato che i due array di char siano uguali nel caso in cui abbiano gli stessi elementi (stessa posizione, stesso valore) il pezzo di codice qui sopra fa acqua da parecchie parti. Secondo quanto hai scritto, la stringa "uguali" verrebbe stampata nel caso in cui l'elemento di indice k dell'array a fosse uguale all'elemento di indice j dell'array b.

Ripigliamo la condizione da verificare e si vede perchè non vada bene quel pezzo di codice:

Dati due array a e b aventi pari lunghezza, per ogni elemento x di indice i dell'array a deve esistere un elemento y di indice i dell'array b tale che x == y.

Di solito questo è ciò che si intende per uguaglianza di due array in questi esercizi, tuttavia dovresti controllare a scanso di equivoci che sia così anche nel tuo esercizio.

Si tratta a questo punto di trovare un algoritmo che soddisfi quelle tre righe.

Sai già che gli array hanno pari lunghezza (li hai creati così).
Resta da verificare che "per ogni elemento x di indice i dell'array a esista un elemento y di indice i dell'array b tale che x == y".

Logica vuole che se i due array sono uguali nel caso in cui siano uguali tutti i loro elementi, essi saranno diversi nel caso in cui almeno uno degli elementi di a in posizione i sia diverso dall'elemento di b in posizione i. E qui scrivere il codice dovrebbe diventare facile.

[Xidius]

Ma Leggi.unDouble è una cosa creata da lui vero?

[michelev83]

Originariamente inviato da Xidius
Ma Leggi.unDouble è una cosa creata da lui vero?


si si...:cool: