Sunday, October 6, 2024
Google search engine
HomeData Modelling & AIValidating traditional time formats using Regular Expression

Validating traditional time formats using Regular Expression

Given a string Time Format, the task is to check whether the string follows the time formats “HH: MM: SS” or “HH: MM” using Regular Expression. Rules for valid time formats:

  • It should contain only digits[0-9] and colon (:).
  • No alphabets are allowed or any special characters. 

Examples:

Input: “12: 55”
Output: True

Input: “24: 12: 12”
Output: False
Explanation: The standard time is never expressed 24:00:00 hours or anything else after that.

Approach: The problem can be solved based on the following idea:

Create a regex pattern to validate the number as written below:   
regex= ^(?:[01]?[0-9]|2[0-3]):[0-5]?[0-9](?::[0-5]?[0-9])?$

^ : Beginning of the string
?: : not compulsion to be present
[01] : indicates either 1 or 0
[0 – 9] : any one digit from 0 to 9 should be present.
\ : either first part before ” or second part after ”. 

Follow the below steps to implement the idea:

  • Create regex expression for Time formats.
  • Use Pattern class to compile the regex formed.
  •  Use the matcher function to check whether the Time format is valid or not.
  • If it is valid, return true. Otherwise, return false.

Below is the implementation of the above approach.

C++




// C++ program to validate the
// Traditional Time Formats (HH:MM:SS  or HH:MM)
// using RegularExpression
 
#include <bits/stdc++.h>
#include <regex>
using namespace std;
 
// Function to validate the
// Traditional Time Formats (HH:MM:SS  or HH:MM)
string isValidTime(string str)
{
    // Regex to check valid
    // Traditional Time Formats
    // (HH:MM:SS  or HH:MM).
    const regex pattern("^(?:[01]?[0-9]|2[0-3]):[0-5]?[0-9]"
                        "(?::[0-5]?[0-9])?$");
 
    // 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 = "23:01:00";
    cout << isValidTime(str1) << endl;
 
    // Test Case 2:
    string str2 = "12:59:00";
    cout << isValidTime(str2) << endl;
 
    // Test Case 3:
    string str3 = "19:00:59";
    cout << isValidTime(str3) << endl;
 
    // Test Case 4:
    string str4 = "19:00:96";
    cout << isValidTime(str4) << endl;
 
    // Test Case 5:
    string str5 = "08:78:70";
    cout << isValidTime(str5) << endl;
 
    // Test Case 6:
    string str6 = "00:98:00";
    cout << isValidTime(str6) << endl;
 
    return 0;
}


Java




// Java code to implement the approach
 
import java.util.regex.*;
 
class GFG {
 
    // Function to validate the
    // Traditional Time Formats
    // (HH:MM:SS  or HH:MM)
    public static boolean isValidTime(String str)
    {
        // Regex to check valid Time
        String regex
            = "^(?:[01]?[0-9]|2[0-3]):[0-5]?[0-9](?::[0-5]?[0-9])?$";
 
        // 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 regex.
        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 = "23:10:59";
        System.out.println(isValidTime(str1));
 
        // Test Case 2:
        String str2 = "12:59:00";
        System.out.println(isValidTime(str2));
 
        // Test Case 3:
        String str3 = "19:00:59";
        System.out.println(isValidTime(str3));
 
        // Test Case 4:
        String str4 = "19:00:96";
        System.out.println(isValidTime(str4));
 
        // Test Case 5:
        String str5 = "08:78:70";
        System.out.println(isValidTime(str5));
 
        // Test Case 6:
        String str6 = "00:98:00";
        System.out.println(isValidTime(str6));
    }
}


Python3




# Python3 program to validate
# Traditional Time Formats (HH:MM:SS  or HH:MM)
# using Regular Expression
 
import re
 
 
# Function to validate
# Traditional Time Formats (HH:MM:SS  or HH:MM)
def isValidTime(str):
 
    # Regex to check valid time
    regex = "^(?:[01]?[0-9]|2[0-3]):[0-5]?[0-9](?::[0-5]?[0-9])?$"
 
    # 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
if __name__ == '__main__':
     
    # Test Case 1:
    str1 = "23:01:00"
    print(isValidTime(str1))
     
    # Test Case 2:
    str2 = "12:59:00"
    print(isValidTime(str2))
     
    # Test Case 3:
    str3 = "19:00:59"
    print(isValidTime(str3))
     
    # Test Case 4:
    str4 = "19:00:96"
    print(isValidTime(str4))
     
    # Test Case 5:
    str5 = "08:78:70"
    print(isValidTime(str5))
     
    # Test Case 6:
    str6 = "00:98:00"
    print(isValidTime(str6))


C#




// Include namespace system
using System;
using System.Text.RegularExpressions;
 
public class GFG
{
 
  // Function to validate the
  // Traditional Time Formats
  // (HH:MM:SS  or HH:MM)
  public static bool isValidTime(String str)
  {
 
    // Regex to check valid LEI Code
    var regex = new Regex("^(?:[01]?[0-9]|2[0-3]):[0-5]?[0-9](?::[0-5]?[0-9])?$");
 
    // If the str
    // is empty return false
    if (str == null)
    {
      return false;
    }
 
    // Pattern class contains matcher()
    // method to find matching between
    // given LEI Code using regex.
    var m = regex.Match(str);
 
    // Return if the MICR Code
    // matched the ReGex
    return m.Success;
  }
 
  // Driver Code.
  public static void Main(String[] args)
  {
 
    // Test Case 1:
    var str1 = "23:10:59";
    Console.WriteLine(GFG.isValidTime(str1));
 
    // Test Case 2:
    var str2 = "12:59:00";
    Console.WriteLine(GFG.isValidTime(str2));
 
    // Test Case 3:
    var str3 = "19:00:59";
    Console.WriteLine(GFG.isValidTime(str3));
 
    // Test Case 4:
    var str4 = "19:00:96";
    Console.WriteLine(GFG.isValidTime(str4));
 
    // Test Case 5:
    var str5 = "08:78:70";
    Console.WriteLine(GFG.isValidTime(str5));
 
    // Test Case 6:
    var str6 = "00:98:00";
    Console.WriteLine(GFG.isValidTime(str6));
  }
}
 
// This code is contributed by Potta Lokesh.


Javascript




// Javascript program to validate
// Traditional Time Formats (HH:MM:SS  or HH:MM)
//using Regular Expression
 
// Function to validate the
// Traditional Time Formats (HH:MM:SS  or HH:MM)
function isValidTime(str) {
    // Regex to check valid
    // Traditional Time Formats (HH:MM:SS  or HH:MM)
    let regex = new RegExp(/^(?:[01]?[0-9]|2[0-3]):[0-5]?[0-9](?::[0-5]?[0-9])?$/);
 
    // 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 = "23:01:00";
console.log(isValidTime(str1));
 
// Test Case 2:
let str2 = "12:59:00";
console.log(isValidTime(str2));
 
// Test Case 3:
let str3 = "19:00:59";
console.log(isValidTime(str3));
 
// Test Case 4:
let str4 = "19:00:96";
console.log(isValidTime(str4));
 
// Test Case 5:
let str5 = "08:78:70";
console.log(isValidTime(str5));
 
// Test Case 6:
let str6 = "00:98:00";
console.log(isValidTime(str6));


Output

true
true
true
false
false
false

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

Related Articles:

Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!

RELATED ARTICLES

Most Popular

Recent Comments