Check if an Array is made up of Subarrays of continuous repetitions of every distinct element

• Difficulty Level : Medium
• Last Updated : 26 Mar, 2021

Given an array arr[], consisting of N integers, the task is to check whether the entire array is only made up of subarrays such that each subarray consists of consecutive repetitions of a single element and every distinct element in the array is part of such subarray.

Examples:

Input: N = 10, arr[] = {1, 1, 1, 1, 2, 2, 3, 3, 3, 3}
Output: Yes
Explanation:
The given array consists of 3 distinct elements {1, 2, 3} and subarrays {1, 1, 1, 1}, {2, 2}, {3, 3, 3, 3}.
Therefore, the given array satisfies the conditions.

Input: N = 10, arr[] = {1, 1, 1, 2, 2, 2, 2, 1, 3, 3}
Output: No
Explanation:
The given array consists of 3 distinct elements {1, 2, 3} and subarrays {1, 1, 1}, {2, 2, 2, 2}, {1}, {3, 3}.
Since the subarray {1} does not contain any repetition, the given array does not satisfy the conditions.

Approach:
Follow the steps below to solve the problem:

• Initialize a variable curr = 0 to store the size of every subarray of a single repeating element is encountered.
• If any such index is found where arr[i] ≠ arr[i – 1], check if curr is greater than 1 or not. If so, reset curr to 0 and continue. Otherwise, print “No” as a subarray exists of a single element without repetition.
• Otherwise, increase curr.
• After traversing the array, check if curr is greater than 1 or not. If curr is equal to 1, this ensures that the last element is different from the second last element. Therefore, print “No”.
• Otherwise, print “Yes”.

Below is the implementation of the above approach:

C++

 // C++ Program to implement// the above problem#include using namespace std; // Function to check if the// array is made up of// subarrays of repetitionsbool ContinuousElements(int a[],                        int n){     // Base Case    if (n == 1)        return false;     // Stores the size of    // current subarray    int curr = 1;    for (int i = 1; i < n; i++) {         // If a different element        // is encountered        if (a[i] != a[i - 1]) {             // If the previous subarray            // was a single element            if (curr == 1)                return false;             // Reset to new subarray            else                curr = 0;        }         // Increase size of subarray        curr++;    }     // If last element differed from    // the second last element    if (curr == 1)        return false;     return true;} // Driver codeint main(){    int a[] = { 1, 1, 2, 2, 1, 3, 3 };    int n = sizeof(a)            / sizeof(a);     if (ContinuousElements(a, n))        cout << "Yes" << endl;    else        cout << "No" << endl;     return 0;}

Java

 // Java Program to implement// the above approachclass GFG{  // Function to check if the// array is made up of// subarrays of repetitionsstatic boolean ContinuousElements(int a[],                                  int n){      // Base Case    if (n == 1)        return false;      // Stores the size of    // current subarray    int curr = 1;    for (int i = 1; i < n; i++)    {          // If a different element        // is encountered        if (a[i] != a[i - 1])        {              // If the previous subarray            // was a single element            if (curr == 1)                return false;              // Reset to new subarray            else                curr = 0;        }          // Increase size of subarray        curr++;    }      // If last element differed from    // the second last element    if (curr == 1)        return false;      return true;}  // Driver codepublic static void main(String[] args){    int a[] = { 1, 1, 2, 2, 1, 3, 3 };    int n = a.length;      if (ContinuousElements(a, n))        System.out.println("Yes");    else        System.out.println("No");}} // This code is contributed by rock_cool

Python3

 # Python3 program to implement# the above problem # Function to check if the# array is made up of# subarrays of repetitionsdef ContinuousElements(a, n):   # Base Case  if (n == 1):    return False   # Stores the size of  # current subarray  curr = 1  for i in range (1, n):     # If a different element    # is encountered    if (a[i] != a[i - 1]):       # If the previous subarray      # was a single element      if (curr == 1):        return False       # Reset to new subarray      else:        curr = 0         # Increase size of subarray        curr += 1         # If last element differed from        # the second last element        if (curr == 1):          return False         return True # Driver codeif __name__ == "__main__":      a = [1, 1, 2, 2, 1, 3, 3]    n = len(a)     if (ContinuousElements(a, n)):          print ("Yes")    else:          print ("No") # This code is contributed by Chitranayal

C#

 // C# program to implement// the above approachusing System; class GFG{ // Function to check if the// array is made up of// subarrays of repetitionsstatic Boolean ContinuousElements(int []a,                                  int n){     // Base Case    if (n == 1)        return false;     // Stores the size of    // current subarray    int curr = 1;    for(int i = 1; i < n; i++)    {         // If a different element        // is encountered        if (a[i] != a[i - 1])        {             // If the previous subarray            // was a single element            if (curr == 1)                return false;             // Reset to new subarray            else                curr = 0;        }         // Increase size of subarray        curr++;    }     // If last element differed from    // the second last element    if (curr == 1)        return false;     return true;} // Driver codepublic static void Main(String[] args){    int []a = { 1, 1, 2, 2, 1, 3, 3 };    int n = a.Length;     if (ContinuousElements(a, n))        Console.WriteLine("Yes");    else        Console.WriteLine("No");}} // This code is contributed by shivanisinghss2110

Javascript


Output:
No

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

My Personal Notes arrow_drop_up