Related Articles
Minimum operations required to transform a sequence of numbers to a sequence where a[i]=a[i+2]
• Difficulty Level : Basic
• Last Updated : 18 Dec, 2019

Given a sequence of integers of even length ‘n’, the task is to find the minimum number of operations required to convert the sequence to follow the rule a[i]=a[i+2] where ‘i’ is the index.
The operation here is to replace any element of the sequence with any element.

Examples :

```Input : n=4 ; Array : 3, 1, 3, 2
Output : 1
If we change the last element to '1' then,
the sequence will become 3, 1, 3, 1 (satisfying the condition)
So, only 1 replacement is required.

Input : n=6 ; Array : 105 119 105 119 105 119
Output : 0
As the sequence is already in the required state.
So, no replacement of elements is required.
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach : As we see that the indices 0, 2, …, n-2 are connected independently and 1, 3, 5, …, n are connected independently and must have the same value. So,

• We have to find the most occurring number in both the sequences (even and odd) by storing the numbers and their frequency in a map.
• Then every other number of that sequence will have to be replaced with the most occurring number in the same sequence.
• Finally, the count of the replacements from the previous step will be the answer.

Below is the implementation of the above approach :

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;`` ` `// Function to return the minimum replacements``int` `minReplace(``int` `a[], ``int` `n)``{``    ``int` `i;`` ` `    ``// Map to store the frequency of``    ``// the numbers at the even indices``    ``map<``int``, ``int``> te;`` ` `    ``// Map to store the frequency of``    ``// the numbers at the odd indices``    ``map<``int``, ``int``> to;`` ` `    ``for` `(i = 0; i < n; i++) ``    ``{`` ` `        ``// Checking if the index``        ``// is odd or even``        ``if` `(i % 2 == 0)`` ` `            ``// If the number is already present then,``            ``// just increase the occurrence by 1``            ``te[a[i]]++;``        ``else`` ` `            ``// If the number is already present then,``            ``// just increase the occurrence by 1``            ``to[a[i]]++;``    ``}`` ` `    ``// To store the character with``    ``// maximum frequency in even indices.``    ``int` `me = -1;`` ` `    ``// To store the character with``    ``// maximum frequency in odd indices.``    ``int` `mo = -1;`` ` `    ``// To store the frequency of the``    ``// maximum occurring number in even indices.``    ``int` `ce = -1;`` ` `    ``// To store the frequency of the``    ``// maximum occurring number in odd indices.``    ``int` `co = -1;`` ` `    ``// Iterating over Map of even indices to``    ``// get the maximum occurring number.``    ``for` `(``auto` `it : te) ``    ``{``        ``if` `(it.second > ce)``        ``{``            ``ce = it.second;``            ``me = it.first;``        ``}``    ``}`` ` `    ``// Iterating over Map of odd indices to``    ``// get the maximum occurring number.``    ``for` `(``auto` `it : to) ``    ``{``        ``if` `(it.second > co) ``        ``{``            ``co = it.second;``            ``mo = it.first;``        ``}``    ``}`` ` `    ``// To store the final answer``    ``int` `res = 0;`` ` `    ``for` `(i = 0; i < n; i++)``    ``{``        ``if` `(i % 2 == 0) ``        ``{`` ` `            ``// If the index is even but``            ``// a[i] != me``            ``// then a[i] needs to be replaced``            ``if` `(a[i] != me) res++;``        ``}``         ` `        ``else``        ``{`` ` `            ``// If the index is odd but``            ``// a[i] != mo``            ``// then a[i] needs to be replaced``            ``if` `(a[i] != mo) res++;``        ``}``    ``}``    ``return` `res;``}`` ` `// Driver Code``int` `main()``{``    ``int` `n = 4;``    ``int` `a[] = {3, 1, 3, 2};``    ``cout << minReplace(a, n) << endl;``    ``return` `0;``}`` ` `// This code is contributed by``// sanjeev2552`

## Java

 `// Java implementation of the approach``import` `java.util.HashMap;``class` `GFG {`` ` `    ``// Function to return the minimum replacements``    ``public` `static` `int` `minReplace(``int` `a[], ``int` `n)``    ``{``        ``int` `i;`` ` `        ``// Map to store the frequency of``        ``// the numbers at the even indices``        ``HashMap te = ``new` `HashMap<>();`` ` `        ``// Map to store the frequency of``        ``// the numbers at the odd indices``        ``HashMap to = ``new` `HashMap<>();`` ` `        ``for` `(i = ``0``; i < n; i++) {`` ` `            ``// Checking if the index``            ``// is odd or even``            ``if` `(i % ``2` `== ``0``) {`` ` `                ``// If the number is already present then,``                ``// just increase the occurrence by 1``                ``if` `(te.containsKey(a[i]))``                    ``te.put(a[i], te.get(a[i]) + ``1``);``                ``else``                    ``te.put(a[i], ``1``);``            ``}``            ``else` `{`` ` `                ``// If the number is already present then,``                ``// just increase the occurrence by 1``                ``if` `(to.containsKey(a[i]))``                    ``to.put(a[i], to.get(a[i]) + ``1``);``                ``else``                    ``to.put(a[i], ``1``);``            ``}``        ``}`` ` `        ``// To store the character with``        ``// maximum frequency in even indices.``        ``int` `me = -``1``;`` ` `        ``// To store the character with``        ``// maximum frequency in odd indices.``        ``int` `mo = -``1``;`` ` `        ``// To store the frequency of the``        ``// maximum occurring number in even indices.``        ``int` `ce = -``1``;`` ` `        ``// To store the frequency of the``        ``// maximum occurring number in odd indices.``        ``int` `co = -``1``;`` ` `        ``// Iterating over Map of even indices to``        ``// get the maximum occurring number.``        ``for` `(Integer It : te.keySet()) {``            ``if` `(te.get(It) > ce) {``                ``ce = te.get(It);``                ``me = It;``            ``}``        ``}`` ` `        ``// Iterating over Map of odd indices to``        ``// get the maximum occurring number.``        ``for` `(Integer It : to.keySet()) {``            ``if` `(to.get(It) > co) {``                ``co = to.get(It);``                ``mo = It;``            ``}``        ``}`` ` `        ``// To store the final answer``        ``int` `res = ``0``;`` ` `        ``for` `(i = ``0``; i < n; i++) {``            ``if` `(i % ``2` `== ``0``) {`` ` `                ``// If the index is even but``                ``// a[i] != me``                ``// then a[i] needs to be replaced``                ``if` `(a[i] != me)``                    ``res++;``            ``}``            ``else` `{`` ` `                ``// If the index is odd but``                ``// a[i] != mo``                ``// then a[i] needs to be replaced``                ``if` `(a[i] != mo)``                    ``res++;``            ``}``        ``}`` ` `        ``return` `res;``    ``}`` ` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `n;``        ``n = ``4``;``        ``int` `a[] = { ``3``, ``1``, ``3``, ``2` `};``        ``System.out.println(minReplace(a, n));``    ``}``}`

## Python3

 `# Python3 implementation of the approach`` ` `# Function to return the minimum replacements``def` `minReplace(a: ``list``, n) ``-``> ``int``:`` ` `    ``# Map to store the frequency of``    ``# the numbers at the even indices``    ``te ``=` `dict``()`` ` `    ``# Map to store the frequency of``    ``# the numbers at the odd indices``    ``to ``=` `dict``()`` ` `    ``for` `i ``in` `range``(n):`` ` `        ``# Checking if the index``        ``# is odd or even``        ``if` `i ``%` `2` `=``=` `0``:`` ` `            ``# If the number is already present then,``            ``# just increase the occurrence by 1``            ``if` `a[i] ``not` `in` `te:``                ``te[a[i]] ``=` `1``            ``else``:``                ``te[a[i]] ``+``=` `1``        ``else``:`` ` `            ``# If the number is already present then,``            ``# just increase the occurrence by 1``            ``if` `a[i] ``not` `in` `to:``                ``to[a[i]] ``=` `1``            ``else``:``                ``to[a[i]] ``+``=` `1`` ` `    ``# To store the character with``    ``# maximum frequency in even indices.``    ``me ``=` `-``1`` ` `    ``# To store the character with``    ``# maximum frequency in odd indices.``    ``mo ``=` `-``1`` ` `    ``# To store the frequency of the``    ``# maximum occurring number in even indices.``    ``ce ``=` `-``1`` ` `    ``# To store the frequency of the``    ``# maximum occurring number in odd indices.``    ``co ``=` `-``1`` ` `    ``# Iterating over Map of even indices to``    ``# get the maximum occurring number.``    ``for` `it ``in` `te:``        ``if` `te[it] > ce:``            ``ce ``=` `te[it]``            ``me ``=` `it`` ` `    ``# Iterating over Map of odd indices to``    ``# get the maximum occurring number.``    ``for` `it ``in` `to:``        ``if` `to[it] > co:``            ``co ``=` `to[it]``            ``mo ``=` `it`` ` `    ``# To store the final answer``    ``res ``=` `0`` ` `    ``for` `i ``in` `range``(n):``        ``if` `i ``%` `2` `=``=` `0``:`` ` `            ``# If the index is even but``            ``# a[i] != me``            ``# then a[i] needs to be replaced``            ``if` `a[i] !``=` `me:``                ``res ``+``=` `1``        ``else``:`` ` `            ``# If the index is odd but``            ``# a[i] != mo``            ``# then a[i] needs to be replaced``            ``if` `a[i] !``=` `mo:``                ``res ``+``=` `1`` ` `    ``return` `res`` ` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:``    ``n ``=` `4``    ``a ``=` `[``3``, ``1``, ``3``, ``2``]``    ``print``(minReplace(a, n))`` ` `# This code is contributed by``# sanjeev2552`

## C#

 `// C# implementation of the approach``using` `System;``using` `System.Collections.Generic;`` ` `class` `GFG``{`` ` `    ``// Function to return the minimum replacements``    ``public` `static` `int` `minReplace(``int` `[]a, ``int` `n)``    ``{``        ``int` `i;`` ` `        ``// Map to store the frequency of``        ``// the numbers at the even indices``        ``Dictionary<``int``, ``                   ``int``> te = ``new` `Dictionary<``int``, ``                                            ``int``>();`` ` `        ``// Map to store the frequency of``        ``// the numbers at the odd indices``        ``Dictionary<``int``,``                   ``int``> to = ``new` `Dictionary<``int``, ``                                            ``int``>();`` ` `        ``for` `(i = 0; i < n; i++) ``        ``{`` ` `            ``// Checking if the index``            ``// is odd or even``            ``if` `(i % 2 == 0) ``            ``{`` ` `                ``// If the number is already present then,``                ``// just increase the occurrence by 1``                ``if` `(te.ContainsKey(a[i]))``                    ``te[a[i]] = te[a[i]] + 1;``                ``else``                    ``te.Add(a[i], 1);``            ``}``            ``else` `            ``{`` ` `                ``// If the number is already present then,``                ``// just increase the occurrence by 1``                ``if` `(to.ContainsKey(a[i]))``                    ``to[a[i]] = te[a[i]] + 1;``                ``else``                    ``to.Add(a[i], 1);``            ``}``        ``}`` ` `        ``// To store the character with``        ``// maximum frequency in even indices.``        ``int` `me = -1;`` ` `        ``// To store the character with``        ``// maximum frequency in odd indices.``        ``int` `mo = -1;`` ` `        ``// To store the frequency of the``        ``// maximum occurring number in even indices.``        ``int` `ce = -1;`` ` `        ``// To store the frequency of the``        ``// maximum occurring number in odd indices.``        ``int` `co = -1;`` ` `        ``// Iterating over Map of even indices to``        ``// get the maximum occurring number.``        ``foreach` `(``int` `It ``in` `te.Keys) ``        ``{``            ``if` `(te[It] > ce) ``            ``{``                ``ce = te[It];``                ``me = It;``            ``}``        ``}`` ` `        ``// Iterating over Map of odd indices to``        ``// get the maximum occurring number.``        ``foreach` `(``int` `It ``in` `to.Keys) ``        ``{``            ``if` `(to[It] > co)``            ``{``                ``co = to[It];``                ``mo = It;``            ``}``        ``}`` ` `        ``// To store the final answer``        ``int` `res = 0;`` ` `        ``for` `(i = 0; i < n; i++)``        ``{``            ``if` `(i % 2 == 0)``            ``{`` ` `                ``// If the index is even but``                ``// a[i] != me``                ``// then a[i] needs to be replaced``                ``if` `(a[i] != me)``                    ``res++;``            ``}``            ``else` `            ``{`` ` `                ``// If the index is odd but``                ``// a[i] != mo``                ``// then a[i] needs to be replaced``                ``if` `(a[i] != mo)``                    ``res++;``            ``}``        ``}``        ``return` `res;``    ``}`` ` `    ``// Driver code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``int` `n;``        ``n = 4;``        ``int` `[]a = { 3, 1, 3, 2 };``        ``Console.WriteLine(minReplace(a, n));``    ``}``}`` ` `// This code is contributed by Rajput-Ji`
Output:
```1
```

My Personal Notes arrow_drop_up