Java Zero to Hero Practice Roadmap

Write a standard Java program that prints 'Hello, World!' to the console output.

Swap two integer variables `a` and `b` without introducing a temporary third variable.

Given an integer `n`, determine if it is Even or Odd using arithmetic operators.

Write a program to determine and print the largest of three integers `a`, `b`, and `c`.

Determine whether a given number is positive (> 0), negative (< 0), or zero (== 0).

Calculate n! (n factorial) for a non-negative integer n.

Generate the first N terms of the Fibonacci sequence starting from 0, 1.

Given an integer n, reverse its digits (e.g. 1234 -> 4321).

Check whether a given integer reads the same backwards as forwards.

Determine if a number n > 1 is a prime number (divisible only by 1 and itself).

Print all prime numbers between a given range [start, end].

Find the Greatest Common Divisor (GCD) of two integers `a` and `b` using Euclidean algorithm.

Calculate the Least Common Multiple (LCM) of two numbers `a` and `b`.

Count the total number of digits in an integer n.

Calculate the sum of all digits of a given integer n.

Check if a number of k digits equals the sum of its digits each raised to the k-th power (e.g. 153 = 1^3 + 5^3 + 3^3).

Check if a number equals the sum of its proper positive divisors (excluding itself e.g. 6 = 1 + 2 + 3).

Print the multiplication table for a given integer n up to 10.

Print a centered number pyramid pattern of height N.

Print a right-angled star triangle pattern of N rows.

Find and return the maximum element present in an integer array.

Find and return the minimum element present in an integer array.

Find the second largest distinct element in an array in O(n) time.

Find all duplicate values present in an array.

Remove duplicate values from a sorted array in-place or return a clean distinct array.

Reverse an array of N integers in-place and print the reversed elements space-separated.

Rotate an array of N integers to the left by K positions.

Rotate an array of N integers to the right by K positions.

Merge two sorted arrays into a single sorted sequence.

Sort an array of N integers in ascending order.

Given array of N-1 distinct integers in range 1 to N, find the missing integer.

Find common elements present in array A (size N) and array B (size M).

Compute the intersection of two integer arrays preserving duplicates.

Find the union of two integer arrays (distinct sorted elements).

Move all zeros to end while maintaining relative order of non-zero elements.

Find the contiguous subarray with the largest sum using Kadane's algorithm.

Find a pair of numbers in array adding up to target sum S.

Find three elements whose sum equals target sum S.

Find index where sum of lower indices equals sum of higher indices.

Count frequency of each distinct element and print as 'x: count' in ascending order.

Count how many even and odd integers are present in array.

Find element appearing strictly more than N/2 times or print -1.

Rearrange array so all positive numbers appear before negative numbers.

An element is a leader if it is >= all elements to its right.

Find length of the longest consecutive sequence in unsorted array.

Read a 2D matrix of size R×C from stdin and print it row by row, with elements separated by spaces.

Given a 2D matrix, compute and print the sum of each row and the sum of each column.

Compute the transpose of a given N×N square matrix (swap rows with columns).

Search for a target value in an R×C matrix and print its position, or 'Not found' if absent.

Compute the sum of primary and secondary diagonals of an N×N matrix.

Print all elements of an R×C matrix in clockwise spiral order.

Rotate an N×N square matrix 90 degrees clockwise in-place.

For each row in an R×C matrix, find and print the maximum element.

Check if given N×N matrix is symmetric (matrix[i][j] == matrix[j][i]).

Multiply two matrices A (R×K) and B (K×C) and print product matrix.

Reverse the given string.

Check if input string reads the same forwards and backwards.

Count vowels and consonants in string (alphabetic characters only).

Count whitespace-separated words in sentence.

Remove all whitespace characters from input string.

Remove duplicate characters keeping only first occurrence.

Find characters that appear more than once in string.

Check if two strings are anagrams (contain same characters).

Find first non-repeated character or print 'None'.

Find first character that repeats or print 'None'.

Find the longest word in a sentence.

Count frequency of each character in alphabetical order as 'char: count'.

Run-length compression: 'aabcccccaaa' becomes 'a2b1c5a3'.

Reverse the order of words in a sentence.

Check if string B is a rotation of string A.

Convert all lowercase characters to uppercase without built-in toUpperCase().

Generate all non-empty substrings of string space-separated.

Find longest common prefix string among N strings.

Determine if parentheses '()', '[]', '{}' are properly closed.

Remove non-alphanumeric characters from string.

Find longest palindromic substring in S.

Check if string consists exclusively of digits (0-9).

Find character with highest frequency in string.

URL-encode string by replacing spaces with '%20'.

Check if characters in string s can be replaced to get string t.

Create a class Student with fields name and roll. Read name and roll, instantiate a Student, and print details.

Create BankAccount with private balance. Support deposit(amount) and withdraw(amount) only if balance >= amount.

Implement a Calculator with overloaded add methods for (int, int), (int, int, int), and (double, double).

Create Animal with method sound() and derived class Dog with method bark(). Call both methods.

Base Shape has method draw(). Derived Circle and Square override draw(). Call draw() using a Shape reference.

Person has constructor taking name. Employee extends Person, calls super(name), and adds id. Print employee details.

Maintain a static counter that increments every time an instance of Item is created. Instantiate N items and print count.

Abstract class Vehicle has abstract speed() and concrete fuel(). Car extends Vehicle. Print outputs of both.

Define interface Playable with method play(). Guitar and Piano implement Playable. Call play() on selected instrument.

SmartPhone implements Camera (takePhoto) and MusicPlayer (playMusic). Call both methods.

Interface Logger has static info(msg) and default log(msg). Implement in ConsoleLogger and invoke both.

Engine has horsepower. Car HAS-A Engine. Instantiate Car with an Engine and print car status.

Read a and b. Compute a / b. Catch ArithmeticException if b == 0 and print error. Always print 'Execution completed' in finally.

Define InvalidAgeException extends Exception. Throw it if age < 18. Catch and print 'InvalidAgeException: Underage'. Else print 'Eligible for voting'.

Implement Point with copy constructor Point(Point other). Create p1, copy to p2, mutate p1.x += 10, print both points.

Read N integers, create a singly linked list, and print elements space-separated.

Reverse a singly linked list iteratively and print elements.

Detect if linked list contains a cycle using Floyd's algorithm.

Find middle node value using slow and fast pointers.

Delete duplicate nodes from a sorted linked list.

Merge two sorted linked lists into one sorted linked list.

Given access only to that node, delete it from linked list.

Find value of K-th node from end of linked list.

Determine if linked list values form a palindrome.

Reverse nodes of linked list K at a time.

Find value of node where two singly linked lists merge.

Remove cycle from linked list if present.

Flatten a multi-level linked list with next and child pointers.

Sort linked list in ascending order in O(N log N) using merge sort.

Create a deep copy of a linked list with next and random pointers.

Simulate stack push and pop operations.

Simulate linked list backed stack push and pop.

Simulate queue enqueue and dequeue operations.

Simulate linked list backed FIFO queue.

Implement FIFO queue semantics using two LIFO stacks.

Implement LIFO stack semantics using two queues.

Reverse a stack of N integers and print elements from top to bottom.

Reverse elements in a queue using a stack.

Check if string of parentheses is balanced.

For each element, find the first greater element to its right, or -1.

Calculate span of stock prices (consecutive days price was <= today).

Design a stack that retrieves the minimum element in O(1) time.

Simulate circular buffer queue with fixed capacity K.

Evaluate value of postfix (Reverse Polish Notation) arithmetic expression.

Convert valid infix expression with single-letter operands to postfix.

Build binary tree from level order array and print root value.

Print inorder traversal (left, root, right) of binary tree.

Print preorder traversal (root, left, right) of binary tree.

Print postorder traversal (left, right, root) of binary tree.

Print binary tree nodes in breadth-first level order.

Calculate max depth (height) of binary tree.

Count number of leaf nodes in a complete binary tree.

Check if two binary trees are structurally identical with same values.

A balanced binary tree has depth difference of subtrees <= 1.

Find Lowest Common Ancestor (LCA) of nodes p and q in a BST.

Validate if binary tree satisfies BST invariants.

Find K-th smallest element in a Binary Search Tree.

Convert binary tree into its mirror image.

Find length of longest path between any two nodes in tree.

Convert binary tree to string and back to identical tree.

Find 0-based indices of two numbers that add up to target.

Check if array contains any duplicate values.

Count frequency of each element and print sorted.

Group an array of strings into anagram clusters.

Find first non-repeating element in array or -1.

Find length of longest consecutive elements sequence.

Return true if any value appears at least twice in array.

Count total contiguous subarrays whose sum equals K.

Find intersection of elements in arrays A and B.

Simulate Least Recently Used (LRU) Cache get and put operations.

Calculate N! using recursion.

Compute N-th Fibonacci number recursively (0-indexed).

Generate all 2^N subsets of an integer array.

Calculate total distinct permutations of array of N distinct integers.

Find number of distinct valid solutions to place N non-attacking queens on an N×N board.

Check if a 9x9 Sudoku board state is valid.

Check if path exists from top-left (0,0) to bottom-right (N-1,N-1) in maze.

Determine if word exists in 2D character grid by adjacent cells.

Calculate minimum moves required to solve Tower of Hanoi with N disks (2^N - 1).

Calculate total valid combinations of N pairs of balanced parentheses (Catalan number).

Count distinct ways to climb N steps taking 1 or 2 steps at a time.

Find fewest number of coins needed to make up amount A.

Find maximum value that can be put in a knapsack of capacity W.

Find length of longest common subsequence of two strings.

Find length of longest strictly increasing subsequence in array.

Find minimum operations (insert, delete, replace) to convert word1 to word2.

Maximize robbery amount without robbing adjacent houses.

Find contiguous subarray that has largest product.

Find path from top left to bottom right of R×C grid minimizing sum of numbers.

Determine if array can be partitioned into two subsets with equal sum.

Implement LRU Cache data structure supporting get and put in O(1).

Design parking lot with parking spots for small, medium, and big cars.

Manage book checkouts and returns tracking availability.

Design Base62 URL shortener converting integer IDs to short URLs.

Simulate thread-safe bounded buffer producer and consumer.