Problems on Colan Biemer

LeetCode 2

Sun, 21 Jun 2026 09:06:31 -0500

LeetCode 2 asks the user to add two numbers represented as linked lists, where that linked list is reversed.

Example 1:
Input: l1 = 2->4->3, l2 = 5->6->4
Output: 7->0->8

Example one shows why the linked list being reversed is important. 2->4->3 represents 342 NOT 243

Example 2:
Input: l1 = 0, l2 = 0
Output: 0
Example 3:
Input: l1 = 9->9->9->9->9->9->9, l2 = 9->9->9->9
Output: 8->9->9->9->0->0->0->1

This becomes important because if you look at example 3, we have two input numbers of different magnitudes, but because they are reversed, we can add from the start of the list. We’ll do this a little later in the post.

LeetCode 1

Sat, 20 Jun 2026 12:11:03 -0500

As mentioned in the last post, we are going back to the start of the LeetCode problem set, and doing LeetCode 1. The problem is to find two elements in the input array that add up to a target value that is also input. The output, then, is the indices of those two elements:

Example 1:
Input: nums = [2,7,11,15], target = 9
Output: [0,1]
Example 2:
Input: nums = [3,2,4], target = 6
Output: [1,2]
Example 3:
Input: nums = [3,3], target = 6
Output: [0,1]

We are also given several constraints, the most important of which is that there is only one valid answer. Meaning, an input of nums=[1,1,1] and target=2 is impossible because that means there would be multiple valid ouputs: [[0,1], [0,2], [1,2]].

LeetCode 32

Fri, 19 Jun 2026 07:30:25 -0500

We are now on LeetCode 32. It is titled, “Longest Valid Parentheses,” and the problem definition is wonderfully sparse: “Given a string containing just the characters ‘(’ and ‘)’, return the length of the longest valid (well-formed) parentheses substring.”

Example 1:
Input: s = "(()"
Output: 2
Example 2:
Input: s = ")()())"
Output: 4
Example 3:
Input: s = ""
Output: 0

Oh! This problem is listed as… HARD!!!

Solution 1: Single Pass Stack

The worst solution would have been O(n³) where n=len(s), and I was tempted, but I didn’t bother. After doing so many leetcode problems—as if 15 problems were a lot when I know others have done hundreds, maybe thousands of these hellish things—I decided that I would rather get the problem done quickly. Especially a “hard” problem.

LeetCode 31

Wed, 17 Jun 2026 06:30:45 -0500

Problem 31 is medium difficulty. The title is “Next Permutation,” which partially relates to yesterday’s problem where I tried to use permutations, but the goal is different. To see, let’s look at the examples that LeetCode gave:

Example 1:
Input: nums = [1,2,3]
Output: [1,3,2]
Example 2:
Input: nums = [3,2,1]
Output: [1,2,3]
Example 3:
Input: nums = [1,1,5]
Output: [1,5,1]

The goal, as the problem’s title suggest, is to generate the next permutation. Not just any permutation, though. That would be too easy. They want the “next” one, and they defined next by, “The next permutation of an array of integers is the next lexicographically greater permutation of its integer.”

LeetCode 30

Tue, 16 Jun 2026 09:24:41 -0500

We are finally back to a HARD problem with LeetCode 30. As input, we get one string and one array of strings. The expected output is an array of indices.

Example 1:
Input: s = "barfoothefoobarman", words = ["foo","bar"]
Output: [0,9]
Example 2:
Input: s = "wordgoodgoodgoodbestword", words = ["word","good","best","word"]
Output: []
Example 3:
Input: s = "barfoofoobarthefoobarman", words = ["bar","foo","the"]
Output: [6,9,12]

The output array is expected to have indices into s. Looking at Example 1, there are two indices: 0 and 9:

LeetCode 29

Mon, 15 Jun 2026 09:22:12 -0500

LeetCode 29 asks for you to implement integer division without using division, mod, or multiplication. Naturally, the first thing I did was use division.

func divide(dividend int, divisor int) int {
 return dividend / divisor
}

This, though, failed!

input: -2147483648 / -1
Output: 2147483648
Expected Output: 2147483647

That led me to the conclusion that this is silly and a waste of time.¹ So I didn’t bother with the bit manipulation solutions I know are out there. Instead, I made a quick fix for division to make Go’s division of integers fit what LeetCode wanted.

LeetCode 28

Sun, 14 Jun 2026 07:58:24 -0500

LeetCode 28 is another very easy problem. You are given two strings, and you have to see if the second string exists in the first string. If so, return the index of the start of that string. If it can’t be found, return -1.

Solution 1: `strings.Index`

This kind of problem is so common in programming, that the majority of standard libraries include it. In C, you can use strstr. In Go, you can use strings.Index().

LeetCode 27

Sat, 13 Jun 2026 09:59:33 -0500

LeetCode 27 is, like the last problem, an easy problem. The problem itself is to remove elements from an array that equal v. Here is an example:

Input: nums = [1,2,3,1,2], val = 1
Output: nums = [2,3,2,_,_], size = 3

If you read the post for problem 26, then I think you’ll know the solution.

func removeElement(nums []int, val int) int {
 write_index := 0

 for _, v := range nums {
 if val != v {
 nums[write_index] = v
 write_index++
 }
 }

 return write_index
}

write_index tracks where the next kept element goes, so each value that isn’t val gets compacted toward the front while everything else is skipped. If the code doesn’t make sense, then I recommend that you read the last post.

LeetCode 26

Fri, 12 Jun 2026 09:24:02 -0500

Problem 26 lives up to its label: easy. You are given a sorted array, and you have to remove duplicates from it. It also asks that you include the number of unique elements in the array. Here are some samples.

Input: [1,1,2]
Output: 2, nums = [1,2,_]

The first solution I came up with was to find duplicates and remove them from the array:

func removeDuplicates(nums []int) int {
 for i := 0; i < len(nums) - 1; i++ {
 j := i + 1

 if nums[i] == nums[j] {
 j++
 for ; j < len(nums) && nums[i] == nums[j]; j++ { }

 nums = slices.Delete(nums, i+1,j)
 }
 }

 return len(nums)
}

This, though, is O(n²). The reason why is not the two for loops, it is the slices.Delete, which will shift all the elements from the right over to the left. We can avoid this cost and get the solution down to just O(n) by not shifting.

LeetCode 25

Thu, 11 Jun 2026 09:15:19 -0500

Welcome back. We are going to be solving a dreaded HARD problem. Specifically, we are going to do problem 25. What I like about it is that it directly builds on problem 24, the problem I solved yesterday. As a reminder, problem 24 asked you to swap nodes in pairs. This problem is the same idea, except instead of pairs, we have to swap k nodes. Meaning, problem 24 was a specific instance of this problem where k=2. To help, here are two examples:

LeetCode 24

Wed, 10 Jun 2026 09:25:33 -0500

LeetCode 24 is a problem where you have to swap pairs of nodes in a linked list. I think the examples are more informative than the text, so here are the examples but I did modify them to use linked list notation:

Example 1:
Input: 1 -> 2 -> 3 -> 4
Output: 2 -> 1 -> 4 -> 3
Example 2:
Input: nil
Output: nil
Example 3:
Input: 1
Output: 1
Example 4:
Input: 1 -> 2 -> 3
Output: 2 -> 1 -> 3

This post will be shorter than the others in the series. Despite being listed as medium difficulty, there wasn’t anything that I found interesting.

LeetCode 23

Tue, 09 Jun 2026 10:46:22 -0500

LeetCode 23 is the first problem in the series that covers a HARD problem. Should be challenging, right? Well, let’s see.

To start, I need to define the problem. You get a list of linked lists that are sorted. You have to merge them all into one big linked list, that is also sorted. That’s it.

Solution 1: Screw Linked Lists

I don’t have anything against linked lists. They’re cool. However, sorting an array is a solved problem. So, if everything was in just one big slice, then we’d be done.

LeetCode 22

Mon, 08 Jun 2026 10:10:27 -0500

Welcome back. This time we are going to work on problem 22. The idea is simple. We need to generate every possible valid string of open and closed parenthesis for an integer n. The example they give is for n=1 and n=3:

Input: n = 1
Output: ["()"]
Input: n = 3
Output: ["((()))","(()())","(())()","()(())","()()()"]

Failed Attempt

func generateParenthesis(n int) []string {
 var strings []string
 switch n {
 case 0:
 // do nothing
 case 1:
 strings = append(strings, "()")
 default:
 old_strings := generateParenthesis(n - 1)
 for _, o := range old_strings {
 strings = append(strings, "()" + o)
 strings = append(strings, "(" + o + ")")
 }
 }
 return strings
}

This was my first solution, but it failed. The reason why can be shown with n=3, where it can’t generate the string “(())()”. This may lead you to think that you should add one more line in the for loop: strings = append(strings, o + "()"). This, though, will cause duplicate strings, which breaks the rules. So, after that we could go the de-duplication route like we did for #18, but I’d rather not. So, let’s abandon this solution and go to the smarter approach.

LeetCode 21

Sun, 07 Jun 2026 09:41:05 -0500

Unfortunately, LeetCode 21 had no interesting wrinkles to explore.

func mergeTwoLists(list1 *ListNode, list2 *ListNode) *ListNode {
 if list1 == nil {
 return list2
 } else if list2 == nil {
 return list1
 }

 var head *ListNode
 if list1.Val <= list2.Val {
 head = list1
 list1 = list1.Next
 } else {
 head = list2
 list2 = list2.Next
 }

 cur := head

 for list1 != nil && list2 != nil {
 if list1.Val <= list2.Val {
 cur.Next = list1
 list1 = list1.Next
 } else {
 cur.Next = list2
 list2 = list2.Next
 }

 cur = cur.Next
 }

 if list1 == nil {
 cur.Next = list2
 } else if list2 == nil {
 cur.Next = list1
 }

 return head
}

There is one way to reduce the amount of code, which is to create a dummy variable like so:

LeetCode 20

Sat, 06 Jun 2026 12:00:54 -0500

LeetCode 20 gives you a string made up of the six bracket characters ()[]{} and asks whether they are properly matched and nested. “Properly” means every opener has a corresponding closer of the same type, and they close in the right order. So ()[]{} is valid, ([]) is valid, but ([)] is not.

Anywho, I’ll start with a dumb implementation for fun and then move on to the better but less exciting version.

LeetCode 19

Fri, 05 Jun 2026 09:37:33 -0500

LeetCode 19 asks the solver to remove a node from a linked list. It does have a trick, though. Rather than the typical “remove the nth element” it gives you an index based on the end of the list, “remove the nth element from the end of the list.”

That framing is the whole problem. In a singly linked list you can only move forward, so “nth from the end” isn’t something you can read off directly the way you would in an array. Every solution below is really just a different way of figuring out which node sits before the one you want to drop, since removing a node means pointing its predecessor’s Next past it.

LeetCode 18

Thu, 04 Jun 2026 08:00:41 -0400

LeetCode 18, 4Sum asks for every unique quadruplet [a, b, c, d] in an array nums that sums to a target. For example, given nums = [1, 0, -1, 0, -2, 2] and target = 0, the answer is [[-2, -1, 1, 2], [-2, 0, 0, 2], [-1, 0, 0, 1]]. The word unique is the whole game here. It is easy to find quadruplets that sum to the target; it is annoying to make sure you never report the same one twice.

LeetCode 17

Wed, 03 Jun 2026 08:49:11 +0000

From Array Confusion to a Mixed-Radix Decoder: Solving LeetCode 17 in Go

LeetCode 17, Letter Combinations of a Phone Number is simple: given a string of digits like "23", return every combination of letters those digits could spell on an old phone keypad. For example, 2 maps to ['a', 'b', 'c'] and if given the input 22, we would expect the output: ["aa", "ab", "ac", "ba", "bb", "bc", "ca", "cb", "cc"].