Given string str, the task is to check whether the given string is a valid IFSC (Indian Financial System) Code or not by using Regular Expression.
The valid IFSC (Indian Financial System) Code must satisfy the following conditions:
- It should be 11 characters long.
- The first four characters should be upper case alphabets.
- The fifth character should be 0.
- The last six characters are usually numeric, but can also be alphabetic.
Examples:
Input: str = “SBIN0125620”;
Output: true
Explanation:
The given string satisfies all the above-mentioned conditions. Therefore, it is a valid IFSC (Indian Financial System) Code.
Input: str = “SBIN0125”;
Output: false
Explanation:
The given string has 8 characters. Therefore it is not a valid IFSC (Indian Financial System) Code.
Input: str = “1234SBIN012”;
Output: false
Explanation:
The given string doesn’t starts with alphabets. Therefore it is not a valid IFSC (Indian Financial System) Code.
Approach: The idea is to use Regular Expression to solve this problem. The following steps can be followed to compute the answer.
- Get the String.
- Create a regular expression to check valid IFSC (Indian Financial System) Code as mentioned below:
regex = "^[A-Z]{4}0[A-Z0-9]{6}$";- Where:
- ^ represents the starting of the string.
- [A-Z]{4} represents the first four characters should be upper case alphabets.
- 0 represents the fifth character should be 0.
- [A-Z0-9]{6} represents the next six characters usually numeric, but can also be alphabetic.
- $ represents the ending of the string.
Below is the implementation of the above approach:
C++
#include <iostream>
#include <regex>
using namespace std;
bool isValidIFSCCode(string str)
{
const regex pattern("^[A-Z]{4}0[A-Z0-9]{6}$");
if (str.empty())
{
return false;
}
if(regex_match(str, pattern))
{
return true;
}
else
{
return false;
}
}
int main()
{
string str1 = "SBIN0125620";
cout << boolalpha << isValidIFSCCode(str1) << endl;
string str2 = "SBIN0125";
cout << boolalpha << isValidIFSCCode(str2) << endl;
string str3 = "1234SBIN012";
cout << boolalpha << isValidIFSCCode(str3) << endl;
string str4 = "SBIN7125620";
cout << boolalpha <<isValidIFSCCode(str4) << endl;
return 0;
}
|
Java
import java.util.regex.*;
class GFG {
public static boolean isValidIFSCCode(String str)
{
String regex = "^[A-Z]{4}0[A-Z0-9]{6}$";
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 = "SBIN0125620";
System.out.println(isValidIFSCCode(str1));
String str2 = "SBIN0125";
System.out.println(isValidIFSCCode(str2));
String str3 = "1234SBIN012";
System.out.println(isValidIFSCCode(str3));
String str4 = "SBIN7125620";
System.out.println(isValidIFSCCode(str4));
}
}
|
Python3
import re
def isValidIFSCCode(str):
regex = "^[A-Z]{4}0[A-Z0-9]{6}$"
p = re.compile(regex)
if (str == None):
return False
if(re.search(p, str)):
return True
else:
return False
str1 = "SBIN0125620"
print(isValidIFSCCode(str1))
str2 = "SBIN0125"
print(isValidIFSCCode(str2))
str3 = "1234SBIN012"
print(isValidIFSCCode(str3))
str4 = "SBIN7125620"
print(isValidIFSCCode(str4))
|
C#
using System;
using System.Text.RegularExpressions;
class GFG
{
static void Main(string[] args)
{
string[] str = { "SBIN0125620", "SBIN0125",
"1234SBIN012", "SBIN7125620" };
foreach(string s in str)
{
Console.WriteLine(isValidIFSCCode(s) ? "true"
: "false");
}
Console.ReadKey();
}
public static bool isValidIFSCCode(string str)
{
string strRegex = @"^[A-Z]{4}0[A-Z0-9]{6}$";
Regex re = new Regex(strRegex);
if (re.IsMatch(str))
return (true);
else
return (false);
}
}
|
Javascript
function isValid_IFSC_Code(ifsc_Code)
{
let regex = new RegExp(/^[A-Z]{4}0[A-Z0-9]{6}$/);
if (ifsc_Code == null) {
return "false";
}
if (regex.test(ifsc_Code) == true) {
return "true";
}
else {
return "false";
}
}
let str1 = "SBIN0125620";
console.log(isValid_IFSC_Code(str1));
let str2 = "SBIN0125";
console.log(isValid_IFSC_Code(str2));
let str3 = "1234SBIN012";
console.log(isValid_IFSC_Code(str3));
let str4 = "SBIN7125620";
console.log(isValid_IFSC_Code(str4));
let str5 = "RAH12071998";
console.log(isValid_IFSC_Code(str5));
|
Outputtrue
false
false
false
Time Complexity: O(N) for each test case, where N is the length of the given string.
Auxiliary Space: O(1)
Using String.matches() method
This method tells whether or not this string matches the given regular expression. An invocation of this method of the form str.matches(regex) yields exactly the same result as the expression Pattern.matches(regex, str). Pattern.compile(regex) compiles the pattern so that when you execute Matcher.matches(), the pattern is not recompiled again and again. Pattern.compile pre compiles it. However, if you use string.matches, it compiles the pattern every time you execute this line. So, it is better to use Pattern.compile().
C++
#include <iostream>
#include <regex>
using namespace std;
bool isValidIFSCode(string str)
{
string regex = "^[A-Z]{4}0[A-Z0-9]{6}$";
return regex_match(str, std::regex(regex));
}
int main()
{
string str1 = "SBIN0125620";
cout << isValidIFSCode(str1) << endl;
string str2 = "SBIN0125";
cout << isValidIFSCode(str2) << endl;
string str3 = "1234SBIN012";
cout << isValidIFSCode(str3) << endl;
string str4 = "SBIN7125620";
cout << isValidIFSCode(str4) << endl;
return 0;
}
|
Java
class GFG {
public static boolean isValidIFSCode(String str)
{
String regex = "^[A-Z]{4}0[A-Z0-9]{6}$";
return str.trim().matches(regex);
}
public static void main(String args[])
{
String str1 = "SBIN0125620";
System.out.println(isValidIFSCode(str1));
String str2 = "SBIN0125";
System.out.println(isValidIFSCode(str2));
String str3 = "1234SBIN012";
System.out.println(isValidIFSCode(str3));
String str4 = "SBIN7125620";
System.out.println(isValidIFSCode(str4));
}
}
|
Python3
import re
def isValidIFSCode(str):
regex = "^[A-Z]{4}0[A-Z0-9]{6}$"
return bool(re.match(regex, str))
str1 = "SBIN0125620"
if(isValidIFSCode(str1)):
print('true')
else:
print('false')
str2 = "SBIN0125"
if(isValidIFSCode(str2)):
print('true')
else:
print('false')
str3 = "1234SBIN012"
if(isValidIFSCode(str3)):
print('true')
else:
print('false')
str4 = "SBIN7125620"
if(isValidIFSCode(str4)):
print('true')
else:
print('false')
|
C#
using System;
using System.Text.RegularExpressions;
class Program {
static bool isValidIFSCode(string str)
{
string regex = "^[A-Z]{4}0[A-Z0-9]{6}$";
return Regex.IsMatch(str, regex);
}
static void Main(string[] args)
{
string str1 = "SBIN0125620";
Console.WriteLine(isValidIFSCode(str1));
string str2 = "SBIN0125";
Console.WriteLine(isValidIFSCode(str2));
string str3 = "1234SBIN012";
Console.WriteLine(isValidIFSCode(str3));
string str4 = "SBIN7125620";
Console.WriteLine(isValidIFSCode(str4));
}
}
|
Javascript
function isValidIFSCode(str) {
let regex = /^[A-Z]{4}0[A-Z0-9]{6}$/;
return str.trim().match(regex) != null;
}
let str1 = "SBIN0125620";
console.log(isValidIFSCode(str1));
let str2 = "SBIN0125";
console.log(isValidIFSCode(str2));
let str3 = "1234SBIN012";
console.log(isValidIFSCode(str3));
let str4 = "SBIN7125620";
console.log(isValidIFSCode(str4));
|
Outputtrue
false
false
false
Time Complexity: O(N) for each test case, where N is the length of the given string.
Auxiliary Space: O(1)