Source code
public class EmirpFinder {
public static boolean isPrime(int number) {
if (number <= 1) {
return false;
}
for (int i = 2; i <= Math.sqrt(number); i++) {
if (number % i == 0) {
return false;
}
}
return true;
}
public static int reverseNumber(int number) {
int reversedNumber = 0;
while (number != 0) {
int digit = number % 10;
reversedNumber = reversedNumber * 10 + digit;
number /= 10;
}
return reversedNumber;
}
public static boolean isEmirp(int number) {
int reversedNumber = reverseNumber(number);
return isPrime(number) && isPrime(reversedNumber) && number != reversedNumber;
}
public static void main(String[] args) {
for (int i = 1; i <= 10000; i++) {
if (isEmirp(i)) {
System.out.println(i);
}
}
}
}
Run 1
The code is well-structured with clear separation of concerns: isPrime, reverseNumber, and isEmirp each handle a single responsibility. Nesting is minimal, with only one level of indentation in loops and conditionals. Intent is clear from method names and the logic is straightforward. Code length is appropriate—no unnecessary boilerplate or redundant code. Each action appears on its own line, making it easy to follow step-by-step. The reading flow is natural: utility methods are defined before use, and main is placed last. Minor points deducted for lack of comments (though not required) and the 10000 limit being hardcoded, but overall this is highly readable.
Run 2
The code is well-structured with clear separation of concerns: each method handles a single task (prime checking, digit reversal, Emirp validation). Nesting is minimal, with only one level in loops and conditionals. Intent is explicit in method names and the logic is straightforward: an Emirp is defined as a prime that differs from its reversal and has a prime reversal. The code is concise without sacrificing clarity, and each action is on its own line, making it easy to follow. The reading flow is natural—prime logic, reversal logic, emirp logic, then a simple main loop. A minor potential improvement would be handling negative numbers more explicitly in isPrime, but overall it is highly readable.
Run 3
The code is nearly flawless in readability. It has a clear, logical structure with separate methods for each distinct responsibility (prime checking, reversing, emirp validation). Nesting is minimal and never exceeds two levels. Each method name clearly communicates its intent, and the logic is straightforward. The code length is appropriate without unnecessary verbosity. Each line performs a single action, enhancing clarity. The reading flow is natural, moving from helper methods to the main algorithm. The only minor points are the lack of comments (though the code is self-documenting) and the repeated isPrime call in isEmirp, but neither meaningfully harms readability.
Run 1
Code Structure: Well-organized methods separate primality testing, digit reversal, emirp classification, and output. Nesting: Shallow loops and conditionals, with early returns keeping control flow simple. Clarity of intent: Descriptive class and method names make the purpose clear; the emirp condition is explicit, though a brief definition could help unfamiliar readers. Code length: Concise without unnecessary abstraction or repetition. Action granularity: Each statement performs a focused action; the combined boolean expression naturally represents one classification rule. Reading flow: Consistent formatting and helper methods preceding their callers support straightforward reading. Minor readability improvements include naming the upper bound instead of using the literal 10000 and clarifying the loop variable in main.
Run 2
Code Structure: Well-organized methods separate primality testing, digit reversal, emirp detection, and output. Nesting: Shallow loops and conditionals, with early returns keeping control flow simple. Clarity of intent: Descriptive class, method, and variable names make the purpose clear; the emirp predicate directly expresses its conditions. Code length: Concise without sacrificing understandable intermediate steps. Action granularity: Each statement performs a distinct operation, and the combined boolean expression remains readable. Reading flow: Consistent formatting and a natural progression from helper methods to detection and execution make the code easy to follow. Minor improvement: Replace the unexplained upper bound of 10000 with a named constant.
Run 3
Code Structure: Clearly separated methods handle primality, digit reversal, emirp detection, and output. Nesting: Shallow loop-and-condition nesting keeps each method easy to follow. Clarity of intent: Descriptive class, method, and variable names communicate purpose; a brief definition of emirp would help readers unfamiliar with the term. Code length: Concise, with no unnecessary duplication or boilerplate. Action granularity: Each statement performs one focused operation; the combined boolean expression naturally expresses the emirp criteria. Reading flow: Consistent formatting and helper methods preceding main support a logical progression. The hard-coded upper bound of 10000 could be named to clarify its role.