Strings

Strings are sequences of characters. They're fundamental in programming and frequently appear in coding interviews.

String Basics

In Python, strings are immutable - you cannot change characters in-place. Any modification creates a new string.

s = "hello"
s[0] = 'H'  # Error! Strings are immutable

# Instead, create new string
s = 'H' + s[1:]  # "Hello"

String Operations & Complexity

| Operation | Time Complexity | Example | |-----------|-----------------|---------| | Access | O(1) | s[i] | | Concatenation | O(n+m) | s1 + s2 | | Slice | O(k) | s[i:j] (k = j-i) | | Search | O(n*m) | pattern in string | | Replace | O(n) | s.replace(old, new) |

String Reversal

# Method 1: Slicing (Pythonic)
reversed_str = s[::-1]

# Method 2: Two pointers
def reverse_string(s):
    chars = list(s)  # Convert to list (mutable)
    left, right = 0, len(chars) - 1
    
    while left < right:
        chars[left], chars[right] = chars[right], chars[left]
        left += 1
        right -= 1
    
    return ''.join(chars)

Pattern Matching

Check if Substring Exists

# Using 'in' operator - O(n*m)
if "pattern" in text:
    print("Found")

# Using find() - returns index or -1
index = text.find("pattern")

Count Occurrences

count = text.count("pattern")

Anagram Problems

Two strings are anagrams if they contain the same characters with the same frequencies.

def are_anagrams(s1, s2):
    # Method 1: Sort and compare
    return sorted(s1) == sorted(s2)
    
    # Method 2: Count frequencies
    from collections import Counter
    return Counter(s1) == Counter(s2)

Palindrome Problems

A palindrome reads the same forwards and backwards.

def is_palindrome(s):
    # Simple check
    return s == s[::-1]

def is_palindrome_alphanumeric(s):
    # Ignore non-alphanumeric and case
    cleaned = ''.join(c.lower() for c in s if c.isalnum())
    return cleaned == cleaned[::-1]

String Compression

def compress_string(s):
    """Compress: 'aaabbcccc' -> 'a3b2c4'"""
    if not s:
        return ""
    
    compressed = []
    count = 1
    
    for i in range(1, len(s)):
        if s[i] == s[i-1]:
            count += 1
        else:
            compressed.append(s[i-1] + str(count))
            count = 1
    
    # Don't forget last group
    compressed.append(s[-1] + str(count))
    
    result = ''.join(compressed)
    return result if len(result) < len(s) else s

Quiz

Key Takeaways

✅ Strings are immutable in Python - modifications create new strings
✅ Pattern matching is O(n*m) for naive search
✅ Anagrams have same characters with same frequencies
✅ Palindromes read the same forwards and backwards
✅ String problems are extremely common in interviews

Master string manipulation for real-world text processing! 🚀