This reminds me of something about flash games in the 2000s. I was in high school at the time and every morning in class I would check onemorelevel, kongregate, etc for new games. There was a pattern in flash games where someone would make a great simple game with an interesting, novel, or long-forgotten mechanic. It would get to the frontpage of all these sites, and a few months later you'd see that mechanic mixed with every other popular flash game mechanic. It was really cool to see a community of creative people embrace an idea and then beat it to death in a short period of time. I think in a lot of other creative genres, this kind of "copying your idea but a twist" is seen as poor form, plagiarism, or derivative. Maybe the flash game community was low enough stakes that it welcomed that kind of community engagement. I wonder what the people actually making the games thought.

Anyway, this is a really cool example of that. It's wordle, but with a twist.

“Immature poets imitate; mature poets steal; bad poets deface what they take, and good poets make it into something better, or at least something different. The good poet welds his theft into a whole of feeling which is unique, utterly different than that from which it is torn.” https://www.benshoemate.com/2012/08/02/what-does-it-mean-goo...

My side-project this week has been searching for an optimal Wordle strategy. I figured it would make a great blog post but I haven't got that far yet.

Step 1 is to find an optimal starting word. My most insightful finding so far has came from trying to define a cost function for comparing potential starting words. It turns out that "% of potential guesses [not] eliminated" is an excellent loss function.

Importantly, the full set of all Acceptable Guesses is knowable. For any given (guess, answer) pair, the game provides feedback about each character (or digit). There are basically three pieces of potential feedback: (N)ot Used, (U)sed Elsewhere, (E)xact Match. For example, a single guess might produce the feedback "NUNNE". Each of these will eliminate some subset of Acceptable Guesses which means you can attribute a fixed value between 0.0 and 1.0 to any piece of feedback, and multiply those together to get the loss score of a given guess. Average that across all Potential Answers to get a cost score.

Not sure what my goal of this post is. Guess I just wanted to share that these games are as much fun to analyze as they are to play (if not more).

I've given some light thought to this: There are several which are considered "good starting words", that mainly contain lots of vowels or most common used letters (such as "audio", Raise, etc). Then, as a second word, you could use another word that complements those letters (audio/rents, raise/mould ).

But there is a better strategy (similar to what is used in those interview puzzles of "From N weights, find 1 that is different in X measurements of a scale): The fact that you input some vowels and see that they are not in there, tells you that the remaining ones MUST be in the word (treating Y as a vowel as well). So it might be possible to come up with a strategy that uses that negative information as well to minimize the search space.

I still find it useful to supply the missing vowels anyway because it gives you an opportunity to find out where they are in the word.

I made a lil clone of wordle and found that the full list of solutions, past and future, is right there in the minified js. Could be useful for your analysis.

Maybe I shouldn't be sharing this, it's a bit sad to break the illusion that the creator is picking a new word for us every day.

I had always assumed it was a random word from a dictionary. I didn’t think someone was actually choosing a word manually :)

I went to the source code of wordle & copied all 12000 words to an excel sheet Column A, starting from row 4.

3rd row for next 18 columns has drop down filter.

You guess any word with at least 2 vowels, if 3 better, no repeat letters. You get some grey, some yellow, some maybe green.

2nd column to 6th column on excel sheet is the Grey Letters, Not Found in Answer. In this, 2nd row, if u find any grey you type it here. The formula from row 4 downwards in this group checks if its top input cell is empty, if yes, true, if not empty, then it check if that letter exists in its row cell of column A. If exists, false (grey means no letter), otherwise true.

Column 7th to 11 are yellow. Same thing, row 2 gets input, 4th row onwards checks if this exists in Column A cell, true, otherwise false. If input cell empty, then True.

Column 12 to 16 gets green letter input. Here input goes by position, if 2nd letter is green, you type it in 2nd column of this group, which is 13th column.

Formula in 4th and next checks if input empty, true, otherwise if input exist in exact position, true, otherwise false.

17th column is empty & narrow, to create a gap.

18th column returns 0 if any false found in while row. Any false means this word is not the answer. Otherwise returns 1.

A separate one cell counts all those 1, tells me how many potential answers are. After every try/word, one can filter this last column on 1.

You are looking for Information Gain and Mutual Information (concepts from information theory). Have fun!

This website is currently hosting a competition until the end of the month for Wordle strategies if you want to see how it compares: https://botfights.io/game/wordle

Interestingly, I made a coding challenge for this exact problem a few years ago. You can find it on the Code Golf StackExchange website: https://codegolf.stackexchange.com/questions/26858/guess-the.... The challenge is named after the Lingo TV show which used the concept repopularized by Wordle. Lingo itself took inspiration from a 1955 paper game named Jotto. Regarding strategies used in the challenge, the best performing solution was an adaptation of a Mastermind solver.

My first two guesses are usually AUDIO and RENTS if it helps ¯\_(ツ)_/¯

I use WEIRD, my completely untested and I researched intuition being that knowing common consonants are in a word isn’t helpful unless you get the right place, but knowing the vowels is. At least that was my logic when I first played and my brain produced WEIRD.

I’m sure it’s far from optimal, but I continue to use it because I obviously understand how I came to choose it, and it “works” and survivor bias is powerful :)

I recall seeing HN posts from people working out “optimal” starting words and guess patterns, but I just like mine :)

I use ADIEU to get 4 wovels, likely the same reason you picked AUDIO.

SLATE/ROUND/PICKY has been a 8/8 for getting the correct word on the 4th guess since I started using it.

Since you've been looking into it, how are words with multiple of the same letters treated on Wordle. If there are two (or three) 'E' in the solution or the guess?

I've spent some time analyzing Wordle (my starting words are SOARE and then BUILT, unless I've already got strong clues from SOARE).

If the answer has one E and you guess a word with two Es, only one of the Es will be marked correct (green/yellow). If one of the Es is in the correct place, it will be green and the other one grey. Otherwise the first E will be yellow and the second grey. So if the answer has fewer Es than your guess the game tells you.

If the answer has more Es than your guess there is no indication of this.

Today 538 gave the optimal starting word and all the best second words, with a 60% chance of solving it in three words. Completely ruined the game, in my opinion.

There is one solution which is very close to what you're describing. Read if you want to ruin the fun for yourself.

https://aditya-sengupta.github.io/coding/2022/01/13/wordle.h...

I think single level is not enough for the best guess. There is a maximum depth ( 6 guesses ). So strategy should consider also this limit.

Crowdsourcing decryption on the web is so crazy... it just might work.

Now come up with a hash that starts with many zeroes.

There should be an option to use the "numbers" that are prime in a different universe.

what would that be?

"oops, sorry that one was discovered already"

    12347
      -
    65393
    ++--
   [solution next - omitted for spoiler reasons]

I was more surprised about how little trial and error I needed to find primes than about how few guesses it actually took...

Same, I was so surprised to get it solved at the second row, after ~8 attempts to find a prime without the numbers that had not matched.

    12347
      -
   [solved]

It seems a lot of us came up with 12347 for the first line.

While natural in terms of just inputting numbers, it's also not bad to use as first guess because primes are denser (in an "average absolute distance" sense) the lower the magnitude you're around. Without having checked, I would expect there to be more primes of the form 123** than 987**, so you're more likely to gain correct digits with this guess.

Edit: I checked, it's 9 vs 8 primes. But nearby prefixes also have more and there's a lot of variance. Still, there are overall more primes among the same range of smaller numbers (1000-5499 has ~4400 primes, 5500-99999 has ~4000).

Note that, despite this, you probably shouldn't include 0 in the starting guess (e.g. 10247) because 0 will be in the solution less frequently (can't be the leading digit), meaning you gain less info on average.

I read the "help" thing, which suggested 71429 as the first guess, so I started there. (9 was right, and the other digits were wrong. That meant the second guess got the right digits, and the third guess got the right prime.)

56809 is a pretty good second guess for this situation :p

Ha, those were exactly my first 2 guesses.

log(100000) is 5, so approximately 1 in 5 numbers below 100k is prime. Obviously those in the range 10000-99999 are less dense, but primes are still surprisingly common.

You want a natural log there; ln(100000) ~ 11.5.

That being said, the pool you're really working from is the numbers with last digit 1, 3, 7, or 9. One out of every 4.6 such numbers under 10^5 is prime. So just guessing until you find a prime is practical.

Ah you're correct. Annoying how Google interprets log(x) as base-10 (but more shame on me for not realising that e^5 is obviously not 100000). In my experience everyone uses log and ln interchangeable outside of lessons at school.

log(x) historically conventionally defaults to base-10. https://en.m.wikipedia.org/wiki/Common_logarithm

As the wiki page itself notes though:

> On calculators, it is printed as "log", but mathematicians usually mean natural logarithm (logarithm with base e ≈ 2.71828) rather than common logarithm when they write "log".

Hi, can you provide some search terms that will help me understand the relationship between ln and prime density?

Or https://en.wikipedia.org/wiki/Prime-counting_function .

And you can knock out multiples of 3 by adding digits.

Sure, but that's a little more work than just looking at the last digit, so it's debatable whether it's worth the trouble.

Looks like there's 8,363 5 digit primes, from 10007 to 99991, so about 1 in 11

Why isn’t 00002 your lower bound?

The game does not accept leading zeros (00017: "Not a 5 digit prime")

This is really cool, nice idea!

Also, the following script might help to make the game more accessible (or to help you cheat :P) -

  // note: game doesn't seem to automatically clear at the end, so in the dev console use:
  // window.localStorage.clear();
  // then refresh the page

  const prime = n => {
    for (let i = 2, s = Math.sqrt(n); i <= s; i++) {
      if (n % i === 0) {
        return false;
      }
    }
    return n > 1;
  }
  const generateNums = digits => (
    m => [...Array(9 * m).keys()].map(i => i + m)
  )(Math.pow(10, digits - 1));
  const generate5DigitPrimes = () => generateNums(5).filter(prime);

  const all5DigitPrimes = generate5DigitPrimes();

  // updated to take an optional array (defaults to all5DigitPrimes)
  // this means you can chain the check function to do things that normal regex can't do
  // e.g. check(/some_regex/, check(/some_other_regex/))
  const check = (r, a = all5DigitPrimes) => a.filter(p => r.test('' + p));

Usage:

paste the above code into the dev console

type 'all5DigitPrimes' and press Enter to see a list of all 5-digit primes

type 'check(/some_regular_expression/)' to see a filtered list of primes that match your regular expression

I also cheated with a script, leading to this:

https://pastebin.com/sQtekXCW

I thought coming up with primes would be very challenging, but then my first three guesses were all prime (all I did was pick numbers that ended with odd numbers that weren't five). I got it on the fourth after a few attempts at entering the number - the prime constraint here makes it easier.

There are 8,363 five digit primes. If you limit your guesses to numbers ending in 1, 3, 7, and 9, there is a 23% chance of randomly picking a prime.

Amusing to see people starting with odd digits so much. You're going to have to use an odd digit in every guess, so you can more efficiently explore the space by going after all the even digits first with 24683.

56843 was mine, for similar reasons.

So are people just really good with numbers? I don't know any 5 digit primes nor do I know a way to calculate them on the fly.

apparently 9.3% of all '5 digit' numbers are prime, so random guessing isn't a bad strategy - you'll find one in 10.75 totally randomly chosen numbers to be prime.

Being a little smarter, prime number can only end in a 1, 3, 7 or 9 - (ending in 0, 2, 4, 6, 8 would be even, ending in 5 would be odd), so in fact it's more like 25% of 'likely' guesses.

IIRC, randomly guessing is _always_ a good strategy for "give me a prime in the range [a, b]" , in other words that's what's used for algorithms that need primes anyway. Either guess and check or guess and increase-by-2-until-prime.

Does work _much_ better in this range than at crypto sizes though.

Its a weird thing where in smaller scales, primes numbers that LOOK prime are decent candidates of actually being prime.

All one- and two-digit numbers that look prime are prime, except 91.

This assumes that you can easily identify - multiples of 2 and 5 (by their last digit) - multiples of 3 (the sum of their digits is divisible by 3) - multiples of 11 (for two-digit ones, they have both digits the same: 11, 22, 33, ..., 99) - squares

So the first number that looks prime but isn't is the product of the two smallest primes that aren't "easy", which is 7*13 = 91.

I used this site to explore options. http://compoasso.free.fr/primelistweb/page/prime/liste_onlin... It's a bit tedious but still fun-ish and seemed better than guessing.

Unlike Wordle, I assume it's unreasonable to expect a player to know primes so I don't think I'd call this cheating.

I intuited a probably-inaccurate trick with exponentially raising a small prime (e.g 7*7*7etc), doubling the multiple (*2), and subtracting 1 (to get an odd number).

That got me two substantially-different primes and narrowed my numbers a lot, which then became guesswork.

My guesses in the end:

  -?---
  ?---!
  ?-??!
  ?!??!
  !!!!!

The number you come up with in that way is at least guaranteed to not be divisible by 2 or 7. Obviously that doesn't mean it's prime but it definitely helps your odds.

Also usefully, (2(a+1)^n-1) % a = (2a(a+1)^(n-1) + 2(a+1)^(n-1) - 1) % a = 1. So if you choose one of the 3k+1 primes, it's also guaranteed not divisible by 3.

lol this would not help me at all

by the way am I supposed to take some meaning from the italicized '7' or was that just a typo?

He probably had 7x7x7, but with asterisks instead of the "x"s.

correct, thanks for the heads up. Fixed

If you are on Unix:

    primes 10000 99999 | less

Then recall that "less" includes a regex-based search on the / key.

This doesn't give you direction as to the best to try, of course, but it's hard to beat it in terms of bang for the buck if you're just going to try a few.

You can guess a prime relatively easily given a few attempts, as besides 2 and 5, all other primes will have a 1, 3, 7, or 9 as its least significant digit. So, for starters, you'd never guess a number with any other least significant digit.

Yeah I would really rather this just let me guess non-primes even though that would make it more challenging. Trying to find a prime by guessing randomly over and over is pretty frustrating.

I thought the same, but it rejects guesses that are not valid prime numbers. So you'll find some with trial and error. With that it took me only three guesses.

This script took less than a second to run:

seq 10000 99999 | factor | grep '^\([^:]*\): \1$' | cut -d: -f1 >5_digit_primes.txt

Using that file with grep was helpful for refining guesses.

I always appreciate a good shell pipeline, shared.

I am stronger in python, and definitely wrote a script to cheat at Words With Friends back in the day (always told my friend afterwards and only pulled that stunt a few times).

If I had known posix better, my script may very well have been a one-liner of bash. Awk-ward.

Someone more skilled than me make Assemble, each box is an x86 opcode and the program must terminate (or maybe NOT terminate?).

I couldn't come up with any primes, nor I'm any good with numbers, so I started with the prime from the game example:

71429

Than I already had one digit guessed and simply clicked the unused numbers from the virtual numpad below and got to having all digits with just two being in the wrong place:

35869

Now this was easy to figure out.

Got the following score: 20 3/6

My first inclination was to write a solver :)

https://gist.github.com/nickponline/9a3fb1ee5333c52ed195625e...

Nice solver! I did optimize the sieve a little...

N = 100000 primes = [False, True] * N // 2 for i in range(3, N, 2):

    if primes[i]:
        k = i ** 2
        while k < N:
            primes[k] = False
            k += i * 2

N = 100000 prime = [False, True] * (N // 2) primes = [] for i in range(3, N, 2):

    if prime[i]:
        primes.append(i)
        k = i ** 2
        while k < N:
            prime[k] = False
            k += i * 2

useful = [ str(i) for i in primes ]

# Enter your clues

for i in useful: if i[0] == '6' and ('3' in i) and len(str(i)) == 5: print(i)

This is neat! Although the prime constraint makes this a lot easier than Mastermind

A list of possible primes showing up as you type would be helpful...

Can't work out how to play again.

This is modeled on Wordle, which only allows one game per day... to keep you coming back. Apparently it is effective.

I have the same problem with the cross words in my newspaper ;)

Clear local storage.

Wow, that’s some bad UX. Especially when it can’t as easily be done on mobile.

Or play in privacy mode.

The intent, I think, is to mimic how Wordle works. Wordle has one puzzle per day, progress and statistics are stored in a cookie on your local machine (and only there). You can clear the cookie or use another browser or privacy mode to play multiple times per day, but you'll always get the same word.

It's a clone of Wordle. There is a single correct answer per day, and everybody gets the same puzzle. There will be a new answer tomorrow.

So, since the puzzle will be the same, there isn't a huge amount of reason to let you reset.

The page could have made that clearer. (Wordle says it when you open it the first time, and also under the help menu.) I double-checked this by looking at the sourcecode.

> So, since the puzzle will be the same, there isn't a huge amount of reason to let you reset.

Good point! Somehow, being numbers, I thought it would just make up another.

It’s intentional, same as Wordle’s designed did it.

That... is not ideal.

First attempt I tried:

  45677
  56779 (Didn't read the instructions, the 5 should have stayed from 1st)
  15809
  35869
  65839 (Solved)

EDIT: I'm slow today, just realized they are both the same primes.

The repo linked in the game seems to lead to a general Wordle clone. I’m guessing you forked it and replaced the keyboard with numbers and the word checker with a prime number checker?

That's a lot more work than just populating with a list of eligible primes

Hahaha yes, true ;)

Ok, so once you've won how do you start a new game?

If it works like Wordle, you wait until tomorrow.

Looks like that's the case, thanks!

The prime detection is broken. I tried 00002, 00005, and 00031 and it said those aren't prime even though they are.

It says they aren't 5 digit primes. 2 and 5 are 1 digit primes, 31 is a 2 digit prime. Putting extra 0s in front of them doesn't change that.

97501 and 24683 will get you all of the numbers (and maybe some position matches), from there it becomes much easier.

Enable "hard mode" in a future release, which, like Wordle's hard mode, rejects any guesses ruled out by previous answers.

I'm not seeing a hard mode option today.

when sum of the digits is divisible by 3, the number itself is divisible by 3

1+8+1+4+1 = 15 15/3 = 5

Sure, but that shouldn't halt the game entirely, should it?

Only primes are valid guesses, just like how in Wordle only English words found in a dictionary are valid.

You have to click delete to reset the last digit.

I think it should clear the whole guess after an invalid guess.

That would be annoying.

Were you able to hit the delete key and remove the typed numbers? (Works on wordle too)

I did 235711*13 - 1

Primel 20 6/6

⬜⬜⬜30029 ⬜⬜⬜⬜12347 ⬜⬜⬜⬜33331 ⬜⬜⬜⬜13337 86539 65839

This is way harder than wordle

MasterMind!

Just say so!

Not easy. Mine:

65537

12497

80747

23459

64217

14771

I solved it on the first try! (after cheating with localStorage)

Hint: The number should not end in any of 0, 2, 4, 6, or 8!

Or 5.

00003 is not a prime?

It's not a 5 digit prime.

0 is a digit.

Apparently I have stumbled over an idiom of the prime-enthusiast community.

I don't think it's specific to "the prime-enthusiast community". Most people would look at you oddly if you claimed that 3 is a five-digit number.

Only to win an argument by nitpick golfing. In everyday serious conversation that’s a 4-byte number, not an 8-digit number.

> 0 is a digit.

It’s not a significant digit[0], though, when it’s leading.

[0] https://en.wikipedia.org/wiki/Significant_figures

I don't think the different usage is related to an individual group rather context, particularly when referring to numbers.

E.g. 3 is a 1 digit number because that's the number of digits needed to uniquely identify 3. There are infinitely more ways to identify 3 the number with padded 0s but those aren't useful unless you're talking about combinations/sequences of groups of digits (like random numbers or PIN codes) instead of actual number values.

I agree -- maybe technically not a digit, but I'd argue it's a UX issue if it is allowed in the leading slot.

But I still love the concept!

Edit: Alas, the yellow and green square emoji are discarded.

⬛⬛⬛⬛ ⬛⬛⬛ ⬛

Partially interpreted:

⬛⬛🟨⬛⬛

🟨⬛🟨⬛⬛

🟨🟨🟨⬛🟩

🟩🟩🟩🟩🟩

Primel 20 2/6

Edit, I guess HN doesn't like emojis lol

My path:

1 2 [3] 4 7

[5][6](8)[9][3]

(6)(5)(8)(3)(9)

Fun game! Might take a while to explain to people though!

Primel 22 3/6

⬜⬜ 18413 ⬜ 28163 98123

Primel 20 6/6

⬜⬜⬜ ⬜ ⬜ ⬜ ⬜