3
votes

Lecture aléatoire d'un tableau (Java)

J'essaie de mélanger au hasard des entiers dans un tableau. Cela semble assez simple, mais je dois les mélanger pour qu'ils restent dans un ordre particulier (impair, pair, impair, pair, etc.). Par exemple, si le tableau d'origine contenait [1, 2, 3, 4, 5, 6, 7, 8], le tableau mélangé pourrait ressembler à [5, 8, 7, 4, 1, 6, 3, 2], mais en conservant toujours le même ordre alterné, en commençant par impair.

Merci pour l'aide. Au fait, ce n’est pas exactement mon problème de devoirs. Je veux juste savoir comment faire cela pour que je puisse faire mes devoirs. Je ne sais pas où commencer.

java shuffle

0 commentaires

4 Réponses :

5
votes

Je le ferais probablement:

Saisissez tous les éléments aux positions indexées ODD dans un tableau et mélangez cela
Récupérez tous les éléments aux positions même indexées dans un tableau séparé et mélangez-les; puis
Regroupez-les

5 commentaires

Si je devais assembler ces deux tableaux, cela ne ferait-il pas toutes les chances d'un côté et tous les égales de l'autre?

"splice" désigne ici une opération où, à partir de deux tableaux, [a, b, c] et [x, y, z] , vous en créez un nouveau, [a, x, b, y, c, z] - essentiellement "entrelacer" les éléments des deux tableaux, en alternance.

Oh, d'accord, merci d'avoir clarifié. Comment pourrais-je y parvenir? Désolé pour la confusion, je suis encore un peu nouveau dans ce domaine.

En supposant deux tableaux odds et evens contenant les tableaux individuels mélangés et épissés le nouveau tableau pour contenir le résultat, puis en pséduocode quelque chose du genre: pour i dans len (cote): spliced.push (cote [i]); spliced.push (égalise [i]); je suivant

Vous devrez faire attention à la valeur finale de i car, selon la longueur du tableau d'origine, la longueur de evens peut être 1 plus courte que la longueur de cotes .

0
votes

Une façon de mélanger votre tableau serait de "trier aléatoirement" les éléments.

Par exemple, si vous utilisez Java 8 ou supérieur, vous pouvez fournir un compartiment de tri sous forme de lambda illustré ci-dessous, qui renvoie simplement des indices positifs ou négatifs à chaque itération pendant l'opération de tri pour obtenir un résultat mélangé:

ArrayList<Integer> list = new ArrayList<>();
Random random = new Random();

/* Ordered input list */
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);

/* Apply random sorting behavior to achieve obtain a shuffled array */
Collections.sort(list, (Integer a, Integer b) -> {
    /* Obtain random number between 0 - 1 */
    Integer randomValue = random.nextInt(1);

    /* Return random positive or negative value which causes "shuffled" 
    sort */
    return randomValue == 1 ? 1 : -1;
});

/* list is now shuffled */

2 commentaires

Vous avez une ArrayList et vous y ajoutez des entiers? Les génériques Java sont mauvais, mais je n'avais aucune idée qu'ils considéraient les tableaux d'entiers et les entiers comme la même chose!

Le but de la question n'était pas de mélanger le tableau, mais de le mélanger d'une manière qui conserve l'ordre pair-impair des éléments. En dehors de cela, pourquoi devriez-vous implémenter quelque chose comme Collections # shuffle (qui est O (n)) basé sur Collections.sort (qui est O (nlogn))?

0
votes

Collections.shuffle(Arrays.asList(array));
With array as [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
I get output [9, 5, 8, 2, 0, 7, 4, 3, 6, 1]Let it be noted that it cannot work with primitive arrays, int[] will not work only Integer[]

1 commentaires

Le but de la question n'était pas de mélanger le tableau, mais de le mélanger d'une manière qui conserve l'ordre pair-impair des éléments.

1
votes

Vous pouvez laisser les éléments souhaités du tableau apparaître sous forme de List , en implémentant AbstractList en conséquence, en tant que vue sur les éléments du tableau pertinents. Ensuite, un simple Collections # shuffle sur les listes fera l'affaire.

Cela peut sembler "non conventionnel" à première vue, mais présente quelques avantages:

il fonctionne sur des tableaux int (bien que vous puissiez le changer en Integer si vous le souhaitez)
il n'a pas besoin de copier le tableau (pas de surcharge de mémoire supplémentaire)
il n'a pas besoin de "traiter" le tableau de quelque manière que ce soit (autre que de le mélanger)

Implémenté ici en tant que MCVE:

import java.util.AbstractList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Random;

public class ConstrainedShuffle
{
    public static void main(String[] args)
    {   
        int array[] = new int[] { 1, 2, 3, 4, 5, 6, 7, 8 };

        System.out.println("Before: " + Arrays.toString(array));

        constrainedShuffle(array, new Random(0));

        System.out.println("After : " + Arrays.toString(array));
    }

    private static void constrainedShuffle(int array[], Random random)
    {
        Collections.shuffle(asList(array, 0, 2), random);
        Collections.shuffle(asList(array, 1, 2), random);
    }

    private static List<Integer> asList(int array[], int offset, int stride)
    {
        int size = (array.length - offset + stride - 1) / stride;
        return new AbstractList<Integer>()
        {
            @Override
            public Integer get(int index)
            {
                return array[offset + index * stride];
            }

            @Override
            public Integer set(int index, Integer element)
            {
                int i = offset + index * stride;
                Integer old = array[i];
                array[i] = element;
                return old;
            }

            @Override
            public int size()
            {
                return size;
            }
        };
    }
}

0 commentaires