Source code
public class Emirp {
public static void main(String[] args) {
int count = 0;
for (int i = 1; i <= 10000; i++) {
if (isPrime(i) && isPrime(reverseNumber(i)) && i != reverseNumber(i)) {
System.out.println(i);
count++;
}
}
}
public static int reverseNumber(int number) {
int reverse = 0;
while (number != 0) {
reverse = reverse * 10 + number % 10;
number /= 10;
}
return reverse;
}
public static boolean isPrime(int number) {
if (number == 1 || number == 0) {
return false;
}
for (int i = 2; i <= Math.sqrt(number); i++) {
if (number % i == 0) {
return false;
}
}
return true;
}
}
Run 1
The code is well-structured with clear separation of concerns: main controls flow, reverseNumber and isPrime handle distinct tasks. Nesting is minimal, with only a single conditional inside a loop in main and in isPrime. Intent is evident from method names and the straightforward emirp check. Code length is concise—no unnecessary verbosity. Action granularity is mostly one action per line, though the emirp condition combines three checks on one line; still readable. Reading flow is natural top-to-bottom. Minor deductions: the unused `count` variable and lack of comments or output labeling reduce clarity slightly.
Run 2
The code is well structured with clear separation of concerns via methods for prime checking and number reversal. Nesting is minimal and control flow is easy to follow. Names like isPrime and reverseNumber make intent clear. The main loop is concise, though the condition combining prime, reverse-prime, and non-palindrome checks could be extracted for readability. Action granularity is mostly one action per line, and the reading flow is logical. Minor issues: the unused count variable, lack of comments explaining what an emirp is, and the condition check requiring i != reverseNumber(i) is slightly dense. Overall the code is approachable and maintainable.
Run 3
The code is well-structured with clear method separation for prime checking and number reversal. Nesting is minimal and the logic is easy to follow. Intent is clear: find emirp primes up to 10000. The main method is concise, but the missing increment of count is an oversight. Action granularity is good, with one meaningful operation per line. However, variable naming is slightly generic (e.g., 'reverse', 'number'), and the unused count variable suggests incomplete implementation. Overall, it is readable and maintainable, though minor naming and unused code improvements would enhance clarity.
Run 1
Code Structure: Clearly separates enumeration, digit reversal, and primality testing into small methods. Nesting: Shallow loop-and-condition nesting is easy to follow. Clarity of intent: Descriptive method names and the Emirp class name communicate purpose, though the unused count variable and unexplained limit of 10000 add minor ambiguity. Code length: Compact without being cryptic; reverseNumber(i) is unnecessarily called twice. Action granularity: Each statement performs a distinct action, while the compound condition expresses closely related checks. Reading flow: Execution proceeds naturally from main to helper methods, with straightforward early returns. Blank lines between methods and a named upper-limit constant would improve readability.
Run 2
Code Structure: Well organized into a main method and two focused helper methods. Nesting: Shallow and easy to follow, with only simple loops and conditionals. Clarity of intent: Descriptive method names clearly express primality testing and digit reversal, though the emirp condition could benefit from a named variable, and count is incremented but never used. Code length: Concise without unnecessary boilerplate; computing reverseNumber(i) twice adds minor redundancy. Action granularity: Each statement performs a distinct action, although the compound condition combines several checks. Reading flow: Natural progression from iteration to filtering and output, followed by helpers. Consistent indentation supports readability, but blank lines between methods and a named constant for 10000 would improve scanning and communicate intent.
Run 3
Code Structure: Well organized into a main method and two focused helpers. Nesting: Shallow loop-and-condition nesting is easy to follow. Clarity of intent: Descriptive helper names make the prime and digit-reversal checks clear, though the emirp condition could benefit from a brief explanation; count is incremented but never used. Code length: Concise overall, with minor redundancy from calling reverseNumber(i) twice. Action granularity: Each statement performs a distinct action, although the compound condition combines several checks. Reading flow: Consistent indentation and straightforward control flow support natural reading; blank lines between methods and a named constant for 10000 would improve scanning and context.