Un número automórfico es un número que es un sufijo de su cuadrado en la base 10. Esta es la secuencia A003226 en el OEIS.

Tu tarea:

Escriba un programa o función para determinar si una entrada es un número Automorphic.

Entrada:

Un número entero entre 0 y 10 ^ 12 (inclusive), que puede o no ser un número Automorphic.

Salida:

Un valor verdadero / falso que indica si la entrada es o no un número Automorphic.

Ejemplos:

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

Puntuación:

Este es el código de golf , gana la puntuación más baja en bytes.

Brachylog , 5 bytes

~√a₁?

Pruébalo en línea!

Cómo 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`

Pruébalo en línea!

Por primera vez en la historia, la adición de Python 2 La la repetición de longs es una característica más que un error.

La idea es verificar si decir, 76^2=5776termina 76verificando si 76Les una subcadena de 5776L. Para hacer Laparecer los números no grandes, multiplicamos por 1Lo tenemos 2Lcomo exponente, ya que una operación aritmética con un largo con produce un largo.

Python 2 , 31 bytes

Out-golfed by xnor ... (esto sucede cada vez)> <Pero bueno, sorprendentemente es Pythonic para code-golf .

La gente no tiende a recordar que Python tiene str.endswith()...

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

Pruébalo en línea!

05AB1E , 5 bytes

n.s¹å

Pruébalo en línea!

Retina , 44 bytes

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

Pruébalo en línea!

Hay exactamente 4 soluciones a la ecuación de 10 adic x*x = x.

Alice , 17 bytes

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

Pruébalo en línea!

No genera nada (que es falso en el modo Ordinal) o Jabberwocky(que no está vacío y, por lo tanto, es verdadero en el modo Ordinal; también es el valor de cadena de verdad canónico).

Explicación

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

Esta es una ligera modificación del marco general para los programas lineales en modo ordinal. El /en el medio se usa para tener un solo operador en modo Cardinal entre (the *) y luego necesitamos #saltearlo en modo Ordinal en el camino de regreso. El programa lineal es entonces:

i..*.QLzno@

Veamos eso:

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@#]==#&

Pruébalo en línea! Matemáticas imprime un mensaje extra pero la respuesta es correcta

Python 2, 37 33 30 29 bytes

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

Guardado 4 bytes gracias a @LeakyNun. Se guardaron 3 bytes al notar que la entrada es inferior a 10 ^ 12, por lo nque no termina con una "L". Ahorré 1 byte gracias a @Dennis porque en primer lugar conté mal.

Pruébalo en línea! (Enlace TIO cortesía de @Dennis).

C (gcc) , 57 bytes

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

Según la respuesta de @ betseg, esta es una función que devuelve 1 o 0 . Produce salida de basura a STDOUT, que está permitida por defecto .

La puntuación contiene +4 bytes para el indicador del compilador -lm.

Pruébalo en línea!

Ruby, 22 bytes

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

Pruébalo en línea!

C # (.NET Core) , 47 bytes

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

Pruébalo en línea!

Carbón , 12 11 bytes

Ｉ¬⌕⮌ＩＸＩθ²⮌θ

Pruébalo en línea!

Devuelve Falseas falseyy Trueas truthy.

• ¡1 byte guardado gracias a ASCII-only! (¿Cómo podría perder la Powerfunción?)

JavaScript (ES6), 23 bytes

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

Intentalo

Escribí este fragmento en mi teléfono, así que edítelo si no funciona correctamente.

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>

Jalea , 6 bytes

²ṚwṚ⁼1

Pruébalo en línea!

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

Pruébalo en línea!

R, 28 bytes

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

Crea una función:

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

Toma el módulo de x^2tal manera que mantenemos los últimos dígitos, con los cuales los comparamos x.

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

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

Pruébalo en línea!

Jalea , 7 bytes

²_ọæċ⁵$

Pruébalo en línea!

Número positivo para sí, 0 para no.

Retina , 47 33 bytes

14 bytes gracias a Martin Ender.

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

Pruébalo en línea!

PHP , 41 bytes

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

PHP Sandbox en línea

PHP , 42 bytes

sin Regex

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

PHP , 44 bytes

Usa la distancia 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))

El algoritmo está limitado solo por el tipo entero usado para las variables. En el caso de Batch, se trata de enteros con signo de 32 bits, por lo que el máximo es 2147483647. Funciona probando tanto n como n-1 para las potencias necesarias de 2 y 5 como factores. (Excepto cuando n es 0 o 1, n y n-1 tendrán un factor cada uno).

> <> , 30 bytes

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

¡Pruébelo en línea o mírelo en el parque de peces !

Asume que el número de entrada x ya está en la pila.

Explicación: El pez toma el cociente de x ² aumentando las potencias de 10, y cuenta cuántas veces es igual a x . Cuando la potencia de 10 es mayor que x , imprime el conteo y se detiene. El recuento será 1 si x es automórfico y 0 si no lo es.

Pari / GP , 23 bytes

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

Pruébalo en línea!

Pyth , 10 9 bytes

-1 byte gracias a isaacg .

x_`^vz2_z

Devuelve 0 cuando el número es automorfo, cualquier otra cosa si no lo es.

¡Pruébelo en línea!

Explicaciones

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

Pruébalo en línea!

Perl 6 , 15 bytes

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

Pruébalo en línea!

Devuelve un objeto Match verdadero para entradas automórficas y un valor Nulo falso para otros números.

Clojure, 59 bytes

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

Esto parece demasiado detallado.

MATL , 10 bytes

UUVG36hXXn

Esto funciona para números hasta floor(sqrt(2^53)), según doublelas limitaciones de precisión.

La salida es un número positivo (que es verdadero) si es automorfo, o vacío (que es falso) si no.

Pruébalo en línea!

Explicación

Es curioso que esta respuesta use las dos versiones sobrecargadas de U: con la entrada de cadena se evalúa como un número, y con la entrada de número calcula el cuadrado.

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