🎯 String Patterns: The Magic of Text Detective Work

Imagine you’re a detective with a magnifying glass, looking for secret messages hidden in text. That’s what string patterns are all about!

🏠 Our Story: The Word Detective Agency

Meet Sam the String Detective! Sam works at a special agency where they solve text mysteries. Every day, people bring Sam puzzles like:

• “Is this word the same backwards?”
• “Can we squish this long text into something smaller?”
• “Are these two words secretly the same letters scrambled?”

Let’s join Sam and learn the secrets of string pattern detection!

📚 Part 1: Strings Fundamentals

What is a String?

Think of a string like a necklace of letter beads. Each bead is one character, and they’re all connected in order.

String name = "HELLO";
// H-E-L-L-O are 5 beads
// on one necklace

Key Things About Strings

The Index Secret 🤫

Here’s a tricky thing! Counting starts at 0, not 1.

graph TD
    A["String: HELLO"] --> B["H = index 0"]
    B --> C["E = index 1"]
    C --> D["L = index 2"]
    D --> E["L = index 3"]
    E --> F["O = index 4"]

Real Example:

String word = "PIZZA";
char first = word.charAt(0);
// first = 'P'
char last = word.charAt(4);
// last = 'A'

✂️ Part 2: String Manipulation

What is String Manipulation?

It’s like playing with clay letters. You can:

• Cut them apart
• Stick them together
• Change their shape

The 5 Super Powers

🔗 Power 1: Joining Strings (Concatenation)

String first = "SUPER";
String second = "HERO";
String together = first + second;
// together = "SUPERHERO"

✂️ Power 2: Cutting Strings (Substring)

String word = "BUTTERFLY";
String piece = word.substring(0, 6);
// piece = "BUTTER"
// Cut from 0 to 5 (6 not included!)

🔄 Power 3: Changing Case

String shout = "hello".toUpperCase();
// shout = "HELLO"
String whisper = "HELLO".toLowerCase();
// whisper = "hello"

🔍 Power 4: Finding Characters

String word = "BANANA";
int pos = word.indexOf('N');
// pos = 2 (first N found!)

🔁 Power 5: Replacing Characters

String old = "cat";
String newer = old.replace('c', 'b');
// newer = "bat"

📦 Part 3: String Compression

The Squishing Game

Imagine you have: AAABBBCCCC

Instead of writing all letters, you write:

• A3B3C4 (letter + count)

You just made it smaller! 🎉

How Compression Works

graph TD
    A["AAABBBCCCC"] --> B["Count each group"]
    B --> C["A appears 3 times"]
    B --> D["B appears 3 times"]
    B --> E["C appears 4 times"]
    C --> F["Result: A3B3C4"]
    D --> F
    E --> F

The Compression Code

String compress(String s) {
    StringBuilder result =
        new StringBuilder();
    int count = 1;

    for(int i = 1; i <= s.length(); i++) {
        if(i < s.length() &&
           s.charAt(i) == s.charAt(i-1)) {
            count++;
        } else {
            result.append(s.charAt(i-1));
            result.append(count);
            count = 1;
        }
    }
    return result.toString();
}

When Compression Helps

Rule: Only use compression if it makes things shorter!

🔀 Part 4: Anagram Detection

What’s an Anagram?

Two words are anagrams if they use the exact same letters, just scrambled.

Examples:

• LISTEN ↔ SILENT ✅
• CAT ↔ ACT ✅
• DOG ↔ CAT ❌ (different letters!)

How Sam Checks for Anagrams

graph TD
    A["Word 1: LISTEN"] --> B["Sort letters: EILNST"]
    C["Word 2: SILENT"] --> D["Sort letters: EILNST"]
    B --> E{"Same?"}
    D --> E
    E -->|Yes| F["ANAGRAM! ✅"]
    E -->|No| G["NOT Anagram ❌"]

The Letter Counting Method

Instead of sorting, count each letter!

boolean isAnagram(String a, String b) {
    if(a.length() != b.length())
        return false;

    int[] count = new int[26];

    for(char c : a.toCharArray())
        count[c - 'a']++;

    for(char c : b.toCharArray())
        count[c - 'a']--;

    for(int n : count)
        if(n != 0) return false;

    return true;
}

Simple Example

All match = Anagram!

🪞 Part 5: Palindrome Detection

What’s a Palindrome?

A word that reads the same forwards and backwards!

Examples:

• MOM → MOM ✅
• RACECAR → RACECAR ✅
• HELLO → OLLEH ❌

The Mirror Test

graph TD
    A["RACECAR"] --> B["Front: R"]
    A --> C["Back: R"]
    B --> D{"Match?"}
    C --> D
    D -->|Yes| E["Check next pair"]
    E --> F["Front: A, Back: A ✅"]
    F --> G["Front: C, Back: C ✅"]
    G --> H["Middle: E ✅"]
    H --> I["PALINDROME! 🎉"]

Simple Palindrome Check

boolean isPalindrome(String s) {
    int left = 0;
    int right = s.length() - 1;

    while(left < right) {
        if(s.charAt(left) !=
           s.charAt(right)) {
            return false;
        }
        left++;
        right--;
    }
    return true;
}

Two Pointer Magic ✨

We use two fingers:

1. One starts at the beginning
2. One starts at the end
3. They walk toward each other, checking matches

🏆 Part 6: Longest Palindromic Substring

The Big Challenge

Finding the longest palindrome hidden inside a string!

Example: In “BABAD”

• “BAB” is a palindrome (length 3)
• “ABA” is a palindrome (length 3)
• Either one is the answer!

The Expand-From-Center Trick

Imagine standing at each letter and growing outward like ripples in water.

graph TD
    A["String: BABAD"] --> B["Try center at B"]
    A --> C["Try center at A"]
    A --> D["Try center at B"]
    A --> E["Try center at A"]
    A --> F["Try center at D"]
    C --> G["Expand: A → BAB → ✅"]
    G --> H["Longest = BAB"]

Two Types of Centers

The Code

String longestPalindrome(String s) {
    String longest = "";

    for(int i = 0; i < s.length(); i++) {
        // Odd length
        String odd = expand(s, i, i);
        // Even length
        String even = expand(s, i, i+1);

        if(odd.length() > longest.length())
            longest = odd;
        if(even.length() > longest.length())
            longest = even;
    }
    return longest;
}

String expand(String s, int L, int R) {
    while(L >= 0 && R < s.length()
          && s.charAt(L) == s.charAt(R)) {
        L--;
        R++;
    }
    return s.substring(L+1, R);
}

Visual Example

For “CBBD”:

1. Center at C → just “C”
2. Center at B → just “B”
3. Center between B-B → “BB” ✨ (longest!)
4. Center at D → just “D”

Answer: “BB”

🎉 Congratulations, Detective!

You’ve learned all the string pattern secrets:

Now you’re ready to solve any text mystery! 🔍

“Every string holds a pattern. You just need to know how to look.” — Sam the String Detective