Thread: How to randomize the if loops?

I have a method something like this
if(x = 1){
statement1;
break;
}
if(y = 1){
statement2;
break;
}
if(z = 1){
statement3;
break;
}
if(t = 1){
statement4;
break;
}
else{
statementElse;
}
and I want it to shuffle the order of if loops everytime it is called .How can i do it?

If loops? Maybe, you confuse it with While loops? You can just make the order dependent on some integer and each time the method is called you generate a random integer with Random.

No i mean ,when i call this method it should check randomly first x or first y or the other , and then continue the rest again randomly.I tried to do that but couldn't succeed and i think i should use the switch statement for this but i don't know how to implement

You can wrap each check into Runnable. Then you can define your method as, say, "public void randomized(Runnable[] array)". That is, all the operations are in an array. When the method is invoked, an integer from 0 to array.length is picked up, and the corresponding check operation is invoked. Then you remove invoked operation from a collection and recursively invoke the same method on the remainder array.

Originally Posted by efluvio

...i think i should use the switch...

I'm liking that idea. You could use an array of ints to determine the order in which the things are executed.


A very simple approach might be something like:

    static void foo(int [] order) {
 
        for (int selection = 0; selection < order.length; selection++) {
            switch (order[selection]) {
                case 0:
                    System.out.println("Executing first  thingie.");
                    // Do the first one
                    break;
 
                case 1:
                    System.out.println("Executing second thingie.");
                    // Do the second one
                    break;
 
                case 2:
                    System.out.println("Executing third  thingie.");
                    // Do the third one
                    break;
 
                case 3:
                    System.out.println("Executing fourth thingie.");
                    // Do the fourth one
                    break;
 
                case 4:
                    System.out.println("Executing fifth  thingie.");
                    // Do the fifth one
                    break;
            } // End switch.
        } // End for
 
    } // End foo;

Start out with the array in any order you want, then, from the calling function, re-arrange the elements of the array each time before calling:

public class Z {
 
    // Use rng.nextInt() in the randomShuffle method.
    static Random rng = new Random();
 
    static Scanner keyboard = new Scanner(System.in);
 
    public static void main(String [] args) {
 
        // Start with 0..4 in order
        int orderArray[] = {0, 1, 2, 3, 4};
 
        while (true) {
            // Re-arrange the order in which things will be
            // executed each time.
            randomShuffle(orderArray);
 
            foo(orderArray);
 
            System.out.print("\nPress 'Enter' to continue...");
            keyboard.nextLine();
            System.out.println();
        }
    } // End main
 
 
 
    static void foo(int [] order) {
 
        //
        // Code to do stuff in sequence, depending on the order.
        //
 
    } // End foo;
 
    public static void randomShuffle(int [] iarray) {
        // Uncomment the following for debugging
        //System.out.printf("Into   shuffle: %s\n", Arrays.toString(iarray));
 
        //
        // Code to shuffle the elements if iarray
        //
 
        // Uncomment the following for debugging
        //System.out.printf("Out of shuffle: %s\n", Arrays.toString(iarray));
    } // End shuffle
 
} // End class definition.

Some folks might prefer to put the shuffling inside foo so that the mechanism would be invisible to the calling function. That might be a better implementation, but the idea is the same.


Random shuffle algorithms can be very simple and easy to implement in Java. For example there is some pseudo-code for the Fisher-Yates shuffle that can be efficiently implemented in something like seven or so lines of elementary Java.

Anyhow...

A sample run might look like:

Executing fourth thingie.
Executing third  thingie.
Executing first  thingie.
Executing fifth  thingie.
Executing second thingie.
 
Press 'Enter' to continue...
 
Executing first  thingie.
Executing fourth thingie.
Executing second thingie.
Executing third  thingie.
Executing fifth  thingie.
 
Press 'Enter' to continue...
 
Executing fifth  thingie.
Executing first  thingie.
Executing third  thingie.
Executing second thingie.
Executing fourth thingie.
 
Press 'Enter' to continue...
 
Executing second thingie.
Executing third  thingie.
Executing first  thingie.
Executing fourth thingie.
Executing fifth  thingie.
 
Press 'Enter' to continue...
 
Executing fourth thingie.
Executing first  thingie.
Executing third  thingie.
Executing second thingie.
Executing fifth  thingie.
 
Press 'Enter' to continue...
 
Executing second thingie.
Executing fourth thingie.
Executing fifth  thingie.
Executing first  thingie.
Executing third  thingie.
 
Press 'Enter' to continue...
 
Executing second thingie.
Executing fifth  thingie.
Executing first  thingie.
Executing third  thingie.
Executing fourth thingie.
 
Press 'Enter' to continue...
 
Executing third  thingie.
Executing first  thingie.
Executing fourth thingie.
Executing second thingie.
Executing fifth  thingie.
 
Press 'Enter' to continue...
 
Executing first  thingie.
Executing fifth ...

Finally: I think that learning to write shuffling code is very worthwhile, but actually you can use the Collections.shuffle() method on a list that is based on an array of Integers. I think that's also worth a glimpse.



Cheers!

Z