Dived deep into some core concepts that shape how efficient and safe programs are built: • Object Lifetime (Stack & Scope Lifetimes) – understanding how and when objects are created and destroyed • Memory Model – getting clarity on how memory is structured and accessed • Smart Pointers – explored std::unique_ptr, std::shared_ptr, and std::weak_ptr (thanks to Yan Chernikov for the clear explanations) • Deep dive into std::unique_ptr – ownership and zero-overhead abstraction • Memory Leaks – why they happen and how to prevent them • Forward Declarations – reducing dependencies and improving compile times • Header Files in C++ – understanding structure and best practices (Saldina Nurak) Each of these topics adds another layer to writing cleaner, safer, and more efficient C++ code. Still a lot to explore, but enjoying the process of strengthening fundamentals step by step. #CPP #LearningInPublic #Programming #SoftwareEngineering #SmartPointers #MemoryManagement #100DaysOfCode

🚀 Built a Function Pointer-Based Calculator Exploring the power of function pointers in C... 🚀 one of the most powerful and often underrated concepts in C — Function Pointers and Callback Functions. 💡 Instead of using traditional if-else or switch-case logic, I designed a dynamic approach using: ✔ Function Pointer Array ✔ Callback Mechanism ✔ Modular Multi-file Architecture ✔ Makefile for build automation 📌 This project helped me understand: 🔹 How to achieve dynamic function execution 🔹 Code scalability and maintainability 🔹 Real-world use of callbacks in system-level programming 🛠️ Tech Used: C Programming | Function Pointers | GCC | Makefile 🔗 GitHub Repository: https://lnkd.in/gVKTmBXv I’m continuously exploring low-level programming and embedded systems concepts. #CProgramming #EmbeddedSystems #FunctionPointers #Coding #Learning #GitHub

Day 88 on LeetCode Add Two Numbers 🔗➕💡 A classic linked list problem focusing on digit-wise addition with carry handling. 🔹 Approach Used in My Solution • Traverse both linked lists simultaneously • Maintain a carry variable for overflow • Add corresponding node values + carry • Create new nodes for result using a dummy head • Continue until both lists and carry are fully processed ⚡ Complexity: • Time Complexity: O(max(n, m)) • Space Complexity: O(max(n, m)) 💡 Key Takeaways: • Dummy node simplifies linked list construction • Carry handling is the core concept in this problem • Reinforces simulation of real-world arithmetic using linked lists 🔥 Another step forward in strengthening pointer-based problem solving. #LeetCode #DSA #Algorithms #DataStructures #LinkedList #AddTwoNumbers #CarryLogic #ProblemSolving #Coding #Programming #Cpp #STL #SoftwareEngineering #ComputerScience #CodingPractice #DeveloperLife #TechJourney #CodingDaily #Consistency #100DaysOfCode #BuildInPublic #AlgorithmPractice #CodingSkills #Developers #TechCommunity #SoftwareDeveloper #EngineeringJourney

The C compilation process transforms source code into an executable through four key stages: Preprocessing (handling macros), Compilation (converting code to assembly), Assembly(generating binary object code), and Linking (merging libraries). This sequence ensures human-written logic is correctly mapped to hardware for execution. Understanding this flow is vital for efficient debugging and optimizing software performance. #CProgramming #SoftwareEngineering #CodingTips #TechEducation #Learning

🚀 Day 225 of #300DaysOfCoding Today’s challenge: Maximum Score From Grid Operations (Hard) This problem really tested my understanding of Dynamic Programming + Prefix Sum + State Management. 🔍 Key Learnings: Simple DP on heights was not enough ❌ Needed to carefully handle left & right dependencies Introduced a 2-state DP (include / exclude) to avoid double counting Prefix sums helped in optimizing range sum calculations ⚡ 💡 Main Insight: Each cell must be counted exactly once, and managing when to include a column’s contribution is the real challenge. 🧠 This problem improved my thinking in: Handling tricky DP transitions Avoiding overcounting bugs Breaking complex problems into manageable states 💻 Language: C++ Consistency is the real key — small progress every day adds up 🚀 #leetcode #dsa #coding #programming #cpp #developers #100DaysOfCode #300DaysOfCoding

🚀 Day 33 of 100 Days LeetCode Challenge Problem: Maximum Amount of Money Robot Can Earn Day 33 brings a powerful Dynamic Programming + state management problem 🔥 💡 Key Insight: This is not just a normal grid DP. 👉 We also have a special power (neutralize up to 2 robbers) So the state must include: Position (i, j) Number of neutralizations used (0, 1, or 2) 🔍 Core Approach (DP): 1️⃣ Define DP State dp[i][j][k] → maximum coins at cell (i, j) using k neutralizations 2️⃣ Transitions From top (i-1, j) and left (i, j-1): If current cell ≥ 0: Add coins normally If current cell < 0: 👉 Two choices: Take loss OR use neutralization (if k < 2) 3️⃣ Take Maximum Choose best among all possibilities 4️⃣ Final Answer Max of dp[m-1][n-1][0..2] 🔥 What Makes It Interesting: Multiple states → adds complexity Decision making at each step (use power or not) 🔥 What I Learned Today: DP becomes powerful when handling extra constraints (states) Decision-based problems require exploring all valid paths State design is the most important part of DP 📈 Challenge Progress: Day 33/100 ✅ Leveling up in DP! LeetCode, Dynamic Programming, Matrix, Optimization, State Management, Algorithms, DSA Practice, Problem Solving #100DaysOfCode #LeetCode #DSA #CodingChallenge #DynamicProgramming #Matrix #ProblemSolving #TechJourney #ProgrammerLife #SoftwareDeveloper #CodingLife #LearnToCode #Developers #Consistency #GrowthMindset #InterviewPrep

🚀 Day 4: C Programming Journey Today I explored how control statements guide the flow of execution in a program. 🔹 Conditional Statements: if...else, else...if, switch 🔹 Looping Statements: for, while, do...while 🔹 Jump Statements: break, continue, return, goto Each plays a vital role in decision‑making, repetition, and flow control — forming the backbone of structured programming. #CProgramming #CodingJourney #LearningSeries #SoftwareDevelopment #ProgrammingBasics #CodeFlow

🚀 Day 212 of #300DaysOfCoding Today I solved a challenging DP problem: 👉 Minimum Distance to Type a Word Using Two Fingers This problem really tested my understanding of Dynamic Programming, state optimization, and decision making. 🧠 Key Learning At every step, we have two choices: Use finger 1 Use finger 2 The goal is to minimize total movement distance I implemented a DP solution where: State = positions of both fingers Transition = try both fingers and take minimum ⚙️ Approach Represent each character as coordinates on a grid Use Manhattan Distance for movement Apply Bottom-Up DP (27 × 27 states) Optimize transitions carefully to avoid recomputation 💡 What I Learned DP problems are not just about memorization — they are about thinking in states and transitions Small mistakes in optimization can completely break the solution 😅 Debugging teaches more than solving 🧪 Example Input: "CAKE" Output: 3 🔥 Takeaway Consistency is the real game changer. Every day, I’m getting better at problem-solving and thinking logically. #300DaysOfCoding #DataStructures #Algorithms #DynamicProgramming #CodingJourney #LeetCode #Cplusplus #ProblemSolving

“I wish I knew this roadmap before learning C…” Want to become a professional in C? Here’s a simple roadmap that actually works 👇 - Master basics (syntax, loops, functions) - Learn pointers & memory (MOST IMPORTANT) -Understand stack vs heap & memory layout - Practice file handling & system basics -Write clean, modular code (.h / .c) -Solve problems on HackerRank & LeetCode -Build real projects (data structures, mini tools) -Learn debugging with GDB -Explore advanced topics (function pointers, optimization) 💡 Consistency is the key: Code → Fail → Debug → Repeat #programming #cprogramming #embedded #softwareengineering #learncoding

Implemented a menu-driven Queue using C 💻 Built a simple program demonstrating core queue operations: • Enqueue (Insertion) • Dequeue (Deletion) • Display Worked with front and rear pointers to manage the queue and handled edge cases like overflow and underflow. Attached a short video demo showing the program in action 🎥 This helped reinforce my understanding of data structures and modular coding in C. Next step: implementing a circular queue for better efficiency. #CProgramming #DataStructures #Queue #CodingPractice #LearningByDoing