Wsrtjtyk

The code I have written takes elements of an array and goes through the array to give all permutations. But I need it to only display a certain number of permutations:

The final code is to give only 6 permutations of 9 elements (in other words, print the first 60480 arrangements of the total 362880 outputs). For simplicity, I'm working with 4 elements in the array and I get all 24 arrangements to print out. But I need the code to work for any number of permutations. For example, if I need it to print out 1-permutation, the code should print the first 4 arrangements - ABCD, ABDC, ACBD, and ACDB. I'm unsure how to solve this.

public static void main(String args) {

    // TODO Auto-generated method stub





    String myArray = {"A","B","C", "D"};

    int size = myArray.length; 

    permutation(myArray, 0, size-1);



    // Calculate Permutations

    int n=size;

    int r=6; // subject to change

    int p = n - r;

    int total=1;

    int total2=1;

    int total3=0;



    for (int top=n; top>0; top--)

    {

        total *= top;

    }



    if ((n-r<0))

    {

     System.out.println("r value cannot be greater than array size");

     total3=0;

    }

    else 

    {

        for (int bot=1; bot<=p; bot++)

        {

            if (p==0) // should be -- else if (p==0) -- after correction

            {

                total2=1;

            }

            else

            {

                total2 *= bot;

            }

        }

        total3 = total/total2;

    }



    System.out.printf("%d permutations of %d elements = %dn",r,n,total3);

    // end calculation



}

// end main



// print array

public static void prtArray(String myArray, int size)

{

    for(int i=0; i<size; i++)

    {

        System.out.printf("%s", myArray[i]);

    }

    System.out.println();

}



// swap elements    

public static void swap(String myArray, int i, int j) {

    String temp;

    temp = myArray[i];

    myArray[i]=myArray[j];

    myArray[j]=temp;

}



// permutation 

private static void permutation(String myArray, int b, int e)

{

    if (b == e)

        prtArray(myArray, e+1); // accounts for array of size 1

    else

    {

        for(int i = b; i <= e; i++)

        {



            swap(myArray, i, b);

            permutation(myArray, b+1, e);

            swap(myArray, i, b);



        }

    }

}

}

I am assuming you don't want an element to be repeated in a permutation.
eg.

If input array is {1, 2, 3, 4}, then for length 3: 123, 124, etc are valid permutations but 122 or 111 is not.

To avoid picking elements which are already picked, we need to pass a visited array in the recursion.

public class Main {

    // Maintain a global counter. After finding a permutation, increment this. 

    private static int count = 0;



    // pos is the current index, and K is the length of permutation you want to print, and N is the number of permutation you want to print.

    private static void printPermutations(int arr, int visited, int pos, int K, int N, String str) {



        // We have already found N number of permutations. We don't need anymore. So just return.

        if (count == N) {

            return;

        }



        if (pos == K) {

            System.out.println(str);

            count++; // we have found a valid permutation, increment counter.

            return;

        }



        for (int i = 0; i < arr.length; i++) {

            // Only recur if the ith element is not visited.

            if (visited[i] == 0) {

                // mark ith element as visited.

                visited[i] = 1;

                printPermutations(arr, visited, pos + 1, K, N, str + arr[i]);

                // unmark ith element as visited.

                visited[i] = 0;

            }

        }



    }





    public static void main(String args) {

        int arr = {1, 2, 3, 4};

        int visited = {0, 0, 0, 0}; // same as size of input array.

        count = 0; // make sure to reset this counter everytime you call printPermutations.

        // let's print first 4 permutations of length 3.

        printPermutations(arr, visited, 0, 3, 4, "");

    }

}

Outputs:

for N = 4 and K = 3 (i.e First 4 permutations of length 3):

printPermutations(arr, visited, 0, 3, 4, "");



123

124

132

134

for N = 4 and K = 4 (i.e First 4 permutations of length 4):

printPermutations(arr, visited, 0, 4, 4, "");



1234

1243

1324

1342