Source code
import java.util.*;
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) {
sentence = sentence.toLowerCase();
Set<Character> alphabet = new HashSet<>();
for (int i = 0; i < sentence.length(); i++) {
char c = sentence.charAt(i);
if (c >= 'a' && c <= 'z') {
alphabet.add(c);
}
}
return alphabet.size() == 26;
}
}
Run 1
The code is highly readable with a clear, logical structure: a simple main method calls a well-named isPangram method. Nesting is minimal, with only one level of control flow inside the loop. Intent is explicit—the method name and logic clearly indicate it checks whether a sentence contains all 26 letters. The code is concise and avoids unnecessary verbosity, while each line performs a single logical action, such as lowercasing the string or adding a character to the set. Reading flow is natural: normalization, character inspection, filtering, and a final size check. Potential minor improvements could include using a for-each loop over characters or a stream-based approach, but these are stylistic. Overall, the code is approachable, maintainable, and easily understood by developers of varying experience.
Run 2
The code is clean, concise, and logically structured. It has a clear separation of concerns: main handles input/output while isPangram encapsulates the checking logic. Nesting is minimal, with only one level of conditional inside the loop, and action granularity is appropriate with one operation per line. The intent is immediately clear from method and variable names (alphabet, isPangram). The reading flow is natural—input validation, then processing, then output. The isPangram method is short and focused. Minor deductions: the main method could be slightly more descriptive, and the alphabet set could be named seenLetters to better reflect its role. Overall, it's highly readable and maintainable.
Run 3
The code is highly readable. It has a clear, logical structure with a simple main method and a well-named isPangram method. Nesting is minimal—only one level deep in the loop and a single conditional. Intent is obvious from method and variable names. The implementation is concise, avoiding unnecessary length while still being clear. Each line performs a single, focused action, improving granularity. Reading flow is natural: input handling, normalization, character filtering, and final check. Minor nitpicks: could use a for-each loop over toCharArray() for slightly better clarity, and the alphabet set could be named seenLetters to better reflect its purpose, but these are trivial.
Run 1
Code Structure: Clean separation between argument processing and pangram detection. Nesting: Shallow and conventional, with one conditional inside each loop. Clarity of intent: Descriptive class and method names make the purpose clear; alphabet could be named uniqueLetters for greater precision. Code length: Concise, with no unnecessary logic. Action granularity: Each statement performs a single clear action. Reading flow: Natural progression from input normalization through letter collection to the final check. Minor readability improvements include replacing the wildcard import with explicit imports and naming the constant 26.
Run 2
Code Structure: Clearly separates command-line processing from pangram detection. Nesting: Shallow loops and conditionals are easy to follow. Clarity of intent: Descriptive class and method names make the purpose obvious, though alphabet could be named seenLetters to better describe its contents. Code length: Concise without sacrificing comprehension. Action granularity: Each statement performs one straightforward action. Reading flow: Natural progression from input normalization to collecting distinct letters and checking their count. Minor readability drawbacks include the wildcard import and the unexplained constant 26.
Run 3
Code Structure: Clean separation between command-line processing and pangram detection. Nesting: Shallow loop-and-condition nesting is easy to follow. Clarity of intent: Descriptive class and method names make the purpose obvious; 'alphabet' could be more precisely named 'seenLetters'. Code length: Concise, with no unnecessary logic or repetition. Action granularity: Each statement performs a single clear action. Reading flow: Natural progression from input processing to normalization, character collection, and the final check. Minor readability drawbacks are the wildcard import and the unexplained constant 26.