Source code
import java.io.*;
import java.lang.*;
import java.util.*;
import java.math.*;
class RemoveOcc {
/**
* * Write a Java function to remove first and last occurrence of a given character from the string.
*
* > removeOcc("hello", "l")
* "heo"
* > removeOcc("abcda", "a")
* "bcd"
* > removeOcc("PHP", "P")
* "H"
*/
public static String removeOcc(String s, String ch) {
if (s == null || ch == null || ch.length() != 1 || s.isEmpty()) {
return s;
}
char target = ch.charAt(0);
int firstIndex = s.indexOf(target);
int lastIndex = s.lastIndexOf(target);
if (firstIndex == -1 || firstIndex == lastIndex) {
// character not found or occurs only once, no removal needed
return s;
}
StringBuilder result = new StringBuilder();
for (int i = 0; i < s.length(); i++) {
if (i != firstIndex && i != lastIndex) {
result.append(s.charAt(i));
}
}
return result.toString();
}
}
Run 1
The code is generally clean and easy to follow. It has a clear structure with a single method, minimal nesting, and good readability. Each action is placed on its own line, and the logic flows naturally from validation to finding indices, then to string construction. The method name and comments clarify intent. There is mild redundancy in imports (java.lang, java.math, java.io) and the null/empty check could be simplified, but overall the code is concise and maintainable.
Run 2
The code is exceptionally readable. It has a clear structure with input validation, edge-case handling, and a straightforward loop. Nesting is minimal—only a single if statement inside the loop. Intent is obvious from the method and variable names, and the docstring clearly explains the purpose with examples. Action granularity is appropriate: each line performs one logical step. The only minor weaknesses are the unused imports (java.io, java.lang, java.math) and a slightly redundant edge-case comment, but these are trivial. The loop is simple and efficient, though a two-pass approach using StringBuilder.deleteCharAt could be marginally shorter. Overall, it follows clean-code principles well.
Run 3
The code is well-structured and readable. It follows logical organization with clear method separation. Nesting is minimal, with only one level of conditional and loop nesting. Intent is clear through good variable naming and a helpful Javadoc comment with examples. Code length is appropriate, and actions are granular, generally one per line. The reading flow is natural; validation occurs upfront, followed by index computation, edge case handling, and then string construction. Minor improvement could be extracting the character-not-found condition into a separate guard clause, but overall the code is concise, maintainable, and easy to understand.
Run 1
Code Structure: Logically organized into input validation, occurrence lookup, filtering, and return. Nesting: Shallow, with guard clauses and only one conditional inside the loop. Clarity of intent: Descriptive index names and documented examples make the purpose clear; however, leaving a single occurrence unchanged may be surprising given the stated goal. Code length: Concise implementation, though unused wildcard imports add clutter. Action granularity: Each statement performs one clear action, and formatting is consistent. Reading flow: Natural top-to-bottom progression makes the algorithm easy to follow.
Run 2
Code Structure: Logically organized into input validation, occurrence lookup, and result construction. Nesting: Shallow, with guard clauses limiting complexity and only one conditional inside the loop. Clarity of intent: Descriptive index names, examples, and a comment explain the behavior, although abbreviated names such as RemoveOcc, s, and ch reduce clarity slightly; leaving a single occurrence unchanged may also surprise readers. Code length: Concise overall, but unused wildcard imports add clutter. Action granularity: Each statement performs one clear action. Reading flow: Natural progression from validation to processing to return, with consistent formatting.
Run 3
Code Structure: Logically organized into validation, occurrence lookup, and result construction. Nesting: Early returns keep nesting shallow; only a single conditional sits inside the loop. Clarity of intent: Descriptive names such as target, firstIndex, lastIndex, and result make the algorithm clear, and examples document its purpose. However, leaving a single occurrence unchanged may be surprising given the stated goal. Code length: The implementation is concise, though unused wildcard imports and the redundant java.lang import add clutter. Action granularity: Each statement performs one clear action, with conventional loop syntax. Reading flow: Execution proceeds naturally from input checks to locating matches and building the output; spacing and the explanatory comment support readability.