🚀 50 Days of Java – Day 49 🚀 Continuing my #50DaysOfJava journey by solving another interesting Graph problem using DFS 💻📊 📘 What I covered today: • Wrote a Java program to print all paths from source to target in a graph • Used Depth First Search (DFS) to explore different paths • Represented the graph using an Adjacency List • Learned how DFS can help in exploring multiple possible paths between nodes This problem helped me understand how graph traversal can be used to explore and track different routes in a network. Sharing my daily learning and code on GitHub to stay consistent 🚀 🔗 GitHub repo: (https://lnkd.in/ezZkPqxt) Almost at the final day of the challenge 💪 #Java #50DaysOfJava #Day49 #Graphs #DFS #DataStructures #DSA #LearningInPublic #CodingJourney #bca #student #invertis_university

🚀 50 Days of Java – Day 47 🚀 Continuing my #50DaysOfJava journey by exploring Graph Data Structures in Java 📊💻 📘 What I covered today: • Implemented Breadth First Search (BFS) Traversal in a graph • Represented the graph using an Adjacency List • Used a Queue to process nodes level by level • Learned how BFS helps in exploring vertices in a systematic way BFS is widely used in graph problems such as shortest path in unweighted graphs, network traversal, and level-order exploration. Sharing my daily learning and code on GitHub to stay consistent 🚀 🔗 GitHub repo: (https://lnkd.in/gsYf6Kkm) Almost at the finish line of the challenge 💪 #Java #50DaysOfJava #Day47 #Graphs #BFS #DataStructures #DSA #LearningInPublic #CodingJourney #bca #student #invertis_university

🚀 Exploring Java Collections Framework Today I deepened my understanding of how the Java Collections Framework is structured and how different data structures like List, Set, and Queue work internally. 🔍 Key Learnings: • Difference between List, Set, and Queue • Working of ArrayList, LinkedList, HashSet, TreeSet • Importance of SortedSet and data organization • How Java manages data efficiently using collections 📊 This hierarchy diagram helped me visualize everything clearly and build a strong foundation in Java. Consistency in learning is helping me grow step by step 💪 Big thanks to Prasoon Bidua sir and REGex Software Services for guidance and support 🙏 #Java #DSA #CollectionsFramework #LearningJourney #Coding #100DaysOfCode #JavaDeveloper

🚀 50 Days of Java – Day 48 🚀 Continuing my #50DaysOfJava journey by exploring another important Graph traversal algorithm 💻📊 📘 What I covered today: • Implemented Depth First Search (DFS) Traversal in a graph • Represented the graph using an Adjacency List • Used recursion to explore nodes deeply before backtracking • Understood how DFS helps in exploring paths and connected components DFS is widely used in problems like cycle detection, path finding, and topological sorting. Sharing my daily learning and code on GitHub to stay consistent 🚀 🔗 GitHub repo: (https://lnkd.in/gQtJYtNy) Getting closer to completing the challenge 💪 #Java #50DaysOfJava #Day48 #Graphs #DFS #DataStructures #DSA #LearningInPublic #CodingJourney #bca #student #invertis_university

This problem reminded me a bit of the tasks I got in Java courses, where you have to draw tables for the data and use proper formatting to show the columns of numbers, which was kinda fun. In this problem, we use strings, but there's also a solution with characters, which is much more convoluted (this one has lots of opportunities for cleanup as well). However, if we aim for better time complexity, it doesn't matter how much data we store; if it scales to the input in the same way, we have the same complexity. In this case, we store the directory length at each level (depth). Since we could have many nested folders, this storage would have the same complexity as storing the entire thing as strings. However, it might have a much better runtime. The post: https://lnkd.in/d4Rzja_n The problem: https://lnkd.in/dWTs7a92 #LeetCode #DSATips #DSA #ThinkDSA #ProblemSolving

🚀 Day 92 – #100DaysOfCode Qn. Combination Sum III Today I worked on the Combination Sum III problem using recursion and backtracking in Java. 🔹 Problem Summary: Find all possible combinations of k numbers that add up to n, using numbers 1–9 only once. 🔹 My Approach: Used recursion to explore all possible number combinations. Maintained a running sum and a temporary list. When the sum equals n and the list size equals k, the combination is added to the result. Used a HashSet to avoid duplicate combinations. 🔹 Key Learning: This problem helped me strengthen my understanding of: Backtracking Recursive decision trees Managing state during recursion (adding/removing elements) 📌 Next Goal: Optimize the solution further by avoiding the HashSet and pruning unnecessary recursive calls. #Day92 #LeetCode #DSA #Java #Recursion #Backtracking #CodingJourney

Day 66 of #100DaysOfLeetCode 💻✅ Solved #3427. Sum of Variable Length Subarrays problem in Java. Approach: • Iterated through each index of the array • Determined the starting index using i - nums[i] • Ensured the start index does not go below 0 • Calculated sum of elements from start to current index i • Added each subarray sum to the total Performance: ✓ Runtime: 1 ms (Beats 99.90% submissions) ✓ Memory: 45.22 MB (Beats 56.30% submissions) Key Learning: ✓ Practiced handling variable-length subarrays ✓ Improved understanding of index-based range calculations ✓ Strengthened nested loop logic for array problems Learning one problem every single day 🚀 #Java #LeetCode #DSA #Arrays #PrefixSum #ProblemSolving #CodingJourney #100DaysOfCode

Day 46 of #100DaysOfLeetCode 💻✅ Solved #374. Guess Number Higher or Lower problem in Java. Approach: • Used Binary Search to efficiently guess the number. • Calculated mid using low + (high - low) / 2 to avoid overflow. • Used the guess(mid) API to check if the number is higher, lower, or correct. • Updated the search range accordingly until the number was found. Performance: ✓ Runtime: 0 ms (Beats 100% submissions) 🚀 ✓ Memory: 41.68 MB (Beats 97.84% submissions) Key Learning: ✓ Practiced implementing binary search on a real problem ✓ Learned how to safely calculate mid to prevent integer overflow ✓ Strengthened problem-solving skills with search algorithms Learning one problem every single day 🚀 #Java #LeetCode #DSA #BinarySearch #ProblemSolving #CodingJourney #100DaysOfCode

🚀 Starting My Java Journey I’ve recently started learning Java and diving into Data Structures & Algorithms. So far, I’ve learned: • Basics of Java (variables, loops, conditions)   • Arrays and how to work with them   • Solving beginner problems on LeetCode  I’m really enjoying the process of solving problems and improving my thinking skills. Looking forward to building projects and sharing my progress here! If you have any tips or resources, feel free to share 💻 #Java #DSA #CodingJourney #LearningInPublic

Day 47 of #100DaysOfLeetCode 💻✅ Solved #101. Symmetric Tree problem in Java. Approach: • Used recursion to compare the left and right subtrees of the root • If both nodes are null, the tree is symmetric at that level • If one node is null and the other is not, the tree is not symmetric • Compared the values of both nodes • Recursively checked left.left with right.right and left.right with right.left to verify mirror structure Performance: ✓ Runtime: 0 ms (Beats 100% submissions) ✓ Memory: 43.62 MB (Beats 48.60% submissions) Key Learning: ✓ Practiced mirror comparison in binary trees ✓ Learned how recursion can verify symmetry between two subtrees ✓ Strengthened understanding of tree traversal and structural comparison Learning one problem every single day 🚀 #Java #LeetCode #DSA #BinaryTrees #ProblemSolving #CodingJourney #100DaysOfCode