Am I an Automorphic Number?

Question

An Automorphic number is a number which is a suffix of its square in base 10. This is sequence A003226 in the OEIS.

Your Task:

Write a program or function to determine whether an input is an Automorphic number.

Input:

An integer between 0 and 10^12 (inclusive), that may or may not be an Automorphic number.

Output:

A truthy/falsy value indicating whether or not the input is an Automorphic number.

Examples:

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

Scoring:

This is code-golf, lowest score in bytes wins.

Answer 1

Brachylog, 5 bytes

~√a₁?

Try it online!

How it works

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

Answer 2

Python 2, 24 bytes

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

Try it online!

For the first time in history, Python 2's appending an L to the repr of longs is a feature rather than a bug.

The idea is to check if say, 76^2=5776 ends in 76 by checking if 76L is a substring of 5776L. To make the L appear for non-huge numbers, we multiply by 1L or have 2L as the exponent, since an arithmetic operation with a long with produces a long.

Answer 3

Python 2, 31 bytes

Out-golfed by xnor... (this happens every single time) >< But hey, it's surprisingly Pythonic for code-golf.

People don't tend to remember Python has str.endswith()...

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

Try it online!

Answer 4

05AB1E, 5 bytes

n.s¹å

Try it online!

Answer 5

Retina, 44 bytes

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

Try it online!

There are exactly 4 solutions to the 10-adic equation x*x = x.

Answer 6

Python 2, 37 33 30 29 bytes

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

Saved 4 bytes thanks to @LeakyNun. Saved 3 bytes by noticing that the input is lower than 10^12 so n doesn't end with an "L". Saved 1 byte thanks to @Dennis because I miscounted in the first place.

Try it online! (TIO link courtesy of @Dennis).

Answer 7

Alice, 17 bytes

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

Try it online!

Outputs nothing (which is falsy in Ordinal mode) or Jabberwocky (which is non-empty and therefore truthy in Ordinal mode; it's also the canonical truthy string value).

Explanation

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

This is a slight modification of the general framework for linear Ordinal mode programs. The / in the middle is used to have a single operator in Cardinal mode in between (the *) and then we need the # to skip it in Ordinal mode on the way back. The linear program is then:

i..*.QLzno@

Let's go through that:

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.

Answer 8

Mathematica, 31 bytes

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

Try it online! Mathics prints an extra message but the answer is correct

Answer 9

C (gcc), 57 bytes

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

Based on @betseg's answer, this is a function that returns 1 or 0. It produces garbage output to STDOUT, which is allowed by default.

The score contains +4 bytes for the compiler flag -lm.

Try it online!

Answer 10

Ruby, 22 bytes

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

Try it online!

Answer 11

Charcoal, 12 11 bytes

Ｉ¬⌕⮌ＩＸＩθ²⮌θ

Try it online!

Returns False as falsey and True as truthy.

• 1 byte saved thanks to ASCII-only! (How could I miss the Power function?)

Answer 12

C# (.NET Core), 47 bytes

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

Try it online!

Answer 13

JavaScript (ES6), 23 bytes

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

---

Try it

Wrote this Snippet up on my phone, so please edit if it's not working correctly.

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>

Answer 14

Jelly, 6 bytes

²ṚwṚ⁼1

Try it online!

Answer 15

Kotlin, 36 bytes

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

Answer 16

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

Try it online!

Answer 17

R, 28 bytes

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

Creates a function:

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

Takes the modulus of x^2 such that we keep the last digits, which we compare to x.

Answer 18

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

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

Try it online!

Answer 19

Jelly, 7 bytes

²_ọæċ⁵$

Try it online!

Positive number for yes, 0 for no.

Answer 20

PHP, 41 bytes

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

PHP Sandbox Online

PHP, 42 bytes

without Regex

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

PHP, 44 bytes

Use the levenshtein distance

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

Answer 21

Retina, 47 33 bytes

14 bytes thanks to Martin Ender.

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

Try it online!

Answer 22

Dyvil, 26 bytes

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

Usage:

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

Answer 23

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

Algorithm is limited only by the integer type used for variables. In the case of Batch, this is 32-bit signed integers, so the maximum is 2147483647. Works by testing both n and n-1 for necessary powers of 2 and 5 as factors. (Except when n is 0 or 1, n and n-1 will have one factor each.)

Answer 24

Pyth, 10 9 bytes

-1 byte thanks to isaacg.

x_`^vz2_z

Returns 0 when the number is automorphic, anything else if it is not.

Test it online!

Explanations

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

Answer 25

><>, 30 bytes

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

Try it online, or watch it at the fish playground!

Assumes the input number x is already on the stack.

Explanation: The fish takes the quotient of x² by increasing powers of 10, and counts how many times this equals x. When the power of 10 gets larger than x, it prints the count and halts. The count will be 1 if x is automorphic, and 0 if it isn't.

Answer 26

Pari/GP, 23 bytes

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

Try it online!

Answer 27

Rexx (Regina), 48 bytes

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

Try it online!

Answer 28

Python 3, 40 35 bytes

-@Nick A saved 5 bytes: use of endswith()

lambda x:str(x*x).endswith(str(x)) 

Try it online!

Python 2, 31 bytes (Does not work for large numbers)

lambda x:`x*x`[-len(`x`):]==`x`

Try it online!

Answer 29

Perl 6, 15 bytes

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

Try it online!

Returns a truthy Match object for automorphic inputs, and a falsy Nil value for other numbers.

Answer 30

Clojure, 59 bytes

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

This seems overly verbose.

Answer 31

MATL, 10 bytes

UUVG36hXXn

This works for numbers up to floor(sqrt(2^53)), as per double precision limitations.

Output is a positive number (which is truthy) if automorphic, or empty (which is falsy) if not.

Try it online!

Explanation

Funny that this answer uses the two overloaded versions of U: with string input it evaluates as a number, and with number input it computes the square.

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

Answer 32

Java 8, 36 bytes

n->(n.multiply(n)+"").endsWith(n+"")

Input is a java.math.BigInteger, output a boolean.

Explanation:

Try it here.

n->                   // Method with BigInteger parameter and boolean return-type 
  (n.multiply(n)+"")  //  Return if the String representation of n*n
   .endsWith(n+"")    //  ends with the String representation of n
                      // End of method (implicit / single-line body)

Answer 33

Haskell, 45 bytes

f=reverse.show
g a=and$zipWith(==)(f a)$f$a^2

Try it online!

Haskell + Data.Function, 42 bytes

g a=and$on(zipWith(==))(reverse.show)a$a^2

Try it online!

Haskell + Data.Function + Control.Monad, 40 bytes

and.ap(on(zipWith(==))$reverse.show)(^2)

Try it online!