Optimize Systems with FIFO Queues in DSA

Solved 𝗟𝗖 𝟮𝟲𝟰𝟬 · Find the Score of All Prefixes of an Array (Medium) First glance at the problem? Skimmed it, saw "prefix" and some operation on elements — 𝗮𝘀𝘀𝘂𝗺𝗲𝗱 𝗶𝘁 𝘄𝗮𝘀 𝘀𝗼𝗺𝗲𝘁𝗵𝗶𝗻𝗴 𝗹𝗶𝗸𝗲 𝘀𝗾𝘂𝗮𝗿𝗶𝗻𝗴. Wrote code. Wrong answer. Read the statement properly this time. Turns out conver[i] = arr[i] + max(arr[0..i]) — each element gets added to the 𝗿𝘂𝗻𝗻𝗶𝗻𝗴 𝗺𝗮𝘅 up to that index. The score of a prefix is just the sum of its conversion array. Track 𝗺𝗮𝘅_𝘀𝗼_𝗳𝗮𝗿 as you iterate, add it to the current element, accumulate into score. 𝗢𝗻𝗲 𝗽𝗮𝘀𝘀, 𝗱𝗼𝗻𝗲. Day 39 — #1000DaysOfLearning #DSA #LeetCode #Python #1000DaysOfLearning #LearningInPublic

Day 109 Backtracking patterns are repeating again — and that’s a good sign. #Day109 🧩 78. Subsets How today went: • Used recursion to explore all elements • At each step, decide to include or skip the current element • Append current subset → explore → then pop to backtrack • Move to the next index and repeat What I’m noticing: Subsets is one of the cleanest backtracking patterns: → choose → explore → undo Another revision day, but clarity is improving. Consistency continues. #LeetCode #DSA #Python #Backtracking #Recursion #LearningInPublic #Consistency

Day 105 Backtracking is becoming more structured now. #Day105 🧩 131. Palindrome Partitioning How today went: • Iterated through the string, taking one substring at a time • Used DFS to explore partitions • Checked if each substring is a palindrome before going deeper • Built the result step by step and backtracked when needed What clicked: At each step: → choose a substring → validate (palindrome) → explore further → backtrack This pattern is repeating across problems. Backtracking is slowly becoming more intuitive. #LeetCode #DSA #Python #Backtracking #DFS #Recursion #LearningInPublic #Consistency

Day 119 Same problem family, new constraint — but now it feels easier. #Day119 🧩 40. Combination Sum II How today went: • Very similar to Combination Sum • First step: sort the array • Move to i + 1 (each element used once) • Skip duplicates to avoid repeating combinations Key idea: 👉 No reuse of same element 👉 Handle duplicates carefully What I realized: Once you understand the base pattern, variants like this become much easier. Backtracking is starting to feel natural now. #LeetCode #DSA #Python #Backtracking #Recursion #LearningInPublic #Consistency

Day 121 Backtracking with clear rules makes things simple. #Day121 🧩 22. Generate Parentheses How today went: • Tracked two values: open and close • Add '(' when open < n • Add ')' when close < open • Build the string step by step using recursion What clicked: It’s all about following the rules: → never let close exceed open → keep building valid sequences Backtracking here is clean: add → recurse → backtrack Simple logic, strong pattern. #LeetCode #DSA #Python #Backtracking #Recursion #LearningInPublic #Consistency

Day 27/100 – DSA Practice Solved LeetCode 459: Repeated Substring Pattern today. Key Insight: If a string s is formed by repeating a substring, then it will always exist inside: (s + s)[1:-1] Why this works: Doubling the string generates all possible rotations Removing first & last characters avoids trivial matches If s is found in this modified string, it confirms a repeating pattern This elegant trick reduces the problem to a simple one-liner and highlights the power of pattern observation in strings. Approach Used: return s in (s + s)[1:-1] Constant progress > Perfection. On to the next one! #Day27 #100DaysOfCode #DSA #LeetCode #Python #CodingJourney #ProblemSolving

Beyond String Concatenation  When I started, I used to concatenate strings the old-school way. It was messy, prone to errors, and hard to read The Problem: Using + requires manual type conversion (like str(21)) and gets confusing with all the extra quotes and spaces Solution: F-strings Introduced in Python 3.6, F-strings makes your code: ✅ Readable: You see the full sentence structure ✅ Fast: They are more efficient than older methods ✅ Flexible: You can perform math or call methods directly inside { } It’s a small concept, but it’s one of the easiest ways to make code look 10x more professional. #Python #30DaysOfCode #BCA #LearningInPublic #Day21 #JECRC Day 21/30

Day 111 Backtracking is starting to feel consistent now. #Day111 🧩 39. Combination Sum How today went: • Used backtracking with index i • Two choices: → stay at i (reuse the same element) → move to i + 1 (try next element) • Track the current total • If total == target → add result • If total > target → stop that path What I realized: This problem is about: → controlling index movement → managing the running total Same pattern, different control. Revision is making it clearer. #LeetCode #DSA #Python #Backtracking #Recursion #LearningInPublic #Consistency

Day 13/100 – Understanding Before Solving Today’s problem: Reverse String At first glance, it looks simple—but the real goal is to understand how to solve it efficiently. The challenge is to reverse the string in-place, meaning without using extra memory. Approach Explained: We use the two-pointer technique: One pointer starts from the beginning One from the end Swap characters and move inward This avoids creating a new array and keeps the solution optimal. Time Complexity: O(n) Space Complexity: O(1) Key Learning: Writing code is important, but understanding why it works is what truly builds strong problem-solving skills. One step closer to mastering DSA. #100DaysOfCode #DSA #Learning #ProblemSolving #Python #LeetCode #GrowthMindset

Day 110 Same pattern, new constraint. #Day110 🧩 90. Subsets II How today went: • Very similar to the basic Subsets problem • First step: sort the array • While iterating, skip duplicate elements to avoid repeating subsets • Use the same backtracking pattern: append → recurse → pop What I learned: The core pattern stays the same — only the duplicate handling logic changes. This small condition makes a big difference. Backtracking is becoming more predictable now. #LeetCode #DSA #Python #Backtracking #Recursion #LearningInPublic #Consistency