REVESE AN ARRAY

import java.util.Arrays;

public class ReverseArray {

public static void main(String[] args) {

int[] numbers = {1, 2, 3, 4, 5, 6};

System.out.println("Original Array: " + Arrays.toString(numbers));

reverseArray(numbers);

System.out.println("Reversed Array: " + Arrays.toString(numbers));

public static void reverseArray(int[] array) {

int start = 0; // Start pointer

int end = array.length - 1; // End pointer

while (start < end) {

// Swap elements at start and end

int temp = array[start];

array[start] = array[end];

array[end] = temp;

// Move the pointers

start++;

end--;

}
FINDING SMALLEST AND LARGEST IN AN ARRAY

public class MinMaxInArray {

public static void main(String[] args) {

int[] numbers = {15, 42, 3, 17, 8, 90, 1};

// Initialize variables for smallest and largest

int smallest = numbers[0];

int largest = numbers[0];

// Iterate through the array

for (int number : numbers) {

if (number < smallest) {

smallest = number;

if (number > largest) {

largest = number;

// Print the results

System.out.println("Smallest number: " + smallest);

System.out.println("Largest number: " + largest);

SUM OF ELEMENTS

public class ArraySum {

public static void main(String[] args) {

int[] numbers = {10, 20, 30, 40, 50};

// Calculate sum of array elements

int sum = calculateSum(numbers);

 System.out.println("Sum of elements in the array: " + sum);

public static int calculateSum(int[] array) {

int sum = 0; // Initialize sum to 0

// Iterate through the array

for (int num : array) {

sum += num; // Add each element to the sum

return sum;

Factorial

public class Factorial {

public static void main(String[] args) {

int number = 5; // You can change this number to test with other values

// Calculate factorial using an iterative approach

long result = factorial(number);

System.out.println("Factorial of " + number + " is: " + result);

public static long factorial(int n) {

long result = 1; // Initialize result as 1 (since factorial of 0 is 1)

// Iterate from 1 to n and multiply the numbers

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

 result *= i;

return result;

RECUSRIVE IN FACTORIAL

public class Factorial {

public static void main(String[] args) {

int number = 5; // You can change this number to test with other values

// Calculate factorial using recursion

long result = factorial(number);

System.out.println("Factorial of " + number + " is: " + result);

// Recursive method to calculate factorial

public static long factorial(int n) {

if (n == 0) {

return 1; // Base case: 0! = 1

} else {

return n * factorial(n - 1); // Recursive case

// Calculate maximum product of two integers

import java.util.Arrays;

public class MaxProduct {

public static void main(String[] args) {

 int[] numbers = {1, 10, -5, 1, -100};

// Calculate maximum product of two integers

int result = maxProduct(numbers);

System.out.println("Maximum product of two integers: " + result);

public static int maxProduct(int[] array) {

// Sort the array

Arrays.sort(array);

// Compare the product of two largest numbers and two smallest numbers

int n = array.length;

int product1 = array[n - 1] * array[n - 2]; // Product of the two largest numbers

int product2 = array[0] * array[1]; // Product of the two smallest numbers (negative)

// Return the maximum product

return Math.max(product1, product2);

ANAGRAM

import java.util.Arrays;

public class AnagramCheck {

public static void main(String[] args) {

String str1 = "listen";

String str2 = "silent";

// Check if the strings are anagrams

boolean result = areAnagrams(str1, str2);

 System.out.println("Are the two strings anagrams? " + result);

public static boolean areAnagrams(String str1, String str2) {

// If lengths are different, they cannot be anagrams

if (str1.length() != str2.length()) {

return false;

// Convert strings to char arrays and sort them

char[] arr1 = str1.toCharArray();

char[] arr2 = str2.toCharArray();

Arrays.sort(arr1);

Arrays.sort(arr2);

// Compare sorted arrays

return Arrays.equals(arr1, arr2);

PALINDROME

public class PalindromeCheck {

public static void main(String[] args) {

String str = "madam"; // You can test with other strings as well

// Check if the string is a palindrome

boolean result = isPalindrome(str);

System.out.println("Is the string a palindrome? " + result);

}
 public static boolean isPalindrome(String str) {

// Remove spaces and convert to lowercase for uniformity

str = str.replaceAll("[^a-zA-Z0-9]", "").toLowerCase();

// Initialize pointers to start and end of the string

int left = 0;

int right = str.length() - 1;

// Compare characters from both ends of the string

while (left < right) {

if (str.charAt(left) != str.charAt(right)) {

return false; // If characters don't match, it's not a palindrome

left++;

right--;

return true; // If loop completes, it's a palindrome

PATTERNS

In Java, patterns can be printed using loops. Common patterns include stars (*), numbers, and
alphabets arranged in different shapes, such as triangles, squares, and pyramids.

Below are some popular star patterns with Java code examples:

1. Right-Angled Triangle (Star Pattern)

**

***

****

*****
Java Code:

public class StarPattern {

public static void main(String[] args) {

int n = 5; // Number of rows

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

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

System.out.print("*");

System.out.println(); // Move to the next line

2. Inverted Right-Angled Triangle

*****

****

***

**

Java Code:

public class InvertedTriangle {

public static void main(String[] args) {

int n = 5; // Number of rows

for (int i = n; i >= 1; i--) {

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

System.out.print("*");

System.out.println(); // Move to the next line

3. Pyramid Pattern
 *

***

*****

*******

*********

Java Code:

public class PyramidPattern {

public static void main(String[] args) {

int n = 5; // Number of rows

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

// Print spaces

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

System.out.print(" ");

// Print stars

for (int j = 1; j <= (2 * i - 1); j++) {

System.out.print("*");

System.out.println(); // Move to the next line

4. Inverted Pyramid

*********

*******

*****

***

Java Code:

public class InvertedPyramid {

public static void main(String[] args) {

 int n = 5; // Number of rows

for (int i = n; i >= 1; i--) {

// Print spaces

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

System.out.print(" ");

// Print stars

for (int j = 1; j <= (2 * i - 1); j++) {

System.out.print("*");

System.out.println(); // Move to the next line

5. Diamond Pattern

***

*****

*******

*********

*******

*****

***

Java Code:

public class DiamondPattern {

public static void main(String[] args) {

int n = 5; // Number of rows for the upper part

// Upper half of the diamond

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

// Print spaces
 for (int j = i; j < n; j++) {

System.out.print(" ");

// Print stars

for (int j = 1; j <= (2 * i - 1); j++) {

System.out.print("*");

System.out.println(); // Move to the next line

// Lower half of the diamond

for (int i = n - 1; i >= 1; i--) {

// Print spaces

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

System.out.print(" ");

// Print stars

for (int j = 1; j <= (2 * i - 1); j++) {

System.out.print("*");

System.out.println(); // Move to the next line

6. Hollow Square Pattern

*****

* *

* *

* *

*****

Java Code:
public class HollowSquarePattern {

public static void main(String[] args) {

int n = 5; // Size of the square

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

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

if (i == 1 || i == n || j == 1 || j == n) {

System.out.print("*");

} else {

System.out.print(" ");

System.out.println();

7. Floyd’s Triangle (Number Pattern)

23

456

7 8 9 10

11 12 13 14 15

Java Code:

public class FloydsTriangle {

public static void main(String[] args) {

int n = 5; // Number of rows

int num = 1; // Starting number

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

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

System.out.print(num + " ");

num++;

}
 System.out.println(); // Move to the next line

1. Reverse a String

public class ReverseString {

public static void main(String[] args) {

String str = "hello";

String reversed = new StringBuilder(str).reverse().toString();

System.out.println("Reversed String: " + reversed);

2. Check for Palindrome

public class Palindrome {

public static void main(String[] args) {

String str = "madam";

String reversed = new StringBuilder(str).reverse().toString();

if (str.equals(reversed)) {

System.out.println("Palindrome");

} else {

System.out.println("Not a Palindrome");

3. Find the Largest and Smallest Number in an Array

public class MinMax {

public static void main(String[] args) {

int[] arr = {4, 1, 9, 3, 6};

int max = arr[0], min = arr[0];

for (int num : arr) {

 if (num > max) max = num;

if (num < min) min = num;

System.out.println("Largest: " + max);

System.out.println("Smallest: " + min);

4. Count Occurrences of a Character in a String

public class CountChar {

public static void main(String[] args) {

String str = "hello world";

char ch = 'l';

int count = 0;

for (char c : str.toCharArray()) {

if (c == ch) {

count++;

System.out.println("Occurrences of '" + ch + "': " + count);

5. Factorial of a Number

public class Factorial {

public static void main(String[] args) {

int num = 5;

int fact = 1;

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

 fact *= i;

System.out.println("Factorial of " + num + " is: " + fact);

6. Fibonacci Series

public class Fibonacci {

public static void main(String[] args) {

int n = 5;

int a = 0, b = 1;

System.out.print(a + " " + b + " ");

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

int c = a + b;

System.out.print(c + " ");

a = b;

b = c;

7. Find the Second Largest Element in an Array

public class SecondLargest {

public static void main(String[] args) {

int[] arr = {5, 2, 9, 1, 6};

int max = Integer.MIN_VALUE, secondMax = Integer.MIN_VALUE;

for (int num : arr) {

if (num > max) {

secondMax = max;
 max = num;

} else if (num > secondMax && num != max) {

secondMax = num;

System.out.println("Second Largest: " + secondMax);

8. Prime Number Check

public class PrimeNumber {

public static void main(String[] args) {

int num = 7;

boolean isPrime = true;

for (int i = 2; i <= Math.sqrt(num); i++) {

if (num % i == 0) {

isPrime = false;

break;

System.out.println(isPrime ? "Prime" : "Not Prime");

9. Find the Missing Number in an Array

public class MissingNumber {

public static void main(String[] args) {

int[] arr = {1, 2, 4, 5};

int n = 5; // Array should contain numbers from 1 to n

int total = n * (n + 1) / 2;
 int sum = 0;

for (int num : arr) {

sum += num;

System.out.println("Missing number: " + (total - sum));

10. Sum of Digits of a Number

public class SumOfDigits {

public static void main(String[] args) {

int num = 1234;

int sum = 0;

while (num > 0) {

sum += num % 10;

num /= 10;

System.out.println("Sum of digits: " + sum);

11. Armstrong Number

public class Armstrong {

public static void main(String[] args) {

int num = 153;

int sum = 0, temp = num, digits = String.valueOf(num).length();

while (temp != 0) {

int remainder = temp % 10;

 sum += Math.pow(remainder, digits);

temp /= 10;

System.out.println(sum == num ? "Armstrong" : "Not Armstrong");

12. Count Vowels and Consonants in a String

public class VowelConsonantCount {

public static void main(String[] args) {

String str = "hello";

int vowels = 0, consonants = 0;

for (char ch : str.toLowerCase().toCharArray()) {

if (ch >= 'a' && ch <= 'z') {

if ("aeiou".indexOf(ch) != -1) {

vowels++;

} else {

consonants++;

System.out.println("Vowels: " + vowels + ", Consonants: " + consonants);

13. Find the GCD (Greatest Common Divisor)

public class GCD {

public static void main(String[] args) {

int a = 12, b = 15;

 while (b != 0) {

int temp = b;

b = a % b;

a = temp;

System.out.println("GCD: " + a);

14. Sort an Array

import java.util.Arrays;

public class SortArray {

public static void main(String[] args) {

int[] arr = {5, 2, 9, 1, 6};

Arrays.sort(arr);

System.out.println("Sorted Array: " + Arrays.toString(arr));

15. Sum of the Elements in an Array

public class SumArray {

public static void main(String[] args) {

int[] arr = {1, 2, 3, 4, 5};

int sum = 0;

for (int num : arr) {

sum += num;

System.out.println("Sum of array elements: " + sum);

 }

16. Reverse an Array

public class ReverseArray {

public static void main(String[] args) {

int[] arr = {1, 2, 3, 4};

int start = 0, end = arr.length - 1;

while (start < end) {

int temp = arr[start];

arr[start] = arr[end];

arr[end] = temp;

start++;

end--;

System.out.println("Reversed Array: " + Arrays.toString(arr));

17. Matrix Multiplication

public class MatrixMultiplication {

public static void main(String[] args) {

int[][] matrix1 = {{1, 2}, {3, 4}};

int[][] matrix2 = {{5, 6}, {7, 8}};

int[][] result = new int[2][2];

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

for (int j = 0; j < 2; j++) {

result[i][j] = matrix1[i][0] * matrix2[0][j] + matrix1[i][1] * matrix2[1][j];

}
 System.out.println("Matrix Multiplication Result: ");

for (int[] row : result) {

System.out.println(Arrays.toString(row));

18. Find the Longest Substring Without Repeating Characters

import java.util.HashSet;

public class LongestSubstring {

public static void main(String[] args) {

String str = "abcabcbb";

int maxLength = 0;

HashSet<Character> set = new HashSet<>();

int left = 0;

for (int right = 0; right < str.length(); right++) {

while (set.contains(str.charAt(right))) {

set.remove(str.charAt(left));

left++;

set.add(str.charAt(right));

maxLength = Math.max(maxLength, right - left + 1);

System.out.println("Longest Substring Length: " + maxLength);

19. Find if Two Strings are Anagrams

import java.util.Arrays;
public class Anagram {

public static void main(String[] args) {

String str1 = "listen";

String str2 = "silent";

char[] arr1 = str1.toCharArray();

char[] arr2 = str2.toCharArray();

Arrays.sort(arr1);

Arrays.sort(arr2);

if (Arrays.equals(arr1, arr2)) {

System.out.println("Anagrams");

} else {

System.out.println("Not Anagrams");

20. Find Missing Number in the Sequence

public class MissingNumberInSequence {

public static void main(String[] args) {

int[] arr = {1, 2, 4, 5};

int total = 15; // sum of numbers from 1 to 5

int sum = 0;

for (int num : arr) {

sum += num;

System.out.println("Missing number: " + (total - sum));

 }

number patterns

1. Right-Angled Triangle (Number Pattern)

public class NumberPattern1 {

public static void main(String[] args) {

int n = 5; // number of rows

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

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

System.out.print(j + " ");

System.out.println();

Output:

12

123

1234

12345

2. Inverted Right-Angled Triangle (Number Pattern)

public class NumberPattern2 {

public static void main(String[] args) {

int n = 5; // number of rows

for (int i = n; i >= 1; i--) {

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

System.out.print(j + " ");

}
 System.out.println();

Output:

12345

1234

123

12

3. Pyramid (Number Pattern)

public class NumberPattern3 {

public static void main(String[] args) {

int n = 5; // number of rows

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

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

System.out.print(" ");

for (int j = 1; j <= (2 * i - 1); j++) {

System.out.print(j);

System.out.println();

Output:

121

12321

1234321
123454321

4. Inverted Pyramid (Number Pattern)

public class NumberPattern4 {

public static void main(String[] args) {

int n = 5; // number of rows

for (int i = n; i >= 1; i--) {

for (int j = n; j > i; j--) {

System.out.print(" ");

for (int j = 1; j <= (2 * i - 1); j++) {

System.out.print(j);

System.out.println();

Output:

123454321

1234321

12321

121

5. Diamond Pattern (Number Pattern)

public class NumberPattern5 {

public static void main(String[] args) {

int n = 5; // number of rows

// Upper part of the diamond

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

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

 System.out.print(" ");

for (int j = 1; j <= (2 * i - 1); j++) {

System.out.print(j);

System.out.println();

// Lower part of the diamond

for (int i = n - 1; i >= 1; i--) {

for (int j = n; j > i; j--) {

System.out.print(" ");

for (int j = 1; j <= (2 * i - 1); j++) {

System.out.print(j);

System.out.println();

Output:

121

12321

1234321

123454321

1234321

12321

121

6. Floyd’s Triangle (Number Pattern)

public class NumberPattern6 {

public static void main(String[] args) {

int n = 5; // number of rows

int num = 1;

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

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

System.out.print(num + " ");

num++;

System.out.println();

Output:

23

456

7 8 9 10

11 12 13 14 15

7. Pascals Triangle (Number Pattern)

public class NumberPattern7 {

public static void main(String[] args) {

int n = 5; // number of rows

int[][] arr = new int[n][n];

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

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

if (j == 0 || j == i) {

arr[i][j] = 1;

} else {
 arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j];

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

System.out.println();

Output:

11

121

1331

14641

8. Right-Angled Triangle (Number Pattern with spaces)

public class NumberPattern8 {

public static void main(String[] args) {

int n = 5; // number of rows

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

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

System.out.print(i + " ");

System.out.println();

Output:

22

333
4444

55555

Mirroing of letters
. // Online Java Compiler

// Use this editor to write, compile and run your Java code online

class Main {

static String compute(String str, int n)

// Creating a string having reversed alphabetical order

String reverseAlphabet = "zyxwvutsrqponmlkjihgfedcba";

int l = str.length();

String answer = "";

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

answer = answer + str.charAt(i);

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

answer = answer + reverseAlphabet.charAt(str.charAt(i) - 'a');

return answer;

// Driver function

public static void main(String args[])

String str = "mazhu";

int n = 2;

System.out.print(compute(str, n - 1));

}
Rearrange positive and negative
// numbers in an array

import java.util.Arrays;

class GfG {

// Function to rearrange the array in-place

static void rearrange(int[] arr) {

// Traverse the array starting from the second element

for (int i = 1; i < arr.length; i++) {

// If the current element is positive, do nothing

if (arr[i] > 0)

continue;

// If the current element is negative, we need to rearrange

int temp = arr[i]; // Store the negative element temporarily

int j = i - 1; // Start shifting from the previous index

// Shift all positive elements to the right until the correct

// position for the negative number is found

while (j >= 0 && arr[j] > 0) {

arr[j + 1] = arr[j]; // Shift the positive element one position to the right

j--; // Move to the previous element

// Place the negative element in its correct position

arr[j + 1] = temp;

// Main function to test the rearrangement

 public static void main(String[] args) {

// Input array containing positive and negative integers

int[] arr = {-12, 11, -13, -5, 6, -7, 5, -3, -6};

// Call the rearrange function

rearrange(arr);

// Print the rearranged array

for (int ele : arr)

System.out.print(ele + " ");

String Manipulation

import java.util.HashMap;

import java.util.Map;

class Solution {

public static int getSumOfSequence(String str) {

// Create a map to store the values of each letter

Map<Character, Integer> valueMap = new HashMap<>();

valueMap.put('A', 1);

valueMap.put('B', 10);

valueMap.put('C', 100);

valueMap.put('D', 1000);

valueMap.put('E', 10000);

valueMap.put('F', 100000);

valueMap.put('G', 1000000);

int sum = 0;

// Loop through each character in the string and sum their corresponding values
 for (int i = 0; i < str.length(); i++) {

char ch = str.charAt(i);

// If the character is a valid key in the map, add its value to the sum

if (valueMap.containsKey(ch)) {

sum += valueMap.get(ch);

return sum;

public static void main(String[] args) {

// Example usage

String input = "BC";

int result = getSumOfSequence(input);

System.out.println("Sum of sequence: " + result);