Memory Bug in C++: Virtual Functions and Pointer Arithmetic

Day 51 on LeetCode — Permutation in String 🔤✅ Today’s problem was a strong application of the Sliding Window + Frequency Count technique. 🔹 Approach Used in My Solution The goal was to check if any permutation of s1 exists as a substring in s2. Key idea in the solution: • Use two frequency arrays (size 26) to track character counts • Initialize frequencies for s1 and the first window of s2 • Compare both frequency arrays — if equal, permutation exists • Slide the window across s2:   – Add incoming character   – Remove outgoing character • Check for a match at each step This ensures we efficiently check all substrings of size k without recomputing frequencies. ⚡ Complexity: • Time Complexity: O(n) • Space Complexity: O(1) 💡 Key Takeaways: • Mastered sliding window with fixed-size frequency arrays • Learned how to efficiently detect anagram/permutation patterns • Reinforced optimizing from brute force to linear-time solutions #LeetCode #DSA #Algorithms #DataStructures #SlidingWindow #Strings #Hashing #FrequencyArray #ProblemSolving #Coding #Programming #Cpp #STL #SoftwareEngineering #ComputerScience #CodingPractice #DeveloperLife #TechJourney #CodingDaily #100DaysOfCode #BuildInPublic #AlgorithmPractice #CodingSkills #Developers #TechCommunity #SoftwareDeveloper #EngineeringJourney

Solved a great DP problem today: Count Binary Strings Without Consecutive 1’s. Given a length n, the task is to count all distinct binary strings such that no two 1s are adjacent. Example: n = 3 → 000, 001, 010, 100, 101 → 5 n = 2 → 00, 01, 10 → 3 The key insight: 1. Strings ending with 0 can be formed by appending 0 to all valid strings of previous length. 2. Strings ending with 1 can only be formed by appending 1 to strings that previously ended with 0. This leads to a simple DP relation: 1. zero[i] = zero[i-1] + one[i-1] 2. one[i] = zero[i-1] So the pattern follows a Fibonacci-style sequence, and the problem can be solved in: O(n) time and O(1) space I enjoy how problems like this look simple at first, but the right state definition makes them very elegant. #DataStructures #Algorithms #DynamicProgramming #Coding #ProblemSolving #Cpp #Programming #SoftwareDevelopment

my weekend rabbit hole this time: does Box<dyn Trait> actually matter in hot loops? built a pipeline with 8 operations running over 10 million floats. one version with Box<dyn Processor>, one with generics. same logic, same values, same machine. 118ms vs 13ms. WILD the vtable itself isn't even the problem, 2ns per call, genuinely irrelevant. the real issue is what it stops the compiler from doing. with dyn Trait it can't inline across steps, can't vectorize, can't use SIMD. just calls function pointers one by one. with generics it knows every type at compile time and goes crazy, fuses all the operations, auto-vectorizes the whole loop, multiple elements per cycle. same code. the compiler just had more information and used it. worth auditing if you have Box<dyn Trait> in anything performance sensitive. sometimes you need the flexibility. but if the types are known at compile time, you might be paying 10x for an abstraction you don't actually need repo below if you want to run it on your machine https://lnkd.in/drtUJTwq #rust #programming #performance #systems #lowlevel #softwaredevelopment #rustlang #softwareengineering #coding #techcommunity

🚀 Day 11 of 100 Days LeetCode Challenge Problem: Complement of Base 10 Integer Today’s problem is a clean example of bit manipulation fundamentals 🔥 💡 Key Insight: To find the complement: Convert the number to binary Flip all bits (0 → 1, 1 → 0) Convert it back to decimal 👉 But here’s the trick: We only flip significant bits (ignore leading zeros) 🔍 Optimized Approach: Create a bitmask with all bits set to 1 (same length as n) Then: complement = n XOR mask 👉 Example: n = 5 → (101) mask = 111 Result = 101 ⊕ 111 = 010 → 2 🔥 What I Learned Today: XOR is powerful for bit flipping operations Bitmasking simplifies binary problems Always consider binary representation constraints 📈 Challenge Progress: Day 11/100 ✅ Bit by bit improving! LeetCode, Bit Manipulation, XOR, Binary Representation, Bitmasking, DSA Practice, Coding Challenge, Problem Solving, Algorithms #100DaysOfCode #LeetCode #DSA #CodingChallenge #BitManipulation #Binary #XOR #ProblemSolving #TechJourney #ProgrammerLife #SoftwareDeveloper #CodingLife #LearnToCode #Developers #Consistency #GrowthMindset #InterviewPrep

🚀 Day 69 of #100DaysOfCode 🔥 Problem: Majority Element II (LeetCode 229) Today’s challenge was all about finding elements that appear more than ⌊n/3⌋ times in an array. Sounds simple, but the twist is doing it efficiently! 💡 Key Insight: Instead of counting frequencies using extra space, we can use an optimized approach based on the Boyer-Moore Voting Algorithm. ✨ Approach Highlights: • There can be at most 2 majority elements (> n/3) • Maintain 2 candidates and their counts • First pass → find potential candidates • Second pass → verify their frequency ⚡ Why this works? Because any element appearing more than n/3 times will survive the elimination process. 📈 Complexity: • Time: O(n) • Space: O(1) 🎯 Takeaway: Smart algorithms > brute force. Understanding patterns like voting algorithms can save both time and space! #DSA #LeetCode #CodingJourney #ProblemSolving #100DaysOfCode #Algorithms #Programming

 Day 12 of #30DaysOfLeetCode Solved #26 – Remove Duplicates from Sorted Array using C. Problem: Given a sorted array, remove duplicates in-place and return the number of unique elements while keeping the order unchanged. Approach: • Used the two-pointer technique • One pointer scans the array • Another pointer stores only unique elements • Since the array is already sorted, duplicates appear next to each other – which makes the solution efficient Performance: • Runtime: 0 ms (Beats 100% ) • Memory: 12.98 MB What I learned today: • How powerful the two-pointer technique is • Writing clean in-place algorithms without extra memory • Better understanding of array manipulation • Small problems help build strong fundamentals #LeetCode #DSA #Algorithms #TwoPointers #CProgramming #ProblemSolving

DSA Visualized Day 7 - Sliding Window Maximum (O(n)) At first glance, this problem looks like O(n²) But with the right structure, it becomes O(n). Given an array and a window size k, Find the maximum in every sliding window. Example: [1, 3, -1, -3, 5, 3, 6, 7], k = 3 Output → [3,3,5,5,6,7] The naive approach For every window: → scan all k elements -Repeated work -Same elements checked again and again -The key idea Not every element deserves to stay. When a new number comes in: -Smaller elements before it become useless -They will never be the maximum again The trick: Monotonic Deque We maintain a deque such that: * Front → always the maximum * Values → decreasing order At every step: -Remove elements outside the window -Remove smaller elements from the back -Add current element -Front gives the answer We don’t store the full window We store only what can become the maximum Complexity -Each element is added once -Each element is removed once O(n) time, O(k) space #DSA #DataStructures #Algorithms #SlidingWindow #MonotonicDeque  #LeetCode #CodingInterview #ProblemSolving  #SoftwareEngineering #SystemsProgramming #LowLatency  #Tech #Developers #Coding #LearnToCode

Heap Sort is a comparison-based sorting algorithm based on the Binary Heap data structure. It is an optimized version of selection sort. The algorithm repeatedly finds the maximum (or minimum) element and swaps it with the last (or first) element. Using a binary heap allows efficient access to the max (or min) element in O(log n) time instead of O(n). The process is repeated for the remaining elements until the array is sorted. Overall, Heap Sort achieves a time complexity of O(n log n). #softwareengineer #datastructures #coding #algorithms #programming

🔥 𝗖 𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴 𝗜𝗻𝘁𝗲𝗿𝘃𝗶𝗲𝘄 𝗧𝗿𝗮𝗽 – 𝗕𝗶𝘁-𝗳𝗶𝗲𝗹𝗱 𝗔𝗱𝗱𝗿𝗲𝘀𝘀𝗶𝗻𝗴 Let’s test your understanding of 𝘀𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗲𝘀 𝗮𝗻𝗱 𝗯𝗶𝘁-𝗳𝗶𝗲𝗹𝗱𝘀 𝗶𝗻 𝗖. Consider the following code. ❓ 𝗤𝘂𝗲𝘀𝘁𝗶𝗼𝗻 𝗳𝗼𝗿 𝗖 / 𝗘𝗺𝗯𝗲𝗱𝗱𝗲𝗱 𝗘𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝘀 What will happen when this program is compiled?  A️) Both addresses will print normally  B️) Compiler error for ptr2  C️) Runtime crash  D️) Undefined behavior but compiles successfully 💡 𝗕𝗼𝗻𝘂𝘀 𝗤𝘂𝗲𝘀𝘁𝗶𝗼𝗻: Why does the C standard treat 𝗯𝗶𝘁-𝗳𝗶𝗲𝗹𝗱𝘀 𝗱𝗶𝗳𝗳𝗲𝗿𝗲𝗻𝘁𝗹𝘆 𝗳𝗿𝗼𝗺 𝗻𝗼𝗿𝗺𝗮𝗹 𝘀𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗲 𝗺𝗲𝗺𝗯𝗲𝗿𝘀 𝘄𝗵𝗲𝗻 𝗶𝘁 𝗰𝗼𝗺𝗲𝘀 𝘁𝗼 𝗮𝗱𝗱𝗿𝗲𝘀𝘀𝗶𝗻𝗴? 💬 Drop your answer in the comments and explain 𝘄𝗵𝘆. Let's see how many developers know this subtle C language rule! #CProgramming #EmbeddedSystems #BitFields #InterviewQuestion #CodingChallenge #SoftwareEngineering

Solved today’s LeetCode Daily and it made me pause 👇 “XOR After Range Multiplication Queries I” At first glance, it looks like: Segment Tree? Lazy Propagation? Some heavy optimization? 🤯 But the reality? Sometimes… brute force wins. --- Given constraints were small. And that completely changes the game. So instead of overengineering: ✔️ Just simulate each query ✔️ Jump with k steps ✔️ Apply multiplication (mod 1e9+7) ✔️ Take final XOR And that’s it. --- The interesting part 👇 As developers, we are trained to think: “Optimize first” But problems like this remind us: 👉 Understand constraints before choosing approach Because honestly, A simple O(n * q) solution can beat an overcomplicated design any day. --- What I learned today: • Not every problem needs advanced DS • Constraints are part of the problem statement for a reason • Simplicity is underrated --- Consistency check ✅ One more problem done. --- Curious 👇 Comment your approach. #LeetCode #DSA #Programming #Coding #Developers #ProblemSolving #Rust