Anshika Shukla’s Post

Most people solve LeetCode problems the wrong way. I did too. I used to: → Jump into coding immediately → Get stuck → Check solution after 10–15 mins And repeat. Result? No real improvement. Then I changed my approach. Now every problem I solve follows this: 1️⃣ Understand the problem (don’t rush) → Read it twice → Identify inputs, outputs, constraints 2️⃣ Think before coding → Start with brute force → Break problem into smaller parts 3️⃣ Focus on patterns, not problems → Two pointers → Sliding window → DP, graphs, etc. 4️⃣ Dry run with examples → Test edge cases → See where it breaks 5️⃣ Then code → First correct → Then optimize 💡 Biggest mistake people make: They treat LeetCode like a quiz. But it’s not about knowing the answer. It’s about building the thinking process. Once I started doing this: Less frustration. More clarity. Real improvement. If you’re stuck in DSA: Don’t solve more problems. Solve them better. What’s your approach when you see a new problem? #LeetCode #DSA #SoftwareEngineering #CodingInterview #Developers #ProblemSolving #TechCareers

🚀 Day 32 of My Coding Journey — Mastering Binary Search Today I solved the classic Binary Search problem (LeetCode 704), and it reinforced one important concept: 👉 Divide and conquer can turn O(n) problems into O(log n). 💡 What I practiced today: Iterative Binary Search (most optimal & commonly used) Recursive Binary Search (clean logic, but uses stack space) 🔍 Key Learning: Instead of scanning the whole array, we eliminate half of the search space in every step. That’s why Binary Search is extremely powerful for sorted data. 📌 Approach (Recursive): Find mid index Compare with target If smaller → search right half If larger → search left half Stop when low > high ⚡ Time Complexity: O(log n) ⚡ Space Complexity: Iterative → O(1) Recursive → O(log n) (due to call stack) 💭 My Takeaway: Binary Search looks simple, but mastering edge cases (like overflow in mid, base conditions) is what actually matters in interviews. 📈 Slowly building strong fundamentals for problem solving and technical interviews. #Day32 #DSA #BinarySearch #CodingJourney #LeetCode #ProblemSolving #TechLearning

I still remember the first time I opened LeetCode. I thought “Let me just solve a few problems.” That “few problems” turned into hours of staring at a screen, feeling stuck on something as simple as a Linked List. At one point, I almost quit. Because it didn’t feel like coding. It felt like solving puzzles designed to break my confidence. But something changed. Not my intelligence. Not my coding language. My approach. I stopped trying to “solve everything.” Instead, I focused on patterns: → Linked Lists stopped being scary → Trees started making sense → Graphs became predictable → Arrays felt like strategy, not guessing That’s when I realized something important: Most developers don’t fail because they can’t code. They fail because they try to memorize solutions… …instead of understanding patterns. This PDF? It’s not just a collection of solutions. It’s a map of patterns: • Cycle detection • Two pointers • Recursion in trees • Traversal techniques • Problem breakdown thinking If you’re a student or developer struggling with DSA right now… Read this slowly: You’re not stuck. You’re just looking at problems individually instead of structurally. The moment you start seeing patterns. Everything changes. If you want the PDF or a structured roadmap to master these patterns, Comment “DSA” or DM me. I’ll share it with you. #DSA #LeetCode #CodingJourney #Developers #Students #TechCareers #Programming #SoftwareEngineering

I just completed 100 problems on LeetCode — but the real value is in how my thinking evolved. When I started, I struggled with basic syntax, debugging errors, and even simple problems felt overwhelming. Instead of rushing through questions, I focused on building a strong foundation step by step. Here’s how my journey progressed: 🔹 Data Structures I worked on: • Arrays • Strings • Linked Lists • Stack • HashMap 🔹 Problem-Solving Patterns I learned : • Brute Force → understanding the problem • Two Pointer technique • Sliding Window (fixed & variable) • Hashing / Frequency Maps • Prefix Sum • Slow & Fast Pointer • Stack-based problems • Monotonic Stack • Greedy Algorithms 🔹 Key Improvements: • Reduced silly mistakes (index errors, edge cases) • Better debugging and cleaner code • Shifted from “what to do” → “why it works” 📊 Stats: • 100 problems solved • 55 Easy | 41 Medium | 4 Hard • 70%+ acceptance rate 💡 Biggest realization: DSA is not about solving more problems — it’s about recognizing patterns and applying them efficiently. 🚀 Next Goals: • Solve more Medium & Hard problems • Improve speed and consistency • Prepare for real coding interviews If you're starting your DSA journey: Don’t focus on speed. Focus on understanding. Speed comes later. #leetcode #dsa #coding #programming #softwareengineering #learning

Getting a coding job isn't about solving 1,000+ LeetCode problems. It’s about recognizing the 𝗽𝗮𝘁𝘁𝗲𝗿𝗻𝘀 that actually matter. I just went through a comprehensive DSA Revision Guide, and the biggest takeaway isn't a complex formula—it’s that most interview questions boil down to a few core "mental models": • 𝗧𝗵𝗲 "𝗧𝘄𝗼 𝗣𝗼𝗶𝗻𝘁𝗲𝗿𝘀" 𝗦𝘁𝗿𝗮𝘁𝗲𝗴𝘆: If you see a sorted array or need to find a middle element, stop overthinking. Use a left and right pointer to close in on your target. It’s the foundation for everything from "Two Sum" to "Sliding Windows". • 𝗧𝗵𝗲 𝗣𝗼𝘄𝗲𝗿 𝗼𝗳 𝗛𝗮𝘀𝗵𝗶𝗻𝗴: If you’re stuck on "how to store this," a Hash Map is usually the answer. It turns O(N^2) searches into O(1) lookups by mapping keys to values. • 𝗟𝗶𝗻𝗸𝗲𝗱 𝗟𝗶𝘀𝘁𝘀 𝗮𝗿𝗲 "𝗦𝗻𝗮𝗸𝗲𝘀": Don't let them scare you. You can’t jump to the 5th element; you have to follow the head. Master the "Slow and Fast pointer" trick to detect cycles—it’s a classic for a reason. • 𝗗𝗼𝗻'𝘁 𝗙𝗲𝗮𝗿 𝗥𝗲𝗰𝘂𝗿𝘀𝗶𝗼𝗻: Think of it as solving a smaller version of the same problem until you hit a "base case". It's the secret sauce for Trees and Backtracking. 𝗧𝗵𝗲 𝗥𝗲𝗮𝗹 𝗦𝗲𝗰𝗿𝗲𝘁? Consistency beats intensity. The guide suggests that even solving just 2 questions a day for 75 days is enough to build the confidence you need. You don’t need to rush; you just need to start. Coding is more than just data structures—it’s about building things and staying curious. What’s one DSA pattern that finally "clicked" for you? Let’s discuss in the comments! 👇 📌 𝗖𝗼𝗻𝗻𝗲𝗰𝘁 & 𝗙𝗼𝗹𝗹𝗼𝘄: Dinesh Sahu #CodingInterview #DSA #SoftwareEngineering #CareerAdvice #100DaysOfCode

Getting a coding job isn't about solving 1,000+ LeetCode problems. It’s about recognizing the 𝗽𝗮𝘁𝘁𝗲𝗿𝗻𝘀 that actually matter. I just went through a comprehensive DSA Revision Guide, and the biggest takeaway isn't a complex formula—it’s that most interview questions boil down to a few core "mental models": • 𝗧𝗵𝗲 "𝗧𝘄𝗼 𝗣𝗼𝗶𝗻𝘁𝗲𝗿𝘀" 𝗦𝘁𝗿𝗮𝘁𝗲𝗴𝘆: If you see a sorted array or need to find a middle element, stop overthinking. Use a left and right pointer to close in on your target. It’s the foundation for everything from "Two Sum" to "Sliding Windows". • 𝗧𝗵𝗲 𝗣𝗼𝘄𝗲𝗿 𝗼𝗳 𝗛𝗮𝘀𝗵𝗶𝗻𝗴: If you’re stuck on "how to store this," a Hash Map is usually the answer. It turns O(N^2) searches into O(1) lookups by mapping keys to values. • 𝗟𝗶𝗻𝗸𝗲𝗱 𝗟𝗶𝘀𝘁𝘀 𝗮𝗿𝗲 "𝗦𝗻𝗮𝗸𝗲𝘀": Don't let them scare you. You can’t jump to the 5th element; you have to follow the head. Master the "Slow and Fast pointer" trick to detect cycles—it’s a classic for a reason. • 𝗗𝗼𝗻'𝘁 𝗙𝗲𝗮𝗿 𝗥𝗲𝗰𝘂𝗿𝘀𝗶𝗼𝗻: Think of it as solving a smaller version of the same problem until you hit a "base case". It's the secret sauce for Trees and Backtracking. 𝗧𝗵𝗲 𝗥𝗲𝗮𝗹 𝗦𝗲𝗰𝗿𝗲𝘁? Consistency beats intensity. The guide suggests that even solving just 2 questions a day for 75 days is enough to build the confidence you need. You don’t need to rush; you just need to start. Coding is more than just data structures—it’s about building things and staying curious. What’s one DSA pattern that finally "clicked" for you? Let’s discuss in the comments! 👇 📌 𝗖𝗼𝗻𝗻𝗲𝗰𝘁 & 𝗙𝗼𝗹𝗹𝗼𝘄: Dinesh Sahu #CodingInterview #DSA #SoftwareEngineering #CareerAdvice #100DaysOfCode

Trying to solve every LeetCode problem out there? That’s probably the slowest way to prepare. Even if you solve 2 questions daily, it will take years to go through everything. And interviews don’t test how many problems you have done. They test how you think. What actually matters? 👉 Pattern recognition Once you start spotting patterns, a lot of problems feel familiar instead of scary. Instead of random practice, try this: Pick one pattern at a time: Sliding Window Two Pointers Binary Search Graphs (BFS/DFS) Dynamic Programming Backtracking Heaps / Top K Go deep, not wide. Simple plan: → Pick 1 pattern → Solve 2 problems daily → Stick with it for a few weeks But here’s the real game changer 👇 After each problem, take 2 mins to note: What approach worked Where you got stuck What you’ll do differently next time Random practice feels productive. Structured practice actually works. If you are preparing right now, this shift can save you months. Comment "DSA" if you want a simple pattern roadmap 👍 #DSA #leetcode #codinginterview #developers #interviewpreparation

100 Leetcode Problems solved. When I started, even “easy” problems felt confusing. I used to jump straight into coding and get stuck more often than not. Over time, I changed my approach. Instead of rushing to solutions, I started focusing on: 🔹breaking problems down before coding 🔹identifying patterns (especially in stacks, arrays, and linked lists) 🔹understanding time & space complexity 🔹learning how to optimize brute force approaches That shift made a big difference. Now, I’m not just solving problems — I’m thinking more like how I would in an interview setting: “How can I explain this clearly?” “Is this the most optimal approach?” “What edge cases am I missing?” 100 is still just the beginning, but it feels good to see progress from where I started. Next goal: improve problem-solving speed + consistency, and keep strengthening core DSA concepts. If you're on the same path — keep going. It’s slow, but it adds up. #LeetCode #DSA #InterviewPrep #ProblemSolving #Java #SoftwareEngineering

🚀 Day 14 of 100 Days LeetCode Challenge Problem: The K-th Lexicographical String of All Happy Strings of Length n Today’s problem is a perfect blend of Backtracking + Lexicographical Ordering 🔥 💡 Key Insight: A happy string: Uses only 'a', 'b', 'c' No two adjacent characters are the same 👉 Instead of generating all strings blindly, we: Build valid strings using backtracking Maintain lexicographical order naturally 🔍 Core Approach: 1️⃣ Backtracking (DFS) Start building string character by character At each step: Choose from 'a', 'b', 'c' Skip if same as previous character 2️⃣ Lexicographical Order Always try characters in order: 'a' → 'b' → 'c' 3️⃣ Stop Early Once we reach the k-th string, stop recursion 👉 If total strings < k → return "" 🔥 What I Learned Today: Backtracking is powerful for constraint-based generation Ordering decisions early helps avoid extra sorting Early stopping = major optimization 📈 Challenge Progress: Day 14/100 ✅ 2 weeks strong! LeetCode, Backtracking, Recursion, Lexicographical Order, Strings, DFS, DSA Practice, Coding Challenge, Problem Solving #100DaysOfCode #LeetCode #DSA #CodingChallenge #Backtracking #Recursion #Strings #ProblemSolving #TechJourney #ProgrammerLife #SoftwareDeveloper #CodingLife #LearnToCode #Developers #Consistency #GrowthMindset #InterviewPrep

🚀 Master Time Complexity Like a Pro! Understanding time complexity is not just for interviews — it’s the foundation of writing efficient and scalable code. Here’s a quick cheat sheet of common patterns every developer should know: ✔ Single loop → O(n) ✔ Nested loops → O(n²) ✔ Halving input → O(log n) ✔ Divide & Conquer → O(n log n) 💡 If you can identify patterns, you can solve problems faster — both in coding rounds and real-world systems. 📌 Bookmark this for your coding journey! #programming #dotnet #coding #algorithms #datastructures #softwareengineering #developer #dsa #dotnetfullstackdeveloper #dotnet #interviewprep #developers