Skip to content

Commit 2bc0dd8

Browse files
HardvanHardvan
committed
refactor: Enhance docs, code, add tests in KeithNumber 
1 parent c0ca704 commit 2bc0dd8

File tree

2 files changed

+228
-33
lines changed

2 files changed

+228
-33
lines changed

‎src/main/java/com/thealgorithms/maths/KeithNumber.java‎

Lines changed: 74 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -4,57 +4,98 @@
44
import java.util.Collections;
55
import java.util.Scanner;
66

7-
final class KeithNumber {
7+
/**
8+
* A Keith number is an n-digit positive integer where the sequence formed by
9+
* starting with its digits and repeatedly adding the previous n terms,
10+
* eventually reaches the number itself.
11+
*
12+
* <p>
13+
* For example:
14+
* <ul>
15+
* <li>14 is a Keith number: 1, 4, 5, 9, 14</li>
16+
* <li>19 is a Keith number: 1, 9, 10, 19</li>
17+
* <li>28 is a Keith number: 2, 8, 10, 18, 28</li>
18+
* <li>197 is a Keith number: 1, 9, 7, 17, 33, 57, 107, 197</li>
19+
* </ul>
20+
*
21+
* @see <a href="https://en.wikipedia.org/wiki/Keith_number">Keith Number -
22+
* Wikipedia</a>
23+
* @see <a href="https://mathworld.wolfram.com/KeithNumber.html">Keith Number -
24+
* MathWorld</a>
25+
*/
26+
public final class KeithNumber {
827
private KeithNumber() {
928
}
1029

11-
// user-defined function that checks if the given number is Keith or not
12-
static boolean isKeith(int x) {
13-
// List stores all the digits of the X
30+
/**
31+
* Checks if a given number is a Keith number.
32+
*
33+
* <p>
34+
* The algorithm works as follows:
35+
* <ol>
36+
* <li>Extract all digits of the number and store them in a list</li>
37+
* <li>Generate subsequent terms by summing the last n digits</li>
38+
* <li>Continue until a term equals or exceeds the original number</li>
39+
* <li>If a term equals the number, it is a Keith number</li>
40+
* </ol>
41+
*
42+
* @param number the number to check (must be positive)
43+
* @return {@code true} if the number is a Keith number, {@code false} otherwise
44+
* @throws IllegalArgumentException if the number is not positive
45+
*/
46+
public static boolean isKeith(int number) {
47+
if (number <= 0) {
48+
throw new IllegalArgumentException("Number must be positive");
49+
}
50+
51+
// Extract digits and store them in the list
1452
ArrayList<Integer> terms = new ArrayList<>();
15-
// n denotes the number of digits
16-
int temp = x;
17-
int n = 0;
18-
// executes until the condition becomes false
53+
int temp = number;
54+
int digitCount = 0;
55+
1956
while (temp > 0) {
20-
// determines the last digit of the number and add it to the List
2157
terms.add(temp % 10);
22-
// removes the last digit
2358
temp = temp / 10;
24-
// increments the number of digits (n) by 1
25-
n++;
59+
digitCount++;
2660
}
27-
// reverse the List
61+
62+
// Reverse the list to get digits in correct order
2863
Collections.reverse(terms);
64+
65+
// Generate subsequent terms in the sequence
2966
int nextTerm = 0;
30-
int i = n;
31-
// finds next term for the series
32-
// loop executes until the condition returns true
33-
while (nextTerm < x) {
67+
int currentIndex = digitCount;
68+
69+
while (nextTerm < number) {
3470
nextTerm = 0;
35-
// next term is the sum of previous n terms (it depends on number of digits the number
36-
// has)
37-
for (int j = 1; j <= n; j++) {
38-
nextTerm = nextTerm + terms.get(i - j);
71+
// Sum the last 'digitCount' terms
72+
for (int j = 1; j <= digitCount; j++) {
73+
nextTerm = nextTerm + terms.get(currentIndex - j);
3974
}
4075
terms.add(nextTerm);
41-
i++;
76+
currentIndex++;
4277
}
43-
// when the control comes out of the while loop, there will be two conditions:
44-
// either nextTerm will be equal to x or greater than x
45-
// if equal, the given number is Keith, else not
46-
return (nextTerm == x);
78+
79+
// Check if the generated term equals the original number
80+
return (nextTerm == number);
4781
}
4882

49-
// driver code
83+
/**
84+
* Main method for demonstrating Keith number detection.
85+
* Reads a number from standard input and checks if it is a Keith number.
86+
*
87+
* @param args command line arguments (not used)
88+
*/
5089
public static void main(String[] args) {
51-
Scanner in = new Scanner(System.in);
52-
int n = in.nextInt();
53-
if (isKeith(n)) {
54-
System.out.println("Yes, the given number is a Keith number.");
90+
Scanner scanner = new Scanner(System.in);
91+
System.out.print("Enter a positive integer: ");
92+
int number = scanner.nextInt();
93+
94+
if (isKeith(number)) {
95+
System.out.println("Yes, " + number + " is a Keith number.");
5596
} else {
56-
System.out.println("No, the given number is not a Keith number.");
97+
System.out.println("No, " + number + " is not a Keith number.");
5798
}
58-
in.close();
99+
scanner.close();
59100
}
60101
}

‎src/test/java/com/thealgorithms/maths/KeithNumberTest.java‎

Lines changed: 154 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,154 @@
1+
package com.thealgorithms.maths;
2+
3+
import static org.junit.jupiter.api.Assertions.assertEquals;
4+
import static org.junit.jupiter.api.Assertions.assertFalse;
5+
import static org.junit.jupiter.api.Assertions.assertThrows;
6+
import static org.junit.jupiter.api.Assertions.assertTrue;
7+
8+
import org.junit.jupiter.api.Test;
9+
10+
/**
11+
* Test cases for {@link KeithNumber}.
12+
*/
13+
class KeithNumberTest {
14+
15+
/**
16+
* Tests single-digit Keith numbers.
17+
* All single-digit numbers (1-9) are Keith numbers by definition.
18+
*/
19+
@Test
20+
void testSingleDigitKeithNumbers() {
21+
assertTrue(KeithNumber.isKeith(1));
22+
assertTrue(KeithNumber.isKeith(2));
23+
assertTrue(KeithNumber.isKeith(3));
24+
assertTrue(KeithNumber.isKeith(4));
25+
assertTrue(KeithNumber.isKeith(5));
26+
assertTrue(KeithNumber.isKeith(6));
27+
assertTrue(KeithNumber.isKeith(7));
28+
assertTrue(KeithNumber.isKeith(8));
29+
assertTrue(KeithNumber.isKeith(9));
30+
}
31+
32+
/**
33+
* Tests two-digit Keith numbers.
34+
* Known two-digit Keith numbers: 14, 19, 28, 47, 61, 75.
35+
*/
36+
@Test
37+
void testTwoDigitKeithNumbers() {
38+
assertTrue(KeithNumber.isKeith(14));
39+
assertTrue(KeithNumber.isKeith(19));
40+
assertTrue(KeithNumber.isKeith(28));
41+
assertTrue(KeithNumber.isKeith(47));
42+
assertTrue(KeithNumber.isKeith(61));
43+
assertTrue(KeithNumber.isKeith(75));
44+
}
45+
46+
/**
47+
* Tests three-digit Keith numbers.
48+
* Known three-digit Keith numbers: 197, 742.
49+
*/
50+
@Test
51+
void testThreeDigitKeithNumbers() {
52+
assertTrue(KeithNumber.isKeith(197));
53+
assertTrue(KeithNumber.isKeith(742));
54+
}
55+
56+
/**
57+
* Tests four-digit Keith numbers.
58+
* Known four-digit Keith numbers: 1104, 1537, 2208, 2580, 3684, 4788, 7385,
59+
* 7647, 7909.
60+
*/
61+
@Test
62+
void testFourDigitKeithNumbers() {
63+
assertTrue(KeithNumber.isKeith(1104));
64+
assertTrue(KeithNumber.isKeith(1537));
65+
assertTrue(KeithNumber.isKeith(2208));
66+
}
67+
68+
/**
69+
* Tests two-digit non-Keith numbers.
70+
*/
71+
@Test
72+
void testTwoDigitNonKeithNumbers() {
73+
assertFalse(KeithNumber.isKeith(10));
74+
assertFalse(KeithNumber.isKeith(11));
75+
assertFalse(KeithNumber.isKeith(12));
76+
assertFalse(KeithNumber.isKeith(13));
77+
assertFalse(KeithNumber.isKeith(15));
78+
assertFalse(KeithNumber.isKeith(20));
79+
assertFalse(KeithNumber.isKeith(30));
80+
assertFalse(KeithNumber.isKeith(50));
81+
}
82+
83+
/**
84+
* Tests three-digit non-Keith numbers.
85+
*/
86+
@Test
87+
void testThreeDigitNonKeithNumbers() {
88+
assertFalse(KeithNumber.isKeith(100));
89+
assertFalse(KeithNumber.isKeith(123));
90+
assertFalse(KeithNumber.isKeith(196));
91+
assertFalse(KeithNumber.isKeith(198));
92+
assertFalse(KeithNumber.isKeith(456));
93+
assertFalse(KeithNumber.isKeith(741));
94+
assertFalse(KeithNumber.isKeith(743));
95+
assertFalse(KeithNumber.isKeith(999));
96+
}
97+
98+
/**
99+
* Tests validation for edge case 14 in detail.
100+
* 14 is a Keith number: 1, 4, 5 (1+4), 9 (4+5), 14 (5+9).
101+
*/
102+
@Test
103+
void testKeithNumber14() {
104+
assertTrue(KeithNumber.isKeith(14));
105+
}
106+
107+
/**
108+
* Tests validation for edge case 197 in detail.
109+
* 197 is a Keith number: 1, 9, 7, 17, 33, 57, 107, 197.
110+
*/
111+
@Test
112+
void testKeithNumber197() {
113+
assertTrue(KeithNumber.isKeith(197));
114+
}
115+
116+
/**
117+
* Tests that zero throws an IllegalArgumentException.
118+
*/
119+
@Test
120+
void testZeroThrowsException() {
121+
assertThrows(IllegalArgumentException.class, () -> KeithNumber.isKeith(0));
122+
}
123+
124+
/**
125+
* Tests that negative numbers throw an IllegalArgumentException.
126+
*/
127+
@Test
128+
void testNegativeNumbersThrowException() {
129+
assertThrows(IllegalArgumentException.class, () -> KeithNumber.isKeith(-1));
130+
assertThrows(IllegalArgumentException.class, () -> KeithNumber.isKeith(-14));
131+
assertThrows(IllegalArgumentException.class, () -> KeithNumber.isKeith(-100));
132+
}
133+
134+
/**
135+
* Tests various edge cases with larger numbers.
136+
*/
137+
@Test
138+
void testLargerNumbers() {
139+
assertTrue(KeithNumber.isKeith(2208));
140+
assertFalse(KeithNumber.isKeith(2207));
141+
assertFalse(KeithNumber.isKeith(2209));
142+
}
143+
144+
/**
145+
* Tests the expected behavior with all two-digit Keith numbers.
146+
*/
147+
@Test
148+
void testAllKnownTwoDigitKeithNumbers() {
149+
int[] knownKeithNumbers = {14, 19, 28, 47, 61, 75};
150+
for (int number : knownKeithNumbers) {
151+
assertEquals(true, KeithNumber.isKeith(number), "Expected " + number + " to be a Keith number");
152+
}
153+
}
154+
}

0 commit comments

Comments
 (0)