codewords_solver 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 752df23fecf9cad700d45c1123280c1cb5abefaa6b6451d7b115c2e8b9923f83
+  data.tar.gz: 88e769f70915d86deb0f999b03a7207891858e88dbb27b2844109ed40e16d41a
+SHA512:
+  metadata.gz: fb6626bd1b4a6b9f59fbdc536c66babe61b2f97bc58d4e3927b1ef8cb1ab7284e0ddae85f4d3239e8c59a57066ecfc60d9d5656952d1535a9f1c33471c310f78
+  data.tar.gz: a59f255b6b4306082db65a6c50bca75d5969aee5fadf0b9c01f9f0fa1ab983f60ed5ae56174c8e175461bf29e33a0659ad7e9c4599e6294a7c7af19d5d6c74b6

data/.gitignore

@@ -0,0 +1 @@
+pkg

data/Gemfile

@@ -0,0 +1,8 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in quince.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "rspec", "~> 3.0"

data/Gemfile.lock

@@ -0,0 +1,58 @@
+PATH
+  remote: .
+  specs:
+    codewords_solver (0.0.1)
+      activesupport (~> 7.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (7.1.3)
+      base64
+      bigdecimal
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      connection_pool (>= 2.2.5)
+      drb
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      mutex_m
+      tzinfo (~> 2.0)
+    base64 (0.2.0)
+    bigdecimal (3.1.5)
+    concurrent-ruby (1.2.3)
+    connection_pool (2.4.1)
+    diff-lcs (1.5.0)
+    drb (2.2.0)
+      ruby2_keywords
+    i18n (1.14.1)
+      concurrent-ruby (~> 1.0)
+    minitest (5.21.1)
+    mutex_m (0.2.0)
+    rake (13.1.0)
+    rspec (3.12.0)
+      rspec-core (~> 3.12.0)
+      rspec-expectations (~> 3.12.0)
+      rspec-mocks (~> 3.12.0)
+    rspec-core (3.12.2)
+      rspec-support (~> 3.12.0)
+    rspec-expectations (3.12.3)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-mocks (3.12.6)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-support (3.12.1)
+    ruby2_keywords (0.0.5)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+
+PLATFORMS
+  arm64-darwin-22
+
+DEPENDENCIES
+  codewords_solver!
+  rake (~> 13.0)
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   2.4.10

data/README.md

@@ -0,0 +1,58 @@
+# Codewords solver
+
+A simple ruby-based allgorithm for solving codewords (AKA [Cypher crosswords](https://en.wikipedia.org/wiki/Crossword#Cipher_crosswords)) - popular in many newspapers.
+
+## Usage
+
+```ruby
+require "codewords_solver"
+
+CodewordsSolver.solve! coded_words: grid, starting_letters: { 5 => "F", 7 => "L" }
+```
+or
+```ruby
+require "codewords_solver"
+
+solver = CodewordsSolver.new grid, { 5 => "F", 7 => "L" }
+solver.solve!
+```
+where
+```ruby
+grid = [
+  [1, 13, 7, 11],
+  [22, 5, 5, 13, 10, 17, 4, 15],
+  [4, 13, 18, 3, 23],
+  [16, 13, 7, 7, 13, 22, 26],
+  [15, 10, 4, 12, 24, 25, 7, 17],
+  [25, 13, 4, 22],
+  [12, 24, 22, 9, 26, 23],
+  [5, 13, 12, 26, 10, 17],
+  [17, 26, 21, 14],
+  [24, 12, 4, 23, 13, 12, 26, 15],
+  [19, 4, 22, 8, 17, 10, 23],
+  [4, 12, 13, 15, 17],
+  [11, 13, 15, 10, 22, 9, 26, 23],
+  [2, 9, 13, 19],
+  [1, 22, 4, 20, 15, 19, 12, 10, 17],
+  [19, 22, 11],
+  [7, 12, 18, 17, 4],
+  [22, 25, 21, 13, 22, 9, 15],
+  [15, 23, 12, 24, 13, 26, 12],
+  [7, 17, 18, 22],
+  [5, 13, 16, 16, 7, 17],
+  [23, 12, 4, 23, 12, 26],
+  [13, 11, 7, 17],
+  [24, 13, 6, 23, 9, 4, 17],
+  [17, 11, 13, 23, 13, 22, 26],
+  [12, 11, 13, 17, 9],
+  [15, 22, 26],
+  [22, 21, 17, 4, 15, 7, 17, 17, 19],
+]
+```
+**Note that while a codewords puzzle is typically formed into a grid with intersecting words, you do not need to mark such intersections here. A simple array of each of the numbered words will suffice!**
+
+### Please note
+
+A good codewords solver requires a good word list, and this one is far from perfect. If it isn't
+solving a puzzle or it's making a mistake, it's quite likely that it's because there are words
+missing from the list!

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/codewords_solver.gemspec

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "lib/codewords_solver/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "codewords_solver"
+  spec.version = CodewordsSolver::VERSION
+  spec.authors = ["Joseph Johansen"]
+  spec.email = ["joe@stotles.com"]
+
+  spec.summary = "A simple algorithm for solving codeword puzzles"
+  spec.description = "A simple algorithm for solving codeword puzzles"
+  spec.homepage = "https://github.com/johansenja/codewords_solver"
+  spec.license = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.7.0")
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  spec.add_dependency "activesupport", "~> 7.1"
+
+  # For more information and examples about making a new gem, checkout our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/lib/codewords_solver/dictionary.rb

@@ -0,0 +1,36 @@
+require "active_support/inflector"
+
+class CodewordsSolver
+  class Dictionary
+    include ActiveSupport::Inflector
+
+    def initialize
+      @words = import_words_by_filepath("./word_list.txt")
+    end
+
+    def find_by_regexp(regexp)
+      all = @words.filter { |w| w.length > 2 and w.match? regexp }
+    end
+
+    private
+
+    def import_words_by_filepath(filepath)
+      # puts "Loading words in from #{filepath}"
+      file = File.read(filepath)
+      file.chomp!
+
+      words = file.split("\n")
+
+      words.map! do |w|
+        w.upcase!
+        w = transliterate(w, "")
+        w.gsub!(/[^A-Z]/, "")
+        w
+      end
+
+      # puts "Loaded #{words.length} words"
+
+      words
+    end
+  end
+end

data/lib/codewords_solver/version.rb

@@ -0,0 +1,3 @@
+class CodewordsSolver
+  VERSION = "0.0.1".freeze
+end

data/lib/codewords_solver.rb

@@ -0,0 +1,150 @@
+require "codewords_solver/dictionary"
+
+class CodewordsSolver
+  def self.solve!(coded_words:, starting_letters:)
+    new(coded_words, starting_letters).solve!
+  end
+
+  MAX_LOOP_ATTEMPTS = 5
+
+  def initialize(coded_words, starting_letters)
+    @coded_words = coded_words
+    @starting_letters = starting_letters
+    @letters_by_number = (1..26).to_h { |n| [n, nil] }.merge(
+      starting_letters.transform_values(&:upcase)
+    )
+    @dictionary = Dictionary.new
+  end
+
+  def solve!
+    num_attempts = 0
+
+    until complete? || num_attempts == MAX_LOOP_ATTEMPTS
+      # puts "Doing a loop (attempts so far: #{num_attempts})"
+      do_loop
+      num_attempts += 1
+    end
+
+    if complete?
+      puts "PUZZLE IS COMPLETE:"
+
+      puts
+
+      print_words
+
+      puts
+      return
+    end
+
+    print_answer
+
+    raise "Could not complete puzzle in #{num_attempts} (max attempts: #{MAX_LOOP_ATTEMPTS})"
+  end
+
+  private
+
+  def do_loop
+    @coded_words.each_with_index do |coded_word|
+      next if coded_word.all? { |num| number_assigned? num }
+
+      regexp = to_regexp(coded_word)
+      possibilities = @dictionary.find_by_regexp(regexp)
+      # this is a bit of a leak/hack; at this point, we're going a bit beyond regex's capabilities
+      possibilities = filter_invalid_possibilities(possibilities, coded_word)
+
+      # puts(
+      #   "Found #{possibilities.length > 10 ? possibilities.length : possibilities.join(", ")} for #{coded_word} (regexp: /#{regexp}/)"
+      # )
+
+      assign_word(coded_word, possibilities[0]) if possibilities.length == 1
+
+      if possibilities.length <= 10 && !possibilities.empty?
+        # if the same letter appears in the same position for all of the possibilities, then it's
+        # safe to assign it
+        possibilities[0].chars.each_with_index do |char, index|
+          if possibilities.all? { |word| word[index] == char } && !number_assigned?(coded_word[index])
+            assign_letter(coded_word[index], char)
+          end
+        end
+      end
+
+      break if complete?
+    end
+  end
+
+  def assign_word(coded_word, word)
+    coded_word.each_with_index do |num, index|
+      next if number_assigned?(num)
+
+      assign_letter num, word[index]
+    end
+  end
+
+  def number_assigned?(number)
+    !@letters_by_number[number].nil?
+  end
+
+  def assign_letter(number, letter)
+    raise if number.nil?
+
+    existing_num = @letters_by_number.invert[letter]
+
+    if existing_num && existing_num != number
+      raise "#{letter} cannot be assigned to #{number} - it's already assigned to #{existing_num}"
+    end
+
+    puts "Assigning #{letter} to #{number}"
+
+    @letters_by_number[number] ||= letter
+  end
+
+  def complete?
+    @letters_by_number.each_value.all? { |letter| !letter.nil? }
+  end
+
+  def filter_invalid_possibilities(possibilities, coded_word)
+    possibilities.filter { |poss| poss.chars.uniq.length == coded_word.uniq.length }
+  end
+
+  def print_answer
+    @letters_by_number.each do |num, letter|
+      puts "#{num.to_s.rjust(2, "0")} ==> #{letter}"
+    end
+  end
+
+  def print_words
+    words = @coded_words.map do |code_word|
+      code_word.each_with_object("") do |number, word|
+        word << @letters_by_number[number]
+      end
+    end
+
+    max_word_length = words.max_by(&:length).length
+
+    words.each_with_index do |word, i|
+      puts "#{word.rjust(max_word_length, " ")} ===> #{@coded_words[i]}"
+    end
+  end
+
+  def to_regexp(coded_word)
+    backreferences_for_unknown_numbers = []
+
+    unassigned_letters = ("A".."Z").to_a.join("").tr @letters_by_number.values.join(""), ""
+
+    regexp_chars = coded_word.map do |number|
+      letter = @letters_by_number[number]
+      next letter if letter
+
+      backreference_num = backreferences_for_unknown_numbers.index(number)
+
+      if backreference_num.nil?
+        backreferences_for_unknown_numbers << number
+        "(#{unassigned_letters.split("").join("|")})"
+      else
+        "\\#{backreference_num + 1}"
+      end
+    end
+
+    /\A#{regexp_chars.join("")}\z/
+  end
+end