lironmiz/Computer-Science-in-Java

  public class ExamplesOfBasicVariablesTypes
  {
    public static void main(String[] args)
    {
		  // define char
      char c = 'k';
      // define int 
      int num = 5;
      // define long
      long num1 = 765;
      // define sort
      sort num2 = 6;
      // define byte
      byte num3 = 32;
      // define double
      double num4 = 326;
      // define float
      float num5 = 89;
      // define boolean
      boolean bool = true;
	 }// end of method main 
  }// end of class ExamplesOfBasicVariablesTypes

import java.util.Scanner;

public class InputExample 
{
    public static void main(String[] args) 
    {
        // make a Scanner object
        Scanner scan = new Scanner(System.in);

        // Prompt user to enter an integer
        System.out.print("Enter an integer: ");
        int num1 = scan.nextInt();

        // Prompt user to enter a short
        System.out.print("Enter a short: ");
        short num2 = scan.nextShort();

        // Prompt user to enter a long
        System.out.print("Enter a long: ");
        long num3 = scan.nextLong();

        // Prompt user to enter a character
        System.out.print("Enter a character: ");
        char ch = scan.next().charAt(0);

        // Prompt user to enter a float
        System.out.print("Enter a float: ");
        float num4 = scan.nextFloat();

        // Prompt user to enter a double
        System.out.print("Enter a double: ");
        double num5 = scan.nextDouble();

        // Prompt user to enter a byte
        System.out.print("Enter a byte: ");
        byte num6 = scan.nextByte();

        // Prompt user to enter a boolean
        System.out.print("Enter a boolean: ");
        boolean bool = scan.nextBoolean();

        System.out.println("You entered: " + num1 + ", " + num2 + ", " + num3 + ", " + ch + ", " + num4 + ", " + num5 + ", " + num6 + ", " + bool);
    }// end of method main
}// end of class InputExample

public class Arithmetic
{
    public static void main(String[] args)
    {
        int a = 5;
        int b = 2;

        // addition
        int c = a + b;
        System.out.println("Addition: " + a + " + " + b + " = " + c);

        // subtraction
        c = a - b;
        System.out.println("Subtraction: " + a + " - " + b + " = " + c);

        // multiplication
        c = a * b;
        System.out.println("Multiplication: " + a + " * " + b + " = " + c);

        // division
        c = a / b;
        System.out.println("Division: " + a + " / " + b + " = " + c);

        // modulus
        c = a % b;
        System.out.println("Modulus: " + a + " % " + b + " = " + c);
    }// end of method main
    
}// end of class Arithmetic

public class ShorthandExpressions 
{
    public static void main(String[] args) 
    {
        int x = 10;
        int y = 5;

        // addition assignment
        x += y;
        System.out.println("Addition Assignment: x += y : " + x);

        // subtraction assignment
        x -= y;
        System.out.println("Subtraction Assignment: x -= y : " + x);

        // multiplication assignment
        x *= y;
        System.out.println("Multiplication Assignment: x *= y : " + x);

        // division assignment
        x /= y;
        System.out.println("Division Assignment: x /= y : " + x);

        // modulus assignment
        x %= y;
        System.out.println("Modulus Assignment: x %= y : " + x);
    }// end of method main 
}// end of class ShorthandExpressions 

public class Casting 
{
    public static void main(String[] args) 
    {
        // Implicit casting
        int a = 10;
        long b = a; // automatic casting from int to long

        // Explicit casting
        double c = 2.12;
        int d = (int)c; // explicit casting from double to int

        System.out.println("Implicit casting: int to long : " + b);
        System.out.println("Explicit casting: double to int : " + d);
    }// end of method main 
}// end of class Casting

public class RelationalAndLogicalExpressions
{
    public static void main(String[] args)
    {
        int a = 13;
        int b = 5;

        // relational greater than
        if (a > b)
        {
            System.out.println("a is greater than b");
        }

        // relational less than
        if (a < b)
        {
            System.out.println("a is less than b");
        }

        // relational greater than or equal to
        if (a >= b)
        {
            System.out.println("a is greater than or equal to b");
        }

        // relational less than or equal to
        if (a <= b)
        {
            System.out.println("a is less than or equal to b");
        }

        // relational equal to
        if (a == b)
        {
            System.out.println("a is equal to b");
        }

        // relational not equal to
        if (a != b)
        {
            System.out.println("a is not equal to b");
        }

        // logical AND
        if (a > b && a < 20)
        {
            System.out.println("a is greater than b and less than 20");
        }

        // logical OR
        if (a > b || a < 20)
        {
            System.out.println("a is either greater than b or less than 20");
        }

        // logical NOT
        if (!(a == b))
        {
            System.out.println("a is not equal to b");
        }
    }// end of method main
}// end of class RelationalAndLogicalExpressions

public class IfElseExample
{
    public static void main(String[] args)
    {

        int age = 40;

        // if statement
        if (age >= 18)
        {
            System.out.println("You are an adult.");
        }

        // if-else statement
        if (age >= 21)
        {
            System.out.println("You can drink alcohol.");
        } 
        else
        {
            System.out.println("You cannot drink alcohol.");
        }

        // if-if-else-else statement
        if (age >= 65)
        {
            System.out.println("You are a senior citizen.");
        } 
        else if (age >= 18)
        {
            System.out.println("You are an adult.");
        }
        else
        {
            System.out.println("You are a minor.");
        }
    }// end of method main 
}// end of class IfElseExample

public class WeekDayChecker 
{
    public static void main(String[] args)
    {
        int day = 2;
        // switch statement to check the day of the week
        switch(day)
	{
            case 1:
                System.out.println("Monday");
                break;
            case 2:
                System.out.println("Tuesday");
                break;
            case 3:
                System.out.println("Wednesday");
                break;
            case 4:
                System.out.println("Thursday");
                break;
            case 5:
                System.out.println("Friday");
                break;
            case 6:
                System.out.println("Saturday");
                break;
            case 7:
                System.out.println("Sunday");
                break;
            default:
                System.out.println("Invalid day of the week");
                break;
        }
    }// end of method main
}// end of class WeekDayChecker 

public class ForLoopExample
{
    public static void main(String[] args) 
    {
        // for loop to print the numbers from 0 to 10
        for (int i = 0; i < 11; i++)
	{
            System.out.println(i);
     	}// end of for loop
    }// end of method main
}// end of class ForLoopExample

public class WhileLoopExample
{
    public static void main(String[] args)
    {
        int i = 0; // initialization
        // while loop to iterate through numbers 0 to 10
        while (i < 11) // termination condition
	{ 
            System.out.println(i);
            i++; // increment
        }// end of while loop
    }// end of method main
}// end of class WhileLoopExample

public class DoWhileLoopExample
{
    public static void main(String[] args)
    {
        int counter = 0;
        do 
	{
            System.out.println(counter);
            counter++;
        } while (counter < 10);
    }// end of method main
}// end of class DoWhileLoopExample

class OneDimensionalArrayExample
{
    public static void main(String[] args)
    {
        // Declare a one-dimensional array of integers
        int[] myArray = new int[5];

        // Assign values to the elements of the array
        myArray[0] = 1;
        myArray[1] = 2;
        myArray[2] = 3;
        myArray[3] = 4;
        myArray[4] = 5;
	// the array
	//  - - - - -
	// |1|2|3|4|5|
	//  - - - - -
        // Print out the third element of the array
        System.out.println("The third element of the array is: " + myArray[2]);
    }// end of method main 
}// end of method OneDimensionalArrayExample

public class TwoDimensionalArrayExample
{
    public static void main(String[] args)
    {
    	// create a 2D array with 3 rows and 3 columns
        // and initialize it with values
        int[][] arr = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };

        System.out.println("The original array:");
        //printing the original array using two for loops
        for (int i = 0; i < arr.length; i++)
	{
            for (int j = 0; j < arr[i].length; j++)
	    {
                System.out.print(arr[i][j] + " ");
            }// end of nested loop
            System.out.println();
        }// end of first loop

        //modifying the array
        arr[1][2] = 8;

        System.out.println("\nThe modified array:");
        //printing the modified array
        for (int i = 0; i < arr.length; i++)
	{
            for (int j = 0; j < arr[i].length; j++)
	    {
                System.out.print(arr[i][j] + " ");
            }// end of nested loop
            System.out.println();
        }// end of first loop
    }// end of method main
}// TwoDimensionalArrayExample

class BubbleSort
{
    public static void main(String[] args)
    {
    	// the array before sorting 
        int[] arr = {5, 3, 8, 6, 2, 1, 9, 4, 7};
	// print the array before sorting 
        System.out.println("Original Array: " + Arrays.toString(arr));
	// sort the array
        bubbleSort(arr);
	// print the array after sorting 
        System.out.println("Sorted Array: " + Arrays.toString(arr));
    }// end of method main
    /**
    * sort the array using bubble sort method 
    * @param array - the original array
    * @return None
    */
    public static void bubbleSort(int[] arr)
    {
        int temp;
        for (int i = 0; i < arr.length - 1; i++)
	{
            for (int j = 1; j < arr.length - i; j++)
	    {
                if (arr[j - 1] > arr[j])
		{
                    temp = arr[j - 1];
                    arr[j - 1] = arr[j];
                    arr[j] = temp;
                }// end of if 
            }// end of nested for loops 
        }// end of for loop
    }// end of method bubbleSort
}// end of class BubbleSort

class InsertionSort
{
    public static void main(String[] args)
    {
    	// the array before sorting 
        int[] arr = {5, 3, 8, 6, 2, 1, 9, 4, 7};
	// print the array before sorting 
        System.out.println("Original Array: " + Arrays.toString(arr));
	// sort the array
        insertionSort(arr);
	// print the array after sorting 
        System.out.println("Sorted Array: " + Arrays.toString(arr));
    }// end of method main 
    /**
    * sort the array using insertion sort sort method 
    * @param array - the original array
    * @return None
    */
    public static void insertionSort(int[] arr)
    {
        int key, j;
        for (int i = 1; i < arr.length; i++)
	{
            key = arr[i];
            j = i - 1;
            while (j >= 0 && arr[j] > key)
	    {
                arr[j + 1] = arr[j];
                j = j - 1;
            }// end of while loop
            arr[j + 1] = key;
        }// end of foor loop 
    }// end of method insertionSort
}// end of class InsertionSort

public class SelectionSort
{

    public static void main(String[] args)
    {
        int[] arr = {5, 3, 6, 2, 10};
	
        // Print the original array
        System.out.print("Original Array: ");
        for (int i : arr)
	{
            System.out.print(i + " ");
        }// end of for loop 

        // Sort the array using selection sort
        selectionSort(arr);

        // Print the sorted array
        System.out.print("\nSorted Array: ");
        for (int i : arr)
	{
            System.out.print(i + " ");
        }// end of for loop 
    }// end of method main
    /**
    * sort the array using selection sort method 
    * @param array - the original array
    * @return None
    */
    public static void selectionSort(int[] arr)
    {
        // Loop through the array
        for (int i = 0; i < arr.length - 1; i++)
	{
            // Find the index of the minimum element
            int minIndex = i;
            for (int j = i + 1; j < arr.length; j++)
	    {
                if (arr[j] < arr[minIndex])
		{
                    minIndex = j;
                }// end of if
            }// end of for loop
            // Swap the minimum element with the current element
            int temp = arr[minIndex];
            arr[minIndex] = arr[i];
            arr[i] = temp;
        }// end of for loop
    }// end of method selectionSort
}// end of class SelectionSort

public class MergeSort 
{
    public static void main(String[] args) 
    {
        int[] array = {5, 1, 9, 3, 7, 6, 8, 2, 4};
        mergeSort(array);
        for (int i : array) 
	{
            System.out.print(i + " ");
        }// end of for 
    }// end of main method 
	
    /**
    * Sorts an array using the merge sort algorithm
    * @param: array - the array to be sorted
    * @return: None
    */
    public static void mergeSort(int[] array) 
    {
        if (array.length > 1) 
	{
	    // Split the array into left and right halves
            int[] left = leftHalf(array);
            int[] right = rightHalf(array);
	    
	    // Recursively sort the left and right halves
            mergeSort(left);
            mergeSort(right);
            // Merge the sorted left and right halves back together
            merge(array, left, right);
        }
    }// end of mergeSort method 
    /**
    * Returns the left half of an array
    * @param array - the original array
    * @return array - the left half of the array
    */
    public static int[] leftHalf(int[] array) 
    {
        int size1 = array.length / 2;
        int[] left = new int[size1];
        for (int i = 0; i < size1; i++)
	{
            left[i] = array[i];
        }
        return left;
    }// end of leftHalf method 
    /**
    * Returns the right half of an array
    * @param array - the original array
    * @return array - the right half of the array
    */
    public static int[] rightHalf(int[] array)
    {
        int size1 = array.length / 2;
        int size2 = array.length - size1;
        int[] right = new int[size2];
        for (int i = 0; i < size2; i++) {
            right[i] = array[i + size1];
        }
        return right;
    }// end of method rightHalf
    /**
    * Merges two sorted arrays into a single sorted array
    * @param result - the final sorted array, left - the left half of the array, right - the right half of the array
    @ @return None
    */
    public static void merge(int[] result, int[] left, int[] right)
    {
        int i1 = 0;
        int i2 = 0;

        for (int i = 0; i < result.length; i++)
	{
            if (i2 >= right.length || (i1 < left.length && left[i1] <= right[i2]))
	    {
                result[i] = left[i1];
                i1++;
            }
	    else
	    {
                result[i] = right[i2];
                i2++;
            }
        }// end of for loop 
    }// end of merge method 
}// end of class  MergeSort

public class QuickSort
{

    public static void main(String[] args)
    {
        int[] array = {5, 1, 9, 3, 7, 6, 8, 2, 4};
        sort(array);
        for (int i : array)
	{
            System.out.print(i + " ");
        }
    }// end of main method 

    /**
    * Sorts an array using the quick sort algorithm
    * @param array - the array to be sorted
    * @return none
    */
    public static void sort(int[] array)
    {
        sort(array, 0, array.length - 1);
    }// end of sort method 

    /**
    * Sorts an array within a given range using the quick sort algorithm
    * @param array - the array to be sorted, int - low - the lower bound of the range to be sorted int - high - the upper bound of the range to be sorted
    * @return None
    */
    private static void sort(int[] array, int low, int high)
    {
        if (low < high)
	{
            // Choose pivot and partition the array
            int pivotIndex = partition(array, low, high);
            // Recursively sort the left and right partitions
            sort(array, low, pivotIndex);
            sort(array, pivotIndex + 1, high);
        }
    }// end of sort method 

    /**
    * Partitions an array within a given range and returns the pivot index
    * @param array - the array to be partitioned, int - low - the lower bound of the range to be partitioned, int high - the upper bound of the range to be partitioned
    * @return the pivot index
    */
    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++;
                // Swap array[i] and array[j]
                int temp = array[i];
                array[i] = array[j];
                array[j] = temp;
            }
        }
        // Swap array[i + 1] and array[high]
        int temp = array[i + 1];
        array[i + 1] = array[high];
        array[high] = temp;
        return i + 1;
    }// end of partition method 
}// end of QuickSort class 

class HeapSort
{

    // Heap sort method
    public static void heapSort(int[] arr)
    {
        int n = arr.length;

        // Build heap (rearrange array)
        for (int i = n / 2 - 1; i >= 0; i--)
	{
	   heapify(arr, n, i);
	}
        // One by one extract an element from heap
        for (int i=n-1; i>=0; i--)
	{
            // Move current root to end
            int temp = arr[0];
            arr[0] = arr[i];
            arr[i] = temp;

            // call max heapify on the reduced heap
            heapify(arr, i, 0);
        }
    }// end of method heapSort

    // To heapify a subtree rooted with node i which is
    // an index in arr[]. n is size of heap
    static void heapify(int[] arr, int n, int i) 
    {
        int largest = i;  // Initialize largest as root
        int l = 2*i + 1;  // left = 2*i + 1
        int r = 2*i + 2;  // right = 2*i + 2

        // If left child is larger than root
        if (l < n && arr[l] > arr[largest])
	{
	   largest = l;
	}
            
        // If right child is larger than largest so far
        if (r < n && arr[r] > arr[largest])
	{
	     largest = r;
	}
	
        // If largest is not root
        if (largest != i)
	{
            int swap = arr[i];
            arr[i] = arr[largest];
            arr[largest] = swap;

            // Recursively heapify the affected sub-tree
            heapify(arr, n, largest);
        }
    }// end of heapify method 

    public static void main(String args[])
    {
        int[] arr = {12, 11, 13, 5, 6, 7};
        heapSort(arr);

        System.out.println("Sorted array is:");
        for (int i=0; i<arr.length; ++i)
	{
	    System.out.print(arr[i]+" ");
	}      
    }// end of main method 
}// end of class HeapSort

public class LinearSearch
{
    /**
    * Method to implement Linear Search algorithm to find a specific element in an array. 
    * If the element doesn't exist in the array, the method returns -1.
    * @param array - array, int x - the number we want to find  
    * @return int 
    */
    public static int linearSearch(int[] arr, int x)
    {
        for (int i = 0; i < arr.length; i++)
	{
            if (arr[i] == x)
	    {
                return i;
            }
        }
        return -1;
    }// end of linearSearch method 

    public static void main(String[] args)
    {
        int[] arr = {2, 3, 4, 10, 40};
        int x = 10;

        int result = linearSearch(arr, x);
        if (result == -1)
	{
            System.out.println("Element not present in array.");
        } 
	else
	{
            System.out.println("Element found at index: " + result);
        }
    }// end of main method 
}// end of class LinearSearch

public class BinarySearch
{
    /**
    * Method to implement Binary Search algorithm to find a specific element in an array. 
    * If the element doesn't exist in the array, the method returns -1.
    * @param array, int x
    * @return int 
    */
    public static int binarySearch(int[] arr, int x)
    {
        int left = 0;
        int right = arr.length - 1;
        while (left <= right)
	{
            int mid = left + (right - left) / 2;
            if (arr[mid] == x)
	    {
                return mid;
            } 
	    else if (arr[mid] < x)
	    {
                left = mid + 1;
            }
	    else
	    {
                right = mid - 1;
            }
        }
        return -1;
    }// end of method binarySearch

    public static void main(String[] args)
    {
        int[] arr = {2, 3, 4, 10, 40};
        int x = 10;

        int result = binarySearch(arr, x);
        if (result == -1)
	{
            System.out.println("Element not present in array.");
        }
	else
	{
            System.out.println("Element found at index: " + result);
        }
    }// end of main method 
}// end of class BinarySearch

public class JumpSearch
{
    /**
    * Method to implement Jump Search algorithm to find a specific element in an array. 
    * If the element doesn't exist in the array, the method returns -1.
    * @param array - the array to search through, int x - the element to search for
    * @return int - the index of the element if found, -1 if not found
    */
    public static int jumpSearch(int[] array, int x)
    {
        int n = array.length;
        int step = (int) Math.sqrt(n);
        int prev = 0;
        while (array[Math.min(step, n) - 1] < x)
	{
            prev = step;
            step += (int) Math.sqrt(n);
            if (prev >= n)
	    {
                return -1;
            }
        }
        while (array[prev] < x)
	{
            prev++;
            if (prev == Math.min(step, n))
	    {
                return -1;
            }
        }
        if (array[prev] == x)
	{
            return prev;
        }
        return -1;
    }// end of method jumpSearch

    public static void main(String[] args)
    {
        int[] array = {0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144};
        int x = 55;
        int index = jumpSearch(array, x);
        if (index != -1)
	{
            System.out.println("Element found at index: " + index);
        }
	else
	{
            System.out.println("Element not found in array.");
        }
    }// end of main method 
}// end of class JumpSearch

public class InterpolationSearch
{
    /**
    * Method to implement Interpolation Search algorithm to find a specific element in an array. 
    * If the element doesn't exist in the array, the method returns -1.
    * @param array - the array to search through, int x - the element to search for
    * @return int - the index of the element if found, -1 if not found
    */
    public static int interpolationSearch(int[] array, int x)
    {
        int low = 0;
        int high = array.length - 1;
        while (low <= high && x >= array[low] && x <= array[high])
	{
            int pos = low + (((high - low) / (array[high] - array[low])) * (x - array[low]));
            if (array[pos] == x)
	    {
                return pos;
            }
            if (array[pos] < x)
	    {
                low = pos + 1;
            } 
	    else
	    {
                high = pos - 1;
            }
        }
        return -1;
    }// end of method interpolationSearch

    public static void main(String[] args)
    {
        int[] array = {10, 12, 13, 16, 18, 19, 20, 21, 22, 23, 24, 33, 35, 42, 47};
        int x = 18;
        int index = interpolationSearch(array, x);
        if (index != -1)
	{
            System.out.println("Element found at index: " + index);
        } 
	else
	{
            System.out.println("Element not found in array.");
        }
    }// end of main method 
}// end of InterpolationSearch class 

import java.util.LinkedList;
import java.util.Queue;

public class DepthFirstSearch
{
    static class TreeNode
    {
        int val;
        TreeNode left;
        TreeNode right;

        TreeNode(int val)
	{
            this.val = val;
            this.left = null;
            this.right = null;
        }
    }// end of class TreeNode

    /**
     * Method to implement Depth First Search algorithm to find a specific element in a tree.
     * If the element doesn't exist in the tree, the method returns false.
     * @param root - the root of the tree, int x - the element to search for
     * @return boolean - true if the element is found, false if not found
     */
      public static boolean dfs(TreeNode root, int x)
      {
        if (root == null)
	{
            return false;
        }
        if (root.val == x)
	{
            return true;
        }
        boolean left = dfs(root.left, x);
        boolean right = dfs(root.right, x);
        return left || right;
      }// end of method dfs

    public static void main(String[] args)
    {
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.right = new TreeNode(3);
        root.left.left = new TreeNode(4);
        root.left.right = new TreeNode(5);
        int x = 4;
        boolean found = dfs(root, x);
        if (found)
	{
            System.out.println("Element found in tree.");
        }
	else
	{
            System.out.println("Element not found in tree.");
        }
    }// end of method main
}// end of class DepthFirstSearch

import java.util.LinkedList;
import java.util.Queue;

public class BreadthFirstSearch
{
    /**
    * method find a specific element in a tree using breadth first search
    * if the element is not found, the method returns -1
    * @param Node root - the root of the tree, int x - the element to search for
    * @return int - the value of the element if found, -1 if not found
    */
    public static int bfs(Node root, int x)
    {
        Queue<Node> queue = new LinkedList<>();
        queue.add(root);

        while (!queue.isEmpty())
	{
            Node current = queue.poll();
            if (current.value == x)
	    {
                return current.value;
            }
            if (current.left != null)
	    {
                queue.add(current.left);
            }
            if (current.right != null)
	    {
                queue.add(current.right);
            }
        }

        return -1;
      }// end of method bfs

    public static void main(String[] args)
    {
        // create a sample tree for demonstration
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.left = new Node(4);
        root.left.right = new Node(5);

        int elementToFind = 4;
        int result = bfs(root, elementToFind);
        System.out.println("Value of element " + elementToFind + ": " + result);
    }// end of main method 
}// end of class BreadthFirstSearch

class Node
{
    int value;
    Node left;
    Node right;

    public Node(int value)
    {
        this.value = value;
        left = null;
        right = null;
    }// end of method Node 
}// end of class Node

class MathClassExample
{
    public static void main(String[] args)
    {

        // Using Math.abs()
        int number = -5;
        int absoluteValue = Math.abs(number);
        System.out.println("Absolute value of " + number + " is " + absoluteValue);
        
        // Using Math.ceil()
        double decimal = 4.3;
        double ceilValue = Math.ceil(decimal);
        System.out.println("Smallest integer greater than or equal to " + decimal + " is " + ceilValue);
        
        // Using Math.floor()
        decimal = 5.8;
        double floorValue = Math.floor(decimal);
        System.out.println("Largest integer less than or equal to " + decimal + " is " + floorValue);
        
        // Using Math.max()
        int x = 10;
        int y = 15;
        int maxValue = Math.max(x, y);
        System.out.println("Larger of " + x + " and " + y + " is " + maxValue);
        
        // Using Math.min()
        x = 20;
        y = 25;
        int minValue = Math.min(x, y);
        System.out.println("Smaller of " + x + " and " + y + " is " + minValue);
        
        // Using Math.pow()
        x = 2;
        y = 3;
        double powerValue = Math.pow(x, y);
        System.out.println(x + " raised to the power of " + y + " is " + powerValue);
    }// end of main method 
}// end of class MathClassExample

public class MethodExample
{
    public static void main(String[] args)
    {
        printMessage();
        int result = add(5, 10);
        System.out.println("Result of addition: " + result);
        double quotient = divide(20, 10);
        System.out.println("Result of division: " + quotient);
        int product = multiply(5, 10);
        System.out.println("Result of multiplication: " + product);
    }// end of main method 
    /**
    * method print message 
    * @param None
    * @return None
    */
    public static void printMessage()
    {
        System.out.println("Hello, this is a message from the print method.");
    }// end of method printMessage 
    /**
    * method add two numbers 
    * @param int a, int b
    * @return int
    */
    public static int add(int a, int b)
    {
        return a + b;
    }// end of method add
    /**
    * method divide two numbers 
    * @param double a, double b
    * @return double
    */
    public static double divide(double a, double b)
    {
        return a / b;
    }// end of method divide
    /**
    * method multiply two numbers 
    * @param int a, int b
    * @return int 
    */
    public static int multiply(int a, int b)
    {
        return a * b;
    }// end of method multiply
}// end of class MethodExample

import java.util.Random;

public class RandomNumbers
{
    public static void main(String[] args)
    {
        // Creating an object of the Random class
        Random rand = new Random();
        
        // Generating a random integer between 0 and 9 (inclusive)
        int randomInt = rand.nextInt(10);
        System.out.println("Random Integer: " + randomInt);

        // Generating a random float between 0 and 1 (inclusive)
        float randomFloat = rand.nextFloat();
        System.out.println("Random Float: " + randomFloat);

        // Generating a random double between 0 and 1 (inclusive)
        double randomDouble = rand.nextDouble();
        System.out.println("Random Double: " + randomDouble);
    }// end of method main 
}// end of class RandomNumbers 

public class Recursion 
{
    public static void main(String[] args)
    {
        // Call the recursive method
        int result = factorial(5);
        System.out.println("Factorial of 5: " + result);
    }// end of method main 

    // Recursive method to calculate the factorial of a given number
    public static int factorial(int n)
    {
        // Base case: if n is 0 or 1, return 1
        if (n == 0 || n == 1)
	{
            return 1;
        }
        // Recursive case: return n * factorial(n-1)
        else 
	{
            return n * factorial(n-1);
        }
    }// end of method factorial
}// end of class Recursion 

import java.io.*;

public class WorkWithFile
{
    public static void main(String[] args)
    {
        // File to read from
        File file = new File("example.txt");
        // File to write to
        File outputFile = new File("output.txt");
        
        try 
	{
            // Reading from file
            BufferedReader br = new BufferedReader(new FileReader(file));
            String line;
            while ((line = br.readLine()) != null) 
	    {
                System.out.println(line);
            }
            br.close();
            
            // Writing to file
            PrintWriter writer = new PrintWriter(new FileWriter(outputFile));
            writer.println("Writing to file example");
            writer.close();
            
        } 
	catch (IOException e
	{
            System.out.println("An error occurred.");
            e.printStackTrace();
        }
    }// end of main method 
}// end of class WorkWithFile

import java.io.*; 
    
// Java program to implement 
// a Singly Linked List 
public class LinkedList 
{ 
    
    Node head; // head of list 
    
    // Linked list Node. 
    // This inner class is made static 
    // so that main() can access it 
    static class Node 
    { 
    
        int data; 
        Node next; 
    
        // Constructor 
        Node(int d) 
        { 
            data = d; 
            next = null; 
        } // end of method Node
    } // end of class Node
    
    // Method to insert a new node 
    public static LinkedList insert(LinkedList list, int data) 
    { 
        // Create a new node with given data 
        Node new_node = new Node(data); 
          
    
        // If the Linked List is empty, 
        // then make the new node as head 
        if (list.head == null)
	{ 
            list.head = new_node; 
        } 
        else
	{ 
            // Else traverse till the last node 
            // and insert the new_node there 
            Node last = list.head; 
            while (last.next != null)
	    { 
                last = last.next; 
            } 
    
            // Insert the new_node at last node 
            last.next = new_node; 
        } 
    
        // Return the list by head 
        return list; 
    } // end of method insert
    
    // Method to print the LinkedList. 
    public static void printList(LinkedList list) 
    { 
        Node currNode = list.head; 
     
        System.out.print("LinkedList: "); 
     
        // Traverse through the LinkedList 
        while (currNode != null)
	{ 
            // Print the data at current node 
            System.out.print(currNode.data + " "); 
     
            // Go to next node 
            currNode = currNode.next; 
        } 
    } // end of method printList
    
     // Method to delete a node in the LinkedList by KEY
    public static LinkedList deleteByKey(LinkedList list,int key)
    {
        // Store head node
        Node currNode = list.head, prev = null;
  

        if (currNode != null && currNode.data == key)
	{
            list.head = currNode.next; // Changed head
  
            // Display the message
            System.out.println(key + " found and deleted");
  
            // Return the updated List
            return list;
        }

        while (currNode != null && currNode.data != key)
	{
            // If currNode does not hold key
            // continue to next node
            prev = currNode;
            currNode = currNode.next;
        }
  
        // If the key was present, it should be at currNode
        // Therefore the currNode shall not be null
        if (currNode != null)
	{
            // Since the key is at currNode
            // Unlink currNode from linked list
            prev.next = currNode.next;
	    
            System.out.println(key + " found and deleted");
        }
  
        if (currNode == null)
	{
            // Display the message
            System.out.println(key + " not found");
        }
  
        // return the List
        return list;
    }// end of method deleteByKey
    
    // Method to delete a node in the LinkedList by POSITION
    public static LinkedList deleteAtPosition(LinkedList list, int index)
    {
        // Store head node
        Node currNode = list.head, prev = null;
  
        if (index == 0 && currNode != null)
	{
            list.head = currNode.next; // Changed head
  
            // Display the message
            System.out.println(
                index + " position element deleted");
  
            // Return the updated List
            return list;
        }
  
        while (currNode != null)
	{
  
            if (counter == index)
	    {
                // Since the currNode is the required
                // position Unlink currNode from linked list
                prev.next = currNode.next;
  
                // Display the message
                System.out.println(
                    index + " position element deleted");
                break;
            }
            else
	    {
                // If current position is not the index
                // continue to next node
                prev = currNode;
                currNode = currNode.next;
                counter++;
            }
        }
  
        // In this case, the currNode should be null
        if (currNode == null)
	{
            // Display the message
            System.out.println(index + " position element not found");
        }
  
        // return the List
        return list;
    }// end of method deleteAtPosition
    
    public static void main(String[] args) 
    { 
        /* Start with the empty list. */
        LinkedList list = new LinkedList(); 
    
        // Insert the values 
        list = insert(list, 1); 
        list = insert(list, 2); 
        list = insert(list, 3); 
        list = insert(list, 4); 
        list = insert(list, 5); 
        list = insert(list, 6); 
        list = insert(list, 7); 
        list = insert(list, 8); 
    
        // Print the LinkedList 
        printList(list); 
    } // end of main method 
}// end of class LinkedList

import java.util.Deque;
import java.util.ArrayDeque;

public class StackExample
{
    public static void main(String[] args)
    {
        // Creating a stack using the ArrayDeque class
        Deque<Integer> stack = new ArrayDeque<>();

        // Adding elements to the stack
        stack.push(1);
        stack.push(2);
        stack.push(3);

        // Retrieving and removing the top element
        int top = stack.pop();
        System.out.println("Top element: " + top);

        // Retrieving the top element without removing it
        top = stack.peek();
        System.out.println("Top element: " + top);

        // Checking if the stack is empty
        boolean isEmpty = stack.isEmpty();
        System.out.println("Is the stack empty? " + isEmpty);

        // Determining the size of the stack
        int size = stack.size();
        System.out.println("Size of the stack: " + size);
    }// end of method main
}// end of class StackExample

class BinaryTree
{
    Node root;
 
    public void add(int data)
    {
        root = addRecursive(root, data);
    }// end of method add
 
    private Node addRecursive(Node current, int data)
    {
        if (current == null)
	{
            return new Node(data);
        }
 
        if (data < current.data)
	{
            current.left = addRecursive(current.left, data);
        } 
	else if (data > current.data)
	{
            current.right = addRecursive(current.right, data);
        }
	else
	{
            return current;
        }
 
        return current;
    }// end of method addRecursive 
 
    public boolean containsNode(int data)
    {
        return containsNodeRecursive(root, data);
    }// end of method containsNode
 
    private boolean containsNodeRecursive(Node current, int data)
    {
        if (current == null) 
	{
            return false;
        } 
        if (data == current.data) 
	{
            return true;
        } 
        return data < current.data ? containsNodeRecursive(current.left, data) : containsNodeRecursive(current.right, data);
    }// end of method containsNodeRecursive
 
    public void delete(int data) 
    {
        root = deleteRecursive(root, data);
    }// end of delete method 
 
    private Node deleteRecursive(Node current, int data) 
    {
        if (current == null) 
	{
            return null;
        }
 
        if (data == current.data)
	{
            if (current.left == null && current.right == null)
	    {
                return null;
            }
            if (current.right == null)
	    {
                return current.left;
            }
 
            if (current.left == null)
	    {
                return current.right;
            }
            int smallestValue = findSmallestValue(current.right);
            current.data = smallestValue;
            current.right = deleteRecursive(current.right, smallestValue);
            return current;
        }
        if (data < current.data)
	{
            current.left = deleteRecursive(current.left, data);
            return current;
        }
        current.right = deleteRecursive(current.right, data);
        return current;
    }// end of deleteRecursive methdo 
 
    private int findSmallestValue(Node root)
    {
        return root.left == null ? root.data : findSmallestValue(root.left);
    }// end of method findSmallestValue
    
    public void traverseInOrder(Node node)
    {
        if (node != null)
	{
            traverseInOrder(node.left);
            System.out.print(" " + node.data);
            traverseInOrder(node.right);
        }
    }// end of method traverseInOrder 
}// end of class BinaryTree

class StaticKeyword
{
    static int staticInt = 0; //static variable

    public static void staticMethod()
    {  
        staticInt++;
        System.out.println("This is a static method. staticInt = " + staticInt);
    }// end of method staticMethod 
}// end of method StaticKeyword

/**
 * This class demonstrates the use of JavaDoc
 *
 * @author liron mizrhai
 */
class JavaDoc 
{

    /**
     * The main method that runs the program
     * @param args Command line arguments
     * @return None
     */
    public static void main(String[] args)
    {
        System.out.println("Hello, this is a JavaDoc example!");
    }// end of method main
}// end of class JavaDoc
``