给定一个整数，如果它是相同的上下颠倒（旋转180°），则输出真实值，否则输出虚假值。

0，1并且8具有旋转对称性。6成为9，反之亦然。

产生真实结果的数字序列：OEIS 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, ...

这个问题是受我在发布时的声誉所启发6009。

05AB1E，22 16 15 14字节

码：

Â23457ð«-69‡Q

在线尝试！

先前的代码：

Â69‡Q¹¹„vd•ÃQ*

为了弄清楚如果字符串为旋转对称的，我们只需要音译69用96，扭转字符串，并检查它们是否相等。我们需要知道的另一件事是，如果数字仅包含数字0，1，8，6和9。所以这就是我们要做的：

                     # 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.

该„vd•部分实际上将字符串vd从基数190转换为基数10。您可以在这里尝试。

            Ã        # 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.

使用CP-1252编码。在线尝试！

Python 2，50个字节

lambda n:`n`==`map('01xxxx9x86'.find,`n`)`[-2::-3]

该方法'01xxxx9x86'.find将数字字符加到其上下颠倒的数字上，并给出任何不可翻转的数字-1。此函数映射到反向数字字符串，从而产生数字列表。

这将通过[1::3]技巧将其转换为字符串，但通过执行相反的操作来代替它[-2::-3]（这要归功于Dennis，节省了4个字节），并与原始数字字符串进行了比较。-1不可翻转数字中的任何都会使转换不对齐，从而使转换失败。

56个字节：

lambda n:`n`[::-1]==`n`.translate('01xxxx9x86______'*16)

检查反转的数字字符串是否与上下颠倒的替换字符串相同。无法翻转的数字将替换'x'为始终给出错误的答案。

替换使用translate256个字符的字符串完成，替换了相应的ASCII值。只有10个值48到57无所谓，但我填充到长度为16，使总长度是256。我不知道是否有一个较短的方式。

其他一些方法（长度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]))

Ruby，54 46字节

 ->a{(b=a.to_s).tr('1-9','1w-z9x86').reverse==b}

我不知道，是否允许这样的匿名函数

与Python2答案基本相同。如果输入不是整数，则表现不佳（即aba给出true）

JavaScript（ES6），56个字节

n=>n==[...''+n].reverse().map(c=>'0100009086'[c]).join``

Perl，29个 26字节

包括+1的 -p

使用STDIN上的输入运行：

rotation.pl <<< 69

rotation.pl：

#!/usr/bin/perl -p
$_=reverse==y/962-7/69a/r

果冻，16 15字节

,ȷ9+90860¤Dị/⁼Ṛ

在线尝试！

怎么运行的

,ȷ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.

视网膜，57 49字节

@MartinBüttner节省了8个字节。

+`^(([018])(.*)\2|9(.*)6|6(.*)9)$
$3$4$5
^[018]?$

• 按如下方式应用归约：1610880191-> 61088019-> 108801-> 0880-> 88->（空）。
• 返回1如果只0，1，8，或（空）在左边。
• 0否则返回。

在线尝试！

sh，40 33字节

[ `rev<<<$1|tr 6923457 96` = $1 ]

通过命令行参数输入，通过退出代码输出。生成所有测试用例：

for i in `seq 0 10000`
do
  if [ `rev<<<$i|tr 6923457 96` = $i ]
  then
    echo $i
  fi
done

TSQL，122字节

我是打高尔夫球的新手，所以不太清楚如何计算角色。由于在这种情况下使用的数字是8，因此此处将其计为1

当反转的值匹配时，它将返回1；而当反向值不匹配时，它将不返回：

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))

可读性：

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))

视网膜，40 38 33字节

$
;$_
T`92-7`69`;.+
+`(.);\1
;
^;

在线尝试！

说明

这使用了与其他视网膜答案完全不同的方法。无需删除所有对称部分，我们只需执行反转字符串和交换6和9s的转换，然后比较相等性即可。为了确保没有出现非对称数字，我们还将它们变成二9分之一。

$
;$_

我们通过匹配字符串的末尾并插入;后跟整个输入来复制输入。

T`92-7`69`;.+

通过与匹配，它仅在后半部分执行字符音译;.+。这两个音译集扩展为：

9234567
6999999

因为2-7表示范围，目标集将填充最后一个字符以匹配源集的长度。因此，该阶段交换6，9并且也将全部23457变为9s。

+`(.);\1
;

重复（+）删除;。周围的一对相同的字符。这将继续，直到仅;剩下或直到周围的两个字符;不再相同为止，这意味着字符串不再是相反的。

^;

检查第一个字符是，;然后打印0或1相应地打印。

Pyth-21个字节

&!-z+`180K`69qzX_z_KK

测试套件。

Pyth，17个字节

!-FmC_B`d,QC\􄽥

在Pyth编译器中进行测试。

怎么运行的

!-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.

Visual Basic应用程序，150 111字节

可在控制台中使用或作为UDF使用。

Function c(b)
c=(Not b Like"*[!01869]*")And b=Replace(Replace(Replace(StrReverse(b),9,7),6,9),7,6)
End Function

通过利用隐式类型转换并在公式的每一侧执行三步交换而不是两步进行了改进。计数包含Function和End Function语句。

GNU sed，84字节

（包括+1 -r）

:
s/^6(.*)9$/\1/
s/^9(.*)6$/\1/
s/^([081])(.*)\1$/\2/
t
s/^[081]$//
s/.+/0/
s/^$/1/

如果该行以其起始字符旋转结束，则将两端修剪一。重复直到没有匹配项。考虑单个对称字符，那么如果还有任何剩余内容，则输入不是对称的，并且我们返回false；否则返回true。

C，82字节

char*s="0100009086";f(x){int y=0,z=x;for(;x;x/=10)y=y*10+s[x%10]-'0';return z==y;}

展开式

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;
}

说明

我们反转x使用10模运算的数字，将6和9替换为它们的反射。我们将旋转不对称的数字替换为零（请注意，我们可以通过简单地更改替换表来处理对称的5和/或2。s）。如果新数字等于原始数字（保存为“ z”），则它是旋转对称的。

测试程序

#include <stdio.h>
int main()
{
    int i;
    for(i=0;  i <= 16091; ++i)
        if (f(i))
            printf("%d\n", i);
}

这将打印问题中给出的对称数字列表。

MATL，25 21 22字节

j69801VmAGtP69VtPXE=vA

在线尝试！

说明

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

严重的是23个字节

,$;`"01xxxx9x86"í`MRεj=

在线尝试！

本质上，这是xnor的Python 2解决方案的一部分。

说明：

,$;`"01xxxx9x86"í`MRεj=
,$;                      push two copies of str(input)
   `"01xxxx9x86"í`M      map: get each digit's rotated digit (or x if not rotatable)
                   Rεj   reverse and join on empty string to make a string
                      =  compare equality with original input

Kotlin，69字节

这将获取数字，将其转换为字符串，旋转它，然后将其与原始字符串进行比较以确保相等。不可旋转的数字只需转换为0

{i->"$i".map{"0100009086"[it-'0']}.joinToString("").reversed()=="$i"}

在这里测试！