Newsgroup: it.comp.java
Titolo: generatore di sequenza

Ciao a tutti...
un progettino universitario impellente mi obbliga ad implorare il vostro
aiuto....
data una stringa o un array di caratteri validi "0...9a..zA..Z"
devo generare la sequenza
0..9a..zA..Z10..19 1a...1z 1A...1Z... e cosě via
Qualcuno potrebbe aiutarmi con qualche pezzo di cosice?
Grazie.
 Mario

 0..9a..zA..Z10..19 1a...1z 1A...1Z... e così via
Sai che non ho capito cosa devi fare? :-)
ciao D.
Inviato da 
www.mynewsgate.net

 Inviato da 
www.mynewsgate.net

 è più chiaro adesso?
Sì, un po' di più :-D
Dunque, la prima soluzione che mi viene in mente ma non molto elegante, è
quella di memorizzarti in un array tutti i caratteri che rappresentano la
tua unità.
Quando incrementi di uno, cerchi all'interno dell'array la posizione del
carattere e se hai superato il limite superiore della struttura dati, allora
porti la cifra che stai considerando all'unità più bassa ed incrementi
quella successiva di uno ripetendo lo stesso ragionamento.
Ciao D.
Inviato da 
www.mynewsgate.net


Vero, a questo punto l'unico problems potrebbe essere la gestione degli
indici e dei riporti.... devo solo fare un loop...
Non c'è in giro il codice di qualche adder?
 Mario

 Non c'è in giro il codice di qualche adder?
Guarda, questo lo ho scritto io in 10 minuti.
Mancano i controlli di eccezioni e similari ma sembra funzionare
Ciao D.
public class Sequence {
	private char[] 			seq 	= new char[]{'0','1','2','a','b','c','A','B','C'};
	private StringBuffer	count	= null;
 
	public Sequence(){
		count = new StringBuffer();
		count.append(seq[0]);
	}
 
	public String getCount(){
		return count.toString();
	}
 
	public void addByOne(){
		addAtPosition(count.length()-1);
	}
 
	private void addAtPosition(int position){
		char 	c 	= '\0';
		int		i	= 0;
 
		if(position < 0){
			count.insert(0,seq[0]);
		}else{
			c = count.charAt(position);
			for(i=0; i<seq.length; i++){
				if(c == seq[i]){
					break;
				}
			}
 
			if(++i >= seq.length){
				count.setCharAt(position, seq[0]);
				addAtPosition(--position);
			}else{
				count.setCharAt(position,seq[i]);
			}
		}
	}
 
	public static void main(String[] args) {
		Sequence s = new Sequence();
		System.out.println(s.getCount());
		s.addByOne();
		System.out.println(s.getCount());
		s.addByOne();
		System.out.println(s.getCount());
		s.addByOne();
		System.out.println(s.getCount());
		s.addByOne();
		System.out.println(s.getCount());
		s.addByOne();
		System.out.println(s.getCount());
		s.addByOne();
		System.out.println(s.getCount());
	}
}
Inviato da 
www.mynewsgate.net

 wrote in message
news:200405041...@mynewsgate.net...


 Mancano i controlli di eccezioni e similari ma sembra funzionare
Funziona perfettamente!
 Grazie mille!!
  Mario

Io ti suggerirei di utilizzare le congruenze modulo n...mai fatto un 
esame di metematica discreta ?  ;)
Suvvia, un po' di inventiva, altrimenti si finisce per programmare con 
le pappette pronte...
-- 
                 ''~``
                ( o o )
+---------.oooO--(_)--Oooo.----+
 
http://www.jroller.com/page/megadix/
 
http://www.mict.it/

 le pappette pronte...
"Finchč va quel tant che basta tuchel no se no se guasta".... cosě insegna
il nonno... ;)
Mario


Beh, un altro modo che mi era venuto in mente era di usare il valore
ascii del carattere per codificare il tutto.
La difficoltà nel tuo caso sta nel fatto che non tutti i caratteri sono
nell'ordine giusto. Nella tabella ascii hai prima i numeri, poi le
lettere maiuscole e poi quelle minuscole. L'altro problema è che non
essendo consecutivi (hai altri caratteri in mezzo), devi gestirti i salti.
Così facendo però avresti un codice più flessbile ed elegante (a mio
avviso).
Ciao D.
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.0.6 (GNU/Linux)
Comment: For info see 
http://www.gnupg.org
iD8DBQFAl+8k4bZBbJz82hMRAps0AJ0dtxx2RTFkNMxm+n21eqAT+SIq5gCgx2ZF
fF0L0BTVdRj2FD0sUb185bM=
=kNpK
-----END PGP SIGNATURE-----


    Già, ma non potrei "limitare" l'utilizzo di solo alcuni caratteri....
cosa che cmq mi è particolarmente utile!
Grazie.
 Mario

Allora, vediamo un po'...
- abbiamo 10 cifre (da 0 a 9) + 26 lettere minuscole + 26 maiuscole
- la notazione č posizionale
Ergo: stiamo realizzando una conversione in base...62 !!
Un paio di suggerimenti:
- crea un array con i caratteri da usare per la rappresentazione; il 
fatto che gli indici per gli array partano da zero aiuta moooltissimo 
(tu capě a me...)
- algoritmo delle divisioni successive...ti dice niente ?
Mi raccomando trova tu la soluzione !
