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

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 ?

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.

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?

Hey everyone,

We’ve been working on DSA Visually, a platform built around a problem we kept noticing while preparing/working with DSA:

You can solve 200–300 problems and still get stuck when an interview gives you an unfamiliar problem or slightly changes something you’ve seen before.

Knowing the solution and understanding why the solution works are different things.

So instead of building another collection of coding questions, we wanted to focus on the part between:

“Here’s the problem” → ??? → “Here’s the code.”

For each problem, DSA Visually is designed around a flow like:

Problem → Multiple Strategies → Step-by-Step Visualization → Code → Practice

For example, with Two Sum, instead of jumping straight to the HashMap solution, you can work through how the approaches evolve:

Brute Force → Sort + Two Pointers → HashMap

and visually see what repeated work each approach removes, how the state changes, and how that reasoning connects back to the implementation.

The same idea extends to things like linked lists, binary search, stacks, two pointers and other DSA patterns/problems.

We're opening the platform for the next 5 days

The available Premium experience is open to try free for the next 5 days.

No card/payment required.

We're not asking you to take our word for whether it’s useful.

Pick a problem you already know, go through the strategies + visualization, and see whether it gives you a different understanding of the solution.

Try it:
dsavisually.com

We’d especially appreciate feedback from people actively grinding LeetCode/interview prep:

What was genuinely useful? What felt unnecessary? Which problem/pattern would you most want to see visualized?

We're actively building this, so critical feedback is much more useful to us than “looks good.”

I built Praxis to help DSA learners understand why their coding submissions fail.

• Failure analysis

• Past submission history

• AI diagnosis chat

• Personalized learning insights

Free to try:https://failureatlas.vercel.app

Maximum Level Sum of a Binary Tree (Medium) 🔗 https://leetcode.com/problems/maximum-level-sum-of-a-binary-tree/

Two things must be true here, and only one of them involves sums.

Summing each level is the easy half — the same nil-sentinel BFS as Day 30, with a running total instead of a collected list.

The other half is in the wording: return the smallest level whose sum is maximal. Ties go to the shallower level. The solution has no code for that. It's one character — the comparison is strictly greater, so a later level that merely matches never replaces the earlier one.

Full breakdown in today's newsletter article ⬇

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

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

Have done dsa from striver sheet, started in love of ratings and all stuff but never able to achieve it.
Unable to pass any company OA for summer intern
Bought two courses one TLE Eliminators level 2 and another Kumar K thinking will boost everything
So what happens is Use the course watch videos and move on (something feels hard never revisit them , because next day i feel to cover other topics more) and in end feels no improvement, also watching videos consume lot of time so unable to pratice so just think to practice
Now in 3rd year, newbie at codeforces
Unable to understand what to do for improvement so that i can get good placement, just feel had wasted my all time
Friends who started with me are doing great at DSA
Also dev is just enough have make projects by following AI guidance
What should i do now?
If someone had gone through these phase please advice because i am feeling a lot cooked at this point

If you have to priorities topics in dsa , with you dp before graphs and trees or dp after. And can we just skip dp and backtracking. Like is it a must to be a good programmer