Project Euler Problem 12: Highly divisible triangular number

Problem

The sequence of triangle numbers is generated by adding the natural numbers. So the 7^th triangle number would be 1 + 2 + 3 + 4 + 5 + 6 + 7 = 28. The first ten terms would be:

1, 3, 6, 10, 15, 21, 28, 36, 45, 55, ...

Let us list the factors of the first seven triangle numbers:

 1: 1
 3: 1,3
 6: 1,2,3,6
10: 1,2,5,10
15: 1,3,5,15
21: 1,3,7,21
28: 1,2,4,7,14,28

We can see that 28 is the first triangle number to have over five divisors.

What is the value of the first triangle number to have over five hundred divisors?

Solution

First attempt

The trick of counting the divisors is only check up to the square root of the number, and each time add 2 to the count. It didn't cross my mind the first time, and I checked up to half the number and each time add 1 to the count. It took forever....

      private static final int DIVISOR_NUMBER = 500;  
      public static void main(String[] args) {  
           int triangleNumber = 1;  
           int natualNumber = 2;  
           int divisorNumber = 1;  
           while (divisorNumber <= DIVISOR_NUMBER){  
                triangleNumber += natualNumber;  
                divisorNumber = divisorNumber(triangleNumber);  
                natualNumber++;  
           }  
           System.out.println(triangleNumber);  
      }  
      private static int divisorNumber(int number){  
           int count = 2;  
           int sqrt = (int)Math.sqrt(number);  
           for (int i=2; i<=sqrt; i++){  
                if (number % i == 0){  
                     count+=2;  
                }  
           }  
           if (sqrt * sqrt == number){  
                count--;  
           }  
           return count;  
      }  

Second attempt

This is really brilliant.

Kudos to kpsychas who came up with it. https://projecteuler.net/thread=12;page=3#5370

It is a bit difficult to understand the original post. So I have expanded it to make it more clear.

      private static final int DIVISOR_NUMBER = 500;  
      public static void main(String[] args) {  
           int k = 2;  
           int divisorNumberOdd = 0;  
           int divisorNumberEven = 0;  
           do{  
                k++;  
                divisorNumberOdd = divisorNumber(k) * divisorNumber(2*k-1);  
                divisorNumberEven = divisorNumber(k) * divisorNumber(2*k+1);  
           }while(divisorNumberOdd <= DIVISOR_NUMBER && divisorNumberEven <= DIVISOR_NUMBER);  
           if (divisorNumberOdd > DIVISOR_NUMBER){  
                System.out.println(k*(2*k-1));  
           }else{  
                System.out.println(k*(2*k+1));  
           }  
      }  
      private static int divisorNumber(int number){  
           int count = 2;  
           int sqrt = (int)Math.sqrt(number);  
           for (int i=2; i<=sqrt; i++){  
                if (number % i == 0){  
                     count+=2;  
                }  
           }  
           if (sqrt * sqrt == number){  
                count--;  
           }  
           return count;  
      }  

Project Euler Problem 11: Largest product in a grid

Problem

In the 20×20 grid below, four numbers along a diagonal line have been marked in red.

08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48

The product of these numbers is 26 × 63 × 78 × 14 = 1788696.

What is the greatest product of four adjacent numbers in the same direction (up, down, left, right, or diagonally) in the 20×20 grid?

Solution

It is worth mentioning that the algorithm to calculate adjacent product for horizontal, vertical and diagonal direction can be consolidated.

      private static final int SIZE = 20;  
      private static final int[][] m = new int[SIZE][SIZE];  
      private static final int K = 4;  
      public static void main(String[] args) {  
           readFile();  
           int greatestProduct = 0;  
           for (int i=0; i<SIZE; i++){  
                for (int j=0; j<SIZE; j++){  
                     int rowProduct = adjacentProduct(i, j, 1, 0);  
                     int colProduct = adjacentProduct(i, j, 0, 1);  
                     int diagProductRight = adjacentProduct(i, j, 1, 1);  
                     int diagProductLeft = adjacentProduct(i,j, 1, -1);  
                     int tempGreatest = Math.max(Math.max(rowProduct, colProduct),   
                               Math.max(diagProductLeft, diagProductRight));  
                     greatestProduct = Math.max(greatestProduct, tempGreatest);  
                }  
           }  
           System.out.println(greatestProduct);  
      }  
      private static int adjacentProduct(int i, int j, int iStep, int jStep){  
           int iK = i+iStep*(K-1);  
           int jK = j+jStep*(K-1);  
           if (!withinBoundary(iK) || !withinBoundary(jK)){  
                return 0;  
           }  
           int product = 1;  
           for (int x=i,y=j,count=0; count<K; x+=iStep,y+=jStep, count++){  
                product *= m[x][y];  
           }  
           return product;  
      }  
      private static boolean withinBoundary(int i) {  
           return 0 <= i && i < SIZE;  
      }  
      private static void readFile() {  
           File file = new File("Q11.txt");  
           try {  
                Scanner sc = new Scanner(file);  
                int row = 0;  
                int col = 0;  
                while (sc.hasNextLine()) {  
                     int i = sc.nextInt();  
                     m[row][col] = i;  
                     col++;  
                     if (col == SIZE){  
                          col = 0;  
                          row++;  
                     }  
                }  
                sc.close();  
           } catch (FileNotFoundException e) {  
                e.printStackTrace();  
           }  
      }