[Question]
  [
Do you have any tips for [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'")ing in [05AB1E](https://github.com/Adriandmen/05AB1E), a golfing language created by [Adnan](https://codegolf.stackexchange.com/users/34388/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.
[Answer]
# Using the Canvas (`Λ` or `.Λ`)
Since it wasn't part of the docs, and *@Adnan* is currently a bit too busy to write it, I asked permission to add it as a tip here for now.
The Canvas function (`Λ` or `.Λ`) can be used to draw ASCII-lines on the screen. It has three required parameters:
* ***a*** Length: The size of the line(s). This can be a single integer, or a list of integers
* ***b*** String: The character(s) we want to display. This can be a single character, a string, a list of characters, or a list of strings (in the last three cases it will use all of them one-by-one including wrap-around)
* ***c*** Direction: The direction the character-lines should be drawn in. In general we have the digits `[0,7]` for the directions, for which we can use one or multiple. There are also some special options that require a certain character (more about that later).
The direction-digits `[0,7]` map to the following directions:
```
7   0   1
  ↖ ↑ ↗
6 ← X → 2
  ↙ ↓ ↘
5   4   3
```
Some example 05AB1E answers where the Canvas is used:
* [Print a negative of your code](https://codegolf.stackexchange.com/a/169298/52210)
* [ASCII Art Octagons](https://codegolf.stackexchange.com/a/175412/52210)
* [Eiffel Towers: Create a large “A” from “A”s](https://codegolf.stackexchange.com/a/160031/52210)
* [Make an alphabet searchlight!](https://codegolf.stackexchange.com/a/141741/52210)
* [A nicely-spaced ASCII spiral](https://codegolf.stackexchange.com/a/167486/52210)
Let's do something similar as the last one, so assume we use the Canvas `Λ` function with the following three parameters:
* ***a***: `[3,3,5,5,7,7,9,9]`
* ***b***: `!@#`
* ***c***: `[0,2,4,6]`
This will give the following output:
```
  !@#!@#!
  #     @
  @ #!@ #
  ! @ # !
  # ! ! @
  @   @ #
  !#@!# !
        @
@!#@!#@!#
```
[Try it online.](https://tio.run/##yy9OTMpM/f//3Oz//6MNdIx0THTMYrkUHZS5oo11jHVMgdAcCC11LGMB)
So how does it work? Well, here are the steps with these inputs above:
1. Draw `3` characters (`!@#`) upwards (direction `0`)
2. Draw `3-1` characters (`!@`) towards the right (direction `2`)
3. Draw `5-1` characters (`#!@#`) downwards (direction `4`)
4. Draw `5-1` characters (`!@#!`) towards the left (direction `6`)
5. Draw `7-1` characters (`@#!@#!`) upwards (direction `0`)
6. Draw `7-1` characters (`@#!@#!`) towards the right (direction `2`)
7. Draw `9-1` characters (`@#!@#!@#`) downwards (direction `4`)
8. Draw `9-1` characters (`!@#!@#!@`) towards the left (direction `6`)
The `-1` are there because the lines overlap. So the first two steps are:
```
#
@
!
```
And
```
 !@
```
Which combined is:
```
#!@
@
!
```
**Some minor notes:**
* Apart from the options `[0,7]` there are a few specific options available, which basically translate to a certain direction-sequence.
	+ `+` (`'+` inline) translates to the pattern `04402662`, which creates a `+`-cross with arms of the given length. [See it in action.](https://tio.run/##yy9OTMpM/f//3Oz//7W5HJ24TAE)
	+ `×` (`'×` inline) translates to the pattern `15513773`, which creates a `X`-cross with arms of the given length. [See it in action.](https://tio.run/##yy9OTMpM/f//3Oz//w9P53J04jIFAA)
	+ `8` returns to the origin of where we started drawing from. [See it in action](https://tio.run/##yy9OTMpM/f//3Oz//40sjC1MuRyduEwB) and [see the difference without the `8`](https://tio.run/##yy9OTMpM/f//3Oz//42MTbkcnbhMAQ).
* The Canvas builtin will implicitly add trailing spaces to make the output a rectangle.
* The `Λ` will output immediately, and `.Λ` results a string that is pushed to the stack, which we can still re-use, modify, and do anything with that we'd want. Some examples:
	+ We can convert it [to a list of strings](https://tio.run/##yy9OTMpM/f/f/PBcvXOz9Zz@/zcGAA) or [to a list of characters](https://tio.run/##yy9OTMpM/f/f/PBcvXOzg///NwYA).
	+ [We could replace a certain character](https://tio.run/##yy9OTMpM/f/f/PBcvXOzPdWVrf7/NwYA)
	+ [Insert a certain character](https://tio.run/##yy9OTMpM/f/f/PBcvXOzXdKt1f2Lj8/9/98YAA)
	+ etc. etc.
* Depending on the given options, either the lengths or directions are leading when drawing the output:
	+ If a list of lengths is given, those lengths will always be leading. In this case, wrap-around can be used for the directions-list. Some examples:
		- [`lengths = [3,4]` and `directions = [2,3,4,5]`](https://tio.run/##yy9OTMpM/f//3Oz//6ONdIx1THRMY7kcuaKBrFgA) will use directions `[2,3]` (the `4,5` are ignored), since only two lengths are given.
		- [`lengths = [3,4,4,2,3]` and `directions = [1,2]`](https://tio.run/##yy9OTMpM/f//3Oz//6MNdYxiuRy5oo11TIDQKBYA) will use directions `[1,2,1,2,1]` since there are five given lengths.
	+ If a single length-integer is given, the directions will be leading instead. In this case, you can't use wrap-around of the directions-list. For example:
		- [`length = 2` and `directions = [3,3,5,5,7,7,1,3]`](https://tio.run/##yy9OTMpM/f//3Oz//6ONdYx1TIHQHAgNdYxjuRy5jAA) will use length `2` for all directions in the list. In this case you can't remove the trailing direction `3` despite already having a leading `3`, since the directions are leading for drawing the output. This would [give a different output](https://tio.run/##yy9OTMpM/f//3Oz//6ONdYx1TIHQHAgNY7kcuYwA).
[Answer]
# Implicit input
Back in the days when 05AB1E was released, implicit input was quite new and fancy. Nowadays it seems to be necessary in order to keep track with other competitive languages (like Jelly, MATL, Pyth, etc.).
For example, when you want to add two numbers, you can do `II+`:
```
I    # Input_1.
 I   # Input_2.
  +  # Add them up.
```
[**Test it here**](http://05ab1e.tryitonline.net/#code=SUkr&input=Nwo2)
---
However, using **implicit input**, we can shorten in to just 1 byte, namely `+`:
```
+    # Take two numbers implicitly and add them up.
```
[**Test it here**](http://05ab1e.tryitonline.net/#code=Kw&input=Nwo2)
---
This only happens when the length of the stack is smaller than the arity of the operator. A last example is `3+`. The arity of the `+` operator is **2** while there is only **1** element in the stack:
```
3    # Push the number 3 on top of the stack.
 +   # Request implicit input and add to the 3.
```
[**Test it here**](http://05ab1e.tryitonline.net/#code=Mys&input=Nw)
[Answer]
# Substrings
`£` is the command for taking the first `b` characters of string `a`.  
**ex:** [`"hello_world"5£`](http://05ab1e.tryitonline.net/#code=ImhlbGxvX3dvcmxkIjXCow&input=) `->` `"hello"`
But if `b` is a list of indices it instead splits the string into parts of (upto) those sizes.  
**ex:** [`"hello_world"5L£`](http://05ab1e.tryitonline.net/#code=ImhlbGxvX3dvcmxkIjVMwqM&input=) `->` `['h', 'el', 'lo_', 'worl', 'd']`
[Answer]
# Predefined variables
They are a bit hidden in 05AB1E. Here's a list of all the predefined variables:
* [`¾`](http://05ab1e.tryitonline.net/#code=wr4&input=), pushes **`0`** if the counter\_variable is not changed before this command.
* [`X`](http://05ab1e.tryitonline.net/#code=WA&input=), pushes **`1`** if variable X is not changed before this command with `U`.
* [`Y`](http://05ab1e.tryitonline.net/#code=WQ&input=), pushes **`2`** if variable Y is not changed before this command with `V`.
* [`®`](http://05ab1e.tryitonline.net/#code=wq4&input=), pushes **`-1`** if the register is not changed before this command with `©`.
* [`¯`](https://tio.run/##yy9OTMpM/f//0Pr//wE), pushes **`[]`** (empty array) if nothing is added to the global\_array before this command.
* [`¸`](https://tio.run/##yy9OTMpM/f//0I7//wE), pushes **`[""]`** on an empty stack if there is no input. (Thank you @Emigna for finding this one.)
[Answer]
# Small [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands) golfing tips
Will expand this with small golfing tips I learned along the way. (Only just started 05AB1E personally.)
* If you have a list of lists and first want to join each inner list by spaces, and then those space-delimited strings by newlines, the to-the-point approach would be [`ðý»`](https://tio.run/##yy9OTMpM/f//8IbDew/t/v8/OlrJKz8zT0lHKakSSBQXJCanFivF6kQrJealAAVKMlLhknmp5TmZeSDpWAA) of course. However, the `»` already implicitly joins inner lists by spaces before joining by newlines, so the `ðý` isn't necessary in this case: [try it online](https://tio.run/##yy9OTMpM/f//0O7//6OjlbzyM/OUdJSSKoFEcUFicmqxUqxOtFJiXgpQoCQjFS6Zl1qek5kHko4FAA).
* `D` (duplicate) and `Ð` (triplicate) in combination with `s` (swap) and `Š` (triple-swap `a,b,c` to `c,a,b`) are usually shorter than using `©` (save in *global\_variable*) and `®` (push *global\_variable*) inside loops. This [saved a byte in this answer of mine](https://codegolf.stackexchange.com/a/166305/52210), as well as two in [this answer of mine](https://codegolf.stackexchange.com/a/165755/52210).
* `½` (if 1, then increase *counter\_variable* by 1) isn't necessary at the end of a `µ` (while *counter\_variable* != a, do...), since it's done implicitly ([saved a byte in this answer of mine](https://codegolf.stackexchange.com/a/164398/52210)).
* `.B` implicitly splits on new-lines. This was useful in [this answer of mine](https://codegolf.stackexchange.com/a/166162/52210) when we were looking for an alternative for `¡` (split) while still keeping empty items (NOTE: Solution in the linked answer doesn't work when elements contain trailing spaces after splitting.) - Hopefully a builtin will be added to split but keep empty lines in the future.
* [legacy version only] `SÖ` (which of the digits of the input-integer can evenly divide the input-integer) will contain the number itself for the digits `0` (instead of divide-by-zero errors). For example, [`1053` will result in `[1,1053,0,1]`](https://tio.run/##MzBNTDJM/f8/@PC0//8NDUyNAQ) (1053 is divisible by 1 and 3; is not divisible by 5; and gives a division-by-zero error for 0). This was pretty useful in [this answer of mine](https://codegolf.stackexchange.com/a/164415/52210) by taking the power of the list, since only `1` is truthy in 05AB1E and everything else is falsey. `SÖP` resulting in truthy (`1`) therefore means an input-integer is evenly divisible by each of its digits.
* After seeing `û` (palindromize a given string) I was surprised there isn't an *is\_palindrome* builtin. But later on I realized only 2 bytes are needed to accomplish that, which are [`ÂQ`](https://tio.run/##MzBNTDJM/V9TVmmvpPCobZKCkn3l/8NNgf91/ufllygkKhQk5mTmpRTl56ZyGRoZm5hy5aWWpRblp6TkFwEZeSBBI0MA) (where `Â` is bifurcate, which is short for `DR`: Duplicate & Reverse copy; and `Q` is to check if the top two values on the stack are equal).
* When you want to filter a list by multiple things, it's usually cheaper to have multiple loose filters, rather than all combined in one filter. Because when you have two filters you'll need something along the lines of `Ds*` (duplicate, swap, multiply to act as logical-AND) vs `}ʒ` (close first filter, filter again) when you use two filters. For example: in [this challenge](https://codegolf.stackexchange.com/q/174049/52210) we have to list all numbers of four digits long, containing at least one `0`, and with a digit sum equal to `9`. Using a range `[1000,10000]` covers the number of four digits long, but then you are left with two more filters. Initially I used [`₄4°ŸʒD0åsSO9Q*`](https://tio.run/##yy9OTMpM/f//UVOLyaENR3ecmuRicHhpcbC/ZaDW//8A) (14 bytes), but by using two filters a byte can be saved: [`₄4°Ÿʒ0å}ʒSO9Q`](https://tio.run/##AR4A4f9vc2FiaWX//@KChDTCsMW4ypIww6V9ypJTTzlR//8) (13 bytes). (Which later got golfed to [`₄4°ŸεW°ö9Q`](https://tio.run/##ARsA5P9vc2FiaWX//@KChDTCsMW4ypJXwrDDtjlR//8) (10 bytes) by *@Grimmy*.)
* When you want to zip with integer `0` as filler, you could use `0ζ`. One issue with this however is that the filler `0` will become a string `"0"`, so if you later try to sort with mixed strings and integer, this will most likely not give the result you'd want. Here an example of how it will sort the zipped inner lists: [`0ζ€{`](https://tio.run/##yy9OTMpM/f/f4Ny2R01rqv//j442jNWJNtUx0DEG0oY6RrGxAA). This can be fixed by adding an explicit cast to int (`ï`) after the zip, and only then sort: [`0ζï€{`](https://tio.run/##yy9OTMpM/f/f4Ny2w@sfNa2p/v8/OtowVifaVMdAxxhIG@oYxcYCAA). However, using the `¾` as constant `0` with the zip-filler, will cause it to remain an integer instead of a string during the zip. So [`¾ζ€{`](https://tio.run/##yy9OTMpM/f//0L5z2x41ran@/z862jBWJ9pUx0DHGEgb6hjFxgIA) will save a byte here. This tip was provided by *@Mr.Xcoder* to save a byte [in this answer of mine](https://codegolf.stackexchange.com/a/175101/52210). (The same applies to `X` instead of `1` and `Y` instead of `2`.)
* If you want to sum the digits of multiple numbers in a list, you could use `€SO`. Shorter however is using `1ö`, which automatically vectorizes. This tip was provided by *@Grimmy* to [save a byte here](https://codegolf.stackexchange.com/a/164398/52210) (and [2 bytes here](https://codegolf.stackexchange.com/a/174058/52210)).
* If you're only dealing with non-negative integers, and you want to get a truthy value (`1`) when the integer is either 0 or 1, you could of course use the obvious `2‹`. However, using `!` (factorial) will also only result in 1 (truthy) for `0` and `1`, and every other value will result in something higher (and thus falsey, since only `1` is truthy in 05AB1E). This tip was provided by *@Grimmy* to [save a byte here](https://codegolf.stackexchange.com/a/191389/52210).
* If you want a list of all overlapping pairs (i.e. `[1,2,3,4,5,6,7,8,9]` → `[[1,2],[2,3],[3,4],[4,5],[5,6],[6,7],[7,8],[8,9],[9]]`), most probably already know `ü‚` can be used ([Try it online](https://tio.run/##yy9OTMpM/W/p8//wnkcNs/7/BwA)). But what if you want a list of overlapping triplets or quartets? The most obvious approach would seem to be `Œ3ù` (substrings & keep those of length 3 - [Try it online](https://tio.run/##yy9OTMpM/W/p8//oJOPDO///BwA)). But `ü` actually has a (currently undocumented) feature as shortcut for this `ü3` ([Try it online](https://tio.run/##yy9OTMpM/W/p8//wHuP//wE)), which works with any integer given to `ü`, including `2` to create overlapping pairs ([Try it online](https://tio.run/##yy9OTMpM/W/p8//wHqP//wE)).
* If the stack is empty, some builtins will use the last value that was previously on the stack (and thus there is also no implicit input!), saving you on a potential duplicate. For example, in [this 05AB1E answer](https://codegolf.stackexchange.com/a/201191/52210) the `×` will use the `9L` list twice, without a need to duplicate it first. And in [this 05AB1E program](https://codegolf.stackexchange.com/questions/200713/print-a-list-of-iphones#comment482343_200719) the `ÿ` inside the string will use the `11` all three times, without the need to triplicate it first.
* If we've used `|` to get all (remaining) inputs, the next `I` or implicit input will push this same list instead of the final input. Knowing this can sometimes save bytes, like in [the top program of this answer of mine](https://codegolf.stackexchange.com/a/211092/52210).
* There is a flatten builtin `˜` to flatten a multi-dimensional list to a single list: [try it online](https://tio.run/##FYrLEYAgEEN7yZmOdjiAouIPFf@12JFFrfGQTF7mpex8DKrvoyoicL6AQRkqdt1EWCNou540jIk9zQvsf2bCymwg7BwHc/6@4LrpWPsB). There is also a way to flatten a (potentially multi-dimensional) list of strings to a single list of characters with `S`: [try it online](https://tio.run/##FYpJEoAgEAP/kjO/8TjFARQVN1TcPz@GQ1LpVKfsfAyqlaqIwPkaBk1o2V0fYY1gGCfSvCT2uu2w5cyEgzlBuDhu5im@4P3oWPsD). But what if we only want to flatten it down one level, instead of all the way? In that case, `€``  can be used if the order of items isn't important ([try it online](https://tio.run/##yy9OTMpM/f//UdOahP//o6OjlRKTkpV0lFJS04BkekamUqxOtFJWdg6Ql5uXDyQLCouUYkGCxUBOCRCXKgE5ZUBGORBXgNRHK1VWAdXExgIA)) or `í€``  if retaining the order of items is important ([try it online](https://tio.run/##yy9OTMpM/f//8NpHTWsS/v@Pjo5WSkxKVtJRSklNA5LpGZlKsTrRSlnZOUBebl4@kCwoLFKKBQkWAzklQFyqBOSUARnlQFwBUh@tVFkFVBMbCwA)). The unordered version is used pretty often in matrix-related challenges, like I used in [this answer of mine](https://codegolf.stackexchange.com/a/240671/52210).
* You probably know how `δ` (apply double-vectorized) can be used on two list arguments to execute it on every pair (e.g. `δ‚` will create pairs using the values in the two lists - [try it online](https://tio.run/##yy9OTMpM/f//3JZHDbP@/4821DHSMY7lijbRMdUxiwUA)). You probably also know how it can be used as an apply-map with both a list and loose argument (e.g. `0δK` will remove all 0s from each inner list, which is shorter than a regular map `ε0K}` - [try it online](https://tio.run/##yy9OTMpM/f/f4NwW7///o6MNdQx0jGJ1ok10THXMgLQ5iA/EhgaxsQA)). What you might not know, at least it was new to me, is when two integers are given as arguments, it implicitly uses their `[1,n]` ranged lists instead (e.g. `δ‚` again on two integer arguments will convert both to a list and applies the pairing to those - [try it online](https://tio.run/##yy9OTMpM/f//3JZHDbP@/zfmMgEA)). This saved two bytes in a couple of answers of mine ([here](https://codegolf.stackexchange.com/a/235746/52210) and [here](https://codegolf.stackexchange.com/a/241528/52210) for example).
[Answer]
# Pop or get
As in other stack-based languages, 05AB1E's functions usually **pop** (consume) their inputs from the stack and push their outputs onto the stack.
However, some functions **get** their inputs from the stack without consuming them. An example is the `head` function, `¬`, which produces the first element from the input list. See an example program here: [`¬+`](http://05ab1e.tryitonline.net/#code=wqwr&input=WzEwLCAyMCwgMzBd). This adds the first number of the input list to each number of that list.
To know which functions pop and which get, see the corresponding column in the [function information file](https://github.com/Adriandmen/05AB1E/blob/master/docs/info.txt).
[Answer]
# 05AB1E ASCII-Art Golfing
The below code helps turn ASCII-art into 05AB1E using a custom base conversion.
```
|»©ÐÙSDŠ¢øΣθ}R€н¬®sÅ?iD2£RDŠKsì}J©žLR‡®gö₅B®s"•ÿ•“ÿ“ÅвJ"
```
[Try it online.](https://tio.run/##JU/LSgNBEPyV9olKEI3vkw@CSFSQKHgTJru9uwOTmTA9Y1wwEAK5exVyUHMKhBw8SEBU2CXXkG/YH4mzeuluqoqqakWsynE2e0w@k376lD5fl8YvyVs6mvQmo2Ylaw@mX8kgGVLaOeSlYtKrOP6c0kGznPTH3xeVrPWaDMP0I2t3TpxsPmu9pT9uZK1uvrtpZ/penp/N4JjgSiNxH6WBG21rdSAeSvSBATUQ61yGgA/oWcPvEZT2UYOScKq5z@ICUGSNyTUmQqj@0QRGgcbAhogETPqgHOngQKsaEN6jBMF0iCKGS0uC18BTVhrNkQp/PoSeRsN0DCqASNVQ5C4OtZqbGBqM8goMbiNuEM6UJXQWMkCN0nMnEwJC/O8VcRfMNRkIrIOrLiXIcWeQR4VCVZlwb/DAAJdQV4J78frc0cLi0t3y2srqZnFre2d3b/9g4xc)
This is accomplished by:
1. Listing out the unique characters in the ASCII drawing.
2. Order them by how many times they occur in the string in descending order (most occurring to least occurring characters).
3. Reverse the first two items if the ASCII drawing starts with the most occurring character (to prevent leading 0s in the compressed integer).
4. Map the characters of the input to `0-9A-Za-z` in that order, each distinct character getting its own mapping-character, until every one has been replaced.
5. Base compress it, using the highest base you needed to replace (based on the amount of unique characters).
6. Base convert it again to base-255 (for 05AB1E compression).
7. Format everything in the format: `•<compressed_integer>•“<sorted_distinct_characters>“ÅвJ`.
The `“` allows you to also compress string-quotes `"`; the `Åв` will use this string to base-convert the generated integer using the string as custom base; and `J` will join all these characters together to a single string, which is output implicitly.
Accepts patterns with up to and including 62 unique characters, good for ASCII-art.  
The less amount of unique characters, the better the compression.
---
**Example output for [Draw the XNOR digital timing diagram](https://codegolf.stackexchange.com/questions/105853/draw-the-xnor-digital-timing-diagram) (214 bytes, 9 unique characters):**
```
    ┌─┐ ┌─┐ ┌─────┐ ┌─┐ ┌─┐ ┌───┐  
A ──┘ └─┘ └─┘     └─┘ └─┘ └─┘   └──
  ┌───┐ ┌───┐ ┌─┐ ┌─────┐   ┌─┐ ┌─┐
B ┘   └─┘   └─┘ └─┘     └───┘ └─┘ └
    ┌─────┐   ┌─┐   ┌─┐   ┌───┐   
X ──┘     └───┘ └───┘ └───┘   └────
```
Would be:
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 106 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
•I£.µ*:]ó±øqaµb₄ΘYQmœ¹µû₄p´ζÂĆ_5ŠKÑ×ðòË|₄#¹¶úôÂ-Í|¯ε¼É₂ïδ&é–9»ÞFò1î×HÃBjý2ĆÉ≠FYÂÂèC j‘£Å₅Œ•“─ └┘┐┌
XBA“ÅвJ
```
[Try it online.](https://tio.run/##AckANv9vc2FiaWX//@KAoknCoy7CtSo6XcOzwrHDuHFhwrVi4oKEzphZUW3Fk8K5wrXDu@KChHDCtM62w4LEhl81xaBLw5HDl8Oww7LDi3zigoQjwrnCtsO6w7TDgi3DjXzCr861wrzDieKCgsOvzrQmw6nigJM5wrvDnkbDsjHDrsOXSMODQmrDvTLEhsOJ4omgRlnDgsOCw6hDIGrigJjCo8OF4oKFxZLigKLigJzilIAg4pSU4pSY4pSQ4pSMClhCQeKAnMOF0LJK//8)
**(106/214)\*100 = 49.53% the size of the original ASCII-art string.**
Which is the same byte-count as [my actual submission for that challenge](https://codegolf.stackexchange.com/a/106621/52210) in 05AB1E (legacy).
---
# Code explanation:
NOTE: Code is absolutely not golfed. It's quickly written to convert ASCII art to the most efficient compression, so it's quite ugly and long..
```
|»               # Take multi-line input
  ©              # Store it in the register to reuse later                         
ÐÙS              # Only leave unique characters (as list)
   DŠ¢ø          # Map it with the count for each of those characters
       Σθ}R      # Sort it based on that count (highest to lowest)
           €н    # Remove the count again, so the sorted characters remain
¬®sÅ?i           # If the input starts with the most occurring character:
      D2£RDŠKsì} #  Swap the first two characters in the list
J©               # Join everything together, and store it in the register to reuse later
  žLR‡           # Map each character to [0-9A-Za-z]
      ®gö        # Get the amount of unique characters, and convert it to that Base
         ₅B      # And then convert that to Base-255
®s               # Push the string and swap so the compressed integer is at the top again
  "•ÿ•“ÿ“ÅвJ"    # Insert it in the correct output format
                 #  `•<compressed_integer>•“<sorted_distinct_characters>“ÅвJ`
"•ÿ•"            # (after which the result is output implicitly with trailing newline)
```
[Answer]
# Implicit `http://`
When using `.w` to make requests to URLs, you may be tempted to prepend `žX` (the builtin for `"http://"`) to the URL. Don't do it! According to [line 239](https://github.com/Adriandmen/05AB1E/blob/master/lib/commands/gen_commands.ex#L239) of `gen_commands.ex` (general commands), if the URL does not start with `http`, it will automatically prepend `http://`. Not only that, but for URLs like `http://http-server.com`, while 05AB1E won't prepend `http://` to `http-server.com` as it starts with `http`, HTTPoison, 05AB1E's Elixir HTTP client, [will automatically prepend `http://`](https://github.com/edgurgel/httpoison/blob/main/lib/httpoison/base.ex#L691) ([following](https://github.com/edgurgel/httpoison/blob/main/lib/httpoison/base.ex#L689) [the](https://github.com/edgurgel/httpoison/blob/main/lib/httpoison/base.ex#L241) [function](https://github.com/edgurgel/httpoison/blob/main/lib/httpoison/base.ex#L240) [calls](https://github.com/edgurgel/httpoison/blob/main/lib/httpoison/base.ex#L245) [all](https://github.com/edgurgel/httpoison/blob/main/lib/httpoison/base.ex#L345) [the](https://github.com/edgurgel/httpoison/blob/main/lib/httpoison/base.ex#L334) [way](https://github.com/edgurgel/httpoison/blob/main/lib/httpoison/base.ex#L428) [down](https://github.com/edgurgel/httpoison/blob/main/lib/httpoison/base.ex#L427) [to](https://github.com/edgurgel/httpoison/blob/main/lib/httpoison/base.ex#L455) [05AB1E](https://github.com/Adriandmen/05AB1E/blob/master/lib/commands/gen_commands.ex#L239)).
[Answer]
# Conditionals and loops
Loops and conditionals automatically receive closing brackets at the end of a program, so you only need to add them in the code if you need to something outside of the loop/conditional.
For example, this (ungolfed) program creating a list of the first `n` prime numbers do not need closing brackets.
[`[¹¾Q#NpiNˆ¼`](http://05ab1e.tryitonline.net/#code=W8K5wr5RI05waU7LhsK8&input=MTI)
But if we wanted to perform some operation on the resulting list, for example taking delta's we'd need to close the loop first.
[`[¹¾Q#NpiNˆ¼]¯¥`](http://05ab1e.tryitonline.net/#code=W8K5wr5RI05waU7LhsK8XcKvwqU&input=MTI)
[Answer]
# Automatic vectorization
Note that some operators in 05AB1E vectorize automatically on arrays. For example, the code `5L3+`, which disassembles to the following pseudocode:
```
[1, 2, 3, 4, 5] + 3
```
would become:
```
[4, 5, 6, 7, 8]
```
If it doesn't vectorize automatically, you can also use the `€` operator. It takes a single character command, and performs that (monadic) operator on each element. An example to split each element is the following code ([**try it here**](http://05ab1e.tryitonline.net/#code=4oKsUw&input=WyJhYmMiLCAiZGVmIiwgImdoaSJd)):
```
€S
```
Whereas the normal `S` operator would split each element in the array and flattens it into a single array ([**try it here**](http://05ab1e.tryitonline.net/#code=Uw&input=WyJhYmMiLCAiZGVmIiwgImdoaSJd)).
[Answer]
# Ordering of the Inputs
The order that you take input can have a drastic effect on your code, and, oftentimes if you're using `s` to swap the top of the stack with the next highest thing on the stack, you're not thinking about the problem correctly. Try to reorder inputs and see if you can get rid of the need to swap by either swapping the inputs ahead of time, adding it to the stack earlier on or duplicating it somewhere. The most obvious I&O can be the least successful 05AB1E answer.
[Answer]
# Strings and ints are equal types
Not something that everybody agrees with, but it works.
Consider the following two programs:
```
4 5+
"4""5"+
```
They both result into **9**. That is because every value is first evaluated (with `ast.literal_eval`). Because of that, we can perform all string manipulation operators on ints and all int manipulation operators on strings.
For example, `12345û` palindromizes the number `12345`, resulting in `123454321`. After that, we can do the regular math on this number.
```
12345û50000-
```
This would result into: [**123404321**](http://05ab1e.tryitonline.net/#code=MTIzNDXDuzUwMDAwLQ&input=).
[Answer]
# Hidden loops and iterators
05AB1E has the following normal loops and iterators:
* `F`, which iterates through **0 .. n-1**.
* `G`, which iterates through **1 .. n-1**.
* `ƒ`, which iterates through **0 .. n**.
* `v`, which iterates over each element **s[0], s[1], .., s[n]**.
* `ʒ`, which is not exactly a loop, but a *filter-by* command. We abuse this command for it's unintended behaviour of looping through each element.
Using these loops, we can derive the following *hidden loops*:
* Instead of `gF`, you can use `v` which also has an `N`-index that can be used.
* The `vy -> ʒ` replacement is a bit more tricky:
	+ You need to immediately print the results. This surpresses the automatic print from printing the top of the stack.
	+ The code snippet is run on a **new temporary stack**. This means that stack-dependent snippets cannot be used.
	+ Invoking `y` is not possible in these kind of loops.
]