Ayush Mishra’s Post

🚀 Day 6 of #DSAChallenge 🔁 Problem: Reverse Integer 📍 Platform: LeetCode #7. ⚡ Difficulty: Medium 💻 Language: Java 📝 Problem Statement: Given a signed 32-bit integer x, return x with its digits reversed. If reversing x causes the value to go outside the signed 32-bit integer range [-2³¹, 2³¹ - 1], then return 0. 💡 Approach: Using Mathematical Operations Instead of string conversion, I used pure arithmetic to reverse digits while proactively preventing overflow: 1️⃣ Extract digits one by one using modulo (x % 10) 2️⃣ Build the reversed number incrementally 3️⃣ Critical: Check for overflow before performing multiplication by 10 — this ensures we never exceed 32-bit limits 🔢 Time Complexity: O(log₁₀(x)) 💾 Space Complexity: O(1) 💻 Java Solution class Solution {   public int reverse(int x) {     int reversed = 0;     for (; x != 0; x /= 10) {       if (reversed < Integer.MIN_VALUE / 10 ||          reversed > Integer.MAX_VALUE / 10) {         return 0;       }       reversed = reversed * 10 + x % 10;     }     return reversed;   } } 📌 Key Learnings: ✅ Proactive Overflow Handling: Always check boundary conditions before operations, not after ✅ Elegant Arithmetic: Mathematical solutions can be more efficient than string manipulation ✅ 32-bit Constraints: Working within system limitations teaches resource-conscious programming ✅ Negative Numbers: Java's modulo operator handles negatives correctly, so no special sign handling needed #LeetCode #DSA #CodingInterview #Java #ProblemSolving #SoftwareEngineering #DataStructures #Algorithms #Coding #Programming #Tech #ReverseInteger #Overflow #CodingChallenge #LearnToCode #Developer #CodeNewbie #100DaysOfCode

🚀 DSA Series – Problem Solving Today I solved a classic String problem: Removing Duplicate Characters. 🧩 Problem Statement Given a string, remove duplicate characters while maintaining the order of first occurrence. Example: Input: `"programming"` Output: `"progamin"` 🧠 Optimized Approach (Using Boolean Array) Instead of using a HashSet, I used a boolean array to track characters. This works great when the character set is limited (like ASCII). 🔹 Step-by-step Logic 1️⃣ Create a boolean array of size 256 (for all ASCII characters). * Each index represents a character. * Default value is `false` → means character not seen yet. 2️⃣ Create a StringBuilder to store the result. 3️⃣ Traverse the string character by character: * For each character `ch`, check `if (seen[ch] == false)` → Mark it as seen: `seen[ch] = true` → Append it to StringBuilder * If already `true`, skip it (duplicate). 4️⃣ Convert StringBuilder to string — final answer ready ✅ ⏱ Time & Space Complexity Time Complexity: O(n) We traverse the string only once. Space Complexity:O(1) Because the boolean array size is fixed (256), not dependent on input size. 💡 Key Learning Choosing the right data structure matters a lot. Boolean arrays can be faster and more memory-efficient than HashSet when the character range is small. Small optimizations = Big performance impact 🚀 #DSA #Java #ProblemSolving #CodingJourney #Placements #LearningInPublic

🚀 𝗝𝗮𝘃𝗮 𝗕𝗲𝗴𝗶𝗻𝗻𝗲𝗿 𝗦𝗲𝗿𝗶𝗲𝘀 | 𝗣𝗮𝗿𝘁 𝟱 𝗩𝗮𝗿𝗶𝗮𝗯𝗹𝗲𝘀, 𝗦𝗰𝗼𝗽𝗲 & 𝗟𝗶𝗳𝗲𝘁𝗶𝗺𝗲 Variables are not just “containers.” They define where data lives, how long it lives, and who can access it. Let’s break it down clearly: 🔹 𝗟𝗼𝗰𝗮𝗹 𝗩𝗮𝗿𝗶𝗮𝗯𝗹𝗲𝘀 Declared inside methods. Stored in 𝙎𝙩𝙖𝙘𝙠 𝙢𝙚𝙢𝙤𝙧𝙮. They exist only while the method runs. Once the method finishes → memory is cleared. That’s why they “disappear.” 🔹 𝗜𝗻𝘀𝘁𝗮𝗻𝗰𝗲 𝗩𝗮𝗿𝗶𝗮𝗯𝗹𝗲𝘀 Declared inside a class, outside methods. Stored in 𝙃𝙚𝙖𝙥 𝙢𝙚𝙢𝙤𝙧𝙮 (inside objects). They live as long as the object exists. No object → no instance variables. 🔹 𝗦𝘁𝗮𝘁𝗶𝗰 𝗩𝗮𝗿𝗶𝗮𝗯𝗹𝗲𝘀 Declared using static. Stored in the 𝙈𝙚𝙩𝙝𝙤𝙙 𝘼𝙧𝙚𝙖 (Class memory). Created only once when the class loads. Shared across all objects of that class. 💡 𝙏𝙝𝙚 𝙧𝙚𝙖𝙡 𝙙𝙞𝙛𝙛𝙚𝙧𝙚𝙣𝙘𝙚? 𝗟𝗼𝗰𝗮𝗹 → 𝘔𝘦𝘵𝘩𝘰𝘥-𝘭𝘦𝘷𝘦𝘭 𝘭𝘪𝘧𝘦 𝗜𝗻𝘀𝘁𝗮𝗻𝗰𝗲 → 𝘖𝘣𝘫𝘦𝘤𝘵-𝘭𝘦𝘷𝘦𝘭 𝘭𝘪𝘧𝘦 𝗦𝘁𝗮𝘁𝗶𝗰 → 𝘊𝘭𝘢𝘴𝘴-𝘭𝘦𝘷𝘦𝘭 𝘭𝘪𝘧𝘦 When you understand scope & lifetime, you stop memorizing… and start thinking like the JVM. Hashtags : #Java #JavaBeginnerSeries #JavaMemory #StackVsHeap #BackendDevelopment #Programming #SoftwareEngineering #LearnInPublic #CodingJourney #Developers #Backend #API #Developers

Many developers believe that complex conditional logic requires endless chains of if-else statements or clunky switch cases. This assumption often leads to brittle codebases, where a single missing logic branch can cause unpredictable runtime failures in production. We frequently accept this verbosity as a necessary trade-off of software engineering, but it actively hinders both readability and long-term maintainability. Functional languages like Haskell and OCaml treated this feature as a first-class citizen for decades before it finally migrated to the mainstream. We now see robust implementations in Rust with its match keyword and recently in Python 3.10 with structural pattern matching. This adoption curve proves that the industry recognizes the limitations of traditional control flow when dealing with complex data types. Adopting these modern features allows teams to write code that expresses intent much more clearly than legacy approaches. You no longer need to manually unpack variables or check types before acting on them because the language handles the structural validation for you. Consider a common scenario where you must handle an API response that might return a success payload, a distinct error code, or a loading state. In a traditional Java 8 environment, you would likely write a series of checks using instanceof casts that clutter the business logic with implementation details. Rust solves this elegantly by forcing you to handle every possible variant of an Enum at compile time through exhaustive matching. The power of pattern matching extends beyond simple value checking into deep structural decomposition of objects and arrays. You can look inside a complex JSON object to extract specific fields only when they match a precise nested structure. The transition from imperative branching to declarative matching requires a significant mental adjustment for developers raised on C-style syntax. You must stop thinking about how to manualy extract data and instead start defining what the data should look like for a valid operation. This move toward a declarative future allows the compiler to take on the cognitive load of ensuring logical completeness. Ultimately, you should ask yourself if your current codebase relies too heavily on archaic control structures that hide the true shape of your data. #SoftwareEngineering #RustLang #Python #Programming #CodeQuality #Refactoring #DevCommunity #TechDebt #FunctionalProgramming #SoftwareArchitecture

📌 Today’s DSA Series Topic: Linked List A Linked List is a linear data structure where elements (called nodes) are stored in non-contiguous memory locations. Each node contains: Data – the value stored Next – reference to the next node The list starts with a head node and ends with NULL. Unlike arrays, linked lists are dynamic in size and allow efficient insertions and deletions. 🔹 CRUD Operations on Linked List (Explained visually in the images below 👇) ✅ Create – Insert a new node (at beginning or end) ✅ Read – Traverse the list from head to NULL ✅ Update – Modify the data of an existing node ✅ Delete – Remove a node and adjust pointers 📊 Time Complexity Overview Insert at Beginning: O(1) Read / Traverse: O(n) Update: O(n) Delete: O(1) / O(n) (based on position) 💬 Want to learn Linked List CRUD operations in a specific programming language (C, C++, Java, Python, JavaScript)? Comment the language name, and I’ll explain it with code examples. 🚀 Keep learning. Keep growing. #DSASeries #LinkedList #DataStructures #CRUD #Programming #TimeComplexity #SoftwareEngineering

To understand the spectrum from low-level to high-level programming, and identify exactly where your code sits, you can simply look at how you handle memory. Assembly Level: At the Assembly level, the concept of a "heap" doesn’t inherently exist. You explicitly make a system call to the OS (like brk or mmap) saying, "Give me a page (4096 bytes)," and the OS returns a raw memory address in a register. That is your base pointer. Once you receive that starting address (let's say 0x400000), you are solely responsible for every byte and bit flip within that address space. C: In C, the standard library (typically glibc on Linux) manages the allocation logic for you via malloc, but you are still manually in charge of the object lifecycle. If you allocate it, you must free it. Rust: Rust takes this a step further. It utilizes the same underlying "Wholesaler" (the Allocator), but it automates the lifecycle management. Through ownership and borrowing rules, the compiler ensures memory safety without manual intervention. High-Level (Java, JS, Python): In managed languages like Java, JavaScript, or Python, you don't care about memory management; the Garbage Collector handles it. You focus almost exclusively on business logic. That is, until you hit a performance cliff and realize your service can't handle the load, forcing you to hunt for optimization tricks. Essentially, these languages aren't for talking to the hardware—they are for talking to the runtime environment. Low-Code: At this point, you don't even bother talking to the code. Your only drive is solving the immediate business problem. The platform abstracts away the entire execution environment for you. LLM Vibe-Coding: Finally, there is LLM "vibe-coding." At this stage, you simply state the problem and don't even bother with the solution logic. You are operating purely on intent. #memory #management #lowlevel #highlevel #lowcode #ai #vibe #context #business

Feat to https://lnkd.in/dXJrdyea --- Who knows, over the past 10 - 15 years some parts of the industry are moving back. Structured exceptions were a great change once they appeared; I remember Turbo Pascal, 1989 - big WOW!!! But now we have languages with this `if (err) { ... }` Maybe in 2026 someone will invent a new trend - a language with a fancy goto operator, like: “It is so cool and simple, you can jump to any line in your program!!! Let’s rewrite our Java microservice in this new amazing lang”. --- Introducing JumpLang JumpLang is a modern systems and application programming language built around a simple but often misunderstood idea: explicit control flow is a feature, not a flaw. By embracing goto as a first-class construct, JumpLang removes layers of abstraction that obscure how programs actually execute. Control flow is visible, predictable, and direct. Instead of mentally expanding nested loops, exceptions, and implicit stack unwinding, a developer can read the code top-to-bottom and see exactly where execution goes next. This clarity aligns with how CPUs work and how experienced engineers reason about performance-critical systems. JumpLang is intentionally easy to learn. Its syntax is small, orthogonal, and free of heavyweight constructs such as exceptions, hidden destructors, or complex lifetime rules. Error handling is explicit: success continues, failure jumps to a clearly named label. There is no magic and no compiler-inserted control flow. Much like Go’s philosophy, JumpLang favors straightforward rules that can be understood in an afternoon and mastered over years. The language specification fits in a short document, and the entire mental model can be held in your head without constantly consulting references. Flexibility is where JumpLang truly shines. goto enables patterns that are otherwise verbose or awkward: early exits, centralized cleanup, efficient state machines, and fast error paths. These patterns are not hacks; they are idiomatic and encouraged. By avoiding heavy abstractions, JumpLang produces code that is easy to debug, easy to profile, and easy to change. In a world where software stacks grow ever more complex, JumpLang deliberately goes in the opposite direction—offering a small, honest language that trusts developers and gives them full control over how their programs run.

Finished the core IDE practice for Multidimensional Arrays today. The focus here was on searching inside sorted matrices and understanding how the approach changes performance, not just correctness. I worked on: - basic search through full traversal - optimized search starting from a matrix corner - handling matrix updates like Set Matrix Zeroes using better space strategies These problems made it clear that matrix questions are often about choosing the right starting point, not just writing more loops. int[][] matrix = {   {1, 4, 7, 11},   {2, 5, 8, 12},   {3, 6, 9, 16},   {10, 13, 14, 17} }; int target = 9; int i = 0; int j = matrix[0].length - 1; boolean found = false; // Efficient search from top-right corner while (i < matrix.length && j >= 0) {   if (matrix[i][j] == target) {     found = true;     break;   } else if (matrix[i][j] > target) {     j--;   } else {     i++;   } } System.out.println(found); // Output: true What became clearer from this stage: - better starting position can reduce time complexity - optimization is often about direction, not new logic - matrix problems reward thinking before coding - many advanced questions reuse the same core ideas This felt like a good checkpoint before moving to LeetCode matrix problems. #Java #DSA #Matrices #Arrays #LearningInPublic #ProblemSolving #CodingJourney #Programming #JavaDeveloper

𝐓𝐮𝐫𝐧𝐢𝐧𝐠 𝐌𝐚𝐭𝐡 𝐃𝐞𝐟𝐢𝐧𝐢𝐭𝐢𝐨𝐧𝐬 𝐢𝐧𝐭𝐨 𝐉𝐚𝐯𝐚 𝐋𝐨𝐠𝐢𝐜. Implemented an algorithm to identify Armstrong Numbers in Java. The definition is simple: 𝐀 𝐧𝐮𝐦𝐛𝐞𝐫 𝐢𝐬 𝐚𝐧 𝐀𝐫𝐦𝐬𝐭𝐫𝐨𝐧𝐠 𝐧𝐮𝐦𝐛𝐞𝐫 𝐢𝐟 𝐭𝐡𝐞 𝐬𝐮𝐦 𝐨𝐟 𝐢𝐭𝐬 𝐝𝐢𝐠𝐢𝐭𝐬 𝐫𝐚𝐢𝐬𝐞𝐝 𝐭𝐨 𝐭𝐡𝐞 𝐩𝐨𝐰𝐞𝐫 𝐨𝐟 𝐭𝐡𝐞 𝐧𝐮𝐦𝐛𝐞𝐫 𝐨𝐟 𝐝𝐢𝐠𝐢𝐭𝐬 𝐞𝐪𝐮𝐚𝐥𝐬 𝐭𝐡𝐞 𝐧𝐮𝐦𝐛𝐞𝐫 𝐢𝐭𝐬𝐞𝐥𝐟(e.g., 153 = 1³ + 5³ + 3³). 𝐓𝐡𝐞 𝐈𝐦𝐩𝐥𝐞𝐦𝐞𝐧𝐭𝐚𝐭𝐢𝐨𝐧 𝐒𝐭𝐫𝐚𝐭𝐞𝐠𝐲: [1.] 𝐃𝐲𝐧𝐚𝐦𝐢𝐜 𝐃𝐢𝐠𝐢𝐭 𝐂𝐨𝐮𝐧𝐭𝐢𝐧𝐠: Used 𝐒𝐭𝐫𝐢𝐧𝐠.𝐯𝐚𝐥𝐮𝐞𝐎𝐟(𝐧).𝐥𝐞𝐧𝐠𝐭𝐡() to handle numbers of any size, rather than hardcoding the power to 3. [2.]𝐃𝐢𝐠𝐢𝐭 𝐄𝐱𝐭𝐫𝐚𝐜𝐭𝐢𝐨𝐧: Used Modulo % 10 to strip digits one by one. [3.] 𝐏𝐨𝐰𝐞𝐫 𝐂𝐚𝐥𝐜𝐮𝐥𝐚𝐭𝐢𝐨𝐧: Leveraged 𝐌𝐚𝐭𝐡.𝐩𝐨𝐰() for the exponential math. Ran the code to find all Armstrong numbers up to 1,000,000. It’s a great exercise for practicing loops and type casting. #Java #Algorithms #NumberTheory #Coding #BackendDevelopment #WeMakeDevs #CleanCode #SoftwareEngineering #DeveloperJourney #IntelliJ