# Minimum inversions required so that no two adjacent elements are same

Given a binary array **arr[]** of size **N**. The task is to find the minimum number of inversions required so that no two adjacent elements are same. After a single inversion, an element could change from **0** to **1** or from **1** to **0**.**Examples:**

Input:arr[] = {1, 1, 1}Output:1

Change arr[1] from 1 to 0 and

the array becomes {1, 0, 1}.Input:arr[] = {1, 0, 0, 1, 0, 0, 1, 0}Output:3

**Approach:** There are only two possibilities to make the array {1, 0, 1, 0, 1, 0, 1, …} or {0, 1, 0, 1, 0, 1, 0, …}. Let **ans_a** and **ans_b** be the count of changes required to get these arrays respectively. Now, the final answer will be **min(ans_a, ans_b)**.

Below is the implementation of the above approach:

## C++

`// C++ implementation of the approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to return the minimum` `// inversions required so that no` `// two adjacent elements are same` `int` `min_changes(` `int` `a[], ` `int` `n)` `{` ` ` `// To store the inversions required` ` ` `// to make the array {1, 0, 1, 0, 1, 0, 1, ...}` ` ` `// and {0, 1, 0, 1, 0, 1, 0, ...} respectively` ` ` `int` `ans_a = 0, ans_b = 0;` ` ` `// Find all the changes required` ` ` `for` `(` `int` `i = 0; i < n; i++) {` ` ` `if` `(i % 2 == 0) {` ` ` `if` `(a[i] == 0)` ` ` `ans_a++;` ` ` `else` ` ` `ans_b++;` ` ` `}` ` ` `else` `{` ` ` `if` `(a[i] == 0)` ` ` `ans_b++;` ` ` `else` ` ` `ans_a++;` ` ` `}` ` ` `}` ` ` `// Return the required answer` ` ` `return` `min(ans_a, ans_b);` `}` `// Driver code` `int` `main()` `{` ` ` `int` `a[] = { 1, 0, 0, 1, 0, 0, 1, 0 };` ` ` `int` `n = ` `sizeof` `(a) / ` `sizeof` `(a[0]);` ` ` `cout << min_changes(a, n);` ` ` `return` `0;` `}` |

## Java

`// Java implementation of the approach` `class` `GFG` `{` `// Function to return the minimum` `// inversions required so that no` `// two adjacent elements are same` `static` `int` `min_changes(` `int` `a[], ` `int` `n)` `{` ` ` `// To store the inversions required` ` ` `// to make the array {1, 0, 1, 0, 1, 0, 1, ...}` ` ` `// and {0, 1, 0, 1, 0, 1, 0, ...} respectively` ` ` `int` `ans_a = ` `0` `, ans_b = ` `0` `;` ` ` `// Find all the changes required` ` ` `for` `(` `int` `i = ` `0` `; i < n; i++)` ` ` `{` ` ` `if` `(i % ` `2` `== ` `0` `)` ` ` `{` ` ` `if` `(a[i] == ` `0` `)` ` ` `ans_a++;` ` ` `else` ` ` `ans_b++;` ` ` `}` ` ` `else` ` ` `{` ` ` `if` `(a[i] == ` `0` `)` ` ` `ans_b++;` ` ` `else` ` ` `ans_a++;` ` ` `}` ` ` `}` ` ` `// Return the required answer` ` ` `return` `Math.min(ans_a, ans_b);` `}` `// Driver code` `public` `static` `void` `main(String[] args)` `{` ` ` `int` `a[] = { ` `1` `, ` `0` `, ` `0` `, ` `1` `, ` `0` `, ` `0` `, ` `1` `, ` `0` `};` ` ` `int` `n = a.length;` ` ` `System.out.println(min_changes(a, n));` `}` `}` `// This code is contributed by Rajput-Ji` |

## Python3

`# Python3 implementation of the approach` `# Function to return the minimum` `# inversions required so that no` `# two adjacent elements are same` `def` `min_changes(a, n):` ` ` `# To store the inversions required` ` ` `# to make the array {1, 0, 1, 0, 1, 0, 1, ...}` ` ` `# and {0, 1, 0, 1, 0, 1, 0, ...} respectively` ` ` `ans_a ` `=` `0` `;` ` ` `ans_b ` `=` `0` `;` ` ` `# Find all the changes required` ` ` `for` `i ` `in` `range` `(n):` ` ` `if` `(i ` `%` `2` `=` `=` `0` `):` ` ` `if` `(a[i] ` `=` `=` `0` `):` ` ` `ans_a ` `+` `=` `1` `;` ` ` `else` `:` ` ` `ans_b ` `+` `=` `1` `;` ` ` `else` `:` ` ` `if` `(a[i] ` `=` `=` `0` `):` ` ` `ans_b ` `+` `=` `1` `;` ` ` `else` `:` ` ` `ans_a ` `+` `=` `1` `;` ` ` `# Return the required answer` ` ` `return` `min` `(ans_a, ans_b);` `# Driver code` `if` `__name__ ` `=` `=` `'__main__'` `:` ` ` `a ` `=` `[ ` `1` `, ` `0` `, ` `0` `, ` `1` `, ` `0` `, ` `0` `, ` `1` `, ` `0` `];` ` ` `n ` `=` `len` `(a);` ` ` `print` `(min_changes(a, n));` `# This code is contributed by Rajput-Ji` |

## C#

`// C# implementation of the approach` `using` `System;` `class` `GFG` `{` `// Function to return the minimum` `// inversions required so that no` `// two adjacent elements are same` `static` `int` `min_changes(` `int` `[]a, ` `int` `n)` `{` ` ` `// To store the inversions required` ` ` `// to make the array {1, 0, 1, 0, 1, 0, 1, ...}` ` ` `// and {0, 1, 0, 1, 0, 1, 0, ...} respectively` ` ` `int` `ans_a = 0, ans_b = 0;` ` ` `// Find all the changes required` ` ` `for` `(` `int` `i = 0; i < n; i++)` ` ` `{` ` ` `if` `(i % 2 == 0)` ` ` `{` ` ` `if` `(a[i] == 0)` ` ` `ans_a++;` ` ` `else` ` ` `ans_b++;` ` ` `}` ` ` `else` ` ` `{` ` ` `if` `(a[i] == 0)` ` ` `ans_b++;` ` ` `else` ` ` `ans_a++;` ` ` `}` ` ` `}` ` ` `// Return the required answer` ` ` `return` `Math.Min(ans_a, ans_b);` `}` `// Driver code` `public` `static` `void` `Main(String[] args)` `{` ` ` `int` `[]a = { 1, 0, 0, 1, 0, 0, 1, 0 };` ` ` `int` `n = a.Length;` ` ` `Console.WriteLine(min_changes(a, n));` `}` `}` `// This code is contributed by Rajput-Ji` |

## Javascript

`<script>` `// JavaScript implementation of the approach` `// Function to return the minimum` `// inversions required so that no` `// two adjacent elements are same` `function` `min_changes(a, n) {` ` ` `// To store the inversions required` ` ` `// to make the array {1, 0, 1, 0, 1, 0, 1, ...}` ` ` `// and {0, 1, 0, 1, 0, 1, 0, ...} respectively` ` ` `let ans_a = 0, ans_b = 0;` ` ` `// Find all the changes required` ` ` `for` `(let i = 0; i < n; i++) {` ` ` `if` `(i % 2 == 0) {` ` ` `if` `(a[i] == 0)` ` ` `ans_a++;` ` ` `else` ` ` `ans_b++;` ` ` `}` ` ` `else` `{` ` ` `if` `(a[i] == 0)` ` ` `ans_b++;` ` ` `else` ` ` `ans_a++;` ` ` `}` ` ` `}` ` ` `// Return the required answer` ` ` `return` `Math.min(ans_a, ans_b);` `}` `// Driver code` `let a = [1, 0, 0, 1, 0, 0, 1, 0];` `let n = a.length;` `document.write(min_changes(a, n));` `</script>` |

**Output:**

3

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. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend **live classes **with experts, please refer **DSA Live Classes for Working Professionals **and **Competitive Programming Live for Students**.