Strings are one of the most fundamental data structures in programming. Understanding string operations is crucial for coding interviews and real-world applications.

What is a String?

A string is a sequence of characters. It's one of the most commonly used data types in programming.

"Hello, World!"  ← String
['H','e','l','l','o']  ← Array of characters

Key Concept: In most languages, strings are either character arrays or immutable objects storing character sequences.

String Representation

Internal Storage

Python

# Python strings are immutable sequences
s = "Hello"
# Internally: array of Unicode code points
# 'H' 'e' 'l' 'l' 'o'

String vs Character Array

Feature	String	Character Array
Type	Object/Primitive	Array
Mutability	Usually Immutable	Mutable
Operations	Rich methods	Manual indexing
Memory	Optimized (pooling)	Raw array

String Creation

Different Ways to Create Strings

Python

# Python - multiple ways
s1 = "Hello"              # String literal
s2 = 'World'              # Single quotes work too
s3 = """Multi
line"""                   # Triple quotes for multiline
s4 = str([1, 2, 3])       # Convert from other types
s5 = "".join(['a','b'])   # From list of chars

# Empty string
empty = ""

Basic String Operations

1. Length / Size

Python

s = "Hello"
length = len(s)  # 5

# Empty string
empty = ""
print(len(empty))  # 0

Time Complexity: O(1) in most languages

2. Accessing Characters

Python

s = "Hello"

# Access by index (0-based)
first = s[0]      # 'H'
last = s[-1]      # 'o' (negative indexing)
second = s[1]     # 'e'

# Iterate over characters
for char in s:
    print(char)

# Get character at index safely
if len(s) > 10:
    char = s[10]

Time Complexity: O(1) for single character access

3. Substring / Slicing

Python

s = "Hello World"

# Slicing [start:end] (end not included)
sub1 = s[0:5]     # "Hello"
sub2 = s[6:11]    # "World"
sub3 = s[6:]      # "World" (from 6 to end)
sub4 = s[:5]      # "Hello" (from start to 5)
sub5 = s[:]       # "Hello World" (copy)

# Step slicing
reverse = s[::-1]  # "dlroW olleH" (reverse)
every2 = s[::2]    # "HloWrd" (every 2nd char)

Time Complexity: O(k) where k = length of substring

4. Concatenation

Python

s1 = "Hello"
s2 = "World"

# Using + operator
result = s1 + " " + s2  # "Hello World"

# Using join (more efficient for multiple strings)
words = ["Hello", "World", "!"]
result = " ".join(words)  # "Hello World !"

# Using f-strings (Python 3.6+)
name = "Alice"
greeting = f"Hello, {name}!"  # "Hello, Alice!"

Time Complexity: O(n + m) where n, m are string lengths

Performance Note: For multiple concatenations in a loop, use StringBuilder (Java), list+join (Python), or array+join (JavaScript) for better performance.

5. String Comparison

Python

s1 = "Hello"
s2 = "hello"
s3 = "Hello"

# Equality (case-sensitive)
print(s1 == s3)   # True
print(s1 == s2)   # False

# Case-insensitive comparison
print(s1.lower() == s2.lower())  # True

# Lexicographic comparison
print("apple" < "banana")  # True (alphabetical)
print("Apple" < "apple")   # True (uppercase < lowercase in ASCII)

Important: In Java, ALWAYS use .equals() for string comparison, not ==. The == operator checks reference equality, not content.

6. Searching in Strings

Python

s = "Hello World"

# Find substring
index = s.find("World")     # 6 (returns -1 if not found)
index2 = s.find("Python")   # -1

# Check if substring exists
exists = "World" in s        # True
exists2 = "Python" in s      # False

# Find all occurrences
text = "hello hello hello"
indices = [i for i in range(len(text)) if text.startswith("hello", i)]

# Count occurrences
count = s.count("l")         # 3

Time Complexity: O(n × m) for naive search, where n = text length, m = pattern length

String Immutability

What is Immutability?

In many languages, strings are immutable - once created, they cannot be changed.

Python

# Python strings are IMMUTABLE
s = "Hello"
s[0] = 'h'  # TypeError! Can't modify

# Instead, create new string
s = 'h' + s[1:]  # "hello" (new string)

# Original string unchanged
original = "Hello"
modified = original.lower()
print(original)  # Still "Hello"
print(modified)  # "hello"

Why Immutability Matters

Advantages:

›Thread-safe: Can share between threads
›Caching: String pools save memory
›Security: Prevents accidental changes
›Hashable: Can use as hash map keys

Disadvantages:

›Performance: Concatenation in loops is slow
›Memory: Creates many intermediate strings

Best Practice: For heavy string manipulation (loops, building), use mutable builders (StringBuilder, list, etc.)

ASCII and Unicode

Character Encoding

Python

# Get ASCII/Unicode value
char = 'A'
value = ord(char)  # 65

# Get character from value
char2 = chr(65)    # 'A'

# Example: Caesar cipher
def caesar_shift(char, shift):
    return chr((ord(char) - ord('a') + shift) % 26 + ord('a'))

print(caesar_shift('a', 1))  # 'b'

Common ASCII Values

Character	ASCII Value	Range
'0' - '9'	48 - 57	Digits
'A' - 'Z'	65 - 90	Uppercase
'a' - 'z'	97 - 122	Lowercase
Space ' '	32	Whitespace

Useful Math:

›'a' - 'A' = 32 (convert case)
›'0' = 48 (convert digit char to int: char - '0')

Common String Patterns

1. Reverse a String

Python

def reverse_string(s):
    # Method 1: Slicing (Pythonic)
    return s[::-1]

# Method 2: Using reversed()
def reverse_v2(s):
    return ''.join(reversed(s))

# Method 3: Two pointers (in-place on list)
def reverse_v3(s):
    chars = list(s)
    left, right = 0, len(chars) - 1
    while left < right:
        chars[left], chars[right] = chars[right], chars[left]
        left += 1
        right -= 1
    return ''.join(chars)

Time: O(n), Space: O(1) for in-place, O(n) for new string

2. Check Palindrome

Python

def is_palindrome(s):
    # Method 1: Compare with reverse
    return s == s[::-1]

# Method 2: Two pointers
def is_palindrome_v2(s):
    left, right = 0, len(s) - 1
    while left < right:
        if s[left] != s[right]:
            return False
        left += 1
        right -= 1
    return True

# Method 3: Ignore non-alphanumeric (LeetCode style)
def is_palindrome_v3(s):
    # Remove non-alphanumeric and convert to lowercase
    cleaned = ''.join(c.lower() for c in s if c.isalnum())
    return cleaned == cleaned[::-1]

Time: O(n), Space: O(1)

String Complexity Guide

Operation	Time	Space	Notes
Access char	O(1)	O(1)	Direct indexing
Length	O(1)	O(1)	Stored value
Concatenation	O(n+m)	O(n+m)	Creates new string
Substring	O(k)	O(k)	k = substring length
Comparison	O(n)	O(1)	Lexicographic
Search	O(n×m)	O(1)	Naive algorithm
Reverse	O(n)	O(n)	New string created
Upper/Lower	O(n)	O(n)	New string created

Key Takeaways

Strings are Immutable (in most languages)

›Modifications create new strings
›Use builders for heavy manipulation
›Concatenation in loops is expensive

Always Check Bounds

›Index out of range causes errors
›Use length checks before access
›Negative indices in Python work, but not all languages

Case Sensitivity

›"Hello" ≠ "hello"
›Use toLowerCase()/upper() for comparison
›ASCII: 'A' ≠ 'a' (differ by 32)

Common Patterns

›Two pointers for palindrome/reverse
›Hash map for character frequency
›Sliding window for substrings
›StringBuilder for concatenation

Master these basics before moving to advanced string algorithms! 🚀

←

PreviousPractice Problems

NextString Traversal

→