Pension Scheme Tax Reference Number Validation using Regular Expressions
Last Updated :
31 Jan, 2023
Given some Pension Scheme Tax Reference Numbers, the task is to check if they are valid or not using regular expressions. Rules for the valid Tax Reference Numbers are :
- It is an alphanumeric string ie., digits(0-9) and Uppercase Alphabet letters(A-Z).
- It does not contain whitespaces and other special characters.
- It starts with a digit and ends wends an alphabet letter.
- The first 8 places are reserved for digits, the next one place is reserved for the alphabet letter ‘R’ next one space is occupied by an alphabet letter.
- Its length should be equal to 10.
Examples:
Input: str = ”12345678RC”
Output: True
Input: str = ”RC12345678”
Output: False
Explanation:It should start with digit and end with upper case alphabet letter.
Approach: The problem can be solved based on the following idea:
Create a regex pattern to validate the number as written below:
regex = “^[0-9]{8}[R]{1}[A-HJ-NP-TV-Z]{1}$“
Where,
- ^ : Indicate the start of the string
- [0-9]{8} : This pattern will allow 8 of the preceding items if they are digits.
- [R}{1} : this will match one of the preceding item if it is uppercase alphabet letter ‘R’.
- [A-HJ-NP-TV-Z]{1} : It will allow one of the preceding in the given range .
- $ : Indicates the end of the string.
Follow the below steps to implement the idea:
- Create a regex expression for Tax Reference Number.
- Use Pattern class to compile the regex formed.
- Use the matcher function to check whether the Tax Reference Number is valid or not.
- If it is valid, return true. Otherwise, return false.
Below is the code implementation of the above-discussed approach:
Java
import java.util.regex.*;
class GFG {
public static boolean isValidPSTaxRefNumber(String str)
{
String regex = "^[0-9]{8}[R]{1}[A-HJ-NP-TV-Z]{1}$" ;
Pattern p = Pattern.compile(regex);
if (str == null ) {
return false ;
}
Matcher m = p.matcher(str);
return m.matches();
}
public static void main(String args[])
{
String str1 = "12345678RC" ;
System.out.println(isValidPSTaxRefNumber(str1));
String str2 = "RC12345678" ;
System.out.println(isValidPSTaxRefNumber(str2));
String str3 = "12345678" ;
System.out.println(isValidPSTaxRefNumber(str3));
String str4 = "12345678AB" ;
System.out.println(isValidPSTaxRefNumber(str4));
String str5 = "12071998RC" ;
System.out.println(isValidPSTaxRefNumber(str5));
}
}
|
C++
#include <iostream>
#include <regex>
using namespace std;
bool isValidPSTaxRefNumber(string str)
{
const regex pattern(
"^[0-9]{8}[R]{1}[A-HJ-NP-TV-Z]{1}$" );
if (str.empty()) {
return false ;
}
if (regex_match(str, pattern)) {
return true ;
}
else {
return false ;
}
}
int main()
{
string str1 = "12345678RC" ;
cout << isValidPSTaxRefNumber(str1) << endl;
string str2 = "RC12345678" ;
cout << isValidPSTaxRefNumber(str2) << endl;
string str3 = "12345678" ;
cout << isValidPSTaxRefNumber(str3) << endl;
string str4 = "12345678AB" ;
cout << isValidPSTaxRefNumber(str4) << endl;
string str5 = "12071998RC" ;
cout << isValidPSTaxRefNumber(str5) << endl;
return 0;
}
|
Python3
import re
def isValidPSTaxRefNumber( str ):
regex = "^[0-9]{8}[R]{1}[A-HJ-NP-TV-Z]{1}$"
p = re. compile (regex)
if ( str = = None ):
return False
if (re.search(p, str )):
return True
else :
return False
str1 = "12345678RC"
print (isValidPSTaxRefNumber(str1))
str2 = "RC12345678"
print (isValidPSTaxRefNumber(str2))
str3 = "12345678"
print (isValidPSTaxRefNumber(str3))
str4 = "12345678AB"
print (isValidPSTaxRefNumber(str4))
str5 = "12071998RC"
print (isValidPSTaxRefNumber(str5))
|
C#
using System;
using System.Text.RegularExpressions;
class GFG {
static void Main( string [] args)
{
string [] str
= { "12345678RC" , "RC12345678" , "12345678" ,
"12345678AB" , "12071998RC" };
foreach ( string s in str)
{
Console.WriteLine(isValidPSTaxRefNumber(s)
? "true"
: "false" );
}
Console.ReadKey();
}
public static bool isValidPSTaxRefNumber( string str)
{
string strRegex
= @"^[0-9]{8}[R]{1}[A-HJ-NP-TV-Z]{1}$" ;
Regex re = new Regex(strRegex);
if (re.IsMatch(str))
return ( true );
else
return ( false );
}
}
|
PHP
<?php
function isValidPSTaxRefNumber( $str ){
if (preg_match( '/^[0-9]{8}[R]{1}[A-HJ-NP-TV-Z]{1}$/' , $str )) {
echo "true\n" ;
} else {
echo "false\n" ;
}
}
isValidPSTaxRefNumber( "12345678RC" );
isValidPSTaxRefNumber( "RC12345678" );
isValidPSTaxRefNumber( "12345678" );
isValidPSTaxRefNumber( "12345678AB" );
isValidPSTaxRefNumber( "12071998RC" );
?>
|
Javascript
function isValidPSTaxRefNumber(str) {
let regex = new RegExp(/^[0-9]{8}[R]{1}[A-HJ-NP-TV-Z]{1}$/);
if (str == null ) {
return "false" ;
}
if (regex.test(str) == true ) {
return "true" ;
}
else {
return "false" ;
}
}
let str1 = "12345678RC" ;
console.log(isValidPSTaxRefNumber(str1));
let str2 = "RC12345678" ;
console.log(isValidPSTaxRefNumber(str2));
let str3 = "12345678" ;
console.log(isValidPSTaxRefNumber(str3));
let str4 = "12345678AB" ;
console.log(isValidPSTaxRefNumber(str4));
let str5 = "12071998RC" ;
console.log(isValidPSTaxRefNumber(str5));
|
Output
true
false
false
false
true
Time complexity: O(n) // where n is the length of the string.
Auxiliary space: O(1).
Related Articles:
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...