Edit - Code Golf Stack Exchange

You are not logged in. Your edit will be placed in a queue until it is peer reviewed.

We welcome edits that make the post easier to understand and more valuable for readers. Because community members review edits, please try to make the post substantially better than how you found it, for example, by fixing grammar or adding additional resources and hyperlinks.

Required fields*

Rev

Required fields*

Tips for golfing in 05AB1E

Do you have any tips for code-golfing in 05AB1E, a golfing language created by Adnan?

Your tips should be at least somewhat specific to 05AB1E.

Please post one tip per answer.

Answer*

Since it wasn't part of the [Wiki on 05AB1E's GitHub pages](https://github.com/Adriandmen/05AB1E/wiki) (I think it should), I'm just gonna add it here now that I better understand it myself.

#How to use the dictionary?

05AB1E has the following [words.ex dictionary file](https://github.com/Adriandmen/05AB1E/blob/master/lib/reading/dictionary/words.ex) containing all the words it knows. But how do we access the words in this dictionary? Let's take the word `"testing"` as example:

`"testing"` can be found on row 1453 of the dictionary file. Since the first two lines aren't words, and we need the 0-indexed word, we subtract 3. 
So, now we have the index (`1450`), but how to use it?

We open and start a compressed string with `“`*†*. We then look at the second column of the [info.txt file](https://github.com/Adriandmen/05AB1E/blob/master/docs/info.txt). (So `€` is 00; `‚` is 01; etc.) 
In the case of `"testing"` this means `î` (14) and `»` (50).

The compressed String for `"testing"` is therefore: `“î»“` [Try it online.](https://tio.run/##MzBNTDJM/f//UcOcw@sO7QZS//8DAA) As with almost all 05AB1E pieces of code, the trailing `“` is optional if you don't access the string, so [without works as well in this case](https://tio.run/##MzBNTDJM/f//UcOcw@sO7f7/HwA).

**Some things to note:**

All characters that doesn't have any index in the info.txt file can be used as is. This can be useful for adding an `s` to output a plural instead of singular word or use punctuation like `,.?!` for example. 
`ÿ` (string-interpolation) can also be used when you want to insert values from the stack within the string. 
NOTE: Every loose character that doesn't have any index in the info.txt file counts as a word for the compression types below.

*†* There are different types of compressed strings you can use:

- `'`: Take a single compressed word as is (no trailing `'` required) - [`'î»`](https://tio.run/##MzBNTDJM/f9f/fC6Q7v//wcA): "testing"
- `„`: Takes two compressed words with space delimiter (no trailing `„` required) - [`„î»î»`](https://tio.run/##MzBNTDJM/f//UcO8w@sO7Qbh//8B): "testing testing"
- `…`: Takes three compressed words with space delimiter (no trailing `…` required) - [`…î»î»î»`](https://tio.run/##MzBNTDJM/f//UcOyw@sO7Ybh//8B): "testing testing testing"
- `“`: Take the compressed string with space delimiter - [`“î»î»“`](https://tio.run/##MzBNTDJM/f//UcPMw@sO7QZhIPP/fwA): "testing testing"
- `’`: Take the compressed string as is without implicit spaces - [`’î»î»’`](https://tio.run/##MzBNTDJM/f//UcPMw@sO7Qbh//8B): "testingtesting"
- `”`: Take the compressed string in title-case with space delimiter - [`”î»î»”`](https://tio.run/##MzBNTDJM/f//UcPcw@sO7QZhIPP/fwA): "Testing Testing"
- `‘`: Take the compressed string in full uppercase with space delimiter - [`‘î»î»‘`](https://tio.run/##MzBNTDJM/f//UcOMw@sO7QZhIPP/fwA): "TESTING TESTING"

Here a useful program to get the compressed string based on a space-delimited input of words:

 '“? lAð«Ã#¸˜ vyU "€‚ƒ„…†‡ˆ‰Š‹ŒŽ•–—™š›œžŸ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîï" Dâ vy"“ÿ“".V XlQi y?1#] '“,

###[Try it online.](https://tio.run/##FZC5TgJRGEZf5WYobIyRwppofAAtNDYWmFCYkJhQmNBdAXHfADdEZAYYVgF3QIHk@3JteIv/RcaxOTntOfML4a1gxPNmRBdCKrrIHlpMBtCfFtRufE1ZkmiLzv9mRBdFu6JLou1pWnTP@DYwGTMS7YjOis5JyjG26KHJmrHpw4aDMiqowkUNdTTQRAttdNBFDy94xRve8YFPfKGPAYb4xg9GGGNCzT0mmGSK@0zzgIc84jFPeMoznvOCl7xihlnmeM0b3vKO98zzgQU@ssgnlmjTYZkVVumyxjobbLLFNp/ZYddSy3T8Psuv5sSHNbeuNqKr2yoeCgY21f@NWc9b2YmGY2opEo79AQ)

This program will:

1. Take the input as lowercase, removes any non-alphabetic characters (except for spaces), and then splits the words by spaces (`lAð«Ã#`), or wraps the words in a list if only a single word was inputted (`¸˜`)
2. Loops over each word (`vyU`)
3. Then has an inner loop over each compressed word from the dictionary (`"€...ï"Dâvy`), which it will try to run as 05AB1E program (`"“ÿ“".V`)
4. And if it's equal to the current word it will print it and break the inner loop `XlQiy?1#`

With an input `good bye world` the output would therefore be `“‚¿Þ¡‚ï“`. [Try it online.](https://tio.run/##FZC5TgJRGEZf5WYobIyRwpqY@AIWGhsLCcSYkJBYaOiugLhvgBsiMsO@CLgDCiTfl2vDW/wvMo7NyWnPmV/YCPrDrjsjOh9QkUX20GLCh/40r3ZiK8qSeFt07jctuiC6Kroo2p6mRPeMZwOTNiPRjuiM6KwkHWOLHpqMGZs@bDgooYwKqqihjgaaaKGNDrro4QWveMM7PvCJL/QxwBDf@MEIY0youcc4E0xynyke8JBHPOYJT3nGc17wkldMM8Msr3nDW97xnjk@MM9HFvjEIm06LLHMCqussc4Gm2yxzWd22LXUEh2vz/KqOfFgza2qtcjylooF/L519X9j1nU3o9GQCsbCaje6HQn9AQ)

NOTE: You'd still have to see if the word exist in the dictionary in order for this generator to work, and it will ignore any special characters or plural words. Only the words that are exactly the same in the dictionary will be found.

[Here an example where I use `…Ÿ™‚ï!` for the string "hello world!" and `’‚¿Þ¡ ÿ ‚ï!’` for the string "goodbye ÿ world!".](https://codegolf.stackexchange.com/a/170983/52210) Note how the spaces and exclamation mark are used as is, because they don't have indices in the info.txt file. In addition, it uses `ÿ` to insert the "cruel" that was at the top of the stack, which unfortunately wasn't part of the dictionary (but was still compressed using the method at the section below).

#How to compress strings not part of the dictionary?

Although the words.ex dictionary file is pretty big (10,000 words to be exact), it can happen that you need a word which isn't part of it, or a string which is just plain gibberish. So is there a way to compress those as well? 
There certainly is, by using `.•`, which is a compressed base-255 alphabet based string. NOTE: This method can only be used for characters in the lowercase alphabet and spaces.

Here is a useful program to convert a word/string to the compressed base-255 alphabet based string:

 vAyk})> 27β 255B ".•ÿ•"

###[Try it online.](https://tio.run/##MzBNTDJM/f@/zLEyu1bTTsHI/NwmBSNTUycFJb1HDYsO7wcSSv//J@fnFhSlFhcrpOfnF6cCAA).

What this program above does is:

- `vAyk})>`: Take the 1-indexed alphabet indices of the individual letters of the input, with spaces becoming index 0
- `27β`: Convert these indices from base 27 to a single number
- `255B`: Convert this number to Base-255 using 05AB1E's own code page
- `".•ÿ•"`: Places a leading `.•` and trailing `•` before this compressed string

[Here an example answer where *@Kaldo* uses `.•zíΘ•` to compress the word "goose".](https://codegolf.stackexchange.com/a/157910/52210)

#How to compress large integers?

Let's say we want to use a very big number for something, but it can't really be retrieved by pow-calculations. For example, let's say we want to access the large integer `18238098189071058293` for whatever reason.

In this case we can use both a leading and trailing `•` to compress a number in the format `[1-9][0-9]+`. 
The example number above will become `•15Y₁Ò'Θpc•`. [Try it online.](https://tio.run/##MzBNTDJM/f//UcMiQ9PIR02Nhyepn5tRkAzk//8PAA) Again, just like with the compressed dictionary string, [the trailing `•` can optionally be removed](https://tio.run/##MzBNTDJM/f//UcMiQ9PIR02Nhyepn5tRkPz/PwA).

Optionally, when the integer is small enough so only 2 compressed characters have to be used, we can use `Ž` instead, in which case we won't need a trailing byte to close it and the integer is compressed in 3 bytes instead of 4. For example, the integer `13562` would result in [`•rl•`](https://tio.run/##yy9OTMpM/f//UcOiohwg8f8/AA), but because it only uses two characters, it can be [`Žrl`](https://tio.run/##yy9OTMpM/f//6N6inP//AQ) instead.

Also, numbers in the range `[101, 355]` can be compressed in 2 bytes using `Ƶ` plus an additional character from 05AB1E's codepage. So for example, [`Ƶ–`](https://tio.run/##yy9OTMpM/f//2NZHDZP//wcA) can be used for the integer `250`. [Here an overview of all available numbers.](https://tio.run/##DZBpU1JhGIb/CtFeZlrZvmf7bmV7LmX7vlhWNC9HRLRsASpUIBZFEVK2A4d95rk5NJMz79BfeP4I8e2eueb6cN0tbT29rX31OqUpIlVjVUXZ2N7cyWLCJINSM/UPdHQbUTaw1W5ooKZ6/Y/nr13GZUImZUqqMi0zUqslalqtUCv@U6RDOqVLZhtymEd8bBtl2xjbvKyYWVFYGWTFwsoQK1bDEuPSZctXrFy1es3apnXN61taN2zc1LZ5y9Zt23fs3LV7z959@w@0Hzx0@MjRY8dPnDx1@szZjnPnL3RevHT5ytVr1290dff03rzVd/vO3Xv3Hzx89PjJ02fPX7x81f/6zcDbd@9NH6oqK1E52Qip2ll4WYRY@Fj4F60sYnpjZXV7xaoXq@mKYOFiMc7CzcLDwsHCuehmS0D3s8jpjsqwXtK1ipn8FKAgTdE0hWiGZilMcxShqMzTPC1QjOKUoCSlSG2cmSGNspSjPBWoSCUqQ8AMBYOwYAhWDMOGEYziIz5hDJ/xBV/xDXY44MR3/MBPuDCOCUzCDQ@8@AUf/AggiClMI4QZzCKMOUQQxW/MYwExxJFAEimoSCMDDVnkkEcBRZRQ/g8) These characters are converted from Base-255 to Base-10, and then 101 is added (since the numbers in the range `[0,100]` are already 1 or 2 bytes).

How are these `15Y₁Ò'Θpc` and `rl` created? Very simple, the number is converted to Base-255 using 05AB1E's own codepage. So you can use the following program to get a compressed number, for which it will then use `Ƶ.`, `Ž..`, or `•...•` depending on the size of the compressed integer:

 101 355Ÿså i 101-255B"Ƶÿ" ë 255B Dg2Qi "Žÿ" ë "•ÿ•"

###[Try it online.](https://tio.run/##yy9OTMpM/f/f0MBQwdjU9OiO4sNLFTIVgFxdI1NTJ6VjWw/vV1I4vFoBxFNwSTcKzFRQOroXKqj0qGHR4f1AQglogoWRsYWBpYWhhaWBuaGBqYWRpTEA)

[Here an example answer where *@Emigna* uses `•3Èñ•` for the integer `246060`.](https://codegolf.stackexchange.com/a/164461/52210)

#How to compress integer lists?

Sometimes you want to compress an entire list of integers instead of a single number. For example, let's say we want the list `[5,94,17,83,4,44,32,19,4,45,83,90,0,14,3,17,17,81]` for whatever reason. In this case, we can use the following instead: `•5O›YJ&p‘ÑÎ!6¯8,•₃в` [Try it online.](https://tio.run/##MzBNTDJM/f8/yu7QSoVzmxSMTE2dFA6tK1Z61LDo8H4wcWGT0v//0aY6liY6huY6FsY6JjomJjrGRjqGliCmKUjI0kDHQMcQKApSAlJlGAsA)

Here a useful program to generate both this compressed number and the Base we want to convert to:

 Z>© β 255B ®s"•ÿ•ÿв"

###[Try it online.](https://tio.run/##MzBNTDJM/f8/yu7QSoVzmxSMTE2dFA6tK1Z61LDo8H4wcWGT0v//0aY6lsY6huY6FsY6JjomJjrGRjqGliCmKUjI0kDHQMcQKApSAlJlGAsA)

What this program above does is:

- `Z>`: Get the max number + 1 of the input-list (`©`: and store it in the register)
- `β`: Convert the input list from base `max+1` to a single number
- `255B`: Compress this single number (as we did at the section above)
- `®s"•ÿ•ÿв"`: Returns the result in the format: leading `•`, compressed number, `•`, max+1, trailing `в`

[Here an example answer where I use `•4Œ”dóŒfÝŸĀTUÕáOyÖOÀÁàu¼6¹₆Žr‡_›y³eß₂©ǝ²ƶ"SAÎAñ'¡û†Ø(•91в` to compress the list `[85,30,29,39,28,37,33,88,31,40,34,89,35,41,32,90,36,38,42,43,44,60,45,61,46,62,47,63,48,64,49,65,81,50,66,51,67,52,68,53,69,86,54,70,87,55,71,56,72,82,57,73,79,80,58,74,59,75,76,77,78,83,84]`.](https://codegolf.stackexchange.com/a/169126/52210) 
PS: In this answer [``•6j|eDEJÞó(ÍêΓλùÄÞKüzHÇ-ø`JδŠ₂+Öηôî®À8†6/ðÎ6ùøΓ°ÓĆ;ˆ©Ā•2ô``](https://tio.run/##AWsAlP9vc2FiaWX//@KAojZqfGVERUrDnsOzKMONw6rOk867w7nDhMOeS8O8ekjDhy3DuGBKzrTFoOKCgivDls63w7TDrsKuw4A44oCgNi/DsMOONsO5w7jOk8Kww5PEhjvLhsKpxIDigKIyw7T//w) is an equal-bytes (57) alternative, since all numbers have exactly two digits. In some cases (especially small lists) this can be a shorter alternative.

One thing to note is that it's usually shorter to use a slightly larger single-byte integer constant (i.e. `T₂₆₃т₅₁₄` for `10,26,36,95,100,255,256,1000` respectively) instead of the maximum+1 found by the program above. Let's say our example `[5,94,17,83,4,44,32,19,4,45,83,90,0,14,3,17,17,81]` was `[5,95,17,83,4,44,32,19,4,45,83,90,0,14,3,17,17,81]` instead, it would find [`•6MÖ∊]ć;?,ćiåÑ6Š•96в` (20 bytes)](https://tio.run/##MzBNTDJM/f8/yu7QSoVzmxSMTE2dFA6tK1Z61LDo8H4wcWGT0v//0aY6lqY6huY6FsY6JjomJjrGRjqGliCmKUjI0kDHQMcQKApSAlJlGAsA) as shortest, but [`•CRā»ïζyˆöÍ†y“a±•тв` (19 bytes)](https://tio.run/##AS8A0P9vc2FiaWX//@KAokNSxIHCu8OvzrZ5y4bDtsON4oCgeeKAnGHCseKAotGC0LL//w) with the single-byte constant `100` would be 1 byte shorter. 
You can still get the compressing program above by replacing the `Z>` with the single-byte constant (or its value): [Try it online](https://tio.run/##MzBNTDJM/f/f0MDg0EqFc5sUjExNnRQOrStWetSw6PB@MHFhk9L//9GmOpamOobmOhbGOiY6JiY6xkY6hpYgpilIyNJAx0DHECgKUgJSZRgLAA).

**Integer compression vs Integer list compression:**

With these two it can go either way. Sometimes a compressed list is shorter, sometimes a compressed integer, sometimes a completely different alternative is shorter. So always use your own judgment and golfing skills to possibly golf things further, instead of relying on the above generators completely. Here some examples:

`[44, 59]` ([used in this answer of *@Emigna*](https://codegolf.stackexchange.com/a/171988/52210)):

- [`•A–•60в`](https://tio.run/##yy9OTMpM/f//UcMix0cNk4GUmcGFTf//m5iYWgIA) is 7 bytes (generated by the compressed integer list generator)
- [`•H|•2ô`](https://tio.run/##yy9OTMpM/f//UcMijxogYXR4y///JiamlgA) or [`•H|•2ä`](https://tio.run/##yy9OTMpM/f//UcMijxogYXR4yf//JiamlgA) or hardcoded [`44 59‚`](https://tio.run/##yy9OTMpM/f/fxETB1PJRw6z//wE) are all 6 bytes
- [`ŽH|2ô`](https://tio.run/##yy9OTMpM/f//6F6PGqPDW/7/NzExtQQA) or [`ŽH|2ä`](https://tio.run/##yy9OTMpM/f//6F6PGqPDS/7/NzExtQQA) are both 5 bytes
- But in this case, [`„,;Ç`](https://tio.run/##yy9OTMpM/f//UcM8HevD7f//AwA) with 4 bytes would be the best option (codepoints of characters ',' and ';')

`[2,4,6,0]` ([used in this answer of *@Emigna*](https://codegolf.stackexchange.com/a/173636/52210)):

- [`•3ā•7в`](https://tio.run/##yy9OTMpM/f//UcMi4yONQNL8wqb//wE) is 6 bytes (generated by the compressed integer list generator)
- [`Ž3ā7в`](https://tio.run/##yy9OTMpM/f//6F7jI43mFzb9/w8A) is 5 bytes
- But in this case, [`Ž9¦S`](https://tio.run/##yy9OTMpM/f//6F7LQ8uC//8HAA) with 4 bytes would be the best option (compressed integer 2460 to a list of digits)

`10101001100101001` ([initially used in this answer of mine](https://codegolf.stackexchange.com/a/173556/52210)):

- [`•a½₄Ƶ6®í•`](https://tio.run/##yy9OTMpM/f//UcOixEN7HzW1HNtqdmjd4bVA/v//AA) is 9 bytes (generated by compressed large integer generator)
- [`•1∊}•2вJ`](https://tio.run/##yy9OTMpM/f//UcMiw0cdXbVA2ujCJq///wE) is 8 bytes (generated by compressed integer list generator with added join)
- [`•1∊}•b`](https://tio.run/##yy9OTMpM/f//UcMiw0cdXbVAOun/fwA) with 6 bytes would be even shorter (compressed integer list, with a *to binary* instead of `2в`, which implicitly joins)
- But [`Ž«ǝbĆ`](https://tio.run/##yy9OTMpM/f//6N5Dq4/PTTrS9v8/AA) with 5 bytes would be the shortest option here (compressed integer, to binary, and enclose - appending its own head)

`[85,30,29,39,28,37,33,88,31,40,34,89,35,41,32,90,36,38,42,43,44,60,45,61,46,62,47,63,48,64,49,65,81,50,66,51,67,52,68,53,69,86,54,70,87,55,71,56,72,82,57,73,79,80,58,74,59,75,76,77,78,83,84]` ([used in this answer of mine](https://codegolf.stackexchange.com/a/169126/52210)):

- [`•4Œ”dóŒfÝŸĀTUÕáOyÖOÀÁàu¼6¹₆Žr‡_›y³eß₂©ǝ²ƶ"SAÎAñ'¡û†Ø(•91в`](https://tio.run/##AW4Akf9vc2FiaWX//@KAojTFkuKAnWTDs8WSZsOdxbjEgFRVw5XDoU95w5ZPw4DDgcOgdcK8NsK54oKGxb1y4oChX@KAunnCs2XDn@KCgsKpx53Cssa2IlNBw45Bw7EnwqHDu@KAoMOYKOKAojkx0LL//w) is 57 bytes (generated by compressed integer list generator)
- [`•6j|eDEJÞó(ÍêΓλùÄÞKüzHÇ-ø`JδŠ₂+Öηôî®À8†6/ðÎ6ùøΓ°ÓĆ;ˆ©Ā•2ô`](https://tio.run/##AWsAlP9vc2FiaWX//@KAojZqfGVERUrDnsOzKMONw6rOk867w7nDhMOeS8O8ekjDhy3DuGBKzrTFoOKCgivDls63w7TDrsKuw4A44oCgNi/DsMOONsO5w7jOk8Kww5PEhjvLhsKpxIDigKIyw7T//w) is also 57 bytes (compressed integer, split into parts of size 2)
- [`•Bšā¿ÑáζΔÕæ₅"®GÙ₂®°ƶío"§óÏ4¸bćÔ!₃ùZFúÐìŸ
,λ₂Ï¦P(Ì•65в₂+`](https://tio.run/##AW4Akf9vc2FiaWX//@KAokLFocSBwr/DkcOhzrbOlMOVw6bigoUiwq5Hw5nigoLCrsKwxrbDrW8iwqfDs8OPNMK4YsSHw5Qh4oKDw7laRsO6w5DDrMW4CizOu@KCgsOPwqZQKMOM4oCiNjXQsuKCgiv//w) is however 2 bytes shorter, by compression the list with each value 26 lower, and then add that afterwards with ``₂+``. This trick of adding a single-byte value later on can be used pretty often to save bytes in compressed lists.

If this is an answer to a challenge…

…Be sure to follow the challenge specification. However, please refrain from exploiting obvious loopholes. Answers abusing any of the standard loopholes are considered invalid. If you think a specification is unclear or underspecified, comment on the question instead.
…Try to optimize your score. For instance, answers to code-golf challenges should attempt to be as short as possible. You can always include a readable version of the code in addition to the competitive one. Explanations of your answer make it more interesting to read and are very much encouraged.
…Include a short header which indicates the language(s) of your code and its score, as defined by the challenge.

More generally…

…Please make sure to answer the question and provide sufficient detail.
…Avoid asking for help, clarification or responding to other answers (use comments instead).

Draft saved

Draft discarded

Edit Summary*

Cancel

1

\$\begingroup\$ @Grimmy Missed this comment apparently, but rofl at even golfing my tip answers, haha. xD \$\endgroup\$

Kevin Cruijssen
– Kevin Cruijssen

2020年02月11日 08:51:38 +00:00
Commented Feb 11, 2020 at 8:51
\$\begingroup\$ •4βŸ{©£MG]q‡dZΘp•94в => •CHʒýo}ÚΛвÛÓĀ[ÁL•тв for -1. Yay for more tips golf x) \$\endgroup\$

Grimmy
– Grimmy

2020年02月23日 23:58:50 +00:00
Commented Feb 23, 2020 at 23:58
\$\begingroup\$ @Grimmy Lol, that list was just some random numbers used as an example.. xD But I've increased the 93 to 94, so the single-byte builting for 95 can be used instead, and added a note how often the single-byte integer constants can be used for shorter compressed lists. :) \$\endgroup\$

Kevin Cruijssen
– Kevin Cruijssen

2020年02月24日 07:33:53 +00:00
Commented Feb 24, 2020 at 7:33
\$\begingroup\$ Does this mean, then, that "ŸTM,‚ï! is a maximally compressed version of "Hello, World!" \$\endgroup\$

Someone
– Someone

2021年01月07日 17:58:06 +00:00
Commented Jan 7, 2021 at 17:58
\$\begingroup\$ @Someone Yep, that's indeed correct. I think you can find that exact program in the Hello, World! codegolf challenge. :) \$\endgroup\$

Kevin Cruijssen
– Kevin Cruijssen

2021年01月07日 22:47:05 +00:00
Commented Jan 7, 2021 at 22:47

| Show 4 more comments

How to Edit

Correct minor typos or mistakes
Clarify meaning without changing it
Add related resources or links
Always respect the author’s intent
Don’t use edits to reply to the author

How to Format

create code fences with backticks ` or tildes ~
```
like so
```
add language identifier to highlight code
```python
def function(foo):
print(foo)
```
put returns between paragraphs
for linebreak add 2 spaces at end
_italic_ or **bold**
indent code by 4 spaces
backtick escapes `like _so_`
quote by placing > at start of line
to make links (use https whenever possible)

<https://example.com>

[example](https://example.com)

<a href="https://example.com">example</a>
MathJax equations \$\sin^2 \theta\$

formatting help »
answering help »

MathJax help »

How to Tag

A tag is a keyword or label that categorizes your question with other, similar questions. Choose one or more (up to 5) tags that will help answerers to find and interpret your question.

complete the sentence: my question is about...
use tags that describe things or concepts that are essential, not incidental to your question
favor using existing popular tags
read the descriptions that appear below the tag

If your question is primarily about a topic for which you can't find a tag:

combine multiple words into single-words with hyphens (e.g. code-golf), up to a maximum of 35 characters
creating new tags is a privilege; if you can't yet create a tag you need, then post this question without it, then ask the community to create it for you

popular tags »