Natan Code

Why is it important to study data structures and algorithms?

• Natan Ferreira
• August 11, 2025
• 0
• 286

One day I was talking to a friend who is learning programming. I suggested solving a problem to check whether a word or phrase is a palindrome. We entered a prompt asking to AI for this and received a response using Java’s StringBuilder. The solution was correct, but with a more critical eye, I thought it could be improved using the two-pointers technique.

Hands on

First Approach (Using StringBuilder)

public static boolean isPalimdrome1(String s) {
    String text = s.replaceAll("[^a-zA-Z0-9]", "").toLowerCase();
    String reversedName = new StringBuilder(text).reverse().toString();
    return text.toLowerCase().equals(reversedName);
}

Step-by-step Explanation:

✅ Step 1: Sanitize the input

String text = s.replaceAll("[^a-zA-Z0-9]", "").toLowerCase();

• s.replaceAll("[^a-zA-Z0-9]", "") removes everything except letters and digits.
• .toLowerCase() converts all characters to lowercase.

Example:
Input: "A man, a plan, a canal: Panama"
After this step: "amanaplanacanalpanama"

✅ Step 2: Reverse the sanitized string

String reversedName = new StringBuilder(text).reverse().toString();

Creates a new StringBuilder with the sanitized text

• .reverse() reverses the string
• .toString() converts it back to a String

✅ Step 3: Compare original cleaned text with reversed version

return text.toLowerCase().equals(reversedName);

If the original and reversed strings match, then it’s a palindrome → return true.

Second Approach (Using two pointers)

public static boolean isPalimdrome2(String s) {
    String text = s.replaceAll("[^a-zA-Z0-9]", "").toLowerCase();

    for(int l=0, r= text.length() -1; l < r; l++, r--) {
        if(text.charAt(l) != text.charAt(r)) {
            return false;
        }
    }

    return true;
}

✅ Step 1: Sanitize the input

String text = s.replaceAll("[^a-zA-Z0-9]", "").toLowerCase();

• s.replaceAll("[^a-zA-Z0-9]", "") removes everything except letters and digits.
• .toLowerCase() converts all characters to lowercase.

Example:
Input: "A man, a plan, a canal: Panama"
After this step: "amanaplanacanalpana

✅ Step 2: Two Pointers

for(int l=0, r= text.length() -1; l < r; l++, r--) {
      if(text.charAt(l) != text.charAt(r)) {
          return false;
      }
  }

Initializes two pointers:

• l starts at the beginning of the string
• r starts at the end of the string

At each step, compare the characters:

• If they don’t match, return false (not a palindrome)
• If they do match, move inward (l++ and r--)

Loop continues until the pointers meet in the middle

return true;

If the loop completes without mismatches, the string is a palindrome.

This approach is cleaner and faster, especially for large strings since it avoids creating a reversed copy.

Comparison

With the use of two pointers, it’s also important to note that in some cases, it’s not necessary to iterate through every character. This results in faster processing since the number of steps is reduced. On the other hand, with StringBuilder, this optimization doesn’t occur, as it’s always necessary to reverse the entire string to perform the comparison.

Conclusion

Both approaches solve the problem, but when dealing with large strings, it’s recommended to use the two-pointers technique as it offers better efficiency. The prompt used with the AI also makes a difference — the more specific the prompt, the better and more complete the results. Writing in English tends to yield even better responses.

Using AI as a support tool is a great idea, but we should always review its answers critically.

How to Manage Profiles in Spring Boot (with Docker)?

What is Java Bean Validation and how to use it?