public class Main{
    public static void main(String [] argv){
        int product= 36;
        int sums [][] = new int[product][4];
        int sumIndex = 0;
        System.out.println("----------All possibilities --------");
        for(int first = 1; first <= product; first++ ){
            for(int second = first; second <=product/first; second++){
                for(int third = second; third <= product/(first*second); third++){
                    if((first*second*third) == product) {
                        System.out.println("|" + first + "|" + "|" + second + "|" + "|" + third + "||" + (first * second * third) + " -> " + (first + second + third));
                        sums[sumIndex][0] = first;
                        sums[sumIndex][1] = second;
                        sums[sumIndex][2] = third;
                        sums[sumIndex][3] = first+second+third;
                        sumIndex++;
                    }
                }
            }
        }

        System.out.println("----------Ambiguous solutions--------");
        int [][] ambs = findAmbiguous(sums);
        for(int i = 0; i < ambs.length && ambs[i][0] != 0;i++){
            System.out.println("|" + ambs[i][0] + "|" + "|" + ambs[i][1] + "|" + "|" + ambs[i][2] + "||" + (ambs[i][0]+ambs[i][1]+ambs[i][2]));
        }

        System.out.println("----------Solution--------");
        int [] solution  = findMostPowerful(ambs);
        if(solution != null) {
            System.out.println("The solution is First: " + solution[0] + " second: " + solution[1] + " and third: " + solution[2]);
        }


    }

    public static int [][] findAmbiguous(int [][] sums){
        int [][] ambiguous = new int[sums.length][3];
        int ambIndex = 0;
        for(int i = 0; i < sums.length && sums[i][3] != 0;i++){
            for(int j = i+1; j < sums.length && sums[j][3] != 0;j++){
                if(sums[i][3] == sums[j][3]){
                    ambiguous[ambIndex][0] = sums[i][0];
                    ambiguous[ambIndex][1] = sums[i][1];
                    ambiguous[ambIndex][2] = sums[i][2];
                    ambIndex++;
                    ambiguous[ambIndex][0] = sums[j][0];
                    ambiguous[ambIndex][1] = sums[j][1];
                    ambiguous[ambIndex][2] = sums[j][2];
                    ambIndex++;
                }
            }
        }
        return ambiguous;
    }

    public static int [] findMostPowerful(int [][] ambiguous){
        for(int i = 0;i < ambiguous.length;i++){
            if(ambiguous[i][0] > ambiguous[i][1] && ambiguous[i][0] > ambiguous[i][2]){
                return ambiguous[i];
            }else if(ambiguous[i][1] > ambiguous[i][0] && ambiguous[i][1] > ambiguous[i][2]){
                return ambiguous[i];
            }else if(ambiguous[i][2] > ambiguous[i][0] && ambiguous[i][2] > ambiguous[i][1]){
                return ambiguous[i];
            }
        }
        return null;
    }
}