Open in App
Not now

# How to validate MAC address using Regular Expression

• Difficulty Level : Medium
• Last Updated : 22 Dec, 2022

Given string str, the task is to check whether the given string is a valid MAC address or not by using Regular Expression.

A valid MAC address must satisfy the following conditions:

1. It must contain 12 hexadecimal digits.
2. One way to represent them is to form six pairs of the characters separated with a hyphen (-) or colon(:). For example, 01-23-45-67-89-AB is a valid MAC address.
3. Another way to represent them is to form three groups of four hexadecimal digits separated by dots(.). For example, 0123.4567.89AB is a valid MAC address.

Examples:

Input: str = “01-23-45-67-89-AB”;
Output: true
Explanation:
The given string satisfies all the above mentioned conditions. Therefore, it is a valid MAC address.

Input: str = “01-23-45-67-89-AH”;
Output: false
Explanation:
The given string contains ‘H’, the valid hexadecimal digits should be followed by letter from a-f, A-F, and 0-9. Therefore, it is not a valid MAC address.

Input: str = “01-23-45-67-AH”;
Output: false
Explanation:
The given string has five groups of two hexadecimal digits. Therefore, it is not a valid MAC address.

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 MAC address as mentioned below:

regex = “^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})|([0-9a-fA-F]{4}\\.[0-9a-fA-F]{4}\\.[0-9a-fA-F]{4})\$”;

• Where:
• ^ represents the starting of the string.
• ([0-9A-Fa-f]{2}[:-]){5} represents the five groups of two hexadecimal digits separated by hyphens (-) or colons (:)
• ([0-9A-Fa-f]{2}) represents the one groups of two hexadecimal digits.
• | represents the or.
• ( represents the starting of the group.
• [0-9a-fA-F]{4}\\. represents the first part of four hexadecimal digits separated by dots (.).
• [0-9a-fA-F]{4}\\. represents the second part of four hexadecimal digits separated by dots (.).
• [0-9a-fA-F]{4} represents the third part of four hexadecimal digits.
• ) represents the ending of the group.
• \$ represents the ending of the string.
• Match the given string with the Regular Expression. In Java, this can be done by using Pattern.matcher().
• Return true if the string matches with the given regular expression, else return false.

Below is the implementation of the above approach:

## C++

 `// C++ program to validate the` `// MAC address` `// using Regular Expression` `#include ` `#include ` `using` `namespace` `std;`   `// Function to validate the MAC address` `bool` `isValidMACAddress(string str)` `{`   `    ``// Regex to check valid MAC address` `    ``const` `regex pattern(` `    ``"^([0-9A-Fa-f]{2}[:-]){5}"` `      ``"([0-9A-Fa-f]{2})|([0-9a-"` `    ``"fA-F]{4}\\.[0-9a-fA-F]"` `      ``"{4}\\.[0-9a-fA-F]{4})\$"``);`   `    ``// If the MAC address` `    ``// is empty return false` `    ``if` `(str.empty()) ` `    ``{` `        ``return` `false``;` `    ``}`   `    ``// Return true if the MAC address` `    ``// matched the ReGex` `    ``if` `(regex_match(str, pattern)) ` `    ``{` `        ``return` `true``;` `    ``}` `    ``else` `    ``{` `        ``return` `false``;` `    ``}` `}`   `// Driver Code` `int` `main()` `{` `    ``// Test Case 1:` `    ``string str1 = ``"01-23-45-67-89-AB"``;` `    ``cout << isValidMACAddress(str1) << endl;`   `    ``// Test Case 2:` `    ``string str2 = ``"01:23:45:67:89:AB"``;` `    ``cout << isValidMACAddress(str2) << endl;`   `    ``// Test Case 3:` `    ``string str3 = ``"0123.4567.89AB"``;` `    ``cout << isValidMACAddress(str3) << endl;`   `    ``// Test Case 4:` `    ``string str4 = ``"01-23-45-67-89-AH"``;` `    ``cout << isValidMACAddress(str4) << endl;`   `    ``// Test Case 5:` `    ``string str5 = ``"01-23-45-67-AH"``;` `    ``cout << isValidMACAddress(str5) << endl;`   `    ``return` `0;` `}`   `// This code is contributed by yuvraj_chandra`

## Java

 `// Java program to validate` `// MAC address using` `// regular expression`   `import` `java.util.regex.*;` `class` `GFG {`   `    ``// Function to validate` `    ``// MAC address` `    ``// using regular expression` `    ``public` `static` `boolean` `isValidMACAddress(String str)` `    ``{` `        ``// Regex to check valid` `        ``// MAC address` `        ``String regex = ``"^([0-9A-Fa-f]{2}[:-])"` `                       ``+ ``"{5}([0-9A-Fa-f]{2})|"` `                       ``+ ``"([0-9a-fA-F]{4}\\."` `                       ``+ ``"[0-9a-fA-F]{4}\\."` `                       ``+ ``"[0-9a-fA-F]{4})\$"``;`   `        ``// Compile the ReGex` `        ``Pattern p = Pattern.compile(regex);`   `        ``// If the string is empty` `        ``// return false` `        ``if` `(str == ``null``)` `        ``{` `            ``return` `false``;` `        ``}`   `        ``// Find match between given string` `        ``// and regular expression` `        ``// uSing Pattern.matcher()`   `        ``Matcher m = p.matcher(str);`   `        ``// Return if the string` `        ``// matched the ReGex` `        ``return` `m.matches();` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String args[])` `    ``{`   `        ``// Test Case 1:` `        ``String str1 = ``"01-23-45-67-89-AB"``;` `        ``System.out.println(isValidMACAddress(str1));`   `        ``// Test Case 2:` `        ``String str2 = ``"01:23:45:67:89:AB"``;` `        ``System.out.println(isValidMACAddress(str2));`   `        ``// Test Case 3:` `        ``String str3 = ``"0123.4567.89AB"``;` `        ``System.out.println(isValidMACAddress(str3));`   `        ``// Test Case 4:` `        ``String str4 = ``"01-23-45-67-89-AH"``;` `        ``System.out.println(isValidMACAddress(str4));`   `        ``// Test Case 5:` `        ``String str5 = ``"01-23-45-67-AH"``;` `        ``System.out.println(isValidMACAddress(str5));` `    ``}` `}`

## Python3

 `# Python3 program to validate` `# MAC address using` `# using regular expression` `import` `re`   `# Function to validate MAC address.`     `def` `isValidMACAddress(``str``):`   `    ``# Regex to check valid` `    ``# MAC address` `    ``regex ``=` `(``"^([0-9A-Fa-f]{2}[:-])"` `+` `             ``"{5}([0-9A-Fa-f]{2})|"` `+` `             ``"([0-9a-fA-F]{4}\\."` `+` `             ``"[0-9a-fA-F]{4}\\."` `+` `             ``"[0-9a-fA-F]{4})\$"``)`   `    ``# 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 ``=` `"01-23-45-67-89-AB"` `print``(isValidMACAddress(str1))`   `# Test Case 2:` `str2 ``=` `"01:23:45:67:89:AB"` `print``(isValidMACAddress(str2))`   `# Test Case 3:` `str3 ``=` `"0123.4567.89AB"` `print``(isValidMACAddress(str3))`   `# Test Case 4:` `str4 ``=` `"01-23-45-67-89-AH"` `print``(isValidMACAddress(str4))`   `# Test Case 5:` `str5 ``=` `"01-23-45-67-AH"` `print``(isValidMACAddress(str5))`   `# This code is contributed by avanitrachhadiya2155`

## C#

 `// C# program to validate` `// MAC address using` `// regular expression`   `using` `System;` `using` `System.Text.RegularExpressions;`   `class` `GFG {`   `    ``// Function to validate` `    ``// MAC address` `    ``// using regular expression` `    ``public` `static` `bool` `isValidMACAddress(``string` `str)` `    ``{` `        ``// Regex to check valid` `        ``// MAC address` `        ``string` `regex = ``"^([0-9A-Fa-f]{2}[:-])"` `                    ``+ ``"{5}([0-9A-Fa-f]{2})|"` `                    ``+ ``"([0-9a-fA-F]{4}\\."` `                    ``+ ``"[0-9a-fA-F]{4}\\."` `                    ``+ ``"[0-9a-fA-F]{4})\$"``;`   `        ``// Compile the ReGex` `        ``Regex p = ``new` `Regex(regex);`   `        ``// If the string is empty` `        ``// return false` `        ``if` `(str == ``null``)` `        ``{` `            ``return` `false``;` `        ``}`   `        ``// Find match between given string` `        ``// and regular expression` `        ``// uSing Pattern.matcher()`   `        ``Match m = p.Match(str);`   `        ``// Return if the string` `        ``// matched the ReGex` `        ``return` `m.Success;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main()` `    ``{`   `        ``// Test Case 1:` `        ``string` `str1 = ``"01-23-45-67-89-AB"``;` `        ``Console.WriteLine(isValidMACAddress(str1));`   `        ``// Test Case 2:` `        ``string` `str2 = ``"01:23:45:67:89:AB"``;` `        ``Console.WriteLine(isValidMACAddress(str2));`   `        ``// Test Case 3:` `        ``string` `str3 = ``"0123.4567.89AB"``;` `        ``Console.WriteLine(isValidMACAddress(str3));`   `        ``// Test Case 4:` `        ``string` `str4 = ``"01-23-45-67-89-AH"``;` `        ``Console.WriteLine(isValidMACAddress(str4));`   `        ``// Test Case 5:` `        ``string` `str5 = ``"01-23-45-67-AH"``;` `        ``Console.WriteLine(isValidMACAddress(str5));` `    ``}` `}`   `// This code is contributed by Aman Kumar.`

## Javascript

 `// Javascript program to validate` `// MAC Address  using Regular Expression`   `// Function to validate the` `// MAC_Address  ` `function` `isValidMACAddress(str) {` `    ``// Regex to check valid` `    ``// MAC_Address  ` `    ``let regex = ``new` `RegExp(/^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})|([0-9a-fA-F]{4}.[0-9a-fA-F]{4}.[0-9a-fA-F]{4})\$/);`   `    ``// 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 = ``"01-23-45-67-89-AB"``;` `console.log(isValidMACAddress(str1));`   `// Test Case 2:` `let str2 = ``"01:23:45:67:89:AB"``;` `console.log(isValidMACAddress(str2));`   `// Test Case 3:` `let str3 = ``"0123.4567.89AB"``;` `console.log(isValidMACAddress(str3));`   `// Test Case 4:` `let str4 = ``"01-23-45-67-89-AH"``;` `console.log(isValidMACAddress(str4));`   `// Test Case 5:` `let str5 = ``"01-23-45-67-AH"``;` `console.log(isValidMACAddress(str5));`   `// This code is contributed by Rahul Chauhan`

Output

```true
true
true
false
false```

Time Complexity: O(N) for each testcase, where N is the length of the given string.
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Related Articles