Prateek Gupta

💡 LeetCode Problem: Lexicographical Numbers 💡 The "Lexicographical Numbers" problem is a unique challenge where we are required to return the numbers in lexicographical order (also called dictionary order) from 1 to n. 🧠 Problem Overview: Given an integer n, the task is to return the numbers from 1 to n sorted in lexicographical order. For example, for n = 13, the output should be [1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9]. 🔍 Key Insights: Understanding Lexicographical Order: Lexicographical order is similar to the order used in a dictionary. Numbers are compared as if they were strings. For example, the number 10 comes before 2 in lexicographical order because '10' is smaller than '2' when compared as strings. Approach to Solve the Problem: The problem can be tackled efficiently by building the numbers using a depth-first search (DFS) approach. We simulate the lexicographical order by starting from 1 and recursively building the sequence by appending digits (0-9) to form the next valid number. DFS Traversal for Building the Sequence: Start from the number 1 and keep expanding the sequence by attempting to add digits from 0 to 9 to the current number. Once a valid number is formed (i.e., a number less than or equal to n), it is added to the result list. This process continues recursively until all possible numbers from 1 to n have been generated in lexicographical order. Efficiency Considerations: Using DFS ensures that we avoid sorting the numbers explicitly, which would require extra time and space. Instead, the recursive DFS guarantees that the numbers are generated directly in the correct order, making the solution efficient. The time complexity is O(n) because each number between 1 and n is visited once. 🌟 Edge Cases: If n is a single-digit number, the lexicographical order is simply the natural order from 1 to n. Ensure the DFS traversal doesn't attempt to generate numbers larger than n by adding conditions to terminate early when the current number exceeds n. 🌱 Conclusion: The "Lexicographical Numbers" problem is a great exercise in recursive traversal and understanding how strings and numbers interact in sorting. Instead of sorting the numbers directly, the DFS approach efficiently generates the sequence in lexicographical order, avoiding the need for additional sorting. This problem highlights the power of recursion in problem-solving, especially when dealing with structured sequences like lexicographical order. It is a wonderful demonstration of how algorithmic design can simplify otherwise complex tasks. 🌍 #leetcode #dfs #problemsolving #recursion #algorithm #coding #dsa #c #java #python #learning #content #day265 #consistency #tech

14

3 Comments

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

🎯 Ultimate DSA Interview Guide: FAANG Edition After analyzing many recent interview experiences at FAANG/MANGA companies, here's your comprehensive algorithm roadmap: 🟢 Foundation (Master these first): • Arrays & String manipulation • Two Pointer & Sliding Window • Hash Maps/Sets • Stack & Queue • Basic recursion • Math & Basic Number Theory • Time/Space complexity analysis • Basic sorting • Binary Search (standard) 🟡 Intermediate (Most frequently tested): • Binary Trees & BST • Tree traversals (all variants) • Basic Dynamic Programming - Knapsack problems - Longest sequences - Grid traversal • Heap/Priority Queue • Backtracking • BFS/DFS implementations • Linked Lists (including advanced operations) • Advanced Sorting • Graph representation & traversal • Basic System Design concepts 🔴 Advanced (High-frequency at FAANG): • Advanced Dynamic Programming - State compression - Digit DP - Probability DP • Advanced Graph Algorithms - Dijkstra's & Bellman-Ford - Floyd Warshall - Topological Sort - Strongly Connected Components • Advanced Binary Search variations • Monotonic Stack/Queue • Trie & its applications • Segment Trees & Fenwick Trees • Binary Indexed Trees • Union Find (DSU) • String algorithms - KMP - Rabin-Karp - Suffix Arrays ⚫ Expert (Rare but differentiating): • Network Flow algorithms • Advanced Tree structures - Red-Black Trees - AVL Trees - B-Trees • Heavy-Light Decomposition • Advanced Bit Manipulation • Game Theory algorithms • Geometric algorithms • Line Sweep algorithms • Rolling Hash • Suffix Automaton • Advanced String algorithms - Aho-Corasick - Manacher's Algorithm 💡 Pro Tips: 1. Focus on implementation speed - FAANG interviews value clean, quick coding 2. Practice variations of each topic - they rarely ask textbook versions 3. Always optimize! They love seeing you improve from O(n²) to O(n log n) 4. Learn to combine multiple concepts - modern interviews often require this 🎯 Study Strategy: • Week 1-4: Master all 🟢 • Week 5-8: Deep dive into 🟡 • Week 9-12: Focus on high-frequency 🔴 • Final weeks: Cherry-pick relevant ⚫ based on target company #faanginterviews #coding #algorithms #interviewprep #softwareengineering #programming #techjobs Been through FAANG interviews recently? Share your experience below! What topics surprised you? 🤔 Follow: Shivaji Kant Think Big Execute Bigger(#TBEB) 🙂

15

Leetcode Problem Of The Day : Shortest Subarray With OR at Least K II Approach: 1. Initialize Variables: Use count to store the count of set bits (1s) for each bit position from 0 to 31 across the current subarray. Use start and end to represent the window boundaries. Use min to keep track of the minimum subarray length that satisfies the condition. 2. Expand the Window (end pointer): For each end in nums, add nums[end] to the window. Update count using the updateBits method to record the contribution of nums[end] in terms of bits. 3. Contract the Window (start pointer): While the combined OR value (computed by getVal) of the elements in the current window is at least k, calculate the current window length end - start + 1. If the current length is less than min, update min. Move the start pointer forward, removing nums[start] from the window, and update count by decrementing its bit contributions. 4. Return Result: If min is still Integer.MAX_VALUE, return -1 (no valid subarray was found). Otherwise, return min. Helper Methods : 1. updateBits(int[] count, int num, int val): This method iterates over each bit position (0 to 31). For each bit in num, if it is set (i.e., 1), it increments or decrements the count at that bit position by val. 2. getVal(int[] count): This method calculates the combined bitwise OR of the current subarray by checking each bit in count. If a bit position in count is greater than zero, it means at least one element in the current window has this bit set, so it adds this bit to the OR result. Time Complexity : O(n) Space Complexity : O(1) Problem Link : https://shorturl.at/8eIHK #Coding #CompetitiveProgramming #dsa #DatastructuresAndAlgorithms #Leetcode #Consistency #Programming #CodingChallenge

15

Day 20 of 100 Days of Code : Problem 1 : https://lnkd.in/gW7xkJEF Approach : 1.Edge Case: If k is 0, return 0 immediately, as there are no subarrays with product less than 0. 2.Initialize Variables: Initialize count to 0 to store the total number of subarrays, and product to 1 to store the product of the current subarray. 3.Iterate Through Array: Iterate through the array using two pointers, i and j. j points to the current element, and i points to the starting element of the subarray. 4.Multiply Product: Multiply product by the current element nums[j]. 5.While Loop: If product becomes greater than or equal to k, divide product by the element at index i and increment i. This effectively slides the window of the subarray to the right. 6.Add to Count: Add the number of subarrays ending at index j to count. This is calculated as j - i + 1, which represents the number of subarrays that can be formed with the current i and j indices. 7.Return Count: Finally, return the total count of subarrays with product less than k. Code : class Solution {     public int numSubarrayProductLessThanK(int[] nums, int k) {         //EDge Test Case where k is 0 the return 0         if(k == 0)             return 0;         int count = 0;         int product = 1;         for(int i = 0,j=0;j<nums.length;j++) {             product *= nums[j];             while(i<=j && product >= k) {                 product /= nums[i++];             }             count += (j-i+1);         }         return count;     } } Problem 2 : Find the Number of Pairs with Sum Less Than or Equal to K Approach : Explanation: 1.Initialize Variables: Initialize count to 0 to store the total number of pairs. 2.Nested Loops: Use two nested loops to iterate through the array. The outer loop iterates through each element, and the inner loop iterates through the remaining elements. 3.Check Sum: Check if the sum of the current pair of elements is less than or equal to k. If true, increment count. 4.Return Count: Finally, return the total count of pairs with sum less than or equal to k. Example: In the main method, we provide an example array, length, and value of k. We call the sum Pairs function and print the result. Code : public class sumPairs {   public static int sumPairs(int arr[], int n, int k) {     int count = 0; // Initialize count to 0     for (int i = 0; i < n; i++) { // Iterate through the array       for (int j = i + 1; j < n; j++) { // Iterate through the remaining elements         if (arr[i] + arr[j] <= k) { // Check if sum is less than or equal to k           count++; // Increment count if true         }       }     }     return count; // Return the total count   }   public static void main(String[] args) {     int arr[] = {1, 2, 3, 4, 5, 6}; // Example array     int n = arr.length; // Length of the array     int k = 5; // Example value of k     int ans = sumPairs(arr, n, k); // Call the function     System.out.println(ans); // Print the result   } }

3

Never Skip to solve these DSA Questions during interview 👉ARRAYS👈 Two Sum (https://lnkd.in/gyyMkbys) Best Time to Buy and Sell Stock (https://lnkd.in/gNAuXPJw) Maximun Subarray (https://lnkd.in/gbG2F_S4) Container With Most Water (https://lnkd.in/ggWBUs95) Rotate Array (https://lnkd.in/gq4ranjr) 👉String 👈 Reverse String (https://lnkd.in/grpJc8Sb) Valid Palindrome (https://lnkd.in/gkJiaApN) Longest Substring Without Repeating Characters (https://lnkd.in/g3nEeYC8) Group Anagrams (https://lnkd.in/gxnBvnvk) Longest Palindromic Substring (https://lnkd.in/gDjAbJm3) 👉LINKED LIST👈 Reverse Linked List(https://lnkd.in/gx-7YS4b) Merge Two Sorted Lists (https://lnkd.in/gHXJYkpW) Remove Nth Node From End of List (https://lnkd.in/g2gxRpNs) Linked List Cycle (https://lnkd.in/gMDAZvmn) Intersection of Two Linked Lists (https://lnkd.in/gdSXwcaq) 👉SEARCH AND SORTING 👈 Merge Sort (https://lnkd.in/gJazVtMw) Quick Sort (https://lnkd.in/gB7HdhZS) Binary Search (https://lnkd.in/gWc4XpK9) Search in Rotated Sorted Array (https://lnkd.in/gquVTq4k) First Bad Version (https://lnkd.in/gxPYXiEm) 👉DYNAMIC PROGRAMMING (DP)👈 Fibonacci Number (https://lnkd.in/gGj4As6d) Climbing Stairs (https://lnkd.in/gMwb8Gj2) Longest Increasing Subsequence (https://lnkd.in/gPy7ZMeW) Maximum Subarray Sum (https://lnkd.in/gjPKy83y) Coin Change (https://lnkd.in/g7Jn5y8p) 👉TREES👈 Maximum Depth of Binary Tree (https://lnkd.in/guSH46jY) Validate Binary Search Tree (https://lnkd.in/gdrmc-WE) Symmetric Tree (https://lnkd.in/gaKwnCfP) Binary Tree Level Order Traversal (https://lnkd.in/gMHQGtNF) Lowest Common Ancestor of a Binary Tree (https://lnkd.in/gEcr7FdP) 👉GRAPHS👈 Number of Islands (https://lnkd.in/gfj_x24R) Course Schedule (https://lnkd.in/gaWXyykz) Word Ladder (https://lnkd.in/gPaMJCpc) Clone Graph (https://lnkd.in/gp8YPgw6) Network Delay Time (https://lnkd.in/gHzrVAKJ) #DSA #Questions #interview #notes #important #amazon #google #practice #microsoft #job #jobseeker #software #engineer #help

15

3 Comments

10 Graph Algorithms You Must Know for Coding Interviews: 1. Depth First Search (DFS) 2. Breadth First Search (BFS) 3. Topological Sort 4. Union Find 5. Cycle Detection 6. Connected Components 7. Bipartite Graphs 8. Flood Fill 9. Minimum Spanning Tree 10. Shortest Path If you want to learn them in detail, check out this article: https://lnkd.in/gsDdADSi ♻️ Repost to help others in your network. 👉 If you want to master coding and system design interviews, subscribe to 51,501+ readers of my free newsletter: blog.algomaster.io

420

11 Comments

LeetCode weekly -400 able to solve 3:- a.) iterate and check where you get E do count++ and take maxi from them and if you got L do count-- and return maxi b.) we create two events one for the start and one for the end .Sort the events by the day. through the events, maintaining a count of active meetings,Track the days with no active meetings and count them. c) use minheap and stack for this.... C gives 2 wa then it accepted Vivek Gupta Abhishek Saini #icpsc #summercamp #linkedin #community #reach #tweet #follow #comment #share #problemsolving #like #leetcode #codeforces #codechef #geeksforgeeks #tweet #codingninjas #leetcode2024 #codeforces #codechef

57

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.

422

18 Comments

system analysis and design basics

1

1 Comment

If you're a front-end developer and want to pursue companies like #google ?where DSA is a crucial skill and you never solved serious DSA in your career ? not understanding where to get started ? Here is my advice. 1. Goto MDN documentation, learn about set, map and array functions to splice, slice, reduce, fill and few other, same goes for strings. 2. Goto leetcode -> create an account -> Problems section 3. Select Array filter with easy difficulty problem. Most easy problems will look difficult for you. But, hang on, try to solve them by Brute force first. 4. After you solve about 30 easy array problems, your confidence will reach a state where you can solve any easy array problems. 5. That is when you switch to strings, followed by linked list and trees. 6. Without touch basing easy problems of LL and Trees, don't attempt medium difficulty problems of array and strings. As many problems there involve recursion, DFS, BFS etc, which will be hard to solve without knowing trees. By the time you reach Step 6, you will figure out your own strategy to proceed further. Let me know what your DSA strategy is in the comments section. Follow me and I will help you to clear your frontend developer interview :Vasanth Bhat

123

4 Comments

System Design for front-end engineers. Starting with the next post, I'll begin discussing the system design problem. This post is just an introduction. We will tackle some of the most frequently asked system design questions: 1. User Interface Components: (a) Autocomplete: https://lnkd.in/gwau6RQq (b) Instagram Comment section: https://lnkd.in/eRuDem3q (c) Some Basic UI Components: https://lnkd.in/gx4E9qWX 2. Application :  (a) News feed (Ex Facebook) (b) Photo sharing application (Ex Instagram):  (c) Travel booking website (d) Video watching website (e) Google Calendar To solve these types of questions, we need to follow these steps: 1. Requirements exploration: Thoroughly understand the problem and determine its scope by asking several clarifying questions. 2. Architecture / High-level design: Visualize the entire design in your mind, focusing on the key components of the product. 3. Data model (State Management): Think about using Redux and Context for managing state. Also, create a simulated frontend database to store sensitive data securely, and explore caching options for better performance. great example to understand these problem is nested comments example. 4. Interface definition (API): Define product component interfaces (APIs), detailing functionality, parameters, and responses. A great example to understand these concepts is a nested comments system. 5. Optimizations and deep dive: Consider various optimization techniques used in different contexts, such as web workers, micro-frontends, virtualization, windowing, caching, image optimization, file compression, and more. Starting from the next post, I will share detailed solutions to the above questions. Follow me for more updates! #javascript #webdevelopment #frontenddevelopment #frontendsystemdesign #FrontEnd #SystemDesign #SoftwareEngineering #FrontendPerformance #FrontendSystemDesign #ramohit #react #interviewpreparation #code #interview

11

While writing multi-threaded code on a single machine, we can make it thread-safe by using mutexes, semaphores, atomic counters, lock-free data structures, blocking queues and other related stuff,but these concepts doesn't apply to distributed systems as they don't have any shared memory. In distributed systems, where multiple processes or nodes communicate over a network and do not share memory, ensuring consistency and coordination among different components becomes more complex compared to single-machine, multi-threaded scenarios but couple of ways are there to accomplish it to certain extent because nodes in distributed system communicate with each other over unreliable network These are some of the ways which can be implemented,apart from this there are many other ways 1. Instead of shared memory, data can be replicated across multiple nodes in a distributed system. Different consistency models such as strong consistency, eventual consistency, and causal consistency are employed to manage how updates are propagated and observed across replicas. 2. Distributed locking (like Zookeeper) mechanisms can be used to coordinate access to shared resources across multiple nodes. Techniques like distributed lock managers, distributed mutexes, and distributed semaphores ensure that only one process can access a resource at a time. 3. Distributed transactions ensure atomicity, consistency, isolation, and durability (ACID properties) across multiple nodes. Techniques like two-phase commit (2PC), three-phase commit (3PC), and optimistic concurrency control are used to maintain consistency and integrity of data across distributed systems. 4. Distributed systems employ various concurrency control algorithms such as timestamp ordering, multi-version concurrency control (MVCC), and distributed snapshot isolation to manage concurrent access to shared data without centralized coordination. 5. Distributed data structures like distributed hash tables (DHTs), distributed queues, distributed caches, and distributed counters are designed to operate across multiple nodes in a distributed system, providing efficient access and coordination of shared data. #systemDesign #distributedSystems #backendEngineering

3

20 DSA questions frequently asked by service based and mid level product companies 📌 Arrays & Strings 1. Two Sum - https://lnkd.in/gUUp8UtD 2. Longest Substring Without Repeating Characters - https://lnkd.in/gAcpdxsU 3. Container With Most Water - https://lnkd.in/gxaATtTY 4. Maximum Subarray (Kadane's Algorithm) - https://lnkd.in/gTPYuKwg 📌 Linked Lists 5. Reverse a Linked List - https://lnkd.in/gQ6tjhMe 6. Merge Two Sorted Lists - https://lnkd.in/gHk6ZbFT 7. Linked List Cycle - https://lnkd.in/gEMZCNTf 8. Intersection of Two Linked Lists - https://lnkd.in/g4y3FSPu 📌 Stacks & Queues 9. Valid Parentheses - https://lnkd.in/gJ_qZ6UD 10. Min Stack - https://lnkd.in/gQmZBX8h 11. Implement Queue using Stacks - https://lnkd.in/gWP5sfPm 📌 Trees 12. Binary Tree Inorder Traversal - https://lnkd.in/gsrJwvZV 13. Lowest Common Ancestor of a Binary Tree - https://lnkd.in/gxW4-bgH 14. Maximum Depth of Binary Tree - https://lnkd.in/g-BHqnjP 📌 Heaps 15. Top K Frequent Elements - https://lnkd.in/gP8Rbrj2 16. Kth Largest Element in an Array - https://lnkd.in/gdbYa5HT 📌 Graphs 17. Number of Islands - https://lnkd.in/g4uHsTiP 18. Graph Cycle Detection (Course Schedule) - https://lnkd.in/gutn9zeX 📌 Dynamic Programming (Least probability) 19. Climbing Stairs - https://lnkd.in/ge9NE8XB 20. Longest Increasing Subsequence - https://lnkd.in/gDaV8FpY Get the complete list of MOST IMPORTANT DSA questions here - https://lnkd.in/gZDApNar Do follow Akanksha Buchke for hiring updates, referrals, DSA, Java, system design content. #jobs #freshers #hiring #interviews #placements #tech #interview #softwareengineer #techjobs #connections #programming #careers

77

7 Comments

As a software engineer, have you ever wondered why your code is running slower than expected? Or why some algorithms seem to take forever to complete? The answer lies in understanding Big O notation, a fundamental concept that can make or break the efficiency of your code. In simple terms, Big O notation is a measure of how well your algorithm scales as the input size increases. It's crucial to know because it helps you write more efficient code, saving you and your users time and resources. Imagine being able to optimize your code to handle large datasets with ease! So, take the first step in mastering Big O notation and unlock the full potential of your coding skills. Your users (and your boss) will thank you! Share your own experiences with Big O notation in the comments below!

1

Let's talk about those #LinkedIn messages we all get. You know the ones. "Hi [FIRSTNAME], we have an exciting SDE3 position!" Like we're all supposed to know what these engineering levels mean, as if SDE3 is some universal truth that transcends companies and cultures, rather than arbitrary HR jargon. But more on that corporate numbering nonsense later. 🤖 It's like the modern dating scene out there. These companies are the equivalent of someone sending "hey" at 2 AM on #Tinder. Meanwhile, the tech giants? They craft thoughtful first messages that make it feel personal. When Facebook London contacted me by email a few years ago, they gave real context about their engineering culture and focused on hiring for general skills, not just filling a position. They made it clear that specific roles could be discussed later, as they had numerous opportunities available. They understand that engineers don't join positions - they join visions. Google London? They picked up the phone and called. Notice something? No LinkedIn in sight. These companies treat recruitment like a proper courtship, not a numbers game. 💌 So while our LinkedIn inboxes are flooded with these wannabe tech giants treating engineers like IKEA furniture parts - "Oh, we need one SDE3 to complete our engineering shelf!" - they're missing the point entirely. Engineers are not standardized parts you can just plug and play. We're more like that friend who has weird hobbies but somehow makes them work - you might not understand the appeal of sock matching consultancy, but you respect the passion. 🎨 The truth is, great engineers don't just want jobs - they want adventures. They want to be part of something meaningful, even if that meaning is just "we make really cool stuff that people love." When your recruitment message reads like it was written by #ChatGPT's boring corporate cousin who never got invited to parties, you know you've fucked up somewhere along the way. 🤦‍♂️ So to all those companies out there: stop treating engineering levels like Pokémon evolution stages. Start treating engineers like the complex, creative, caffeine-powered beings they are. Because right now, your recruitment game is about as appealing as a "u up?" message at midnight. 💔 And because someone had to say it: At the beginning, who decided that engineering levels should sound like robot designations from a low-budget sci-fi movie? Let's rename them to mathematical constants. Level φ (phi) for entry roles, as you begin your golden journey. Level e for mid-level, as you're experiencing exponential growth. And Level π for senior positions, because by then you've come full circle and realized how much you still don't know. At least that would show some creativity from HR! But until then... 🔢 #WhyIsMyTitleANumber #MySDELevelIsImaginary #LinkedInIsTheTinderOfJobs #RecruitersSwipingLeftOnCreativity #MyTitleNeedsMoreEmojis #TechCulture #TechIndustry #TechRecruitment #TechJobs #SoftwareEngineering #LinkedInFails

9

4 Comments

10 System Design Projects to Crack Top Tech Interviews Dreaming of landing roles at top companies like Uber, Netflix, or Facebook? 🚀 Mastering System Design (HLD + LLD) is essential for creating scalable, efficient architectures. These 10 projects will help you tackle real-world challenges such as load balancing, caching, and database scaling, all while preparing you for tough technical interviews. 💡 Pro Tip: Enhance your system design expertise by combining traditional skills with GenAI tools. Leverage technologies like GitHub Copilot, LangChain, and RAG (Retrieval-Augmented Generation) to improve your workflows and innovate faster. Thanks to Learnbay for curating this project roadmap! Whether you're gearing up for interviews or building complex systems, mastering these projects will elevate your skills and confidence. 📚 Explore Learnbay ’s specialized programs for developers, where you’ll: ✅ Learn System Design and GenAI tools ✅ Work on hands-on projects inspired by real-world challenges ✅ Get personalized career guidance from top MNC mentors 💡 Don’t miss their free demo sessions for career tips and interview strategies from FAANG professionals. Details here: https://bit.ly/3VKaLJy (Register here ) Start building today, and take your first step toward cracking your dream tech interviews! 🚀 #systemdesign #maanginterviews #interviews #systemdesignroadmap #Uber #Netflix #Facebook #google #microsoft

231

44 Comments

Doing 694 Leetcodes won't get you anywhere. 20 patterns to crush your next interviews: 0. Sliding Window: Efficiently compute a target subset in a fixed-size window. 1. Matrix Traversal: Efficiently traverse 2D matrices. 2. Two Pointers: Use two pointers to process input data from two ends. 3. Fast and Slow Pointers: Detect cycles or find the middle in linked structures. 4. Merge Intervals: Work with intervals by merging overlapping ones. 5. Cyclic Sort: Sort numbers when the range is known. 6. In-place Reversal of a LinkedList: Reverse linked lists in-place for space efficiency. 7. Tree BFS: Level order traversal of trees. 8. Tree DFS: Depth-first traversal of trees for various tree-related problems. 9. Two Heaps: Use two heaps to find the median in a data stream. 10. Subsets: Generate all subsets of a given set. 11. Modified Binary Search: Customize binary search to fit problem requirements. 12. Bitwise XOR: Use XOR operations for unique element problems. 13. Top ‘K’ Elements: Use heaps to find the top K elements. 14. K-way Merge: Merge multiple sorted arrays. 15. Topological Sort: Order tasks based on dependency using graph algorithms. 16. Knapsack (Dynamic Programming): Solve optimization problems using dynamic programming. 17. Fibonacci Numbers: Simpler cases of dynamic programming (staircase...) 18. Palindrome Subsequence: Techniques to find or check palindromes with string combinations. 19. Longest Common Substring: Find the longest substring shared by two strings. What did I miss? Credit: Design Gurus #softwareengineering #interview #programming _____ Join my free software engineering newsletter: https://lnkd.in/dkJiiBnf

406

57 Comments

The SDE-2/SDE-3 position in some companies is just like SDE-1, so don't be too surprised. Don't make them gods of tech who are SDE-2/SDE-3 in these companies. They are not gods, they are just like you. PS: Even the compensation is just like to SDE-1. #AsheeshTalks #linkedin #SDE2 #SDE3

953

35 Comments