# Explore Keith Number in Java

(Last Updated On: 22/05/2023)

Keith Numbers in Java are an intriguing phenomenon that will pique your interest and test your grasp of numerical sequences. We’ll explore Keith Numbers’ properties, algorithms, and practical uses in this blog as we delve deep into their world.

## What is a Keith Number?

A Keith Number is a special type of number that possesses a distinct property: its digits combine in a unique way to generate a new sequence of numbers. The algorithm for generating Keith Numbers involves summing up the previous occurrences of the number’s digits, creating a new number in the sequence. This process continues until the generated number equals the original number. It is this intriguing behavior that distinguishes Keith Numbers from other numeric sequences.

## Examples of Keith Numbers

Let’s explore some examples of Keith Numbers to gain a better understanding of their properties. Take, for instance, the number 14. When we apply the Keith Number algorithm, the sequence generated is 14, 5, 9, 23, 37, 77, 141, and so on. Each subsequent number in the sequence is derived by summing up its previous occurrences. This distinct pattern is a hallmark of Keith Numbers.

## Various Methods to find Keith Number in Java:

There are several methods to find Keith Numbers in Java. Here, we will discuss two common approaches: the brute force method and the optimized method:

### Program in Java to check if a number is a Keith Number

```import java.util.Scanner;
public class KeithEx  {

public static void main(String[] args) {

Scanner sc = new Scanner( System.in );
System.out.print("Input a number: ");
int num = sc.nextInt();
int n1 = num;
String s = Integer.toString(num);
int d=s.length();
int arr[]=new int[num];
int i, sum;
for(i=d-1; i>=0; i--)
{
arr[i]=n1 % 10;
n1=n1/10;

}

i=d; sum=0;
while(sum<num)
{
sum = 0;
for(int j=1; j<=d; j++)
{
sum=sum+arr[i-j];
}
arr[i]=sum;
i++;
}

if(sum==num)
System.out.println("Keith Number");
else
System.out.println("Not a Keith Number");
}
}```

#### Output:

``````Input a number: 14
Keith Number
``````

## Find first n keith numbers using Java

```import java.util.Scanner;

// Find the first n keith numbers in Java
public class KeithNumGenerator {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("How many keith numbers do you want? ");

int size = scanner.nextInt();
int counter = 0;
for (long l = 10; l < Long.MAX_VALUE; l++) {
if (isKeithNumber(String.valueOf(l))) {
System.out.print(l + ", ");
counter++;
if(counter==size) {
break;
}
}
}
scanner.close();
}

// Checks whether input number is a Keith number
public static boolean isKeithNumber(String input) {
int len = input.length();
// we keep only last n elements of the series
long[] arr = new long[len];

for (int i = 0; i < len; i++) {
arr[i] = Long.valueOf(input.substring(i, i + 1));
}
long next = 0;
long number = Long.valueOf(input);

while (next < number) {
next = 0;
for (int i = 0; i < len; i++) {
next += arr[i];
if (i < len - 1) {
arr[i] = arr[i + 1];
} else {
arr[i] = next;
}
}
if (next == number) {
return true;
}
}
return false;
}
}```

#### Output:

``````How many keith numbers do you want? 5
14, 19, 28, 47, 61,
``````

Although Keith Numbers may seem abstract, they find practical applications in various domains. In number theory and mathematics, Keith Numbers have been utilized to study and analyze number patterns. Moreover, their unique properties make them suitable for puzzle design, game development, and even encryption algorithms. Understanding Keith Numbers can unlock creative possibilities in these areas.

While Keith Numbers possess intriguing properties, they also come with limitations and challenges. As the numbers grow larger, the computational complexity increases, requiring efficient algorithms and data structures to handle them effectively. Additionally, the scarcity of large Keith Numbers poses a challenge for researchers and enthusiasts in discovering new instances of this sequence.

In conclusion, exploring Keith Numbers in Java opens a doorway to a captivating world of number theory. We have delved into their definition, properties, and algorithms, shedding light on their distinct patterns. By implementing the Keith Number algorithm, checking for Keith Numbers, and generating them within a range, we can expand our understanding and unlock their potential applications. As you venture forth, remember that Keith Numbers are just the tip of the iceberg—there is a vast universe of numeric wonders waiting to be explored. Happy coding and discovering the hidden mysteries of numbers!