digits_solver 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b539861e0a6120403802c85ac9fb08960aa17c7064687064269a2b59b6213f3d
+  data.tar.gz: c0a746b1c33a7866ed10b39e51ae672806f723b01336b81f63b0563a3b45fd05
+SHA512:
+  metadata.gz: dd7f9d5a8c08a0ad227aa02f1adbdf12b331b69a9e068f8a1586d9e2867766b5bd6eed8c1d7bae93b57cabb310d6f637397aedf9471a5a2aecf1e07b88bea120
+  data.tar.gz: 0dcb86378227e3184e92b63af05fcd3b2cf210d18e0c3e1e4d92bbe973f333c68a47567ae2ba9bd023906fe673426353052e7a0f86d2c2752932e02875c646d3

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,13 @@
+AllCops:
+  TargetRubyVersion: 2.6
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Layout/LineLength:
+  Max: 120

data/Gemfile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in digits_solver.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "rspec", "~> 3.0"
+
+gem "rubocop", "~> 1.21"

data/README.md

@@ -0,0 +1,34 @@
+# DigitsSolver
+
+This is basically a coding exercice.
+
+The goal of this gem is to solve puzzles à-la [NY Times Digits game](https://www.nytimes.com/games/digits). You may 
+actually know this game under a different name. In France this looks like the calculation part of a 40 year old TV 
+show named 'Les chiffres et les lettres'...
+
+This gem implements a brute-force approach to solve the problem but is ready to host alternative strategies.
+
+
+## Installation
+
+    $ gem install digits_solver
+
+## Usage
+
+This gem provides an executable named `find_nydigits_solutions`.
+
+* First argument is the target number.
+* All subsequent arguments are the numbers to be used in calculations to reach the target.
+
+ex:
+
+```
+$ find_nydigits_solutions 437 3 5 7 13 20 25
+Trying to find 437
+A best solution has been found (total of 67 found).
+Solved in 4 operations:
+ => 5 * 7 = 35
+ => 35 - 13 = 22
+ => 22 * 20 = 440
+ => 440 - 3 = 437
+```

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/digits_solver.gemspec

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "lib/digits_solver/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "digits_solver"
+  spec.version = DigitsSolver::VERSION
+  spec.authors = ["Laurent B."]
+  spec.email = ["lbnetid+rb@gmail.com"]
+
+  spec.summary = "Solves NYTimes Digits puzzle."
+  spec.description = "Finds solutions to the NYTimes Digits game."
+  spec.homepage = "https://gitlab.com/coding_exercices/digits_solver"
+  spec.required_ruby_version = ">= 2.6.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(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'rspec'
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/exe/find_nydigits_solutions

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+# coding: utf-8
+
+require 'rubygems'
+require 'bundler/setup'
+require 'digits_solver'
+
+def help(out = STDOUT)
+  out.puts <<EOM
+To run this program:
+
+find_nydigits_solution <number to find> <space separated list of numbers>
+
+This program will solve if possible the NY Digits puzzle.
+EOM
+end
+
+begin
+  raise DigitsSolver::Error, 'Invalid parameters' unless ARGV.size >= 3 && ARGV.size <= 7
+
+  target = ARGV.shift.to_i
+  draw = ARGV.map do |val|
+    raise DigitsSolver::Error, 'Invalid parameters (candidate figures) ! ' unless val == val.to_i.to_s
+
+    val.to_i
+  end
+  puts "Trying to find #{target}"
+  solutions = DigitsSolver.solve_for target, *draw
+  raise DigitsSolver::Error, %q[Couldn't find any solution !] if solutions.sorted_solutions.empty?
+
+  puts "A best solution has been found (total of #{solutions.size} possible solutions found)."
+  puts solutions.best_solution
+rescue => e
+  STDERR.puts e.message
+  help STDERR
+end

data/lib/digits_solver/error.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+module DigitsSolver
+  class Error < StandardError ; end
+end

data/lib/digits_solver/problem_statement.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+module DigitsSolver
+  class ProblemStatement
+
+    attr_reader :target_number
+
+    def draw
+      @draw.dup
+    end
+
+    def initialize(target_number_or_problem_statement, *draw)
+      @target_number, @draw = if target_number_or_problem_statement.is_a? DigitsSolver::ProblemStatement
+                            [target_number_or_problem_statement.target_number, target_number_or_problem_statement.draw]
+                          else
+                            [target_number_or_problem_statement, draw]
+                              end
+      DigitsSolver.logger.info "The target is #{target_number}"
+      DigitsSolver.logger.info "The draw is #{draw.inspect}"
+    end
+
+    def max_operations_number
+      @max_operations_number ||= @draw.size - 1
+    end
+
+  end
+end

data/lib/digits_solver/solution.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+module DigitsSolver
+
+  class Solution
+
+    include DigitsSolver::Strategies::Base
+
+    attr_reader :problem_statement, :operands, :operations_to_apply
+
+    def initialize(problem_statement, operands, operations_to_apply)
+      raise DigitsSolver::Error, "Invalid problem statement" unless problem_statement.is_a? DigitsSolver::ProblemStatement
+      unless operands.size == operations_to_apply.size + 1
+        raise DigitsSolver::Error, "Invalid solution #{operands.inspect} => #{operations_to_apply.inspect}"
+      end
+
+      DigitsSolver.logger.info "New solution: #{self.inspect}"
+
+      @problem_statement = problem_statement
+      @operands = operands
+      @operations_to_apply = operations_to_apply
+    end
+
+    def ==(other_solution)
+      (operations_to_apply == other_solution.operations_to_apply) && (operands == other_solution.operands)
+    end
+
+    def to_s
+      res = ["Solved in #{operations_to_apply.size} operation#{operations_to_apply.size <= 1 ? '' : 's'}:"]
+      res.concat to_operation_lines
+      res.join "\n"
+    end
+
+    def to_operation_lines
+      res = []
+      operations_to_apply.each.with_index.reduce(operands.first) do |acc, (operation, idx)|
+        computed_result = apply_operation_to_operands operation, acc, operands[idx + 1]
+        res << format(' => %u %s %u = %u',
+                      acc,
+                      DigitsSolver::Strategies::Base::OPERATIONS[operation],
+                      operands[idx + 1],
+                      computed_result)
+        computed_result
+      end
+      res
+    end
+
+    def pretty_print(pp)
+      pp.object_address_group(self) do
+        pp.breakable
+        pp.text "Solution: '#{to_evaluable_code} = #{problem_statement.target_number}'"
+        pp.text ','
+        pp.breakable
+        pp.seplist(self.instance_variables) do |v|
+          pp.text "#{v}="
+          pp.pp self.instance_variable_get v
+        end
+      end
+    end
+
+    def to_evaluable_code
+      res = operations_to_apply.each.with_index.reduce(operands.first) do |res, (operation, idx)|
+        op1 = res
+        op2 = operands[idx + 1]
+        format_string = operation == :multiply ? '%s %s %u' : '(%s %s %u)'
+        format(format_string, op1, DigitsSolver::Strategies::Base::OPERATIONS[operation], op2)
+      end
+      res[-1] == ')' ? res[1...-1] : res
+    end
+
+  end
+
+end

data/lib/digits_solver/solution_set.rb

@@ -0,0 +1,76 @@
+module DigitsSolver
+
+  class SolutionSet
+
+    include Enumerable
+
+    DEFAULT_STRATEGY = DigitsSolver::Strategies::BruteForce
+    attr_reader :problem_statement, :strategy
+
+    class << self
+
+      def solve_for(problem_statement, strategy: DEFAULT_STRATEGY)
+        extend strategy
+        solutions = solve(problem_statement)
+        new problem_statement, solutions, strategy
+      end
+
+    end
+
+    def each(&block)
+      solutions.each(&block)
+    end
+
+    def sorted_solutions
+      indexed_solutions.keys
+                       .sort { |a, b| a.size <=> b.size }
+                       .map { |k| indexed_solutions[k] }
+                       .flatten
+    end
+
+    def best_solution(nb = 1)
+      res = indexed_solutions.keys
+                             .sort { |a, b| a.size <=> b.size }
+                             .take(nb)
+                             .map { |k| indexed_solutions[k] }
+                             .flatten
+                             .take(nb)
+      nb == 1 ? res.first : res
+    end
+    alias best_solutions best_solution
+
+    def size
+      solutions.size
+    end
+
+    private
+
+    attr_reader :solutions, :indexed_solutions
+
+    def <<(solution)
+      return nil if solutions.include? solution
+
+      solutions << solution
+      indexed_solutions[solution.operands] ||= []
+      indexed_solutions[solution.operands] << solution
+      solutions
+    end
+
+    def initialize(problem_statement, solutions, strategy)
+      raise DigitsSolver::Error, "Invalid problem statement" unless problem_statement.is_a? DigitsSolver::ProblemStatement
+
+      @problem_statement = problem_statement
+      @strategy = strategy
+
+      @indexed_solutions = {}
+      @solutions = []
+
+      solutions.each do |solution|
+        self << solution
+      end
+
+    end
+
+  end
+
+end

data/lib/digits_solver/strategies/base.rb

@@ -0,0 +1,77 @@
+module DigitsSolver
+  module Strategies
+
+    module Base
+
+      class OperationError < StandardError; end
+
+      OPERATIONS = {
+        plus: :+,
+        minus: :-,
+        multiply: :*,
+        divide: :/
+      }.freeze
+
+      def solve(_)
+        raise DigitsSolver::Error 'You should not be there !'
+      end
+
+      protected
+
+      def possible_operations_for_ordered_draw(max_operations_number)
+        nb_operations = OPERATIONS.size
+        ops_a = OPERATIONS.to_a
+        number_of_possibilities = nb_operations ** max_operations_number
+
+        DigitsSolver.logger.info "number of operations permutations: #{number_of_possibilities}, nb op: #{nb_operations}"
+
+        (0...number_of_possibilities).map do |i|
+          i.to_s(nb_operations)
+           .ljust(max_operations_number, '0')
+           .chars
+           .map { |operation_index_str| ops_a[operation_index_str.to_i].first }
+        end
+      end
+
+      def apply_operations_chain_to_ordered_draw(operations_chain, ordered_draw, problem_statement)
+        operations_chain.each.with_index.reduce(ordered_draw.first) do |acc, (operation, idx)|
+          cur_op_res = apply_operation_to_operands(operation, acc, ordered_draw[idx + 1])
+          if cur_op_res == problem_statement.target_number
+            ops = operations_chain.take(idx + 1)
+            operands = ordered_draw.take(idx + 2)
+            yield DigitsSolver::Solution.new(problem_statement, operands, ops)
+            break
+          end
+          cur_op_res
+        end
+      end
+
+      def apply_operation_to_operands (operation, operand1, operand2)
+        res = send(operation, operand1, operand2)
+        DigitsSolver.logger.debug "#{operand1} #{OPERATIONS[operation]} #{operand2} = #{res}"
+        res
+      end
+
+      def plus(a, b)
+        a + b
+      end
+
+      def minus(a, b)
+        raise DigitsSolver::Strategies::Base::OperationError, "#{a} - #{b} is not allowed as result would be negative" unless a >= b
+
+        a - b
+      end
+
+      def multiply(a, b)
+        a * b
+      end
+
+      def divide(a, b)
+        raise DigitsSolver::Strategies::Base::OperationError, "#{a} / #{b} is not allowed as result would not be an integer" unless a % b == 0
+
+        a / b
+      end
+
+    end
+  end
+end

data/lib/digits_solver/strategies/brute_force.rb

@@ -0,0 +1,36 @@
+module DigitsSolver
+  module Strategies
+
+    module BruteForce
+
+      include DigitsSolver::Strategies::Base
+
+      def solve(problem_statement)
+        solutions = []
+        draw = problem_statement.draw
+        possible_operations = possible_operations_for_ordered_draw problem_statement.max_operations_number
+        # DigitsSolver.logger.debug possible_operations.inspect
+
+        draw.permutation.map do |ordered_draw|
+
+          DigitsSolver.logger.debug ordered_draw.inspect
+          possible_operations.each do |operations_chain|
+            DigitsSolver.logger.debug operations_chain.inspect
+            begin
+              apply_operations_chain_to_ordered_draw(operations_chain, ordered_draw, problem_statement) do |valid_solution|
+                solutions << valid_solution
+              end
+            rescue DigitsSolver::Strategies::Base::OperationError => dsboe
+              DigitsSolver.logger.debug "#{ordered_draw.inspect} => #{operations_chain.inspect} is discarded because #{dsboe.message}"
+            end
+          end
+
+        end
+        DigitsSolver.logger.info "Solutions: #{solutions.inspect}"
+        solutions
+      end
+
+    end
+
+  end
+end

data/lib/digits_solver/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module DigitsSolver
+  VERSION = '0.1.1'.freeze
+end

data/lib/digits_solver.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "digits_solver/version"
+require_relative "digits_solver/error"
+require_relative "digits_solver/problem_statement"
+require_relative "digits_solver/strategies/base"
+require_relative "digits_solver/strategies/brute_force"
+require_relative "digits_solver/solution"
+require_relative 'digits_solver/solution_set'
+
+module DigitsSolver
+  class Error < StandardError; end
+
+  class DummyLogger
+    private
+
+    def respond_to_missing?(method_name, *_)
+      return true if %i[debug info warn error fatal].include? method_name
+
+      super
+    end
+
+    def method_missing(method_name, *args)
+      return if %i[debug info warn error fatal].include? method_name
+
+      super
+    end
+  end
+
+  # Your code goes here...
+
+  def self.solve_for(target_number, *draw)
+    problem_statement = DigitsSolver::ProblemStatement.new target_number, *draw
+    DigitsSolver::SolutionSet.solve_for problem_statement
+  end
+
+  def self.logger
+    @logger ||= DigitsSolver::DummyLogger.new
+  end
+
+  def self.logger=(logger)
+    @logger = logger
+  end
+end

data/sig/digits_solver.rbs

@@ -0,0 +1,4 @@
+module DigitsSolver
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: digits_solver
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Laurent B.
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2023-05-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Finds solutions to the NYTimes Digits game.
+email:
+- lbnetid+rb@gmail.com
+executables:
+- find_nydigits_solutions
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- Gemfile
+- README.md
+- Rakefile
+- digits_solver.gemspec
+- exe/find_nydigits_solutions
+- lib/digits_solver.rb
+- lib/digits_solver/error.rb
+- lib/digits_solver/problem_statement.rb
+- lib/digits_solver/solution.rb
+- lib/digits_solver/solution_set.rb
+- lib/digits_solver/strategies/base.rb
+- lib/digits_solver/strategies/brute_force.rb
+- lib/digits_solver/version.rb
+- sig/digits_solver.rbs
+homepage: https://gitlab.com/coding_exercices/digits_solver
+licenses: []
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://gitlab.com/coding_exercices/digits_solver
+  source_code_uri: https://gitlab.com/coding_exercices/digits_solver
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.26
+signing_key: 
+specification_version: 4
+summary: Solves NYTimes Digits puzzle.
+test_files: []