Keith Number Program in Java and Python

/**
* The class Keith accepts a number and checks whether it is a Keith Number.
* A Keith sequence starts with the digits of the number and each next term
* is the sum of the previous d terms, where d is the number of digits.
*
* @author : www.guideforschool.com
* @Program Type : BlueJ Program - Java
*/

import java.util.Scanner;

class Keith
{
    public static void main(String args[])
    {
        Scanner sc = new Scanner(System.in);

        System.out.print("Enter a number: ");
        int n = sc.nextInt();

        /*
        * The original number is preserved in n.
        * copy is used for extracting digits by repeated division.
        */
        int copy = n;

        /*
        * The number of digits tells us how many previous terms
        * must be added to generate each new Keith sequence term.
        */
        String s = Integer.toString(n);
        int d = s.length();

        /*
        * The array stores the original digits first, followed by
        * the generated terms of the Keith sequence.
        */
        int arr[] = new int[n + 1];

        /*
        * Digits are obtained from right to left using % 10.
        * Therefore, they are stored from index d - 1 down to 0
        * so that the original left-to-right order is maintained.
        */
        for(int i = d - 1; i >= 0; i--)
        {
            arr[i] = copy % 10;
            copy = copy / 10;
        }

        int i = d;
        int sum = 0;

        /*
        * New terms are generated until the sequence reaches
        * or crosses the original number.
        */
        while(sum < n)
        {
            sum = 0;

            /*
            * A Keith sequence term is formed by adding the previous d terms.
            */
            for(int j = 1; j <= d; j++)
            {
                sum = sum + arr[i - j];
            }

            arr[i] = sum;
            i++;
        }

        /*
        * If the generated term is exactly equal to the number,
        * the number appears in its own Keith sequence.
        */
        if(sum == n)
        System.out.println("The number is a Keith Number");
        else
        System.out.println("The number is not a Keith Number");
    }
}

n = int(input("Enter a number: "))

# The original number is kept unchanged for final comparison.
copy = n

# The number of digits decides how many previous terms are added.
s = str(n)
d = len(s)

# The list stores the original digits followed by the generated
# Keith sequence terms.
arr = [0] * (n + 1)

# Digits are obtained from right to left using % 10.
# They are stored backwards in the list to preserve the original order.
for i in range(d - 1, -1, -1):
    arr[i] = copy % 10
    copy = copy // 10

i = d
total = 0

# New terms are generated until the sequence reaches or crosses
# the original number.
while total < n:
    total = 0

    # A Keith sequence term is formed by adding the previous d terms.
    for j in range(1, d + 1):
        total = total + arr[i - j]

    arr[i] = total
    i = i + 1

# If the generated term is equal to the number, it is a Keith Number.
if total == n:
    print("The number is a Keith Number")
else:
    print("The number is not a Keith Number")