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=2Output:2Explanation:

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

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:

- Traverse the range
**[1, N]**. - 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. - Remove
**i**. - 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 <bits/stdc++.h>` `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(Set<Integer>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.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<Integer> arr = ` `new` `HashSet<Integer>();` ` ` ` ` `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` |

**Output:**

10

**Time Complexity:** O(N×N!)**Auxiliary Space:** O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.