Skip to content
Related Articles

Related Articles

Panarithmic numbers within a given range
  • Difficulty Level : Expert
  • Last Updated : 07 Nov, 2020
GeeksforGeeks - Summer Carnival Banner

Given two positive numbers A and B. The task is to print all the

Panarithmic Number between two numbers (inclusively). 
Panarithmic Numbers or Practical number is a positive integer N such that all positive integers smaller than N can be represented as sums of distinct divisors of N
For Example:, 12 is a practical number because all the numbers from 1 to 11 can be expressed as sums of its divisors 1, 2, 3, 4, and 6 { 5 = 3 + 2, 7 = 6 + 1, 8 = 6 + 2, 9 = 6 + 3, 10 = 6 + 3 + 1, 11 = 6 + 3 + 2}

Examples: 

Input: A = 1 B = 20 
Output: 1 2 4 6 8 12 16 18 20 
Explanation: 
There are 9 Practical Numbers and these are the numbers whose factors can represent all the number smaller than it. 
For e.g. 4. Factors of 4 are 1 and 2. 
The number 3 can be represented as 1+2 = 3. 

Input: A = 100 B = 150 
Output: 100 104 108 112 120 126 128 132 140 144 150 



Approach: 

  1. Iterate from A to B (inclusively).
  2. Check for each number if it is practical number or not.
  3. Compute and store factors of each number within [A, B] one by one and check if all numbers less than the respective numbers can be expressed as the sum of the factors.

Below is the implementation of the above approach: 

C++




// C++ program to print Practical
// Numbers in given range
 
#include <bits/stdc++.h>
using namespace std;
 
// function to compute divisors
// of a number
vector<int> get_divisors(int A)
{
    // vector to store divisors
    vector<int> ans;
 
    // 1 will always be a divisor
    ans.push_back(1);
 
    for (int i = 2; i <= sqrt(A); i++) {
        if (A % i == 0) {
 
            ans.push_back(i);
 
            // check if i is squareroot
            // of A then only one time
            // insert it in ans
            if ((i * i) != A)
                ans.push_back(A / i);
        }
    }
    return ans;
}
 
// function to check that a
// number can be represented as
// sum of distinct divisor or not
bool Sum_Possible(vector<int> set, int sum)
{
    int n = set.size();
 
    // The value of subset[i][j]
    // will be true if
    // there is a subset of
    // set[0..j-1] with sum
    // equal to i
    bool subset[n + 1][sum + 1];
 
    // If sum is 0, then answer is true
    for (int i = 0; i <= n; i++)
        subset[i][0] = true;
 
    // If sum is not 0 and set is empty,
    // then answer is false
    for (int i = 1; i <= sum; i++)
        subset[0][i] = false;
 
    // Fill the subset table
    // in bottom up manner
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= sum; j++) {
 
            if (j < set[i - 1])
                subset[i][j] = subset[i - 1][j];
 
            if (j >= set[i - 1])
                subset[i][j]
                    = subset[i - 1][j]
                      || subset[i - 1]
                               [j - set[i - 1]];
        }
    }
 
    // return the possibility
    // of given sum
    return subset[n][sum];
}
 
// function to check a number is
// Practical or not
bool Is_Practical(int A)
{
    // vector to store divisors
    vector<int> divisors;
 
    divisors = get_divisors(A);
    for (int i = 2; i < A; i++) {
 
        if (Sum_Possible(divisors, i) == false)
            return false;
    }
 
    // if all numbers can be
    // represented as sum of
    // unique divisors
    return true;
}
 
// function to print Practical
// Numbers in a range
void print_practica_No(int A, int B)
{
    for (int i = A; i <= B; i++) {
        if (Is_Practical(i) == true) {
            cout << i << " ";
        }
    }
}
 
// Driver Function
int main()
{
    int A = 1, B = 100;
    print_practica_No(A, B);
    return 0;
}

Java




// Java program to print practical
// Numbers in given range
import java.util.*;
import java.math.*;
 
class GFG{
     
// Function to compute divisors
// of a number
static ArrayList<Integer> get_divisors(int A)
{
     
    // Vector to store divisors
    ArrayList<Integer> ans = new ArrayList<>();
     
    // 1 will always be a divisor
    ans.add(1);
 
    for(int i = 2; i <= Math.sqrt(A); i++)
    {
        if (A % i == 0)
        {
            ans.add(i);
             
            // Check if i is squareroot
            // of A then only one time
            // insert it in ans
            if ((i * i) != A)
                ans.add(A / i);
        }
    }
    return ans;
}
 
// Function to check that a
// number can be represented as
// sum of distinct divisor or not
static boolean Sum_Possible(ArrayList<Integer> set,
                            int sum)
{
    int n = set.size();
 
    // The value of subset[i][j]
    // will be true if there is
    // a subset of set[0..j-1]
    // with sum equal to i
    boolean subset[][] = new boolean[n + 1][sum + 1];
 
    // If sum is 0, then answer is true
    for(int i = 0; i <= n; i++)
        subset[i][0] = true;
 
    // If sum is not 0 and set is empty,
    // then answer is false
    for(int i = 1; i <= sum; i++)
        subset[0][i] = false;
 
    // Fill the subset table
    // in bottom up manner
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= sum; j++)
        {
            if (j < set.get(i - 1))
                subset[i][j] = subset[i - 1][j];
 
            if (j >= set.get(i - 1))
                subset[i][j] = subset[i - 1][j] ||
                               subset[i - 1][j -
                               set.get(i - 1)];
        }
    }
 
    // Return the possibility
    // of given sum
    return subset[n][sum];
}
 
// Function to check a number is
// Practical or not
static boolean Is_Practical(int A)
{
     
    // Vector to store divisors
    ArrayList<Integer> divisors;
 
    divisors = get_divisors(A);
    for(int i = 2; i < A; i++)
    {
        if (Sum_Possible(divisors, i) == false)
            return false;
    }
     
    // If all numbers can be
    // represented as sum of
    // unique divisors
    return true;
}
 
// Function to print Practical
// Numbers in a range
static void print_practica_No(int A, int B)
{
    for(int i = A; i <= B; i++)
    {
        if (Is_Practical(i) == true)
        {
            System.out.print(i + " ");
        }
    }
}
 
// Driver Code
public static void main(String args[])
{
    int A = 1, B = 100;
     
    print_practica_No(A, B);
}
}
 
// This code is contributed by jyoti369

Python3




# Python3 program to print Practical
# Numbers in given range
import math
 
# Function to compute divisors
# of a number
def get_divisors(A):
     
    # Vector to store divisors
    ans = []
     
    # 1 will always be a divisor
    ans.append(1)
    for i in range(2, math.floor(math.sqrt(A)) + 1):
        if (A % i == 0):
            ans.append(i)
             
            # Check if i is squareroot
            # of A then only one time
            # insert it in ans
            if ((i * i) != A):
                ans.append(A // i)
    return ans
 
# Function to check that a
# number can be represented as
# summ of distinct divisor or not
def summ_Possible(sett, summ):
     
    n = len(sett)
     
    # The value of subsett[i][j] will
    # be True if there is a subsett of
    # sett[0..j-1] with summ equal to i
    subsett = [[0 for i in range(summ + 1)]
                  for j in range(n + 1)]
     
    # If summ is 0, then answer is True
    for i in range(n + 1):
        subsett[i][0] = True
         
    # If summ is not 0 and sett is empty,
    # then answer is False
    for i in range(1, summ + 1):
        subsett[0][i] = False
         
    # Fill the subsett table
    # in bottom up manner
    for i in range(n + 1):
        for j in range(summ + 1):
            if (j < sett[i - 1]):
                subsett[i][j] = subsett[i - 1][j]
             
            if (j >= sett[i - 1]):
                subsett[i][j] = (subsett[i - 1][j] or
                                 subsett[i - 1]
                                        [j - sett[i - 1]])
                 
    # Return the possibility
    # of given summ
    return subsett[n][summ]
 
# Function to check a number
#  is Practical or not
def Is_Practical(A):
     
    # Vector to store divisors
    divisors = []
     
    divisors = get_divisors(A)
    for i in range(2, A):
        if (summ_Possible(divisors, i) == False):
            return False
             
    # If all numbers can be
    # represented as summ of
    # unique divisors
    return True
 
# Function to prPractical
# Numbers in a range
def print_practica_No(A, B):
     
    for i in range(A, B + 1):
        if (Is_Practical(i) == True):
            print(i, end = " ")
         
# Driver code
A = 1
B = 100
 
print_practica_No(A, B)
 
# This code is contributed by shubhamsingh10

C#




// C# program to print practical
// Numbers in given range
using System;
using System.Collections;
 
class GFG{
     
// Function to compute divisors
// of a number
static ArrayList get_divisors(int A)
{
     
    // To store divisors
    ArrayList ans = new ArrayList();
   
    // 1 will always be a divisor
    ans.Add(1);
   
    for(int i = 2;
            i <= (int)Math.Sqrt(A);
            i++)
    {
        if (A % i == 0)
        {
            ans.Add(i);
             
            // Check if i is squareroot
            // of A then only one time
            // insert it in ans
            if ((i * i) != A)
                ans.Add(A / i);
        }
    }
    return ans;
}
 
// Function to check that a
// number can be represented as
// sum of distinct divisor or not
static bool Sum_Possible(ArrayList set,
                         int sum)
{
    int n = set.Count;
   
    // The value of subset[i][j]
    // will be true if
    // there is a subset of
    // set[0..j-1] with sum
    // equal to i
    bool [,]subset = new bool[n + 1, sum + 1];
   
    // If sum is 0, then answer is true
    for(int i = 0; i <= n; i++)
        subset[i, 0] = true;
   
    // If sum is not 0 and set is empty,
    // then answer is false
    for(int i = 1; i <= sum; i++)
        subset[0, i] = false;
   
    // Fill the subset table
    // in bottom up manner
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= sum; j++)
        {
            if (j < (int)set[i - 1])
                subset[i, j] = subset[i - 1, j];
   
            if (j >= (int)set[i - 1])
                subset[i, j] = subset[i - 1, j] ||
                               subset[i - 1, j -
                             (int)set[i - 1]];
        }
    }
     
    // Return the possibility
    // of given sum
    return subset[n, sum];
}
 
// Function to check a number is
// Practical or not
static bool Is_Practical(int A)
{
     
    // To store divisors
    ArrayList divisors = new ArrayList();
   
    divisors = get_divisors(A);
    for(int i = 2; i < A; i++)
    {
        if (Sum_Possible(divisors, i) == false)
            return false;
    }
   
    // If all numbers can be
    // represented as sum of
    // unique divisors
    return true;
}
 
// Function to print Practical
// Numbers in a range
static void print_practica_No(int A, int B)
{
    for(int i = A; i <= B; i++)
    {
        if (Is_Practical(i) == true)
        {
            Console.Write(i + " ");
        }
    }
}
 
// Driver code
public static void Main(string []args)
{
    int A = 1, B = 100;
     
    print_practica_No(A, B);
}
}
 
// This code is contributed by rutvik_56

Output:

1 2 4 6 8 12 16 18 20 24 28 30 32 36 40 42 48 54 56 60 64 66 72 78 80 84 88 90 96 100 



Time Complexity: O(( B – A) * B 5/2) 
Auxiliary Space: O( B 3/2)

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 :