I am considering a problem with ~ 3k valid solutions and ~ 17k possible guesses.

I have tried running the code:

• on my local machine,
• on Google Colab.

In both cases, I am faced with high usage of RAM. I wonder if this is normal due to the method used, or if there is a memory leak in the code.

The script runs fine for now.

The RAM usage linearly increases.

High RAM usage ends up leading to a crash.

The script has crashed.

For reference, this does not happen (or it does not have enough time to happen) if I consider a smaller problem where the possible guesses are forced to be valid solutions, i.e. with ~ 3k valid solutions and ~ 3k possible guesses.

Also, the tool TylerGlaiel/wordlebot does not have this issue with the large problem. It is a C++ program which uses different methods, vaguely explained in this blog post. There are 3 methods, and the Complex one is horrendously slow (but does not crash), and the two other methods (Simple and MinMax) are fine.

Add an all_word.txt file and let the bot use the entropy until the entropy gets too small. It helps to reduce over-rounded resolutions. Added option to choose initial guess ('tares' for every word) to reduce testing time. The average round is now around 4.12 for all 2315 solutions with 1 over-rounded solution (7 rounds)

next stage

1. Use multi-processing to reduce processing time.
2. Consider frequently used words using NLTK or other way

For example, calculate_pattern('meets', 'weary') currently returns (0, 2, 1, 0, 0), however the correct pattern should be (0, 2, 0, 0, 0) since there is not a second e in the target word. One way to do this correctly is:

from collections import Counter

def calculate_pattern(guess, true):
    '''Yield the pattern that Wordle would return if you guessed `guess` and the true word is `true`'''
    yellows = Counter(true)
    for x, y in zip(guess, true):
        if x == y:
            yield 2
        elif yellows[x] > 0:
            yield 1
        else:
            yield 0
        yellows[x] -= 1

you just need to then call this as tuple(calculate_pattern(word, word2)).

Running the wordle.py file with a larger wordlist. 3b1b's 12k word list to be precise. Will make its way to 63% and then my computer freezes and then the terminal kills what's running and it stops.

(wdlENV) [ori@orio Wordle-Bot]$ python wordle.py

 63%|█████████████████████████████████████████████▋                          | 8226/12972 [04:43<07:08, 11.07it/s]
Killed

(wdlENV) [ori@orio Wordle-Bot]$ 

No idea as to why this happens but it does...

I think you need to do two passes in order to also catch corner cases like calculate_pattern('rower', 'goner'), which currently returns (1, 2, 0, 2, 2) instead of (0, 2, 0, 2, 2).

Originally posted by @gbotev1 in https://github.com/GillesVandewiele/Wordle-Bot/issues/2#issuecomment-1038630546

This commit builds upon #13, and aims to follow the strategy described in https://github.com/GillesVandewiele/Wordle-Bot/issues/9#issuecomment-1193172701 for the computation of entropy.

I would need to test the software to check if I did not break anything with my changes.

This should clarify with view from #9 and would avoid removing the code as I suggested in #10.

This commit builds upon #12, and aims to break down the computation of entropy in chunks.

This commit adds utilities to read/write pattern_dict.p (retro-compatibility), and allows to deal with several numbered versions.

This is important for another pull request (#12) which breaks down the dictionary of patterns into chunks.

This commit fixes a bug in the original code, as a function is missing an argument. Without this fix, the following error is returned:

Traceback (most recent call last):
  File "C:\Users\Wok\PycharmProjects\Wordle-Bot\wordle.py", line 135, in <module>
    main()
  File "C:\Users\Wok\PycharmProjects\Wordle-Bot\wordle.py", line 113, in main
    entropies = calculate_entropies(candidates, all_words, pattern_dict)
  File "C:\Users\Wok\PycharmProjects\Wordle-Bot\wordle.py", line 62, in calculate_entropies
    for pattern in all_patterns:
NameError: name 'all_patterns' is not defined

I don't understand the double call to calculate_entropies(). Could you clarify the reason behind it?

https://github.com/GillesVandewiele/Wordle-Bot/blob/f6334959105549745300ff2c1fc7f80e7c8d7a07/wordle.py#L112-L117

Indeed:

• the set all_words is a subset of all_dictionary,
• the variable entropies is a dictionary whose keys are candidates by design.

So the second call to calculate_entropies() recomputes entropy values which were already computed by the first call.

If the objective is to decrease the number of items fed to max(), it could be done by filtering entropies returned by the first call.

https://github.com/GillesVandewiele/Wordle-Bot/blob/f6334959105549745300ff2c1fc7f80e7c8d7a07/wordle.py#L119-L120