# Panarithmic numbers within a given range

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

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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 ` `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] = ``true``; ` ` `  `    ``// If sum is not 0 and set is empty, ` `    ``// then answer is false ` `    ``for` `(``int` `i = 1; i <= sum; i++) ` `        ``subset[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; ` `} `

## 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 `

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)

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

My Personal Notes arrow_drop_up If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : SHUBHAMSINGH10, nidhi_biet