Losowanie 9 niepowtarzalnych sekwencji liczb 0-9 [as2]

0

Potrzebuję wygenerować 9 tablic jednowymiarowych, 10-elementowych tak, aby układ liczb w każdej z nich był inny - czyli żadna liczba z tab1[i] nie może byc taka sama z tab2[i], tab3[i] itd...

Napisałem pewien algorytm (tylko dla 5 tablic), ale nie do końca on działa.
Najpierw wypełniam w pętli tablicę tab[i] = i, a następnie ją mieszam.
Dołączam kod. Gdzie robię błąd?

// tworzę losow 1. tablicę
tab = [];
for (var i:Number = 0; i<10; i++) {
	tab[i] = i;
}
 
mieszamy(tab);
 
function mieszamy(tab) {
    for (var i = 0; i < tab.length; i++) { 
        var j = Math.floor(Math.random() * tab.length);
        var temp = tab[i]; 
        tab[i] = tab[j];
        tab[j] = temp; 
    }
}
 
//////////////////////////////////////////////////////////////////////////////////////
tab2 = [];
for (var i:Number = 0; i<10; i++) {
	tab2[i] = i;
}
 
function mieszamy2() {
    for (var i = 0; i < tab2.length; i++) { 
        var j:Number = Math.floor(Math.random() * tab2.length);
 
while (tab[i] == tab2[i]) {
		var temp = tab2[i];
        tab2[i] = tab2[j];
        tab2[j] = temp; 
		 j = Math.floor(Math.random() * tab2.length);
}
    }
}
 
mieszamy2();
 
/////////////////////////////////////////////////////////////////////////////////////////////
tab3 = [];
for (var i:Number = 0; i<10; i++) {
	tab3[i] = i;
}
 
function mieszamy3() {
    for (var i = 0; i < tab3.length; i++) { 
        var j:Number = Math.floor(Math.random() * tab3.length);
 
while (tab3[i] == tab2[i] || tab3[i] == tab[i]) {
		var temp = tab3[i];
        tab3[i] = tab3[j];
        tab3[j] = temp; 
		 j = Math.floor(Math.random() * tab3.length);
}
    }
}
 
mieszamy3();
 
///////////////////////////////////////////////////////////////////////////////////////////////////
tab4 = [];
for (var i:Number = 0; i<10; i++) {
	tab4[i] = i;
}
 
function mieszamy4() {
    for (var i = 0; i < tab4.length; i++) { 
        var j:Number = Math.floor(Math.random() * tab4.length);
 
while (tab4[i] == tab3[i] || tab4[i] == tab2[i] || tab4[i] == tab[i]) {
		var temp = tab4[i];
        tab4[i] = tab4[j];
        tab4[j] = temp; 
		 j = Math.floor(Math.random() * tab4.length);
}
    }
}
 
mieszamy4();
///////////////////////////////////////////////////////////////////////////////////////////////////
tab5 = [];
for (var i:Number = 0; i<10; i++) {
	tab5[i] = i;
}
 
function mieszamy5() {
    for (var i = 0; i < tab5.length; i++) { 
        var j:Number = Math.floor(Math.random() * tab5.length);
 
while (tab5[i] == tab4[i] || tab5[i] == tab3[i] || tab5[i] == tab2[i] || tab5[i] == tab[i]) {
		var temp = tab5[i];
        tab5[i] = tab5[j];
        tab5[j] = temp; 
		 j = Math.floor(Math.random() * tab5.length);
}
    }
}
 
mieszamy5();
//////////////////////////////////////////////////////////////////////////////////////////////////
tab6 = [];
for (var i:Number = 0; i<10; i++) {
	tab6[i] = i;
}
 
function mieszamy6() {
    for (var i = 0; i < tab6.length; i++) { 
        var j:Number = Math.floor(Math.random() * tab6.length);
 
while (tab6[i] == tab5[i] || tab6[i] == tab4[i] || tab6[i] == tab3[i] || tab6[i] == tab2[i] || tab6[i] == tab[i]) {
		var temp = tab6[i];
        tab6[i] = tab6[j];
        tab6[j] = temp; 
		 j = Math.floor(Math.random() * tab6.length);
}
    }
}
 
mieszamy6();
 
// wysw
trace(tab[0]+" "+tab[1]+" "+tab[2]+" "+tab[3]+" "+tab[4]+" "+tab[5]+" "+tab[6]+" "+tab[7]+" "+tab[8]+" "+tab[9]);
trace(tab2[0]+" "+tab2[1]+" "+tab2[2]+" "+tab2[3]+" "+tab2[4]+" "+tab2[5]+" "+tab2[6]+" "+tab2[7]+" "+tab2[8]+" "+tab2[9]);			
trace(tab3[0]+" "+tab3[1]+" "+tab3[2]+" "+tab3[3]+" "+tab3[4]+" "+tab3[5]+" "+tab3[6]+" "+tab3[7]+" "+tab3[8]+" "+tab3[9]);		
trace(tab4[0]+" "+tab4[1]+" "+tab4[2]+" "+tab4[3]+" "+tab4[4]+" "+tab4[5]+" "+tab4[6]+" "+tab4[7]+" "+tab4[8]+" "+tab4[9]);	
trace(tab5[0]+" "+tab5[1]+" "+tab5[2]+" "+tab5[3]+" "+tab5[4]+" "+tab5[5]+" "+tab5[6]+" "+tab5[7]+" "+tab5[8]+" "+tab5[9]);
trace(tab6[0]+" "+tab6[1]+" "+tab6[2]+" "+tab6[3]+" "+tab6[4]+" "+tab6[5]+" "+tab6[6]+" "+tab6[7]+" "+tab6[8]+" "+tab6[9]);

Być może ktoś ma inny pomysł na wygenerowanie tych 9 tablic?
Z góry dziękuję za pomoc. :)

0

A według mnie o wiele łatwiej będzie zrobić jedną tablicę dwuwymiarową. Wystarczy, że sprawdzi się, czy 2 równe liczby nie mają wspólnego jednego z dwóch... ehhh... "wymiarów". W sensie:

x[1][2] = 1;
x[2][3] = 2; //tak
x[2][4] = 3; //tak
x[2][5] = 2; //NIE! sprzeczność z pierwszą linijką!
x[3][2] = 2; //tak
x[4][2] = 1; //NIE! sprzeczność z drugą linijką!
0

Ten problem mozesz sprowadzic do wygenerowanie n tablic ktora bedzie zawierala unikalne liczby losowe, a nastepnie zamienic wiersze z kolumnami (tudziez zrobic transpose). Jak zalezy Ci na wydajnosci to mozna tez to w miejscu zrobic.
Z kolei zeby wygenerowac jednowymiarowa tablice z unikalnymi liczbami losowymi mozna uzyc kilku sposobow w zaleznosci od potrzeb:

  1. Wygenerowac taka tablice, ze tab[i] = i a nastepnie zrobic random shuffle (np. algorytmem Fishera-Yates'a). Tutaj tak na prawde nie masz losowych liczb za to masz losowa kolejnosc.
  2. Wygenerowac losowa liczbe startowa a nastepnie uzyc iteracyjnego CRC (to gwarantuje, ze liczby bedziesz mial unikalne)
  3. Dodawac do hashseta losowe liczby dopoki nie uzyskasz odpowiedniego rozmiaru (proste, najmniej wydajne)

Implementacja pierwszego wariantu:

 	public static void genCol(int[][] a, int col)
	{
		for(int i = 0; i < a.length; ++i)
		{
			a[i][col] = i;
		}
		
		Random r = new Random();
		for(int m = a.length-1; m > 0; --m)
		{
			int idx = r.nextInt(m+1);
			int tmp = a[idx][col];
			a[idx][col] = a[m][col] ;
			a[m][col] = tmp;
		}
	}
	
    public static void main(String[] args) {
    	int arraysCount = 9;
    	int elemCount = 10;
    	
    	int[][] output = new int[arraysCount][elemCount];
    	for(int i = 0; i < elemCount; ++i)
    	{
    		genCol(output, i);
    	}
    	for(int i = 0; i < output.length; ++i)
    	{
    		System.out.println(Arrays.toString(output[i]));
    	}    	
    }
0

Nie wiem czy dokladnie zrozumialem problem, ale problem mozna sprowadzic do 9-krotnego tworzenia tablic 10-elementowych, ktorych elementy sa unikalne i losowane z pewnego uniwersum elementow, przy czym to uniwersum musi zapamietywac juz wybrane elementy przez wszystkie losowania (a wiec dla 9 tablic). Oto krotki proof of concept w Groovy, tlumaczenie na Jave jest trywialne):

final TABS_COUNT = 9
final TAB_SIZE = 10
final UNIVERSE_SIZE = TABS_COUNT * TAB_SIZE
final universe = new int[UNIVERSE_SIZE]

(0..<UNIVERSE_SIZE).each { i ->
  universe[i] = i
}

sizeLeft = UNIVERSE_SIZE

tabs = new int[TABS_COUNT][]
rand = new java.util.Random()
(0..<TABS_COUNT).each { tabnum ->
   tabs[tabnum] = new int[TAB_SIZE]
  (0..<TAB_SIZE).each { i ->
    idx = rand.nextInt(sizeLeft)
    tabs[tabnum][i] = universe[idx]
    --sizeLeft
    universe[idx] = universe[sizeLeft]
  }
}
assert sizeLeft == 0
println tabs

// check
all = [] as Set
(0..<TABS_COUNT).each { tabnum ->
  all.addAll(tabs[tabnum])
}
println all.size()
assert all.size() == UNIVERSE_SIZE

Liczby sa zawsze takie same (uniwersum 0-89), lecz nie ma mowy w zadaniu o tym jakie te liczby maja byc.

1 użytkowników online, w tym zalogowanych: 0, gości: 1