LeetCode 925: Long Pressed Name
A clear explanation of the Long Pressed Name problem using a two-pointer scan.
Tag
String
264 notes
LeetCode 972: Equal Rational Numbers
A clear explanation of comparing rational numbers written as decimal strings with optional repeating parts.
LeetCode 966: Vowel Spellchecker
A clear explanation of implementing a spellchecker with exact, case-insensitive, and vowel-error matching.
LeetCode 960: Delete Columns to Make Sorted III
A clear explanation of deleting the minimum number of columns so every remaining row is individually sorted.
LeetCode 955: Delete Columns to Make Sorted II
A clear explanation of deleting the minimum number of columns so rows become lexicographically sorted.
LeetCode 953: Verifying an Alien Dictionary
A clear explanation of checking whether words are sorted according to a custom alien alphabet order.
LeetCode 848: Shifting Letters
A clear explanation of the Shifting Letters problem using suffix sums and modulo arithmetic.
LeetCode 844: Backspace String Compare
A clear explanation of the Backspace String Compare problem using stack simulation and an O(1) space two-pointer scan.
LeetCode 843: Guess the Word
A clear explanation of the Guess the Word interactive problem using candidate filtering and minimax-style guessing.
LeetCode 842: Split Array into Fibonacci Sequence
A clear explanation of the Split Array into Fibonacci Sequence problem using backtracking, leading-zero checks, and 32-bit integer limits.
LeetCode 839: Similar String Groups
A clear explanation of the Similar String Groups problem using graph connectivity and union-find.
LeetCode 838: Push Dominoes
A clear explanation of the Push Dominoes problem using force propagation and a two-pass scan.
LeetCode 833: Find And Replace in String
A clear explanation of the Find And Replace in String problem using simultaneous replacement, source matching, and a replacement map.
LeetCode 831: Masking Personal Information
A clear explanation of the Masking Personal Information problem using string parsing and format-specific masking rules.
LeetCode 830: Positions of Large Groups
A clear explanation of the Positions of Large Groups problem using a simple two-pointer scan.
LeetCode 828: Count Unique Characters of All Substrings of a Given String
A clear explanation of Count Unique Characters of All Substrings using contribution counting with previous and next occurrences.
LeetCode 921: Minimum Add to Make Parentheses Valid
A clear explanation of making a parentheses string valid using greedy counting.
LeetCode 917: Reverse Only Letters
A clear explanation of reversing only English letters while keeping all non-letter characters fixed.
LeetCode 916: Word Subsets
A clear explanation of finding universal words by merging character frequency requirements from words2.
LeetCode 899: Orderly Queue
A clear explanation of finding the lexicographically smallest string after queue operations using rotation and sorting.
LeetCode 893: Groups of Special-Equivalent Strings
A clear explanation of counting special-equivalent string groups by building canonical signatures from even and odd positions.
LeetCode 890: Find and Replace Pattern
A clear explanation of finding words that match a pattern using bijective character mapping.
LeetCode 884: Uncommon Words from Two Sentences
A clear explanation of finding uncommon words by counting word frequencies across both sentences.
LeetCode 880: Decoded String at Index
A clear explanation of finding the kth character in a decoded string without building the full decoded string.
LeetCode 249: Group Shifted Strings
A clear explanation of grouping strings by their shifting sequence using normalized hash keys.
LeetCode 248: Strobogrammatic Number III
A clear explanation of counting strobogrammatic numbers in a string range using recursive generation and range filtering.
LeetCode 247: Strobogrammatic Number II
A clear explanation of generating all strobogrammatic numbers of length n using recursion from the inside out.
LeetCode 246: Strobogrammatic Number
A clear explanation of the Strobogrammatic Number problem using digit rotation rules and two pointers.
LeetCode 245: Shortest Word Distance III
A clear explanation of the Shortest Word Distance III problem, including the special case where both target words are the same.
LeetCode 244: Shortest Word Distance II
A clear explanation of the Shortest Word Distance II problem using preprocessing and two pointers.
LeetCode 243: Shortest Word Distance
A clear explanation of the Shortest Word Distance problem using one pass and the latest seen indices of both words.
LeetCode 990: Satisfiability of Equality Equations
A clear explanation of checking equality and inequality constraints using union-find.
LeetCode 988: Smallest String Starting From Leaf
A clear explanation of finding the lexicographically smallest leaf-to-root string in a binary tree using DFS.
LeetCode 984: String Without AAA or BBB
A clear explanation of constructing a string with exact counts of a and b while avoiding three equal consecutive characters.
LeetCode 981: Time Based Key-Value Store
A clear explanation of designing a time-based key-value store using a hash map and binary search.
LeetCode 859: Buddy Strings
A clear explanation of checking whether one swap in a string can make it equal to another string.
LeetCode 856: Score of Parentheses
A clear explanation of scoring a balanced parentheses string using depth counting.
LeetCode 854: K-Similar Strings
A clear explanation of finding the minimum number of swaps needed to transform one anagram string into another using BFS.
LeetCode 949: Largest Time for Given Digits
A clear explanation of solving Largest Time for Given Digits by checking all permutations of four digits.
LeetCode 944: Delete Columns to Make Sorted
A clear explanation of solving Delete Columns to Make Sorted by checking each column independently.
LeetCode 943: Find the Shortest Superstring
A clear explanation of solving Find the Shortest Superstring using pairwise overlaps and bitmask dynamic programming.
LeetCode 942: DI String Match
A clear explanation of solving DI String Match using a greedy two-pointer construction.
LeetCode 940: Distinct Subsequences II
A clear explanation of solving Distinct Subsequences II using dynamic programming and last occurrence tracking.
LeetCode 937: Reorder Data in Log Files
A clear explanation of solving Reorder Data in Log Files using custom sorting and stable handling of digit logs.
LeetCode 936: Stamping The Sequence
A clear explanation of solving Stamping The Sequence using reverse simulation and BFS-style processing.
LeetCode 929: Unique Email Addresses
A clear explanation of solving Unique Email Addresses using string normalization and a hash set.
LeetCode 926: Flip String to Monotone Increasing
A clear explanation of solving Flip String to Monotone Increasing with a one-pass dynamic programming approach.
LeetCode 824: Goat Latin
A string simulation solution for converting each word in a sentence into Goat Latin.
LeetCode 821: Shortest Distance to a Character
A two-pass solution for computing the shortest distance from each index to the nearest occurrence of a target character.
LeetCode 820: Short Encoding of Words
A suffix-removal solution for finding the shortest reference string that can encode every word.
LeetCode 819: Most Common Word
A hash map and string parsing solution for finding the most frequent non-banned word in a paragraph.
LeetCode 816: Ambiguous Coordinates
An enumeration solution for reconstructing all valid coordinate pairs after commas, spaces, and decimal points were removed.
LeetCode 811: Subdomain Visit Count
A hash map solution for accumulating visit counts across domains and all of their parent subdomains.
LeetCode 809: Expressive Words
A two-pointer group comparison solution for counting how many words can be stretched to match a target string.
LeetCode 806: Number of Lines To Write String
A simple simulation solution for counting how many 100-pixel lines are needed to write a string.
LeetCode 804: Unique Morse Code Words
A set-based solution for counting how many different Morse code transformations appear among a list of words.
LeetCode 800: Similar RGB Color
A clear explanation of finding the closest shorthand RGB color by rounding each color channel to the nearest repeated hexadecimal pair.
LeetCode 796: Rotate String
A clear explanation of checking whether one string can become another by repeated left rotations.
LeetCode 792: Number of Matching Subsequences
A clear explanation of counting how many words are subsequences of a string using waiting queues.
LeetCode 791: Custom Sort String
A clear explanation of rearranging a string so that selected characters follow a custom order.
LeetCode 788: Rotated Digits
A clear explanation of counting good numbers after rotating every digit by 180 degrees.
LeetCode 784: Letter Case Permutation
A clear explanation of generating all strings formed by independently changing each letter to lowercase or uppercase.
LeetCode 777: Swap Adjacent in LR String
A clear explanation of validating string transformation using two pointers and movement constraints.
LeetCode 772: Basic Calculator III
A clear explanation of evaluating arithmetic expressions with parentheses, precedence, and integer division.
LeetCode 771: Jewels and Stones
A clear explanation of counting how many stones are jewels using a hash set for fast membership checks.
LeetCode 770: Basic Calculator IV
A clear explanation of simplifying algebraic expressions by parsing, substituting variables, and combining polynomial terms.
LeetCode 767: Reorganize String
A clear explanation of rearranging characters so no two adjacent characters are equal using a greedy max heap.
LeetCode 763: Partition Labels
A clear explanation of partitioning a string into the maximum number of parts so each character appears in at most one part.
LeetCode 761: Special Binary String
A clear explanation of making a special binary string lexicographically largest using recursive decomposition and sorting.
LeetCode 758: Bold Words in String
A clear explanation of marking matching substrings and merging overlapping bold ranges.
LeetCode 756: Pyramid Transition Matrix
A clear explanation of solving Pyramid Transition Matrix using backtracking and memoization over pyramid rows.
LeetCode 752: Open the Lock
A clear explanation of solving Open the Lock using breadth-first search over lock states.
LeetCode 751: IP to CIDR
A clear explanation of converting a range of IPv4 addresses into the shortest list of CIDR blocks using greedy bit manipulation.
LeetCode 722: Remove Comments
A clear explanation of removing line comments and block comments from source code using a state machine.
LeetCode 721: Accounts Merge
A clear explanation of merging accounts that share emails using union find and sorted email groups.
LeetCode 720: Longest Word in Dictionary
A clear explanation of finding the longest buildable word using sorting and a hash set.
LeetCode 712: Minimum ASCII Delete Sum for Two Strings
A clear explanation of using dynamic programming to minimize the ASCII cost of deletions needed to make two strings equal.
LeetCode 709: To Lower Case
A clear explanation of converting uppercase ASCII letters to lowercase by scanning the string once.
LeetCode 748: Shortest Completing Word
Find the shortest word that contains all required license plate letters using frequency counting.
LeetCode 745: Prefix and Suffix Search
Support fast prefix and suffix queries by indexing every prefix-suffix combination with the largest word index.
LeetCode 737: Sentence Similarity II
Check sentence similarity with transitive word relationships using union-find.
LeetCode 736: Parse Lisp Expression
Evaluate a Lisp-like expression with integers, variables, let bindings, addition, multiplication, and lexical scope.
LeetCode 734: Sentence Similarity
Check whether two word arrays are sentence-similar using a hash set of symmetric similar word pairs.
LeetCode 730: Count Different Palindromic Subsequences
Count distinct non-empty palindromic subsequences using interval dynamic programming and duplicate handling.
LeetCode 727: Minimum Window Subsequence
Find the shortest substring of s1 that contains s2 as a subsequence using dynamic programming.
LeetCode 726: Number of Atoms
Parse a chemical formula with nested parentheses, atom names, and multipliers using recursive descent.
LeetCode 696: Count Binary Substrings
Count substrings with equal consecutive groups of 0s and 1s using run lengths.
LeetCode 692: Top K Frequent Words
Find the k most frequent words using frequency counting and custom sorting by count and lexicographical order.
LeetCode 691: Stickers to Spell Word
Find the minimum number of stickers needed to form a target string using top-down dynamic programming with memoization.
LeetCode 686: Repeated String Match
Find the minimum number of times one string must be repeated so another string becomes a substring.
LeetCode 681: Next Closest Time
Find the next valid 24-hour time using only the digits from the current time.
LeetCode 680: Valid Palindrome II
Check whether a string can become a palindrome after deleting at most one character using two pointers.
LeetCode 678: Valid Parenthesis String
Check whether a string containing parentheses and wildcard stars can be made valid using a greedy range of possible open counts.
LeetCode 677: Map Sum Pairs
Design a map that supports key-value insertion and prefix-sum queries using a hash map and trie.
LeetCode 676: Implement Magic Dictionary
Design a dictionary that can check whether a word can match a stored word after changing exactly one character.
LeetCode 670: Maximum Swap
A clear explanation of maximizing an integer by swapping at most two digits once.
LeetCode 664: Strange Printer
A clear explanation of minimizing printer turns using interval dynamic programming.
LeetCode 657: Robot Return to Origin
A clear explanation of determining whether a robot returns to the origin after executing movement instructions.
LeetCode 649: Dota2 Senate
A queue-based simulation for predicting which party wins after senators ban opponents in turn order.
LeetCode 648: Replace Words
A trie-based solution for replacing each derivative word with the shortest matching root.
LeetCode 647: Palindromic Substrings
A center expansion solution for counting every palindromic substring in a string.
LeetCode 640: Solve the Equation
A string parsing solution for reducing a linear equation into coefficient and constant terms.
LeetCode 639: Decode Ways II
A dynamic programming solution for counting decodings of a digit string with wildcard characters.
LeetCode 636: Exclusive Time of Functions
A stack-based solution for computing exclusive execution time from nested start and end logs.
LeetCode 635: Design Log Storage System
A design solution for storing timestamped logs and retrieving IDs by inclusive time range at a chosen granularity.
LeetCode 616: Add Bold Tag in String
A string-marking guide for adding bold tags around all matched words while merging overlapping and adjacent bold regions.
LeetCode 609: Find Duplicate File in System
A hash map guide for grouping file paths by identical file content and returning only duplicate groups.
LeetCode 606: Construct String from Binary Tree
A recursive guide for converting a binary tree into a preorder parenthesized string while preserving the one-to-one mapping between the tree and the string.
LeetCode 604: Design Compressed String Iterator
A guide to implementing a lazy iterator over a run-length encoded string without fully decompressing it.
LeetCode 242: Valid Anagram
A clear explanation of checking whether two strings are anagrams using character frequency counting.
LeetCode 227: Basic Calculator II
A detailed explanation of evaluating arithmetic expressions with stack-based parsing and operator precedence.
LeetCode 49: Group Anagrams
A clear explanation of Group Anagrams using a hash map keyed by each word's sorted character signature.
LeetCode 44: Wildcard Matching
A clear explanation of Wildcard Matching using dynamic programming over string and pattern prefixes.
LeetCode 43: Multiply Strings
A clear explanation of Multiply Strings using grade-school multiplication with digit arrays.
LeetCode 599: Minimum Index Sum of Two Lists
A clear hash map solution for finding common strings with the smallest index sum.
LeetCode 592: Fraction Addition and Subtraction
A clear parsing and math solution for evaluating fraction addition and subtraction expressions.
LeetCode 591: Tag Validator
A clear stack-based parser for validating nested XML-like tags with CDATA sections.
LeetCode 588: Design In-Memory File System
A clear design guide for implementing an in-memory file system with directory listing, directory creation, file append, and file read operations.
LeetCode 583: Delete Operation for Two Strings
A clear dynamic programming solution for finding the minimum deletions needed to make two strings equal.
LeetCode 567: Permutation in String
A clear explanation of Permutation in String using a fixed-size sliding window and character frequency counts.
LeetCode 564: Find the Closest Palindrome
A clear explanation of Find the Closest Palindrome using prefix mirroring and a small candidate set.
LeetCode 557: Reverse Words in a String III
A clear explanation of Reverse Words in a String III using two-pointer scanning and string reversal.
LeetCode 556: Next Greater Element III
A clear explanation of Next Greater Element III using the next permutation algorithm on the digits of an integer.
LeetCode 555: Split Concatenated Strings
A clear explanation of Split Concatenated Strings using string reversal choices and enumeration of every possible cut point.
LeetCode 553: Optimal Division
A clear explanation of Optimal Division using the structure of division expressions to build the maximum-value expression.
LeetCode 552: Student Attendance Record II
A clear explanation of Student Attendance Record II using dynamic programming over absence count and late streak.
LeetCode 551: Student Attendance Record I
A clear explanation of Student Attendance Record I using simple string checks and a one-pass counter solution.
LeetCode 544: Output Contest Matches
A clear explanation of building the final tournament bracket by repeatedly pairing strongest and weakest teams.
LeetCode 541: Reverse String II
A clear explanation of reversing the first k characters in every 2k block of a string.
LeetCode 539: Minimum Time Difference
A clear explanation of finding the minimum difference between 24-hour clock times using minute conversion and sorting.
LeetCode 537: Complex Number Multiplication
A clear explanation of multiplying complex numbers represented as strings using algebraic expansion.
LeetCode 536: Construct Binary Tree from String
A clear explanation of parsing a parenthesized string recursively to construct a binary tree.
LeetCode 535: Encode and Decode TinyURL
A clear explanation of designing a simple URL encoder and decoder using a hash map and generated keys.
LeetCode 527: Word Abbreviation
A clear explanation of generating minimal unique word abbreviations using grouping and trie prefixes.
LeetCode 524: Longest Word in Dictionary through Deleting
A clear explanation of finding the longest dictionary word obtainable as a subsequence using two pointers and sorting rules.
LeetCode 522: Longest Uncommon Subsequence II
A clear explanation of finding the longest uncommon subsequence among many strings using subsequence checks.
LeetCode 514: Freedom Trail
A clear explanation of finding the minimum steps to spell a key on a circular ring using dynamic programming and memoized DFS.
LeetCode 521: Longest Uncommon Subsequence I
A clear explanation of finding the longest uncommon subsequence between two strings using simple case analysis.
LeetCode 520: Detect Capital
A clear explanation of checking whether a word uses capital letters correctly by counting uppercase letters.
LeetCode 516: Longest Palindromic Subsequence
A clear explanation of finding the length of the longest palindromic subsequence using interval dynamic programming.
LeetCode 504: Base 7
A clear explanation of converting an integer into its base 7 string representation using repeated division.
LeetCode 500: Keyboard Row
A clear explanation of filtering words that can be typed using only one row of an American keyboard.
LeetCode 488: Zuma Game
A clear explanation of solving Zuma Game with DFS, memoization, and chain-removal simulation.
LeetCode 484: Find Permutation
A clear explanation of constructing the lexicographically smallest permutation that matches an I and D pattern.
LeetCode 482: License Key Formatting
A clear explanation of reformatting a license key by removing dashes, uppercasing characters, and grouping from the right.
LeetCode 481: Magical String
A clear explanation of constructing the magical string by using the string itself as run-length instructions.
LeetCode 474: Ones and Zeroes
A clear explanation of solving the largest subset problem as a two-dimensional 0/1 knapsack over zero and one counts.
LeetCode 472: Concatenated Words
A clear explanation of finding all words that can be formed by concatenating at least two shorter words from the same list.
LeetCode 471: Encode String with Shortest Length
A clear explanation of interval dynamic programming for encoding a string into the shortest k[encoded_string] form.
LeetCode 468: Validate IP Address
A clear explanation of validating IPv4 and IPv6 addresses by checking segment count, length, characters, range, and leading-zero rules.
LeetCode 467: Unique Substrings in Wraparound String
A clear explanation of counting unique substrings that appear in the infinite alphabet wraparound string using dynamic programming by ending character.
LeetCode 466: Count The Repetitions
A clear explanation of counting how many repeated copies of one string can be obtained as a subsequence of another repeated string.
LeetCode 459: Repeated Substring Pattern
A clear explanation of checking whether a string can be built by repeating one of its proper substrings.
LeetCode 451: Sort Characters By Frequency
A clear explanation of sorting characters by decreasing frequency using a hash map and sorting.
LeetCode 443: String Compression
Compress a character array in-place using two pointers and grouped character counting.
LeetCode 439: Ternary Expression Parser
Evaluate a nested ternary expression using a right-to-left stack parser.
LeetCode 438: Find All Anagrams in a String
Find all starting indices where an anagram of p appears in s using a fixed-size sliding window.
LeetCode 434: Number of Segments in a String
Count the number of word segments in a string by detecting transitions from spaces to non-space characters.
LeetCode 433: Minimum Genetic Mutation
Find the minimum number of valid one-character gene mutations using breadth-first search.
LeetCode 425: Word Squares
A clear explanation of building all word squares using backtracking with prefix pruning.
LeetCode 424: Longest Repeating Character Replacement
A clear explanation of finding the longest substring that can become all one letter using a sliding window.
LeetCode 423: Reconstruct Original Digits from English
A clear explanation of reconstructing digits from shuffled English words using character frequency counts and unique identifying letters.
LeetCode 422: Valid Word Square
A clear explanation of checking whether rows and columns read the same using direct index comparison.
LeetCode 418: Sentence Screen Fitting
A clear explanation of fitting a sentence onto a screen using cyclic string simulation and greedy row transitions.
LeetCode 415: Add Strings
A clear explanation of adding two non-negative integer strings using manual digit-by-digit simulation.
LeetCode 412: Fizz Buzz
A clear explanation of the Fizz Buzz problem using direct simulation and divisibility checks.
LeetCode 411: Minimum Unique Word Abbreviation
A clear explanation of finding the shortest abbreviation that does not conflict with any dictionary word using bit masks.
LeetCode 409: Longest Palindrome
A clear explanation of finding the longest palindrome length that can be built from given letters using character counts.
LeetCode 420: Strong Password Checker
A clear explanation of checking the minimum edits needed to make a password strong using greedy handling of length, missing character types, and repeated runs.
LeetCode 408: Valid Word Abbreviation
A clear explanation of validating a word abbreviation using two pointers and number parsing.
LeetCode 402: Remove K Digits
A clear explanation of the Remove K Digits problem using a greedy monotonic stack.
LeetCode 395: Longest Substring with At Least K Repeating Characters
A clear explanation of finding the longest substring where every character appears at least k times using divide and conquer.
LeetCode 394: Decode String
A clear explanation of decoding nested repeat expressions using a stack.
LeetCode 392: Is Subsequence
A clear explanation of checking whether one string is a subsequence of another using two pointers.
LeetCode 389: Find the Difference
A clear explanation of finding the extra character added to a shuffled string using counting and XOR.
LeetCode 388: Longest Absolute File Path
A clear explanation of computing the longest absolute path to a file from a serialized file system string using path lengths by depth.
LeetCode 387: First Unique Character in a String
A clear explanation of finding the first non-repeating character in a string using character frequency counting.
LeetCode 385: Mini Parser
A clear explanation of parsing a serialized nested integer string using a stack.
LeetCode 383: Ransom Note
A clear explanation of checking whether one string can be constructed from another using character frequency counting.
LeetCode 358: Rearrange String k Distance Apart
A clear explanation of rearranging a string so equal characters are at least k positions apart using a heap and cooldown queue.
LeetCode 345: Reverse Vowels of a String
A clear explanation of Reverse Vowels of a String using two pointers and selective swaps.
LeetCode 344: Reverse String
A clear explanation of Reverse String using two pointers and in-place swaps.
LeetCode 340: Longest Substring with At Most K Distinct Characters
A clear explanation of Longest Substring with At Most K Distinct Characters using a sliding window and character counts.
LeetCode 336: Palindrome Pairs
A clear explanation of Palindrome Pairs using reversed-word lookup and palindrome split checks.
LeetCode 331: Verify Preorder Serialization of a Binary Tree
A clear explanation of verifying preorder serialization using slot counting without reconstructing the tree.
LeetCode 320: Generalized Abbreviation
A clear explanation of Generalized Abbreviation using backtracking to choose whether each character is kept or abbreviated.
LeetCode 318: Maximum Product of Word Lengths
A clear explanation of Maximum Product of Word Lengths using bit masks to test disjoint character sets efficiently.
LeetCode 316: Remove Duplicate Letters
A clear explanation of Remove Duplicate Letters using a greedy monotonic stack.
LeetCode 306: Additive Number
A clear explanation of Additive Number using split enumeration and deterministic checking.
LeetCode 301: Remove Invalid Parentheses
A clear explanation of Remove Invalid Parentheses using BFS to guarantee the minimum number of removals.
LeetCode 299: Bulls and Cows
A counting solution for producing the Bulls and Cows hint while handling duplicate digits correctly.
LeetCode 297: Serialize and Deserialize Binary Tree
A preorder DFS codec for converting a binary tree to a string and reconstructing the same tree from that string.
LeetCode 294: Flip Game II
A recursive game theory solution with memoization for deciding whether the starting player can force a win.
LeetCode 293: Flip Game
A simple string scanning solution for generating every possible next state after flipping one consecutive ++ pair into --.
LeetCode 291: Word Pattern II
A backtracking solution for matching a pattern string to a target string using a bijective character-to-substring mapping.
LeetCode 290: Word Pattern
A hash map solution for checking whether a pattern string and a space-separated word string form a bijection.
LeetCode 288: Unique Word Abbreviation
A hash map design for checking whether a word's abbreviation is unique in a dictionary.
LeetCode 282: Expression Add Operators
A backtracking solution for inserting operators into a numeric string so the expression evaluates to a target value.
LeetCode 273: Integer to English Words
A clear explanation of the Integer to English Words problem using three-digit chunks and scale words.
LeetCode 271: Encode and Decode Strings
A clear explanation of the Encode and Decode Strings problem using length-prefix encoding.
LeetCode 269: Alien Dictionary
A clear explanation of the Alien Dictionary problem using graph construction and topological sorting.
LeetCode 267: Palindrome Permutation II
A clear explanation of the Palindrome Permutation II problem using character counts and backtracking over half of the palindrome.
LeetCode 266: Palindrome Permutation
A clear explanation of the Palindrome Permutation problem using character parity counting.
LeetCode 257: Binary Tree Paths
A clear explanation of the Binary Tree Paths problem using DFS backtracking to collect every root-to-leaf path.
LeetCode 224: Basic Calculator
A clear explanation of evaluating an expression with plus, minus, spaces, and parentheses using a stack.
LeetCode 214: Shortest Palindrome
A clear explanation of building the shortest palindrome by finding the longest palindromic prefix using KMP.
LeetCode 208: Implement Trie Prefix Tree
A clear explanation of implementing a Trie with insert, search, and startsWith operations.
LeetCode 205: Isomorphic Strings
A clear explanation of checking whether two strings follow the same character mapping pattern.
LeetCode 97: Interleaving String
A detailed guide to solving Interleaving String with two-dimensional dynamic programming.
LeetCode 93: Restore IP Addresses
A detailed guide to solving Restore IP Addresses with backtracking over four valid IP segments.
LeetCode 91: Decode Ways
A detailed guide to solving Decode Ways with dynamic programming and careful handling of zeroes.
LeetCode 87: Scramble String
A detailed guide to solving Scramble String with recursive dynamic programming and memoization.
LeetCode 79: Word Search
A detailed guide to solving Word Search with depth-first search and backtracking on a grid.
LeetCode 76: Minimum Window Substring
A detailed guide to solving Minimum Window Substring with a sliding window and frequency counters.
LeetCode 187: Repeated DNA Sequences
A clear explanation of finding repeated 10-letter DNA substrings using a fixed-size sliding window and hash sets.
LeetCode 186: Reverse Words in a String II
A clear explanation of reversing the order of words in a character array in-place using two reversals.
LeetCode 179: Largest Number
A clear explanation of arranging non-negative integers to form the largest possible concatenated number using a custom sort order.
LeetCode 171: Excel Sheet Column Number
A clear explanation of converting an Excel column title into its numeric index using base 26 accumulation.
LeetCode 168: Excel Sheet Column Title
A clear explanation of converting a positive integer into an Excel column title using bijective base 26.
LeetCode 166: Fraction to Recurring Decimal
A clear explanation of converting a fraction into decimal form and detecting repeating fractional parts with a hash map.
LeetCode 165: Compare Version Numbers
A clear explanation of comparing version strings revision by revision while ignoring leading zeros.
LeetCode 161: One Edit Distance
A clear explanation of checking whether two strings are exactly one edit apart using a linear scan.
LeetCode 159: Longest Substring with At Most Two Distinct Characters
A clear explanation of finding the longest substring with at most two distinct characters using a sliding window.
LeetCode 151: Reverse Words in a String
A clear explanation of reversing word order while removing extra spaces.
LeetCode 140: Word Break II
Return all valid sentences formed by inserting spaces into a string so every word belongs to the dictionary, using DFS with memoization.
LeetCode 139: Word Break
Decide whether a string can be segmented into dictionary words using dynamic programming over prefixes.
LeetCode 132: Palindrome Partitioning II
Find the minimum number of cuts needed to split a string into palindromic substrings using palindrome precomputation and dynamic programming.
LeetCode 131: Palindrome Partitioning
Generate all ways to split a string so that every piece is a palindrome, using backtracking with palindrome precomputation.
LeetCode 127: Word Ladder
Use breadth-first search to find the shortest transformation sequence length between two words.
LeetCode 126: Word Ladder II
Find all shortest word transformation sequences using BFS to build shortest-path parents, then backtracking to reconstruct every answer.
LeetCode 125: Valid Palindrome
A clear explanation of checking whether a string is a palindrome after ignoring non-alphanumeric characters and case.
LeetCode 115: Distinct Subsequences
A clear explanation of counting distinct subsequences using dynamic programming.
LeetCode 72: Edit Distance
A clear guide to computing the minimum number of insert, delete, and replace operations needed to convert one string into another.
LeetCode 71: Simplify Path
A clear guide to simplifying Unix-style file paths using a stack.
LeetCode 68: Text Justification
A clear guide to formatting text with greedy line packing and even space distribution.
LeetCode 67: Add Binary
A clear guide to adding two binary strings using two pointers and a carry.
LeetCode 65: Valid Number
A clear guide to validating whether a string is a valid number using grammar rules and one left-to-right scan.
LeetCode 58: Length of Last Word
A clear guide to solving Length of Last Word by scanning the string from right to left.
LeetCode 38: Count and Say
A clear explanation of generating the count-and-say sequence using run-length encoding.
LeetCode 32: Longest Valid Parentheses
A clear explanation of finding the longest well-formed parentheses substring using a stack of indices.
LeetCode 30: Substring with Concatenation of All Words
A clear explanation of finding all starting indices where a substring is formed by concatenating every word exactly once.
LeetCode 28: Find the Index of the First Occurrence in a String
A clear explanation of finding the first occurrence of one string inside another using direct string matching.
LeetCode 22: Generate Parentheses
A detailed explanation of generating all well-formed parentheses strings using backtracking.
LeetCode 20: Valid Parentheses
A detailed explanation of checking whether a bracket string is valid using a stack.
LeetCode 17: Letter Combinations of a Phone Number
A detailed explanation of generating all possible phone keypad letter combinations using backtracking.
LeetCode 14: Longest Common Prefix
A detailed explanation of finding the longest common prefix among an array of strings by comparing characters column by column.
LeetCode 13: Roman to Integer
A detailed explanation of converting a Roman numeral string into an integer using symbol values and the subtraction rule.
LeetCode 12: Integer to Roman
A detailed explanation of converting an integer into a Roman numeral using a fixed value-symbol table and greedy subtraction.
LeetCode 10: Regular Expression Matching
A detailed explanation of matching a full string against a simplified regular expression with dot and star using dynamic programming.
LeetCode 8: String to Integer (atoi)
A detailed explanation of parsing a string into a 32-bit signed integer with whitespace, sign, digit reading, and clamping rules.
LeetCode 6: Zigzag Conversion
A detailed explanation of converting a string into a zigzag pattern using row simulation.
LeetCode 5: Longest Palindromic Substring
A detailed explanation of finding the longest palindromic substring using expand-around-center.
LeetCode 3: Longest Substring Without Repeating Characters
A clear explanation of the longest substring problem using sliding window and a hash set.
SA-IS Suffix Array Construction
Linear time suffix array construction using induced sorting of LMS substrings.
DC7 Suffix Array Sort
Generalized divide and conquer suffix array construction using modulo 7 partitioning.
Skew Suffix Array Sort (DC3)
Linear time suffix array construction using the DC3 divide and conquer strategy.
Suffix Array Doubling Sort
Build a suffix array using the prefix doubling technique with iterative ranking.
LCP Accelerated Suffix Search
Search for a pattern in a suffix array using LCP information to reduce redundant character comparisons.
Suffix Array Binary Search
Search for a pattern in a text by binary searching the lexicographically sorted suffix array.
Suffix Tree Search
Search for a pattern in a text using a suffix tree in time proportional to the pattern length.
Ternary Search Tree Search
Search for a string key in a ternary search tree using character comparisons and three-way branching.
Radix Tree Search
Search for a string or byte key in a radix tree using variable length edge labels.
Compressed Trie Search
Search for a string key in a trie whose unary paths are compressed into edge labels.
Trie Search
Search for a string key in a prefix tree by following character transitions.