public class Main {

    public static void show(int value) {
        System.out.println("Podana wartosc: " + value);
    }

    public static void modifyValue(int value) {
        System.out.println("Dostarczona zmienna: " + value);
        value = value * 5;
        System.out.println("Zmienna zmodyfikowana: " + value);
    }

    public static void charCount(char[] array) {
        char sign = 'A';
        for (int i = 0; i < 52; i++) {
            if (i == 26)
                sign = 'a';
            int count = 0;
            for (int j = 0; j < array.length; j++) {
                if (array[j] == sign)
                    count++;
            }
            if (count > 0)
                System.out.print(sign + " : " + count + "  ");
            sign++;
        }
        System.out.println();
    }

    public static void fillRandom(int[] array) {
        for (int i = 0; i < array.length; i++) {
            array[i] = (int) (Math.random() * 100);
        }
    }

    public static int[] arrayStatement(int[] array1, int[] array2, int argument) {
        if (array1.length == array2.length) {
            int[] emptyArray = new int[1];
            return emptyArray;
        } else if (argument < 0) {
            int[] arraysSum;
            if (array1.length > array2.length)
                arraysSum = new int[array2.length];
            else
                arraysSum = new int[array1.length];
            for (int i = 0; i < arraysSum.length; i++) {
                arraysSum[i] = array1[i] + array2[i];
            }
            return arraysSum;
        } else {
            int[] arrayNoCouple;
            if (array1.length > array2.length) {
                int index = array2.length;
                arrayNoCouple = new int[array1.length - array2.length];
                for (int i = 0; i < arrayNoCouple.length; i++) {
                    arrayNoCouple[i] = array1[index++];
                }
            } else {
                int index = array1.length;
                arrayNoCouple = new int[array2.length - array1.length];
                for (int i = 0; i < arrayNoCouple.length; i++) {
                    arrayNoCouple[i] = array2[index++];
                }
            }
            return arrayNoCouple;
        }
    }

    public static boolean palindrom(char[] array, int valueZero, int arrayLengthWithoutOne) {
        while (valueZero < arrayLengthWithoutOne) {
            if (array[valueZero++] == array[arrayLengthWithoutOne--]) {
                palindrom(array, valueZero, arrayLengthWithoutOne);
            } else
                return false;
        }
        return true;
    }

    public static boolean oneUpReducedArea(int[][] array) {
        boolean oneUp = false;
        boolean statementBreak = false;
        for (int i = 0, l = 1; i < array.length - 1; i++, l++) {
            for (int j = 0; j < array[i].length - l; j++) {
                if (i == array.length - 2 && j == 0 && array[i][j] == 1) {
                    oneUp = true;
                } else if (array[i][j] == 0) {
                    statementBreak = true;
                }
                if (statementBreak) break;
            }
            if (statementBreak) break;
        }
        if (!oneUp) {
            statementBreak = false;
            for (int i = 0, l = 1; i < array.length - 1; i++, l++) {
                for (int j = l; j < array[i].length; j++) {
                    if (i == array.length - 2 && j == array[i].length - 1 && array[i][j] == 1) {
                        oneUp = true;
                    } else if (array[i][j] == 0) {
                        statementBreak = true;
                    }
                    if (statementBreak) break;
                }
                if (statementBreak) break;
            }
        }

        return oneUp;
    }

    public static boolean zeroDownReducedArea(int[][] array) {
        boolean zeroDown = false;
        boolean statementBreak = false;
        for (int i = array.length - 1, l = 0; i > 0; i--, l++) {
            for (int j = array[i].length - 1; j > l; j--) {
                if (i == 1 && j == array[i].length - 1 && array[i][j] == 0) {
                    zeroDown = true;
                } else if (array[i][j] == 1) {
                    statementBreak = true;
                }
                if (statementBreak) break;
            }
            if (statementBreak) break;
        }
        if (!zeroDown) {
            statementBreak = false;
            for (int i = 1, l = 1; i < array.length; i++, l++) {
                for (int j = 0; j <= l; j++) {
                    if (i == array.length - 1 && j == array[i].length - 1 && array[i][j] == 0) {
                        zeroDown = true;
                    } else if (array[i][j] == 1) {
                        statementBreak = true;
                    }
                    if (statementBreak) break;
                }
                if (statementBreak) break;
            }
        }
        return zeroDown;
    }

    public static void oneUpZeroDownArea(int[][] array, int columns, int rows) {
        boolean onlyOne = false;
        if (columns >= 2 && rows >= 2) {
            int[][] reducedArray = new int[columns][rows];
            boolean oneUp = false, zeroDown = false;
            for (int i = 0; i <= array.length - columns; i++) {
                for (int j = 0; j <= array[i].length - columns; j++) {
                    for (int k = i, a = 0; k < i + columns; k++, a++) {
                        for (int l = j, b = 0; l < j + columns; l++, b++) {
                            reducedArray[a][b] = array[k][l];
                        }
                    }
                    oneUp = oneUpReducedArea(reducedArray);
                    zeroDown = zeroDownReducedArea(reducedArray);
                    if (oneUp && zeroDown) {
                        System.out.println("Początek pierwszego największego pasującego obszaru. Wielkosc: " + columns + "X" + rows + " kolumna: " + i + " wiersz: " + j + " (liczone od 0)");
                        display(reducedArray);
                        onlyOne = true;
                    }
                    if (onlyOne) break;
                }
                if (onlyOne) break;
            }
            if (!oneUp || !zeroDown) {
                columns -= 2;
                rows -= 2;
                oneUpZeroDownArea(array, columns, rows);
            }
        }
    }

    public static void display(int[][] array) {
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j] + " ");
            }
            System.out.println();
        }
    }

    public static void fillRow(int[][] array, int row, int val) {
        for (int i = 0; i < array[row].length; i++) {
            array[row][i] = val;
        }
    }

    public static void fillCol(int[][] array, int col, int val) {
        for (int i = 0; i < array.length; i++) {
            array[i][col] = val;
        }
    }

    public static void fillRowInRange(int[][] array, int row, int from, int to, int val) {
        for (int i = from; i <= to; i++) {
            array[row][i] = val;
        }
    }

    public static void fillColInRange(int[][] array, int col, int from, int to, int val) {
        for (int i = from; i <= to; i++) {
            array[i][col] = val;
        }
    }


    public static void main(String[] args) {

/*        //ZADANIE1
        int value1 = 1;
        show(value1);

        //ZADANIE2
        int wrt = 5;
        System.out.println(wrt);
        modifyValue(wrt);
        System.out.println(wrt);

        //ZADANIE3
        char[] inscription = {'A','l','a','m','a','k','o','t','a'};
        charCount(inscription);

        //ZADANIE4
        int[] array1 = new int[10];
        int[] array2 = new int[15];
        fillRandom(array1);
        fillRandom(array2);
        int[] myArray = arrayStatement(array1,array2,1);
        for (int i = 0; i < myArray.length; i++) {
            System.out.print(myArray[i] + " ");
        }
        System.out.println();

        //ZADANIE5
        char[] palindrom = {'k','a','j','a','k'};
        int valueZero = 0;
        int arrayLe = palindrom.length-1;
        boolean palindromY = palindrom(palindrom, valueZero , arrayLe);
        System.out.println(palindromY);*/

        //ZADANIE6
        int[][] intArray = new int[25][25];
        for (int i = 0; i < intArray.length; i++) {
            for (int j = 0; j < intArray[i].length; j++) {
                intArray[i][j] = (int) (Math.random() * 2);
            }
        }
        display(intArray);
        System.out.println();
        oneUpZeroDownArea(intArray, intArray.length, intArray.length);

       //ZADANIE7
        int[][] spiral = new int[15][15];
        for (int i = 0, j = spiral.length - 1; i < spiral.length; i++, j--) {
            if (i == 0) {
                fillCol(spiral, 0, 1);
                fillCol(spiral, spiral[i].length - 1, 1);
                fillRow(spiral, j, 1);
                fillRowInRange(spiral, i, i + 2, spiral[i].length - 1, 1);
            }
            if (i % 2 == 0 && i != 0 && i < spiral.length / 2) {
                fillColInRange(spiral, i, i - 2, j, 1);
                fillRowInRange(spiral, i, i + 2, j, 1);
            }
            if (spiral.length % 2 == 0) {
                if (j % 2 != 0 && j != spiral.length - 1 && j > (spiral.length / 2) - 2) {
                    fillRowInRange(spiral, j, i + 1, j, 1);
                    fillColInRange(spiral, j, i + 1, j, 1);
                }
            }
            else if (spiral.length % 2 != 0) {
                if (j % 2 != 0 && j != spiral.length - 1 && j > (spiral.length / 2) - 2) {
                    fillRowInRange(spiral, j-1, i + 1, j-1, 1);
                    fillColInRange(spiral, j-1, i + 1, j-1, 1);
                }
            }
        }

        display(spiral);

    }
}