Related Articles

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.

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

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <bits/stdc++.h>
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

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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<Integer, Integer> te = new HashMap<>();
  
        // Map to store the frequency of
        // the numbers at the odd indices
        HashMap<Integer, Integer> 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));
    }
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Output:

1

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.




My Personal Notes arrow_drop_up
Recommended Articles
Page :