Check if a given string is a valid Hexadecimal Color Code or not

0 0 5 minutes read

Given a string str, the task is to check whether the given string is an HTML Hex Color Code or not. Print Yes if it is, otherwise print No.

Examples:

Input: str = “#1AFFa1”
Output: Yes

Input: str = “#F00”
Output: Yes

Input: str = �”
Output: No

Approach: An HTML Hex Color Code follows the below-mentioned set of rules:

It starts with the ‘#’ symbol.
Then it is followed by the letters from a-f, A-F and/or digits from 0-9.
The length of the hexadecimal color code should be either 6 or 3, excluding ‘#’ symbol.
For example: #abc, #ABC, #000, #FFF, #000000, #FF0000, #00FF00, #0000FF, #FFFFFF are all valid Hexadecimal color codes.

Now, to solve the above problem follow the below steps:

Check the string str for the following conditions:
- If the first character is not #, return false.
- If the length is not 3 or 6. If not, return false.
- Now, check for all characters other than the first character that are 0-9, A-F or a-f.
If all the conditions mentioned above are satisfied, then return true.
Print answer according to the above observation.

Below is the implementation of the above approach:

CPP

// C++ program for the above approach
 
#include <iostream>
using namespace std;
 
// Function to validate 
// the HTML hexadecimal color code.
bool isValidHexaCode(string str)
{
    if (str[0] != '#')
        return false;
 
    if (!(str.length() == 4 or str.length() == 7))
        return false;
 
    for (int i = 1; i < str.length(); i++)
        if (!((str[i] >= '0' && str[i] <= 9)
              || (str[i] >= 'a' && str[i] <= 'f')
              || (str[i] >= 'A' || str[i] <= 'F')))
            return false;
 
    return true;
}
 
// Driver Code
int main()
{
    string str = "#1AFFa1";
 
    if (isValidHexaCode(str)) {
        cout << "Yes" << endl;
    }
    else {
        cout << "No" << endl;
    }
    return 0;
}

Java

// Java program for the above approach
import java.util.*;
class GFG{
 
    // Function to validate 
    // the HTML hexadecimal color code.
    static boolean isValidHexaCode(String str)
    {
        if (str.charAt(0) != '#')
            return false;
 
        if (!(str.length() == 4 || str.length() == 7))
            return false;
 
        for (int i = 1; i < str.length(); i++)
            if (!((str.charAt(i) >= '0' && str.charAt(i) <= 9)
                || (str.charAt(i) >= 'a' && str.charAt(i) <= 'f')
                || (str.charAt(i) >= 'A' || str.charAt(i) <= 'F')))
                return false;
 
        return true;
    }
     
    // Driver code
    public static void main(String args[])
    {
        String str = "#1AFFa1";
 
        if (isValidHexaCode(str)) {
            System.out.println("Yes");
        }
        else {
            System.out.println("No");
        }
    }
}
 
// This code is contributed by Samim Hossain Mondal.

Python3

# python program for the above approach
 
# Function to validate
# the HTML hexadecimal color code.
def isValidHexaCode(str):
 
    if (str[0] != '#'):
        return False
 
    if (not(len(str) == 4 or len(str) == 7)):
        return False
 
    for i in range(1, len(str)):
        if (not((str[i] >= '0' and str[i] <= '9') or (str[i] >= 'a' and str[i] <= 'f') or (str[i] >= 'A' or str[i] <= 'F'))):
            return False
 
    return True
 
 
# Driver Code
if __name__ == "__main__":
 
    str = "#1AFFa1"
 
    if (isValidHexaCode(str)):
        print("Yes")
 
    else:
        print("No")
 
    # This code is contributed by rakeshsahni

C#

// C# program for the above approach
using System;
class GFG{
 
    // Function to validate 
    // the HTML hexadecimal color code.
    static bool isValidHexaCode(string str)
    {
        if (str[0] != '#')
            return false;
 
        if (!(str.Length == 4 || str.Length == 7))
            return false;
 
        for (int i = 1; i < str.Length; i++)
            if (!((str[i] >= '0' && str[i] <= 9)
                || (str[i] >= 'a' && str[i] <= 'f')
                || (str[i] >= 'A' || str[i] <= 'F')))
                return false;
 
        return true;
    }
     
    // Driver code
    public static void Main()
    {
        string str = "#1AFFa1";
 
        if (isValidHexaCode(str)) {
            Console.Write("Yes");
        }
        else {
            Console.Write("No");
        }
    }
}
// This code is contributed by Samim Hossain Mondal.

Javascript

<script>
       // JavaScript Program to implement
       // the above approach
 
       // Function to validate 
       // the HTML hexadecimal color code.
       function isValidHexaCode(str) {
           if (str[0] != '#')
               return false;
 
           if (!(str.length == 4 || str.length == 7))
               return false;
 
           for (let i = 1; i < str.length; i++)
               if (!((str[i].charCodeAt(0) <= '0'.charCodeAt(0) && str[i].charCodeAt(0) <= 9)
                   || (str[i].charCodeAt(0) >= 'a'.charCodeAt(0) && str[i].charCodeAt(0) <= 'f'.charCodeAt(0))
                   || (str[i].charCodeAt(0) >= 'A'.charCodeAt(0) || str[i].charCodeAt(0) <= 'F'.charCodeAt(0))))
                   return false;
 
           return true;
       }
 
       // Driver Code
       let str = "#1AFFa1";
 
       if (isValidHexaCode(str)) {
           document.write("Yes" + '<br>');
       }
       else {
           document.write("No" + '<br>');
       }
 
   // This code is contributed by Potta Lokesh
   </script>

Output

Yes

Time Complexity: O(N)
Auxiliary Space: O(1)

Approach 2: Regex Expression:

In this approach, we have used regex library to define a regular expression pattern to match the HTML hexadecimal color code. The regular expression pattern ^#([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$ matches the string that starts with # and followed by either 6 hexadecimal digits or 3 hexadecimal digits. The regex_match function checks if the given string matches the regular expression pattern or not, and returns true if it matches, else false.

Here is the code given below:

C++

#include <iostream>
#include <regex>
using namespace std;
 
// Function to validate 
// the HTML hexadecimal color code using regex.
bool isValidHexaCode(string str)
{
    regex hexaCode("^#([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$");
    return regex_match(str, hexaCode);
}
 
// Driver Code
int main()
{
    string str = "#1AFFa1";
 
    if (isValidHexaCode(str)) {
        cout << "Yes" << endl;
    }
    else {
        cout << "No" << endl;
    }
    return 0;
}

Java

import java.util.regex.Pattern;
import java.util.regex.Matcher;
 
public class GFG {
 
    // Function to check if a given string is a valid hexadecimal color code
    public static boolean isValidHexaCode(String input) {
        // Define the regular expression pattern for a valid hexadecimal color code
        // It matches either a 6-character or 3-character code, preceded by a #
        Pattern hexaPattern = Pattern.compile("^#([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$");
         
        // Create a Matcher object to match the input against the pattern
        Matcher matcher = hexaPattern.matcher(input);
         
        // Return true if the input matches the pattern, otherwise false
        return matcher.matches();
    }
 
    public static void main(String[] args) {
        String input = "#1AFFa1";
 
        if (isValidHexaCode(input)) {
            System.out.println("Yes");
        } else {
            System.out.println("No");
        }
    }
}

Python3

import re
 
def is_valid_hexa_code(string):
    hexa_code = re.compile(r'^#([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$')
    return bool(re.match(hexa_code, string))
 
if __name__ == "__main__":
    string = "#1AFFa1"
 
    if is_valid_hexa_code(string):
        print("Yes")
    else:
        print("No")

C#

using System;
using System.Text.RegularExpressions;
 
class GFG
{
    // Function to validate the HTML hexadecimal color code using regex.
    static bool IsValidHexaCode(string str)
    {
        // Regular expression to match a valid hexadecimal color code.
        // The pattern "^#([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$" checks for:
        // ^        - Start of the string
        // #        - The string must start with a hash character (#)
        // (        - Start of the first group
        // [a-fA-F0-9]{6} - Matches exactly six characters which can be any of a-f, A-F, or 0-9
        // |        - OR
        // [a-fA-F0-9]{3} - Matches exactly three characters which can be any of a-f, A-F, or 0-9
        // )        - End of the first group
        // $        - End of the string
        Regex hexaCode = new Regex(@"^#([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$");
 
        // Check if the input string matches the regex pattern.
        return hexaCode.IsMatch(str);
    }
 
    static void Main()
    {
        string str = "#1AFFa1";
 
        if (IsValidHexaCode(str))
        {
            Console.WriteLine("Yes");
        }
        else
        {
            Console.WriteLine("No");
        }
    }
}

Javascript

function isValidHexaCode(input) {
    // Define the regular expression pattern for a valid hexadecimal color code
    // It matches either a 6-character or 3-character code, preceded by a #
    var hexaPattern = /^#([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$/;
 
    // Test the input against the pattern using the test() method
    return hexaPattern.test(input);
}
 
var input = "#1AFFa1";
 
if (isValidHexaCode(input)) {
    console.log("Yes");
} else {
    console.log("No");
}

Output

Yes

Time Complexity: O(N)
Auxiliary Space: O(1)

Recommended

Solve DSA problems on GfG Practice.

Solve Problems

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 zambiatek!