Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Count of all possible Arrays such that each array element can be over the range [1, arr[i]]

  • Difficulty Level : Medium
  • Last Updated : 14 Sep, 2021

Given an array arr[] consisting of N positive integers, the task is to find the number of all possible arrays such that each array element can be over the range [1, arr[i]] all elements in the newly constructed array must be pairwise distinct.

Examples:

Input: arr[] = {5}
Output: 5
Explanation:
All possible arrays that can be formed using the given criteria is {1}, {2}, {3}, {4}, {5}. Therefore, the count of such array is 5.

Input: arr[] = {4, 4, 4, 4}
Output: 24

Approach: The given problem can be solved based on the observation that the order of array elements arr[] doesn’t matter which generating the arrays using the new criteria. Below is the illustration for the same:



Illustration:

Consider the array arr[] = {1, 2}, every possible array formed satisfying the given criteria is {1, 2}.

Now, if the order of element of arr[] is changed, say {2, 1}, then every possible array formed satisfying the given criteria is {2, 1}.

Follow the steps below to solve the given problem:

  • Sort the array arr[] in non-decreasing order.
  • Initialize a variable, say res as 1 that stores the count of all possible arrays formed.
  • Traverse the given array arr[] and for each array element arr[i] perform the following steps:
    • The count of all possible choices to insert a new array element at index i is arr[i], but to make the array pairwise distinct, all previously selected numbers can’t be selected again. So, the total number of available choices is (arr[i] – i).
    • Now, the total number of combinations possible till the index i is given by res*(arr[i] – i). Therefore, update the value of res as res*(arr[i] – i).
  • After completing the above steps, print the value of res as the resultant possible count of arrays formed.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the total number of
// arrays of pairwise distinct element
// and each element lies in [1, arr[i]]
int findArraysInRange(int arr[], int N)
{
    // Stores all possible arrays formed
    int res = 1;
 
    // Sort the array arr[] in the
    // non-decreasing order
    sort(arr, arr + N);
 
    for (int i = 0; i < N; i++) {
 
        // Total combinations for the
        // current index i
        int combinations = (arr[i] - i);
 
        // Update the value of res
        res *= combinations;
    }
 
    // Return the possible count
    return res;
}
 
// Driver Code
int main()
{
    int arr[] = { 4, 4, 4, 4 };
    int N = sizeof(arr) / sizeof(arr[0]);
    cout << findArraysInRange(arr, N);
 
    return 0;
}

Java




// Java program for the above approach
import java.util.*;
 
class GFG {
 
    // Function to find the total number of
    // arrays of pairwise distinct element
    // and each element lies in [1, arr[i]]
    static int findArraysInRange(int[] arr, int N)
    {
       
        // Stores all possible arrays formed
        int res = 1;
 
        // Sort the array arr[] in the
        // non-decreasing order
        Arrays.sort(arr);
 
        for (int i = 0; i < N; i++) {
 
            // Total combinations for the
            // current index i
            int combinations = (arr[i] - i);
 
            // Update the value of res
            res *= combinations;
        }
 
        // Return the possible count
        return res;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int[] arr = { 4, 4, 4, 4 };
        int N = arr.length;
        System.out.print(findArraysInRange(arr, N));
    }
}
 
// This code is contributed by subhammahato348.

Python3




# Python program for the above approach
 
# Function to find the total number of
# arrays of pairwise distinct element
# and each element lies in [1, arr[i]]
def findArraysInRange(arr, n):
   
    # Sort the array
    arr.sort()
 
    # res Stores all possible arrays formed
    res = 1
    i = 0
 
    # Sort the array arr[] in the
    # non-decreasing order
    arr.sort()
 
    for i in range(0, n):
 
        # Total combinations for the
        # current index i
        combinations = (arr[i] - i)
 
        # Update the value of res
        res = res*combinations
 
    # Return the possible count
    return res
 
# Driver Code
arr = [4, 4, 4, 4]
N = len(arr)
print(findArraysInRange(arr, N))
 
# This code is contributed by _saurabh_jaiswal

C#




// C# program for the approach
using System;
using System.Collections.Generic;
 
class GFG {
 
    // Function to find the total number of
    // arrays of pairwise distinct element
    // and each element lies in [1, arr[i]]
    static int findArraysInRange(int[] arr, int N)
    {
        
        // Stores all possible arrays formed
        int res = 1;
  
        // Sort the array arr[] in the
        // non-decreasing order
        Array.Sort(arr);
  
        for (int i = 0; i < N; i++) {
  
            // Total combinations for the
            // current index i
            int combinations = (arr[i] - i);
  
            // Update the value of res
            res *= combinations;
        }
  
        // Return the possible count
        return res;
    }
 
    // Driver Code
    public static void Main()
    {
        int[] arr = { 4, 4, 4, 4 };
        int N = arr.Length;
        Console.Write(findArraysInRange(arr, N));
    }
}
 
// This code is contributed by sanjoy_62.

Javascript




<script>
// Javascript program for the above approach
 
// Function to find the total number of
// arrays of pairwise distinct element
// and each element lies in [1, arr[i]]
function findArraysInRange(arr, n, k) {
// Sort the array
arr.sort((a, b) => a - b);
 
// res Stores all possible arrays formed
let res= 1,i=0,combinations;
 
 
// Sort the array arr[] in the
    // non-decreasing order
   arr.sort((a, b) => a - b);
   
    for (i = 0; i < N; i++) {
   
        // Total combinations for the
        // current index i
         combinations = (arr[i] - i);
   
        // Update the value of res
        res = res*combinations;
    }
   
    // Return the possible count
 
return res;
}
 
// Driver Code
 
let arr = [4,4,4,4];
let N = arr.length;
document.write(findArraysInRange(arr, N));
 
// This code is contributed by dwivediyash
</script>
Output: 
24

 

Time Complexity: O(N*log N)
Auxiliary Space: O(1)




My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!