Hitesh G.

Here is a step-by-step process to pick apart any low-level design question. ----- 𝑆𝐷𝐸 1+ ----- 𝟏. 𝐒𝐂𝐎𝐏𝐄 𝐓𝐇𝐄 𝐏𝐑𝐎𝐁𝐋𝐄𝐌 As you speak with the interviewer, you may list 5-10 requirements for the question. You cannot satisfy these requirements in 45 minutes. Decide on what is important to the system. Pick JUST ONE important requirement, and start with it. The rest can be picked later, if time permits. 𝟐. 𝐋𝐈𝐒𝐓 𝐓𝐇𝐄 𝐀𝐏𝐈𝐬 𝐅𝐈𝐑𝐒𝐓 Users interact with the system using APIs. That's what matters most. Name the APIs sensibly. Walk through how a user will use these APIs to meet the given requirement. Example: In a booking system, how does a customer temporarily lock, pay for, and permanently book a seat? They do it using APIs. Your job is to explain the request flow and interactions. 𝟑. 𝐍𝐎𝐖 𝐃𝐄𝐅𝐈𝐍𝐄 𝐓𝐇𝐄 𝐎𝐁𝐉𝐄𝐂𝐓𝐒 List the request and response parameters. Most of your system's objects will surface here. At this point, you can write the skeleton code, with objects and services. ----- 𝑆𝐷𝐸 2+ ----- 𝟒. 𝐂𝐎𝐍𝐒𝐈𝐃𝐄𝐑 𝐂𝐎𝐍𝐂𝐔𝐑𝐑𝐄𝐍𝐂𝐘 You won't be expected to code a concurrent system. But you will be expected to talk about "how will this system handle concurrent requests?" The usual problems with concurrency are dirty reads and out-of-order processing. Even identifying these problems (without a clear solution) is a big green flag. ----- 𝑆𝐷𝐸 3+ ----- 𝟓. 𝐂𝐎𝐍𝐒𝐈𝐃𝐄𝐑 𝐓𝐄𝐒𝐓 𝐒𝐔𝐈𝐓𝐄𝐒 A system is going to have edge cases. It's the tricky ones that matter most. Noting edge cases, and adapting the system to solve them, is a clear green flag. 𝟔. 𝐂𝐎𝐌𝐌𝐔𝐍𝐈𝐂𝐀𝐓𝐄 𝐂𝐎𝐍𝐒𝐓𝐀𝐍𝐓𝐋𝐘 Walk your interviewer through the code while you write it. You don't need to say everything on your mind, but you DO need to explain everything that's important. In general, over-communication is harmless. Undercommunication leads to confusion. ----- 𝑅𝑒𝑠𝑜𝑢𝑟𝑐𝑒𝑠 ----- 1. Read your writes: https://lnkd.in/dJYZ3Z_7 2. Asynchronous Processing with Futures: https://lnkd.in/d55-j-G8 3. Request Collapsing: https://lnkd.in/dFbJmwJC 4. What are threads? https://lnkd.in/dF4q9ez2 5. Event Bus Publishers and Subscribers: https://lnkd.in/dcciJ4vM 6. Classes and package structuring: https://lnkd.in/dqagPDG9 7. Dependency Inversion: https://lnkd.in/djU2uw4K #SystemDesign

514

7 Comments

Today's POTD Leetcode: 2487. Remove Nodes From the Linked List Question: You are given the head of a linked list. Remove every node which has a node with a greater value anywhere to the right side of it. Return the head of the modified linked list. Eg: Input: head = [5,2,13,3,8] Output: [13,8] Explanation: The nodes that should be removed are 5, 2 and 3. - Node 13 is to the right of node 5. - Node 13 is to the right of node 2. - Node 8 is to the right of node 3. Approach: We need to see the elements from the right side to compare the value with the left. But do we have access to it directly? No, we can only traverse from left to right because it is a singly linked list. Create a vector with pair<int, bool> where int will keep the value of the node while bool will tell me if there is any element on the right which is greater than the current element. If false then there is an element greater than the current element, so we need to remove that element. Start traversing from the right side and only need to keep track of the max value, as we want the max till now. Mark false to the elements that are smaller than the current element. Make a new linked list and take only that element that have a bool value as true. Time Complexity: O(n) Traversal of the linked list, marking of the greater element to the right, creating a list that has bool as true Space Complexity: O(n) Used Vector Please feel free to reach out if you have any doubts regarding the solution!! #LearnInPublic #POTD #Leetcode #CONNECT Code Link:https://lnkd.in/diaycmSx Here is the solution for a better understanding of the approach:

30

DSA is NOW mandatory for ML & DS Roles (PERIOD)! 5 years back, when ML was mostly in research, companies didn't need DSA. They wanted people who could build basic systems and grow them. Now, things are very different. ML research has gone far, but there are many new problems like making it reliable, easy to use, and fast. This needs more engineering work. Chip Huyen, ML Expert, said machine learning work is 90% engineering and 10% research. Even Elon Musk agreed with this. This change has made new jobs, but most learners are still only studying the old stuff. They learn ML, DL, and fancy things but forget about the main part - engineering. DSA is very important, not because you'll use it directly, but because it helps you think better and solve problems. Companies will give you time to learn, and you need to use what you know to learn new things and fix problems. Before, people used to argue about DSA vs Dev. Now, in AI engineering, companies want you to be good at both. You need both skills to move ahead. An Alumni of Antern who learned both DSA and ML got a job at Google as an SWE. P.S: We're opening a waitlist for our next AI Engineering Specialisation(CS001) (DSA+ML+MLOps+GenAI+Python), if interested - https://lnkd.in/gHzdBUG6 .

1,152

75 Comments

Sort the Jumbled Numbers 🔥 24 July 2024, Daily LeetCode Challenge Q: 2191. Sort the Jumbled Numbers 🔥 Intuition Behind this: 🤔 1. Traverse every number in nums and get its mapping value. 2. Sort it based on mapped values. 3. If mapped values are the same then sort based on the index in increasing order. Time Complexity: O(Nlogn) Space Complexity: O(n) For a more detailed explanation visit here: https://lnkd.in/g_yFC-hb Can you develop an optimized solution or share your thoughts on approaching this problem? Comment below! 👇 If you found this helpful, please feel free to like, and share.❤️ Follow me Shiva Kumar for more insightful posts in future:)❤️ #Java #Programming #SoftwareDevelopment #dailycoding #3 #dailyleetcodechallenge Rahul Maheshwari

5

I solved this question from POTD of LeetCode today. This asks us to XOR queries of a subarray. Intution: I will put the queries into a queue. and perform the xor operation on the array from the length given by the query. Code explaination : Declare a queue which will store query array. Declared an array of size queries. While the queue is not empty, remove each query from the queue, assign the first element to start and second element as the end. Run a for loop from start till end and XOR the values. Put them in the index defined and increment index. Return the result array Time complexity: O(Size of query array * Size of subarray) P.S.: I would love to know what are the other ways to optimise this . #dsa #SDE #leetcode

9

🌟 Excited to Share My Latest Editorial on LeetCode! 🌟 I recently tackled a fascinating problem on LeetCode: "Number of Ways to Reorder Array to Get Same BST." This problem not only challenged my algorithmic skills but also provided a great opportunity to delve into combinatorics and unique arrangement counting. I've written an editorial to share my approach and insights into this problem. If you're interested in exploring how combinatorics can be applied to solve complex problems or just want to see a different perspective on tackling this challenge, check out my detailed solution here: Link to Editorial : https://lnkd.in/g9iiqSph Writing this editorial was a rewarding experience, and I hope it can help others in the community. Happy coding! 🚀 #leetcode #coding #programming #combinatorics #algorithm #computerscience #problemsolving #NITDurgapur

18

Today's POTD Leetcode: 2441. Largest Positive Integer That Exists With Its Negative Question: Given an integer array nums that does not contain any zeros, find the largest positive integer k such that -k also exists in the array. Return the positive integer k. If there is no such integer, return -1. Eg: Input: nums = [-1,10,6,7,-7,1] Output: 7 Explanation: Both 1 and 7 have their corresponding negative values in the array. 7 has a larger value. Approach 1: Use sorting and two-pointers. After doing sorting take i=0 && j=n-1. Make sure that ith pointer is -ve while the jth pointer is +ve. Check if abs(a[i]) == a[j]. Return a[j] as that would be my max. if(abs(a[i]) > a[j]) move the ith pointer as we want smaller value and similarly decrease the jth pointer when abs(a[i]) < a[j]. Time Complexity: O(nlogn + n) nlogn for sorting and n for checking the values. Space Complexity: O(1) Approach 2: Using a map. Iterate through an array, whenever you find a -ve element check if the positive of it is present or not in the map. If present take max with ans. Similarly, for the +ve element check if -ve of it is present. Increase the freq of that element. Time Complexity: O(n) Inserting in an unordered map takes O(1) Traversing through each of the elements will take O(n) Space Complexity: O(n) used map for storing the freq. Please feel free to reach out if you have any doubts regarding the solution!! #LearnInPublic #POTD #CONNECT #Leetcode Code Link:https://lnkd.in/ddwGuDZk Here is the solution for a better understanding of the approach:

22

1 Comment

When I started out CP, there were very few resources like usaco.guide and CP algorithms. But these resources weren't that beginner friendly. So, newcomers would face a lot of problems going through these resources. Most of the resources in India were paid. But we wanted to create free beginner friendly resources. This is the reason we worked on Ask Senior. We wanted to create a platform for problem solving which would include all the topics required and help anyone in grinding the problems. We succeeded in making such a platform, also known as Road to Candidate Master sheet - asksenior.in/learn. This is the perfect roadmap for anyone containing hints and solutions to 50% of the problems out of 2000+ problems.

420

18 Comments

why why why One-Picture Solution 🍱 (Bento Box), A picture is worth a thousand words, I made a wrong decision🥺, single Pdf Dsa Mastering 👇 Why the one-picture solution?🍱 I made the wrong decision while I was learning and I was on the wrong track to taking classical notes and hard to revise, especially during interview prep 🔊 Classical Notes Issues: They can be unorganized, making it tough to find and revise what we need This can be confusing and inefficient during critical times like interviews 🔊 Time-consuming: can take a lot of time to review and revise. ✅ my goal is to simplify this process by creating a visual aid that captures the essence of each problem, the right data structures, key features, and solution patterns,puzzle-free description What Does One-Picture Solution?🍱 The One-Picture Solution involves creating a single picture for each problem. This makes revision simpler, more efficient, and handy. 🏆 Core Problem Uncovered: The main issue is clearly defined. 🏆Solution Breakdown: Step-by-step solution process with key points highlighted. 🏆Right Data Structures and Algorithms: Identifies the most suitable data structures and algorithms for the problem. 🏆Dry-Run and Tracing: Visual representation of the problem-solving steps in action --> Once we’ve covered a topic like Heaps with 30 important problems, I’ll compile all the pictures into a single PDF, key concepts & core of the problem, and pseudocode (Roman), guiding you in the right direction. Who Will Benefit?🍱 "One Picture Solution" This resource is designed for those who are already familiar with basic concepts and who tackled similar problems aiming to refine their understanding and preparation for interviews beginners might find it challenging at first but it's a valuable tool for review Personal Experience? there is one problem I faced when I took notes when I solved the problem through my notebook (solved ahhh) yes you heard me right because I don't have a personal laptop however I solved everything in my notebook it's almost 200 problems solved (5 pages, Full Dry-Run) & I realized that a single picture could encapsulate the core of the problem, the solution pattern, and the behind-the-scenes logic. this experience inspired me to create a One-Picture Solution easy to recall Where Did I Get Inspired?🎬 We can recall scenes dialogue, and whole storylines! but try remembering something specific from a textbook you studied last year – not so easy, right? This is because our brains are wired to remember visuals and stories better than plain text that's the core idea behind the "One-Picture Solution" You can quickly scan these pictures and instantly refresh your memory on important concepts no more sifting through mountains of notes I’d love to hear your thoughts please share your feedback in the comments below without your support it wouldn't be possible to make more handy improvements don't forget to hit the like button thanks again #javascipt #ideas #coding #habits

12

1 Comment

Leetcode problem of the day : Remove Nodes From Linked List The problem that we are tackling for today is removing nodes from a singly-linked list based on a specific condition. Approach used : 1. Reversal: Initially, I reversed the given linked list to simplify the removal process. This allows easier traversal from the head to the tail. 2. Pointer Adjustment: After reversing, I traversed the list again, this time removing nodes based on the given condition. If a node's value is greater than or equal to the value of the previous node, it gets removed. 3. Returning Result: Finally, I returned the modified linked list, which now contains only the nodes that meet the removal criteria. Time Complexity : O(N) Space Complexity : O(1) Link : https://lnkd.in/gRv7bicY Feel free to share your thoughts or optimizations! Happy coding! 💻 #Java #CodingChallenge #Algorithm #Programming #LinkedInCoding #CodingSolution #JavaProgramming #DSA #CodingJourney #CodingChallenge #DataStructuresAndAlgorithms #LeetcodeDailyChallenge #CompetativeProgramming #Consistency 💪🏻❤

14

𝐖𝐡𝐲 𝐮𝐬𝐞 𝐑𝐞𝐚𝐜𝐭.𝐦𝐞𝐦𝐨 𝐰𝐢𝐭𝐡 𝐮𝐬𝐞𝐂𝐚𝐥𝐥𝐛𝐚𝐜𝐤 Every now and then I have seen comments on github PRs asking to use the useCallback() hook. However, in order to actually gain the performance benefit, one should know how & when to use it 💡 1. 𝙋𝙪𝙧𝙥𝙤𝙨𝙚 𝙤𝙛 𝙪𝙨𝙚𝘾𝙖𝙡𝙡𝙗𝙖𝙘𝙠: ➪ useCallback memoizes a function, preventing it from being recreated on every render. ➪ However, useCallback alone doesn't prevent re-renders of child components. 2. 𝙍𝙤𝙡𝙚 𝙤𝙛 𝙍𝙚𝙖𝙘𝙩.𝙢𝙚𝙢𝙤: ➪ React.memo is a higher-order component that memoizes the entire component. ➪ It performs a shallow comparison of props to determine if a re-render is necessary. 3. 𝙏𝙝𝙚 𝙋𝙧𝙤𝙗𝙡𝙚𝙢: ➪ Without React.memo, a child component will re-render whenever its parent re-renders, regardless of whether its props have changed. ➪ This happens even if you use useCallback for function props. 4. 𝙏𝙝𝙚 𝙎𝙤𝙡𝙪𝙩𝙞𝙤𝙣: ➪ Wrapping the child component with React.memo allows it to compare incoming props. ➪ When used with useCallback, React.memo can recognize that the function prop hasn't changed. 5. 𝙒𝙤𝙧𝙠𝙞𝙣𝙜 𝙏𝙤𝙜𝙚𝙩𝙝𝙚𝙧: ➪ useCallback ensures the function reference remains stable. ➪ React.memo uses this stable reference to determine if a re-render is needed. 6. 𝙆𝙚𝙮 𝙏𝙖𝙠𝙚𝙖𝙬𝙖𝙮: ➪ Using useCallback without React.memo (or similar) on the child component doesn't fully optimise performance. ➪ The combination of both is what provides the performance benefit in many scenarios. #webdevelopment #programming #softwareengineering #coding #reactjs #javascript

3

Mastering Node.js seemed like scaling a tech giant's fortress to me, and here's why👇🏻 Every tech forum and discussion was abuzz with talk of asynchronous programming in Node.js, and honestly, the concept was daunting. I was convinced it would be an arduous journey of trial and error spread over countless weeks, maybe even years. But, I was mistaken. It happened much quicker than anticipated, all thanks to my Preplaced mentor . With their guidance, I've conquered three pivotal aspects of Node.js that are crucial for backend development in my field: 👉🏼 Express.js for building web applications with robust features and functions. 👉🏼 Asynchronous programming to handle multiple operations simultaneously without bogging down the server. 👉🏼 Working with RESTful APIs for creating scalable and maintainable service-oriented architectures. I've not only learned a significant skill but have gained a deep confidence in my backend development capabilities. The once intimidating event loop is now my trusted ally! A heartfelt note of appreciation to everyone who supported me on this path✨ If you're on the fence about leveling up your technical skills, let my story be the nudge you need. With the right mentor, even the steepest learning curves can be navigated. Go for it!

3

But, GRAPHS are TOUGH🙃 Say no more. Graphs were always my fav topic, sharing some sheets for your ease: Go through these 5 LeetCode discussion. Graphs sorted: 1. Graph algorithms + problems to practice: - https://lnkd.in/dCgzmMEr 2. Graph For Beginners (Problems, Pattern, Sample Solutions): - https://lnkd.in/dw78hTsC 3. Mastering Graph Algorithms: A Comprehensive DSA Graph Common Question Patterns CheatSheet: - https://lnkd.in/d-ZYvZaq 4. Become Master In Graph: - https://lnkd.in/dWnfYDTu 5. Important Graph Questions: - https://lnkd.in/dJ6sYcMz 𝗝𝗼𝗶𝗻 𝗺𝘆 𝘁𝗲𝗹𝗲𝗴𝗿𝗮𝗺 𝗰𝗵𝗮𝗻𝗻𝗲𝗹 - https://lnkd.in/dxqEen4X Stay curious, keep learning, keep sharing !

400

17 Comments

Explaining BLS12–381 … The “Zero Knowledge Proof” Curve What’s “BLS”, “12” and “381” in BLS12–381? A good deal of my work involves using elliptic curves, along with implementing pairing-based cryptography for things like zero-knowledge proofs (ZKPs). At the core of this is often the magical BLS12–381 curve, and which has not one curve, but two. More details: https://lnkd.in/eV_cxbgZ

15

1 Comment

kubectl use-context youtube kubectl get subscribers -n abhishek.veeramalla -> 3,00,000 We are 3,00,000 Family now ❤️ Exactly a year ago we were at 30,000. This incredible journey wouldn’t have been possible without your love and support to the channel. Subscribe today, if you haven’t for Free DevOps and Cloud courses.

2,940

122 Comments

🚀 𝐃𝐚𝐲 𝟏𝟏/𝟕𝟓 - 𝟕𝟓 𝐃𝐚𝐲𝐬 𝐏𝐫𝐨𝐛𝐥𝐞𝐦-𝐒𝐨𝐥𝐯𝐢𝐧𝐠 𝐂𝐡𝐚𝐥𝐥𝐞𝐧𝐠𝐞 🎯 Today, I tackled the Find the Highest Altitude problem on LeetCode (Problem 1732), a straightforward yet thought-provoking challenge that emphasizes cumulative sums and array traversal. 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐋𝐢𝐧𝐤 👉:https://lnkd.in/gVV5H6uH 𝗧𝗶𝗺𝗲 𝗖𝗼𝗺𝗽𝗹𝗲𝘅𝗶𝘁𝘆: O(n) This problem requires calculating the running sum of an array to determine the highest altitude during a bike ride. 𝐖𝐡𝐚𝐭 𝐈 𝐥𝐞𝐚𝐫𝐧𝐞𝐝 𝐚𝐧𝐝 𝐢𝐦𝐩𝐥𝐞𝐦𝐞𝐧𝐭𝐞𝐝: 1️⃣ Approach: Used a simple loop to compute the cumulative altitude while tracking the maximum altitude reached. Leveraged a variable to keep track of the running total and updated the highest altitude on each step. 2️⃣ Time Complexity: Achieved an O(n) solution by iterating through the array only once and updating the running sum and maximum altitude in constant time per iteration. 3️⃣ Key Insights: Strengthened my understanding of cumulative sums for solving dynamic state-based problems. Enhanced my ability to track and update intermediate results efficiently during traversal. This problem served as a great exercise in applying simple logic and iteration to solve practical scenarios. It reinforced the value of cumulative techniques and real-time state updates in problem-solving. Excited to build on this momentum and take on new challenges tomorrow! 💪 Jay Shree Ram 🙏 - Let's keep climbing new heights! 🚴‍♂️😎😊 #75DaysChallenge #Day11 #ProblemSolving #LeetCode #LearningJourney #CodingSkills #GrowthMindset #CumulativeSum #ArrayTraversal

8

📈 Just solved LeetCode Problem #122: Best Time to Buy and Sell Stock II! 💹 This problem involves maximizing profit from stock prices given in an array, where you can make multiple transactions (buy and sell one share of the stock multiple times). It’s an excellent exercise for practicing greedy algorithms and understanding profit optimization. Key approach: 1️⃣ Greedy Algorithm: Iterate through the array and sum up all the positive differences between consecutive days. This approach ensures that you capture all the upward trends, effectively maximizing the profit. 2️⃣ Simple and Efficient: The algorithm runs in O(n) time complexity, making it efficient and easy to implement for large datasets. A straightforward yet powerful problem that enhances your skills in greedy algorithms and profit optimization strategies! 🚀 #Interested SDE Summer Intern, 2026 Google Microsoft Salesforce Goldman Sachs Baker Hughes #LeetCode #CodingChallenge #StockTrading #GreedyAlgorithm #ProfitOptimization #Algorithm #Programming #TechLife #DeveloperJourney #Java #Google #Microsoft #Salesforce #GoldmanSachs #BakerHughes

11

🔹 **Problem Solved on LeetCode: "Best Time to Buy and Sell Stock"** 🔹 I completed **LeetCode Problem 121 - Best Time to Buy and Sell Stock**! This problem was a great exercise in optimizing profits by identifying the lowest buy and highest sell days in a stock price array. 💡 **Problem Summary**: Given an array where each element represents a stock’s price on a given day, the task was to determine the maximum profit by choosing a single buy day and a later sell day. If no profit was possible, the function returns 0. 🔍 **Key Concepts**: - **Dynamic tracking of minimum price** to establish the best possible buy day. - **Calculating max profit on-the-go** for each day, which allowed me to achieve a single-pass solution. This was an excellent problem to practice maximizing value with minimal memory usage and time complexity! #LeetCode #CodingChallenge #ProblemSolving #Java #Programming #StockMarket

3

Frequently used bitwise operation tricks for competitive programming - Along with intuition of why the trick works. 1) Check if the number is odd X & 1 = 1 (Works because only the last bit remains after operation) 2) Same logic be extended to check if the kth bit is set (X >> k) & 1 = 1 3) Flip the kth bit X = X ^ (1 << k) 4) Set and Unset Kth bit - Instead of XOR use OR/AND X = X | (1 << k) X = X & ~(1 << k) 5) Count set bits [Unlike other tips this one is C++ specific) Use __builtin_popcountll, very fast. 6) Check if the number is a power of 2 X & (X - 1) = 0 (Power of 2 has only one bit set, what happens if we subtract one from such a number, think AND with that) 7) Super handy in solving problems many times A + B = (A | B) + (A & B) (Proof - OR counts every bit once, we want to count bit set in both twice, hence the additional AND too). If you found this useful, like this to encourage me to write more such educational posts.

1,428

31 Comments