Nombres avec symétrie de rotation


27

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



2
@xnor Ce ne sont pas du tout les mêmes. Cette question implique de savoir si le nombre deviendrait un autre nombre valide lors de la rotation (et d'ajouter une période pour le garder distinct), et non s'il s'agit du même nombre. J'ai examiné cette question avant de poster la mienne.
mbomb007

@ mbomb007 Mon erreur. J'ai rouvert.
xnor

Pouvons-nous prendre l'entrée comme une chaîne?
xnor

@xnor Si le langage a des types numériques, il doit les utiliser, par exemple pour les paramètres de fonction. Mais si, en Python par exemple, vous prenez raw_input, l'utilisateur a entré un entier, qui deviendrait une chaîne dans les coulisses. C'est très bien.
mbomb007

Réponses:


6

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!


10

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

Peut-être que cela vous aidera: codegolf.stackexchange.com/a/48994/34718
mbomb007

6

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)


1
Bienvenue dans Programmation d'énigmes et Code Golf! Belle première réponse: D Les fonctions anonymes sont autorisées dans tous les contextes où les fonctions nommées normales sont autorisées.
chat


4

JavaScript (ES6), 56 octets

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

Que fait le ... dans le tableau?
ericw31415

@ ericw31415 Dans ce cas, il transforme la chaîne en un tableau de caractères. Plus généralement, vous pouvez fournir tout ce qui est itérable et il l'itérera et inclura les éléments dans le tableau.
Neil

Donc [... '' + n] est essentiellement la même chose que n.split ("")? Où puis-je en savoir plus à ce sujet?
ericw31415

@ ericw31415 Oui, dans ce cas, je l'utilise comme raccourci pour split``. Voir Un tableau plus puissant littéral
Neil

2

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

2

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.

Cette réponse est liée à une autre à 15 octets, mais l'autre réponse a été publiée en premier. Pouvez-vous raser 1 octet?
mbomb007

J'ai essayé assez fort; Je ne pense pas pouvoir. Cependant, notre briseur d'égalité par défaut est la première réponse pour atteindre le score gagnant , et je pense que je suis arrivé à 15 premiers.
Dennis

2

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!


2

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

2

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

2

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.


Levier, très levier.
CalculatorFeline


1

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.

1

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.


1

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.


1

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.


0

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

0

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

0

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!

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.