# Construction of multiple AP Arrays

Last Updated : 19 Oct, 2023

Given an array A[] of N integers, the task is to check if it is possible to construct several arrays (at least one) using all the elements of the array A[] such that in each array, the value of each element is equal to the number of elements to its left.

Examples:

Input: N = 9, A[] = {0, 0, 0, 0, 1, 1, 1, 2, 2}
Output: YES
Explanation: The array A[] can be divided into 4 arrays as follows –

• {0,1,2} -> 1st element (0) has 0 elements to its left, 2nd element (1) has 1 element to its left and 3rd element (2) has 2 elements to its left
• {0,1} -> 1st element (0) has 0 elements to its left and 2nd element (1) has 1 element to its left
• {0,1,2} -> 1st element (0) has 0 elements to its left, 2nd element (1) has 1 element to its left and 3rd element (2) has 2 elements to its left
• {0} -> 1st element (0) has 0 elements to its left

Input: N = 3, A[] = {0, 0, 2}
Output: NO

Approach: To solve the problem follow the below observations:

Observation:

• The problem can be rephrased as ” Is it possible to divide input array in Arithmetic Progressions each having the first digit 0 and a common difference equal to 1 “?
• For each A.P., if an integer X is a part of it, then X-1 must also be there. So, in the whole sequence if X occurs “count” times, then X-1 must also occur at least count times.

Following is the code based on the above approach:

## C++

 `// C++ code for the above approach` `#include ` `using` `namespace` `std;`   `// Function to Check if it is possible ` `// to construct several number` `// of arrays from the given array` `// satisfying the given condition` `bool` `isPossible(``int` `N, ``int` `A[])` `{`   `    ``// Initialize flag variable to` `    ``// store the answer` `    ``bool` `flag = ``true``;`   `    ``// Initializing an unordered_map to` `    ``// store frequency of each element` `    ``unordered_map<``int``, ``int``> mp;`   `    ``// Iterating through the array` `    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// If the current element is less` `        ``// than N, increment` `        ``// its frequency in map` `        ``if` `(A[i] < N) {` `            ``mp[A[i]]++;` `        ``}`   `        ``// Else, make the value of flag = false` `        ``// (as there can never be more than` `        ``// N elements before any` `        ``// element in the array)` `        ``else` `{` `            ``flag = ``false``;` `        ``}` `    ``}`   `    ``// Iterate from 1 to N and check the` `    ``// required condition` `    ``for` `(``int` `i = 1; i <= N; i++) {` `        ``if` `(mp[i] > mp[i - 1]) {` `            ``flag = ``false``;` `            ``break``;` `        ``}` `    ``}`   `    ``return` `flag;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `N = 9;` `    ``int` `A[] = { 0, 0, 0, 0, 1, 1, 1, 2, 2 };`   `    ``// Function Call` `    ``int` `answer = isPossible(N, A);` `    ``if` `(answer == 1) {` `        ``cout << "YES";` `    ``}` `    ``else` `{` `        ``cout << "NO";` `    ``}` `}`

## Java

 `import` `java.util.HashMap;`   `public` `class` `GFG {`   `    ``// Function to Check if it is possible` `    ``// to construct several number` `    ``// of arrays from the given array` `    ``static` `boolean` `isPossible(``int` `N, ``int``[] A) {`   `        ``// Initialize flag variable to` `        ``// store the answer` `        ``boolean` `flag = ``true``;`   `        ``// Initializing a HashMap to` `        ``// store frequency of each element` `        ``HashMap map = ``new` `HashMap<>();`   `        ``// Iterating through the array` `        ``for` `(``int` `i = ``0``; i < N; i++) {` `            ``// If the current element is less` `            ``// than N, increment` `            ``// its frequency in the map` `            ``if` `(A[i] < N) {` `                ``map.put(A[i], map.getOrDefault(A[i], ``0``) + ``1``);` `            ``}`   `            ``// Else, make the value of flag = false` `            ``// (as there can never be more than` `            ``// N elements before any` `            ``// element in the array)` `            ``else` `{` `                ``flag = ``false``;` `            ``}` `        ``}`   `        ``// Iterate from 1 to N and check the` `        ``// required condition` `        ``for` `(``int` `i = ``1``; i <= N; i++) {` `            ``if` `(map.getOrDefault(i, ``0``) > map.getOrDefault(i - ``1``, ``0``)) {` `                ``flag = ``false``;` `                ``break``;` `            ``}` `        ``}`   `        ``return` `flag;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args) {` `        ``int` `N = ``9``;` `        ``int``[] A = { ``0``, ``0``, ``0``, ``0``, ``1``, ``1``, ``1``, ``2``, ``2` `};`   `        ``// Function Call` `        ``boolean` `answer = isPossible(N, A);` `        ``if` `(answer) {` `            ``System.out.println(``"YES"``);` `        ``} ``else` `{` `            ``System.out.println(``"NO"``);` `        ``}` `    ``}` `}`

## Python3

 `# Python code for the above approach`   `# Function to Check if it is possible` `# to construct several number` `# of arrays from the given array` `# satisfying the given condition` `def` `isPossible(N, A):` `    ``# Initialize flag variable to` `    ``# store the answer` `    ``flag ``=` `True`   `    ``# Initializing a dictionary to` `    ``# store frequency of each element` `    ``mp ``=` `{}`   `    ``# Iterating through the array` `    ``for` `i ``in` `range``(N):` `        ``# If the current element is less` `        ``# than N, increment` `        ``# its frequency in the dictionary` `        ``if` `A[i] < N:` `            ``if` `A[i] ``in` `mp:` `                ``mp[A[i]] ``+``=` `1` `            ``else``:` `                ``mp[A[i]] ``=` `1` `        ``# Else, make the value of flag = false` `        ``# (as there can never be more than` `        ``# N elements before any` `        ``# element in the array)` `        ``else``:` `            ``flag ``=` `False`   `    ``# Iterate from 1 to N and check the` `    ``# required condition` `    ``for` `i ``in` `range``(``1``, N ``+` `1``):` `        ``if` `i ``in` `mp ``and` `mp[i] > mp.get(i ``-` `1``, ``0``):` `            ``flag ``=` `False` `            ``break`   `    ``return` `flag`   `# Driver code` `N ``=` `9` `A ``=` `[``0``, ``0``, ``0``, ``0``, ``1``, ``1``, ``1``, ``2``, ``2``]`   `# Function Call` `answer ``=` `isPossible(N, A)` `if` `answer:` `    ``print``(``"YES"``)` `else``:` `    ``print``(``"NO"``)` `    `  `# this code is contributed by uttamdp_10`

## C#

 `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG {` `    ``// Function to Check if it is possible` `    ``// to construct several number` `    ``// of arrays from the given array` `    ``static` `bool` `IsPossible(``int` `N, ``int``[] A)` `    ``{` `        ``// Initialize flag variable to` `        ``// store the answer` `        ``bool` `flag = ``true``;`   `        ``// Initializing a Dictionary to` `        ``// store frequency of each element` `        ``Dictionary<``int``, ``int``> map` `            ``= ``new` `Dictionary<``int``, ``int``>();`   `        ``// Iterating through the array` `        ``for` `(``int` `i = 0; i < N; i++) {` `            ``// If the current element is less` `            ``// than N, increment` `            ``// its frequency in the dictionary` `            ``if` `(A[i] < N) {` `                ``if` `(map.ContainsKey(A[i])) {` `                    ``map[A[i]]++;` `                ``}` `                ``else` `{` `                    ``map[A[i]] = 1;` `                ``}` `            ``}`   `            ``// Else, make the value of flag = false` `            ``// (as there can never be more than` `            ``// N elements before any` `            ``// element in the array)` `            ``else` `{` `                ``flag = ``false``;` `            ``}` `        ``}`   `        ``// Iterate from 1 to N and check the` `        ``// required condition` `        ``for` `(``int` `i = 1; i <= N; i++) {` `            ``if` `(map.TryGetValue(i, ``out` `int` `countI)` `                ``&& map.TryGetValue(i - 1,` `                                   ``out` `int` `countPrev)) {` `                ``if` `(countI > countPrev) {` `                    ``flag = ``false``;` `                    ``break``;` `                ``}` `            ``}` `        ``}`   `        ``return` `flag;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main(``string``[] args)` `    ``{` `        ``int` `N = 9;` `        ``int``[] A = { 0, 0, 0, 0, 1, 1, 1, 2, 2 };`   `        ``// Function Call` `        ``bool` `answer = IsPossible(N, A);` `        ``if` `(answer) {` `            ``Console.WriteLine(``"YES"``);` `        ``}` `        ``else` `{` `            ``Console.WriteLine(``"NO"``);` `        ``}` `    ``}` `}`

## Javascript

 `// Added by: Nikunj Sonigara`   `// Function to check if it's possible to create an array of length N` `// with values ranging from 0 to N-1 using the input array A.` `function` `isPossible(N, A) {` `    ``// Initialize a flag as true to assume it's possible.` `    ``let flag = ``true``; ` `    ``// Create a Map to store counts of each element.` `    ``const map = ``new` `Map(); `   `    ``// Loop through the input array A.` `    ``for` `(let i = 0; i < N; i++) {` `        ``if` `(A[i] < N) {` `            ``// Update the count of A[i] in the map.` `            ``map.set(A[i], (map.get(A[i]) || 0) + 1); ` `        ``} ``else` `{` `            ``// If any element in A is greater than or equal to N, set flag to false.` `            ``flag = ``false``; ` `        ``}` `    ``}`   `    ``// Loop through numbers from 1 to N and check if their counts are non-decreasing.` `    ``for` `(let i = 1; i <= N; i++) {` `        ``if` `((map.get(i) || 0) > (map.get(i - 1) || 0)) {` `            ``// If counts are not non-decreasing, set flag to false.` `            ``flag = ``false``; ` `            ``// Exit the loop.` `            ``break``; ` `        ``}` `    ``}` `    ``// Return the final flag indicating if it's possible.` `    ``return` `flag; ` `}`   `// Test input values` `const N = 9;` `const A = [0, 0, 0, 0, 1, 1, 1, 2, 2];`   `// Call the isPossible function with the test input and print "YES" or "NO" accordingly.` `const answer = isPossible(N, A);` `if` `(answer) {` `    ``console.log(``"YES"``);` `} ``else` `{` `    ``console.log(``"NO"``);` `}`

Output

```YES

```

Time Complexity: O(N).
Auxiliary Space: O(N)

Article Tags :
Practice Tags :