 Open in App
Not now

# Check if any permutation of a large number is divisible by 8

• Difficulty Level : Medium
• Last Updated : 05 Sep, 2022

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

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

## Javascript

 ``

Output

`Yes`

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

Auxiliary space: O(1) as it is using constant space

My Personal Notes arrow_drop_up