word_search 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d6966dcbd25d6689f540841bbc311906cd8fb7c9
-  data.tar.gz: b4764a2f5ab6996c09ec7fc9a8a37c3d3c5b22a5
+  metadata.gz: 7bc57d355737b67f6e08e5b58dabe5a891328f3b
+  data.tar.gz: 9314298eb080b5b5a5496e9cde14168b76bd4d81
 SHA512:
-  metadata.gz: db068f3c4cd0f2c12f9612e32bdbca5d81ab479ea7e89d4dc88e9d458ba2bfdf96f08bd9bc25a623f9e37604a58641d65b3144f8c021415590ba73fa9dfe47f1
-  data.tar.gz: 94de5566fe37d9ac130b85f5edbc16e3ceeaeb168e4b0e92f201b7d4db4368d282ae9b4de613b026f4740c6117cf858108a50c25e9446f416497d361e941cc88
+  metadata.gz: b12c07d549111243d9692fdc87dc2adefaf036b26619e112d49cdc98e580bfc99ec153e3dafb3dadc05f8d71184481769eb733d12896532e80b7d76581294759
+  data.tar.gz: afea61baebcb38d02ac8dc0e4c5e4ee23f41d450c00d9e02cb33b515a836ca3835f4a887ebaa24625f14cc7957ae87c1772cd1e2bb77e616f8134806a849c5a1

data/.gitignore

@@ -13,3 +13,4 @@
 /docs/.sass-cache
 /docs/build
 solution_*
+/solution/

data/README.md

@@ -69,7 +69,9 @@ To solve or benchmark your solution script:
 => #<Benchmark::Tms:0x007fd722cc6b58 @cstime=0.07, @cutime=0.44, @label="", @real=0.5259899999946356, @stime=0.0, @total=0.51, @utime=0.0>
 ```
 _NOTE_: Your script should be an executable ruby script that writes the location
-of each letter to a file in the following format and returns the file path:
+of each letter to a file in the following format and returns the file path. Your
+script should also accept command line arguments the first being the plane file
+the second being the word list file.
 ```
 h [4, 9]
 e [5, 9]

data/docs/source/index.html.haml

@@ -94,7 +94,10 @@ title: Word Search Gem
     You can benchmark and check if your solution works by using the Solver class.
     Your script should be an executable ruby script that writes the location
     of each letter to a file in the following format and returns the file path.
+    It should also be able to accept command line arguments for the plane file
+    and the words file, in that order.
     %pre
+
       :preserve
         h [4, 9]
         e [5, 9]

data/lib/word_search/generator/base.rb

@@ -24,19 +24,6 @@ module WordSearch
         end
       end
 
-      def write_solution
-        file_name = "solution_#{plane.digest}"
-        File.open(file_name, "w") do |f|
-          solution = positions.map do |_word, letter_positions|
-            letter_positions.map do |letter, position|
-              "#{letter.split('-')[0]} #{position.values}"
-            end.join("\n")
-          end.join("\n---\n")
-
-          f.write solution
-        end
-      end
-
       private
 
       def place_word(word)

data/lib/word_search/generator.rb

@@ -24,7 +24,6 @@ module WordSearch
 
       if valid?
         plane.add_letters
-        write_solution
         plane
       else
         false

data/lib/word_search/plane/base.rb

@@ -38,10 +38,6 @@ module WordSearch
         puts to_s
       end
 
-      def digest
-        Digest::MD5.hexdigest(to_s)
-      end
-
       def to_s
         raise NotImplementedError
       end
@@ -58,6 +54,10 @@ module WordSearch
         raise NotImplementedError
       end
 
+      def letter_at(*positions)
+        dig(*positions)
+      end
+
       private
 
       def initialize_plane

data/lib/word_search/plane.rb

@@ -1,14 +1,17 @@
 # frozen_string_literal: true
 module WordSearch
   class Plane < SimpleDelegator
-    def self.make_from_file(file)
-      obj =
+    def self.make_from_file(file, should_catalog: true)
+      dimension =
         if File.read(file).split("\n\n").count > 1
-          ThreeDimensional::Plane.make_from_file(file)
+          ThreeDimensional
         else
-          TwoDimensional::Plane.make_from_file(file)
+          TwoDimensional
         end
 
+      obj =
+        dimension::Plane.make_from_file(file, should_catalog: should_catalog)
+
       new(obj)
     end
 

data/lib/word_search/solver.rb

@@ -1,33 +1,31 @@
 # frozen_string_literal: true
 module WordSearch
   class Solver
-    attr_accessor :script, :word_bank, :plane, :failed
+    attr_accessor :script, :word_bank, :plane, :failed, :benchmark,
+                  :word_list_file, :plane_file
 
     def initialize(script, word_list_file, plane_file)
-      @script = script
-      @word_bank = WordBank.new(word_list_file)
-      @plane = Plane.make_from_file(plane_file)
-      @failed = false
+      @script         = script
+      @word_list_file = word_list_file
+      @word_bank      = WordBank.new(word_list_file)
+      @plane_file     = plane_file
+      @plane          = Plane.make_from_file(plane_file, should_catalog: false)
+      @failed         = false
     end
 
     def perform
-      master_solutions # load master solutions so it doesn't effect benchmark
+      return if script.blank?
       bm = benchmark_solution
 
-      return bm if !failed && solved?
+      return(@benchmark = bm) if !failed && solved?
 
       "Word Search incorrectly solved"
     end
 
-    def master_solutions
-      @master_solutions ||=
-        import_solutions(
-          if File.exist?("solution_#{plane.digest}")
-            File.read("solution_#{plane.digest}")
-          else
-            generate_master_solution
-          end
-        )
+    def solved?
+      @word_bank.all? do |word|
+        correctly_found?(word, users_solution[word])
+      end && proper_direction?
     end
 
     private
@@ -43,12 +41,36 @@ module WordSearch
     end
 
     def users_solution
-      @users_solution ||=
-        import_solutions(File.read(JSON.parse(`ruby #{script}`)))
+      @users_solution ||= import_solutions(File.read(JSON.parse(
+        `ruby #{script} #{plane_file} #{word_list_file}`
+      )))
     end
 
-    def solved?
-      @word_bank.all? { |word| users_solution[word] == master_solutions[word] }
+    def correctly_found?(word, positions)
+      word.split("").map.with_index do |letter, index|
+        plane.letter_at(*positions[index]).letter == letter
+      end.inject(:&)
+    end
+
+    def proper_direction?
+      users_solution.all? do |word, positions|
+        values = positions.values
+        direction = reduce_direction(values.pop.zip(*values), word)
+        plane.directions.values.include?(direction)
+      end
+    end
+
+    def reduce_direction(values, word)
+      values.map do |direction|
+        gcd = direction.reduce(:gcd)
+        direction.map { |coord| coord / gcd }.uniq
+      end.map do |direction|
+        if (direction = direction.inject(:-)).gcd(word.length) == word.length
+          direction / word.length
+        else
+          direction
+        end
+      end
     end
 
     def import_solutions(solution_array)
@@ -61,67 +83,5 @@ module WordSearch
         }
       end.reduce({}, :merge)
     end
-
-    def generate_master_solution
-      word_bank.map do |word|
-        find_word(word)
-      end.join("---")
-    end
-
-    def directions
-      @directions ||=
-        if plane.two_dimensional?
-          WordSearch::TwoDimensional::Direction
-        else
-          WordSearch::ThreeDimensional::Direction
-        end.values
-    end
-
-    def find_word(word)
-      string = ""
-      plane.catalog[word[0]].find do |point|
-        directions.find do |direction|
-          next if (spot = find_point(point, word.size - 1, direction)).blank? ||
-                  not_found?(spot, word, point, direction)
-
-          string = letter_positions(word, direction, point)
-        end
-      end
-
-      string
-    end
-
-    def letter_positions(word, direction, point)
-      solution = ""
-      word.split("").each_with_index do |letter, index|
-        solution += "#{letter} #{point.coordinate}\n"
-        next if index == (word.length - 1)
-
-        point = plane.find_next_point(point, direction)
-      end
-
-      solution
-    end
-
-    def not_found?(spot, word, point, direction)
-      !(spot.letter == word[-1] && double_check(word, point, direction))
-    end
-
-    def find_point(point, move, direction)
-      plane.dig(
-        point.x + (move * direction[0]),
-        point.y + (move * direction[1]),
-      )
-    end
-
-    def double_check(word, point, direction)
-      matching = true
-
-      (word.length - 2).times do |i|
-        matching &&= find_point(point, (1 + i), direction).letter == word[1 + i]
-      end
-
-      matching
-    end
   end
 end

data/lib/word_search/three_dimensional/plane.rb

@@ -61,12 +61,12 @@ module WordSearch
       end
 
       class << self
-        def make_from_file(file)
+        def make_from_file(file, should_catalog: true)
           string = File.read(file).split("\n\n").map(&:split)
 
           return false unless valid_file?(string)
 
-          make_word_search(string)
+          make_word_search(string, should_catalog: should_catalog)
         end
 
         private
@@ -76,14 +76,14 @@ module WordSearch
             string.flat_map { |row| row.map(&:length) }.uniq.count == 1
         end
 
-        def make_word_search(string)
+        def make_word_search(string, should_catalog: true)
           plane = empty_3d_plane_from_string(string)
 
           string.each_with_index do |slice, z|
             slice.reverse.each_with_index do |row, y|
               row.split("").each_with_index do |letter, x|
                 plane[x][y][z] = Point.new(x, y, z, letter)
-                add_to_catalog(plane, plane[x][y][z])
+                add_to_catalog(plane, plane[x][y][z], should_catalog)
               end
             end
           end
@@ -97,7 +97,9 @@ module WordSearch
           new(x, y, string.count)
         end
 
-        def add_to_catalog(plane, point)
+        def add_to_catalog(plane, point, should_catalog = true)
+          return unless should_catalog
+
           plane.catalog[point.letter] ||= []
           plane.catalog[point.letter] << point
         end

data/lib/word_search/two_dimensional/plane.rb

@@ -40,30 +40,34 @@ module WordSearch
       end
 
       class << self
-        def make_from_file(file)
+        def make_from_file(file, should_catalog: true)
           string = File.read(file).split("\n").reverse
 
           return false if (x_len = string.collect(&:length).uniq).count > 1 ||
                           x_len.blank?
 
-          make_word_search(x_len, string)
+          make_word_search(x_len, string, should_catalog: should_catalog)
         end
 
         private
 
-        def make_word_search(x_len, string)
+        def make_word_search(x_len, string, should_catalog: true)
           plane = new(x_len.first, string.count)
 
           string.each_with_index do |row, y|
             row.split("").each_with_index do |letter, x|
-              add_to_catalog(plane, plane[x][y] = Point.new(x, y, letter))
+              add_to_catalog(
+                plane, plane[x][y] = Point.new(x, y, letter), should_catalog
+              )
             end
           end
 
           plane
         end
 
-        def add_to_catalog(plane, point)
+        def add_to_catalog(plane, point, should_catalog = true)
+          return unless should_catalog
+
           plane.catalog[point.letter] ||= []
           plane.catalog[point.letter] << point
         end

data/lib/word_search/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module WordSearch
-  VERSION = "1.0.1"
+  VERSION = "1.1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: word_search
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
 platform: ruby
 authors:
 - npezza93
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-09 00:00:00.000000000 Z
+date: 2017-01-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport