Given a range [L, R]. The task is to find the total number of Hexadecimal alphabets that are required to write every number in the range.
Hexadecimal alphabets are the alphabets in the range [A, F] that are required to represent decimal numbers from the range [10, 15]
Examples:
Input: L = 10, R = 15
Output: 6
All the numbers from 10 to 15 contain a hexadecimal alphabet.
Input: L = 15, R = 16
Output: 1
15 and 16 are represented in hexadecimal as F and 10 respectively.
Approach:
- First of all, check if num ? 10 and num ? 15. If yes then increment the count as decimal numbers from 10 to 15 containing a hexadecimal alphabet.
- If num > 15 then update the number as num = num % 16. If it is greater than 10 then increment the count.
- Repeat 2nd step till the number (for every number) is greater than 0.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int countHexadecimal( int L, int R)
{
int count = 0;
for ( int i = L; i <= R; i++) {
if (i >= 10 && i <= 15)
count++;
else if (i > 15) {
int k = i;
while (k != 0) {
if (k % 16 >= 10)
count++;
k = k / 16;
}
}
}
return count;
}
int main()
{
int L = 5, R = 100;
cout << countHexadecimal(L, R);
return 0;
}
|
Java
class GFG
{
static int countHexadecimal( int L, int R)
{
int count = 0 ;
for ( int i = L; i <= R; i++)
{
if (i >= 10 && i <= 15 )
count++;
else if (i > 15 )
{
int k = i;
while (k != 0 )
{
if (k % 16 >= 10 )
count++;
k = k / 16 ;
}
}
}
return count;
}
public static void main(String args[])
{
int L = 5 , R = 100 ;
System.out.print(countHexadecimal(L, R));
}
}
|
Python3
def countHexadecimal(L, R) :
count = 0 ;
for i in range (L, R + 1 ) :
if (i > = 10 and i < = 15 ) :
count + = 1 ;
elif (i > 15 ) :
k = i;
while (k ! = 0 ) :
if (k % 16 > = 10 ) :
count + = 1 ;
k = k / / 16 ;
return count;
if __name__ = = "__main__" :
L = 5 ; R = 100 ;
print (countHexadecimal(L, R));
|
C#
using System;
class GFG
{
static int countHexadecimal( int L, int R)
{
int count = 0;
for ( int i = L; i <= R; i++)
{
if (i >= 10 && i <= 15)
count++;
else if (i > 15)
{
int k = i;
while (k != 0)
{
if (k % 16 >= 10)
count++;
k = k / 16;
}
}
}
return count;
}
public static void Main()
{
int L = 5, R = 100;
Console.Write(countHexadecimal(L, R));
}
}
|
PHP
<?php
function countHexadecimal( $L , $R )
{
$count = 0;
for ( $i = $L ; $i <= $R ; $i ++)
{
if ( $i >= 10 && $i <= 15)
$count ++;
else if ( $i > 15)
{
$k = $i ;
while ( $k != 0)
{
if ( $k % 16 >= 10)
$count ++;
$k = $k / 16;
}
}
}
return $count ;
}
$L = 5;
$R = 100;
echo countHexadecimal( $L , $R );
?>
|
Javascript
<script>
function countHexadecimal(L, R)
{
var count = 0;
for ( var i = L; i <= R; i++) {
if (i >= 10 && i <= 15)
count++;
else if (i > 15) {
var k = i;
while (k != 0) {
if (k % 16 >= 10)
count++;
k = k / 16;
}
}
}
return count;
}
var L = 5, R = 100;
document.write( countHexadecimal(L, R));
</script>
|
Time Complexity: O(N * log16 N), Here N is the range (R – L) and for every number, we need log16 N time to calculate the number of hexadecimal alphabets.
Auxiliary Space: O(1), As constant extra space is used.
Method 2: Using string manipulation and set intersection
1. This method uses a set intersection operation to check if the hexadecimal characters are present in the hexadecimal string of each number in the range.
2. It initializes a set of hexadecimal characters and loops through each number in the range.
3. It then computes the hexadecimal string of the number using the built-in hex function and removes the ‘0x’ prefix using string slicing.
4. It checks if the intersection of the set of hexadecimal characters and the set of characters in the hexadecimal string is non-empty, indicating the presence of a hexadecimal character. If the intersection is non-empty, the count is incremented.
C++
#include <bits/stdc++.h>
using namespace std;
int count_hex_numbers( int L, int R) {
int count = 0;
set< char > hex_chars = { 'a' , 'b' , 'c' , 'd' , 'e' , 'f' , 'A' , 'B' , 'C' , 'D' , 'E' , 'F' };
for ( int num = L; num <= R; num++) {
stringstream ss;
ss << hex << num;
string hex_str = ss.str();
for ( char c : hex_str) {
if (hex_chars.count(c)) {
count += 1;
break ;
}
}
}
return count;
}
int main() {
int L = 10;
int R = 15;
cout << count_hex_numbers(L, R) << endl;
return 0;
}
|
Java
import java.util.*;
public class GFG {
public static int countHexNumbers( int L, int R) {
int count = 0 ;
Set<Character> hexChars = new HashSet<Character>();
hexChars.addAll(Arrays.asList( 'a' , 'b' , 'c' , 'd' , 'e' , 'f' , 'A' , 'B' , 'C' , 'D' , 'E' , 'F' ));
for ( int num = L; num <= R; num++) {
Set<Character> digits = new HashSet<Character>();
for ( char c : Integer.toHexString(num).toCharArray()) {
digits.add(c);
}
digits.remove( 'x' );
if (!Collections.disjoint(digits, hexChars)) {
count++;
}
}
return count;
}
public static void main(String[] args) {
int L = 10 ;
int R = 15 ;
System.out.println(countHexNumbers(L, R));
}
}
|
Python3
def count_hex_numbers(L, R):
count = 0
hex_chars = set ( 'abcdefABCDEF' )
for num in range (L, R + 1 ):
if set ( hex (num)[ 2 :]) & hex_chars:
count + = 1
return count
L = 10
R = 15
print (count_hex_numbers(L, R))
|
Javascript
function count_hex_numbers(L, R) {
let count = 0;
let hex_chars = new Set([ 'a' , 'b' , 'c' , 'd' , 'e' , 'f' , 'A' , 'B' , 'C' , 'D' , 'E' , 'F' ]);
for (let num = L; num <= R; num++) {
let hex_str = num.toString(16);
if (hex_str.slice(0, 2) === '0x' )
hex_str = hex_str.slice(2);
if (hex_chars.has(hex_str))
count += 1;
}
return count;
}
let L = 10;
let R = 15;
console.log(count_hex_numbers(L, R));
|
C#
using System;
using System.Collections.Generic;
namespace HexCount {
class Program {
static int CountHexNumbers( int L, int R)
{
int count = 0;
HashSet< char > hexChars
= new HashSet< char >{ 'a' , 'b' , 'c' , 'd' ,
'e' , 'f' , 'A' , 'B' ,
'C' , 'D' , 'E' , 'F' };
for ( int num = L; num <= R; num++) {
string hexStr = num.ToString( "X" );
foreach ( char c in hexStr)
{
if (hexChars.Contains(c)) {
count += 1;
break ;
}
}
}
return count;
}
static void Main( string [] args)
{
int L = 10;
int R = 15;
Console.WriteLine(CountHexNumbers(L, R));
}
}
}
|
Time complexity: O((R-L+1) * k), where k is the length of the maximum hexadecimal string in the range.
The reason for this is that the method loops through each number in the range (R-L+1 numbers), computes its hexadecimal string using the built-in hex function (which takes time proportional to the number of digits in the hexadecimal representation), removes the ‘0x’ prefix using string slicing (which takes constant time), and checks if the intersection of the set of hexadecimal characters and the set of characters in the hexadecimal string is non-empty using the & operator (which takes time proportional to the length of the sets being intersected). The maximum length of the hexadecimal string is k, which is log base 16 of the maximum number in the range.
Auxiliary space: O(k), since it creates a set of hexadecimal characters with constant size and potentially creates a set of characters in the hexadecimal string for each number in the range with maximum size k. However, since k is a fixed constant, the space complexity is considered O(1) in practice.
Last Updated :
27 Mar, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...