# 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 <bits/stdc++.h>
using namespace std;

// Function to count total number of ways
long long noOfWays(long long N)
{
// 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)
{

// 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) :

# 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)
{

// 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) => {

// 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