scrambler 0.1.0 → 0.1.1

data/lib/scrambler.rb

@@ -5,4 +5,7 @@ require "scrambler/cube"
 require "scrambler/pyraminx"
 require "scrambler/clock"
 require "scrambler/square1"
-require "scrambler/megaminx"
+require "scrambler/megaminx"
+
+require "scrambler/random_state/solver"
+require "scrambler/random_state/two_by_two"

data/lib/scrambler/clock.rb

@@ -1,6 +1,6 @@
 module Scrambler
   class Clock
-    def scramble
+    def scramble(length = 0)
       pins = %w(U d)
       states = %w(UUdd dUdU ddUU UdUd dUUU UdUU UUUd UUdU UUUU dddd)
       scramble = states.map do |state|

data/lib/scrambler/random_state/corner_orientation.rb

@@ -0,0 +1,51 @@
+# TODO Connascence of position...
+# Up:
+# 3 0
+# 2 1
+# Down
+# - 4
+# 6 5
+module Scrambler
+  module RandomState
+    class CornerOrientation
+      def initialize(orientation = [0] * 7)
+        case orientation
+        when Array
+          @orientation = orientation.clone
+        else
+          @orientation = convert_to_array orientation
+        end
+      end
+
+      def to_a
+        @orientation
+      end
+
+      def to_i
+        n = -1
+        @orientation.inject(0) { |sum, i| n += 1; sum + i * (3**n) }
+      end
+
+      def turn!(move)
+        o = @orientation
+        case move
+        when :R
+          @orientation = [(o[1] + 1) % 3, (o[5] + 2) % 3, o[2], o[3], (o[0] + 2) % 3, (o[4] + 1) % 3, o[6]]
+        when :F
+          @orientation = [o[0], (o[2] + 1) % 3, (o[6] + 2) % 3, o[3], o[4], (o[1] + 2) % 3, (o[5] + 1) % 3]
+        when :U
+          @orientation = [o[3], o[0], o[1], o[2], o[4], o[5], o[6]]
+        end
+        self
+      end
+
+    private
+      def convert_to_array(number)
+        short = number.to_s(3).reverse.split(//).map do |s|
+          s.to_i
+        end
+        short + [0] * (7 - short.size)
+      end
+    end
+  end
+end

data/lib/scrambler/random_state/corner_permutation.rb

@@ -0,0 +1,43 @@
+module Scrambler
+  module RandomState
+    class CornerPermutation
+      def initialize(permutation = [0, 1, 2, 3, 4, 5, 6])
+        case permutation
+        when Array
+          @permutation = permutation.clone
+        else
+          @permutation = convert_to_array(permutation)
+        end
+      end
+
+      def to_a
+        @permutation
+      end
+
+      def to_i
+        @permutation.map do |piece|
+          piece.to_s
+        end.join.to_i
+      end
+
+      def turn!(move)
+        p = @permutation
+        case move
+        when :R
+          @permutation = [p[1], p[5], p[2], p[3], p[0], p[4], p[6]]
+        when :F
+          @permutation = [p[0], p[2], p[6], p[3], p[4], p[1], p[5]]
+        when :U
+          @permutation = [p[3], p[0], p[1], p[2], p[4], p[5], p[6]]
+        end
+        self
+      end
+
+    private
+      def convert_to_array(number)
+        result = number.to_s.split(//).map { |s| s.to_i }
+        result.size < 7 ? [0] + result : result
+      end
+    end
+  end
+end

data/lib/scrambler/random_state/cube_state.rb

@@ -0,0 +1,28 @@
+module Scrambler
+  module RandomState
+    class CubeState
+      attr_reader :orientation, :permutation
+
+      def initialize
+        @orientation = [0] * 8
+        @permutation = [0, 1, 2, 3, 4, 5, 6, 7]
+      end
+
+      def turn!(layer)
+        o = @orientation.clone
+        p = @permutation.clone
+        case layer
+        when :R
+          @permutation = [p[1], p[5], p[2], p[3], p[0], p[4], p[6], p[7]]
+          @orientation = [(o[1] + 1) % 3, (o[5] + 2) % 3, o[2], o[3], (o[0] + 2) % 3, (o[4] + 1) % 3, o[6], o[7]]
+        when :F
+          @permutation = [p[0], p[2], p[6], p[3], p[4], p[1], p[5], p[7]]
+          @orientation = [o[0], (o[2] + 1) % 3, (o[6] + 2) % 3, o[3], o[4], (o[1] + 2) % 3, (o[5] + 1) % 3, o[7]]
+        when :U
+          @permutation = [p[3], p[0], p[1], p[2], p[4], p[5], p[6], p[7]]
+          @orientation = [o[3], o[0], o[1], o[2], o[4], o[5], o[6], o[7]]
+        end
+      end
+    end
+  end
+end

data/lib/scrambler/random_state/solver.rb

@@ -0,0 +1,98 @@
+require "scrambler/random_state/corner_orientation"
+require "scrambler/random_state/corner_permutation"
+
+module Scrambler
+  module RandomState
+    class Solver
+      SOLVED_PERMUTATION = [0, 1, 2, 3, 4, 5, 6]
+      SOLVED_ORIENTATION = [0] * 7
+      TURNS = [:R, :U, :F]
+      MODS = ["", "2", "'"]
+
+      def initialize
+        @permutation_map = []
+        SOLVED_PERMUTATION.permutation.each do |p|
+          @permutation_map[CornerPermutation.new(p).to_i] = { :R => CornerPermutation.new(p).turn!(:R).to_i,
+                                                              :U => CornerPermutation.new(p).turn!(:U).to_i,
+                                                              :F => CornerPermutation.new(p).turn!(:F).to_i,
+                                                              :length => -1
+                                                            }
+        end
+
+        @permutation_map[123456][:length] = 0
+        7.times do |l|
+          SOLVED_PERMUTATION.permutation.each do |p|
+            if @permutation_map[CornerPermutation.new(p).to_i][:length] == l
+              [:R, :U, :F].each do |m|
+                q = CornerPermutation.new(p).to_i
+                3.times do |c|
+                  q = @permutation_map[q][m]
+                  @permutation_map[q][:length] = l + 1 if @permutation_map[q][:length] == -1
+                end
+              end
+            end
+          end
+        end
+
+        @orientation_map = []
+        (3**7).times do |i|
+          @orientation_map[i] = { :R => CornerOrientation.new(i).turn!(:R).to_i,
+                                  :U => CornerOrientation.new(i).turn!(:U).to_i,
+                                  :F => CornerOrientation.new(i).turn!(:F).to_i,
+                                  :length => -1
+                                }
+        end
+
+        @orientation_map[0][:length] = 0
+        6.times do |l|
+          (3**7).times do |o|
+            if @orientation_map[o][:length] == l
+              [:R, :U, :F].each do |m|
+                q = o
+                3.times do |c|
+                  q = @orientation_map[q][m]
+                  @orientation_map[q][:length] = l + 1 if @orientation_map[q][:length] == -1
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def solve(corner_permutation, corner_orientation)
+        @solution = []
+        move_limit = -1
+        begin
+          move_limit += 1
+        end while !search(corner_permutation.to_i, corner_orientation.to_i, move_limit)
+        @solution.map { |t| t[0].to_s + t[1] }.join " "
+      end
+
+    private
+
+      def search(current_permutation, current_orientation, limit, depth = 0, last_move = nil)
+        if current_permutation == 123456 and current_orientation == 0
+          return true
+        elsif limit == 0
+          return false
+        else
+          return false if @permutation_map[current_permutation][:length] > limit or @orientation_map[current_orientation][:length] > limit
+          TURNS.each do |turn|
+            if last_move != turn
+              next_permutation = current_permutation
+              next_orientation = current_orientation
+              MODS.each do |modifier|
+                next_permutation = @permutation_map[next_permutation][turn]
+                next_orientation = @orientation_map[next_orientation][turn]
+                @solution[depth] = [turn, modifier]
+                return true if search(next_permutation, next_orientation, limit - 1, depth + 1, turn)
+              end
+            end
+          end
+        end
+
+        return false
+      end
+    end
+  end
+end

data/lib/scrambler/random_state/two_by_two.rb

@@ -0,0 +1,21 @@
+require "scrambler/random_state/corner_orientation"
+require "scrambler/random_state/corner_permutation"
+require "scrambler/random_state/solver"
+
+module Scrambler
+  module RandomState
+    class TwoByTwo
+      def initialize
+        @solver = Solver.new
+      end
+
+      def scramble
+        permutation = Solver::SOLVED_PERMUTATION.shuffle
+        orientation = Array.new(6) { rand 3 }
+        orientation += [(3 - (orientation.inject { |sum, i| sum + i } % 3)) % 3] # fix orientation parity
+
+        @solver.solve(CornerPermutation.new(permutation), CornerOrientation.new(orientation))
+      end
+    end
+  end
+end

data/lib/scrambler/square1.rb

@@ -1,6 +1,6 @@
 module Scrambler
   class Square1
-    def scramble
+    def scramble(length = 0)
       scramble = []
       up_layer = (0..7).map{|i| i%2 == 0 ? 30 : 60}
       down_layer = [up_layer].flatten!

data/lib/scrambler/version.rb

@@ -1,3 +1,3 @@
 module Scrambler
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/spec/scrambler/random_state/corner_orientation_spec.rb

@@ -0,0 +1,41 @@
+require "spec_helper"
+
+describe Scrambler::RandomState::CornerOrientation do
+  include Scrambler::RandomState
+
+  it "should have all corners oriented right after initialization" do
+    subject.to_a.should == [0] * 7
+    subject.to_i.should == 0
+  end
+
+  it "should have orientation [1, 2, 0, 0, 2, 1, 0] after R turn" do
+    co = subject.turn!(:R)
+    co.to_a.should == [1, 2, 0, 0, 2, 1, 0]
+    co.to_i.should == 412
+  end
+
+  it "should have orientation [0, 1, 2, 0, 0, 2, 1] after F turn" do
+    subject.turn!(:F).to_a.should == [0, 1, 2, 0, 0, 2, 1]
+  end
+
+  it "should have orientation [0, 0, 0, 0, 0, 0, 0] after U turn" do
+    subject.turn!(:U).to_a.should == [0, 0, 0, 0, 0, 0, 0]
+    subject.turn!(:U).to_i.should == 0
+  end
+
+  it "should have orientation [0, 1, 2, 0, 2, 1, 0] after R U turns" do
+    subject.turn!(:R).turn!(:U).to_a.should == [0, 1, 2, 0, 2, 1, 0]
+  end
+
+  it "should have all corners oriented after a U-Perm" do
+    subject.turn!(:R).turn!(:R).turn!(:U).turn!(:U).turn!(:U).
+            turn!(:R).turn!(:R).turn!(:R).turn!(:U).turn!(:U).turn!(:U).
+            turn!(:R).turn!(:U).turn!(:R).turn!(:U).turn!(:R).
+            turn!(:U).turn!(:U).turn!(:U).turn!(:R).to_a.should == [0] * 7
+  end
+
+  it "should accept numbers and arrays as initial value" do
+    CornerOrientation.new(248).to_a.should == [2, 1, 0, 0, 0, 1, 0]
+    CornerOrientation.new([2, 1, 0, 0, 0, 1, 0]).to_i.should == 248
+  end
+end

data/spec/scrambler/random_state/corner_permutation_spec.rb

@@ -0,0 +1,31 @@
+require "spec_helper"
+
+describe Scrambler::RandomState::CornerPermutation do
+  include Scrambler::RandomState
+
+  it "should return solved permutation after initialization" do
+    subject.to_a.should == [0, 1, 2, 3, 4, 5, 6]
+    subject.to_i.should == 123456
+  end
+
+  it "should have permutation [1, 5, 2, 3, 0, 4, 6] after R turn" do
+    subject.turn!(:R).to_a.should == [1, 5, 2, 3, 0, 4, 6]
+  end
+
+  it "should have permutation [0, 2, 6, 3, 4, 1, 5] after F turn" do
+    subject.turn!(:F).to_a.should == [0, 2, 6, 3, 4, 1, 5]
+  end
+
+  it "should have permutation [3, 0, 1, 2, 4, 5, 6] after U turn" do
+    subject.turn!(:U).to_a.should == [3, 0, 1, 2, 4, 5, 6]
+  end
+
+  it "should return proper number representation" do
+    CornerPermutation.new([1, 0, 2, 4, 5, 6, 3]).to_i.should == 1024563
+  end
+
+  it "should accept numbers and convert them to arrays" do
+    CornerPermutation.new(1024563).to_a.should == [1, 0, 2, 4, 5, 6, 3]
+    CornerPermutation.new(123456).to_a.should == [0, 1, 2, 3, 4, 5, 6]
+  end
+end

data/spec/scrambler/random_state/cube_state_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+require "scrambler/random_state/cube_state"
+
+describe Scrambler::RandomState::CubeState do
+  include Scrambler::RandomState
+
+  Given(:cube) { CubeState.new }
+
+  context "when new" do
+    Then { cube.orientation.should == [0] * 8 }
+    Then { cube.permutation.should == [0, 1, 2, 3, 4, 5, 6, 7] }
+  end
+
+  context "when turned R" do
+    When { cube.turn! :R }
+
+    Then { cube.orientation.should == [1, 2, 0, 0, 2, 1, 0, 0] }
+    Then { cube.permutation.should == [1, 5, 2, 3, 0, 4, 6, 7] }
+  end
+
+  context "when turned F" do
+    When { cube.turn! :F }
+
+    Then { cube.orientation.should == [0, 1, 2, 0, 0, 2, 1, 0] }
+    Then { cube.permutation.should == [0, 2, 6, 3, 4, 1, 5, 7] }
+  end
+
+  context "when turned U" do
+    When { cube.turn! :U }
+
+    Then { cube.orientation.should == [0] * 8 }
+    Then { cube.permutation.should == [3, 0, 1, 2, 4, 5, 6, 7] }
+  end
+end

data/spec/scrambler/random_state/solver_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+describe Scrambler::RandomState::Solver do
+  include Scrambler::RandomState
+
+  before(:all) do
+    @solver ||= Solver.new
+  end
+
+  it "should solve scramble R U optimally" do
+    @solver.solve(CornerPermutation.new([3, 1, 5, 2, 0, 4, 6]), CornerOrientation.new([0, 1, 2, 0, 2, 1, 0])).should == "U' R'"
+  end
+
+  it "should solve scramble U R U' R' optimally" do
+    @solver.solve(CornerPermutation.new([3, 5, 2, 0, 4, 1, 6]), CornerOrientation.new([0, 1, 0, 1, 0, 1, 0])).should == "R U R' U'"
+  end
+
+  it "should solve scramble F U R U' R' F' optimally" do
+    @solver.solve(CornerPermutation.new([3, 2, 1, 0, 4, 5, 6]), CornerOrientation.new([0, 0, 2, 1, 0, 0, 0])).should == "F R U R' U' F'"
+  end
+
+  it "should solve 8 move scramble optimally" do
+    @solver.solve(CornerPermutation.new([0, 1, 4, 2, 5, 6, 3]), CornerOrientation.new([2, 1, 2, 2, 0, 2, 0])).should == "U R' U2 F R' F U2 F'"
+  end
+
+  it "should solve 9 move scramble optimally" do
+    @solver.solve(CornerPermutation.new([0, 5, 6, 3, 2, 1, 4]), CornerOrientation.new([2, 1, 1, 2, 0, 2, 1])).should == "R U' F' R2 F R' F U2 R'"
+  end
+
+  it "should solve 10 move scramble optimally" do
+    @solver.solve(CornerPermutation.new([2, 5, 0, 6, 1, 4, 3]), CornerOrientation.new([2, 1, 2, 1, 1, 2, 0])).should == "U2 F U' R2 U F2 U R' U' R2"
+  end
+
+  it "should solve 11 move scramble optimally" do
+    @solver.solve(CornerPermutation.new([3, 2, 1, 0, 4, 5, 6]), CornerOrientation.new([0, 0, 0, 0, 0, 0, 0])).should == "R U2 R' U' F U2 R' F' R U' F2"
+  end
+end
+

data/spec/scrambler/random_state/two_by_two_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+describe Scrambler::RandomState::TwoByTwo do
+  include Scrambler::RandomState
+
+  let(:valid_turns) { %w(R R' R2 U U' U2 F F' F2) }
+
+  it "should not have more than 11 moves" do
+    subject.scramble.split(" ").size.should be <= 11
+  end
+
+  it "should only contain moves out or <R, F, U>" do
+    subject.scramble.split(" ").each do |turn|
+      valid_turns.should include(turn)
+    end
+  end
+
+  it "should return different scrambles (almost) every time" do
+    subject.scramble.should_not == subject.scramble
+  end
+end

data/spec/spec_helper.rb

@@ -1,4 +1,4 @@
-require "rubygems"
 require "bundler/setup"
+Bundler.require(:default)
 
-Bundler.require(:default)
+require "rspec/given"

metadata

@@ -2,7 +2,7 @@
 name: scrambler
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors: 
 - Tim Habermaas
@@ -23,6 +23,17 @@ dependencies:
         version: 2.6.0
   type: :development
   version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec-given
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id002
 description: Scrambler for cubes and other puzzles
 email: t.habermaas@gmail.com
 executables: []
@@ -37,19 +48,29 @@ files:
 - lib/scrambler/cube.rb
 - lib/scrambler/megaminx.rb
 - lib/scrambler/pyraminx.rb
+- lib/scrambler/random_state/corner_orientation.rb
+- lib/scrambler/random_state/corner_permutation.rb
+- lib/scrambler/random_state/cube_state.rb
+- lib/scrambler/random_state/solver.rb
+- lib/scrambler/random_state/two_by_two.rb
 - lib/scrambler/square1.rb
 - lib/scrambler/version.rb
 - lib/scrambler.rb
 - spec/scrambler/clock_spec.rb
-- spec/scrambler/five_by_five_spec.rb
-- spec/scrambler/four_by_four_spec.rb
+- spec/scrambler/cubes/five_by_five_spec.rb
+- spec/scrambler/cubes/four_by_four_spec.rb
+- spec/scrambler/cubes/seven_by_seven_spec.rb
+- spec/scrambler/cubes/six_by_six_spec.rb
+- spec/scrambler/cubes/three_by_three_spec.rb
+- spec/scrambler/cubes/two_by_two_spec.rb
 - spec/scrambler/megaminx_spec.rb
 - spec/scrambler/pyraminx_spec.rb
-- spec/scrambler/seven_by_seven_spec.rb
-- spec/scrambler/six_by_six_spec.rb
+- spec/scrambler/random_state/corner_orientation_spec.rb
+- spec/scrambler/random_state/corner_permutation_spec.rb
+- spec/scrambler/random_state/cube_state_spec.rb
+- spec/scrambler/random_state/solver_spec.rb
+- spec/scrambler/random_state/two_by_two_spec.rb
 - spec/scrambler/square1_spec.rb
-- spec/scrambler/three_by_three_spec.rb
-- spec/scrambler/two_by_two_spec.rb
 - spec/spec_helper.rb
 - Gemfile
 homepage: https://github.com/timhabermaas/scrambler
@@ -75,9 +96,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.8.15
 signing_key: 
 specification_version: 3
 summary: Scrambler for cubes and other puzzles
 test_files: []
 
+has_rdoc: