 GFG App
Open App Browser
Continue

# Minimum operations required to transform a sequence of numbers to a sequence where a[i]=a[i+2]

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. ```

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 in that sequence will have to be replaced with the most occurring number in the same sequence.
• Finally, the count of 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`

## Javascript

 ``

Output

`1`

### Space Complexity: O(N)

My Personal Notes arrow_drop_up