ruby-wordle 0.9.2 → 1.0.0

data/lib/ruby-wordle/dictionary.rb

@@ -0,0 +1,74 @@
+require "set"
+
+module RubyWordle
+  # Word lists for one word length.
+  #
+  # +answers+ are common words a game picks from; +guesses+ are every word
+  # accepted as a guess. Every answer is also a valid guess.
+  class Dictionary
+    DATA_DIR = File.expand_path("../../word-lists", __dir__)
+    WORD_LENGTH = 5
+
+    attr_reader :answers, :guesses, :length
+
+    def self.load(dir = File.join(DATA_DIR, "#{WORD_LENGTH}-letters"), length: WORD_LENGTH)
+      read = ->(name) { File.readlines(File.join(dir, name), chomp: true) }
+      new(answers: read.("word-list-basic.txt"), guesses: read.("word-list.txt"), length: length)
+    end
+
+    def self.default
+      @default ||= load
+    end
+
+    def initialize(answers:, guesses:, length: WORD_LENGTH)
+      @length = length
+      invalid = (answers + guesses).grep_v(/\A[a-z]{#{length}}\z/)
+      raise ArgumentError, "not #{length} letters a-z: #{invalid.first(3).join(', ')}" unless invalid.empty?
+      raise ArgumentError, "no answers" if answers.empty?
+
+      @answers = answers.uniq.sort.freeze
+      @guesses = (guesses | answers).sort.freeze
+      @answer_set = @answers.to_set
+      @guess_set = @guesses.to_set
+    end
+
+    def valid_guess?(word)
+      @guess_set.include?(word)
+    end
+
+    def common?(word)
+      @answer_set.include?(word)
+    end
+
+    # Keeps alphabetic words of +length+ letters, lowercased. Capitalized
+    # entries in a source list (proper nouns) are dropped when
+    # +lowercase_only+ is set.
+    def self.normalize(lines, length:, lowercase_only: false)
+      lines.map(&:strip)
+           .reject { |w| lowercase_only && w.match?(/\A[A-Z][a-z]/) }
+           .map(&:downcase)
+           .select { |w| w.match?(/\A[a-z]{#{length}}\z/) }
+           .uniq
+           .sort
+    end
+
+    # Writes the n-letter lists derived from the full and basic source lists.
+    def self.generate(length:, source_dir: DATA_DIR, out_dir: File.join(source_dir, "#{length}-letters"))
+      read = ->(name) { File.readlines(File.join(source_dir, name), chomp: true) }
+      basic = normalize(read.("word-list-basic.txt"), length: length, lowercase_only: true)
+      all = (normalize(read.("word-list-original.txt"), length: length) | basic).sort
+      uniq = ->(words) { words.select { |w| w.chars.uniq.size == length } }
+
+      Dir.mkdir(out_dir) unless Dir.exist?(out_dir)
+      {
+        "word-list.txt" => all,
+        "word-list-uniq-letters.txt" => uniq.(all),
+        "word-list-basic.txt" => basic,
+        "word-list-basic-uniq-letters.txt" => uniq.(basic)
+      }.each do |name, words|
+        File.write(File.join(out_dir, name), words.map { |w| "#{w}\n" }.join)
+      end
+      out_dir
+    end
+  end
+end

data/lib/ruby-wordle/feedback.rb

@@ -0,0 +1,73 @@
+module RubyWordle
+  # Wordle feedback for one guess against one answer.
+  #
+  # A pattern is an Integer in base 3, one digit per position (position 0 is
+  # the least significant digit): 0 = absent, 1 = present elsewhere,
+  # 2 = correct. Integers keep the solver's partitioning cheap.
+  module Feedback
+    ABSENT  = 0
+    PRESENT = 1
+    CORRECT = 2
+
+    SYMBOLS = { "x" => ABSENT, "b" => ABSENT, "0" => ABSENT, "-" => ABSENT, "." => ABSENT,
+                "y" => PRESENT, "1" => PRESENT,
+                "g" => CORRECT, "2" => CORRECT }.freeze
+
+    module_function
+
+    def score(guess, answer)
+      size = guess.bytesize
+      marks = Array.new(size, ABSENT)
+      remaining = Hash.new(0)
+
+      size.times do |i|
+        if guess.getbyte(i) == answer.getbyte(i)
+          marks[i] = CORRECT
+        else
+          remaining[answer.getbyte(i)] += 1
+        end
+      end
+
+      size.times do |i|
+        next if marks[i] == CORRECT
+
+        byte = guess.getbyte(i)
+        if remaining[byte] > 0
+          marks[i] = PRESENT
+          remaining[byte] -= 1
+        end
+      end
+
+      encode(marks)
+    end
+
+    def encode(marks)
+      marks.reverse_each.reduce(0) { |acc, mark| acc * 3 + mark }
+    end
+
+    def decode(pattern, size)
+      Array.new(size) do
+        mark = pattern % 3
+        pattern /= 3
+        mark
+      end
+    end
+
+    def solved(size)
+      encode(Array.new(size, CORRECT))
+    end
+
+    # Parses user notation such as "xygxx", "01200" or "b.y-g".
+    # Returns nil when the text is not a valid pattern of the given size.
+    def parse(text, size)
+      chars = text.downcase.chars
+      return nil unless chars.size == size && chars.all? { |c| SYMBOLS.key?(c) }
+
+      encode(chars.map { |c| SYMBOLS[c] })
+    end
+
+    def notation(pattern, size)
+      decode(pattern, size).map { |mark| "xyg"[mark] }.join
+    end
+  end
+end

data/lib/ruby-wordle/game.rb

@@ -0,0 +1,84 @@
+require "ruby-wordle/feedback"
+
+module RubyWordle
+  # One round of Wordle with a hidden answer.
+  class Game
+    class InvalidGuess < StandardError; end
+
+    MAX_ATTEMPTS = 6
+
+    attr_reader :answer, :history, :max_attempts, :dictionary, :revealed
+
+    def initialize(dictionary, answer: nil, random: Random.new, max_attempts: MAX_ATTEMPTS)
+      @dictionary = dictionary
+      @answer = answer || dictionary.answers.sample(random: random)
+      raise ArgumentError, "#{@answer} is not in the word list" unless dictionary.valid_guess?(@answer)
+
+      @max_attempts = max_attempts
+      @history = []
+      @assisted = false
+      @revealed = nil
+    end
+
+    # Marks that the player used a hint.
+    def assist!
+      @assisted = true
+    end
+
+    def assisted?
+      @assisted
+    end
+
+    # Reveals the letter at the first position never guessed correctly, once
+    # per game, as [position, letter]. Returns nil when fewer than two
+    # positions have never been guessed correctly.
+    def reveal
+      return @revealed if @revealed
+
+      found = @history.flat_map do |_, pattern|
+        marks = Feedback.decode(pattern, length)
+        marks.each_index.select { |i| marks[i] == Feedback::CORRECT }
+      end
+      unknown = (0...length).to_a - found
+      return nil if unknown.size < 2
+
+      assist!
+      @revealed = [unknown.first, @answer[unknown.first]]
+    end
+
+    def length
+      @answer.length
+    end
+
+    def guess(word)
+      raise InvalidGuess, "the game is over" if over?
+      raise InvalidGuess, "type #{length} letters (a-z)" unless word.match?(/\A[a-z]{#{length}}\z/)
+      raise InvalidGuess, "\"#{word}\" is not in the word list" unless @dictionary.valid_guess?(word)
+
+      pattern = Feedback.score(word, @answer)
+      @history << [word, pattern]
+      pattern
+    end
+
+    def won?
+      @history.any? { |_, pattern| pattern == Feedback.solved(length) }
+    end
+
+    def over?
+      won? || @history.size >= @max_attempts
+    end
+
+    def attempts_left
+      @max_attempts - @history.size
+    end
+
+    # The best feedback seen for each guessed letter, for the keyboard.
+    def letter_states
+      @history.each_with_object({}) do |(word, pattern), states|
+        word.chars.zip(Feedback.decode(pattern, length)) do |char, mark|
+          states[char] = mark if states.fetch(char, -1) < mark
+        end
+      end
+    end
+  end
+end

data/lib/ruby-wordle/solver.rb

@@ -0,0 +1,92 @@
+require "ruby-wordle/feedback"
+
+module RubyWordle
+  # Narrows down the words consistent with a history of guesses and
+  # feedback, and ranks the next guess.
+  #
+  # A word stays a candidate only if scoring it as the answer reproduces
+  # every observed pattern, so repeated letters are handled exactly as the
+  # game scores them.
+  class Solver
+    Suggestion = Struct.new(:word, :expected, :possible)
+
+    SAMPLE_SIZE = 400
+    PROBE_SIZE = 300
+
+    attr_reader :dictionary, :history, :candidates
+
+    def initialize(dictionary, pool: dictionary.guesses)
+      @dictionary = dictionary
+      @pool = pool
+      reset
+    end
+
+    def reset
+      @history = []
+      @candidates = @pool
+      self
+    end
+
+    def add(guess, pattern)
+      guess = guess.dup.freeze
+      @history << [guess, pattern]
+      @candidates = @candidates.select { |word| Feedback.score(guess, word) == pattern }
+      self
+    end
+
+    def undo
+      previous = @history[0...-1]
+      reset
+      previous.each { |guess, pattern| add(guess, pattern) }
+      self
+    end
+
+    # Candidates that are common words; the answer is most likely among them.
+    def likely
+      common = @candidates.select { |w| @dictionary.common?(w) }
+      common.empty? ? @candidates : common
+    end
+
+    # Ranks guesses by the expected number of likely candidates left after
+    # playing them (lower is better), preferring words that can still be
+    # the answer on ties. Large sets are estimated from an even sample.
+    def suggest(limit = 10)
+      targets = likely
+      return [] if targets.empty?
+
+      sample = spread(targets, SAMPLE_SIZE)
+      scale = targets.size.to_f / (sample.size**2)
+      possible = @candidates.to_h { |w| [w, true] }
+
+      ranked = probes(targets).map do |probe|
+        buckets = Hash.new(0)
+        sample.each { |answer| buckets[Feedback.score(probe, answer)] += 1 }
+        expected = buckets.each_value.sum { |n| n * n } * scale
+        Suggestion.new(probe, expected, possible.key?(probe))
+      end
+
+      ranked.min_by(limit) { |s| [s.expected, s.possible ? 0 : 1, s.word] }
+    end
+
+    private
+
+    def spread(words, size)
+      return words if words.size <= size
+
+      Array.new(size) { |i| words[i * words.size / size] }
+    end
+
+    # The targets themselves plus guesses whose letters split the targets
+    # most evenly, which can narrow them down better than any target can.
+    def probes(targets)
+      frequency = Hash.new(0)
+      targets.each { |w| w.chars.uniq.each { |c| frequency[c] += 1 } }
+      split = frequency.transform_values { |n| n * (targets.size - n) }
+      coverage = ->(w) { -w.chars.uniq.sum { |c| split.fetch(c, 0) } }
+
+      own = targets.size <= PROBE_SIZE ? targets : targets.min_by(PROBE_SIZE, &coverage)
+      others = @dictionary.guesses.min_by(PROBE_SIZE / 2, &coverage)
+      own | others
+    end
+  end
+end

data/lib/ruby-wordle/style.rb

@@ -0,0 +1,56 @@
+require "ruby-wordle/feedback"
+
+module RubyWordle
+  # Terminal styling. With color disabled, marks are shown with brackets:
+  # [A] correct, (A) present elsewhere, and a plain lowercase letter absent.
+  class Style
+    CODES = { bold: 1, dim: 2, underline: 4, red: 31, green: 32, yellow: 33,
+              blue: 34, magenta: 35, cyan: 36, gray: 90 }.freeze
+    # Fixed 256-color tiles (green, yellow, gray with white letters) look the
+    # same in every terminal theme.
+    TILE_CODES = { Feedback::CORRECT => "1;38;5;231;48;5;71", Feedback::PRESENT => "1;38;5;231;48;5;178",
+                   Feedback::ABSENT => "1;38;5;231;48;5;240" }.freeze
+    EMOJI = { Feedback::CORRECT => "🟩", Feedback::PRESENT => "🟨", Feedback::ABSENT => "⬛" }.freeze
+
+    def self.for(output, env = ENV)
+      new(color: output.respond_to?(:tty?) && output.tty? && env["NO_COLOR"].to_s.empty?)
+    end
+
+    def initialize(color:)
+      @color = color
+    end
+
+    def color?
+      @color
+    end
+
+    def paint(text, *styles)
+      return text.to_s unless @color && !styles.empty?
+
+      "\e[#{styles.map { |s| CODES.fetch(s) }.join(';')}m#{text}\e[0m"
+    end
+
+    # A letter tile; +mark+ is a Feedback mark, or nil for an untested letter.
+    def tile(char, mark)
+      if @color
+        mark ? "\e[#{TILE_CODES.fetch(mark)}m #{char.upcase} \e[0m" : " #{char.upcase} "
+      else
+        case mark
+        when Feedback::CORRECT then "[#{char.upcase}]"
+        when Feedback::PRESENT then "(#{char.upcase})"
+        when Feedback::ABSENT then " #{char.downcase} "
+        else " #{char.upcase} "
+        end
+      end
+    end
+
+    def row(word, pattern)
+      marks = Feedback.decode(pattern, word.length)
+      word.chars.zip(marks).map { |char, mark| tile(char, mark) }.join(" ")
+    end
+
+    def emoji(pattern, length)
+      Feedback.decode(pattern, length).map { |mark| EMOJI[mark] }.join
+    end
+  end
+end

data/lib/ruby-wordle/version.rb

@@ -1,3 +1,3 @@
 module RubyWordle
-  VERSION = "0.9.2"
+  VERSION = "1.0.0"
 end

data/lib/ruby-wordle.rb

@@ -0,0 +1,7 @@
+require "ruby-wordle/version"
+require "ruby-wordle/feedback"
+require "ruby-wordle/dictionary"
+require "ruby-wordle/game"
+require "ruby-wordle/solver"
+require "ruby-wordle/style"
+require "ruby-wordle/cli"

data/word-lists/5-letters/word-list-basic-uniq-letters.txt

@@ -1,9 +1,3 @@
-april
-bible
-false
-islam
-march
-x-ray
 abhor
 abide
 abort
@@ -333,6 +327,7 @@ facet
 faint
 fairy
 faith
+false
 fancy
 farce
 fault
@@ -523,7 +518,6 @@ leafy
 learn
 least
 lemon
-let's
 light
 liken
 liner
@@ -1107,7 +1101,6 @@ wring
 wrist
 write
 wrong
-x-ray
 yacht
 yearn
 yeast

data/word-lists/5-letters/word-list-basic.txt

@@ -1,10 +1,3 @@
-april
-bible
-false
-islam
-march
-satan
-x-ray
 abate
 abbey
 abhor
@@ -501,6 +494,7 @@ facet
 faint
 fairy
 faith
+false
 fancy
 farce
 fatal
@@ -776,7 +770,6 @@ ledge
 leech
 legal
 lemon
-let's
 level
 lever
 libel
@@ -1592,7 +1585,6 @@ wring
 wrist
 write
 wrong
-x-ray
 yacht
 yearn
 yeast

data/word-lists/5-letters/word-list-uniq-letters.txt

@@ -4772,6 +4772,7 @@ kilty
 kimbo
 kinah
 kinch
+kinda
 kinds
 kines
 kings

data/word-lists/5-letters/word-list.txt

@@ -7526,6 +7526,7 @@ kimbo
 kimmo
 kinah
 kinch
+kinda
 kinds
 kines
 kings

metadata

@@ -1,31 +1,30 @@
 --- !ruby/object:Gem::Specification
 name: ruby-wordle
 version: !ruby/object:Gem::Version
-  version: 0.9.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Yoichiro Hasebe
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-02-01 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: readline
+  name: reline
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-description: A set of ruby scripts to generate word-lists, solve Wordle, and play
-  Wordle
+        version: '0.3'
+description: A command-line Wordle game and a solver that ranks the next guess, with
+  English word lists.
 email:
 - yohasebe@gmail.com
 executables:
@@ -33,31 +32,29 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- Gemfile
+- CHANGELOG.md
 - LICENSE
 - README.md
-- Rakefile
 - bin/ruby-wordle
-- img/ruby-wordle-play.png
-- img/ruby-wordle-solver.png
-- lib/ruby-wordle/script-filter.rb
-- lib/ruby-wordle/script-play.rb
-- lib/ruby-wordle/script-solver.rb
-- lib/ruby-wordle/script-utils.rb
+- lib/ruby-wordle.rb
+- lib/ruby-wordle/cli.rb
+- lib/ruby-wordle/dictionary.rb
+- lib/ruby-wordle/feedback.rb
+- lib/ruby-wordle/game.rb
+- lib/ruby-wordle/solver.rb
+- lib/ruby-wordle/style.rb
 - lib/ruby-wordle/version.rb
-- ruby-wordle.gemspec
 - word-lists/5-letters/word-list-basic-uniq-letters.txt
 - word-lists/5-letters/word-list-basic.txt
 - word-lists/5-letters/word-list-uniq-letters.txt
 - word-lists/5-letters/word-list.txt
-- word-lists/word-list-basic.txt
-- word-lists/word-list-original.txt
-homepage: http://github.com/yohasebe/ruby-wordle
+homepage: https://github.com/yohasebe/ruby-wordle
 licenses:
 - MIT
-metadata: {}
-post_install_message:
+metadata:
+  source_code_uri: https://github.com/yohasebe/ruby-wordle
+  changelog_uri: https://github.com/yohasebe/ruby-wordle/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -65,15 +62,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
-summary: A set of ruby scripts to generate word-lists, solve Wordle, and play Wordle
+summary: Play Wordle and solve Wordle on the command line
 test_files: []

data/.gitignore

@@ -1,58 +0,0 @@
-*.gem
-*.rbc
-/.config
-/coverage/
-/InstalledFiles
-/pkg/
-/spec/reports/
-/spec/examples.txt
-/test/tmp/
-/test/version_tmp/
-/tmp/
-
-# Used by dotenv library to load environment variables.
-# .env
-
-# Ignore Byebug command history file.
-.byebug_history
-
-## Specific to RubyMotion:
-.dat*
-.repl_history
-build/
-*.bridgesupport
-build-iPhoneOS/
-build-iPhoneSimulator/
-
-## Specific to RubyMotion (use of CocoaPods):
-#
-# We recommend against adding the Pods directory to your .gitignore. However
-# you should judge for yourself, the pros and cons are mentioned at:
-# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
-#
-# vendor/Pods/
-
-## Documentation cache and generated files:
-/.yardoc/
-/_yardoc/
-/doc/
-/rdoc/
-
-## Environment normalization:
-/.bundle/
-/vendor/bundle
-/lib/bundler/man/
-
-# for a library or gem, you might want to ignore these files since the code is
-# intended to run in multiple environments; otherwise, check them in:
-# Gemfile.lock
-# .ruby-version
-# .ruby-gemset
-
-# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
-.rvmrc
-
-# Used by RuboCop. Remote config files pulled in from inherit_from directive.
-# .rubocop-https?--*
-
-.DS_Store

data/Gemfile

@@ -1,3 +0,0 @@
-source "http://rubygems.org"
-
-gem 'readline'

data/Rakefile

@@ -1 +0,0 @@
-require "bundler/gem_tasks"