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

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

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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.sort(reverse = True)
          
        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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Output:

Yes

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



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.