Economical Numbers

Economical Number is a number N if the number of digits in the prime factorization of N (including powers) is less than the number of digits in N.
The first few Economical numbers are: 

125, 128, 243, 256, 343, 512, 625, 729, … 

Find the Economical numbers less than N

Given a number N, the task is to print all Economical Numbers upto N.
Examples:

Input: N = 200 
Output: 125 128
Input: N = 700 
Output: 125 128 243 256 343 512 625 

Approach:

1. Count all primes upto 10^6 using Sieve of Sundaram.
2. Find number of digits in N.
3. Find all prime factors of N and do following for every prime factor P. 
   • Find number of digits in P.
   • Count highest power of P that divides N.
   • Find sum of above two.
4. If digits in prime factors is less than digits in original number then return true. Else return false.

Below is the implementation of the approach:

C++

// C++ implementation to find
// Economical Numbers till n

#include <bits/stdc++.h>
using namespace std;
const int MAX = 10000;

// Array to store all prime less
// than and equal to MAX.
vector<int> primes;

// Utility function for sieve of sundaram
void sieveSundaram()
{
    // In general Sieve of Sundaram,
    // produces primes smaller
    // than (2*x + 2) for a number
    // given number x. Since
    // we want primes smaller than MAX,
    // we reduce MAX to half
    bool marked[MAX / 2 + 1] = { 0 };

    // Main logic of Sundaram. Mark all numbers which
    // do not generate prime number by doing 2*i+1
    for (int i = 1; i <= (sqrt(MAX) - 1) / 2; i++)
        for (int j = (i * (i + 1)) << 1;
             j <= MAX / 2; j = j + 2 * i + 1)
            marked[j] = true;

    // Since 2 is a prime number
    primes.push_back(2);

    // Print other primes. Remaining primes are of the
    // form 2*i + 1 such that marked[i] is false.
    for (int i = 1; i <= MAX / 2; i++)
        if (marked[i] == false)
            primes.push_back(2 * i + 1);
}

// Function to check if a number is
// a Economical number
bool isEconomical(int n)
{
    if (n == 1)
        return false;

    // Count digits in original number
    int original_no = n;
    int sumDigits = 0;
    while (original_no > 0) {
        sumDigits++;
        original_no = original_no / 10;
    }

    // Count all digits in prime factors of n
    // pDigit is going to hold this value.
    int pDigit = 0, count_exp = 0, p;
    for (int i = 0; primes[i] <= n / 2; i++) {
        // Count powers of p in n
        while (n % primes[i] == 0) {
            // If primes[i] is a prime factor,
            p = primes[i];
            n = n / p;

            // Count the power of prime factors
            count_exp++;
        }

        // Add its digits to pDigit.
        while (p > 0) {
            pDigit++;
            p = p / 10;
        }

        // Add digits of power of
        // prime factors to pDigit.
        while (count_exp > 1) {
            pDigit++;
            count_exp = count_exp / 10;
        }
    }

    // If n!=1 then one prime
    // factor still to be
    // summed up;
    if (n != 1) {
        while (n > 0) {
            pDigit++;
            n = n / 10;
        }
    }

    // If digits in prime factors is less than
    // digits in original number  then
    // return true. Else return false.
    return (pDigit < sumDigits);
}

// Driver code
int main()
{
    // Finding all prime numbers
    // before limit. These
    // numbers are used to
    // find prime factors.
    sieveSundaram();

    for (int i = 1; i < 200; i++)
        if (isEconomical(i))
            cout << i << " ";
    return 0;
}

Java

// Java implementation to find
// Economical Numbers till n
import java.util.*;
class GFG{

static int MAX = 10000;

// Array to store all prime less
// than and equal to MAX.
static Vector<Integer> primes = new Vector<Integer>();

// Utility function for sieve of sundaram
static void sieveSundaram()
{
    // In general Sieve of Sundaram,
    // produces primes smaller
    // than (2*x + 2) for a number
    // given number x. Since
    // we want primes smaller than MAX,
    // we reduce MAX to half
    boolean []marked = new boolean[MAX / 2 + 1];

    // Main logic of Sundaram. Mark all numbers which
    // do not generate prime number by doing 2*i+1
    for (int i = 1; i <= (Math.sqrt(MAX) - 1) / 2; i++)
        for (int j = (i * (i + 1)) << 1;
             j <= MAX / 2; j = j + 2 * i + 1)
            marked[j] = true;

    // Since 2 is a prime number
    primes.add(2);

    // Print other primes. Remaining primes are of the
    // form 2*i + 1 such that marked[i] is false.
    for (int i = 1; i <= MAX / 2; i++)
        if (marked[i] == false)
            primes.add(2 * i + 1);
}

// Function to check if a number is
// a Economical number
static boolean isEconomical(int n)
{
    if (n == 1)
        return false;

    // Count digits in original number
    int original_no = n;
    int sumDigits = 0;
    while (original_no > 0) {
        sumDigits++;
        original_no = original_no / 10;
    }

    // Count all digits in prime factors of n
    // pDigit is going to hold this value.
    int pDigit = 0, count_exp = 0, p = 0;
    for (int i = 0; primes.get(i) <= n / 2; i++) {
        // Count powers of p in n
        while (n % primes.get(i) == 0)
        {
            // If primes[i] is a prime factor,
            p = primes.get(i);
            n = n / p;

            // Count the power of prime factors
            count_exp++;
        }

        // Add its digits to pDigit.
        while (p > 0)
        {
            pDigit++;
            p = p / 10;
        }

        // Add digits of power of
        // prime factors to pDigit.
        while (count_exp > 1)
        {
            pDigit++;
            count_exp = count_exp / 10;
        }
    }

    // If n!=1 then one prime
    // factor still to be
    // summed up;
    if (n != 1)
    {
        while (n > 0)
        {
            pDigit++;
            n = n / 10;
        }
    }

    // If digits in prime factors is less than
    // digits in original number  then
    // return true. Else return false.
    return (pDigit < sumDigits);
}

// Driver code
public static void main(String[] args)
{
    // Finding all prime numbers
    // before limit. These
    // numbers are used to
    // find prime factors.
    sieveSundaram();

    for (int i = 1; i < 200; i++)
        if (isEconomical(i))
            System.out.print(i + " ");
}
}

// This code is contributed by Rajput-Ji

Python3

# Python3 implementation to find
# Economical Numbers till n
import math
MAX = 10000

# Array to store all prime less
# than and equal to MAX.
primes = []

# Utility function for sieve of sundaram
def sieveSundaram():

    # In general Sieve of Sundaram,
    # produces primes smaller
    # than (2*x + 2) for a number
    # given number x. Since
    # we want primes smaller than MAX,
    # we reduce MAX to half
    marked = [0] * (MAX // 2 + 1)

    # Main logic of Sundaram. Mark all numbers which
    # do not generate prime number by doing 2*i+1
    for i in range(1, (int(math.sqrt(MAX)) - 1) // 2 + 1):
        j = (i * (i + 1)) << 1
        while(j <= MAX // 2):
            marked[j] = True
            j = j + 2 * i + 1

    # Since 2 is a prime number
    primes.append(2)

    # Prother primes. Remaining primes are of the
    # form 2*i + 1 such that marked[i] is false.
    for i in range(1, MAX // 2 + 1):
        if (marked[i] == False):
            primes.append(2 * i + 1)

# Function to check if a number is
# a Economical number
def isEconomical(n):

    if (n == 1):
        return False

    # Count digits in original number
    original_no = n
    sumDigits = 0
    while (original_no > 0):
        sumDigits += 1
        original_no = original_no // 10

    # Count all digits in prime factors of n
    # pDigit is going to hold this value.
    pDigit = 0
    count_exp = 0
    i = 0
    p = 0
    while(primes[i] <= n // 2):

        # Count powers of p in n
        while (n % primes[i] == 0):

            # If primes[i] is a prime factor,
            p = primes[i]
            n = n // p

            # Count the power of prime factors
            count_exp += 1
        i += 1

        # Add its digits to pDigit.
        while (p > 0):
            pDigit += 1
            p = p // 10

        # Add digits of power of
        # prime factors to pDigit.
        while (count_exp > 1):
            pDigit += 1
            count_exp = count_exp // 10

    # If n!=1 then one prime
    # factor still to be
    # summed up
    if (n != 1):
        while (n > 0):
            pDigit += 1
            n = n // 10

    # If digits in prime factors is less than
    # digits in original number then
    # return true. Else return false.
    if (pDigit < sumDigits):
        return True
    return False

# Driver code

# Finding all prime numbers
# before limit. These
# numbers are used to
# find prime factors.
sieveSundaram()

for i in range(1, 200):
    if (isEconomical(i)):
        print(i, end = " ")

# This code is contributed by shubhamsingh10

C#

// C# implementation to find
// Economical Numbers till n
using System;
using System.Collections.Generic;

class GFG{

static int MAX = 10000;

// Array to store all prime less
// than and equal to MAX.
static List<int> primes = new List<int>();

// Utility function for sieve of sundaram
static void sieveSundaram()
{

    // In general Sieve of Sundaram,
    // produces primes smaller
    // than (2*x + 2) for a number
    // given number x. Since
    // we want primes smaller than MAX,
    // we reduce MAX to half
    bool[] marked = new bool[MAX / 2 + 1];

    // Main logic of Sundaram. Mark all numbers which
    // do not generate prime number by doing 2*i+1
    for(int i = 1; i <= (Math.Sqrt(MAX) - 1) / 2; i++)
        for(int j = (i * (i + 1)) << 1; j <= MAX / 2;
                j = j + 2 * i + 1)
            marked[j] = true;

    // Since 2 is a prime number
    primes.Add(2);

    // Print other primes. Remaining primes are of the
    // form 2*i + 1 such that marked[i] is false.
    for(int i = 1; i <= MAX / 2; i++)
        if (marked[i] == false)
            primes.Add(2 * i + 1);
}

// Function to check if a number is
// a Economical number
static bool isEconomical(int n)
{
    if (n == 1)
        return false;

    // Count digits in original number
    int original_no = n;
    int sumDigits = 0;

    while (original_no > 0)
    {
        sumDigits++;
        original_no = original_no / 10;
    }

    // Count all digits in prime factors of n
    // pDigit is going to hold this value.
    int pDigit = 0, count_exp = 0, p = 0;
    for(int i = 0; primes[i] <= n / 2; i++)
    {

        // Count powers of p in n
        while (n % primes[i] == 0)
        {

            // If primes[i] is a prime factor,
            p = primes[i];
            n = n / p;

            // Count the power of prime factors
            count_exp++;
        }

        // Add its digits to pDigit.
        while (p > 0)
        {
            pDigit++;
            p = p / 10;
        }

        // Add digits of power of
        // prime factors to pDigit.
        while (count_exp > 1)
        {
            pDigit++;
            count_exp = count_exp / 10;
        }
    }

    // If n!=1 then one prime
    // factor still to be
    // summed up;
    if (n != 1)
    {
        while (n > 0)
        {
            pDigit++;
            n = n / 10;
        }
    }

    // If digits in prime factors is less than
    // digits in original number then
    // return true. Else return false.
    return (pDigit < sumDigits);
}

// Driver code
public static void Main(String[] args)
{

    // Finding all prime numbers
    // before limit. These
    // numbers are used to
    // find prime factors.
    sieveSundaram();

    for(int i = 1; i < 200; i++)
        if (isEconomical(i))
            Console.Write(i + " ");
}
}

// This code is contributed by Rajput-Ji

Javascript

// JS implementation to find
// Economical Numbers till n

let MAX = 10000;

// Array to store all prime less
// than and equal to MAX.
let primes = [];

// Utility function for sieve of sundaram
function sieveSundaram()
{
    // In general Sieve of Sundaram,
    // produces primes smaller
    // than (2*x + 2) for a number
    // given number x. Since
    // we want primes smaller than MAX,
    // we reduce MAX to half
    let marked = new Array(Math.floor(MAX / 2) + 1).fill(0)

    // Main logic of Sundaram. Mark all numbers which
    // do not generate prime number by doing 2*i+1
    for (var i = 1; i <= (Math.sqrt(MAX) - 1) / 2; i++)
        for (var j = (i * (i + 1)) << 1;
             j <= MAX / 2; j = j + 2 * i + 1)
            marked[j] = true;

    // Since 2 is a prime number
    primes.push(2);

    // Print other primes. Remaining primes are of the
    // form 2*i + 1 such that marked[i] is false.
    for (var i = 1; i <= MAX / 2; i++)
        if (marked[i] == false)
            primes.push(2 * i + 1);
}

// Function to check if a number is
// a Economical number
function isEconomical(n)
{
    if (n == 1)
        return false;

    // Count digits in original number
    let original_no = n;
    let sumDigits = 0;
    while (original_no > 0) {
        sumDigits++;
        original_no = Math.floor(original_no / 10);
    }

    // Count all digits in prime factors of n
    // pDigit is going to hold this value.
    let pDigit = 0, count_exp = 0, p;
    for (var i = 0; primes[i] <= n / 2; i++) {
        // Count powers of p in n
        while (n % primes[i] == 0) {
            // If primes[i] is a prime factor,
            p = primes[i];
            n = n / p;

            // Count the power of prime factors
            count_exp++;
        }

        // Add its digits to pDigit.
        while (p > 0) {
            pDigit++;
            p = Math.floor(p / 10);
        }

        // Add digits of power of
        // prime factors to pDigit.
        while (count_exp > 1) {
            pDigit++;
            count_exp = Math.floor(count_exp / 10);
        }
    }

    // If n!=1 then one prime
    // factor still to be
    // summed up;
    if (n != 1) {
        while (n > 0) {
            pDigit++;
            n = Math.floor(n / 10);
        }
    }

    // If digits in prime factors is less than
    // digits in original number  then
    // return true. Else return false.
    return (pDigit < sumDigits);
}

// Driver code


// Finding all prime numbers
// before limit. These
// numbers are used to
// find prime factors.
sieveSundaram();

for (var i = 1; i < 200; i++)
    if (isEconomical(i))
        process.stdout.write(i + " ");

// This code is contributed by phasing17.

Output:

125 128

Time Complexity: O(n^1/2)

Auxiliary Space: O(1)