Source code
public class Emirp {
public static void main(String[] args) {
for (int i = 2; i <= 10000; i++) {
if(isPrime(i)) {
int reversed = reverseNumber(i);
if(isPrime(reversed) && reversed != i) {
System.out.println(i);
}
}
}
}
public static boolean isPrime(int num) {
if(num < 2) {
return false;
}
for(int i = 2; i <= Math.sqrt(num); i++) {
if(num % i == 0) {
return false;
}
}
return true;
}
public static int reverseNumber(int num) {
int reversed = 0;
while(num > 0) {
reversed = (reversed * 10) + (num % 10);
num /= 10;
}
return reversed;
}
}
Run 1
The code is highly readable due to its clear structure and separation of concerns. It uses small, focused helper methods (isPrime, reverseNumber) that each perform a single task. The main method is concise and expresses intent clearly by combining these helpers in a simple, flat conditional flow. Nesting is minimal—only two levels deep—and the logic is easy to follow. Naming is descriptive, and there is no unnecessary complexity or duplication. Minor improvements could include more comments or a brief explanation of what an Emirp number is, but the code itself is self-explanatory enough.
Run 2
The code is well-structured into clear methods with single responsibilities: isPrime and reverseNumber. Nesting is minimal, with only one level of conditional within the main loop. The intent of finding emirp numbers (primes whose reverse is a different prime) is clear from the method names and logic flow. Code length is appropriate for the task, with no unnecessary verbosity. Each line generally performs one action, improving readability. The reading flow is natural: iterate, check primality, reverse, check again, and output. Minor potential improvements could include adding comments or explaining the emirp concept, but overall the code is highly readable.
Run 3
The code is well-structured into logical methods (isPrime, reverseNumber) and a clear main loop, making the intent easy to follow. Nesting is minimal, with early returns reducing complexity. The action granularity is appropriate—each line performs a distinct operation. The reading flow is natural: prime check, reversal, then emirp validation. The code is concise and avoids unnecessary verbosity. Minor points deducted for lack of explanatory comments and slightly compressed formatting in the isPrime loop, but overall readability is very high.
Run 1
Code Structure: Well organized into a main routine and two focused helper methods. Nesting: Shallow overall, though main contains a loop and two nested conditions that could be flattened. Clarity of intent: Descriptive method names and straightforward arithmetic clearly convey prime checking and digit reversal; naming the 10000 limit would improve context. Code length: Concise without unnecessary complexity or repetition. Action granularity: Each statement performs a clear, discrete action, and the reversal expression remains easy to understand. Reading flow: Natural progression from candidate enumeration to primality checking, reversal, and output. Minor spacing inconsistencies around if, for, and while slightly reduce polish.
Run 2
Code Structure: Well organized into a main enumeration loop and two focused helper methods. Nesting: Moderate nesting in main, with a loop and two conditional levels, but each block is short and easy to follow. Clarity of intent: Descriptive method names clearly communicate primality checking and digit reversal; the emirp condition is explicit. The upper bound of 10000 could use a named constant to clarify its role. Code length: Concise, without unnecessary repetition or boilerplate. Action granularity: Each statement performs a single clear action; the arithmetic in digit reversal is appropriately grouped. Reading flow: Natural progression from candidate generation to primality checking, reversal, and output. Minor spacing inconsistencies around control statements slightly reduce polish.
Run 3
Code Structure: Well organized into three focused methods separating enumeration, primality testing, and digit reversal. Nesting: Generally shallow, though main contains a loop with two nested conditionals that could be flattened. Clarity of intent: Descriptive method names and straightforward conditions make the purpose clear; the upper limit of 10000 is unexplained. Code length: Concise without unnecessary duplication or boilerplate beyond standard Java structure. Action granularity: Each statement performs a single clear action, with conventional loop headers and arithmetic expressions. Reading flow: Methods follow a natural top-down sequence, and early returns simplify primality testing. Minor spacing inconsistencies around control statements slightly reduce polish.