Mélange aléatoire d'un tableau

232

J'ai besoin de mélanger au hasard le tableau suivant:

int[] solutionArray = {1, 2, 3, 4, 5, 6, 6, 5, 4, 3, 2, 1};

Y a-t-il une fonction pour le faire?

Hubert
la source
5
Il s'agit de la méthode SDK que vous recherchez Collections.shuffle (Arrays.asList (array));
Louis Hong
2
@Louie Non, ça ne marche pas. Cela créerait une List<int[]>entrée contenant une. Voir ma réponse pour savoir comment y parvenir en utilisant Collections.shuffle().
Duncan Jones
2
Pas vraiment une réponse à la question d'origine, mais MathArrays.shuffle de la bibliothèque commons-math3 fait le travail.
sandris
1
Ce n'est pas assez sur le sujet pour justifier une réponse, mais je me souviens d'un article vraiment cool du livre "Graphics Gems" qui parlait de traverser un tableau dans un ordre pseudo aléatoire. Dans mon esprit, cela vaut mieux que de mélanger les données en premier lieu. L'implémentation C se trouve ici github.com/erich666/GraphicsGems/blob/master/gems/Dissolve.c
Lennart Rolland
Voir également cette question étroitement liée: stackoverflow.com/questions/2450954/…
Pierz

Réponses:

263

Utiliser des collections pour mélanger un tableau de types primitifs est un peu exagéré ...

Il est assez simple d'implémenter la fonction vous-même, en utilisant par exemple le shuffle de Fisher – Yates :

import java.util.*;
import java.util.concurrent.ThreadLocalRandom;

class Test
{
  public static void main(String args[])
  {
    int[] solutionArray = { 1, 2, 3, 4, 5, 6, 16, 15, 14, 13, 12, 11 };

    shuffleArray(solutionArray);
    for (int i = 0; i < solutionArray.length; i++)
    {
      System.out.print(solutionArray[i] + " ");
    }
    System.out.println();
  }

  // Implementing Fisher–Yates shuffle
  static void shuffleArray(int[] ar)
  {
    // If running on Java 6 or older, use `new Random()` on RHS here
    Random rnd = ThreadLocalRandom.current();
    for (int i = ar.length - 1; i > 0; i--)
    {
      int index = rnd.nextInt(i + 1);
      // Simple swap
      int a = ar[index];
      ar[index] = ar[i];
      ar[i] = a;
    }
  }
}
PhiLho
la source
26
Nitpick extrêmement trivial, mais vous pouvez simplement utiliser à la println()place de println(""). Plus clair dans l'intention je pense :)
Cowan
55
Il serait préférable d'utiliser Collections.shuffle (Arrays.asList (array)); puis faire un mélange vous-même.
Louis Hong
21
@Louie Collections.shuffle(Arrays.asList(array))ne fonctionne pas, car ne Arrays.asList(array)revient Collection<int[]>pas Collection<Integer>comme vous le pensiez.
Adam Stelmaszczyk
15
@exhuma Parce que si vous avez un tableau de milliers ou de millions de valeurs primitives à trier, envelopper chacune dans un objet juste pour faire un tri est un peu coûteux, à la fois en mémoire et en CPU.
PhiLho
14
Ce n'est pas le remaniement Fisher-Yates. C'est ce qu'on appelle le shuffle de Durstenfeld . Le shuffle de pêcheur d'origine fonctionne en temps O (n ^ 2), ce qui est extrêmement lent.
Pacerier
164

Voici une manière simple d'utiliser un ArrayList:

List<Integer> solution = new ArrayList<>();
for (int i = 1; i <= 6; i++) {
    solution.add(i);
}
Collections.shuffle(solution);
méthode
la source
1
Vous pouvez simplementCollectons.shuffle(Arrays.asList(solutionArray));
FindOutIslamNow
@Timmos Vous vous trompez. Arrays.asList enveloppe le tableau d'origine et donc le modifier modifie le tableau d'origine. C'est pourquoi vous ne pouvez pas ajouter ou supprimer, car les tableaux sont de taille fixe.
Nand
@Nand pas sûr de ce que je pensais, mais en regardant le code source, en effet la méthode Arrays.asList crée un ArrayList soutenu par le tableau donné. Merci de l'avoir signalé. Supprimé mon commentaire précédent (impossible de le modifier).
Timmos
100

Voici une fonction de mélange aléatoire et efficace de Fisher – Yates:

private static void shuffleArray(int[] array)
{
    int index;
    Random random = new Random();
    for (int i = array.length - 1; i > 0; i--)
    {
        index = random.nextInt(i + 1);
        if (index != i)
        {
            array[index] ^= array[i];
            array[i] ^= array[index];
            array[index] ^= array[i];
        }
    }
}

ou

private static void shuffleArray(int[] array)
{
    int index, temp;
    Random random = new Random();
    for (int i = array.length - 1; i > 0; i--)
    {
        index = random.nextInt(i + 1);
        temp = array[index];
        array[index] = array[i];
        array[i] = temp;
    }
}
Dan Bray
la source
1
A voté parce que j'avais besoin d'une solution qui n'avait pas le surcoût élevé de création d'une Collection d'Integer
mwk
2
La deuxième implémentation n'a-t-elle pas le potentiel d'échanger avec son propre index? random.nextInt(int bound)est exclusif mais le donner i + 1comme argument permettrait indexet ipourrait être le même.
bmcentee148
21
@ bmcentee148 L'échange d'un élément avec lui-même est autorisé dans un ordre aléatoire. Ne pas comprendre cela a affaibli l'Enigma et a permis à Alan Turing de le casser. en.wikipedia.org/wiki/…
Ellen Spertus
4
L' xorastuce est idéale pour échanger des registres de CPU lorsque le CPU n'a pas d'instruction de swap et qu'il n'y a pas de registres libres, mais pour échanger des éléments de tableau dans une boucle, je ne vois aucun avantage. Pour les variables locales temporaires, il n'y a aucune raison de les déclarer en dehors de la boucle.
Holger
1
Il est légèrement plus efficace de déclarer la tempvariable en dehors de la boucle. L' XORastuce devrait être plus rapide que d'utiliser une tempvariable, mais la seule façon de s'assurer qu'elle effectue un test de référence.
Dan Bray
25

La classe Collections a une méthode efficace pour mélanger, qui peut être copiée, afin de ne pas en dépendre:

/**
 * Usage:
 *    int[] array = {1, 2, 3};
 *    Util.shuffle(array);
 */
public class Util {

    private static Random random;

    /**
     * Code from method java.util.Collections.shuffle();
     */
    public static void shuffle(int[] array) {
        if (random == null) random = new Random();
        int count = array.length;
        for (int i = count; i > 1; i--) {
            swap(array, i - 1, random.nextInt(i));
        }
    }

    private static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}
KitKat
la source
pour ne pas en dépendre ? Je préférerais de beaucoup en dépendre, si cela n'était possible.
shmosel
@shmosel Alors n'hésitez pas à l'utiliser. Assurez-vous que vous importez la classe requise et que vous avez converti le tableau en une liste avec Arrays.asList. Vous devez également convertir la liste résultante en tableau
KitKat
Vous ne pouvez pas utiliser Arrays.asList()sur un tableau primitif. Et vous n'auriez pas besoin de le reconvertir car c'est juste un wrapper.
shmosel
13

Regardez la Collectionsclasse en particulier shuffle(...).

Dave
la source
8
Comment utilisez-vous cette classe Collections dans Android? Vous devez faire une importation spéciale (CRTL SHIFT O ne fonctionne pas) pour l'utiliser?
Hubert
@Hubert, il devrait faire partie du package java.util. Il fait partie de la bibliothèque standard depuis la v1.2.
MauganRa
3
Pour rendre votre réponse plus autonome, elle doit contenir un exemple de code. IE:import java.util.Collections; shuffle(solutionArray);
Stevoisiak
10

Voici une solution complète utilisant l' Collections.shuffleapproche:

public static void shuffleArray(int[] array) {
  List<Integer> list = new ArrayList<>();
  for (int i : array) {
    list.add(i);
  }

  Collections.shuffle(list);

  for (int i = 0; i < list.size(); i++) {
    array[i] = list.get(i);
  }    
}

Notez qu'il souffre en raison de l'incapacité de Java à traduire en douceur entre int[]et Integer[](et donc int[]et List<Integer>).

Duncan Jones
la source
10

Vous avez quelques options ici. Une liste est un peu différente d'un tableau lorsqu'il s'agit de mélanger.

Comme vous pouvez le voir ci-dessous, un tableau est plus rapide qu'une liste et un tableau primitif est plus rapide qu'un tableau d'objets.

Exemples de durées

List<Integer> Shuffle: 43133ns
    Integer[] Shuffle: 31884ns
        int[] Shuffle: 25377ns

Ci-dessous, trois implémentations différentes d'un shuffle. Vous ne devez utiliser Collections.shuffle que si vous avez affaire à une collection. Il n'est pas nécessaire d'envelopper votre tableau dans une collection juste pour le trier. Les méthodes ci-dessous sont très simples à mettre en œuvre.

Classe ShuffleUtil

import java.lang.reflect.Array;
import java.util.*;

public class ShuffleUtil<T> {
    private static final int[] EMPTY_INT_ARRAY = new int[0];
    private static final int SHUFFLE_THRESHOLD = 5;

    private static Random rand;

Méthode principale

    public static void main(String[] args) {
        List<Integer> list = null;
        Integer[] arr = null;
        int[] iarr = null;

        long start = 0;
        int cycles = 1000;
        int n = 1000;

        // Shuffle List<Integer>
        start = System.nanoTime();
        list = range(n);
        for (int i = 0; i < cycles; i++) {
            ShuffleUtil.shuffle(list);
        }
        System.out.printf("%22s: %dns%n", "List<Integer> Shuffle", (System.nanoTime() - start) / cycles);

        // Shuffle Integer[]
        start = System.nanoTime();
        arr = toArray(list);
        for (int i = 0; i < cycles; i++) {
            ShuffleUtil.shuffle(arr);
        }
        System.out.printf("%22s: %dns%n", "Integer[] Shuffle", (System.nanoTime() - start) / cycles);

        // Shuffle int[]
        start = System.nanoTime();
        iarr = toPrimitive(arr);
        for (int i = 0; i < cycles; i++) {
            ShuffleUtil.shuffle(iarr);
        }
        System.out.printf("%22s: %dns%n", "int[] Shuffle", (System.nanoTime() - start) / cycles);
    }

Mélanger une liste générique

    // ================================================================
    // Shuffle List<T> (java.lang.Collections)
    // ================================================================
    @SuppressWarnings("unchecked")
    public static <T> void shuffle(List<T> list) {
        if (rand == null) {
            rand = new Random();
        }
        int size = list.size();
        if (size < SHUFFLE_THRESHOLD || list instanceof RandomAccess) {
            for (int i = size; i > 1; i--) {
                swap(list, i - 1, rand.nextInt(i));
            }
        } else {
            Object arr[] = list.toArray();

            for (int i = size; i > 1; i--) {
                swap(arr, i - 1, rand.nextInt(i));
            }

            ListIterator<T> it = list.listIterator();
            int i = 0;

            while (it.hasNext()) {
                it.next();
                it.set((T) arr[i++]);
            }
        }
    }

    public static <T> void swap(List<T> list, int i, int j) {
        final List<T> l = list;
        l.set(i, l.set(j, l.get(i)));
    }

    public static <T> List<T> shuffled(List<T> list) {
        List<T> copy = copyList(list);
        shuffle(copy);
        return copy;
    }

Mélange d'un tableau générique

    // ================================================================
    // Shuffle T[]
    // ================================================================
    public static <T> void shuffle(T[] arr) {
        if (rand == null) {
            rand = new Random();
        }

        for (int i = arr.length - 1; i > 0; i--) {
            swap(arr, i, rand.nextInt(i + 1));
        }
    }

    public static <T> void swap(T[] arr, int i, int j) {
        T tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

    public static <T> T[] shuffled(T[] arr) {
        T[] copy = Arrays.copyOf(arr, arr.length);
        shuffle(copy);
        return copy;
    }

Mélanger un tableau primitif

    // ================================================================
    // Shuffle int[]
    // ================================================================
    public static <T> void shuffle(int[] arr) {
        if (rand == null) {
            rand = new Random();
        }

        for (int i = arr.length - 1; i > 0; i--) {
            swap(arr, i, rand.nextInt(i + 1));
        }
    }

    public static <T> void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

    public static int[] shuffled(int[] arr) {
        int[] copy = Arrays.copyOf(arr, arr.length);
        shuffle(copy);
        return copy;
    }

Méthodes utilitaires

Méthodes utilitaires simples pour copier et convertir des tableaux en listes et vice-versa.

    // ================================================================
    // Utility methods
    // ================================================================
    protected static <T> List<T> copyList(List<T> list) {
        List<T> copy = new ArrayList<T>(list.size());
        for (T item : list) {
            copy.add(item);
        }
        return copy;
    }

    protected static int[] toPrimitive(Integer[] array) {
        if (array == null) {
            return null;
        } else if (array.length == 0) {
            return EMPTY_INT_ARRAY;
        }
        final int[] result = new int[array.length];
        for (int i = 0; i < array.length; i++) {
            result[i] = array[i].intValue();
        }
        return result;
    }

    protected static Integer[] toArray(List<Integer> list) {
        return toArray(list, Integer.class);
    }

    protected static <T> T[] toArray(List<T> list, Class<T> clazz) {
        @SuppressWarnings("unchecked")
        final T[] arr = list.toArray((T[]) Array.newInstance(clazz, list.size()));
        return arr;
    }

Classe de plage

Génère une plage de valeurs, similaire à la rangefonction de Python .

    // ================================================================
    // Range class for generating a range of values.
    // ================================================================
    protected static List<Integer> range(int n) {
        return toList(new Range(n), new ArrayList<Integer>());
    }

    protected static <T> List<T> toList(Iterable<T> iterable) {
        return toList(iterable, new ArrayList<T>());
    }

    protected static <T> List<T> toList(Iterable<T> iterable, List<T> destination) {
        addAll(destination, iterable.iterator());

        return destination;
    }

    protected static <T> void addAll(Collection<T> collection, Iterator<T> iterator) {
        while (iterator.hasNext()) {
            collection.add(iterator.next());
        }
    }

    private static class Range implements Iterable<Integer> {
        private int start;
        private int stop;
        private int step;

        private Range(int n) {
            this(0, n, 1);
        }

        private Range(int start, int stop) {
            this(start, stop, 1);
        }

        private Range(int start, int stop, int step) {
            this.start = start;
            this.stop = stop;
            this.step = step;
        }

        @Override
        public Iterator<Integer> iterator() {
            final int min = start;
            final int max = stop / step;

            return new Iterator<Integer>() {
                private int current = min;

                @Override
                public boolean hasNext() {
                    return current < max;
                }

                @Override
                public Integer next() {
                    if (hasNext()) {
                        return current++ * step;
                    } else {
                        throw new NoSuchElementException("Range reached the end");
                    }
                }

                @Override
                public void remove() {
                    throw new UnsupportedOperationException("Can't remove values from a Range");
                }
            };
        }
    }
}
M. Polywhirl
la source
1
Vous ne chronométrez pas les mêmes choses et vous chronométrez chacune une seule fois (alors leur ordre compte et vous oubliez l'optimisation de l'exécution). Vous devez appeler range, toArrayet toPrimitiveavant tout chronométrage, et boucler pour pouvoir conclure quoi que ce soit (pseudo-code: faire plusieurs fois {générer la liste, arr et iarr; liste de lecture aléatoire; liste de lecture aléatoire arr; liste de lecture aléatoire iarr}). Mes résultats: 1er: list: 36017ns, arr: 28262ns, iarr: 23334ns. 100: list: 18445ns, arr: 19995ns, iarr: 18657ns. Cela montre simplement que int [] est pré-optimisé (par code) mais ils sont presque équivalents à l'optimisation d'exécution.
syme
9

L'utilisation ArrayList<Integer>peut vous aider à résoudre le problème du brassage sans appliquer beaucoup de logique et consommer moins de temps. Voici ce que je propose:

ArrayList<Integer> x = new ArrayList<Integer>();
for(int i=1; i<=add.length(); i++)
{
    x.add(i);
}
Collections.shuffle(x);
SalmaanKhan
la source
Probablement pas ce dernier - consommant moins de temps . En fait, c'est certainement plus lent que les implémentations primitives ci-dessus.
Boris the Spider du
1
Pour quelqu'un copie le code, regardez le "pour le cycle" i = 1 peut-être vous avez besoin i = 0
Boris Karloff
5

Vous pouvez utiliser java 8 maintenant:

Collections.addAll(list, arr);
Collections.shuffle(list);
cardsList.toArray(arr);
Иван Николайчук
la source
2
Il n'y a rien de spécifique à Java8 dans ce code. Cela fonctionne depuis Java2. Eh bien, cela fonctionnerait, une fois que vous corrigez l'incohérence entre la première utilisation listet la référence soudaine cardsList. Mais comme vous devez créer le temporaire list, que vous avez omis, l' Collections.shuffle(Arrays.asList(arr));approche présentée à plusieurs reprises ici ne présente aucun avantage . Qui fonctionne également depuis Java2.
Holger
3

Voici une version générique pour les tableaux:

import java.util.Random;

public class Shuffle<T> {

    private final Random rnd;

    public Shuffle() {
        rnd = new Random();
    }

    /**
     * Fisher–Yates shuffle.
     */
    public void shuffle(T[] ar) {
        for (int i = ar.length - 1; i > 0; i--) {
            int index = rnd.nextInt(i + 1);
            T a = ar[index];
            ar[index] = ar[i];
            ar[i] = a;
        }
    }
}

Étant donné que ArrayList n'est fondamentalement qu'un tableau, il peut être conseillé de travailler avec un ArrayList au lieu du tableau explicite et d'utiliser Collections.shuffle (). Cependant, les tests de performances ne montrent aucune différence significative entre ce qui précède et Collections.sort ():

Shuffe<Integer>.shuffle(...) performance: 576084 shuffles per second
Collections.shuffle(ArrayList<Integer>) performance: 629400 shuffles per second
MathArrays.shuffle(int[]) performance: 53062 shuffles per second

L'implémentation d'Apache Commons MathArrays.shuffle est limitée à int [] et la pénalité de performance est probablement due au générateur de nombres aléatoires utilisé.

user1050755
la source
1
Il semble que vous puissiez passer new JDKRandomGenerator()à MathArrays.shuffle. Je me demande comment cela affecte la performance?
Brandon
En fait ... il ressemble MathArrays#shufflea une allocation dans sa boucle de base: int targetIdx = new UniformIntegerDistribution(rng, start, i).sample();. Bizarre.
Brandon
3
Random rnd = new Random();
for (int i = ar.length - 1; i > 0; i--)
{
  int index = rnd.nextInt(i + 1);
  // Simple swap
  int a = ar[index];
  ar[index] = ar[i];
  ar[i] = a;
}

Par ailleurs, j'ai remarqué que ce code renvoie un ar.length - 1certain nombre d'éléments, donc si votre tableau a 5 éléments, le nouveau tableau mélangé aura 4 éléments. Cela se produit car la boucle for indique i>0. Si vous passez à i>=0, tous les éléments sont mélangés.

Cristiane Dos Santos Costa
la source
Juste un avertissement, vous voudrez peut-être déplacer cela dans la section des commentaires de votre question, car il sera probablement signalé s'il est laissé comme sa propre réponse.
Jason D
1
Cela semble répondre à la question, donc je ne sais pas de quoi vous parlez @JasonD
Sumurai8
1
Le code est correct, le commentaire est faux. Si vous passez i>0à i>=0, vous perdez du temps en échangeant l'élément 0avec lui-même.
jcsahnwaldt Reinstate Monica
3

Voici une solution utilisant Apache Commons Math 3.x (pour les tableaux int [] uniquement):

MathArrays.shuffle(array);

http://commons.apache.org/proper/commons-math/javadocs/api-3.6.1/org/apache/commons/math3/util/MathArrays.html#shuffle (int [])

Alternativement, Apache Commons Lang 3.6 a introduit de nouvelles méthodes de lecture aléatoire dans la ArrayUtilsclasse (pour les objets et tout type primitif).

ArrayUtils.shuffle(array);

http://commons.apache.org/proper/commons-lang/javadocs/api-release/org/apache/commons/lang3/ArrayUtils.html#shuffle-int:A-

Emmanuel Bourg
la source
3

J'ai vu des informations manquantes dans certaines réponses, j'ai donc décidé d'en ajouter une nouvelle.

Collections Java Arrays.asList prend var-arg de type T (T ...). Si vous passez un tableau primitif (int array), la méthode asList déduira et générera unList<int[]> , qui est une liste à un élément (le premier élément est le tableau primitif). si vous mélangez cette liste d'éléments, cela ne changera rien.

Donc, vous devez d'abord convertir votre tableau primitif en tableau d'objets Wrapper. pour cela, vous pouvez utiliser la ArrayUtils.toObjectméthode de apache.commons.lang. puis passez le tableau généré à une liste et mélangez-le finalement.

  int[] intArr = {1,2,3};
  List<Integer> integerList = Arrays.asList(ArrayUtils.toObject(array));
  Collections.shuffle(integerList);
  //now! elements in integerList are shuffled!
Mr.Q
la source
3

Voici une autre façon de mélanger une liste

public List<Integer> shuffleArray(List<Integer> a) {
List<Integer> b = new ArrayList<Integer>();
    while (a.size() != 0) {
        int arrayIndex = (int) (Math.random() * (a.size()));
        b.add(a.get(arrayIndex));
        a.remove(a.get(arrayIndex));
    }
    return b;
}

Choisissez un nombre aléatoire dans la liste d'origine et enregistrez-le dans une autre liste. Supprimez ensuite le numéro de la liste d'origine. La taille de la liste d'origine continuera de diminuer d'une unité jusqu'à ce que tous les éléments soient déplacés vers la nouvelle liste.

PS5
la source
2

Une solution simple pour Groovy:

solutionArray.sort{ new Random().nextInt() }

Cela triera tous les éléments de la liste de tableaux de manière aléatoire, ce qui archivera le résultat souhaité de mélanger tous les éléments.

Hans Kristian
la source
2

Utiliser Guava Ints.asList()est aussi simple que:

Collections.shuffle(Ints.asList(array));
BeeOnRope
la source
1

Je me penche sur cette question très populaire parce que personne n'a écrit une version à lecture aléatoire. Le style est largement emprunté à Arrays.java, car qui ne pille pas la technologie Java de nos jours? Générique et intimplémentations inclus.

   /**
    * Shuffles elements from {@code original} into a newly created array.
    *
    * @param original the original array
    * @return the new, shuffled array
    * @throws NullPointerException if {@code original == null}
    */
   @SuppressWarnings("unchecked")
   public static <T> T[] shuffledCopy(T[] original) {
      int originalLength = original.length; // For exception priority compatibility.
      Random random = new Random();
      T[] result = (T[]) Array.newInstance(original.getClass().getComponentType(), originalLength);

      for (int i = 0; i < originalLength; i++) {
         int j = random.nextInt(i+1);
         result[i] = result[j];
         result[j] = original[i];
      }

      return result;
   }


   /**
    * Shuffles elements from {@code original} into a newly created array.
    *
    * @param original the original array
    * @return the new, shuffled array
    * @throws NullPointerException if {@code original == null}
    */
   public static int[] shuffledCopy(int[] original) {
      int originalLength = original.length;
      Random random = new Random();
      int[] result = new int[originalLength];

      for (int i = 0; i < originalLength; i++) {
         int j = random.nextInt(i+1);
         result[i] = result[j];
         result[j] = original[i];
      }

      return result;
   }
QED
la source
1

Il s'agit de l'algorithme de lecture aléatoire de knuth.

public class Knuth { 

    // this class should not be instantiated
    private Knuth() { }

    /**
     * Rearranges an array of objects in uniformly random order
     * (under the assumption that <tt>Math.random()</tt> generates independent
     * and uniformly distributed numbers between 0 and 1).
     * @param a the array to be shuffled
     */
    public static void shuffle(Object[] a) {
        int n = a.length;
        for (int i = 0; i < n; i++) {
            // choose index uniformly in [i, n-1]
            int r = i + (int) (Math.random() * (n - i));
            Object swap = a[r];
            a[r] = a[i];
            a[i] = swap;
        }
    }

    /**
     * Reads in a sequence of strings from standard input, shuffles
     * them, and prints out the results.
     */
    public static void main(String[] args) {

        // read in the data
        String[] a = StdIn.readAllStrings();

        // shuffle the array
        Knuth.shuffle(a);

        // print results.
        for (int i = 0; i < a.length; i++)
            StdOut.println(a[i]);
    }
}
BufBills
la source
1

Il y a une autre façon aussi, pas encore de poster

//that way, send many object types diferentes
public anotherWayToReciveParameter(Object... objects)
{
    //ready with array
    final int length =objects.length;
    System.out.println(length);
    //for ready same list
    Arrays.asList(objects);
}

de cette façon plus facile, en fonction du contexte

Marcelo Ferreira
la source
1

La solution la plus simple pour ce mélange aléatoire dans un tableau.

String location[] = {"delhi","banglore","mathura","lucknow","chandigarh","mumbai"};
int index;
String temp;
Random random = new Random();
for(int i=1;i<location.length;i++)
{
    index = random.nextInt(i+1);
    temp = location[index];
    location[index] = location[i];
    location[i] = temp;
    System.out.println("Location Based On Random Values :"+location[i]);
}
Archit Goel
la source
1
  1. Boîte de int[]àInteger[]
  2. Envelopper un tableau dans une liste avec la Arrays.asListméthode
  3. Mélanger avec Collections.shuffleméthode

    int[] solutionArray = { 1, 2, 3, 4, 5, 6, 6, 5, 4, 3, 2, 1 };
    
    Integer[] boxed = Arrays.stream(solutionArray).boxed().toArray(Integer[]::new);
    Collections.shuffle(Arrays.asList(boxed));
    
    System.out.println(Arrays.toString(boxed));
    // [1, 5, 5, 4, 2, 6, 1, 3, 3, 4, 2, 6]
YujiSoftware
la source
1

Code le plus simple à mélanger:

import java.util.*;
public class ch {
    public static void main(String args[])
    {
        Scanner sc=new Scanner(System.in);
        ArrayList<Integer> l=new ArrayList<Integer>(10);
        for(int i=0;i<10;i++)
            l.add(sc.nextInt());
        Collections.shuffle(l);
        for(int j=0;j<10;j++)
            System.out.println(l.get(j));       
    }
}
suraj
la source
1

Utilisation de la classe aléatoire

  public static void randomizeArray(int[] arr) {

      Random rGenerator = new Random(); // Create an instance of the random class 
      for (int i =0; i< arr.length;i++ ) {
          //Swap the positions...

          int rPosition = rGenerator.nextInt(arr.length); // Generates an integer within the range (Any number from 0 - arr.length)
          int temp = arr[i]; // variable temp saves the value of the current array index;
          arr[i] = arr[rPosition];  // array at the current position (i) get the value of the random generated 
          arr[rPosition] = temp; // the array at the position of random generated gets the value of temp

      }

      for(int i = 0; i<arr.length; i++) {
          System.out.print(arr[i]); //Prints out the array
      } 

  }
Fiel Muhongo
la source
0
public class ShuffleArray {
public static void shuffleArray(int[] a) {
    int n = a.length;
    Random random = new Random();
    random.nextInt();
    for (int i = 0; i < n; i++) {
        int change = i + random.nextInt(n - i);
        swap(a, i, change);
    }
}

private static void swap(int[] a, int i, int change) {
    int helper = a[i];
    a[i] = a[change];
    a[change] = helper;
}

public static void main(String[] args) {
    int[] a = new int[] { 1, 2, 3, 4, 5, 6, 6, 5, 4, 3, 2, 1 };
    shuffleArray(a);
    for (int i : a) {
        System.out.println(i);
    }
}
}
nikhil gupta
la source
Veuillez ajouter une description connexe concernant votre réponse.
ankit suthar
0
import java.util.ArrayList;
import java.util.Random;
public class shuffle {
    public static void main(String[] args) {
        int a[] =  {1,2,3,4,5,6,7,8,9};
         ArrayList b = new ArrayList();
       int i=0,q=0;
       Random rand = new Random();

       while(a.length!=b.size())
       {
           int l = rand.nextInt(a.length);
//this is one option to that but has a flaw on 0
//           if(a[l] !=0)
//           {
//                b.add(a[l]);
//               a[l]=0;
//               
//           }
//           
// this works for every no. 
                if(!(b.contains(a[l])))
                {
                    b.add(a[l]);
                }



       }

//        for (int j = 0; j <b.size(); j++) {
//            System.out.println(b.get(j));
//            
//        }
System.out.println(b);
    }

}
aurobind singh
la source
0

similaire sans utiliser swap b

        Random r = new Random();
    int n = solutionArray.length;
    List<Integer> arr =  Arrays.stream(solutionArray).boxed().collect(Collectors.toList());
    for (int i = 0; i < n-1; i++) {
        solutionArray[i] = arr.remove( r.nextInt(arr.size())); // randomize base on size
    }
    solutionArray[n-1] = arr.get(0);
digitebs
la source
0

L'une des solutions consiste à utiliser la permutation pour pré-calculer toutes les permutations et stockées dans ArrayList

Java 8 a introduit une nouvelle méthode, ints (), dans la classe java.util.Random. La méthode ints () renvoie un flux illimité de valeurs int pseudo-aléatoires. Vous pouvez limiter les nombres aléatoires entre une plage spécifiée en fournissant les valeurs minimale et maximale.

Random genRandom = new Random();
int num = genRandom.nextInt(arr.length);

Avec l'aide de la génération du nombre aléatoire, vous pouvez parcourir la boucle et permuter avec l'index en cours avec le nombre aléatoire. C'est ainsi que vous pouvez générer un nombre aléatoire avec une complexité d'espace O (1).


la source
0

Sans solution aléatoire:

   static void randomArrTimest(int[] some){
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < some.length; i++) {
            long indexToSwap = startTime%(i+1);
            long tmp = some[(int) indexToSwap];
            some[(int) indexToSwap] = some[i];
            some[i] = (int) tmp;
        }
        System.out.println(Arrays.toString(some));
    }
izum286
la source