Dado um número inteiro, a saída de um truthy valor se for o mesmo de cabeça para baixo (girado 180 °) ou um Falsas valor de outra forma.

0, 1, E 8tem simetria de rotação. 6torna 9- se e vice-versa.

Sequência de números que produzem resultados verdadeiros : 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, ...

Esta questão é inspirado por minha própria reputação no momento da postagem: 6009.

05AB1E , 22 16 15 14 bytes

Código:

Â23457ð«-69‡Q

Experimente online!

Código anterior:

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

Para descobrir se a string é simétrica rotacional, basta transliterar 69com 96, inverter a string e verificar se são iguais. A outra coisa que precisamos saber é se o número única contém a dígitos 0, 1, 8, 6e 9. Então é exatamente isso que vamos fazer:

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

A „vd•peça, na verdade, converte a sequência vdda base 190 para a base 10 . Você pode tentar isso aqui .

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

Usa a codificação CP-1252 . Experimente online!

Python 2, 50 bytes

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

O método '01xxxx9x86'.findleva um caractere de dígito para o seu número invertido, com qualquer dígito irrestrito -1. Essa função é mapeada para a sequência de números invertidos, produzindo uma lista de dígitos.

Isso é convertido em uma seqüência de caracteres com o [1::3]truque , exceto que, ao contrário, é revertido [-2::-3](graças a Dennis por isso, economizando 4 bytes) e comparado à seqüência de caracteres do número original. Qualquer -1um de dígitos que não pode ser deslocado irá desalinhar a conversão, fazendo com que ela falhe.

56 bytes:

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

Verifica se a sequência numérica invertida é a mesma das substituições invertidas. Os dígitos que não podem ser invertidos são substituídos por 'x'para sempre dar a resposta errada.

A substituição é feita translateem uma sequência de 256 caracteres, substituindo os valores ASCII correspondentes. Apenas os valores 10 48para 57importa, mas eu acolchoada para comprimento de 16 para tornar o comprimento total é 256. Gostaria de saber se existe uma maneira mais curta.

Algumas outras abordagens (comprimentos 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 bytes

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

Eu não sei, funções anônimas como essa são permitidas ou não

Basicamente, a mesma idéia que a resposta do Python2. Se a entrada não for um número inteiro, aja mal (ou seja, abadê true)

JavaScript (ES6), 56 bytes

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

Perl, 29 26 bytes

Inclui +1 para -p

Execute com a entrada em STDIN:

rotation.pl <<< 69

rotation.pl:

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

Geléia, 16 15 bytes

,ȷ9+90860¤Dị/⁼Ṛ

Experimente online!

Como funciona

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

Retina, 57 49 bytes

8 bytes salvos graças a @Martin Büttner .

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

• Aplique a redução como tal: 1610880191-> 61088019->108801 -> 0880-> 88-> (vazio).
• Retorna 1se apenas0 , 1, 8, ou (Vazio) está à esquerda.
• Devoluções 0 caso contrário.

Experimente online!

sh, 40 33 bytes

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

Entrada via argumento de linha de comando, saída via código de saída. Gere todos os casos de teste:

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

TSQL, 122 bytes

Eu sou novo em codificar golfe, por isso não tenho certeza de como contar os caracteres. Contando como 1 aqui, já que o número usado neste caso é 8

Isso retornará 1 quando o valor revertido corresponder e nada quando não corresponder:

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

Legível por humanos:

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

Retina , 40 38 33 bytes

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

Experimente online!

Explicação

Isso usa uma abordagem completamente diferente da outra resposta da Retina. Em vez de remover todas as partes simétricas, nós simplesmente executar a transformação de reverter a corda e trocando 6e 9s e então comparar a igualdade. Para garantir que nenhum dígito não simétrico apareça, também os transformamos em 9s ao meio.

$
;$_

Duplicamos a entrada combinando o final da string e inserindo ;seguido pela entrada inteira.

T`92-7`69`;.+

Isso realiza uma transliteração de caracteres apenas na segunda metade, combinando-a com ;.+. Os dois conjuntos de transliteração se expandem para:

9234567
6999999

Porque 2-7denota um intervalo e o conjunto de destino é preenchido com o último caractere para corresponder ao comprimento do conjunto de origem. Assim, os swaps de palco 6e 9e também se transforma todos 23457em 9s.

+`(.);\1
;

Repetidamente ( +) remova um par de caracteres idênticos ao redor do ;. Isso continuará até que apenas o ;seja deixado ou até que os dois caracteres ao redor ;não sejam mais idênticos, o que significaria que as seqüências não são o inverso uma da outra.

^;

Verifique se o primeiro caractere é ;e imprima 0ou de 1acordo.

Pitão - 21 bytes

&!-z+`180K`69qzX_z_KK

Conjunto de Teste .

Pitão, 17 bytes

!-FmC_B`d,QC\􄽥

Teste-o no Pyth Compiler .

Como funciona

!-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 for Applications, 150 111 bytes

Utilizável no console ou como um UDF.

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

Aprimorado, aproveitando as conversões implícitas de tipo e executando três etapas em vez de duas etapas em cada lado da equação. Contagem inclui Functione End Functiondeclarações.

GNU sed, 84 bytes

(incluindo +1 para -rsinalizador)

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

Se a linha terminar com uma rotação do caractere inicial, apare as duas extremidades em uma. Repita até que não haja correspondência. Considere um único caractere simétrico; se restar alguma coisa, a entrada não será simétrica e retornamos false; caso contrário, retorne verdadeiro.

C, 82 bytes

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

Expandido

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

Explicação

Invertemos os dígitos do xuso da aritmética do módulo 10, substituindo 6 e 9 por seus reflexos à medida que avançamos. Substituímos os dígitos rotacionalmente assimétricos por zeros (observe que podemos lidar com cinco e / ou dois simétricos simplesmente mudando a tabela de substituição s). Se o novo número for igual ao original (salvo em 'z'), será simétrico de rotação.

Programa de teste

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

Isso imprime a lista de números simétricos fornecidos na pergunta.

MATL, 25 21 22 bytes

j69801VmAGtP69VtPXE=vA

Experimente Online!

Explicação

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

Sério, 23 bytes

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

Experimente online!

Este é essencialmente um porto de solução Python 2 xnor .

Explicação:

,$;`"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 bytes

Isso pega o número, converte-o em uma sequência de caracteres, gira-o e depois o compara com o original como uma sequência de igualdade. Dígitos não rotativos são simplesmente convertidos em0

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

Teste aqui!