Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Split an array into equal length subsequences consisting of equal elements only

  • Last Updated : 14 May, 2021

Given an array arr[] of size N, the task is to check if it is possible to split the array arr[] into different subsequences of equal size such that each element of the subsequence are equal. If found to be true, then print “YES”. Otherwise, print “NO”.

Examples:

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: arr[] = {1, 2, 3, 4, 4, 3, 2, 1}
Output: YES
Explanation: Possible partition: {1, 1}, {2, 2}, {3, 3}, {4, 4}.



Input: arr[] = {1, 1, 1, 2, 2, 2, 3, 3}
Output: NO

Approach: The idea is based on the following observation: Let the frequency of arr[i] be Ci, then these elements must be broken down into subsequences of X such that Ci % X = 0. This must be YES for every index i. To satisfy this, the value of X should be equal to the greatest common divisor(GCD) of all Ci (1≤i≤N). If X is greater than 1, then print YES otherwise print NO.

Follow the steps below to solve the problem:

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 GCD
// of two numbers a and b
int gcd(int a, int b)
{
    if (b == 0)
        return a;
    return gcd(b, a % b);
}
 
// Function to check if it is possible to
// split the array into equal length subsequences
// such that all elements in the subsequence are equal
void splitArray(int arr[], int N)
{
 
    // Store frequencies of
    // array elements
    map<int, int> mp;
 
    // Traverse the array
    for (int i = 0; i < N; i++) {
 
        // Update frequency of arr[i]
        mp[arr[i]]++;
    }
 
    // Store the GCD of frequencies
    // of all array elements
    int G = 0;
 
    // Traverse the map
    for (auto i : mp) {
 
        // Update GCD
        G = gcd(G, i.second);
    }
 
    // If the GCD is greater than 1,
    // print YES otherwise print NO
    if (G > 1)
        cout << "YES";
    else
        cout << "NO";
}
 
// Driver Code
int main()
{
 
    // Given array
    int arr[] = { 1, 2, 3, 4, 4, 3, 2, 1 };
 
    // Store the size of the array
    int n = sizeof(arr) / sizeof(arr[0]);
 
    splitArray(arr, n);
 
    return 0;
}
Java



// Java program for the above approach
import java.io.*;
import java.lang.*;
import java.util.*;
 
class GFG
{
 
    // Function to find the GCD
    // of two numbers a and b
    int gcd(int a, int b)
    {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }
 
    // Function to check if it is possible to
    // split the array into equal length subsequences
    // such that all elements in the subsequence are equal
    void splitArray(int arr[], int N)
    {
 
        // Store frequencies of
        // array elements
        TreeMap<Integer, Integer> mp
            = new TreeMap<Integer, Integer>();
 
        // Traverse the array
        for (int i = 0; i < N; i++)
        {
 
            // Update frequency of arr[i]
            if (mp.containsKey(arr[i]))
            {
                mp.put(arr[i], mp.get(arr[i]) + 1);
            }
            else
            {
                mp.put(arr[i], 1);
            }
        }
 
        // Store the GCD of frequencies
        // of all array elements
        int G = 0;
 
        // Traverse the map
        for (Map.Entry<Integer, Integer> m :
             mp.entrySet())
        {
           
            // update gcd
            Integer i = m.getValue();
            G = gcd(G, i.intValue());
        }
 
        // If the GCD is greater than 1,
        // print YES otherwise print NO
        if (G > 1)
            System.out.print("YES");
        else
            System.out.print("NO");
    }
 
    // Driver Code
    public static void main(String[] args)
    {
 
        // Given array
        int[] arr = new int[] { 1, 2, 3, 4, 4, 3, 2, 1 };
 
        // Store the size of the array
        int n = arr.length;
        new GFG().splitArray(arr, n);
    }
}
 
// This code is contributed by abhishekgiri1
Python3



# Python3 program for the above approach
from collections import defaultdict
 
# Function to find the GCD
# of two numbers a and b
def gcd(a, b):
     
    if (b == 0):
        return a
         
    return gcd(b, a % b)
 
# Function to check if it is possible
# to split the array into equal length
# subsequences such that all elements
# in the subsequence are equal
def splitArray(arr, N):
     
    # Store frequencies of
    # array elements
    mp = defaultdict(int)
     
    # Traverse the array
    for i in range(N):
         
        # Update frequency of arr[i]
        mp[arr[i]] += 1
 
    # Store the GCD of frequencies
    # of all array elements
    G = 0
 
    # Traverse the map
    for i in mp:
 
        # Update GCD
        G = gcd(G, mp[i])
 
    # If the GCD is greater than 1,
    # print YES otherwise print NO
    if (G > 1):
        print("YES")
    else:
        print("NO")
 
# Driver Code
if __name__ == "__main__":
     
    # Given array
    arr = [ 1, 2, 3, 4, 4, 3, 2, 1 ]
 
    # Store the size of the array
    n = len(arr)
 
    splitArray(arr, n)
 
# This code is contributed by chitranayal
C#



// C# program for the above approach
using System;
using System.Collections.Generic;
using System.Linq;
class GFG{
     
// Function to find the GCD
// of two numbers a and b
static int gcd(int a, int b)
{
    if (b == 0)
        return a;
    return gcd(b, a % b);
}
 
// Function to check if it is possible to
// split the array into equal length subsequences
// such that all elements in the subsequence are equal
static void splitArray(int[] arr, int n)
{
 
    // Store frequencies of
    // array elements
    Dictionary<int,
             int> mp = new Dictionary<int,
                                      int>();
 
    // Traverse the array
    for(int i = 0; i < n; ++i)
    {
           
        // Update frequency of
        // each array element
        if (mp.ContainsKey(arr[i]) == true)
        mp[arr[i]] += 1;
      else
        mp[arr[i]] = 1;
    }
 
    // Store the GCD of frequencies
    // of all array elements
    int G = 0;
 
    // Traverse the map
    foreach (KeyValuePair<int, int> i in mp)
    {
 
        // Update GCD
        G = gcd(G, i.Value);
    }
 
    // If the GCD is greater than 1,
    // print YES otherwise print NO
    if (G > 1)
        Console.Write("YES");
    else
        Console.Write("NO");
}
 
// Driver Code
public static void Main()
{
   
    // Given array
    int[] arr = { 1, 2, 3, 4, 4, 3, 2, 1 };
 
    // Store the size of the array
    int n = arr.Length;
    splitArray(arr, n);
}
}
 
// This code is contributed by sanjoy_62.
Javascript



<script>
 
// Javascript program for the above approach
 
// Function to find the GCD
// of two numbers a and b
function gcd(a, b)
{
    if (b == 0)
        return a;
         
    return gcd(b, a % b);
}
 
// Function to check if it is
// possible to split the array
// into equal length subsequences
// such that all elements in the
// subsequence are equal
function splitArray(arr, N)
{
     
    // Store frequencies of
    // array elements
    var mp = new Map();
 
    // Traverse the array
    for(var i = 0; i < N; i++)
    {
         
        // Update frequency of arr[i]
        if (mp.has(arr[i]))
        {
            mp.set(arr[i], mp.get(arr[i]) + 1);
        }
        else
        {
            mp.set(arr[i], 1);
        }
    }
 
    // Store the GCD of frequencies
    // of all array elements
    var G = 0;
 
    // Traverse the map
    mp.forEach((value, key) => {
         
        // Update GCD
        G = gcd(G, value);
    });
 
    // If the GCD is greater than 1,
    // print YES otherwise print NO
    if (G > 1)
        document.write("YES");
    else
        document.write("NO");
}
 
// Driver Code
 
// Given array
var arr = [ 1, 2, 3, 4, 4, 3, 2, 1 ];
 
// Store the size of the array
var n = arr.length;
splitArray(arr, n);
 
// This code is contributed by rutvik_56
 
</script>
Output: 
YES
 
Time Complexity: O(N * log(N))
Auxiliary Space: O(N)



My Personal Notes
arrow_drop_up
Previous
Search for an element in a Mountain Array
Next

Split an array into minimum number of non-increasing or non-decreasing subarrays
Recommended Articles
Page :
Minimum length of a rod that can be split into N equal parts that can further be split into given number of equal parts
16, May 21
Make all array elements equal to 0 by replacing minimum subsequences consisting of equal elements
13, Jan 21
Check if an array can be split into K consecutive non-overlapping subarrays of length M consisting of single distinct element
12, Feb 21
Check if given String can be split only into subsequences ABC
06, Jul 21
Count subarrays consisting of only 0's and only 1's in a binary array
14, Nov 18
Split array into two subsequences having minimum count of pairs with sum equal to X
09, Oct 20
Check if an array can be split into 3 subsequences of equal sum or not
27, Aug 20
Largest element in the longest Subarray consisting of only Even or only Odd numbers
09, Dec 20
Check if a Binary String can be split into disjoint subsequences which are equal to "010"
11, Jun 21
Partition array into minimum number of equal length subsets consisting of a single distinct value
23, Nov 20
Split an Array A[] into Subsets having equal Sum and sizes equal to elements of Array B[]
21, Aug 20
Query to find length of the longest subarray consisting only of 1s
06, Jan 21
Length of longest subarray consisting only of 1s
22, Feb 21
Count N-length strings consisting only of vowels sorted lexicographically
09, Nov 20
Length of the longest substring consisting only of vowels in non-increasing order
31, May 21
Split first N natural numbers into two subsequences with non-coprime sums
22, Dec 20
Split array into equal length subsets with maximum sum of Kth largest element of each subset
02, Dec 20
Split array into two equal length subsets such that all repetitions of a number lies in a single subset
28, Sep 20
Print indices of pair of array elements required to be removed to split array into 3 equal sum subarrays
22, Feb 21
Subsequences of given string consisting of non-repeating characters
02, Dec 20
Count of subsequences consisting of the same element
21, Jul 20
Split an array containing N elements into K sets of distinct elements
31, May 20
Maximum sum of K-length subarray consisting of same number of distinct elements as the given array
02, Mar 21
Split array into maximum possible subsets having product of their length with the maximum element at least K
30, Jul 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
18bhupenderyadav18
@18bhupenderyadav18
Vote for difficulty





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