[Question]
  [
This is intended to be an easy, bite-size code-golf.
The [mex](http://en.wikipedia.org/wiki/Mex_(mathematics)) (minimal excluded number) of a finite collection of numbers is the smallest non-negative integer `0, 1, 2, 3, 4, ...` that does *not* appear in the collection. In other words, it's the minimum of the complement. The mex operation is central to the analysis of [impartial games](http://en.wikipedia.org/wiki/Impartial_game) in [combinatorial game theory](http://en.wikipedia.org/wiki/Combinatorial_game_theory).
Your goal is to write a *program* or *named function* to compute the mex using as few bytes as possible.
**Input:**
A list of non-negative integers in any order. May contain repeats. For concreteness, the length of the list and the allowed range of elements will both be between `0` and `20` inclusive.
The definition of "list" here is flexible. Any structure that represents a collection of numbers is fine, as long as it has a fixed ordering of elements and allows repeats. It may not include any auxiliary information except its length.
The input can be taken as a function argument or through STDIN. 
**Output**
The smallest excluded number. Output or print it.
**Test cases**
```
[1]
0
[0]
1
[2, 0]
1
[3, 1, 0, 1, 3, 3]
2
[]
0
[1, 2, 3]
0
[5, 4, 1, 5, 4, 8, 2, 1, 5, 4, 0, 7, 7]
3
[3, 2, 1, 0]
4
[0, 0, 1, 1, 2, 2, 3]
4
[1, 0, 7, 6, 3, 11, 15, 1, 9, 2, 3, 1, 5, 2, 3, 4, 6, 8, 1, 18]
10
```
  
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 6 bytes
```
h-U21Q
```
# Example run
```
$ pyth -c h-U21Q <<< '[5, 4, 1, 5, 4, 8, 2, 1, 5, 4, 0, 7, 7]'
3
```
### How it works
```
  U21   range(21)
     Q  eval(input())
 -U21Q  setwisedifference(range(21), eval(input))          # Pyth function. Preserves order.
h-U21Q  setwisedifference(range(21), eval(input))[0]
```
[Answer]
## CJam, ~~11~~ 8 bytes
```
K),l~^1<
```
How it works:
```
K),         "Create an array with numbers 0 through 20"
   l~       "Read the input and eval it, resulting to an array"
     ^      "XOR the elements of two arrays, resulting in a complement array"
      1<    "Take the first element of the resultant array"
```
Sample input:
```
[1 0 7 6 3 11 15 1 9 2 3 1 5 2 3 4 6 8 1 18]
```
Output:
```
10
```
[Try it online here](http://cjam.aditsu.net/)
[Answer]
# J - 13 char
```
f=:0{i.@21&-.
```
Very simple actions in J, and thus very hard to make smaller.
`i.@21` creates a list from 0 to 20 inclusive. `-.` performs set-subtracts the input from this list. `0{` takes the first element of what's left, i.e. the smallest number. `f=:` defines a named function. At the REPL:
```
   f=:0{(i.21)&-.
   f 1
0
   f 0
1
   f 2 0
1
   f 3 1 0 1 3 3
2
   f ''    NB. empty list
0
   f 1 2 3
0
   f 5 4 1 5 4 8 2 1 5 4 0 7 7
3
   f 3 2 1 0
4
   f 0 0 1 1 2 2 3
4
   f 1 0 7 6 3 11 15 1 9 2 3 1 5 2 3 4 6 8 1 18
10
```
Since the release of J806 in November 2017, a new syntax exists which saves us one byte by letting us use `i.@21` for the old `(i.21)` in this context.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~5~~ 4 bytes
```
0ḟ1#
```
[Try it online!](https://tio.run/##y0rNyan8/9/g4Y75hsr/D7c/alrz/380F2e0YawOkDQAk0Y6ChCGsY6CIZANJoFsY7AgmAAKGMEETHUUTMBKIAwLsBScC9RtDkQw8yBSEOMNYGZDTIMbaAjTZQa21hCkwhSsyhKiCmY8hG0CVmgBMckilisWAA "Jelly – Try It Online")
Doesn't use the bounds on the input.
...am I missing something?
```
0       Starting with 0,
  1#    find the first integer
 ḟ      which is not in the input.
```
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 4 bytes
```
ℕ≜¬∈
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/r//1HL1Eedcw6tedTR8f9/1P9oQx0FAx0Fcx0FMx0FYx0FQyDf0BSIdRQsdRSMIGI6CqYwtglYoQVY0NAiFgA "Brachylog – Try It Online")
Works for any list size and any integer magnitudes.
Takes input from the Output variable, and outputs to the Input variable.
### Explanation
```
ℕ      We want a non-negative integer
 ≜     Assign a value such that… 
  ¬∈   …it is not an element of the list
```
[Answer]
# Golfscript 7
```
~21,^0=
```
A further-golfed version of Peter Taylor's answer. Community wiki since I don't have the rep to comment on his post.
The difference is using the known max list size from the question instead of length +1 to save a character and dropping the irrelevant $.
[Try it online](http://golfscript.apphb.com/?c=OydbNSA0IDEgNSA0IDggMiAxIDUgNCAwIDcgN10nCgp%2BMjEsXjA9)
[Answer]
# [Burlesque](http://mroman.ch/burlesque/) - 9 Bytes
```
20rzj\\<]
```
Takes input from stdin in the format {7 6 5 5 1 2 2 4 2 0}
Explained:
```
 20 rz   map a range from 0 to 20. (thanks to algorithmshark for the cocde fix)
  j \\    swaps the two arrays, and collects the difference between the two into a new array
  <]      gets the smallest element of the resulting array.
```
Try some examples:
[{1 0 7 6 3 11 15 1 9 2 3 1 5 2 3 4 6 8 1 18}20rzj\\<]](http://eso.mroman.ch/cgi/burlesque.cgi?q=%7B1+0+7+6+3+11+15+1+9+2+3+1+5+2+3+4+6+8+1+18%7D20rzj%5C%5C%3C%5D)
[{5 4 1 5 4 8 2 1 5 4 0 7 7}20rzj\\<]](http://eso.mroman.ch/cgi/burlesque.cgi?q=%7B5%204%201%205%204%208%202%201%205%204%200%207%207%7D20rzj%5C%5C%3C%5D)
[Answer]
# Bash+coreutils, 23 bytes
```
seq 0 20|egrep -vwm1 $1
```
This assumes input as a `|` (pipe) separated list. E.g:
```
$ ./mex.sh "5|4|1|5|4|8|2|1|5|4|0|7|7"
3
$
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 7 bytes
```
Ṁ‘‘Ḷḟ⁸Ḣ
```
[Try it online!](https://tio.run/nexus/jelly#PY27DYAwDERrmCIDpCCET5gFZRegYQU6JGpqFGomSRYJ5iwjWafL@fyS4z2laaOJ4YphT3OI4cjPmpYz57EsRuM1aQWttWJjtTLkoeQtQggFtQStVg0qbBxW/5Ouexrh8YrxlbCZ9gONXHX41nyNFq2BW4Jn36DomOR86V8 "Jelly – TIO Nexus")
## How it works
```
Ṁ‘‘Ḷḟ⁸Ḣ  Main Link; argument is z
Ṁ‘‘      Takes 2 above the largest element in z
   Ḷ     Takes lowered range (thus returning [0, ..., max(z) + 1])
    ḟ⁸   Exclude all elements from the range that are also in z
      Ḣ  Take the first element (which is the smallest)
```
Thanks to @LeakyNun for -1 byte!
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `gH`, 2 bytes
```
ʀ⊍
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyJnQUgiLCIiLCLKgOKKjSIsIiIsIlsxXVxuWzBdXG5bMiwgMF1cblszLCAxLCAwLCAxLCAzLCAzXVxuW11cblsxLCAyLCAzXVxuWzUsIDQsIDEsIDUsIDQsIDgsIDIsIDEsIDUsIDQsIDAsIDcsIDddXG5bMywgMiwgMSwgMF1cblswLCAwLCAxLCAxLCAyLCAyLCAzXVxuWzEsIDAsIDcsIDYsIDMsIDExLCAxNSwgMSwgOSwgMiwgMywgMSwgNSwgMiwgMywgNCwgNiwgOCwgMSwgMThdIl0=) (Includes test cases)
```
   # H flag presets the stack to 100
ʀ  # inclusive range 0..100
 ⊍ # set difference
   # g flag takes the minimum of the top of stack after execution
   # which is implicitly output
```
[Answer]
# [Nekomata](https://github.com/AlephAlpha/Nekomata), 2 bytes
```
ᵏf
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m70iLzU7PzexJHFZtJJurlLsgqWlJWm6Fksebu1PW1KclFwMFVhwc2e0YSxXtAEQG-kogChjHQVDIAtMAtnGQCEgAnKMIBxTHQUTsCSEYQGWgHOB-syBCGIORAJkqAHMRIg5UKMMYerNwFYZguRNwWosIWpgBkPYJmCFFhBzLGIhPgAA)
```
ᵏf
ᵏ   Find the first natural number n such that:
 f  the input does not contain n
```
[Answer]
# [Trilangle](https://github.com/bbrk24/Trilangle/), 53 bytes
```
'0.<_.\.>?0e#L_'\r/(&\,<.|.1.2S<.^#':2',.<..^\,!@.^)S
```
I'm not convinced this is optimal, but I've thought about it for a while and I don't think I can shrink it without substantial restructuring. I have proven that it's impossible to do this general approach without at *least* a grid of size n=8, and this is n=10.
Try it on [the online interpreter](https://bbrk24.github.io/Trilangle/?i=1%200%207%206%203%2011%2015%201%209%202%203%201%205%202%203%204%206%208%201%2018#%270.%3C_.%5C.%3E%3F0e%23L_%27%5Cr%2F(%26%5C%2C%3C.%7C.1.2S%3C.%5E%23%27%3A2%27%2C.%3C..%5E%5C%2C!%40.%5E)S)!
Unfolds to this:
```
         '
        0 .
       < _ .
      \ . > ?
     0 e # L _
    ' \ r / ( &
   \ , < . | . 1
  . 2 S < . ^ # '
 : 2 ' , . < . . ^
\ , ! @ . ^ ) S . .
```
[![](https://i.stack.imgur.com/z7nES.png)](https://i.stack.imgur.com/z7nES.png)
Equivalent to this C code:
```
#include <stdio.h>
// Read an integer from stdin, throwing out any separators. Returns -1 on EOF.
// Exact implementation is unimportant (and provided by the interpreter).
extern int getint(void);
int main() {
    // RED PATH
    // Keep a bitfield of the numbers that have been seen so far
    int field = 0;
    int i;
    while ((i = getint()) >= 0)
        // GREEN PATH
        field |= 1 << i;
    // BLUE PATH
    // Find the lowest nonzero bit
    int missing = 0;
    while (field & 1) {
        // MAGENTA PATH
        field >>= 1;
        ++missing;
    }
    // YELLOW PATH
    printf("%d\n", missing);
}
```
I am not doing an instruction-by-instruction walkthrough of this code. If you're interested, you can look into the disassembly feature of the interpreter.
[Answer]
## Ruby, 32 bytes
```
f=->n{(0..20).find{|i|n-[i]==n}}
```
Defines a function `f` to be called with an array.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 7 bytes
Another approach. Can be used in a chain with any arity, and doesn't need chain separator or anything.
```
‘Ṭ;0i0’
```
Because the answer is guaranteed to be less than 256, this also works:
# [Jelly](https://github.com/DennisMitchell/jelly), 5 bytes
```
⁹ḶḟµḢ
```
[Try it online!](https://tio.run/##ASUA2v9qZWxsef//4oG54bi24bifwrXhuKL///9bMCwxLDIsMyw1LDdd "Jelly – Try It Online")
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf), ~~5~~ 4 bytes
```
Jr,╓
```
[Try it online!](https://tio.run/##y00syUjPz0n7/9@rSOfR1Mn//0cb6JjrGOoY6RjrWOiY6JjFAgA "MathGolf – Try It Online")
This solution is restricted to just the range 0 to 20, though this can be extended easily by increasing the initial range.
### Explanation:
```
Jr     Range from 0 to 20
  ,    Remove elements from the input list from this range
   ╓   Return the minimum element
```
Alternatively, a 5 byte solution for all numbers:
```
Åï╧▲ï
```
[Try it online!](https://tio.run/##ASkA1v9tYXRoZ29sZv//w4XDr@KVp@KWssOv//9bMCw3LDEsMiwzLDgsNCw2XQ "MathGolf – Try It Online")
### Explanation:
```
Å  ▲   Do while true
  ╧    Does the input contain
 ï     The index of the loop?
    ï  Push the number of iterations of the last loop
```
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), ~~18~~ 16 bytes
*-2 bytes thanks to nwellnhof*
```
{(0...*∉@_)-1}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYKvwv1rDQE9PT@tRR6dDvKauYe3/4sRKhTSNaAMdQx0jHWMdEx3TWE1rLiRRBQWcokCx/wA "Perl 6 – Try It Online")
Anonymous code block that counts up until it finds a number that is not an element of the input list, and returns the length of the range minus one
[Answer]
# JavaScript (ES6), 33 bytes
Thanks to [@fhuvi](https://codegolf.stackexchange.com/users/116582/fhuvi) for letting me know that [my answer](https://codegolf.stackexchange.com/a/258384/58563) to [this more recent challenge](https://codegolf.stackexchange.com/q/258335/58563) also works here.
```
a=>a.reduce(m=>m+a.includes(m),0)
```
[Try it online!](https://tio.run/##rZLRDoIgFIbvewouYZGCWtmFvkjjgiE2m0rT7PWJILuwrKkxxs7Z2Pef859z5jfeiqa4XDe1yqTOE82TlHuNzDohYZWk1Zp7RS3KLpMtrBAmSAtVt6qUXqlOMIdHysCCgxDwfUBWAyj5A5QOoQEGC7gj0BADarj2NXHIZkCDIXRR92OemgKDyQX@gm4xiGzvLoitxis1tuzNZd@h4QdPHWXWuBw0elupfkrOh4lWjEBp3@POTp8@8FsrcXASvRkujuzH2JURs@dKEX0H "JavaScript (Node.js) – Try It Online")
[Answer]
# [Rust](https://www.rust-lang.org/), ~~117, 113, 79~~ 78 bytes
```
|l:&[u8]|{let mut r:Vec<_>=(0..22).collect();r.retain(|n|!l.contains(n));r[0]}
```
[Attempt This Online!](https://ato.pxeger.com/run?1=jVK7boMwFJW6ma8wGSJboggT0tCkaZfOHbsgFCFkJCTitNh0Ab6kS4b2o9qv6bUN6YMMtZCx7zn3nGPpvr7VjVTHz4v7QuB9VgpCces4qOIKKy7VLs8kl3iLEwcPi7zw3E1Y6uGAen-qAVTZpBoC9SywgCJgZofzAkjhhHTWCBpC2zDFlh6OjKQ9xIZ6uoLbCj7oXJzLY6k6bjR93ZjVug8BfvEchJDhnkp6ITb6XpmHMq2xNDrXVmcMaM-RIcbWK_YcNAqlnjZgAez_cA3GpFZyaVRXRhhsWTAE0U_WAaIhFJDYyhhjpuMFkwAh-w6QboZxKfD2vVHFZfzx0FXredLEaddqYN8oXK8feX6zu92SwPfDkPr5oap4rgjd1H7NlZ68TnRuBYDQN0kEBQwmqh9US7RxUHGoMdEz6eFMSIpL8XNMW4iVSclrtePPLinIXNep5UI3eqpLoSrhkhlgrQbXdz2F8W6B0c80p3cGw-PR_r8A)
## Explanation
```
|l: &[u8]| {
    // Make a vector of the integers from 0 to 21
    let mut r: Vec<_> = (0..22).collect();
    // Keep only the numbers that aren't in the input
    r.retain(|n|!l.contains(n));
    // Return the first remaining number in the vector
    r[0]
}
```
[Answer]
## GolfScript (10 9 bytes)
```
~.,),^$0=
```
Takes input from stdin in the format `[5 4 1 5 4 8 2 1 5 4 0 7 7]`.
[Online demo](http://golfscript.apphb.com/?c=OydbNSA0IDEgNSA0IDggMiAxIDUgNCAwIDcgN10nCgp%2BLiwpLF4kMD0%3D)
[Answer]
# Xojo, 55 bytes
```
dim x as int8
while a.indexOf(x)>-1
x=x+1
wend
return x
```
[Answer]
# Ruby, 22
```
x=->n{([*0..20]-n)[0]}
```
## Explanation
* Input is taken as an argument to a lambda. It expects an `Array` of `Integer`s.
* The input is subtracted from the array `[0,1,2..20]`.
* Because the `Array` `[0,1,2..20]` is sorted, the first element must be the mex.
[Answer]
# Haskell, 30
```
f s=filter(`notElem`s)[0..]!!0
```
This works for lists of all size and lists beyond 20. This can be made 15 bytes long if Data.List is imported:
```
f s=[0..]\\s!!0
```
[Answer]
## Scheme - 219
```
(define (A X) (define (B X) (if (equal? (length X) 1) (+ (car X) 1) (if (< (- (cadr X) (car X)) 2) (B (cdr X)) (+ (car X) 1)))) (if (empty? X) `() (if (equal? (car (sort X <)) 0) (B (sort X <)) (- (car (sort X <)) 1))))
```
Not very competitive. But I like writing scheme :),
Here's the ungolfed code:
```
(define (minExclude X)
  (define (firstNonOneDifference X)
     (if (equal? (length X) 1)
         (+ (car X) 1)
     (if (< (- (cadr X) (car X)) 2) 
         (firstNonOneDifference (cdr X))
         (+ (car X) 1)
     ))
  )
  (let ([s (sort X <)])
     (if (empty? X)
         `()
     (if (equal? (car s) 0)
        (firstNonOneDifference s)
        (- (car s) 1)
     ))
  )
)
```
[Answer]
# R, 27 bytes
Reads from stdin; computes the first element in the set difference between `[0..20]` and `x`.
```
x=scan()
setdiff(0:20,x)[1]
```
# R, 36 bytes
`which.min(y%in%x)` returns the index of the first element of `y` that is not in `x`.
```
x=scan()
y=0:20
y[which.min(y%in%x)]
```
[Answer]
# [Perl 5](https://www.perl.org/) `-p`, 28 bytes
```
$#i++;/\b$#i\b/&&redo;$_=$#i
```
[Try it online!](https://tio.run/##K0gtyjH9/19FOVNb21o/JgnIiEnSV1MrSk3Jt1aJtwXy//83VrBQMFQwUDBRMFIwVzD7l19QkpmfV/xftwAA "Perl 5 – Try It Online")
[Answer]
# Powershell, 28 bytes
```
for(;+$i-in$args){$i++}+$i
```
Test script:
```
$f = {
 for(;+$i-in$args){$i++}+$i
#for(;$i++-in$args){}(--$i)   # alternative version
}
@(
    ,(0 , 1)
    ,(1 , 0)
    ,(2 , 3, 1, 0, 1, 3, 3)
    ,(0 )
    ,(0 , 1, 2, 3)
    ,(3 , 5, 4, 1, 5, 4, 8, 2, 1, 5, 4, 0, 7, 7)
    ,(4 , 3, 2, 1, 0)
    ,(4 , 0, 0, 1, 1, 2, 2, 3)
    ,(10, 1, 0, 7, 6, 3, 11, 15, 1, 9, 2, 3, 1, 5, 2, 3, 4, 6, 8, 1, 18)
) | % {
    $e, $a = $_
    $r = &$f @a
    "$($r-eq$e): $r"
}
```
Output:
```
True: 0
True: 1
True: 2
True: 0
True: 0
True: 3
True: 4
True: 4
True: 10
```
Explanation:
* Increment `$i` while the `$args` array contains the integer value `+$i`.
* Output a last integer value `+$i`.
[Answer]
# [Prolog (SWI)](http://www.swi-prolog.org), ~~64~~ 35 bytes
*-29 bytes thanks to [@Jo King](https://codegolf.stackexchange.com/users/76162/jo-king)*
```
L+X:-between(0,20,X),\+member(X,L).
```
[Try it online!](https://tio.run/##PY/LCoMwEEV/JbhKcFLiq7UuBPd@QCDNQiEtgo@ggjt/3Y5JLUwyd3JvToidp3768GXrjqMOZcFbs27GjFRALEAyeIWDGVozUwk1ux0FHxrbd8tKVaXLklahhPc0D81Kg90SXpLd7mMAqgKpGQOlIg1K4IqBnC0BEqFyO@oEj7BwiP2QAUmd6UXujP@I9x5YnuONEyououf8UNGVv7unotPPXObpMxfY69QFc8/JtcbffgE "Prolog (SWI) – Try It Online")
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `r`, ~~7~~ ~~5~~ 4 bytes
```
₇ʀFg
```
*-2 bytes thanks to lyxal*
*-1 byte thanks to Steffan*
[Try it online](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLigofKgCRGZyIsIiIsIlszLCAxLCAwLCAxLCAzLCAzXSJd) or [verify all test cases](https://vyxal.pythonanywhere.com/#WyJyQSIsIiIsIuKCh8qARmciLCIiLCJbMV1cblswXVxuWzIsIDBdXG5bMywgMSwgMCwgMSwgMywgM11cbltdXG5bMSwgMiwgM11cbls1LCA0LCAxLCA1LCA0LCA4LCAyLCAxLCA1LCA0LCAwLCA3LCA3XVxuWzMsIDIsIDEsIDBdXG5bMCwgMCwgMSwgMSwgMiwgMiwgM11cblsxLCAwLCA3LCA2LCAzLCAxMSwgMTUsIDEsIDksIDIsIDMsIDEsIDUsIDIsIDMsIDQsIDYsIDgsIDEsIDE4XSJd).
Explanation:
```
 ʀ    # The range 0 to
₇     # 128
  F   # Filter out items from the range that are in the input list
      # (The r flag swaps the arguments)
    g  # Get the lowest one
```
[Answer]
# [Thunno](https://github.com/Thunno/Thunno), \$ 9 \log\_{256}(96) \approx \$ 7.41 bytes
```
21RAq0sAh
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72sJKM0Ly9_wYKlpSVpuhYrjQyDHAsNih0zIHyo8IKb9tGGOgoGOgrmOgpmOgrGOgqGQL6hKRDrKFjqKBhBxHQUTGFsE7BCC7CgoUUsxBwA)
#### Explanation
```
21RAq0sAh  # Implicit input                     INPUT: [4, 1, 0, 2]
21R        # Push range(21)                     STACK: [4, 1, 0, 2], [0..20]
   Aq      # Check whether each of the items    STACK: [1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
           # in the input occurs in range(21)
     0sAh  # Find the index of the first 0      STACK: 3
           # (0-indexed)
           # Implicit output
```
[Answer]
# [Julia 0.6](http://julialang.org/), 22 bytes
```
>(x,i=0)=i∈x?x>i+1:i
```
[Try it online!](https://tio.run/##yyrNyUw0@//fTqNCJ9PWQNM281FHR4V9hV2mtqFV5n9lBdeKxNyCnFQuh@KM/HIFO41oQx0FIx0F41hNLi5lhZDU4pJiLofE4uLUohKwbKymgq2tggGymAFEzBBZDGgENmFjHQWg@QZg0hhsC0iJEbISLBbAnYQhY6qjYAI2DMKwACuEc4H2mAMRRJ8xmjsgCqGONEHxD8yFEHsRVpugOQpivhnYK4Yg9aZgPZYQPTCHQNgmYIUWEHMtoEFj8B8A "Julia 0.6 – Try It Online")
Minimally adapted from [MarcMush's recursive solution](https://codegolf.stackexchange.com/a/258847/114865) to a [related challenge](https://codegolf.stackexchange.com/q/258335/114865).
Julia 0.6 supports ternary operators without spaces, which were deprecated in 0.7 and removed in 1.0.
]