algorithm and problems

1.
factorial number:
public class Factorial1 {
public static void main(String[] args) {
int num = 10;

long factorial = 1;
for(int i = 1; i <= num; ++i)
{
// factorial = factorial * i;
factorial *= i;
}
System.out.printf("Factorial of %d = %d", num, factorial);
}
}
2. fibonacci number.
class fibonacci {
int n = 10, firstTerm = 0, secondTerm = 1;

System.out.println("Fibonacci Series till " + n + " terms:");
for (int i = 1; i <= n; ++i) {

System.out.print(firstTerm + ", ");
// compute the next term

int nextTerm = firstTerm + secondTerm;
firstTerm = secondTerm;
secondTerm = nextTerm;
}
}
}
3.GCD of two numbers.

class gcd {
// find GCD between n1 and n2

int n1 = 81, n2 = 153;
// initially set to gcd

int gcd = 1;
for (int i = 1; i <= n1 && i <= n2; ++i) {
// check if i perfectly divides both n1 and n2

if (n1 % i == 0 && n2 % i == 0)
gcd = i;
}
System.out.println("GCD of " + n1 +" and " + n2 + " is " + gcd);

}
}
4.array bubble sort

class BubbleSort {
void bubbleSort(int arr[])
{
int n = arr.length;
for (int i = 0; i < n - 1; i++)

for (int j = 0; j < n - i - 1; j++)
if (arr[j] > arr[j + 1]) {
// swap temp and arr[i]

int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
// Driver method to test above

public static void main(String args[])
{
BubbleSort ob = new BubbleSort();
int a[] = { 64, 34, 25, 12 };
ob.bubbleSort(a);
int n = a.length;
for (int i = 0; i < n; ++i)

System.out.print(a[i] + " ");
System.out.println();
}
}
5.palindrome in string .
class palindrome{
public static void main(String args[]){
String s = "ARORA";
String rev = "";
for(int i=s.length()-1;i>=0;i--){
rev = rev+s.charAt(i);
}
if(s.toLowerCase().equals(rev.toLowerCase())){
System.out.println(s + " is a palindrome");
}
else{
System.out.println(s + "is not a palindrome");
}
}
}
6.binaer search
class BinarySearch {
// Binary Search Function (Iterative)
public static int binarySearch(int[] arr, int target) {
int left = 0, right = arr.length - 1;
while (left <= right) {

int mid = left + (right - left) / 2;
// Check if target is at mid
if (arr[mid] == target)
return mid;
// If target is greater, ignore left half

if (arr[mid] < target)
left = mid + 1;
else // If target is smaller, ignore right half
right = mid - 1;
}
return -1; // Element not found
}

int[] sortedArray = {10, 20, 30, 40, 50, 60, 70};
int target = 40;
int result = binarySearch(sortedArray, target);

if (result != -1)
System.out.println("Element found at index: " + result);
else
System.out.println("Element not found.");
}
}
7.Write a program to detect a cycle in a graph
import java.util.ArrayList;
import java.util.List;
public class SimpleCycleDetection {
static class Graph {

int vertices;
List<List<Integer>> adjList;
// Constructor
public Graph(int vertices) {
this.vertices = vertices;
adjList = new ArrayList<>();
for (int i = 0; i < vertices; i++) {
adjList.add(new ArrayList<>());
}
}
// Add edge to the graph

public void addEdge(int source, int destination) {
adjList.get(source).add(destination);
}
// Detect cycle
public boolean hasCycle() {
boolean[] visited = new boolean[vertices];
boolean[] recStack = new boolean[vertices];

if (dfs(i, visited, recStack)) {
return true;
}
}
return false;
}
// DFS helper
private boolean dfs(int node, boolean[] visited, boolean[] recStack) {
if (recStack[node]) return true;
if (visited[node]) return false;
visited[node] = true;
recStack[node] = true;
for (int neighbor : adjList.get(node)) {

if (dfs(neighbor, visited, recStack)) {
return true;
}
}
recStack[node] = false;
return false;
}
}

Graph graph = new Graph(3);
graph.addEdge(0, 1);
if (graph.hasCycle()) {
System.out.println("Cycle detected.");
} else {
System.out.println("No cycle detected.");
}
}
}
8.Write a program to perform depth-first search (DFS).
import java.util.ArrayList;
import java.util.List;
public class DepthFirstSearch {
static class Graph {

private int vertices; // Number of vertices
private List<List<Integer>> adjList; // Adjacency list
// Constructor
public Graph(int vertices) {
this.vertices = vertices;
adjList = new ArrayList<>();
adjList.add(new ArrayList<>());
}
}
// Add an edge to the graph

public void addEdge(int source, int destination) {
adjList.get(source).add(destination);
}
// Perform DFS
public void dfs(int start) {
boolean[] visited = new boolean[vertices];
System.out.println("Depth-First Search starting from vertex " + start +
":");
dfsUtil(start, visited);
}
// Recursive DFS utility function

private void dfsUtil(int vertex, boolean[] visited) {
visited[vertex] = true;
System.out.print(vertex + " ");
for (int neighbor : adjList.get(vertex)) {

if (!visited[neighbor]) {
dfsUtil(neighbor, visited);
}
}
}
}

Graph graph = new Graph(6);
// Add edges to the graph

// Perform DFS starting from vertex 0

graph.dfs(0);
}
}
9.Implement a binary tree in Java.
// Binary Tree Implementation in Java

class BinaryTree {
// Node class representing a single node in the tree

static class Node {
int value;
Node left;
Node right;
Node(int value) {
this.value = value;
left = null;
right = null;
}
}
// Root of the binary tree

Node root;
// Constructor
public BinaryTree() {
root = null;
}
// Insert a new value into the binary tree

public void insert(int value) {
root = insertRec(root, value);
}
// Recursive helper function for insertion

private Node insertRec(Node root, int value) {
if (root == null) {
root = new Node(value);
return root;
}
if (value < root.value) {
root.left = insertRec(root.left, value);
} else if (value > root.value) {
root.right = insertRec(root.right, value);
}
return root;
}
// Inorder traversal of the tree

public void inorder() {
inorderRec(root);
}
// Recursive helper function for inorder traversal

private void inorderRec(Node root) {
if (root != null) {
inorderRec(root.left);
System.out.print(root.value + " ");
inorderRec(root.right);
}
}

BinaryTree tree = new BinaryTree();
// Insert nodes
tree.insert(50);
tree.insert(30);
tree.insert(70);
tree.insert(20);
tree.insert(40);
tree.insert(60);
tree.insert(80);
// Print inorder traversal

System.out.println("Inorder traversal of the binary tree:");
tree.inorder();
}
}
10.Implement a queue using two stacks

import java.util.Stack;
public class QueueStacks {

static class Queue {
Stack<Integer> stack1; // Primary stack
Stack<Integer> stack2; // Auxiliary stack
// Constructor
public Queue() {
stack1 = new Stack<>();
stack2 = new Stack<>();
}
// Enqueue operation
public void enqueue(int value) {
stack1.push(value);
}
// Dequeue operation
public int dequeue() {
if (stack2.isEmpty()) {
throw new RuntimeException("Queue is empty");
}
// Transfer all elements from stack1 to stack2
while (!stack1.isEmpty()) {
stack2.push(stack1.pop());
}
}
return stack2.pop();
}
// Check if the queue is empty

public boolean isEmpty() {
return stack1.isEmpty() && stack2.isEmpty();
}
// Peek the front element

public int peek() {
throw new RuntimeException("Queue is empty");
}
// Transfer all elements from stack1 to stack2
while (!stack1.isEmpty()) {
stack2.push(stack1.pop());
}
}
return stack2.peek();
}
}

Queue queue = new Queue();
// Enqueue elements
queue.enqueue(1);
queue.enqueue(2);
queue.enqueue(3);
// Dequeue and display elements
System.out.println("Dequeued: " + queue.dequeue()); // 1
System.out.println("Peek: " + queue.peek()); // 2
System.out.println("Dequeued: " + queue.dequeue()); // 2
// Enqueue more elements

queue.enqueue(4);
queue.enqueue(5);
// Dequeue remaining elements

while (!queue.isEmpty()) {
System.out.println("Dequeued: " + queue.dequeue());
}
}
}
___________________________________________________________________________________
------- multi threading---------------

11. Implement a thread-safe Singleton design pattern
class Singleton {
// Volatile keyword ensures visibility of changes to variables across threads
private static volatile Singleton instance;
// Private constructor to prevent instantiation from outside

private Singleton() {
// Prevent instantiation via reflection
if (instance != null) {
throw new IllegalStateException("Instance already created");
}
}
// Public method to provide access to the Singleton instance

public static Singleton getInstance() {
if (instance == null) { // First check (no locking)
synchronized (Singleton.class) {
if (instance == null) { // Second check (with locking)
instance = new Singleton();
}
}
}
return instance;
}
}
public class Singleton1 {
Singleton singleton1 = Singleton.getInstance();
Singleton singleton2 = Singleton.getInstance();
System.out.println(singleton1 == singleton2); // true

}
}
12. Write a program to implement a producer-consumer problem using semaphores.
import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.Semaphore;
public class ProducerConsumer {
// Shared buffer
private static final int BUFFER_SIZE = 5;
private static final Queue<Integer> buffer = new LinkedList<>();
// Semaphores
private static final Semaphore empty = new Semaphore(BUFFER_SIZE); // Tracks
empty slots
private static final Semaphore full = new Semaphore(0); // Tracks
filled slots
private static final Semaphore mutex = new Semaphore(1); // Mutual
exclusion
public static void main(String[] args) throws InterruptedException {

Thread producerThread = new Thread(new Producer());
Thread consumerThread = new Thread(new Consumer());
// Start threads
producerThread.start();
consumerThread.start();
// Keep main thread alive

producerThread.join();
consumerThread.join();
}
static class Producer implements Runnable {

@Override
public void run() {
while (true) {
produce();
}
}
private void produce() {

try {
int item = (int) (Math.random() * 100); // Produce an item
empty.acquire(); // Wait if no empty slots
mutex.acquire(); // Enter critical section
buffer.add(item); // Add item to buffer
System.out.println("Producer produced: " + item + ", Buffer: " +
buffer);
mutex.release(); // Exit critical section
full.release(); // Signal that a slot is filled
Thread.sleep((int) (Math.random() * 1000)); // Simulate time to
produce
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
static class Consumer implements Runnable {

@Override
public void run() {
while (true) {
consume();
}
}
private void consume() {

try {
full.acquire(); // Wait if buffer is empty
int item = buffer.poll(); // Remove item from buffer
System.out.println("Consumer consumed: " + item + ", Buffer: " +
buffer);
empty.release(); // Signal that a slot is empty
Thread.sleep((int) (Math.random() * 1000)); // Simulate time to
consume
}
}
}
}
13. Implement the Readers-Writers problem
public class ReadersWriters {
// Semaphores
private static final Semaphore mutex = new Semaphore(1); // For reader count
access
private static final Semaphore rwMutex = new Semaphore(1); // For resource
access
private static int readerCount = 0; // Tracks the number of readers

// Create multiple readers and writers
Thread reader1 = new Thread(new Reader(), "Reader 1");
Thread reader2 = new Thread(new Reader(), "Reader 2");
Thread writer1 = new Thread(new Writer(), "Writer 1");
Thread writer2 = new Thread(new Writer(), "Writer 2");
// Start threads
reader1.start();
reader2.start();
writer1.start();
writer2.start();
}
static class Reader implements Runnable {

@Override
public void run() {
while (true) {
try {
// Entering critical section to update readerCount
mutex.acquire();
readerCount++;
if (readerCount == 1) {
rwMutex.acquire(); // First reader locks the resource
}
mutex.release();
// Reading (non-critical section)

System.out.println(Thread.currentThread().getName() + " is
reading...");
Thread.sleep((int) (Math.random() * 1000)); // Simulate reading
time
// Leaving critical section

mutex.acquire();
readerCount--;
if (readerCount == 0) {
rwMutex.release(); // Last reader unlocks the resource
}
mutex.release();
// Simulate delay between reads

Thread.sleep((int) (Math.random() * 1000));
}
}
}
}
static class Writer implements Runnable {

@Override
public void run() {
while (true) {
try {
rwMutex.acquire(); // Lock resource for writing
// Writing (critical section)
writing...");
Thread.sleep((int) (Math.random() * 1000)); // Simulate writing
time
rwMutex.release(); // Unlock resource
// Simulate delay between writes

Thread.sleep((int) (Math.random() * 1000));
}
}
}
}
}
14. Design a thread-safe bounded blocking queue
import java.util.LinkedList;
import java.util.Queue;
public class BoundedBlockingQueue<T> {

private final Queue<T> queue;
private final int capacity;
private final Semaphore enqueueSemaphore; // Tracks available space
private final Semaphore dequeueSemaphore; // Tracks available items
private final Semaphore mutex; // Mutual exclusion for queue
operations
public BoundedBlockingQueue(int capacity) {

this.capacity = capacity;
this.queue = new LinkedList<>();
this.enqueueSemaphore = new Semaphore(capacity); // Initially, the queue
has all slots available
this.dequeueSemaphore = new Semaphore(0); // Initially, no items in
the queue
this.mutex = new Semaphore(1); // Ensures thread-safe
operations
}
public void enqueue(T item) throws InterruptedException {

enqueueSemaphore.acquire(); // Wait if the queue is full
try {
queue.add(item);
System.out.println("Enqueued: " + item);
} finally {
}
dequeueSemaphore.release(); // Signal that an item is available
}
public T dequeue() throws InterruptedException {

dequeueSemaphore.acquire(); // Wait if the queue is empty
try {
T item = queue.poll();
System.out.println("Dequeued: " + item);
return item;
} finally {
}
enqueueSemaphore.release(); // Signal that space is available
}
public int size() {

mutex.acquireUninterruptibly();
try {
return queue.size();
} finally {
mutex.release();
}
}

BoundedBlockingQueue<Integer> queue = new BoundedBlockingQueue<>(5);
// Producer thread
Thread producer = new Thread(() -> {
try {
for (int i = 1; i <= 10; i++) {
queue.enqueue(i);
Thread.sleep((int) (Math.random() * 500)); // Simulate work
}
}
});
// Consumer thread
Thread consumer = new Thread(() -> {
try {
for (int i = 1; i <= 10; i++) {
queue.dequeue();
}
}
});
producer.start();
consumer.start();
}
}
15. Write a program to solve the dining philosophers problem
public class DiningPhilosophers {
// Number of philosophers
private static final int NUM_PHILOSOPHERS = 5;
// Array of semaphores, one for each fork

private static final Semaphore[] forks = new Semaphore[NUM_PHILOSOPHERS];
// Semaphore to limit the number of philosophers trying to eat (prevent

deadlock)
private static final Semaphore table = new Semaphore(NUM_PHILOSOPHERS - 1);

// Initialize fork semaphores
for (int i = 0; i < NUM_PHILOSOPHERS; i++) {
forks[i] = new Semaphore(1);
}
// Create and start philosopher threads

for (int i = 0; i < NUM_PHILOSOPHERS; i++) {
new Thread(new Philosopher(i)).start();
}
}
static class Philosopher implements Runnable {

private final int id;
private final int leftFork;
private final int rightFork;
public Philosopher(int id) {
this.id = id;
this.leftFork = id;
this.rightFork = (id + 1) % NUM_PHILOSOPHERS;
}
@Override
public void run() {
try {
while (true) {
think();
pickUpForks();
eat();
putDownForks();
}
}
}
private void think() throws InterruptedException {

System.out.println("Philosopher " + id + " is thinking...");
Thread.sleep((int) (Math.random() * 1000)); // Simulate thinking time
}
private void pickUpForks() throws InterruptedException {

table.acquire(); // Limit the number of philosophers trying to eat
forks[leftFork].acquire(); // Pick up the left fork
System.out.println("Philosopher " + id + " picked up left fork " +
leftFork);
forks[rightFork].acquire(); // Pick up the right fork
System.out.println("Philosopher " + id + " picked up right fork " +
rightFork);
}
private void eat() throws InterruptedException {

System.out.println("Philosopher " + id + " is eating...");
Thread.sleep((int) (Math.random() * 1000)); // Simulate eating time
}
private void putDownForks() {

forks[leftFork].release(); // Put down the left fork
System.out.println("Philosopher " + id + " put down left fork " +
leftFork);
forks[rightFork].release(); // Put down the right fork
System.out.println("Philosopher " + id + " put down right fork " +
rightFork);
table.release(); // Allow another philosopher to try eating
}
}
}
16. Implement a cyclic barrier.
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class CyclicBarrier {

private final int parties; // Total number of threads to wait for
private int count; // Tracks the current number of waiting threads
private final Runnable barrierAction; // Optional action to execute when
barrier is tripped
private final Lock lock = new ReentrantLock();

private final Condition condition = lock.newCondition();
public CyclicBarrier(int parties, Runnable barrierAction) {

if (parties <= 0) {
throw new IllegalArgumentException("Number of parties must be greater
than 0");
}
this.parties = parties;
this.count = parties;
this.barrierAction = barrierAction;
}
public CyclicBarrier(int parties) {

this(parties, null);
}
public void await() throws InterruptedException {

lock.lock();
try {
count--;
if (count == 0) {
// All threads have reached the barrier
if (barrierAction != null) {
barrierAction.run(); // Execute the optional barrier action
}
// Reset the barrier for reuse
count = parties;
condition.signalAll(); // Wake up all waiting threads
} else {
// Wait for other threads to reach the barrier
while (count > 0) {
condition.await();
}
}
} finally {
lock.unlock();
}
}
}
//example of cyclic barrier
public class CyclicBarrierExample {

final int NUM_THREADS = 3;
// CyclicBarrier with an action to execute when the barrier is tripped

CyclicBarrier barrier = new CyclicBarrier(NUM_THREADS,
() -> System.out.println("All threads reached the barrier. Barrier
tripped!"));
Runnable task = () -> {
try {
performing work...");
System.out.println(Thread.currentThread().getName() + " is waiting
at the barrier...");
barrier.await();
System.out.println(Thread.currentThread().getName() + " has crossed
the barrier.");
}
};
// Create and start threads

for (int i = 0; i < NUM_THREADS; i++) {
new Thread(task).start();
}
}
}
17. Write a program to implement a custom thread pool.
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
public class CustomThreadPool {
private final int poolSize;

private final WorkerThread[] workers;
private final BlockingQueue<Runnable> taskQueue;
private volatile boolean isShutdown = false;
public CustomThreadPool(int poolSize) {

this.poolSize = poolSize;
this.taskQueue = new LinkedBlockingQueue<>();
this.workers = new WorkerThread[poolSize];
// Initialize and start worker threads

for (int i = 0; i < poolSize; i++) {
workers[i] = new WorkerThread();
workers[i].start();
}
}
public void submit(Runnable task) {

if (isShutdown) {
throw new IllegalStateException("Thread pool is shutting down, cannot
accept new tasks.");
}
taskQueue.offer(task); // Add task to the queue
}
public void shutdown() {

isShutdown = true; // Mark the thread pool for shutdown
for (WorkerThread worker : workers) {
worker.interrupt(); // Interrupt each worker thread
}
}
private class WorkerThread extends Thread {

@Override
public void run() {
while (!isShutdown || !taskQueue.isEmpty()) {
try {
Runnable task = taskQueue.take(); // Take task from the queue
task.run(); // Execute the task
// Allow thread to exit if interrupted during shutdown
if (isShutdown) {
break;
}
}
}
}
}

CustomThreadPool threadPool = new CustomThreadPool(3); // Create a pool of
3 threads
// Submit tasks to the thread pool

for (int i = 1; i <= 10; i++) {
final int taskId = i;
threadPool.submit(() -> {
System.out.println("Task " + taskId + " is being executed by " +
Thread.currentThread().getName());
try {
Thread.sleep(500); // Simulate task execution time
}
});
}
threadPool.shutdown(); // Shut down the thread pool

}
}
18. Implement a parallel merge sort algorithm
import java.util.concurrent.RecursiveAction;
import java.util.concurrent.ForkJoinPool;
public class ParallelMergeSort {
public static void parallelMergeSort(int[] array) {

if (array == null || array.length <= 1) {
return; // Already sorted or empty
}
ForkJoinPool pool = new ForkJoinPool(); // Create ForkJoinPool
pool.invoke(new MergeSortTask(array, 0, array.length - 1));
}
private static class MergeSortTask extends RecursiveAction {
private final int[] array;
private final int left;
private final int right;
public MergeSortTask(int[] array, int left, int right) {

this.array = array;
this.left = left;
this.right = right;
}
@Override
protected void compute() {
if (left < right) {
int mid = left + (right - left) / 2;
// Split the task into two subtasks

MergeSortTask leftTask = new MergeSortTask(array, left, mid);
MergeSortTask rightTask = new MergeSortTask(array, mid + 1, right);
// Invoke the subtasks in parallel

invokeAll(leftTask, rightTask);
// Merge the results

merge(array, left, mid, right);
}
}
private void merge(int[] array, int left, int mid, int right) {
int n1 = mid - left + 1;
int n2 = right - mid;
// Create temporary arrays

int[] leftArray = new int[n1];
int[] rightArray = new int[n2];
// Copy data into temporary arrays

System.arraycopy(array, left, leftArray, 0, n1);
System.arraycopy(array, mid + 1, rightArray, 0, n2);
int i = 0, j = 0, k = left;
// Merge the temporary arrays

while (i < n1 && j < n2) {
if (leftArray[i] <= rightArray[j]) {
array[k++] = leftArray[i++];
} else {
array[k++] = rightArray[j++];
}
}
// Copy any remaining elements from leftArray

while (i < n1) {
array[k++] = leftArray[i++];
}
// Copy any remaining elements from rightArray

while (j < n2) {
array[k++] = rightArray[j++];
}
}
}

int[] array = {38, 27, 43, 3, 9, 82, 10};
System.out.println("Original array:");
printArray(array);
parallelMergeSort(array);
System.out.println("\nSorted array:");
printArray(array);
}
private static void printArray(int[] array) {

for (int num : array) {
System.out.print(num + " ");
}
System.out.println();
}
}
//Input: {38, 27, 43, 3, 9, 82, 10}

//Output: {3, 9, 10, 27, 38, 43, 82}
19. Write a program to simulate a bank transaction system with multiple threads.
class BankAccount {
private int balance;
public BankAccount(int initialBalance) {

this.balance = initialBalance;
}
// Synchronized deposit method

public synchronized void deposit(int amount) {
balance += amount;
System.out.println(Thread.currentThread().getName() + " deposited $" +
amount + ". Current balance: $" + balance);
notifyAll(); // Notify waiting threads
}
// Synchronized withdraw method

public synchronized void withdraw(int amount) {
while (balance < amount) {
System.out.println(Thread.currentThread().getName() + " wants to
withdraw $" + amount + " but only $" + balance + " is available. Waiting...");
try {
wait(); // Wait until there is enough balance
}
}
balance -= amount;
System.out.println(Thread.currentThread().getName() + " withdrew $" +
amount + ". Current balance: $" + balance);
}
public synchronized int getBalance() {
return balance;
}
}
public class BankTransactionSystem {

BankAccount account = new BankAccount(100); // Initial balance is $100
// Runnable for deposit transactions

Runnable depositTask = () -> {
for (int i = 0; i < 5; i++) {
account.deposit((int) (Math.random() * 100) + 1); // Deposit a
random amount
try {
Thread.sleep(500); // Simulate processing time
}
}
};
// Runnable for withdrawal transactions

Runnable withdrawTask = () -> {
for (int i = 0; i < 5; i++) {
account.withdraw((int) (Math.random() * 100) + 1); // Withdraw a
random amount
try {
}
}
};
// Create threads for deposit and withdrawal

Thread depositor1 = new Thread(depositTask, "Depositor-1");
Thread depositor2 = new Thread(depositTask, "Depositor-2");
Thread withdrawer1 = new Thread(withdrawTask, "Withdrawer-1");
Thread withdrawer2 = new Thread(withdrawTask, "Withdrawer-2");
// Start all threads

depositor1.start();
depositor2.start();
withdrawer1.start();
withdrawer2.start();
// Wait for all threads to finish

try {
depositor1.join();
depositor2.join();
withdrawer1.join();
withdrawer2.join();
}
// Final balance
System.out.println("Final balance: $" + account.getBalance());
}
}
20. Design a concurrent cache using ConcurrentHashMap.
import java.util.concurrent.*;
public class ConcurrentCache<K, V> {
private final ConcurrentHashMap<K, V> cache;

private final int cacheSize;
// Constructor for cache with a specified maximum size

public ConcurrentCache(int cacheSize) {
this.cacheSize = cacheSize;
this.cache = new ConcurrentHashMap<>();
}
// Add or update an item in the cache

public void put(K key, V value) {
if (cache.size() >= cacheSize) {
evictCache(); // Evict an item if cache exceeds size
}
cache.put(key, value);
}
// Get an item from the cache

public V get(K key) {
return cache.get(key);
}
// Remove an item from the cache

public void remove(K key) {
cache.remove(key);
}
// Evict an item from the cache (simple approach: remove first item)
private void evictCache() {
// For simplicity, we just remove one entry. A better strategy could be an
LRU (Least Recently Used) eviction policy.
for (K key : cache.keySet()) {
cache.remove(key);
break; // Evict only one element for this simple example
}
}
// Print the cache (just for demonstration)

public void printCache() {
System.out.println(cache);
}
// Test the cache with concurrent threads

ConcurrentCache<Integer, String> cache = new ConcurrentCache<>(5);
// Runnable to simulate cache operations

Runnable cacheTask = () -> {
for (int i = 0; i < 10; i++) {
int key = (int) (Math.random() * 10); // Random key
String value = "Value-" + key;
cache.put(key, value); // Put new value in cache
System.out.println(Thread.currentThread().getName() + " put " + key
+ ": " + value);
// Randomly get value

String retrievedValue = cache.get(key);
System.out.println(Thread.currentThread().getName() + " got " + key
+ ": " + retrievedValue);
}
};
// Create multiple threads to access the cache concurrently

Thread thread1 = new Thread(cacheTask, "Thread-1");
thread1.start();
thread2.start();
thread3.start();
// Wait for threads to finish

try {
thread1.join();
thread2.join();
thread3.join();
}
// Final cache state

System.out.println("Final Cache State:");
cache.printCache();
}
}
_________________________________________________________________________________
--------------data structure and algorithms------------
1. Implement a Trie data structure with insert, search, and delete operations.
class Trie {
// TrieNode definition
static class TrieNode {
TrieNode[] children = new TrieNode[26]; // Array for 26 lowercase letters
boolean isEndOfWord = false; // Flag to mark the end of a word
}
private final TrieNode root;
// Constructor to initialize the Trie

public Trie() {
root = new TrieNode();
}
// Insert a word into the Trie

public void insert(String word) {
TrieNode node = root;
for (char ch : word.toCharArray()) {
int index = ch - 'a'; // Find index of the character
if (node.children[index] == null) {
node.children[index] = new TrieNode(); // Create a new TrieNode if
not already present
}
node = node.children[index];
}
node.isEndOfWord = true; // Mark the end of the word
}
// Search for a word in the Trie

public boolean search(String word) {
TrieNode node = root;
for (char ch : word.toCharArray()) {
int index = ch - 'a';
if (node.children[index] == null) {
return false; // Word not found
}
node = node.children[index];
}
return node.isEndOfWord; // Check if the word ends correctly
}
// Delete a word from the Trie

public boolean delete(String word) {
return delete(root, word, 0);
}
private boolean delete(TrieNode node, String word, int depth) {

if (node == null) {
}
if (depth == word.length()) {
if (!node.isEndOfWord) {
}
node.isEndOfWord = false; // Unmark the end of the word
return isEmpty(node); // Check if node has no children
}
int index = word.charAt(depth) - 'a';

if (delete(node.children[index], word, depth + 1)) {
node.children[index] = null; // Remove the child reference
return !node.isEndOfWord && isEmpty(node); // Check if the current node
can be deleted
}
return false;
}
// Helper method to check if a node has any children

private boolean isEmpty(TrieNode node) {
for (TrieNode child : node.children) {
if (child != null) {
return false; // Node has children
}
}
return true; // Node has no children
}
// Main method for testing

Trie trie = new Trie();
// Insert words
trie.insert("hello");
trie.insert("world");
trie.insert("help");
trie.insert("heap");
// Search for words

System.out.println(trie.search("hello")); // true
System.out.println(trie.search("hell")); // false
System.out.println(trie.search("heap")); // true
// Delete words
System.out.println(trie.delete("heap")); // true
System.out.println(trie.search("heap")); // false
System.out.println(trie.search("help")); // true
}
}
------------------------------------------------------------------------------
------ string manipulation -----------
31. Write a program to find all permutations of a string.
public class StringPermutations {
// Method to generate permutations

public static void generatePermutations(String str, int left, int right) {
if (left == right) {
System.out.println(str);
} else {
for (int i = left; i <= right; i++) {
str = swap(str, left, i); // Swap characters
generatePermutations(str, left + 1, right); // Recursive call
str = swap(str, left, i); // Backtrack
}
}
}
// Utility method to swap characters in a string

private static String swap(String str, int i, int j) {
char[] charArray = str.toCharArray();
char temp = charArray[i];
charArray[i] = charArray[j];
charArray[j] = temp;
return String.valueOf(charArray);
}

String input = "ABC";
System.out.println("All permutations of the string: " + input);
generatePermutations(input, 0, input.length() - 1);
}
}
32. Implement a program to find the longest palindromic substring.
public class LongestPalindromicSubstring {
// Method to expand around center and find longest palindrome

private static String expandAroundCenter(String s, int left, int right) {
while (left >= 0 && right < s.length() && s.charAt(left) ==
s.charAt(right)) {
left--;
right++;
}
return s.substring(left + 1, right); // Extract palindromic substring
}
// Main method to find the longest palindromic substring

public static String findLongestPalindrome(String s) {
if (s == null || s.length() < 1) return "";
String longestPalindrome = "";
for (int i = 0; i < s.length(); i++) {

// Check for odd-length palindrome (single center)
String oddPalindrome = expandAroundCenter(s, i, i);
// Check for even-length palindrome (two-character center)
String evenPalindrome = expandAroundCenter(s, i, i + 1);
// Update the longest palindrome found

if (oddPalindrome.length() > longestPalindrome.length()) {
longestPalindrome = oddPalindrome;
}
if (evenPalindrome.length() > longestPalindrome.length()) {
longestPalindrome = evenPalindrome;
}
}
return longestPalindrome;
}

String input = "babad";
System.out.println("Longest Palindromic Substring: " +
findLongestPalindrome(input));
}
}
33. Write a program to perform wildcard pattern matching.
public class WildcardMatching {
// Function to check if text matches pattern

public static boolean isMatch(String text, String pattern) {
int m = pattern.length();
int n = text.length();
boolean[][] dp = new boolean[m + 1][n + 1];
// Base case: Empty pattern and empty text match
dp[0][0] = true;
// Handle patterns with '*' at the start (can match empty text)
for (int i = 1; i <= m; i++) {
if (pattern.charAt(i - 1) == '*') {
dp[i][0] = dp[i - 1][0]; // '*' can represent empty sequence
}
}
// Fill DP table
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
if (pattern.charAt(i - 1) == text.charAt(j - 1) || pattern.charAt(i
- 1) == '?') {
dp[i][j] = dp[i - 1][j - 1]; // Match character or '?'
} else if (pattern.charAt(i - 1) == '*') {
dp[i][j] = dp[i - 1][j] || dp[i][j - 1]; // '*' matches empty
or any char
}
}
}
return dp[m][n];
}

String text = "abcd";
String pattern = "a*d";
System.out.println("Pattern matches string: " + isMatch(text, pattern)); //

Output: true
}
}
________________________________________________________________________
file handling
import java.io.File;
import java.io.FileWriter;
import java.io.FileReader;
import java.io.BufferdReader;
import java.io.IOException;
public class file{

File newFile = new File("ex.txt");
System.out.println("file created...");
try(FileWriter myWrite = new FileWriter(newFile)){
myWrite.write("hello file\n");
myWrite.write("adding extra information...");
System.out.println("file have some content");
}
catch(IOException e){
System.out.println("error occured");
e.printStackTrace();
}
try(FileReader myRead = new FileReader(newFile);
BufferedReader buff = new BufferedReader(myRead)){
String line;
while(line = buff.readLine() != null);
System.out.println("read the data" +line);
}
catch(IOException e){
System.out.println("error occured");
e.printStackTrace();
}
}
}
111. reader writer in mutlithreading .
class SharedResource {
private int data = 0; // Shared variable
// Writer Method
public synchronized void write(int value) {
System.out.println(Thread.currentThread().getName() + " is Writing: " +
value);
data = value;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {}
System.out.println(Thread.currentThread().getName() + " finished
Writing.");
}
// Reader Method
public synchronized void read() {
System.out.println(Thread.currentThread().getName() + " is Reading: " +
data);
try { Thread.sleep(500); } catch (InterruptedException e) {}
}
}
// Reader Thread using Runnable

class Reader implements Runnable {
private SharedResource resource;
public Reader(SharedResource resource) {

this.resource = resource;
}
public void run() {

for (int i = 0; i < 3; i++) {
resource.read();
}
}
}
// Writer Thread using Runnable

class Writer implements Runnable {
private SharedResource resource;
public Writer(SharedResource resource) {

this.resource = resource;
}
public void run() {

for (int i = 1; i <= 2; i++) {
resource.write(i * 10);
}
}
}
// Main Class
public class ReaderWriterRunnable {
SharedResource resource = new SharedResource();
Thread reader1 = new Thread(new Reader(resource), "Reader-1");

Thread reader2 = new Thread(new Reader(resource), "Reader-2");
Thread writer = new Thread(new Writer(resource), "Writer");
reader1.start();
reader2.start();
writer.start();
}
}
112.producer consumer in multithread
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
class Producer implements Runnable {

private BlockingQueue<Integer> queue;
public Producer(BlockingQueue<Integer> queue) {

this.queue = queue;
}
@Override
public void run() {
for (int i = 1; i <= 5; i++) {
try {
System.out.println("Produced: " + i);
queue.put(i); // Put item in the queue
Thread.sleep(1000); // Simulate time-consuming task
}
}
}
}
class Consumer implements Runnable {

private BlockingQueue<Integer> queue;
public Consumer(BlockingQueue<Integer> queue) {

this.queue = queue;
}
@Override
public void run() {
while (true) {
try {
Integer item = queue.take(); // Take item from queue
System.out.println("Consumed: " + item);
break;
}
}
}
}
public class ProducerConsumerExample {

BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(3); // Max size 3
Thread producerThread = new Thread(new Producer(queue));

Thread consumerThread = new Thread(new Consumer(queue));
producerThread.start();
consumerThread.start();
}
}
-----------------------------------------
bank details
import java.util.Scanner;
class BankAcc{
private String name;
private double accno;
private double balance;
public BankAcc(String name, double accno, double balance){

this.name = name;
this.accno = accno;
this.balance = balance;
}
public void deposit(double amount){
if(amount>0){
balance = balance + amount;
System.out.println("after deposit the balance is:" +balance);
}
else{
System.out.println("invalid deposit:");
}
}
public void withdraw(double amount){
if(amount>0 && amount<=balance){
balance = balance - amount;
System.out.println("balance after withdraw:" +balance);
}
else{
System.out.println("insufient amount you eneter:");
}
}
public void display(){
System.out.println("account holde name:" +name);
System.out.println("account number:" +accno);
System.out.println("balance is:" +balance);
}
}
public class BankDetails{
Scanner sc = new Scanner(System.in);
System.out.println("enter the account holder name:");
String accName = sc.nextLine();
System.out.println("enter the account number:");
double accNo = sc.nextDouble();
System.out.println("enter initial balance:");
double initialBalance = sc.nextDouble();
BankAcc account = new BankAcc(accName, accNo, initialBalance);

int choice;
do{
System.out.println("\n1. Deposit");
System.out.println("2. Withdraw");
System.out.println("3. Display Account Details");
System.out.println("4. Exit");
System.out.print("Enter your choice: ");
choice = sc.nextInt();
switch(choice){
case 1:
System.out.println("enter the amount of deposit:");
double depositAmount = sc.nextDouble();
account.deposit(depositAmount);
break;
case 2:
System.out.println("enter amount you withdraw:");
double withdrawAmount = sc.nextDouble();
account.withdraw(withdrawAmount);
break;
case 3:
account.display();
break;
case 4:
System.out.println("exit.. Thank u");
break;
default:
System.out.println(" invalid choice");
}
}
while(choice != 4);
sc.close();
}
}

algorithm and problems

Uploaded by

algorithm and problems

Uploaded by

1.

public class Factorial1 {

public static void main(String[] args) {

int num = 10;

int n = 10, firstTerm = 0, secondTerm = 1;

for (int i = 1; i <= n; ++i) {

// compute the next term

3.GCD of two numbers.

// find GCD between n1 and n2

// initially set to gcd

for (int i = 1; i <= n1 && i <= n2; ++i) {

// check if i perfectly divides both n1 and n2

System.out.println("GCD of " + n1 +" and " + n2 + " is " + gcd);

4.array bubble sort

for (int i = 0; i < n - 1; i++)

// swap temp and arr[i]

// Driver method to test above

for (int i = 0; i < n; ++i)

while (left <= right) {

// If target is greater, ignore left half

public static void main(String[] args) {

int result = binarySearch(sortedArray, target);

7.Write a program to detect a cycle in a graph

public class SimpleCycleDetection {

static class Graph {

// Add edge to the graph

for (int i = 0; i < vertices; i++) {

for (int neighbor : adjList.get(node)) {

public static void main(String[] args) {

8.Write a program to perform depth-first search (DFS).

public class DepthFirstSearch {

static class Graph {

// Add an edge to the graph

// Recursive DFS utility function

for (int neighbor : adjList.get(vertex)) {

public static void main(String[] args) {

// Add edges to the graph

// Perform DFS starting from vertex 0

9.Implement a binary tree in Java.

// Binary Tree Implementation in Java

// Node class representing a single node in the tree

// Root of the binary tree

// Insert a new value into the binary tree

// Recursive helper function for insertion

// Inorder traversal of the tree

// Recursive helper function for inorder traversal

public static void main(String[] args) {

// Print inorder traversal

10.Implement a queue using two stacks

public class QueueStacks {

// Check if the queue is empty

// Peek the front element

public static void main(String[] args) {

// Enqueue more elements

// Dequeue remaining elements

------- multi threading---------------

// Private constructor to prevent instantiation from outside

// Public method to provide access to the Singleton instance

System.out.println(singleton1 == singleton2); // true

12. Write a program to implement a producer-consumer problem using semaphores.

public class ProducerConsumer {

public static void main(String[] args) throws InterruptedException {

// Keep main thread alive

static class Producer implements Runnable {

private void produce() {

static class Consumer implements Runnable {

private void consume() {

13. Implement the Readers-Writers problem

public class ReadersWriters {

public static void main(String[] args) {

static class Reader implements Runnable {

// Reading (non-critical section)

// Leaving critical section

// Simulate delay between reads

static class Writer implements Runnable {

// Simulate delay between writes