# Practical Numbers

Last Updated : 22 Apr, 2021

A Practical Number is a number N if all the numbers M < N can be written as the sum of distinct proper divisors of N.

1, 2, 4, 6, 8, 12, 16, 18, 20, 24, 28….

### Check if N is a practical number

Given a number N, the task is to check if N is a Practical Number or not. If N is a Practical Number then print “Yes” else print “No”.

Examples:

Input: N = 6
Output: Yes
Explanation:
Proper divisors of 6 = 1, 2, 3
2 = 2
3 = 1 + 2 or 3
4 = 1 + 3

Input: N = 5
Output: No

Approach: The idea is to store all the factors of the number in an array and then Finally, determine for all numbers i less than N if there is a subset of the stored set of factors with a sum equal to i.
Subset Sum problem for the same is explained in detail in this article: Subset Sum Problem | DP-25

Below is the implementation of the above approach:

## C++

 `// C++ program to check if a number is Practical` `// or not.` `#include ` `using` `namespace` `std;`   `// Returns true if there is a subset of set[]` `// with sun equal to given sum` `bool` `isSubsetSum(vector<``int``>& set, ``int` `n, ``int` `sum)` `{` `    ``// 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` `subset[n][sum];` `}`   `// Function to store divisors of N` `// in a vector` `void` `storeDivisors(``int` `n, vector<``int``>& ``div``)` `{` `    ``// Find all divisors which divides 'num'` `    ``for` `(``int` `i = 1; i <= ``sqrt``(n); i++) {`   `        ``// if 'i' is divisor of 'n'` `        ``if` `(n % i == 0) {`   `            ``// if both divisors are same` `            ``// then store it once else store` `            ``// both divisors` `            ``if` `(i == (n / i))` `                ``div``.push_back(i);` `            ``else` `{` `                ``div``.push_back(i);` `                ``div``.push_back(n / i);` `            ``}` `        ``}` `    ``}` `}`   `// Returns true if num is Practical` `bool` `isPractical(``int` `N)` `{` `    ``// vector to store all` `    ``// divisors of N` `    ``vector<``int``> ``div``;` `    ``storeDivisors(N, ``div``);` `    ``// to check all numbers from 1 to < N` `    ``for` `(``int` `i = 1; i < N; i++) {` `        ``if` `(!isSubsetSum(``div``, ``div``.size(), i))` `            ``return` `false``;` `    ``}` `    ``return` `true``;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `N = 18;` `    ``isPractical(N) ? cout << ``"Yes"` `                   ``: cout << ``"No"``;` `    ``return` `0;` `}`

## Java

 `// Java program to check if a number is Practical` `// or not.` `import` `java.util.*;` `class` `GFG{`   `// Returns true if there is a subset of set[]` `// with sun equal to given sum` `static` `boolean` `isSubsetSum(Vector set, ` `                                ``int` `n, ``int` `sum)` `{` `    ``// 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` `subset[n][sum];` `}`   `// Function to store divisors of N` `// in a vector` `static` `void` `storeDivisors(``int` `n, Vector div)` `{` `    ``// Find all divisors which divides 'num'` `    ``for` `(``int` `i = ``1``; i <= Math.sqrt(n); i++)` `    ``{`   `        ``// if 'i' is divisor of 'n'` `        ``if` `(n % i == ``0``) ` `        ``{`   `            ``// if both divisors are same` `            ``// then store it once else store` `            ``// both divisors` `            ``if` `(i == (n / i))` `                ``div.add(i);` `            ``else` `            ``{` `                ``div.add(i);` `                ``div.add(n / i);` `            ``}` `        ``}` `    ``}` `}`   `// Returns true if num is Practical` `static` `boolean` `isPractical(``int` `N)` `{` `    ``// vector to store all` `    ``// divisors of N` `    ``Vector div = ``new` `Vector();` `    ``storeDivisors(N, div);` `    `  `    ``// to check all numbers from 1 to < N` `    ``for` `(``int` `i = ``1``; i < N; i++)` `    ``{` `        ``if` `(!isSubsetSum(div, div.size(), i))` `            ``return` `false``;` `    ``}` `    ``return` `true``;` `}`   `// Driver code` `public` `static` `void` `main(String[] args)` `{` `    ``int` `N = ``18``;` `    ``if``(isPractical(N) == ``true``)` `        ``System.out.print(``"Yes"``);` `    ``else` `        ``System.out.print(``"No"``);` `}` `}`   `// This code is contributed by PrinciRaj1992`

## Python3

 `# Python3 program to check if a number is` `# Practical or not. ` `import` `math`   `# Returns true if there is a subset of set[] ` `# with sun equal to given sum ` `def` `isSubsetSum(``Set``, n, ``Sum``):` `    `  `    ``# The value of subset[i][j] will be true if ` `    ``# there is a subset of set[0..j-1] with sum ` `    ``# equal to i ` `    ``subset ``=` `[[``False` `for` `i ``in` `range``(``Sum` `+` `1``)]` `                     ``for` `j ``in` `range``(n ``+` `1``)]`   `    ``# If sum is 0, then answer is true ` `    ``for` `i ``in` `range``(n ``+` `1``):` `        ``subset[i][``0``] ``=``True` `        `  `    ``# If sum is not 0 and set is empty, ` `    ``# then answer is false ` `    ``for` `i ``in` `range``(``1``, ``Sum` `+` `1``):` `        ``subset[``0``][i] ``=` `False`   `    ``# Fill the subset table in bottom up manner ` `    ``for` `i ``in` `range``(``1``, n ``+` `1``):` `        ``for` `j ``in` `range``(``1``, ``Sum` `+` `1``):` `            ``if` `(j < ``Set``[i ``-` `1``]):` `                ``subset[i][j] ``=` `subset[i ``-` `1``][j]` `            ``if` `(j >``=` `Set``[i ``-` `1``]):` `                ``subset[i][j] ``=` `(subset[i ``-` `1``][j] ``or` `                                ``subset[i ``-` `1``][j ``-` `Set``[i ``-` `1``]])`   `    ``return` `subset[n][``Sum``]`   `# Function to store divisors of N ` `# in a vector ` `def` `storeDivisors(n, div):` `    `  `    ``# Find all divisors which divides 'num' ` `    ``for` `i ``in` `range``(``1``, ``int``(math.sqrt(n)) ``+` `1``):` `        `  `        ``# If 'i' is divisor of 'n'` `        ``if` `(n ``%` `i ``=``=` `0``):` `            `  `            ``# If both divisors are same ` `            ``# then store it once else store ` `            ``# both divisors ` `            ``if` `(i ``=``=` `int``(n ``/` `i)):` `                ``div.append(i)` `            ``else``:` `                ``div.append(i)` `                ``div.append(``int``(n ``/` `i))`   `# Returns true if num is Practical ` `def` `isPractical(N):` `    `  `    ``# Vector to store all ` `    ``# divisors of N ` `    ``div ``=` `[]` `    ``storeDivisors(N, div)` `    `  `    ``# To check all numbers from 1 to < N ` `    ``for` `i ``in` `range``(``1``, N):` `        ``if` `(``not` `isSubsetSum(div, ``len``(div), i)):` `            ``return` `False` `            `  `    ``return` `True`   `# Driver code ` `N ``=` `18`   `if` `(isPractical(N)):` `    ``print``(``"Yes"``)` `else``:` `    ``print``(``"No"``)`   `# This code is contributed by avanitrachhadiya2155`

## C#

 `// C# program to check if a number ` `// is Practical or not.` `using` `System;` `using` `System.Collections.Generic;` `class` `GFG{`   `// Returns true if there is a subset of set[]` `// with sun equal to given sum` `static` `bool` `isSubsetSum(List<``int``> ``set``, ` `                       ``int` `n, ``int` `sum)` `{` `    ``// 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 < ``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` `subset[n, sum];` `}`   `// Function to store divisors of N` `// in a vector` `static` `void` `storeDivisors(``int` `n, List<``int``> div)` `{` `    ``// Find all divisors which divides 'num'` `    ``for` `(``int` `i = 1; i <= Math.Sqrt(n); i++)` `    ``{`   `        ``// if 'i' is divisor of 'n'` `        ``if` `(n % i == 0) ` `        ``{`   `            ``// if both divisors are same` `            ``// then store it once else store` `            ``// both divisors` `            ``if` `(i == (n / i))` `                ``div.Add(i);` `            ``else` `            ``{` `                ``div.Add(i);` `                ``div.Add(n / i);` `            ``}` `        ``}` `    ``}` `}`   `// Returns true if num is Practical` `static` `bool` `isPractical(``int` `N)` `{` `    ``// vector to store all` `    ``// divisors of N` `    ``List<``int``> div = ``new` `List<``int``>();` `    ``storeDivisors(N, div);` `    `  `    ``// to check all numbers from 1 to < N` `    ``for` `(``int` `i = 1; i < N; i++)` `    ``{` `        ``if` `(!isSubsetSum(div, div.Count, i))` `            ``return` `false``;` `    ``}` `    ``return` `true``;` `}`   `// Driver code` `public` `static` `void` `Main(String[] args)` `{` `    ``int` `N = 18;` `    ``if``(isPractical(N) == ``true``)` `        ``Console.Write(``"Yes"``);` `    ``else` `        ``Console.Write(``"No"``);` `}` `}`   `// This code is contributed by PrinciRaj1992`

## Javascript

 ``

Output:

`Yes`

Time Complexity: O(n)

Previous
Next