Arrays and Strings

a = [3, 1, 2]
a.append(4)            # end insert, O(1) amortized
a.extend([5, 6])       # O(k)
a.insert(0, 9)         # O(n)
a.pop()                # last, O(1)
a.pop(0)               # first, O(n) -- prefer deque
a.remove(3)            # first occurrence by value, O(n)
del a[1:3]             # delete a slice
a.index(2)             # first index, ValueError if absent
a.count(2)
a.sort()               # in place, stable, O(n log n)
b = sorted(a, key=abs, reverse=True)   # new list
a.reverse()            # in place
a[::-1]                # reversed copy
a[::2]                 # every other element
sum(a), min(a), max(a), len(a)
[x * 2 for x in a if x > 1]            # comprehension
list(enumerate(a))                      # (index, value) pairs
list(zip(a, b))                         # pairwise, stops at shorter
[[0] * cols for _ in range(rows)]      # correct 2D grid

rows, cols = len(g), len(g[0])
for r in range(rows):
    for c in range(cols):
        ...

# 4-directional neighbors, bounds-checked
DIRS = ((1, 0), (-1, 0), (0, 1), (0, -1))
for dr, dc in DIRS:
    nr, nc = r + dr, c + dc
    if 0 <= nr < rows and 0 <= nc < cols:
        ...

# transpose
t = [list(row) for row in zip(*g)]

# rotate 90 degrees clockwise: transpose, then reverse each row
rot = [list(row)[::-1] for row in zip(*g)]

# flatten index math for a rows x cols grid
idx = r * cols + c
r, c = divmod(idx, cols)

def reverse(a):
    i, j = 0, len(a) - 1
    while i < j:
        a[i], a[j] = a[j], a[i]
        i += 1
        j -= 1

def remove_val(a, val):
    """Overwrite pointer: keep everything != val, return new length."""
    k = 0
    for x in a:
        if x != val:
            a[k] = x
            k += 1
    return k

def rotate_right(a, k):
    """Reverse whole, then reverse each part. O(n) time, O(1) space."""
    n = len(a)
    k %= n
    a.reverse()
    a[:k] = reversed(a[:k])
    a[k:] = reversed(a[k:])

def dutch_flag(a):
    """Sort 0s, 1s, 2s in one pass."""
    lo, mid, hi = 0, 0, len(a) - 1
    while mid <= hi:
        if a[mid] == 0:
            a[lo], a[mid] = a[mid], a[lo]
            lo += 1
            mid += 1
        elif a[mid] == 2:
            a[mid], a[hi] = a[hi], a[mid]
            hi -= 1
        else:
            mid += 1

# a-z frequency without a dict
cnt = [0] * 26
for ch in s:
    cnt[ord(ch) - ord("a")] += 1

# anagram signature
from collections import Counter
Counter(s) == Counter(t)
sorted(s) == sorted(t)        # O(n log n) alternative

# palindrome check ignoring non-alphanumerics
def is_palindrome(s):
    i, j = 0, len(s) - 1
    while i < j:
        while i < j and not s[i].isalnum():
            i += 1
        while i < j and not s[j].isalnum():
            j -= 1
        if s[i].lower() != s[j].lower():
            return False
        i += 1
        j -= 1
    return True

// Java: StringBuilder for O(n) construction
StringBuilder sb = new StringBuilder();
for (char c : s.toCharArray()) sb.append(Character.toLowerCase(c));
String out = sb.reverse().toString();

int[] a = new int[n];                 // zero-filled, fixed length
Arrays.fill(a, -1);
Arrays.sort(a);                       // dual-pivot quicksort on primitives
int[][] g = new int[rows][cols];
List<Integer> list = new ArrayList<>();
list.add(1); list.get(0); list.size();
int[] copy = Arrays.copyOfRange(a, 1, 4);

// C++: vector plus string, both mutable and growable
vector<int> a(n, 0);
a.push_back(5);
sort(a.begin(), a.end());
reverse(a.begin(), a.end());
vector<vector<int>> g(rows, vector<int>(cols, 0));

string s = "abc";
s += 'd';                     // O(1) amortized, string is mutable here
s.substr(1, 2);               // "bc"
s.find("bc");                 // string::npos if absent