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: YesInput: str = “#F00”
Output: YesInput: 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:
// 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 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. |
# 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# 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. |
<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>
|
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:
#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;
} |
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" );
}
}
} |
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" )
|
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" );
}
}
} |
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" );
} |
Yes
Time Complexity: O(N)
Auxiliary Space: O(1)