Similar RGB Color - Practice Coding Problems

Input & Output

Example 1 — Basic Case

$ Input: color = "#09f24a"

› Output: "#0af"

💡 Note: RGB components are (9, 242, 74). Closest shorthand digits: R→0 (0 vs 9), G→f (255 vs 242), B→a (170 vs 74). Result: #0af

Example 2 — Already Shorthand

$ Input: color = "#aabbcc"

› Output: "#abc"

💡 Note: Input is already in shorthand-compatible format. RGB (170, 187, 204) maps perfectly to shorthand #abc

Example 3 — Dark Color

$ Input: color = "#123456"

› Output: "#123"

💡 Note: RGB components (18, 52, 86). Closest shorthand: R→1 (17 vs 18), G→3 (51 vs 52), B→5 (85 vs 86). Very close matches.

Constraints

color is a valid 6-digit hexadecimal color string
color follows the format "#ABCDEF" where A, B, C, D, E, F are hexadecimal digits
Return value should be in format "#XYZ" where X, Y, Z are hexadecimal digits

Visualization

Tap to expand

Understanding the Visualization

Input

Full hex color #09f24a with RGB values

Process

Find closest shorthand hex digits for each component

Output

Shorthand color #0af with maximum similarity

Key Takeaway

🎯 Key Insight: Shorthand colors have identical hex digit pairs, so we only need to find the best single digit for each RGB component

Asked in

G Google 15 f Facebook 12

The key insight is that shorthand hex colors have identical digit pairs (e.g., #1a3 → #11aa33). We can find the optimal shorthand by checking which of the 16 hex digits (0-f) gives the minimum distance for each RGB component independently. The optimized approach runs in O(1) time by testing only 48 comparisons instead of 4096.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Enumeration	O(1)	O(1)	Try all possible shorthand colors and find the one with maximum similarity
Component-Wise Optimization	O(1)	O(1)	Find optimal shorthand digit for each RGB component independently

Brute Force Enumeration — Algorithm Steps

Step 1: Parse input color into RGB components
Step 2: Generate all possible shorthand colors
Step 3: Calculate similarity for each shorthand color
Step 4: Return color with maximum similarity

Visualization

Tap to expand

Step-by-Step Walkthrough

Parse Input

Convert #09f24a to RGB (9, 242, 74)

Generate Candidates

Try all 4096 shorthand colors (#000 to #fff)

Find Best Match

Calculate similarity and keep the maximum

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <ctype.h>

int hexToInt(char hexChar) {
    if (hexChar >= '0' && hexChar <= '9') {
        return hexChar - '0';
    }
    return tolower(hexChar) - 'a' + 10;
}

char intToHex(int num) {
    if (num < 10) {
        return '0' + num;
    }
    return 'a' + num - 10;
}

char* solution(char* color) {
    // Parse input color (skip #)
    int r = hexToInt(color[1]) * 16 + hexToInt(color[2]);
    int g = hexToInt(color[3]) * 16 + hexToInt(color[4]);
    int b = hexToInt(color[5]) * 16 + hexToInt(color[6]);
    
    int maxSimilarity = INT_MIN;
    char* bestColor = (char*)malloc(5 * sizeof(char));
    
    // Try all possible shorthand colors
    for (int rShort = 0; rShort < 16; rShort++) {
        for (int gShort = 0; gShort < 16; gShort++) {
            for (int bShort = 0; bShort < 16; bShort++) {
                // Convert shorthand to full format
                int rFull = rShort * 16 + rShort;
                int gFull = gShort * 16 + gShort;
                int bFull = bShort * 16 + bShort;
                
                // Calculate similarity
                int similarity = -(r - rFull) * (r - rFull) - (g - gFull) * (g - gFull) - (b - bFull) * (b - bFull);
                
                if (similarity > maxSimilarity) {
                    maxSimilarity = similarity;
                    sprintf(bestColor, "#%c%c%c", intToHex(rShort), intToHex(gShort), intToHex(bShort));
                }
            }
        }
    }
    
    return bestColor;
}

int main() {
    char color[8];
    fgets(color, sizeof(color), stdin);
    color[strcspn(color, "\n")] = 0;
    char* result = solution(color);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Always checks exactly 4096 combinations (16³), which is constant

✓ Linear Growth

Space Complexity

O(1)

Only uses variables to store current best color and similarity

✓ Linear Space

18.5K Views

Medium Frequency

~15 min Avg. Time

324 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Enumeration — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler