Related Articles
Count pairs of same parity indexed elements with same MSD after replacing each element by the sum of maximum digit * A and minimum digits * B
• Difficulty Level : Hard
• Last Updated : 29 Apr, 2021

Given an array arr[] of N 3-digit integers and two integers a and b, the task is to modify each array element according to the following rules:

The task is to count the number of pairs such that the chosen elements are at only odd or even indices and the most significant digits(MSD) must be equal and the number of pairs formed from that MSD is at most 2.

Examples:

Input: arr[] = {234, 567, 321, 345, 123, 110, 767, 111}, N = 8, A = 11, B  = 7
Output: 3
Explanation:
Modify the array elements by the following operations:

• The maximum and minimum digit of arr (= 234) are 4 and 2 respectively. Therefore, replace arr by 11 * 4 + 7 * 2 = 58.
• The maximum and minimum digit of arr (= 567) are 7 and 5 respectively. Therefore, replace arr by 11 * 7 + 7 * 5 = 77 + 35 = 112.
• The maximum and minimum digit of arr (= 321) and arr (= 123) are 3 and 1 respectively. Therefore, replace them by 11 * 3 + 7 * 1 = 40.
• The maximum and minimum digit of arr (= 345) are 5 and 3 respectively. Therefore, replace arr by 11 * 5 + 7 * 3 = 76.
• The maximum and minimum digit of arr (= 110 ) are 1 and 0 respectively. Therefore, replace arr by 11 * 1 + 7 * 0 = 11.
• The maximum and minimum digit of arr (= 767) are 7 and 6 respectively. Therefore, replace arr by 11 * 7 + 7 * 6 = 77 + 42 = 119.
• The maximum and minimum digit of arr (= 111) are 1 and 2 respectively. Therefore, replace arr by 11 * 1 + 7 * 1 = 18.

Therefore, the array arr[] modifies to {58, 12, 40, 76, 40, 11, 19, 18].
One possible way of forming pairs is {{40, 40}, {12, 11}, {11, 18}}.

Input: arr[] = {123, 452, 345, 124, 453}, N = 5, A = 11, B = 7
Output:1

Approach: The given problem can be solved using a frequency array. Follow the steps below to solve the given problem:

• Update each array element of arr[] with (A * X + B * Y)%100 by finding the minimum and maximum digit of the element, where X and Y are maximum and minimum digits of the arr[i].
• Initialize a 2D array, say mp, to store the count of numbers with MSD at even and odd positions separately.
• Traverse the array arr[] and increment the count of mp[arr[i]/10][i%2] by 1.
• Initialize a variable, say res, to store the resultant count of pairs.
• Iterate over the range [0, 9] and perform the following steps:
• Increment the count of res by 2 if there exist at least 3 numbers with i as MSD at even indices or odd indices i.e., mp[i] >= 3 || mp[i] >= 3.
• Otherwise, if there exists one pair at odd indices and one pair at even indices i.e., mp[i] == 2 && mp[i] == 2, then increment the count of res by 2.
• Otherwise, if there exists a pair either at odd indices or even indices with MSD as i i.e., mp[i] == 2 || mp[i] == 2, then increment the count of res by 1.
• After completing the above steps, print the value of res as the count of pairs.

Below is the implementation of the above approach:

## C++14

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to modify N into``// A * max digit + B * min digit``// and calculate score``int` `bit_score(``int` `N)``{``    ``// Stores maximum and minimum digit``    ``int` `maxi = 0, mini = 11;``  ` `    ``// Stores the val of N``    ``int` `score;``  ` `      ``// Find the maximum and minimum digits``    ``for` `(``int` `i = 0; i < 3; i++) {``      ` `          ``// Update maximum digit``        ``maxi = max(maxi, N % 10);``          ` `          ``// Update minimum digit``        ``mini = min(mini, N % 10);``        ``N /= 10;``        ``if` `(N == 0)``            ``break``;``    ``}``  ` `    ``// Calculate the modified number``    ``score = maxi * 11 + mini * 7;``  ` `      ``// Extract last two digits``    ``score = score % 100;``  ` `      ``// Return the final score``    ``return` `score;``}` `// Function to count the number of``// pairs possible from either odd``// or even indices having same MSD``int` `findPairs(``int` `arr[], ``int` `N, ``int` `a, ``int` `b)``{``    ``// Update the array``    ``for` `(``int` `i = 0; i < N; i++) {``        ``arr[i] = bit_score(arr[i]);``    ``}``  ` `    ``// Stores the total number of pairs``    ``int` `pairs = 0;` `    ``// Stores the count of numbers having``    ``// MSD at even or odd position seperately``    ``int` `mp;``  ` `    ``// Initialize all elements as 0``    ``memset``(mp, 0, ``sizeof``(mp));` `    ``// Calculate the count of a MSD``    ``// at even and odd positions``    ``for` `(``int` `i = 0; i < N; i++)``        ``mp[arr[i] / 10][i % 2]++;` `    ``// Iterate over range [0, 9]``    ``for` `(``int` `i = 0; i < 10; i++) {` `        ``if` `(mp[i] >= 3 || mp[i] >= 3)``            ``pairs += 2;``        ``else` `if` `(mp[i] == 2 && mp[i] == 2)``            ``pairs += 2;``        ``else` `if` `(mp[i] == 2 || mp[i] == 2)``            ``pairs += 1;``    ``}``  ` `    ``// Return the resultant count of pairs``    ``return` `pairs;``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 234, 567, 321, 345,``                  ``123, 110, 767, 111 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);``      ``int` `a = 11, b = 7;``  ` `    ``cout << findPairs(arr, N, a, b);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;``import` `java.lang.*;``import` `java.util.*;` `class` `GFG {` `  ``// Function to modify N into``  ``// A * max digit + B * min digit``  ``// and calculate score``  ``static` `int` `bit_score(``int` `N)``  ``{``    ``// Stores maximum and minimum digit``    ``int` `maxi = ``0``, mini = ``11``;` `    ``// Stores the val of N``    ``int` `score;` `    ``// Find the maximum and minimum digits``    ``for` `(``int` `i = ``0``; i < ``3``; i++) {` `      ``// Update maximum digit``      ``maxi = Math.max(maxi, N % ``10``);` `      ``// Update minimum digit``      ``mini = Math.min(mini, N % ``10``);``      ``N /= ``10``;``      ``if` `(N == ``0``)``        ``break``;``    ``}` `    ``// Calculate the modified number``    ``score = maxi * ``11` `+ mini * ``7``;` `    ``// Extract last two digits``    ``score = score % ``100``;` `    ``// Return the final score``    ``return` `score;``  ``}` `  ``// Function to count the number of``  ``// pairs possible from either odd``  ``// or even indices having same MSD``  ``static` `int` `findPairs(``int` `arr[], ``int` `N, ``int` `a, ``int` `b)``  ``{``    ``// Update the array``    ``for` `(``int` `i = ``0``; i < N; i++) {``      ``arr[i] = bit_score(arr[i]);``    ``}` `    ``// Stores the total number of pairs``    ``int` `pairs = ``0``;` `    ``// Stores the count of numbers having``    ``// MSD at even or odd position seperately``    ``int` `mp[][] = ``new` `int``[``10``][``2``];` `    ``// Calculate the count of a MSD``    ``// at even and odd positions``    ``for` `(``int` `i = ``0``; i < N; i++)``      ``mp[arr[i] / ``10``][i % ``2``]++;` `    ``// Iterate over range [0, 9]``    ``for` `(``int` `i = ``0``; i < ``10``; i++) {` `      ``if` `(mp[i][``1``] >= ``3` `|| mp[i][``0``] >= ``3``)``        ``pairs += ``2``;``      ``else` `if` `(mp[i][``1``] == ``2` `&& mp[i][``0``] == ``2``)``        ``pairs += ``2``;``      ``else` `if` `(mp[i][``1``] == ``2` `|| mp[i][``0``] == ``2``)``        ``pairs += ``1``;``    ``}` `    ``// Return the resultant count of pairs``    ``return` `pairs;``  ``}` `  ``// Driver Code``  ``public` `static` `void` `main(String[] args)``  ``{` `    ``int` `arr[] = { ``234``, ``567``, ``321``, ``345``, ``123``, ``110``, ``767``, ``111` `};``    ``int` `N = arr.length;``    ``int` `a = ``11``, b = ``7``;` `    ``System.out.println(findPairs(arr, N, a, b));``  ``}``}` `// This code is contributed by Kingash.`

## Python3

 `# Python3 program for the above approach` `# Function to modify N into``# A * max digit + B * min digit``# and calculate score``def` `bit_score(N):``  ` `    ``# Stores maximum and minimum digit``    ``maxi , mini ``=` `0``, ``11` `    ``# Stores the val of N``    ``score ``=` `0` `      ``# Find the maximum and minimum digits``    ``for` `i ``in` `range``(``3``):` `          ``# Update maximum digit``        ``maxi ``=` `max``(maxi, N ``%` `10``)` `          ``# Update minimum digit``        ``mini ``=` `min``(mini, N ``%` `10``)``        ``N ``/``/``=` `10``        ``if` `(N ``=``=` `0``):``            ``break` `    ``# Calculate the modified number``    ``score ``=` `maxi ``*` `11` `+` `mini ``*` `7` `      ``# Extract last two digits``    ``score ``=` `score ``%` `100` `      ``# Return the final score``    ``return` `score` `# Function to count the number of``# pairs possible from either odd``# or even indices having same MSD``def` `findPairs(arr, N, a, b):``    ``#Update the array``    ``for` `i ``in` `range``(N):``        ``arr[i] ``=` `bit_score(arr[i])` `    ``# Stores the total number of pairs``    ``pairs ``=` `0` `    ``# Stores the count of numbers having``    ``# MSD at even or odd position seperately``    ``mp ``=` `[[``0` `for` `i ``in` `range``(``2``)] ``for` `i ``in` `range``(``10``)]` `    ``# Initialize all elements as 0``    ``# memset(mp, 0, sizeof(mp))` `    ``# Calculate the count of a MSD``    ``# at even and odd positions``    ``for` `i ``in` `range``(N):``        ``mp[arr[i] ``/``/` `10``][i ``%` `2``] ``+``=` `1` `    ``# Iterate over range [0, 9]``    ``for` `i ``in` `range``(``10``):``        ``if` `(mp[i][``1``] >``=` `3` `or` `mp[i][``0``] >``=` `3``):``            ``pairs ``+``=` `2``        ``elif` `(mp[i][``1``] ``=``=` `2` `and` `mp[i][``0``] ``=``=` `2``):``            ``pairs ``+``=` `2``        ``elif` `(mp[i][``1``] ``=``=` `2` `or` `mp[i][``0``] ``=``=` `2``):``            ``pairs ``+``=` `1` `    ``# Return the resultant count of pairs``    ``return` `pairs` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``arr ``=` `[``234``, ``567``, ``321``, ``345``, ``123``, ``110``, ``767``, ``111``]``    ``N ``=` `len``(arr)``    ``a, b ``=` `11``, ``7` `    ``print` `(findPairs(arr, N, a, b))` `# This code is contributed by mohit kumar 29.`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{` `// Function to modify N into``// A * max digit + B * min digit``// and calculate score``static` `int` `bit_score(``int` `N)``{``    ` `    ``// Stores maximum and minimum digit``    ``int` `maxi = 0, mini = 11;``    ` `    ``// Stores the val of N``    ``int` `score;``    ` `    ``// Find the maximum and minimum digits``    ``for``(``int` `i = 0; i < 3; i++)``    ``{``    ` `        ``// Update maximum digit``        ``maxi = Math.Max(maxi, N % 10);``        ` `        ``// Update minimum digit``        ``mini = Math.Min(mini, N % 10);``        ``N /= 10;``        ` `        ``if` `(N == 0)``            ``break``;``    ``}``    ` `    ``// Calculate the modified number``    ``score = maxi * 11 + mini * 7;``    ` `    ``// Extract last two digits``    ``score = score % 100;``    ` `    ``// Return the final score``    ``return` `score;``}``    ` `// Function to count the number of``// pairs possible from either odd``// or even indices having same MSD``static` `int` `findPairs(``int``[] arr, ``int` `N,``                     ``int` `a, ``int` `b)``{``    ` `    ``// Update the array``    ``for``(``int` `i = 0; i < N; i++)``    ``{``        ``arr[i] = bit_score(arr[i]);``    ``}``    ` `    ``// Stores the total number of pairs``    ``int` `pairs = 0;``    ` `    ``// Stores the count of numbers having``    ``// MSD at even or odd position seperately``    ``int``[,] mp = ``new` `int``[10, 2];``    ` `    ``// Calculate the count of a MSD``    ``// at even and odd positions``    ``for``(``int` `i = 0; i < N; i++)``        ``mp[arr[i] / 10, i % 2]++;``    ` `    ``// Iterate over range [0, 9]``    ``for``(``int` `i = 0; i < 10; i++)``    ``{``        ``if` `(mp[i, 1] >= 3 || mp[i, 0] >= 3)``            ``pairs += 2;``        ``else` `if` `(mp[i, 1] == 2 && mp[i, 0] == 2)``            ``pairs += 2;``        ``else` `if` `(mp[i, 1] == 2 || mp[i, 0] == 2)``            ``pairs += 1;``    ``}``    ` `    ``// Return the resultant count of pairs``    ``return` `pairs;``}` `// Driver Code``public` `static` `void` `Main()``{``    ``int``[] arr = { 234, 567, 321, 345,``                  ``123, 110, 767, 111 };``    ``int` `N = arr.Length;``    ``int` `a = 11, b = 7;` `    ``Console.Write(findPairs(arr, N, a, b));``}``}` `// This code is contributed by sanjoy_62`

## Javascript

 ``
Output:
`3`

Time Complexity: O(N)
Auxiliary Space: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up