# What is the optimal strategy for this game?

I've tried a few approaches, but I just can't make a tile with 2048 Numbers Clash ( http://www.numbersclash.com )

-
Related SO question – Unionhawk Mar 19 '14 at 4:51
@Unionhawk , thanks for the info, but I guess it's more related to a programming point of view. cheers – André Lucas Mar 19 '14 at 4:54
Be advised that the original version is hosted here: gabrielecirulli.github.io/2048 – Anzeo Mar 27 '14 at 9:33

## The key

... to all merging/matching/combining games like this is creating what's called immutable subsets. I'll explain what this means using 2048, but it really applies to most, if not all, of the games similar to it in nature.

## Intermission

An immutable subset is a collection of tiles that don't change (in this case move) within a specific set of rules. Usually this comes with a restriction on the input commands you can use and the immutable subsets with respect to the different input commands can be different. Let me give you an example:

2  2  4  8

2     2
2

The 2 4 8part of the top row is immutable with respect to up and the 4 8 part is immutable w.r.t. right. The 2 in the bottom right corner is immutable w.r.t. down and right.

In sum, the immutable subsets w.r.t. each input are:

• up: the 2 4 8 block in the top row
• down: the 2 in the bottom right corner
• left: nothing
• right: the 4 8 block and the 2 in the bottom right corner

## Solving algorithm

Understanding immutable subsets is basically all you need. From there on, the trick is to use only such input commands that include your highest tile in an immutable subset. This way, the highest tile will remain in the same spot no matter what you do. Pick a corner, build a high tile there and make sure it's always part of an immutable subset from then on. The only exception is when you actually created another tile of same value next to it and merge them to get one step further. In this case, though, make sure the location of the new highest tile is the same as that of the old highest tile.

To actually do this, you will need a preference order of keys you use. One key will be the one you use most of the time, another one nearly as often. Those are the keys that point towards the corner you picked earlier. The key you use most often will result in the creation of an immutable subset along an entire border of the field w.r.t. the inputs perpendicular to the first one. For example, if you choose the bottom left corner and down over left, then you will soon have an immutable subset along the bottom row w.r.t. left and right. This puts right as the third key in you preference order and means the last key, which you will want to avoid as much as possible, is up.

Respecting this preference order, the second trick to solve the puzzle is to build consecutive chains, that is, tiles with values decreasing one step each, one next to the other. This chain can be along borders, usually in a snake formation, but can also go inside the field. What's important is that this chain or most of it should be part of your immutable subset. So basically, you're building a tile of one step less than your highest value tile next to it in such a way that they don't move around.

## The problems

Sometimes it just happens that the entire field is immutable w.r.t. some direction and mutable to all others. An example of such a field would be this:

32 16 8
16 8  4
8  4

This is completely immutable w.r.t. up and left, but entirely mutable w.r.t. down and right. This is one of those cases where you have to gamble and hope your highest tile is not blocked by the newly spawned tile.
If it is, however, there are ways to recover. Explaining them in detail would go beyond the scope of this answer, but the basic strategy is to get the highest tile immutable w.r.t. the direction opposite of the border it touches (so if it's at the left, make it immutable w.r.t. right) and have all tiles to either side of it mutable, then execute that command and in the next step, move it back into the now free corner. An example of this setup is this:

2  32 16 8
16 8  4
8  4
2

This could be a lucky result from going left after a 2 appeared in the wrong place when going right in the previous example. Now, going down will result in the top row holding only the 32 and possibly a random spawn, so you can move the 32 back to either the top right or top left corner.

## Common mistakes

While purely subjective and based solely on personal experience, I'll give you some things to look out for which I feel are done wrong often, even if you try to apply the strategy described here. Avoiding those can be the key to reaching the next level.

• Merges in your "immutable" row/column
You carefully built your immutable row with the highest and some other tiles so that it's immutable w.r.t. leftand right(or accordingly with a column), so you know you are free to use both of those commands. Then a tile in said row becomes the same as another one, you don't pay attention, hit the wrong direction and the tiles merge, moving you highest tile out of the corner! Make sure to go towards the corner if your row ever gets a double tile. You can get away with it, you can also recover (see previous section), but it's better to avoid this altogether.
• Trying to keep the immutable row/column at all costs
It's not only possible, but also advisable to sometimes switch from row to column. The only really important thing is that your highest tile remains in its corner. Sometimes you reach a state where the highest tile is absolutely immutable (w.r.t. all commands). That's generally a good time to think about switching your direction. Don't forget to also adapt your command preference order!
• Trying to use up high tiles at all costs
Picture this situation: Your highest tile sits at 256 and you have a 128 tile somewhere, but not close enough. You then get another 128 tile next to your 256 tile and desperately try to get the first 128 closer in order to merge them and get to 512. In the process, lots of low tiles spawn and soon, your field is all clogged up. Sometimes, you just can't use some tiles. Sometimes, you actually get a second one of the highest tile, but in the wrong place, because you just had to recover from a mistake or unlucky spawn as described in the previous section. Unless we're talking about 1024 tiles, it's usually the best idea to just leave it there, continue building up the rest of your field and use it once it comes in handy. Don't force anything, having high tiles hanging around is not as bad thing.
• Blocking your field with alternating 2 and 4 tiles
This is relevent when you reach a point when your field is nearly full. At this point, it's very important to not block your tiles. Moving into the wrong directions can mean you get a pattern of alternating 2s and 4s, which basically kills you. Make sure you can combine as many tiles as possible with each move when your field nears the point of being full. Also, make sure to move your last rows so that you can immediately recombine the spawning 2.

That's all I can give you, if you stick to this strategy and make sure you avoid the mistakes, winning should be a matter of time. Due to the random nature of the game and the occurence of situations where you must break the pattern, you just can't win sometimes. Keep trying and the strategy described here should help you win something between 10 and 60 percent of your games. It all comes with experience.

-
I wrote an article recently covering these basic rules in a "human" digestible manner. gameskinny.com/lnagr/… I think it works well with your guidance above and I've linked from the article. – GL_Stephen May 6 '14 at 19:32

I have been following the instruction from the link below:

Managed to get to a 4096 tile and I think it is possible to do a 8192, see the screenshot.

-
Every time you pause the video to get the URL, mentioned in the video, it is covered up by an add. For those curious URL is ov3y.github.io/2048-AI – spuder Mar 21 '14 at 22:26
You might want to extract the relevant info from the video and actually write it down. If the video goes down in the future, this answer will become utterly useless. – scenia Mar 25 '14 at 9:13

My strategy is to make a number one before the current (eg if the current highest is 4096, make 2048). Then make the one before that, and repeat until you have an easy one to get 2 of. Make 2, then combine the 2 to make a higher one, repeat until you have 2 of the highest number, combine them, and you have a new highest number. Hope this helps. :D

-