# What is the optimal strategy for 2048?

I’ve tried a few approaches, but I just can’t make a tile with 2048

## 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 8`part 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. `left`and `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 a bad thing.
• Blocking your field with alternating `2` and `4` tiles
This is relevant 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 `2`s and `4`s, which basically kills you. Make sure you can combine as many tiles as possible with each move when your field approaches 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.