fifteen_puzzle 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in fifteen_puzzle.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Idris
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,74 @@
+# FifteenPuzzle
+
+Fifteen puzzle solver by A* algorithm.
+
+NOTE: In puzzle with more than 20 turns program may work > 1 min.
+
+Tested in Ruby 1.9.3-p125
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'fifteen_puzzle'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install fifteen_puzzle
+
+## Usage
+
+1. Create the game matrix: 
+
+        @game_matrix = FifteenPuzzle::GameMatrix.new( Matrix[[ 1, 4, 14, 13],
+					                  [ 11, 9, 8, 12],
+					                  [ 3, 6, FifteenPuzzle::GameMatrix::FREE_CELL, 7],
+					                  [15, 5, 2, 10]] )
+					                  
+2. Create AStar alogrithm runner:
+
+        @algorithm = FifteenPuzzle::AStarAlgorithm.new( @game_matrix )
+        
+3. Run AStar:
+
+        @algorithm.run
+        #NOTE: In puzzle with more than 20 turns to solve program may work > 1 min.
+        
+4. To access the solution:
+
+        @solution = algorithm.solution	       
+It returns the goal state of game matrix
+To Get previous states enter:
+
+        par1 = @solution.parent     
+        next_parent = par1.parent        
+5. To get the Matrix of board:
+
+        @solution.matrix
+        @solution.parent.matrix
+
+
+## Testing
+
+RSpec needs for testing.
+The specs can run more than 1 minute.
+
+There are several example of matrixes. 
+You can change the run matrixes in spec/game_matrix_spec.rb
+
+To run tests enter in command line:
+
+    rspec
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/fifteen_puzzle.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/fifteen_puzzle/version', __FILE__)
+
+Gem::Specification.new do |gem|
+
+  gem.add_development_dependency "rspec"
+
+  gem.authors       = ["MO-524a"]
+  gem.email         = ["mo124a@ya.ru"]
+  gem.description   = %q{15puzzle solver with A* algorithm}
+  gem.summary       = %q{15puzzle solver with A* algorithm}
+  gem.homepage      = "https://github.com/sld/astar-15puzzle-solver"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "fifteen_puzzle"
+  gem.require_paths = ["lib"]
+  gem.version       = FifteenPuzzle::VERSION
+end

data/lib/fifteen_puzzle/version.rb

@@ -0,0 +1,3 @@
+module FifteenPuzzle
+  VERSION = "0.0.1"
+end

data/lib/fifteen_puzzle.rb

@@ -0,0 +1,246 @@
+#coding: utf-8
+require 'matrix'
+require 'set'
+require "fifteen_puzzle/version"
+
+
+class Matrix
+  def []=(i, j, x)
+    @rows[i][j] = x
+  end
+end
+
+
+module FifteenPuzzle
+
+
+  class AStarAlgorithm
+    attr_reader :solution
+    # For Beam search
+    MAX_OPEN_LIST = 1000
+
+
+    def initialize( game_matrix )
+      @matrix = game_matrix
+      @nodes_count = 0
+    end
+
+
+    def find_cheapest( states )
+      min_cheapest = states.min_by{|e| e.cost}  
+      cheapest_list = states.find_all{|e| e.cost==min_cheapest.cost} 
+      return cheapest_list.last
+    end
+
+
+    def run
+      @closed_list = [].to_set
+      @open_list = [@matrix].to_set
+      while !@open_list.empty?        
+
+        if @matrix.solved?
+          @solution = @matrix
+          return true 
+        end
+
+        @closed_list << @matrix.matrix_hash    
+        @open_list.delete(@matrix)                
+        states = @matrix.neighbors(@open_list, @closed_list)   
+        if !states.empty? 
+          @open_list += states
+          @matrix = find_cheapest(states)                    
+        else
+          @matrix = @open_list.min_by{|e| e.cost}
+        end
+
+        # Beam search euristic
+        if @open_list.count > MAX_OPEN_LIST        
+          @open_list = @open_list.sort_by{|e| e.cost}[0..MAX_OPEN_LIST/2].to_set
+        end
+      end
+
+    end
+
+
+  end
+
+
+
+  class GameMatrix  
+    FREE_CELL = 0
+    ROW_SIZE = 4
+    COLUMN_SIZE = 4 
+    CORRECT_ANSWER = Matrix[[1,2,3,4], [5,6,7,8], [9,10,11,12], [13,14,15,0]]
+    
+
+    def initialize( matrix, parent=nil, depth_val=0 )
+      raise ArgumentError if matrix.row_size != ROW_SIZE ||  matrix.column_size != COLUMN_SIZE
+
+      @matrix = matrix
+      @parent = parent  
+      @cost = 0   
+      @depth = depth_val
+    end
+
+
+    def ==(other)            
+      @matrix == other.matrix
+    end
+
+
+    def solved?
+      @matrix == CORRECT_ANSWER
+    end
+
+
+    def matrix
+      @matrix
+    end
+
+    # Get matrix_hash to save it on closed list
+    def matrix_hash
+      @matrix.hash
+    end
+
+
+    # Get current position of free cell
+    def free_cell
+      @matrix.find_index{ |elem| elem == FREE_CELL}
+    end
+
+
+    def index_exist?(i, j)
+      return false if i < 0 || j < 0
+      not @matrix[i, j].nil?
+    end
+
+
+    def parent
+      return @parent
+    end
+
+
+    def parent=(val)
+      @parent = val
+    end
+
+
+    def parents_count
+      count = 0
+    
+      par = parent
+      while !par.nil?
+        count += 1        
+        par = par.parent
+      end
+      return count
+    end
+
+
+    def depth 
+      @depth
+    end
+
+
+    def depth=(val)
+      @depth = val
+    end
+
+
+    def cost
+      @cost
+    end
+
+
+    def manhattan_distance
+      matrix_hash = {}
+      @matrix.each_with_index do |e, i, j|
+        matrix_hash[e] = Vector[i, j]
+      end
+
+      etalon_hash = {}
+      CORRECT_ANSWER.each_with_index do |e, i, j|
+        etalon_hash[e] = Vector[i, j]
+      end
+
+      sum = 0
+      etalon_hash.keys.each do |e|
+        sum += (matrix_hash[e] - etalon_hash[e]).collect{|e| e.abs}.inject{|ind_sum,x| ind_sum + x }
+      end
+
+      return sum
+    end
+
+
+    def get_g
+      @depth
+    end
+
+
+    def get_h
+      manhattan_distance 
+    end
+
+
+    def calculate_cost
+      g = get_g      
+      h = get_h
+      @cost = g + h
+    end
+
+
+    def swap(i, j, new_i, new_j)
+      swapped_matrix = @matrix.clone
+      val = swapped_matrix[i,j]
+      swapped_matrix[i, j] = swapped_matrix[new_i, new_j]
+      swapped_matrix[new_i, new_j] = val
+      return swapped_matrix
+    end
+
+
+    # Get swapped matrix, check him in closed and open list
+    def moved_matrix( i, j, new_i, new_j, open_list, closed_list )
+      return nil if !index_exist?( new_i, new_j )      
+
+      swapped_matrix = swap( i, j, new_i, new_j )    
+
+      new_depth = @depth + 1
+      swapped_matrix = GameMatrix.new( swapped_matrix, self, new_depth )            
+      return nil if closed_list.include?( swapped_matrix )
+      swapped_matrix.calculate_cost    
+
+      open_list_matrix = open_list.find{ |e| e == swapped_matrix }      
+      if open_list_matrix && open_list_matrix.cost < swapped_matrix.cost
+        return open_list_matrix
+      elsif open_list_matrix
+        open_list_matrix.parent = self
+        open_list_matrix.depth = new_depth
+        return open_list_matrix        
+      else
+        return swapped_matrix
+      end
+    end
+
+    
+    # Get all possible movement matrixes
+    def neighbors( open_list=[], closed_list=[] )
+      i,j = free_cell      
+      up = moved_matrix(i, j, i-1, j, open_list, closed_list)
+      down = moved_matrix(i, j, i+1, j, open_list, closed_list)
+      left = moved_matrix(i, j, i, j-1, open_list, closed_list)
+      right = moved_matrix(i, j, i, j+1, open_list, closed_list)
+
+      moved = []
+      moved << up if !up.nil? 
+      moved << down if !down.nil? 
+      moved << left if !left.nil? 
+      moved << right if !right.nil? 
+
+      return moved
+    end
+  end
+
+
+end
+
+

data/spec/game_matrix_spec.rb

@@ -0,0 +1,133 @@
+require 'rspec'
+require 'fifteen_puzzle'
+
+include FifteenPuzzle
+
+describe GameMatrix do
+
+	it "should == to another game matrix" do
+    matrix = GameMatrix.new Matrix[[ 1, 4, 14, 13],
+                  [ 11, 9, 8, 12],
+                  [ 3, 6, GameMatrix::FREE_CELL, 7],
+                  [15, 5, 2, 10]]
+
+    matrix2 = GameMatrix.new Matrix[[ 1, 4, 14, 13],
+                  [ 11, 9, 8, 12],
+                  [ 3, 6, GameMatrix::FREE_CELL, 7],
+                  [15, 5, 2, 10]]
+    matrix.should == matrix2              
+  end
+
+  it "should show next moves" do
+    matrix = GameMatrix.new Matrix[[ 1, 4, 14, 13],
+                  [ 11, 9, 8, 12],
+                  [ 3, 6, 0, 7],
+                  [15, 5, 2, 10]]
+    matrix_up = GameMatrix.new Matrix[[ 1, 4, 14, 13],
+                  [ 11, 9, 0, 12],
+                  [ 3, 6, 8, 7],
+                  [15, 5, 2, 10]], matrix,1
+    matrix_down = GameMatrix.new Matrix[[ 1, 4, 14, 13],
+                  [ 11, 9, 8, 12],
+                  [ 3, 6, 2, 7],
+                  [15, 5, 0, 10]], matrix,1                  
+
+    matrix_left = GameMatrix.new Matrix[[ 1, 4, 14, 13],
+                  [ 11, 9, 8, 12],
+                  [ 3, 0, 6, 7],
+                  [15, 5, 2, 10]], matrix,1
+    matrix_right = GameMatrix.new Matrix[[ 1, 4, 14, 13],
+                  [ 11, 9, 8, 12],
+                  [ 3, 6, 7, 0],
+                  [15, 5, 2, 10]], matrix,1   
+
+
+    matrix.parents_count.should == 0
+    matrix_up.parents_count.should == 1
+
+    matrix_up.calculate_cost
+    matrix_down.calculate_cost
+    matrix_left.calculate_cost
+    matrix_right.calculate_cost
+
+    matrix.neighbors([],[]).collect{|e| e.matrix}.should == [matrix_up, matrix_down, matrix_left, matrix_right].collect{|e| e.matrix}
+  end
+
+  it "should return swapped matrix" do
+    matrix = GameMatrix.new Matrix[[ 1, 4, 14, 13],
+                [ 11, 9, 8, 12],
+                [ 3, 6, 7, 0],
+                [15, 5, 2, 10]], matrix   
+    matrix.moved_matrix(2,3,3,3,[], []).should == GameMatrix.new(Matrix[[ 1, 4, 14, 13],
+                      [ 11, 9, 8, 12],
+                      [ 3, 6, 7, 10],
+                      [15, 5, 2, 0]], matrix    )         
+  end
+
+  it "should solve simplest 15 " do
+    matrix1 = Matrix[[ 1, 2, 3, 4],
+                [ 5, 6, 7, 8],
+                [ 9, 10, 11, 12],
+                [ 13, 14, 0, 15]]
+
+    matrix2 = Matrix[[ 1, 2, 3, 0],
+                [ 5, 6, 7, 4],
+                [ 9, 10, 11, 8],
+                [ 13, 14, 15, 12]]
+
+    matrix3 = Matrix[[ 1, 2, 3, 4],
+                [ 5, 6, 7, 8],
+                [ 9, 10, 12, 15],
+                [ 13, 14, 11, 0]]
+
+    matrix5 = Matrix[[ 1, 2, 3, 4],
+                [ 5, 6, 7, 8],
+                [ 9, 10, 0, 12],
+                [ 13, 14, 11, 15]]
+
+    game_matrix = GameMatrix.new( matrix5 )
+    algorithm = AStarAlgorithm.new( game_matrix )
+    algorithm.run.should == true
+    
+    game_matrix = GameMatrix.new( matrix2 )
+    algorithm = AStarAlgorithm.new( game_matrix )
+    algorithm.run.should == true
+
+    game_matrix = GameMatrix.new( matrix1 )
+    algorithm = AStarAlgorithm.new( game_matrix )
+    algorithm.run.should == true
+
+    game_matrix = GameMatrix.new( matrix3 )
+    algorithm = AStarAlgorithm.new( game_matrix )
+    algorithm.run.should == true
+
+  end
+
+  it "should calc manhattan distance" do
+    h_matrix = GameMatrix.new Matrix[[15,1,2,3],[4,5,6,7],[8,9,10,11],[0,13,14,12]]
+    h_matrix.get_h.should == 28
+  end
+
+  it "should solve hard example" do
+      matrix = Matrix[[1,3,4,8],[5,2,0,12],[11,7,6,14],[10,9,15,13]]
+      matrix2 = Matrix[[6,4,8,7],[2,1,3,10],[5,0,9,12],[13,14,11,15]]
+      matrix3 = Matrix[[1, 0, 2, 3],[5, 6, 7, 4],
+                        [9, 10,  11,  8],
+                        [13,  14,  15,  12]
+                        ]
+      matrix4= Matrix[[2,6,0,8],[1,9,7,4],[5,10,15,3],[13,12,14,11]]
+      game_matrix = GameMatrix.new( matrix2 )
+      algorithm = AStarAlgorithm.new( game_matrix )
+      algorithm.run.should == true
+  end
+
+  it "should solve Marina example" do
+    # matrix = Matrix[[1, 2, 3], [4, 8, 5], [7,6,0]]
+    # game_matrix = GameMatrix.new( matrix2 )
+    # algorithm = AStarAlgorithm.new( game_matrix )
+    # algorithm.run.should == true 
+  end
+
+
+  
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: fifteen_puzzle
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- MO-524a
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 15puzzle solver with A* algorithm
+email:
+- mo124a@ya.ru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- fifteen_puzzle.gemspec
+- lib/fifteen_puzzle.rb
+- lib/fifteen_puzzle/version.rb
+- spec/game_matrix_spec.rb
+homepage: https://github.com/sld/astar-15puzzle-solver
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: 15puzzle solver with A* algorithm
+test_files:
+- spec/game_matrix_spec.rb