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

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

Javascript

<script>

      // JavaScript 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 (parseInt(n) % 8 === 0) return true;

          // check for the reverse
          // of a number
          n = reverse(n);

          if (parseInt(n) % 8 === 0) return true;
          return false;
        }

        // Stores the Frequency of
        // characters in the n.
        var hash = new Array(10).fill(0);
        for (var i = 0; i < l; i++) hash[parseInt(n[i]) - 0]++;

        // Iterates for all
        // three digit numbers
        // divisible by 8
        for (var i = 104; i < 1000; i += 8) {
          var dup = i;

          // stores the frequency of
          // all single digit in
          // three-digit number
          var freq = new Array(10).fill(0);
          freq[parseInt(dup % 10)]++;
          dup = dup / 10;
          freq[parseInt(dup % 10)]++;
          dup = dup / 10;
          freq[parseInt(dup % 10)]++;

          dup = i;

          // check if the original
          // number has the digit
          if (freq[parseInt(dup % 10)] > hash[parseInt(dup % 10)])
          continue;
          dup = dup / 10;

          if (freq[parseInt(dup % 10)] > hash[parseInt(dup % 10)])
          continue;
          dup = dup / 10;

          if (freq[parseInt(dup % 10)] > hash[parseInt(dup % 10)])
          continue;

          return true;
        }

        // when all are checked
        // its not possible
        return false;
      }

      function reverse(input) {
        var a = input.split("");
        var l,
          r = 0;
        r = a.length - 1;

        for (l = 0; l < r; l++, r--) {
          // Swap values of l and r
          var temp = a[l];
          a[l] = a[r];
          a[r] = temp;
        }
        return a.join("");
      }

      // Driver Code
      var number = "31462708";

      var l = number.length;

      if (solve(number, l))
      document.write("Yes");
      else
      document.write("No");

</script>

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