 Open in App
Not now

# Count ways to form N sized Strings with at most two adjacent different pair

• Last Updated : 21 Nov, 2022

Given a value N, the task is to find the number of ways a binary string of size N can be formed such that at most 2 adjacent pairs have different values.

Examples:

Input: N = 1
Output: 2
Explanation: Possible ways to form string are “1”, “0”. So the answer is 2

Input: N = 2
Output: 4
Explanation: Possible ways are “10”, “01”, “11”, “00”. So the answer is 4.

Input: N = 4
Output: 14
Explanation: Possible ways are “1111”, “1110”, “1101”, “1011”, “0111”, “1100”, “1001”, “0110”, “0011”, “1000”, “0100”, “0010”, “0001”, “0000”. So the answer is 14.

Approach: This problem can be solved by following the below idea:

Consider all possible cases and add them up. Since maximum, we can have 2 adjacent pairs of different values, we count the number of ways for all 3 cases individually. The 3 ways possible are as follows:

1. No adjacent pair with different values: We can have all the same bits i.e all bits are 0 or 1. So can form 2 strings in this case.
2. Only one adjacent pair of different values: In this case, we will have all 1s together and 0s together so that only one pair of adjacent values is different. If the 1 is the first bit then the other are 0s. The total number of ways to do so is N-1(as there can be one ‘1’ + (N-1) ‘0’, 2 ‘1’ + (N-2) ‘0’, . . ., (N-1) ‘1’ + one ‘0’). Similarly, there can be 0s first and then 1s. So (N-1) more ways. Therefore total ways in this case, is 2*(N-1).
3. Two adjacent pairs with different values: In this case, we keep bits in two patterns to make exactly two such positions where adjacents are different:
• Set of 1s then set of 0s and then again set of 1s – In this case, the set of 0s can be starting from the 2nd position and end maximum at the (N-1)th position (because at least first and last bit should be 1 for two adjacent different bits). So the number of ways, in this case, can be counted as the sum of the following:
• Number of ways if the set of 0s from 2nd position = N-2 ways (As blue color balls can end from 2nd to the (N-1)th position if it starts from 2nd position.)
• Number of ways if the set of 0s starts from 3rd position = N-3 ways.
• Similarly, till 0s start at (N-1)th position.
• Therefore the total number of ways, in this case, is (N – 2) + (N – 3)+ . . . + 1 = (N – 2) * (N – 1)/2.
• Set of 1s then set of 0s and then again set of 0s – This case is similar to the previous one. So the total number of ways, in this case, is also (N-1) * (N-2)/2.
• So the total number of ways is 2*{(N-1)*(N-2)/2} = (N-1)*(N-2) ways.

And hence total ways possible are the combination of these 3 cases i.e., 2 + 2*(N-1) + (N-2)*(N-1).

Below is the implementation of the above approach.

## C++

 `// C++ code to implement the approach` `#include ``using` `namespace` `std;` `// Function to count total number of ways``long` `long` `noOfWays(``long` `long` `N)``{``    ``// Adding all 3 cases``    ``// possible and returning it``    ``return` `2 + 2 * (N - 1) + (N - 2) * (N - 1);``}` `// Driver code``int` `main()``{``    ``int` `N = 4;` `    ``// Function call``    ``cout << noOfWays(N);` `    ``return` `0;``}`

## Java

 `// Java code to implement the approach``import` `java.io.*;` `class` `GFG``{` `  ``// Function to count total number of ways``  ``static` `int` `noOfWays(``int` `N)``  ``{` `    ``// Adding all 3 cases``    ``// possible and returning it``    ``return` `2` `+ ``2` `* (N - ``1``) + (N - ``2``) * (N - ``1``);``  ``}` `  ``// Driver code``  ``public` `static` `void` `main (String[] args)``  ``{``    ``int` `N = ``4``;` `    ``// Function call``    ``System.out.println(noOfWays(N));``  ``}``}` `// This code is contributed by Aman Kumar.`

## Python3

 `# Python3 code to implement the above approach` `# Function to count total number of ways``def` `noOfWays(N) :` `    ``# Adding all 3 cases``    ``# possible and returning it``    ``return` `2` `+` `2` `*` `(N ``-` `1``) ``+` `(N ``-` `2``) ``*` `(N ``-` `1``);`  `# Driver code``if` `__name__ ``=``=` `"__main__"` `:` `    ``N ``=` `4``;` `    ``# Function call``    ``print``(noOfWays(N));` `    ``# This code is contributed by AnkThon`

## C#

 `// C# code to implement the approach` `using` `System;` `public` `class` `GFG {` `    ``// Function to count total number of ways``    ``static` `int` `noOfWays(``int` `N)``    ``{` `        ``// Adding all 3 cases``        ``// possible and returning it``        ``return` `2 + 2 * (N - 1) + (N - 2) * (N - 1);``    ``}` `    ``static` `public` `void` `Main()``    ``{` `        ``// Code``        ``int` `N = 4;` `        ``// Function call``        ``Console.WriteLine(noOfWays(N));``    ``}``}` `// This code is contributed by lokeshmvs21.`

## Javascript

 `// JavaScript code to implement the approach` `// Function to count total number of ways``const noOfWays = (N) => {` `    ``// Adding all 3 cases``    ``// possible and returning it``    ``return` `2 + 2 * (N - 1) + (N - 2) * (N - 1);``}` `// Driver code``let N = 4;` `// Function call``console.log(noOfWays(N));` `// This code is contributed by rakeshsahni`

Output

`14`

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

My Personal Notes arrow_drop_up