 GeeksforGeeks App
Open App Browser
Continue

# Check the divisibility of Hexadecimal numbers

Given a string S consisting of a large hexadecimal number, the task is to check its divisibility by a given decimal number M. If divisible then print Yes else print No.

Examples:

Input: S = “10”, M = 4
Output: Yes
10 is 16 in decimal and (16 % 4) = 0

Input: S = “10”, M = 5
Output: No

Approach 1: In this approach, we first convert the hexadecimal number to decimal using the algorithm to convert a number from one base to another. Then, we simply check if the decimal number is divisible by the given number M using the modulo operator.

Here are the steps of above approach:

• Convert the given hexadecimal number to a decimal number. To do this, initialize a decimal_num variable to 0 and a base variable to 1. Iterate over the hexadecimal number from right to left and convert each hexadecimal digit to its decimal equivalent. If a character is not a valid hexadecimal digit, return false. Multiply the decimal equivalent of each digit by the base and add it to decimal_num. Finally, multiply the base by 16.
• Check whether the decimal_num is divisible by m using the modulo operator. If the remainder is 0, return true, else return false.

Below is the implementation of the above approach:

## C++

 `#include ``using` `namespace` `std;` `// Function that returns true``// if s is divisible by m``bool` `isDivisible(string s, ``int` `m)``{``    ``// Convert hexadecimal number to decimal``    ``int` `decimal_num = 0;``    ``int` `base = 1;``    ``int` `n = s.length();``    ``for` `(``int` `i = n - 1; i >= 0; i--) {``        ``int` `digit;``        ``if` `(s[i] >= ``'0'` `&& s[i] <= ``'9'``) {``            ``digit = s[i] - ``'0'``;``        ``} ``else` `if` `(s[i] >= ``'A'` `&& s[i] <= ``'F'``) {``            ``digit = s[i] - ``'A'` `+ 10;``        ``} ``else` `{``            ``// Invalid character in hexadecimal number``            ``return` `false``;``        ``}``        ``decimal_num += digit * base;``        ``base *= 16;``    ``}``    ``// Check if decimal_num is divisible by m``    ``return` `decimal_num % m == 0;``}` `// Driver code``int` `main()``{``    ``string s = ``"10"``;``    ``int` `m = 4;` `    ``if` `(isDivisible(s, m))``        ``cout << ``"Yes"``;``    ``else``        ``cout << ``"No"``;` `    ``return` `0;``}`

## Java

 `// Java code implementation of above approach``import` `java.util.*;` `public` `class` `Main``{``  ` `    ``// Function that returns true``    ``// if s is divisible by m``    ``public` `static` `boolean` `isDivisible(String s, ``int` `m)``    ``{``      ` `        ``// Convert hexadecimal number to decimal``        ``int` `decimal_num = ``0``;``        ``int` `base = ``1``;``        ``int` `n = s.length();``        ``for` `(``int` `i = n - ``1``; i >= ``0``; i--) {``            ``int` `digit;``            ``if` `(s.charAt(i) >= ``'0'` `&& s.charAt(i) <= ``'9'``) {``                ``digit = s.charAt(i) - ``'0'``;``            ``} ``else` `if` `(s.charAt(i) >= ``'A'` `&& s.charAt(i) <= ``'F'``) {``                ``digit = s.charAt(i) - ``'A'` `+ ``10``;``            ``} ``else` `{``                ``// Invalid character in hexadecimal number``                ``return` `false``;``            ``}``            ``decimal_num += digit * base;``            ``base *= ``16``;``        ``}``        ``// Check if decimal_num is divisible by m``        ``return` `decimal_num % m == ``0``;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args) {``        ``String s = ``"10"``;``        ``int` `m = ``4``;` `        ``if` `(isDivisible(s, m))``            ``System.out.println(``"Yes"``);``        ``else``            ``System.out.println(``"No"``);``    ``}``}`

Output

`Yes`

Time Complexity: O(n), where n is the length of the input string.
Auxiliary Space: O(1)

Approach 2: An approach used in this article will be used to avoid overflow. Iterate the entire string from the back-side.
If the remainder of the sub-string S[0…i] is known on division with M. Let’s call this remainder as R. This can be used to get the remainder when the substring S[0…i+1] is divided. To do that, first left shift the string S[0…i] by 1. This will be equivalent to multiplying the string by 16. Then, add S[i+1] to this and take its mod with M. With a little bit of modular arithmetic it boils down to

S[0…i+1] % M = (S[0…i] * 16 + S[i+1]) % M = ((S[0…i] % M * 16) + S[i+1]) % M

Thus, continue the above steps till the end of the string. If the final remainder is 0 then the string is divisible otherwise it is not.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `const` `string CHARS = ``"0123456789ABCDEF"``;``const` `int` `DIGITS = 16;` `// Function that returns true``// if s is divisible by m``bool` `isDivisible(string s, ``int` `m)``{``    ``// Map to map characters to real values``    ``unordered_map<``char``, ``int``> mp;` `    ``for` `(``int` `i = 0; i < DIGITS; i++) {``        ``mp[CHARS[i]] = i;``    ``}` `    ``// To store the remainder at any stage``    ``int` `r = 0;` `    ``// Find the remainder``    ``for` `(``int` `i = 0; i < s.size(); i++) {``        ``r = (r * 16 + mp[s[i]]) % m;``    ``}` `    ``// Check the value of remainder``    ``if` `(!r)``        ``return` `true``;``    ``return` `false``;``}` `// Driver code``int` `main()``{``    ``string s = ``"10"``;``    ``int` `m = 4;` `    ``if` `(isDivisible(s, m))``        ``cout << ``"Yes"``;``    ``else``        ``cout << ``"No"``;` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.util.*;` `class` `GFG``{` `static` `char` `[]CHARS = ``"0123456789ABCDEF"``.toCharArray();``static` `int` `DIGITS = ``16``;` `// Function that returns true``// if s is divisible by m``static` `boolean` `isDivisible(String s, ``int` `m)``{``    ``// Map to map characters to real values``    ``Map mp = ``new` `HashMap<>();` `    ``for` `(``int` `i = ``0``; i < DIGITS; i++)``    ``{        ``        ``mp. put(CHARS[i], i);``    ``}` `    ``// To store the remainder at any stage``    ``int` `r = ``0``;` `    ``// Find the remainder``    ``for` `(``int` `i = ``0``; i < s.length(); i++)``    ``{``        ``r = (r * ``16` `+ mp.get(s.charAt(i))) % m;``    ``}` `    ``// Check the value of remainder``    ``if` `(r == ``0``)``        ``return` `true``;``    ``return` `false``;``}` `// Driver code``public` `static` `void` `main(String []args)``{``    ``String s = ``"10"``;``    ``int` `m = ``3``;` `    ``if` `(isDivisible(s, m))``        ``System.out.println(``"Yes"``);``    ``else``        ``System.out.println(``"No"``);``}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 implementation of the approach``CHARS ``=` `"0123456789ABCDEF"``;``DIGITS ``=` `16``;` `# Function that returns true``# if s is divisible by m``def` `isDivisible(s, m) :` `    ``# Map to map characters to real value``    ``mp ``=` `dict``.fromkeys(CHARS, ``0``);` `    ``for` `i ``in` `range``( DIGITS) :``        ``mp[CHARS[i]] ``=` `i;` `    ``# To store the remainder at any stage``    ``r ``=` `0``;` `    ``# Find the remainder``    ``for` `i ``in` `range``(``len``(s)) :``        ``r ``=` `(r ``*` `16` `+` `mp[s[i]]) ``%` `m;` `    ``# Check the value of remainder``    ``if` `(``not` `r) :``        ``return` `True``;``        ` `    ``return` `False``;` `# Driver code``if` `__name__ ``=``=` `"__main__"` `:``    ` `    ``s ``=` `"10"``;``    ``m ``=` `3``;` `    ``if` `(isDivisible(s, m)) :``        ``print``(``"Yes"``);``    ``else` `:``        ``print``(``"No"``);` `# This code is contributed by AnkitRai01`

## C#

 `// C# implementation of the approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{` `static` `char` `[]CHARS = ``"0123456789ABCDEF"``.ToCharArray();``static` `int` `DIGITS = 16;` `// Function that returns true``// if s is divisible by m``static` `bool` `isDivisible(String s, ``int` `m)``{``    ``// Map to map characters to real values``    ``Dictionary<``char``, ``int``> mp = ``new` `Dictionary<``char``, ``int``>();` `    ``for` `(``int` `i = 0; i < DIGITS; i++)``    ``{        ``        ``if``(mp.ContainsKey(CHARS[i]))``            ``mp[CHARS[i]] = i;``        ``else``            ``mp.Add(CHARS[i], i);``    ``}` `    ``// To store the remainder at any stage``    ``int` `r = 0;` `    ``// Find the remainder``    ``for` `(``int` `i = 0; i < s.Length; i++)``    ``{``        ``r = (r * 16 + mp[s[i]]) % m;``    ``}` `    ``// Check the value of remainder``    ``if` `(r == 0)``        ``return` `true``;``    ``return` `false``;``}` `// Driver code``public` `static` `void` `Main(String []args)``{``    ``String s = ``"10"``;``    ``int` `m = 3;` `    ``if` `(isDivisible(s, m))``        ``Console.WriteLine(``"Yes"``);``    ``else``        ``Console.WriteLine(``"No"``);``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output

`Yes`

Time complexity: O(n)
Auxiliary Space: O(log(n))

My Personal Notes arrow_drop_up