Methods_new.java

Methods_new.java

class TaskMethods {
    public static void main(String[] args) {
        printCharArray(new char[] {'X', 'Y', 'Z'});

        char[] intArrayToCharArray = intArrayToCharArray(new int[] {68, 69, 70});
        printCharArray(intArrayToCharArray);

        System.out.println(getBiggerOfTwoNumbers(14, 49));

        System.out.println(getBiggerOfThreeNumbers(45, -4, 46));

        System.out.println(getBiggerOfFiveNimbers(56, -2, 4581, 18, 47));

        System.out.println(stringFromCharArray(new char [] {'A', 'B', 'C'}));

        System.out.println(findIndexFromBegin(new int[] {10, 20, 30}, 10));

        System.out.println(findIndexFromBegin(new int[] {0, 20, 10, 30}, 10));

        System.out.println(factorial(8));

        System.out.println(isLeapYear(2020));

        printMultiplesValue(new int[] {10, 20, 30, 40, 32, 45, 66,}, 10);
        System.out.println();

        int [] arrayUnsort = new int[] {44, 10, 1, 28, 90, 1000, 21, 9999, 100000};
        int [] arraySort = bubbleSort(arrayUnsort);
        printIntArray(arraySort);

        System.out.println(arrayDuplicates(new byte[] {10, 20, 30, 10}));

        int[] arrayMultiplied = multiepiedArrays(new int[] {10, 20, 30}, new int[] {10, 20, 30});
        printIntArray(arrayMultiplied); 

        int[] testArray11 = new int[]{0, 2, 3, 4, 5};
        int[] testArray12 = new int[]{1, 2, 3, 4, 9};
        for (int element : notMatchedElements(testArray11, testArray12)) {
        System.out.print(element + " ");
    }
        System.out.println();

        
        int[] arrayNotReversed = new int[] {10, 20, 30};
        int[] arrayReversed = reverseArray(arrayNotReversed);
        printIntArray(arrayReversed);

        int[] arrayNotCreated;
        int[] arrayCreateRandom = randomArray(10, 1, 10);
        printIntArray(arrayCreateRandom);
    }

    //1) принимает массив чаров, выводит его на экран
    static void printCharArray(char [] array) {
        for(int i = 0; i < array.length; i++) {
            System.out.print(array[i]+ " ");
        }
        System.out.println();
    }
    static void printIntArray(int [] array) {
        for(int i = 0; i < array.length; i++) {
            System.out.print(array[i]+ " ");
        }
        System.out.println();
    }
    //2) принимает массив интов, возвращает массив чаров, каждый символ в позиции массива соответствует коду символа передаваемого инта
    static char[] intArrayToCharArray(int[] array) {
        char[] arrayResult = new char[array.length];
        for(int i = 0; i < array.length; i++) {
            arrayResult[i] = (char) array[i];
        }
        return arrayResult;
    }

    //3) приминает 2 инта, а и б, возвращает большее их этих 2х чисел
    static int getBiggerOfTwoNumbers(int a, int b) {
        if(a > b) {
            return a;
        } else {
            return b;
        }
    }

    //4) принимает 3 инта, возвращает большее из них
    static int getBiggerOfThreeNumbers(int a, int b, int c) {
        if(a > b && a > c) {
            return a;
        } else if(b > a && b > c) {
            return b;
        } else {
            return c;
        }
    }
    //5) приминает 5 интов, возвращает большее из них
    static int getBiggerOfFiveNimbers(int a, int b, int c, int d, int e) {
        int max = a;
        if(b > a) {
            return b;
        } else if(c > a) {
            return c;
        } else if(d > a) {
            return d;
        } else if(e > a) {
            return e;
        }
        return max;
    }
    //6) принимает массив чаров, возвращает строку состоящую из символов массива
    static String stringFromCharArray(char[] array) {
        String result = "";
        for(int i = 0; i < array.length; i++) {
            result += array[i];
        }
        return result;
    }
    
    //8) принимает массив интов, и значение типа инт, возвращает индекс массива в котором значение совпадает с передаваемым, начиная с начала массива. Если значения в массиве нет возвращает -1
    static int findIndexFromBegin(int [] array, int a) {
        int index = -1;
        for(int i = 0; i < array.length; i++) {
            if(array[i] == a) {
                return index = i;
            }
        }
        return index;
    }
    //9) принимает массив интов, и значение типа инт, возвращает индекс массива в котором значение совпадает с передаваемым, начиная с конца массива. Если значения в массиве нет возвращает -1
    static int findIndexFromEnd(int[] array, int a) {
        int index = -1;
        for(int i = array.length - 1; i >= 0; i --) {
            if(array[i] == a) {
                index = i;
            }
        }
        return index;   
    }
    //10) метод принимает инт, и возвращает факториал от заданого инта
    static long factorial(int number) {
        long result = 1L;
        for(int i = 1; i <= number; i++) {
            result *= (long) i;
        }
        return result;
    }
    //11) принимает инт год, и возвращает тру если год высокосный
    static boolean isLeapYear(int year) {
        if(year % 4 != 0 || (year % 100 == 0 && year % 400 != 0)) {
            return false;
        } else {
            return true;
        }
    }
    //12) приминает массив интов и число, выводит на екран только елементы массива которые кратны этому числу
    static void printMultiplesValue(int[] array, int number) {
        for(int i = 0; i < array.length; i++) {
            if(array[i] % number == 0) {
                System.out.print(array[i] + " ");
            }
        }
    }
    //13) метод принимает массив интов сортирует его по возрастанию
    static int[] bubbleSort(int[] array) {
        for(int i = 0; i < array.length; i ++) {
            for(int j = 0; j < array.length - 1; j++) {
                if(array[j] > array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }   
        }
        return array;
    }
    //14) принимает массив байт, если в массиве есть повторяющиеся елементы, возвращает тру
    static boolean arrayDuplicates(byte[] array) {
        boolean flag = false;
        for(int i = 0; i < array.length; i++) {
            for(int j = 0; j < array.length; j++) {
                if(i == j) {
                    continue;
                } else if(array[i] == array[j]) {
                    flag = true;
                }
            }
        }
        return flag;
    }
    //15) принимает два массива интов одинаковых по длинне, возращает массив интов который состоит из перемноженных елементов входящих массивов
    static int[] multiepiedArrays(int[] array1, int[] array2) {
        int[] result = new int[array1.length];
        for(int i = 0; i < array1.length; i++) {
            result[i] = array1[i] * array2[i]; 
        }
        return result;
    }
    //16) принимает два массива интов, возвращает массив из елементов которые не совпадают в массивах
static int[] notMatchedElements(int[] one, int[] two) {
   int count = 0;
   int [] temporary = new int[one.length + two.length];
   for (int i = 0; i < one.length; i++) {
       boolean isUnique = true;
       for (int j = 0; j < two.length; j++) {
           if (one[i] == two[j]) {
               isUnique = false;
               break;
           }
       }
       if(isUnique){
           temporary[count] = one[i];
           count++;
       }
   }
   for (int k = 0; k < two.length; k++) {
       boolean isUnique = true;
       for (int u = 0; u < one.length; u++) {
           if (two[k] == one[u]) {
               isUnique = false;
               break;
           }
       }
       if(isUnique){
           temporary[count] = two[k];
           count++;
       }
   }

   int[] result = new int[count];

   for(int i = 0; i < temporary.length; i++) {
       if(temporary[i] != 0) {
           result[i] = temporary[i];
       }
   }
   return result;
}
    //17) принимает масив интов, возвращает его же но в реверсном порядке
    static int[] reverseArray(int[] array) {
        int[] arrayResult = new int[array.length];
        for(int i = 0; i < array.length / 2; i++) {
            int temp = array[array.length - i - 1];
            array[array.length - i - 1] = array[i];
            array[i] = temp; 
        }
        for(int numbers : array) {
            System.out.print(numbers + " ");
        }
        System.out.println();
        return array;
    }
    //18) принимает 3 инта:
    //- размер выходного массива
    //- нижняя граница
    //- верхняя граница
    //возвращает массив интов заданой длинный, который содержит случайные числа от нижней границы до верхней границы"
    static int[] randomArray(int size, int min, int max) {
        int[] array = new int[size];
        int delta = max - min;
        for(int i = 0; i < size; i++) {
            double random = Math.random();
            array[i] = (int) (random * delta + min);
        }
        return array;
    }
}