Étant donné un entier, émettez une valeur véridique si elle est la même à l'envers (rotation de 180 °) ou une valeur fausse sinon.

0,, 1et 8ont une symétrie de rotation. 6devient 9et vice versa.

Séquence de nombres produisant des résultats véridiques: 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, ...

Cette question est inspirée de ma propre réputation au moment de l' affichage: 6009.

05AB1E , 22 16 15 14 octets

Code:

Â23457ð«-69‡Q

Essayez-le en ligne!

Code précédent:

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

Pour savoir si la chaîne est symétrique en rotation, il suffit de transliter 69avec 96, d'inverser la chaîne et de vérifier si elles sont égales. L'autre chose que nous devons savoir est si le nombre ne contient que les chiffres0 , 1, 8, 6et 9. C'est exactement ce que nous allons faire:

                     # 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•partie convertit en fait la chaîne vdde la base 190 en base 10 . Vous pouvez l'essayer ici .

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

Utilise l' encodage CP-1252 .Essayez-le en ligne!

Python 2, 50 octets

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

La méthode '01xxxx9x86'.find prend un caractère numérique à son nombre à l'envers, avec n'importe quel chiffre non flippable -1. Cette fonction est mappée à la chaîne numérique inversée, produisant une liste de chiffres.

Ceci est converti en une chaîne avec l' [1::3]astuce , sauf qu'il est inversé à la place en faisant[-2::-3] (merci à Dennis pour cela, économisant 4 octets), et comparé à la chaîne numérique d'origine. N'importe -1lequel à partir de chiffres inviolables désalignera la conversion, ce qui la fera échouer.

56 octets:

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

Vérifie si la chaîne de nombres inversée est la même que pour les remplacements à l'envers. Les chiffres qui ne peuvent pas être inversés sont remplacés par 'x'pour toujours donner la mauvaise réponse.

Le remplacement se fait translatesur une chaîne de 256 caractères, en remplaçant les valeurs ASCII correspondantes. Seules les 10 valeurs48 à la 57matière, mais je rembourrées à la longueur 16 pour rendre la longueur totale soit 256. Je me demande s'il y a un moyen plus court.

Quelques autres approches (longueurs 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]))

Rubis, 54 46 octets

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

Je ne sais pas, les fonctions anonymes comme celle-ci sont-elles autorisées ou non

Fondamentalement, la même idée que la réponse Python2. Si l'entrée n'est pas un entier, agissez mal (c.-à-d. abaDonne true)

JavaScript (ES6), 56 octets

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

Perl, 29 26 octets

Comprend +1 pour -p

Exécutez avec l'entrée sur STDIN:

rotation.pl <<< 69

rotation.pl:

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

Gelée, 16 15 octets

,ȷ9+90860¤Dị/⁼Ṛ

Essayez-le en ligne!

Comment ça marche

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

Rétine, 57 49 octets

8 octets économisés grâce à @Martin Büttner .

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

• Appliquer la réduction comme telle: 1610880191-> 61088019-> 108801-> 0880-> 88-> (vide).
• Retours 1si seulement 0, 1,8 ou (vide) est à gauche.
• Renvoie le 0contraire.

Essayez-le en ligne!

sh, 40 33 octets

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

Entrée via l'argument de ligne de commande, sortie via le code de sortie. Générez tous les cas de test:

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

TSQL, 122 octets

Je suis nouveau dans le code du golf, donc je ne sais pas trop comment compter les personnages. Le compter comme 1 ici car le nombre utilisé dans ce cas est 8

Cela retournera 1 lorsque la valeur inversée correspondra et rien si elle ne correspond pas:

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

Lisible par l'homme:

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

Rétine , 40 38 33 octets

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

Essayez-le en ligne!

Explication

Cela utilise une approche complètement différente de l'autre réponse Retina. Au lieu de supprimer toutes les parties symétriques, nous effectuons simplement la transformation de l'inversion de la chaîne et de l'échange 6et de 9s, puis comparons pour l'égalité. Pour nous assurer qu'aucun chiffre non symétrique n'apparaisse, nous les transformons également en 9s dans une moitié.

$
;$_

Nous dupliquons l'entrée en faisant correspondre la fin de la chaîne et en l'insérant ;suivie de l'entrée entière.

T`92-7`69`;.+

Cela effectue une translittération des caractères uniquement sur la seconde moitié en la faisant correspondre avec ;.+. Les deux ensembles de translittération s'étendent jusqu'à:

9234567
6999999

Parce que 2-7dénote une plage et que l'ensemble cible est complété par le dernier caractère pour correspondre à la longueur de l'ensemble source. Par conséquent, la scène troque 6et 9transforme également le tout 23457en 9art.

+`(.);\1
;

À plusieurs reprises ( +), supprimez une paire de caractères identiques autour du ;. Cela se poursuivra jusqu'à ce qu'il ne ;reste que le ou jusqu'à ce que les deux caractères autour du ;ne soient plus identiques, ce qui signifierait que les chaînes ne sont pas l'inverse l'une de l'autre.

^;

Vérifiez si le premier caractère est ;et imprimez 0ou en 1conséquence.

Pyth - 21 octets

&!-z+`180K`69qzX_z_KK

Suite de tests .

Pyth, 17 octets

!-FmC_B`d,QC\􄽥

Testez-le dans le compilateur Pyth .

Comment ça marche

!-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 pour Applications, 150 111 octets

Utilisable en console ou en UDF.

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

Amélioré en tirant parti des conversions de types implicites et en effectuant un échange en trois étapes au lieu de deux étapes de chaque côté de l'équation. Le compte comprend Functionet les End Functiondéclarations.

GNU sed, 84 octets

(dont +1 pour le -rdrapeau)

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

Si la ligne se termine par une rotation de son caractère de début, coupez les deux extrémités par une. Répétez jusqu'à ce qu'il n'y ait pas de correspondance. Tenez compte d'un seul caractère symétrique, puis s'il reste quelque chose, l'entrée n'était pas symétrique et nous renvoyons false; sinon retourne vrai.

C, 82 octets

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

Étendu

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

Explication

Nous inversons les chiffres de l' xutilisation de l'arithmétique modulo-10, en remplaçant 6 et 9 par leurs réflexions au fur et à mesure. Nous remplaçons les chiffres à rotation asymétrique par des zéros (notez que nous pouvons gérer les cinq et / ou les deux symétriques en changeant simplement la table de remplacements ). Si le nouveau nombre est égal à l'original (enregistré en «z»), alors il est symétrique en rotation.

Programme de test

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

Ceci imprime la liste des nombres symétriques donnée dans la question.

MATL, 25 21 22 octets

j69801VmAGtP69VtPXE=vA

Essayez-le en ligne!

Explication

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érieusement, 23 octets

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

Essayez-le en ligne!

Il s'agit essentiellement d'un portage de la solution Python 2 de xnor .

Explication:

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

Cela prend le nombre, le convertit en chaîne, le fait pivoter, puis le compare à l'original en tant que chaîne pour l'égalité. Les chiffres non rotatifs sont simplement convertis en0

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

Testez-le ici!