Pages

ProjectEuler




 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
//ProjectEuler55
//How many Lychrel numbers are there below ten-thousand?

//BruteForce (improved)
import java.math.BigInteger;

public class Problem55 {

 public static void main(String[] args) {
  int count = 0;
  for (int i = 1; i <= 10000; i++) {
   if (isLychrel(i)) {
    count++;
   }
  }
  System.out.print(count);
 }

 private static boolean isLychrel(int number) {
  BigInteger num = BigInteger.valueOf(number);
  for (int i = 1; i <= 50; i++) {
   num = num.add(reverseInt(num));
   if (isPalindrome(num))
    return false;
  }
  return true;
 }

 private static BigInteger reverseInt(BigInteger num) {
  char[] rev = num.toString().toCharArray();
  return (new BigInteger(new StringBuilder(new String(rev)).reverse()
    .toString()));
 }

 private static boolean isPalindrome(BigInteger num) {
  return num.equals(reverseInt(num));
 }
}
// RESULT:249

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
//ProjectEuler52
/* It can be seen that the number, 125874, and its double, 251748, contain exactly the same digits, but in a different order.
 * Find the smallest positive integer, x, such that 2x, 3x, 4x, 5x, and 6x, contain the same digits.
 */
//Fairly Efficient
import java.util.Arrays;

public class Problem52 {

 public static void main(String[] args) {
  int x = 10;

  while (!equal(x)) {
   x++;
  }
  System.out.print(x);

 }

 public static boolean equal(int x) {

  String x1 = Integer.toString(x);
  String x2 = Integer.toString(2 * x);
  String x3 = Integer.toString(3 * x);
  String x4 = Integer.toString(4 * x);
  String x5 = Integer.toString(5 * x);
  String x6 = Integer.toString(6 * x);

  if (x1.length() == x2.length() && x2.length() == x3.length()
    && x3.length() == x4.length() && x4.length() == x5.length()
    && x5.length() == x6.length()) {

   char array1[] = x1.toCharArray();
   Arrays.sort(array1);
   x1 = new String(array1);

   char array2[] = x2.toCharArray();
   Arrays.sort(array2);
   x2 = new String(array2);

   if (!x1.equals(x2)) {
    return false;
   }

   char array3[] = x3.toCharArray();
   Arrays.sort(array3);
   x3 = new String(array3);

   if (!x2.equals(x3)) {
    return false;
   }

   char array4[] = x4.toCharArray();
   Arrays.sort(array4);
   x4 = new String(array4);

   if (!x3.equals(x4)) {
    return false;
   }

   char array5[] = x5.toCharArray();
   Arrays.sort(array5);
   x5 = new String(array5);

   if (!x4.equals(x5)) {
    return false;
   }

   char array6[] = x6.toCharArray();
   Arrays.sort(array6);
   x6 = new String(array6);

   if (!x5.equals(x6)) {
    return false;
   }

   return true;
  }
  return false;
 }

}
// RESULT:142857


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
//ProjectEuler:48 
//Efficient 
 import java.math.BigInteger;

/*
 * 
 The series, 11 + 22 + 33 + ... + 1010 = 10405071317.
 Find the last ten digits of the series, 11 + 22 + 33 + ... + 10001000.
 */
public class problem48 {

 public static void main(String[] args) {
  BigInteger sum = BigInteger.ZERO;
  for (int i = 1; i <= 1000; i++) {
   BigInteger temp = BigInteger.valueOf(i);
   sum = sum.add(temp.pow(i));
  }
  String result = sum.toString();
  System.out.print(result.subSequence(result.length() - 10,result.length()));
 }

}
//RESULT=9110846700

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
//ProjectEuler:25
//What is the first term in the Fibonacci sequence to contain 1000 digits?

//Efficient
import java.math.BigInteger;

public class Problem25 {
 public static void main(String[] args) {

  BigInteger fib1 = BigInteger.ONE;
  BigInteger fib2 = BigInteger.ONE;
  BigInteger fib3 = BigInteger.ZERO;

  long count = 2;
  while (fib3.toString().length() != 1000) {

   count++;
   fib3 = fib1.add(fib2);
   fib1 = fib2;
   fib2 = fib3;

  }
  System.out.println(count);
 }

}
//RESULT:4782

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
//ProjectEuler:1
//Find the sum of all the multiples of 3 or 5 below 1000.

//Brute-Force

public class Problem1 {
 public static void main(String[] args) {
  long sum = 0;
  for (int number = 1; number <1000; number++) {
   if (number % 3 == 0 || number % 5 == 0) {
    sum=sum+number;    
   }
  }
  System.out.print(sum);
 }

}

//*******************************************

//Efficient method
public class Problem1 {
 public static void main(String[] args) {
  int end=1000;
  int sum3end=3+((end/3)-1)*3;
  int sum3=(end/6)*(3+sum3end);
  int sum5end=5+((end/5)-1)*5;
  int sum5=(end/10)*(5+sum5end);
  int sum15end=15+((end/15)-1)*15;
  int sum15=(end/30)*(15+sum15end);
  System.out.print(sum3+sum5-sum15);
 }
}

//RESULT:233667

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
//ProjectEuler:2
/*By considering the terms in the Fibonacci sequence whose 
  values do not exceed four million, find the sum of 
  the even-valued terms.
*/

//BruteForce
public class Problem2 {

 public static void main (String[] args){
  int sum=0;
  int a=1;
  int b=1;
  int c;
  while (a<=4000000){
   c=a+b;
   a=b;
   b=c;   
    if (b % 2==0){
     sum+=b;
    }
  }
  System.out.println(sum);  
 } 
}
//RESULT: 4613732

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
//ProjectEuler:3
//What is the largest prime factor of the number 600851475143

//Fairly efficient
public class Problem3 {

 public static void main(String[] args) {
  System.out.print(getLargestPrime(600851475143L));

 }

 public static long getLargestPrime(long num) {
  long largestPrime = -1;

  for (long i = 2; i <= num; i++) {
   if (num % i == 0 && isPrime(i)) {
    largestPrime = i;
    num /= i;
   }
  }

  return largestPrime;
 }

 public static boolean isPrime(long n) {
  if (n < 2)
   return false;
  if (n == 2 || n == 3)
   return true;
  if (n % 2 == 0 || n % 3 == 0)
   return false;
  long sqrtN = (long) Math.sqrt(n) + 1;
  for (long i = 6L; i <= sqrtN; i += 6) {
   if (n % (i - 1) == 0 || n % (i + 1) == 0)
    return false;
  }
  return true;
 }
}
//RESULT=6857

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
//ProjectEuler:4
/*
 A palindromic number reads the same both ways.
 The largest palindrome made from the product of
 two 2-digit numbers is 9009 = 91 � 99.
 Find the largest palindrome made from the 
 product of two 3-digit numbers.
 */

//Brute-Force (improved)
public class Problem4 {

 public static void main(String[] args) {
  int product = 0;
  int largest = 0;
  int number, digit, reverse;
  int savei = 0;
  int savej = 0;

  for (int i = 100; i < 1000; i++) {
   for (int j = 100; j < 1000; j++) {
    product = i * j;
    // check integer palindrome
    number = product;
    reverse = 0;
    while (product > 0) {
     digit = product % 10;
     reverse = reverse * 10 + digit;
     product = product / 10;
    }
    if (number == reverse) {
     if (number > largest) {
      largest = number;
      savei = i;
      savej = j;
     }
    }
   }

  }
  System.out.println(largest + " = " + savei + " X " + savej);
 }
}
// RESULT:906609 = 913 X 993

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
//ProjectEuler:5
/*
 2520 is the smallest number that can be divided by 
 each of the numbers from 1 to 10 without any remainder.

 What is the smallest positive number that is evenly
 divisible by all of the numbers from 1 to 20?
 */
//BruteForce (improved)

public class Problem5 {
 public static void main(String[] args) {

  for (int number = 10000; number <= 300000000; number++) {

   for (int i = 2; i <= 20; i++) {
    if (number % i != 0) {
     break;
    }
    if (i == 20) {
     System.out.println(number);
     // System.exit(0);
    }
   }

  }

 }
}
// RESULT:232792560

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
//ProjectEuler:6
/*
 * What is the difference between the sum of the
 * squares and the square of the sums?
 */

//Constant time solution
public class Problem6 {
 public static void main(String[] args) {
  double n = 100;
  double squareOfSum, sumOfSquare;
  squareOfSum = n * ((n + 1) / 2);
  sumOfSquare = squareOfSum * (((2 * n) + 1) / 3);
  System.out.print((int) (sumOfSquare - squareOfSum));
 }
}
//RESULT:333300

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
//ProjectEuler:7
//Find the 10001st prime.

//BruteForce
public class problem7 {
 public static void main(String[] args) {

  int count = 1;
  boolean prime = false;

  for (int number = 3; number <= 1000000; number = number + 2) {
   for (int i = 2; i < number; i++) {
    if (number % i == 0) {
     prime = false;
     break;

    } else {
     prime = true;
    }
   }

   if (prime) {
    count++;
    if (count == 10001) {
     System.out.println(number);
     break;
    }
   }
  }
 }
}

// **************************************************

// Improved

public class problem7 {
 public static void main(String[] args) {

  int[] primes = new int[10001];
  int primeCount = 1;
  int testNumber = 3;
  int largest = 0;
  primes[0] = 2;
  while (primeCount < 10001) {
   for (int i = 0; i < primeCount; i++) {
    if (testNumber % primes[i] == 0) {
     i = -1;
     testNumber++;
    }
   }
   primes[primeCount] = testNumber;
   if (largest < testNumber)
    largest = testNumber;
   primeCount++;
   testNumber++;

  }
  System.out.println(largest);
 }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
//ProjectEuler:8
//Find the greatest product of five consecutive digits in the 1000-digit number.

//Pretty efficient BruteForce
public class Problem8 {
 public static void main(String[] args) {

  String inputText = "73167176531330624919225119674426574742355349194934"
    + "96983520312774506326239578318016984801869478851843"
    + "85861560789112949495459501737958331952853208805511"
    + "12540698747158523863050715693290963295227443043557"
    + "66896648950445244523161731856403098711121722383113"
    + "62229893423380308135336276614282806444486645238749"
    + "30358907296290491560440772390713810515859307960866"
    + "70172427121883998797908792274921901699720888093776"
    + "65727333001053367881220235421809751254540594752243"
    + "52584907711670556013604839586446706324415722155397"
    + "53697817977846174064955149290862569321978468622482"
    + "83972241375657056057490261407972968652414535100474"
    + "82166370484403199890008895243450658541227588666881"
    + "16427171479924442928230863465674813919123162824586"
    + "17866458359124566529476545682848912883142607690042"
    + "24219022671055626321111109370544217506941658960408"
    + "07198403850962455444362981230987879927244284909188"
    + "84580156166097919133875499200524063689912560717606"
    + "05886116467109405077541002256983155200055935729725"
    + "71636269561882670428252483600823257530420752963450";

  int inputTextSize = inputText.length();
  int product = 1;
  int highest = 0;

  for (int i = 0; i < inputTextSize - 5; i = i + 1) {
   product = (inputText.charAt(i) - 48)
     * (inputText.charAt(i + 1) - 48)
     * (inputText.charAt(i + 2) - 48)
     * (inputText.charAt(i + 3) - 48)
     * (inputText.charAt(i + 4) - 48);
   if (highest < product) {
    highest = product;
   }

  }
  System.out.println(highest);

 }
}
//RESULT:40824

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
//ProjectEuler:9
/*
 A Pythagorean triplet is a set of three natural numbers, a < b < c, for which,
 a^2 + b^2 = c^2
 For example, 3^2 + 4^2 = 9 + 16 = 25 = 5^2.
 There exists exactly one Pythagorean triplet for which a + b + c = 1000.
 Find the product abc.
 */

//BruteForce (improved)
public class Problem9 {
 public static void main(String[] args) {
  double squaresum;
  for (double a = 1; a <= 998; a++) {
   for (double b = 1; b <= 998; b++) {
    for (double c = 1; c <= 998; c++) {
     if (a + b + c == 1000) {

      squaresum = Math.pow(a, 2) + Math.pow(b, 2);
      if (squaresum == Math.pow(c, 2)) {
       System.out.println((int) a * b * c);
       System.exit(0);

      }
     }
    }
   }
  }

 }

}
//RESULT:3.1875E7

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
//ProjectEuler:10
//Find the sum of all the primes below two million.

//Efficient
public class Problem10 {

 public static void main(String[] args) {
  
  long sum=0;
  for (long i=1; i<=2000000; i=i+2){
   if (isPrime(i)){
    sum=sum+i;
   }  
  } 
  System.out.print(sum);
 }
 public static boolean isPrime(long n) {
  if (n < 2)
   return false;
  if (n == 2 || n == 3)
   return true;
  if (n % 2 == 0 || n % 3 == 0)
   return false;
  long sqrtN = (long) Math.sqrt(n) + 1;
  for (long i = 6L; i <= sqrtN; i += 6) {
   if (n % (i - 1) == 0 || n % (i + 1) == 0)
    return false;
  }
  return true;
 }

}
//RESULT:142913828920

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
//ProjectEuler:13

/* Work out the first ten digits of the sum of the following 
 * one-hundred 50-digit numbers.
 */

//Super Efficient
import java.math.BigInteger;

public class problem13 {
 public static void main(String[] args) {
  String inputText = 
      "37107287533902102798797998220837590246510135740250"
    + "46376937677490009712648124896970078050417018260538"
    + "74324986199524741059474233309513058123726617309629"
    + "91942213363574161572522430563301811072406154908250"
    + "23067588207539346171171980310421047513778063246676"
    + "89261670696623633820136378418383684178734361726757"
    + "28112879812849979408065481931592621691275889832738"
    + "44274228917432520321923589422876796487670272189318"
    + "47451445736001306439091167216856844588711603153276"
    + "70386486105843025439939619828917593665686757934951"
    + "62176457141856560629502157223196586755079324193331"
    + "64906352462741904929101432445813822663347944758178"
    + "92575867718337217661963751590579239728245598838407"
    + "58203565325359399008402633568948830189458628227828"
    + "80181199384826282014278194139940567587151170094390"
    + "35398664372827112653829987240784473053190104293586"
    + "86515506006295864861532075273371959191420517255829"
    + "71693888707715466499115593487603532921714970056938"
    + "54370070576826684624621495650076471787294438377604"
    + "53282654108756828443191190634694037855217779295145"
    + "36123272525000296071075082563815656710885258350721"
    + "45876576172410976447339110607218265236877223636045"
    + "17423706905851860660448207621209813287860733969412"
    + "81142660418086830619328460811191061556940512689692"
    + "51934325451728388641918047049293215058642563049483"
    + "62467221648435076201727918039944693004732956340691"
    + "15732444386908125794514089057706229429197107928209"
    + "55037687525678773091862540744969844508330393682126"
    + "18336384825330154686196124348767681297534375946515"
    + "80386287592878490201521685554828717201219257766954"
    + "78182833757993103614740356856449095527097864797581"
    + "16726320100436897842553539920931837441497806860984"
    + "48403098129077791799088218795327364475675590848030"
    + "87086987551392711854517078544161852424320693150332"
    + "59959406895756536782107074926966537676326235447210"
    + "69793950679652694742597709739166693763042633987085"
    + "41052684708299085211399427365734116182760315001271"
    + "65378607361501080857009149939512557028198746004375"
    + "35829035317434717326932123578154982629742552737307"
    + "94953759765105305946966067683156574377167401875275"
    + "88902802571733229619176668713819931811048770190271"
    + "25267680276078003013678680992525463401061632866526"
    + "36270218540497705585629946580636237993140746255962"
    + "24074486908231174977792365466257246923322810917141"
    + "91430288197103288597806669760892938638285025333403"
    + "34413065578016127815921815005561868836468420090470"
    + "23053081172816430487623791969842487255036638784583"
    + "11487696932154902810424020138335124462181441773470"
    + "63783299490636259666498587618221225225512486764533"
    + "67720186971698544312419572409913959008952310058822"
    + "95548255300263520781532296796249481641953868218774"
    + "76085327132285723110424803456124867697064507995236"
    + "37774242535411291684276865538926205024910326572967"
    + "23701913275725675285653248258265463092207058596522"
    + "29798860272258331913126375147341994889534765745501"
    + "18495701454879288984856827726077713721403798879715"
    + "38298203783031473527721580348144513491373226651381"
    + "34829543829199918180278916522431027392251122869539"
    + "40957953066405232632538044100059654939159879593635"
    + "29746152185502371307642255121183693803580388584903"
    + "41698116222072977186158236678424689157993532961922"
    + "62467957194401269043877107275048102390895523597457"
    + "23189706772547915061505504953922979530901129967519"
    + "86188088225875314529584099251203829009407770775672"
    + "11306739708304724483816533873502340845647058077308"
    + "82959174767140363198008187129011875491310547126581"
    + "97623331044818386269515456334926366572897563400500"
    + "42846280183517070527831839425882145521227251250327"
    + "55121603546981200581762165212827652751691296897789"
    + "32238195734329339946437501907836945765883352399886"
    + "75506164965184775180738168837861091527357929701337"
    + "62177842752192623401942399639168044983993173312731"
    + "32924185707147349566916674687634660915035914677504"
    + "99518671430235219628894890102423325116913619626622"
    + "73267460800591547471830798392868535206946944540724"
    + "76841822524674417161514036427982273348055556214818"
    + "97142617910342598647204516893989422179826088076852"
    + "87783646182799346313767754307809363333018982642090"
    + "10848802521674670883215120185883543223812876952786"
    + "71329612474782464538636993009049310363619763878039"
    + "62184073572399794223406235393808339651327408011116"
    + "66627891981488087797941876876144230030984490851411"
    + "60661826293682836764744779239180335110989069790714"
    + "85786944089552990653640447425576083659976645795096"
    + "66024396409905389607120198219976047599490197230297"
    + "64913982680032973156037120041377903785566085089252"
    + "16730939319872750275468906903707539413042652315011"
    + "94809377245048795150954100921645863754710598436791"
    + "78639167021187492431995700641917969777599028300699"
    + "15368713711936614952811305876380278410754449733078"
    + "40789923115535562561142322423255033685442488917353"
    + "44889911501440648020369068063960672322193204149535"
    + "41503128880339536053299340368006977710650566631954"
    + "81234880673210146739058568557934581403627822703280"
    + "82616570773948327592232845941706525094512325230608"
    + "22918802058777319719839450180888072429661980811197"
    + "77158542502016545090413245809786882778948721859617"
    + "72107838435069186155435662884062257473692284509516"
    + "20849603980134001723930671666823555245252804609722"
    + "53503534226472524250874054075591789781264330331690";

  BigInteger sum = BigInteger.ZERO;
  for (int i = 0; i < inputText.length(); i = i + 50) {
   sum = sum.add(new BigInteger(inputText.substring(i, i + 50)));
  }
  System.out.print(sum.toString().substring(0, 10));
 }

}
//RESULT:5537376230

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
//ProjectEuler:16

/*
 * What is the sum of the digits of the number 2^1000?
 */

//Pretty Efficient
import java.math.BigInteger;

public class problem16 {

 public static void main(String[] args) {
  BigInteger a = BigInteger.valueOf(2);
  String text = a.pow(1000).toString();
  long sum = 0;
  for (int i = 0; i < text.length(); i++) {
   sum = sum + text.charAt(i) - 48;
  }
  System.out.print(sum);
 }
}
//RESULT:1366

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
//ProjectEuler:15
//How many such routes are there through a 20×20 grid?
import java.math.BigInteger;

//fairly efficient
public class problem15 {
 public static void main(String[] args) {
  BigInteger fact20 = getFactorial(20, 1);
  BigInteger fact40 = fact20.multiply(getFactorial(40, 21));
  System.out.println((fact40.divide(fact20)).divide(fact20));
 }

 public static BigInteger getFactorial(int num, int loop) {
  BigInteger fact = BigInteger.ONE;
  for (int i = loop; i <= num; i++)
   fact = fact.multiply(BigInteger.valueOf(i));
  return fact;
 }
}
//RESULT:137846528820

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
//ProjectEuler:20
/*
 n! means n × (n − 1) × ... × 3 × 2 × 1  * 
 * For example, 10! = 10 × 9 × ... × 3 × 2 × 1 = 3628800, and the sum of the
 * digits in the number 10! is 3 + 6 + 2 + 8 + 8 + 0 + 0 = 27.  * 
 * Find the sum of the digits in the number 100!
 */

//fairly efficient
import java.math.BigInteger;

public class Problem20 {

 public static void main(String[] args) {
  String fact = getFactorial(100).toString();
  long sum = 0;
  for (int i = 0; i < fact.length(); i++) {
   sum = sum + fact.charAt(i) - 48;
  }
  System.out.print(sum);

 }

 public static BigInteger getFactorial(int num) {
  BigInteger fact = BigInteger.ONE;
  for (int i = 1; i <= num; i++)
   fact = fact.multiply(BigInteger.valueOf(i));
  return fact;
 }

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
//ProjectEuler:36
/*
 * The decimal number, 585 = 10010010012 (binary), is palindromic in
 * both bases. Find the sum of all numbers, less than one million, which
 * are palindromic in base 10 and base 2. (Please note that the
 * palindromic number, in either base, may not include leading zeros.)
 */

//Efficient

public class Problem36 {
 public static void main(String[] args) {
  long sum = 0;
  for (Integer i = 1; i < 1000000; i++) {

   if (palindrome(Integer.toString(i))
     && palindrome(Integer.toBinaryString(i))) {
    sum = sum + i;
   }
  }
  System.out.print(sum);

 }

 public static boolean palindrome(String str) {
  return str.equals(new StringBuffer().append(str).reverse().toString());
 }
}
//RESULT:872187

Ayush Subedi

Coffee Connoisseur