Competitive Programming Logs

I used to have these logs in the GitHub, now moving them over to Obsidian.

TODO: Do 912div2 https://codeforces.com/contest/1903

Practice with this: https://themecp.vercel.app/guide

https://codeforces.com/blog/entry/136704

I think I should have a more systematic thing. Use a table?

Like what colin-galen does with Metacognition

https://www.youtube.com/watch?v=9M5voWYmie4

Look into your process of thinking.

Hard problems that are easy to understand:

https://codeforces.com/contest/2033/problem/F

Easy problems that are super hard for me. Should reattempt to reassess if my thinking process is improved:

1979B (div2), 1000 rated…
2024C 1300 rated, counting number of inversions
1987C
https://codeforces.com/contest/1950/problem/D div4 question FFS
- The reason I fumbled here is because I didn’t really know a fast way to generate all binary numbers. There’s the
2025C 1300, could have been 2 pointers
2033C 1400, a permutations problem that wasn’t obvious to me
- Actually had something pretty close to optimal solution, however the order in which I did it was wrong
- Have more intuition on the ordering! But I don’t understand how this is different

for (int l = n / 2 - 1; l >= 0; l--) {
    int r = n - 1 - l;
    if ((a[l] == a[l + 1] || a[r] == a[r - 1])) {
        swap(a[l], a[r]);
    }
}

for (int l = 0; l < n/2; l++) {
    int r = n - 1 - l;
    if ((a[l] == a[l + 1] || a[r] == a[r - 1])) {
        swap(a[l], a[r]);
    }
}

Like that doesn’t produce the correct answer.

This is because, because your comparisons are based on a[l+1] and a[r-1]. However, if those values don’t stay fixed (Which it won’t if you go for l from 0 to n/2 -1), then your solution cannot produce a correct answer. Whereas fro n/2, your checks for l+1, those values are final, since that is the ordering of your l.

Weaknesses:

Overassuming that greedy works, and not seeing when it doesn’t work
- Because you might be missing out on greater gains → like this one https://codeforces.com/contest/2047/problem/C
Sliding window problems:
- Fumbled this during a contest https://leetcode.com/problems/count-substrings-that-can-be-rearranged-to-contain-a-string-i/description/
- Almost couldn’t solve this interval question https://codeforces.com/contest/2014/problem/D

Need to practice more Tree questions.

Things that work for me

Write down the thinking process in comments since you hate pen and paper, helps step through the problem

USE your iPad, actually really helps

For hard problems, it’s oftentimes

I actually get stuck on so many problem Cs, it’s so sad. If I can solve problem Cs, I will unlock a lot of potential.

You gotta finish these:

Problem	Difficulty	Status	Analysis	Metacognition	Takeaways
2040D	?		Could understand the problem, but actually had no idea about the working solution.
2040C	?	TODO	Couldn’t do this at the contest, but seems like 2k+ people were able to do it.
2050E			Got a little confused on the indexing.
2050F		TODO	I knew pretty fast that this was a segment tree problem. However, I never actually did many segment tree problems
2021B	1200	DONE	WTF, I’m so stupid. Couldn’t solve it. Had the right idea with a priority queue, but even that TLEd because you don’t have a guarantee of O(n). The map as well didn’t well	Use the frequency array. Never underestimate frequency arrays.
2047D
2047C		DONE	Really wasn’t hard. But I semi-brainfarted in terms of greedy intuition. I was like, why is there n = 5000, I have an O(n) solution, this can’t be right…	Had the intuition super fast. But then, I couldn’t figure out why greedily taking the column with the largest sum doesn’t work.	You cannot assume the following: If a + b > c + d, then a+b+ max(c,d) > c + d + max(a,b). This is NOT TRUE. Consider a = 19, b =2, c = 10, d = 10 31 > 39 is NOT TRUE.
2042C	?		Came up with idea to binary search k. But there’s a smarter solution of sorting the suffixes!!	I thought binary search, and then you always greedily choose the first few intervals. But that didn’t work.	There’s a similar problem 1903C.
1948D	1700	TO FINISH	Easily saw the O(n^3) solution, but could not figure out a faster solution in O(n^2). Cost me 2 hours of sleep.	There’s a way to do it in O(n^2).
1968E	1600	DONE	Honestly should have been able to do this one without looking at editorial. The key idea of splitting even numbers and odd numbers went over my head. I should know this better.	Was good drawing it and trying to visualize a solution. Intuition was good, drawing the diagonal. And then just switching the 2 numbers.
1968F	1800	TO FINISH	It’s an XOR problem.
1925C	1500	DONE	Easy! yay I don’t think i was supposed to get it that easily?? I literally got it in 1 minute
1925D	1900		It’s a probability question, which I should have gotten faster!! I can do this definitely.
1934B	1200	DONE	For some reason, I fumbled this. Maybe it was because I did it pretty late at night.	Essentially, should have reasoned more about the coins, and checked the cases. I missed the idea that each coin except for 15 can only be used at most 1-2 times.	Think harder.
1934C	1700	DONE	Pretty happy that I got the initial idea correctly with those 4 queries. I did struggle for the cases of computing the top right, I was thinking of binary searching that number, but you can just derive it analytically through math.		Be faster next time!!
1969C	1700		Damn, harder problem than I thought it was. I thought a greedy approach would work.
2025C	1300		Like i got a solution, but there were simpler ideas: 1. Binary searching for first value where there’s a “jump” 2. Using 2 pointers where you move index i and j	Get more comfortable with 2 pointer implementations. practice again
1966A	800	DONE	For some reason, really struggled with the logic here. I ended up using a priority queue. However, I think it can be brute forced because the input is so small.
1966C	1400		Found this problem to be quite hard, even though it was 1400 rated.
1934C	1700	TODO
2026C	1500			Made a silly mistake because a value of 0 with type size_t -1 becomes a super large number, and then accessing an array results in an incorrect value.

Problem	Difficulty	Status	Metacognition	Takeaways	Analysis
1990C	1500	DONE	Really panicked and was afraid of not being able to come up with a solution. Take the time to write out the problem, and the steps to solve it.	Try to figure out patterns and insights, in this case after an iteration or two, the numbers stabilize to always be increasing, and you notice that numbers don’t disappear anymore.	I didn’t know how to approach the problem. Made the most STUPID mistake with vectors, and not noticing that I should not `push_back` when I already initialized them with a given size… That was just a huge brain fart. My assumptions are wrong, was put in shambles. In those scenarios, look at every assumption you make and question if it is correct. push_back assumes that the vector is initially empty, but I forgot the factor that i initialized it with `vector<int> v(n)` (size n already). Mistake happened because most of the time, I just initialize it without anything.
1990D	1800	DONE	Thinking was good, just a little slow	Solution is actually not that hard, it’s just making sure that the greedy solution is optimal.	Have trouble coming up with the insight. Made the observation that in most cases, just wipe by rows. I have feeling DP works, but I didn’t have ideas to the solution. Actually, let me think it through more. I got the insight without looking at editorial, which shows that I am capable of solving1800 problems
1988C	1300	DONE	Knew very early on that it was a bitmask problem. Double checked my correctness in my mind, which was great.	I forgot to do `1ll << shift` instead of `1 << shift`, causing negative values to creep up…	Can’t believe I’m struggling on a 1300 problem.
1988D	2000	TODO	Was intimidated because I saw it as a tree question. Didn’t know how to solve it with current toolset, but actually, I did. I just needed to confidence		Don’t know how to prove that my solution is correct, i.e. greedy is good (maybe it isn’t?)
1994C	1600	DONE	Had to read the solution to understand. It’s actually not that hard, but it’s undersatnding and visualizing.	Need to figure out the subproblem correctly through DP.	My implementation was also a bit wrong. Need to read the nuance, because it’s <= and not <. So be aware when it resets.
1995B2	1700	DONE	Had no ideas for the life of me. Read up again on solution, and have a vague idea
1993B			Took me much longer, had 2 failed submissions. Had an idea with the greedy solution of just replacing with the maximum sum. However, that was not optimal. Should have convinced myself that it was optimal first. See that we have at most n +1 replacements, where n is the number of even numbers.		This is just practice, and maybe a bit of bad luck.
1993C			I solved this but didn’t think my solution was optimal.		Could not reason about the number of periods. Yea, somewhere from $0$ to $2 k - 1$ , for some reason I did $0$ to $2 k$ and got the right answer…
1995C	1800		Idea was partially there, but I couldn’t see that you can square in constant time, and that relative powers could be used. However, the idea of using negatives was a nuance that I couldn’t catch. Also, “resetting” to 0
1983B	1200	DONE	Honestly struggled with this one even though it was a 1200. I only thought of 1 pattern for the solution, which was to move outside in to find a solution. I didn’t think of just using the top left corner of the rectangle. I was also “tricked” because the grid can be any size, as the question thought. Next time, need to think through more possibilities.		Fairly trivial question, just need to make the observation.
1983C	1400	DONE	very not bad, had the idea fairly quickly due to it being interval question, maybe also I saw the question type… but I think implementation still needs to be faster, I spend too much time thinking and implementing, and not enough time convincing myself it’s a correct solution
1992D	1700		Wasn’t actually that hard, though my idea might not pass. They essentially find the bounds of the number, I could not reason about that. Not actually that complicated, just needed to be able tot hink it through
1989B			Took way too long for implementation, idea came pretty quickly. Could have gone for a linear time solution. Ideas are all there, try all the numbers, that ends up being the best one.		I just binary search it, and it seems like I can’t exactly binary search it well. Because the increasing decreasing order doesn’t work that well. Also, iterating from -neg to n
1979B	1000		XOR question. could not come up with solution, seems to boil down to algebra. There’s some idea that my brain can’t come up with.
1979D	1600				Idea was off, didn’t make the right observation of it being 1 of 3 choices, I also misread the question.
1999B			Fumbled this question even though it was so easy. I drew out the game tree in my head, but it wasn’t so obvious that the two scenarios are basically the same.Finally figured out by writing out the 4 scenarios. I w
1999C					Also easiest question of my life that I fumbled. I had a if for the last case, because the case is handled differently, when actually, it’s an extra check that I need to do. It’s just a habit that I had, which caused me to overlook it.
1999D	1500		Make the observation about the potential subsequences. How those would look like.
1981B	1300	DONE	ideas were there, just had to push a little to get there.		Came up with solution :)) Failed first attempt due to only checking the first 30 bits, instead of first 31 bits… stupid mistake
1981C	1800	DONE	Idea is also there, but pushing through to something working is hard. Also taking me too long.		Spent like 1.5 hours. Ideas was there pretty quickly, but I could not figure it out. Their solution encodes this as a binary tree. My idea was from a pretty simple observation about the shortest set of sequences to go from a to b.
1981D	2400
1977B	1100	DONE	found it pretty hard to come up with the correct idea, even though the intuition was there. Ultimately got there with observation about 11 = -101
1977C	1900	NOT DONE	Also made observations, but correct idea is just not there for me.	Read the solution and still don’t understand.
1987C	1200	DONE	FAILED SO MANY TIMES… have the idea pretty fast, but implementation is wrong. Yea, I missed the greedy part.		Didn’t realize I can just shave off `a[i]` and then take a max to `a[i+1]`, the recurrence is quite simple, but you gotta make sure you get the idea corrrectly.
1987D	1800	NOT DONE	Really not obvious to me why we can’t just greedily eat the smallest cake and end of story?	This is the Alice and Bob question that I cannot figure out for the life of me. Need to use some kind of DP.	Right because as the opponent, if i eat a cake that apears multiple times, then it’s a waste of energy. Need to eat the unique cakes first.
1986D	1400	DONE	I always come up with the greedy solution and am convinced it works, without proving it. I need to prove it more.		I actually had the correct idea. However, when my implementation doesn’t work, and I can’t figure out why, this is like debugging. And it seems that I really suck at debugging, or figuring out really quick the root issue. CP is really good practice for this. - Figured it out, it’s because I treat 1 and 0s to be the same. But if it’s 0, the answer is actually 0, whereas if it’s 1, it’s a multiplication by 1. Very big difference.
2002C	1200	DONE	Idea was there, good job steven. However, my stupid brain started using double’s… should have kept using long long.
1980C	1300	DONE	This was REALLY easy to me. Instantly got the idea.		I get TLE if I use unordered map here…hash collisions I’m guessing.
1980D	1400	DONE	Really not hard, just have to brute force it. Thinking was correct.
1980E	1600	DONE	I’m either cracked or this was a really easy problem.
1985E	1200	DONE	Really struggling with this one for some reason, looks like the solution might be some sort of brute forcing? Yes, I figured it out, though a little slower than I thought.		Just brute force the different options.
1985F	1500	DONE	Problem is easy to understand, but couldn’t come up with a fast solution instantly.
1985G	1600	DONE	This isn’t that hard too, though it was a little harder to understand. I think I figured out the pattern, but I was slow, and I don’t know how to handle for 10^9 case.		Okay, this is just hard because of the counting rules.
1996D	1500	DONE	Got intimidated by this, but really it’s not that hard.
1984C	1300-1700	DONE	Again, easy problem to understand, but difficult to reason about a correct solution. - The reason it’s hard to solve in my head is due to having difficulty reasoning about the fluctations in the numbers.		The harder problem was also not that bad, but reasoning about it proved a little difficult. Also, need to account for the case that all the numbers are positive, in which case its just 2^n. Else, you need to go over each time the number reaches the minimum sum, as you have the option of taking the absolute value.
1997D	1500	DONE	Solution is actually pretty simple		Got wrong answer due to large values…it’s actually stupid. Needed to add a check for integer overflow
1996E	1600	DONE	Read the question, had only the idea of a prefix array, but could not see a way to do it in linear time. Binary search is at best O(n log n), but how would you even binary search that??
1982B	1200	DONE	Struggling with this problem is actually disappointing, I don’t think I’m taking the time to think.		Think. And be careful with variables getting updated.
1879D	1700	DONE, BUT VERY HARD…	I found this to be a REALLY hard problem. T	he #1 observation I need to make is that in XOR, usually you do bit wise. However, I still don’t understand the solution doesn’t subtract 1 at the end.	ooh the length of the subarray is correct, I don’t need to do 1, because it’s actually the length -1.
1976C	1600	VERY HARD without being shown solution DONE	Found this to also be a little hard, I think problems are a lot easier if you can frame it in the correct way. How could I have framed it again, not knowing the solution? Have the idea that at some point of the process, the recruiter has to choose incompetent. So things will change if we don’t hire someone, and only the first person who is hired incorrectly is changed. Him changing won’t change the rest, since it’s just 1 good spot.	Had to see that we’re essentially left with forced to choose a candiate.	Need to think about it in terms of how the score looks if
2000E	1400	DONE	Am struggling to figure out how to do the summation correctly. Could not figure that idea out.	Yes, this formula: (min(𝑖,𝑛−𝑘)−max(−1,𝑖−𝑘))⋅(min(𝑗,𝑚−𝑘)−max(−1,𝑗−𝑘)) .	I need to get better at deriving that. Need to make the basic observation of (i - (i-k))(j - (j-k). However, we need to cap it, since left and right side. So then you take a min and a max. Actually a hard problem for me.
1974C	1400	DONE	Using the idea of a map of set, as opposed to tuples. And then going over the array and just updating the counts. That’s smart. I did not think about that. How could I have thought about the idea? I was actually very close. Just needed to subtract the count of the current one, and needed to work with tuple. And not use the n (n-1)/2 formula.
2001B			Had the idea pretty quickly, which I was happy with, but I was not able to prove the correctness of the solution on the fly, so I got AC by luck. I guess the insight is that we can control how much carriage returns by swapping the order. However, I did not prove there was a sequence in which they exactly match.		Good observation of seeing the numbers decrease.
2001C	1500	DONE	Essentially a binary search on trees through queries, should have figured it out…
1973B	1300	DONE	Small mistake in setting up the if-else statement.
1973C	1700	DONE	Did this with a little help from the solution. The main observation here that I missed was the idea that we can even indices sum to <= n, and odd indices sum to >= n+1. For even indices, only use the numbers smaller to n/2. And then we use the greater numbers. We just need to be careful about where n is.
1956C	1600	DONE with help	Didn’t seem that hard, yet I got it wrong a few times…		This is a problem where the solution is really easy, but proving that it is optimal is the hardest part. You need to use the pattern.
1957C	1600	DONE with help	The most obvious thing is to just do DP. But I don’t know. I could exhaustively search. Should have made the observation in a 2x2, and realized if I used 2x for the diagonal, that already gives the wrong answer, and similarly for the other sides.	Order doesn’t here, because you can always have it come up later. So just pick a row and a column. I’m still not convinced. It’s the DOUBLE COUNTING part that I’m getting confused on. Yea, it’s because you still need to check the last row and column, which are still free. So you would essentially double count.	The big thing that I missed here is to observe that order doesn’t matter. I came up with the semi correct formula, but it was wrong because I thought order mattered, in which case I counted extra cases.
1956D	2000		This problem, even reading the solution is a little hard.
2004D	1600	DONE with help	I missed the observation that only 1 intermediate city is possible.	And to get the closest city, use a table that tells you the nearest node with that particular value. You only have 6 possible values
2004E	2100		Need to revisit this once I understand the Sprague-Grundy Theorem theorem
1946C			Happy that I had the idea of binary searching early on the value. However, the thing I miss is checking whether $x$ is possible or not… I actually had the idea of doing DFS too, but I couldn’t prove in my head that the greedy way works.
2003D2			I feel like I should have gotten that one. I got the idea pretty fast with formulating the problem as a graph.	Needed a modified disjoint set union. I mean, rather should have used DP with a graph. How could I have had the foresight that disjoint Union set doesn’t work? When the formulation requires some weird tricks. There might be a better formulation for the problem. Just be able to see the problem better. I mean, you can reach 4. The size doesn’t model the relationship correctly.	Wow, there’s also nuance to the value being the MEX itself as the max that we need to initialize. There’s a lot of nuance to this question, hard to get right.
1838B	1100	DONE	This is the problem that caused me a massive elo drop at a contest.	Damn I fumbled it again. I made the correct observations, but like 90%. I eliminated the possibility of considering the 3 cases. It was an idea for a split second. I was like, we only need to look at the 2 smallest values.
1944D	2000	DONE		Looking at how a string is not K-good by looking at the case that it is K-Good.
1935C	1800	DONE	My idea/intuition was to use a greedy approach, but it couldn’t work since there the remaining val has too many values to check.	Optimal seems to be greedy. The idea of iterating over the array, and greedily taking away the maximum value is something I need to remember. Greedily taking away the max sum, using the data structure to store the actual values, it’s really smart.
1935D	1800	DONE	ALMOST had it. I didn’t know how to calculate the intersection of both sets.
1935E	2300	TODO	Some bit things
1991C	1300		Wow, idea went completely over my head, going bit by bit. I should have made the observation that we are limited to 40 numbers, and thinking about reducing the range of possible numbers through a bitwise fashion. I was just thinking about numbers alone.	I think I had a brief though about iterating over bits, but im so stupid. Didn’t necessarily need to think bitwise. Just take the maximum number, and divide by 2. Then, you divide the range by half. At most ~30 elements (log 10^9)
1954D	1800		RAELLY HARD. DP over the potential values. That idea didn’t come up to me.	Should have made the observation about the sum of the balls not exceeding 5000. Also, realize that the distribution is always s/2. But even so, it seems non trivial.
2008F			This was a relatively easy question using prefix sums. However, I did not know modulus for the life of me. Either should use a class, and learn Modular Multiplicative Inverse
1950D	1100	Done	This is a Div4 D problem, should be easy yet I as not able.	Do not underestimate brute-forcing. Be smarter understanding time complexity. 2^5 divisors.
1950E	1500		It went over my head that there are only so many divisors.
1950F			Correct idea but failed a few times in implementation… Actually my idea was partially wrong	I need to be able to prove that the tree is minimum height. I was not able to come up with a counter example.
2009C			learned about how to implement ceil fast.
2014D		DONE	I rejected the idea of a sliding window. I had good ideas, and it’s actually not hard, but I opted for just checking overlaps. It’s stupid.	Sliding window is still O(n), do not reject that idea.
2014E			I could not see how a variant of Dijkstra’s could solve this..
2030C		DONE	Could’ve had more conviction in my idea. Didn’t follow up. The first observation about 1s being on the side was really good. Just had to see that contiguous ones work.	Kind of cheated. My idea was halfway there
2022B		DONE	Holy shit I’m stupid, I don’t know why I’m not able to do this problem
2019B		DONE	Really struggled with the interval calculations. Integer overflow again… at this point I’m just going to default to long long and not worry about these stupid problems.
2013C		DONE	Bruh, I actually solved this pretty fast. I realized that the first character takes 1 guess, and then subsequent will take 2 guesses at most (to check that it is the last string). And then if both guesses are wrong, then you know it’s in the other direction. And then that only takes 1 guess.	I was pretty happy that I found the answer pretty quick. It seems that I didn’t need to do this BFS approach. Actually, tutorial has this graph implementation, but I didn’t need that. Could’ve just pushed back the edges, and then tried to create something: https://codeforces.com/contest/2027/standings/friends/true/participant/195276602
2013D
2027C			I’m SO PISSED. I forgot that I should never use `unordered_map` or `unordered_set` for a codeforces problem…why am I so stupid. I got the question right.
1955E	1700		Man, I got too intimidated. Solution really isn’t that hard, it’s just sliding window bruteforcing.
2032D	1800	DONE	It was similar ideas, but actually here, it’s doing a linear search as opposed to a binary search of components. Pretty fun to try out.
2024C	1300	DONE	This is a very easy problem that I didn’t manage to figure out?? Like I genuinely didn’t know what to do…	Very not obvious that the idea is to use the sum to compare. I need to prove this out.

problem - difficulty - status - metacognition - takeaways

Problem solving: Lots of intuition, the solution should come to you. You make observations that lead you to coming up with a correct solution.

Leetcode:

https://leetcode.com/contest/weekly-contest-409/problems/shortest-distance-after-road-addition-queries-ii/description/
- Just couldn’t come up with the solution on the spot

[1,0,1,0,1],
[1,1,1,1,1],
[0,0,0,0,0],
[1,1,1,1,1],
[1,0,1,0,1]

[0,0,0,0,0],
[1,1,1,1,1],
[0,1,0,1,0],
[0,1,0,1,0],
[1,0,0,0,1]]

2024-08-17

This is not the same as

ans = (ans + m[prefix[i]] * (n - i + 1ll)) % MOD;

Incorrect

ans += (m[prefix[i]] * (n - i + 1ll)) % MOD;

Ahh, because I need to take a MOD on ans afterwards too, i’m so stupid..

2024-08-09

Really werid compiler optimization going on

behavior causes modifcations to same memory addresses

        cout << endl;
        int m = median(n - 1);
        for (int i = m; i >= 0; i--) {
            if (mod1[i].second == 1) {
                mod1[i].first += k;
                cout << "? " << i << endl;
                break;
            }
        }
        for (int i = m; i >= 0; i++) {
            if (mod2[i].second == 1) {
                mod2[i].first += k;
                break;
            }
        }

965div2 C.cpp

2024-02-27

Doing a codeforces contest again today.

This question is pretty easy, but I am not sure how to deal with the edge case?? https://codeforces.com/contest/1932/problem/C

Need to take a modulus, but when??

2024-02-26

Struggled with diameter of the tree offer.

2023-07-04

Bruh, why do I find this leetcode daily problem hard. Am I just bad at XOR problems?? 137. Single Number II https://leetcode.com/problems/single-number-ii/

2023-06-15

Got the nvidia offer, but this is still super fun. 714. Best Time to Buy and Sell Stock with Transaction Fee: https://leetcode.com/problems/best-time-to-buy-and-sell-stock-with-transaction-fee/submissions/

Damn I really struggled with this problem today.

2023-06-06

Well… seems like the interview is spread over 2 days now. More stress. But this should be fun.

https://leetcode.com/problems/letter-combinations-of-a-phone-number/

Really make sure to pay attention to detail!!

2023-06-05

(INCOMPLETE) This leetcode problem is really hard: https://leetcode.com/problems/median-of-two-sorted-arrays/
I have the intuition of doing the binary search

Speedrun this list https://leetcode.com/explore/featured/card/top-interview-questions-easy/ (brush up on your data structures and algorithms, < 1 hour?)

I think that the math questions are super easy

I have a lot of trouble with sorting, therefore I am going to focus a lot on the sorting stuff.

2023-06-04

I completely bombed the Codeforces contest today: https://codeforces.com/contest/1838/standings/participant/156529852#p156529852

I feel like it could be due to a lack of sleep, or I got unlucky with the questions, because they just didn’t click with me

bro I did so many practice interviews on Pramp, so many of these people are SOOO slow at getting the solution. At this point, it’s better to just practice

(INCOMPLETE) https://leetcode.com/problems/count-the-number-of-square-free-subsets/
- Count the Number of Square Free Subsets: There is the idea of counting the prime factors using bitwise, it’s honestly really hard and I’m getting stuck. Very hard for me. I can’t do those leetcode mediums :(

Goal is to

Speedrun this list https://leetcode.com/explore/featured/card/top-interview-questions-easy/ (brush up on your data structures and algorithms, < 1 hour?)

Bruh, even with a question as simple as removing duplicates, I am struggling. This is honestly really pathetic.

🛠️ Steven Gong

Table of Contents

Competitive Programming Logs

2024-08-17

2024-08-09

2024-02-27

2024-02-26

2023-07-04

2023-06-15

2023-06-06

2023-06-05

2023-06-04

Graph View

Backlinks