Sort elements on the basis of number of factors

Given an array of positive integers. Sort the given array in decreasing order of number of factors of each element, i.e., element having the highest number of factors should be the first to be displayed and the number having least number of factors should be the last one. Two elements with equal number of factors should be in the same order as in the original array.
Examples: 

Input : {5, 11, 10, 20, 9, 16, 23}
Output : 20 16 10 9 5 11 23
Number of distinct factors:
For 20 = 6, 16 = 5, 10 = 4, 9 = 3
and for 5, 11, 23 = 2 (same number of factors
therefore sorted in increasing order of index)

Input : {104, 210, 315, 166, 441, 180}
Output : 180 210 315 441 104 166

The following steps sort numbers in decreasing order of count of factors. 

1. Count distinct number of factors of each element. Refer this.
2. You can use a structure for each element to store its original index and count of factors. Create an array of such structures to store such information for all the elements.
3. Sort this array of structures on the basis of the problem statement using any sorting algorithm.
4. Traverse this array of structures from the beginning and get the number from the original array with the help of the index stored in the structure of each element of the sorted array of structures.

C++

// C++ implementation to sort numbers on
// the basis of factors
#include <bits/stdc++.h>

using namespace std;

// structure of each element having its index
// in the input array and number of factors
struct element
{
    int index, no_of_fact;
};

// function to count factors for
// a given number n
int countFactors(int n)
{
    int count = 0;
    int sq = sqrt(n);

    // if the number is a perfect square
    if (sq * sq == n)
        count++;

    // count all other factors
    for (int i=1; i<sqrt(n); i++)
    {
        // if i is a factor then n/i will be
        // another factor. So increment by 2
        if (n % i == 0)
            count += 2;
    }
    return count;
}

// comparison function for the elements
// of the structure
bool compare(struct element e1, struct element e2)
{
    // if two elements have the same number
    // of factors then sort them in increasing
    // order of their index in the input array
    if (e1.no_of_fact == e2.no_of_fact)
        return e1.index < e2.index;

    // sort in decreasing order of number of factors
    return e1.no_of_fact > e2.no_of_fact;
}

// function to print numbers after sorting them in
// decreasing order of number of factors
void printOnBasisOfFactors(int arr[], int n)
{
    struct element num[n];

    // for each element of input array create a
    // structure element to store its index and
    // factors count
    for (int i=0; i<n; i++)
    {
        num[i].index = i;
        num[i].no_of_fact = countFactors(arr[i]);
    }

    // sort the array of structures as defined
    sort(num, num+n, compare);

    // access index from the structure element and corresponding
    // to that index access the element from arr
    for (int i=0; i<n; i++)
        cout << arr[num[i].index] << " ";
}

// Driver program to test above
int main()
{
    int arr[] = {5, 11, 10, 20, 9, 16, 23};
    int n = sizeof(arr) / sizeof(arr[0]);
    printOnBasisOfFactors(arr, n);
    return 0;
}

Java

// Java implementation to sort numbers on
// the basis of factors

import java.util.Arrays;
import java.util.Comparator;

class Element
{
    //each element having its index
    // in the input array and number of factors
    int index, no_of_fact;

    public Element(int i, int countFactors)
    {
        index = i;
        no_of_fact = countFactors;
    }

    // method to count factors for
    // a given number n
    static int countFactors(int n)
    {
        int count = 0;
        int sq = (int)Math.sqrt(n);

        // if the number is a perfect square
        if (sq * sq == n)
            count++;

        // count all other factors
        for (int i=1; i<Math.sqrt(n); i++)
        {
            // if i is a factor then n/i will be
            // another factor. So increment by 2
            if (n % i == 0)
                count += 2;
        }

        return count;
    }

    // function to print numbers after sorting them in
    // decreasing order of number of factors
    static void printOnBasisOfFactors(int arr[], int n)
    {
        Element num[] = new Element[n];

        // for each element of input array create a
        // structure element to store its index and
        // factors count
        for (int i=0; i<n; i++)
        {
            num[i] = new Element(i,countFactors(arr[i]));
        }

        // sort the array of structures as defined
        Arrays.sort(num,new Comparator<Element>() {

            @Override
            // compare method for the elements
            // of the structure
            public int compare(Element e1, Element e2) {
                // if two elements have the same number
                // of factors then sort them in increasing
                // order of their index in the input array
                if (e1.no_of_fact == e2.no_of_fact)
                 return e1.index < e2.index ? -1 : 1;

                // sort in decreasing order of number of factors
                return e1.no_of_fact > e2.no_of_fact ? -1 : 1;
            }

        });

        // access index from the structure element and corresponding
        // to that index access the element from arr
        for (int i=0; i<n; i++)
            System.out.print(arr[num[i].index]+" ");
    }

    // Driver program to test above
    public static void main(String[] args)
    {

        int arr[] = {5, 11, 10, 20, 9, 16, 23};

        printOnBasisOfFactors(arr, arr.length);

    }
}
// This code is contributed by Gaurav Miglani

Python3

import math

# structure of each element having its index
# in the input array and number of factors
class Element:
    def __init__(self, index, no_of_fact):
        self.index = index
        self.no_of_fact = no_of_fact

# function to count factors for
# a given number n
def countFactors(n):
    count = 0
    sq = int(math.sqrt(n))

    # if the number is a perfect square
    if sq * sq == n:
        count += 1

    # count all other factors
    for i in range(1, int(math.sqrt(n))+1):
        # if i is a factor then n/i will be
        # another factor. So increment by 2
        if n % i == 0 and n/i != i:
            count += 2

    return count

# comparison function for the elements
# of the structure
def compare(e1, e2):
    # if two elements have the same number
    # of factors then sort them in increasing
    # order of their index in the input array
    if e1.no_of_fact == e2.no_of_fact:
        return e1.index < e2.index

    # sort in decreasing order of number of factors
    return e1.no_of_fact > e2.no_of_fact

# function to print numbers after sorting them in
# decreasing order of number of factors
def printOnBasisOfFactors(arr):
    n = len(arr)
    num = []

    # for each element of input array create a
    # structure element to store its index and
    # factors count
    for i in range(n):
        num.append(Element(i, countFactors(arr[i])))

    # sort the array of structures as defined
    num.sort(key=lambda x: (x.no_of_fact, -x.index), reverse=True)

    # access index from the structure element and corresponding
    # to that index access the element from arr
    for i in range(n):
        print(arr[num[i].index], end=" ")

# Driver program to test above
arr = [5, 11, 10, 20, 9, 16, 23]
printOnBasisOfFactors(arr)

C#

// C# implementation to sort numbers on
// the basis of factors
using System;
using System.Collections.Generic;

class Element
{

  // each element having its index
  // in the input array and number of factors
  public int index, no_of_fact;

  public Element(int i, int countFactors)
  {
    index = i;
    no_of_fact = countFactors;
  }

  static int compare(Element e1, Element e2) {
    // if two elements have the same number
    // of factors then sort them in increasing
    // order of their index in the input array
    if (e1.no_of_fact == e2.no_of_fact)
      return e1.index < e2.index ? -1 : 1;

    // sort in decreasing order of number of factors
    return e1.no_of_fact > e2.no_of_fact ? -1 : 1;
  }

  // method to count factors for
  // a given number n
  static int countFactors(int n)
  {
    int count = 0;
    int sq = (int)Math.Sqrt(n);

    // if the number is a perfect square
    if (sq * sq == n)
      count++;

    // count all other factors
    for (int i = 1; i < Math.Sqrt(n); i++)
    {
      // if i is a factor then n/i will be
      // another factor. So increment by 2
      if (n % i == 0)
        count += 2;
    }

    return count;
  }

  // function to print numbers after sorting them in
  // decreasing order of number of factors
  static void printOnBasisOfFactors(int[] arr, int n)
  {
    Element[] num = new Element[n];

    // for each element of input array create a
    // structure element to store its index and
    // factors count
    for (int i = 0; i < n; i++)
    {
      num[i] = new Element(i,countFactors(arr[i]));
    }

    // sort the array of structures as defined
    Array.Sort(num,(a,b)=>compare(a,b));

    // access index from the structure element and corresponding
    // to that index access the element from arr
    for (int i = 0; i < n; i++)
      Console.Write(arr[num[i].index] + " ");
  }

  // Driver program to test above
  public static void Main()
  {
    int[] arr = {5, 11, 10, 20, 9, 16, 23};
    printOnBasisOfFactors(arr, arr.Length);
  }
}

// This code is contributed by Pushpesh Raj

Javascript

<script>
// Javascript implementation to sort numbers on
// the basis of factors

// each element having its index
// in the input array and number of factors
class Element {
  constructor(i, countFactors) {
    this.index = i;
    this.no_of_fact = countFactors;
  }
}

// method to count factors for
// a given number n
function countFactors(n) {
  let count = 0;
  let sq = Math.floor(Math.sqrt(n));

  // if the number is a perfect square
  if (sq * sq == n)
    count++;

  // count all other factors
  for (let i = 1; i < Math.sqrt(n); i++) {
    // if i is a factor then n/i will be
    // another factor. So increment by 2
    if (n % i == 0)
      count += 2;
  }

  return count;
}

// function to print numbers after sorting them in
// decreasing order of number of factors
function printOnBasisOfFactors(arr, n) {
  let num = new Array(n);

  // for each element of input array create a
  // structure element to store its index and
  // factors count
  for (let i = 0; i < n; i++) {
    num[i] = new Element(i, countFactors(arr[i]));
  }

  // sort the array of structures as defined

  num.sort((e1, e2) => {
    // if two elements have the same number
    // of factors then sort them in increasing
    // order of their index in the input array
    if (e1.no_of_fact == e2.no_of_fact)
      return e1.index < e2.index ? -1 : 1;

    // sort in decreasing order of number of factors
    return e1.no_of_fact > e2.no_of_fact ? -1 : 1;
  })





  // access index from the structure element and corresponding
  // to that index access the element from arr
  for (let i = 0; i < n; i++)
    document.write(arr[num[i].index] + " ");
}

// Driver program to test above
let arr = [5, 11, 10, 20, 9, 16, 23];
printOnBasisOfFactors(arr, arr.length);

// This code is contributed by gfgking
</script>

Output: 

20 16 10 9 5 11 23

Time Complexity: O(n ?n)
Auxiliary Space: O(n)

If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.