# Count of permutations of an Array having each element as a multiple or a factor of its index

Given an integer, N, the task is to count the number of ways to generate an array, arr[] of consisting of N integers such that for every index i(1-based indexing), arr[i] is either a factor or a multiple of i, or both. The arr[] must be the permutations of all the numbers from the range [1, N].

Examples:

Input: N=2
Output: 2
Explanation:
Two possible arrangements are {1, 2} and {2, 1}

Input: N=3
Output: 3
Explanation:
The 6 possible arrangements are {1, 2, 3}, {2, 1, 3}, {3, 2, 1}, {3, 1, 2}, {2, 3, 1} and {1, 3, 2}.
Among them, the valid arrangements are {1, 2, 3}, {2, 1, 3} and {3, 2, 1}.

Approach: The problem can be solved using Backtracking technique and the concept of print all permutations using recursion. Follow the steps below to find the recurrence relation:

1. Traverse the range [1, N].
2. For the current index pos, if i % pos == 0 and i % pos == 0, then insert i into the arrangement and use the concept of Backtracking to find valid permutations.
3. Remove i.
4. Repeat the above steps for all values in the range [1, N], and finally, print the count of valid permutations.

Below is the implementation of the above approach:

## C++

 `// C++ Program to implement``// the above approach``#include ``using` `namespace` `std;` `// Function to find the count of``// desired permutations``int` `findPermutation(unordered_set<``int``>& arr,``                    ``int` `N)``{``    ``int` `pos = arr.size() + 1;` `    ``// Base case``    ``if` `(pos > N)``        ``return` `1;` `    ``int` `res = 0;` `    ``for` `(``int` `i = 1; i <= N; i++) {` `        ``// If i has not been inserted``        ``if` `(arr.find(i) == arr.end()) {` `            ``// Backtrack``            ``if` `(i % pos == 0 or pos % i == 0) {` `                ``// Insert i``                ``arr.insert(i);` `                ``// Recur to find valid permutations``                ``res += findPermutation(arr, N);` `                ``// Remove i``                ``arr.erase(arr.find(i));``            ``}``        ``}``    ``}` `    ``// Return the final count``    ``return` `res;``}` `// Driver Code``int` `main()``{``    ``int` `N = 5;``    ``unordered_set<``int``> arr;``    ``cout << findPermutation(arr, N);` `    ``return` `0;``}`

## Java

 `// Java program to implement``// the above approach``import` `java.util.*;` `class` `GFG{``    ` `// Function to find the count of``// desired permutations``static` `int` `findPermutation(Setarr,``                           ``int` `N)``{``    ``int` `pos = arr.size() + ``1``;` `    ``// Base case``    ``if` `(pos > N)``        ``return` `1``;` `    ``int` `res = ``0``;` `    ``for``(``int` `i = ``1``; i <= N; i++) ``    ``{``        ` `        ``// If i has not been inserted``        ``if` `(! arr.contains(i))``        ``{``            ` `            ``// Backtrack``            ``if` `(i % pos == ``0` `|| pos % i == ``0``)``            ``{``                ` `                ``// Insert i``                ``arr.add(i);` `                ``// Recur to find valid permutations``                ``res += findPermutation(arr, N);` `                ``// Remove i``                ``arr.remove(i);``            ``}``        ``}``    ``}` `    ``// Return the final count``    ``return` `res;``}` `// Driver Code``public` `static` `void` `main(String []args)``{``    ``int` `N = ``5``;``    ``Set arr = ``new` `HashSet();``    ` `    ``System.out.print(findPermutation(arr, N));``}``}` `// This code is contributed by chitranayal`

## Python3

 `# Python3 program to implement``# the above approach` `# Function to find the count of``# desired permutations``def` `findPermutation(arr, N):` `    ``pos ``=` `len``(arr) ``+` `1` `    ``# Base case``    ``if``(pos > N):``        ``return` `1` `    ``res ``=` `0` `    ``for` `i ``in` `range``(``1``, N ``+` `1``):` `        ``# If i has not been inserted``        ``if``(i ``not` `in` `arr):` `            ``# Backtrack``            ``if``(i ``%` `pos ``=``=` `0` `or` `pos ``%` `i ``=``=` `0``):` `                ``# Insert i``                ``arr.add(i)` `                ``# Recur to find valid permutations``                ``res ``+``=` `findPermutation(arr, N)` `                ``# Remove i``                ``arr.remove(i)` `    ``# Return the final count``    ``return` `res` `# Driver Code``N ``=` `5``arr ``=` `set``()` `# Function call``print``(findPermutation(arr, N))` `# This code is contributed by Shivam Singh`

## C#

 `// C# program to implement``// the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{``    ` `// Function to find the count of``// desired permutations``static` `int` `findPermutation(HashSet<``int``>arr,``                           ``int` `N)``{``    ``int` `pos = arr.Count + 1;` `    ``// Base case``    ``if` `(pos > N)``        ``return` `1;` `    ``int` `res = 0;` `    ``for``(``int` `i = 1; i <= N; i++) ``    ``{``        ` `        ``// If i has not been inserted``        ``if` `(! arr.Contains(i))``        ``{``            ` `            ``// Backtrack``            ``if` `(i % pos == 0 || pos % i == 0)``            ``{``                ` `                ``// Insert i``                ``arr.Add(i);` `                ``// Recur to find valid permutations``                ``res += findPermutation(arr, N);` `                ``// Remove i``                ``arr.Remove(i);``            ``}``        ``}``    ``}` `    ``// Return the readonly count``    ``return` `res;``}` `// Driver Code``public` `static` `void` `Main(String []args)``{``    ``int` `N = 5;``    ``HashSet<``int``> arr = ``new` `HashSet<``int``>();``    ` `    ``Console.Write(findPermutation(arr, N));``}``}` `// This code is contributed by gauravrajput1`

## Javascript

 ``

Output:
`10`

Time Complexity: O(NÃ—N!)
Auxiliary Space: O(N)

### Using Brute Force in python:

Approach:

The first approach is to generate all possible permutations of the array and check if each element is a multiple or a factor of its index. We can do this using a recursive function to generate permutations and then checking each permutation.

• Define a function is_valid(arr) that takes an array arr and checks if each element is a multiple or a factor of its index. It returns True if all elements satisfy this condition, otherwise False.
• Define a recursive function generate_permutations(arr, l, r, valid_permutations) that generates all possible permutations of the array arr from index l to index r. For each permutation, it checks if it is valid using the function is_valid(arr). If a valid permutation is found, it is added to the list valid_permutations.
• Define a function count_permutations(n) that creates an array arr of size n, initializes it with values 1 to n, and calls the function generate_permutations() with arr, 0, n-1, and an empty list valid_permutations. It then returns the length of valid_permutations.
Call the function count_permutations() with the input n and print the result.

## Python3

 `def` `is_valid(arr):``    ``for` `i ``in` `range``(``len``(arr)):``        ``if` `arr[i] ``%` `(i``+``1``) !``=` `0` `and` `(i``+``1``) ``%` `arr[i] !``=` `0``:``            ``return` `False``    ``return` `True` `def` `generate_permutations(arr, l, r, valid_permutations):``    ``if` `l ``=``=` `r:``        ``if` `is_valid(arr):``            ``valid_permutations.append(arr[:])``    ``else``:``        ``for` `i ``in` `range``(l, r``+``1``):``            ``arr[l], arr[i] ``=` `arr[i], arr[l]``            ``generate_permutations(arr, l``+``1``, r, valid_permutations)``            ``arr[l], arr[i] ``=` `arr[i], arr[l]` `def` `count_permutations(n):``    ``arr ``=` `[i``+``1` `for` `i ``in` `range``(n)]``    ``valid_permutations ``=` `[]``    ``generate_permutations(arr, ``0``, n``-``1``, valid_permutations)``    ``return` `len``(valid_permutations)` `print``(count_permutations(``2``)) ``# Output: 2``print``(count_permutations(``3``)) ``# Output: 3`

Output
```2
3
```

Time Complexity: O(n!)
Space Complexity: O(n!)

Previous
Next