<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/">
  <channel>
    <title>K5kC | Code &amp; More</title>
    <link>https://k5kc.com/</link>
    <description>Recent content on K5kC | Code &amp; More</description>
    <generator>Next.js</generator>
    <language>en-us</language>
    <lastBuildDate>Sat, 07 Feb 2026 20:14:04 GMT</lastBuildDate>
    <atom:link href="https://k5kc.com/index.xml" rel="self" type="application/rss+xml"/>
    <item>
      <title>Course Schedule 1 - Is it Possible</title>
      <link>https://k5kc.com/cs/problems/course-schedule-1-is-it-possible</link>
      <guid>https://k5kc.com/cs/problems/course-schedule-1-is-it-possible</guid>
      <pubDate>Sat, 07 Feb 2026 13:43:00 GMT</pubDate>
      <description>
## Problem

There are a total of `numCourses` courses you have to take, labeled from `0` to `numCourses - 1`. You are given an array `prerequisites` where `prerequisites[i] = [ai, bi]` indicates that</description>
    </item>
    <item>
      <title>Clone Undirected Graph</title>
      <link>https://k5kc.com/cs/problems/clone-undirected-graph</link>
      <guid>https://k5kc.com/cs/problems/clone-undirected-graph</guid>
      <pubDate>Sat, 07 Feb 2026 13:33:00 GMT</pubDate>
      <description>
## Problem

Given a reference of a node in a **[connected](https://en.wikipedia.org/wiki/Connectivity_(graph_theory)#Connected_graph)** undirected graph.

Return a [**deep copy**](https://en.wikipedi</description>
    </item>
    <item>
      <title>Valid Parentheses</title>
      <link>https://k5kc.com/cs/problems/valid-parentheses</link>
      <guid>https://k5kc.com/cs/problems/valid-parentheses</guid>
      <pubDate>Sat, 07 Feb 2026 07:31:00 GMT</pubDate>
      <description>
## Problem

Given a string `s` containing just the characters `&apos;(&apos;`, `&apos;)&apos;`, `&apos;{&apos;`, `&apos;}&apos;`, `&apos;[&apos;` and `&apos;]&apos;`, determine if the input string is valid.

An input string is valid if:

1. Open brackets must</description>
    </item>
    <item>
      <title>Alien Dictionary</title>
      <link>https://k5kc.com/cs/problems/alien-dictionary</link>
      <guid>https://k5kc.com/cs/problems/alien-dictionary</guid>
      <pubDate>Sun, 01 Feb 2026 22:15:00 GMT</pubDate>
      <description>
## Problem

**Gist:**
Given a sorted dictionary (array of words) of an alien language, find order of characters in the language.

**Detailed:**
There is a new alien language which uses the latin alph</description>
    </item>
    <item>
      <title>Pacific Atlantic Water Flow</title>
      <link>https://k5kc.com/cs/problems/pacific-atlantic-water-flow</link>
      <guid>https://k5kc.com/cs/problems/pacific-atlantic-water-flow</guid>
      <pubDate>Mon, 19 Jan 2026 00:48:00 GMT</pubDate>
      <description>
## Problem

There is an `m x n` rectangular island that borders both the **Pacific Ocean** and **Atlantic Ocean**. The **Pacific Ocean** touches the island&apos;s left and top edges, and the **Atlantic Oc</description>
    </item>
    <item>
      <title>Graph Valid Tree</title>
      <link>https://k5kc.com/cs/problems/graph-valid-tree</link>
      <guid>https://k5kc.com/cs/problems/graph-valid-tree</guid>
      <pubDate>Sat, 10 Jan 2026 06:52:00 GMT</pubDate>
      <description>
## Problem

Given `n` nodes labeled from `0` to `n-1` and a list of undirected edges (each edge is a pair of nodes), write a function to check whether these edges make up a valid tree.

### Examples
</description>
    </item>
    <item>
      <title>Happy Number</title>
      <link>https://k5kc.com/cs/problems/happy-number</link>
      <guid>https://k5kc.com/cs/problems/happy-number</guid>
      <pubDate>Mon, 05 Jan 2026 00:32:00 GMT</pubDate>
      <description>
## Problem

Write an algorithm to determine if a number is &quot;happy&quot;.

### Definition

A **happy number** is a number defined by the following process:

- Starting with any positive integer, replace th</description>
    </item>
    <item>
      <title>Open the Lock</title>
      <link>https://k5kc.com/cs/problems/open-the-lock</link>
      <guid>https://k5kc.com/cs/problems/open-the-lock</guid>
      <pubDate>Mon, 05 Jan 2026 00:28:00 GMT</pubDate>
      <description>
## Problem

You have a lock in front of you with 4 circular wheels. Each wheel has 10 slots: `&apos;0&apos;, &apos;1&apos;, &apos;2&apos;, &apos;3&apos;, &apos;4&apos;, &apos;5&apos;, &apos;6&apos;, &apos;7&apos;, &apos;8&apos;, &apos;9&apos;`. The wheels can rotate freely and wrap around: for exam</description>
    </item>
    <item>
      <title>Seat Reservation Manager</title>
      <link>https://k5kc.com/cs/problems/seat-reservation-manager</link>
      <guid>https://k5kc.com/cs/problems/seat-reservation-manager</guid>
      <pubDate>Mon, 05 Jan 2026 00:24:00 GMT</pubDate>
      <description>
## Problem

Design a system that manages the reservation state of `n` seats that are numbered from `1` to `n`.

Implement the `SeatManager` class:

- `SeatManager(int n)` Initializes a `SeatManager` </description>
    </item>
    <item>
      <title>Convert Sorted Array to height-balanced Binary Search Tree</title>
      <link>https://k5kc.com/cs/problems/convert-sorted-array-to-height-balanced-binary-search-tree</link>
      <guid>https://k5kc.com/cs/problems/convert-sorted-array-to-height-balanced-binary-search-tree</guid>
      <pubDate>Mon, 05 Jan 2026 00:22:00 GMT</pubDate>
      <description>
## Problem

Given an integer array `nums` where the elements are sorted in **ascending order**, convert _it to a **height-balanced** binary search tree_.

### Examples

**Example 1:**

```d
Input: nu</description>
    </item>
    <item>
      <title>Palindrome Linked List</title>
      <link>https://k5kc.com/cs/problems/palindrome-linked-list</link>
      <guid>https://k5kc.com/cs/problems/palindrome-linked-list</guid>
      <pubDate>Mon, 05 Jan 2026 00:16:00 GMT</pubDate>
      <description>
## Problem

Given the `head` of a singly linked list, return `true` if it is a [palindrome]({{&lt; relref &quot;/gk/algorithms/palindrome-definition.md&quot; &gt;}}) _or_ `false` otherwise.

### Examples

**Example </description>
    </item>
    <item>
      <title>Remove Linked List Elements</title>
      <link>https://k5kc.com/cs/problems/remove-linked-list-elements</link>
      <guid>https://k5kc.com/cs/problems/remove-linked-list-elements</guid>
      <pubDate>Mon, 05 Jan 2026 00:16:00 GMT</pubDate>
      <description>
## Problem

Remove all elements from a linked list of integers that have value val.

### Examples

**Example 1:**

```d
Given: 1 --&gt; 2 --&gt; 6 --&gt; 3 --&gt; 4 --&gt; 5 --&gt; 6, val = 6
Return: 1 --&gt; 2 --&gt; 3 --&gt;</description>
    </item>
    <item>
      <title>Capacity To Ship Packages Within D Days</title>
      <link>https://k5kc.com/cs/problems/capacity-to-ship-packages-within-d-days</link>
      <guid>https://k5kc.com/cs/problems/capacity-to-ship-packages-within-d-days</guid>
      <pubDate>Mon, 05 Jan 2026 00:13:00 GMT</pubDate>
      <description>
## Problem

A conveyor belt has packages that must be shipped from one port to another within `days` days.

The `ith` package on the conveyor belt has a weight of `weights[i]`. Each day, we load the </description>
    </item>
    <item>
      <title>Single Element in a Sorted Array</title>
      <link>https://k5kc.com/cs/problems/single-element-in-a-sorted-array</link>
      <guid>https://k5kc.com/cs/problems/single-element-in-a-sorted-array</guid>
      <pubDate>Mon, 05 Jan 2026 00:13:00 GMT</pubDate>
      <description>
## Problem

You are given a sorted array consisting of only integers where every element appears exactly twice, except for one element which appears exactly once.

Return _the single element that app</description>
    </item>
    <item>
      <title>Asteroid Collision</title>
      <link>https://k5kc.com/cs/problems/asteroid-collision</link>
      <guid>https://k5kc.com/cs/problems/asteroid-collision</guid>
      <pubDate>Mon, 05 Jan 2026 00:11:00 GMT</pubDate>
      <description>
## Problem

We are given an array `asteroids` of integers representing asteroids in a row.

For each asteroid, the absolute value represents its size, and the sign represents its direction (positive </description>
    </item>
    <item>
      <title>Binary Tree Level Order Traversal</title>
      <link>https://k5kc.com/cs/problems/binary-tree-level-order-traversal</link>
      <guid>https://k5kc.com/cs/problems/binary-tree-level-order-traversal</guid>
      <pubDate>Sun, 04 Jan 2026 21:53:00 GMT</pubDate>
      <description>
## Problem

Given a binary tree, return the level order traversal of its nodes&apos; values. (ie, from left to right, level by level).

### Examples

**Example 1:**

```mermaid
graph TD;
    3 --&gt; 9 &amp; 20
</description>
    </item>
    <item>
      <title>Implement Trie</title>
      <link>https://k5kc.com/cs/problems/implement-trie</link>
      <guid>https://k5kc.com/cs/problems/implement-trie</guid>
      <pubDate>Sun, 04 Jan 2026 21:23:00 GMT</pubDate>
      <description>
## Problem

A [**trie**](https://en.wikipedia.org/wiki/Trie) (pronounced as &quot;try&quot;) or **prefix tree** is a tree data structure used to efficiently store and retrieve keys in a dataset of strings. The</description>
    </item>
    <item>
      <title>Detect Squares</title>
      <link>https://k5kc.com/cs/problems/detect-squares</link>
      <guid>https://k5kc.com/cs/problems/detect-squares</guid>
      <pubDate>Sun, 04 Jan 2026 21:15:00 GMT</pubDate>
      <description>
## Problem

You are given a stream of points on the X-Y plane. Design an algorithm that:

- **Adds** new points from the stream into a data structure. **Duplicate** points are allowed and should be t</description>
    </item>
    <item>
      <title>Multiply Strings</title>
      <link>https://k5kc.com/cs/problems/multiply-strings</link>
      <guid>https://k5kc.com/cs/problems/multiply-strings</guid>
      <pubDate>Sun, 04 Jan 2026 21:15:00 GMT</pubDate>
      <description>
## Problem

Given two non-negative integers `num1` and `num2` represented as strings, return the product of `num1` and `num2`, also represented as a string.

**Note:** You must not use any built-in B</description>
    </item>
    <item>
      <title>Roman To Integer</title>
      <link>https://k5kc.com/cs/problems/roman-to-integer</link>
      <guid>https://k5kc.com/cs/problems/roman-to-integer</guid>
      <pubDate>Sun, 04 Jan 2026 21:15:00 GMT</pubDate>
      <description>
## Problem

[Roman numerals]({{&lt; relref &quot;roman-numerals.md&quot; &gt;}})

Given a roman numeral, convert it to an integer.

Input is guaranteed to be within the range from 1 to 3999.

### Examples

**Example</description>
    </item>
    <item>
      <title>Implement Power Function 1</title>
      <link>https://k5kc.com/cs/problems/implement-power-function-1</link>
      <guid>https://k5kc.com/cs/problems/implement-power-function-1</guid>
      <pubDate>Sun, 04 Jan 2026 21:14:00 GMT</pubDate>
      <description>
## Problem

Implement [pow(x, n)](http://www.cplusplus.com/reference/valarray/pow/), which calculates `x` raised to the power `n` (i.e., `x^n`).

### Examples

**Example 1:**

```d
Input: x = 2.00000</description>
    </item>
    <item>
      <title>Plus One 1 - Given number as array plus one</title>
      <link>https://k5kc.com/cs/problems/plus-one-1-given-number-as-array-plus-one</link>
      <guid>https://k5kc.com/cs/problems/plus-one-1-given-number-as-array-plus-one</guid>
      <pubDate>Sun, 04 Jan 2026 21:14:00 GMT</pubDate>
      <description>
## Problem

Given a non-negative number represented as an array of digits, plus one to the number. The digits are stored such that the most significant digit is at the head of the list.

### Examples</description>
    </item>
    <item>
      <title>Add Binary Strings</title>
      <link>https://k5kc.com/cs/problems/add-binary-strings</link>
      <guid>https://k5kc.com/cs/problems/add-binary-strings</guid>
      <pubDate>Sun, 04 Jan 2026 21:12:00 GMT</pubDate>
      <description>
## Problem

Given two binary strings `a` and `b`, return _their sum as a binary string_.

### Examples

**Example 1:**

```d
Input: a = &quot;11&quot;, b = &quot;1&quot;
Output: &quot;100&quot;
```

**Example 2:**

```d
Input: a </description>
    </item>
    <item>
      <title>Reverse Integer</title>
      <link>https://k5kc.com/cs/problems/reverse-integer</link>
      <guid>https://k5kc.com/cs/problems/reverse-integer</guid>
      <pubDate>Sun, 04 Jan 2026 21:12:00 GMT</pubDate>
      <description>
## Problem

Given a signed 32-bit integer `x`, return `x` _with its digits reversed_. If reversing `x` causes the value to go outside the signed 32-bit integer range `[-2^31, 2^31 - 1]`, then return </description>
    </item>
    <item>
      <title>Summary Ranges</title>
      <link>https://k5kc.com/cs/problems/summary-ranges</link>
      <guid>https://k5kc.com/cs/problems/summary-ranges</guid>
      <pubDate>Sun, 04 Jan 2026 21:10:00 GMT</pubDate>
      <description>
## Problem

You are given a **sorted unique** integer array `nums`.

A **range** `[a,b]` is the set of all integers from `a` to `b` (inclusive).

Return _the **smallest sorted** list of ranges that *</description>
    </item>
    <item>
      <title>Merge Triplets to Form Target Triplet</title>
      <link>https://k5kc.com/cs/problems/merge-triplets-to-form-target-triplet</link>
      <guid>https://k5kc.com/cs/problems/merge-triplets-to-form-target-triplet</guid>
      <pubDate>Sun, 04 Jan 2026 21:09:00 GMT</pubDate>
      <description>
## Problem

A **triplet** is an array of three integers. You are given a 2D integer array `triplets`, where `triplets[i] = [ai, bi, ci]` describes the `ith` **triplet**. You are also given an integer</description>
    </item>
    <item>
      <title>Partition Labels</title>
      <link>https://k5kc.com/cs/problems/partition-labels</link>
      <guid>https://k5kc.com/cs/problems/partition-labels</guid>
      <pubDate>Sun, 04 Jan 2026 21:09:00 GMT</pubDate>
      <description>
## Problem

You are given a string `s`. We want to partition the string into as many parts as possible so that each letter appears in at most one part.

Note that the partition is done so that after </description>
    </item>
    <item>
      <title>Valid Parenthesis String</title>
      <link>https://k5kc.com/cs/problems/valid-parenthesis-string</link>
      <guid>https://k5kc.com/cs/problems/valid-parenthesis-string</guid>
      <pubDate>Sun, 04 Jan 2026 21:09:00 GMT</pubDate>
      <description>
## Problem

Given a string `s` containing only three types of characters: `&apos;(&apos;`, `&apos;)&apos;` and `&apos;*&apos;`, return `true` _if_ `s` _is **valid**_.

The following rules define a **valid** string:

- Any left pa</description>
    </item>
    <item>
      <title>Hand of Straights</title>
      <link>https://k5kc.com/cs/problems/hand-of-straights</link>
      <guid>https://k5kc.com/cs/problems/hand-of-straights</guid>
      <pubDate>Sun, 04 Jan 2026 21:08:00 GMT</pubDate>
      <description>
## Problem

Alice has some number of cards and she wants to rearrange the cards into groups so that each group is of size `groupSize`, and consists of `groupSize` consecutive cards.

Given an integer</description>
    </item>
    <item>
      <title>Jump Game 2 - Get min jumps</title>
      <link>https://k5kc.com/cs/problems/jump-game-2-get-min-jumps</link>
      <guid>https://k5kc.com/cs/problems/jump-game-2-get-min-jumps</guid>
      <pubDate>Sun, 04 Jan 2026 21:08:00 GMT</pubDate>
      <description>
## Problem

Given an array of non-negative integers `nums`, you are initially positioned at the first index of the array.

Each element in the array represents your maximum jump length at that positi</description>
    </item>
    <item>
      <title>Burst Balloons</title>
      <link>https://k5kc.com/cs/problems/burst-balloons</link>
      <guid>https://k5kc.com/cs/problems/burst-balloons</guid>
      <pubDate>Sun, 04 Jan 2026 21:06:00 GMT</pubDate>
      <description>
## Problem

You are given `n` balloons, indexed from `0` to `n - 1`. Each balloon is painted with a number on it represented by an array `nums`. You are asked to burst all the balloons.

If you burst</description>
    </item>
    <item>
      <title>Distinct Subsequences</title>
      <link>https://k5kc.com/cs/problems/distinct-subsequences</link>
      <guid>https://k5kc.com/cs/problems/distinct-subsequences</guid>
      <pubDate>Sun, 04 Jan 2026 21:06:00 GMT</pubDate>
      <description>
## Problem

Given two strings s and t, return _the number of distinct_ **_subsequences_** _of_ s _which equals_ t.

The test cases are generated so that the answer fits on a 32-bit signed integer.

#</description>
    </item>
    <item>
      <title>Regular Expression Matching</title>
      <link>https://k5kc.com/cs/problems/regular-expression-matching</link>
      <guid>https://k5kc.com/cs/problems/regular-expression-matching</guid>
      <pubDate>Sun, 04 Jan 2026 21:06:00 GMT</pubDate>
      <description>
## Problem

Given an input string `s` and a pattern `p`, implement regular expression matching with support for `&apos;.&apos;` and `&apos;*&apos;` where:

- `&apos;.&apos;` Matches any single character.
- `&apos;*&apos;` Matches zero or m</description>
    </item>
    <item>
      <title>Interleaving String</title>
      <link>https://k5kc.com/cs/problems/interleaving-string</link>
      <guid>https://k5kc.com/cs/problems/interleaving-string</guid>
      <pubDate>Sun, 04 Jan 2026 21:05:00 GMT</pubDate>
      <description>
## Problem

Given strings `s1`, `s2`, and `s3`, find whether `s3` is formed by an **interleaving** of `s1` and `s2`.

An **interleaving** of two strings `s` and `t` is a configuration where they are </description>
    </item>
    <item>
      <title>Longest Increasing Path in a Matrix</title>
      <link>https://k5kc.com/cs/problems/longest-increasing-path-in-a-matrix</link>
      <guid>https://k5kc.com/cs/problems/longest-increasing-path-in-a-matrix</guid>
      <pubDate>Sun, 04 Jan 2026 21:05:00 GMT</pubDate>
      <description>
## Problem

Given an `m x n` integers `matrix`, return _the length of the longest increasing path in_ `matrix`.

From each cell, you can either move in four directions: left, right, up, or down. You </description>
    </item>
    <item>
      <title>Target Sum</title>
      <link>https://k5kc.com/cs/problems/target-sum</link>
      <guid>https://k5kc.com/cs/problems/target-sum</guid>
      <pubDate>Sun, 04 Jan 2026 21:05:00 GMT</pubDate>
      <description>
## Problem

You are given an integer array `nums` and an integer `target`.

You want to build an **expression** out of nums by adding one of the symbols `&apos;+&apos;` and `&apos;-&apos;` before each integer in nums an</description>
    </item>
    <item>
      <title>Best Time To Buy And Sell Stock With Cooldown</title>
      <link>https://k5kc.com/cs/problems/best-time-to-buy-and-sell-stock-with-cooldown</link>
      <guid>https://k5kc.com/cs/problems/best-time-to-buy-and-sell-stock-with-cooldown</guid>
      <pubDate>Sun, 04 Jan 2026 21:04:00 GMT</pubDate>
      <description>
## Problem

# Problem Definition

You are given an array `prices` where `prices[i]` is the price of a given stock on the `ith` day.

Find the maximum profit you can achieve. You may complete as many </description>
    </item>
    <item>
      <title>Min Cost Climbing Stairs</title>
      <link>https://k5kc.com/cs/problems/min-cost-climbing-stairs</link>
      <guid>https://k5kc.com/cs/problems/min-cost-climbing-stairs</guid>
      <pubDate>Sun, 04 Jan 2026 21:03:00 GMT</pubDate>
      <description>
## Problem

You are given an integer array `cost` where `cost[i]` is the cost of `ith` step on a staircase. Once you pay the cost, you can either climb one or two steps.

You can either start from th</description>
    </item>
    <item>
      <title>Swim in Rising Water</title>
      <link>https://k5kc.com/cs/problems/swim-in-rising-water</link>
      <guid>https://k5kc.com/cs/problems/swim-in-rising-water</guid>
      <pubDate>Sun, 04 Jan 2026 21:02:00 GMT</pubDate>
      <description>
## Problem

You are given an `n x n` integer matrix `grid` where each value `grid[i][j]` represents the elevation at that point `(i, j)`.

The rain starts to fall. At time `t`, the depth of the water</description>
    </item>
    <item>
      <title>Network Delay Time</title>
      <link>https://k5kc.com/cs/problems/network-delay-time</link>
      <guid>https://k5kc.com/cs/problems/network-delay-time</guid>
      <pubDate>Sun, 04 Jan 2026 21:01:00 GMT</pubDate>
      <description>
## Problem

You are given a network of `n` nodes, labeled from `1` to `n`. You are also given `times`, a list of travel times as directed edges `times[i] = (ui, vi, wi)`, where `ui` is the source nod</description>
    </item>
    <item>
      <title>Min Cost to Connect All Points</title>
      <link>https://k5kc.com/cs/problems/min-cost-to-connect-all-points</link>
      <guid>https://k5kc.com/cs/problems/min-cost-to-connect-all-points</guid>
      <pubDate>Sun, 04 Jan 2026 21:00:00 GMT</pubDate>
      <description>
## Problem

You are given an array `points` representing integer coordinates of some points on a 2D-plane, where `points[i] = [xi, yi]`.

The cost of connecting two points `[xi, yi]` and `[xj, yj]` i</description>
    </item>
    <item>
      <title>Course Schedule 2 - Get Ordered Courses</title>
      <link>https://k5kc.com/cs/problems/course-schedule-2-get-ordered-courses</link>
      <guid>https://k5kc.com/cs/problems/course-schedule-2-get-ordered-courses</guid>
      <pubDate>Sun, 04 Jan 2026 20:57:00 GMT</pubDate>
      <description>
## Problem

There are a total of `numCourses` courses you have to take, labeled from `0` to `numCourses - 1`. You are given an array `prerequisites` where `prerequisites[i] = [ai, bi]` indicates that</description>
    </item>
    <item>
      <title>Rotting Oranges</title>
      <link>https://k5kc.com/cs/problems/rotting-oranges</link>
      <guid>https://k5kc.com/cs/problems/rotting-oranges</guid>
      <pubDate>Sun, 04 Jan 2026 20:56:00 GMT</pubDate>
      <description>
## Problem

You are given an `m x n` `grid` where each cell can have one of three values:

- `0` representing an empty cell,
- `1` representing a fresh orange, or
- `2` representing a rotten orange.
</description>
    </item>
    <item>
      <title>Surrounded Regions</title>
      <link>https://k5kc.com/cs/problems/surrounded-regions</link>
      <guid>https://k5kc.com/cs/problems/surrounded-regions</guid>
      <pubDate>Sun, 04 Jan 2026 20:56:00 GMT</pubDate>
      <description>
## Problem

# Surrounded Regions

Given an `m x n` matrix `board` containing `&apos;X&apos;` and `&apos;O&apos;`, _capture all regions that are 4-directionally surrounded by_ `&apos;X&apos;`.

A region is **captured** by flipping</description>
    </item>
    <item>
      <title>Walls and Gates</title>
      <link>https://k5kc.com/cs/problems/walls-and-gates</link>
      <guid>https://k5kc.com/cs/problems/walls-and-gates</guid>
      <pubDate>Sun, 04 Jan 2026 20:56:00 GMT</pubDate>
      <description>
## Problem

# Problem

You are given an `m x n` grid `rooms` initialized with these three possible values.

- `-1` A wall or an obstacle.
- `0` A gate.
- `INF` Infinity means an empty room. We use th</description>
    </item>
    <item>
      <title>Max Area of Island</title>
      <link>https://k5kc.com/cs/problems/max-area-of-island</link>
      <guid>https://k5kc.com/cs/problems/max-area-of-island</guid>
      <pubDate>Sun, 04 Jan 2026 20:55:00 GMT</pubDate>
      <description>
## Problem

You are given an `m x n` binary matrix `grid`. An island is a group of `1`&apos;s (representing land) connected **4-directionally** (horizontal or vertical.) You may assume all four edges of t</description>
    </item>
    <item>
      <title>Number of Islands</title>
      <link>https://k5kc.com/cs/problems/number-of-islands</link>
      <guid>https://k5kc.com/cs/problems/number-of-islands</guid>
      <pubDate>Sun, 04 Jan 2026 20:55:00 GMT</pubDate>
      <description>
## Problem

Given an `m x n` 2D binary grid `grid` which represents a map of `&apos;1&apos;`s (land) and `&apos;0&apos;`s (water), return _the number of islands_.

An **island** is surrounded by water and is formed by c</description>
    </item>
    <item>
      <title>Letter Combinations of a Phone Number</title>
      <link>https://k5kc.com/cs/problems/letter-combinations-of-a-phone-number</link>
      <guid>https://k5kc.com/cs/problems/letter-combinations-of-a-phone-number</guid>
      <pubDate>Sun, 04 Jan 2026 20:54:00 GMT</pubDate>
      <description>
## Problem

Given a string containing digits from `2-9` inclusive, return all possible letter combinations that the number could represent. Return the answer in **any order**.

A mapping of digit to </description>
    </item>
    <item>
      <title>N-Queens</title>
      <link>https://k5kc.com/cs/problems/n-queens</link>
      <guid>https://k5kc.com/cs/problems/n-queens</guid>
      <pubDate>Sun, 04 Jan 2026 20:54:00 GMT</pubDate>
      <description>
## Problem

The **n-queens** puzzle is the problem of placing `n` queens on an `n x n` chessboard such that no two queens attack each other.

Given an integer `n`, return _all distinct solutions to t</description>
    </item>
    <item>
      <title>Palindrome Partitioning</title>
      <link>https://k5kc.com/cs/problems/palindrome-partitioning</link>
      <guid>https://k5kc.com/cs/problems/palindrome-partitioning</guid>
      <pubDate>Sun, 04 Jan 2026 20:54:00 GMT</pubDate>
      <description>
## Problem

&gt; Given a string `s`, partition `s` such that every substring of the partition is a **palindrome**. Return all possible palindrome partitioning of `s`.

### Definition

[Palindrome Defini</description>
    </item>
  </channel>
</rss>