Related Articles
Check if any permutation of a large number is divisible by 8
• Difficulty Level : Medium
• Last Updated : 04 Aug, 2020

Given a large number N and the task is to check if any permutation of a large number is divisible by 8.

Examples:

```Input: N = 31462708
Output: Yes
Many of permutation of number N like
34678120, 34278160 are divisible by 8.

Input: 75
Output: No
```

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

A naive approach is to generate all permutations of the number N and check if(N % 8 == 0) and return true if any of the permutations is divisible by 8.

An efficient approach is to use the fact that if the last three digits of a number are divisible by 8, then the number is also divisible by 8. Below are the required steps:

• Use a hash-table to count the occurrences of all digits in the given number.
• Traverse for all three-digit numbers which are divisible by 8.
• Check if the digits in the three-digit number are in the hash-table.
• If yes a number can be formed by permutation where the last three digits combine to form the three-digit number.
• If none of the three-digit numbers can be formed, return false.

Below is the implementation of the above approach:

## C++

 `// C++ program to check if any permutation of``// a large number is divisible by 8 or not``#include ``using` `namespace` `std;`` ` `// Function to check if any permutation``// of a large number is divisible by 8``bool` `solve(string n, ``int` `l)``{`` ` `    ``// Less than three digit number``    ``// can be checked directly.``    ``if` `(l < 3) {``        ``if` `(stoi(n) % 8 == 0)``            ``return` `true``;`` ` `        ``// check for the reverse of a number``        ``reverse(n.begin(), n.end());``        ``if` `(stoi(n) % 8 == 0)``            ``return` `true``;``        ``return` `false``;``    ``}`` ` `    ``// Stores the Frequency of characters in the n.``    ``int` `hash = { 0 };``    ``for` `(``int` `i = 0; i < l; i++)``        ``hash[n[i] - ``'0'``]++;`` ` `    ``// Iterates for all three digit numbers``    ``// divisible by 8``    ``for` `(``int` `i = 104; i < 1000; i += 8) {`` ` `        ``int` `dup = i;`` ` `        ``// stores the frequency of all single``        ``// digit in three-digit number``        ``int` `freq = { 0 };``        ``freq[dup % 10]++;``        ``dup = dup / 10;``        ``freq[dup % 10]++;``        ``dup = dup / 10;``        ``freq[dup % 10]++;`` ` `        ``dup = i;`` ` `        ``// check if the original number has``        ``// the digit``        ``if` `(freq[dup % 10] > hash[dup % 10])``            ``continue``;``        ``dup = dup / 10;`` ` `        ``if` `(freq[dup % 10] > hash[dup % 10])``            ``continue``;``        ``dup = dup / 10;`` ` `        ``if` `(freq[dup % 10] > hash[dup % 10])``            ``continue``;`` ` `        ``return` `true``;``    ``}`` ` `    ``// when all are checked its not possible``    ``return` `false``;``}`` ` `// Driver Code``int` `main()``{``    ``string number = ``"31462708"``;``    ``int` `l = number.length();`` ` `    ``if` `(solve(number, l))``        ``cout << ``"Yes"``;``    ``else``        ``cout << ``"No"``;``    ``return` `0;``}`

## Java

 `// Java program to check if ``// any permutation of a large``// number is divisible by 8 or not``import` `java.util.*;`` ` `class` `GFG``{``    ``// Function to check if any ``    ``// permutation of a large ``    ``// number is divisible by 8``    ``public` `static` `boolean` `solve(String n, ``int` `l)``    ``{``         ` `        ``// Less than three digit number``        ``// can be checked directly.``        ``if` `(l < ``3``) ``        ``{``            ``if` `(Integer.parseInt(n) % ``8` `== ``0``)``                ``return` `true``;``     ` `            ``// check for the reverse``            ``// of a number``            ``n = ``new` `String((``new` `StringBuilder()).append(n).reverse());``             ` `            ``if` `(Integer.parseInt(n) % ``8` `== ``0``)``                ``return` `true``;``            ``return` `false``;``        ``}``     ` `        ``// Stores the Frequency of``        ``// characters in the n.``        ``int` `[]hash = ``new` `int``[``10``];``        ``for` `(``int` `i = ``0``; i < l; i++)``            ``hash[n.charAt(i) - ``'0'``]++;``     ` `        ``// Iterates for all ``        ``// three digit numbers``        ``// divisible by 8``        ``for` `(``int` `i = ``104``; i < ``1000``; i += ``8``) ``        ``{``            ``int` `dup = i;``     ` `            ``// stores the frequency of ``            ``// all single digit in ``            ``// three-digit number``            ``int` `[]freq = ``new` `int``[``10``];``            ``freq[dup % ``10``]++;``            ``dup = dup / ``10``;``            ``freq[dup % ``10``]++;``            ``dup = dup / ``10``;``            ``freq[dup % ``10``]++;``     ` `            ``dup = i;``     ` `            ``// check if the original ``            ``// number has the digit``            ``if` `(freq[dup % ``10``] > ``                ``hash[dup % ``10``])``                ``continue``;``            ``dup = dup / ``10``;``     ` `            ``if` `(freq[dup % ``10``] > ``                ``hash[dup % ``10``])``                ``continue``;``            ``dup = dup / ``10``;``     ` `            ``if` `(freq[dup % ``10``] > ``                ``hash[dup % ``10``])``                ``continue``;``     ` `            ``return` `true``;``        ``}``     ` `        ``// when all are checked ``        ``// its not possible``        ``return` `false``;``    ``}``     ` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``String number = ``"31462708"``;``         ` `        ``int` `l = number.length();``     ` `        ``if` `(solve(number, l))``            ``System.out.println(``"Yes"``);``        ``else``            ``System.out.println(``"No"``);``    ``}``}`` ` `// This code is contributed``// by Harshit Saini`

## Python3

 `# Python3 program to check if ``# any permutation of a large``# number is divisible by 8 or not`` ` `# Function to check if any ``# permutation of a large ``# number is divisible by 8``def` `solve(n, l):``     ` `    ``# Less than three digit ``    ``# number can be checked ``    ``# directly.``    ``if` `l < ``3``:``        ``if` `int``(n) ``%` `8` `=``=` `0``:``            ``return` `True``         ` `        ``# check for the reverse ``        ``# of a number``        ``n ``=` `n[::``-``1``]`` ` `         ` `        ``if` `int``(n) ``%` `8` `=``=` `0``:``            ``return` `True``        ``return` `False`` ` `    ``# Stores the Frequency of``    ``# characters in the n.``    ``hash` `=` `10` `*` `[``0``]``    ``for` `i ``in` `range``(``0``, l):``        ``hash``[``int``(n[i]) ``-` `0``] ``+``=` `1``;`` ` `    ``# Iterates for all ``    ``# three digit numbers``    ``# divisible by 8``    ``for` `i ``in` `range``(``104``, ``1000``, ``8``):``        ``dup ``=` `i`` ` `        ``# stores the frequency ``        ``# of all single digit ``        ``# in three-digit number``        ``freq ``=` `10` `*` `[``0``]``        ``freq[``int``(dup ``%` `10``)] ``+``=` `1``;``        ``dup ``=` `dup ``/` `10``        ``freq[``int``(dup ``%` `10``)] ``+``=` `1``;``        ``dup ``=` `dup ``/` `10``        ``freq[``int``(dup ``%` `10``)] ``+``=` `1``;``         ` `        ``dup ``=` `i``         ` `        ``# check if the original ``        ``# number has the digit``        ``if` `(freq[``int``(dup ``%` `10``)] > ``            ``hash``[``int``(dup ``%` `10``)]):``            ``continue``;``        ``dup ``=` `dup ``/` `10``;``         ` `        ``if` `(freq[``int``(dup ``%` `10``)] > ``            ``hash``[``int``(dup ``%` `10``)]):``            ``continue``;``        ``dup ``=` `dup ``/` `10``         ` `        ``if` `(freq[``int``(dup ``%` `10``)] > ``            ``hash``[``int``(dup ``%` `10``)]):``            ``continue``;``         ` `        ``return` `True`` ` `    ``# when all are checked``    ``# its not possible``    ``return` `False``     ` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:``     ` `    ``number ``=` `"31462708"``     ` `    ``l ``=` `len``(number)``     ` `    ``if` `solve(number, l):``        ``print``(``"Yes"``)``    ``else``:``        ``print``(``"No"``)``         ` `# This code is contributed``# by Harshit Saini`

## C#

 `// C# program to check if ``// any permutation of a large``// number is divisible by 8 or not``using` `System;``using` `System.Collections.Generic; ``     ` `class` `GFG``{``    ``// Function to check if any ``    ``// permutation of a large ``    ``// number is divisible by 8``    ``public` `static` `bool` `solve(String n, ``int` `l)``    ``{``         ` `        ``// Less than three digit number``        ``// can be checked directly.``        ``if` `(l < 3) ``        ``{``            ``if` `(``int``.Parse(n) % 8 == 0)``                ``return` `true``;``     ` `            ``// check for the reverse``            ``// of a number``            ``n = reverse(n);``             ` `            ``if` `(``int``.Parse(n) % 8 == 0)``                ``return` `true``;``            ``return` `false``;``        ``}``     ` `        ``// Stores the Frequency of``        ``// characters in the n.``        ``int` `[]hash = ``new` `int``;``        ``for` `(``int` `i = 0; i < l; i++)``            ``hash[n[i] - ``'0'``]++;``     ` `        ``// Iterates for all ``        ``// three digit numbers``        ``// divisible by 8``        ``for` `(``int` `i = 104; i < 1000; i += 8) ``        ``{``            ``int` `dup = i;``     ` `            ``// stores the frequency of ``            ``// all single digit in ``            ``// three-digit number``            ``int` `[]freq = ``new` `int``;``            ``freq[dup % 10]++;``            ``dup = dup / 10;``            ``freq[dup % 10]++;``            ``dup = dup / 10;``            ``freq[dup % 10]++;``     ` `            ``dup = i;``     ` `            ``// check if the original ``            ``// number has the digit``            ``if` `(freq[dup % 10] > ``                ``hash[dup % 10])``                ``continue``;``            ``dup = dup / 10;``     ` `            ``if` `(freq[dup % 10] > ``                ``hash[dup % 10])``                ``continue``;``            ``dup = dup / 10;``     ` `            ``if` `(freq[dup % 10] > ``                ``hash[dup % 10])``                ``continue``;``     ` `            ``return` `true``;``        ``}``     ` `        ``// when all are checked ``        ``// its not possible``        ``return` `false``;``    ``}``     ` `    ``static` `String reverse(String input) ``    ``{``        ``char``[] a = input.ToCharArray();``        ``int` `l, r = 0;``        ``r = a.Length - 1;`` ` `        ``for` `(l = 0; l < r; l++, r--) ``        ``{``            ``// Swap values of l and r ``            ``char` `temp = a[l];``            ``a[l] = a[r];``            ``a[r] = temp;``        ``}``        ``return` `String.Join(``""``,a);``    ``}``     ` `    ``// Driver Code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``String number = ``"31462708"``;``         ` `        ``int` `l = number.Length;``     ` `        ``if` `(solve(number, l))``            ``Console.WriteLine(``"Yes"``);``        ``else``            ``Console.WriteLine(``"No"``);``    ``}``}`` ` `// This code is contributed by Princi Singh`

## PHP

 ` ``            ``\$hash``[``\$dup` `% 10])``            ``continue``;``        ``\$dup` `= ``\$dup` `/ 10;`` ` `        ``if` `(``\$freq``[``\$dup` `% 10] > ``            ``\$hash``[``\$dup` `% 10])``            ``continue``;``        ``\$dup` `= ``\$dup` `/ 10;`` ` `        ``if` `(``\$freq``[``\$dup` `% 10] > ``            ``\$hash``[``\$dup` `% 10])``            ``continue``;`` ` `        ``return` `true;``    ``}`` ` `    ``// when all are checked ``    ``// its not possible``    ``return` `false;``}`` ` `// Driver Code``\$number` `= ``"31462708"``;``\$l` `= ``strlen``(``\$number``);`` ` `if` `(solve(``\$number``, ``\$l``))``    ``echo` `"Yes"``;``else``    ``echo` `"No"``;`` ` `// This code is contributed``// by Akanksha Rai(Abby_akku)`
Output:
```Yes
```

Time Complexity: O(L), where L is the number of digits in the number. My Personal Notes arrow_drop_up