Count all the permutation of an array

// Java implementation of the approach
// Recursive function that return count of 
// permutation based on the length of array.
import java.util.*;

class GFG
{

static int count(int n)
{
    if(n == 0)
        return 1;
    if(n == 1)
        return 1;
    else
        return (n * count(n - 1)) + 
                        ((n - 1) * count(n - 2));
}

// Driver Code
static public void main(String[] arg) 
{
    int []A = {1, 2, 3, 9};

    System.out.print(count(A.length - 1));
}
}

// This code is contributed by PrinciRaj1992

import java.util.ArrayList;
import java.util.Collections;

public class PermutationCount {

    // Function to check if a given permutation is valid
    static boolean
    isValidPermutation(ArrayList<Integer> permutation,
                       ArrayList<Integer> arr)
    {
        for (int i = 0; i < permutation.size() - 1; i++) {
            int x = permutation.get(i);
            int y = permutation.get(i + 1);
            // Check if the adjacent elements in the
            // permutation are consecutive and form an
            // increasing subsequence in the original array.
            if (Math.abs(x - y) == 1
                && arr.get(x) < arr.get(y)) {
                return false; // If the condition is not
                              // met, the permutation is not
                              // valid.
            }
        }
        return true; // If all adjacent elements satisfy the
                     // condition, the permutation is valid.
    }

    // Function to count valid permutations
    static int countPermutations(ArrayList<Integer> arr)
    {
        int n = arr.size();
        ArrayList<Integer> permutation = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            permutation.add(
                i); // Create an initial permutation (0, 1,
                    // 2, ..., n-1).
        }
        int count = 0; // Initialize the count of valid
                       // permutations to 0.
        do {
            if (isValidPermutation(permutation, arr)) {
                count++; // If the current permutation is
                         // valid, increment the count.
            }
        } while (nextPermutation(
            permutation)); // Generate all permutations
                           // using lexicographic order.
        return count; // Return the total count of valid
                      // permutations.
    }

    // Function to find the next permutation
    static boolean
    nextPermutation(ArrayList<Integer> permutation)
    {
        int i = permutation.size() - 2;
        // Find the longest suffix of the permutation that
        // is in non-increasing order.
        while (i >= 0
               && permutation.get(i)
                      >= permutation.get(i + 1)) {
            i--;
        }
        if (i < 0) {
            return false; // If the entire permutation is in
                          // non-increasing order, there is
                          // no next permutation.
        }
        int j = permutation.size() - 1;
        // Find the rightmost element in the suffix that is
        // greater than the current element
        // (permutation[i]).
        while (permutation.get(j) <= permutation.get(i)) {
            j--;
        }
        // Swap the current element with the next greater
        // element in the suffix.
        swap(permutation, i, j);
        // Reverse the suffix to get the next permutation in
        // lexicographic order.
        reverse(permutation, i + 1, permutation.size() - 1);
        return true; // Successfully generated the next
                     // permutation.
    }

    // Function to swap two elements in an ArrayList
    static void swap(ArrayList<Integer> arr, int i, int j)
    {
        int temp = arr.get(i);
        arr.set(i, arr.get(j));
        arr.set(j, temp);
    }

    // Function to reverse a portion of the ArrayList
    static void reverse(ArrayList<Integer> arr, int i,
                        int j)
    {
        while (i < j) {
            swap(arr, i, j);
            i++;
            j--;
        }
    }

    public static void main(String[] args)
    {
        ArrayList<Integer> arr1 = new ArrayList<>();
        arr1.add(1);
        arr1.add(2);
        arr1.add(3);
        System.out.println(countPermutations(
            arr1)); // Output: 2 (Valid permutations: (1, 3,
                    // 2) and (2, 1, 3))

        ArrayList<Integer> arr2 = new ArrayList<>();
        arr2.add(1);
        arr2.add(2);
        arr2.add(3);
        arr2.add(9);
        System.out.println(countPermutations(
            arr2)); // Output: 0 (No valid permutation, as
                    // (1, 3, 2, 9) breaks the increasing
                    // subsequence condition)
    }
}