Kandidatexamensarbete vid CSC, KTH

Transcription

Kandidatexamensarbete vid CSC, KTH
Variations of solving methods for the 5x5x5 Rubik’s cube
Variationer av lösningsmetoder för 5x5x5 Rubiks kub
Ståhl Jens
Address: Slipargränd 7
Phone: 0707604973
e-mail: [email protected]
Kandedatexjobb i datateknik
Handledare: Boye, Johan
Uppdragsgivare: CSC, KTH
Abstract
Examining the most common solving methods for the 5x5x5 Rubik’s cube can tell us which
ways of solving the cube that requires the least number of face turns. This essay copes with two
distinct steps and concludes clear indications in which order and in which fashion to do certain
steps by simulating how the same problem instance would be solved using different solving
methods.
Sammanfattning
Genom att undersöka de vanligaste lösningsmetoderna för 5x5x5 Rubiks kub kan det tas reda på
vilka metoder som använder lägst antal drag. Denna uppsats berör två olika steg som
förekommer i de vanligaste lösningsmetoderna och visar på tydliga tendenser vilka metoder som
är snabbast.
Table of contents
Kandidatexamensarbete vid CSC, KTH..........................................................................................1
Context........................................................................................................................................4
Background.................................................................................................................................4
Problem Statement......................................................................................................................5
Definitions...................................................................................................................................5
Solving the cube..........................................................................................................................5
Step one, building the 3x3 centers..........................................................................................6
Step two, build the twelve 3x1x1 edges.................................................................................6
Fix parity errors......................................................................................................................7
Solve the reduced cube as an ordinary 3x3x3 cube................................................................7
Problem statement redefinition...................................................................................................8
Method........................................................................................................................................8
Notation..................................................................................................................................8
Modelling the cube in a programming language....................................................................8
The Professor`s cube Domain Specific Language..................................................................9
Result...........................................................................................................................................9
Order of centres with block building......................................................................................9
Opposite first: Down-Up-Front.........................................................................................9
Single step edge creation (storage method).....................................................................11
Discussion.................................................................................................................................17
Centers discussion................................................................................................................17
Tredges discussion................................................................................................................18
References.................................................................................................................................19
Litterature..................................................................................................................................19
Appendix A - The cube DSL.....................................................................................................20
Appendix B - The application...................................................................................................26
Context
This project is done as a part of the DD143x course at KTH for 6 credits. The project idea came
from Johan Boye, whom is the writers supervisor, and has been refined a bit to isolate what the
writer finds to be interesting aspects of this problem.
Background
The 5x5x5 Rubik’s cube, also known as ”The Professor’s Cube”, is a variation of the original
3x3x3 cube. With 98 pieces to move around (instead of 26 as on the classic 3x3x3) it adds
complexity making it a very interesting subject to study. This essay will be about investigating
and comparing different methods for solving this puzzle.
The physical puzzle consists of blocks that can be rotated in slices around any of the x, y and zaxis in 90 degree intervals. Each plastic sticker has one of 6 colors and there are 25 of each. To
solve it one has to align upp all sides to only have one single color, as in the picture below:
Figure 1: The solved professors cube. Since all 25 stickers on each side is the same the cube is
considered solved, given that it holds for the non visible sides as well.
The main reason that this project is interesting is the widespread interest in the puzzle itself,
Rubik’s cube has had an enormous interest over the last 30 years with over 350 million cubes
sold since the introduction in the 1980s [1].
It is not for certain if the problem stated in this essay has been investigated this thoroughly in an
academic paper earlier. No such work has been found, but advice is given [6] on which methods
are faster. A possible explanation for this could be that seasoned speedcubers can make educated
guesses of which methods are better using their experience.
Problem Statement
The problem that will be examined is how variations of the solving technique will affect number
of moves required, as well as detection of problems with certain solving techniques. More
specifically it will be examined in which way it’s preferable to build the centers, as well as which
technique that is most efficient when building the first 8 tredges.
Key ﬁgures that will be of interest for these solving methods in foremost measuring the number
of turns that is required using different variations of these solving steps.
Definitions
Below is a table of definitions for terms used in this essay. Standard notation is used where
possible.
Table 1: definitions
Term
Description
Solving method
A step by step description for solving the
cube.
Turn
A turn will be interpreted as a 90 or 180
degree rotation of one slice (any outer or
inner layer).
Orientation
Describing which directions the different
stickers are on an edge or corner piece. The
same piece can be in the same position and
have different orientations.
Permutation
Relative position of pieces of the same type,
i.e. corners.
Tredge
The three pieces that builds an edge in the
reduced 5x5x5 cube. It is called a tredge when
all three pieces are aligned with correct
orientation in respect to each other.
Algorithm
A predefined set of moves that permutes and
orients pieces on the cube in a certain way.
Look ahead
When a human solves the cube he or she uses
Look ahead to predict future actions. It is a
way of saving time by planning ahead [4].
Cube rotation
This means changing the orientation of the
cube in the person solving the cube’s hands.
Solving the cube
A common way for both beginners and advanced cubers is to reduce the 5x5x5 into its 3x3x3
equivalence, meaning that solving the 5x5x5 usually contains the following steps with many
variations possible. This is in fact the preferred way to solve it for most speed cubers [5], and the
method described here has been developed by the speedcubing community and is taught in detail
using video tutorials [6].
Step one, building the 3x3 centers
Building the centers means that the 3x3 inner squares of each side should be built. Note that the
middle pieces of each side cannot move in relation to each other.
Figure 2: 3 solved centers, usually the first step in solving the 5x5x5 cube. A gray sticker means
that it is currently not interesting.
Step two, build the twelve 3x1x1 edges
When all centers are built its time to build the 3x1x1 tredges, as marked in white in the figure
below, and the positioning of the edges is irrelevant, hence the use of a neutral color. This is one
of the most time consuming steps since there are a total of 12 edges. Also keep in mind that all
centers should still be intact after this step.
Figure 3: Edges marked with white.
Fix parity errors
The 5x5x5 cube has one parity error that can occur when using this method. When the eleven
first edges are built the last one can either be correct or with its middle piece oriented incorrectly.
Figure 4: All edges solved except for the last one - this is called a parity error and is usually
solved using a standard algorithm.
When this case arrives the easiest solution is to apply a standard algorithm of 15 moves [3]
which flips the two outer edges to align the entire tredge.
Solve the reduced cube as an ordinary 3x3x3 cube
When the centers and edges are solved along with any parity error the cube can be treated as an
ordinary 3x3x3 cube by only turning the outer faces. Solving the 3x3x3 is an interesting puzzle
in its own right but it is not a part of this project so this part will not be discussed further.
Problem statement redefinition
Using the knowledge in the ”Solving the cube” section the problem statement will be redefined
with more granularity. The problem will be divided into two sub problems:
1) Is it faster to build two opposing 3x3 centers first, for example Down and Up, or is it
better to start with two adjacent 3x3 centers, such as Down and Front?
2) Is it faster to build the first 8 3x1x1-edges using the storage method where they are
assembled all three pieces at once, or is it better to build them piece by piece?
Method
The aspects of variation will be examined by simulating solving a set of problem instances with
the different variations of solving methods. To do this the chosen method will be to build a
computer program that can answer these questions.The program will be a cube simulator and
solver that can simulate a 5x5x5 cube and do the following operations:
●
●
●
●
●
Scramble the cube entirely or partially ( i.e only edges, like a 3x3x3 etc)
Solve the cube according to an externally defined algorithm (using a DSL)
Store statistics on what is happening as algorithms are run in a database
Be able to control batching of several solving methods a set of problem instances
Manually turn the faces and replay old scramble- and solving sequences of the cube using
a GUI.
The last point is a bit of a luxury function and not entirely necessary, but will facilitate
debugging and demo aspects of the project so that it is worth building.
When it comes to solving the cube an exhaustive search is not a feasible approach given its huge
number of allowed states since the total number of states exceeds 1073 [2]. Hence a different
approach is needed, and the chosen path is to define several substeps and then do local searches
in how to get from one state to the next. Each step is defined by numerous parameters all
described in Appendix A. This is how we will define the different methods, and this is where
they will different.
Notation
The notation used in the application and this essay is based on the directions Up, Front, Left,
Back, Right and Down. Turning a face clockwise is denoted using only the first capital letter of
the direction (i.e. U). Turning the inner slice is the same notation but lower case (i.e. u). Counter
clockwise is appended with a p, and a 180 degree turn is appended a 2 (but still counts as exactly
one move).
Modelling the cube in a programming language
The program built for and used in this project is has been made open source by the author (me)
and is available at https://github.com/Spacejoker/professor . The application is built in python
and the total project size including the algorithms is around 3 500 lines of code. To run the
application the user must have python, mongoDB and several python packages such as pygame
installed. Everything is described in the README.md file.
The Professor`s cube Domain Specific Language
To be able to evaluate different solving methods a Domain Specific Language has been defined,
which defines a series of solutions steps in a solving method. When a solving method has been
defined in code it can be stored externally and, if the user chooses, updated and changed.
It's main purpose is to decouple solving methods from the actual application. The DSL is a set of
JSON-compliant documents implying that they are declarative - they describe what should be
done in which order and giving options on which algorithms to use, but it does not decide which
steps to take in order to achieve the desired state. Details and definitions are in Appendix A.
The main advantage of having the solution methods decoupled from the application code base is
that they can be developed independently. Some parts have been built probabilistically using
large search-batches to find good sub steps in the methods.
Result
The results is divided into several parts depending on which variation that is examined. Isolating
different steps of the algorithm makes the results more clear and easier to understand.
Order of centres with block building
This part of the result shows how varying orders of centers will affect total move count. The
substep is started with a completely scrambled cube and is considered finished when three
centres are done and the three remaining centres are connected. The different methods have all
been tested on the same problem instances.
Opposite first: Down-Up-Front
The opposite first approach concerns building of the three first centers in the following order:
Bottom->Top->Front. The key point here is that the first and second centers are opposite, hence
the name. A detailed description of this method as well as the full results are described in
Appendix X.
A summary of the test runs done is shown in the table below.
Table 1: Opposite first results
Measurement
Total scrambles tested
Average move count
Minimum move count
Maximum move count
Value
250
74.5
58
94
Successfully solved problem instances
250 ( 100 % )
A visualization of the data is shown in the figure below. It is show that a large quantity of the
solutions were found with 65-79 moves, which is close to the average of 73.5. The tail is bigger
on the plus side, with very few solutions lower than 60 moves.
Figure 5, describing frequency of number of moves required to solve the first three centers of 250
scrambled cubes with the Opposite first-method.
Adjacent first: Donw-Front-Up
The adjacent first approach as the name suggests starts with two adjacent centers, in this case the
order is Bottom -> Front -> Up.
Summary of the results is shown in the table below.
Table 2: Adjacent first results
Measurement
Total problem instances
Average move count
Minimum move count
Maximum move count
Value
250
101.63
79
130
250 ( 100 % )
A visulaization is show below. Here it is show that there are very few solutions under 80 moves,
and most solutions requiring 95-104 moves.
Figure 6, describing frequency of number of moves required to solve the first three centers of 250
scrambled cubes with the Adjacent first-method.
Methods for tredge building
This regards the first 8 tredges that are built which is the phase where the two methods differ.
The initial state of the problem is a cube with all centers complete but all edges randomly
scrambled. The sub step is considered done when there are 8 tredges completed and all are stored
in the top and bottom layer.
Single step edge creation (storage method)
The single step edge creation method is building the tredges by first aligning three edges of the
same tredge on in the { FR, LF, BL RB } positions as well as setting up orientation. In the
following figure the outer edges are set up correctly on { LF } and { RB } while having the
center piece located at { FR }.
Figure 7: three edge pieces of the same tredge aligned correctly on { LF, RF, BR }.
The next step is to align them all using only the u and b slices.
Figure 8: the tredge is built while having the centers temporarily destroyed.
Thereafter the edge can be stored in the top or bottom layer using an intuitive algorithm. For
example storing it in { UF } can be done with [R, U, Rp].
Figure 9: the tredge is stored in the upper layer.
The last step is then to undo the set up move to restore the centers.
Figure 10: the centers restored while still having the tredge located in the U-layer.
This can then be repeated for seven more tredges, with the only difference being a different store
algorithm. The customized store algorithm is very easy to build depending on where the edge
should be stored. For each tredge that is stored the outer pieces become more and more likely to
be located in the middle layer, hence giving shorter solutions. However when there are no
tredges stored the cube can be moved more freely without destroying them so the move count is
not guaranteed to go down as more tredges gets built.
Table 3: Results for storage method
Measurement
Average move count
Minimum move count
Maximum move count
Value
250
252.75
168
308
250 ( 100 % )
We can see that there are a few samples which have much higher or lower move count than the
rest of the tests. Most problem instances wind up with a solution around 250 moves, varying
between 200 and 300.
Figure 11, result for tredges using storage method.
Building the edges piece by piece
The piece by piece building technique starts first pairing up the center part of the tredge with one
of the outer pieces. When this step is complete the last piece is added to the tredge whereafter it
can be stored in the top or bottom layer.
The first step is to get one of the edges that corresponds to the tredges center piece incorrectly
oriented in the { LF } position.
Figure 12: the first piece is set up with incorrect orientation.
It can then be brought to its correct position using a predefined algorithm.
Figure 13:Two pieces of the tredge is completed.
Then repeat this previous step for the other outer edge to complete the tredge.
Figure 14: The entire tredge is complete.
Then storing the edge can be done intuitively, in this case using [R, U, Rp].
Figure 15: The tredge is stored in the top layer.
Table 4: Results for piece by piece tredge building
Measurement
Value
250
Average move count
320.14
Minimum move count
223
Maximum move count
414
250 ( 100 % )
Most solutions are in the range of 250 to 400 with a center around 320. The best solution was
with 223 moves.
Figure 16, result for tredges piece by piece.
Discussion
The number of moves measured for the different cases should be taken with a grain of salt since
it is very implementation dependant. What is interesting is the relative counts since the
implementations of them are similar.
Centers discussion
Looking closer at the data of centers it is clear that Opposites first tend to have a lower move
count than Adjacent first. The average is over 25 moves lower for opposites first which is quite a
big difference (around 25%), and the lowest recorded is lower for Opposites first as well. A
possible explanation for this is that the third face in Adjacent first is much more restricted,
meaning that building the third face will need a lot more commutators and hence more moves.
One thing to keep in mind is that for a human using Adjacent first the look ahead and cube
rotations will probably be a lot better for the second face since it is not hidden while solving the
first face.
Tredges discussion
Comparing the two different methods it is obvious that less moves are required for the storage
method. The average differs on 80 moves which is a considerable amount since the total for
storage method have an average of 252 ( 80 is almost a third of 252 ). For learning purposes the
piece by piece method might be easier to grasp but that is of no concern in this context. The
minimum move count of 168 give indications that this method also have a quite large variation
which could be interesting for people trying to break records for time or few moves.
References
[1] William Lee Adams, The Rubik's Cube: A Puzzling Success, updated 2009-01-28,
fetched 2013-03-18,
http://www.time.com/time/magazine/article/0,9171,1874509,00.html
[2] David Singmaster, Jaap’s puzzle page, first published in a paper 1982, fetched 2013-0315, http://www.jaapsch.net/puzzles/cubic3.htm#p18
[3] Natalie, How to Solve a 5x5x5 Rubik’s Cube – Part 4 – Parity Errors, updated 2011-0622, fetched 2013-03-22, http://trinitrinkets.com/easycrafts/?p=1789
[4] Badmephisto, FIRST TWO LAYERS (F2L) , updated NOT VISIBLE, fetched 2013-0408, http://badmephisto.com/f2l.php
[5] Lucas Garron, updated 2008-08-28, fetched 2013-04-19
http://www.speedsolving.com/wiki/index.php/Reduction_Method
[6] LanceTheBlueKnight, updated 2008-08-28, fetched 2013-04-19, Rubik's 5x5 Tutorial The Reduction Method (part 2a) . https://www.youtube.com/watch?v=DQ0ylGxcsmk
Litterature
Speedsolving wiki: http://www.speedsolving.com/wiki/index.php/Main_Page
Speedsolving forum: http://www.speedsolving.com/forum/forum.php
Mathew Monroe: http://www.alchemistmatt.com/cube/5by5cube.html
Badmephisto: http://badmephisto.com/f2l.php
Appendix A - The cube DSL
The cube DSL is described in this appendix. It can give insight in how the solving methods are
constructed.
The domain specific language defines a solving method, including its name, set of commands
and which category the method belongs to. The commands is a list that is processed one by one,
and the following commands are applicable.
Command
set_moves
set_search_moves
set_mode
set_flip_algo
Description
Set the current allowed
moves as a comma separated
string. A “move” can be a
single move or an algorithm.
Only applicable while the
mode is “inner” and means
that no rotations can be done
that does not affect a sticker
of that color.
Sets the mode, can be
“edges”, “inner” or “normal”.
Affects how the application
searches, and for best result it
should be set to whatever the
current new rules change.
Used to set which algo to use
to flip edges/tredges. Only
used in some cases when
building the edges.
req (add)
req (remove)
solve
comment
Used to comment the
algorithm. This can aslo be
shown when running the
Example
{ "type" : "set_moves",
"sequence" : "rp,dp,fp U f"},
{ "type" :
"set_search_moves",
"value" : "D"},
{ "type" : "set_mode",
"value" : "inner"},
{ "type" : "set_flip_algo",
"sequence" : "R U Rp Up Fp
U F"},
{ "type" : "req", "operation" :
"add", "rule" : {"step_type" :
"inner", "block": "inner_1x1",
"color" : "D", "target_color" :
"D", "rule_id" : "10001"}},
{ "type" : "req", "operation" :
"add", "rule" : {"step_type" :
"inner", "block": "inner_1x1",
"color" : "D", "target_color" :
"D", "rule_id" : "10001"}},
{ "type" : "solve" }
{ "type" : "comment", "value"
: "Bottom correcto" },
application.
Below is an example of an algorithm that solves the first 3x3 face on the bottom as well as the
3x3 on the top. All algorithms are available at github: https://github.com/Spacejoker/professor
{ "name" : "algorithm name",
"commands" : [
{ "type" : "set_moves", "sequence" : "rp,dp,fp,B2,d2,F,u2,r2,Dp,Fp, b U bp,b,rp U
r,Bp,f2,F2,L,d,b2,R2,fp U f,L2,up,D2,B,lp,f,bp,l,u,L,Rp,R,D,Lp,U2,U,r"},
{ "type" : "set_search_moves", "value" : "D"},
{ "type" : "set_mode", "value" : "inner"},
{ "type" : "set_flip_algo", "sequence" : "R U Rp Up Fp U F"},
{ "type" : "req", "operation" : "add", "rule" : {"step_type" : "inner", "block": "inner_1x1",
"color" : "D", "target_color" : "D", "rule_id" : "10001"}},
{ "type" : "solve" },
{ "type" : "set_moves", "sequence" : "B,L,L2,B2,r U rp,Fp,rp U r,dp,bp,R2,D,l2,U2,F,R, b U
bp,Lp,rp,lp,u2,up,Bp,fp U f,f,fp,D2,d2,d,bp U b,L,r,Rp,F,u,f2,l,b2,U,r2,F2,Dp,b"},
"color" : "D", "target_color" : "Any", "rule_id" : "10002"}},
{ "type" : "set_moves", "sequence" : "R2,fp U f,b,U,d,f,dp,F,l,R,rp,Dp,b2,Bp,F,r U
rp,L2,Lp,u,lp,d2,F2,fp,Fp,U2,bp,Rp, b U bp,B,f2,bp U b,D2,r2,r,up,B2,L,rp U r,D"},
"color" : "D", "target_color" : "U", "rule_id" : "10003"}},
{ "type" : "req", "operation" : "remove", "rule_id" : "10002"},
{ "type" : "set_moves", "sequence" : "B,B2,Dp,L,bp,f,l,b2,Rp, b U bp,f2,fp U f,Lp,L2,dp,lp,rp
U r,F,R2,R,B,D2,b,up,F2,r2,fp,l2,r,u2,r U rp,u,U2,bp U b,d,Bp,rp,F,Fp,D,U"},
{ "type" : "set_moves", "sequence" : "Fp,U2,u2,dp,D2,fp,d,l2,F,F2,R,d2,Bp,Rp,fp U
f,l,Dp,f2,L,Lp,up,r,R2,B2,L2,U,u,rp U r,bp,bp U b,B,rp,b,B,lp,r U rp,r2,b2, b U bp,f"},
{ "type" : "set_moves", "sequence" : "Fp,U2,u2,dp,D2,fp,d,l2,F,F2,R,d2,Bp,Rp,fp U
f,l,Dp,f2,L,Lp,up,r,R2,B2,L2,U,u,rp U r,bp,bp U b,B,rp,b,B,lp,r U rp,r2,b2, b U bp,f"},
"color" : "D", "target_color" : "F", "rule_id" : "10005"}},
{ "type" : "set_moves", "sequence" : "d,Dp,F2,B,F,rp U r,L,D2,rp,up,Bp, b U
bp,r,l,d2,L2,Lp,L,b,u,Rp,fp,dp,u2,r U rp,b2,Fp,B,F,bp U b,l2,R,U2,R,r2,B2,bp,R2,fp U
f,f2,f,D,lp"},
{ "type" : "set_moves", "sequence" : "U, U2, Up, u, up, u2, d, dp, d2, F, F2, Fp, r, rp"},
{ "type" : "req", "operation" : "add", "rule" : {"step_type" : "inner", "block":
"inner_1x1_corner", "color" : "D", "target_color" : "F", "rule_id" : "10011"}},
{ "type" : "set_moves", "sequence" : "L2,l,rp,Lp,fp,r U rp,D2,b2,B2, b U bp,l2,f,R2,b,r,u2,bp
U b,rp U r,Rp,Bp,fp U f,r2,B,Dp,F2,L,U2,lp,D,R,F,dp,bp,f2,up,d2,d,u,U"},
{ "type" : "set_moves", "sequence" : "L, R, F, B, r U rp,b U bp, f U fp, l U lp, rp, U r, bp U b,
fp U f, lp U l,r, l, f, b"},
"color" : "D", "target_color" : "U", "rule_id" : "10007"}},
{ "type" : "set_moves", "sequence" : "U, U2, u2,Bp,Fp,B2,L2,d,R,rp,f2,dp,Dp,r,Lp,L,bp U
b,u,rp U r,b,fp U f,F2,bp,r U rp,f,lp,l,F,b2,R2,l2,B,D,up,B,Rp,d2,r2,U2,fp"},
{ "type" : "set_moves", "sequence" : "Dp,Fp,d2,L,l,up,fp U f,u2,bp U b,L2,dp,rp U
r,R,bp,b,r2,Bp,B,F,Lp,F2,D2,d,r,u,D,f,U, b U bp,r U rp,lp,f2,fp,Rp,l2,rp,R2,B2"},
"color" : "D", "target_color" : "F", "rule_id" : "10009"}},
{ "type" : "set_moves", "sequence" : "Dp,l,fp,Fp,b2,D2,B2,rp U
r,f2,u2,r2,R,U,Bp,Lp,b,lp,B,D,F2,l2,r U rp,bp U b,R2,bp,Rp, b U bp,U2,L,rp,u,r,f,up,dp,F,d,d2"},
{ "type" : "comment", "value" : "Bottom correcto" },
{ "type" : "set_moves", "sequence" : "r U rp,rp U r, b U bp,bp U b,fp U
f,F,R,L,B,Fp,Rp,Lp,Bp"},
{ "type" : "set_search_moves", "value" : "U"},
{ "type" : "set_mode", "value" : "inner"},
"color" : "U", "target_color" : "U", "rule_id" : "20001"}},
"color" : "U", "target_color" : "Any", "rule_id" : "20002"}},
{ "type" : "set_moves", "sequence" : "r U rp,rp U r, b U bp,bp U b,fp U
f,F,R,L,B,Fp,Rp,Lp,Bp,u,d"},
"color" : "U", "target_color" : "F", "rule_id" : "20003"}},
{ "type" : "set_moves", "sequence" : "r U rp,r Up rp, lp U l, lp Up l,F,Fp, U, Up"},
{ "type" : "set_moves", "sequence" : "F,Fp,L,Lp,B,Bp,R,Rp,u,up,d,dp,u u,d d"},
{ "type" : "set_moves", "sequence" : "r U rp,r Up rp,lp U l,lp Up l,Fp,F,U,Up"},
{ "type" : "set_moves", "sequence" : "F,Fp,L,Lp,B,Bp,R,Rp,u,up,d,dp,U, Up, rp F F r"},
{ "type" : "req", "operation" : "add", "rule" : {"step_type" : "inner", "block":
"inner_1x1_corner", "color" : "U", "target_color" : "L", "rule_id" : "20011"}},
{ "type" : "set_moves", "sequence" : "r U U rp,lp U U l,F,U,Up"},
{ "type" : "comment", "value" : "done" }
],
"category" : "f3x3"
}
Appendix B - The application
The graphical interface where it is possible to review solving sequences created in batch mode.
Source available at https://github.com/Spacejoker/professor .

Kandidatexamensarbete vid CSC, KTH

Transcription

Similar documents

Unbridle Your True Self

CyberDream 11 x 17 poster.cdr

Too harsh? Bottoming? Trouble in the whoops?

as PDF

Nicole Moneer

Solenne Bouchard Maeve Brennan Salvatore Cingari Sofia Cingari

Hexominoes 1 - Learning can be fun

PLANT HANGER.idw - Big Rivers, Ltd.

Zaxby`s Licensee Finds Easier Route and Cost Savings

DEAN GRAZIOSI - Winning State of Mind