Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

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

  • Difficulty Level : Expert
  • Last Updated : 02 Jun, 2021

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 <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
Javascript



<script>
 
// Javascript program to implement
// the above approach
 
// Function to find the count of
// desired permutations
function findPermutation(arr, N)
{
    var pos = arr.size + 1;
 
    // Base case
    if (pos > N)
        return 1;
 
    var res = 0;
 
    for(var i = 1; i <= N; i++)
    {
         
        // If i has not been inserted
        if (!arr.has(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.delete(i);
            }
        }
    }
 
    // Return the final count
    return res;
}
 
// Driver Code
var N = 5;
var arr = new Set();
 
document.write(findPermutation(arr, N));
 
// This code is contributed by importantly
 
</script>
Output: 
10
 
Time Complexity: O(N×N!)
Auxiliary Space: O(N)
 

My Personal Notes
arrow_drop_up
Previous
Minimize count of Subsets with difference between maximum and minimum element not exceeding K
Next

Minimum possible value T such that at most D Partitions of the Array having at most sum T is possible
Recommended Articles
Page :
Count subsets consisting of each element as a factor of the next element in that subset
15, Feb 21
Find the index having sum of elements on its left equal to reverse of the sum of elements on its right
13, Jan 21
Count of pairs having each element equal to index of the other from an Array
30, Jul 20
Number of permutations such that sum of elements at odd index and even index are equal
02, Jul 18
Length of longest subarray for each index in Array where element at that index is largest
28, Jun 21
Find Array formed by adding each element of given array with largest element in new array to its left
24, Mar 20
Minimize cost to split an array into K subsets such that the cost of each element is its product with its position in the subset
03, Jan 21
Maximum subsequence sum possible by multiplying each element by its index
16, Sep 20
Generate longest possible array with product K such that each array element is divisible by its previous adjacent element
12, Mar 21
Generate array having differences between count of occurrences of every array element on its left and right
31, Oct 20
Convert a number to another by dividing by its factor or removing first occurrence of a digit from an array
15, Apr 21
Form an array of distinct elements with each element as sum of an element from each array
26, Mar 20
Remaining array element after repeated removal of last element and subtraction of each element from next adjacent element
23, Feb 21
Count of binary strings of length N having equal count of 0's and 1's and count of 1's ≥ count of 0's in each prefix substring
25, Jul 20
Range Query on array whose each element is XOR of index value and previous element
24, Dec 17
Count of permutations of an Array having maximum MEXs sum of prefix arrays
11, Oct 21
Modify given array by reducing each element by its next smaller element
02, Dec 20
Minimum index i such that all the elements from index i to given index are equal
11, Feb 19
Count sequences of length K having each term divisible by its preceding term
30, Jun 20
Rearrange given array such that no array element is same as its index
02, Dec 20
Count of sequence of length K in range [1, N] where every element is a multiple of its previous one
30, Nov 21
Count of contiguous subarrays possible for every index by including the element at that index
08, May 20
Count array elements having at least one smaller element on its left and right side
09, Nov 20
Find the array element having equal count of Prime Numbers on its left and right
10, May 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Ripunjoy Medhi
@Ripunjoy Medhi
Vote for difficulty
Current difficulty :
Expert





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!