Count permutations of 0 to N-1 with at least K elements same as positions

// Java code for the above approach:
import java.util.*;

class GFG {

  static int ans = 0;
  
  // Recursive function to get the
  // all permutations of current array
  static void getPermutations(Vector<Integer> arr,
                              int index, long k)
  {

    // Base condition if current index is
    // greater than or equal to array size

    if (index >= arr.size()) {

      // Initialising the variable count
      int count = 0;

      // Counting the number of positions
      // with arr[i] = i in the array
      for (int i = 0; i < arr.size(); i++) {
        if (arr.get(i) == i) {
          count++;
        }
      }

      // If count is greater than
      // or equal to k then
      // increment the ans
      if (count >= k) {
        ans++;
      }

      return;
    }

    // Iterating over the array arr
    for (int i = index; i < arr.size(); i++) {

      // Swapping current index with I
      int temp = arr.get(index);
      arr.set(index, arr.get(i));
      arr.set(i, temp);
      // Calling recursion for current
      // condition
      getPermutations(arr, index + 1, k);

      // Resetting the swapped position.
      temp = arr.get(index);
      arr.set(index, arr.get(i));
      arr.set(i, temp);
    }
  }

  static int numberOfPermutations(long n,
                                  long k)
  {

    // Initializing the variables
    //'mod' and 'ans'.
    int mod = 1000000000 + 7;


    // Initializing the array 'arr'.
    Vector<Integer> arr = new Vector<Integer>();

    // Pushing numbers in the array.
    for (int i = 0; i < n; i++) {
      arr.add(i);
    }

    // Calling recursive function 'getPermutations'
    getPermutations(arr, 0, k);

    // Returning 'ans'.
    return ans % mod;
  }

  // Driver Code
  public static void main (String[] args) {
    long N = 4;
    long K = 2;
    System.out.println(numberOfPermutations(N, K));
  }
}

// This code is contributed by hrithikgarg03188.

// Java program for the above approach
import java.util.ArrayList;

class GFG {

  // Driver function to get the
  // modular addition.
  static long add(long a, long b)
  {
    long mod = (int)1e9 + 7;
    return ((a % mod) + (b % mod)) % mod;
  }

  // Driver function to get the
  // modular multiplication.
  static long mul(long a, long b)
  {
    long mod = (int)1e9 + 7;
    return ((a % mod) * 1 * (b % mod)) % mod;
  }

  // Driver function to get the
  // modular binary exponentiation.
  static long bin_pow(long a, long b)
  {
    long mod = (int)1e9 + 7;
    a %= mod;
    long res = 1;
    while (b > 0) {
      if ((b & 1) != 0) {
        res = res * 1 * a % mod;
      }
      a = a * 1 * a % mod;
      b >>= 1;
    }
    return res;
  }

  // Driver function to get the
  // modular division.
  static long reverse(long x)
  {
    long mod = (int)1e9 + 7;
    return bin_pow(x, mod - 2);
  }

  static long numberOfPermutations(long n, long k)
  {

    // Updating 'k' with 'n - k'.
    k = n - k;

    // Initializing the 'ans' by 1.
    long ans = 1;

    // Condition when 'k' is 1.
    if (k == 0 || k == 1) {
      return ans;
    }

    // Adding derangement for 'k' = 2.
    ans += mul(mul(n, n - 1), reverse(2));

    // Condition when 'k' is 2.
    if (k == 2) {
      return ans;
    }

    // Adding derangement for 'k' = 3.
    ans += mul(mul(n, mul(n - 1, n - 2)),
               reverse(3));

    // Condition when 'k' is 3.
    if (k == 3) {
      return ans;
    }

    // Adding derangement for 'k' = 4.
    long u = mul(n, mul(n - 1, mul(n - 2,
                                   n - 3)));
    ans = add(ans, mul(u, reverse(8)));
    ans = add(ans, mul(u, reverse(4)));

    return ans;
  }

  // Driver Code
  public static void main(String args[]) {
    long N = 4;
    long K = 2;

    System.out.print( numberOfPermutations(N, K));
  }
}

// This code is contributed by sanjoy_62.