inserimento ordinato in array
Marco Zanon
Capisco di essere un po' babbeo, ma il seguente codice mi sembra perfetto,
eppure (visto che il programma non gira correttamente e le altre procedure
sono ok) è sbagliato, voi cosa ne dite? In pratica, ho un array a[n] con
a[0]=a[1]=...=a[n-1]=0. A mano a mano che inserisco un numero, questo deve
inserirsi "già in ordine".
*** BEGIN CODICE ***
private static void aux_insertinarray(int x)
{
int shiftindex=0,
tempindex=shiftindex;
boolean foundpoint=false;
// inserimento del numero nell'array
while ((shiftindex<a.length)&&(!foundpoint))
if ((a[shiftindex]<x)&&(a[shiftindex]>0)) shiftindex++;
else foundpoint=true;
tempindex=shiftindex;
while (shiftindex<a.length-2)
{
a[shiftindex+1]=a[shiftindex];
shiftindex++;
};
a[tempindex]=x;
};
*** END CODICE ***
Grazie infinite e saluti :-)
Marco Zanon (m.z...@usa.net)
http://www.geocities.com/SiliconValley/Peaks/6455
(BUY CDS AT THE LOWEST PRICES through my site!!!
Zamorano fan page, free MIDI mailing list, Music db...)
Dario Piantanida
wrote:
> while ((shiftindex<a.length)&&(!foundpoint))
Perchè fate tutti &&?? Ne basta una!
--
Bye,
Dario
ICQ: http://wwp.mirabilis.com/11871099
Remove anti-spam from e-mail address
Marco Zanon
Dario Piantanida <ar...@logic.DELETE_THIS.it> wrote in message
36c5148f...@news.interbusiness.it...
>On Fri, 5 Feb 1999 18:48:36 +0100, "Marco Zanon" <m.z...@usa.net>
>wrote:
>
>> while ((shiftindex<a.length)&&(!foundpoint))
>
>Perchč fate tutti &&?? Ne basta una!
per abitudine col c++, dove & lavora bit per bit, && variabile con variabile
(forse vale anche qui)...
>--
>Bye,
> Dario
Ciao :-)
Marina Berati
> while (shiftindex<a.length-2)
> {
> a[shiftindex+1]=a[shiftindex];
> shiftindex++;
> };
> a[tempindex]=x;
Qui sta l'errore: se vuoi shiftare a dx tutti gli
elementi di un array devi partire dal fondo, senno'
ogni volta vai a scrivere su tutto l'array da shiftindex in poi
sempre lo stesso elemnto, cioe' a[shiftindex].
Quindi il while va fatto la a.length all'indietro,
decrementando l'indice ad ogni giro.
Ma immagino che nel frattempo ci sarai arrivato anche
da solo :-)
Ciao,
Marina
Marco Zanon
Saluti e grazie :-)
Marco Zanon (m.z...@usa.net)
http://www.geocities.com/SiliconValley/Peaks/6455
(BUY CDS AT THE LOWEST PRICES through my site!!!
Zamorano fan page, free MIDI mailing list, Music db...)
Marina Berati <mar...@dalia.cselt.it> wrote in message
36BEA509...@dalia.cselt.it...
Francesca
<mar...@dalia.cselt.it> wrote:
>Qui sta l'errore: se vuoi shiftare a dx tutti gli
>elementi di un array devi partire dal fondo, senno'
>ogni volta vai a scrivere su tutto l'array da shiftindex in poi
>sempre lo stesso elemnto, cioe' a[shiftindex].
>Quindi il while va fatto la a.length all'indietro,
>decrementando l'indice ad ogni giro.
>
>Ma immagino che nel frattempo ci sarai arrivato anche
>da solo :-)
>
>Ciao,
> Marina
Facendo come dici tu viene copiato sempre il valore dell'ultimo
elemento.
Prova cosi':
String a[] = {"zero", "uno", "due", "tre", "quattro"};
String temp[] = {"", ""};
for (int i=0; i<a.length; i++) {
if ( (i % 2)== 0 ) {
temp[1]=a[i];
a[i]=temp[0];
} else {
temp[0]=a[i];
a[i]=temp[1];
}
}
a[0]=temp[1];
Ciao
Francesca
trz
>
> Ciao,
>
> Dario Piantanida <ar...@logic.DELETE_THIS.it> wrote in message
> 36c5148f...@news.interbusiness.it...
> >On Fri, 5 Feb 1999 18:48:36 +0100, "Marco Zanon" <m.z...@usa.net>
> >wrote:
> >
> >> while ((shiftindex<a.length)&&(!foundpoint))
> >
>
> per abitudine col c++, dove & lavora bit per bit, && variabile con variabile
> (forse vale anche qui)...
Si', vale anche qui :)
Ciao
--
...almost any game *CAN* be imagined to be an RPG, but a "real RPG"
would facilitate role-playing, not require spending most of your effort
on sustaining your SOD.
M. Hughes
Marina Berati
> >Qui sta l'errore: se vuoi shiftare a dx tutti gli
> >elementi di un array devi partire dal fondo, senno'
> >ogni volta vai a scrivere su tutto l'array da shiftindex in poi
> >sempre lo stesso elemnto, cioe' a[shiftindex].
> >Quindi il while va fatto la a.length all'indietro,
> >decrementando l'indice ad ogni giro.
>
> Facendo come dici tu viene copiato sempre il valore dell'ultimo
> elemento.
non e' vero affatto.
Per inserire un elemento in un array ordinato, devi fargli spazio
spostando a dx di un posto tutti gli elementi piu'
grandi di quello nuovo, partendo dal fondo, ovviamente,
senno' perdi dei dati.
Fatto lo spazio inserisci l'elemento nello spazio vuoto.
Questo, ovviamente, se nell'array lo spazio c'e', in caso
contrario devi creare un nuovo array e copiare in esso tutti gli
elementi in modo ordinato, compreso quello nuovo.
Non so il codice che hai scritto tu a cosa serva, ma certo non
ad inserire un elemento in un array ordinato, visto che
l'emento da inserire non c'e'.
Ciao,
Marina
Dario Piantanida
>> >Perchè fate tutti &&?? Ne basta una!
>> per abitudine col c++, dove & lavora bit per bit, && variabile con variabile
>> (forse vale anche qui)...
>Si', vale anche qui :)
Sono andato a leggermi le specifiche di Java e ho scoperto che in
realtà c'è una differenza, ma non quella che dite.
A & B valuta sia A che B
A && B valuta B solo se A è vera.
Secondo me era meglio fare il contrario...
Leonardo Boselli
Newsgroup: it.comp.java
Data: venerdì 12 febbraio 1999 14.34
Oggetto: Re: R: inserimento ordinato in array
>
>A & B valuta sia A che B
>A && B valuta B solo se A è vera.
>Secondo me era meglio fare il contrario...
Perche'?
Con questa scelta il comportamento e' simile a quello del C
e si evitano confusioni.
"&&" in C e' l'AND tra valori logici e quindi e' inutile
valutare il secondo operatore se il primo e' 0 (falso).
"&" in C e' l'AND tra bit e quindi e' necessaria la
valutazione di entrambi gli operandi.
Anche se l'AND tra bit non ha piu' senso in Java e' bene che i due
operatori abbiano mantenuto il loro comportamento originale,
permettendo ottimizzazioni nel primo caso e forzando i calcoli nel
secondo.
--
o Leonardo Boselli <bos...@technologist.com>
o o TETRACTYS Software <tetr...@uno.it>
o o o Java Tutorials: http://surf.to/tetractys
o o o o Java Jousters : www.uno.it/utenti/tetractys
Marco Zanon
>Sono andato a leggermi le specifiche di Java e ho scoperto che in
>realtà c'è una differenza, ma non quella che dite.
>
>A & B valuta sia A che B
>
>A && B valuta B solo se A è vera.
>
>Secondo me era meglio fare il contrario...
vabbè, ma è la stessa cosa (se per "valuta" intendi, come credo, bit per
bit, appunto...), comunque grazie
>--
>Bye,
> Dario
Ciao,
Dario Piantanida
<tetr...@uno.it> wrote:
>>A & B valuta sia A che B
>>A && B valuta B solo se A è vera.
>>Secondo me era meglio fare il contrario...
>Perche'?
Perchè, secondo me, quello che si usa di più è il secondo e tocca
scrivere il doppio! ;-)
Adesso mi toccherà convertirli tutti.
Bruno Bossola
& e' un operatore binario che esegue l'operazione di AND fra due
_valori_
&& e' un operatore che esegue l'AND logico fra due espressioni
>>>Perchè fate tutti &&?? Ne basta una!
Non ne basta affatto una, a meno che le due espressioni non siano
trasformate (come nell'esempio) in due valori valori booleani e quindi
diano come risultato un valore booleano, che l'istruzione if() accetta
come risultato della valutazione di un espressione. if() infatti, a
differenza del C, e' in grado di valutare solo espressioni booleane.
>A & B valuta sia A che B
L'operatore & esegue un _operazione_ fra i due _valori_ A e B, e
quindi e' costretto a valutare entrambe le espressioni
>A && B valuta B solo se A è vera.
L'operatore && serve a verificare se entrambe le _espressioni_ sono
vere, ed esegue la valutazione da sinistra verso destra. Ne consegue
che se la prima e' falsa, non deve andare a verificare la seconda.
Questa proprieta' e' chiamata corto-circuito, ed e' ereditata dal C.
Ovviamente, la stessa cosa succede (in modo diverso) anche con
l'operatore OR
Ciao,
On Fri, 12 Feb 1999 13:34:31 GMT, ar...@logic.DELETE_THIS.it (Dario
Piantanida) wrote:
> You wrote:
>
>>> >Perchè fate tutti &&?? Ne basta una!
>>> per abitudine col c++, dove & lavora bit per bit, && variabile con variabile
>>> (forse vale anche qui)...
>>Si', vale anche qui :)
>
>Sono andato a leggermi le specifiche di Java e ho scoperto che in
>realtà c'è una differenza, ma non quella che dite.
>
>A & B valuta sia A che B
>A && B valuta B solo se A è vera.
>
>Secondo me era meglio fare il contrario...
>--
>Bye,
> Dario
>
>ICQ: http://wwp.mirabilis.com/11871099
>Remove anti-spam from e-mail address
| --
| Bruno Bossola
| Groupware/Intranet B.U. Phone: +39-11-2252211
| ATOS SpA v.Vaninetti 27 Fax: +39-11-2203182
| I-10148 Torino ITALY Change NOSPAM in atos to email me!
Leonardo Boselli
>>>Secondo me era meglio fare il contrario...
Inconvenienti del mestiere ;-)
>Anche se l'AND tra bit non ha piu' senso in Java e' bene che i due
>operatori abbiano mantenuto il loro comportamento originale,
Sommerso da una marea di critiche, sono obbligato a rettificare.
Ebbene si'! Anch'io sto combattendo con
i campi di bit dei vari getModifiers() ;-)
-- o
o o Leonardo Boselli <bos...@technologist.com>
o o o TETRACTYS Software <tetr...@uno.it>
o o o o Java Tutorials: http://surf.to/tetractys
Dario Piantanida
wrote:
>Non ne basta affatto una, a meno che le due espressioni non siano
>trasformate (come nell'esempio) in due valori valori booleani e quindi
>diano come risultato un valore booleano
Dal basso della mia ignoranza: mi fai un esempio contrario? Credo di
non aver capito cosa intendi...
Bruno Bossola
Spero che tu scherzi! Semmai sono io che tendo ad essere un po'
logorroico con l'eta', e mi sa che anche questa risposta viene
lunga...
Il succo e' che con & fai una operazione aritmetica, con && fai una
valutazione logica. La stessa sintassi di Java "aiuta" virtualmente a
non commettere errori, perche', a differenza del C, le uniche
espressioni valutabili in una funzione di controllo ciclo sono
booleane.
Ad esempio in C potevi fare:
int x = 5;
...
if (x)
{
}
Mentre in Java sei costretto a convertire l'espressione "x" in una
espressione booleana:
int x = 5;
...
if (x != 0)
{
}
In C scrivere quindi:
int x = 5;
int y = 7;
if (x & y)
{
}
rappresentava di norma un _grave_ errore di programmazione, perche'
non equivaleva a dire "se x e' diverso da 0 _e_ y e' diverso da 0" ma
significava "esegui l'and binario fra x ed y, e verifica se il
risultato e' diverso da 0". Il codice che faceva invece l'operazione
tipicamente giusta era questo:
if (x && y)
{
}
In Java il problema in espressioni semplici non si pone, in quanto e'
impossibile fare valutare una espressione del genere:
int x = 5;
int y = 7;
if (x & y)
{
}
...ma e' possibile confondendo le due notazioni, in espressioni
complesse, fare questo:
int x = 5;
int y = 7;
boolean found = true;
if ((x & y) || found)
In tale caso dovrebbe comunque salvarti il compilatore, che ti
dovrebbe dare un errore del tipo "mi aspettavo un boolean ma mi hai
dato un intero": infatti x&y e' una _operazione_ che produce un
risultato intero, e non una valutazione.
Funzionerebbe invece in questo caso:
boolean x = true;
boolean y = true;
boolean found = true;
if ((x & y) || found)
in quanto l'operazione di & aritmetico e' effettuata fra due valori
boolean e quindi da' come risultato un boolean, accettabile per una
successiva valutazione dell'espressione.
Comunque in espressioni complesse che non coinvolgano solo boolean (o
espressioni ridotte a boolean) ma anche valori interi, ricordati che &
e && non sono intercambiabili! Una fa l'AND aritmetico sui bit, una
valuta con AND logico una espressione. L'unica occasione in cui i due
comportamenti corrispondono e' quando entrambi gli operandi sono dei
boolean.
Ehm, mi sa che la risposta e' venuta lunga.... ma spero che ti abbia
chiarito la problematica.
Ciao,
| --
Dario Piantanida
wrote:
>>Dal basso della mia ignoranza...
>Spero che tu scherzi!
No... Non č una vasta esperienza di programmazione e molte cose non le
so.
>In C scrivere quindi:
>
> int x = 5;
> int y = 7;
>
> if (x & y)
> {
> }
>
>rappresentava di norma un _grave_ errore di programmazione, perche'
>non equivaleva a dire "se x e' diverso da 0 _e_ y e' diverso da 0" ma
>significava "esegui l'and binario fra x ed y, e verifica se il
>risultato e' diverso da 0".
Ah, ok. Adesso ho capito cosa intendi. Ma quello che non capivo (e
continuo a non capire) č la differenza tra & e && in Java: se occorre
sempre valutare booleani, dove sta il problema nell'usare uno o
l'altro quando?
>...ma e' possibile confondendo le due notazioni, in espressioni
>complesse, fare questo:
>
> int x = 5;
> int y = 7;
> boolean found = true;
>
> if ((x & y) || found)
>
>In tale caso dovrebbe comunque salvarti il compilatore, che ti
>dovrebbe dare un errore del tipo "mi aspettavo un boolean ma mi hai
>dato un intero": infatti x&y e' una _operazione_ che produce un
>risultato intero, e non una valutazione.
Appunto. Quello che non capisco č la differenza in Java.
>Ehm, mi sa che la risposta e' venuta lunga.... ma spero che ti abbia
>chiarito la problematica.
Si e no... :)