Guess my RGB

by talonx • 2 years ago

618 144 2 years ago

pierrelf• 2 years ago

Amazing! Just needs an expert mode with 0-255 and alpha channel

pavlov2• 2 years ago

Real expert mode is guessing CIE 1931 XYZ values in a windowless room with a carefully calibrated display and ambient lighting.

LoganDark• 2 years ago

You also might need calibrated eyes. (My left and right eyes don't see the same colors.)

pavlov2• 2 years ago

After submitting, the background color of the box displaying the match percentage result shows you the color you guessed.

(This may be obvious depending on the color you’re guessing, but in my case the color was quite gray and it took me a few guesses to notice this essential visual aid.)

bun_terminator• 2 years ago

Fun! Spill your scores. I can usually get within 85%, had one perfect out of 10. And one 70%

envp• 2 years ago

So far I’ve gotten to the end for a few colors. Quite fun, took my about 20-30 guesses!

a_e_k• 2 years ago

Fun! After a few game, my best was 100% on the 4th guess.

It looks like it's using Euclidean RGB difference, so one potential approach if you don't want to eyeball it is to just try to try to find the match for each channel one by one.

Edit: Okay, my new best score was 100% on the 1st guess, thanks to the browser inspector. :-)

B1FF_PSUVM• 2 years ago

Five games, number of tries to "Splendid!": 9, 4, 11, 19, 8

(Burnt orange, bright yellow, light blue, shock pink, dark blue)

williameckert• 2 years ago

First game: 77 % on the first try, Splendid! on the second.

Applejinx• 2 years ago

I thought it just always said 'splendid!' at the end. Tried twice, got both within six tries. I've paid attention to this sort of thing before, though. If I could get it close I'd generally have an idea as to what was left to change. I could see 'this is more red than it should be' and go from there.

johnisgood2• 2 years ago

2 games, one was correct at the 27th try, the second one at the 14th.

trashtensor• 2 years ago

8-12 attempts to get the color seems to be the range i tend to land in.

thehucklecat• 2 years ago

i got 6. surprised that it was that few, I figured it would take forever.

DangerousPie• 2 years ago

Fun! This takes me back to coding up websites in plain HTML in Notepad. Coming up with the right hex codes for colors was an essential skill!

panchtatvam• 2 years ago

Loved it !

Timwi• 2 years ago

Would love to try a “Guess my HSL” spinoff.

speedgoose• 2 years ago

And a guess OKlab.

https://bottosson.github.io/posts/oklab/

rikroots• 2 years ago

Not a "Guess my OKLCH" game as such - more of an "Order my gradient numbers" thing - but it does use OKLCH ... https://codepen.io/kaliedarik/full/YzvYadX

ricardo812• 2 years ago

Only took me 18 guesses. Should've thought about ROYBGIV a bit before guessing.

ldjb2• 2 years ago

Heads-up: It's ROYGBIV

ricardo812• 2 years ago

Pretty fundamental to this situation :-) cheers.

new_user_final• 2 years ago

Took me 42 guesses.

p4bl02• 2 years ago

Very cool idea! On my first two tries, I quickly got to 94% but then got absolutely stuck there. The 94% seemed like a local optimum (moving any slider one slot in either direction

Any way to explain that?

Also: it would be cool to have a way to forfeit and get the solution.

aiprogress• 2 years ago

I don't think that's possible. When I tried it, if you only pick one number the percentage match goes up or down.

otherme1232• 2 years ago

94% means you need only one slide up or down, so 6 posibilities. If you move one and it doesn't solve, you can't move another without getting the first to the old position.

miggol• 2 years ago

The score is defined as follows:

      function score (r, g, b, rr, gg, bb) {
        const maxRErr = Math.max(r, 15 - r)
        const maxGErr = Math.max(g, 15 - g)
        const maxBErr = Math.max(b, 15 - b)
        const maxDist = Math.sqrt(maxRErr * maxRErr +
                                  maxGErr * maxGErr +
                                  maxBErr * maxBErr)
        const rErr = Math.abs(rr - r)
        const gErr = Math.abs(gg - g)
        const bErr = Math.abs(bb - b)
        const dist = Math.sqrt(rErr * rErr +
                               gErr * gErr +
                               bErr * bErr)
        return Math.floor(100 * (1 - dist / maxDist))
      }

Before even starting to count the error, it calculates the maximum error possible for the target colour. That makes sense! We want the percentages to feel more or less the same every round. Otherwise a medium grey would score relatively higher with every guess.

But to answer your question, I don't think the local optimum situation you are describing is possible. I'm no math wizard but looking at this function there must (surely?) always be a direction to move one slider to get a higher score, unless you're bang on. So I think you just missed out on that one move, which does get ever more likely as your guesses get closer.

neogodless• 2 years ago

I had this issue. Didn't realize that on my phone I was fat-fingering and struggling to get exactly one movement on a slider instead of two.

p4bl02• 2 years ago

Oh, that's probably it!

chrisjj4• 2 years ago

Bug? #952 shows matching colour but scores only 94%.

Android Chrome.

jstanley• 2 years ago

I think to ensure readability it caps the colour at the lower end, so #950, #951, #952 all show up the same.

That's my best guess.

EDIT: But from reading the code there seems to be no such logic. Strange, because I observed the same thing, in Firefox on Android.

chrisjj4• 2 years ago

Certainly something odd is happening.

otherme1232• 2 years ago

RGB tells you that #952 is as far from #951 as, for example #952 is from #851, or from #962. They aren't. The first two are very close, practically the same to the eye.

susam3• 2 years ago

The actual colour may have been #950 or #951 which looks very similar to #951.

Pulling the blue slider down by a notch or two could have got you a perfect match.

Here is a demo of these colours if you want to see for yourself how similar they look:

https://susam.net/code/bin/2024-03-31-rgb-952.html

chrisjj4• 2 years ago

Thanks. Colour was identical.

leononame• 2 years ago

Just joining in on the canon that this is incredibly fun, much more than I would've anticipated

somedude895• 2 years ago

I sometimes play this with people at work. Point at something in the office and guess the RGB.

ramshanker• 2 years ago

22) #5A7 (Splendid!)

elyobo• 2 years ago

Fun game, a convenient wordle style social media sharing utility would spread the word. Not sure what would work.

animaomnium• 2 years ago

One idea is to embed the guesses in the url fragment (perhaps delta encoded) and from that url fragment, generate a social media preview image with a horizontal discrete gradient of the guesses.

You would need a server to generate the preview images ofc, but something like a subdomain redirect to a cloudflare worker or what-have-you could be sufficient. If done right the generated previews could be pretty small.

mg2• 2 years ago

I wonder what the optimal strategy would be if you can't see the color and only the answers when you click submit.

Hillclimbing is already somewhat efficient:

    For each slider:
        - Start at 0
        - Move to the right until the score drops
        - Move one to the left

That should result in something like 9 tries per slider on average, so 27 tries per color.

One signal that could be used to improve it: The difference in score between 0 to 1 gives you the approximate length you have to move to the right.

Due to rounding, you don't get the exact length.

So My guess is that with an optimal strategy, on average you would need something like 4 tries per slider.

That comes down to and average of 12 tries per color.

elsombrero• 2 years ago

you could apply a binary search for each slider and improve the number of tries by moving the slider by half of the shortest distance to the edge

tetris115• 2 years ago

Poor man's attempt:

        var speed = 50
        // Prime the result output
        for (col of [rin, bin, gin]) {
          rin.valueAsNumber = 0
          bin.valueAsNumber = 0
          gin.valueAsNumber = 0
        }
        rin.dispatchEvent(new Event('change'));

        async function tryit(col, incr) {
          // Increment a single color
          col.valueAsNumber = col.valueAsNumber + incr
          col.dispatchEvent(new Event('change'));
          submit.click()
          await (new Promise(resolve => setTimeout(resolve, speed)));
          var res_text = result.innerText.split(/[ ()%]/)[4]
          if (res_text === "Splendid!") {
            throw new Error("Finished")
          }
          return (parseInt(res_text))
        }

        async function trymany() {
          // We need to iterate at least twice due to rounding
          // in result percentage, sometimes making neighbouring 
          // colors have the same result. 
          var last_res = 0, max_tries = 3;
          while (--max_tries > 0) {
            for (col of [rin, gin, bin]) {
              while (true) {
                var new_res = await tryit(col, 1)
                if (last_res >= new_res) {
                  // set last value and break
                  await tryit(col, -1)
                  break
                }
                last_res = new_res
              }
            }
          }
        }
        await trymany()

js4ever• 2 years ago

Not bad, 18 to 43 attempts on 10 games I tried. Far from optimal but good enough :p

sleepingreset2• 2 years ago

how do you run this?

sunnynagam• 2 years ago

Optimized with binary search (can't figure out why ycomb formats my code all ugly)

var speed = 500;

[rin, bin, gin].forEach(col => { col.valueAsNumber = 7; col.dispatchEvent(new Event('change')); col.score = 0; });

async function tryit(col, value) { col.valueAsNumber = value; col.dispatchEvent(new Event('change')); submit.click(); await new Promise(resolve => setTimeout(resolve, speed)); var res_text = result.innerText.split(/[ ()%]/)[4]; if (res_text === "Splendid!") { throw new Error("Finished - Found correct combination"); } col.score = parseInt(res_text); return col.score; }

async function binarySearch(col) { let start = 0; let end = 15; let mid = 7; let startAccuracy = await tryit(col, start); let endAccuracy = await tryit(col, end); let midAccuracy = 0;

    while (true) {
        mid = Math.floor((start + end) / 2);
        midAccuracy = await tryit(col, mid);

        if ((end - start) <= 2) {
            const max = Math.max([startAccuracy, midAccuracy, endAccuracy]);
            if (startAccuracy == max) await tryit(col, start);
            else if (midAccuracy == max) await tryit(col, mid);
            else await tryit(col, end);
            return;
        }

        if (endAccuracy > startAccuracy) {
            start = mid;
            startAccuracy = midAccuracy;
        } else {
            end = mid;
            endAccuracy = midAccuracy;
        }
    }

} async function findOptimalCombination() { for (const col of [rin, gin, bin]) { await binarySearch(col); } /* rounding */ for (const col of [rin, gin, bin]) { const mid = col.valueAsNumber; const score = await tryit(col, mid); const left = await tryit(col, mid - 1); if (score >= left) { const right = await tryit(col, mid + 1); if (score >= right) await tryit(col, mid); } } console.log("Optimization complete"); }

await findOptimalCombination();

SmartHypercube2• 2 years ago

If we ignore the information contained in the score numbers, only comparing which score is higher, we could optimize using ternary search (or golden-section search). https://en.wikipedia.org/wiki/Golden-section_search

(Note that binary search does not apply here. This is searching for an extremum, not a zero point.)

    - Start at the range of 0-F, measure the score of 6 and 9 (2 tries)
    - Depending on which is higher, narrow the range to 0-9 or 6-F
    - Suppose the range is 0-9, measure the score of 3 and 6 (1 try. 6 is already measured)
    - Narrow the range to 0-6 or 3-9
    - Suppose the range is 0-6, measure the score of 2 and 3 (1 try. 3 is already measured)
    - The worse case is 3's score is higher. The range is now 2-6. Since 2, 3, 6 are all measured, in the worst case you need 2 more tries for 4 and 5.
    - The other case is 2's score is higher. The range is now 0-3 and 0, 2, 3 are all measured.

So in worst case there are 6 tries per slider. ~5 tries on average. I suspect this can be further optimized but I'll stop here :)

alex_smart3• 2 years ago

Assuming the score is 100-Euclidean distance, you should be able to triangulate to the correct answer after three random guesses. Triangulation will give you two candidates for the correct colour, so if you choose between them randomly you should get the correct colour in 4.5 tries on average.

n2d44• 2 years ago

Because the space is bounded and discrete, you can further optimize by triangulating smartly. If you always pick a triangulation point on the boundary, you will always end up with a single candidate as the other candidate will be out of bounds. (Due to discreteness, you can only pick a point near the boundary, but this will still work in a vast majority of cases.) That reduces the average to ~4.

penteract7• 2 years ago

The score is floor(100*(1-distance/max_distance)) where max_distance is the greatest distance to the target from any point in the cube. This means that the spheres used in triangulation look funny. Rounding also gets in the way, but you can do it in 5 guesses starting with #B74, #448, #B8B and #4B7 (the first 3 are enough in to uniquely identify it in 3911 out of 4096 cases, and the first 2 are enough in 735; giving an average of less than 4 tries).

KineticLensman• 2 years ago

I just tried this and it took 12 goes to get "12) #02C (Splendid!)". Admittedly the target colour was very blueish, so I started with the blue slider and then added a couple of green clicks.

penteract7• 2 years ago

It's calculating distance in 3D space, scaled by the longest distance available. Without the scaling (and ignoring the rounding for the moment), distances from the target to any 3 non-collinear points would narrow it down to at most 2 options, regardless of the precision required on each axis; giving a 50% chance to get it on guess 3 and a 50% chance to get it on guess 4.

With the scaling, it can still be thought of as a problem of intersecting spheres, but the spheres begin to look quite strange since the distance function isn't symmetric. For example if your first guess was a corner of the cube, 1/8 of the space would have the same score (0%) since you've picked the furthest available point. This probably could be analyzed in the same way as above, since the 'spheres' centered at non-corner points aren't degenerate, and their intersections probably still have the right topological dimensions (dropping by 1 each time you add a new sphere, so 3 spheres are still likely to take you to a finite set of points in the continuous case) but that would require some work to prove.

Since we still need to consider the loss of precision from rounding, we can just look at this as a discrete problem and try to find a tuple of points that are sufficient to distinguish everything. It took a me couple of attempts, but the following 4 tetrahedrally arranged ones work: [11,7,4],[4,4,8],[11,8,11],[4,11,7].

There might be a smaller set that work, it would take ~2^48 work to exhaustively search for 3 points that could distinguish everything, and it might be possible to do better since you can choose the second point based on results from the first.

mg2• 2 years ago

So after calculating the 4 scores for [11,7,4],[4,4,8],[11,8,11],[4,11,7] we can put the 4 scores into a formula and it outputs the correct 3 values? Which formula would that be?

nvader• 2 years ago

Could you binary search on the slider to find the optimum?

n2d44• 2 years ago

Here's a solution with ~3.27 average tries total (including the last guess). It works by spreading the possibilities across each of the 100 "score" buckets as evenly as possible (aka minimizing the variance).

It can identify more than half of all colors in just 2 guesses. If you edit the code to minimize the size of the largest bucket instead, you get an algorithm that has a slightly worse average case, but never needs more than 4 guesses.

Paste it in the site's browser console to try.

    function solve() {
      let possibleTargets = new Array(0x1000).fill(0).map((_, i) => i);
      while (true) {
        // for each possible guess, calculate the score-buckets
        const guessResults = possibleTargets.map((guess) => {  // for better brute-force, iterate through all colors, but this performs better (probably because we don't reward for guessing correctly in the current turn)
          const buckets = new Array(101).fill(0).map(() => []);
          for (const possibleTarget of possibleTargets) {
            buckets[calcScore(possibleTarget, guess)].push(possibleTarget);
          }
          return { guess, buckets };
        });

        // find guess with lowest variance
        const best = guessResults.sort((a, b) => calcVariance(a.buckets) - calcVariance(b.buckets))[0];

        // make the guess & update possible targets
        const sc = makeGuess(best.guess);
        if (sc >= 100) return "Success!";
        possibleTargets = best.buckets[sc];
      }
    }

    function calcVariance(buckets) { const maxBucketSize = Math.max(...buckets.map(b => b.length)); return buckets.reduce((acc, b) => acc + (b.length - maxBucketSize) ** 2, 0); }

    function deconstruct(color) { return [(color & 0xF00) >> 8, (color & 0x0F0) >> 4, (color & 0x00F)]; }

    function calcScore(target, guess) { return score(...deconstruct(target), ...deconstruct(guess)); }

    function makeGuess(guess) { [rr, gg, bb] = deconstruct(guess); submitInput(); return score(r, g, b, rr, gg, bb); };

    solve();

penteract7• 2 years ago

That's great. What's the first guess? And does this prove that there is no way of identifying the answer in 2 guesses? I tried running a version of your code across all targets, but my current machine isn't up to it (and there are obviously more efficient ways that you've probably implemented).

I'd like to try out a few alternatives in place of your variance function. Something like b.length*log(b.length) to estimate the expected number of guesses, and perhaps using a version of log closer to ceil(log(x)/log(100)).

kevin_thibedeau• 2 years ago

Binary search on each channel is the optimal general solution without starting from an educated guess on the first try. This is how a successive approximation ADC performs a conversion.

Taek2• 2 years ago

You can do a lot better than binary search because you get a weighted score for each guess.

pinkmuffinere• 2 years ago

You should be able to use BFGS to search for the optimal vector [r, g, b] [1]. BFGS estimates the hessian, and then takes a step in the right direction, so you don’t need any derivatives (the score should be enough).

[1] https://en.wikipedia.org/wiki/Broyden%E2%80%93Fletcher%E2%80...

ldjb2• 2 years ago

It's not linked to from the page, but here's the GitHub repo for anyone interested:

https://github.com/susam/myrgb

cjk25• 2 years ago

This is my party trick. Describe a colour and I'll give you the hex code.

As you can imagine I'm really popular at parties...

benrutter2• 2 years ago

OK let's go!

A muddy yellow reminiscent of the sweet and sour fruit found across Central America and the Southern States.

(Taken from a paint description)

cjk25• 2 years ago

ffcc33

I'm going on supermarket starfruit here so might be a bit off :)

tetris115• 2 years ago

A melancholy purple reminiscent of the twilight depicted in childrens books, 1910, colorized.

cjk25• 2 years ago

eeeeff

comradesmith• 2 years ago

#8855aa

Vvector• 2 years ago

There is a boardgame with this theme. First clue is just one word. Second clue is two words. Everyone places a pawn on their color guess. Points awarded based on distance. Easy to play.

https://boardgamegeek.com/boardgame/302520/hues-and-cues

geoduck14• 2 years ago

This is a good game if you want to be able to hold a conversation with thr people you are playing with. It gets people talking about their experiences. I've played with my own wife and learned about how much she watched TV as a child (did you know Barney changed costumes?), what she thinks of nacho cheese, lipstick, and more.

It is good for people you know as well as people you don't know. The only situation I don't recommend it is if someone in your group wants to win something because the "win" factor is weak.

salomon8122• 2 years ago

Yes! This game is a lot of fun. My only gripe with it is that the red area is small and the green area is huge, and that's really minor complaint. With the right people this game is amazing.

rrr_oh_man4• 2 years ago

A picture taken with a Soviet camera, late 1980's, nostalgia and teddy bears, carpets on the wall, dark wood juxtaposed with the lightness of youth.

cjk25• 2 years ago

That'd be a distinct #66666 ... very boring middle grey. But not too bright.

This would of course just be the median colour. It'd be black and white film because it was cheaper, completely incorrectly exposed so that the blacks were bang at the bottom and the film would be much too high an ISO so it'd be grainy as hell. And there would be someone with a really bad hair cut smoking in it.

Source: still own my Zenit from back then :)

hamburglar• 2 years ago

Now do it by answering with words interpreted as colors using the Netscape algorithm.

I once read a blog post here about how Netscape interpreted colors that are words but aren’t in the official name list, and it comes down to tossing out the non-hex characters and padding/chunking the remaining characters to make RGB numbers, so “dumptruck” might end up being yellow because it ends up being DC0. I immediately wrote a little app that interpreted all the words in /usr/share/dict/words and stuck them in a sqlite db with Lab color representations so you could query for the nearest phony color word for a specific RGB you wanted. It just showed the 100 best matches sorted by closeness, written in their actual color. Fun little spur of the moment evening project.

keepamovin2• 2 years ago

Really so much fun!

This guy produces great things. He did that micro drawing language a while back, right?

Would also be cool to have a camera link where you can select the color to guess by pointing the camera at something.

I find this guy so inspiring. He codes and creates tools like I aspire to. Just beautiful stuff!

susam3• 2 years ago

Thank you for the kind words. Crafting these small tools is a creative outlet for me. To learn that you like these tools is both gratifying and inspiring. So thank you for leaving this comment.

keepamovin2• 2 years ago

You’re welcome man. I love your (art) work.

One day when I get out of the rat race side of software, I would love to just focus on this kind of stuff. So satisfying and creative and beautiful.

zafka• 2 years ago

Reminds me of this: http://yizzle.com/whatthehex/

junon• 2 years ago

This is a lot of fun :)

yakkomajuri• 2 years ago

As someone who knows very little about colors, it was quite fun to see how much green is a light shade of purple I got. Could probably get better at guessing base RGBs I want for thing X on a frontends I build by playing this.

mmahemoff• 2 years ago

This is fun. I like the fact you can click anywhere, which is nice for a non-touch device. Probably would help to emphasise those slider ticks as they are almost invisible, it would it more inviting to click instead of drag.

jacknews• 2 years ago

There are a lot of similar games, eg https://trycolors.com/games/guess-color

I use them in my code club to teach about what is light, actually, how do we perceive color, how tv and computer screens 'trick' your color perception by simply mixing RGB in the right proportions, etc.

skobes• 2 years ago

I got the first one in 10 guesses, then I tapped New Game but the background didn't change and my next guess said NaN%

(Android Chrome)

xandrius• 2 years ago

Try on Android Firefox.

Davidzheng• 2 years ago

same (desktop firefox)

SmartHypercube2• 2 years ago

Exact same behavior here. I got it in 24 guesses. New Game doesn't change the color and guesses show NaN%.

(Windows Chrome)

brk• 2 years ago

Same safari mobile.

susam3• 2 years ago

Thanks for the bug report. This should be fixed now!

penteract7• 2 years ago

I swear that #516 looks darker than #505 (although perhaps only against a background of #505 with #808 next to it). Something interesting is going on there with my perception of saturation.

lukew3• 2 years ago

I made something similar a while ago. I opted for calculating a score based on the sum of distance between each of the channel values and gave users one guess. https://lukew3.github.io/color-code-tutor/

sidedishes• 2 years ago

This is very nice! Someone I know made one of these too a while back with a similar UI - https://gkpotter.com/projects/rgb/

kookamamie• 2 years ago

Is the guessing done in linear or sRGB space?

doctorhandshake• 2 years ago

Vaguely reminiscent of Specimen by Charlie Whitney and Erica Gorochow https://playspecimen.com/ … a great game if you haven’t tried it, and unusually revealing about the limits of perception.

nurple• 2 years ago

Reminds me of a video[0] that describes Diffie-Hellman key exchange in terms of mixing color values (as globs of oil paint).

I guess in this game you're guessing the mix of primary colors, so maybe it doesn't hold the same property of difficulty in deriving the constituents?

[0] https://www.youtube.com/watch?v=YEBfamv-_do

bbx• 2 years ago

It's funny. I just finished writing a lesson where I teach about different color formats. In it, I explained how difficult it was to choose a color with rgb values, because that's not how humans think about color. This game is a great example of that.

HSL is much more intuitive. As soon as you have an idea of the hue scale, it's very easy to define a color with saturation and lightness levels.

Daub• 2 years ago

Completely agree about HSL being the 'thinking' color space. As an exfersise, I get my students to define the difference in the colors they are wearing using HSL.

If you think RGB is hard to conceptualize, try Lab.

mansarip• 2 years ago

my eyes!

antonpuz• 2 years ago

What's the problem? just check the background color in inspect element and normalize to 16 levels :) haha

But really, good job! very nice game, fun and challenging

CuriouslyC• 2 years ago

Landed on a high blue, guessed #00CC00, was correct, closed the browser. Kind of interesting I suppose though maybe more granularity so that I can't so easily guess?

azeemba• 2 years ago

Ha this reminds me of a game me and my friend made a few years ago: http://rbgnrgb.com/

You play as RBG fighting monsters with different RGB values.

ssimono• 2 years ago

Reminds me of something similar I made a few years ago: https://github.com/ssimono/hexliterate It still works, that's a multiplayer real-time game

chrismorgan• 2 years ago

#f09 hurt.

seabass• 2 years ago

This is unintentionally a great ad for perceptual color spaces. I found it easier to ignore the color and just look at the percentage changes after a while when zeroing in on a guess. I wonder if that would be different in a game of Guess My OKLCH!

ivanjermakov• 2 years ago

I noticed that percentages are not quite accurate to perception when color is really close (it seems to cap at 95%).

htk• 2 years ago

I LOVE this. I'll become RGBruceLee if I play this enough.

mirlind_guri223• 2 years ago

snap hack paswordp

mirlind_guri223• 2 years ago

hack pasword

mirlind_guri223• 2 years ago

hack pasword snapchat

nick238• 2 years ago

Did it work?

salomon8122• 2 years ago

For those that love this game (as I do) I recommend "I Love Hue" for mobile.

blt2• 2 years ago

Agree, that game is great for anyone who enjoys a color perception challenge!

I just bought my first OLED phone, maybe it's time to play again.

tamimio• 2 years ago

Love it, first one took 15 steps, second one took only 4!

blt2• 2 years ago

Curious if anyone can see the difference between #DD2 and #DD3. It was impossible on my 2013 Retina Macbook.

chrisjj4• 2 years ago

I can on Samsung phone. But the difference is tiny. You found two of the closest colours in the space.

hivacruz• 2 years ago

For a few recruitments, we asked the candidates to create a front app like this with React. It was quite nice as we could quickly see how they use the library, what they know etc.

Simple app but funny game.

mldbk• 2 years ago

Randomly got from first attempt

teensydata• 2 years ago

It's funny that I made a website exactly like this a few months ago. It was supposed to be Wordle for colors

pteraspidomorph• 2 years ago

I got the first one in a single guess and now I'm afraid it can only go downhill from here...

yoyopa• 2 years ago

isn't this HEX? RGB is usually 0-255 or 0 to 1

stanleykm• 2 years ago

it is rgb just 4 bits per channel instead of 8

imacomputer• 2 years ago

Nice! I would love to study how people hone in the correct color, and how close people get on the first try.

Do people binary search or scan a range?, how do they prioritize the color channels? etc

taylorius• 2 years ago

I seem to be able to get it in around 7-8 guesses usually - based on a fairly good initial guess (85% or so) and the heuristic that if the percentage went up by 1 in the previous axis increment / decrement, that axis is now at the correct value. It's a really entertaining game. Kudos to the author!

hunter2_• 2 years ago

Reminds me of notching out microphone feedback on a 31-band graphic equalizer without a real-time analyzer revealing the frequency. There was ear training software to simulate this activity, for practicing the art.

indigoabstract• 2 years ago

It would be interesting to know what type of people would find this game amusing..

Since I'm one of them, perhaps programmers?

xzel• 2 years ago

This is awesome! I would love a GeoGuessr style gameplay element and watch my design friends compete over a couple of beers!

Guess my RGB

Related Stories