package kursovrchernyak;

public class Main {


        public static void main(String[] args) {

                application1(MyPoint.newArray(4), MyPoint.newArray(5));
                application2(MyPoint.newSortedArray(3), MyPoint.newSortedArray(2));
                application3(MyPoint.newSortedArray(5), MyPoint.newSortedArray(8));
                application4(MyPoint.newArray(5), new MyPoint());

        }


        /** Приложение 1.
         * Даны два массива точек p1: array[0..k] и p2: array[0..l].
         * Координаты точек заданы вручную.
         *
         * Найти количество общих элементов в этих массивах,
         * то есть количество тех целых t, для которых
         * {p1[i].x = p2[j].x и p1[i].y = p2[j].y} для некоторых i и j.
         * т.е. найти количество точек с одинаковыми координатами.
         * @param k - кол-во элементов в массиве p1
         * @param l - кол-во элементов в массиве p2
         */

        static int application1(MyPoint[] p1, MyPoint[] p2) {

                int n = 0;
                for(int i=0; i < p1.length; i++) {
                        for(int j=0; j < p2.length; j++) {
                                if (p1[i].isEqual(p2[j])) {
                                        n++;
                                }
                        }
                }
                System.out.println("Equal points total: " + n);
                return n;
        }


        /** Приложение 2.
         * @param k - кол-во элементов в массиве p1
         * @param l - кол-во элементов в массиве p2
         *
         * Даны два массива точек p1: array[0..k] и p2: array[0..l]. Причем:
         *      p1[1].getX()<=..<=p1[k].getX()
         *      p1[1].getY()<=..<=p1[k].getY()
         *      p2[1].getX()<=..<=p2[j].getX()
         *      p2[1].getY()<=..<=p2[j].getY()
         * и
         *      p1[n].getX() = p1[n].getY()
         *      p2[q].getX() = p2[q].getY()
         * "Соединить" их в массив p3, причем:
         *      p3[1].getX()<=..<=p3[m].getX()
         *      p3[1].getY()<=..<=p3[m].getY()
         * (m = k+l; каждый элемент массива должен входить в массив p3 столько раз,
         * сколько он входит в общий сложности в массивы p1 и p2)
         */

        static MyPoint[] application2(MyPoint[] p1, MyPoint[] p2) {
                MyPoint[] p3 = new MyPoint[p1.length + p2.length];
                int i=0, j=0, m=0;
                for (; m < p3.length; m++) {
                        if (j >= p2.length) {
                                p3[m] = p1[i++];
                        } else if (i >= p1.length) {
                                p3[m] = p2[j++];
                        } else if (p1[i].getX() < p2[j].getX()) {
                                p3[m] = p1[i++];
                        } else {
                                p3[m] = p2[j++];
                        }
                }
                return p3;
        }



        /** Приложение 3.
         * Даны два массива точек p1: array[0..k] и p2: array[0..l]. Причем:
         *      p1[1].getX()<=..<=p1[k].getX()
         *      p1[1].getY()<=..<=p1[k].getY()
         *      p2[1].getX()<=..<=p2[j].getX()
         *      p2[1].getY()<=..<=p2[j].getY()
         * и
         *      p1[n].getX() = p1[n].getY()
         *      p2[q].getX() = p2[q].getY()
         *
         * Найти их "пересечение", то есть массив p3[1]<=...<=p3[m], содержащий
         * их общие элементы, причем кратность каждого элемента в массиве p3
         * равняется минимуму из его кратностей в массивах p1 и p2.
         */

        static MyPoint[] application3(MyPoint[] p1, MyPoint[] p2) {
                MyPoint[] arr = new MyPoint[Math.min(p1.length, p2.length)];

                int i=0, j=0, k=0;
                for(; i < p1.length; i++) {
                        for(; j < p2.length; j++) {
                                if(p1[i].getX() < p2[j].getX())
                                        break;  // stop seek on p2[] - next elemets will be greater.

                                if (p1[i].isEqual(p2[j])) {     // Main operation here:
                                        arr[k++] = p1[i];
                                }
                        }
                        if(p1[i].getX() > p2[j].getX())
                                break;  // stop seek on p1
                }
                return trim(arr,k);     /// trim array to length k
        }


        static MyPoint[] trim(MyPoint[] arr, int len) {
                if (len > arr.length) return arr;
                MyPoint[] newArr = new MyPoint[len];
                for (int i=0; i < len; i++) {
                        newArr[i] = arr [i];
                }
                return newArr;
        }


        /** Приложение 4.
         * Дан массив точек a[1..n] и число точка b.
         * Переставить точки в массиве таким образом, чтобы слева от некоторой
         * границы стояли точки, меньшие по Х или равные b.getX(), а справа от
         * границы большие по X или равные b.getX().
         */

        static int application4(MyPoint[] a, MyPoint b) {

                int head=0, tail=a.length-1;
                while(head < tail) {
                        if ( a[head].getX() <= b.getX() ) {
                                // Nothing to do: skip to next element at head.
                                head++;
                        } else {
                                // Swap points a[head] and a[tail]
                                MyPoint tmp = a[tail];
                                a[tail] = a[head];
                                a[head] = tmp;

                                tail--; // and then decrement tail
                        }
                }
                System.out.println("Array: " + a);
                System.out.println("Point: " + head);
                return head;
        }
}