docs(docs): add ProblemBadges component, layout slot, and enrich pages with topics/video frontmatter, plus guide placeholders and topic‑landing map.

2026-11-02 21:22:43 +00:00 · 2026-09-28 11:20:41 -04:00
1 parent b035d1ffa0
commit d2888360e2
@@ -2,13 +2,15 @@
 title: '153. Find Minimum in Rotated Sorted Array'
 description: 'Suppose an array of length n sorted in ascending order is rotated between 1 and n times. For example, the array nums = [0,1,2,4,5,6,7] might become:'
 icon: dot
+topics:
+  - { name: "Array", slug: "array" }
+  - { name: "Binary Search", slug: "binary-search" }
+video: "nIVW4P8b1VA"
 sidebar:
  label: 'Find Minimum in Rotated Sorted Array'
  badge: 'Medium'
 ---

-<Badge variant="accent">Array</Badge>
-
 ::::warning
 Notice that rotating an array [a[0], a[1], a[2], ..., a[n-1]] 1 time results in the array [a[n-1], a[0], a[1], a[2], ..., a[n-2]].
 ::::
@@ -69,7 +71,3 @@ class Solution:

        return nums[lowest_index]
 ```
-
-## Explanation
-
-<YouTube id="nIVW4P8b1VA" title="Find Minimum in Rotated Sorted Array - Binary Search - Leetcode 153 - Python" />
@@ -2,13 +2,15 @@
 title: '33. Search in Rotated Sorted Array'
 description: There is an integer array nums sorted in ascending order (with distinct values)
 icon: dot
+topics:
+  - { name: "Array", slug: "array" }
+  - { name: "Binary Search", slug: "binary-search" }
+video: "U8XENwh8Oy8"
 sidebar:
  label: 'Search in Rotated Sorted Array'
  badge: 'Medium'
 ---

-<Badge variant="accent">Array</Badge>
-
 ::::warning
 You must write an algorithm with O(log n) runtime complexity.
 ::::
@@ -93,7 +95,3 @@ var search = function(nums, target) {
  return -1;
 };
 ```
-
-## Explanation
-
-<YouTube id="U8XENwh8Oy8" title="Search in rotated sorted array - Leetcode 33 - Python" />
@@ -2,13 +2,15 @@
 title: '35. Search Insert Position'
 description: Given a sorted array of distinct integers and a target value, return the index if the target is found. If not, return the index where it would be if it were inserted in order
 icon: dot
+topics:
+  - { name: "Array", slug: "array" }
+  - { name: "Binary Search", slug: "binary-search" }
+video: "K-RYzDZkzCI"
 sidebar:
  label: 'Search Insert Position'
  badge: 'Easy'
 ---

-<Badge variant="accent">Array</Badge>
-
 ::::warning
 You must write an algorithm with O(log n) runtime complexity.
 ::::
@@ -66,7 +68,3 @@ class Solution:

        return (l + r) // 2 + 1
 ```
-
-## Explanation
-
-<YouTube id="K-RYzDZkzCI" title="Search Insert Position - Binary Search - Leetcode 35 - Python" />
@@ -2,13 +2,15 @@
 title: '704. Binary Search'
 description: Given an array of integers nums which is sorted in ascending order, and an integer target, write a function to search target in nums. If target exists, then return its index. Otherwise, return -1
 icon: dot
+topics:
+  - { name: "Array", slug: "array" }
+  - { name: "Binary Search", slug: "binary-search" }
+video: "s4DPM8ct1pI"
 sidebar:
  label: 'Binary Search'
  badge: 'Easy'
 ---

-<Badge variant="accent">Array</Badge>
-
 ::::warning
 You must write an algorithm with O(log n) runtime complexity.
 ::::
@@ -71,7 +73,3 @@ var search = function(nums, target) {
    return -1;
 };
 ```
-
-## Explanation
-
-<YouTube id="s4DPM8ct1pI" title="Binary Search - Leetcode 704 - Python" />
@@ -2,13 +2,16 @@
 title: '74. Search a 2D Matrix'
 description: 'You are given an m x n integer matrix matrix with the following two properties:'
 icon: dot
+topics:
+  - { name: "Array", slug: "array" }
+  - { name: "Binary Search", slug: "binary-search" }
+  - { name: "Matrix", slug: "matrix" }
+video: "Ber2pi2C0j0"
 sidebar:
  label: 'Search a 2D Matrix'
  badge: 'Medium'
 ---

-<Badge variant="accent">Array</Badge>
-
 ::::warning
 You must write a solution in O(log(m * n)) time complexity.
 ::::
@@ -86,7 +89,3 @@ class Solution:
                return True
        return False
 ```
-
-## Explanation
-
-<YouTube id="Ber2pi2C0j0" title="Search a 2D Matrix - Leetcode 74 - Python" />
@@ -2,13 +2,15 @@
 title: '875. Koko Eating Bananas'
 description: Koko loves to eat bananas. There are n piles of bananas, the i^th pile has piles[i] bananas. The guards have gone and will come back in h hours
 icon: dot
+topics:
+  - { name: "Array", slug: "array" }
+  - { name: "Binary Search", slug: "binary-search" }
+video: "U2SozAs9RzA"
 sidebar:
  label: 'Koko Eating Bananas'
  badge: 'Medium'
 ---

-<Badge variant="accent">Array</Badge>
-
 ### Example 1:
 - Input: `piles = [3,6,7,11], h = 8`
 - Output: `4`
@@ -77,7 +79,3 @@ var minEatingSpeed = function(piles, h) {
  return l;
 };
 ```
-
-## Explanation
-
-<YouTube id="U2SozAs9RzA" title="Koko Eating Bananas - Binary Search - Leetcode 875 - Python" />
@@ -2,13 +2,15 @@
 title: '1. Two Sum'
 description: You are given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target
 icon: dot
+topics:
+  - { name: "Array", slug: "array" }
+  - { name: "Hash Table", slug: "hash-table" }
+video: "KLlXCFG5TnA"
 sidebar:
  label: 'Two Sum'
  badge: 'Easy'
 ---

-<Badge variant="accent">Array</Badge>
-
 ::::warning
 Can you come up with an algorithm that is less than O(n^2) time complexity?
 ::::
@@ -60,7 +62,3 @@ class Solution:
            seen[num] = i
        return []
 ```
-
-## Explanation
-
-<YouTube id="KLlXCFG5TnA" title="Two Sum - Leetcode 1 - HashMap - Python" />
@@ -2,13 +2,14 @@
 title: '1832. Check if the Sentence Is Pangram'
 description: A pangram is a sentence where every letter of the English alphabet appears at least once
 icon: dot
+topics:
+  - { name: "Hash Table", slug: "hash-table" }
+  - { name: "String", slug: "string" }
 sidebar:
  label: 'Check if the Sentence Is Pangram'
  badge: 'Easy'
 ---

-<Badge variant="accent">Hash Table</Badge>
-
 ### Example 1:
 - Input: `sentence = "thequickbrownfoxjumpsoverthelazydog"`
 - Output: `true`
@@ -2,13 +2,16 @@
 title: '217. Contains Duplicate'
 description: Given an integer array nums, return true if any value appears at least twice in the array, and return false if every element is distinct
 icon: dot
+topics:
+  - { name: "Array", slug: "array" }
+  - { name: "Hash Table", slug: "hash-table" }
+  - { name: "Sorting", slug: "sorting" }
+video: "3OamzN90kPg"
 sidebar:
  label: 'Contains Duplicate'
  badge: 'Easy'
 ---

-<Badge variant="accent">Array</Badge>
-
 ### Example 1:
 - Input: `nums = [1,2,3,1]`
 - Output: `true`
@@ -48,7 +51,3 @@ class Solution:
    def containsDuplicate(self, nums: List[int]) -> bool:
        return len(set(nums)) != len(nums)
 ```
-
-## Explanation
-
-<YouTube id="3OamzN90kPg" title="Contains Duplicate - Leetcode 217 - Python" />
@@ -2,13 +2,16 @@
 title: '242. Valid Anagram'
 description: Given two strings s and t, return true if t is an anagram of s, and false otherwise
 icon: dot
+topics:
+  - { name: "Hash Table", slug: "hash-table" }
+  - { name: "String", slug: "string" }
+  - { name: "Sorting", slug: "sorting" }
+video: "9UtInBqnCgA"
 sidebar:
  label: 'Valid Anagram'
  badge: 'Easy'
 ---

-<Badge variant="accent">Hash Table</Badge>
-
 ::::warning
 What if the inputs contain Unicode characters? How would you adapt your solution to such a case?
 ::::
@@ -60,7 +63,3 @@ var isAnagram = function(s, t) {
  return true;
 };
 ```
-
-## Explanation
-
-<YouTube id="9UtInBqnCgA" title="Valid Anagram - Leetcode 242 - Python" />
@@ -2,13 +2,21 @@
 title: '347. Top K Frequent Elements'
 description: Given an integer array nums and an integer k, return the k most frequent elements. You may return the answer in any order
 icon: dot
+topics:
+  - { name: "Array", slug: "array" }
+  - { name: "Hash Table", slug: "hash-table" }
+  - { name: "Divide and Conquer", slug: "divide-and-conquer" }
+  - { name: "Sorting", slug: "sorting" }
+  - { name: "Heap (Priority Queue)", slug: "heap-priority-queue" }
+  - { name: "Bucket Sort", slug: "bucket-sort" }
+  - { name: "Counting", slug: "counting" }
+  - { name: "Quickselect", slug: "quickselect" }
+video: "YPTqKIgVk-k"
 sidebar:
  label: 'Top K Frequent Elements'
  badge: 'Medium'
 ---

-<Badge variant="accent">Array</Badge>
-
 ::::warning
 Your algorithm's time complexity must be better than O(n log n), where n is the array's size.
 ::::
@@ -60,7 +68,3 @@ var topKFrequent = function (nums, k) {
    .slice(0, k);
 };
 ```
-
-## Explanation
-
-<YouTube id="YPTqKIgVk-k" title="Top K Frequent Elements - Bucket Sort - Leetcode 347 - Python" />
@@ -2,13 +2,17 @@
 title: '387. First Unique Character in a String'
 description: Given a string s, find the first non-repeating character in it and return its index. If it does not exist, return -1
 icon: dot
+topics:
+  - { name: "Hash Table", slug: "hash-table" }
+  - { name: "String", slug: "string" }
+  - { name: "Queue", slug: "queue" }
+  - { name: "Counting", slug: "counting" }
+video: "rBENYgWy3xU"
 sidebar:
  label: 'First Unique Character in a String'
  badge: 'Easy'
 ---

-<Badge variant="accent">Hash Table</Badge>
-
 ### Example 1:
 - Input: `s = "leetcode"`
 - Output: `0`
@@ -58,7 +62,3 @@ var firstUniqChar = function (s) {
  return -1;
 };
 ```
-
-## Explanation
-
-<YouTube id="rBENYgWy3xU" title="First Unique Character in a String - Leetcode 387 - Python" />
@@ -2,13 +2,19 @@
 title: '451. Sort Characters By Frequency'
 description: Given a string s, sort it in decreasing order based on the frequency of the characters. The frequency of a character is the number of times it appears in the string
 icon: dot
+topics:
+  - { name: "Hash Table", slug: "hash-table" }
+  - { name: "String", slug: "string" }
+  - { name: "Sorting", slug: "sorting" }
+  - { name: "Heap (Priority Queue)", slug: "heap-priority-queue" }
+  - { name: "Bucket Sort", slug: "bucket-sort" }
+  - { name: "Counting", slug: "counting" }
+video: "OXdXc9HTrIg"
 sidebar:
  label: 'Sort Characters By Frequency'
  badge: 'Medium'
 ---

-<Badge variant="accent">Hash Table</Badge>
-
 ### Example 1:
 - Input: `s = "tree"`
 - Output: `"eert"`
@@ -60,7 +66,3 @@ var frequencySort = function (s) {
    .join("");
 };
 ```
-
-## Explanation
-
-<YouTube id="OXdXc9HTrIg" title="Sort Characters By Frequency - Leetcode 451 - Python" />
@@ -2,13 +2,17 @@
 title: '49. Group Anagrams'
 description: Given an array of strings strs, group the anagrams together. You can return the answer in any order
 icon: dot
+topics:
+  - { name: "Array", slug: "array" }
+  - { name: "Hash Table", slug: "hash-table" }
+  - { name: "String", slug: "string" }
+  - { name: "Sorting", slug: "sorting" }
+video: "vzdNOK2oB2E"
 sidebar:
  label: 'Group Anagrams'
  badge: 'Medium'
 ---

-<Badge variant="accent">Array</Badge>
-
 ### Example 1:
 - Input: `strs = ["eat","tea","tan","ate","nat","bat"]`
 - Output: `[["bat"],["nat","tan"],["ate","eat","tea"]]`
@@ -65,7 +69,3 @@ var groupAnagrams = function(strs) {
  return Object.values(anagrams);
 };
 ```
-
-## Explanation
-
-<YouTube id="vzdNOK2oB2E" title="Group Anagrams - Categorize Strings by Count - Leetcode 49" />
@@ -2,13 +2,16 @@
 title: '739. Daily Temperatures'
 description: Given an array of integers temperatures represents the daily temperatures, return an array answer such that answer[i] is the number of days you have to wait after the i^th day to get a warmer temperature. If there is no future day for which this is possible, keep answer[i] == 0 instead
 icon: dot
+topics:
+  - { name: "Array", slug: "array" }
+  - { name: "Stack", slug: "stack" }
+  - { name: "Monotonic Stack", slug: "monotonic-stack" }
+video: "cTBiBSnjO3c"
 sidebar:
  label: 'Daily Temperatures'
  badge: 'Medium'
 ---

-<Badge variant="accent">Array</Badge>
-
 ### Example 1:
 - Input: `temperatures = [73,74,75,71,69,72,76,73]`
 - Output: `[1,1,4,2,1,1,0,0]`
@@ -54,7 +57,3 @@ class Solution:
            stack.append(i)
        return ans
 ```
-
-## Explanation
-
-<YouTube id="cTBiBSnjO3c" title="Daily Temperatures - Monotonic Stack - Leetcode 739 - Python" />
@@ -2,13 +2,17 @@
 title: '853. Car Fleet'
 description: There are n cars at given miles away from the starting mile 0, traveling to reach the mile target
 icon: dot
+topics:
+  - { name: "Array", slug: "array" }
+  - { name: "Stack", slug: "stack" }
+  - { name: "Sorting", slug: "sorting" }
+  - { name: "Monotonic Stack", slug: "monotonic-stack" }
+video: "Pr6T-3yB9RM"
 sidebar:
  label: 'Car Fleet'
  badge: 'Medium'
 ---

-<Badge variant="accent">Array</Badge>
-
 ### Example 1:
 - Input: `target = 12, position = [10,8,0,5,3], speed = [2,4,1,1,3]`
 - Output: `3`
@@ -62,7 +66,3 @@ class Solution:

        return len(stack)
 ```
-
-## Explanation
-
-<YouTube id="Pr6T-3yB9RM" title="Car Fleet - Leetcode 853 - Python" />
@@ -2,13 +2,15 @@
 title: '238. Product of Array Except Self'
 description: Given an integer array nums, return an array answer such that answer[i] is equal to the product of all the elements of nums except nums[i]
 icon: dot
+topics:
+  - { name: "Array", slug: "array" }
+  - { name: "Prefix Sum", slug: "prefix-sum" }
+video: "bNvIQI2wAjk"
 sidebar:
  label: 'Product of Array Except Self'
  badge: 'Medium'
 ---

-<Badge variant="accent">Array</Badge>
-
 ::::warning
 You must write an algorithm that runs in O(n) time and without using the division operation.
 Can you solve the problem in O(1) extra space complexity? (The output array does not count as extra space for space complexity analysis.)
@@ -63,7 +65,3 @@ var productExceptSelf = function(nums) {
  return answer;
 };
 ```
-
-## Explanation
-
-<YouTube id="bNvIQI2wAjk" title="Product of Array Except Self - Leetcode 238 - Python" />
@@ -2,13 +2,16 @@
 title: '303. Range Sum Query - Immutable'
 description: Given an integer array nums, handle multiple queries of the following type
 icon: dot
+topics:
+  - { name: "Array", slug: "array" }
+  - { name: "Design", slug: "design" }
+  - { name: "Prefix Sum", slug: "prefix-sum" }
+video: "2pndAmo_sMA"
 sidebar:
  label: 'Range Sum Query - Immutable'
  badge: 'Easy'
 ---

-<Badge variant="accent">Array</Badge>
-
 ### Example 1:
 - Input: `["NumArray", "sumRange", "sumRange", "sumRange"]` `[[[-2, 0, 3, -5, 2, -1]], [0, 2], [2, 5], [0, 5]]`
 - Output: `[null, 1, -1, -3]`
@@ -66,7 +69,3 @@ class NumArray {
 * var param_1 = obj.sumRange(left,right)
 */
 ```
-
-## Explanation
-
-<YouTube id="2pndAmo_sMA" title="Range Sum Query Immutable - Leetcode 303 - Python" />
@@ -2,13 +2,16 @@
 title: '560. Subarray Sum Equals K'
 description: Given an array of integers nums and an integer k, return the total number of subarrays whose sum equals to k
 icon: dot
+topics:
+  - { name: "Array", slug: "array" }
+  - { name: "Hash Table", slug: "hash-table" }
+  - { name: "Prefix Sum", slug: "prefix-sum" }
+video: "fFVZt-6sgyo"
 sidebar:
  label: 'Subarray Sum Equals K'
  badge: 'Medium'
 ---

-<Badge variant="accent">Array</Badge>
-
 ### Example 1:
 - Input: `nums = [1,1,1], k = 2`
 - Output: `2`
@@ -65,7 +68,3 @@ var subarraySum = function(nums, k) {
  return count
 };
 ```
-
-## Explanation
-
-<YouTube id="fFVZt-6sgyo" title="Subarray Sum Equals K - Prefix Sums - Leetcode 560 - Python" />
@@ -2,13 +2,15 @@
 title: '121. Best Time to Buy and Sell Stock'
 description: You are given an array prices where prices[i] is the price of a given stock on the i^th day
 icon: dot
+topics:
+  - { name: "Array", slug: "array" }
+  - { name: "Dynamic Programming", slug: "dynamic-programming" }
+video: "1pkOgXD63yU"
 sidebar:
  label: 'Best Time to Buy and Sell Stock'
  badge: 'Easy'
 ---

-<Badge variant="accent">Array</Badge>
-
 ### Example 1:
 - Input: `prices = [7,1,5,3,6,4]`
 - Output: `5`
@@ -55,7 +57,3 @@ class Solution:
            ans = max(ans, curr)
        return ans
 ```
-
-## Explanation
-
-<YouTube id="1pkOgXD63yU" title="Sliding Window: Best Time to Buy and Sell Stock - Leetcode 121 - Python" />
@@ -2,13 +2,16 @@
 title: '3. Longest Substring Without Repeating Characters'
 description: Given a string s, find the length of the longest substring without duplicate characters
 icon: dot
+topics:
+  - { name: "Hash Table", slug: "hash-table" }
+  - { name: "String", slug: "string" }
+  - { name: "Sliding Window", slug: "sliding-window" }
+video: "wiGpQwVHdE0"
 sidebar:
  label: 'Longest Substring Without Repeating Characters'
  badge: 'Medium'
 ---

-<Badge variant="accent">Hash Table</Badge>
-
 ### Example 1:
 - Input: `s = "abcabcbb"`
 - Output: `3`
@@ -61,7 +64,3 @@ class Solution:

        return ans
 ```
-
-## Explanation
-
-<YouTube id="wiGpQwVHdE0" title="Longest Substring Without Repeating Characters - Leetcode 3 - Python" />
@@ -2,13 +2,16 @@
 title: '424. Longest Repeating Character Replacement'
 description: You are given a string s and an integer k. You can choose any character of the string and change it to any other uppercase English character. You can perform this operation at most k times
 icon: dot
+topics:
+  - { name: "Hash Table", slug: "hash-table" }
+  - { name: "String", slug: "string" }
+  - { name: "Sliding Window", slug: "sliding-window" }
+video: "gqXU1UyA8pk"
 sidebar:
  label: 'Longest Repeating Character Replacement'
  badge: 'Medium'
 ---

-<Badge variant="accent">Hash Table</Badge>
-
 ### Example 1:
 - Input: `s = "ABAB", k = 2`
 - Output: `4`
@@ -61,7 +64,3 @@ class Solution:
            res = max(res, r - l + 1)
        return res
 ```
-
-## Explanation
-
-<YouTube id="gqXU1UyA8pk" title="Longest Repeating Character Replacement - Leetcode 424 - Python" />
@@ -2,13 +2,17 @@
 title: '567. Permutation in String'
 description: Given two strings s1 and s2, return true if s2 contains a permutation of s1, or false otherwise
 icon: dot
+topics:
+  - { name: "Hash Table", slug: "hash-table" }
+  - { name: "Two Pointers", slug: "two-pointers" }
+  - { name: "String", slug: "string" }
+  - { name: "Sliding Window", slug: "sliding-window" }
+video: "UbyhOgBN834"
 sidebar:
  label: 'Permutation in String'
  badge: 'Medium'
 ---

-<Badge variant="accent">Hash Table</Badge>
-
 ### Example 1:
 - Input: `s1 = "ab", s2 = "eidbaooo"`
 - Output: `true`
@@ -68,7 +72,3 @@ class Solution:

        return False
 ```
-
-## Explanation
-
-<YouTube id="UbyhOgBN834" title="Permutation in String - Leetcode 567 - Python" />
@@ -2,13 +2,16 @@
 title: '150. Evaluate Reverse Polish Notation'
 description: You are given an array of strings tokens that represents an arithmetic expression in a Reverse Polish Notation
 icon: dot
+topics:
+  - { name: "Array", slug: "array" }
+  - { name: "Math", slug: "math" }
+  - { name: "Stack", slug: "stack" }
+video: "iu0082c4HDE"
 sidebar:
  label: 'Evaluate Reverse Polish Notation'
  badge: 'Medium'
 ---

-<Badge variant="accent">Array</Badge>
-
 ### Example 1:
 - Input: `tokens = ["2","1","+","3","*"]`
 - Output: `9`
@@ -69,7 +72,3 @@ class Solution:

        return stack[0]
 ```
-
-## Explanation
-
-<YouTube id="iu0082c4HDE" title="Evaluate Reverse Polish Notation - Leetcode 150 - Python" />
@@ -2,13 +2,15 @@
 title: '155. Min Stack'
 description: Design a stack that supports push, pop, top, and retrieving the minimum element in constant time
 icon: dot
+topics:
+  - { name: "Stack", slug: "stack" }
+  - { name: "Design", slug: "design" }
+video: "qkLl7nAwDPo"
 sidebar:
  label: 'Min Stack'
  badge: 'Medium'
 ---

-<Badge variant="accent">Stack</Badge>
-
 ::::warning
 You must implement a solution with O(1) time complexity for each function.
 ::::
@@ -77,7 +79,3 @@ class MinStack:
 # param_3 = obj.top()
 # param_4 = obj.getMin()
 ```
-
-## Explanation
-
-<YouTube id="qkLl7nAwDPo" title="Design Min Stack - Amazon Interview Question - Leetcode 155 - Python" />
@@ -2,13 +2,16 @@
 title: '20. Valid Parentheses'
 description: Given a string s containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid
 icon: dot
+topics:
+  - { name: "String", slug: "string" }
+  - { name: "Stack", slug: "stack" }
+  - { name: "Bracket Sequences", slug: "bracket-sequences" }
+video: "WTzjTskDFMg"
 sidebar:
  label: 'Valid Parentheses'
  badge: 'Easy'
 ---

-<Badge variant="accent">String</Badge>
-
 ### Example 1:
 - Input: `s = "()"`
 - Output: `true`
@@ -71,7 +74,3 @@ class Solution:

        return True if not stack else False
 ```
-
-## Explanation
-
-<YouTube id="WTzjTskDFMg" title="Valid Parentheses - Stack - Leetcode 20 - Python" />
@@ -2,13 +2,16 @@
 title: '11. Container With Most Water'
 description: You are given an integer array height of length n. There are n vertical lines drawn such that the two endpoints of the i^th line are (i, 0) and (i, height[i])
 icon: dot
+topics:
+  - { name: "Array", slug: "array" }
+  - { name: "Two Pointers", slug: "two-pointers" }
+  - { name: "Greedy", slug: "greedy" }
+video: "UuiTKBwPgAo"
 sidebar:
  label: 'Container With Most Water'
  badge: 'Medium'
 ---

-<Badge variant="accent">Array</Badge>
-
 ::::warning
 Notice that you may not slant the container.
 ::::
@@ -63,7 +66,3 @@ class Solution:

        return res
 ```
-
-## Explanation
-
-<YouTube id="UuiTKBwPgAo" title="Container with Most Water - Leetcode 11 - Python" />
@@ -2,13 +2,15 @@
 title: '125. Valid Palindrome'
 description: A phrase is a palindrome if, after converting all uppercase letters into lowercase letters and removing all non-alphanumeric characters, it reads the same forward and backward. Alphanumeric characters include letters and numbers
 icon: dot
+topics:
+  - { name: "Two Pointers", slug: "two-pointers" }
+  - { name: "String", slug: "string" }
+video: "jJXJ16kPFWg"
 sidebar:
  label: 'Valid Palindrome'
  badge: 'Easy'
 ---

-<Badge variant="accent">Two Pointers</Badge>
-
 ### Example 1:
 - Input: `s = "A man, a plan, a canal: Panama"`
 - Output: `true`
@@ -64,7 +66,3 @@ var isPalindrome = function(s) {
  return true;
 };
 ```
-
-## Explanation
-
-<YouTube id="jJXJ16kPFWg" title="Valid Palindrome - Leetcode 125 - Python" />
@@ -2,13 +2,16 @@
 title: '15. 3Sum'
 description: Given an integer array nums, return all the triplets [nums[i], nums[j], nums[k]] such that i != j, i != k, and j != k, and nums[i] + nums[j] + nums[k] == 0
 icon: dot
+topics:
+  - { name: "Array", slug: "array" }
+  - { name: "Two Pointers", slug: "two-pointers" }
+  - { name: "Sorting", slug: "sorting" }
+video: "jzZsG8n2R9A"
 sidebar:
  label: '3Sum'
  badge: 'Medium'
 ---

-<Badge variant="accent">Array</Badge>
-
 ::::warning
 Notice that the solution set must not contain duplicate triplets.
 ::::
@@ -99,7 +102,3 @@ class Solution:

        return result
 ```
-
-## Explanation
-
-<YouTube id="jzZsG8n2R9A" title="3Sum - Leetcode 15 - Python" />
@@ -2,13 +2,16 @@
 title: '167. Two Sum II - Input Array Is Sorted'
 description: Given a 1-indexed array of integers numbers that is already sorted in non-decreasing order, find two numbers such that they add up to a specific target number. Let these two numbers be numbers[index1] and numbers[index2] where 1 <= index1 < index2 <= numbers.length
 icon: dot
+topics:
+  - { name: "Array", slug: "array" }
+  - { name: "Two Pointers", slug: "two-pointers" }
+  - { name: "Binary Search", slug: "binary-search" }
+video: "cQ1Oz4ckceM"
 sidebar:
  label: 'Two Sum II - Input Array Is Sorted'
  badge: 'Medium'
 ---

-<Badge variant="accent">Array</Badge>
-
 ::::warning
 Your solution must use only constant extra space.
 ::::
@@ -70,7 +73,3 @@ class Solution:
                j-=1
        return []
 ```
-
-## Explanation
-
-<YouTube id="cQ1Oz4ckceM" title="TWO SUM II - Amazon Coding Interview Question - Leetcode 167 - Python" />
@@ -2,13 +2,15 @@
 title: '344. Reverse String'
 description: Write a function that reverses a string. The input string is given as an array of characters s
 icon: dot
+topics:
+  - { name: "Two Pointers", slug: "two-pointers" }
+  - { name: "String", slug: "string" }
+video: "_d0T_2Lk2qA"
 sidebar:
  label: 'Reverse String'
  badge: 'Easy'
 ---

-<Badge variant="accent">Two Pointers</Badge>
-
 :::warning
 You must do this by modifying the input array in-place with O(1) extra memory.
 :::
@@ -56,7 +58,3 @@ var reverseString = function(s) {
    }   
 };
 ```
-
-## Explanation
-
-<YouTube id="_d0T_2Lk2qA" title="Reverse String - 3 Ways - Leetcode 344 - Python" />
@@ -2,13 +2,16 @@
 title: '392. Is Subsequence'
 description: Given two strings s and t, return true if s is a subsequence of t, or false otherwise
 icon: dot
+topics:
+  - { name: "Two Pointers", slug: "two-pointers" }
+  - { name: "String", slug: "string" }
+  - { name: "Dynamic Programming", slug: "dynamic-programming" }
+video: "99RVfqklbCE"
 sidebar:
  label: 'Is Subsequence'
  badge: 'Easy'
 ---

-<Badge variant="accent">Two Pointers</Badge>
-
 ::::warning
 Suppose there are lots of incoming s, say s1, s2, ..., sk where k >= 10^9, and you want to check one by one to see if t has its subsequence. In this scenario, how would you change your code?
 ::::
@@ -59,7 +62,3 @@ class Solution:

        return i == len(s)
 ```
-
-## Explanation
-
-<YouTube id="99RVfqklbCE" title="Is Subsequence - Leetcode 392" />
@@ -2,13 +2,16 @@
 title: '977. Squares of a Sorted Array'
 description: Given an integer array nums sorted in non-decreasing order, return an array of the squares of each number sorted in non-decreasing order
 icon: dot
+topics:
+  - { name: "Array", slug: "array" }
+  - { name: "Two Pointers", slug: "two-pointers" }
+  - { name: "Sorting", slug: "sorting" }
+video: "FPCZsG_AkUg"
 sidebar:
  label: 'Squares of a Sorted Array'
  badge: 'Easy'
 ---

-<Badge variant="accent">Array</Badge>
-
 ::::warning
 Squaring each element and sorting the new array is very trivial, could you find an O(n) solution using a different approach?
 ::::
@@ -69,7 +72,3 @@ var sortedSquares = function(nums) {
  return ans;
 };
 ```
-
-## Explanation
-
-<YouTube id="FPCZsG_AkUg" title="Squares of a Sorted Array - Leetcode 977 - Python" />