Source code
import java.io.*;
import java.lang.*;
import java.util.*;
import java.math.*;
class RemoveDirtyChars {
/**
* * Write a function to remove characters from the first string which are present in the second string.
*
* > removeDirtyChars("probasscurve", "pros")
* "bacuve"
* > removeDirtyChars("digitalindia", "talent")
* "digiidi"
* > removeDirtyChars("exoticmiles", "toxic")
* "emles"
*/
public static String removeDirtyChars(String string, String secondString) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < string.length(); i++) {
char ch = string.charAt(i);
boolean flag = false;
int k = 0;
while (k < secondString.length()) {
if (ch == secondString.charAt(k)) {
flag = true;
}
k++;
}
if (!flag) {
sb.append(ch);
}
}
return sb.toString();
}
}
Run 1
The code is generally readable but has several weaknesses. The structure is logical with a single method and a clear purpose. However, nesting is moderate with an if statement inside a while loop inside a for loop, making the logic somewhat harder to follow. Clarity of intent is decent—the method name and variable names are reasonable, but the use of a flag variable and manual while loop for character matching is less clear than using built-in methods like indexOf or contains. The code length is acceptable but could be shortened significantly. Action granularity is mostly one action per line, which helps. Reading flow is natural but disrupted by the nested loops. The algorithm could be simplified by using a HashSet for constant-time lookups or String.indexOf to avoid manual character comparison, which would improve both readability and performance.
Run 2
The code is reasonably readable: it has clear method naming, a logical structure, and moderate nesting. However, it could be improved by using a Set for characters to avoid the nested while loop, reducing complexity. The flag and k variables add unnecessary verbosity. Variable names like 'string' and 'secondString' are clear but not ideal. The intent is understandable, but the implementation is longer than needed. Overall, it is concise enough but not optimized for clarity or efficiency.
Run 3
The code is generally readable due to clear variable names, simple logic, and a straightforward, flat structure. The method name and parameter names communicate intent well. However, readability is reduced by the use of an unnecessary boolean flag and an inefficient while loop with manual index increment, which obscures the simple purpose of checking if a character exists in the second string. The action granularity is adequate but could be improved by using a for-each loop and a HashSet for clarity. Overall, the code is concise and logically organized, but minor improvements could make the intent clearer and reduce cognitive load.
Run 1
Code Structure: The method is logically organized into initialization, character checking, filtering, and return. Nesting: The outer loop, inner while loop, and conditional introduce moderate nesting, but remain easy to follow. Clarity of intent: The method name and documentation clearly explain the purpose; generic names such as flag, sb, and secondString are less expressive. Code length: The implementation is reasonably concise, although a membership check could replace the manual inner scan, and unused wildcard imports add clutter. Action granularity: Each statement performs one action, making individual steps easy to understand. Reading flow: Execution proceeds naturally from examining each character to appending allowed characters. Continuing the inner scan after finding a match adds unnecessary work and slightly obscures the decision point.
Run 2
Code Structure: The method is logically organized into initialization, character filtering, and result construction. Nesting: The outer loop, inner loop, and conditional create moderate nesting, but remain easy to follow. Clarity of intent: The method name and documentation clearly describe the purpose, though names such as flag, sb, and secondString could be more descriptive. Code length: The implementation is reasonably short, but the manual inner search and unused wildcard imports add unnecessary verbosity. Action granularity: Each statement performs a single action, with conventional loop syntax. Reading flow: Execution proceeds naturally from input traversal to membership checking and output assembly. Using a clearer membership check or breaking after a match would simplify the search and improve readability.
Run 3
Code Structure: The method is logically organized into initialization, character filtering, and result return. Nesting: The outer loop, inner while loop, and conditional create moderate nesting, but remain easy to follow. Clarity of intent: The method name and documentation clearly explain the purpose, although names such as flag, sb, and secondString could be more descriptive. Code length: The implementation is reasonably concise, but unnecessary wildcard imports and the explicit inner-loop counter add clutter. Action granularity: Each statement performs a single action, making individual steps easy to understand. Reading flow: Execution proceeds naturally from input traversal to membership checking and output construction. A clearer membership test or helper would reduce the mental effort required to follow the nested search.