Strings

A String is an immutable sequence of characters in Java: you never change it, you only create a new one.

Compare the outermost characters and move inward: if every mirrored pair matches, it is a palindrome.

Walk the string once, tally vowels and consonants, and skip anything that is not a letter.

Anagrams have identical character frequencies: count up for one string, count down for the other, and check everything cancels to zero.

Count every character's frequency, then scan in original order and return the first one with a count of exactly one.

dp[i][j] = (fromS1 and match) OR (fromS2 and match); length must equal m+n.

Count characters into a LinkedHashMap to keep first-seen order, then return the first key with count one.

Count up for one string and down for the other: equal lengths with all counts zero means valid anagram.

Reverse the digits by peeling the last one with modulo ten each step, then check if the reversed number equals the original.

Prefix each string with its length and a separator, so decoding reads exactly that many characters and no character is ever ambiguous.

Union-Find tracks which group each element belongs to, and path compression plus union by rank make find and union almost O(1).

Slide a window the size of the pattern and compare character counts; equal counts mean the window is an anagram.

Try every prefix cut, keep only palindromic prefixes, recurse on the remainder until the whole string is consumed.

Expand right, and when distinct characters exceed k, shrink left until they fit, tracking the longest window.

Stack of indices with a -1 sentinel; on close parenthesis pop and measure current minus new top; track max.

Each element points toward a set representative; find walks to the root with path compression, union links roots by rank, giving near-constant amortised time.

dp[i] is true if some dp[j] is true and the substring from j to i is a dictionary word.

dp[i] = (single valid ? dp[i−1] : 0) + (pair valid ? dp[i−2] : 0).

Read from the right, let each backspace eat the next real character, and compare the survivors in lockstep.

Sort each word's letters to make a canonical key and bucket words by that key in a HashMap.

Scan character positions top to bottom across all strings and stop at the first mismatch or end.

Grow the window on the right, shrink it from the left past any duplicate, and track the widest all-unique window.

A window is valid when its size minus the most frequent character's count is at most K; grow while valid and track the max.

Grow the window on the right, and when a character repeats inside it, jump the left edge to just past that character's previous position using a last-seen map.

A window is valid when the number of characters to replace, its size minus the most frequent character's count, is at most K.

Expand until the window has everything required, then shrink from the left while it still does, tracking the minimum window.

Try every character and every gap as a center, expand while both sides match, and keep the longest.

For every center, each outward step where both sides match is one more palindrome; sum them all.

Expand right until the window has everything needed, then shrink left while it still does, tracking the smallest.

Walk every character, fail fast on the first non-digit, and only pass if the whole string is digits and non-empty.

Build a new string with a StringBuilder, appending only non-space characters, since strings cannot be edited in place.

Lowercase is 32 above uppercase in ASCII, so subtract 32 to capitalize and add 32 to make lowercase, leaving non-letters unchanged.

Walk two pointers inward, skip non-alphanumeric characters, and compare case-insensitively until they meet.

A contiguous range is a palindrome when its ends match and the strictly inner range is already a palindrome.

For every range, if its ends match and the inner range is a palindrome, count it and mark it.

Minimum deletions equal the string length minus the longest palindromic subsequence length.

Fewest cuts up to position i is the best over every palindromic piece ending at i of one plus the cuts before that piece.

Minimum insertions equal the string length minus the longest palindromic subsequence length.

On a match the run extends from the diagonal by one, and on a mismatch it resets to zero.

On a match add one to the diagonal, on a mismatch keep the larger of the top or left neighbor.

Deletions equal first length minus common subsequence, insertions equal second length minus common subsequence.

The shortest supersequence length equals the sum of the two string lengths minus their longest common subsequence length.

On a match, copy the diagonal; on a mismatch, add one to the minimum of substitute (diagonal), delete (top), or insert (left).

Each adjacent word pair's first difference gives one ordering edge, then topologically sort the characters.

Walk the grid and the trie together, pruning any path whose prefix matches no word.

Only descend through trie nodes that are themselves complete words, and keep the longest reachable path.

Count character frequencies, push into a max-heap by frequency, then poll and repeat each character by its count.

Expand the right pointer and jump the left boundary past any duplicate's last position, tracking the longest all-distinct window.

Keep the window valid when its length minus the most frequent character count is at most k, and track the widest such window.

Expand right until all required characters are satisfied, then shrink left while still satisfied, recording the smallest complete window.

Slide a fixed-width window the size of the pattern and check whether its character counts ever exactly match the pattern's counts.

Slide a fixed-width window the size of the pattern and collect every start index where the window's character counts match the pattern's counts.

Slide a window in whole-word steps, tracking word counts against the requirement, and record each start where every word appears exactly the required number of times.

For each letter, duplicate all current strings with that letter's case flipped; for each digit, do nothing.

When characters match, take the diagonal plus one; when they differ, take the maximum of the top and left cells.

Try every possible center, expand outward while both sides match, and keep the longest span.

When characters match, take the diagonal plus one; when they differ, reset to zero; the answer is the largest cell in the entire table.

From each start position, try every prefix, recurse only on palindromic prefixes, and record a partition when the whole string is consumed.

Two pointers close in from both ends, skip non-alphanumeric characters, compare lowercased letters, and declare a palindrome if they meet without a mismatch.

Track a low and high range of possible open-bracket counts, clamp low at zero, reject if high goes negative, and accept if low reaches zero at the end.

If both strings have equal length and the second string is a substring of the first concatenated with itself, they are rotations.