Source code
import java.math.BigInteger;
public class JacobiSymbol {
public static int jacobiSymbol(int a, int n) {
int t = 1;
while (a != 0) {
while (a % 2 == 0) {
a /= 2;
int r = n % 8;
if (r == 3 || r == 5) {
t = -t;
}
}
int temp = a;
a = n;
n = temp;
if (a % 4 == n % 4 && n % 4 == 3) {
t = -t;
}
a %= n;
}
if (n == 1) {
return t;
} else {
return 0;
}
}
public static void main(String[] args) {
for (int i = 0; i < args.length; i += 2) {
int a = Integer.parseInt(args[i]);
int n = Integer.parseInt(args[i + 1]);
System.out.println(jacobiSymbol(a, n));
}
}
}
Run 1
The code implements the Jacobi symbol algorithm but suffers from readability issues. The structure is logical but lacks helper functions or comments explaining the mathematical steps. Variable names like 'a', 'n', 't' are conventional in number theory but unclear without context. The algorithm uses nested loops and modulus operations with magic numbers (8, 4, 2) that obscure the mathematical logic. The swap operation between 'a' and 'n' uses a temporary variable but could be clearer. The main method's argument parsing is straightforward but lacks input validation. The reading flow is disrupted by the dense mathematical operations packed into single lines. While the code is concise and each line performs one main action, the lack of comments and clear naming makes it difficult to understand the Jacobi symbol calculation process.
Run 2
The code follows a logical mathematical algorithm and has a relatively flat structure, but it suffers from unclear variable naming and ambiguous intent. The parameters 'a' and 'n' and local variables 'r' and 't' are not self-documenting; 't' especially obscures the sign-tracking purpose. The core loop mutates variables heavily (swapping a, n, then using a %= n), which makes the state transitions difficult to follow. Action granularity is mostly one-per-line, but some lines pack multiple concerns (e.g., condition with two checks). The reading flow is hampered by reliance on mathematical knowledge of Jacobi symbols without comments or helper methods to explain steps like the quadratic reciprocity adjustment. Overall, understandable only if the reader already knows the algorithm.
Run 3
The code is compact and implements Jacobi symbol calculation, but it has several readability issues. The algorithm lacks explanatory comments, making the intent and mathematics unclear. Variable names like 'a', 'n', 't', and 'r' are terse and don't convey meaning. The main loop has multiple operations per line, and the deep nesting of while loops reduces clarity. The swapping logic and modulus operations are condensed, which hurts the reading flow. Although the structure is logically organized, the lack of spacing and descriptive identifiers makes it harder to follow for someone unfamiliar with the algorithm.
Run 1
Code Structure: The calculation and command-line entry point are cleanly separated into methods. Nesting: Two nested loops with a conditional create moderate but manageable depth. Clarity of intent: Class and method names identify the purpose, but terse variables and unexplained modular arithmetic obscure the mathematical steps; the unused BigInteger import adds distraction. Code length: The implementation is compact without excessive boilerplate, although the final else is unnecessary after a return. Action granularity: Each statement performs one clear action, including the explicit swap sequence. Reading flow: Consistent indentation and sequential processing make the code easy to follow, but brief comments explaining factor removal and quadratic reciprocity would improve understanding.
Run 2
Code Structure: The calculation and command-line entry point are logically separated into methods. Nesting: Two nested loops and an inner conditional add moderate complexity, but indentation keeps them readable. Clarity of intent: Class and method names clearly identify the purpose, while terse variables and unexplained number-theoretic rules make the algorithm harder to understand without domain knowledge. Code length: The implementation is concise, though the unused BigInteger import and final else are unnecessary. Action granularity: Each statement performs a single action, and the explicit swap is easy to follow. Reading flow: Execution proceeds naturally from factor removal through swapping and reduction to the result; main straightforwardly processes argument pairs. Missing documentation of input assumptions slightly weakens clarity.
Run 3
Code Structure: The calculation and command-line processing are cleanly separated into two methods; the unused BigInteger import adds minor clutter. Nesting: The nested loops and conditionals are moderate and manageable. Clarity of intent: Class and method names clearly identify the purpose, but terse variables and unexplained number-theoretic rules make the algorithm harder to understand without domain knowledge. Code length: The implementation is compact without being compressed, although the final else could be omitted after the return. Action granularity: Each line generally performs one action, and the explicit swap is easy to follow. Reading flow: Consistent indentation and a sequential algorithm support natural reading, though comments explaining sign changes and the expected input constraints would improve comprehension.