Open In App

Program to check if a number belongs to a particular base or not

Improve
Improve
Like Article
Like
Save
Share
Report

TiGiven a number N and its radix base R, find whether its valid or not according to its radix base. 
Find valid/invalid number for any base ranging from binary to base32. 

Examples: 

Input : 1000101010001
Output : Valid
1000101010001 is valid binary number.

Input : 0xFFFAG
Output : invalid
0xFFFAG is not a valid hexa-decimal number because of character 'G' .

Method used : strspn

  • strspn :
strspn(numStr, validNumber)
Strspan: 
returns number of matching digits from 
character-set provided, so here it will return 1 - N,
where N is length of validNumber String.
numStr[]  : 
And that number is provided to numStr[] array.
  • numStr : 
numStr[strspn(numStr, validNumber)]
Using this number as index for numStr[] array,
we access the digit there and it will be NULL 
in case string is matched and it will be non-zero 
if string is not matched
  • !numStr : And Finally we invert the result using invert operator to match for true case ! 
!numStr[strspn(numStr, validNumber)]

C++




// Program to check if a number belongs
// to particular base or not#include
 
#include <cstdio>
#include <cstdlib>
#include <cstring>
 
#define BINARY_BASE 2 // Defining binary base
#define OCTAL_BASE 8 // Defining octal base
#define DECIMAL_BASE 10 // Defining decimal base
#define HEXA_BASE 16 // Defining hexa-decimal base
#define BASE32_BASE 32 // Defining base32 base
 
// Function prototypes
bool isValid(const char* numStr, int base);
const char* print(bool status);
 
// Main method for base check
int main(void)
{
    // Defining valid/invalid numbers in radix bases
    char* binaryStr = "1000101010001";
    char* decimalStr = "45221";
    char* base32Str = "AD22F";
 
    // invalid
    char* octalStr = "7778A";
    char* hexStr = "FAG463";
 
    // Printing status of radix bases
    printf("Binary string %s is %s\n", binaryStr,
           print(isValid(binaryStr, BINARY_BASE)));
    printf("Octal string %s is %s\n", octalStr,
           print(isValid(hexStr, OCTAL_BASE)));
    printf("Decimal string %s is %s\n", decimalStr,
           print(isValid(decimalStr, DECIMAL_BASE)));
    printf("Hex string %s is %s\n", hexStr,
           print(isValid(hexStr, HEXA_BASE)));
    printf("Base32 string %s is %s\n", base32Str,
           print(isValid(base32Str, BASE32_BASE)));
 
    return 0;
}
 
bool isValid(const char* numStr, int base)
{
    // Defining valid base strings
    const char* validBinary = "01";
    const char* validOctal = "01234567";
    const char* validDecimal = "0123456789";
    const char* validHex = "0123456789abcdefABCDEF";
    const char* validBase32 = "0123456789abcdefghijklmnopqrstuvABCDEFGHIJKLMNOPQRSTUV";
    const char* validNumber = NULL;
 
    // Checking for valid base
    validNumber = (base == BINARY_BASE)
                      ? validBinary
                      : ((base == OCTAL_BASE)
                             ? validOctal
                             : (base == DECIMAL_BASE)
                                   ? validDecimal
                                   : (base == HEXA_BASE)
                                         ? validHex
                                         : (base == BASE32_BASE)
                                               ? validBase32
                                               : NULL);
 
    // Error checking for invalid base
    if (validNumber == NULL) {
        fputs("Invalid base encountered", stderr);
        exit(EXIT_FAILURE);
    }
 
    // Check for valid base string using strspn
    return (!numStr[strspn(numStr, validNumber)]) ? true : false;
}
 
const char* print(bool status)
{
    return (status) ? "Valid" : "Invalid";
}


Java




import java.util.*;
 
public class BaseChecker {
    private static final int BINARY_BASE = 2;
    private static final int OCTAL_BASE = 8;
    private static final int DECIMAL_BASE = 10;
    private static final int HEXA_BASE = 16;
    private static final int BASE32_BASE = 32;
 
    public static void main(String[] args) {
        // Defining valid/invalid numbers in radix bases
        String binaryStr = "1000101010001";
        String decimalStr = "45221";
        String base32Str = "AD22F";
 
        // invalid
        String octalStr = "7778A";
        String hexStr = "FAG463";
 
        // Printing status of radix bases
        System.out.printf("Binary string %s is %s\n", binaryStr,
                print(isValid(binaryStr, BINARY_BASE)));
        System.out.printf("Octal string %s is %s\n", octalStr,
                print(isValid(hexStr, OCTAL_BASE)));
        System.out.printf("Decimal string %s is %s\n", decimalStr,
                print(isValid(decimalStr, DECIMAL_BASE)));
        System.out.printf("Hex string %s is %s\n", hexStr,
                print(isValid(hexStr, HEXA_BASE)));
        System.out.printf("Base32 string %s is %s\n", base32Str,
                print(isValid(base32Str, BASE32_BASE)));
    }
 
    private static boolean isValid(String numStr, int base) {
        // Defining valid base strings
        String validBinary = "01";
        String validOctal = "01234567";
        String validDecimal = "0123456789";
        String validHex = "0123456789abcdefABCDEF";
        String validBase32 = "0123456789abcdefghijklmnopqrstuvABCDEFGHIJKLMNOPQRSTUV";
        String validNumber = null;
 
        // Checking for valid base
        if (base == BINARY_BASE) {
            validNumber = validBinary;
        } else if (base == OCTAL_BASE) {
            validNumber = validOctal;
        } else if (base == DECIMAL_BASE) {
            validNumber = validDecimal;
        } else if (base == HEXA_BASE) {
            validNumber = validHex;
        } else if (base == BASE32_BASE) {
            validNumber = validBase32;
        } else {
            throw new IllegalArgumentException("Invalid base encountered");
        }
 
        // Check for valid base string using a loop
        for (int i = 0; i < numStr.length(); i++) {
            if (validNumber.indexOf(numStr.charAt(i)) == -1) {
                return false;
            }
        }
        return true;
    }
 
    private static String print(boolean status) {
        return (status) ? "Valid" : "Invalid";
    }
}


Python3




BINARY_BASE = 2
OCTAL_BASE = 8
DECIMAL_BASE = 10
HEXA_BASE = 16
BASE32_BASE = 32
 
def is_valid(num_str, base):
    # Defining valid base strings
    valid_binary = "01"
    valid_octal = "01234567"
    valid_decimal = "0123456789"
    valid_hex = "0123456789abcdefABCDEF"
    valid_base32 = "0123456789abcdefghijklmnopqrstuvABCDEFGHIJKLMNOPQRSTUV"
     
    # Checking for valid base
    valid_number = None
    if base == BINARY_BASE:
        valid_number = valid_binary
    elif base == OCTAL_BASE:
        valid_number = valid_octal
    elif base == DECIMAL_BASE:
        valid_number = valid_decimal
    elif base == HEXA_BASE:
        valid_number = valid_hex
    elif base == BASE32_BASE:
        valid_number = valid_base32
    else:
        raise ValueError("Invalid base encountered")
     
    # Check for valid base string using set intersection
    return set(num_str).issubset(set(valid_number))
 
# Main method for base check
if __name__ == "__main__":
    # Defining valid/invalid numbers in radix bases
    binary_str = "1000101010001"
    decimal_str = "45221"
    base32_str = "AD22F"
 
    # invalid
    octal_str = "7778A"
    hex_str = "FAG463"
 
    # Printing status of radix bases
    print(f"Binary string {binary_str} is {'Valid' if is_valid(binary_str, BINARY_BASE) else 'Invalid'}")
    print(f"Octal string {octal_str} is {'Valid' if is_valid(hex_str, OCTAL_BASE) else 'Invalid'}")
    print(f"Decimal string {decimal_str} is {'Valid' if is_valid(decimal_str, DECIMAL_BASE) else 'Invalid'}")
    print(f"Hex string {hex_str} is {'Valid' if is_valid(hex_str, HEXA_BASE) else 'Invalid'}")
    print(f"Base32 string {base32_str} is {'Valid' if is_valid(base32_str, BASE32_BASE) else 'Invalid'}")


C#




using System;
 
public class BaseChecker
{
  private const int BINARY_BASE = 2;
  private const int OCTAL_BASE = 8;
  private const int DECIMAL_BASE = 10;
  private const int HEXA_BASE = 16;
  private const int BASE32_BASE = 32;
  public static void Main()
  {
     
    // Defining valid/invalid numbers in radix bases
    string binaryStr = "1000101010001";
    string decimalStr = "45221";
    string base32Str = "AD22F";
 
    // invalid
    string octalStr = "7778A";
    string hexStr = "FAG463";
 
    // Printing status of radix bases
    Console.WriteLine($"Binary string {binaryStr} is {Print(IsValid(binaryStr, BINARY_BASE))}");
    Console.WriteLine($"Octal string {octalStr} is {Print(IsValid(octalStr, OCTAL_BASE))}");
    Console.WriteLine($"Decimal string {decimalStr} is {Print(IsValid(decimalStr, DECIMAL_BASE))}");
    Console.WriteLine($"Hex string {hexStr} is {Print(IsValid(hexStr, HEXA_BASE))}");
    Console.WriteLine($"Base32 string {base32Str} is {Print(IsValid(base32Str, BASE32_BASE))}");
  }
 
  private static bool IsValid(string numStr, int baseValue)
  {
    // Defining valid base strings
    string validBinary = "01";
    string validOctal = "01234567";
    string validDecimal = "0123456789";
    string validHex = "0123456789abcdefABCDEF";
    string validBase32 = "0123456789abcdefghijklmnopqrstuvABCDEFGHIJKLMNOPQRSTUV";
    string validNumber = null;
 
    // Checking for valid base
    switch (baseValue)
    {
      case BINARY_BASE:
        validNumber = validBinary;
        break;
      case OCTAL_BASE:
        validNumber = validOctal;
        break;
      case DECIMAL_BASE:
        validNumber = validDecimal;
        break;
      case HEXA_BASE:
        validNumber = validHex;
        break;
      case BASE32_BASE:
        validNumber = validBase32;
        break;
      default:
        throw new ArgumentException("Invalid base encountered");
    }
 
    // Check for valid base string using a loop
    for (int i = 0; i < numStr.Length; i++)
    {
      if (validNumber.IndexOf(numStr[i]) == -1)
      {
        return false;
      }
    }
    return true;
  }
 
  private static string Print(bool status)
  {
    return (status) ? "Valid" : "Invalid";
  }
}


Javascript




const BINARY_BASE = 2;
const OCTAL_BASE = 8;
const DECIMAL_BASE = 10;
const HEXA_BASE = 16;
const BASE32_BASE = 32;
 
// Function to check if a number is valid in a particular base
function isValid(numStr, base) {
  const validBinary = '01';
  const validOctal = '01234567';
  const validDecimal = '0123456789';
  const validHex = '0123456789abcdefABCDEF';
  const validBase32 = '0123456789abcdefghijklmnopqrstuvABCDEFGHIJKLMNOPQRSTUV';
  let validNumber = null;
 
  switch (base) {
    case BINARY_BASE:
      validNumber = validBinary;
      break;
    case OCTAL_BASE:
      validNumber = validOctal;
      break;
    case DECIMAL_BASE:
      validNumber = validDecimal;
      break;
    case HEXA_BASE:
      validNumber = validHex;
      break;
    case BASE32_BASE:
      validNumber = validBase32;
      break;
    default:
      console.error('Invalid base encountered');
      return false;
  }
 
  return numStr.split('').every(c => validNumber.indexOf(c) !== -1);
}
 
// Function to print the validity status of a number
function print(status) {
  return status ? 'Valid' : 'Invalid';
}
 
// Main method
function main() {
  // Defining valid/invalid numbers in radix bases
  const binaryStr = '1000101010001';
  const decimalStr = '45221';
  const base32Str = 'AD22F';
 
  // invalid
  const octalStr = '7778A';
  const hexStr = 'FAG463';
 
  // Printing status of radix bases
  console.log(`Binary string ${binaryStr} is ${print(isValid(binaryStr, BINARY_BASE))}`);
  console.log(`Octal string ${octalStr} is ${print(isValid(hexStr, OCTAL_BASE))}`);
  console.log(`Decimal string ${decimalStr} is ${print(isValid(decimalStr, DECIMAL_BASE))}`);
  console.log(`Hex string ${hexStr} is ${print(isValid(hexStr, HEXA_BASE))}`);
  console.log(`Base32 string ${base32Str} is ${print(isValid(base32Str, BASE32_BASE))}`);
}
 
main();


Output: 

Binary string 1000101010001 is Valid
Octal string 7778A is Invalid
Decimal string 45221 is Valid
Hex string FAG463 is Invalid
Base32 string AD22F is Valid                                                                                         

Time complexity: O(1)
 



Last Updated : 16 Mar, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads