 GFG App
Open App Browser
Continue

# Count of distinct alternate triplets of indices from given Array | Set 2

Given a binary array arr[] of size N, the task is to find the count of distinct alternating triplets.

Note: A triplet is alternating if the values of those indices are in {0, 1, 0} or {1, 0, 1} form.

Examples:

Input: arr[] = {0, 0, 1, 1, 0, 1}
Output: 6
Explanation: Here four sequence of “010” and two sequence of “101” exist.
So, the total number of ways of alternating sequence of size 3 is 6.

Input: arr[] = {0, 0, 0, 0, 0}
Output: 0
Explanation: As there are no 1s in the array so we cannot find any 3 size alternating sequence.

Naive Approach: The naive approach and the approach based on dynamic programming is mentioned in the Set 1 of this article.

Efficient Approach: This problem can be solved efficiently using prefix sum based on the following idea:

• The possible groups that can be formed are {0, 1, 0} or {1, 0, 1}
• So for any 1 encountered in the array the total possible combinations can be calculated by finding the number of ways to select one 0 from its left and one 0 from its right. This value is same as the product of number of 0s to its left and the number of 0s to its right.
• For a 0, the number of possible triplets can be found in the same way.
• The final answer is the sum of these two values.

Follow the below steps to solve the problem:

• Traverse the array starting from the left and count the number of 0s in (say count1) and the total number of 1s (say count2).
• Then, initialize the left_count of both the numbers as 0.
• Traverse the array from i = 0 to N:
• Now, lets suppose 1 is encountered, so first calculate the combinations of {0, 1, 0} possible using this 1. For this, multiply left_count_Zero and count1 and add the result to our final answer.
• Add this value with the sum.
• Now, decrement the count2 as for the next element it appears in left and thus, increment the left_count_One
• Similarly, do the same when 0 is encountered.
• Return the final sum.

Below is the implementation for the above approach:

## C++

 `// C++ code for the above approach:`   `#include ` `using` `namespace` `std;`   `// Function to calculate the possible` `// number of ways to select 3 numbers` `long` `long` `numberOfWays(``int` `A[], ``int` `N)` `{` `    ``int` `left_count_Zero = 0, count1 = 0;` `    ``int` `left_count_One = 0, count2 = 0;` `    ``long` `long` `ans = 0;`   `    ``// Storing the right counts of` `    ``// 1s and 2s in the array` `    ``for` `(``int` `i = 0; i < N; i++) {` `        ``if` `(A[i] == 1)` `            ``count2++;` `        ``else` `            ``count1++;` `    ``}`   `    ``// Traversing the array from left side` `    ``for` `(``int` `i = 0; i < N; i++) {`   `        ``// If 1 is encountered,` `        ``// looking for all combinations of` `        ``// 0, 1, 0 possible` `        ``if` `(A[i] == 1) {`   `            ``// Number of ways to select one` `            ``// 0 from left side * Number of` `            ``// ways to select one 0 from right` `            ``ans += (left_count_Zero * count1);`   `            ``// Decrement right_count of 1` `            ``// and increment left_count of 1` `            ``left_count_One++;` `            ``count2--;` `        ``}`   `        ``// If 0 is encountered,` `        ``// looking for all combinations` `        ``// of 1, 0, 1 possible` `        ``else` `{`   `            ``// Number of ways to select` `            ``// one 1 from left side` `            ``// * Number of ways to select a 1` `            ``// from right` `            ``ans += (left_count_One * count2);`   `            ``// Decrement right_count of 2` `            ``// and increment left_count of 2` `            ``left_count_Zero++;` `            ``count1--;` `        ``}` `    ``}` `    ``return` `ans;` `}`   `// Drivers code` `int` `main()` `{` `    ``int` `arr[] = { 0, 0, 1, 1, 0, 1 };` `    ``int` `N = 6;`   `    ``// Function call` `    ``cout << numberOfWays(arr, N);` `    ``return` `0;` `}`

## Java

 `// Java code for the above approach` `import` `java.io.*;`   `class` `GFG ` `{`   `  ``// Function to calculate the possible` `  ``// number of ways to select 3 numbers` `  ``public` `static` `long` `numberOfWays(``int` `A[], ``int` `N)` `  ``{` `    ``int` `left_count_Zero = ``0``, count1 = ``0``;` `    ``int` `left_count_One = ``0``, count2 = ``0``;` `    ``long` `ans = ``0``;`   `    ``// Storing the right counts of` `    ``// 1s and 2s in the array` `    ``for` `(``int` `i = ``0``; i < N; i++) {` `      ``if` `(A[i] == ``1``)` `        ``count2++;` `      ``else` `        ``count1++;` `    ``}`   `    ``// Traversing the array from left side` `    ``for` `(``int` `i = ``0``; i < N; i++) {`   `      ``// If 1 is encountered,` `      ``// looking for all combinations of` `      ``// 0, 1, 0 possible` `      ``if` `(A[i] == ``1``) {`   `        ``// Number of ways to select one` `        ``// 0 from left side * Number of` `        ``// ways to select one 0 from right` `        ``ans += (left_count_Zero * count1);`   `        ``// Decrement right_count of 1` `        ``// and increment left_count of 1` `        ``left_count_One++;` `        ``count2--;` `      ``}`   `      ``// If 0 is encountered,` `      ``// looking for all combinations` `      ``// of 1, 0, 1 possible` `      ``else` `{`   `        ``// Number of ways to select` `        ``// one 1 from left side` `        ``// * Number of ways to select a 1` `        ``// from right` `        ``ans += (left_count_One * count2);`   `        ``// Decrement right_count of 2` `        ``// and increment left_count of 2` `        ``left_count_Zero++;` `        ``count1--;` `      ``}` `    ``}` `    ``return` `ans;` `  ``}`   `  ``public` `static` `void` `main(String[] args)` `  ``{` `    ``int` `arr[] = { ``0``, ``0``, ``1``, ``1``, ``0``, ``1` `};` `    ``int` `N = ``6``;`   `    ``// Function call` `    ``System.out.print(numberOfWays(arr, N));` `  ``}` `}`   `// This code is contributed by Rohit Pradhan`

## Python3

 `# Python code for the above approach:`   `# Function to calculate the possible` `# number of ways to select 3 numbers` `def` `numberOfWays(A, N):` `    ``left_count_Zero,count1,left_count_One,count2 ``=` `0``,``0``,``0``,``0` `    ``ans ``=` `0`   `    ``# Storing the right counts of` `    ``# 1s and 2s in the array` `    ``for` `i ``in` `range``(N):` `        ``if` `(A[i] ``=``=` `1``):` `            ``count2 ``+``=` `1` `        ``else``:` `            ``count1 ``+``=` `1`   `    ``# Traversing the array from left side` `    ``for` `i ``in` `range``(N):`   `        ``# If 1 is encountered,` `        ``# looking for all combinations of` `        ``# 0, 1, 0 possible` `        ``if` `(A[i] ``=``=` `1``):`   `            ``# Number of ways to select one` `            ``# 0 from left side * Number of` `            ``# ways to select one 0 from right` `            ``ans ``+``=` `(left_count_Zero ``*` `count1)`   `            ``# Decrement right_count of 1` `            ``# and increment left_count of 1` `            ``left_count_One ``+``=` `1` `            ``count2 ``-``=` `1`   `        ``# If 0 is encountered,` `        ``# looking for all combinations` `        ``# of 1, 0, 1 possible` `        ``else``:`   `            ``# Number of ways to select` `            ``# one 1 from left side` `            ``# * Number of ways to select a 1` `            ``# from right` `            ``ans ``+``=` `(left_count_One ``*` `count2)`   `            ``# Decrement right_count of 2` `            ``# and increment left_count of 2` `            ``left_count_Zero ``+``=` `1` `            ``count1 ``-``=` `1`   `    ``return` `ans`   `# Drivers code` `arr ``=` `[``0``, ``0``, ``1``, ``1``, ``0``, ``1``]` `N ``=` `6`   `# Function call` `print``(numberOfWays(arr, N))`   `# This code is contributed by shinjanpatra`

## C#

 `// C# code for the above approach` `using` `System;` `class` `GFG {`   `  ``// Function to calculate the possible` `  ``// number of ways to select 3 numbers` `  ``static` `long` `numberOfWays(``int``[] A, ``int` `N)` `  ``{` `    ``int` `left_count_Zero = 0, count1 = 0;` `    ``int` `left_count_One = 0, count2 = 0;` `    ``long` `ans = 0;`   `    ``// Storing the right counts of` `    ``// 1s and 2s in the array` `    ``for` `(``int` `i = 0; i < N; i++) {` `      ``if` `(A[i] == 1)` `        ``count2++;` `      ``else` `        ``count1++;` `    ``}`   `    ``// Traversing the array from left side` `    ``for` `(``int` `i = 0; i < N; i++) {`   `      ``// If 1 is encountered,` `      ``// looking for all combinations of` `      ``// 0, 1, 0 possible` `      ``if` `(A[i] == 1) {`   `        ``// Number of ways to select one` `        ``// 0 from left side * Number of` `        ``// ways to select one 0 from right` `        ``ans += (left_count_Zero * count1);`   `        ``// Decrement right_count of 1` `        ``// and increment left_count of 1` `        ``left_count_One++;` `        ``count2--;` `      ``}`   `      ``// If 0 is encountered,` `      ``// looking for all combinations` `      ``// of 1, 0, 1 possible` `      ``else` `{`   `        ``// Number of ways to select` `        ``// one 1 from left side` `        ``// * Number of ways to select a 1` `        ``// from right` `        ``ans += (left_count_One * count2);`   `        ``// Decrement right_count of 2` `        ``// and increment left_count of 2` `        ``left_count_Zero++;` `        ``count1--;` `      ``}` `    ``}` `    ``return` `ans;` `  ``}`   `  ``public` `static` `int` `Main()` `  ``{` `    ``int``[] arr = ``new` `int``[] { 0, 0, 1, 1, 0, 1 };` `    ``int` `N = 6;`   `    ``// Function call` `    ``Console.Write(numberOfWays(arr, N));` `    ``return` `0;` `  ``}` `}`   `// This code is contributed by Taranpreet`

## Javascript

 ``

Output

`6`

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

My Personal Notes arrow_drop_up