Um número automórfico é um número que é um sufixo de seu quadrado na base 10. Essa é a sequência A003226 no OEIS.

Sua tarefa:

Escreva um programa ou função para determinar se uma entrada é um número automórfico.

Entrada:

Um número inteiro entre 0 e 10 ^ 12 (inclusive), que pode ou não ser um número automórfico.

Saída:

Um valor de verdade / falsidade indicando se a entrada é ou não um número automórfico.

Exemplos:

0           -> truthy
1           -> truthy
2           -> falsy
9376        -> truthy
8212890625  -> truthy

Pontuação:

Isso é código-golfe , a menor pontuação em bytes ganha.

Braquilog , 5 bytes

~√a₁?

Experimente online!

Como funciona

~√a₁?
~√      the input is the square root of a number
  a₁    whose suffix is
    ?   the input

Python 2 , 24 bytes

lambda n:`n*1L`in`n**2L`

Experimente online!

Pela primeira vez na história, o Python 2 anexar um Lao repr de longs é um recurso e não um bug.

A idéia é verificar se, digamos, 76^2=5776termina 76verificando se 76Lé uma substring de 5776L. Para fazer Laparecer os números não grandes, multiplicamos por 1Lou temos 2Lcomo expoente, pois uma operação aritmética com um longo com produz um longo.

Python 2 , 31 bytes

Superado pelo xnor ... (isso acontece toda vez)> <Mas ei, é surpreendentemente Pythonic para o código-golfe .

As pessoas não tendem a lembrar que o Python tem str.endswith()...

lambda n:str(n*n).endswith(`n`)

Experimente online!

05AB1E , 5 bytes

n.s¹å

Experimente online!

Retina , 44 bytes

$
;918212890625;81787109376;0;1;
^(\d+;).*\1

Experimente online!

Existem exatamente 4 soluções para a equação 10-adic x*x = x.

Alice , 17 bytes

/o.z/#Q/
@in.*.L\

Experimente online!

Não produz nada (que é falso no modo Ordinal) ou Jabberwocky(que não está vazio e, portanto, é verdade no modo Ordinal; é também o valor da string de verdade canônica).

Explicação

/.../#./
....*..\

Essa é uma pequena modificação da estrutura geral dos programas lineares no modo Ordinal. O /meio é usado para ter um único operador no modo Cardinal entre (o *) e, em seguida, precisamos #ignorá-lo no modo Ordinal no caminho de volta. O programa linear é então:

i..*.QLzno@

Vamos passar por isso:

i    Read all input as a string and push it to the stack.
..   Make two copies.
*    This is run in Cardinal mode, so it implicitly converts the top two
     copies to their integer value and multiplies them to compute the square.
.    Implicitly convert the square back to a string and make a copy of it.
Q    Reverse the stack to bring the input on top of the two copies of its square.
L    Shortest common supersequence. This pops the input and the square from
     the top of the stack and pushes the shortest string which begins with
     the square and ends with the input. Iff the square already ends with the
     input, this gives us the square, otherwise it gives us some longer string.
z    Drop. Pop the SCS and the square. If the square contains the SCS (which
     would mean they're equal), this removes everything up to the SCS from
     the square. In other words, if the SCS computation left the square
     unchanged, this gives us an empty string. Otherwise, it gives us back
     the square.
n    Logical not. Turns the empty string into "Jabberwocky" and everything
     else into an empty string.
o    Print the result.
@    Terminate the program.

Mathematica, 31 bytes

Mod[#^2,10^IntegerLength@#]==#&

Experimente online! O Mathics imprime uma mensagem extra, mas a resposta está correta

Python 2, 37 33 30 29 bytes

lambda n:n*~-n%10**len(`n`)<1

Guardado 4 bytes graças a @LeakyNun. Salva 3 bytes ao notar que a entrada é menor que 10 ^ 12, portanto n, não termina com um "L". Economizei 1 byte graças a @Dennis porque eu desconectei em primeiro lugar.

Experimente online! (Link TIO cortesia de @Dennis).

C (gcc) , 57 bytes

f(__int128 n){n=n*n%(long)pow(10,printf("%u",n))==n;}

Com base na resposta de @betseg, esta é uma função que retorna 1 ou 0 . Produz saída de lixo para STDOUT, que é permitido por padrão .

A pontuação contém +4 bytes para o sinalizador do compilador -lm.

Experimente online!

Ruby, 22 bytes

->n{"#{n*n}"=~/#{n}$/}

Experimente online!

C # (.NET Core) , 47 bytes

n=>$"{BigInteger.Multiply(n,n)}".EndsWith(n+"")

Experimente online!

Carvão , 12 11 bytes

Ｉ¬⌕⮌ＩＸＩθ²⮌θ

Experimente online!

Retorna Falsecomo falseye Truecomo truthy.

• 1 byte economizado graças ao ASCII-only! (Como eu poderia perder a Powerfunção?)

JavaScript (ES6), 23 bytes

n=>`${n*n}`.endsWith(n)

Tente

Escrevi este trecho no meu telefone. Por isso, edite se não estiver funcionando corretamente.

f=
n=>`${n*n}`.endsWith(n)
oninput=_=>o.innerText=f(+i.value);o.innerText=f(i.value=1)

<input id=i type=number><pre id=o>

Gelatina , 6 bytes

²ṚwṚ⁼1

Experimente online!

Kotlin, 36 bytes

fun a(i:Int)="${i*i}".endsWith("$i")

C, 77 + 4 ( -lm) = 81 bytes

#import<tgmath.h>
i;f(long double n){i=fmod(n*n,pow(10,(int)log10(n)+1))==n;}

Experimente online!

R, 28 bytes

pryr::f(x^2%%10^nchar(x)==x)

Cria uma função:

function (x) 
x^2%%10^nchar(x) == x

Toma o módulo de x^2tal forma que mantemos os últimos dígitos, com os quais comparamos x.

Perl 5 , 15 + 1 (-p) = 16 bytes

$_=$_**2=~/$_$/

Experimente online!

Geléia , 7 bytes

²_ọæċ⁵$

Experimente online!

Número positivo para sim, 0 para não.

Retina , 47 33 bytes

14 bytes graças a Martin Ender.

.+
$*
$
¶$`
\G1
$%_
M%`1
(.+)¶\1$

Experimente online!

PHP , 41 bytes

<?=preg_match("#$argn$#",bcpow($argn,2));

Sandbox do PHP Online

PHP , 42 bytes

sem Regex

<?=strtr(bcpow($argn,2),[$argn=>X])[-1]>A;

PHP , 44 bytes

Use a distância levenshtein

<?=!levenshtein($argn,bcpow($argn,2),0,1,1);

Dyvil , 26 bytes

x=>"\(x*x)".endsWith"\(x)"

Uso:

let f: int->boolean = x=>"\(x*x)".endsWith"\(x)"
print(f 20) // false

Lote, 122 bytes

@set/an=%1,t=f=1
:l
@set/at+=t,f*=5,n/=10
@if %n% gtr 0 goto l
@cmd/cset/a"(!(%1%%t)|!(~-%1%%t))&(!(%1%%f)|!(~-%1%%f))

O algoritmo é limitado apenas pelo tipo inteiro usado para variáveis. No caso de Lote, são números inteiros assinados de 32 bits; portanto, o máximo é 2147483647. Funciona testando n e n-1 para obter as potências necessárias de 2 e 5 como fatores. (Exceto quando n for 0 ou 1, ne en-1 terão um fator cada.)

> <> , 30 bytes

1&0}\{n;
:&(?\:::*&a*:&%={+}:&

Experimente online ou assista no playground de peixes !

Supõe que o número de entrada x já esteja na pilha.

Explicação: O peixe pega o quociente de x ² aumentando as potências de 10 e conta quantas vezes isso é igual a x . Quando a potência de 10 fica maior que x , ela imprime a contagem e pára. A contagem será 1 se x for automórfico e 0 se não for.

Pari / GP , 23 bytes

n->n^2%10^#digits(n)==n

Experimente online!

Pitão , 10 9 bytes

-1 byte graças a isaacg .

x_`^vz2_z

Retorna 0 quando o número é automórfico, qualquer outra coisa se não for.

Teste online!

Explicações

x_`^vz2_z

   ^vz2      # Evaluate the input to a number, compute the square
  `          # Convert the squared number to a string
 _           # Reverse it
x      _z    # Find the index of the first occurrence of the reversed input in the reversed square. That's basically equivalent of doing an endswith() in Python
             # Implicit input of the index. If 0, then the reversed square starts with the reversed input

Rexx (Regina) , 48 bytes

numeric digits 25
arg n
say right(n*n,length(n))=n

Experimente online!

Perl 6 , 15 bytes

{$^x²~~/$^x$/}

Experimente online!

Retorna um objeto Match de verdade para entradas automórficas e um valor Nulo falso para outros números.

Clojure, 59 bytes

#(apply = true(map =(reverse(str %))(reverse(str(* % %)))))

Isso parece muito detalhado.

MATL , 10 bytes

UUVG36hXXn

Isso funciona para números de até floor(sqrt(2^53)), conforme as doublelimitações de precisão.

A saída é um número positivo (que é verdadeiro) se automático, ou vazio (que é falso) se não.

Experimente online!

Explicação

Engraçado que essa resposta use as duas versões sobrecarregadas de U: com entrada de string, ela é avaliada como um número e, com a entrada de número, calcula o quadrado.

U      % Implicitly input a string. Evaluate as a number
U      % Square of number
V      % Convert number to string representation
G      % Push input string again
36h    % Post-pend '$'
XX     % Regexp match. Gives cell array of matching substrings.
n      % Number of elements. Implicitly display