Skip to content
Related Articles

Related Articles

Sort an array in increasing order of their Multiplicative Persistence
  • Last Updated : 29 Apr, 2021

Given an array arr[] consisting of N positive integers, the task is to sort the array in increasing order with respect to the count of steps required to obtain a single-digit number by multiplying its digits recursively for each array element. If any two numbers have the same count of steps, then print the smaller number first.

Examples:

Input: arr[] = {39, 999, 4, 9876} 
Output: 4 9876 39 999 
Explanation:
Following are the number of steps required to reduce every array element to 0:

  • For arr[0] (= 39): The element 39 will reduce as 39 → 27 → 14 → 4. Therefore, the number of steps required is 3.
  • For arr[1] (= 999): The element 999 will reduce as 999 → 729 → 126 → 12 → 2. Therefore, the number of steps required is 4.
  • For arr[2] (= 4): The element 4 is already a single-digit number. Therefore, the number of steps required is 0.
  • For arr[3] (= 9876): The element 9876 will reduce as 9876 → 3024 → 0. Therefore, the number of steps required is 2.

According to the given criteria the elements in increasing order of count of steps required to reduce them into single-digit number is {4, 9876, 29, 999}

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



Approach: The given problem can be solved by finding the count of steps required to obtain a single-digit number by multiplying its digits recursively for each array element and then sort the array in increasing order using the comparator function. Follow the steps to solve the problem:

  • Declare a comparator function, cmp(X, Y) that takes two elements as a parameter and perform the following steps:
    • Iterate a loop until X becomes a single-digit number and update the value of X to the product of its digit.
    • Repeat the above step for the value Y.
    • If the value of X is less than Y, then return true. Otherwise, return false.
  • Sort the given array arr[] by using the above comparator function as sort(arr, arr + N, cmp).
  • After completing the above steps, print the array arr[].

Below is the implementation of the above approach:

C++




// C++ program for the above approach
  
#include <bits/stdc++.h>
using namespace std;
  
// Function to find the number of
// steps required to reduce a given
// number to a single-digit number
int countReduction(int num)
{
    // Stores the required result
    int ans = 0;
  
    // Iterate until a single digit
    // number is not obtained
    while (num >= 10) {
  
        // Store the number in a
        // temporary variable
        int temp = num;
        num = 1;
  
        // Iterate over all digits and
        // store their product in num
        while (temp > 0) {
            int digit = temp % 10;
            temp = temp / 10;
            num *= digit;
        }
  
        // Increment the answer
        // by 1
        ans++;
    }
  
    // Return the result
    return ans;
}
  
// Comparator function to sort the array
bool compare(int x, int y)
{
    // Count number of steps required
    // to reduce X and Y into single
    // digits integer
    int x1 = countReduction(x);
    int y1 = countReduction(y);
  
    // Return true
    if (x1 < y1)
        return true;
  
    return false;
}
  
// Function to sort the array according
// to the number of steps required to
// reduce a given number into a single
// digit number
void sortArray(int a[], int n)
{
    // Sort the array using the
    // comparator function
    sort(a, a + n, compare);
  
    // Print the array after sorting
    for (int i = 0; i < n; i++) {
        cout << a[i] << " ";
    }
}
  
// Driver Code
int main()
{
    int arr[] = { 39, 999, 4, 9876 };
    int N = sizeof(arr) / sizeof(arr[0]);
  
    // Function Call
    sortArray(arr, N);
  
    return 0;
}
Output:
4 9876 39 999

Time Complexity: O(N * log(N) * log(X)), where X is the largest element in the array, arr[]
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
Recommended Articles
Page :