Newsgroup: it.comp.java
Titolo: PRINCIPIANTE Array

Dovrei generare due liste di nomi in questo modo:
XABCX YEFHY
XEXRX YWRGY
.......... ...........
........... ..........
Dove XABCX YEFHY e XEXRX YWRGY sono due stringhe di 5 caratteri l'una sempre
diverse per mille volte(!!). Ho pensato di usare un array di char e dei
cicli for annidati.
Sono 2 giorni che ci provo ma non sono arrivato a nulla.
Chi mi aiuta per favore.
Garzie



scusa non capisco,
vuoi generare mille * 2 stringhe di 5 caratteri scelti a caso?
e poi stamparle due per riga?
ciao
Andrea
http://digilander.iol.it/schiele

 ha scritto nel
messaggio news:3a2a3f26...@news.tiscalinet.it...


Ciao
/*
 * DemoParole.java - version 1.0
 */
import java.util.*;
public class DemoParole
{
	private static char lettere[] =
	{
	       'a','b','c','d','e','f',
	       'g','h','i','l','m','n',
	       'o','p','q','r','s','t',
	       'u','v','w','z','x','y'
	};
        	public static void main(String[] args)
        	{
	      char a[] = new char[5];
	      char b[] = new char[5];
	      Random r = new Random();
	      for (int p = 0; p < 1000; p++)
	      {
       		for (int i = 0; i < 5; i++)
		{
	a[i] = lettere[(int)(r.nextDouble() * (lettere.length - 1))];
	b[i] = lettere[(int)(r.nextDouble() * (lettere.length - 1))];
	       	}
       System.out.println(new String(a) + " " + new String(b));
	       }
        	}
}
va bene cosi'?
ciao_<
Andrea
http://digilander.iol.it/schiele

 >Sěě., hai capito!


> va bene cosi'?
ma non dovevano essere parole sempre diverse? Col tuo programma non č detto
che lo siano...

 Grazie per altri suggerimenti.
Se ti servono parole sicuramente diverse ma non casuali, un algoritmo
potrebbe essere questo:
prendi un array c[] di char da 10 caratteri;
inizializzalo ad AAAAAAAAAA;
i=0, j=0, k=0;
for (k=0, k<1000, k++)
    ad ogni iterazione, prendi l'elemento c[i] e sostituiscilo con la
lettera successiva dell'alfabeto;
    stampa i primi 5 caratteri dell'array, poi uno spazio, poi gli altri 5.
    j++;
    se j==25 { i++; j=0 }
;
L'implentazione in codice la lascio a te ;)

il codice che ho spedito puo' essere migliorato :
	a[i] = lettere[r.nextInt(lettere.length)];
	b[i] = lettere[r.nextInt(lettere.length)];
ciao_<
Andrea
http://digilander.iol.it/schiele


il Caso, quello vero, non esiste in informatica ;)
(la classe random implementa il "solito" algoritmo
di generazione di numeri pseudo-casuali che
esiste da una vita in tutti i linguaggi di prog.)
ciao_<
Andrea
http://digilander.iol.it/schiele

 esiste da una vita in tutti i linguaggi di prog.)
so che è una funzione equidistribuita, ma intendevo solo che
"concettulamente" non era corretta la soluzione ;)


chiedo scusa ma ho frainteso la tua osservazione
(stavo leggendo di fretta la posta per poi andare a cena...)
hai perfettamente ragione il mio programma puo' generare parole uguali
mi e' sfuggito che le parole dovevano essere tutte diverse, sorry 
ciao_O
Andrea
http://digilander.iol.it/schiele

 hai perfettamente ragione il mio programma puo' generare parole uguali
Si ma dai esiste una soluzione molto semplice, visto che si tratta di sole mille
parole... le infili in una Hashtable, e se sono già presenti ne generi un'altra!
:)
Ciao,
 Stefano
----------
"X WindowSSS, teSSSoro mio... lo odieremo per SSSempre"
Bill Gollum
----------

:)
esatto,
nel frattempo ho pensato ad un'altra soluzione seguendo le indicazioni
di Dark, questo e' il codice (dovrebbe generare parole sempre diverse 
e in piu' introdurre una certa casualita') :
/*
 * DemoParole.java - version 1.1
 */
import java.util.*;
public class DemoParole
{
	private static int a = 0;
	public static void main(String[] args)
	{
	       	char[][] b = inizializza(5);
	       	for (int p = 0; p < 1000; p++)
	       	{
      	System.out.println(genera(b) + " " + genera(b));
	       	}
	}
	private static char[][] inizializza(int n)
	{
	       	char[] l =
	       	{
		      	'a','b','c','d','e','f',
		      	'g','h','i','l','m','n',
		      	'o','p','q','r','s','t',
		      	'u','v','w','z','x','y'
	       	};
	       	char[][] b = new char[n][l.length];
	       	for (int i = 0; i < n; i++)
	       	{
		      	permuta(l);
		      	for (int j = 0; j < l.length; j++)
		      	{
			     	b[i][j] = l[j];
		      	}
	       	}
	       	return (b);
	}
	private static void permuta(char[] l)
	{
	       	Random r = new Random();
	       	int n = l.length - 1;
	       	for (int i = 0; i < n; i++)
	       	{
     	  	       	int m = r.nextInt(n - i + 1);
		      	for (int j = 0; j < m; j++)
		      	{
	       	       	       	ruota(l,i);
		      	}
	       	}
	}
	private static void stampa(char[] l)
	{
	       	int n = l.length - 1;
	       	for (int j = 0; j < n; j++)
	       	{
			System.out.print(l[j]);
	       	}
	       	System.out.println(l[n]);
	}
	private static void ruota(char[] l,int f)
	{
	       	char c = l[f];
	       	int n = l.length - 1;
	       	for (int i = f; i < n; i++)
	       	{
		       	l[i] = l[i + 1];
	       	}
	       	l[n] = c;
	}
	private static String genera(char[][] b)
	{
	       	StringBuffer s = new StringBuffer(5);
	       	char[] c = new char[b.length];
	       	int d = 1;
	       	for (int i = 0; i < b.length; i++)
	       	{
		       	s.append(b[i][(a / d) % b[i].length]);
		       	d *= b[i].length;
	       	}
	       	a += 1;
	       	return (s.toString());
	}
}
ciao_O
Andrea
http://digilander.iol.it/schiele

 Garzie
Una parola di 5 lettere equivale ad un numero in base 26 di 5 cifre. Tradotto
in base 10 equivale a un numero casuale tra zero e 11881375. Come si puo'
vedere sta tutto in 24 bit, quindi un intero a 32 bit dovrebbe bastare. Puoi
generare 1000 numeri casuali diversi (scegli tu l'algoritmo, credo ne esistano
a migliaia), e poi convertirli in base 26...
Con i cicli for annidati i controlli sono dell'ordine di O(n^2), che per 1000
posizioni risulta ancora accettabile. Se pero' usi una struttura ordinata tutto
questo diventa O(n*log n), e guadagni parecchio. L'alternativa e' la seguente
(algoritmo del gioco del lotto, esempio con 90 numeri):
- genero un numero casuale tra 1 e 90 e lo chiamo i[1]. pongo n1=i[1]
- genero un numero casuale tra 1 e 89, lo chiamo i[2]. Se i[2]>=i[1], allora
n[2]=i2+1, altrimenti n2=i2.
- riordino i1 e i2. estraggo i[3] tra 1 e 88, e confronto con i[1] e i[2]...
Forse non vale la pena di riordinare un array di 1000 elementi se la
probabilita' massima di scegliere 2 volte lo stesso numero e' di 1/11mila.