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 <bits/stdc++.h> 
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[10] = { 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[10] = { 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[10]; 
        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[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; 
    } 
      
    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

<?php 
error_reporting(0); 
// PHP 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 
function solve($n, $l) 
{ 
  
    // Less than three digit 
    // number can be checked 
    // directly. 
    if ($l < 3) 
    { 
        if (intval($n) % 8 == 0) 
            return true; 
  
        // check for the  
        // reverse of a number 
        strrev($n); 
        if (intval($n) % 8 == 0) 
            return true; 
        return false; 
    } 
  
    // Stores the Frequency of 
    // characters in the n. 
    $hash[10] = array(0); 
    for ($i = 0; $i < $l; $i++) 
        $hash[$n[$i] - '0']++; 
  
    // Iterates for all three  
    // digit numbers divisible by 8 
    for ($i = 104;  
         $i < 1000; $i += 8)  
    { 
  
        $dup = $i; 
  
        // stores the frequency of  
        // all single digit in  
        // three-digit number 
        $freq[10] = array(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 
$number = "31462708"; 
$l = strlen($number); 
  
if (solve($number, $l)) 
    echo "Yes"; 
else
    echo "No"; 
  
// This code is contributed 
// by Akanksha Rai(Abby_akku) 