Source code
public class PangramChecker {
public static void main(String[] args) {
for(String sentence: args) {
if(isPangram(sentence)) {
System.out.println(sentence);
}
}
}
public static boolean isPangram(String sentence) {
boolean[] letters = new boolean[26];
int index;
for(int i = 0; i < sentence.length(); i++) {
char c = sentence.charAt(i);
if(Character.isLetter(c)) {
if(Character.isUpperCase(c)) {
index = c - 'A';
} else {
index = c - 'a';
}
letters[index] = true;
}
}
for(boolean letter: letters) {
if(!letter) {
return false;
}
}
return true;
}
}
Run 1
The code is well-structured with clear separation of concerns: main handles filtering and isPangram performs the logic. Nesting is minimal and readable, with only one level of indentation in the loops. The intent is obvious from method and variable names. Code length is concise, avoiding unnecessary boilerplate. Action granularity is mostly one action per line, aiding readability. Reading flow is natural: process each argument, check if pangram, print if true. Minor improvements could include extracting the index mapping into a separate method or using Character.toLowerCase to reduce branching, but overall the code is highly readable and maintainable.
Run 2
The code is well-structured with clear separation between the main method and the pangram-checking logic. Nesting is minimal—only two levels deep—and the flow is easy to follow. Intent is evident: it filters command-line arguments to print only pangrams. The isPangram method is concise, using a boolean array to track letters and returning early if any are missing. Each line generally performs one action, and the reading flow is natural. Minor improvements could include using Character.toLowerCase to avoid the uppercase branch, or renaming 'index' for slight clarity, but overall readability is high.
Run 3
The code is well-structured with clear separation of concerns: main handles arguments, isPangram encapsulates the logic. Nesting is generally shallow, with only a two-level if-else inside the loop, which is reasonable. Intent is clear from method and variable names like isPangram and letters. The code is concise without being cryptic, and each line performs a single action, supporting readability. The reading flow is natural: input handling, core logic, then result. Minor improvements could include extracting the letter-indexing logic into a helper method and using a for-each loop over the sentence characters, but overall the code is very readable.
Run 1
Code Structure: Clearly separates argument processing from pangram checking, with logically ordered steps. Nesting: Moderate nesting in character processing; case normalization could remove the inner conditional. Clarity of intent: Descriptive class and method names make the purpose clear, though letters and index could be more specific. Character.isLetter accepts non-ASCII letters, while the indexing assumes English letters, obscuring the supported input. Code length: Concise overall, with minor simplification possible through normalization. Action granularity: Each statement performs a distinct action, making operations easy to follow. Reading flow: Natural progression from collecting letters to verifying completeness, with early returns and helpful spacing; conventional spacing around control statements would improve polish.
Run 2
Code Structure: Clearly separates command-line processing from pangram checking, with logically ordered steps. Nesting: Mostly shallow, though the character loop contains nested conditionals for letter detection and case handling. Clarity of intent: Descriptive method and variable names make the purpose clear; however, Character.isLetter accepts non-ASCII letters while indexing assumes A–Z, creating a misleading mismatch. Code length: Concise overall, although normalizing case could simplify the branching. Action granularity: Each statement performs one distinct action, making operations easy to follow. Reading flow: Natural progression from character collection to completeness checking, with useful whitespace; minor spacing inconsistencies and the separately declared index slightly reduce polish.
Run 3
Code Structure: Clearly separates argument processing from pangram checking. Nesting: Mostly manageable, though the letter-checking loop contains nested conditionals that could be flattened through case normalization. Clarity of intent: Descriptive class and method names make the purpose obvious; however, Character.isLetter accepts non-English letters while the indexing assumes ASCII A–Z, making the supported input ambiguous. Code length: Concise overall, with some avoidable case-handling duplication. Action granularity: Each statement performs a single clear action. Reading flow: Naturally progresses from scanning characters to verifying alphabet coverage, with early returns simplifying the final check. Minor spacing inconsistencies and the broadly scoped index variable slightly reduce readability.