Mastering Two-Pointer Technique in Java: Reverse Vowels Problem

Most of us, when we started Competitive Programming in Java, understood that using the Scanner class for taking inputs and System.out.print() for outputs can make our programs slower, so we quickly switched to BufferedReader and BufferedWriter by following a standard template, which improved the execution time. I decided to understand both to see how they differ and what makes the latter one faster. Honestly, the logic was simple. BufferedReader and BufferedWriter use a buffer to store a large chunk of an input stream in a single I/O operation, then break it up internally according to the needs, using a StringTokenizer or any other means.   Scanner does internal parsing and reads input token by token. It performs extra processing like regex matching, which makes it convenient but slower. It also takes care of token validation internally. BufferedReader works differently. It reads a large chunk of data into memory at once (a buffer) and then processes it. Instead of interacting with the input stream repeatedly, it reduces the system calls made. It just reads the stream and does not do any special parsing. Moreover, Scanner is also not thread safe.   This doesn’t mean Buffered Reader is better than Scanner in any way, though; it depends on specific use cases and what we want.   I decided to learn Java I/O properly and tried to understand how input/output streams and reader/writer classes work. It was fun. 😊 It fascinates me how engineers have tailored systems with clever techniques for several use cases. Happy Coding :)   #Java #Coding #CompetitiveProgramming #SoftwareEngineering

💡 Understanding the Diamond Problem in Multiple Inheritance In Object-Oriented Programming, multiple inheritance allows a class to inherit from more than one parent class. But this can introduce a serious problem called the Diamond Problem. Imagine this inheritance structure: Class A / \ Class B Class C \ / Class D Both Class B and Class C inherit from Class A and override the same method show(). Example: class B extends A { void show() { System.out.println("B"); } } class C extends A { void show() { System.out.println("C"); } } Now when Class D inherits from both: D obj = new D(); obj.show(); Which method should run? B.show() C.show() This creates ambiguity because the compiler cannot determine which method implementation to use. To avoid this confusion, Java does NOT support multiple inheritance with classes. Instead, Java allows multiple inheritance through interfaces, where the implementing class explicitly defines the behavior. Understanding these design decisions helps us appreciate why Java prioritizes clarity, simplicity, and maintainability. #Java #ObjectOrientedProgramming #OOP #JavaDeveloper #SoftwareEngineering #ProgrammingConcepts #Coding #ComputerScience #LearnToCode #TechEducation:

🚨 𝗦𝘁𝗼𝗽 𝗰𝗼𝗻𝗳𝘂𝘀𝗶𝗻𝗴 𝘁𝗼𝗦𝘁𝗿𝗶𝗻𝗴() 𝘄𝗶𝘁𝗵 𝗦𝘁𝗿𝗶𝗻𝗴.𝘃𝗮𝗹𝘂𝗲𝗢𝗳() 𝗶𝗻 𝗝𝗮𝘃𝗮! 🚨 Ever wondered what’s the real difference between String.valueOf() and toString() in Java? 🤔 Here’s a quick breakdown 👇 ✅ 𝗦𝘁𝗿𝗶𝗻𝗴.𝘃𝗮𝗹𝘂𝗲𝗢𝗳() - Converts any type (primitive or object) to a String - Handles null safely → returns "null" - Useful when working with primitives or uncertain values ✅ 𝘁𝗼𝗦𝘁𝗿𝗶𝗻𝗴() - Called on objects only - Throws NullPointerException if the object is null - Can be overridden in classes to provide meaningful output 💡 𝗘𝘅𝗮𝗺𝗽𝗹𝗲: 𝘖𝘣𝘫𝘦𝘤𝘵 𝘰𝘣𝘫 = 𝘯𝘶𝘭𝘭; 𝘚𝘺𝘴𝘵𝘦𝘮.𝘰𝘶𝘵.𝘱𝘳𝘪𝘯𝘵𝘭𝘯(𝘚𝘵𝘳𝘪𝘯𝘨.𝘷𝘢𝘭𝘶𝘦𝘖𝘧(𝘰𝘣𝘫)); // "𝘯𝘶𝘭𝘭" 𝘚𝘺𝘴𝘵𝘦𝘮.𝘰𝘶𝘵.𝘱𝘳𝘪𝘯𝘵𝘭𝘯(𝘰𝘣𝘫.𝘵𝘰𝘚𝘵𝘳𝘪𝘯𝘨());  // 𝘕𝘶𝘭𝘭𝘗𝘰𝘪𝘯𝘵𝘦𝘳𝘌𝘹𝘤𝘦𝘱𝘵𝘪𝘰𝘯 📌 𝗜𝗻 𝘀𝗵𝗼𝗿𝘁:  Use String.valueOf() when you want safety and flexibility, and toString() when you’re sure the object is not null and you want its custom representation. #Java #Programming #Coding #SoftwareDevelopment #Learning

🚨 𝗦𝘁𝗼𝗽 𝗰𝗼𝗻𝗳𝘂𝘀𝗶𝗻𝗴 𝘁𝗼𝗦𝘁𝗿𝗶𝗻𝗴() 𝘄𝗶𝘁𝗵 𝗦𝘁𝗿𝗶𝗻𝗴.𝘃𝗮𝗹𝘂𝗲𝗢𝗳() 𝗶𝗻 𝗝𝗮𝘃𝗮! 🚨 Ever wondered what’s the real difference between String.valueOf() and toString() in Java? 🤔 Here’s a quick breakdown 👇 ✅ 𝗦𝘁𝗿𝗶𝗻𝗴.𝘃𝗮𝗹𝘂𝗲𝗢𝗳() - Converts any type (primitive or object) to a String - Handles null safely → returns "null" - Useful when working with primitives or uncertain values ✅ 𝘁𝗼𝗦𝘁𝗿𝗶𝗻𝗴() - Called on objects only - Throws NullPointerException if the object is null - Can be overridden in classes to provide meaningful output 💡 𝗘𝘅𝗮𝗺𝗽𝗹𝗲: 𝘖𝘣𝘫𝘦𝘤𝘵 𝘰𝘣𝘫 = 𝘯𝘶𝘭𝘭; 𝘚𝘺𝘴𝘵𝘦𝘮.𝘰𝘶𝘵.𝘱𝘳𝘪𝘯𝘵𝘭𝘯(𝘚𝘵𝘳𝘪𝘯𝘨.𝘷𝘢𝘭𝘶𝘦𝘖𝘧(𝘰𝘣𝘫)); // "𝘯𝘶𝘭𝘭" 𝘚𝘺𝘴𝘵𝘦𝘮.𝘰𝘶𝘵.𝘱𝘳𝘪𝘯𝘵𝘭𝘯(𝘰𝘣𝘫.𝘵𝘰𝘚𝘵𝘳𝘪𝘯𝘨());  // 𝘕𝘶𝘭𝘭𝘗𝘰𝘪𝘯𝘵𝘦𝘳𝘌𝘹𝘤𝘦𝘱𝘵𝘪𝘰𝘯 📌 𝗜𝗻 𝘀𝗵𝗼𝗿𝘁:  Use String.valueOf() when you want safety and flexibility, and toString() when you’re sure the object is not null and you want its custom representation. #Java #Programming #Coding #SoftwareDevelopment #Learning

✨DAY-13: 🔁 Polymorphism in Java – Same Method, Different Behavior! This image perfectly explains one of the most powerful concepts in OOP — Polymorphism 👇 🐾 Base Class: Animal() 🐶 Derived Classes: Dog() and Cat() The programmer simply says: 👉 “Objects, do your thing!” 😎 And what happens? 🐕 Dog responds: “Woof! Woof!” 🐈 Cat responds: “Meow!” Same method call. Different outputs. That’s the beauty of runtime polymorphism (method overriding) in Java. 💡 Technical Insight: When we use a parent class reference like: Animal obj = new Dog(); obj.sound(); Java decides at runtime which method to execute. This is called Dynamic Method Dispatch. 📌 Why Polymorphism Matters: Increases flexibility Improves scalability Promotes clean and maintainable code Follows the “program to interface, not implementation” principle In simple terms: You give the same command… But each object responds in its own way. That’s real-world programming power. 💻🔥 #Java #OOP #Polymorphism #Programming #SoftwareDevelopment #CodingLife #TechConcepts

🚀 Java Casting: Upcasting vs Downcasting Understanding type casting in Java is essential for mastering Object-Oriented Programming and Polymorphism. 🔹 Upcasting (Child → Parent) When a child class object is referenced using a parent class reference. Example: Parent ref = new Child(); ✔ Done implicitly by the compiler ✔ Used to achieve runtime polymorphism ⚠ Child-specific methods cannot be accessed directly. 🔹 Downcasting (Parent → Child) When a parent reference is cast back to a child type. Example: Child c = (Child) ref; ✔ Done explicitly by the developer ✔ Allows access to child-specific methods ⚠ Must be used carefully to avoid ClassCastException at runtime. 💡 Key Takeaway: Upcasting = Moving up the class hierarchy (safe & automatic) Downcasting = Moving down the hierarchy (manual & needs caution) Mastering these concepts helps in writing flexible, reusable, and polymorphic Java code. #Java #JavaProgramming #OOP #Polymorphism #Programming #SoftwareDevelopment

🚀 Deep Dive into Java String Algorithms: From Basics to Palindromes I recently wrapped up an intensive session focused on mastering String manipulation in Java, specifically focusing on substrings and algorithmic problem-solving. It was a powerful reminder that complex problems become simple when you break them down into smaller, manageable parts. Here are the key takeaways from the session: 🔹 Subarrays vs. Substrings: One of the most important realizations was that the logic for printing all subarrays and substrings is essentially the same. The transition from handling primitive arrays to String objects is seamless once you understand how to manage indices using loops and s.charAt(). 🔹 Algorithmic Efficiency: We explored how to find the Longest Palindromic Substring by: Breaking down the problem: First, ensure you can print every possible substring. Optimizing the search: Reversing the size loop allows you to find the longest potential candidate first. Two-Pointer Palindrome Check: Implementing a check using two indexing variables (i and j) to compare characters from both ends without the overhead of reversing the string. 🔹 Debugging & Exceptions: We had a fascinating discussion on StringIndexOutOfBoundsException. A key insight was how the way you write your code—such as storing a value in a variable versus printing it directly—can determine exactly when and how an exception is triggered during execution. 🔹 Practical Application: Beyond theory, we implemented logic to: Find if one string is a contiguous substring of another. Count occurrences of a specific substring within a larger text. Handle case sensitivity using equalsIgnoreCase() for more robust comparisons. The Road Ahead: The session concluded with a "six-output" challenge—a complex assignment requiring us to reverse individual words in a sentence, count character lengths, and manipulate sentence structures (e.g., "India is my country"). As we move into a short break, the goal is clear: consistency. Whether it's five hours of deep practice or solving just two problems on the worst of days, staying in touch with the code is what builds mastery. #Java #Coding #SoftwareDevelopment #Algorithms #DataStructures #LearningJourney TAP Academy

🚫 Why Java Doesn’t Allow Implicit Narrowing (and that’s a good thing!) While working with data types in Java, one interesting design decision stands out. ✅ Java allows implicit type casting (widening) Example: int → long Because there’s no risk of data loss, Java handles it automatically. ❌ But when it comes to narrowing (large → small data type) Example: long → int Java does NOT allow it implicitly. 💡 Reason? To prevent unintentional data loss. Instead, Java forces you to be explicit — putting the responsibility on the developer. A small feature, but a big reason why Java is considered a safe and reliable language 💻 #Java #Programming #Developers #Coding #SoftwareEngineering

Hello LinkedIn! Today I learned about Polymorphism, one of the core pillars of Object-Oriented Programming in Java. 📌 What I understood: ✅ Polymorphism means “many forms” ✅ One method can behave differently in different situations ✅ Types of Polymorphism:  • Compile-time (Method Overloading)  • Run-time (Method Overriding) ✅ Helps in writing flexible and scalable code Polymorphism allows us to design systems that are more dynamic and reusable. Step by step, strengthening my OOP concepts and Java fundamentals 💻🔥 Consistency + Practice = Growth 🚀 #Java #OOP #Polymorphism #Programming #LearningJourney #Developer

100 Days of Coding Challenge – Day 17 📌 Problem: String Compression 💻 Language: Java 🧠 Concept Used: Two Pointers + In-place Array Manipulation 🔍 Platform: LeetCode Today’s challenge was to compress a character array in-place by replacing consecutive repeating characters with the character followed by its count. Example: Input: ["a","a","b","b","c","c","c"] Output: ["a","2","b","2","c","3"] Approach: ✔ Use two pointers — one for reading characters and one for writing compressed output ✔ Count consecutive repeating characters ✔ Write the character once and append the count if it is greater than 1 ✔ Modify the array directly without creating extra space Time Complexity: O(n) Space Complexity: O(1) 🔗 Problem Link: https://lnkd.in/eeeWBA4X 🔗 Code: https://lnkd.in/enj4Qcy9 #100DaysOfCode #Day17 #Java #DSA #LeetCode #Strings #TwoPointers #ProblemSolving #CodingJourney