Coding

Automorphic Number

Asked at

Visa

1Give yourself 5 minutes

2Answer out loud, not in your head

3Then compare with the answer below

The problem

Given a positive integer N, determine whether it is an Automorphic Number.

A number is called an Automorphic Number if the square of the number ends with the number itself.

Input: N = 76 Output: true Explanation: 76 * 76 = 5776 → ends in 76

Input: N = 25 Output: true Explanation: 25 * 25 = 625 → ends in 25

Input: N = 7

1 ≤ N ≤ 10⁶

cpp

class Solution {
public:
    bool isAutomorphic(int n) {
        // Your code goes here
    }
};

java

class Solution {
    public boolean isAutomorphic(int n) {
        // Your code goes here
    }
}

python

class Solution:
    def isAutomorphic(self, n: int) -> bool:
        # Your code goes here

javascript

class Solution {
    isAutomorphic(n) {
        // Your code goes here
    }
}

csharp

class Solution {
    public bool IsAutomorphic(int n) {
        // Your code goes here
    }
}

func isAutomorphic(n int) bool {

Stuck? Show a way to structure it+

01Count decimal digits, with zero as one digit
02Compute modulus 10^digits
03Compare square modulo modulus with the original number
04Use a wider numeric type or string arithmetic if needed

Reference answer

Start by restating the input contract for Automorphic Number and testing the smallest boundary case before choosing the algorithm. A number is automorphic when its square ends with the number itself. Compute the square, then compare the trailing digits using a modulus equal to 10 raised to the number of digits. Handle zero deliberately: 0 is normally considered automorphic. Explain the invariant while coding, then show how each update preserves it. For a d-digit integer, counting digits and forming the modulus take O(d) time and O(1) auxiliary space in the usual fixed-width model. Walk through one nontrivial example aloud so the interviewer can see why the method reaches the intended result. Finally, call out input assumptions and failure cases rather than silently relying on them. A clean implementation should keep state local, use descriptive names, and avoid work that the invariant makes unnecessary.

Then expect these follow-ups

How would you test very large integers?
Tests: constraint adaptation
Which residues are automorphic in base 10?
Tests: follow-up reasoning

Free to read · better with Enzo

Practice this out loud with Enzo

Enzo runs it as a mock interview, pushes back with follow-ups, and grades you on the rubric.

Continue with Enzo Sign up free

Next question