Dado un número entero, genera un valor verdadero si es el mismo invertido (girado 180 °) o un valor falso de lo contrario.

0, 1y 8tienen simetría rotacional. 6se convierte 9y viceversa.

Secuencia de números que produce resultados verdaderos: 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 pregunta se inspira en mi propia reputación en el momento de publicación: 6009.

05AB1E , 22 16 15 14 bytes

Código:

Â23457ð«-69‡Q

Pruébalo en línea!

Código anterior:

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

Para determinar si la cadena es simétrica rotacional, solo necesitamos transliterar 69con 96, invertir la cadena y verificar si son iguales. La otra cosa que necesitamos saber es si el número solamente contiene los dígitos 0, 1, 8, 6y 9. Entonces eso es exactamente lo que vamos a hacer:

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

La „vd•parte en realidad convierte la cadena vdde la base 190 a la base 10 . Puedes probar esto aquí .

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

Utiliza la codificación CP-1252 . Pruébalo en línea!

Python 2, 50 bytes

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

El método '01xxxx9x86'.findlleva un carácter de dígito a su número al revés, con cualquier dígito imperturbable -1. Esta función se asigna a la cadena numérica invertida, produciendo una lista de dígitos.

Esto se convierte en una cadena con el [1::3]truco , excepto que se invierte al hacerlo [-2::-3](gracias a Dennis por esto, ahorrando 4 bytes), y se compara con la cadena del número original. Cualquiera de -1los dígitos no deslizables desalineará la conversión, haciendo que falle.

56 bytes:

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

Comprueba si la cadena numérica invertida es la misma que con los reemplazos invertidos. Los dígitos que no se pueden voltear se reemplazan por 'x'para dar siempre la respuesta incorrecta.

El reemplazo se realiza con translateuna cadena de 256 caracteres, reemplazando los valores ASCII correspondientes. Sólo los 10 valores 48que 57son importantes, pero, acolchado en longitud 16 para hacer que la longitud total sea 256. Me pregunto si hay un camino más corto.

Algunos otros enfoques (longitudes 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}

No sé, ¿se permiten o no funciones anónimas como esa?

Básicamente la misma idea que la respuesta de Python2. Si la entrada no es entera, actúa mal (es decir, abada true)

JavaScript (ES6), 56 bytes

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

Perl, 29 26 bytes

Incluye +1 para -p

Ejecutar con la entrada en STDIN:

rotation.pl <<< 69

rotation.pl:

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

Jalea, 16 15 bytes

,ȷ9+90860¤Dị/⁼Ṛ

Pruébalo en línea!

Cómo 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 guardados gracias a @Martin Büttner .

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

• Aplicar reducción como tal: 1610880191-> 61088019-> 108801-> 0880->88 -> (vacío).
• Devuelve 1si solamente 0, 1,8 , o (vacío) que queda.
• Devoluciones de lo 0contrario.

Pruébalo en línea!

sh, 40 33 bytes

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

Entrada por argumento de línea de comando, salida por código de salida. Generar todos los casos de prueba:

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

TSQL, 122 bytes

Soy nuevo en el código de golf, así que no estoy muy seguro de cómo contar los personajes. Contando aquí como 1 ya que el número utilizado en este caso es 8

Esto devolverá 1 cuando el valor invertido coincida y nada cuando no coincida:

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

Legible 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
;
^;

Pruébalo en línea!

Explicación

Esto utiliza un enfoque completamente diferente de la otra respuesta de Retina. En lugar de eliminar todas las partes simétricas, simplemente realizamos la transformación de invertir la cadena e intercambiar 6y 9sy luego comparar para la igualdad. Para asegurarnos de que no aparezcan dígitos no simétricos, también los convertimos en 9s en la mitad.

$
;$_

Duplicamos la entrada haciendo coincidir el final de la cadena e insertando ;seguido por la entrada completa.

T`92-7`69`;.+

Esto realiza una transliteración de caracteres solo en la segunda mitad al combinarla con ;.+. Los dos conjuntos de transliteración se expanden a:

9234567
6999999

Porque 2-7denota un rango y el conjunto de destino se rellena con el último carácter para que coincida con la longitud del conjunto de origen. Por lo tanto, las permutas de escenario 6y 9también convierte a todos 23457en 9s.

+`(.);\1
;

Repetidamente ( +) elimina un par de caracteres idénticos alrededor del ;. Esto continuará hasta que solo ;quede o hasta que los dos caracteres que lo rodean ;ya no sean idénticos, lo que significaría que las cadenas no son opuestas entre sí.

^;

Compruebe si el primer carácter es ;e imprima 0o en 1consecuencia.

Pyth - 21 bytes

&!-z+`180K`69qzX_z_KK

Test Suite .

Pyth, 17 bytes

!-FmC_B`d,QC\􄽥

Pruébelo en el compilador Pyth .

Cómo 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 para Aplicaciones, 150 111 bytes

Utilizable en consola o como UDF.

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

Mejorado al aprovechar las conversiones de tipo implícito y al intercambiar tres pasos en lugar de dos pasos a cada lado de la ecuación. El recuento incluye Functiony End Functiondeclaraciones.

GNU sed, 84 bytes

(incluido +1 para -rbandera)

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

Si la línea termina con una rotación de su carácter inicial, recorte ambos extremos en uno. Repita hasta que no haya coincidencia. Tenga en cuenta un solo carácter simétrico, luego, si queda algo, la entrada no fue simétrica y devolvemos falso; de lo contrario devuelve verdadero.

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

Explicación

Invertimos los dígitos del xuso de la aritmética módulo 10, reemplazando 6 y 9 por sus reflexiones a medida que avanzamos. Reemplazamos los dígitos de rotación asimétrica por ceros (tenga en cuenta que podemos manejar cinco y / o dos simétricos simplemente cambiando la tabla de reemplazo s). Si el nuevo número es igual al original (guardado en 'z'), entonces es rotacionalmente simétrico.

Programa de prueba

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

Esto imprime la lista de números simétricos dados en la pregunta.

MATL, 25 21 22 bytes

j69801VmAGtP69VtPXE=vA

Pruébalo en línea!

Explicación

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

En serio, 23 bytes

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

Pruébalo en línea!

Esto es esencialmente un puerto de la solución Python 2 de xnor .

Explicación:

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

Esto toma el número, lo convierte en una cadena, lo gira y luego lo compara con el original como una cadena para la igualdad. Los dígitos no giratorios simplemente se convierten a0

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

¡Pruébalo aquí!