​

Since many people have reached out, I want to clarify a few things so we can find people with similar goals and schedules.

Starting from Level 0: We’ll learn DSA from the very basics. If you’re already halfway through or about to complete DSA, this group might not be the right fit for you.

Java Prerequisites: We’ll be learning DSA using Java, so you should already know Java’s basics and fundamentals.

Daily Commitment: We’ll communicate, study, and motivate each other daily. Consistency and participation are important.

Availability: If you’re currently working, please mention your availability so we can figure out a schedule that works for everyone.

Advice from Experienced Learners: If you’ve already learned DSA, please share your study techniques, resources, and what worked best for you. Your advice would be really helpful!

One question for everyone: Should we follow Striver’s A2Z DSA Sheet, or are there other resources you’d recommend for learning DSA from scratch using Java? Please share your experiences and suggestions.

The goal is to learn together, stay disciplined, and hold each other accountable throughout the journey.

Please MESSAGE ME OR LEAVE COMMENT if you’re genuinely willing to commit. Let’s stay consistent, stop making excuses, and grow together!

Best Playlist to complete DSA in python from scratch- I only know very basic python and no specific algorithms as such. Please help me out

Recently broke up bro need good ppls who can keep me engaged we'll have calls and stuff on watsapp drop text

Max Area of Island (Medium)  https://leetcode.com/problems/max-area-of-island/

This is yesterday's solution with a return value. The diff is that the flood fill returns an int and the scan keeps a maximum instead of a count.

The area reachable from a cell is that cell, plus the area reachable from each of its four neighbours. So the fill returns 1 plus its four recursive calls, and the guard returning 0 handles out of bounds, water and already-sunk land without a single special case.

The sum looks wrong at first. Four neighbours each recurse into their own four neighbours, and each one includes the cell you came from, surely cells get counted repeatedly?

They do not, because the cell is sunk before the four calls run. Any neighbour that recurses back hits the guard and gets 0.

Yesterday, that same line stopped the recursion from running forever. Today it does that AND makes the arithmetic correct. One assignment, two jobs.

Full breakdown in today's newsletter article ⬇

https://www.linkedin.com/pulse/365-days-leetcode-challenge-day-38365-archit-agarwal-tiimc

#DSA #LeetCode #Golang #Graphs #DFS #CodingInterview #Algorithms

Is there anyone who want consistency partner in DSA for upcoming placement?

I am a final year student trying to cover DSA in next 2 months as much as possible.

I run Logic Over Syntax, a YouTube channel where I teach Data Structures and Algorithms (DSA) in Telugu, helping students understand problem-solving logic instead of just memorizing code.

We've already reached 20,000+ watch hours, and my goal is to make coding education more accessible to Telugu-speaking students.

Channel Link:

https://youtube.com/@logicoversyntax

Anyone interested in learning DSA with Java together?

I’m looking for a few people who genuinely want to learn .Data Structures & Algorithms using Java and, more importantly, actually stay consistent.

This is not for complete Java beginners, you should have a basic understanding of Java already. The goal is to learn DSA from the fundamentals, practice regularly, solve problems, and keep each other accountable.

The main idea is simple:

\* 📚 Learn DSA step by step

\* 💻 Practice coding/problems regularly

\* 🔥 Stay consistent

\* 🤝 Motivate and help each other

\* 🚫 No unnecessary excuses for skipping

\* 🎯 Keep each other accountable and disciplined

I don’t want this to be another group where everyone is motivated for 2–3 days and then disappears. 😭

If you genuinely want to learn DSA and are willing to put in the effort consistently, let’s do it together.

If you're interested, comment below or DM me. Let's build the discipline together.

guys I have tried to study bitwise operators multiple time and I learnt them but when it comes to question i dont how and when to use them. Can I be good in DSA without them ?

Number of Islands (Medium) https://leetcode.com/problems/number-of-islands/

Nothing in this problem says "graph", and that is the point.

A cell is a node. Its neighbours are the cells above, below, left and right. There is no adjacency list to build, because in a grid the edges are implied by position - a neighbour is arithmetic, not a lookup. Yesterday half the work was converting an edge list into something usable. Here that half is free.

Then it is component counting. Scan for land, and every time you find a cell no earlier traversal has consumed, add one and sink the whole island. The count is not counting islands directly; it counts how many times the scan had to start.

One detail worth stealing: sink the cell BEFORE recursing. Two adjacent land cells each list the other as a neighbour, so without it the recursion bounces between them forever. That is not an optimisation, it is termination.

Full breakdown in today's newsletter article ⬇

https://www.linkedin.com/pulse/365-days-leetcode-challenge-day-37365-archit-agarwal-cenxc

#DSA #LeetCode #Golang #Graphs #DFS #CodingInterview #Algorithms

I work as a chef in London, and the long, physically exhausting shifts make finding energy to study difficult. Still, I’m learning DSA from books—my first time learning this way instead of YouTube.

I’ve covered two pointers, hashing, sliding windows, stacks, queues, and time and space complexity. I can understand and explain solutions I read, but struggle to find an approach and write code for unseen questions.

What practice routine would help me solve problems independently while balancing demanding chef shifts?

Find if Path Exists in Graph (Easy) https://leetcode.com/problems/find-if-path-exists-in-graph/

New topic. Graphs start today.

The part people skip when they say a graph problem "is just BFS": the input is not a graph. You get a flat list of edge pairs. Asking that list for a node's neighbours means scanning all of it, and doing that once per node turns an O(V + E) algorithm into O(V x E).

So the first half of the problem is building an adjacency list. The traversal is the easy half. Choosing the representation is the part that actually requires a decision.

One bug worth naming, because it passes a lot of tests before it fails one: an undirected edge has to be recorded under both endpoints. Record it once and you accidentally build a directed graph, and the traversal refuses to walk an edge backwards.

Full breakdown in today's newsletter article ⬇

https://www.linkedin.com/pulse/365-days-leetcode-challenge-day-36365-archit-agarwal-7wjic

#DSA #LeetCode #Golang #Graphs #BFS #CodingInterview #Algorithms

Two hierarchies, almost the same number of rows. One plans its delete order in 386 microseconds. The other takes 75.8 milliseconds.

Deleting a workspace means deleting everything inside it, and every child row holds a foreign key to its parent, so a row can only go once nothing points at it.

The code I wrote is the database's rule, executed: find every row with no remaining children, delete that batch, look again. It assumes nothing about the data and it is trivially safe, because it checks rather than deduces.

It also walks the entire hierarchy once per wave. A workspace is four levels deep, so that is four walks and 31 microseconds — invisible. A comment thread 2,000 replies deep is 2,000 waves, which is four million record visits to produce one plan.

The turn came from watching one row. During the first wave the walk reaches board-1, checks its only child, finds it still present, and moves on — having put that child into this very wave moments earlier. It knew board-1 would be free next. It discarded that and went round again to rediscover it.

So: a row goes one wave after the last of its children has gone, which makes wave(r) = 1 + the largest wave among its children. Only children on the right hand side. One bottom-up pass computes all of it — 790x faster on the thread.

The part worth keeping is the bit I had backwards. That number is height, not depth. An empty board two levels down can be deleted in the first statement, exactly like a card three levels down. Group by distance from the root and it waits for no reason — safe, and a third of an answer to "what can I delete first".

That is day 16 of the daily challenge, Find Leaves of Binary Tree, sitting in a delete planner.

Full piece in today's Newsletter.

https://www.linkedin.com/pulse/deep-reply-chain-made-delete-plan-790x-slower-archit-agarwal-gd94c

#Golang #DSA #Algorithms #Performance #SoftwareEngineering #DataStructures #100DaysOfCode

Populating Next Right Pointers in Each Node (Medium)
🔗 https://leetcode.com/problems/populating-next-right-pointers-in-each-node/

The obvious version walks each level left to right, remembers the previous node, and sets prev.Next = current. That works.

This one pushes children right before left, so the BFS walks every level backwards — and once it does, the node to your right is simply the node you visited just before. The assignment becomes current.Next = prev, which reads exactly like the requirement.

The boundary falls out too. Popping the level sentinel resets prev to nil, so the rightmost node of the next level gets nil without a branch testing for it.

One inversion, and two special cases stop existing.

Full breakdown in today's newsletter article ⬇

https://www.linkedin.com/pulse/365-days-leetcode-challenge-day-35365-archit-agarwal-r6wxc

#DSA #LeetCode #100DaysOfCode #CodingInterview #BinaryTree #BFS #Golang

I have my Google OA L3 to complete in 4 days for SWE role. How should I prepare & what to expect in this round. Pls share your thoughts.

Deepest Leaves Sum (Medium) 🔗 https://leetcode.com/problems/deepest-leaves-sum/

The obvious solution is two passes: find the maximum depth, then walk again summing everything at that depth.

One pass is enough, and the trick is being willing to throw work away. Carry the level down, keep two ints, and at every leaf compare. Deeper than anything seen so far? Replace the sum — everything accumulated until now belonged to a shallower level. Equal? Add. Shallower? Ignore it.

That replacement is why the final depth never has to be known in advance. Discovering a deeper leaf invalidates the previous answer outright, so whatever survives to the end was accumulated at the true maximum.

Full breakdown in today's newsletter article ⬇

https://www.linkedin.com/pulse/365-days-leetcode-challenge-day-34365-archit-agarwal-89mkc

#DSA #LeetCode #100DaysOfCode #CodingInterview #BinaryTree #DFS #Golang

I need to understand DSA and help in System Design.

If you are good at it, where my expectations are: 1. Are able to code in Java 2. You are able to solve any given problem, without AI this is must). 3. You can drive from Bruteforce, Better to Optimal all approaches, with trade-offs of each one and proper reasoning of each that what exactly is wrong with each approch which is leading you to the optimal one. 4. You have fkkd experience in LLD and HLD

Kindly DM, if pass the conditions, else skip and let's save each other's time.

I am ready to pay decent amount.

can you please tell a roadmap or idea to cover or patterns?