Exploring STL in C++: Unlocking Superpowers for Developers

 Day 6 – LeetCode Challenge Today, I solved Problem #128: “Longest Consecutive Sequence” using C++. 🔍 Problem Overview: The task is to find the length of the longest consecutive elements sequence in an unsorted integer array. The key challenge is to ensure the solution works in O(n) time complexity. 💡 Approach: To achieve linear time, I used an unordered_set to quickly check if a number exists. For each number, I only begin counting a sequence when it is the start of a new streak (i.e., (num - 1) does not exist in the set). This ensures each number is processed only once. 🧠 Algorithm Design: Insert all elements into an unordered_set for O(1) average lookups. For every number, check if it's the start of a sequence. If yes, count forward (num + 1, num + 2, ... ) while elements exist in the set. Track and update the maximum streak length. ⏱ Time Complexity: O(n) 📌 Space Complexity: O(n) #LeetCode #CPlusPlus #DSA #100DaysOfCode #ProblemSolving #Algorithms #CodingChallenge #TechCommunity #GeetaUniversity

I just wrote my First code of making function in C++, I am learning coding basics. Wish me luck. /*Write a C++ program that defines a function calculateAverage() which  takes three marks as input and returns the average. Call this function from main() and  display the result.*/ #include <iostream> using namespace std; float calculateAverage(float x, float y, float z); int main() {     float AVG;     float x,y,z;     cout<<"ENTER THE MARKS OF YOUR 3 SUBJECTS:  ";     cin>>x>>y>>z;     calculateAverage( x, y, z);     AVG= calculateAverage(x,y,z);     cout<<AVG; } float calculateAverage(float x, float y, float z) {     float avg;     avg= (x+y+z)/3;     return avg; }

✅ Day 56 of LeetCode Medium/Hard Edition Today’s challenge was “Count All Valid Pickup and Delivery Options” — an elegant blend of recursion, combinatorics, and dynamic programming 🚚📦 📦 Problem: You’re given n orders, where each order has one pickup and one delivery. You must count all valid sequences such that delivery(i) always appears after pickup(i). Since the result can be very large, return it modulo 10⁹ + 7. 🔗 Problem Link: https://lnkd.in/ggJbFBYE ✅ My Submission: https://lnkd.in/gJd5AQuh 💡 Thought Process: At each step, we have two choices: Pick up a new order (if any pickups remain). Deliver one of the already picked (but not yet delivered) orders. We use recursion to explore these choices, and memoization (DP) to store intermediate results for (pick, del) states. This ensures we count every valid sequence efficiently. ⏱ Complexity: Time: O(n²) Space: O(n²) 🔥 Key Takeaway: This problem elegantly captures the symmetry of combinatorial counting — every pickup-delivery pairing contributes to an exponential number of valid sequences, beautifully controlled through recursion and DP 💫 #LeetCodeMediumHardEdition #100DaysChallenge #DynamicProgramming #Recursion #Combinatorics #ProblemSolving #Java

💡 LeetCode 3354 — Make Array Elements Equal to Zero Today I solved one of the most conceptually beautiful array problems I’ve come across. At first glance, it’s labeled as Easy, but it actually blends multiple concepts — making it feel more like a Medium problem. What makes it special: It involves simulation — tracking how a pointer moves across the array. It demonstrates call by reference for array objects in Java. The pointer movement feels like simple harmonic motion (SHM) in physics — oscillating back and forth after each decrement! Here, every time the pointer hits a non-zero value, it decrements it and reverses its direction — just like a particle turning around at the ends of SHM. A perfect example of how programming logic and physics intuition can align beautifully. 🧠 Concepts Involved: Array simulation Recursion and cloning (for preserving states) Java’s reference behavior with arrays LeetCode may call it Easy, but conceptually it deserves a Medium tag for its depth and insight. #LeetCode #Java #DSA #ProblemSolving #Simulation #LearningEveryday

🚀 Solved LeetCode Problem: Single Number (C++) 🔢 Every element appears twice except one This problem is a great reminder that bit manipulation can often beat complex data structures with pure logic and simplicity. 💡 Approach: Used the XOR operator (^) — since x ^ x = 0 and x ^ 0 = x, all duplicate numbers cancel out, leaving the single unique number. 🧠 Key Takeaways: Time Complexity: O(n) Space Complexity: O(1) Concept: Bit Manipulation + XOR Property 💬 Elegant, fast, and minimal — that’s the beauty of C++. 🔖 #LeetCode #Cplusplus #DSA #Coding #ProblemSolving #BitManipulation #CodingInterview #SoftwareEngineering #CodeNewbie #TechLearning #C++Developer #Algorithm #DataStructures #CodingChallenge #XOR #CodeDaily #LearnToCode

💡 LeetCode 1897 – Redistribute Characters to Make All Strings Equal 💡 Today, I solved LeetCode Problem #1897, a neat string frequency problem that tests your understanding of counting characters and modular arithmetic — a perfect exercise for logical reasoning and precision in coding. ⚙️📊 🧩 Problem Overview: You’re given an array of strings words. You can rearrange the characters of the strings however you like. Your task is to check if it’s possible to make all strings equal after redistributing the characters. 👉 Example: Input → ["abc","aabc","bc"] Output → true 💡 Approach: 1️⃣ Create a frequency array of size 26 (for each lowercase English letter). 2️⃣ Count how many times each character appears across all strings. 3️⃣ For all characters, check if their frequency is divisible by the number of words — ensuring equal distribution. 4️⃣ If all checks pass, return true; otherwise, return false. ⚙️ Complexity Analysis: ✅ Time Complexity: O(n * m) — where n is the number of words and m is the average length of each word. ✅ Space Complexity: O(1) — Only a fixed 26-element array is used. ✨ Key Takeaways: Strengthened understanding of frequency counting and modular logic. Reinforced clean looping structures and optimized space usage. Showed how simple math concepts like divisibility can simplify logic. 🌱 Reflection: This problem is a reminder that clean, logical solutions often come from understanding patterns rather than brute-forcing. Paying attention to problem constraints leads to more elegant, scalable code. 🚀 #LeetCode #1897 #Java #StringManipulation #FrequencyCounting #ProblemSolving #AlgorithmicThinking #CleanCode #DSA #CodingJourney #ConsistencyIsKey

📌 Day 159 of Coding - Make Array Elements Equal to Zero (LeetCode - Easy) 🎯 Goal: Given an integer array nums, find the number of valid starting positions and directions such that by repeatedly decrementing and reversing direction (based on the rules), all elements eventually become 0. 💡Approach & Debugging: First computed total sum using Arrays.stream(nums).sum(). Maintained two prefix sums : left and right. For each index i where nums[i] == 0: Incremented left and decremented right progressively. Checked whether the left and right sums balance according to the movement rules. Counted valid selections when the balance was perfect or off by just one. ✔️ Time Complexity: O(N) - single pass through the array. ✔️ Space Complexity: O(1) - constant extra space. #Day159 #LeetCode #Simulation #Arrays #PrefixSum #Java #ProblemSolving #DSA #CodingChallenge #100DaysOfCode #Algorithms #InterviewPrep #SoftwareEngineering #DataStructures #CodeNewbie #ProgrammersLife

🌟 Day 85 of My #100DaysOfCode Challenge 🧩 Problem: LeetCode 119 – Pascal’s Triangle II 🧠 Understanding the Problem We need to return the rowIndexth (0-indexed) row of Pascal’s Triangle. Each number is formed by adding the two numbers directly above it from the previous row. 📘 Example: Input: rowIndex = 3 Output: [1, 3, 3, 1] ⚙️ Approach Start with [1] as the first row. For each new row, update the list from right to left (so we don’t overwrite values that we still need). Append 1 at the end of each iteration to complete the row. 🕒 Complexity Time Complexity: O(n²) Space Complexity: O(n) ✅ (optimized — we use only one list) 💡 Key Learning This problem emphasizes in-place updates — a technique often used to optimize space in dynamic programming problems. ✨ Takeaway Building Pascal’s Triangle row by row mirrors how small consistent steps lead to structured growth — just like progress in coding! 🚀 💬 “Each layer of learning strengthens the next — one row at a time.” 💛 #Day85 #LeetCode #Java #DSA #DynamicProgramming #ProblemSolving #100DaysOfCode #CodingChallenge