Check if the sum of digits of number is divisible by all of its digits

Given an integer N, the task is to check whether the sum of digits of the given number is divisible by all of its digits or not. If divisible then print Yes else print No.

Examples:

Input: N = 12 
Output: No 
Sum of digits = 1 + 2 = 3 
3 is divisible by 1 but not 2.

Input: N = 123 
Output: Yes 

Approach: First find the sum of the digits of the number then one by one check, whether the calculated sum is divisible by all the digits of the number. If for some digit it is not divisible then print No else print Yes.

Below is the implementation of the above approach: 

C++

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;

// Function that returns true if all the digits
// of n divide the sum of the digits of n
bool isDivisible(long long int n)
{

    // Store a copy of the original number
    long long int temp = n;

    // Find the sum of the digits of n
    int sum = 0;
    while (n) {
        int digit = n % 10;
        sum += digit;
        n /= 10;
    }

    // Restore the original value
    n = temp;

    // Check if all the digits divide
    // the calculated sum
    while (n) {
        int digit = n % 10;

        // If current digit doesn't
        // divide the sum
        if (sum % digit != 0)
            return false;

        n /= 10;
    }

    return true;
}

// Driver code
int main()
{
    long long int n = 123;

    if (isDivisible(n))
        cout << "Yes";
    else
        cout << "No";

    return 0;
}

Java

// Java implementation of the approach
public class GFG
{

    // Function that returns true if all the digits
    // of n divide the sum of the digits of n
    static boolean isDivisible(long n)
    {

        // Store a copy of the original number
        long temp = n;

        // Find the sum of the digits of n
        int sum = 0;
        while (n != 0)
        {
            int digit = (int) n % 10;
            sum += digit;
            n /= 10;
        }

        // Restore the original value
        n = temp;

        // Check if all the digits divide
        // the calculated sum
        while (n != 0)
        {
            int digit = (int)n % 10;

            // If current digit doesn't
            // divide the sum
            if (sum % digit != 0)
                return false;

            n /= 10;
        }
        return true;
    }

    // Driver code
    public static void main (String[] args)
    {
        long n = 123;

        if (isDivisible(n))
            System.out.println("Yes");
        else
            System.out.println("No");
    }
}

// This code is contributed by AnkitRai01

Python

# Python implementation of the approach

# Function that returns true if all the digits
# of n divide the sum of the digits of n
def isDivisible(n):

    # Store a copy of the original number
    temp = n

    # Find the sum of the digits of n
    sum = 0
    while (n):
        digit = n % 10
        sum += digit
        n //= 10

    # Restore the original value
    n = temp

    # Check if all the digits divide
    # the calculated sum
    while(n):
        digit = n % 10

        # If current digit doesn't
        # divide the sum
        if(sum % digit != 0):
            return False

        n //= 10;

    return True

# Driver code
n = 123
if(isDivisible(n)):
    print("Yes")
else:
    print("No")

C#

// C# implementation of the approach
using System;

class GFG
{

    // Function that returns true if all the digits
    // of n divide the sum of the digits of n
    static bool isDivisible(long n)
    {

        // Store a copy of the original number
        long temp = n;

        // Find the sum of the digits of n
        int sum = 0;
        while (n != 0)
        {
            int digit = (int) n % 10;
            sum += digit;
            n /= 10;
        }

        // Restore the original value
        n = temp;

        // Check if all the digits divide
        // the calculated sum
        while (n != 0)
        {
            int digit = (int)n % 10;

            // If current digit doesn't
            // divide the sum
            if (sum % digit != 0)
                return false;

            n /= 10;
        }
        return true;
    }

    // Driver code
    static public void Main ()
    {
        long n = 123;

        if (isDivisible(n))
            Console.Write("Yes");
        else
            Console.Write("No");
    }
}

// This code is contributed by @tushil.

Javascript

<script>

// Javascript implementation of the approach

// Function that returns true if all the
// digits of n divide the sum of the digits
// of n
function isDivisible(n)
{

    // Store a copy of the original number
    var temp = n;

    // Find the sum of the digits of n
    var sum = 0;

    while (n != 0)
    {
        var digit = parseInt(n % 10);
        sum += digit;
        n = parseInt(n / 10);
    }

    // Restore the original value
    n = temp;

    // Check if all the digits divide
    // the calculated sum
    while (n != 0)
    {
        var digit = parseInt(n % 10);

        // If current digit doesn't
        // divide the sum
        if (sum % digit != 0)
            return false;

        n = parseInt(n/10);
    }
    return true;
}

// Driver code
var n = 123;

if (isDivisible(n))
    document.write("Yes");
else
    document.write("No");

// This code is contributed by todaysgaurav

</script>

Output

Yes

Time Complexity: O(log(N)) 
Auxiliary Space: O(1)

Method #2: Using string:

• We have to convert the given number to a string by taking a new variable.
• Traverse the string ,Convert each element to integer and add this to sum.
• Traverse the string again
• Check if the sum is not divisible by any one of the digits
• If it is true then return False
• Else return True

Below is the implementation of above approach:

C++

// C++ implementation of above approach
#include <bits/stdc++.h>
using namespace std;

string getResult(int n)
{

    // Converting integer to string
    string st = to_string(n);

    // Initialising sum to 0
    int sum = 0;
    int length = st.size();

    // Traversing through the string
    for (int i = 0; i < st.size(); i++) {

        // Converting character to int
        sum = sum + (int(st[i]) - 48);
    }

    // Comparing number and sum
    // Traversing again
    for (int i = 0; i < st.size(); i++) {

        // Check if any digit is
        // not dividing the sum
        if (sum % (int(st[i]) - 48) != 0) {

            // Return false
            return "No";
        }

        // If any value is not returned
        // then all the digits are dividing the sum
        // SO return true
        else {
            return "Yes";
        }
    }
}

// Driver Code
int main()
{
    int n = 123;

    // passing this number to get result function
    cout << getResult(n);
    return 0;
}

// This code is contributed by subhamkumarm348.

Java

// Java implementation of the approach
import java.io.*;
import java.util.*;

class GFG
{
     // Function that returns true if all the digits
     // of n divide the sum of the digits of n
     public static String getResult(int n)
     {
         // Converting integer to string
         String st = String.valueOf(n);

         // Initialising sum to 0
         int sum = 0;
         int length = st.length();

         // Traversing through the string
         for (int i = 0; i < length; i++)
         {
             // Converting character to int
             int c = st.charAt(i)-48;
             sum += c;
         }

         // Comparing number and sum
         // Traversing again
         for (int i = 0; i < length; i++)
         {
             // Check if any digit is
             // not dividing the sum
             int c = st.charAt(i)-48;
             if (sum % c != 0)
             {
                 // Return false
                 return "No";
             }

             // If any value is not returned
             // then all the digits are dividing the sum
             // SO return true
             else
             {
                 return "Yes";
             }
         }
         return "No";
    }

    // Driver code
    public static void main (String[] args)
    {
        int n = 123;

        // passing this number to get result function
        System.out.println(getResult(n));
    }
}

// This code is contributed by aditya942003patil

Python3

# Python implementation of above approach
def getResult(n):

    # Converting integer to string
    st = str(n)

    # Initialising sum to 0
    sum = 0
    length = len(st)

    # Traversing through the string
    for i in st:

        # Converting character to int
        sum = sum + int(i)

    # Comparing number and sum
    # Traversing again
    for i in st:

        # Check if any digit is
        # not dividing the sum
        if(sum % int(i) != 0):

            # Return false
            return 'No'

    # If any value is not returned
    # then all the digits are dividing the sum
    # SO return true
    return 'Yes'


# Driver Code
n = 123

# passing this number to get result function
print(getResult(n))

# this code is contributed by vikkycirus

C#

// C# program to implement above approach
using System;
using System.Collections.Generic;

class GFG
{

  static string getResult(int n)
  {

    // Converting integer to string
    string st = n.ToString();

    // Initialising sum to 0
    int sum = 0;
    int length = st.Length;

    // Traversing through the string
    for (int i = 0; i < length; i++) {

        // Converting character to int
        sum = sum + ((int)st[i] - 48);
    }

    // Comparing number and sum
    // Traversing again
    for (int i = 0; i < length; i++) {

        // Check if any digit is
        // not dividing the sum
        if (sum % ((int)st[i] - 48) != 0) {
            return "No";
        }

        // If any value is not returned
        // then all the digits are dividing the sum
        // SO return true
        else {
            return "Yes";
        }
    }

    return "No";
  }

  // Driver Code
  public static void Main(string[] args){

    int n = 123;

    // Function call
    Console.Write(getResult(n));
  }
}

// This code is contributed by adityapatil12.

Javascript

<script>

// JavaScript implementation of above approach

function getResult(n){

    // Converting integer to string
    var st = n.toString();

    // Initialising sum to 0
    var sum = 0
    var length = st.length;

    // Traversing through the string
    for (var i= 0 ;i<st.length ; i++){

        // Converting character to int
        sum = sum + Number(st[i])
    }

    // Comparing number and sum
    // Traversing again
    for( var i = 0 ; i < st.length ; i++){

        // Check if any digit is
        // not dividing the sum
        if(sum % Number(st[i]) != 0){

            // Return false
            return 'No'
        }

    // If any value is not returned
    // then all the digits are dividing the sum
    // SO return true
        else{
            return 'Yes';
          }
    }


}


// Driver Code
var n = 123;

// passing this number to get result function
document.write(getResult(n));


</script>

Output

Yes

Time Complexity: O(n), where n represents the length of the given string.
Auxiliary Space: O(d), where d represents the number of digits in the string.