tyler yang

LC 2126: Destroying Asteroids

Sat, 30 May 2026 00:00:00 +0000

Lowkey trivial. Solved it in 1 minute. It’s just a clean heuristic problem, kinda like May 22nd’s Daily Problem, LC 1665: Minimum Initial Energy to Finish Tasks except the heuristic is even easier to see.

My Solution:

class Solution:
 def asteroidsDestroyed(self, mass: int, asteroids: List[int]) -> bool:
 asteroids.sort() # sort lo to hi
 # heuristic: collide with the smallest asteroids first,
 # accumulate mass, 
 # and just keep goin.

 curr = mass
 for a in asteroids:
 if curr >= a:
 curr += a
 continue

 return False
 return True

LC 1752 (and 4)

Fri, 22 May 2026 00:00:00 +0000

The Daily (Easy): `1752. Check if Array Is Sorted and Rotated`

Here is my solution:

class Solution:
 def check(self, nums: List[int]) -> bool:
 n = len(nums)
 diffs = [(nums[i] - nums[i-1]) < 0 for i in range(n)]
 # print(sum(diffs))

 return sum(diffs) == 1 or sum(diffs) == 0

in essence, you just make sure there’s only one inflection point (where the next item is greater than the prev, i.e., breaks monotonically increasing order), or there are no inflection points, i.e., all items are the same.

A greater challenge: `4. Median of Two Sorted Arrays`

At first I thought this was kinda like 210 where we maintain a max heap of all items less than median and min heap of all items greater than current median. But then the TC is $O((m + n) \log (m + n))$ which would just be the same as sorting and then taking the (m + n) // 2th element.

LC 153 and 154: Find Minimum in Rotated Sorted Array (II)

Fri, 15 May 2026 00:00:00 +0000

At first, this problem seems trivial. Returning min(nums) gives you the right answer, but this is $O(n)$ TC. Some people in the solutions were talking about the solution being $\Omega(n)$ runtime, arguing you must check every single element to find the minimum. But that doesn’t quite use the sorted rotation part of the question… so that’s fishy!

My Initial Solution, Before I read the Comments

Linear search for the pivot point of the rotation. Break early, but still worst case $O(n)$.

LC 2784: Check if Array is Good

Wed, 13 May 2026 00:00:00 +0000

This was lwk easy asf I lwk misread at first and thought it was just a permutation of 1 to n but turns out there’s two ns required so it was a little more complicated.

Phone Shortcuts and Automations

Wed, 13 May 2026 00:00:00 +0000

I’ve recently deleted YouTube and Instagram, and now only use them on my computer. As a result I have been picking up my phone and then doing nothing a lot more, so I figure I’d try to automate away as many things as I can to reduce the number of things I need to do on my phone.

I categorize these automations and shortcuts into three types:

Settings, i.e., things you can do in the Settings app in iOS 26
App Automatic Notifications, i.e., things that apps let you do
Shortcuts/Automations, i.e., things in the Shortcuts app.

The productivity apps that I use (and follow) are:

Initial Brainstorm

Tue, 12 May 2026 00:00:00 +0000

Using Google Gemini to feel out the scope of the project

LC 1665: Minimum Initial Energy to Finish Tasks

Tue, 12 May 2026 00:00:00 +0000

Daily Problem for May 11th, 2026

My Notes (Unedited)

class Solution:
 # initial thoughts: this seems like DP....
 # probably bottom-up though right? Idk let's see
 #
 # base case is if there's one task, the min amount of energy is the minimum
 #
 # so let's define the subproblem in terms of index i,
 # where the value is the minimum amount of energy to finish up to and including task i
 #
 # i = 0: then it's just minimum[i]
 # i = 1: it's min of
 # do 0 then 1, so we start with minimum[0], use up actual[0]
 # and now we need minimum[1], so it's minimum[1] - (minimum[0] - actual[0])
 # or we could do 1 and then 0, minimum[0] - (minimum[1] - actual[1])
 # i = 2: we have the results of the first two, so it's analogous?
 # do 2, then 0 and 1, or,
 # do 0 and 1, then 2.
 # the subproblem result is the minimum for [0,1], the actual is just the sum of actual[0] and actual[1].
 # there are n! permutations of tasks, need to reduce this search space


 # dp = [float('inf') for i in range(n)]
 # for i in range(n):
 # if i == 0:
 # dp[i] = minimum[0]

 # else:
 # # do [0...i-1], then i

 # # do i, then [0...i-1]

 # # issue, what if i is somewhere in the middle? This doesn't cover all possibilities.

 # # okay so what if we do graph search?
 # # we consider all possible nodes
 # # each node contains task index i and amount of energy
 # # cost to travel an edge is actual[i]
 # # edges only exist based on minimum[i]
 # # yeah this will do it surely.

 # ok so graph search idea
 # task i can go to all other tasks j if
 # the node has enough energy

 # the max amount of energy necessary is bounded by the sum of all minimum[i]
 # let's say we start there
 # we do a APSP using Floyd Warshall
 # find the min weight SP? but this is more like a spanning tree since we must hit every task
 #
 # I think it's MST but the edges are weighted by the additional energy necessary.
 # it's a directed graph, the logic above (pasted here)
 # do 0 then 1, so we start with minimum[0], use up actual[0]
 # and now we need minimum[1], so it's minimum[1] - (minimum[0] - actual[0])
 # or we could do 1 and then 0, minimum[0] - (minimum[1] - actual[1])
 # is sorta repeatable - we can travel from 0 to 1, or 1 to 0. The cost from 0 to 1 is
 # minimum[1] - (minimum[0] - actual[0]), and it's assumed you have minimum[0] to start.
 # Then we just do a minimum spanning tree? But the issue is the edges are directed so it's a little more annoying.
 # the edges being directed and having to hit all vertices implies some sort of priority first search maybe?
 #
 # it's so hard to figure out what the graph should be, maybe it is DP after all?
 # and my subproblems just suck?
 # I guess technically there are 0 to i-1 solved before,
 # so there are i places to insert task[i],
 # but the number of subproblems blow up in terms of subsets.
 #
 # i guess it might be sort of resembling coin change?
 # it could be a binary search DP. We know the maximum answer is the sum of the minimums[0...n]
 # so we can start at halfway, if that's possible we guess down, otherwise we guess up?
 # but that's log n DPs... that probably sucks ass.
 #

 def minimumEffort(self, tasks: List[List[int]]) -> int:
 n = len(tasks)
 actual = []
 minimum = []
 for i in range(n):
 actual.append(tasks[i][0])
 minimum.append(tasks[i][1])

It could be doable to store states where the states contain the ones completed thus far, but then just this bitset is 2^n possible outcomes, which is surely not in time bounds (so this type of DP is infeasible)

oh shit you can't refill energy, you only start with a bunch. That drastically changes the problem.

Then the answer is lower bounded by the maximum value in the minimum array
and upper bounded by the sum of the actuals

 # bound_1 = sum(actual), need to be able complete all the tasks
 # bound_2 = max(minimum), need to be able to start all the tasks
 # answer lies somewhere in between

take the MST idea from earlier. since we assume taht minimum[i] >= actual[i],
the true cost of a node is (minimum[0] - actual[0]) for the zeroth node,

so the costs are all minimum[i] - actual[i].

oh wait do we just want to do the highest cost nodes first...

is it provable that this attains the minimum solution?
because a [1, 5] node costs more than a [13, 14] node,
but the 14 imposes a stricter requirement?
But anyways we'll need a lot more down the line...
oh shit THAT's where the DP subproblems are?

So the min cost of achieving all the previous is the sum of their minimum[i] - actual[i]?


no because that doesn't tell us where to insert the thing.

if we sum the costs that's naively wrong because in the case of
 [1, 5] and [13, 14] the sum of costs is 4 + 1 = 5, but ig if we added the max actual[i] = 13
 then we'd get 18 which is correct.

so ideally we get the highest cost nodes out of the way earlier,
but we also want to get the highest barrier to entry nodes out of the way earlier too (while we have energy to use)




also patently untrue, because it sometimes may be better to do a higher cost node if its actual[i] is low,
that way we preserve energy. So this somehow still feels like DP...




what if it's sort by cost, tiebreak by putting higher minimums last? but that makes no intuitive sense, you'd want higher minimums to come early on?





continuing the old DP logic
 # i = 0: then it's just minimum[i]
 # i = 1: it's min of
 # do 0 then 1, so we start with minimum[0], use up actual[0]
 # and now we need minimum[1], so it's minimum[1] - (minimum[0] - actual[0])
 # or we could do 1 and then 0, minimum[0] - (minimum[1] - actual[1])
 # i = 2: min of
 # do [0, 1], then 2
 # do 2, then [0, 1]
 # do 0, 2, 1
 # do 1, 2, 0
 #
 # So we reuse the i=1 for the subproblems
 # but then we have to compute new permutations,
 # the number of which is proportional to the number of tasks we've already done.
 #
 #
 # this goes back to the subproblem states being a bitset of length n which gives 2^n states,
 # but maybe the reuse is OK?
 # I mean the issue is there aren't THAT many states right... fib(n) requires n states,
 # it's just that they're reused a lot.
 # but this already has an exponential number of states, and DP work is poly in # of states, so this can't be
 #
 #
 #
 #

For some reason I keep going back to MSTs in my mind.

if we used Kruskal's, we'd sort the edge weights and then try adding one by one

but what would the edges be for this graph so that I can find the MST?


If the n vertices are the n tasks,
the cost of an undirected edge is kinda nonsense...








I'm still thinking about the minimum[0] - actual[0] thing


the cost of a task is that we need to muster up the minimum energy to do it, and then expend the actual energy.

We'd want the high effort tasks first I guess. So we'll sort by cost then by high to low min energy.

Reflection

Yeah I way overthought this problem at first. I guess I was a little traumatized from LC3629, since I missed the quite obvious graph search solution.

Throwing in the Towel

Tue, 12 May 2026 00:00:00 +0000

Ran into a very familiar wall

Second Attempt

Mon, 11 May 2026 00:00:00 +0000

Running into a wall, again

First Attempt

Sat, 09 May 2026 00:00:00 +0000

Running into a wall

Initial Implementation

Fri, 08 May 2026 00:00:00 +0000

Getting Started with the Project

Learning Zig via Ziglings

Fri, 08 May 2026 00:00:00 +0000

Learning a cool programming language

Exigence

Thu, 07 May 2026 00:00:00 +0000

Why did I even want to write this

LC 3629: Minimum Jumps to Reach End via Prime Teleportation

Thu, 07 May 2026 00:00:00 +0000

Daily Problem for May 7th, 2026

Problem Statement

You are given an integer array nums of length n.

You start at index 0, and your goal is to reach index n - 1.

From any index i, you may perform one of the following operations:

Adjacent Step: Jump to index i + 1 or i - 1, if the index is within bounds.
Prime Teleportation: If nums[i] is a prime number p, you may instantly jump to any index j != i such that nums[j] % p == 0.

Return the minimum number of jumps required to reach index n - 1

tyler yang

LC 2126: Destroying Asteroids

My Solution:

LC 1752 (and 4)

The Daily (Easy): 1752. Check if Array Is Sorted and Rotated

A greater challenge: 4. Median of Two Sorted Arrays

LC 153 and 154: Find Minimum in Rotated Sorted Array (II)

My Initial Solution, Before I read the Comments

LC 2784: Check if Array is Good

Phone Shortcuts and Automations

Initial Brainstorm

LC 1665: Minimum Initial Energy to Finish Tasks

My Notes (Unedited)

Reflection

Throwing in the Towel

Second Attempt

First Attempt

Initial Implementation

Learning Zig via Ziglings

Exigence

LC 3629: Minimum Jumps to Reach End via Prime Teleportation

Problem Statement

The Daily (Easy): `1752. Check if Array Is Sorted and Rotated`

A greater challenge: `4. Median of Two Sorted Arrays`