HackerRankPro

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.List;

import static javafx.scene.input.KeyCode.F;

public class HackerRankPro {
    public static void main(String[] args) {
        ArrayList<ArrayList<Integer>> arrayLists = new ArrayList<>();
        ArrayList<Integer> integers = new ArrayList<>();
        integers.add(1);
        integers.add(2);
        integers.add(3);
        arrayLists.add(integers);
        ArrayList<Integer> integers1 = new ArrayList<>();
        integers1.add(4);
        integers1.add(5);
        integers1.add(6);
        arrayLists.add(integers1);
        ArrayList<Integer> integers2 = new ArrayList<>();
        integers2.add(7);
        integers2.add(8);
        integers2.add(9);
        arrayLists.add(integers2);
//        Integer i = diagonalDiferrence(arrayLists);
//        System.out.println(i);
//        squareMultiplyOutput(10);

        ArrayList<Integer> integers3 = new ArrayList<>();
        integers3.add(-4);
        integers3.add(3);
        integers3.add(-9);
        integers3.add(0);
        integers3.add(4);
        integers3.add(1);

//        plusMinus(integers3);

        staircase(4);
    }

    /**
     * 獲取方形矩陣兩串對角線數字之和的差值
     *
     * 1 2 3
     * 4 5 6
     * 7 8 9
     *
     * 1+5+9=15;
     * 3+5+7=15;
     * 15-15=0;
     * @param arr
     * @return
     */
    public static Integer diagonalDiferrence(ArrayList<ArrayList<Integer>> arr){
        if(arr==null){
            return null;
        }
        if (arr.isEmpty()){
            return null;
        }
        for (ArrayList<Integer> integers : arr) {
            for (Integer integer : integers) {
                if (integer<-100 || integer > 100){
                    return null;
                }
            }
        }

        int count=0;
        ArrayList<Integer> integerArrayList = new ArrayList<>();
        for (int i = 0; i < arr.size(); i++) {
            ArrayList<Integer> integerList = arr.get(i);
            for (int i1 = 0; i1 < integerList.size(); i1++) {
                if(count==i1){
                    Integer i2 = integerList.get(i1);
                    integerArrayList.add(i2);
                    break;
                }else if (integerArrayList.size()==count){
                    if (i1==(count-1)){
                        Integer i2 = integerList.get(count);
                        integerArrayList.add(i2);
                        break;
                    }else {
                        continue;
                    }
                }else {
                    break;
                }
            }
            count++;
        }

        System.out.println(integerArrayList);

        int count1=0;
        ArrayList<Integer> integerArrayList1 = new ArrayList<>();
        for (int i = 0; i < arr.size(); i++) {
            List<Integer> integerList = arr.get(i);
            int reverseIndex=integerList.size()-1;
            for (int i1 = integerList.size()-1; i1 >=0 ; i1--) {
                if(count1==(integerList.size()-i1-1)){
                    Integer i2 = integerList.get(i1);
                    integerArrayList1.add(i2);
                    break;
                }else if (integerArrayList1.size()==count1){
                    if (i1==(integerList.size()-count1-1)){
                        Integer i2 = integerList.get(reverseIndex--);
                        integerArrayList1.add(i2);
                        break;
                    }else {
                        continue;
                    }
                }else {
                    break;
                }
            }
            count1++;
        }

        System.out.println(integerArrayList1);

        int sum=0;
        for (Integer integer : integerArrayList) {
            sum+=integer;
        }
        int sum1=0;
        for (Integer integer : integerArrayList1) {
            sum1+=integer;
        }

        int minersVal=sum-sum1;
        if (minersVal<0){
            int i = sum1 - sum;
            return i;
        }

        return minersVal;
    }

    public static void squareMultiplyOutput(int num){
        if (num<2 || num >20){
            return;
        }

        for (int i = 0; i < 10; i++) {
            int index=i+1;
            int i1 = num * index;
            System.out.println(" "+num+" *"+" " +index+" "+"= "+""+i1+"");

        }
    }

    public static void plusMinus(List<Integer> arr){
        if (arr==null){
            return;
        }
        if (arr.isEmpty()){
            return;
        }
        if (arr.size()<0 || arr.size()>100){
            return;
        }
        arr.forEach(e->{
            if (e<-100 || e>100){
                return;
            }
        });

        ArrayList<Integer> negtiveIntegers = new ArrayList<>();
        ArrayList<Integer> positiveIntegers = new ArrayList<>();
        ArrayList<Integer> zeroIntegers = new ArrayList<>();
        for (Integer integer : arr) {
            if (integer<0){
                negtiveIntegers.add(integer);
            }
            else if (integer>0){
                positiveIntegers.add(integer);
            }else {
                zeroIntegers.add(integer);
            }
        }

        int size = zeroIntegers.size();
        String s = size + ".000000";
        BigDecimal bigDecimal5 = new BigDecimal(s);
        bigDecimal5.setScale(6,RoundingMode.HALF_UP);
        int size1 = arr.size();
        String s1 = size1 + ".000000";
        BigDecimal bigDecimal = new BigDecimal(s1);
        bigDecimal.setScale(6,RoundingMode.HALF_UP);
        BigDecimal divide = bigDecimal5.divide(bigDecimal,6,RoundingMode.HALF_UP);

        int size2 = positiveIntegers.size();
        String s2 = size2 + ".000000";
        BigDecimal bigDecimal1 = new BigDecimal(s2);
        bigDecimal1.setScale(6,RoundingMode.HALF_UP);
        BigDecimal divide1 = bigDecimal1.divide(bigDecimal, 6, RoundingMode.HALF_UP);

        int size3 = negtiveIntegers.size();
        String s3 = size3 + ".000000";
        BigDecimal bigDecimal2 = new BigDecimal(s3);
        BigDecimal divide2 = bigDecimal2.divide(bigDecimal, 6, RoundingMode.HALF_UP);

        System.out.println(divide1);
        System.out.println(divide2);
        System.out.println(divide);
    }

    public static void staircase(int n){
        if(n<=0 || n>100){
            return;
        }

        int count=0;
        int N=n;
        int index=0;
        for (int i = n-1; i >= 0; i--) {
            if (count<(n-1)){
                System.out.print(" ");
                count++;
                continue;
            }
            count=0;
            n--;
            for (int j = 0; j < n; j++) {
                if (index<(N-n)){
                    System.out.print("#");
                    index++;
                    continue;
                }
            }
        }
    }
}