Pension Scheme Tax Reference Number Validation using Regular Expressions

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 program to validate the
// Pension Scheme Tax Reference Number
// using Regular Expression

import java.util.regex.*;

class GFG {

    // Function to validate the
    // Pension Scheme Tax Reference Number
    public static boolean isValidPSTaxRefNumber(String str)
    {

        // Regex to check valid Pension Scheme
        // Tax Reference Number
        String regex = "^[0-9]{8}[R]{1}[A-HJ-NP-TV-Z]{1}$";

        // Compile the ReGex
        Pattern p = Pattern.compile(regex);

        // If the str
        // is empty return false
        if (str == null) {
            return false;
        }

        // Pattern class contains matcher()
        // method to find matching between
        // given str using regular expression.
        Matcher m = p.matcher(str);

        // Return if the str
        // matched the ReGex
        return m.matches();
    }

    // Driver Code.
    public static void main(String args[])
    {

        // Test Case 1:
        String str1 = "12345678RC";
        System.out.println(isValidPSTaxRefNumber(str1));

        // Test Case 2:
        String str2 = "RC12345678";
        System.out.println(isValidPSTaxRefNumber(str2));

        // Test Case 3:
        String str3 = "12345678";
        System.out.println(isValidPSTaxRefNumber(str3));

        // Test Case 4:
        String str4 = "12345678AB";
        System.out.println(isValidPSTaxRefNumber(str4));

        // Test Case 5:
        String str5 = "12071998RC";
        System.out.println(isValidPSTaxRefNumber(str5));
    }
}

// C++ program to validate the
// Pension Scheme Tax Reference Number using
// Regular Expression

#include <iostream>
#include <regex>
using namespace std;

// Function to validate the
// Pension Scheme Tax Reference Number
bool isValidPSTaxRefNumber(string str)
{

    // Regex to check valid
    // Pension Scheme Tax Reference Number
    const regex pattern(
        "^[0-9]{8}[R]{1}[A-HJ-NP-TV-Z]{1}$");

    // If the str
    // is empty return false
    if (str.empty()) {
        return false;
    }

    // Return true if the str
    // matched the ReGex
    if (regex_match(str, pattern)) {
        return true;
    }
    else {
        return false;
    }
}

// Driver Code
int main()
{
    // Test Case 1:
    string str1 = "12345678RC";
    cout << isValidPSTaxRefNumber(str1) << endl;

    // Test Case 2:
    string str2 = "RC12345678";
    cout << isValidPSTaxRefNumber(str2) << endl;

    // Test Case 3:
    string str3 = "12345678";
    cout << isValidPSTaxRefNumber(str3) << endl;

    // Test Case 4:
    string str4 = "12345678AB";
    cout << isValidPSTaxRefNumber(str4) << endl;

    // Test Case 5:
    string str5 = "12071998RC";
    cout << isValidPSTaxRefNumber(str5) << endl;

    return 0;
}

# Python3 program to validate
# Pension Scheme Tax Reference Number
# using Regular Expression
import re

# Function to validate
# Pension Scheme Tax Reference Number


def isValidPSTaxRefNumber(str):

    # Regex to check valid Pension Scheme Tax 
    # Reference Number
    regex = "^[0-9]{8}[R]{1}[A-HJ-NP-TV-Z]{1}$"

    # Compile the ReGex
    p = re.compile(regex)

    # If the string is empty
    # return false
    if (str == None):
        return False

    # Return if the string
    # matched the ReGex
    if(re.search(p, str)):
        return True
    else:
        return False

# Driver code


# Test Case 1:
str1 = "12345678RC"
print(isValidPSTaxRefNumber(str1))

# Test Case 2:
str2 = "RC12345678"
print(isValidPSTaxRefNumber(str2))

# Test Case 3:
str3 = "12345678"
print(isValidPSTaxRefNumber(str3))

# Test Case 4:
str4 = "12345678AB"
print(isValidPSTaxRefNumber(str4))

# Test Case 5:
str5 = "12071998RC"
print(isValidPSTaxRefNumber(str5))

// C# program to validate the
// Pension Scheme Tax Reference Number
// using Regular Expressions
using System;
using System.Text.RegularExpressions;
class GFG {

    // Main Method
    static void Main(string[] args)
    {

        // Input strings to Match
        // Pension Scheme Tax Reference Number
        string[] str
            = { "12345678RC", "RC12345678", "12345678",
                "12345678AB", "12071998RC" };
        foreach(string s in str)
        {
            Console.WriteLine(isValidPSTaxRefNumber(s)
                                  ? "true"
                                  : "false");
        }
        Console.ReadKey();
    }

    // method containing the regex
    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 program to validate Pension Scheme Tax Reference Number
// Function to validate Pension Scheme Tax Reference Number using regular expression
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 program to validate
// Pension Scheme Tax Reference Number
//using Regular Expression

// Function to validate the
// Pension Scheme Tax Reference Number
function isValidPSTaxRefNumber(str) {
    // Regex to check valid
    // Pension Scheme Tax Reference Number
    let regex = new RegExp(/^[0-9]{8}[R]{1}[A-HJ-NP-TV-Z]{1}$/);

    // if str 
    // is empty return false
    if (str == null) {
        return "false";
    }

    // Return true if the str
    // matched the ReGex
    if (regex.test(str) == true) {
        return "true";
    }
    else {
        return "false";
    }
}

// Driver Code
// Test Case 1:
let str1 = "12345678RC";
console.log(isValidPSTaxRefNumber(str1));

// Test Case 2:
let str2 = "RC12345678";
console.log(isValidPSTaxRefNumber(str2));

// Test Case 3:
let str3 = "12345678";
console.log(isValidPSTaxRefNumber(str3));

// Test Case 4:
let str4 = "12345678AB";
console.log(isValidPSTaxRefNumber(str4));

// Test Case 5:
let str5 = "12071998RC";
console.log(isValidPSTaxRefNumber(str5));

true
false
false
false
true

Time complexity: O(n) // where n is the length of the string.

Auxiliary space: O(1).

Related Articles:

• Regular Expressions in Java
• Python RegEx
• JavaScript Regular Expressions