90 Java Problems

Complete Solutions Guide

Phase 1 → Phase 6 | Basics to Placement Level

📁 File 1 📁 File 2

With Functions + Built-ins Pure Logic — No Built-ins

Clean modular methods Interview-style raw code

Optimised algorithms No Arrays / Collections API

📋 Table of Contents
Phase 1 — Basics & Logic (Problems 1–20) .............. 3
Patterns (Problems 21–30) ................................ 4
Phase 2 — Functions, Arrays & Strings (31–55) ... 5
Phase 3 — OOP (56–65) .................................... 7
Phase 4 — DSA Core (66–80) .............................. 8
Phase 5 — Advanced DSA (81–88) ......................... 10
Phase 6 — Placement Level (89–96) ...................... 11
File 1 — Full Java Source (with functions) ........... 12
File 2 — Full Java Source (pure logic) ............... 20
🚀 Phase 1 — Basics + Logic (Problems 1–20)

🟢 Core Logic (1–7)

# Problem Key Concept

1 Even or Odd Modulus operator (%)

2 Positive / Negative / Zero if-else chain

3 Largest of 2 Ternary / [Link]

4 Largest of 3 Nested max comparison

5 Leap Year Divisibility rules

6 Swap without 3rd variable XOR / arithmetic swap

7 Simple Calculator (switch) switch-case statement

🔥 Loops (8–14)
# Problem Key Concept

8 Print 1 to N for loop

9 Sum of first N numbers Gauss formula / loop

10 Factorial Iterative multiplication

11 Reverse a Number % 10 + / 10 trick

12 Palindrome Number Reverse and compare

13 Count Digits while + /10

14 Sum of Digits % 10 extraction

🔴 Important Logic (15–20)

# Problem Key Concept

15 Armstrong Number Digit power sum

16 Prime Number Trial division to √n

17 Fibonacci Series Two-variable iteration

18 GCD Euclidean algorithm

19 LCM a*b / GCD

20 Strong Number Sum of digit factorials

⭐ Patterns (Problems 21–30)
# Problem Key Concept

21 Star Triangle Nested for loops

22 Inverted Star Triangle Reverse outer loop

23 Right-Aligned Triangle Spaces + stars

24 Pyramid Centering with spaces

25 Inverted Pyramid Reverse pyramid logic

26 Diamond Pyramid + inverted pyramid

27 Number Triangle Print j in inner loop

28 Floyd's Triangle Incrementing counter

29 Pascal's Triangle nCr iterative

30 Hollow Square Border condition check

🚀 Phase 2 — Functions + Arrays + Strings (31–55)

🔹 Functions (31–34)
# Problem Key Concept

31 Factorial Function Modular function design

32 Prime Function Reusable prime check

33 Recursive Factorial Base case + n * f(n-1)

34 Recursive Fibonacci f(n-1) + f(n-2)

🔹 Arrays (35–44)
# Problem Key Concept

35 Sum of Array Linear traversal

36 Maximum Element Running max variable

37 Minimum Element Running min variable

38 Reverse Array Two-pointer swap

39 Second Largest Track top two

40 Remove Duplicates Set / visited array

41 Move Zeros to End Two-pointer / rewrite

42 Rotate Array by K Triple reverse

43 Frequency of Elements HashMap / count array

44 Missing Number Expected sum − actual sum

🔹 Strings (45–55)
# Problem Key Concept

45 Reverse a String StringBuilder / char[]

46 Palindrome String Reversed == original

47 Count Vowels & Consonants isVowel check + loop

48 Anagram Sort both & compare

49 First Non-Repeating Char LinkedHashMap count

50 Character Frequency HashMap frequency

51 Remove Spaces replaceAll / char filter

52 Convert to Uppercase toUpperCase / -32 trick

53 Check Substring contains / KMP idea

54 Longest Word in Sentence split + max length

55 Remove Duplicate Characters Set + StringBuilder

🚀 Phase 3 — OOP (56–65)
# Problem Key Concept

56 Create Class & Object class, new, reference

57 Student Class (name & marks) Instance variables

58 Constructor this keyword, initialisation

59 Method Overloading Same name, different params

60 Single Inheritance extends, super()

61 Multilevel Inheritance 3-level class chain

62 Polymorphism Override + upcasting

63 Encapsulation (getters/setters) private + public accessors

64 Abstract Class abstract keyword, area()

65 Interface implements, contract

🚀 Phase 4 — DSA Core (66–80)

🔥 Arrays DSA (66–70)

# Problem Key Concept

66 Two Sum HashMap complement look-up O(n)

67 Max Subarray (Kadane's) maxEndingHere + maxSoFar

68 Buy/Sell Stock Track min price, max profit

69 Majority Element Boyer-Moore voting algorithm

70 Subarray Sum = K Prefix sum + HashMap

🔹 Searching (71–74)
# Problem Key Concept

71 Linear Search O(n) sequential scan

72 Binary Search O(log n) divide & conquer

73 First Occurrence (sorted) Binary search — go left on hit

74 Last Occurrence (sorted) Binary search — go right on hit

🔹 Sorting (75–77)
# Problem Key Concept

75 Bubble Sort Adjacent swap, O(n²)

76 Selection Sort Min selection, O(n²)

77 Insertion Sort Shift-insert, O(n²) / O(n) best

🔹 Recursion (78–80)
# Problem Key Concept

78 Sum using Recursion n + f(n-1)

79 Reverse Array (Recursion) Swap lo↔hi, recurse inward

80 Palindrome (Recursion) Compare edges, recurse inward

🚀 Phase 5 — Advanced DSA (81–88)

🔗 Linked List (81–84)

# Problem Key Concept

81 Insert Node Traverse to tail, link new node

82 Delete Node Relink previous node's next

83 Reverse Linked List Iterative prev/cur/next pointers

84 Detect Cycle Floyd's fast/slow pointer

📚 Stack & Queue (85–88)

# Problem Key Concept

85 Stack using Array top pointer, push/pop

86 Valid Parentheses Stack-based bracket matching

87 Queue using Array front/rear pointers

88 Circular Queue (rear+1) % cap wrap-around

🚀 Phase 6 — Placement Level (89–96)
# Problem Key Concept

89 Longest Substring (No Repeat) Sliding window + HashMap

90 Container With Most Water Two-pointer shrink inward

91 3Sum Sort + two pointers

92 Climbing Stairs (DP) Fibonacci-pattern DP

93 Merge Two Sorted Arrays Two-pointer merge O(n+m)

94 Intersection of Arrays HashSet lookup

95 Reverse Linked List (LeetCode) Iterative 3-pointer

96 Valid Palindrome (String) Clean alphanumeric + two-ptr

📁 File 1 — [Link]
✅ Uses built-in methods (Arrays, Collections, Math, StringBuilder)
✅ Clean modular static methods — one function per problem
✅ Optimised algorithms (HashMap, Streams, [Link], etc.)

Phase 1 — Basics + Logic

1. Even or Odd
static String evenOrOdd(int n) {
return (n % 2 == 0) ? "Even" : "Odd";
}

2. Positive / Negative / Zero

static String checkSign(int n) {
if (n > 0) return "Positive";
else if (n < 0) return "Negative";
else return "Zero";
}

3. Largest of 2
static int largest2(int a, int b) {
return [Link](a, b);
}

4. Largest of 3
static int largest3(int a, int b, int c) {
return [Link](a, [Link](b, c));
}

5. Leap Year
static boolean isLeapYear(int y) {
return (y % 4 == 0 && y % 100 != 0) || (y % 400 == 0);
}

6. Swap Without 3rd Variable

static int[] swap(int a, int b) {
a ^= b; b ^= a; a ^= b; // XOR swap
return new int[]{a, b};
}

7. Simple Calculator (switch)

static double calculator(double a, double b, char op) {
switch (op) {
case '+': return a + b;
case '-': return a - b;
case '*': return a * b;
case '/': return (b != 0) ? a / b : [Link];
default : return 0;
}
}
8. Print 1 to N
static void printN(int n) {
for (int i = 1; i <= n; i++) [Link](i + " ");
[Link]();
}

9. Sum of N numbers
static long sumN(int n) {
return (long) n * (n + 1) / 2; // Gauss formula
}

10. Factorial (iterative)

static long factorial(int n) {
long f = 1;
for (int i = 2; i <= n; i++) f *= i;
return f;
}

11. Reverse a Number

static int reverseNum(int n) {
int rev = 0;
boolean neg = n < 0;
n = [Link](n);
while (n > 0) { rev = rev * 10 + n % 10; n /= 10; }
return neg ? -rev : rev;
}

12. Palindrome Number

static boolean isPalindromeNum(int n) {
return n == reverseNum(n);
}

13. Count Digits

static int countDigits(int n) {
return [Link]([Link](n)).length();
}

14. Sum of Digits

static int sumDigits(int n) {
int s = 0; n = [Link](n);
while (n > 0) { s += n % 10; n /= 10; }
return s;
}

15. Armstrong Number

static boolean isArmstrong(int n) {
int digits = countDigits(n), sum = 0, tmp = n;
while (tmp > 0) {
sum += (int) [Link](tmp % 10, digits);
tmp /= 10;
}
return sum == n;
}

16. Prime Check

static boolean isPrime(int n) {
if (n < 2) return false;
if (n == 2) return true;
if (n % 2 == 0) return false;
for (int i = 3; i * i <= n; i += 2)
 if (n % i == 0) return false;
return true;
}

17. Fibonacci Series

static void fibonacci(int n) {
int a = 0, b = 1;
for (int i = 0; i < n; i++) {
[Link](a + " ");
int t = a + b; a = b; b = t;
}
}

18. GCD (Euclidean)

static int gcd(int a, int b) {
return (b == 0) ? a : gcd(b, a % b);
}

19. LCM
static int lcm(int a, int b) {
return a / gcd(a, b) * b;
}

20. Strong Number

static boolean isStrong(int n) {
int tmp = n, sum = 0;
while (tmp > 0) { sum += factorial(tmp % 10); tmp /= 10; }
return sum == n;
}

Patterns (21–30)
21–22. Star Triangle & Inverted
static void starTriangle(int n) {
for (int i = 1; i <= n; i++) {
for (int j = 0; j < i; j++) [Link]("* ");
[Link]();
}
}

static void invertedStarTriangle(int n) {

for (int i = n; i >= 1; i--) {
for (int j = 0; j < i; j++) [Link]("* ");
[Link]();
}
}

24–25. Pyramid & Inverted

static void pyramid(int n) {
for (int i = 1; i <= n; i++) {
for (int j = i; j < n; j++) [Link](" ");
for (int j = 0; j < 2*i-1; j++) [Link]("*");
[Link]();
}
}

26. Diamond
static void diamond(int n) {
pyramid(n);
invertedPyramid(n - 1);
}
28. Floyd's Triangle
static void floydsTriangle(int n) {
int k = 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= i; j++) [Link](k++ + " ");
[Link]();
}
}

29. Pascal's Triangle

static void pascalsTriangle(int n) {
for (int i = 0; i < n; i++) {
long val = 1;
for (int j = 0; j <= i; j++) {
[Link](val + " ");
val = val * (i - j) / (j + 1);
}
[Link]();
}
}

30. Hollow Square

static void hollowSquare(int n) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++)
[Link]((i==0||i==n-1||j==0||j==n-1) ? "* " : " ");
[Link]();
}
}

Phase 2 — Functions + Arrays + Strings

33. Recursive Factorial
static long recursiveFactorial(int n) {
return (n <= 1) ? 1 : n * recursiveFactorial(n - 1);
}

34. Recursive Fibonacci

static int recursiveFibo(int n) {
return (n <= 1) ? n : recursiveFibo(n-1) + recursiveFibo(n-2);
}

38. Reverse Array

static int[] reverseArray(int[] a) {
int[] r = new int[[Link]];
for (int i = 0; i < [Link]; i++) r[i] = a[[Link]-1-i];
return r;
}

39. Second Largest

static int secondLargest(int[] a) {
int max = Integer.MIN_VALUE, second = Integer.MIN_VALUE;
for (int x : a) {
if (x > max) { second = max; max = x; }
else if (x > second && x != max) second = x;
}
return second;
}
40. Remove Duplicates
static int[] removeDuplicates(int[] a) {
LinkedHashSet<Integer> set = new LinkedHashSet<>();
for (int x : a) [Link](x);
return [Link]().mapToInt(Integer::intValue).toArray();
}

41. Move Zeros to End

static int[] moveZerosToEnd(int[] a) {
int[] res = [Link](); int pos = 0;
for (int x : res) if (x != 0) res[pos++] = x;
while (pos < [Link]) res[pos++] = 0;
return res;
}

42. Rotate Array by K

static int[] rotateByK(int[] a, int k) {
int n = [Link]; k %= n;
int[] res = new int[n];
for (int i = 0; i < n; i++) res[i] = a[(i + k) % n];
return res;
}

48. Anagram Check

static boolean isAnagram(String a, String b) {
char[] ca = [Link](), cb = [Link]();
[Link](ca); [Link](cb);
return [Link](ca, cb);
}

49. First Non-Repeating Character

static char firstNonRepeat(String s) {
Map<Character, Integer> map = new LinkedHashMap<>();
for (char c : [Link]()) [Link](c, 1, Integer::sum);
for ([Link]<Character, Integer> e : [Link]())
if ([Link]() == 1) return [Link]();
return '\0';
}

Phase 3 — OOP Classes

64. Abstract Class + 65. Interface
abstract class Shape { abstract double area(); }

class Circle extends Shape {

double r;
Circle(double r) { this.r = r; }
@Override double area() { return [Link] * r * r; }
}

interface Printable { void print(); }

class Document implements Printable {

String title;
Document(String t) { title = t; }
@Override public void print() { [Link](title); }
}
Phase 4 — DSA Core
66. Two Sum — O(n) HashMap
static int[] twoSum(int[] nums, int target) {
Map<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < [Link]; i++) {
int comp = target - nums[i];
if ([Link](comp)) return new int[]{[Link](comp), i};
[Link](nums[i], i);
}
return new int[]{-1, -1};
}

67. Kadane's Max Subarray

static int kadane(int[] a) {
int maxSoFar = a[0], maxEndingHere = a[0];
for (int i = 1; i < [Link]; i++) {
maxEndingHere = [Link](a[i], maxEndingHere + a[i]);
maxSoFar = [Link](maxSoFar, maxEndingHere);
}
return maxSoFar;
}

69. Majority Element — Boyer-Moore

static int majorityElement(int[] a) {
int count = 0, candidate = 0;
for (int x : a) {
if (count == 0) candidate = x;
count += (x == candidate) ? 1 : -1;
}
return candidate;
}

70. Subarray Sum = K — Prefix Sum

static int subarraySumK(int[] a, int k) {
Map<Integer, Integer> map = new HashMap<>();
[Link](0, 1);
int sum = 0, count = 0;
for (int x : a) {
sum += x;
count += [Link](sum - k, 0);
[Link](sum, 1, Integer::sum);
}
return count;
}

72. Binary Search

static int binarySearch(int[] a, int key) {
int lo = 0, hi = [Link] - 1;
while (lo <= hi) {
int mid = lo + (hi - lo) / 2;
if (a[mid] == key) return mid;
else if (a[mid] < key) lo = mid + 1;
else hi = mid - 1;
}
return -1;
}
Phase 5 — Advanced DSA
81–84. Linked List Implementation
class Node { int data; Node next; Node(int d) { data = d; } }

class LinkedList {
Node head;

void insert(int d) { // 81
Node n = new Node(d);
if (head == null) { head = n; return; }
Node cur = head;
while ([Link] != null) cur = [Link];
[Link] = n;
}

void delete(int d) { // 82
if (head == null) return;
if ([Link] == d) { head = [Link]; return; }
Node cur = head;
while ([Link] != null && [Link] != d) cur = [Link];
if ([Link] != null) [Link] = [Link];
}

void reverse() { // 83 / 95
Node prev = null, cur = head, nxt;
while (cur != null) {
nxt = [Link]; [Link] = prev; prev = cur; cur = nxt;
}
head = prev;
}

boolean hasCycle() { // 84
Node slow = head, fast = head;
while (fast != null && [Link] != null) {
slow = [Link]; fast = [Link];
if (slow == fast) return true;
}
return false;
}
}

86. Valid Parentheses

static boolean validParens(String s) {
StackArr stack = new StackArr([Link]());
for (char c : [Link]()) {
if (c=='(' || c=='[' || c=='{') [Link](c);
else {
if ([Link]()) return false;
char top = (char) [Link]();
if ((c==')' && top!='(') || (c==']' && top!='[')
|| (c=='}' && top!='{')) return false;
}
}
return [Link]();
}

Phase 6 — Placement Level

89. Longest Substring Without Repeating — Sliding Window
static int longestSubstring(String s) {
Map<Character, Integer> map = new HashMap<>();
int max = 0, left = 0;
 for (int right = 0; right < [Link](); right++) {
char c = [Link](right);
if ([Link](c) && [Link](c) >= left)
left = [Link](c) + 1;
[Link](c, right);
max = [Link](max, right - left + 1);
}
return max;
}

90. Container With Most Water — Two Pointers

static int containerWater(int[] h) {
int l = 0, r = [Link]-1, max = 0;
while (l < r) {
max = [Link](max, [Link](h[l], h[r]) * (r - l));
if (h[l] < h[r]) l++; else r--;
}
return max;
}

91. 3Sum — Sort + Two Pointers

static List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> res = new ArrayList<>();
[Link](nums);
for (int i = 0; i < [Link]-2; i++) {
if (i > 0 && nums[i] == nums[i-1]) continue;
int l = i+1, r = [Link]-1;
while (l < r) {
int s = nums[i] + nums[l] + nums[r];
if (s == 0) {
[Link]([Link](nums[i], nums[l], nums[r]));
while (l < r && nums[l] == nums[l+1]) l++;
while (l < r && nums[r] == nums[r-1]) r--;
l++; r--;
} else if (s < 0) l++;
else r--;
}
}
return res;
}

92. Climbing Stairs (DP)

static int climbStairs(int n) {
if (n <= 2) return n;
int a = 1, b = 2;
for (int i = 3; i <= n; i++) { int t = a + b; a = b; b = t; }
return b;
}
📁 File 2 — [Link]
✅ Zero built-in helper methods — every problem solved inline
✅ No [Link], no Collections, no StringBuilder, no [Link]
✅ Uses: int[], char[], basic loops, if-else, switch — nothing else

Phase 1 — Pure Logic

1. Even or Odd — raw modulus
int num = 7;
if (num % 2 == 0)
[Link](num + " is Even");
else
[Link](num + " is Odd");

5. Leap Year — raw divisibility

int year = 2024;
boolean isLeap = (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
[Link](year + " is leap year: " + isLeap);

6. Swap — arithmetic (no XOR)

int a = 5, b = 10;
a = a + b;
b = a - b;
a = a - b;
// a=10, b=5

11. Reverse Number — manual

int n = 12345, rev = 0, tmp = n;
while (tmp != 0) {
rev = rev * 10 + tmp % 10;
tmp /= 10;
}
// rev = 54321

15. Armstrong — manual power loop

int n = 153, digits = 0, tmp = n;
while (tmp != 0) { digits++; tmp /= 10; }
int armSum = 0; tmp = n;
while (tmp != 0) {
int d = tmp % 10, pw = 1;
for (int i = 0; i < digits; i++) pw *= d;
armSum += pw;
tmp /= 10;
}
// isArmstrong: armSum == n

17. Fibonacci — two variable

int a = 0, b = 1;
for (int i = 0; i < n; i++) {
[Link](a + " ");
int t = a + b; a = b; b = t;
}
Arrays — Pure
40. Remove Duplicates — nested loop
int[] uniq = new int[[Link]]; int uniqLen = 0;
for (int i = 0; i < [Link]; i++) {
boolean dup = false;
for (int j = 0; j < uniqLen; j++)
if (uniq[j] == arr[i]) { dup = true; break; }
if (!dup) uniq[uniqLen++] = arr[i];
}

42. Rotate by K — triple reverse

// Reverse first k elements
// Reverse remaining elements
// Reverse entire array
// All done inline with lo/hi pointer swaps

Strings — Pure char arrays

45. Reverse String — char[] two-pointer
char[] s = "hello".toCharArray();
int l = 0, r = [Link] - 1;
while (l < r) {
char t = s[l]; s[l] = s[r]; s[r] = t;
l++; r--;
}

48. Anagram — bubble sort on char[]

char[] sa = "listen".toCharArray();
char[] sb = "silent".toCharArray();
// bubble sort both arrays, then compare char-by-char

52. Lowercase to Uppercase — ASCII trick

for (int i = 0; i < [Link]; i++)
if (s[i] >= 'a' && s[i] <= 'z')
s[i] = (char)(s[i] - 32);

Phase 4 — DSA Pure Logic

66. Two Sum — brute-force O(n²)
for (int i = 0; i < [Link]; i++)
for (int j = i+1; j < [Link]; j++)
if (ts[i] + ts[j] == target) {
// found: indices i and j
break;
}

67. Kadane's — pure

int maxSoFar = a[0], maxEnd = a[0];
for (int i = 1; i < [Link]; i++) {
maxEnd = (a[i] > maxEnd + a[i]) ? a[i] : maxEnd + a[i];
if (maxEnd > maxSoFar) maxSoFar = maxEnd;
}

75–77. All Three Sorts — raw swaps

// Bubble Sort
for (int i = 0; i < n-1; i++)
for (int j = 0; j < n-i-1; j++)
if (a[j] > a[j+1]) { int t=a[j]; a[j]=a[j+1]; a[j+1]=t; }
 // Selection Sort
for (int i = 0; i < n-1; i++) {
int minIdx = i;
for (int j = i+1; j < n; j++) if (a[j] < a[minIdx]) minIdx = j;
int t=a[minIdx]; a[minIdx]=a[i]; a[i]=t;
}

// Insertion Sort
for (int i = 1; i < n; i++) {
int key = a[i], j = i-1;
while (j >= 0 && a[j] > key) { a[j+1] = a[j]; j--; }
a[j+1] = key;
}

Phase 5 — Stack & Queue — Raw Arrays

85. Stack
int[] stk = new int[10]; int top = -1;
stk[++top] = 10; // push
stk[++top] = 20;
int popped = stk[top--]; // pop

87. Queue
int[] q = new int[5]; int front = 0, rear = -1, size = 0;
q[++rear] = 1; size++; // enqueue
int dequeued = q[front++]; size--; // dequeue

88. Circular Queue

int[] cq = new int[cap]; int front = -1, rear = -1;
// enqueue
rear = (rear+1) % cap;
if (front == -1) front = 0;
cq[rear] = val;

// dequeue
int v = cq[front];
if (front == rear) { front = rear = -1; } // last element
else front = (front+1) % cap;

Phase 6 — Placement Pure

89. Longest Substring — brute-force with boolean[]
for (int i = 0; i < [Link]; i++) {
boolean[] seen = new boolean[256];
for (int j = i; j < [Link]; j++) {
if (seen[s[j]]) break;
seen[s[j]] = true;
if (j - i + 1 > maxLen) maxLen = j - i + 1;
}
}

91. 3Sum — sort (insertion) + two pointers

// Step 1: inline insertion sort the array
// Step 2: fix i, use lo/hi pointers for remaining sum
for (int i = 0; i < n-2; i++) {
int lo = i+1, hi = n-1;
while (lo < hi) {
int s = nums[i] + nums[lo] + nums[hi];
if (s == 0) { /* print triplet */ lo++; hi--; }
else if (s < 0) lo++;
 else hi--;
}
}

96. Valid Palindrome — clean + two-pointer

// Step 1: extract alphanumeric + lowercase manually
char[] clean = new char[[Link]]; int clen = 0;
for (char c : s) {
if (isAlnum(c)) clean[clen++] = toLower(c);
}
// Step 2: two-pointer palindrome check
int l = 0, r = clen - 1;
while (l < r) {
if (clean[l] != clean[r]) { isPalin = false; break; }
l++; r--;
}