Массивы

import java.util.Random;


//Массивы и всякое с ними связанное


public class Main {

    public static void main(String[] args) {
        int []ar = new int [10];
        System.out.println("At the start");
        printList(ar);
        System.out.println("Fill array");
        fillArray(ar, -10, 10);
        printList(ar);

        Shift(ar, 10);
        System.out.println("Shift");
        printList(ar);

        int [] rr = TwoMinIndex(ar);
        System.out.println("Min1 = " + ar[rr[0]] + "(" + rr[0] + ")");
        System.out.println("Min2 = " + ar[rr[1]] + "(" + rr[1] + ")");


        int [] some = {1, 3, 5, 0, 8, 2, -5, -1, -4, 1};
//      if(isUnique(some)) {
//          System.out.println("There aren't duplication");
//          printList(some);
//      }
        System.out.println("Before");
        printList(some);
        System.out.println("Agregatic order");
        AgregatikOrder(some);
        printList(some);
//      SwapMinMax(ar, 0);
//      System.out.println("Swap Min and max");
//      printList(ar);


//      int [] res = deleteDuplicates(ar);
//      System.out.println("DeleteDuplicates");
//      printList(res);

//      System.out.println("Reverse betveen 1");
//      ReverseBetween(ar, 1);
//      printList(ar);
//      System.out.println("Selection sort");
//      SelectionSort(ar);
//      printList(ar);
//      midSwap(ar);
//      System.out.println("Mid Swap");
//      printList(ar);
//      System.out.println("MinMaxRevers");
//      int min = MinIndex(ar);
//      System.out.println("Min = " + ar[min] + "(" + min + ")");
//      int max = MaxIndex(ar);
//      System.out.println("Min = " + ar[max] + "(" + max + ")");
//      MinMaxRevers(ar);
//      printList(ar);
//
        System.out.println("-------------------------");
        int len = 50;
        char []ChAr = new char [len];
        System.out.println("At the start");
        printList(ChAr);
        fillCharArray(ChAr);
        System.out.println("Filling array");
        printList(ChAr);
        char x = getRandomAlphaNum();
        frequency(ChAr, x);
        System.out.println("\nAfter all 'a' puts '!='");
        printArrayWith(ChAr, 'a', "!=");

        Shift(ChAr, -10);
        System.out.println("\nShift");
        printList(ChAr);


    }


//ПРОСТЕ ЧИСЛО
    public static boolean Prime(int val) {
        if(val <= 1) return false;
        boolean isPrime = true;
        for(int i = 2; i <= Math.sqrt(val) && isPrime; i++) {
            if(val % i == 0) isPrime = false;
        }
        return isPrime;
    }



//Вывод
        private static void printList(int [] array) {
            if(array.length == 0) {
                System.out.println("Your Array is empty.");
            }else {
                for(int i = 0; i < array.length; i++) {
                    System.out.printf(array[i] + "   ");
                }
            }
            System.out.println("");
        }


// Заполнение массива
// if from == to == X, array will be filled by X
        private static void fillArray(int [] array, int from, int to) {
            if(to < from) {
                int tmp = to;
                to = from;
                from = tmp;
            }
            Random rand = new Random();
            for (int i = 0; i < array.length; i++) {
                array[i] = rand.nextInt(to - from + 1) + from;
            }
        }

//Two Sum
        public static int[] twoSum(int[] nums, int target) {
            for (int i = 0; i < nums.length; i++) {
                for (int j = i + 1; j < nums.length; j++) {
                    if (nums[j] == target - nums[i]) {
                        return new int[] { i, j };
                    }
                }
            }
            throw new IllegalArgumentException("No two sum solution");
        }

//Pivot index
        public int pivotIndex(int[] nums) {
            int right = 0;
            int left = 0;
            for(int i = 0; i < nums.length; i++){
                right += nums[i];
            }
            for(int i = 0; i < nums.length; i++){
                if(i != 0){
                    left += nums[i-1];
                }
                right -= nums[i];
                if(right == left){
                    return i;
                }
            }
            return -1;
        }

//Затирание элемента
        public static void rub(int [] ar, int i)  {
            while(i < ar.length - 1) {
                ar[i] = ar[i+1];
                i++;
            }
        }

//удаление повторок
        public static int [] deleteDuplicates(int [] ar) {
            SelectionSort(ar);
            int len = ar.length;
            for(int i = 0; i < len; i++) {
                if(ar[i] == ar[i + 1]) {
                    rub(ar, i);
                    len--;
                    i--;
                }
            }
            int [] res = new int[len];
            for(int i = 0; i < len; i++) {
                res[i] = ar[i];
            }
            return res;
        }

//Сортировка Выборкой
        public static void SelectionSort(int [] ar) {

            int tmp = 0;
            // sorting
            for (int i = 0; i < ar.length - 1; i++) {
                int minIndex = i;
                for (int j = i + 1; j < ar.length; j++) {
                    if (ar[j] < ar[minIndex]) {
                        minIndex = j;
                    }
                }
                if (i != minIndex) {
                    tmp = ar[i];
                    ar[i] = ar[minIndex];
                    ar[minIndex] = tmp;
                }
            }
        }

//Сортировка Вставкой
        public static void InsertionSort (int [] ar) {

            for (int i = 1; i < ar.length; i++) {
                int j = i - 1;
                int key = ar[i];
                while (j >= 0 && ar[j] > key) {
                    ar[j + 1] = ar[j];
                    j--;
                }
                ar[j + 1] = key;
            }
        }

// Реверс отврезка массива
        public static void SwapInInterval(int ar[], int from, int to) {
            if(to < from) {
                int tmp = to;
                to = from;
                from = tmp;
            }
            for (; from < to; from++, to--) {
                int tmp = ar[to];
                ar[to] = ar[from];
                ar[from] = tmp;
            }
        }

//Поиск двух минов
        public static int[] TwoMinIndex(int ar[]) {
            int min1 = 0;
            for(int i = 0; i < ar.length; i++) {
                if(ar[min1] > ar[i]) min1 = i;
            }
            int min2 = 0;
            for(int i = 0; i < ar.length; i++) {
                if(ar[min2] > ar[i] && i != min1) min2 = i;
            }
            int [] res = {min1, min2};
            return res;
        }

//Поиск индексов мина и макса
        public static int MinIndex(int ar[]) {
            int min = 0;
            for(int i = 0; i < ar.length; i++) {
                if(ar[min] > ar[i]) min = i;
            }
            return min;
        }
        public static int MaxIndex(int ar[]) {
            int max = 0;
            for(int i = 0; i < ar.length; i++) {
                if(ar[max] < ar[i]) max = i;
            }
            return max;
        }

//Реверс от мина до макса
        public static void MinMaxRevers(int ar[]) {
            SwapInInterval(ar, MinIndex(ar), MaxIndex(ar));
        }

// Поменять местами половины массива
            public static void midSwap(int ar[]) {
                int len = ar.length;
                int mid = len / 2;
                if(len % 2 == 1) mid++;
                for (int i = 0; mid < len; i++, mid++) {
                    int tmp = ar[mid];
                    ar[mid] = ar[i];
                    ar[i] = tmp;
                }
            }

// Сдвиг массива на 1 вправо-влево
            public static void ShiftLeft(int ar[]) {
                int tmp = ar[0];
                for(int i = 1; i < ar.length; i++) {
                    ar[i-1] = ar[i];
                }
                ar[ar.length - 1] = tmp;
            }

            public static void ShiftRight(int ar[]) {
                int tmp = ar[ar.length - 1];
                for(int i = ar.length - 2; i >= 0; i--) {
                    ar[i + 1] = ar[i];
                }
                ar[0] = tmp;
            }

//Сдвиг на число Х
            public static void Shift(int ar[], int X) {
                X = X % ar.length;
                if(X > 0) {
                    for(int i = 0; i < X; i++) {
                        ShiftRight(ar);
                    }
                }
                else {
                    for(int i = -1; i >= X; i--)
                        ShiftLeft(ar);
                }
            }

//Все ли элементы уникальны
            public static boolean isUnique(int ar[]) {
                boolean res = true;
                InsertionSort(ar);
                for(int i = 0; i < ar.length - 1; i++) {
                    if(ar[i] == ar[i + 1])
                        res = false;
                }
                return res;
            }

//Бинарный поиск первого вхождения
            public static int binFirst(int ar[], int x) {
                int l = 0;
                int h = ar.length - 1;
                while(h >= l) {
                    int mid = (l + h)/2;
                    if((mid == 0 || x > ar[mid-1]) && ar[mid] == x)
                        return mid;
                    else if (x > ar[mid])
                        l = mid + 1;
                    else
                        h = mid - 1;
                }
                return -1;
            }

// Найти количество вхождений через бинарку
            public static int frequency(int ar[], int x) {
                //Sort
                SelectionSort(ar);
                //Search
                int firstIndex = binFirst(ar, x);
                //Counting
                int count = 0;
                if(firstIndex != -1) {
                    // If firstIndex == ar.length, we will go beyond the array
                    while(firstIndex != ar.length && ar[firstIndex] == x) {
                        count++;
                        firstIndex++;
                    }
                }
                // Visual check
                System.out.println("In this array");
                printList(ar);
                System.out.printf("Number \"" + x + "\" is repeated " + count + " times");
                return count;
            }


//Реверс между первым и последним вхождением Х

            private static void ReverseBetween(int [] array, int X) {
                int first = 0;
                int last = array.length - 1;
                while(array[first] != X && first < last)
                    first++;
                while(array[last] != X && first < last)
                    last--;
                SwapInInterval(array, first, last);
            }


//Переместить все отрицательные и 0 в начало
            public static void AgregatikOrder(int [] ar) {

                int tmp = 0;
                for (int i = 1; i < ar.length; i++) {
                    if(ar[i] <= 0) {
                        int j = i - 1;
                        tmp = ar[i];
                        while (j >= 0 && ar[j] > 0) {
                            ar[j + 1] = ar[j];
                            j--;
                        }
                        ar[j + 1] = tmp;
                    }

                }
            }

//Свап мина и макса , меньших какого-то числа

//Их поиск
            public static int MinIndex(int ar[], int x) {
                int min = -1;
                for(int i = 0; i < ar.length; i++) {
                    if(ar[i] < x) {
                        if(min == -1) min = i;
                        else if(ar[min] > ar[i]) min = i;
                    }
                }
                return min;
            }
            public static int MaxIndex(int ar[], int x) {
                int max = -1;
                for(int i = 0; i < ar.length; i++) {
                    if(ar[i] < x) {
                        if(max == -1) max = i;
                        else if(ar[max] < ar[i]) max = i;
                    }
                }
                return max;
            }
// Их свап
            private static void SwapMinMax(int [] array, int X) {
                int min = MinIndex(array, X);
                int max = MaxIndex(array, X);
                int tmp = array[min];
                array[min] = array[max];
                array[max] = tmp;
            }




//---------------------------------------------------------
//                   CHAR's function
//---------------------------------------------------------





        private static void fillCharArray(char [] array) {
            for (int i = 0; i <  array.length; i++) {
                array[i] = getRandomAlphaNum();
            }
        }

        private static char getRandomAlphaNum() {
            char [] symbols = {'0','1','2','3','4','5','6','7','8','9',
                    'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q',
                    'r','s','t','u','v','w','x','y','z', 'A','B','C','D','E','F','G','H','I',
                    'J','K','L','M','N','O','P','Q',
                    'R','S','T','U','V','W','X','Y','Z'};
            Random r = new Random();
            return symbols[r.nextInt(62)];
        }

        private static void printList(char [] array) {
            if(array.length == 0) {
                System.out.println("Your Array is empty.");
            }else {
                for(int i = 0; i <  array.length; i++) {
                    System.out.printf(array[i] + " ");
                }
            }
            System.out.println("");
        }


        public static void SelectionSort(char [] ar) {

            char tmp = 0;
            // sorting
            for (int i = 0; i < ar.length - 1; i++) {
                int minIndex = i;
                for (int j = i + 1; j < ar.length; j++) {
                    if (ar[j] < ar[minIndex]) {
                        minIndex = j;
                    }
                }
                if (i != minIndex) {
                    tmp = ar[i];
                    ar[i] = ar[minIndex];
                    ar[minIndex] = tmp;
                }
            }
        }

        public static int binFirst(char ar[], char x) {
            int l = 0;
            int h = ar.length - 1;
            while(h >= l) {
                int mid = (l + h)/2;
                if((mid == 0 || x > ar[mid-1]) && ar[mid] == x)
                    return mid;
                else if (x > ar[mid])
                    l = mid + 1;
                else
                    h = mid - 1;
            }
            return -1;
        }

        // Найти количество вхождений через бинарку
        public static int frequency(char ar[], char x) {
            //Sort
            SelectionSort(ar);
            //Search
            int firstIndex = binFirst(ar, x);
            //Counting
            int count = 0;
            if(firstIndex != -1) {
                // If firstIndex == ar.length, we will go beyond the array
                while(firstIndex != ar.length && ar[firstIndex] == x) {
                    count++;
                    firstIndex++;
                }
            }
            // Visual check
            System.out.println("In this array");
            printList(ar);
            System.out.printf("Symbol \"" + x + "\" is repeated " + count + " times");

            return count;
        }

// Добавить после каждого символа х "!" и "=" при выводе массива
        public static void printArrayWith(char ar[], char x, String y) {
            for(int i = 0; i < ar.length; i++) {
                System.out.printf("" + ar[i]);
                if(ar[i] == x) System.out.printf(y);
            }
        }

// Сдвиг массива на 1 вправо-влево
                    public static void ShiftLeft(char ar[]) {
                        char tmp = ar[0];
                        for(int i = 1; i < ar.length; i++) {
                            ar[i-1] = ar[i];
                        }
                        ar[ar.length - 1] = tmp;
                    }

                    public static void ShiftRight(char ar[]) {
                        char tmp = ar[ar.length - 1];
                        for(int i = ar.length - 2; i >= 0; i--) {
                            ar[i + 1] = ar[i];
                        }
                        ar[0] = tmp;
                    }

//Сдвиг на число Х
                    public static void Shift(char ar[], int X) {
                        X = X % ar.length;
                        if(X > 0) {
                            for(int i = 0; i < X; i++) {
                                ShiftRight(ar);
                            }
                        }
                        else {
                            for(int i = -1; i >= X; i--)
                                ShiftLeft(ar);
                        }
                    }

}