Source code
public class HexASCIITable {
public static void main(String[] args) {
for (int i = 0; i < 16; i++) {
System.out.print(Integer.toHexString(i).toUpperCase() + ": ");
for (int j = 0; j < 8; j++) {
int c = i * 8 + j;
if (c > 127) {
System.out.print("DEL ");
} else {
System.out.print((char)c + " ");
}
}
System.out.println();
}
}
}
Run 1
The code is well-structured with clear intent: printing a hex-to-ASCII table. It uses two loops, keeping nesting at a reasonable level, and each line performs a single action, giving good action granularity. The flow is natural: outer loop for rows, inner loop for columns, then a newline. The length is concise and appropriate for the task. Minor readability improvements could include defining magic numbers (16, 8, 127) as named constants, and adding a brief comment explaining the mapping logic, especially the handling of DEL for values above 127. These small enhancements would make the purpose even clearer, but overall the code is highly readable.
Run 2
The code is well-structured with a clear, logical flow. It uses a simple nested loop to generate a hex-ASCII table, which is easy to follow. Nesting is shallow (two levels), and each line generally performs a single action, enhancing readability. The intent is evident: print a formatted table of characters grouped by high nibble. The length is concise without sacrificing clarity. Minor improvements could include a named constant for 16 or a comment explaining the 'DEL' mapping for control characters, but overall the code is highly readable.
Run 3
The code is well-structured with a clear main method and two nested loops. Nesting is only two levels deep, which is acceptable. The intent is straightforward: generate a hex-to-ASCII table. Variable names are concise and meaningful (i, j, c). Action granularity is good, with one main operation per line inside loops. Reading flow is logical, moving from row generation to column entries. Minor deductions: the magic numbers 16, 8, and 127 lack named constants, and the DEL handling is slightly awkward inside the loop, but overall readability is high.
Run 1
Code Structure: A single main method organizes table generation logically with row and column loops. Nesting: Two loops and an if/else introduce moderate, manageable nesting. Clarity of intent: The class name and hexadecimal formatting indicate an ASCII table, but terse variable names and unexplained constants reduce clarity. The c > 127 condition is unreachable because c ranges from 0 to 127, making the DEL handling misleading; control characters also obscure the intended output. Code length: Compact without unnecessary verbosity. Action granularity: Statements generally perform one action per line, with straightforward inline calculations and formatting. Reading flow: Execution proceeds naturally from row labels to character output to line breaks, supported by consistent indentation.
Run 2
Code Structure: A single method logically organizes table generation into rows and columns. Nesting: Two loops and an if/else create moderate, manageable nesting. Clarity of intent: The class name and hexadecimal row labels suggest an ASCII table, but terse variables and unexplained constants reduce clarity. The c > 127 condition is unreachable because c ranges from 0 to 127, making the intended DEL handling confusing. Code length: Compact without unnecessary scaffolding. Action granularity: Each statement performs one main action, although formatting expressions combine conversion and concatenation. Reading flow: Consistent indentation and sequential row generation make the code easy to follow.
Run 3
Code Structure: Logically organized as a row loop containing a character loop. Nesting: Moderate nesting from two loops and an if/else, but easy to follow. Clarity of intent: The class name and hexadecimal row labels suggest an ASCII table, although terse variables and unexplained constants reduce clarity. The c > 127 condition is unreachable because c ranges from 0 to 127, making the DEL handling misleading; control characters are also printed directly. Code length: Compact without unnecessary repetition. Action granularity: Each statement performs one main action, with straightforward inline calculations and formatting. Reading flow: Consistent indentation and sequential output provide a natural flow, though clearer names and explicit handling of nonprintable characters would improve readability.