Números com simetria rotacional

27

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.

mbomb007
fonte
Parece um dupe de números seguros para rotação de impressão .
Xnor
2
@xnor Eles não são os mesmos. Essa pergunta envolve se o número se tornaria outro número válido após a rotação (e acrescente um período para mantê-lo distinto), não se é o mesmo número. Eu olhei para essa pergunta antes de postar a minha.
mbomb007
@ mbomb007 Meu erro. Eu reabri.
Xnor
Podemos considerar a entrada como uma string?
Xnor
@xnor Se o idioma tiver tipos numéricos, use-os, por exemplo, para parâmetros de função. Mas se, em Python, por exemplo, raw_inputo usuário digitar um número inteiro, que se tornará uma string nos bastidores. Isso é bom.
mbomb007

Respostas:

6

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!

Adnan
fonte
10

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]))
xnor
fonte
Talvez isto ajude: codegolf.stackexchange.com/a/48994/34718
mbomb007
6

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

m0003r
fonte
1
Bem-vindo à Programação de Puzzles e Code Golf! Ótima primeira resposta: D Funções anônimas são permitidas em qualquer contexto em que funções nomeadas normais sejam permitidas.
gato
4

JavaScript (ES6), 56 bytes

n=>n==[...''+n].reverse().map(c=>'0100009086'[c]).join``
Neil
fonte
O que faz o ... na matriz?
precisa saber é o seguinte
@ ericw31415 Neste caso, transforma a cadeia de caracteres em uma matriz de caracteres. De um modo mais geral, você pode fornecer qualquer coisa iterável e ela iterará e incluirá os elementos na matriz.
21416 Neil
Então [... '' + n] é essencialmente a mesma coisa que n.split ("")? Onde posso ler mais sobre isso?
precisa saber é o seguinte
@ ericw31415 Sim, neste caso, eu o uso como uma abreviação de split``. Veja um conjunto mais poderoso literal
Neil
2

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
Ton Hospel
fonte
2

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.
Dennis
fonte
Esta resposta está ligada a outra em 15 bytes, mas a outra resposta foi postada primeiro. Você pode economizar 1 byte?
mbomb007
Eu tentei bastante; Eu não acho que posso. No entanto, nosso desempate padrão é a primeira resposta para alcançar a pontuação vencedora , e acho que cheguei a 15 primeiro.
Dennis
2

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!

Freira Furada
fonte
2

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
Rainer P.
fonte
2

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))
t-clausen.dk
fonte
2

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.

Martin Ender
fonte
Alavanca, muito alavanca.
CalculatorFeline
1

Pitão - 21 bytes

&!-z+`180K`69qzX_z_KK

Conjunto de Teste .

Maltysen
fonte
X_zKfaz o mesmo trabalho que X_z_KK. O terceiro parâmetro é opcional.
Jakube
1

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.
Dennis
fonte
1

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.

dnep
fonte
1

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.

Toby Speight
fonte
1

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.

Toby Speight
fonte
0

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
Suever
fonte
0

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
Mego
fonte
0

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!

O número um
fonte