Solved Longest String Chain problem using DP and Sorting

1526. Minimum Number of Increments on Subarrays to Form a Target Array 1526. Minimum Number of Increments on Subarrays to Form a Target Array Difficulty: Hard Topics: Array, Dynamic Programming, Stack, Greedy, Monotonic Stack, Biweekly Contest 31 You are given an integer array target. You have an integer array initial of the same size as target with all elements initially zeros. In one operation you can choose any subarray from initial and increment each value by one. Return the minimum number of operations to form a target array from initial. The test cases are generated so that the answer fits in a 32-bit integer. Example 1: Input: target = [1,2,3,2,1] Output: 3 Explanation: We need at least 3 operations to form the target array from the initial array. [0,0,0,0,0] increment 1 from index 0 to 4 (inclusive). [1,1,1,1,1] increment 1 from index 1 to 3 (inclusive). [1,2,2,2,1] increment 1 at index 2. [1,2,3,2,1] target array is formed. Example 2: Input: target = [3,1,1,2] Output: 4 Explanation: [0,0,0,0] -> [1,1,1,1] -> [1,1,1,2] -> [2,1,1,2] -> [3,1,1,2] https://lnkd.in/geCSn5Fq

🚀 Tried breaking down Pascal’s Triangle in the simplest way 👇 We’ve all seen this pattern(Pascal's Triangle) somewhere but have you ever wondered how it’s actually generated? 🤔 The question is simple: 👉 Given an integer n, generate the first n rows of Pascal’s Triangle. For example, when n = 3 💡 How this approach clicked: While thinking about how each element is formed, I realized that every value in Pascal’s Triangle is just a combination (nCr) and this relation C(n,r)=C(n,r−1)∗(n−r+1)/r , is connecting each next element with the previous one computed. This not only makes the logic cleaner but also eliminates redundant factorial computations. so, here is the code and the dry run of the solution , once you see it this way, Pascal’s Triangle feels surprisingly simple! 😄 #C++ #DSA #ProblemSolving #CodingJourney #PascalTriangle #Programming #Learn #CodeVisualization #WomenInTech

Question1: Used top-down dynamic programming with memoization to minimize recalculations for overlapping subproblems. For each segment, maintained the running maximum and total sum to compute wasted space efficiently. Explored all possible partition points recursively to find the minimum total wasted space with at most k resizings. Question2: Sorted the prices to make it easier to apply a greedy check for minimum tastiness gaps. Used binary search on the tastiness value to find the maximum possible minimum difference between chosen candies. Implemented a greedy okay function to verify if a given tastiness can be achieved by selecting k candies. Question3: Sorted events by start time to process them in chronological order. Used a min-heap to track the best value from non-overlapping previous events. Combined the best previous event value with the current event to maximize the total value. #sde #softwaredevelopment

🚀 Day 46 of #100DaysOfCode Today I tackled one of the classic C programming challenges: Matrix Multiplication 💥 🔢 The program takes two square matrices of size n × n as input from the user, multiplies them using nested loops, and outputs the resulting matrix. I used Variable Length Arrays (VLAs) for dynamic sizing and implemented the standard multiplication logic: 🧠 This challenge helped reinforce: Loop nesting for multidimensional arrays Matrix indexing logic Clean, symmetric output formatting for better readability 📸 I’ve kept the output structured for easy sharing and future upgrades (thinking about adding grid-style display or color-coded elements next!). 💡 Code Concepts Covered Dynamic matrix allocation User input handling Matrix multiplication algorithm Output formatting 🔧 Next Steps Thinking of adding: Input validation Grid-style matrix display Support for non-square matrices 🔗 Hashtags #Day46 #100DaysOfCode #CProgramming #CodeNewbie #LearnToCode #CodingChallenge #ProblemSolving #CodeDaily #ProgrammingInC kirti singh

Solved Pow(x, n) (LeetCode #50) recently, and this one turned out to be more than just another coding exercise. 💡 32-bit Integer Insights: 🔹 An integer uses 32 bits: 1 bit is for the sign (positive/negative), and 31 bits store the actual value. 🔹 Negative values: Represented from -1 to -2,147,483,648 (a total of 2,147,483,648 values). 🔹 Positive values: From 1 to 2,147,483,647 (a total of 2,147,483,647 values), since zero also needs a spot. 🔹 That’s why the maximum positive (2,147,483,647) and maximum negative (-2,147,483,648) values in 32-bit integers don’t match. 🔀 My Fix: Convert n to a long before using recursion. This avoids overflow issues and ensures the code works for all edge cases. This challenge not only strengthened my understanding of binary exponentiation, but also revised those crucial details about 32-bit integer representation. #LeetCode #DSA #Programming #100DaysOfCode #BinaryExponentiation #TechLearning #CodingJourney #PGPByAnchal

LeetCode | Maximum Subarray - Solved using Kadane’s Algorithm (C++) Just solved the Maximum Subarray problem on LeetCode - one of the most classic dynamic programming problems that teaches the power of efficient subarray computations. Intuition: At every step, decide whether to extend the current subarray or start a new one based on which gives a larger sum. Approach: This is achieved using Kadane’s Algorithm, which runs in linear time - keeping track of the current maximum subarray sum and updating the global maximum as we iterate. Complexity: Time Complexity: O(n) Space Complexity: O(1)

Top 10 common algorithms used in development: 1. Binary Search 2. Merge Sort 3. Quick Sort 4. Breadth-First/Depth-First Search 5. Dijkstra Shortest Path 6. Floyd-Warshall All-Source Shortest Path 7. Dynamic Programming (Knapsack) 8. Union-Find 9. Topological Sort 10. KMP String Matching Have you learned all of these?

#NationSkill Day 99| Problem Solving Challenge Today’s task: Get Minimum Squares Platform: #GeeksforGeeks | Concepts Used: Dynamic Programming (DP) Problem: Find the minimum number of perfect squares that sum up to a given integer n. Approach: Bottom-Up DP — calculating the minimum count for each value up to n by checking all perfect squares less than it. Example: Input: 6 → Output: 3 Explanation → 1*1 + 1*1 + 2*2 = 6 Time Complexity: O(n * √n)

Day Two: Diving Deeper into C – The Power of Precision and Pointers 🚀 Day 2 of my deep dive into C programming was incredibly productive, spanning three critical areas that enhance control and precision in low-level development. Boolean Logic: Successfully implemented bool functions to handle clear, concise True/False logic. This is key for creating highly readable and efficient decision-making structures within programs. String Manipulation: Explored the mechanics of using multiple arrays of characters (the C way of handling strings). Understanding how to organize and access collections of character data is fundamental for text processing. Pointers Unlocked: Built directly on Day 1's foundation by learning the practical application of Pointers. This exercise truly demonstrated how storing and manipulating the address of a variable allows for powerful, dynamic control over memory. Connecting these concepts reveals the true power of C: the ability to manage data types, logic, and memory with absolute precision. 💡 Next Goal: I'm already working on it 🚀! #CProgramming #Pointers #DataStructures #LowLevelProgramming #LearningInPublic #Day2 #ImanLearns