package array_programming;

import [Link];

import [Link];

public class ArrayCopying {

public static int[] copyArryElements(int arr[]) {

int brr[] = new int[[Link]];

for(int i = 0; i < [Link]; i++) {

brr[i] = arr[i];

return brr;

public static void toPrintArrayElements(int arr[]) {

[Link]("Array Elements of : " + [Link](arr) + " is : " );

for(int i = 0; i < [Link]; i++) {

[Link](arr[i] + " ");

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Enter Array Size : ");

int size = [Link]();

int arr[] = [Link](size);

int brr[] = copyArryElements(arr);

toPrintArrayElements(arr);

[Link]();

toPrintArrayElements(brr);

[Link]();

}
package array_programming;

import [Link];

import [Link];

public class ArrayCopyingInReverse {

public static int[] copyArryElements(int arr[]) {

int index = 0;

int brr[] = new int[[Link]];

for(int i = [Link] - 1; i >= 0; i--) {

brr[index++] = arr[i];

return brr;

public static void toPrintArrayElements(int arr[]) {

[Link]("Array Elements of are : " + [Link](arr));

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Enter Array Size : ");

int size = [Link]();

int arr[] = [Link](size);

int brr[] = copyArryElements(arr);

toPrintArrayElements(arr);

[Link]();

toPrintArrayElements(brr);

[Link]();

}
package array_programming;

import [Link];

import [Link];

public class ArrayMerging {

public static int[] mergeArrays(int arr[], int brr[]) {

int crr[] = new int[[Link] + [Link]];

int index = 0;

for (int i = 0; i < [Link]; i++) {

if (i < [Link]) {

crr[i] = arr[i];

} else {

crr[i] = brr[index++];

return crr;

public static int[] createAndInitialize(Scanner sc, int size) {

int[] array = new int[size];

[Link]("Enter " + size + " elements:");

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

[Link]("Enter " + i + " value:");

array[i] = [Link]();

return array;

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Enter 1st Array Size : ");

int size = [Link]();

[Link]("ENter 2nd Array Size : ");

int size1 = [Link]();

int arr[] = createAndInitialize(sc, size);

int brr[] = createAndInitialize(sc, size1);

[Link]("First Array ELemets are : " + [Link](arr));

[Link]("Second Array ELemets are : " + [Link](brr));

[Link]("Merged Array ELemets are : " + [Link](mergeArrays(arr, brr)));

}
package array_programming;

import [Link];

import [Link];

public class ArraySplitting {

public static int[] firstArray(int arr[]) {

int brr[] = new int[[Link] - ([Link] / 2)];

for(int i = 0; i < [Link]; i++) {

if(i < [Link]) {

brr[i] = arr[i];

return brr;

public static int[] secondArray(int arr[]) {

int index = [Link] - ([Link] / 2);

int crr[] = new int[[Link] / 2];

for(int i = [Link] - 1; i >= 0; i--) {

if(i < [Link]) {

crr[i] = arr[index++];

return crr;

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Enter Array Size: ");

int size = [Link]();

int arr[] = [Link](size);

[Link]("First Half Array Elements After Splitting : " + [Link](firstArray(arr)));

[Link]("Second Half Array Elements After Splitting : " + [Link](secondArray(arr)));

}
package array_programming;

import [Link];

public class ArraySyntax {

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Enter Length of the Array : ");

int size = [Link]();

int a[] = new int[size];

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

[Link]("Enter Array index " + i + " value : ");

a[i] = [Link]();

[Link]("Array Elements are : ");

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

[Link](a[i] + " ");

[Link]();

[Link]();

}
package array_programming;

import [Link];

public class ArrayUtility {

public static int[] createAndInitialize(int size) {

int arr[] = new int[size];

Scanner sc = new Scanner([Link]);

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

[Link]("Enter Array index " + i + " value : ");

arr[i] = [Link]();

return arr;

public static void printElements(int arr[]) {

[Link]("Array Elements are : [ ");

for(int i = 0; i < [Link]; i++) {

if(i == [Link] - 1) {

[Link](arr[i] + " ");

} else {

[Link](arr[i] + " , ");

[Link]("]");

}
package array_programming;

import [Link];

public class ArrayUtilityChar {

public static char[] createAndInitialize(int size) {

char arr[] = new char[size];

Scanner sc = new Scanner([Link]);

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

[Link]("Enter Array index " + i + " value : ");

arr[i] = [Link]().charAt(0);

[Link]();

return arr;

public static void printElements(int arr[]) {

[Link]("Array Elements are : [ ");

for(int i = [Link] - 1; i >= 0; i++) {

if(i == [Link] - 1) {

[Link](arr[i] + " ");

} else {

[Link](arr[i] + " , ");

[Link]("]");

}
package array_programming;

import [Link];

public class Combination1 {

public static int smallestElement(int arr[]) {

int smallest = arr[0];

for(int i = 0; i < [Link]; i++) {

if(arr[i] < smallest) {

smallest = arr[i];

return smallest;

public static int largestElement(int arr[]) {

int largest = arr[0];

for(int i = 0; i < [Link]; i++) {

if(arr[i] > largest) {

largest = arr[i];

return largest;

public static int sum(int largest, int smallest) {

return largest + smallest;

public static boolean checkPrime(int n) {

int count = 0;

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

if(n % i == 0) {

count++;

return count == 2;

public static int reverse(int n) {

int rev = 0;
 while(n > 0) {

int digit = n % 10;

rev = rev * 10 + digit;

n /= 10;

return rev;

public static boolean checkTwistedPrime(int n) {

return checkPrime(n) && checkPrime(reverse(n));

public static int nextTwistedPrime(int sum) {

for(int i = sum + 1; ; i++) {

if(checkTwistedPrime(i)) {

return i;

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Enter Array Size : ");

int size = [Link]();

int arr[] = [Link](size);

[Link]("largest Array ELement : " + largestElement(arr));

[Link]("Smallest Array Element : " + smallestElement(arr));

[Link]("Sum of Largest and Smallest Array Elements : " + sum(largestElement(arr), smallestElement(arr)));

[Link]("The next twisted prime element of Sum of Largest and Smallest Array Elements : " + nextTwistedPrime(sum(largestElement(arr),
smallestElement(arr))));

}
package array_programming;

import [Link];

import [Link];

public class CopyingEvenElements {

public static int countEvenElements(int arr[]) {

int count = 0;

for(int i = 0; i < [Link]; i++) {

if(arr[i] % 2 == 0) {

count++;

return count;

public static int[] copyArryElements(int arr[]) {

int count = countEvenElements(arr);

int index = 0;

int brr[] = new int[count];

for(int i = 0; i < [Link]; i++) {

if(arr[i] % 2 == 0) {

brr[index++] = arr[i];

return brr;

public static void toPrintArrayElements(int arr[]) {

[Link]("Array Elements of are : " + [Link](arr));

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Enter Array Size : ");

int size = [Link]();

int arr[] = [Link](size);

int brr[] = copyArryElements(arr);

 toPrintArrayElements(arr);

[Link]();

toPrintArrayElements(brr);

[Link]();

package array_programming;

import [Link];

import [Link];

public class CopyingEvenIndices {

public static int countEvenElements(int arr[]) {

int count = 0;

for(int i = 0; i < [Link]; i++) {

if(i % 2 == 0) {

count++;

return count;

public static int[] copyArryElements(int arr[]) {

int count = countEvenElements(arr);

int index = 0;

int brr[] = new int[count];

for(int i = 0; i < [Link]; i++) {

if(i % 2 == 0) {

brr[index++] = arr[i];

return brr;

public static void toPrintArrayElements(int arr[]) {

[Link]("Array Elements of are : " + [Link](arr));

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Enter Array Size : ");

int size = [Link]();

int arr[] = [Link](size);

 int brr[] = copyArryElements(arr);

toPrintArrayElements(arr);

[Link]();

toPrintArrayElements(brr);

[Link]();

package array_programming;

import [Link];

import [Link];

public class CopyingOddElements {

public static int countOddElements(int arr[]) {

int count = 0;

for(int i = 0; i < [Link]; i++) {

if(arr[i] % 2 != 0) {

count++;

return count;

public static int[] copyArryElements(int arr[]) {

int count = countOddElements(arr);

int index = 0;

int brr[] = new int[count];

for(int i = 0; i < [Link]; i++) {

if(arr[i] % 2 != 0) {

brr[index++] = arr[i];

return brr;

public static void toPrintArrayElements(int arr[]) {

[Link]("Array Elements of are : " + [Link](arr));

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Enter Array Size : ");

 int size = [Link]();

int arr[] = [Link](size);

int brr[] = copyArryElements(arr);

toPrintArrayElements(arr);

[Link]();

toPrintArrayElements(brr);

[Link]();

package array_programming;

import [Link];

import [Link];

public class CopyingOddIndices {

public static int countEvenElements(int arr[]) {

int count = 0;

for(int i = 0; i < [Link]; i++) {

if(i % 2 != 0) {

count++;

return count;

public static int[] copyArryElements(int arr[]) {

int count = countEvenElements(arr);

int index = 0;

int brr[] = new int[count];

for(int i = 0; i < [Link]; i++) {

if(i % 2 != 0) {

brr[index++] = arr[i];

return brr;

public static void toPrintArrayElements(int arr[]) {

[Link]("Array Elements of are : " + [Link](arr));

}
 public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Enter Array Size : ");

int size = [Link]();

int arr[] = [Link](size);

int brr[] = copyArryElements(arr);

toPrintArrayElements(arr);

[Link]();

toPrintArrayElements(brr);

[Link]();

package array_programming;

import [Link];

import [Link];

public class CopyingPrimeElements {

public static boolean verifyPrime(int num) {

int count = 0;

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

if(num % i == 0) {

count++;

return count == 2;

public static int primeElementCount(int arr[]) {

int count = 0;

for(int i = 0; i < [Link]; i++) {

if(verifyPrime(arr[i])) {

count++;

return count;

public static int[] copyArryElements(int arr[]) {

int count = primeElementCount(arr);

int index = 0;

int brr[] = new int[count];

for(int i = 0; i < [Link]; i++) {

 if(verifyPrime(arr[i])) {

brr[index++] = arr[i];

return brr;

public static void toPrintArrayElements(int arr[]) {

[Link]("Array Elements of are : " + [Link](arr));

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Enter Array Size : ");

int size = [Link]();

int arr[] = [Link](size);

int brr[] = copyArryElements(arr);

toPrintArrayElements(arr);

[Link]();

toPrintArrayElements(brr);

[Link]();

}
package array_programming;

import [Link];

public class ElementsSum {

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Enter Array Size : ");

int size = [Link]();

int a[] = [Link](size);

int sum = 0;

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

sum += a[i];

[Link]("The Sum of the Elements present in the given array is : " + sum);

[Link]();

}
package array_programming;

import [Link];

public class ElemetsProduct {

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Enter Array Size : ");

int size = [Link]();

int a[] = [Link](size);

int pro = 1;

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

pro *= a[i];

[Link]("The Product of the Elements present in the given array is : " + pro);

[Link]();

}
package array_programming;

import [Link];

import [Link];

public class EvenOddSum {

public static int sumOfArray(int size, int arr[]) {

int sum = 0;

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

sum += arr[i];

return sum;

public static boolean evenOdd(int n) {

if(n % 2 == 0) {

return true;

return false;

public static void main(String[] args) {

[Link]("Enter Array Size : ");

Scanner sc = new Scanner([Link]);

int size = [Link]();

int arr[] = [Link](size);

if(evenOdd(sumOfArray(size, arr))) {

[Link]("The sum of the Array Elements "+ [Link](arr) +" is : " + sumOfArray(size, arr) + " Even");
 } else {

[Link]("The sum of the Array Elements is : " + sumOfArray(size, arr) + " Odd");

[Link]();

package array_programming;

import [Link];

public class Example1 {

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Enter Array Size : ");

int size = [Link]();

int a[] = [Link](size);

[Link](a);

[Link]();

}
package array_programming;

import [Link];

public class LargestElement {

public static int largestElement(int arr[]) {

int largest = arr[0];

for(int i = 0; i < [Link]; i++) {

if(arr[i] > largest) {

largest = arr[i];

return largest;

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Enter Array Size : ");

int size = [Link]();

int arr[] = [Link](size);

[Link]("The Largest Element of given array elements are : " + largestElement(arr));

}
package array_programming;

import [Link];

import [Link];

public class MergeAndSort {

public static int[] mergeArrays(int arr[], int brr[]) {

int crr[] = new int[[Link] + [Link]];

int index = 0;

for (int i = 0; i < [Link]; i++) {

if (i < [Link]) {

crr[i] = arr[i];

} else {

crr[i] = brr[index++];

return crr;

public static void swapping(int arr[], int a, int b) {

int temp = arr[a];

arr[a] = arr[b];

arr[b] = temp;

public static int[] sortingInAscending(int arr[]) {

for(int i = 0; i < [Link]; i++) {

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

if(arr[i] > arr[j]) {

 swapping(arr, i, j);

return arr;

public static void main(String args[]) {

Scanner sc = new Scanner([Link]);

[Link]("Enter 1st Array Size : ");

int size = [Link]();

[Link]("Enter 2nd Array Size : ");

int size1 = [Link]();

int arr[] = [Link](size);

int brr[] = [Link](size1);

[Link]([Link](mergeArrays(arr, brr)));

[Link]([Link](sortingInAscending(mergeArrays(arr, brr))));

[Link]();

}
package array_programming;

import [Link];

import [Link];

public class MergedEvenElements {

public static int[] mergeArrays(int arr[], int brr[]) {

int crr[] = new int[[Link] + [Link]];

int index = 0;

for (int i = 0; i < [Link]; i++) {

if (i < [Link]) {

crr[i] = arr[i];

} else {

crr[i] = brr[index++];

return crr;

public static int[] createAndInitialize(Scanner sc, int size) {

int[] array = new int[size];

[Link]("Enter " + size + " elements:");

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

[Link]("Enter " + i + " value:");

array[i] = [Link]();

return array;

}
 public static void printingEvenElements(int crr[]) {

[Link]("The Even Elements of Merged Array are : ");

for(int i = 0; i < [Link]; i++) {

int element = crr[i];

if(element % 2 == 0) {

[Link](crr[i]+ " ");

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Enter 1st Array Size : ");

int size = [Link]();

[Link]("ENter 2nd Array Size : ");

int size1 = [Link]();

int arr[] = createAndInitialize(sc, size);

int brr[] = createAndInitialize(sc, size1);

[Link]("First Array ELemets are : " + [Link](arr));

[Link]("Second Array ELemets are : " + [Link](brr));

[Link]("Merged Array ELemets are : " + [Link](mergeArrays(arr, brr)));

printingEvenElements(mergeArrays(arr, brr));

}
package array_programming;

import [Link];

import [Link];

public class MergeEvenAndSort {

public static int countEvenElements(int arr[]) {

int count = 0;

for(int i = 0; i < [Link]; i++) {

if(arr[i] % 2 == 0) {

count++;

return count;

public static int greaterLength(int arr[], int brr[]) {

if([Link] > [Link]) {

return [Link];

return [Link];

public static int[] mergeArrays(int arr[], int brr[]) {

int count = countEvenElements(arr) + countEvenElements(brr);

int length = greaterLength(arr, brr);

 int crr[] = new int[count];

int index = 0;

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

if (i < [Link] && arr[i] % 2 == 0) {

crr[index++] = arr[i];

if (i < [Link] && brr[i] % 2 == 0) {

crr[index++] = brr[i];

return crr;

public static void swapping(int arr[], int a, int b) {

int temp = arr[a];

arr[a] = arr[b];

arr[b] = temp;

public static int[] sortingInDescending(int arr[]) {

for(int i = 0; i < [Link]; i++) {

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

if(arr[i] < arr[j]) {

swapping(arr, i, j);

return arr;

public static void main(String args[]) {

Scanner sc = new Scanner([Link]);

[Link]("Enter 1st Array Size : ");

int size = [Link]();

[Link]("Enter 2nd Array Size : ");

int size1 = [Link]();

int arr[] = [Link](size);

int brr[] = [Link](size1);

[Link]([Link](sortingInDescending(mergeArrays(arr, brr))));

[Link]();

}
package array_programming;

import [Link];

import [Link];

public class MergeEvenELemets {

public static int countEvenElements(int arr[]) {

int count = 0;

for(int i = 0; i < [Link]; i++) {

if(arr[i] % 2 == 0) {

count++;

return count;

public static int greaterLength(int arr[], int brr[]) {

if([Link] > [Link]) {

return [Link];

return [Link];

public static int[] mergeArrays(int arr[], int brr[]) {

 int count = countEvenElements(arr) + countEvenElements(brr);

int length = greaterLength(arr, brr);

int crr[] = new int[count];

int index = 0;

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

if (i < [Link] && arr[i] % 2 == 0) {

crr[index++] = arr[i];

if (i < [Link] && brr[i] % 2 == 0) {

crr[index++] = brr[i];

return crr;

public static int[] createAndInitialize(Scanner sc, int size) {

int[] array = new int[size];

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

[Link]("Enter " + i + " index value:");

array[i] = [Link]();

return array;

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Enter 1st Array Size : ");

int size = [Link]();

[Link]("Enter 2nd Array Size : ");

int size1 = [Link]();

int arr[] = createAndInitialize(sc, size);

int brr[] = createAndInitialize(sc, size1);

[Link]("First Array ELements are : " + [Link](arr));

[Link]("Second Array ELements are : " + [Link](brr));

if(countEvenElements(arr) + countEvenElements(brr) > 0) {

[Link]("Merged Array ELemets are : " + [Link](mergeArrays(arr, brr)));

} else {

[Link]("No Even ELemets are Present in the Given Arrays");

}
package array_programming;

import [Link];

import [Link];

public class MergePrimeElements {

public static boolean checkPrime(int n) {

int count = 0;

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

if(n % i == 0) {

count++;

return count == 2;

public static int countPrimeElements(int arr[]) {

int count = 0;

for(int i = 0; i < [Link]; i++) {

if(checkPrime(arr[i])) {

count++;
 }

return count;

public static int greaterLength(int arr[], int brr[]) {

if([Link] > [Link]) {

return [Link];

return [Link];

public static int[] mergeArrays(int arr[], int brr[]) {

int count = countPrimeElements(arr) + countPrimeElements(brr);

int length = greaterLength(arr, brr);

int crr[] = new int[count];

int index = 0;

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

if (i < [Link] && checkPrime(arr[i])) {

crr[index++] = arr[i];

if (i < [Link] && checkPrime(brr[i])) {

crr[index++] = brr[i];

return crr;

public static int[] createAndInitialize(Scanner sc, int size) {

int[] array = new int[size];

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

[Link]("Enter " + i + " index value:");

array[i] = [Link]();

return array;

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Enter 1st Array Size : ");

int size = [Link]();

[Link]("Enter 2nd Array Size : ");

int size1 = [Link]();

int arr[] = createAndInitialize(sc, size);

int brr[] = createAndInitialize(sc, size1);

 [Link]("First Array ELements are : " + [Link](arr));

[Link]("Second Array ELements are : " + [Link](brr));

if(countPrimeElements(arr) + countPrimeElements(brr) > 0) {

[Link]("Merged Prime Array ELemets are : " + [Link](mergeArrays(arr, brr)));

} else {

[Link]("No Prime ELemets are Present in the Given Arrays");

package array_programming;

import [Link];

public class OddElements {

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Enter Array Size : ");

int size = [Link]();

int a[] = [Link](size);

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

if (a[i] % 2 != 0) {

[Link](a[i] + " ");

[Link]();

}
package array_programming;

import [Link];

import [Link];

public class ProductArmstrong {

public static int count(int n) {

int count = 0;

while (n > 0) {

count++;

n /= 10;

return count;

public static int sumOfExpo(int n) {

int sum = 0;

int count = count(n);

while (n > 0) {
 int digit = n % 10;

int exp = 1;

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

exp *= digit;

sum += exp;

n /= 10;

return sum;

public static int productOfArray(int size, int arr[]) {

int pro = 1;

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

pro *= arr[i];

return pro;

public static boolean armstrongNumber(int n) {

return sumOfExpo(n) == n;

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Enter the Array Size : ");

int size = [Link]();

int arr[] = [Link](size);

if (armstrongNumber(productOfArray(size, arr))) {

[Link]("The product of the given Array Elements " + [Link](arr) + " is " + productOfArray(size, arr) + " an Armstrong Number");

} else {

[Link]("The product of the given Array Elements " + [Link](arr) + " is " + productOfArray(size, arr) + " not an Armstrong Number");

[Link]();

}
package array_programming;

import [Link];

import [Link];

public class ProductPalindrome {

public static boolean palindromeNumber(int n) {

int rev = 0;

int temp = n;

while(n > 0) {

int digit = n % 10;

rev = rev * 10 + digit;

n /= 10;

if(temp == rev) {

return true;

return false;
 }

public static int productOfArray(int size, int arr[]) {

int pro = 1;

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

pro *= arr[i];

return pro;

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Enter the Array Size : ");

int size = [Link]();

int arr[] = [Link](size);

if(palindromeNumber(productOfArray(size, arr))) {

[Link]("The product of the given Array Elements " + [Link](arr) + " is " + productOfArray(size, arr) +" a Palindrome");

} else {

[Link]("The product of the given Array Elements " + [Link](arr) + " is " + productOfArray(size, arr) + " not a Palindrome");

[Link]();

package array_programming;

import [Link];

import [Link];

public class ProTech {

public static int count(int n) {

int count = 0;

while(n > 0) {

count++;

n /= 10;

return count;

public static boolean even(int n) {

 if(n % 2 == 0) {

return true;

return false;

public static int divisor(int n) {

int divisor = 1;

int count = count(n);

if(even(count)) {

for(int i = 1; i <= count / 2; i++) {

divisor *= 10;

return divisor;

public static int firstHalf(int n) {

return n % divisor(n);

public static int secondHalf(int n) {

return n / divisor(n);

public static int sum(int n, int m) {

return n + m;

public static int squareOfNumber(int n) {

return n * n;

public static boolean techNumber(int n) {

if(squareOfNumber(sum(firstHalf(n), secondHalf(n))) == n) {

return true;

return false;

public static int proOfArray(int size, int arr[]) {

int pro = 1;

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

pro *= arr[i];

}
 return pro;

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Enter Array Size : ");

int size = [Link]();

int arr[] = [Link](size);

if(techNumber(proOfArray(size, arr))) {

[Link]("The product of the given Array Elements " + [Link](arr) + " is " + proOfArray(size, arr) + " a Tech Number");

} else {

[Link]("The product of the given Array Elements " + [Link](arr) + " is " + proOfArray(size, arr) + " not a Tech Number");

[Link]();

package array_programming;

import [Link];

public class ReverseArray {

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Enter Length of the Array : ");

int size = [Link]();

int a[] = new int[size];

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

[Link]("Enter Array index " + i + " value : ");

a[i] = [Link]();

}
 [Link]("Array Elements are : [ ");

for(int i = size -1; i >= 0; i--) {

if(i == 0) {

[Link](a[i] + " ");

} else {

[Link](a[i] + " , ");

[Link]("]");

[Link]();

package array_programming;

import [Link];

import [Link];

public class RightRotation {

public static int[] rotatedArray(int arr[]) {

int temp = arr[0];

for(int i = 0; i < [Link] - 1; i++) {

arr[i] = arr[i+1];

arr[[Link] - 1] = temp;
 return arr;

public static int[] rotateNnumberOfTimes(int arr[], int n) {

while(n > 0) {

arr = rotatedArray(arr);

n--;

return arr;

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Enter Array Size : ");

int size = [Link]();

int arr[] = [Link](size);

[Link]("Enter k value : ");

int n = [Link]();

[Link]("Left Rotated Array Elements are : " + [Link](rotatedArray(arr)));

[Link]("N Times Left Rotated Array Elements are : " + [Link](rotateNnumberOfTimes(rotatedArray(arr), n)));

[Link]();

package array_programming;

import [Link];

public class smallestELement {

public static int smallestElement(int arr[]) {

int smallest = arr[0];

for(int i = 0; i < [Link]; i++) {

if(arr[i] < smallest) {

smallest = arr[i];
 }

return smallest;

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Enter Array Size : ");

int size = [Link]();

int arr[] = [Link](size);

[Link]("The Smallest Element of given array elements are : " + smallestElement(arr));

package array_programming;

import [Link];

import [Link];

public class SortArrayInDescending {

public static void swap(int arr[], int i, int j) {

int temp = arr[i];

 arr[i] = arr[j];

arr[j] = temp;

public static int[] sortingInDescending(int arr[]) {

for(int i = 0; i < [Link]; i++) {

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

if(arr[i] < arr[j]) {

swap(arr, i, j);

return arr;

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Enter Array Size : ");

int size = [Link]();

int arr[] = [Link](size);

[Link]("Array Elements in Descending Order are : " + [Link](sortingInDescending(arr)));

[Link]();

package array_programming;

import [Link];

import [Link];

public class SortEvenElements {

 public static void swapping(int arr[], int a, int b) {

int temp = arr[a];

arr[a] = arr[b];

arr[b] = temp;

public static int[] sorting(int arr[]) {

for(int i = 0; i < [Link]; i++) {

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

if(arr[i] % 2 == 0 && arr[j] % 2 == 0) {

if(arr[i] > arr[j]) {

swapping(arr, i, j);

return arr;

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Enter Array Size : ");

int size = [Link]();

int arr[] = [Link](size);

[Link]("Assending Order of given Array Elements are : " + [Link](sorting(arr)));

[Link]();

package array_programming;

import [Link];

import [Link];

public class Sorting {

 public static void swapping(int arr[], int a, int b) {

int temp = arr[a];

arr[a] = arr[b];

arr[b] = temp;

public static int[] sorting(int arr[]) {

for(int i = 0; i < [Link]; i++) {

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

if(arr[i] > arr[j]) {

swapping(arr, i, j);

return arr;

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Enter Array Size : ");

int size = [Link]();

int arr[] = [Link](size);

[Link]("Assending Order of given Array Elements are : " + [Link](sorting(arr)));

[Link]();

package array_programming;

import [Link];

import [Link];
public class SortingPrimeELements {

public static void swapping(int arr[], int a, int b) {

int temp = arr[a];

arr[a] = arr[b];

arr[b] = temp;

public static boolean verifyPrime(int num) {

int count = 0;

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

if(num % i == 0) {

count++;

return count == 2;

public static int[] sorting(int arr[]) {

for(int i = 0; i < [Link]; i++) {

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

if(verifyPrime(arr[i]) && verifyPrime(arr[j])) {

if(arr[i] > arr[j]) {

swapping(arr, i, j);

return arr;

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Enter Array Size : ");

int size = [Link]();

int arr[] = [Link](size);

[Link]("Assending Order of given Array Elements are : " + [Link](sorting(arr)));

[Link]();

package array_programming;
import [Link];

import [Link];

public class SortOddInDescending {

public static void swapping(int arr[], int a, int b) {

int temp = arr[a];

arr[a] = arr[b];

arr[b] = temp;

public static int[] sorting(int arr[]) {

for(int i = 0; i < [Link]; i++) {

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

if(arr[i] % 2 != 0 && arr[j] % 2 != 0) {

if(arr[i] < arr[j]) {

swapping(arr, i, j);

return arr;

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Enter Array Size : ");

int size = [Link]();

int arr[] = [Link](size);

[Link]("Assending Order of given Array Elements are : " + [Link](sorting(arr)));

[Link]();

}
package array_programming;

import [Link];

import [Link];

public class SplitAnd1stEven2ndOdd {

public static int evenCount(int arr[]) {

int count = 0;

for(int i = 0; i < [Link]; i++) {

if(arr[i] % 2 == 0) {

count++;

return count;

public static int oddCount(int arr[]) {

int count = 0;

for(int i = 0; i < [Link]; i++) {

if(arr[i] % 2 != 0) {

count++;

return count;

public static int[] firstArray(int arr[]) {

int index = 0;

int brr[] = new int[evenCount(arr)];

for(int i = 0; i < [Link]; i++) {

if(i < [Link] && arr[i] % 2 == 0) {

brr[index++] = arr[i];

return brr;

public static int[] secondArray(int arr[]) {

int index = 0;

int crr[] = new int[oddCount(arr)];

for(int i = 0; i < [Link]; i++) {

if(i < [Link] && arr[i] % 2 != 0) {

crr[index++] = arr[i];

}
 }

return crr;

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Enter Array Size: ");

int size = [Link]();

int arr[] = [Link](size);

[Link]("First Half Array Elements After Splitting : " + [Link](firstArray(arr)));

[Link]("Second Half Array Elements After Splitting : " + [Link](secondArray(arr)));

}
package array_programming;

import [Link];

import [Link];

public class SplitAnd1stEvenAscending2ndOddDescending {

public static int evenCount(int arr[]) {

int count = 0;

for(int i = 0; i < [Link]; i++) {

if(arr[i] % 2 == 0) {

count++;

return count;

public static int oddCount(int arr[]) {

int count = 0;

for(int i = 0; i < [Link]; i++) {

if(arr[i] % 2 != 0) {

count++;

return count;

public static void swapping(int arr[], int a, int b) {

int temp = arr[a];

arr[a] = arr[b];

arr[b] = temp;

public static int[] firstArray(int arr[]) {

int index = 0;

int brr[] = new int[evenCount(arr)];

for(int i = 0; i < [Link]; i++) {

if(arr[i] % 2 == 0) {

brr[index++] = arr[i];

return brr;
 }

public static int[] secondArray(int arr[]) {

int index = 0;

int crr[] = new int[oddCount(arr)];

for(int i = 0; i < [Link]; i++) {

if(arr[i] % 2 != 0) {

crr[index++] = arr[i];

return crr;

public static int[] ascendingOrder(int arr[]) {

for(int i = 0; i < [Link]; i++) {

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

if(arr[i] > arr[j]) {

swapping(arr, i, j);

return arr;

public static int[] descendingOrder(int arr[]) {

for(int i = 0; i < [Link]; i++) {

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

if(arr[i] < arr[j]) {

swapping(arr, i, j);

return arr;

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Enter Array Size: ");

int size = [Link]();

int arr[] = [Link](size);

[Link]("First Half Array Elements After Splitting : " + [Link](ascendingOrder(firstArray(arr))));

[Link]("Second Half Array Elements After Splitting : " + [Link](descendingOrder(secondArray(arr))));

}
package array_programming;

import [Link];

import [Link];

public class SplitPrimeNonPrime {

public static int sum(int arr[]) {

int sum = 0;

for(int i = 0; i < [Link]; i++) {

sum += arr[i];

return sum;

public static int product(int arr[]) {

int pro = 1;

for(int i = 0; i < [Link]; i++) {

pro *= arr[i];

return pro;

public static boolean checkPrime(int n) {

int count = 0;

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

if(n % i == 0) {

count++;

return count == 2;

public static int countPrime(int arr[]) {

int count = 0;

for(int i = 0; i < [Link]; i++) {

 if(checkPrime(arr[i])) {

count++;

return count;

public static void swapping(int arr[], int a, int b) {

int temp = arr[a];

arr[a] = arr[b];

arr[b] = temp;

public static int[] firstArray(int arr[]) {

int index = 0;

int brr[] = new int[countPrime(arr)];

for(int i = 0; i < [Link]; i++) {

if(checkPrime(arr[i])) {

brr[index++] = arr[i];

return brr;

public static int[] secondArray(int arr[]) {

int index = 0;

int crr[] = new int[[Link] - countPrime(arr)];

for(int i = 0; i < [Link]; i++) {

if(!checkPrime(arr[i])) {

crr[index++] = arr[i];

return crr;

public static int[] ascending(int arr[]) {

for(int i = 0; i < [Link]; i++) {

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

if(arr[i] > arr[j]) {

swapping(arr, i, j);

return arr;

}
 public static int[] descending(int arr[]) {

for(int i = 0; i < [Link]; i++) {

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

if(arr[i] < arr[j]) {

swapping(arr, i, j);

return arr;

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Enter Array Size : ");

int size = [Link]();

int arr[] = [Link](size);

[Link]("Array Elemts are : " + [Link](arr));

[Link]("Sum of Prime Array Elements are : " + sum(firstArray(arr)));

[Link]("Product of Non-Prime Array Elements are : " + product(secondArray(arr)));

[Link]("Array Prime Elements are : " + [Link](firstArray(arr)));

[Link]("Array Non-Prime Elements are : " + [Link](secondArray(arr)));

[Link]("First Half Array Elements in Asecnding Order are : " + [Link](ascending(firstArray(arr))));

[Link]("Second Half Array Elements in Descending Order are : " + [Link](descending(secondArray(arr))));

}
package array_programming;

import [Link];

public class StringArray {

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Enter Length of the Array : ");

int size = [Link]();

String a[] = new String[size];

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

[Link]("Enter Array index " + i + " value : ");

a[i] = [Link]();

[Link]("Array Elements are : ");

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

[Link](a[i] + " ");

[Link]();

[Link]();

}
package array_programming;

import [Link];

import [Link];

public class SumPerfect {

public static int sumOfFactors(int n) {

int sum = 0;

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

if(n % i == 0) {

sum += i;

return sum;

public static boolean perfectNumber(int n) {

return sumOfFactors(n) == n;

public static int sumOfArray(int size, int arr[]) {

int sum = 0;

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

sum += arr[i];

return sum;

}
 public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Enter Array Size : ");

int size = [Link]();

int arr[] = [Link](size);

if(perfectNumber(sumOfArray(size, arr))) {

[Link]("The sum of the given Array Elements " + [Link](arr) + " is " + sumOfArray(size, arr) + " a Perfect Number");

} else {

[Link]("The sum of the given Array Elements " + [Link](arr) + " is " + sumOfArray(size, arr) + " not a Perfect Number");

[Link]();

package array_programming;

import [Link];

import [Link];

public class SumStrong {

public static int sumOfArray(int size, int arr[]) {

int sum = 0;

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

sum += arr[i];

return sum;

public static int factorialOfNumber(int n) {

int fact = 1;

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

fact *= i;

return fact;

public static int sumOfFact(int n) {

int sum = 0;

while (n > 0) {

int digit = n % 10;

sum += factorialOfNumber(digit);
 n /= 10;

return sum;

public static boolean strongNumber(int n) {

return sumOfFact(n) == n;

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Enter the Array Size : ");

int size = [Link]();

int arr[] = [Link](size);

if (strongNumber(sumOfArray(size, arr))) {

[Link]("The product of the given Array Elements " + [Link](arr) + " is " + sumOfArray(size, arr) + " an Strong Number");

} else {

[Link]("The product of the given Array Elements " + [Link](arr) + " is " + sumOfArray(size, arr) + " not an Strong Number");

[Link]();

package array_programming;

import [Link];

import [Link];

public class SumTech {

public static int count(int n) {

int count = 0;

while(n > 0) {

count++;

n /= 10;

return count;

public static boolean even(int n) {

if(n % 2 == 0) {

return true;

return false;

public static int divisor(int n) {

 int divisor = 1;

int count = count(n);

if(even(count)) {

for(int i = 1; i <= count / 2; i++) {

divisor *= 10;

return divisor;

public static int firstHalf(int n) {

return n % divisor(n);

public static int secondHalf(int n) {

return n / divisor(n);

public static int sum(int n, int m) {

return n + m;

public static int squareOfNumber(int n) {

return n * n;

public static boolean techNumber(int n) {

if(squareOfNumber(sum(firstHalf(n), secondHalf(n))) == n) {

return true;

return false;

public static int sumOfArray(int size, int arr[]) {

int sum = 0;

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

sum += arr[i];

return sum;

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Enter Array Size : ");

int size = [Link]();

 int arr[] = [Link](size);

if(techNumber(sumOfArray(size, arr))) {

[Link]("The sum of the given Array Elements " + [Link](arr) + " is " + sumOfArray(size, arr) + " a Tech Number");

} else {

[Link]("The product of the given Array Elements " + [Link](arr) + " is " + sumOfArray(size, arr) + " not a Tech Number");

[Link]();

package array_programming;

import [Link];

import [Link];

public class SumTwistedPrime {

public static int factorCount(int n) {

int count = 0;

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

if(n % i == 0) {

count++;

return count;

public static boolean isPrime(int n) {

int count = factorCount(n);

return count == 2;

}
 public static int reverseNumber(int n) {

int rev = 0;

while(n > 0) {

int digit = n % 10;

rev = rev * 10 + digit;

n /= 10;

return rev;

public static boolean twistedPrimeNumber(int n) {

return isPrime(n) && isPrime(reverseNumber(n));

public static int sumOfArray(int size, int arr[]) {

int sum = 0;

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

sum += arr[i];

return sum;

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Enter Array Size : ");

int size = [Link]();

int arr[] = [Link](size);

if(twistedPrimeNumber(sumOfArray(size, arr))) {

[Link]("The sum of the given Array Elements " + [Link](arr) + " is " + sumOfArray(size, arr) + " a Twisted Prime");

} else {

[Link]("The product of the given Array Elements " + [Link](arr) + " is " + sumOfArray(size, arr) + " not a Twisted Prime");

[Link]();

}
package array_programming;

import [Link];

import [Link];

public class Z_Project_1 {

public static int[] leftRotation(int arr[]) {

int temp = arr[0];

for (int i = 0; i < [Link] - 1; i++) {

arr[i] = arr[i + 1];

arr[[Link] - 1] = temp;

return arr;

public static int[] rightRotation(int arr[]) {

int temp = arr[[Link] - 1];

 for (int i = [Link] - 1; i > 0; i--) {

arr[i] = arr[i - 1];

arr[0] = temp;

return arr;

public static int[] leftOrRight(int rotationType, int arr[], int no_of_rotations) {

while (no_of_rotations > 0) {

if (rotationType == 1) {

leftRotation(arr);

} else {

rightRotation(arr);

no_of_rotations--;

return arr;

public static boolean yesOrNo(String s) {

return [Link]("yes");

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

while (true) {

[Link]("Enter Array Size: ");

int size = [Link]();

int arr[] = [Link](size);

[Link]("Enter 1 for Left Rotation or 2 for Right Rotation: ");

int rotationType = [Link]();

while (rotationType != 1 && rotationType != 2) {

[Link]("Enter 1 for Left Rotation or 2 for Right Rotation: ");

rotationType = [Link]();

if (rotationType != 1 && rotationType != 2) {

[Link]("Invalid choice. Please enter only 1 or 2.");

[Link]("Enter number of rotations to be performed: ");

int no_of_rotations = [Link]();

if(rotationType == 1) {

[Link]("Array after " + no_of_rotations + " left rotation: " + [Link](leftOrRight(rotationType, arr, no_of_rotations)));
 } else {

[Link]("Array after " + no_of_rotations + " right rotation: " + [Link](leftOrRight(rotationType, arr, no_of_rotations)));

[Link]("Do you want to continue? Enter yes or no:");

String yes_or_no = [Link]();

if (!yesOrNo(yes_or_no)) {

[Link]("The End...!");

break;