Programming

Basic Logic and Control Structures

Array and String Manipulation

Searching and Sorting Algorithms

Write a program to implement binary search.
Write a program to implement linear search.
Write a program to sort an array using selection sort.
Write a program to sort an array using merge sort.
Write a program to sort an array using quick sort.
Write a program to sort an array using heap sort.
Write a program to find the kth smallest/largest element in an array.
Write a program to search an element in a rotated sorted array.
Write a program to implement the Dutch National Flag problem (sort an array of 0s, 1s, and 2s).
Write a program to find the intersection of two sorted arrays.

Mathematical and Number-Based Problems

Write a program to check if a number is a power of two.
Write a program to find the square root of a number without using a built-in function.
Write a program to find the nth Fibonacci number using dynamic programming.
Write a program to generate all prime numbers less than N using the Sieve of Eratosthenes.
Write a program to calculate the binomial coefficient.
Write a program to find the sum of all digits until the sum becomes a single digit.
Write a program to find the sum of all even numbers up to a given number.
Write a program to print the pascal triangle.
Write a program to find the sum of the first N Fibonacci numbers.
Write a program to check if a number is a perfect square.

1. Write a program to check if a number is even or odd.


import java.util.Scanner;

public class EvenOddCheck {
  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);

    System.out.print("Enter a number: ");
    int number = scanner.nextInt();

    if (number % 2 == 0) {
      System.out.println(number + " is even.");
    } else {
      System.out.println(number + " is odd.");
    }

    scanner.close();
  }
}

2. Write a program to find the largest of three numbers.


import java.util.Scanner;

public class LargestOfThree {
  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);

    // Input three numbers
    System.out.print("Enter the first number: ");
    int num1 = scanner.nextInt();

    System.out.print("Enter the second number: ");
    int num2 = scanner.nextInt();

    System.out.print("Enter the third number: ");
    int num3 = scanner.nextInt();

    // Determine the largest number
    int largest;

    if (num1 >= num2 && num1 >= num3) {
      largest = num1;
    } else if (num2 >= num1 && num2 >= num3) {
      largest = num2;
    } else {
      largest = num3;
    }

    // Output the largest number
    System.out.println("The largest number is: " + largest);

    scanner.close();
  }
}

3. Write a program to check if a given year is a leap year.


import java.util.Scanner;

public class LeapYearCheck {
  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);

    // Input the year
    System.out.print("Enter a year: ");
    int year = scanner.nextInt();

    // Check if the year is a leap year
    boolean isLeapYear;

    if (year % 4 == 0) {
      if (year % 100 == 0) {
        if (year % 400 == 0) {
          isLeapYear = true;
        } else {
          isLeapYear = false;
        }
      } else {
        isLeapYear = true;
      }
    } else {
      isLeapYear = false;
    }

    // Output the result
    if (isLeapYear) {
      System.out.println(year + " is a leap year.");
    } else {
      System.out.println(year + " is not a leap year.");
    }

    scanner.close();
  }
}

4. Write a program to calculate the factorial of a number.


import java.util.Scanner;

public class Factorial {
  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);

    // Input the number
    System.out.print("Enter a number: ");
    int number = scanner.nextInt();

    // Calculate factorial
    long factorial = 1;

    for (int i = 1; i <= number; i++) {
      factorial *= i;
    }

    // Output the result
    System.out.println("The factorial of " + number + " is: " + factorial);

    scanner.close();
  }
}

5. Write a program to generate the Fibonacci series up to a given number.


import java.util.Scanner;

public class FibonacciSeries {
  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);

    // Input the number up to which the Fibonacci series will be generated
    System.out.print("Enter the number up to which the Fibonacci series should be generated: ");
    int n = scanner.nextInt();

    // Initialize the first two numbers in the Fibonacci series
    int first = 0, second = 1;

    System.out.print("Fibonacci Series up to " + n + ": " + first + ", " + second);

    // Generate the Fibonacci series
    int next;
    while (true) {
      next = first + second;
      if (next > n) {
        break;
      }
      System.out.print(", " + next);
      first = second;
      second = next;
    }

    scanner.close();
  }
}

6. Write a program to reverse a given integer number.


import java.util.Scanner;

public class ReverseInteger {
  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);

    // Input the number
    System.out.print("Enter an integer number: ");
    int number = scanner.nextInt();

    // Initialize the variable to store the reversed number
    int reversedNumber = 0;

    // Reverse the number
    while (number != 0) {
      int digit = number % 10; // Get the last digit
      reversedNumber = reversedNumber * 10 + digit; // Add the digit to the reversed number
      number = number / 10; // Remove the last digit from the original number
    }

    // Output the reversed number
    System.out.println("Reversed Number: " + reversedNumber);

    scanner.close();
  }
}

7. Write a program to check if a number is a palindrome.


import java.util.Scanner;

public class PalindromeCheck {
  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);

    // Input the number
    System.out.print("Enter an integer number: ");
    int originalNumber = scanner.nextInt();

    int reversedNumber = 0;
    int temp = originalNumber;

    // Reverse the number
    while (temp != 0) {
      int digit = temp % 10; // Get the last digit
      reversedNumber = reversedNumber * 10 + digit; // Build the reversed number
      temp = temp / 10; // Remove the last digit from temp
    }

    // Check if the original number and reversed number are the same
    if (originalNumber == reversedNumber) {
      System.out.println(originalNumber + " is a palindrome.");
    } else {
      System.out.println(originalNumber + " is not a palindrome.");
    }

    scanner.close();
  }
}

8. Write a program to find the greatest common divisor (GCD) of two numbers.


import java.util.Scanner;

public class GCD {
  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);

    // Input two numbers
    System.out.print("Enter the first number: ");
    int num1 = scanner.nextInt();

    System.out.print("Enter the second number: ");
    int num2 = scanner.nextInt();

    // Find GCD using the Euclidean algorithm
    int gcd = findGCD(num1, num2);

    // Output the GCD
    System.out.println("The GCD of " + num1 + " and " + num2 + " is: " + gcd);

    scanner.close();
  }

  // Method to find GCD using Euclidean algorithm
  public static int findGCD(int a, int b) {
    while (b != 0) {
      int temp = b;
      b = a % b;
      a = temp;
    }
    return a;
  }
}

9. Write a program to find the least common multiple (LCM) of two numbers.


import java.util.Scanner;

public class LCM {
  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);

    // Input two numbers
    System.out.print("Enter the first number: ");
    int num1 = scanner.nextInt();

    System.out.print("Enter the second number: ");
    int num2 = scanner.nextInt();

    // Calculate LCM
    int lcm = findLCM(num1, num2);

    // Output the LCM
    System.out.println("The LCM of " + num1 + " and " + num2 + " is: " + lcm);

    scanner.close();
  }

  // Method to find LCM using the relationship between GCD and LCM
  public static int findLCM(int a, int b) {
    return (a * b) / findGCD(a, b);
  }

  // Method to find GCD using Euclidean algorithm
  public static int findGCD(int a, int b) {
    while (b != 0) {
      int temp = b;
      b = a % b;
      a = temp;
    }
    return a;
  }
}

10. Write a program to print the prime numbers up to a given number.


import java.util.Scanner;

public class PrimeNumbers {
  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);

    // Input the number up to which prime numbers will be printed
    System.out.print("Enter a number: ");
    int n = scanner.nextInt();

    System.out.println("Prime numbers up to " + n + " are:");

    // Print prime numbers from 2 to n
    for (int i = 2; i <= n; i++) {
      if (isPrime(i)) {
        System.out.print(i + " ");
      }
    }

    scanner.close();
  }

  // Method to check if a number is prime
  public static boolean isPrime(int num) {
    if (num <= 1) {
      return false;
    }
    for (int i = 2; i <= Math.sqrt(num); i++) {
      if (num % i == 0) {
        return false;
      }
    }
    return true;
  }
}

11. Write a program to check if a number is prime.


import java.util.Scanner;

public class PrimeCheck {
  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);

    // Input the number to check
    System.out.print("Enter an integer number: ");
    int number = scanner.nextInt();

    // Check if the number is prime
    boolean isPrime = isPrime(number);

    // Output the result
    if (isPrime) {
      System.out.println(number + " is a prime number.");
    } else {
      System.out.println(number + " is not a prime number.");
    }

    scanner.close();
  }

  // Method to check if a number is prime
  public static boolean isPrime(int num) {
    if (num <= 1) {
      return false;
    }
    for (int i = 2; i <= Math.sqrt(num); i++) {
      if (num % i == 0) {
        return false;
      }
    }
    return true;
  }
}

12. Write a program to calculate the sum of digits of a number.


import java.util.Scanner;

public class SumOfDigits {
  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);

    // Input the number
    System.out.print("Enter an integer number: ");
    int number = scanner.nextInt();

    // Initialize the variable to store the sum of digits
    int sum = 0;

    // Calculate the sum of digits
    while (number != 0) {
      int digit = number % 10; // Get the last digit
      sum += digit; // Add the digit to the sum
      number = number / 10; // Remove the last digit from the number
    }

    // Output the sum of digits
    System.out.println("The sum of the digits is: " + sum);

    scanner.close();
  }
}

13. Write a program to calculate the power of a number using recursion.


import java.util.Scanner;

public class PowerCalculation {
  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);

    // Input the base and exponent
    System.out.print("Enter the base number: ");
    int base = scanner.nextInt();

    System.out.print("Enter the exponent: ");
    int exponent = scanner.nextInt();

    // Calculate the power using recursion
    long result = power(base, exponent);

    // Output the result
    System.out.println(base + " raised to the power of " + exponent + " is: " + result);

    scanner.close();
  }

  // Recursive method to calculate power
  public static long power(int base, int exponent) {
    if (exponent == 0) { // Base case: any number raised to the power of 0 is 1
      return 1;
    } else if (exponent > 0) { // Recursive case: multiply the base with the result of power(base, exponent - 1)
      return base * power(base, exponent - 1);
    } else { // Handle negative exponents if needed
      return 1 / power(base, -exponent); // Convert the problem to positive exponent for simplicity
    }
  }
}

14. Write a program to swap two numbers without using a third variable.


import java.util.Scanner;

public class SwapNumbers {
  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);

    // Input the two numbers
    System.out.print("Enter the first number: ");
    int num1 = scanner.nextInt();

    System.out.print("Enter the second number: ");
    int num2 = scanner.nextInt();

    // Print the original numbers
    System.out.println("Before swapping:");
    System.out.println("num1 = " + num1);
    System.out.println("num2 = " + num2);

    // Swap the numbers without using a third variable
    num1 = num1 + num2; // Step 1: Add num1 and num2, store the result in num1
    num2 = num1 - num2; // Step 2: Subtract num2 from num1, store the result in num2
    num1 = num1 - num2; // Step 3: Subtract the new num2 from num1, store the result in num1

    // Print the swapped numbers
    System.out.println("After swapping:");
    System.out.println("num1 = " + num1);
    System.out.println("num2 = " + num2);

    scanner.close();
  }
}

15. Write a program to find the sum of the first N natural numbers.


import java.util.Scanner;

public class SumOfNaturalNumbers {
  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);

    // Input the number N
    System.out.print("Enter the value of N: ");
    int N = scanner.nextInt();

    // Calculate the sum of the first N natural numbers
    int sum = calculateSum(N);

    // Output the result
    System.out.println("The sum of the first " + N + " natural numbers is: " + sum);

    scanner.close();
  }

  // Method to calculate the sum of the first N natural numbers
  public static int calculateSum(int N) {
    // Using the formula for the sum of the first N natural numbers: sum = N * (N + 1) / 2
    return N * (N + 1) / 2;
  }
}

16. Write a program to check if a number is an Armstrong number.


import java.util.Scanner;

public class ArmstrongNumberCheck {
  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);

    // Input the number
    System.out.print("Enter an integer number: ");
    int number = scanner.nextInt();

    // Check if the number is an Armstrong number
    boolean isArmstrong = isArmstrongNumber(number);

    // Output the result
    if (isArmstrong) {
      System.out.println(number + " is an Armstrong number.");
    } else {
      System.out.println(number + " is not an Armstrong number.");
    }

    scanner.close();
  }

  // Method to check if a number is an Armstrong number
  public static boolean isArmstrongNumber(int num) {
    int originalNumber = num;
    int numberOfDigits = String.valueOf(num).length();
    int sum = 0;

    // Calculate the sum of each digit raised to the power of the number of digits
    while (num != 0) {
      int digit = num % 10;
      sum += Math.pow(digit, numberOfDigits);
      num /= 10;
    }

    // Check if the sum is equal to the original number
    return sum == originalNumber;
  }
}

17. Write a program to check if a number is a perfect number.


import java.util.Scanner;

public class PerfectNumberCheck {
  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);

    // Input the number
    System.out.print("Enter an integer number: ");
    int number = scanner.nextInt();

    // Check if the number is a perfect number
    boolean isPerfect = isPerfectNumber(number);

    // Output the result
    if (isPerfect) {
      System.out.println(number + " is a perfect number.");
    } else {
      System.out.println(number + " is not a perfect number.");
    }

    scanner.close();
  }

  // Method to check if a number is a perfect number
  public static boolean isPerfectNumber(int num) {
    if (num <= 1) {
      return false;
    }

    int sum = 0;

    // Find the sum of the proper divisors
    for (int i = 1; i <= num / 2; i++) {
      if (num % i == 0) {
        sum += i;
      }
    }

    // Check if the sum of the proper divisors is equal to the original number
    return sum == num;
  }
}

18. Write a program to find the average of N numbers.


import java.util.Scanner;

public class AverageOfNumbers {
  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);

    // Input the number of elements
    System.out.print("Enter the number of elements: ");
    int N = scanner.nextInt();

    // Validate input
    if (N <= 0) {
      System.out.println("The number of elements must be greater than zero.");
      scanner.close();
      return;
    }

    // Input the numbers and calculate the sum
    double sum = 0;
    for (int i = 1; i <= N; i++) {
      System.out.print("Enter number " + i + ": ");
      double number = scanner.nextDouble();
      sum += number;
    }

    // Calculate the average
    double average = sum / N;

    // Output the result
    System.out.println("The average of the " + N + " numbers is: " + average);

    scanner.close();
  }
}

19. Write a program to find the second largest number in an array.


import java.util.Scanner;

public class SecondLargestNumber {
  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);

    // Input the number of elements in the array
    System.out.print("Enter the number of elements in the array: ");
    int n = scanner.nextInt();

    // Validate input
    if (n < 2) {
      System.out.println("Array must have at least two elements.");
      scanner.close();
      return;
    }

    // Initialize the array
    int[] numbers = new int[n];

    // Input the elements of the array
    System.out.println("Enter the elements of the array:");
    for (int i = 0; i < n; i++) {
      numbers[i] = scanner.nextInt();
    }

    // Find the second largest number
    int firstLargest = Integer.MIN_VALUE;
    int secondLargest = Integer.MIN_VALUE;

    for (int num: numbers) {
      if (num > firstLargest) {
        secondLargest = firstLargest;
        firstLargest = num;
      } else if (num > secondLargest && num < firstLargest) {
        secondLargest = num;
      }
    }

    // Output the result
    if (secondLargest == Integer.MIN_VALUE) {
      System.out.println("There is no second largest number.");
    } else {
      System.out.println("The second largest number is: " + secondLargest);
    }

    scanner.close();
  }
}

20. Write a program to find the sum of all prime numbers up to a given number.


import java.util.Scanner;

public class SumOfPrimes {
  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);

    // Input the upper limit
    System.out.print("Enter an upper limit: ");
    int upperLimit = scanner.nextInt();

    // Validate input
    if (upperLimit < 2) {
      System.out.println("There are no prime numbers less than 2.");
      scanner.close();
      return;
    }

    // Calculate the sum of prime numbers up to the upper limit
    int sum = 0;
    for (int i = 2; i <= upperLimit; i++) {
      if (isPrime(i)) {
        sum += i;
      }
    }

    // Output the result
    System.out.println("The sum of all prime numbers up to " + upperLimit + " is: " + sum);

    scanner.close();
  }

  // Method to check if a number is prime
  public static boolean isPrime(int num) {
    if (num <= 1) {
      return false;
    }
    if (num == 2) {
      return true; // 2 is the only even prime number
    }
    if (num % 2 == 0) {
      return false; // Exclude all other even numbers
    }
    for (int i = 3; i <= Math.sqrt(num); i += 2) {
      if (num % i == 0) {
        return false;
      }
    }
    return true;
  }
}

Array Problems

Reverse an array:

public class ReverseArray {
    public static void reverseArray(int[] arr) {
        int start = 0, end = arr.length - 1;
        while (start < end) {
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
            start++;
            end--;
        }
    }

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        reverseArray(arr);
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }
}

Find the maximum and minimum elements in an array:


public class MaxMinArray {
    public static void findMaxMin(int[] arr) {
        int max = arr[0];
        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) max = arr[i];
            if (arr[i] < min) min = arr[i];
        }
        System.out.println("Max: " + max + ", Min: " + min);
    }

    public static void main(String[] args) {
        int[] arr = {12, 5, 7, 9, 3};
        findMaxMin(arr);
    }
}

Sort an array using bubble sort:

public class BubbleSort {
    public static void bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};
        bubbleSort(arr);
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }
}

Sort an array using insertion sort:


public class InsertionSort {
    public static void insertionSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            int key = arr[i];
            int j = i - 1;
            while (j >= 0 && arr[j] > key) {
                arr[j + 1] = arr[j];
                j--;
            }
            arr[j + 1] = key;
        }
    }

    public static void main(String[] args) {
        int[] arr = {12, 11, 13, 5, 6};
        insertionSort(arr);
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }
}

Find the missing number in an array:


public class MissingNumber {
    public static int findMissingNumber(int[] arr) {
        int n = arr.length + 1;
        int total = n * (n + 1) / 2;
        int sum = 0;
        for (int num : arr) {
            sum += num;
        }
        return total - sum;
    }

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 5};
        System.out.println("Missing number: " + findMissingNumber(arr));
    }
}

Remove duplicates from an array:


import java.util.HashSet;

public class RemoveDuplicates {
    public static void removeDuplicates(int[] arr) {
        HashSet<Integer> set = new HashSet<>();
        for (int num : arr) {
            set.add(num);
        }
        System.out.println(set);
    }

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 1, 2, 4, 5};
        removeDuplicates(arr);
    }
}

Find common elements between two arrays:


import java.util.HashSet;

public class CommonElements {
    public static void findCommonElements(int[] arr1, int[] arr2) {
        HashSet<Integer> set1 = new HashSet<>();
        for (int num : arr1) {
            set1.add(num);
        }
        for (int num : arr2) {
            if (set1.contains(num)) {
                System.out.print(num + " ");
            }
        }
    }

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

Merge two sorted arrays:


public class MergeSortedArrays {
    public static int[] mergeArrays(int[] arr1, int[] arr2) {
        int[] result = new int[arr1.length + arr2.length];
        int i = 0, j = 0, k = 0;
        while (i < arr1.length && j < arr2.length) {
            if (arr1[i] < arr2[j]) {
                result[k++] = arr1[i++];
            } else {
                result[k++] = arr2[j++];
            }
        }
        while (i < arr1.length) {
            result[k++] = arr1[i++];
        }
        while (j < arr2.length) {
            result[k++] = arr2[j++];
        }
        return result;
    }

    public static void main(String[] args) {
        int[] arr1 = {1, 3, 5};
        int[] arr2 = {2, 4, 6};
        int[] merged = mergeArrays(arr1, arr2);
        for (int num : merged) {
            System.out.print(num + " ");
        }
    }
}

Rotate an array by K positions:


public class RotateArray {
    public static void rotateArray(int[] arr, int k) {
        k = k % arr.length; // In case k is larger than array length
        reverse(arr, 0, arr.length - 1);
        reverse(arr, 0, k - 1);
        reverse(arr, k, arr.length - 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--;
        }
    }

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7};
        int k = 3;
        rotateArray(arr, k);
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

Find the frequency of each element in an array:


import java.util.HashMap;

public class ElementFrequency {
    public static void findFrequency(int[] arr) {
        HashMap<Integer, Integer> map = new HashMap<>();
        for (int num : arr) {
            map.put(num, map.getOrDefault(num, 0) + 1);
        }
        System.out.println(map);
    }

    public static void main(String[] args) {
        int[] arr = {1, 2, 2, 3, 3, 3};
        findFrequency(arr);
    }
}

String Problems

Check if a string is a palindrome:


public class Palindrome {
    public static boolean isPalindrome(String str) {
        int start = 0, end = str.length() - 1;
        while (start < end) {
            if (str.charAt(start) != str.charAt(end)) {
                return false;
            }
            start++;
            end--;
        }
        return true;
    }

    public static void main(String[] args) {
        String str = "madam";
        System.out.println(isPalindrome(str));
    }
}

Count vowels and consonants in a string:

public class VowelConsonantCount {
    public static void countVowelsAndConsonants(String str) {
        int vowels = 0, consonants = 0;
        for (char c : str.toLowerCase().toCharArray()) {
            if (Character.isLetter(c)) {
                if ("aeiou".indexOf(c) != -1) {
                    vowels++;
                } else {
                    consonants++;
                }
            }
        }
        System.out.println("Vowels: " + vowels + ", Consonants: " + consonants);
    }

    public static void main(String[] args) {
        String str = "Hello World";
        countVowelsAndConsonants(str);
    }
}

Reverse a string:


public class ReverseString {
    public static String reverseString(String str) {
        StringBuilder sb = new StringBuilder(str);
        return sb.reverse().toString();
    }

    public static void main(String[] args) {
        String str = "Hello";
        System.out.println(reverseString(str));
    }
}

Find the first non-repeated character in a string:


public class FirstNonRepeatedChar {
    public static char firstNonRepeated(String str) {
        for (int i = 0; i < str.length(); i++) {
            if (str.indexOf(str.charAt(i)) == str.lastIndexOf(str.charAt(i))) {
                return str.charAt(i);
            }
        }
        return '\0'; // Return null character if no non-repeated character is found
    }

    public static void main(String[] args) {
        String str = "swiss";
        System.out.println(firstNonRepeated(str));
    }
}

Check if two strings are anagrams:


import java.util.Arrays;

public class Anagram {
    public static boolean areAnagrams(String str1, String str2) {
        if (str1.length() != str2.length()) {
            return false;
        }
        char[] arr1 = str1.toCharArray();
        char[] arr2 = str2.toCharArray();
        Arrays.sort(arr1);
        Arrays.sort(arr2);
        return Arrays.equals(arr1, arr2);
    }

    public static void main(String[] args) {
        String str1 = "listen";
        String str2 = "silent";
        System.out.println(areAnagrams(str1, str2));
    }
}

Find all permutations of a given string:


import java.util.*;

public class Permutations {
    public static void permute(String str, int left, int right, List<String> result) {
        if (left == right) {
            result.add(str);
        } else {
            for (int i = left; i <= right; i++) {
                str = swap(str, left, i);
                permute(str, left + 1, right, result);
                str = swap(str, left, i); // Backtrack
            }
        }
    }

    public 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 new String(charArray);
    }

    public static void main(String[] args) {
        String str = "ABC";
        List<String> result = new ArrayList<>();
        permute(str, 0, str.length() - 1, result);
        System.out.println(result);
    }
}

Remove all white spaces from a string:

public class RemoveWhitespace {
    public static String removeWhitespace(String str) {
        return str.replaceAll("\\s+", "");
    }

    public static void main(String[] args) {
        String str = "Hello World";
        System.out.println(removeWhitespace(str));
    }
}

Check if a string contains only digits:


public class CheckDigits {
    public static boolean isDigits(String str) {
        return str.matches("[0-9]+");
    }

    public static void main(String[] args) {
        String str = "12345";
        System.out.println(isDigits(str));
    }
}

Find the longest substring without repeating characters:


public class LongestSubstring {
    public static int longestSubstring(String str) {
        int n = str.length();
        int maxLength = 0;
        Set<Character> set = new HashSet<>();
        int start = 0;

        for (int end = 0; end < n; end++) {
            while (set.contains(str.charAt(end))) {
                set.remove(str.charAt(start));
                start++;
            }
            set.add(str.charAt(end));
            maxLength = Math.max(maxLength, end - start + 1);
        }
        return maxLength;
    }

    public static void main(String[] args) {
        String str = "abcabcbb";
        System.out.println(longestSubstring(str));
    }
}

Count the occurrence of each character in a string:


import java.util.HashMap;

public class CharFrequency {
    public static void countFrequency(String str) {
        HashMap<Character, Integer> map = new HashMap<>();
        for (char c : str.toCharArray()) {
            map.put(c, map.getOrDefault(c, 0) + 1);
        }
        System.out.println(map);
    }

    public static void main(String[] args) {
        String str = "hello";
        countFrequency(str);
    }
}

Searching and Sorting Algorithms

Binary search:

public class BinarySearch {
    public static int binarySearch(int[] arr, int target) {
        int left = 0, right = arr.length - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (arr[mid] == target) return mid;
            if (arr[mid] < target) left = mid + 1;
            else right = mid - 1;
        }
        return -1; // Not found
    }

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        int target = 3;
        System.out.println(binarySearch(arr, target));
    }
}

Linear search:


public class LinearSearch {
    public static int linearSearch(int[] arr, int target) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == target) return i;
        }
        return -1; // Not found
    }

    public static void main(String[] args) {
        int[] arr = {10, 20, 30, 40, 50};
        int target = 30;
        System.out.println(linearSearch(arr, target));
    }
}

Selection sort:

public class SelectionSort {
    public static void selectionSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            int temp = arr[minIndex];
            arr[minIndex] = arr[i];
            arr[i] = temp;
        }
    }

    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};
        selectionSort(arr);
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }
} 
 
 
 
 
 
Merge Sort:
public class MergeSort {
    public static void mergeSort(int[] arr) {
        if (arr.length < 2) return;
        int mid = arr.length / 2;
        int[] left = new int[mid];
        int[] right = new int[arr.length - mid];
        System.arraycopy(arr, 0, left, 0, mid);
        System.arraycopy(arr, mid, right, 0, arr.length - mid);

        mergeSort(left);
        mergeSort(right);
        merge(arr, left, right);
    }

    private static void merge(int[] arr, int[] left, int[] right) {
        int i = 0, j = 0, k = 0;
        while (i < left.length && j < right.length) {
            if (left[i] <= right[j]) {
                arr[k++] = left[i++];
            } else {
                arr[k++] = right[j++];
            }
        }
        while (i < left.length) arr[k++] = left[i++];
        while (j < right.length) arr[k++] = right[j++];
    }

    public static void main(String[] args) {
        int[] arr = {38, 27, 43, 3, 9, 82, 10};
        mergeSort(arr);
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

Quick Sort:

public class QuickSort {
    public static void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            int pi = partition(arr, low, high);
            quickSort(arr, low, pi - 1);
            quickSort(arr, pi + 1, high);
        }
    }

    private static int partition(int[] arr, int low, int high) {
        int pivot = arr[high];
        int i = low - 1;
        for (int j = low; j < high; j++) {
            if (arr[j] <= pivot) {
                i++;
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        int temp = arr[i + 1];
        arr[i + 1] = arr[high];
        arr[high] = temp;
        return i + 1;
    }

    public static void main(String[] args) {
        int[] arr = {10, 80, 30, 90, 40, 50, 70};
        quickSort(arr, 0, arr.length - 1);
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

Heap Sort:
public class HeapSort {
    public static void heapSort(int[] arr) {
        int n = arr.length;
        for (int i = n / 2 - 1; i >= 0; i--) {
            heapify(arr, n, i);
        }
        for (int i = n - 1; i >= 0; i--) {
            int temp = arr[0];
            arr[0] = arr[i];
            arr[i] = temp;
            heapify(arr, i, 0);
        }
    }

    private static void heapify(int[] arr, int n, int i) {
        int largest = i;
        int left = 2 * i + 1;
        int right = 2 * i + 2;

        if (left < n && arr[left] > arr[largest]) {
            largest = left;
        }

        if (right < n && arr[right] > arr[largest]) {
            largest = right;
        }

        if (largest != i) {
            int swap = arr[i];
            arr[i] = arr[largest];
            arr[largest] = swap;
            heapify(arr, n, largest);
        }
    }

    public static void main(String[] args) {
        int[] arr = {4, 10, 3, 5, 1};
        heapSort(arr);
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

Find the kth smallest/largest element in an array:
import java.util.Arrays;

public class KthSmallest {
    public static int findKthSmallest(int[] arr, int k) {
        Arrays.sort(arr);
        return arr[k - 1];
    }

    public static int findKthLargest(int[] arr, int k) {
        Arrays.sort(arr);
        return arr[arr.length - k];
    }

    public static void main(String[] args) {
        int[] arr = {12, 3, 5, 7, 19};
        int k = 2;
        System.out.println("Kth smallest: " + findKthSmallest(arr, k));
        System.out.println("Kth largest: " + findKthLargest(arr, k));
    }
}

Search an element in a rotated sorted array:

public class RotatedBinarySearch {
    public static int search(int[] arr, int target) {
        int low = 0, high = arr.length - 1;
        while (low <= high) {
            int mid = low + (high - low) / 2;
            if (arr[mid] == target) return mid;
            if (arr[low] <= arr[mid]) {
                if (arr[low] <= target && target < arr[mid]) {
                    high = mid - 1;
                } else {
                    low = mid + 1;
                }
            } else {
                if (arr[mid] < target && target <= arr[high]) {
                    low = mid + 1;
                } else {
                    high = mid - 1;
                }
            }
        }
        return -1; // Not found
    }

    public static void main(String[] args) {
        int[] arr = {6, 7, 9, 15, 19, 2, 3};
        int target = 3;
        System.out.println(search(arr, target));
    }
}

Dutch National Flag Problem (Sort 0s, 1s, and 2s):
public class DutchNationalFlag {
    public static void sortColors(int[] arr) {
        int low = 0, mid = 0, high = arr.length - 1;
        while (mid <= high) {
            switch (arr[mid]) {
                case 0:
                    swap(arr, low++, mid++);
                    break;
                case 1:
                    mid++;
                    break;
                case 2:
                    swap(arr, mid, high--);
                    break;
            }
        }
    }

    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    public static void main(String[] args) {
        int[] arr = {2, 0, 1, 2, 0, 1, 1};
        sortColors(arr);
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

Find the intersection of two sorted arrays:

public class IntersectionSortedArrays {
    public static void findIntersection(int[] arr1, int[] arr2) {
        int i = 0, j = 0;
        while (i < arr1.length && j < arr2.length) {
            if (arr1[i] == arr2[j]) {
                System.out.print(arr1[i] + " ");
                i++;
                j++;
            } else if (arr1[i] < arr2[j]) {
                i++;
            } else {
                j++;
            }
        }
    }

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


Mathematical and Number-Based Problems
Check if a number is a power of two:
public class PowerOfTwo {
    public static boolean isPowerOfTwo(int num) {
        return num > 0 && (num & (num - 1)) == 0;
    }

    public static void main(String[] args) {
        int num = 16;
        System.out.println(isPowerOfTwo(num));
    }
}

Find the square root of a number without using a built-in function:
public class SquareRoot {
    public static int sqrt(int num) {
        int left = 0, right = num;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (mid * mid == num) {
                return mid;
            } else if (mid * mid < num) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return right; // Return floor of the square root
    }

    public static void main(String[] args) {
        int num = 10;
        System.out.println(sqrt(num));
    }
}

Find the nth Fibonacci number using dynamic programming:
public class Fibonacci {
    public static int fibonacci(int n) {
        int[] dp = new int[n + 1];
        dp[0] = 0;
        dp[1] = 1;
        for (int i = 2; i <= n; i++) {
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];
    }

    public static void main(String[] args) {
        int n = 9;
        System.out.println(fibonacci(n));
    }
}

Generate all prime numbers less than N using the Sieve of Eratosthenes:
public class SieveOfEratosthenes {
    public static void sieve(int n) {
        boolean[] primes = new boolean[n + 1];
        for (int i = 2; i <= n; i++) {
            primes[i] = true;
        }
        for (int i = 2; i * i <= n; i++) {
            if (primes[i]) {
                for (int j = i * i; j <= n; j += i) {
                    primes[j] = false;
                }
            }
        }
        for (int i = 2; i <= n; i++) {
            if (primes[i]) {
                System.out.print(i + " ");
            }
        }
    }

    public static void main(String[] args) {
        int n = 50;
        sieve(n);
    }
}

Calculate the binomial coefficient:

public class BinomialCoefficient {
    public static int binomialCoefficient(int n, int k) {
        int[][] dp = new int[n + 1][k + 1];
        for (int i = 0; i <= n; i++) {
            for (int j = 0; j <= Math.min(i, k); j++) {
                if (j == 0 || j == i) {
                    dp[i][j] = 1;
                } else {
                    dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
                }
            }
        }
        return dp[n][k];
    }

    public static void main(String[] args) {
        int n = 5, k = 2;
        System.out.println(binomialCoefficient(n, k));
    }
}

add

Programming

Array and String Manipulation

Searching and Sorting Algorithms

Mathematical and Number-Based Problems

Array Problems

String Problems

Searching and Sorting Algorithms

Mathematical and Number-Based Problems

Contact Form

Popular

Sponsor

Watch Tutorial

Report Abuse

Blog Archive

Pages

jiquest

Menu Footer Widget

Popular Posts

Featured Post

Java Interview Question

Followers

Total Pageviews

Popular Posts

add

Programming

Array and String Manipulation

Searching and Sorting Algorithms

Mathematical and Number-Based Problems

Array Problems

String Problems

Searching and Sorting Algorithms

Mathematical and Number-Based Problems

Subscribe via email

Contact Form

Popular

Sponsor

Watch Tutorial

Report Abuse

Blog Archive

Pages

jiquest

Menu Footer Widget

Popular Posts

Featured Post

Java Interview Question

Followers

Total Pageviews

Popular Posts