[Question]
  [
Given an integer, output a [truthy](http://meta.codegolf.stackexchange.com/questions/2190/interpretation-of-truthy-falsey) value if it is the same upside-down (rotated 180¬∞) or a [falsy](http://meta.codegolf.stackexchange.com/questions/2190/interpretation-of-truthy-falsey) value otherwise.
`0`, `1`, and `8` have rotational symmetry. `6` becomes `9` and vice versa.
Sequence of numbers producing truthy results: [OEIS A000787](https://oeis.org/A000787)
```
0, 1, 8, 11, 69, 88, 96, 101, 111, 181, 609, 619, 689, 808, 818, 888, 906, 916, 986, 1001, 1111, 1691, 1881, 1961, 6009, 6119, 6699, 6889, 6969, 8008, 8118, 8698, 8888, 8968, 9006, 9116, 9696, 9886, 9966, 10001, 10101, 10801, 11011, 11111, 11811, 16091, ...
```
This question is inspired by my own reputation at the time of posting: `6009`.
  
[Answer]
## Python 2, 50 bytes
```
lambda n:`n`==`map('01xxxx9x86'.find,`n`)`[-2::-3]
```
The method `'01xxxx9x86'.find` takes a digit character to it's upside-down number, with any unflippable digit giving `-1`. This function is mapped to the reversed number string, producing a list of digits.
This is converted to a string with the [`[1::3]` trick](https://codegolf.stackexchange.com/a/49791/20260), except it's reversed instead by doing `[-2::-3]` (thanks to Dennis for this, saving 4 bytes), and compared to the original number string. Any `-1`'s from unflippable digits will misalign the conversion, making it fail.
---
**56 bytes:**
```
lambda n:`n`[::-1]==`n`.translate('01xxxx9x86______'*16)
```
Checks if the number string reversed is the same as it with the upside-down replacements. Digits that can't be flipped are replaced with `'x'` to always give the wrong answer.
The replacement is done with `translate` on a string of 256 chars, replacing the corresponding ASCII values. Only the 10 values `48` to `57` matter, but I padded to length 16 to make the total length be 256. I wonder if there's a shorter way.
Some other approaches (lengths 59, 60, 60):
```
lambda n:set(zip(`n`,`n`[::-1]))<=set(zip('01896','01869'))
r=lambda s:set(zip(s,s[::-1]));lambda n:r(`n`)<=r('9018106')
lambda n:all(a+b in'001188969'for a,b in zip(`n`,`n`[::-1]))
```
[Answer]
# Regex (ECMAScript / Python), ~~366~~ ~~323~~ ~~254~~ ~~201~~ ~~180~~ ~~148~~ 135 bytes
`^(x$|x{8}$|(?=.*?(?=(((x*)\4{8}(?=\4$))+x$))(x*)\5{99})(?=(\2x)(|\6{5}(\6\6|\2{3}|xxx))(?!\2)(x*)\9{9}$)(?=(x*(?=\5|$))(|\5x)\9$)\10)*$`
Takes its input in unary, as the length of a string of `x`s.
[Try it online!](https://tio.run/##TU9dT8IwFP0rQBa4d8jYEIgwC08@@MKDPlpNGiijWsrSFqis@@3YYUx8Ock9Xzfnk52YWWtR2oEpxYbr/UF98e@rJoqfWy@8eHIlwIUshvH1A1zkXfVQRx6WJImXAQHAxUjHgQ0XHUeIfRfgxk6q2azGxkVHDsHTaTWpgU7p1NNRdV9751ywLtt09BuYVbM6ugVc3NRNfFPl6cQFLUKapRhH13h4wcQeXq0WqgBMjBRrDtO7wRgxNyTNzzshOYAkmrONFIoDYpuoo5RYFUQmppTCQm/Qw1xsARQpEslVYXe4GHkvzIqtQJCSacOflYXiLX1H/BP4f0EtsmU2b2S0O304d57ViUmxaWmmCj5vdfoy3x405OKR8Fz0@xgedlwn0bzkzILAZM/segcasTLdbhkmWWhWZHl5tMbqYMnr@poOsjRNfwA "JavaScript (SpiderMonkey) ‚Äì Try It Online") - ECMAScript  
[Try it online!](https://tio.run/##TY7RboMgFIbvfQpGvACrBm110470JXZXbNKsdGVhaMAmNOKzO7C72M0JnO///pzhMd56tV3Ez9DrEZiHSTVPv02v9kBTDSFcTsjGzk5vc@zQgebJwU@EkE0w2/mt/7FdjPHG@rFuq6lpZhxSrLQYOVZP1YxYzWrHymk7O2utjx5eWPkUmqmZ41WwSairXKhyrLKexZgVBCfx4m85Fm1WdHsgKImuvQYSCBVuzs14EaqNgKQyN4MUI4IZxBEQVyC5QhK/ly2Qx6Kj8ki6CARZBVmf1RdHQo0oAJw@X0WHNwX2faFA89zws/68IZ0CaGGiVhKQaMGgg3KVd3OjH/rO8Yposf8jZtRI4RRwdaEQpuBfciFZSUhUE5K9EvIL "Python 3 ‚Äì Try It Online") - Python  
[Try it on replit.com!](https://replit.com/@Davidebyzero/regex-Rotationally-symmetric-numbers-01689) - RegexMathEngine (much faster), in ECMAScript mode
It's impossible for a ECMAScript regex to match the sequence in decimal, but as demonstrated here, it's possible in unary.
The regex works by looping the following logic:
1. Carve away both the leading and trailing digit if they are an allowed pair, or (for single-digit values) an allowed single digit.
2. Prevent the value sent to the next iteration from having any leading zeroes, since the regex operates on numbers, not strings, so any leading zeroes would be stripped. If it has a leading zero, add \$1\$ to both the leading and trailing digit. If both were zero, both will be changed to \$1\$, preserving the trait of symmetry. If the trailing digit was nonzero (meaning the input is not a rotationally symmetric number), adding one of \$11, 101, 1001, ...\$ is guaranteed not to change it to one that is symmetric, because for example \$1001\$ could only be added to any number in the range \$0001\$ to \$0999\$ with a nonzero last digit, which can only yield a number in the range \$1002\$ to \$2000\$ with a last digit other than \$1\$, none of which are rotationally symmetric. This allows us to golf off 13 bytes, due to not needing the trailing zero check `(?=(x{10})*$)`.
The 135 byte version has been tested from 0 to 1000000 using [RegexMathEngine](https://github.com/Davidebyzero/RegexMathEngine/) without finding any false positives or negatives. The test took 29.342 hours (single-threaded) on my i7-4930K @ 4.1 GHz.
(This was originally part of [this answer](https://codegolf.stackexchange.com/a/248959/17216) and was split due to being very different in nature. See that post's edit history for changes made prior to the 254 byte length.)
```
^                        # tail = input number
(
    x$                   # If tail==1, let tail=0 and end the loop
|
    x{8}$                # If tail==8, let tail=0 and end the loop
|
    # Assert tail >= 10; find \2 = the largest power of 10 that is <= tail
    (?=
        .*?              # Decrease tail by the minimum necessary to satisfy
                         # the following assertion:
        (?=
            # Assert tail is a power of 10 >= 10; \2 = tail
            (((x*)\4{8}(?=\4$))+x$)
        )
        (x*)\5{99}       # \5 = floor(tail / 100)
    )
    # Require tail is of the form 1.*1, 8.*8, 6.*9, or 9.*6
    (?=
        (\2x)            # \6 = \2 + 1
        (
                         # 1.*1
        |
            \6{5}
            (
                \6\6     # 8.*8
            |
                \2{3}    # 9.*6
            |
                xxx      # 6.*9
            )
        )
        (?!\2)
        (x*)\9{9}$       # Assert tail is divisible by 10;
                         # \9 = tail / 10 == floor((N % \2) / 10)
    )
    # Set tail = \9, but if \9 is of the form 0.*0, the next iteration would
    # not be able to see its leading zero, so change it to the form 1.*1 in
    # that case, otherwise leave it unchanged. If \9 is of the form 0.*[1-9],
    # don't go to the next iteration.
    (?=
        (                # \10 = tool to make tail = \9 or \9 + \5 + 1
            x*
            # Assert that the leading digit of tail is not 0, unless tail==0
            (?=
                \5       # Assert that the leading digit of tail is not 0
            |            # or
                $        # Assert that tail==0
            )
        )
        # Iff necessary to satisfy the above, tail += \5 + 1
        (
        |
            \5x
        )
        \9$              # tail = \9
    )
    \10                  # tail = \9 or \9 + \5 + 1
)*                       # Execute the above loop as many times as possible,
                         # with a minimum of zero iterations.
$                        # Assert tail==0
```
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), ~~22~~ ~~16~~ ~~15~~ 14 bytes
Code:
```
√Ç23457√∞¬´-69√Ç‚Ä°Q
```
[Try it online!](http://05ab1e.tryitonline.net/#code=w4IyMzQ1N8OwwqstNjnDguKAoVE&input=Njg5)
---
Previous code:
```
√Ç69√Ç‚Ä°Q¬π¬π‚Äûvd‚Ä¢√ÉQ*
```
To figure out if the string is rotational symmetric, we just need to transliterate `69` with `96`, reverse the string and check if they are equal. The other thing we need to know is if the number *only* contains the digits `0`, `1`, `8`, `6` and `9`. So that's exactly what we are going to do:
```
√Ç                     # Bifurcate the input, which pushes input and input[::-1]
 69√Ç                  # Bifurcate 69, which pushes 69 and 96.
    ‚Ä°                 # Transliterate 69 with 96 in the input, e.g. 1299 becomes 1266.
     Q                # Check for equality.
      ¬π¬π              # Push input again twice.
        ‚Äûvd‚Ä¢          # Compressed version for 10869.
```
The `‚Äûvd‚Ä¢` part actually converts the string `vd` from *base 190* to *base 10*. You can try this out [here](http://05ab1e.tryitonline.net/#code=4oCedmTigKI&input=).
```
            √É        # Keep the characters of the second string in the first string.
                       667788 would become 6688 (since 7 is not in 10869).
             Q       # Check for equality.
              *      # Multiply the top two numbers, which actually does an AND function.
```
Uses **CP-1252** encoding. [Try it online!](http://05ab1e.tryitonline.net/#code=w4I2OcOC4oChUcK5wrnigJ52ZOKAosODUSo&input=Njg5)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 12 bytes
```
≈æh√Ä‚Ä¢yŒòO√±‚Ä¢‚Ä°RQ
```
[Try it online!](https://tio.run/##yy9OTMpM/f//6L6Mww2PGhZVnpvhf3gjkPGoYWFQ4P//RkZGAA "05AB1E ‚Äì Try It Online")
I somehow managed to beat Adnan's 05AB1E answer lol. This
## Explained
```
≈æh√Ä             # Push "1234567890"
   ‚Ä¢yŒòO√±‚Ä¢       # Push "1000090860"
         ‚Ä°      # Transliterate the input based upon the previous two strings
          RQ    # Check if the reverse of that equals the input
```
[Answer]
# Ruby, 54 46 bytes
```
 ->a{(b=a.to_s).tr('1-9','1w-z9x86').reverse==b}
```
I don't know, is anonymous functions like that allowed or not
Basically same idea as Python2 answer.
If input is not integer, act bad (i.e. `aba` gives `true`)
[Answer]
# Regex (Perl / PCRE2 / Boost / Python[`regex`](https://bitbucket.org/mrabarnett/mrab-regex/src/hg/)), 35 bytes
```
^(([018])((?1)\2|)|6(?1)9|9(?1)6|)$
```
Takes its input in decimal.
[Try it online!](https://tio.run/##RU7LasMwEPyVJYhES2wsGRqaykocSK899Za4Ii0xCNTEldxDkdVfdyU3kD3s7szsY7qzNQ/j5w8QK8Cb68fJAClEhLLa7153mwDt1VLiJBPVRqAH3UaEvrP60sPseJmJALWRrjO6p4t8kbnvd9fHFZXlPON4/kpD2zvLIo9PRKFIt1z8eLK1qUr0tTnwRsbMGnH7q2@Q6EpOcuyWS/S6hSiC/IWC2AI9cfP5ZGlyFO1y8e@QaBFCUOr5Za/U@EbpgfHHBindcjyWAw6r1K2HdSqrAck4srxkKf4A "Perl 5 ‚Äì Try It Online") - Perl  
[Try it online!](https://tio.run/##dVBda8IwFH33V4QQMHe22hbnVmLxZRsIYw/b3qwL2qU2rKYhjTDQ/XZ3I3sSFkhyP84593BtY8/zhW0sYY4UhE4oGRPr1E46ZdtNpfhwMr5ZSNlsWi@rbm91q1zJSxDl66QfRmSIt8ai3KkAMF4Z33Mpn5bPj1JCRFJASRQWA2207JXn1FZOjbeb6ss7fGSr99rTiNBplk/z2V2W31K4hjtVHVyvO/MfvO4cZ7pIBGuLGs30/O39YfkCAo5E15y1q967VhmMIE7XRUFLQwHB/WGLHSxHSRSnEPjq27bdp@I0phHCBfKr7mB84M4zJK1QAN9kLQaEXCabv5yZeXHpYzQaAY4m/LLQ/cZXDWcuYgaAHIMlDapquuBDELSeChJywoz4Qdmfq61zEOcPzldJer8GzhcplNkJTrMQ5ac8fLMTsPM5ibMknF8 "PHP ‚Äì Try It Online") - PCRE2  
[Try it online!](https://tio.run/##XZBvT8IwEMbf71Nc1IRWBjJMiG4MEz@C8YUGcSmlbI2ja9ouk39f3dkWUfBetNfL3T2/PlTKXk5pe8kFLesFg/G8qrS5USxnn/1CyklAC6Igk9MZpPB08dg0H/Pb@nW9fnkuRk2B2neEpoPoboYReojw23CHdyOX3e/u3TXa4asW/x@7COFappnsRknwp82ttGJkNQm4MCCVPTOmVKUQrYQ24FGuV0xrkjO81WYRx9Q2wHgMP1WX@joTizIBxUytBETJ3q9cES4Qhm0ANuTUqpVMIIl70SwdJFDbntthZqByLzeQ28Q3HwC8OXHs3bG7kQzPSnHMKdEMJ8eqXhFDC2gKYg5rlpUC5BZv0kEI3MuM0@HARQLdLj/CufD/sIxc5KCt@/5tquxQQhwnv618CeiUJNOMKFogHXrx0MLi09XHmQ0GWRvnK@q8iY4l36RRcta2bBQ3DOk@dcIIh6D7mm@Yy6LQQVW1OUHZB3/nj/3Ww337RZclyXXbKz1o5jm/AQ "C++ (gcc) ‚Äì Try It Online") - Boost  
[Attempt This Online!](https://ato.pxeger.com/run?1=NY9LTsMwEIb3OcXIsJgRSRRnUbUJEQcJRqrAaY2MHY1dQaXchE03IC7BhltwG-qkzGYe_3zzeP8cj3Hv3enbvIyeI4RjyFnv9Fv-HLxrgTsWQnwc4lCsf68eEPtKrhUh3km6ryeaVinaTJvkVhNdX1p_zlQvm0KqFkxXZYNnsGBcWlCG-GRck4HtbBlGayKKQlAGZgCrHVq6rRuwvVSd7SuVQYJdgnnrdhqNi5gEypdIKrqRdJ6XBszHl0Fv-XGPnEOIjI5mNcmmgZETRnOhk-3_Rf4Qy1c2UeMFWT45fVVFXSVb8j8 "Python - Attempt This Online") - Python `import regex`
```
^              # Assert this is the start of the string
(              # Define (?1) recursive subroutine call
    ([018])    # \2 = match a 0, 1, or 8
    ((?1)\2|)  # Optionally match (?1) followed by \2
|              # or
    6(?1)9
|              # or
    9(?1)6
|              # or
    # Match an empty string
)
$              # Assert this is the end of the string
```
## Regex (Ruby), 43 bytes
```
^(([018])(\g<1>\k<2+0>|)|6\g<1>9|9\g<1>6|)$
```
[Try it online!](https://tio.run/##PY5RS8MwFIXf/RXXISxBG5I@DLc0g@KK@DJh@tbWoCzrgiEracYUin@9Jp0ucBPOd8@5ue748T04ELBRjfpqiVUnWOWvOXHqfXt3hovF0@P6eVM85C8FBy0oh9NeGwVGNMp3VwB6B6ZMWC3EpLITHhqmpIQkac1B2W1wBEK61miPpskU/0WIUbbxe4SzNGTKkA@xS2R3cGBBW4iQ@IPUiFFMSDReZPCNs2wkHcIgfsDxSPR1XLQ9@m4cGBdnQTttPdj/P@IdS8pivZJyeEOopOy@xqhqMrasPrP0li573M9GPe/n4zvr8c0w0CSl8fwC "Ruby ‚Äì Try It Online")
This is a direct port of the Perl/PCRE2/Boost version to Ruby's subroutine call syntax and behavior; `(?1)` has been changed to `\g<1>`, and `\2` to `\k<2+0>`.
In Perl, PCRE, and Boost, the contents of capture groups are passed to deeper recursion levels, but upon return from a subroutine call, all captures are returned to the state they were in before the subroutine was called, i.e. there is no way to pass captures done within a subroutine call back to its caller. But in Ruby, captures *are* passed to the caller. So `\2` will refer to whatever it captured at the deepest recursion level, and so would `\k<2>`. It is possible, however, to refer to a capture's value at a specific recursion level; that is why `\k<2+0>` is used here to refer to its value at the current level.
## Regex (.NET), ~~94~~ ~~77~~ ~~66~~ 53 bytes
```
^((?=([018]|6.*9|9.*6)(?<=(.))).?)+(?<-3>\3)*(?(3)^)$
```
[Try it online!](https://tio.run/##RY/haoNAEIRfRWQhu9o7NEJoYq4G@rtPYA2IvdSDy52cFywxPrvVltL59w2zw05nB@n6Vmo9gxOlk5/yqzocjBzwtJnPiIXAMkmfq8eOR/vHnkc7wuIokBMRLyhegGUv7xlFWGBGZ4J5c3oKX@21U1p@hJTDXST5xTpZNy2CDpQJQJnu5mmEWoBmfaeVD1mYqwtCzRt7M55pH2zXQCygLpNqWgoQjCiV8dWPk4NhWv5xunIc07h2OP5W@6aV/XJBv9adxsEpL1lrez8tL6X5PwfM2GWxVkYGYKZpmhO2TVZ9Aw "PowerShell ‚Äì Try It Online")
Implementing this using .NET's Balancing Groups feature turns out to provide an edge over the 57 byte .NET-compatible version that doesn't use any .NET-specific features.
```
^                 # Assert we're at the beginning of the string
(
    (?=
        # Depending on what the next left-edge digit is, push its corresponding
        # right-edge digit onto the Group 3 stack.
        (
            [018]
        |
            6.*9
        |
            9.*6
        )
        (?<=(.))  # \3 = the right-edge digit (push it onto the Group 3 stack)
    )
    .?
)+
(?<-3>\3)*        # Match all right-edge digits in reverse order as they're
                  # popped from the stack.
(?(3)^)           # Assert that the Group 3 stack is now empty (literally: if
                  # its stack is not empty, assert something impossible, that
                  # we're at the beginning of the string).
$                 # Assert we've reached the end of the string, having matched
                  # all of its characters.
```
## Regex (Perl / PCRE / .NET), ~~106~~ ~~62~~ 57 bytes
```
^((?=([018]|6.*9|9.*6)(?<=(.))).?(?=.*(\3(?(4)\4))))*\4?$
```
[Try it online!](https://tio.run/##RU7LTsMwEPwVq7Jab5qHU0JFsV2nUrly4tYEq6BGsmTaYIcDcsOvBydUYg@rnZndnWlP1twPH98IW4a8ubwfDcIZC1Dw/e5lt@1Rc7EEO0EZ3zLwSDcBgW@tPndoVp1nrEelEa41uiOLZBG7rzfXhRMVJ3mcw@lzXJL/LA08PGIFbPzlguPRloavwJfmkNcidFqzm6@@Qay5mOQwLZfgdYOCiMQPyrDNwGM3n0@RpkQhbs7@EmLN@r5X6ul5r9TwSogU5EDzh/q6TqPNdZNGayCSC5ICQCqDnEakuiOSFFAVgYOoKiQeBpqs6Fi/ "Perl 5 ‚Äì Try It Online") - Perl  
**[Try it online!](https://tio.run/##hVNhb9owEP3Or7iytdgQUFKqqk1IUdcx7QNrJ0SlTcAiFhywFpzIMevawl8fO9vQUlppUT6cz@d3z@@d4zyvT@N4/Y6LOF1MGLTyWLLG7KIUz8YSonwwghB65Q93d79@Nhff7@@/9WendzOy/kFIOyQD1zsbLU8b1fPleaN6Skm7FZIGpbTRxu1GlQybpE1O6PAEc7Q6PGm/X9N9sLID1TyM8poXlJ6JFGrCM81kNyW5mL7M8QyzbDx/XXdR4kJBjqGKmJSZJHEmCgXmZtU5K4rxlNFH7OP7MRZAqwWbrA5NnolJGoBkaiEFeMHKQM7HXBAKjyXALx9gt5QJktO6NwrdABZY0zyOFGR6pQ9MMTDFBtOyw418oQLQekNVsgB22SGdXEl7WrJikSob63skScGUA9lCYdupmtmd7DeLVSYHzZFthaihAY/ibJ7zlJHcga9XvU708aZ/2e3C0q5u@5/OHDiyDW2w7eBSC8UTIAeS0a0OidE0IXgbrHagrIEMNQljZGKOw@HEh8NiKNDdHUzbZwOc4AGiyT9opYw4U6ZSLhixrnDhWJ1ogDXeVnNDCo8JF@84VhknpqgRR6gtodQB4TmQZwVu252Eiwmp1CubxvoTnhYIaw7CXV98X@hk@w1cqJn6GiARH5s/Yz1dhIdCe94KhRdArcZ3Ge8PgGZn1iqLbIrwHX7WRG391kj2h8VEMgeub7tdB4otLx0W/IHpyDX/ZhgcaO4Bais3oBchuLBcbnugCmYeOr3eTS@6vvly2b/6vE9/C/FAAXXRo0oqQ1Gx7gSvSq2JOKj6PfHgTahN@xaSOTr6D5kXeGUfOnrkyi9xV28LuGOWrViVzMD6dhAlY8iEPj31zZsrrdZu/djV3984ScfTYl1PtRf/AA "C++ (gcc) ‚Äì Try It Online") - PCRE1**  
[Try it online!](https://tio.run/##dVBdS8MwFH33V4QQ2L2169pZpyUrfVFBEB/Ut3WGWTMb7NKQZiCov33eDp8EA7ncj3POPVzXusOycq1jwrOS8RlnCXNevymvXbdpNExmSVQp1W66oJp@50ynfQ01yvphNkxiNqG/paZ60yPABm3DAErd3N5dK4Uxy5AkSVieGGvUoANw13idvGya9@ApqM7sTOAx4/m8yIvFxbw45/gX7nWz94Pp7X/wbe9BmDKVoiu3ZGaAx6er23uU@MnMFkS3GoLvtKUMp9m6LHltORJ42L/QhNpxGk8zHPn6w3X9qwY@5THBJfGbfm/DyF3OibQiAYrpWp4wdtxsf2thl@VxTtnpKdJqBseD7jahaUH4WFhE9jlaMqibth99SEbWM8nGmgkrv0n2@8/VAeXhGaAqYZVml@uvRRIVX0USLRCqZQkJIiYVjZMI6jOoIMc6px5GdV6JwyGdztPx/QA "PHP ‚Äì Try It Online") - PCRE2  
[Try it online!](https://tio.run/##RY9ha4MwEIb/ishBL7oE7aSsdcHCPu8XqIPg0hnIEokpjlp/u4sbY/ftee7u5W6wk3RjL7VewfHayQ/51Z5ORk543q1viBXHOsuf2vuBJcf7kSUHgtUzR0YIYVVoswSbR6ywIE0RHEmaooJ1d36IX@znoLR8j0kJN56VF@uk6HoEHSkTgTLD1ZMZBAdNx0ErH9O4VBcEwTp7NZ5qH@23gZSDqLN2CQEIhtfK@PbHlGColn@cb5ymZN4yHHsVvuvlGDbIr7qReXLKS9rb0S/hpLz854gaG77WysgIzLIsa0b32Vbf "PowerShell ‚Äì Try It Online") - .NET
In PCRE1, subroutine calls are atomic, which prevents the Perl/PCRE2/Boost version (which requires backtracking to extend into nested subroutine calls) from working. As for .NET (and Java), subroutine calls are not supported.
In this version, instead of using recursion, we read inward from the left and right edges, one pair of characters at a time, remembering the right-edge position using capture group `\4`. A set of alternatives followed by a lookbehind is used to set the required right-edge digit based on whether the left-edge digit was `[018]`, `6`, or `9`.
```
^
(
    # Depending on the next left digit, capture the required right digit in \3
    (?=
        (
            [018]
        |
            6.*9
        |
            9.*6
        )
        (?<=(.))       # Capture the previous character (the right digit) in \3
    )
    .?
    (?=
        .*
        (              # Capture \4 as the following:
            \3
            # Match \4 iff it has been captured (i.e., iff this is not the
            # first iteration). As such, \4 will be prepended with the current
            # right digit.
            (?(4)\4)
        )
    )
)*
\4?
$
```
## Regex (Perl / PCRE / Java / .NET), ~~113~~ ~~76~~ ~~69~~ 64 bytes
```
^((?=([018]|6.*9|9.*6)(?<=(.))).?(?=.*(\3(\6\4|(?!\6))())))*\4?$
```
[Try it online!](https://tio.run/##RU7LTsMwEPwVU1mtN83DKSWiOG5SqVw5cauDVVAjWTJtsMMBOeHXg5NWYg@rnZndnWlORj8Mnz8IG4acvnwcNcIJ85Dn@93rbtuj@mIItpyyfMvAIVV7BK4x6tyimTjPWI9KzW2jVUsW0SK03@@29ScyjNIwhdPXuFT8s9Tz8IQlsPGX9Y5HU@p8Ba7Uh7TivtOK3XzVDWKV80n203IJTtXIi4j/ogSbBBy28/kUaUrk46bsmhAr1ve9lM8veymHN0IKTg40fay6LA423SYOMiBFzkkMAHHh5Tgg4p6ITKw7UtyJDIB4CQKxLvAw0GhFx/oD "Perl 5 ‚Äì Try It Online") - Perl  
[Try it online!](https://tio.run/##hVNhb9owEP3Or7iytdgQUFIq1CakqOs67QNrJ0SlTcAiFhywFpzIMevawl8fO9vQUlppUT6cz@d3z@@d4zyvT@N4/Y6LOF1MGLTzWLLG7LwUz8YSonwwghB65Q93d79@Nhff7@@/9WetuxlZ/yCkE5KB652Olq1G9Wx51qi2KOm0Q9KglDY6uN2okmGTDFvDkyXpHAxblBLcotXhSef9mu5jlh2o5mGU17yg9MynUBOeaUK7KcnF9GWOZ5hl4/nruvMSFwpyDFXEpMwkiTNRKDAXrM5ZUYynjD5iH9@PsQDabdhkdWjyTEzSACRTCynAC1YGcj7mglB4LAF@@QC7pUyQnNa9UegGsMCa5nGkINMrfWCKgSk2mJYdbuQLFYCWHaqSBbDLDunkStrTkhWLVNlY3yNJCqYcyBYK207VzO5kv1msMjlojmwrRA0NeBRn85ynjOQOfL3sXUUfb/oX3S4s7eq2/@nUgSPb0AbbDi61UDwBciAZ3eqQGE0TgrfBagfKGshQkzBGJuY4HE58OCyGAt3dwbR9NsAJHiCa/INWyogzZSrlghHrCheO1YkGWONtNTek8Jhw8Y5jlXFiihpxhNripDkgPAfyrMBtu5NwMSGVemXTWH/C0wJhzUG464vvC53svIELNVNfAyTiY/NnrKeL8FBoz9uh8AKo1fgu4/0B0OzMWmWRTRG@w8@aqK3fGsn@sJhI5sD1bbfrQLHlpcOCPzAduebfDIMDzT1AbeUG9DwEF5bLbQ9UwczDVa9304uub75c9C8/79PfQjxQQF30qJLKUFSsO8GrUmsiDqp@Tzx4E2rTvo1kjo7@Q@YFXtmHKz1y5Ze4q7cF3DHLVqxKZmB9O4iSMWRCn5765s2VVmu3fuzq72@cpONpsa6n2ot/ "C++ (gcc) ‚Äì Try It Online") - PCRE1  
[Try it online!](https://tio.run/##dVBNa@MwEL33V6hCkBnXcexs6q5RjC@7hULZw7a3KCtSr1KLdWQhK7DQ9Len47Cnwgo0zMd7bx7jO39eN77zTARWM77gLGM@mFcdjO93rYHZIksarbtdH3U7HLztTVCgUKqfi3GWshn9PTX1q5kALhoXR9D6/uHxu9aYsgJJkoTllXVWjyYC920w2cuu/RMDBd3bg408ZXy1rFZVebesbjl@hgfTHsNoB/c/@H4IIGydS9HXezIzwtPzt4cfKPGN2T2IfjPG0BtHGc6LbV1z5TgSeDy@0ITaaZ7OC5z45q/vh98G@JynBJfEb4ejixN3vSTShgQo5lt5xdhls/tXC7euL3PKbm6QVjO4HPSwi20HIqTCIbK3yZJF03bD5EMysl5INtVMOPlOsu@frg4oz78Amho2efF1eyqzpDpVWVIiNOsaMkTMGhpnCagvoEq1OkFzrUpEoBEmatWI8zmfL/PpfQA "PHP ‚Äì Try It Online") - PCRE2  
**[Try it online!](https://tio.run/##bVJhT9swEP3OrziiTZwDmJahaixElSZt0qQxTevHtpPcxmkNjpPZF9pR@O3duc02kOov57v3/Hzv7Dv1oM7vivutqZraE9xxLk0t0wxeVloy9mDN64VeM3LUtDNr5jC3KgS4VcbBBrpaIEUcHmpTQMUIjsgbtwDlF2E8FUBLX68CfFrPdUOm5pNHAJ@N1VDmTq92W0zkvC60ZDwR2ce2LLXXxQ@tCu1htqO9LuLfk11aCpF194YzylbLqI8Y8hl7UMVX4zQKcZy71lphSgxS/2qVDZhcpGmaCLF5Td0rINJBgQ0r0D8FFrhghRnz7rNwmp9M3EmMlD3va8/fFZH2Dnze7dht1cQLgsh4GrO6tlo5eMxLVtQZjObKObZuXNMS5BDddjUc/Q6kK2mcyKDzuaPJpQrf9Jq4zd2IAbqBWO6dNfYkx4zOYoePp2AZjiwZGmsIk3N@BOYTuB4jXxzxN/CyUT5oTtCOe1NxBq5/EJRWuwUtby5hCJEJHzj0pzujAGXtY78snbteBu4md30Op6fcdNfv@oUs1fsiRre3iuZLnkrFBC@rfYbr2GsJWMnSuILdx9d5FN2Yava88oY0xmcR2WNOvo0T/g83fAGVmLwNCZsS2XNcR/FfbH8iDnMc9/rvp08DmV4/Xct0IHB4k6MUQsghwzLFyTucDCZXTzg8ngyE4B6ESCdXwzfb@De2vfPLXlx/AA "Java (JDK) ‚Äì Try It Online") - Java**  
[Try it online!](https://tio.run/##RY/haoQwEIRfxUrgdrUJej2kdzZ40N99AvVAbK4G0kRiDsupz25jS@n@@2Z2h9nejMIOnVBqJZaXVnyIr/p00mKE8269ABQcyiR9rueMRcf5yKIMoXjhwBCRFd5mEVRPUGXVYYbiocoQwVsYVYeCrLvzY/hqPnupxHuIObnzJL8aK5q2A6ICqQMidX9zOJGGE0WHXkkX0jCXVyANa81NO6pcsN8WYk6aMqkXHwBE81JqV/8oOdFUiT9ON45jnLYMy94a13Zi8Bf4K91xGq10gnZmcIuvlOb/HFBt/PNKahEQvSzLmtB9ss03 "PowerShell ‚Äì Try It Online") - .NET
This is a port of the Perl/PCRE/.NET version, removing the use of the conditional due to their lack in Java, and emulating it with an empty capture whose set/unset status can be detected. Only the modified portion is shown below:
```
            # Match \4 iff it has been captured (i.e., iff this is not the
            # first iteration). As such, \4 will be prepended with the current
            # right digit.
            (
                \6\4
            |
                (?!\6)
            )
            ()         # \6 = set and empty, to signal \4 is captured
```
[Answer]
## JavaScript (ES6), 56 bytes
```
n=>n==[...''+n].reverse().map(c=>'0100009086'[c]).join``
```
[Answer]
# sh, ~~40~~ 33 bytes
```
[ `rev<<<$1|tr 6923457 96` = $1 ]
```
Input via command line argument, output via exit code. Generate all testcases:
```
for i in `seq 0 10000`
do
  if [ `rev<<<$i|tr 6923457 96` = $i ]
  then
    echo $i
  fi
done
```
[Answer]
## [Retina](https://github.com/mbuettner/retina), ~~40~~ ~~38~~ 33 bytes
```
$
;$_
T`92-7`69`;.+
+`(.);\1
;
^;
```
[Try it online!](http://retina.tryitonline.net/#code=JAo7JF8KVGA5Mi03YDY5YDsuKworYCguKTtcMQo7Cl47&input=MTYxMDg4MDE5MQ)
### Explanation
This uses a completely different approach from the other Retina answer. Instead of removing all symmetric parts, we simply perform the transformation of reversing the string and swapping `6` and `9`s and then compare for equality. To make sure that no non-symmetric digits appear we also turn them into `9`s in one half.
```
$
;$_
```
We duplicate the input by matching the end of the string and inserting `;` followed by the entire input.
```
T`92-7`69`;.+
```
This performs a character transliteration only on the second half by matching it with `;.+`. The two transliteration sets expand to:
```
9234567
6999999
```
Because `2-7` denotes a range and the target set is padded with the last character to match the length of the source set. Hence, the stage swaps `6` and `9` and also turns all of `23457` into `9`s.
```
+`(.);\1
;
```
Repeatedly (`+`) remove a pair of identical characters around the `;`. This will either continue until only the `;` is left or until the two characters around the `;` are no longer identical, which would mean that the strings aren't the reverse of each other.
```
^;
```
Check whether the first character is `;` and print `0` or `1` accordingly.
[Answer]
# [Knight](https://github.com/knight-lang/knight-lang), 70 bytes
```
;=p=sP;=a'';Ws;=a+I|?54=bAs?57bA-111bI||?48b?49b?56bAb''a=sSsF1''O?a p
```
Working with strings is a pain in Knight
[Try It Online!](https://tio.run/##lVhpd9s2Fv3eX0GzqUWINC3lOGktmtZxXKfHZxo5E7vNmZGUCAAhiQ1FKlxspyLnr3sewA3U5vRLIgIXb8N9C/wXvscRDd1lfOQHDnuiHo4i5V@@O5vHV2EYhAp7jJnvRIr4WmU54D0OI9bcl86UqA@JH7uL53G3ccjwYkUDP4rDhMZBqGG0iuduZEZBElJm4wx23OXHuRuzaIkp04r9BY7pXDv@pA1H49FwFMF61hvr6Y/DTyN/3NZGfvoCofYxypaMfYHdkMVJ6CuS8GFnnKZ@4nlZLowY1O6glcdiBdvEZI@MahIcWYUIfsS2bdznP3oyxJZ@m1FCwHYNgxrTY/4sniMDD@kYZXEAjrv@bKtVWSbCodz95/3VrT0cW3mo/sRewlZRjGOXKkt@CxpBK2JuhMeaQhTvcQg@dCx8JsQU@i2s67l/1BbrQzw2S1mWO9UoKuyhmeRrFia@CHsYPCg@e8gZkTmMJLMt6zu8E0LMehNwg2RBWLgDV24C7k0QeAz7O4DVblaw6ncIRoi9inh56NZIFiVLLt0Qoj47OMbAtdxRSckWZ4rv@tw2T4rvJmjDjXJBhrGvHjevQGDFBauxT1kwzb2W3Dg8lIwHPua/yihw4VUIipBs8Kfkep1Nd2/HaHhx9N9x@9joVpTHh4f8grlMTb1TuTaUOcliWTkzKZ15IfIzQ5PMi@e1Kwe1rYeHuHFtMxmnyLiDJjDLybxMornGV5GVp8rV4M/rDzeDd1eDO3uVFQlz7TA/XuPAc@4P8dHfn8f8387R6WcIwXoAhFAwNtvHJpeDgE3N@Iij7tQFXB6iHMcDBea6M5/LkTwZ1phxRc3c4B0onsH3gesonQN@P6XlVp2gcl3WJn/4X/zgwVfcyjKl1TCtNWnGXLiAyvhK0f1eeo0cfTOkENAiXTBaJ1WxUXMKO47ElfJ8zRkdS6UDZVCD98KPmvBF4u2Ft5twx72Xvay3@E00LqEU9Q7HcxN441NJ6jH4veuS1Evs@0GsgCq4E4V8U/5mYaCCqYHzD3XXCn/Cz@oD8YkXSPqWwcN@fbX4ND3Q8FkHfZfz7fZ3eM8el4HPSYpjJgxS4gBqo89mwLd7poBxLAQjvR2V5Ey@t5315ryBahC/pv0AGuJ@3kvVuyL@oCipKOc8F9IoIWUF4e12LQdUDtaQuq8zCHmF88@EkgYLMJOJI6ZaBeMfnpKDw9fK6EBzfDY4nELExlLPUVtjBHNcNLodt/to1D02Xgpa8WgAs4hMJNDAh5V8iMFmPtxxsNribYmmaUtt8R@odqkeWnnRA6sWrg9McpSvSQCEYj4NEr7MnJ7yYoWzybaWLuxv5pHR7aA07azVrGJA2FezuBOTAlAo3Cw9HFTrMkO2ZBh6j1yBnmF8NWrtZXyFki8VFovuCqewc/vNpz2c2SH7mrgh09RppCJjxUdksUWkLTp3PefzMgwoizjq7R@Dy7vrm8Ft3ZvfQg3Y15olluQXDJN5JWZIpE4nblqaVS2JV/2eyDo9NdFxzhjG52k@H/MPB@Zj54yWs7FTzsZTW1hklqZwZQfTHXR650Lv9mcKDmfJgg8cL1aO3s0UUKJMuZfQUQlvpBbLAztFmXTHPBAaNYjB1kYKWKJrYwUXZ@P8t48XzCb5b1Ad2XRzdhUHNNM0K1RVWfIqrnLtsRv4mqpXUqvwEKUcOcVRrNuqoag6MXMZVRfX1Y3adEP@YjQ23Ujw14BxKZsWqpSQzdwoZsJFtILQdnmvKh9Ia28JTR2AScoigSGPQKI@Yhp73xToBQqd4xC@YGbxAn8GNcmqCYLHNpE0QmCqziVfbZFk8ALViJQHSK499RiVvzesrTRQB4FyzyVDoUw8h9sqVDgHUCulrOIBR0YVAvW9amjIPi@eZKpqEPtNMp2y0MSeF1ANBnAn4EHCWgcY0YGJ3ADKE3hSIgKGf7GoDq4@QMYxrQtdWOyIl5zJc@ujC4mvjnwVIWpTM/JceCF2DOWonuzLSkNRJlv2Ibes0bqnXgC@nrw8PTl9/fPL09dtsRpi3wkWPGzy@SvVwPY5DxluhLaGtC5aHFIleh7ewioidzcwoF@amUsyp2GwuAQGXAYODJrF2wn1SnPl6zRpgbuI@cwmG/lGGInlpct8qXhcin/l7YnYrvpQ07kdjqr/FoeKgmiyR3e9ikvYg0qBeGs1H0AN5O8VknssG1Imk4z@lXPrvBrfGsEuLYtiJ0hi8yGExg0C8zxHBm7E7KYpqNZaSFNHI/E8LMgGTOvvkF@yESCotxUz4b3xhwkyqplJtkQHivIiUl8Xb7SFbw3njzaQ/F2wDdneQPK@vA15vIEUr4EtyJ82ZQbb7fy0gRRT9xbkWYWsqFIe4RNBdUQ@c777zGzXmf7uM7zkbz1zWJ3RcJnXjb/T9ItjvUbmpc8ewz2ymZGWdCzfNbYFzJZgjdrCn7RpCiql530zkbFZvM@JXeknDeEfK@Er3j2tRtJaaC3dtpL5OhcBTd8@x1uDRTd9/006JIJW222QxiPN4OVf@iwrGC7/SsmFpKmqNqN2WyhwhIry0DOqHNvZ1FyBy1bPx/o@1mGqLE2ADod0qtcm6Q7vxXXD@F9LrnjNpzvgIDplFYGJ5X74Ejrh09NT93XntPvDk2Uv7ei9ZeNWy/oYwf/6ddp/dWKTi6j/6mdycdTtdsl1mvZPfiH9k1PSf/WaXJBWC9vRbfS222rd9LGy/D8)
[Test Suite](https://tio.run/##lVhpV9tIFv3c/IpCSWMVEsLOIekBIXwIQ2Y4TUwmkM6ZsZ1Qksq2OnLJ0cLStvqv97ynteQF0nwASXXrbXXfUvzO7ljkhN4s3hOBy/9yfBZF5FfhjSfxeRgGIeEPMRduRLK3eZoDPrAw4s11aU@J@piI2Js@j7uOQ86mcycQURwmThyEKqPzeOJFRhQkocMtlsKKN/s88WIezZjD1WJ9ymJnou5/UfuD4aA/iOB7ejTUFi/6XwZiuKsOxOIlpbv7NJ1x/g1WQx4noSCS8H57uFiIxPfTXJitO1abzn0eE2bZBn/gjirBqVmIwC2WZbEuPhzJEEt6NqLEBttVBmoMn4txPKE66ztDmsYBOO6J8Vqr0jQLB7n574fza6s/NPNQ/cb8hM@jmMWeQ2Z4CqpN57axEh5zBFG8YyH40DbZcSam0G8yTcv9c6zse58NjVKW6Y1Uhxb2OKnkaxomIgt7GNwTwe9zRqQut5Pxmu8bvMuEGPUi4HrJ1ObhBly5CLi3QeBzJjYAq9W0YNUlBCNkfkW8PHRLJIuSGUrXM1FfXRYz4FruqKRkjTPFe71vnSfFexO04kb5QYbx7z6aVyAY8cBqJhwejHKvJTd2diTjgY/5UxkFFF6FoAjJCn9KrtfZdPNuSPune/8b7u7rnYrybGcHDxhlqsqNgtpo6ibTWeXMbenMyyw/U3qb@vGkdmW7tnVnhzWObSzjiIzbbgLTnMyzJJqo@JWaeaqc9367@HjVe3/eu7HmaZEwFy4X8RIHnnO/z/b@@DrE3@29w68QguUAZELB2PQpNnkIAjY145Nt9UYe4PIQ5TgMFJjrjQXKkTzp15hhRc3c4A0ozOC7wHNJexvPp7TcrBNUrsvq7SfxTQT3gniVZaTVMK1124x55gIt4ytF90fpNXC11ZBCQIt0YXSZVMVCzSnmuhJXyv01ZzQmlQ6aQg1@Er7XhE8T/0n4bhPueneyl/USnkTjEEpR71k8MYA3wpGk7oPfmw5JOWNCBDEBVXAmxH4kf/AwUMDUwP2bumuFP7Nn9YH4xA8kfbPg/ml9tfjFYltlx236Q87v7v6A9/xhFggkKYt5ZhCJA6iNgo@Bb3ecgHE8BCP9DZXkWD63jfXmpIFqEL@mfQ8a4tO8l6p3RfxeUVJpznkU0ighZQXBdruUAwqCVao81RkyeYXzz4TSCaZgJs@2GEoVjL@5Sw4OfiujA83x2eAghWyLST1HaQ0pzHHR4Hq426WDzr7@KqMVRgOYZctEAg04rORDDDPy4Q7BSgvbkrNYtJQWPtDapXpoxaIHVk09AUxyyfckAEJx4QQJfubuEXk5Z@ntupae2d/MI73TpotFe6lmFQPCUzULnbgtAIXC1dKDoFqXEfIZZ9B75Ar0DOOrUetJxlco@VDhY9FdYRdzrx@Fc8RSK@TfEy/kqjKKFKrPcUTOlmxpyZl4vvt1FgYOjxD17lPv7Obiqndd9@Z3UAOeas0SS/IDhsm8EtO3pU6XnbQ0q5oSr7pHWdZpC4Pu54zhOE/jfIwvLszH7rFTzsZuORuPrMwiozQFlW2PNtDpvQe9W4wJC8fJFAeOl3NX66QElJARegkd1cZGavI8sCOaSmeMgVAd3db50kgBn5ylsQLFWSx/FmzKLTt/BtWR5azOrtkG1TCMClVVlryKK6g99gKhKloltQqPTcqRM9vKNEvRiaLZRi6j6uKaslKbruzfuRMbXpTxV4dxKR0VqkjIx14U88xFOofQdrBXlRekpbuEqvTAJDJNYMizIVEfmBP7jwR6AXEmLIQ3mFn8QIyhJpk1QdjQsiWNEJiqc8lHWyQZ3EBVW8oDKteeeozK7xvmWhoovYDcoWQolInvoq2ZCncbaqWUVRhwqlchUD4oukqtk@JKpii6bb1NRiMeGsz3A0eFAdwNMEhMbQMj2jCR60B5G66U1AbDv5mOBq7eQ8ZxtQNdOFvJbnIG5tZnDxJfGQiFUsdyjMj34IbY1slePdmXlcahqWzZx9yyRuse@QH4evDq8ODwzS@vDt/sZl9DJtxgimGT958rOrNOMGSsEdoa0jptIaRK9Dy8hVW23N3AgG5pZi7JGIXB9AwYcBa4MGgWdyd6VJorH6fhFLjTGGc22ci3mZFM/nSWfyoul9lvefk2W676UNO5DY4q/8k2FQXR4A/echWXsNuVguyu1bwANZCXFRI9lg0pk0lG/xO5dVKNb41gl5ZFsRsksXEfQuMGgXmeU501YnbVFFRrLaQpg0F2PSzIBkzrbpBfshEg9Ggt5hZ749Yt1auZSbZEA4piEamPCxtt4VvD@b0VJN4L1iF3V5DYl9ch91eQ2W1gDfLnVZnBeju/rCCzqXsN8rhCVlQpt@BEUG2R95xs3jPetKe7eQ@W/LV7dqo9KivzuvF/mm6x7aiReYtnt7EjezUjTWlbvqqvC5glwRq1Ba@0iwWolK73zURmRnE/t61Kv90Q/rkSPsfuaTaS1qRL6baWzBe5CGj61glbGyxn1fd/SZuyoNV263bjkqZj@ZdeywrGyv9SopDFQlGaUbsuFLiZinLTM6pcy13VXIHLVo9jfZdpMFWWJkCHo5qj1SZpLvbiumH82ZIrXvPqDjiITllFYGK567@CTvgX/JjWiLy9vDr7lbyAxMP/c7jQpuEyHU8YTIEBj0QL/sJ4LVwYLYAdsyQmahSQe@jnTMCAEczo1k@mNbMirdUSpsVaLfNzBH@1i0X39YFln0bd17/Yp3udTse@WCy6B/@wuweHdvf1G/vUbrWYFV1H7zqtVpeR2ZZpCfJnZ@vzvy8uz8kxUeFV1UiHCEpJ53W73SYvUGVEcNZIxhPSxutu5@Dw8JAwtDGJwUJc5jDzYgCi3JcJg7twGOAkHQjmk@hxOuVx@Lj10w45O728JCNy9enmw6cbIsgLb0RsmDG@wUeOswtciCLUAyMo16EneDDM1hr@Dw)
[Answer]
# C, 73 ~~82~~ bytes
```
f(x){int y=0,z=x;for(;x;x/=10)y=y*10+"0100009086"[x%10]-'0';return z==y;}
```
## Expanded
```
static const char s[] = "0100009086";
int f(int x)
{
    int y=0, z=x;
    for(; x; x/=10)
        y = y*10 + s[x%10]-'0';
    return z==y;
}
```
## Explanation
We reverse the digits of `x` using modulo-10 arithmetic, replacing 6 and 9 by their reflections as we go. We replace the rotationally-asymmetric digits by zeros (note that we can handle symmetric fives and/or twos by simply changing the replacement table `s`). If the new number is equal to the original (saved in 'z'), then it is rotationally symmetric.
## Test program
```
#include <stdio.h>
int main()
{
    int i;
    for(i=0;  i <= 16091; ++i)
        if (f(i))
            printf("%d\n", i);
}
```
This prints the list of symmetric numbers given in the question.
[Answer]
# Jelly, ~~16~~ 15 bytes
```
,»∑9+90860¬§D·ªã/‚Åº·πö
```
[Try it online!](http://jelly.tryitonline.net/#code=LMi3OSs5MDg2MMKkROG7iy_igbzhuZo&input=&args=NjAwOQ)
### How it works
```
,»∑9+90860¬§D·ªã/‚Åº·πö  Main link. Argument: n (integer)
         ¬§       Evaluate the three links to the left as a niladic chain:
 »∑9              Yield 1000000000.
    90860        Yield 90860.
   +             Add to yield 1000090860.
,                Pair; yield [n, 1000090860].
          D      Convert both integers to base 10.
           ·ªã/    Reduce by index, i.e., for each digit of n, retrieve the element
                 of [1, 0, 0, 0, 0, 9, 0, 8, 6, 0] at that index (1-based).
              ·πö  Yield the digits of n in reversed order.
             ‚Åº   Test for equality.
```
[Answer]
# Retina, ~~57~~ 49 bytes
8 bytes saved thanks to [@Martin B√ºttner](https://codegolf.stackexchange.com/users/8478/martin-b%C3%BCttner).
```
+`^(([018])(.*)\2|9(.*)6|6(.*)9)$
$3$4$5
^[018]?$
```
* Apply reduction as such: `1610880191` -> `61088019` -> `108801` -> `0880` -> `88` -> (empty).
* Returns `1` if only `0`, `1`, `8`, or (empty) is left.
* Returns `0` otherwise.
[Try it online!](http://retina.tryitonline.net/#code=K2BeKChbMDE4XSkoLiopXDJ8OSguKik2fDYoLiopOSkkCiQzJDQkNQpeWzAxOF0_JApZClxkKwpO&input=MTYxMDg4MDE5MQ)
[Answer]
# TSQL, 122 bytes
I am new to code golf, so not quite sure how to count the characters. Counting it as 1 here since the number used in this case is 8
This will return 1 when the reversed value match and nothing when it doesn't match:
```
SELECT 1FROM(values(8))x(x)WHERE(x)NOT like'%[23457]%'and REPLACE(REPLACE(x,6,4),9,6)=REVERSE(REPLACE(REPLACE(x,9,4),9,6))
```
Human readable:
```
SELECT 1
FROM
  (values(808))x(x)
WHERE(x)
  NOT like'%[23457]%'
  and REPLACE(REPLACE(x,6,4),9,6)=REVERSE(REPLACE(REPLACE(x,9,4),9,6))
```
[Answer]
# GNU sed, 84 bytes
(including +1 for `-r` flag)
```
:
s/^6(.*)9$/\1/
s/^9(.*)6$/\1/
s/^([081])(.*)\1$/\2/
t
s/^[081]$//
s/.+/0/
s/^$/1/
```
If the line ends with a rotation of its beginning character, trim both ends by one. Repeat until there's no match. Account for a single symmetric character, then if anything remains, the input was not symmetric, and we return false; otherwise return true.
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 56 bytes
```
#~ContainsNone~{2,3,4,5,7}&&Reverse@#==(#/.{6->9,9->6})&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n2b7X7nOOT@vJDEzr9gvPy@1rtpIx1jHRMdUx7xWTS0otSy1qDjVQdnWVkNZX6/aTNfOUsdS186sVlPtf5qDZ15JanpqkUtmemZJsYOymr5DUGJeeqqDoYGBvn5AUWZeyX8A "Wolfram Language (Mathematica) ‚Äì Try It Online")
Takes input as a list of digits.
## Explanation:
---
`#~ContainsNone~{2,3,4,5,7}` Check if the input contains no unflippable digits
`&&Reverse@#` and that the reverse of the input
`==(#` is equal to the input
`/.{6->9,9->6})&` where all 6s are replaced with 9s and 9s with 6s.
[Answer]
# [Julia](https://julialang.org)
## 47 bytes
The first attack.
```
!x=10(d=digits(x))+reverse(d)‚äÜ[0,11,88,69,96]
```
[Attempt This Online!](https://ato.pxeger.com/run?1=LZA9TgMxEIVFg8SewokodkUQ44KRB2SJe6AUkdYhi1CQvF5kLkDBFWhCkUORMidhfrZ5Hv-87z355_g6vQ2bw-nisuSp7D7jM6ycX7nAygsSjzwT8h68HIoEuQK-Qy8S5BXws-BF1ADsIC8S1DubRZGUIRBPqChjKQxJkcJE0nwwtLKRLEGUUIMsSaOQNFASidByNRisPASrAX5uo0uwVkB-_XicyvY2_N0tavTQ9rEfXoYytrXrbnL6SHlMbd-dv7_4m9jFNbgh4Xq23W_fs2Png9Kaq6fNOKZc3KK6GF1b3bB39s-dW9Z4XZdN2vdmPvw2NvwD)
## 39 bytes
Using `@b_str` it can be golfed further as proposed by @MarcMush and @Deadcode:
[Attempt It Online!](https://ato.pxeger.com/run?1=LZBBTgMxDEVhg9Q5RTqqxIwokrPAiqkiOAI7FohFq0lhECpSJlOFC7DgCmzKooeCJSchtmfz7ST-71v5Or6Mr_368Ht6luKYnt_9AyyNXRpXtBSk0paesJzB8iWL4ycob2hZHE9BGXOWRQxQHGRZnHgnMyuSMBhiCQWlLIEhCZKZSJIPihY2kiawEkqQJkkUkgRyIhFqrgSDLg9O1wA7bSPF6VZA9nF1HNP20v2cz7OnpvNd_9SnocltexHDPsQhNF379_mxqU-qu5v7ehq_2r5Fk729Fko1u10PQ4jJzLPx3jTZ9Duj_9uaOvtFrquw69R8-K60-Qc)
[Answer]
# Pure bash, 99 bytes
Using `shopt -s extglob`:
```
o=;for i in ${1//*()/ };do o=${i//6/_}$o;done; o=${o//9/6} o=${o//_/9}
[[ ${o//[23457]} == "$1" ]]
```
There are 98 bytes +1 for *extglob* -> 99 bytes.
## Without extglob, 101 bytes
```
o=;for((i=${#1};i--;)){ o+=${1:i:1};};o=${o//6/_} o=${o//9/6} o=${o//_/9}
[[ $1 == "${o//[23457]}" ]]
```
Sample:
```
rotatable() {
    o=;for i in ${1//*()/ };do o=${i//6/_}$o;done; o=${o//9/6} o=${o//_/9}
    [[ ${o//[23457]} == "$1" ]]
}
for((x=0;x<10000;x++)){ rotatable $x&&echo $x;}|column 
0       69      111     689     906     1111    6009    6969    8888    9696
1       88      181     808     916     1691    6119    8008    8968    9886
8       96      609     818     986     1881    6699    8118    9006    9966
11      101     619     888     1001    1961    6889    8698    9116
```
[Answer]
# Perl, ~~29~~ 26 bytes
Includes +1 for `-p`
Run with the input on STDIN:
```
rotation.pl <<< 69
```
`rotation.pl`:
```
#!/usr/bin/perl -p
$_=reverse==y/962-7/69a/r
```
[Answer]
# MATL, ~~25~~ ~~21~~ 22 bytes
```
j69801VmAGtP69VtPXE=vA
```
[**Try it Online!**](http://matl.tryitonline.net/#code=ajY5ODAxVm1BR3RQNjlWdFBYRT12QQ&input=MTYwOTE)
**Explanation**
```
j       % Explicitly grab input as string
69801   % Number literal
V       % Convert to a string
mA      % Check if all input chars are members of this list
G       % Explicitly grab the input
tP      % Duplicate and flip it
69      % Number literal
V       % Convert to string ('69')
tP      % Duplicate and flip it ('96')
XE      % Replace all '6' with '9', and '9' with '6'
=       % Check that this substituted string is equal to the original
v       % Vertically concatenate all items on the stack
A       % Ensure everything is true
        % Implicitly print boolean result
```
[Answer]
# Pyth, 17 bytes
```
!-FmC_B`d,QC\ÙÑΩ•
```
Test it in the [Pyth Compiler](https://pyth.herokuapp.com/?code=%21-FmC_B%60d%2CQC%5C%F4%84%BD%A5&input=6009&debug=0).
### How it works
```
!-FmC_B`d,QC\ÙÑΩ•  (implicit) Store the input in Q.
            \ÙÑΩ•  Yield the Unicode character with code point 1068901.
           C    Compute its code point.
         ,Q     Pair the input and 1068901.
   m            Map; for each d in [Q, 1068901]:
       `d         Yield the string representation of d.
     _B           Yield the pair of `d` and `d` reversed.
    C             Zip. For the second string, this gives
                  ['11', '00', '69', '88', '96', '00', '11'].
 -F             Fold by difference, i.e., removes all pairs in the second list
                from the first list.
!               Logically negate the result, returning True iff the list is empty.
```
[Answer]
## Visual Basic for Applications, ~~150~~ 111 bytes
Usable in console or as an UDF.
```
Function c(b)
c=(Not b Like"*[!01869]*")And b=Replace(Replace(Replace(StrReverse(b),9,7),6,9),7,6)
End Function
```
Improved by taking advantage of implicit type conversions and by doing three steps swapping instead of two steps on each side of the equation. Count includes `Function` and `End Function` statements.
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 16 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
√™¬±¬∞";‚ïô√±‚ôÄC¬ºEE^‚òº√πŒ£
```
[Run and debug it](https://staxlang.xyz/#p=88f1f8223bd3a40c43ac45455e0f97e4&i=7%0A69&m=2)
[Answer]
# AWK, ~~85~~ ~~84~~ ~~82~~ 80 bytes
```
{n=split($1,a,s="");for(;n;){b=a[n--];s=s (b~/[2-57]/?9:b~6?9:b~9?6:b)}$1=s~$1}1
```
This feels like brute-forcing, but awk has very limited tools, mostly aimed to text processing. This code allows multiple inputs.
```
{
n=split($1,a,s="");    # this splits $1 (the input) into the array _a_
                       # using an empty string as token. each element of the
                       # array is a digit of the input number.
                       # also, sets the number of elements to _n_,
                       # and sets the empty string to _s_.
    
for(;
    n;          # loops until n==0 (evaluates to false)
   ){
      b=a[n--]; # sets the _n_ element of the array to _b_. this will save bytes later
                # immediately after, decrements _n_ by 1 (one less byte here)
                        # here the magic happens:
      s=s (             # this appends a chaining conditional to the variable _s_
          b~/[2-57]/?9: # if _b_ equals 2, 3, 4, 5 or 7, returns 9 (dummy number)
          b~6?9:        # otherwise, if _b_ equals 6, returns 9
          b~9?6:        # otherwise, if _b_ equals 9, returns 6
          b             # otherwise, returns its value
          )
    }
$1=s~$1      # evaluates if _s_ matches $1, and sets this boolean to $1
}
1            # prints $1.
```
[Try it online!](https://tio.run/##LYvBCoMwEETv@xVFPERQzNq6uobgh4iH5FAoLbE0hR5Efz2NaWdgGIY35nMPYXXaPx@3t8ixNKXXWVao6/ISyqlitdpMrqpm5bU/CbvXU1O13VyPPNidUvJIgy22HLXfc9wwBIQeJBADU0yMBaVEICJmhj4pTn9DA2e4QAvdQcRPwmXi8CDj8vMX "AWK ‚Äì Try It Online")
---
# AWK, 78 bytes
This is almost the same as above, but without the `s` variable. Two less bytes, with the effect of allowing only one input.
```
{n=split($1,a,"");for(;n;){b=a[n--];s=s (b~/[2-57]/?9:b~6?9:b~9?6:b)}$1=s~$1}1
```
[Try it online!](https://tio.run/##SyzP/v@/Os@2uCAns0RDxVAnUUdJSdM6Lb9IwzrPWrM6yTYxOk9XN9a62LZYQSOpTj/aSNfUPFbf3tIqqc4MTFram1kladaqGNoW16kY1hr@/29haGZmZmlpaWgBAA "AWK ‚Äì Try It Online")
[Answer]
# [Julia 1.0](http://julialang.org/), 45 bytes
```
!x=prod(d->"01....9.86"[1+d],digits(x))=="$x"
```
[Try it online!](https://tio.run/##DcrbCkBAEADQd18xNolcmn0Rav2IJDVopKVFzd@vPc/n@E5etHgfi7ndRRlVg0JdB13dNmrUBU0l8c7vk0meG6MSUX67HAiwBew14oyIEQSxQJrC7di@pw09Wi35Hw "Julia 1.0 ‚Äì Try It Online")
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 12 bytes
```
¬ª\Œ†¬ªF‚àë69S*·πò=
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLCu1xczqDCu0biiJE2OVMq4bmYPSIsIiIsIlwiOTA4MDZcIiJd)
```
    F‚àë       # Remove elements of...
¬ª\Œ†¬ª         # 23457
         *   # Ring translate by...
      69S    # "69"
          ·πò= # Does it, reversed, equal the input?
```
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 55 bytes
```
n=>!(e=[...''+n]).some(c=>'0x'+'01aaaa9a86'[c]-e.pop())
```
[Try it online!](https://tio.run/##FcdBCsMgEADAe3/RS9ZFsphLaTHmIyEHsWuxpK7EUvJ7k85t3v7na9hS@fZZntyia9lNV8VuJiIAnRekKh9WwU1gdtBgBn96@PsN5rD0TEWKQmz2EmVTyRmbxsH8Wa0TRpWw64LkKivTKq/z7QA "JavaScript (Node.js) ‚Äì Try It Online")
Half test of `n=>![...''+n].some((c,i,e)=>'0100009086'[c]-e.slice(~i)[0])`
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 58 bytes
```
n=>$"{n}".Aggregate("",(z,c)=>"01----9-86"[c-48]+z)==n+"";
```
[Try it online!](https://tio.run/##ZU9Na4QwED2bXzENe1D8IEKRWDdCKfTUew/LHmw2kaAkRbNtWclvt5OFnprDm6/33mTkWsrV7K9XK@ForC/gw7m5Bw0Cdiv6A91soNXzOC5qHLxKKS3SWyEz0VNWl/jakjf0JMtHfs5vmRA2p7Tbv4YF3IQmfrmqjsRS/Xwq6dUFm1Z9w@kMGyugLoAjYmhaTDFvG6xZHZsReBwxnDV1BB5ZDGm8jnAXMFS0dQTehI5ot0CKt4DBVazDcERDhlmem4xsJDEa0r/vVC/O@sHYNTUZPAjQGDOSICvByepmVb0vxqs3Y1V6oHows7o8wWYCzTok3a/Uw7zimUkggURzN933/DegboqysP8C "C# (Visual C# Interactive Compiler) ‚Äì Try It Online")
[Answer]
# [PHP](https://php.net/), 49 bytes (anonymous function)
```
fn($s)=>$s==strrev(strtr($s,"6923457","9600000"))
```
[Try it online!](https://tio.run/##LU89a8MwEP0rQmjQYRlkN00x8iVLli5dms3NUleKA0IWlhNCSn67ezK94b7fe3dxiEu7j0NkwuHighQJcCcSYpqnyd4khXmiruLbpn7ZvL5xxZutzsYBFuNGmj5QG@HRne2c5Ofx8P4BBn4vTgrfEYG3xOuhrE6I/CtwoN10/U6Z2Cutygoy3N6jH3@s5CVXtG4I34/XMGdsWxOoIwLy@mTYKhv@KxFaXKeUFQWwi2NSkHgAYOsVD7D9MGZpQ7dWhuWSiWCez0WX9frNHw "PHP ‚Äì Try It Online")
The `strtr` translates `6` to `9`, `9` to `6`, and all non-symmetric digits to `0` (any character other than themselves would work). The digits `0`, `1`, and `8` are left unchanged. (The order I put them in is purely a stylistic choice; I don't think it even makes a difference in speed.)
Then `strrev` reverses this result, which is then compared with the original string; if they're equal, it has rotational symmetry.
# [PHP](https://php.net/) `-F`, 51 bytes (full program)
```
<?=$argn==strrev(strtr($argn,"6923457","9600000"));
```
[Try it online!](https://tio.run/##LUxBCsIwELzvK8LioYUWum2TJtTYm6/wIlKMlySkwSf4AJ/oQ4xJcQ4zw8ww3vh0XLzxbL0Zxw7XcLcNss/rzZAtp9zpPdN6iyGszypLDNV/J1Q/jHzCBpXoCrCu57Q/4cXinDog6GGAETgImECCAsohQd6rQlSYiqfilSSSIgvnUnydjw9nt9Sefw "PHP ‚Äì Try It Online")
[Answer]
# Pyth - 21 bytes
```
&!-z+`180K`69qzX_z_KK
```
[Test Suite](http://pyth.herokuapp.com/?code=%26%21-z%2B%60180K%6069qzX_z_KK&test_suite=1&test_suite_input=619%0A2%0A108%0A111&debug=0).
]