Modified random moves generator

src/main/kotlin/be/nielandt/CrossSolver.kt

@@ -35,34 +35,25 @@ open abstract class CrossSolver {
  * - new version, optimised now avoid recalc:       47s, 21s, 34s, 14s,  (401592291, 147023415, 67382002, 67381995)
  */
 fun main(args: Array<String>) {
+    /**
+     * choose your moves, fixed or random?
+     */
+//    val moves = parseMoves("U2 F2 U2 D R2 F2 R2 B2 U' D2 L B L2 U2 L B' U L R B".replace('\'', '_'))
+    val moves = randomMoves(10)
 
-    // do a fixed scramble for testing purposes
-    // noskip Move.enum 30s, skip Move.enum 32s
-//    val fixedMoves = parseMoves("L_, D, U, L2, F, D, B, D, U2, D, B_, F2, D2, U_, R, D2, R_, L, B_, R")
-    val moveString: String = "U2 F2 U2 D R2 F2 R2 B2 U' D2 L B L2 U2 L B' U L R B".replace('\'', '_')
-    val s = "L_, D, U, L2, F, D, B, D, U2, D, B_, F2, D2, U_, R, D2, R_, L, B_, R"
-
-    val fixedMoves = parseMoves(moveString)
-    println("fixedMoves = ${fixedMoves}")
-    // scramble random
-    val randomMoves = randomMoves(20)
-
-    val moves = fixedMoves
     println("Scramble: ${moves.map { decodeMove(it) }}")
 
-
     val usedModel = EdgeModel.withMoves(moves)
     println(usedModel)
 
-
-    val upgradedSolve = CrossSolverUpgraded().solveCrossesTimed(usedModel)
-    CrossSolver.printResults(upgradedSolve)
-
-    val upgradedSolveSkip = CrossSolverUpgradedSkip().solveCrossesTimed(usedModel)
-    CrossSolver.printResults(upgradedSolveSkip)
-
-    val solveCrossesTimed = CrossSolverIterator().solveCrossesTimed(usedModel)
-    CrossSolver.printResults(solveCrossesTimed)
+//    val upgradedSolve = CrossSolverUpgraded().solveCrossesTimed(usedModel)
+//    CrossSolver.printResults(upgradedSolve)
+//
+//    val upgradedSolveSkip = CrossSolverUpgradedSkip().solveCrossesTimed(usedModel)
+//    CrossSolver.printResults(upgradedSolveSkip)
+//
+//    val solveCrossesTimed = CrossSolverIterator().solveCrossesTimed(usedModel)
+//    CrossSolver.printResults(solveCrossesTimed)
 
     val s3 = CrossSolverIteratorUpgraded().solveCrossesTimed(usedModel)
     CrossSolver.printResults(s3)

src/main/kotlin/be/nielandt/Move.kt

@@ -26,7 +26,7 @@ const val L2 = 16
 const val R2 = 17
 
 fun decodeMove(i: Int): String {
-    return when(i) {
+    return when (i) {
         F -> "F"
         B -> "B"
         U -> "U"
@@ -55,7 +55,7 @@ fun decodeMove(i: Int): String {
 }
 
 fun classOf(move: Int): Int {
-    return (move%6) / 2
+    return (move % 6) / 2
 }
 
 fun parseMoves(s: String): IntArray {
@@ -91,10 +91,46 @@ fun parseMove(s: String): Int {
     }
 }
 
+/**
+ * Get a proper scramble set of moves. Disallow the obvious symmetries.
+ */
 fun randomMoves(amount: Int): IntArray {
     val rgen = Random()
-    return IntArray(amount) {
-        rgen.nextInt(18)
+    val result = IntArray(amount)
+    for (i in 0 until result.size) {
+        // create valid options for the next one
+        val options = mutableListOf<Int>()
+        if (i == 0) {
+            // all options
+            options.addAll(0..17)
+        }
+        // if there's two before us, we can't add a third of the same class
+        else if (i > 1 && classOf(result[i - 1]) == classOf(result[i - 2])) {
+            options.addAll(
+                    (0..17).filter { classOf(it) != classOf(result[i - 1]) }
+            )
+        } else {
+            // all options except the previous one
+            // also disallow same-face solutions
+            options.addAll(
+                    (0..17)
+                            // can't be the same face move
+                            .filter {
+                                it % 6 != result[i - 1] % 6
+                            }
+            )
+        }
+        result[i] = options[rgen.nextInt(options.size)]
     }
+    return result
 }
 
+fun main(args: Array<String>) {
+    printMoves(randomMoves(50))
+}
+
+fun printMoves(moves: IntArray) {
+    println(moves.map { decodeMove(it) }.joinToString(","))
+}
+
+