Discussion :

[abysr]

Bonjour, est il possible de faire un "shuffle" sur une partie d'un tableau?

[joel.drigo]

Salut,

Je ne connais aucune méthode shuffle() qui prend un tableau en argument, mais la méthode Collections.shuffle(List) permet de faire un shuffle sur une liste, donc on peut utiliser cette méthode pour faire un shuffle sur une sublist :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public static void main(String[] args) {
 
	Integer[] array = new Integer[20];
	for(int i=0; i<array.length; i++) {
		array[i]=i;
	}
 
	array = shuffle(array, 5, 15);
 
	System.out.println(Arrays.toString(array));
 
}
 
public static <T> T[] shuffle(T[] array, int start, int end) {
 
	List<T> list = new ArrayList<>(Arrays.asList(array));
 
	Collections.shuffle(list.subList(start, end));
 
        return list.toArray(array);
 
}

Résultat :

[0, 1, 2, 3, 4, 11, 14, 10, 7, 8, 13, 5, 12, 9, 6, 15, 16, 17, 18, 19]

[thelvin]

Tout à fait, mais, euh.... Pourquoi encapsuler dans une ArrayList ? Arrays.asList() me semblait suffire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public static void shuffle(Object[] array, int start, int end) {
 
  // voir le tableau comme une List
  List<Object> list = Arrays.asList(array);
 
  // prendre une vue d'une partie de la liste
  list = list.subList(start, end);
 
  // mélanger
  Collections.shuffle(list);
}
 
public static void main(String[] args) {
 
  Integer[] array = new Integer[20];
  for(int i=0; i<array.length; i++) {
    array[i]=i;
  }
 
  shuffle(array, 5, 15);
 
  System.out.println(Arrays.toString(array));
}

Aussi, petite remarque annexe : j'ai pas trouvé de moyen de faire la même chose avec un tableau de primitifs, genre int[].
Seules solutions que je vois :
- extraire la partie du tableau qu'on veut mélanger, la mélanger, et réinsérer le résultat
OU
- implémenter soi-même l'algorithme pour mélanger.

[joel.drigo]

Tout à fait, mais, euh.... Pourquoi encapsuler dans une ArrayList ? Arrays.asList() me semblait suffire :

Oui, la force de l'habitude de faire ça, avec Arrays.asList(), parce que le changement de taille est impossible. Mais c'est vrai que là, on ne change pas la taille... C'est bien le problème des habitudes, elle deviennent des réflexes et on réfléchit plus

Aussi, petite remarque annexe : j'ai pas trouvé de moyen de faire la même chose avec un tableau de primitifs, genre int[].
Seules solutions que je vois :
- extraire la partie du tableau qu'on veut mélanger, la mélanger, et réinsérer le résultat
OU
- implémenter soi-même l'algorithme pour mélanger.

Oui, je n'ai pas fait de remarque sur ce cas, attendant la question le cas échéant

Par réflexion, peut-être, ce qui permet d'éviter de dupliquer la partie l'extraction pour tous les types.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public static void shuffle(int[] array, int start, int end) {
	internalShuffle(array, start, end);
}
 
public static void shuffle(double[] array, int start, int end) {
	internalShuffle(array, start, end);
}
 
private static void internalShuffle(Object array, int start, int end) {
 
	if (array.getClass().isArray()) {
		if ( start<0 || end<start ) throw new ArrayIndexOutOfBoundsException();
		int length = Array.getLength(array);
		if ( end>length || start>end ) throw new ArrayIndexOutOfBoundsException();
		Object[] oarray = new Object[end-start];
		for (int i = 0; i < oarray.length; i++) {
			oarray[i] = Array.get(array, i+start);
		}
		Collections.shuffle(Arrays.asList(oarray));
		for (int i = 0; i < oarray.length; i++) {
			Array.set(array, i+start, oarray[i]);
		}
	} else {
		throw new IllegalArgumentException("Not an array");
	}
}

[abysr]

@ Joel en effet désolé d'avoir tronqué le nom de la méthode.
Merci a vous deux vous avez plus que répondu a ma question.