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

Tags: ,
Ayush Subedi

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Morbi eu sem ultrices, porttitor mi eu, euismod ante. Maecenas vitae velit dignissim velit rutrum gravida sit amet eget risus. Donec sit amet mollis nisi, nec commodo est.