A Programming Problem I am stuck on

Question

Hello,
I am trying to solve the following problem:
Given a deck of nCards unique cards, cut the deck iCut cards from top and perform a perfect shuffle. A perfect shuffle begins by putting down the bottom card from the top portion of the deck followed by the bottom card from the bottom portion of the deck followed by the next card from the top portion, etc., alternating cards until one portion is used up. The remaining cards go on top. The problem is to find the number of perfect shuffles required to return the deck to its original order. Your function should be declared as:
static long shuffles(int nCards,int iCut);
find the solution of shuffles(1002,101)
So my code, which is pasted below, is a brute force method of solving the problem in that I am passing the entire array symbolizing a unique deck, to a shuffles function then using for loops to shuffle the deck and pass back the array and use for loops again to check if it matches the original deck. My code works for smaller cases but the (1002,101) case, is taking way too long and there is a solution that can solve the problem within a few minutes, I just need to figure it out.
I am thinking rather than passing the entire array, perhaps i need to pass by reference to my shuffles function and use pointers to manipulate just one array and then use a for loop to check it. However, I am also trying to think of other reasons my code is too slow.
Any help is really appreciated.
srahan.
-------------------------My Code in Java----------------------------
import java.awt.*;
import java.awt.event.*;
import java.io.*;
//import java.util.Arrays;
public class Shuffles
public static int ncards;
public static int icut;
public static long counter;
public static void main (String[] args)
long total=0;
ncards = 102;
icut = 11;
counter = 0;
//arrays for original card decks this stays the same order
int[] deck = new int[ncards];
int[] deck2 = new int[ncards];
int[] ogdeck = new int[ncards];
//create original card deck with unique cards, assume 0 is bottom of deck
//and create initial shuffled deck instance
for (int i=0; i<ncards; i++)
ogdeck[i] = i;
deck[i] = i;
System.out.println("ncards: " + ncards);
System.out.println("icut: " + icut);
boolean equal=false;
do
deck2 = shuffledeck(deck);
//equal = Arrays.equals(deck2, ogdeck);
/* System.out.println("");
System.out.println("ogdeck"); //print out original deck used for testing
for (int i=0; i<ncards; i++)
System.out.println(ogdeck);
System.out.println("");
System.out.println("deck2"); //print out shuffled deck used for testing
for (int i=0; i<ncards; i++)
System.out.println(deck2[i]);
for (int i=0; i < ncards; i++)
if (ogdeck[i]==deck2[i])
equal = true;
else
equal = false;
break;
while (equal==false);
if (equal == true)
System.out.println("");
System.out.println("It took " + counter + " perfect shuffles to return the deck to its orginal order");
//shuffle function
public static int[] shuffledeck (int[] decktoshuffle)
int[] tophalf = new int[ncards];
int[] bottomhalf = new int[ncards];
int temp=0;
int place=0;
//cut passed deck into two halfs
for (int i=0; i < (ncards-icut); i++)
bottomhalf[i] = decktoshuffle[i];
for (int i=(ncards-icut); i < ncards; i++)
tophalf[temp] = decktoshuffle[i];
temp++;
//create new deck by shuffling
//if the bottom half has LESS cards than top half
if ((ncards-icut) <= icut)
for (int i=0; i<(ncards-icut); i++)
decktoshuffle[place]=tophalf[i];
decktoshuffle[place+1]=bottomhalf[i];
place=place+2;
//place remaining cards from TOP half on top of new deck
for (int j=(ncards-icut); j<icut; j++)
decktoshuffle[place] = tophalf[j];
place++;
//if the top half has LESS cards than bottom half
if ((ncards-icut) > icut)
for (int i=0; i<(icut); i++)
decktoshuffle[place]=tophalf[i];
decktoshuffle[place+1]=bottomhalf[i];
place=place+2;
//place remaining cards from TOP half on top of new deck
for (int j=(icut); j<(ncards-icut); j++)
decktoshuffle[place] = bottomhalf[j];
place++;
counter++;
return decktoshuffle;

Answer 1

so i consolidated the two functions into one main function but its still too slow....any help would be appreciated.
import java.awt.*;
import java.awt.event.*;
import java.io.*;
//import java.util.Arrays;
public class Class1
     public static int ncards;
     public static int icut;
     public static long counter;
     public static void main (String[] args)
          long total=0;     
          ncards = 1002;
          icut = 101;
          counter = 0;
          int[] shuffdeck = new int[ncards];
          int[] currdeck = new int[ncards];
          int[] deckpointer = new int[ncards];
          int[] ogdeck = new int[ncards];
          //create original card deck with unique cards, assume 0 is bottom of deck
          //and create initial shuffled deck instance
          for (int i=0; i<ncards; i++)
               currdeck[i] = i;
               ogdeck[i] = i;
          System.out.println("ncards: " + ncards);
          System.out.println("icut: " + icut);
          boolean equal=false;
          int i;
          int j;
          int k;
          do
               //i counts through top portion (of nCut cards)
               //j counts through bottom portion (of nCards-nCut cards)
               //k counts through new shuffle deck
               //You can keep track of whether its back to normal during this process to save on time.
               //We start with a deck with 0 on bottom and nCards-1 on top.
               equal=true;
               for(i=(ncards-icut), j=0, k=0; i<ncards && j<(ncards-icut); i++, j++, k+=2)
                    //Take from bottom of Cut
                    shuffdeck[k] = currdeck;
                    //Take from bottom of other half
                    shuffdeck[k+1] = currdeck[j];
                    if ( shuffdeck[k] != k )
                         equal = false;
               //Add remaining cards to deck ( only one of two loops will be entered )
               while ( k < ncards )
                    shuffdeck[k] = currdeck[j];
                    if ( shuffdeck[k] != k )
                         equal = false;
                    j++;
                    k++;
               deckpointer = currdeck;
               currdeck = shuffdeck;
               shuffdeck = deckpointer;                         
               counter++;
               while (equal==false);
          if (equal == true)
               System.out.println("");
               System.out.println("It took " + counter + " perfect shuffles to return the deck to its orginal order");