rubiks_cube 0.0.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6c52f18a7cefa561a5ddcf4e3ced978f5da8b921
-  data.tar.gz: d876ec06323fb7574a7c14d585bbe9b5d247dd5d
+  metadata.gz: d340c4d6ed10a679b877d834c2051ab5875ce201
+  data.tar.gz: 13e7c52e530391568ef6fc82e6e3ae30f1834788
 SHA512:
-  metadata.gz: 0bfdc210f6c713f895c216b943b9bfd5ec186963a066c88c91a1748b50a77f32c5628b2976d43c97e606c783dd8c9a8d843474a3c6718df29c6a313a2b39f7b5
-  data.tar.gz: 2a673c8aa861243b077c1e026fdcb81488c570949d6008758d2f7f7b47a779aead7b10304edfb502fed4e0f257eefbdb59f89356cbf33e959eb3e3f8b8b825af
+  metadata.gz: 6d04641548416231a627d4fff3d91e8a79701deeaa586b2d71fa33ff608c7b6154e53e82765f4cd8b0f390a50a89023fa7d45e50c7e17d87e7767a51b772692c
+  data.tar.gz: 4b167f837facba5d44b9158e7d8eedc65a68729f26d813538b6615f809e4bb744fd9b9c5901be8f98311500cbcb9c44c3cedb6b2273b34e951af70374cca2f76

data/README.md

@@ -1,16 +1,292 @@
 # Rubik's Cube
-![](http://www.mikesfreegifs.com/main4/underconstruction/atwork89.gif)
 
-## Description
+Can you solve the Rubik's Cube? Do you want to learn how? GREAT!
+
+We will teach you a very simple two-cycle solution for solving the Rubik's
+Cube. It's so simple that I used this exact solution to solve the cube
+blindfolded in the [2005 Rubik's World
+Championship](http://worldcubeassociation.org/results/p.php?i=2005HUNT01)
+with a time of 5 minutes and 40 seconds.
+
+With practice, you can easily average less than 3 minutes using this solution
+and will have enough understanding to progress to the [Fridrich CFOP](http://en.wikipedia.org/wiki/Fridrich_Method) method - taking you to 15 second solve times.
+WOW!
 
 ## Usage
 
+```ruby
+require 'rubiks_cube'
+
+cube = RubiksCube::Cube.new
+cube.solved? #=> true
+
+scramble = "U D B2 U B D2 B2 F' R' U2 F U' L2 F L2 B2 L2 R' U R' U' D R2 F2 B2"
+
+cube.perform! scramble
+cube.solved? #=> false
+
+solution = RubiksCube::TwoCycleSolution.new(cube)
+
+solution.length #=> 458
+
+puts solution.pretty
+
+  # Setup:  L2
+  # Fix:    R U R' U' R' F R2 U' R' U' R U R' F'
+  # Undo:   L2
+  #
+  # Setup:  M2 D L2
+  # Fix:    R U R' U' R' F R2 U' R' U' R U R' F'
+  # Undo:   L2 D' M2
+  #
+  # Setup:  U' F' U
+  # Fix:    R U R' U' R' F R2 U' R' U' R U R' F'
+  # Undo:   U' F U
+  # ...
+```
+
+## Setting Rubik's Cube State Manually
+
+If we'd like to start the Rubik's Cube in a different state, we can do that.
+Most people will want to do this if they have a cube sitting on their desk that
+is already scrambled.
+
+Describing a cube state may seem complicated at first, but it quickly becomes
+easy after you've done it a few times.
+
+Hold your Rubik's Cube in your hand. Notice that the center of each face does
+not move when you rotate a side. The is the basis for entering cube state
+manually. If the center of a face is red, then that face will be red when the
+cube is solved.
+
+Starting with top edges and working down (counter-clockwise), enter the state
+of each cubie. After edges are entered, proceed to corners. See the
+[examples](#examples) below for more help.
+
+![](https://raw.github.com/chrishunt/rubiks-cube/master/img/cube_instructions.jpg)
+
+### Examples
+
+Entering cube state manually can be confusing at first. Here are some examples
+to help you out.
+
+#### Solved Cube
+
+![](https://raw.github.com/chrishunt/rubiks-cube/master/img/cube_solved.jpg)
+
+A Rubik's Cube is solved by default, but let's take a look at entering the
+state of a solved cube manually so it makes sense.
+
+```ruby
+require 'rubiks_cube'
+
+cube = RubiksCube::Cube.new(
+  "UF UR UB UL FL FR BR BL DF DR DB DL UFL URF UBR ULB DLF DFR DRB DBL"
+)
+
+cube.solved? #=> true
+```
+
+#### Slightly Scrambled Cube
+
+![](https://raw.github.com/chrishunt/rubiks-cube/master/img/cube_scramble_1.jpg)
+
+Now let's look at a slightly scrambled cube.
+
+```ruby
+require 'rubiks_cube'
+
+cube = RubiksCube::Cube.new(
+  "RF FU UB UL FL UR BR BL DF DR DB DL UFL FUR UBR ULB DLF DFR DRB BLD"
+)
+
+cube.solved? #=> false
+```
+
+#### Fully Scrambled Cube
+
+![](https://raw.github.com/chrishunt/rubiks-cube/master/img/cube_scramble_2.jpg)
+
+Finally, let's look at a pretty messed up cube. Here's the scramble if you'd
+like to try this one at home:
+
+```
+U D B2 U B D2 B2 F' R' U2 F U' L2 F L2 B2 L2 R' U R' U' D R2 F2 B2
+```
+
+```ruby
+require 'rubiks_cube'
+
+cube = RubiksCube::Cube.new(
+  "RF DL UB DF UF DB FL LB UL DR BR UR FUR LFD UFL DRB BLD DFR BRU LBU"
+)
+
+cube.solved? #=> false
+```
+
+## Turning a Rubik's Cube
+
+Each Rubik's Cube face (l, r, f, b, d, u) can be turned clockwise manually by
+calling the appropriate method on the cube. For example, if we'd like to turn
+the right face twice, the down face once, and the back face three times:
+
+```ruby
+require 'rubiks_cube'
+
+cube = RubiksCube::Cube.new
+
+cube.r.r.d.b.b.b
+```
+
+Most people will prefer to use standard Rubik's Cube [algorithm
+notation](#algorithm-notation) for turning the cube. Here's the same example
+with with cube notation:
+
+```ruby
+require 'rubiks_cube'
+
+cube = RubiksCube::Cube.new
+
+cube.perform! "R2 D B'"
+```
+
+Performing face turns on the cube changes the state.
+
+```ruby
+require 'rubiks_cube'
+
+cube = RubiksCube::Cube.new
+
+cube.perform!(
+  "U D2 F2 L' R' D' B' U' D L D U2 B' L2 F2 R' U D F2 B' R' F2 U F2 B"
+)
+
+cube.solved? #=> false
+
+cube.state
+  # "DB UF RB RF LB DL UR RD FD UB LF UL FDL DFR UBR BDR UFL LDB FUR LBU"
+```
+
+## Solving a Rubik's Cube
+
+We currently only have a very simple two-cycle solution implemented. This
+solution is very inefficient, but wonderful for humans. Using the two-cycle
+solution, you can quickly learn how to solve the Rubik's Cube without using the
+computer.
+
+### Two Cycle Solution
+
+The two-cycle solution is a popular solution used to solve the Rubik's Cube
+blindfolded. It requires little memorization and takes little time to learn.
+Solutions usually range from 400-600 turns, but most of those turns are quickly
+executed. We can easily achieve times of less than 4 minutes with this
+solution.
+
+The two-cycle solution solves the cube by swapping two cubies at a time until
+all cubies are in the correct location. This is the permutation step. After the
+cubies are permuted, we then rotate two cubies at a time (in their current
+location) until all are oriented correctly. This is the orientation step. We
+call this the *two-cycle* solution because everything is done in pairs.
+
+You can use the `rubiks_cube` gem to *learn* the two-cycle solution. For each
+step, we provide setup moves, the [fixing algorithm](#algorithms) (either
+changing permutation or orientation), and the undo moves. Pay close attention
+to how the cube moves and you will be solving by yourself in no time.
+
+See [Usage](#usage) for an example of the `TwoCycleSolution`
+
+#### How It Works: Permutation
+
+![](https://raw.github.com/chrishunt/rubiks-cube/master/img/cube_permutation.jpg)
+
+The permutation step is completed using only two algorithms. One swaps two
+edges and the other swaps two corners. The diagram above shows which edges and
+corners are swapped.
+
+When a solution is calculated, we present a 'setup' algorithm (which gets the
+cubies into a position where they can be swapped), then we present one of the
+two swapping algorithms, followed by an 'undo' algorithm that reverses the
+setup move.
+
+#### How It Works: Orientation
+
+![](https://raw.github.com/chrishunt/rubiks-cube/master/img/cube_orientation.jpg)
+
+The orientation step is completed using only two algorithms. One flips two
+edges and the other rotates two corners (one clockwise and the other
+counter-clockwise). The diagram above shows which edges and corners are
+rotated.
+
+When a solution is calculated, we present a 'setup' algorithm (which gets the
+cubies into a position where they can be rotated), then we present one of the
+two rotation algorithms, followed by an 'undo' algorithm that reverses the
+setup move.
+
+## Algorithms
+
+All algorithms can be found in [`RubiksCube::Algorithms`](https://github.com/chrishunt/rubiks-cube/blob/master/lib/rubiks_cube/algorithms.rb)
+
+### Algorithm Notation
+
+![](https://raw.github.com/chrishunt/rubiks-cube/master/img/cube_algorithm.jpg)
+
+Rubik's Cube algorithm notation is easy to understand, but may look confusing
+at first. Each face is represented by a letter:
+
+- **L**: Left Face
+- **R**: Right Face
+- **F**: Front Face
+- **B**: Back Face
+- **U**: Up Face (top)
+- **D**: Up Face (bottom)
+
+When we see a letter in an algorithm, then we turn that face 90 degrees
+clockwise. To determine which direction is clockwise, rotate the cube so that
+you are looking at the face, then make the turn.
+
+Faces may be followed by one of two modifiers:
+
+- **'**: Rotate the face 90 degrees *counter*-clockwise
+- **2**: Rotate the face 180 degrees (two turns)
+
+For example, if we want to apply the algorithm `F2 B D' R`, then we would take
+these steps:
+
+1. Rotate **F** face 180 degrees (two turns)
+2. Rotate **B** face 90 degrees clockwise
+3. Rotate **D** face 90 degrees *counter*-clockwise
+4. Rotate **R** face 90 degrees clockwise
+
+#### M Slice
+
+![](https://raw.github.com/chrishunt/rubiks-cube/master/img/cube_m_slice.jpg)
+
+There is one special algorithm notation that does not map to a face. This is
+called the M slice. The M slice is the middle vertical layer of the Rubik's
+Cube.
+
+When you see **M**, then rotate this slice 90 degrees clockwise. To figure out
+which direction is clockwise, look at the **L** face.
+
+For example, if we want to apply the algorithm `M2 F M2`, then we would take
+these steps:
+
+1. Rotate **M** slice 180 degrees (two turns)
+2. Rotate **F** face 90 degrees clockwise
+3. Rotate **M** slice 180 degrees (two turns)
+
 ## Installation
 
+```bash
+$ gem install rubiks_cube
+```
+
 ## Contributing
+
 Please see the [Contributing
 Document](https://github.com/chrishunt/rubiks-cube/blob/master/CONTRIBUTING.md)
 
 ## License
+
 Copyright (C) 2013 Chris Hunt, [MIT
 License](https://github.com/chrishunt/rubiks-cube/blob/master/LICENSE.txt)

data/lib/rubiks_cube.rb

@@ -2,6 +2,4 @@ require 'rubiks_cube/version'
 require 'rubiks_cube/cube'
 require 'rubiks_cube/cubie'
 require 'rubiks_cube/algorithms'
-require 'rubiks_cube/edge_cubie'
-require 'rubiks_cube/corner_cubie'
 require 'rubiks_cube/two_cycle_solution'

data/lib/rubiks_cube/cube.rb

@@ -39,38 +39,6 @@ module RubiksCube
       cubie_permuted? :corners, corner
     end
 
-    def has_correct_edge_permutation?
-      incorrect_edge_permutation_locations.empty?
-    end
-
-    def has_correct_corner_permutation?
-      incorrect_corner_permutation_locations.empty?
-    end
-
-    def has_correct_edge_orientation?
-      incorrect_edge_orientation_locations.empty?
-    end
-
-    def has_correct_corner_orientation?
-      incorrect_corner_orientation_locations.empty?
-    end
-
-    def incorrect_edge_permutation_locations
-      unpermuted_locations_for :edges
-    end
-
-    def incorrect_corner_permutation_locations
-      unpermuted_locations_for :corners
-    end
-
-    def incorrect_edge_orientation_locations
-      unoriented_locations_for :edges
-    end
-
-    def incorrect_corner_orientation_locations
-      unoriented_locations_for :corners
-    end
-
     def permuted_location_for(cubie)
       while (location = SOLVED_STATE.index cubie.state) == nil
         cubie = cubie.rotate
@@ -85,49 +53,37 @@ module RubiksCube
       algorithm
     end
 
-    def undo!(algorithm)
-      perform! reverse(algorithm)
-    end
-
     def r
-      turn [1, 5, 9, 6]
-      turn [13, 17, 18, 14]
-      rotate [13, 13, 14, 17, 18, 18]
+      turn [1, 5, 9, 6], [13, 17, 18, 14]
+      rotate [13, 14, 14, 17, 17, 18]
       self
     end
 
     def l
-      turn [3, 7, 11, 4]
-      turn [12, 15, 19, 16]
-      rotate [12, 15, 15, 16, 16, 19]
+      turn [3, 7, 11, 4], [12, 15, 19, 16]
+      rotate [12, 12, 15, 16, 19, 19]
       self
     end
 
     def u
-      turn [0, 1, 2, 3]
-      turn [12, 13, 14, 15]
+      turn [0, 1, 2, 3], [12, 13, 14, 15]
       self
     end
 
     def d
-      turn [8, 11, 10, 9]
-      turn [16, 19, 18, 17]
+      turn [8, 11, 10, 9], [16, 19, 18, 17]
       self
     end
 
     def f
-      turn [0, 4, 8, 5]
-      rotate [0, 4, 8, 5]
-      turn [12, 16, 17, 13]
-      rotate [12, 12, 13, 16, 17, 17]
+      turn [0, 4, 8, 5], [12, 16, 17, 13]
+      rotate [0, 4, 8, 5], [12, 13, 13, 16, 16, 17]
       self
     end
 
     def b
-      turn [2, 6, 10, 7]
-      rotate [2, 6, 10, 7]
-      turn [14, 18, 19, 15]
-      rotate [14, 14, 15, 18, 19, 19]
+      turn [2, 6, 10, 7], [14, 18, 19, 15]
+      rotate [2, 6, 10, 7], [14, 15, 15, 18, 18, 19]
       self
     end
 
@@ -137,6 +93,18 @@ module RubiksCube
       self
     end
 
+    [:edge, :corner].each do |cubie|
+      [:orientation, :permutation].each do |step|
+        define_method "incorrect_#{cubie}_#{step}_locations" do
+          send "incorrect_#{step}_locations_for", cubie
+        end
+
+        define_method "has_correct_#{cubie}_#{step}?" do
+          send("incorrect_#{cubie}_#{step}_locations").empty?
+        end
+      end
+    end
+
     private
 
     def build_state_from_string(state)
@@ -147,16 +115,16 @@ module RubiksCube
       send(type).index(cubie) == permuted_location_for(cubie)
     end
 
-    def unpermuted_locations_for(type)
-      send(type).each_with_index.map do |cubie, location|
+    def incorrect_permutation_locations_for(type)
+      send("#{type}s").each_with_index.map do |cubie, location|
         location unless location == permuted_location_for(cubie)
       end.compact
     end
 
-    def unoriented_locations_for(type)
-      send(type).each_with_index.map do |cubie, location|
+    def incorrect_orientation_locations_for(type)
+      send("#{type}s").each_with_index.map do |cubie, location|
         oriented_state = SOLVED_STATE.fetch(
-          if type == :corners
+          if type == :corner
             location + 12
           else
             location
@@ -167,20 +135,24 @@ module RubiksCube
       end.compact
     end
 
-    def turn(sequence)
-      current_cubie = sequence.shift
-      first_cubie = @state[current_cubie]
+    def turn(*sequences)
+      sequences.each do |sequence|
+        location = sequence.shift
+        first_cubie = @state.fetch(location)
 
-      sequence.each do |cubie|
-        @state[current_cubie] = @state[cubie]
-        current_cubie = cubie
-      end
+        sequence.each do |next_location|
+          @state[location] = @state.fetch(next_location)
+          location = next_location
+        end
 
-      @state[current_cubie] = first_cubie
+        @state[location] = first_cubie
+      end
     end
 
-    def rotate(cubies)
-      cubies.each { |cubie| @state[cubie].rotate! }
+    def rotate(*sequences)
+      sequences.each do |cubies|
+        cubies.each { |cubie| @state[cubie].rotate! }
+      end
     end
 
     def perform_move!(move)
@@ -195,9 +167,5 @@ module RubiksCube
           send operation
       end
     end
-
-    def reverse(algorithm)
-      RubiksCube::Algorithms.reverse algorithm
-    end
   end
 end

data/lib/rubiks_cube/cubie.rb

@@ -1,20 +1,12 @@
 module RubiksCube
   # Generic cubie piece, either edge cubie or corner cubie
-  class Cubie
-    def initialize(state)
-      @cubie = state.size == 2 ? EdgeCubie.new(state) : CornerCubie.new(state)
-    end
-
+  Cubie = Struct.new(:state) do
     def ==(other)
       state == other.state
     end
 
-    def state
-      @cubie.state
-    end
-
     def rotate!
-      @cubie.rotate!
+      self.state = state.split('').rotate.join
       self
     end
 
@@ -23,7 +15,7 @@ module RubiksCube
     end
 
     def to_s
-      @cubie.state
+      state
     end
   end
 end

data/lib/rubiks_cube/two_cycle_solution.rb

@@ -29,7 +29,7 @@ module RubiksCube
       @solution
     end
 
-    def solution_length
+    def length
       solution.flatten.join(' ').split.count
     end
 

data/lib/rubiks_cube/version.rb

@@ -1,3 +1,3 @@
 module RubiksCube
-  VERSION = '0.0.1'
+  VERSION = '1.0.0'
 end

data/spec/rubiks_cube/cube_spec.rb

@@ -297,16 +297,6 @@ describe RubiksCube::Cube do
     end
   end
 
-  describe '#undo!' do
-    it 'performs the algorithm in reverse on the cube' do
-      subject.f.f.f.b.l.l.u.u.u.r
-
-      subject.undo! "F' B L2 U' R"
-
-      expect(subject).to be_solved
-    end
-  end
-
   describe 'face turns' do
     shared_examples_for 'a face turn' do
       it "rotates the face 90 degrees clockwise" do

data/spec/rubiks_cube/cubie_spec.rb

@@ -17,7 +17,7 @@ describe RubiksCube::Cubie do
     end
 
     context 'when the state does not equal the state of the other' do
-      it 'returns true' do
+      it 'returns false' do
         expect(subject == described_class.new('UB')).to be_false
       end
     end
@@ -43,8 +43,8 @@ describe RubiksCube::Cubie do
       let(:state) { 'URF' }
 
       it 'rotates the cubie once couter clockwise' do
-        expect(subject.rotate!.state).to eq 'FUR'
         expect(subject.rotate!.state).to eq 'RFU'
+        expect(subject.rotate!.state).to eq 'FUR'
         expect(subject.rotate!.state).to eq state
       end
     end
@@ -63,5 +63,4 @@ describe RubiksCube::Cubie do
       expect(subject.state).to eq original_state
     end
   end
-
 end

data/spec/rubiks_cube/two_cycle_solution_spec.rb

@@ -96,14 +96,14 @@ describe RubiksCube::TwoCycleSolution do
       end
     end
 
-    describe '#solution_length' do
+    describe '#length' do
       it 'returns the length of the solution' do
         cube.l.r
-        expect(subject.solution_length).to eq 634
+        expect(subject.length).to eq 634
       end
 
       it 'returns zero when cube already solved' do
-        expect(subject.solution_length).to be_zero
+        expect(subject.length).to be_zero
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubiks_cube
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Chris Hunt
@@ -79,12 +79,19 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- img/cube_algorithm.jpg
+- img/cube_blank.jpg
+- img/cube_instructions.jpg
+- img/cube_m_slice.jpg
+- img/cube_orientation.jpg
+- img/cube_permutation.jpg
+- img/cube_scramble_1.jpg
+- img/cube_scramble_2.jpg
+- img/cube_solved.jpg
 - lib/rubiks_cube.rb
 - lib/rubiks_cube/algorithms.rb
-- lib/rubiks_cube/corner_cubie.rb
 - lib/rubiks_cube/cube.rb
 - lib/rubiks_cube/cubie.rb
-- lib/rubiks_cube/edge_cubie.rb
 - lib/rubiks_cube/two_cycle_solution.rb
 - lib/rubiks_cube/version.rb
 - rubiks_cube.gemspec

data/lib/rubiks_cube/corner_cubie.rb

@@ -1,8 +0,0 @@
-module RubiksCube
-  CornerCubie = Struct.new(:state) do
-    def rotate!
-      u, r, f = state.split ''
-      self.state = [f, u, r].join
-    end
-  end
-end

data/lib/rubiks_cube/edge_cubie.rb

@@ -1,7 +0,0 @@
-module RubiksCube
-  EdgeCubie = Struct.new(:state) do
-    def rotate!
-      state.reverse!
-    end
-  end
-end