Randomly prints elements in an array

Question

Is there a way where you can use Math.random to prints the element in a given array?

int[] list = new int[] {1,2,3};

So the output will be like

2,1,3

or

3,1,2

or

2,3,1 

Answer 1

Perhaps you can approach it by shuffling your array then print it. If the original should not be modified, you can make a copy and then shuffle the copy.

There are well-known algorithms for shuffling array (or a deck of cards). One can be found here. An implementation in java looks like this:

static void shuffleArray(int []array) {
    int length = array.length;
    for (int i = length -1; i > 0; i--) {
        // generate a random 0 <= j < i
        int j = (int)(Math.random() * i);
        // swap elements at i and j
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}

Answer 2

The approach proposed in most answers is extremely inefficient, as it works in O(N²) time. Think about it: at first you'll generate unused indexes with one attempt, but closer to the end, when almost all array is processed, it will require nearly N steps to generate next unused index.

The optimal O(N) approach is to create shuffled array of indexes (0..N) where each index appears only once and then process your original array in the order of shuffled indexes. Each step requires O(N) time, so the whole algorithm is O(N).

    int[] input = new int[]{5, 4, 3, 6, 2, 1};
    int []indices = new int[input.length];

    //Fisher-Yates shuffle
    Random rnd = new Random();
    for (int i = 0; i < indices.length; i++) {
        int j = rnd.nextInt(i + 1);
        indices[i] = indices[j];
        indices[j] = i;
    }

    for (int i : indices) {
        System.out.println(input[i]);
    }

I didn't use Collections.shuffle, as it would require usage of Collection and thus wrapped Integer elements, which is very inefficient comparing to the plain int array.

Also, if you are ok with modifying your original array, you can just shuffle it in place (using the same Fisher-Yates shuffle) and then consume it while traversing.

UPD: Replaced shuffling array of indices with shuffled initialization.

Answer 3

Since you have java 8, you can take advantage of the beautiful Stream API.

In short, you can do:

new Random().ints(1, 500).limit(500).forEach(p -> System.out.println(list[p])); 

Where 1 is the lowest int generated (inclusive) and 500 is the highest (exclusive). limit means that your stream will have a length of 500, maybe in that argument you want to put list.length.

For your case:

        int[] list = new int[] {1,2,3,4,5,6};
        new Random().ints(0, list.length).limit(10).forEach(p -> System.out.println(list[p])); 

Prints: 5 2 5 4 6 3 3 5 6 4 (Obviously will not print the same numbers for you)

Answer 4

As I said in the comments. This answer will work.. All you need to do is track the indices that it accessed so you don't repeat them or remove that element from the array.

void printRandom(int[] array) {
    if (array.length == 0)
        return;
    Random rand = new Random();
    int rnd = rand.nextInt(array.length);
    int element = array[rnd];
    array = ArrayUtils.removeElement(array, element);
    System.out.print(element);
    printRandom(array);
}

Just repeat this process until all elements are removed. Obviously add checks to prevent errors and keep in mind I haven't used JAVA in a long time so post back if you have issues!

Lastly keep in mind this deletes the array so you may want to wrap this code in a function and then copy the array as a local variable so you can reuse the original as needed

Answer 5

Create a random integer that may be as high as the length of the array - 1. If the random integer is equal to a previous used random integer -- known by storing used integers in an array -- create a new random integer. Otherwise, print the string correlated with that index specified by the random integer. If the length of the array storing the used random integers is equal to the length of the array of strings, stop the process.

This should print all your strings only once each and randomly.

Answer 6

In this case we can print random value from array using like below :

Steps:

1. Create list object of Integer to hold printed indices
2. Get random number and check whether this index is already printed or not
3. if not printed then add it in list and print value from array using this index

4. if list size and array length is equal then terminate the loop

   import java.util.ArrayList;
   import java.util.List;
   import java.util.Random;
   
   public class RandomIndices {
   
   public static void main(String[] args) {
       int[] list = new int[]{1, 2, 3};
       Random random = new Random();
       List<Integer> randomIndices = new ArrayList<>(); //to hold indices which are already printed
       boolean isRemain = true;
       while (isRemain) {
           int randomIndex = random.nextInt(list.length);
           if (!randomIndices.contains(randomIndex)) { //check random index value of array is printed or not
               randomIndices.add(randomIndex);
               System.out.println(list[randomIndex]);
           }
           if (randomIndices.size() == list.length) {
               isRemain = false;
           }
       }}
   }
   

Answer 7

Here is the solution

 public static void main(String[] args) {
        int[] list = new int[] { 1, 2, 3 };
        int[] aux = new int[list.length];
        int countTimes = 0;
        while (countTimes < list.length) {
            int position = new Random().nextInt(list.length);
            if (aux[position] != list[position]) {
                System.out.println(list[position]);
                aux[position] = list[position];
                countTimes++;
            }
        }
    }

Answer 8

Implement a simple "do while" statement to prevent duplicate numbers from showing up out of your array (I used a StringArray - but an IntegerArray would work the same way - as a side note, I can place the complete code up here but didn't want to do so if it didn't apply. I use a drop-down to select how many random words to generate - then display that set of true RANDOM words (non-repeated):

    final Random rand1 = new Random();
    final Random rand2 = new Random();
    final int rndInt1 = rand1.nextInt(getResources().getStringArray(R.array.words).length);
                    int rndInt2 = rand2.nextInt(getResources().getStringArray(R.array.words).length);
                    if (rndInt1 == rndInt2){
                    do {
                        rndInt2 = rand2.nextInt(getResources().getStringArray(R.array.words).length);
                        }while (rndInt1 == rndInt2);//if indexes are equal - re-run the array search

                    }
                    outString = getResources().getStringArray(R.array.words)[rndInt1];
                    outString += ", " + getResources().getStringArray(R.array.words)[rndInt2];//concatenate the list 
                    textWord = (TextView) findViewById(R.id.textWords);//An empty text field in my layout
                    textWord.setText(outString);//Set that empty text field to this string of random array elements