Given a string **S** of size** N**, the task is to count all possible triplets in the given string which consists of only 3 colours (R)Red, (G)Green and (B)Blue in the order **(R, G, B)**.

**Examples: **

Input:S = “RRGB”

Output:2

Explanation:There are two triplets of RGB in the given string:

- R at index 0, G at index 2 and B at index 3 forms one triplet of RGB.
- R at index 1, G at index 2 and B at index 3 forms the second triplet of RGB.

Input:S = “GBR”

Output:0

Explanation:No triplets exists.

**Approach:**

- Count the number of B(Blue) in the given string and store the value in a
**Blue_Count**variable. - Initialize
**Red_Count**= 0. - Iterate over all character of string from left to right.
- If the current character is (R)red, increase the
**Red_Count**. - If current character is (B)blue, decrease
**Blue_Count**. - If the current character is G(green) add
**Red_Count*****Blue_Count**in the result.

Below is the implementation of the above approach.

## C++

`// C++ code for the above program ` ` ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// function to count the ` `// ordered triplets (R, G, B) ` `int` `countTriplets(string color) ` `{ ` ` ` `int` `result = 0, Blue_Count = 0; ` ` ` `int` `Red_Count = 0; ` ` ` ` ` `// count the B(blue) colour ` ` ` `for` `(` `char` `c : color) { ` ` ` `if` `(c == ` `'B'` `) ` ` ` `Blue_Count++; ` ` ` `} ` ` ` ` ` `for` `(` `char` `c : color) { ` ` ` `if` `(c == ` `'B'` `) ` ` ` `Blue_Count--; ` ` ` `if` `(c == ` `'R'` `) ` ` ` `Red_Count++; ` ` ` `if` `(c == ` `'G'` `) ` ` ` `result += Red_Count * Blue_Count; ` ` ` `} ` ` ` `return` `result; ` `} ` ` ` `// Driver program ` `int` `main() ` `{ ` ` ` `string color = ` `"RRGGBBRGGBB"` `; ` ` ` `cout << countTriplets(color); ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Java

`// Java code for the above program ` `class` `GFG{ ` ` ` `// function to count the ` `// ordered triplets (R, G, B) ` `static` `int` `countTriplets(String color) ` `{ ` ` ` `int` `result = ` `0` `, Blue_Count = ` `0` `; ` ` ` `int` `Red_Count = ` `0` `; ` ` ` `int` `len = color.length(); ` ` ` `int` `i; ` ` ` ` ` `// count the B(blue) colour ` ` ` `for` `(i = ` `0` `; i < len ; i++) ` ` ` `{ ` ` ` `if` `(color.charAt(i) == ` `'B'` `) ` ` ` `Blue_Count++; ` ` ` `} ` ` ` ` ` `for` `(i = ` `0` `; i < len ; i++) ` ` ` `{ ` ` ` `if` `(color.charAt(i) == ` `'B'` `) ` ` ` `Blue_Count--; ` ` ` `if` `(color.charAt(i) == ` `'R'` `) ` ` ` `Red_Count++; ` ` ` `if` `(color.charAt(i) == ` `'G'` `) ` ` ` `result += Red_Count * Blue_Count; ` ` ` `} ` ` ` `return` `result; ` `} ` ` ` `// Driver Code ` `public` `static` `void` `main (String[] args) ` `{ ` ` ` `String color = ` `"RRGGBBRGGBB"` `; ` ` ` `System.out.println(countTriplets(color)); ` `} ` ` ` `} ` ` ` `// This code is contributed by AnkitRai01 ` |

*chevron_right*

*filter_none*

## Python3

`# Python3 code for the above program ` ` ` `# function to count the ` `# ordered triplets (R, G, B) ` `def` `countTriplets(color) : ` ` ` ` ` `result ` `=` `0` `; Blue_Count ` `=` `0` `; ` ` ` `Red_Count ` `=` `0` `; ` ` ` ` ` `# count the B(blue) colour ` ` ` `for` `c ` `in` `color : ` ` ` `if` `(c ` `=` `=` `'B'` `) : ` ` ` `Blue_Count ` `+` `=` `1` `; ` ` ` ` ` `for` `c ` `in` `color : ` ` ` `if` `(c ` `=` `=` `'B'` `) : ` ` ` `Blue_Count ` `-` `=` `1` `; ` ` ` ` ` `if` `(c ` `=` `=` `'R'` `) : ` ` ` `Red_Count ` `+` `=` `1` `; ` ` ` ` ` `if` `(c ` `=` `=` `'G'` `) : ` ` ` `result ` `+` `=` `Red_Count ` `*` `Blue_Count; ` ` ` ` ` `return` `result; ` ` ` `# Driver Code ` `if` `__name__ ` `=` `=` `"__main__"` `: ` ` ` ` ` `color ` `=` `"RRGGBBRGGBB"` `; ` ` ` `print` `(countTriplets(color)); ` ` ` `# This code is contributed by AnkitRai01 ` |

*chevron_right*

*filter_none*

## C#

`// C# code for the above program ` `using` `System; ` `class` `GFG{ ` ` ` `// function to count the ` `// ordered triplets (R, G, B) ` `static` `int` `countTriplets(String color) ` `{ ` ` ` `int` `result = 0, Blue_Count = 0; ` ` ` `int` `Red_Count = 0; ` ` ` `int` `len = color.Length; ` ` ` `int` `i; ` ` ` ` ` `// count the B(blue) colour ` ` ` `for` `(i = 0; i < len ; i++) ` ` ` `{ ` ` ` `if` `(color[i] == ` `'B'` `) ` ` ` `Blue_Count++; ` ` ` `} ` ` ` ` ` `for` `(i = 0; i < len ; i++) ` ` ` `{ ` ` ` `if` `(color[i] == ` `'B'` `) ` ` ` `Blue_Count--; ` ` ` `if` `(color[i] == ` `'R'` `) ` ` ` `Red_Count++; ` ` ` `if` `(color[i] == ` `'G'` `) ` ` ` `result += Red_Count * Blue_Count; ` ` ` `} ` ` ` `return` `result; ` `} ` ` ` `// Driver Code ` `public` `static` `void` `Main(` `string` `[] args) ` `{ ` ` ` `string` `color = ` `"RRGGBBRGGBB"` `; ` ` ` `Console.WriteLine(countTriplets(color)); ` `} ` `} ` ` ` `// This code is contributed by AnkitRai01 ` |

*chevron_right*

*filter_none*

**Output:**

28

**Time Complexity: ** *O(N)*

**Auxiliary Space Cpmplexity: *** O(1)*

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.

## Recommended Posts:

- Restore original String from given Encrypted String by the given operations
- Count of Distinct strings possible by inserting K characters in the original string
- Count of triplets from the given string with non-equidistant characters
- Decode a median string to the original string
- Count ordered pairs of numbers with a given LCM
- Sum of two numbers if the original ratio and new ratio obtained by adding a given number to each number is given
- Count Derangements (Permutation such that no element appears in its original position)
- Count number of triplets with product equal to given number with duplicates allowed | Set-2
- Count number of triplets with product equal to given number with duplicates allowed
- Count of triplets in an array that satisfy the given conditions
- Count ordered pairs of positive numbers such that their sum is S and XOR is K
- Count number of ordered pairs with Even and Odd Sums
- Count number of ordered pairs with Even and Odd Product
- Count ordered pairs with product less than N
- Count of Ordered Pairs (X, Y) satisfying the Equation 1/X + 1/Y = 1/N
- Print n smallest elements from given array in their original order
- Minimum time to return array to its original state after given modifications
- Find the original matrix when largest element in a row and a column are given
- Find the original coordinates whose Manhattan distances are given
- Find the deleted value from the array when average of original elements is given

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.