Replace ' ' Spaces in a URL with a '%20' - Coding Challenge

Let me give some comments to your code as well, with a refactoring coming out at finally:

• Building a char array, seems to be wasteful – Why don't you use StringBuilder? I know when reinventing the wheel, there could be some debate as to what you are allowed to use or not. But you're already using str.trim() and str.toCharArray(), so why not StringBuilder?

• Try to avoid multiple repeated loops – In your code you loop it once to get the new length into the strangly named trueL, this should (if kept) be named newLength or similar. Repeating loops is considered expensive, and should be avoided, if possible.

• oldArr and newArr? – In general I don't think variable names including array, arr, table, and so on are good names. In most cases you know it's an array due to the presence of the array indexing braces. Maybe originalChars or strChars, could be better names.

• Good use of length = str.length() – I like that you calculate then length just once, and use that in the for loop.

• Choose appropriate loops – Albeit the charAt() is slightly faster, I think that in this case I would opt for the for (char currentCharacter : text.toCharArray() ) loop variant. Simply because it clearer conveys what you are working with. In addition it removes the need for some extra temporary variables like x, length and trueL

• Do early returns, if possible – As Janos mentions, in your code you have most of your code within the if (str.contains(" ")) block. This can be reversed, and you can do an early return without almost doing any work.

• Include a little more vertical space – A personal nitpick of mine is to add a little more vertical space in the code. Adding an extra newline in front of for loops, and if blocks can greatly enhance the reading and understanding of code.

Refactored solution

Following all of this advice, gives code like this:

public class URL {
  public static String URLify(String text) {
    
    if (!text.contains(" ")) {
      return text;
    }

    // Use urlifiedText for building the result text
    StringBuilder urlifiedText  = new StringBuilder();
    
    // Replace spaces with %20, after trimming leading and trailing spaces
    for (char currentChar : text.trim().toCharArray()) {

      if (currentChar == ' ') {
        urlifiedText.append("%20");
      } else {
        urlifiedText.append(currentChar);
      }
    } 
    
    return urlifiedText.toString();
  }
  
  public static void main(String[] args) {
    System.out.println(URLify("    my example text    "));
  }
}

Even with some added comments, it still is slightly shorter than your original code, and hopefully understandable.

Update: Alternate implementation

What if you were not allowed to use any of the str.functions()? No str.toCharArray(), str.trim(), str.contains(), and so on? Here is an implementation using the basic String and StringBuilder functionality. If you wanted to you could also replace the StringBuilder method by concatenating into a new String. (Leaving that part to the reader).

A possible implementation could then look like:

/**
 * @description URLifyII ~ Remove leading and trailing spaces,
 *                         and replace remaining spaces with %20.
 * NB! Without using str.trim(), str.contains(), and so on...
 */
public static String URLifyII(String text) {
    
  int startIndex = 0;
  int endIndex = text.length() - 1;
  StringBuilder urlifiedText = new StringBuilder();
    
  // Find first non-space character
  while (text.charAt(startIndex) == ' ' && startIndex < endIndex) {
    startIndex++;
  }
    
  // Find last non-space character
  while (text.charAt(endIndex) == ' ' && endIndex >= startIndex) {
    endIndex--;
  }
    
  // Repeat text, and replace spaces with %20
  for (int i=startIndex; i <= endIndex; i++) {
    if (text.charAt(i) != ' ') {
      urlifiedText.append(text.charAt(i));
    } else {
      urlifiedText.append("%20");
    }
  }
    
  return urlifiedText.toString();
}

This solution still only loops through the original text just once, but divided into three different parts.