90 coding interview questions with their answers using Java 8 or above.

Basic Syntax and Data Structures

1. Reverse a String

java
Copy code
public class ReverseString {
public static void main(String[] args) {
String str = "hello";
String reversed = new
StringBuilder(str).reverse().toString();
[Link](reversed); // Output: "olleh"
}
}

2. Find the Factorial of a Number

java
Copy code
public class Factorial {
public static void main(String[] args) {
int number = 5;
int factorial = 1;
for (int i = 1; i <= number; i++) {
factorial *= i;
}
[Link](factorial); // Output: 120
}
}

3. Check if a Number is Prime

java
Copy code
public class PrimeNumber {
public static void main(String[] args) {
int number = 29;
boolean isPrime = true;
for (int i = 2; i <= number / 2; i++) {
if (number % i == 0) {
isPrime = false;
break;
}
}
[Link](isPrime); // Output: true
}
}

4. Find the Fibonacci Series up to N Terms

java
Copy code
public class Fibonacci {
public static void main(String[] args) {
int n = 10;
int a = 0, b = 1;
[Link](a + " " + b);
for (int i = 2; i < n; i++) {
int next = a + b;
[Link](" " + next);
a = b;
b = next;
}
}
}

5. Find the Largest Element in an Array

java
Copy code
public class LargestElement {
public static void main(String[] args) {
int[] arr = {1, 3, 5, 7, 9};
int max = arr[0];
for (int i : arr) {
if (i > max) {
max = i;
}
}
[Link](max); // Output: 9
}
}

Java 8 Features

6. Use a Lambda Expression to Sort a List

java
Copy code
import [Link].*;

public class LambdaSort {

public static void main(String[] args) {
List<String> names = [Link]("John", "Jane", "Alex",
"Chris");
[Link](names, (a, b) -> [Link](b));
[Link](names); // Output: [Alex, Chris, Jane,
John]
}
}

7. Filter a List using Streams

java
Copy code
import [Link].*;
import [Link].*;

public class FilterList {

public static void main(String[] args) {
List<Integer> numbers = [Link](1, 2, 3, 4, 5, 6, 7, 8,
9, 10);
List<Integer> evenNumbers = [Link]()
.filter(n -> n % 2 == 0)
.collect([Link]());
[Link](evenNumbers); // Output: [2, 4, 6, 8, 10]
}
}

8. Compute Sum of a List of Integers Using Streams

java
Copy code
import [Link].*;
import [Link].*;

public class SumList {

public static void main(String[] args) {
List<Integer> numbers = [Link](1, 2, 3, 4, 5);
int sum = [Link]().mapToInt(Integer::intValue).sum();
[Link](sum); // Output: 15
}
}

9. Find the Maximum Value in a List Using Streams

java
Copy code
import [Link].*;
import [Link].*;

public class MaxValue {

public static void main(String[] args) {
List<Integer> numbers = [Link](1, 2, 3, 4, 5);
int max = [Link]().max(Integer::compare).get();
[Link](max); // Output: 5
}
}

10. Create and Use Optional in Java 8

java
Copy code
import [Link].*;

public class OptionalExample {

public static void main(String[] args) {
Optional<String> name = [Link]("John");
[Link]([Link]("Default Name")); // Output:
John

name = [Link]();
[Link]([Link]("Default Name")); // Output:
Default Name
}
}

Advanced Concepts

11. Implement a Singleton Pattern

java
Copy code
public class Singleton {
private static Singleton instance;

private Singleton() {}

public static Singleton getInstance() {

if (instance == null) {
synchronized ([Link]) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}

12. Implement a Basic LinkedList

java
Copy code
class Node {
int data;
Node next;

Node(int data) {
[Link] = data;
[Link] = null;
}
}

class LinkedList {
Node head;

void append(int data) {

if (head == null) {
head = new Node(data);
} else {
Node current = head;
while ([Link] != null) {
current = [Link];
}
[Link] = new Node(data);
}
}

void printList() {
Node current = head;
while (current != null) {
[Link]([Link] + " ");
current = [Link];
}
[Link]();
}

public static void main(String[] args) {

LinkedList list = new LinkedList();
[Link](1);
[Link](2);
[Link](3);
[Link](); // Output: 1 2 3
}
}

13. Find the Intersection of Two Arrays

java
Copy code
import [Link].*;

public class ArrayIntersection {

public static void main(String[] args) {
int[] array1 = {1, 2, 3, 4, 5};
int[] array2 = {4, 5, 6, 7, 8};
Set<Integer> set1 = new HashSet<>();
for (int num : array1) {
[Link](num);
}
Set<Integer> intersection = new HashSet<>();
for (int num : array2) {
if ([Link](num)) {
[Link](num);
}
}
[Link](intersection); // Output: [4, 5]
}
}

14. Sort a Map by Values

java
Copy code
import [Link].*;
import [Link].*;

public class SortMap {

public static void main(String[] args) {
Map<String, Integer> map = new HashMap<>();
[Link]("John", 25);
[Link]("Jane", 30);
[Link]("Alex", 20);

Map<String, Integer> sortedMap = [Link]()

.stream()
.sorted([Link]())
.collect([Link](
[Link]::getKey,
[Link]::getValue,
(e1, e2) -> e1,
LinkedHashMap::new
));
[Link](sortedMap); // Output: {Alex=20, John=25,
Jane=30}
}
}

15. Implement a Basic Tree Structure

java
Copy code
class TreeNode {
int value;
TreeNode left, right;

TreeNode(int item) {
value = item;
left = right = null;
}
}

class BinaryTree {
TreeNode root;

void inorder(TreeNode node) {

if (node != null) {
inorder([Link]);
[Link]([Link] + " ");
inorder([Link]);
}
}

public static void main(String[] args) {

BinaryTree tree = new BinaryTree();
[Link] = new TreeNode(1);
[Link] = new TreeNode(2);
[Link] = new TreeNode(3);
[Link] = new TreeNode(4);
[Link] = new TreeNode(5);

[Link]([Link]); // Output: 4 2 5 1 3
}
}

Additional Advanced Questions

16. Use Java Streams to Find Duplicate Elements in a List

java
Copy code
import [Link].*;
import [Link].*;

public class FindDuplicates {

public static void main(String[] args) {
List<String> list = [Link]("a", "b", "c", "a", "b",
"d");
Set<String> duplicates = [Link]()
.collect([Link](e -> e,
[Link]()))
.entrySet()
.stream()
.filter(entry -> [Link]() > 1)
.map([Link]::getKey)
.collect([Link]());
[Link](duplicates); // Output: [a, b]
}
}
17. Create a CompletableFuture Example

java
Copy code
import [Link];

public class CompletableFutureExample {

public static void main(String[] args) {
[Link](() -> {
return "Hello";
}).thenApply(result -> {
return result + " World";
}).thenAccept([Link]::println); // Output: Hello World
}
}

18. Use Java 8 Optional with Default Values

java
Copy code
import [Link];

public class OptionalDefault {

public static void main(String[] args) {
Optional<String> optional = [Link](null);
String value = [Link]("Default Value");
[Link](value); // Output: Default Value
}
}

19. Create a Custom Functional Interface

java
Copy code
@FunctionalInterface
interface MyFunctionalInterface {
void execute(String message);
}

public class CustomFunctionalInterface {

public static void main(String[] args) {
MyFunctionalInterface myFunc = (message) -> {
[Link]("Message: " + message);
};
[Link]("Hello, Functional Interface!"); // Output:
Message: Hello, Functional Interface!
}
}

20. Convert a List to a Map Using Streams

java
Copy code
import [Link].*;
import [Link].*;

public class ListToMap {

public static void main(String[] args) {
List<String> list = [Link]("a", "b", "c");
Map<Integer, String> map = [Link]()
.collect([Link](String::length, s -> s));
[Link](map); // Output: {1=a, 2=b, 1=c}
}
}

Additional Questions

21. Remove Duplicates from a List

java
Copy code
import [Link].*;

public class RemoveDuplicates {

public static void main(String[] args) {
List<String> list = [Link]("a", "b", "c", "a", "b");
Set<String> unique = new HashSet<>(list);
[Link](unique); // Output: [a, b, c]
}
}

22. Find the Intersection of Two Sets

java
Copy code
import [Link].*;

public class SetIntersection {

public static void main(String[] args) {
Set<Integer> set1 = new HashSet<>([Link](1, 2, 3, 4,
5));
Set<Integer> set2 = new HashSet<>([Link](4, 5, 6, 7,
8));
[Link](set2);
[Link](set1); // Output: [4, 5]
}
}

23. Find the Longest Common Prefix in an Array of Strings

java
Copy code
public class LongestCommonPrefix {
public static void main(String[] args) {
String[] strs = {"flower", "flow", "flight"};
if (strs == null || [Link] == 0) return;
String prefix = strs[0];
for (int i = 1; i < [Link]; i++) {
while (strs[i].indexOf(prefix) != 0) {
prefix = [Link](0, [Link]() - 1);
if ([Link]()) return;
}
}
[Link](prefix); // Output: "fl"
}
}
24. Implement a Basic Queue

java
Copy code
import [Link];

public class BasicQueue {

private LinkedList<Integer> list = new LinkedList<>();

public void enqueue(int item) {

[Link](item);
}

public int dequeue() {

return [Link]();
}

public boolean isEmpty() {

return [Link]();
}

public static void main(String[] args) {

BasicQueue queue = new BasicQueue();
[Link](1);
[Link](2);
[Link]([Link]()); // Output: 1
[Link]([Link]()); // Output: 2
}
}

25. Calculate the GCD of Two Numbers

java
Copy code
public class GCD {
public static void main(String[] args) {
int a = 56, b = 98;
while (b != 0) {
int temp = b;
b = a % b;
a = temp;
}
[Link](a); // Output: 14
}
}

This list includes a variety of questions that should help you prepare for different aspects of a
Java interview. If you need more questions or specific topics, just let me know!

You said:

remaining 75
ChatGPT said:

ChatGPT

Sure! Here are 75 more coding questions with their answers using Java 8 or above:
Additional Java 8 Features and Functional Programming

26. Merge Two Lists into a Single List

java
Copy code
import [Link].*;

public class MergeLists {

public static void main(String[] args) {
List<String> list1 = [Link]("a", "b", "c");
List<String> list2 = [Link]("d", "e", "f");
List<String> mergedList = [Link]([Link](),
[Link]())

.collect([Link]());
[Link](mergedList); // Output: [a, b, c, d, e, f]
}
}

27. Generate a Range of Numbers Using Streams

java
Copy code
import [Link].*;

public class RangeExample {

public static void main(String[] args) {
List<Integer> numbers = [Link](1,
10).boxed().collect([Link]());
[Link](numbers); // Output: [1, 2, 3, 4, 5, 6, 7,
8, 9]
}
}

28. Group a List of Strings by Length

java
Copy code
import [Link].*;
import [Link].*;

public class GroupByLength {

public static void main(String[] args) {
List<String> words = [Link]("apple", "bat", "banana",
"pear", "kiwi");
Map<Integer, List<String>> groupedByLength = [Link]()
.collect([Link](String::length));
[Link](groupedByLength); // Output: {3=[bat],
4=[pear, kiwi], 5=[apple], 6=[banana]}
}
}

29. Find the Average of a List of Numbers

java
Copy code
import [Link].*;
import [Link].*;

public class AverageExample {

public static void main(String[] args) {
List<Integer> numbers = [Link](1, 2, 3, 4, 5);
double average =
[Link]().mapToInt(Integer::intValue).average().orElse(0.0);
[Link](average); // Output: 3.0
}
}

30. Convert a List of Strings to Uppercase

java
Copy code
import [Link].*;
import [Link].*;

public class ToUpperCase {

public static void main(String[] args) {
List<String> list = [Link]("hello", "world");
List<String> upperCaseList =
[Link]().map(String::toUpperCase).collect([Link]());
[Link](upperCaseList); // Output: [HELLO, WORLD]
}
}

Collections and Data Structures

31. Implement a Stack

java
Copy code
import [Link].*;

public class StackExample {

private Deque<Integer> stack = new ArrayDeque<>();

public void push(int item) {

[Link](item);
}

public int pop() {

return [Link]();
}

public boolean isEmpty() {

return [Link]();
}

public static void main(String[] args) {

StackExample stack = new StackExample();
[Link](1);
[Link](2);
[Link]([Link]()); // Output: 2
[Link]([Link]()); // Output: 1
}
}
32. Implement a PriorityQueue

java
Copy code
import [Link].*;

public class PriorityQueueExample {

public static void main(String[] args) {
PriorityQueue<Integer> pq = new PriorityQueue<>();
[Link](10);
[Link](5);
[Link](20);
[Link]([Link]()); // Output: 5
[Link]([Link]()); // Output: 10
}
}

33. Implement a HashMap and Iterate Over Its Entries

java
Copy code
import [Link].*;

public class HashMapExample {

public static void main(String[] args) {
Map<String, Integer> map = new HashMap<>();
[Link]("apple", 1);
[Link]("banana", 2);
[Link]("cherry", 3);
for ([Link]<String, Integer> entry : [Link]()) {
[Link]([Link]() + ": " +
[Link]());
}
}
}

34. Find the First Non-Repeated Character in a String

java
Copy code
import [Link].*;

public class FirstNonRepeatedCharacter {

public static void main(String[] args) {
String str = "swiss";
Map<Character, Long> frequencyMap = [Link]()
.mapToObj(c -> (char) c)
.collect([Link](c -> c,
[Link]()));
Character firstNonRepeated = [Link]()
.mapToObj(c -> (char) c)
.filter(c -> [Link](c) == 1)
.findFirst()
.orElse(null);
[Link](firstNonRepeated); // Output: w
}
}

35. Sort a List of Custom Objects by a Property

java
Copy code
import [Link].*;

class Person {
String name;
int age;

Person(String name, int age) {

[Link] = name;
[Link] = age;
}

public String toString() {

return name + ": " + age;
}
}

public class SortObjects {

public static void main(String[] args) {
List<Person> people = [Link](new Person("Alice", 30),
new Person("Bob", 25), new Person("Charlie", 35));
[Link]([Link](p -> [Link]));
[Link]([Link]::println); // Output: Bob: 25,
Alice: 30, Charlie: 35
}
}

Algorithms

36. Binary Search Algorithm

java
Copy code
public class BinarySearch {
public static void main(String[] args) {
int[] array = {1, 3, 5, 7, 9};
int target = 7;
int result = binarySearch(array, target);
[Link](result); // Output: 3
}

public static int binarySearch(int[] array, int target) {

int left = 0, right = [Link] - 1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (array[mid] == target) return mid;
if (array[mid] < target) left = mid + 1;
else right = mid - 1;
}
return -1; // Target not found
}
}

37. Merge Sort Algorithm

java
Copy code
import [Link].*;
public class MergeSort {
public static void main(String[] args) {
int[] array = {38, 27, 43, 3, 9, 82, 10};
mergeSort(array, 0, [Link] - 1);
[Link]([Link](array)); // Output: [3, 9,
10, 27, 38, 43, 82]
}

public static void mergeSort(int[] array, int left, int right) {

if (left < right) {
int mid = (left + right) / 2;
mergeSort(array, left, mid);
mergeSort(array, mid + 1, right);
merge(array, left, mid, right);
}
}

public static void merge(int[] array, int left, int mid, int
right) {
int n1 = mid - left + 1;
int n2 = right - mid;

int[] L = new int[n1];

int[] R = new int[n2];

[Link](array, left, L, 0, n1);

[Link](array, mid + 1, R, 0, n2);

int i = 0, j = 0;
int k = left;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
array[k++] = L[i++];
} else {
array[k++] = R[j++];
}
}

while (i < n1) {

array[k++] = L[i++];
}

while (j < n2) {

array[k++] = R[j++];
}
}
}

38. Find the Kth Largest Element in an Array

java
Copy code
import [Link].*;

public class KthLargest {

public static void main(String[] args) {
int[] array = {3, 2, 1, 5, 6, 4};
int k = 2;
int result = findKthLargest(array, k);
[Link](result); // Output: 5
}

public static int findKthLargest(int[] nums, int k) {

PriorityQueue<Integer> minHeap = new PriorityQueue<>();
for (int num : nums) {
[Link](num);
if ([Link]() > k) {
[Link]();
}
}
return [Link]();
}
}

39. Find the Longest Palindromic Substring

java
Copy code
public class LongestPalindromicSubstring {
public static void main(String[] args) {
String s = "babad";
String result = longestPalindrome(s);
[Link](result); // Output: "bab" or "aba"
}

public static String longestPalindrome(String s) {

if (s == null || [Link]() == 0) return "";
int start = 0, end = 0;
for (int i = 0; i < [Link](); i++) {
int len1 = expandAroundCenter(s, i, i);
int len2 = expandAroundCenter(s, i, i + 1);
int len = [Link](len1, len2);
if (len > end - start) {
start = i - (len - 1) / 2;
end = i + len / 2;
}
}
return [Link](start, end + 1);
}

private static int expandAroundCenter(String s, int left, int

right) {
while (left >= 0 && right < [Link]() && [Link](left) ==
[Link](right)) {
left--;
right++;
}
return right - left - 1;
}
}

40. Implement Depth-First Search (DFS) on a Graph

java
Copy code
import [Link].*;

class Graph {
private final Map<Integer, List<Integer>> adjacencyList = new
HashMap<>();

public void addEdge(int src, int dest) {

[Link](src, k -> new
ArrayList<>()).add(dest);
}

public void dfs(int start) {

Set<Integer> visited = new HashSet<>();
dfsRecursive(start, visited);
}

private void dfsRecursive(int node, Set<Integer> visited) {

if ([Link](node)) return;
[Link](node);
[Link](node + " ");
for (int neighbor : [Link](node,
[Link]())) {
dfsRecursive(neighbor, visited);
}
}

public static void main(String[] args) {

Graph graph = new Graph();
[Link](1, 2);
[Link](1, 3);
[Link](2, 4);
[Link](2, 5);
[Link](3, 6);
[Link](3, 7);

[Link](1); // Output: 1 2 4 5 3 6 7
}
}

Object-Oriented Programming

41. Implement an Abstract Class

java
Copy code
abstract class Animal {
abstract void makeSound();

void sleep() {
[Link]("Zzz");
}
}

class Dog extends Animal {

void makeSound() {
[Link]("Woof");
}
}

public class AbstractClassExample {

public static void main(String[] args) {
Animal myDog = new Dog();
[Link](); // Output: Woof
[Link](); // Output: Zzz
}
}

42. Implement an Interface

java
Copy code
interface Drawable {
void draw();
}

class Circle implements Drawable {

public void draw() {
[Link]("Drawing a circle");
}
}

public class InterfaceExample {

public static void main(String[] args) {
Drawable drawable = new Circle();
[Link](); // Output: Drawing a circle
}
}

43. Use Inheritance to Extend a Class

java
Copy code
class Animal {
void eat() {
[Link]("This animal eats food");
}
}

class Dog extends Animal {

void bark() {
[Link]("The dog barks");
}
}

public class InheritanceExample {

public static void main(String[] args) {
Dog dog = new Dog();
[Link](); // Output: This animal eats food
[Link](); // Output: The dog barks
}
}

44. Create a Simple Java Bean

java
Copy code
public class Person {
private String name;
private int age;

public String getName() {

return name;
}

public void setName(String name) {

[Link] = name;
}

public int getAge() {

return age;
}

public void setAge(int age) {

[Link] = age;
}
}

public class JavaBeanExample {

public static void main(String[] args) {
Person person = new Person();
[Link]("Alice");
[Link](30);
[Link]([Link]() + " is " +
[Link]() + " years old.");
// Output: Alice is 30 years old.
}
}

45. Override the toString() Method

java
Copy code
class Book {
private String title;
private String author;

public Book(String title, String author) {

[Link] = title;
[Link] = author;
}

@Override
public String toString() {
return "Book [title=" + title + ", author=" + author + "]";
}
}

public class ToStringExample {

public static void main(String[] args) {
Book book = new Book("1984", "George Orwell");
[Link](book); // Output: Book [title=1984,
author=George Orwell]
}
}

Concurrency and Multithreading

46. Create a Thread Using Runnable Interface

java
Copy code
public class RunnableExample {
public static void main(String[] args) {
Runnable task = () -> {
for (int i = 0; i < 5; i++) {
[Link]([Link]().getId() + "
Value: " + i);
}
};

Thread thread1 = new Thread(task);

Thread thread2 = new Thread(task);
[Link]();
[Link]();
}
}

47. Use Callable and Future to Return a Result from a Thread

java
Copy code
import [Link].*;

public class CallableExample {

public static void main(String[] args) throws
InterruptedException, ExecutionException {
ExecutorService executor = [Link]();
Callable<Integer> task = () -> {
[Link](1000);
return 123;
};

Future<Integer> future = [Link](task);

Integer result = [Link]();
[Link](result); // Output: 123
[Link]();
}
}

48. Synchronize Access to a Shared Resource

java
Copy code
public class SynchronizedExample {
private int counter = 0;

public synchronized void increment() {

counter++;
}

public static void main(String[] args) {

SynchronizedExample example = new SynchronizedExample();
Runnable task = () -> {
for (int i = 0; i < 1000; i++) {
[Link]();
}
};

Thread t1 = new Thread(task);

Thread t2 = new Thread(task);
[Link]();
[Link]();
try {
[Link]();
[Link]();
} catch (InterruptedException e) {
[Link]();
}
[Link]([Link]); // Output: 2000
}
}

49. Use CountDownLatch for Synchronization

java
Copy code
import [Link].*;

public class CountDownLatchExample {

public static void main(String[] args) throws
InterruptedException {
CountDownLatch latch = new CountDownLatch(2);

Runnable task1 = () -> {

[Link]("Task 1 is running");
[Link]();
};

Runnable task2 = () -> {

[Link]("Task 2 is running");
[Link]();
};

new Thread(task1).start();
new Thread(task2).start();

[Link]();
[Link]("All tasks are completed");
}
}

50. Use Semaphore for Managing Resource Access

java
Copy code
import [Link].*;

public class SemaphoreExample {

public static void main(String[] args) throws
InterruptedException {
Semaphore semaphore = new Semaphore(1);

Runnable task = () -> {

try {
[Link]();
[Link]([Link]().getName() +
" acquired semaphore");
[Link](2000);
} catch (InterruptedException e) {
[Link]();
} finally {
[Link]();
[Link]([Link]().getName() +
" released semaphore");
}
};

new Thread(task).start();
new Thread(task).start();
}
}

Miscellaneous

51. Read and Write Files Using Files Class

java
Copy code
import [Link].*;
import [Link];

public class FileIOExample {

public static void main(String[] args) {
String content = "Hello, World!";
Path path = [Link]("[Link]");

try {
[Link](path, [Link]());
String readContent = new
String([Link](path));
[Link](readContent); // Output: Hello, World!
} catch (IOException e) {
[Link]();
}
}
}

52. Serialize and Deserialize an Object

java
Copy code
import [Link].*;

class Person implements Serializable {

private String name;
private int age;

public Person(String name, int age) {

[Link] = name;
[Link] = age;
}

@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}

public class SerializationExample {

public static void main(String[] args) {
Person person = new Person("Alice", 30);

try (ObjectOutputStream out = new ObjectOutputStream(new

FileOutputStream("[Link]"))) {
[Link](person);
} catch (IOException e) {
[Link]();
}

try (ObjectInputStream in = new ObjectInputStream(new

FileInputStream("[Link]"))) {
Person deserializedPerson = (Person) [Link]();
[Link](deserializedPerson); // Output: Person
[name=Alice, age=30]
} catch (IOException | ClassNotFoundException e) {
[Link]();
}
}
}

53. Implement a Simple Calculator

java
Copy code
import [Link];

public class Calculator {

public static void main(String[] args) {
Scanner scanner = new Scanner([Link]);
[Link]("Enter first number: ");
double num1 = [Link]();
[Link]("Enter second number: ");
double num2 = [Link]();
[Link]("Enter operator (+, -, *, /): ");
char operator = [Link]().charAt(0);

double result;
switch (operator) {
case '+':
result = num1 + num2;
break;
case '-':
result = num1 - num2;
break;
case '*':
result = num1 * num2;
break;
case '/':
result = num1 / num2;
break;
default:
[Link]("Invalid operator");
return;
}
[Link]("Result: " + result);
}
}

54. Implement a Basic Tic-Tac-Toe Game

java
Copy code
import [Link];

public class TicTacToe {

private char[][] board = {{' ', ' ', ' '}, {' ', ' ', ' '}, {' ',
' ', ' '}};
private char currentPlayer = 'X';

public static void main(String[] args) {

TicTacToe game = new TicTacToe();
[Link]();
}

private void play() {

while (true) {
printBoard();
makeMove();
if (isWinner()) {
printBoard();
[Link]("Player " + currentPlayer + "
wins!");
return;
}
if (isBoardFull()) {
printBoard();
[Link]("The game is a draw!");
return;
}
currentPlayer = (currentPlayer == 'X') ? 'O' : 'X';
}
}

private void printBoard() {

[Link](" " + board[0][0] + " | " + board[0][1] +
" | " + board[0][2]);
[Link]("-----------");
[Link](" " + board[1][0] + " | " + board[1][1] +
" | " + board[1][2]);
[Link]("-----------");
[Link](" " + board[2][0] + " | " + board[2][1] +
" | " + board[2][2]);
}

private void makeMove() {

Scanner scanner = new Scanner([Link]);
int row, col;
while (true) {
[Link]("Enter row (0, 1, 2) and column (0, 1,
2) for player " + currentPlayer + ": ");
row = [Link]();
col = [Link]();
if (row >= 0 && row < 3 && col >= 0 && col < 3 &&
board[row][col] == ' ') {
board[row][col] = currentPlayer;
break;
} else {
[Link]("Invalid move. Try again.");
}
}
}
private boolean isBoardFull() {
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (board[i][j] == ' ') {
return false;
}
}
}
return true;
}

private boolean isWinner() {

for (int i = 0; i < 3; i++) {
if (board[i][0] == currentPlayer && board[i][1] ==
currentPlayer && board[i][2] == currentPlayer) {
return true;
}
if (board[0][i] == currentPlayer && board[1][i] ==
currentPlayer && board[2][i] == currentPlayer) {
return true;
}
}
if (board[0][0] == currentPlayer && board[1][1] ==
currentPlayer && board[2][2] == currentPlayer) {
return true;
}
if (board[0][2] == currentPlayer && board[1][1] ==
currentPlayer && board[2][0] == currentPlayer) {
return true;
}
return false;
}
}

55. Use Regular Expressions to Validate an Email Address

java
Copy code
import [Link].*;

public class EmailValidator {

public static void main(String[] args) {
String email = "example@[Link]";
String regex = "^[A-Za-z0-9+_.-]+@(.+)$";
Pattern pattern = [Link](regex);
Matcher matcher = [Link](email);
boolean isValid = [Link]();
[Link]("Is email valid? " + isValid); // Output:
Is email valid? true
}
}

56. Convert a String to a Date

java
Copy code
import [Link].*;
import [Link].*;
public class DateConversion {
public static void main(String[] args) throws ParseException {
String dateString = "2024-09-09";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date date = [Link](dateString);
[Link](date); // Output: Mon Sep 09 [Link] EDT
2024
}
}

57. Calculate the Factorial of a Number Using Recursion

java
Copy code
public class Factorial {
public static void main(String[] args) {
int num = 5;
[Link](factorial(num)); // Output: 120
}

public static int factorial(int n) {

if (n == 0) return 1;
return n * factorial(n - 1);
}
}

58. Find the Fibonacci Sequence Up to a Given Number

java
Copy code
import [Link].*;

public class Fibonacci {

public static void main(String[] args) {
int count = 10;
List<Integer> fibonacciSequence = fibonacci(count);
[Link](fibonacciSequence); // Output: [0, 1, 1,
2, 3, 5, 8, 13, 21, 34]
}

public static List<Integer> fibonacci(int count) {

List<Integer> sequence = new ArrayList<>();
int a = 0, b = 1;
while (count-- > 0) {
[Link](a);
int next = a + b;
a = b;
b = next;
}
return sequence;
}
}

59. Find the Greatest Common Divisor (GCD) of Two Numbers Using Euclid's
Algorithm

java
Copy code
public class GCD {
public static void main(String[] args) {
int a = 56;
int b = 98;
int gcd = findGCD(a, b);
[Link](gcd); // Output: 14
}

public static int findGCD(int a, int b) {

while (b != 0) {
int temp = b;
b = a % b;
a = temp;
}
return a;
}
}

60. Generate a Random Number Between 1 and 100

java
Copy code
import [Link];

public class RandomNumber {

public static void main(String[] args) {
Random random = new Random();
int number = [Link](100) + 1;
[Link](number); // Output: A random number
between 1 and 100
}
}

More Algorithms

61. Implement Quick Sort Algorithm

java
Copy code
import [Link];

public class QuickSort {

public static void main(String[] args) {
int[] array = {10, 7, 8, 9, 1, 5};
quickSort(array, 0, [Link] - 1);
[Link]([Link](array)); // Output: [1, 5,
7, 8, 9, 10]
}

public static void quickSort(int[] array, int low, int high) {

if (low < high) {
int pi = partition(array, low, high);
quickSort(array, low, pi - 1);
quickSort(array, pi + 1, high);
}
}

private static int partition(int[] array, int low, int high) {

int pivot = array[high];
int i = (low - 1);
for (int j = low; j < high; j++) {
if (array[j] <= pivot) {
i++;
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
int temp = array[i + 1];
array[i + 1] = array[high];
array[high] = temp;
return i + 1;
}
}

62. Implement Merge Sort Algorithm

java
Copy code
import [Link];

public class MergeSort {

public static void main(String[] args) {
int[] array = {12, 11, 13, 5, 6, 7};
mergeSort(array, 0, [Link] - 1);
[Link]([Link](array)); // Output: [5, 6,
7, 11, 12, 13]
}

public static void mergeSort(int[] array, int left, int right) {

if (left < right) {
int mid = (left + right) / 2;
mergeSort(array, left, mid);
mergeSort(array, mid + 1, right);
merge(array, left, mid, right);
}
}

private static void merge(int[] array, int left, int mid, int
right) {
int n1 = mid - left + 1;
int n2 = right - mid;
int[] leftArray = new int[n1];
int[] rightArray = new int[n2];

[Link](array, left, leftArray, 0, n1);

[Link](array, mid + 1, rightArray, 0, n2);

int i = 0, j = 0;
int k = left;
while (i < n1 && j < n2) {
if (leftArray[i] <= rightArray[j]) {
array[k++] = leftArray[i++];
} else {
array[k++] = rightArray[j++];
}
}
while (i < n1) {
array[k++] = leftArray[i++];
}
while (j < n2) {
array[k++] = rightArray[j++];
}
}
}

63. Implement Dijkstra's Algorithm for Shortest Path

java
Copy code
import [Link].*;

public class DijkstraAlgorithm {

private static final int INF = Integer.MAX_VALUE;

public static void main(String[] args) {

int[][] graph = {
{0, 7, INF, INF, INF, 14},
{7, 0, 9, INF, INF, 10},
{INF, 9, 0, 6, INF, INF},
{INF, INF, 6, 0, 8, 15},
{INF, INF, INF, 8, 0, 9},
{14, 10, INF, 15, 9, 0}
};

dijkstra(graph, 0);
}

public static void dijkstra(int[][] graph, int src) {

int V = [Link];
int[] dist = new int[V];
boolean[] sptSet = new boolean[V];

[Link](dist, INF);
dist[src] = 0;

for (int count = 0; count < V - 1; count++) {

int u = minDistance(dist, sptSet);
sptSet[u] = true;

for (int v = 0; v < V; v++) {

if (!sptSet[v] && graph[u][v] != INF && dist[u] !=
INF && dist[u] + graph[u][v] < dist[v]) {
dist[v] = dist[u] + graph[u][v];
}
}
}

printSolution(dist);
}

private static int minDistance(int[] dist, boolean[] sptSet) {

int min = INF, minIndex = -1;
for (int v = 0; v < [Link]; v++) {
if (!sptSet[v] && dist[v] <= min) {
min = dist[v];
minIndex = v;
}
}
return minIndex;
}

private static void printSolution(int[] dist) {

[Link]("Vertex \t Distance from Source");
for (int i = 0; i < [Link]; i++) {
[Link](i + " \t " + dist[i]);
}
}
}

64. Implement the A Algorithm for Shortest Path*

java
Copy code
import [Link].*;

class Node {
int x, y;
int gCost, hCost;
Node parent;

Node(int x, int y) {
this.x = x;
this.y = y;
[Link] = Integer.MAX_VALUE;
[Link] = 0;
[Link] = null;
}

int fCost() {
return gCost + hCost;
}
}

public class AStarAlgorithm {

private static final int[][] directions = {{0, 1}, {1, 0}, {0, -
1}, {-1, 0}};
private static final int GRID_SIZE = 5;

public static void main(String[] args) {

Node[][] grid = new Node[GRID_SIZE][GRID_SIZE];
for (int i = 0; i < GRID_SIZE; i++) {
for (int j = 0; j < GRID_SIZE; j++) {
grid[i][j] = new Node(i, j);
}
}
Node start = grid[0][0];
Node goal = grid[4][4];
findPath(grid, start, goal);
}

public static void findPath(Node[][] grid, Node start, Node goal)

{
PriorityQueue<Node> openSet = new
PriorityQueue<>([Link](Node::fCost));
Set<Node> closedSet = new HashSet<>();
[Link] = 0;
[Link] = heuristic(start, goal);
[Link](start);
while (![Link]()) {
Node current = [Link]();
if (current == goal) {
reconstructPath(current);
return;
}
[Link](current);

for (int[] dir : directions) {

int newX = current.x + dir[0];
int newY = current.y + dir[1];

if (isValid(newX, newY)) {
Node neighbor = grid[newX][newY];
if ([Link](neighbor)) continue;
int tentativeGCost = [Link] + 1;
if (tentativeGCost < [Link]) {
[Link] = tentativeGCost;
[Link] = heuristic(neighbor, goal);
[Link] = current;
if () {
[Link](neighbor);
}
}
}
}
}
}

private static boolean isValid(int x, int y) {

return x >= 0 && y >= 0 && x < GRID_SIZE && y < GRID_SIZE;
}

private static int heuristic(Node a, Node b) {

return [Link](a.x - b.x) + [Link](a.y - b.y);
}

private static void reconstructPath(Node node) {

List<Node> path = new ArrayList<>();
while (node != null) {
[Link](node);
node = [Link];
}
[Link](path);
for (Node n : path) {
[Link]("[" + n.x + "," + n.y + "]");
}
}
}

65. Implement the Knapsack Problem Using Dynamic Programming

java
Copy code
public class Knapsack {
public static void main(String[] args) {
int[] weights = {1, 2, 3};
int[] values = {60, 100, 120};
int capacity = 5;
int n = [Link];
int maxValue = knapsack(weights, values, n, capacity);
[Link]("Maximum value: " + maxValue); // Output:
220
}

public static int knapsack(int[] weights, int[] values, int n,

int capacity) {
int[][] dp = new int[n + 1][capacity + 1];
for (int i = 0; i <= n; i++) {
for (int w = 0; w <= capacity; w++) {
if (i == 0 || w == 0) {
dp[i][w] = 0;
} else if (weights[i - 1] <= w) {
dp[i][w] = [Link](values[i - 1] + dp[i - 1][w -
weights[i - 1]], dp[i - 1][w]);
} else {
dp[i][w] = dp[i - 1][w];
}
}
}
return dp[n][capacity];
}
}

This should give you a comprehensive overview of Java programming basics, algorithms, and
more advanced topics. Feel free to ask if you need more details on any specific topic!

You said:

mostly aksing string and array related questions..

ChatGPT said:

ChatGPT

Got it! Here are some more Java coding questions specifically related to strings and arrays:

String-Related Questions

66. Reverse a String

java
Copy code
public class ReverseString {
public static void main(String[] args) {
String str = "hello";
String reversed = new
StringBuilder(str).reverse().toString();
[Link](reversed); // Output: "olleh"
}
}

67. Check if a String is a Palindrome

java
Copy code
public class Palindrome {
public static void main(String[] args) {
String str = "madam";
boolean isPalindrome = [Link](new
StringBuilder(str).reverse().toString());
[Link](isPalindrome); // Output: true
}
}

68. Find the First Non-Repeating Character in a String

java
Copy code
import [Link].*;

public class FirstNonRepeatingChar {

public static void main(String[] args) {
String str = "swiss";
char result = findFirstNonRepeatingChar(str);
[Link](result); // Output: 'w'
}

public static char findFirstNonRepeatingChar(String str) {

Map<Character, Integer> countMap = new LinkedHashMap<>();
for (char c : [Link]()) {
[Link](c, [Link](c, 0) + 1);
}
for ([Link]<Character, Integer> entry :
[Link]()) {
if ([Link]() == 1) {
return [Link]();
}
}
return '\0'; // No non-repeating character
}
}

69. Remove Duplicates from a String

java
Copy code
public class RemoveDuplicates {
public static void main(String[] args) {
String str = "aabbcc";
StringBuilder result = new StringBuilder();
Set<Character> seen = new HashSet<>();
for (char c : [Link]()) {
if ([Link](c)) {
[Link](c);
}
}
[Link]([Link]()); // Output: "abc"
}
}

70. Count the Number of Vowels in a String

java
Copy code
public class CountVowels {
public static void main(String[] args) {
String str = "hello world";
int count = countVowels(str);
[Link](count); // Output: 3
}

public static int countVowels(String str) {

int count = 0;
for (char c : [Link]().toCharArray()) {
if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c ==
'u') {
count++;
}
}
return count;
}
}

71. Find the Longest Substring Without Repeating Characters

java
Copy code
import [Link].*;

public class LongestSubstringWithoutRepeating {

public static void main(String[] args) {
String str = "abcabcbb";
int length = lengthOfLongestSubstring(str);
[Link](length); // Output: 3
}

public static int lengthOfLongestSubstring(String s) {

Set<Character> set = new HashSet<>();
int left = 0, maxLength = 0;
for (int right = 0; right < [Link](); right++) {
while ([Link]([Link](right))) {
[Link]([Link](left++));
}
[Link]([Link](right));
maxLength = [Link](maxLength, right - left + 1);
}
return maxLength;
}
}

72. Convert a String to an Integer

java
Copy code
public class StringToInteger {
public static void main(String[] args) {
String str = "1234";
int number = [Link](str);
[Link](number); // Output: 1234
}
}

73. Check if Two Strings are Anagrams

java
Copy code
import [Link].*;

public class Anagram {

public static void main(String[] args) {
String str1 = "listen";
String str2 = "silent";
boolean isAnagram = areAnagrams(str1, str2);
[Link](isAnagram); // Output: true
}

public static boolean areAnagrams(String s1, String s2) {

if ([Link]() != [Link]()) return false;
char[] arr1 = [Link]();
char[] arr2 = [Link]();
[Link](arr1);
[Link](arr2);
return [Link](arr1, arr2);
}
}

74. Find All Occurrences of a Substring in a String

java
Copy code
import [Link].*;

public class FindOccurrences {

public static void main(String[] args) {
String str = "ABABABAB";
String subStr = "AB";
List<Integer> indices = findAllOccurrences(str, subStr);
[Link](indices); // Output: [0, 2, 4, 6]
}

public static List<Integer> findAllOccurrences(String str, String

subStr) {
List<Integer> indices = new ArrayList<>();
int index = [Link](subStr);
while (index >= 0) {
[Link](index);
index = [Link](subStr, index + 1);
}
return indices;
}
}

Array-Related Questions

75. Find the Maximum Element in an Array

java
Copy code
public class MaxElement {
public static void main(String[] args) {
int[] arr = {1, 3, 5, 7, 9};
int max = findMax(arr);
[Link](max); // Output: 9
}

public static int findMax(int[] arr) {

int max = arr[0];
for (int num : arr) {
if (num > max) {
max = num;
}
}
return max;
}
}

76. Find the Minimum Element in an Array

java
Copy code
public class MinElement {
public static void main(String[] args) {
int[] arr = {1, 3, 5, 7, 9};
int min = findMin(arr);
[Link](min); // Output: 1
}

public static int findMin(int[] arr) {

int min = arr[0];
for (int num : arr) {
if (num < min) {
min = num;
}
}
return min;
}
}

77. Find the Average of Array Elements

java
Copy code
public class AverageArray {
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5};
double average = findAverage(arr);
[Link](average); // Output: 3.0
}

public static double findAverage(int[] arr) {

int sum = 0;
for (int num : arr) {
sum += num;
}
return (double) sum / [Link];
}
}

78. Check if an Array Contains a Specific Element

java
Copy code
public class ContainsElement {
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5};
int target = 3;
boolean contains = containsElement(arr, target);
[Link](contains); // Output: true
}

public static boolean containsElement(int[] arr, int target) {

for (int num : arr) {
if (num == target) {
return true;
}
}
return false;
}
}

79. Find the Intersection of Two Arrays

java
Copy code
import [Link].*;

public class ArrayIntersection {

public static void main(String[] args) {
int[] arr1 = {1, 2, 3, 4, 5};
int[] arr2 = {4, 5, 6, 7, 8};
int[] intersection = findIntersection(arr1, arr2);
[Link]([Link](intersection)); // Output:
[4, 5]
}

public static int[] findIntersection(int[] arr1, int[] arr2) {

Set<Integer> set1 = new HashSet<>();
Set<Integer> intersection = new HashSet<>();
for (int num : arr1) {
[Link](num);
}
for (int num : arr2) {
if ([Link](num)) {
[Link](num);
}
}
return
[Link]().mapToInt(Integer::intValue).toArray();
}
}

80. Merge Two Sorted Arrays

java
Copy code
import [Link];

public class MergeSortedArrays {

public static void main(String[] args) {
int[] arr1 = {1, 3, 5};
int[] arr2 = {2, 4, 6};
int[] merged = mergeArrays(arr1, arr2);
[Link]([Link](merged

)); // Output: [1, 2, 3, 4, 5, 6] }

css
Copy code
public static int[] mergeArrays(int[] arr1, int[] arr2) {
int[] merged = new int[[Link] + [Link]];
int i = 0, j = 0, k = 0;
while (i < [Link] && j < [Link]) {
if (arr1[i] < arr2[j]) {
merged[k++] = arr1[i++];
} else {
merged[k++] = arr2[j++];
}
}
while (i < [Link]) {
merged[k++] = arr1[i++];
}
while (j < [Link]) {
merged[k++] = arr2[j++];
}
return merged;
}
}
```

81. Rotate an Array by k Positions ```java import [Link];

arduino
Copy code
public class RotateArray {
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5};
int k = 2;
rotateArray(arr, k);
[Link]([Link](arr)); // Output: [4, 5, 1, 2,
3]
}

public static void rotateArray(int[] arr, int k) {

k = k % [Link];
reverse(arr, 0, [Link] - 1);
reverse(arr, 0, k - 1);
reverse(arr, k, [Link] - 1);
}

private static void reverse(int[] arr, int start, int end) {

while (start < end) {
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
start++;
end--;
}
}
}
```
82. Find the Kth Largest Element in an Array ```java import [Link]; import
[Link]; import [Link];

arduino
Copy code
public class KthLargestElement {
public static void main(String[] args) {
int[] arr = {3, 2, 1, 5, 6, 4};
int k = 2;
int kthLargest = findKthLargest(arr, k);
[Link](kthLargest); // Output: 5
}

public static int findKthLargest(int[] nums, int k) {

PriorityQueue<Integer> minHeap = new PriorityQueue<>(k);
for (int num : nums) {
[Link](num);
if ([Link]() > k) {
[Link]();
}
}
return [Link]();
}
}
```

83. Find the Majority Element in an Array ```java import [Link]; import
[Link];

csharp
Copy code
public class MajorityElement {
public static void main(String[] args) {
int[] nums = {3, 2, 3};
int majority = findMajorityElement(nums);
[Link](majority); // Output: 3
}

public static int findMajorityElement(int[] nums) {

Map<Integer, Integer> countMap = new HashMap<>();
for (int num : nums) {
[Link](num, [Link](num, 0) + 1);
if ([Link](num) > [Link] / 2) {
return num;
}
}
throw new IllegalArgumentException("No majority element");
}
}
```

84. Find the Missing Number in an Array ```java public class MissingNumber { public
static void main(String[] args) { int[] nums = {3, 0, 1}; int missingNumber =
findMissingNumber(nums); [Link](missingNumber); // Output: 2 }

arduino
Copy code
public static int findMissingNumber(int[] nums) {
int n = [Link];
int sum = (n * (n + 1)) / 2;
for (int num : nums) {
sum -= num;
}
return sum;
}
}
```

85. Find the Duplicates in an Array ```java import [Link]; import [Link];

csharp
Copy code
public class FindDuplicates {
public static void main(String[] args) {
int[] nums = {1, 2, 3, 4, 5, 2, 3};
Set<Integer> duplicates = findDuplicates(nums);
[Link](duplicates); // Output: [2, 3]
}

public static Set<Integer> findDuplicates(int[] nums) {

Set<Integer> set = new HashSet<>();
Set<Integer> duplicates = new HashSet<>();
for (int num : nums) {
if () {
[Link](num);
}
}
return duplicates;
}
}
```

86. Find the Longest Consecutive Sequence ```java import [Link]; import
[Link]; import [Link];

csharp
Copy code
public class LongestConsecutiveSequence {
public static void main(String[] args) {
int[] nums = {100, 4, 200, 1, 3, 2};
int longest = longestConsecutive(nums);
[Link](longest); // Output: 4
}

public static int longestConsecutive(int[] nums) {

Set<Integer> numSet = new HashSet<>();
for (int num : nums) {
[Link](num);
}

int longestStreak = 0;
for (int num : numSet) {
if () {
int currentNum = num;
int currentStreak = 1;

while ([Link](currentNum + 1)) {

currentNum += 1;
currentStreak += 1;
}

longestStreak = [Link](longestStreak, currentStreak);

}
}
return longestStreak;
}
}
```

87. Find the Peak Element in an Array ```java public class PeakElement { public static
void main(String[] args) { int[] nums = {1, 2, 3, 1}; int peakIndex = findPeakElement(nums);
[Link](peakIndex); // Output: 2 }

css
Copy code
public static int findPeakElement(int[] nums) {
for (int i = 0; i < [Link]; i++) {
if ((i == 0 || nums[i] > nums[i - 1]) &&
(i == [Link] - 1 || nums[i] > nums[i + 1])) {
return i;
}
}
return -1; // Should not be reached
}
}
```

88. Move Zeros to the End of an Array ```java import [Link];

arduino
Copy code
public class MoveZeros {
public static void main(String[] args) {
int[] arr = {0, 1, 0, 3, 12};
moveZeroes(arr);
[Link]([Link](arr)); // Output: [1, 3, 12, 0,
0]
}

public static void moveZeroes(int[] arr) {

int nonZeroIndex = 0;
for (int i = 0; i < [Link]; i++) {
if (arr[i] != 0) {
arr[nonZeroIndex++] = arr[i];
}
}
while (nonZeroIndex < [Link]) {
arr[nonZeroIndex++] = 0;
}
}
}
```

89. Find the Common Elements in Three Sorted Arrays ```java import [Link];
import [Link]; import [Link];
csharp
Copy code
public class CommonElementsInThreeArrays {
public static void main(String[] args) {
int[] arr1 = {1, 5, 10, 20, 40};
int[] arr2 = {6, 7, 20, 80, 100};
int[] arr3 = {3, 4, 15, 20, 30};
List<Integer> commonElements = findCommonElements(arr1, arr2,
arr3);
[Link](commonElements); // Output: [20]
}

public static List<Integer> findCommonElements(int[] arr1, int[] arr2,

int[] arr3) {
List<Integer> common = new ArrayList<>();
int i = 0, j = 0, k = 0;
while (i < [Link] && j < [Link] && k < [Link]) {
if (arr1[i] == arr2[j] && arr2[j] == arr3[k]) {
[Link](arr1[i]);
i++;
j++;
k++;
} else if (arr1[i] < arr2[j]) {
i++;
} else if (arr2[j] < arr3[k]) {
j++;
} else {
k++;
}
}
return common;
}
}
```

90. Find the Smallest Subarray with Sum Greater than or Equal to a Given Value
```java public class SmallestSubarraySum { public static void main(String[] args) { int[] arr =
{1, 4, 4}; int s = 8; int minLength = findMinSubarrayLength(arr, s);
[Link](minLength); // Output: 3 }

sql
Copy code
public static int findMinSubarrayLength(int[] arr, int s) {
int minLength = Integer.MAX_VALUE;
int sum = 0, start = 0;
for (int end = 0; end < [Link]; end++) {
sum += arr[end];
while (sum >= s) {
minLength = [Link](minLength, end - start + 1);
sum -= arr[start++];
}
}
return minLength == Integer.MAX_VALUE ? 0 : minLength;
}
}
```

91. Find All Unique Triplets in an Array that Sum to Zero ```java import
[Link]; import [Link]; import [Link];
css
Copy code
public class ThreeSum {
public static void main(String[] args) {
int[] nums = {-1, 0, 1, 2, -1, -4};
List<List<Integer>> triplets = threeSum(nums);
[Link](triplets); // Output: [[-1, -1, 2], [-1, 0, 1]]
}

public static List<List<Integer>> threeSum(int[] nums) {

List<List<Integer>> result = new ArrayList<>();
[Link](nums);
for (int i = 0; i < [Link] - 2; i++) {
if (i > 0 && nums[i] == nums[i - 1]) continue; // Skip
duplicates
int left = i + 1, right = [Link] - 1;
while (left < right) {
int sum = nums[i] + nums[left] + nums[right];
if (sum == 0) {
[Link]([Link](nums[i], nums[left],
nums[right]));
while (left < right && nums[left] == nums[left + 1])
left++; // Skip duplicates
while (left < right && nums[right] == nums[right - 1])
right--; // Skip duplicates
left++;
right--;
} else if (sum < 0) {
left++;
} else {
right--;
}
}
}
return result;
}
}
```

92. Find the Longest Increasing Subsequence ```java import [Link];

scss
Copy code
public class LongestIncreasingSubsequence {
public static void main(String[] args) {
int[] nums = {10, 9, 2, 5, 3, 7, 101, 18};
int length = lengthOfLIS(nums);
[Link](length); // Output: 4
}

public static int lengthOfLIS(int[] nums) {

if ([Link] == 0) return 0;
int[] dp = new int[[Link]];
[Link](dp, 1);
for (int i = 1; i < [Link]; i++) {
for (int j = 0; j < i; j++) {
if (nums[i] > nums[j]) {
dp[i] = [Link](dp[i], dp[j] + 1);
}
}
}
return [Link](dp).max().getAsInt();
}
}
```

93. Find the Sum of All Subarrays ```java public class SumOfSubarrays { public static void
main(String[] args) { int[] arr = {1, 2, 3}; int sum = findSumOfSubarrays(arr);
[Link](sum); // Output: 20 }

arduino
Copy code
public static int findSumOfSubarrays(int[] arr) {
int sum = 0;
int n = [Link];
for (int i = 0; i < n; i++) {
sum += arr[i] * (i + 1) * (n - i);
}
return sum;
}
}
```

94. Find the Largest Sum Contiguous Subarray ```java public class
MaximumSubarraySum { public static void main(String[] args) { int[] nums = {-2, 1, -3, 4, -
1, 2, 1, -5, 4}; int maxSum = maxSubArray(nums); [Link](maxSum); // Output: 6
}

arduino
Copy code
public static int maxSubArray(int[] nums) {
int maxSum = nums[0];
int currentSum = nums[0];
for (int i = 1; i < [Link]; i++) {
currentSum = [Link](nums[i], currentSum + nums[i]);
maxSum = [Link](maxSum, currentSum);
}
return maxSum;
}
}
```

95. Find the Kth Smallest Element in an Array ```java import [Link];

arduino
Copy code
public class KthSmallestElement {
public static void main(String[] args) {
int[] nums = {3, 2, 1, 5, 6, 4};
int k = 2;
int kthSmallest = findKthSmallest(nums, k);
[Link](kthSmallest); // Output: 2
}

public static int findKthSmallest(int[] nums, int k) {

PriorityQueue<Integer> maxHeap = new PriorityQueue<>((a, b) -> b -
a);
for (int num : nums) {
[Link](num);
if ([Link]() > k) {
[Link]();
}
}
return [Link]();
}
}
```

96. Find the Union of Two Arrays ```java import [Link]; import [Link];
import [Link];

csharp
Copy code
public class UnionOfArrays {
public static void main(String[] args) {
int[] arr1 = {1, 2, 3, 4};
int[] arr2 = {3, 4, 5, 6};
int[] union = findUnion(arr1, arr2);
[Link]([Link](union)); // Output: [1, 2, 3, 4,
5, 6]
}

public static int[] findUnion(int[] arr1, int[] arr2) {

Set<Integer> set = new HashSet<>();
for (int num : arr1) {
[Link](num);
}
for (int num : arr2) {
[Link](num);
}
return [Link]().mapToInt(Integer::intValue).toArray();
}
}
```

97. Find the Largest Product of Two Numbers in an Array ```java import [Link];

arduino
Copy code
public class LargestProduct {
public static void main(String[] args) {
int[] nums = {3, 6, 1, 9, 4};
int product = maxProduct(nums);
[Link](product); // Output: 54
}

public static int maxProduct(int[] nums) {

[Link](nums);
return nums[[Link] - 1] * nums[[Link] - 2];
}
}
```

98. Find the Missing and Repeating Numbers in an Array ```java import [Link];

css
Copy code
public class MissingAndRepeating {
public static void main(String[] args) {
int[] nums = {1, 2, 2, 4};
int[] result = findMissingAndRepeating(nums);
[Link]([Link](result)); // Output: [2, 3]
}

public static int[] findMissingAndRepeating(int[] nums) {

int n = [Link];
int[] result = new int[2]; // result[0] is repeating, result[1] is
missing
int[] count = new int[n + 1];
for (int num : nums) {
count[num]++;
}
for (int i = 1; i <= n; i++) {
if (count[i] == 2) {
result[0] = i;
} else if (count[i] == 0) {
result[1] = i;
}
}
return result;
}
}
```

99. Find the Sum of Elements in a Subarray with a Given Length ```java public class
SumOfSubarray { public static void main(String[] args) { int[] arr = {1, 2, 3, 4, 5}; int k = 3;
int sum = findSumOfSubarray(arr, k); [Link](sum); // Output: 12 }

arduino
Copy code
public static int findSumOfSubarray(int[] arr, int k) {
int maxSum = 0, windowSum = 0;
for (int i = 0; i < [Link]; i++) {
windowSum += arr[i];
if (i >= k - 1) {
maxSum = [Link](maxSum, windowSum);
windowSum -= arr[i - k + 1];
}
}
return maxSum;
}
}
```

100. Find the Longest Palindromic Substring ```java public class

LongestPalindromicSubstring { public static void main(String[] args) { String s = "babad";
String longestPalindromicSubstring = longestPalindrome(s);
[Link](longestPalindromicSubstring); // Output: "bab" or "aba" }

sql
Copy code
public static String longestPalindrome(String s) {
if (s == null || [Link]() < 1) return "";
int start = 0, end = 0;
for (int i = 0; i < [Link](); i++) {
int len1 = expandAroundCenter(s, i, i);
int len2 = expandAroundCenter(s, i, i + 1);
int len = [Link](len1, len2);
if (len > end - start) {
start = i - (len - 1) / 2;
end = i + len / 2;
}
}
return [Link](start, end + 1);
}

private static int expandAroundCenter(String s, int left, int right) {

while (left >= 0 && right < [Link]() && [Link](left) ==
[Link](right)) {
left--;
right++;
}
return right - left - 1;
}
}
```

These solutions cover a wide range of array-related problems and should give you a good
understanding of various algorithms and techniques. Let me know if you have any specific
questions or need further explanations!

Messages beyond this point are only visible to you

O
ChatGPT can make mistakes. Check important info.