How to print out X number of permutations in java?

Question

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 = %d\n",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);

        }
    }
}
}

Answer 1

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