Welcome to the Speedsolving.com, home of the web's largest puzzle community! You are currently viewing our forum as a guest which gives you limited access to join discussions and access our other features.

@oranjules: Wow, 10-11 tps... I can press keys pretty fast but I'm not really used to going fast on the arrow keys. And your method is kinda weird, I'm honestly not quite sure what you are doing a lot of the time.

@oranjules: Wow, 10-11 tps... I can press keys pretty fast but I'm not really used to going fast on the arrow keys. 2) And your method is kinda weird, I'm honestly not quite sure what you are doing a lot of the time.

On large puzzles, you can group tiles and move 'snakes' instead of single tiles. This is much faster than moving tiles one-by-one.

With grouping the tiles, learning many cases can probably improve speed. (E.g., how to move up three consecutive tiles in row? Or what to do if you almost solved 16x16 but just noticed that tiles 1 and 2 are swapped?)

One more possibility is to reduce NxN puzzle to (N-1)x(N-1) puzzle. You solve fringe tiles (1,2,3,4,5,9,13), then fringe tiles of remaining 3x3 puzzle (6,7,8,10,14), then cycle remaining 2x2 puzzle. Potentially it is faster but it requires faster thinking / memorizing the sequence of tiles (not in numerical order).

On large puzzles, such as 16x16, this method is definitely faster but harder to execute (for example, see Ben's video in this thread).

One more improvement over this method is to reduce (NxN) to (N-2)x(N-2) ("two layers at a time") but I haven't tried this.

- Bulat

Edit: To all: I have a question regarding the coloring of tiles. In the current implementation of the timer, there are two colors A and B for even and odd tiles. I thought about some other potentially useful ways to color the tiles:

1) Tiles from odd columns (or rows) with color A; tiles from even columns (or rows) with color B;
2) Already solved rows with color A; tiles from the first unsolved yet row with color B; all remaining tiles with color C;
3) Already solved tiles with color A; tiles from the first unsolved yet "fringe" with color B; all remaining tiles with color C;

Spoiler: Example

1

2

3

4

5

6

7

13

8

10

11

12

9

15

16

17

19

14

20

21

22

18

23

24

4) Solved tiles with color A; unsolved tiles with color B;
5) Without coloring at all (all the tiles with color C);
6) Something else?

Such modification could be useful to learn the particular cases, to improve speed etc. However, on "real competitions" some may consider it as being "against rules" because it simplifies the solving.

This is what we already do, right? It may be useful to have some kind of plaid design with 4 colors: A for even row/even column, B for even row/odd column, etc. etc.

2) Already solved rows with color A; tiles from the first unsolved yet row with color B; all remaining tiles with color C;
3) Already solved tiles with color A; tiles from the first unsolved yet "fringe" with color B; all remaining tiles with color C;
4) Solved tiles with color A; unsolved tiles with color B;

I would actually like to have a different color on each row. You could either keep a list of different colors (max 16, so it's not too hard) or use a function like this:

Code:

// return an array of x different colors
function getColors(x) {
var colors = [];
for (var i=0; i<x; i++) {
h = 6 * i/x;
w = Math.floor(h);
f = h - w;
color = "#";
if (w==0) {
color += "FF" + strHex(f) + "00";
} else if (w==1) {
color += strHex(1-f) + "FF00";
} else if (w==2) {
color += "00FF" + strHex(f);
} else if (w==3) {
color += "00" + strHex(1-f) + "FF";
} else if (w==4) {
color += strHex(f) + "00FF";
} else {
color += "FF00" + strHex(1-f);
}
colors.push(color);
}
return colors;
}
// float from 0 to 1, multiplied by 256, to string hex
function strHex(n) {
x = Math.floor(n*256);
if (x>255) x=255;
return "0123456789ABCDEF"[Math.floor(x/16)] + "0123456789ABCDEF"[x%16];
}

This is what we already do, right? It may be useful to have some kind of plaid design with 4 colors: A for even row/even column, B for even row/odd column, etc. etc.

Not exactly. Coloring odd/even tiles and coloring odd/even columns looks the same when the width of the puzzle is even. For puzzles with odd width (5x4, 7x7, 3x6) it's two different coloring schemes.

Edit: ninja'd by vcuber13.

As for your idea of having 4 colors, I'd agree. I've seen somewhere designed in such way real 4x4 puzzle (maybe on Jaap's site).

Yeah, it's true, and it's the whole point of having such scheme You see what tiles you're solving at the moment. During learning, it may be useful, but it's most likely not fair when competing.

I would actually like to have a different color on each row. You could either keep a list of different colors (max 16, so it's not too hard) or use a function like this:

v5.2 is released. Multiple coloring schemes are included. A short description:
- Alt XXX = Alternate XXX (interleaving odd and even);
- Live XXX are coloring schemes where the colors of tiles would change during a solve to show current progress;
- Multi XXX are schemes where there is a different color on each row/column/fringe level (qqwref's function is used);
- Mono is scheme with only one color;
- Plaid is scheme with four colors.

Note that Live schemes are rather slow on large puzzles. This is because after each move, all tiles are re-colored. It is possible to optimize the code but I have not yet as Live schemes are anyway "against rules" for at least two reasons

I've had to add two colors to existing two colors in each of color sets. Please comment if you think some colors are chosen poorly (and add your suggestions of better colors).

if (color_scheme == 'mr') return getColors(puzzle.h)[homerow];
if (color_scheme == 'mc') return getColors(puzzle.w)[homecol];
if (color_scheme == 'mf') return getColors(maxf)[maxf - 1 - homef];

It would save some time to either store the result of getColors (updating when the puzzle size or color scheme is changed), or to just not compute the whole array each time, e.g.

Code:

// return the i'th color out of x possible colors
function getColor(x, i) {
h = 6 * i/x;
w = Math.floor(h);
f = h - w;
color = "#";
if (w==0) {
color += "FF" + strHex(f) + "00";
} else if (w==1) {
color += strHex(1-f) + "FF00";
} else if (w==2) {
color += "00FF" + strHex(f);
} else if (w==3) {
color += "00" + strHex(1-f) + "FF";
} else if (w==4) {
color += strHex(f) + "00FF";
} else {
color += "FF00" + strHex(1-f);
}
return color;
}