(anti)clockwise rotation of array elements...HELP!

[Ken Ng]

hi all, need some help!
I'm designing a method that can rotate array elements clockwise or anticlockwise some no. of times and return the result.
public int[] rotate(int[] array, int num_rotation, boolean clockwise)

Take for instance, int[] a = {1, 2, 3, 4, 5};
ANTICLOCKWISE
i.e last element become first, the rest push from L to R in an anticlockwise fasion
1st clockwise rotation => result: {5, 1, 2, 3, 4}
2nd clockwise rotation => result: {4, 5, 1, 2, 3}
and so on..
----------------------------------------------------------------------
CLOCKWISE
i.e first element become last, the rest push from R to L in an clockwise fashion
1st anti-clockwise rotation => result: {2, 3, 4, 5, 1}
2nd anti-clockwise rotation => result: {3, 4, 5, 1, 2}
and so on..

Can't figure the algorithm for rotation
Is there some better way of doing it.
Thanks in adv

[Dirk Schreckmann]

What have you thought to try so far? What do you think might be some of the steps of the algorithm?

[Vicken Karaoghlanian]

Let me help you a little bit on the algorithm
1) Save the first element of the array in a variable.
2) Loop through the elements of the array and assign each element to it predecessor.
3) Assign the value you saved in step 1 to the last element of the array.

[Ken Ng]

Thanks for your hint, Vicken
But i have problem with ANTI-CLOCKWISE
Here's my code

  
public class rotate{
  public static void main(String args[]) {
    int[] a = {1, 2, 3, 4, 5};
    System.out.println("CLOCKWISE\tANTI-CLOCKWISE");
    for(int x = 0; x < 6 ; x++) {
display(rotator(a, x, true));
System.out.print("\t");
display(rotator(a, x, false));
System.out.println();
    }
  }
  public static int[] rotator(int[] array, int numRot, boolean clockwise) {
    int temp;
    if(clockwise) {
        for(int f = 0; f < numRot; f++) {
            temp = array[0];
    for(int i = 1, j = 0; i < array.length ; i++, j++) {
        array[j] = array[i];
    }
    array[array.length-1] = temp;
        }
return array;
    }
    else {
for(int f = 0; f < numRot; f++) {
    temp = array[array.length-1];
    for(int i = array.length-1, j = i-1; i > 0; i--, j--) {
array[i] = array[j];
    }
    array[0] = temp;
}
return array;
    }
  }
  public static void display(int[] b) {
      for(int i=0; i<b.length; i++) System.out.print(b[i] + " ");
  }
}

 
OUTPUT obtained:
12345    12345
23451    12345
34512    12345
45123    12345
51234    12345
12345    12345

Results in 2nd col belongs to ANTI-CLOCKWISE and is wrong!
ANTI-CLOCKWISE algorithm looks OK, but can't figure out what is wrong?
[ March 15, 2004: Message edited by: Ken Ng ]

[Vicken Karaoghlanian]

Ken-
I modified your code, to make it a little bit more efficient.

class test {

int[] a = {1,2,3,4,5};
int[] clockwise(int[] a) {

int temp = a[0];

for (int i = 1; i < a.length; i++)
a[i-1] = a[i];

a[a.length-1] = temp;

return a;
}

int[] antiClockwise(int[] a) {

int temp = a[a.length-1];

for (int i = a.length-1; i > 0 ; i--)
a[i] = a[i-1];

a[0] = temp;

return a;
}

void printArray(int[] a) {

for (int i=0; i<a.length; i++)
System.out.print(a[i] + " ");

System.out.println();
}

public static void main(String[] args) {

test t = new test();
t.antiClockwise(t.a);
t.printArray(t.a);

t.clockwise(t.a);
t.printArray(t.a);
}
}

[ March 15, 2004: Message edited by: Vicken Karaoghlanian ]

[Michael Dunn]

Here's another way, using JOptionPane
(needs error handling)

import javax.swing.JOptionPane;
class ArrayRotation
{
  int[] arr = {1,2,3,4,5};
  public ArrayRotation()
  {
    int selection = 0;
    int rotations = 1;
    boolean clockwise;
    String[] options = {"Anti-Clockwise","Clockwise","Quit"};
    while(selection < 2)
    {
      printArray();
      selection =  JOptionPane.showOptionDialog(null,"Rotate the array?","",-1,-1,null,options,"");
      if(selection == 2) break;
      rotations = Integer.parseInt(JOptionPane.showInputDialog("How many rotations?"));
      clockwise = selection == 1? true:false;
      rotate(arr,rotations,clockwise);
    }
    System.exit(0);
  }
  public void rotate(int[] array, int num_rotation, boolean clockwise)
  {
    int direction = clockwise? 1:-1;
    int startElement, endElement, temp;
    for(int x = 0; x < num_rotation; x++)
    {
      startElement = clockwise? 0:array.length -1;
      endElement = clockwise? array.length -1:0;
      temp = array[startElement];
      for(int y = 0; y < array.length-1; y++)
      {
        array[startElement] = array[startElement+direction];
        startElement += direction;
      }
      array[endElement] = temp;
    }
  }
  public void printArray()
  {
    String output = "The array is\n\n";
    for(int x = 0; x < arr.length; x++) output += arr[x] + " ";
    JOptionPane.showMessageDialog(null,output);
  }
  public static void main(String[] args){new ArrayRotation();}
}

[Stan James]

Say you have 1-2-3-4-5 written around a wheel like this:

     1     <- start here
   5   2
    4 3

If you rotate two positions counterclockwise, it will come out 3-4-5-1-2. I have to put my fingers on the wheel and turn click, click to make sure that's right.

     3     <- start here
   2   4
    1 5

right?
Where 1 used to be first 3 is now first. Hmmm, to rotate two positions, we skip two positions over to find the new first element. That has promise:

Rotated[0] = Original[2]  -> 3
Rotated[1] = Original[3]  -> 4
Rotated[2] = Original[4]  -> 5
Rotated[3] = Original[5] 
Error! The array only goes to 4. So wrap around the wheel to position 0.
Rotated[3] = Original[0]  -> 1
Rotated[4] = Original[1]  -> 2

Fortunately that wrapping around the wheel is available in math with modulus, which gives the remainder of a division. So this will work for any counterclockwise rotation up to 4.

x = CounterClockwiseRotation (this time it's 2)
Rotated[0] = Original[x]         x = 2     -> 3
x = x + 1 % 5
Rotated[1] = Original[x]         x = 3     -> 4
x = x + 1 % 5
Rotated[2] = Original[x]         x = 4     -> 5
x = x + 1 % 5
Rotated[3] = Original[x]         x = 0     -> 1
x = x + 1 % 5
Rotated[4] = Original[x]         x = 1     -> 2

See if you can turn that into a more generic loop. The rotated index goes from 0 to length of array-1. The x index goes from 2 however much you rotate (this time 2) and wraps around.
I hope that made sense. Now look at clockwise.

     1     <- start here
   5   2
    4 3
rotates two positions to:
     4     <- start here
   3   5
    2 1

This is just the same except we subtract the number of rotations from zero. So x starts out at -2. We have to make this positive first, so add the length of the array: -2 + 5 = 3. Now we can start around the wheel exactly as before.
What we're doing here is commonly called a "circular buffer" - a fixed sized array that we use from beginning to end and then start over. This is common in some kinds of stream processing and may come in handy in your future.
Hey, how do you make it work for any rotation? Say somebody wants to rotate 99, like spinning the wheel of fortune on TV!