Add Wordle.import/2 to speed up setting up Wordles

lib/wordle.ex

@@ -14,6 +14,17 @@ defmodule Wordle do
 
   alias Wordle.{Game, Solver}
 
+  @spec import(:en | :pt_br, integer) :: [binary]
+  def import(language, n_letters) do
+    "dicts/#{language}.txt"
+    |> Parser.import_dictionary()
+    |> Parser.trim()
+    |> Language.normalize(language)
+    |> Parser.filter_valid()
+    |> WordStats.order_by_scores()
+    |> Parser.filter_number_of_letters(n_letters)
+  end
+
   @spec solve([binary], binary) :: {:ok | :error, [binary]}
   def solve(wordlist, right_word) do
     solve(wordlist, right_word, [], wordlist)

test/integration_test.exs

@@ -1,35 +1,55 @@
 defmodule IntegrationTest do
   use ExUnit.Case, async: true
 
-  @max_attempts 11
+  @language :pt_br
   @letter_count 5
   @moduletag :integration
+  @moduletag timeout: :infinity
 
   setup :wordlist
 
   describe "Wordle.solve/2" do
-    test "solves every case in less than #{@max_attempts} attempts", %{words: words} do
-      words
-      |> Enum.with_index()
-      |> Enum.each(fn {right_word, index} ->
-        assert {:ok, guesses} = Wordle.solve(words, right_word),
-               "Could not solve for #{right_word} at position #{index}."
-
-        assert length(guesses) <= @max_attempts,
-               "Expected to succeed with less than #{@max_attempts} attempts, got [#{guesses |> Enum.join(", ")}]. Failed with word #{right_word} at position #{index}."
-      end)
+    test "solves in an average number of guesses", %{words: words} do
+      solved =
+        words
+        |> Enum.with_index()
+        |> Enum.map(fn {right_word, index} ->
+          Task.async(fn ->
+            assert {:ok, guesses} = Wordle.solve(words, right_word),
+                   "Could not solve for #{right_word} at position #{index}."
+
+            {right_word, length(guesses)}
+          end)
+        end)
+        |> Task.await_many(:infinity)
+        |> Enum.group_by(&elem(&1, 1), &elem(&1, 0))
+        |> Enum.map(fn {n_guesses, words} -> {n_guesses, length(words)} end)
+        |> Map.new()
+
+      average =
+        Enum.reduce(solved, 0, fn {guesses, count}, acc -> acc + guesses * count end) /
+          length(words)
+
+      assert average == 4.0650467289719625
+
+      assert solved == %{
+               1 => 1,
+               2 => 185,
+               3 => 1574,
+               4 => 2088,
+               5 => 980,
+               6 => 335,
+               7 => 125,
+               8 => 47,
+               9 => 10,
+               10 => 3,
+               11 => 2
+             }
     end
   end
 
   defp wordlist(context) do
-    words =
-      "dicts/pt_br.txt"
-      |> Parser.import_dictionary()
-      |> Parser.trim()
-      |> Language.normalize(:pt_br)
-      |> Parser.filter_number_of_letters(@letter_count)
-      |> Parser.filter_valid()
-      |> WordStats.order_by_scores()
+    words = Wordle.import(@language, @letter_count)
 
     context
     |> Map.put(:words, words)

test/parser_test.exs

@@ -2,8 +2,6 @@ defmodule ParserTest do
   use ExUnit.Case, async: true
   doctest Parser
 
-  @moduletag :wip
-
   describe "filter_number_of_letters/1" do
     test "only returns 5 letter words" do
       words = ~w(do you wanna see five letter words now)

test/word_stats_test.exs

@@ -1,5 +1,6 @@
 defmodule WordStatsTest do
   use ExUnit.Case, async: true
+
   doctest WordStats
 
   describe "letter_frequencies/1" do

test/wordle/game_test.exs

@@ -1,6 +1,8 @@
 defmodule Wordle.GameTest do
   use ExUnit.Case, async: true
+
   alias Wordle.Game
+
   doctest Game
 
   describe "guess/2" do

test/wordle_test.exs

@@ -1,5 +1,6 @@
 defmodule WordleTest do
   use ExUnit.Case, async: true
+
   doctest Wordle
 
   setup :words