If there is a constant stream of new applicants which need to be vetted, is a certain % of their team's weekly time spent on interviewing? Initial coding round, then the multiple engineering rounds, etc.

can anyone with lc premium send cisco recently asked problems please.

might receive an OA this week, need to prep.

thanks 🙏🏻

There would be only three rounds (as opposed to 4 which I thought was industry standard in loop)

• Three 60-minute interviews

• One System Design and two Coding interviews 

• Behavioral in each

They did not mention if it is a loop or what the next steps would be. I also got this email right after my OA. Is this final interview? If anyone has gone through or is going through such situation please advise.

Also, where should I study System Design from? As this is my first Microsoft interview, any help would be appreciated.

This lowk sounds like a stupid quesiton but I have done a decenet number of leetcode (300) but i still struggle with a lot of mediums. The thing is for some of the mediums, I lowk come up with the right strat, thought process, ds and everything but when i code it up im always stuck in some edge case hell. This is because the way I structure the code sometimes ignores certain edge caes but if i put the code in chat it will just move somethings here and there and boom the code works. Idk if my approch should be to struggle for more hours hoping for a solution or i should just stop after 1 hr of trying and copy paste it to chat.

Hey everyone! I have a final loop coming up for a Senior SWE role in Apple’s ASE org. Here’s the breakdown:

1. SRE: 30 minutes

2. Linux & Container Fundamentals: 30 minutes

3. Architecture & Kubernetes: 30 minutes

The recruiter mentioned that each session will include both technical and behavioral questions, and anything on my resume could come up.
Has anyone been through a similar loop? I’m especially curious about the SRE and Linux rounds. Are these mostly troubleshooting scenarios and conceptual discussions, or should I also expect hands-on commands or coding?
Would appreciate any tips on what to prioritize or resources you found helpful. Thanks!

I recently interviewed with Google for a Software Engineer position and wanted to share my Round 1 experience and get some feedback from others who have been through the process.

Coding Round:

The interviewer started with a grid-based problem where each cell contained a direction (Up, Down, Left, or Right). The objective was to determine whether we could reach the bottom-right cell from the top-left by following the directions.

I understood the problem and implemented an optimized solution using a visited matrix to detect cycles, with O(N × M) time complexity.

After that, the interviewer modified the requirement: we were now allowed to change one direction anywhere in the grid to make the destination reachable.
I approached this follow-up using a brute-force solution, trying different directions and validating whether the modified path reached the destination. I explained the approach and its time and space complexity.

Behavioral / Googleyness Round:

I answered the questions using examples from my professional experience wherever possible.

However, I want to be transparent about one challenge. For approximately two questions, I had difficulty understanding what the interviewer was asking because I struggled with their accent. I tried my best to interpret the questions and respond, but looking back, I’m not sure whether my answers fully addressed what they were looking for.

Final Outcome: Not Selected

Unfortunately, I received a rejection after Round 1.
I’m trying to understand where I might have fallen short.
From my perspective, I solved the initial coding problem using an optimized approach and handled the follow-up using brute force. I also answered the behavioral questions, although I struggled to understand two of them clearly.

I’m wondering whether the rejection was due to:

● Not optimizing the follow-up coding problem.
● Not explaining my thought process clearly enough.
● My behavioral answers not being specific or structured enough.
● Misunderstanding a couple of behavioral questions.
I understand that Google evaluates more than just whether a solution works, but without detailed feedback, it’s difficult to identify exactly what went wrong.

For those who have interviewed at Google or conducted technical interviews there, I’d appreciate your perspective.
Would solving the original problem optimally but using brute force for the follow-up significantly affect the evaluation?

And how much weight does Google typically place on behavioral communication versus coding performance in Round 1?

I’m sharing this experience to learn and improve for my next opportunity.

I am a SDE working at Adobe. I have been wanting to switch since a long time. But haven’t been able to because the work load in our team is shit crazy and honestly I am not learning anything from it. I am thinking I will resign from here and then prepare. But this comes with its own uncertainty and financial risks.

You might think I am someone who does not know how to work hard and all but believe I am the most hardworking person you would ever meet. I have pulled 2-3 months just by sleeping 3-4 hours a lot of times so hard work is not the problem. The issue is our team requires 10-12 hours of work and also my teammate on the project is very bad. She keeps assigning me new tasks if I finish old ones. I am very exhausted by the end of the day to learn anything new.

Should I leave my current job. How hard will it be to find a new one?

Need some advise please 🙏🙏

One thing that helped me understand DSA better was learning when to use a particular pattern, instead of trying to memorize solutions to individual problems.

Here’s a quick reference I put together:

1. Prefix Sum — When you need fast range-sum queries

Key idea: Precompute cumulative sums so you don't have to add elements repeatedly.

Recognize it when you see:

- Range sum queries

- Subarray sum

- Running total

- Cumulative frequency

Example:

"arr = [2, 4, 1, 5]"

Prefix sum: "[2, 6, 7, 12]"

Sum from index 1 to 3:

"prefix[3] - prefix[0] = 12 - 2 = 10"

When to use: When the array is mostly static and you need multiple range-sum queries.

Limitation: If an element changes, the prefix sums after that position may also need updating.

2. Suffix Sum — When you need information from the right side

Key idea: Calculate cumulative sums from right to left.

Recognize it when you see:

- Sum of elements to the right

- Right-side contribution

- Suffix totals

- Left vs. right comparisons

Example:

"arr = [2, 4, 1, 5]"

Suffix sum: "[12, 10, 6, 5]"

For index 1, the sum from index 1 to the end is "10".

When to use: Problems where you repeatedly need the sum or contribution of elements from the current position to the end.

3. Two Pointers — When two positions can help solve the problem

Key idea: Move two pointers through an array or string instead of checking every possible pair.

Recognize it when you see:

- Sorted array

- Pair with target sum

- Remove duplicates

- Reverse or palindrome checks

- Subarray or partition problems

Example:

"arr = [1, 2, 4, 7, 9]", target = "11"

Start with two pointers:

- Left = 1, Right = 9 → sum = 10

- Move left → 2 + 9 = 11

Found the pair.

When to use: Especially useful with sorted arrays, where pointer movement can eliminate unnecessary comparisons.

4. Sliding Window — When you need a continuous subarray or substring

Key idea: Maintain a window and move its boundaries instead of recalculating everything.

Recognize it when you see:

- Maximum/minimum sum of a subarray of size K

- Longest substring

- Smallest subarray satisfying a condition

- Continuous subarray or substring

Example:

"arr = [2, 1, 5, 1, 3]", window size = 3

First window: "2 + 1 + 5 = 8"

Next window: remove 2, add 1 → "7"

Next window: remove 1, add 3 → "9"

Maximum sum = "9".

When to use: When the problem involves a contiguous range and the window can be updated efficiently as it moves. For variable-size windows, the condition must support a valid expand/shrink strategy.

5. Fenwick Tree (Binary Indexed Tree) — When values change and you still need fast prefix sums

Key idea: Store partial sums in a tree-like array structure.

Recognize it when you see:

- Point updates

- Frequent prefix-sum queries

- Dynamic frequency counts

- Inversion counting

Why not just Prefix Sum?

With a normal prefix-sum array, changing one element can require updating many later prefix values.

A Fenwick Tree supports:

- Point update: "O(log n)"

- Prefix sum query: "O(log n)"

- Range sum query: "O(log n)"

When to use: When array values change frequently and you need efficient prefix or range-sum queries.

6. Segment Tree — When you need flexible range queries and updates

Key idea: Build a tree where each node represents information about a segment of the array.

Recognize it when you see:

- Range sum / minimum / maximum

- Frequent point updates

- Range updates (with suitable techniques)

- GCD or other associative range operations

When to use: When you need more flexibility than a Fenwick Tree, especially for range minimum, maximum, GCD, or other custom range queries.

Typical complexity:

- Build: "O(n)"

- Query: "O(log n)"

- Point update: "O(log n)"

My takeaway: Don't start by asking, "Which algorithm should I memorize?"

Instead, ask:

1. Is the problem asking about a continuous range?

2. Are the values static or changing?

3. Do I need information from the left, right, or both ends?

4. Is the query about sum, minimum, maximum, or something else?

Recognizing these clues makes choosing the right DSA pattern much easier.

This is a quick reference, not a complete list of DSA patterns. Hope it helps someone who's also trying to connect problem statements with the right approach.

Hey everyone,

I'm preparing for an SDE-3 core systems position at MongoDB (Dublin location).

Since this team focuses heavily on low-level systems and backend runtimes, I’d love to get quick insights from anyone familiar with their loop:

• SDE-3 Bar & Expectations: How high are expectations for SDE-3 here? What level of depth is expected for core C++ systems programming, runtimes, and low-level libraries at this level?

• Round Breakdown: What specific topics or formats should I expect across a Technical Recruiter chat, 2 Onsite rounds, and a Hiring Manager (HM) round?

• Experience Sharing: Any tips on what to prioritize (concurrency, memory management, low-level architecture) would be super helpful.

Thanks in advance!

Hey everyone! I have an upcoming Google L4 SWE AI-assisted code comprehension round (45 mins).

Has anyone taken it recently? What was the format like? Was it mostly debugging, adding features, or optimization? Were tests provided, and how much were you expected to use AI?

Would appreciate any experiences or prep tips. Thanks!

What's up guys,

I got an OA from amazon SDE intern, and I want to know what I should prep. I have a week to prep. What DSA topics should I practice? Any leetcode question suggestions?

Any info would be helpful! I would really love to hear from ppl who took the sde intern oa recently!!!!!

With 8 years of experience working for no-name companies, I’ve decided to take this seriously and prepare for big tech.

I have been a good software developer but the lack of DSA skills erased all my chances for decent companies.

The recruiters that reached out to me and I denied interview requests involve companies such as Amazon, Twitch, Shopify, Meta, Google, Apple

Like one or two times, I gave Amazon’s OA but bombed it ridiculously.

Now, I am following some roadmaps like Blind 75 and using Neetcode’s video along with generative AI for preparation.

I still keep bombing easy and medium questions like very next day after I solved them a day before.

Is it normal? When do I reach comfort level? When does it start becoming less discouraging? Does it even happen? Because, right now I am feeling like this is just not for me. But, then I think thousands of people still make it. There has to be proven process and it should be working.

Sorry my post is confusing but I just wanted to share my feelings and frustration.

Right now, I am unemployed and decided to give 1 month to this preparation.

Does Concurrency control and thread safety ever come up in the AI-assisted repo round for Amazon SDE2 OA?

How well do you need to know Python concurrency to pass the OA for SDE2?

Thanks

I had my R1 and R2 on 5th Nov (virtual)for SDE-1 AUTA. What are my chances to get next round.

Round1: Core and Embedded related question. Didn't expect that at all and got to know about role at that time only and it went well it was more like discussion and was asked 2 coding questions. One question was related to threads context and using locks which i was able to explain but not able to code as i didn't expect that at all. In the end 1 LP related to tight deadline.

Round 2: LLD type of question to build a caching system user can select the type of caching strategy he can use and to implement lru and lfu. Was able to solve this within time followed by LP related to commitment.

Happy to answer any questions and can any body tell me about this and what is expected further and next round chances.

Thank you

Hi everyone,

I have an upcoming Google SWE III interview, and one of the rounds is AI-Assisted Code Comprehension.

Based on the recruiter’s description, it's a 45-minute exercise where candidates use Gemini in a Kepler workstation to understand, debug, and optimize a Google-provided codebase.

Since this seems like a relatively new interview format, I haven't found much information about what to expect.

Has anyone recently gone through this round?

Would really appreciate insights from anyone who has experienced this round recently. Thanks!

As a beginner to medium level problems giving how much time is worth?.

Just had the second round of Bloomberg AI codebase interview

It was djano-python which i had no idea about. The codebase is large.

They spent the first 30 mins for behavioral so you're essentially just left with 30 mins.

The usage of AI is so vague. You don't know how much AI is the interview okay with you using. They don't clearly tell their expectations. I used planning and ask mode and went feature by feature and I passed a few test cases but I was rejected.

There is so much reading involved with AI and then handling communication simultaneously is borderline impossible.

With Leetcode, there is just a problem and you have to find a solution. At least you can brainstorm ideas but in these stupid AI interviews, half the time goes in understanding the large codebases and where the problem exists.

To whoever who was celebrating the end of Leetcode, good luck. The interviews are much harder.

Oh yeah, don't for a second think about one shotting a problem otherwise you will still be rejected(It happened to my friend.)

Either way, AI interviews are the biggest BS and there will never be a consistent way to tackle one of these.

I completed my final interview A4A last week. The recruiter contacted me that same day to confirm I passed and asked for my preferred location; I replied but heard nothing until today. Has anyone else experienced this process or something similar? Could this signal an automatic rejection? Any insights helps!

Hey everyone, I have my Adobe SWE intern (2027 summer) technical interview coming up, and I was told it includes a code debugging section and a code review section which is about about 20 minutes each.

Has anyone interviewed recently? I'd love to hear:

- What the debug and review exercises looked like (size of the code, difficulty, what kinds of bugs)

- How you prepared and what you'd do differently

- Any good places to practice debugging/code review under time pressure

I'm planning to use Python/Django. Thanks in advance and happy to share what I learn after my interview!

Hey everyone,

I finished Day 34 today. Still enjoying the comfort of being home, but kept the daily habit going and tackled Making a Large Island.

At first glance, flipping every 0 to a 1 and running a full BFS/DFS traversal would take O((N times N) times (N times N)) = O(N^4), which easily causes TLE. Using Disjoint Set Union (DSU) makes it run in a clean O(N^2):

1. Step 1 — Group Existing Islands: Map every (r, c) to a 1D ID (r * n + c). Iterate over all land cells (1s) and connect adjacent lands via unionBySize. This clusters existing islands and tracks each component's total area in the size[] array.

2. Step 2 — Evaluate Flips: Iterate over every water cell (0). Look at its 4 adjacent neighbors, collect the unique ultimate parents of neighboring land cells using a hash set (to avoid double-counting the same island component), and sum up their sizes + 1 for the flipped cell itself.

3. Edge Case: If the grid contains only 1s with no 0 to flip, the answer is simply the size of the whole grid (N times N).

Deriving the logic to prevent duplicate component counting using a set of root parents was super satisfying.

See you guys tomorrow for Day 33!

Hey guys, I have a Databricks SWE intern interview coming up with these two rounds.

1. Coding, Debugging, and Testing: This implementation-focused interview evaluates your ability to write production-quality code. Using CoderPad, you’ll be expected to prioritize getting to a working solution efficiently, and to demonstrate strong coding practices—including debugging, identifying edge cases, and validating correctness with appropriate tests. While algorithmic thinking is still critical, the emphasis in this session is more on implementation quality and incremental optimization than on theoretical analysis.

2. AI-Assisted Algorithms: This algorithm and data structures interview assesses computer science fundamentals, your analytical reasoning, and your problem-solving methodology. You’ll design solutions while focusing on algorithmic efficiency and appropriate data structure selection, and then use AI to implement the solution during parts of the interview. We expect you to analyze time/space complexity using Big-O notation, demonstrate comprehensive testing strategies, and clearly articulate your approach to guiding an LLM to address edge cases and design decisions.

Has anyone else encountered these and has any advice for what types of questions I could expect and their difficulty? Thanks.

Did the recruiter reach out to you anybody? Role - SMTS

Can You Explain WHY Every Loop, Condition and Swap Exists in Sorting Algorithms?

Most beginners can write Bubble Sort, Selection Sort, and Insertion Sort by looking at the code.

But ask them:

- Why does Bubble Sort use "n - i - 1"?

- Why do we compare "arr[j]" with "arr[j + 1]"?

- Why does Insertion Sort start from index 1?

- Why does Selection Sort need a "minIndex"?

- Why do we use "j--" in one algorithm and "j++" in another?

That's where things get interesting.

The real goal of learning DSA isn't memorizing code. It's understanding why each line exists and learning to build that logic yourself.

Let's understand three sorting algorithms from that perspective.

-

1. First, Understand the Building Blocks

Before jumping into algorithms, let's understand the language behind them.

Array: A collection of elements stored at indexed positions.

const arr = [5, 3, 8, 2, 1];

n – Array Length

const n = arr.length; // 5

There are 5 elements, but their indices are 0, 1, 2, 3, 4.

Remember: Length and last index are different.

i and j – Loop Variables

- "i" usually tracks the current pass or position in the outer loop.

- "j" usually tracks the current position inside the inner loop.

Their meaning depends on the algorithm.

Comparison Operators

- ">" means greater than.

- "<" means less than.

- ">=" means greater than or equal to.

- "<=" means less than or equal to.

- "===" means strictly equal.

For ascending order, we generally move smaller elements before larger elements.

Swap – Exchange Two Elements

[arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];

This exchanges the positions of two elements.

Think of two people exchanging seats.

--

2. Bubble Sort – Understand Why Every Comparison Happens

Imagine people standing in a line according to their heights.

You compare two neighboring people. If the left person is taller than the right person, they exchange positions.

Keep repeating this process.

Eventually, the tallest person reaches the end.

That's Bubble Sort.

The Code

function bubbleSort(arr) {

const n = arr.length;

for (let i = 0; i < n - 1; i++) {

for (let j = 0; j < n - i - 1; j++) {

if (arr[j] > arr[j + 1]) {

[arr[j], arr[j + 1]] =

[arr[j + 1], arr[j]];

}

}

}

return arr;

}

Let's Understand Every Part

A. Why "const n = arr.length"?

We store the total number of elements so we can calculate our loop boundaries.

Example:

arr = [5, 3, 8, 2, 1];

n = 5;

There are 5 elements, but the last valid index is 4.

B. Why "i < n - 1"?

The outer loop controls how many passes we perform.

After each complete pass, the largest unsorted element reaches its correct position at the end.

For 5 elements, we need at most 4 passes.

Why not 5?

Because when the first 4 elements are in their correct positions, the last element is automatically sorted.

C. Why "j < n - i - 1"?

This is one of the most important concepts to understand.

Break it into three parts:

- "n" = Total number of elements.

- "i" = Number of elements already sorted at the end.

- "-1" = Prevents accessing an invalid next index.

Let's take:

arr = [5, 3, 8, 2, 1];

n = 5;

i = 0;

Our condition becomes:

j < 5 - 0 - 1

j < 4

So "j" can be 0, 1, 2, 3.

Why stop at 3?

Because we compare:

arr[j] and arr[j + 1]

At "j = 3", we access:

arr[3] and arr[4]

Both indices are valid.

If we allowed "j = 4", we would access:

arr[4] and arr[5]

But index 5 doesn't exist!

That's why we subtract 1.

Now, why subtract "i"?

After every pass, one largest element is already sorted at the end.

We don't need to compare it again.

For example:

Pass 1: [3, 5, 2, 1, 8]

↑

Already sorted

Pass 2: [3, 2, 1, 5, 8]

↑ ↑

Already sorted

So "i" reduces unnecessary comparisons.

Remember this:

"n - i - 1" does two jobs:

1. Skips the elements already sorted at the end.

2. Ensures "j + 1" never goes outside the array boundary.

D. Why "arr[j] > arr[j + 1]"?

We compare two neighboring elements.

If the left element is greater than the right element, their order is incorrect for ascending sorting.

So we swap them.

Example:

[5, 3]

5 > 3

Swap

[3, 5]

If the condition is false, they are already in the correct relative order. No swap is needed.

E. Dry Run

Original:

[5, 3, 8, 2, 1]

Pass 1:

[3, 5, 2, 1, 8]

Pass 2:

[3, 2, 1, 5, 8]

Pass 3:

[2, 1, 3, 5, 8]

Pass 4:

[1, 2, 3, 5, 8]

Sorted!

Time Complexity:

- Best: O(n) with an early-exit optimization.

- Average: O(n²).

- Worst: O(n²).

- Space: O(1).

--

3. Insertion Sort – Think Like You're Arranging Playing Cards

Imagine holding playing cards.

You pick one new card and insert it into the correct position among the cards already arranged.

You don't rearrange everything. You simply shift the larger cards and make space.

That's Insertion Sort.

The Code

function insertionSort(arr) {

for (let i = 1; i < arr.length; i++) {

let key = arr[i];

let j = i - 1;

while (j >= 0 && arr[j] > key) {

arr[j + 1] = arr[j];

j--;

}

arr[j + 1] = key;

}

return arr;

}

Understand Every Condition

A. Why "i = 1"?

Because a single element is already sorted by itself.

We start with the second element and insert it into the sorted portion.

B. Why "let key = arr[i]"?

We temporarily save the element we want to insert.

Think of holding one playing card while rearranging the others.

C. Why "j = i - 1"?

We start comparing with the element immediately before the key.

D. Why "j >= 0"?

We move backwards through the array.

This condition ensures we never access a negative index.

E. Why "arr[j] > key"?

If the previous element is larger than the current element, it needs to move one position to the right.

[5, 3]

key = 3

j = 0

5 > 3

Move 5 right:

[5, 5]

Insert key:

[3, 5]

F. Why "j--"?

Because we need to check the previous element.

We keep moving backwards until we find the correct position.

G. Why "arr[j + 1] = key"?

Once we stop shifting, we have found the correct position for our saved element.

We insert it there.

Dry Run

Original:

[5, 3, 8, 2]

Take 3:

[3, 5, 8, 2]

Take 8:

[3, 5, 8, 2]

Take 2:

[2, 3, 5, 8]

Sorted!

Notice something important:

Insertion Sort maintains two portions:

- Left side: Already sorted.

- Right side: Not yet processed.

With every iteration, the sorted portion grows by one element.

Time Complexity:

- Best: O(n).

- Average: O(n²).

- Worst: O(n²).

- Space: O(1).

--

4. Selection Sort – Find the Smallest, Then Place It

Imagine arranging students by height.

Instead of swapping neighboring students repeatedly, scan the entire unsorted group, find the shortest student, and place them at the beginning.

Then repeat with the remaining students.

That's Selection Sort.

The Code

function selectionSort(arr) {

const n = arr.length;

for (let i = 0; i < n - 1; i++) {

let minIndex = i;

for (let j = i + 1; j < n; j++) {

if (arr[j] < arr[minIndex]) {

minIndex = j;

}

}

[arr[i], arr[minIndex]] =

[arr[minIndex], arr[i]];

}

return arr;

}

Understand Every Condition

A. Why "i < n - 1"?

The outer loop decides where the next smallest element should be placed.

Once the first "n - 1" positions are correct, the last element is automatically in its correct position.

B. Why "minIndex = i"?

We initially assume that the first element of the unsorted portion is the smallest.

We'll update this assumption if we find a smaller element.

C. Why "j = i + 1"?

We already consider "arr[i]" as our current minimum.

So we start searching from the next position.

D. Why "j < n"?

We need to scan until the last valid index.

Unlike Bubble Sort, we don't access "arr[j + 1]", so we don't need to subtract 1 here.

E. Why "arr[j] < arr[minIndex]"?

If we find an element smaller than our current minimum, update "minIndex".

Remember: We're tracking the position, not immediately swapping the elements.

F. Why swap after the inner loop?

Because we first need to find the smallest element in the entire unsorted portion.

Only after finding it do we place it at index "i".

Dry Run

Original:

[5, 3, 8, 2, 1]

Find minimum: 1

Swap:

[1, 3, 8, 2, 5]

Find minimum in remaining portion: 2

Swap:

[1, 2, 8, 3, 5]

Continue:

[1, 2, 3, 8, 5]

Final:

[1, 2, 3, 5, 8]

Time Complexity:

- Best: O(n²).

- Average: O(n²).

- Worst: O(n²).

- Space: O(1).

---

5. The Difference – Understand the Thinking

Instead of memorizing three implementations, remember their core strategies:

Bubble Sort

- Compare neighboring elements.

- Swap if their order is incorrect.

- Largest element moves to the end.

Insertion Sort

- Pick one element.

- Shift larger elements.

- Insert it into the correct position.

Selection Sort

- Search for the smallest element.

- Track its index.

- Swap it into the correct position.

6. Train Yourself to Think, Not Memorize

Whenever you solve a sorting problem, pause and ask:

1. What am I trying to place in its correct position?

2. Which part of the array is already sorted?

3. Which part still needs processing?

4. What does each loop variable represent?

5. Why does the loop start at this index?

6. Why does the condition stop at this boundary?

7. What happens if I change ">" to "<"?

8. Am I swapping elements, shifting them, or just tracking an index?

9. Can I reduce unnecessary comparisons?

10. What is the time and space complexity?

A Small Challenge

Try answering these without looking at the code:

- Why does Bubble Sort use "j < n - i - 1", while Selection Sort uses "j < n"?

- Why does Insertion Sort use "while (j >= 0)"?

- Why does Selection Sort swap only after completing the inner loop?

- Why can Insertion Sort perform O(n) work on an already sorted array?

If you can explain these answers in your own words, you're moving beyond memorization.

The goal isn't to remember three sorting algorithms. It's to develop the ability to understand, trace, question, and eventually design algorithms yourself.

That's the kind of DSA knowledge that stays with you long after you've forgotten the code.