1) // Java Program to find the solutions of specified equations

public class GFG {

// Method to check for solutions of equations

static void checkSolution(int a, int b, int c)
{

// If the expression is greater than 0,

// then 2 solutions
if (((b * b) - (4 * a * c)) > 0)
System.out.println("2 solutions");

// If the expression is equal 0, then 2 solutions

else if (((b * b) - (4 * a * c)) == 0)
System.out.println("1 solution");

// Else no solutions
else
System.out.println("No solutions");
}

// Driver Code
public static void main(String[] args)
{
int a = 2, b = 5, c = 2;
checkSolution(a, b, c);
}
}

2) // Java Code for Linked List Implementation

public class StackAsLinkedList {

StackNode root;
static class StackNode {

int data;

StackNode next;

StackNode(int data) { this.data = data; }

public boolean isEmpty()

if (root == null) {

return true;

else

return false;

public void push(int data)

StackNode newNode = new StackNode(data);

 if (root == null) {

root = newNode;

else {

StackNode temp = root;

root = newNode;

newNode.next = temp;

System.out.println(data + " pushed to stack");

public int pop()

int popped = Integer.MIN_VALUE;

if (root == null) {

System.out.println("Stack is Empty");

else {

popped = root.data;

root = root.next;

return popped;
}

public int peek()

if (root == null) {

System.out.println("Stack is empty");

return Integer.MIN_VALUE;

else {

return root.data;

// Driver code

public static void main(String[] args)

StackAsLinkedList sll = new StackAsLinkedList();

sll.push(10);

sll.push(20);

sll.push(30);
 System.out.println(sll.pop()

+ " popped from stack");

System.out.println("Top element is " + sll.peek());

Output
10 pushed to stack
20 pushed to stack
30 pushed to stack
30 popped from stack
Top element is 20
Elements present in stack : 20 10

4a) // Java program to implement a queue using an array

class Queue {

static private int front, rear, capacity;

static private int queue[];

Queue(int c)
{

front = rear = 0;

capacity = c;

queue = new int[capacity];

// function to insert an element

// at the rear of the queue

static void queueEnqueue(int data)

// check queue is full or not

if (capacity == rear) {

System.out.printf("\nQueue is full\n");

return;

// insert element at the rear

else {

queue[rear] = data;

rear++;

return;
}

// function to delete an element

// from the front of the queue

static void queueDequeue()

// if queue is empty

if (front == rear) {

System.out.printf("\nQueue is empty\n");

return;

// shift all the elements from index 2 till rear

// to the right by one

else {

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

queue[i] = queue[i + 1];

// store 0 at rear indicating there's no element

if (rear < capacity)

queue[rear] = 0;
 // decrement rear

rear--;

return;

// print queue elements

static void queueDisplay()

int i;

if (front == rear) {

System.out.printf("\nQueue is Empty\n");

return;

// traverse front to rear and print elements

for (i = front; i < rear; i++) {

System.out.printf(" %d <-- ", queue[i]);

return;

}
 // print front of queue

static void queueFront()

if (front == rear) {

System.out.printf("\nQueue is Empty\n");

return;

System.out.printf("\nFront Element is: %d",

queue[front]);

return;

public class StaticQueueinjava {

// Driver code

public static void main(String[] args)

// Create a queue of capacity 4

Queue q = new Queue(4);

// print Queue elements

q.queueDisplay();

// inserting elements in the queue

q.queueEnqueue(20);

q.queueEnqueue(30);

q.queueEnqueue(40);

q.queueEnqueue(50);

// print Queue elements

q.queueDisplay();

// insert element in the queue

q.queueEnqueue(60);

// print Queue elements

q.queueDisplay();

q.queueDequeue();

q.queueDequeue();

System.out.printf(
 "\n\nafter two node deletion\n\n");

// print Queue elements

q.queueDisplay();

// print front of the queue

q.queueFront();

Output
Queue is Empty
20 <-- 30 <-- 40 <-- 50 <--
Queue is full
20 <-- 30 <-- 40 <-- 50 <--

after two node deletion

40 <-- 50 <--
Front Element is: 40

6) // Java program to multiply

// two matrices of any size.

import java.io.*;

// Driver Class

class GFG {

// Function to print Matrix

static void printMatrix(int M[][], int rowSize,

int colSize)

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

for (int j = 0; j < colSize; j++)

System.out.print(M[i][j] + " ");

System.out.println();

// Function to multiply

// two matrices A[][] and B[][]

static void multiplyMatrix(int row1, int col1,

int A[][], int row2,

int col2, int B[][])

{
int i, j, k;

// Print the matrices A and B

System.out.println("\nMatrix A:");

printMatrix(A, row1, col1);

System.out.println("\nMatrix B:");

printMatrix(B, row2, col2);

// Check if multiplication is Possible

if (row2 != col1) {

System.out.println(

"\nMultiplication Not Possible");

return;

// Matrix to store the result

// The product matrix will

// be of size row1 x col2

int C[][] = new int[row1][col2];

 // Multiply the two matrices

for (i = 0; i < row1; i++) {

for (j = 0; j < col2; j++) {

for (k = 0; k < row2; k++)

C[i][j] += A[i][k] * B[k][j];

// Print the result

System.out.println("\nResultant Matrix:");

printMatrix(C, row1, col2);

// Driver code

public static void main(String[] args)

int row1 = 4, col1 = 3, row2 = 3, col2 = 4;

int A[][] = { { 1, 1, 1 },

{ 2, 2, 2 },

{ 3, 3, 3 },
 { 4, 4, 4 } };

int B[][] = { { 1, 1, 1, 1 },

{ 2, 2, 2, 2 },

{ 3, 3, 3, 3 } };

multiplyMatrix(row1, col1, A, row2, col2, B);

Output
Matrix A:
1 1 1
2 2 2
3 3 3
4 4 4

Matrix B:
1 1 1 1
2 2 2 2
3 3 3 3

Resultant Matrix:
6 6 6 6
12 12 12 12
18 18 18 18
24 24 24 24
7b) // Optimized java implementation of Bubble sort

import java.io.*;

class GFG {

// An optimized version of Bubble Sort

static void bubbleSort(int arr[], int n)

int i, j, temp;

boolean swapped;

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

swapped = false;

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

if (arr[j] > arr[j + 1]) {

// Swap arr[j] and arr[j+1]

temp = arr[j];

arr[j] = arr[j + 1];

arr[j + 1] = temp;

swapped = true;
 }

// If no two elements were

// swapped by inner loop, then break

if (swapped == false)

break;

// Function to print an array

static void printArray(int arr[], int size)

int i;

for (i = 0; i < size; i++)

System.out.print(arr[i] + " ");

System.out.println();

// Driver program

public static void main(String args[])

{
 int arr[] = { 64, 34, 25, 12, 22, 11, 90 };

int n = arr.length;

bubbleSort(arr, n);

System.out.println("Sorted array: ");

printArray(arr, n);

// This code is contributed

Output
Sorted array:
11 12 22 25 34 64 90

9) // Java program for the above approach

import java.util.*;

class GFG{

// Function to calculate

// factorial of N

static int fact(int n)

{
 // Base Case

if (n == 1 || n == 0)

return 1;

// Otherwise, recursively

// calculate the factorial

else

return n * fact(n - 1);

// Function to find the value of

// P(n + r) for polynomial P(X)

static int findValue(int n, int r, int a)

// Stores the value of k

int k = (a - 1) / fact(n);

// Store the required answer

int answer = k;
 // Iterate in the range [1, N] and

// multiply (n + r - i) with answer

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

answer = answer * (n + r - i);

// Add the constant value C as 1

answer = answer + 1;

// Return the result

return answer;

// Driver Code

public static void main(String args[])

int N = 1;

int A = 2;

int R = 3;

System.out.print(findValue(N, R, A));

}
}

Output:
4

10) // Java code for thread creation by extending

// the Thread class

class MultithreadingDemo extends Thread {

public void run()

try {

// Displaying the thread that is running

System.out.println(

"Thread " + Thread.currentThread().getId()

+ " is running");

catch (Exception e) {

// Throwing an exception

System.out.println("Exception is caught");

}
 }

// Main Class

public class Multithread {

public static void main(String[] args)

int n = 8; // Number of threads

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

MultithreadingDemo object

= new MultithreadingDemo();

object.start();

Output
Thread 15 is running
Thread 14 is running
Thread 16 is running
Thread 12 is running
Thread 11 is running
Thread 13 is running
Thread 18 is running
Thread 17 is running
11)
// Java Program to Illustrate binarySearch() method

// of Collections class

// Importing required classes

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

// Main class

public class GFG {

// Main driver method

public static void main(String[] args)

// Creating empty List

List<Integer> al = new ArrayList<Integer>();

// Adding elements to the List

al.add(12);

al.add(53);
 al.add(23);

al.add(46);

al.add(54);

// Using binarySearch() method of Collections class

// over random inserted element and storing the

// index

int index = Collections.binarySearch(al, 23);

// Print and display the index

System.out.print(index);

Output
2

13) // Java program to demonstrate working of

// interface

import java.io.*;
// A simple interface

interface In1 {

// public, static and final

final int a = 10;

// public and abstract

void display();

// A class that implements the interface.

class TestClass implements In1 {

// Implementing the capabilities of

// interface.

public void display(){

System.out.println("Geek");

// Driver Code

public static void main(String[] args)

 {

TestClass t = new TestClass();

t.display();

System.out.println(a);

Output
Geek
10