NITIN N TAMBAT’s Post

🚀 Day 4 of 50 Days Coding Challenge Today I solved a problem on Hashing Pattern 🔹 Problem: Two Sum 🔹 Approach: First tried brute force using nested loops (checking all pairs) Then optimized using HashMap (Hashing concept) to reduce time complexity 🔹 Key Learning: Instead of checking every pair, we can store values and directly check if the required complement exists. This reduces time complexity from O(n²) → O(n) 🚀 Also learned an important concept: 👉 need = target - current element 🔹 Time Complexity: O(n) 🔹 Code (Java): import java.util.*; class Solution { public int[] twoSum(int[] nums, int target) { HashMap<Integer, Integer> map = new HashMap<>(); for(int i = 0; i < nums.length; i++) { int need = target - nums[i]; if(map.containsKey(need)) { return new int[]{map.get(need), i}; } map.put(nums[i], i); } return new int[]{-1, -1}; } } 💡 Consistency > Motivation #coding #leetcode #100DaysOfCode #java #programming #dsa #learning #hashmap

🚀 Day 36 – Understanding Encapsulation in Java Today’s focus was on one of the most important pillars of Object-Oriented Programming — Encapsulation. Encapsulation is all about data hiding and controlled access. Instead of exposing variables directly, we protect them and interact through methods, making our code more secure, modular, and maintainable. 📚 Concepts Covered ✔ Introduction to OOP Principles ✔ Understanding Encapsulation ✔ Data Hiding using private variables ✔ Controlled access using Getter & Setter methods 💻 What I Implemented • Created a class with private fields • Used getters and setters to access and update values • Ensured data validation before modifying object state 💡 Key Learning Encapsulation is not just about hiding data — it’s about building secure, flexible, and scalable applications. This concept is heavily used in real-world systems to maintain data integrity and clean architecture. #Java #OOP #Encapsulation #CoreJava #JavaProgramming #SoftwareDevelopment #CodingJourney #DeveloperJourney #LearningInPublic #BackendDevelopment

Exploring more about Collections Framework About: I don't just use Java Collections; I understand the engineering behind them. My training under Sharath R Sir at TAP Academy has allowed me to master the internal mechanics of data structures—moving beyond simple usage to architectural optimization. Core Expertise: Memory Architecture: Expert in navigating the trade-offs between contiguous memory (ArrayList) and dispersed node-based structures (Doubly Linked Lists). LinkedList Internals: Deep understanding of the Node N-1/N/N+1 logic, managing previous/next addresses, and maintaining insertion order with zero initial capacity. Utility Classes: Proficient in leveraging java.util.Arrays and java.util.Collections for high-performance sorting, searching (min/max), and data manipulation. Advanced Traversal: Skilled in using Iterator and ListIterator for bi-directional data navigation and concurrent modification safety. I am passionate about writing clean, polymorphic code that prioritizes loose coupling and scalability. #Java #CollectionsFramework #BackendDevelopment #DataStructures #TapAcademy #SharathSir

Today in TAP Academy with Sharath R sir we had a deep dive into the Java Collections Framework was all about exploring custom object manipulation and data integrity. I moved beyond simple data types to explore the architecture of POJO classes, learning how to handle complex, real-world objects like Student or Employee. One of the most impactful takeaways was learning to manage duplicates in a HashSet by overriding hashCode() and equals(). By generating these based on specific object values—like an ID or Name—rather than memory addresses, you can ensure your collections accurately reflect your data's unique constraints. I also delved into custom sorting logic by implementing the Comparable interface. Understanding how the compareTo() method interacts with Collections.sort()—returning positive, negative, or zero to trigger swaps—is essential for building sophisticated sorting features, such as nested sorting by salary and then by name. #JavaProgramming #JavaCollections #SoftwareDevelopment #OOPS #CodingSkills #ComparableInterface #DataStructures #CleanCode #TechLearning

🌱 Day 83/90 – Pattern Matching & Frequency Logic | hashtag#DSAPattern Today’s practice focused on understanding how patterns can be derived from frequency and positional relationships within data. Problems like these test our ability to think beyond direct comparisons and instead analyze mirrored or symmetric behavior. The key idea is to observe how elements relate to each other across positions and use that insight to compute distances efficiently. The goal? Train my brain to break complex pattern-based problems into simple logical steps and optimize the approach. 🧠 Problem I Practiced Today 👇 ✔ 3889. Mirror Frequency Distance This problem involves analyzing frequency distribution and comparing elements based on their mirrored positions. Key insight: Track frequencies smartly and compute distances by considering symmetry rather than brute force comparisons. 💡 What I Focused On Today 👉 Frequency mapping 👉 Pattern observation 👉 Symmetry & mirror logic 👉 Efficient distance calculation 👉 Writing optimized and clean Java code One important reminder from today’s practice: Not every problem is about direct traversal — sometimes, recognizing symmetry simplifies everything. ✅ Day 83 done – improving step by step 🚀💪 #Day83Done #90DaysOfDSA #DSAPattern #LeetCode #Algorithms #Java #DataStructures #CodingInterviewPrep #JavaDSA #Programming #CompetitiveProgramming #CodingJourney #ThinkInPatterns #PlacementPreparation

Last month, we gathered our Java COP for a Java workshop that featured sessions on AI, effective coding practices, and resilience in Java, bringing valuable insights for developers at all levels. These are the 3 lessons participants took from Java PostCode Workshop. 1. AI integration is engineering, not magic. With LangChain4J, a smart personal finance app was built where users simply describe expenses in a chat and the app categorizes everything. 2. Vibe Coding is powerful, but awareness is everything. Claude Code turned a raw idea into a functional product in real-time. 3. Resilience is an architecture decision, not an infra detail. Temporal.io's durable workflow engine showed that fault-tolerance in Java distributed systems is a design choice, not something to patch later. The pattern across all three? Powerful abstractions only deliver value when you understand what's underneath. A special thank you to our three software engineers who hosted the session: Paul Ribeiro, João Matheus Benevides, and Lucas Peixoto dos Santos. #SwissPostITCampus #letspaintthefutureyellow #CoP

#CodeEveryday — My DSA Journey | Day 2 🧩 Problem Solved: Combination Sum II (LeetCode) 💭 What I Learned: Used backtracking to generate all unique combinations whose sum equals the target. Sorted the array initially to efficiently handle duplicates and enable pruning. At each step: ✔️ Skipped duplicate elements using i > n && nums[i] == nums[i-1] ✔️ Stopped recursion early when the current element exceeded the target ✔️ Moved to the next index (i+1) to avoid reusing elements Strengthened my understanding of handling duplicates in recursion and optimizing search space. ⏱ Time Complexity: O(2ⁿ)*k (k is avg length of each combination) 🧠 Space Complexity: O(n) ⚡ Key Takeaways: ✔️ Sorting helps in both pruning and duplicate handling ✔️ Skipping duplicates is crucial for unique combinations ✔️ Backtracking becomes efficient with early stopping conditions 💻 Language Used: Java ☕ 📘 Concepts: Backtracking · Recursion · Arrays · Duplicate Handling · Pruning #CodeEveryday #DSA #LeetCode #Java #Backtracking #ProblemSolving #Algorithms #CodingJourney #Consistency 🚀

Day 64 of Sharing What I’ve Learned 🚀 Understanding Multithreading — From Programs to Threads After exploring how Java collections help manage and traverse data efficiently, I started looking into something equally important — how programs actually execute and handle multiple tasks. That’s where multithreading comes in. Before diving deeper into threads, I decided to revisit the fundamentals and build a clearer understanding first: 🔹Program A program is simply a set of instructions written in a language like Java. It’s what we write — but not yet running. 🔹Process When we run a program, it becomes a process. A process is an active instance of a program with its own memory and resources. 🔹Thread A thread is an independent set of code or the smallest unit of execution inside a process. Each process can have multiple threads working simultaneously. 🔹Multithreading Multithreading means running multiple threads within a single process. Instead of doing tasks one by one, we can perform multiple operations at the same time. 🔹Why it matters In real-world applications, tasks often need to happen together: 👉 Handling multiple users in an application 👉 Performing background tasks 👉 Improving performance and responsiveness Without multithreading, everything would run sequentially — slower and less efficient. 🔹Simple perspective Program → What we write Process → What runs Thread → What actually executes 🔹My realization Until now, I focused on how data is stored and traversed. Now it’s time to understand how execution can be optimized and made more efficient. 👉 Collections manage data 👉 Threads manage execution And both together are what make applications powerful. This is just the beginning — next, I’ll dive into how to create and manage threads in Java. #Java #Multithreading #Programming #JavaDeveloper #100DaysOfCode #DeveloperJourney #Day64 Grateful for guidance from TAP Academy Sharath R kshitij kenganavar

When I first started learning C++, I learned that data structures in the STL, like vector, stack, queue, etc., use heap memory internally. But when I wrote: vector<int> vec; …it clearly looked like it lived on the stack. No object creation or destruction was visible (coming from Java, I was used to seeing the new keyword everywhere an object is created). So where exactly was this “heap magic” happening? Turns out, the vector object itself does live on the stack when declared normally. But internally, it maintains a pointer to dynamically allocated memory on the heap where the elements are stored. When the object goes out of scope, its destructor is automatically called, and that destructor is responsible for freeing the heap memory. So the cleanup also happens kind of automatically, if we understand what’s going on under the hood. This pattern follows a design principle called RAII (Resource Acquisition Is Initialisation) (more on that in the next post). What advantage does this approach provide? • You get the performance of stack allocation • You get the flexibility of heap allocation • And you still maintain control… woww Also, in C++, we can explicitly create objects on the heap when needed. For example: • to enable runtime polymorphism • to extend the lifetime of an object beyond a specific scope I guess complete resource control wasn’t that bad after all XD. Happy Coding :) #Cpp #LearningInPublic #SoftwareDevelopment #Coding #Algorithms #Programming

Day 7/30 – Encapsulation and Graph Safety States Day 7 of the challenge focused on strengthening OOP fundamentals and solving another important graph problem. Today’s learning was about writing secure, maintainable code through encapsulation and understanding reverse graph logic in DSA. MERN / OOP Concepts – Encapsulation Today I learned about Encapsulation, one of the core pillars of Object Oriented Programming. What is Encapsulation: • Binding data and methods together inside a single unit (class) • Restricting direct access to object data using access modifiers How it works: • Variables are usually marked as private • Public getter and setter methods are used to access or update values safely Why it matters: • Protects data from unwanted modification • Improves code security and maintainability • Gives better control over how data is handled Real world example: • A bank account balance should not be modified directly • It should only change through deposit or withdraw methods Key takeaway: • Encapsulation is about data hiding and controlled access DSA – Find Eventual Safe States Today I solved Find Eventual Safe States, a graph problem based on cycles and topological sorting. Approach: • Reverse all graph edges • Calculate outdegree of each node • Nodes with outdegree 0 are terminal nodes and considered safe • Add them to queue • Process using BFS and reduce outdegree of connected nodes • Nodes that become outdegree 0 are also safe Key insight: • Nodes leading to cycles are unsafe • Nodes eventually reaching terminal nodes are safe Why reverse graph helps: • Makes it easier to process dependencies backward Time Complexity: O(V + E) Space Complexity: O(V + E) Takeaways • Encapsulation helps build clean and secure object-oriented code • Controlled access to data prevents many bugs • Graph problems often become easier after reversing perspective • Topological thinking is useful beyond DAG problems Day 7 completed. One more day of consistency, one more step of growth. #30DaysChallenge #OOP #Encapsulation #Java #DSA #Graphs #TopologicalSort #Consistency #LearningInPublic