Just a quick pat on my own shoulder…

Project Euler’s problem 266, posted this very last weekend, was proposed by yours truly:

The divisors of 12 are: 1,2,3,4,6 and 12.
The largest divisor of 12 that does not exceed the square root of 12 is 3.
We shall call the largest divisor of an integer n that does not exceed the square root of n the pseudo square root (PSR) of n.
It can be seen that PSR(3102)=47.

Let p be the product of the primes below 190.
Find PSR(p) mod 10¹⁶.

I had something much more modest in mind, such as “all primes below 100″, since the way I figured it out this was to be solved treating it as a variation of the knapsack problem and then using dynamic programming on it. An approach that will see you die of old age if you try it for the proposed value…

But I then had the pleasure of witnessing how xan, hk and daniel.is.fischer started coming up with alternative, much more sophisticated and elegant methods, that pushed the question all the way up to were it is now. It is both a humbling and edifying experience to see these people at work, so if you have an idea for a problem, do propose it to them.

I won’t go into any more details as to how to solve this particular problem: the right place to ask questions is here.

I have noticed people searching for my IProblemBase class. There is really nothing to it to be honest. I just have all my Problem[n] classes implement it so that my test harness can call them easily. What I really need to publish is my BigInt class that most of the solutions I do publish use. Sorry, it needs some polish so its going to be a while for that one.

IProblemBase

namespace Euler
{
    public interface IProblemBase
    {
        string GetAnswer();

    }

}

Program

namespace Euler
{
    class Program
    {
        static void Main(string[] args)
        {
            IProblemBase p = new Problem48();
            string answer = p.GetAnswer();
            //etc.....
        }

    }

}

Decided that i want to take a look at F# and to solve the project euler problems is a fun way to learn. And here is the first of the problems.

If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23.

Find the sum of all the multiples of 3 or 5 below 1000.

Menentukan nilai maksimal dari 5 bilangan terurut dari 1000 digit bilangan berikut:

73167176531330624919225119674426574742355349194934
96983520312774506326239578318016984801869478851843
85861560789112949495459501737958331952853208805511
12540698747158523863050715693290963295227443043557
66896648950445244523161731856403098711121722383113
62229893423380308135336276614282806444486645238749
30358907296290491560440772390713810515859307960866
70172427121883998797908792274921901699720888093776
65727333001053367881220235421809751254540594752243
52584907711670556013604839586446706324415722155397
53697817977846174064955149290862569321978468622482
83972241375657056057490261407972968652414535100474
82166370484403199890008895243450658541227588666881
16427171479924442928230863465674813919123162824586
17866458359124566529476545682848912883142607690042
24219022671055626321111109370544217506941658960408
07198403850962455444362981230987879927244284909188
84580156166097919133875499200524063689912560717606
05886116467109405077541002256983155200055935729725
71636269561882670428252483600823257530420752963450

Silahkan kalo mau menghitung sendiri, berapa nilai maksimalnya . Tetapi berikut ini akan saya berikan program untuk menghitungnya dengan menggunakan bahasa pemrograman java.

import java.io.BufferedReader;
import java.io.FileReader;

/**
 *
 * @author Windu Purnomo
 */
public class Euler8 {
    public static void main(String[] args) {
        String temp;
        int num, mul = 1, maks=1;
        try{
            BufferedReader reader = new BufferedReader(new FileReader("1000.txt"));
            if(!(temp=reader.readLine()).equals(null)){
                for(int i=0; i<temp.length()-4; i++){
                    for(int j=i; j<i+5; j++){
                        Character c = new Character(temp.charAt(j));
                        String s = c.toString();
                        num = Integer.parseInt(s);
                        mul *= num;
                    }
					//System.out.println("Perkalian lima ke-"+i+" "+mul);
                    if(maks<mul) maks = mul;
					num = 0;
					mul = 1;
                }
            }
            reader.close();
        }catch(Exception e){
                System.out.println("gagal");
        }
        System.out.println("Nilai terbesar: "+ maks);
    }
}

Example problem:
What is 6th prime number?
Answer:
By listing the first six prime numbers: 2, 3, 5, 7, 11, and 13, we can see that the 6-th prime is 13

Now, what is 10001-th prime number?

It is simple, if we use program to count it:

/*
  Name: N-th Prime Number
  Copyright: 2009
  Author: Windu Purnomo
  Date: 23/11/09 11:40
  Description: Get n-th prime number, after list it.
*/

#include<stdio.h>
main(){
    int i, j, n;
    int flag = 1;
    int counter = 0;

    scanf("%d", &n);
    for(i=2; i>0; i++){
       for(j=2; j<i; j++){
          if(i%j==0){
             flag = 0;
             break;
          }
       }
       if(flag){
          counter++;
          if(counter == n){
             printf("It is %d-th prime number: %d", n, i);
             break;
          }
       }else{
          flag = 1;
       }
    }
    getch();
    return 0;
}

For the 13th problem of the Euler project, I started by defining a list containing the one hundred numbers. So, it would be something like:

import Char

l = [37107287533902102798797998220837590246510135740250,

46376937677490009712648124896970078050417018260538,

...

53503534226472524250874054075591789781264330331690]

Then, it was a matter of defining a small function that would return the first 10 digits of the sum of all those numbers:

sumF :: [Integer] -> [Char]
sumF = take 10 . show . sum

The result (of executing sumF l) was achieved using the following timing/memory resources: (0.01 secs, 5340404 bytes)

The problem number 20 of the Euler project aims to find the sum of the digits in the number 100!.

First, I defined the factorial function, as follows:

import Char

fac n = foldr (*) 1 [1..n]

Then, I just defined a function that calculates the factorial of a given number and performs some transformations in order to sum the digits of that number. The function was defined as one can see below:

sumF = sum . map digitToInt . show . fac

Then, by executing sumF 100, one gets the correct result for this problem.

Read the details of the problem here

Summary

For how many triangles in the text file does the interior contain the origin?

Solution

This question had me wondering for a while as to what the best approach to take might be. In the end I went for a simple approach that just relied on the fact that the interior angles from any point within a triangle to the vertexes would add up to 360° or 2 * Pi radians. To calculate the angles at the origin I relied on some things I’d learned when I used to write computer games as a hobby.

The dot product of two 2D vectors, U and V, is equivalent to the following two formulae:

U•V = U₀V₀ + U₁V₁

U•V = |U| * |V| * cos θ

Where |U| is the magnitude of the vector U, i.e. sqrt( U₀² + U₁² )

So this gives: cos θ = ( U₀V₀ + U₁V₁ ) / ( |U| * |V| )

The coded solution is then quite trivial and just calculates the angle at the origin subtended by vectors out to the pairs of vertices for each line segment.

new File("euler_P102_triangles.txt").eachLine {
    def (x0, y0, x1, y1, x2, y2) = it.split(",")*.toInteger()
    def ( a, b, c ) = [ [ x0, y0 ], [ x1, y1 ], [ x2, y2 ] ]
    def theta = 0.0

    [ [ a, b ], [ a, c ], [ b, c ] ].each {
        def ( u, v ) = it
        def dot = u[0] * v[0] + u[1] * v[1]
        def ul =  Math.sqrt(u[0] * u[0] + u[1] * u[1])
        def vl =  Math.sqrt(v[0] * v[0] + v[1] * v[1])
        theta += Math.acos(dot / (ul * vl))
    }

    if (Math.abs(theta - 2 * Math.PI) < 1E-7) answer++
}

It ran in 0.96 seconds and wasn’t difficult to write once I’d decided what approach to take! Note the importance of using an epsilon value (1E-7) when comparing floating-point numbers as you can’t rely on an exact equality.

There are probably quicker ways to do this (in fact, I know there are) but this approach was nice & straightforward to code off the top of my head and ran in an acceptable time.

Conclusion

Groovy makes reading a text file and parsing it into appropriate data structures quite simple. It didn’t really make any difference to the rest of the solution apart from perhaps the nice syntax on the <list of sides>.each{} loop as it was mostly just straightforward maths.

The challenge

The short version:

Find the difference between the sum of the squares of the first one hundred natural numbers and the square of the sum.

Today’s solution is a one-liner, I ran it in the interactive environment:

[1I .. 100I] |> (fun nums -> List.sum nums ** 2I - (List.map (fun x -> x ** 2I) nums |> List.sum));;

I pass a list of the bigints 1 through 100 into an anonymous function. The function squares the list’s sum, and then subtracts the sum of all of the squares of the list elements.

Read the details of the problem here

Summary

Which base/exponent pair in the file has the greatest numerical value?

Solution

I took the straightforward approach to this one. As the resulting numbers would be huge it was just a matter of using log10(base) * exp and comparing those values. The coded solution is trivial.

def ( i, answer, max ) = [ 1, -1, 0.0 ]

new File("base_exp.txt").eachLine {
    def ( base, exp ) = it.split(",")*.toDouble()
    def log = Math.log10(base) * exp
    if (log > max) ( answer, max ) = [ i, log ]
    i++
}

It ran in 46 ms and took a very short time to write!

Conclusion

Groovy was a very nice language to use for this. It was very easy to read the file and process the contents. See how the spread-dot operator is used on the list resulting from the split to convert both operands in to Doubles ready for the next step. The only slightly irritating part was that I had to maintain my own record count as there is no eachWithIndex() method available on a File object. I could have treated this differently by reading into a list first but this seemed quicker!

As there was no heavy maths processing performance was fine, it was quick to write and the code intent is clear.

The 16th problem of the project Euler site was fairly easy to solve.

With a one-line function, I am able to calculate the sum of the digits of 2^x, for a given x as input:

import Char

sumF = sum . map digitToInt . show . (^) 2

Then, it was just a matter of calling the function with 1000 as input. The execution was really fast, so ghci presented (0.00 secs, 0 bytes).

The challenge

Each new term in the Fibonacci sequence is generated by adding the previous two terms. By starting with 1 and 2, the first 10 terms will be:

1, 2, 3, 5, 8, 13, 21, 34, 55, 89, …

Find the sum of all the even-valued terms in the sequence which do not exceed four million.

We will use lazily-evaluated sequences in F# to solve this problem. First, we define the Fibonacci series:

let fibs =
    let rec loop a b = seq { yield a; yield! loop b (a+b) }
    loop 1I 2I

Next, we define a simple test for the even-ness of a bigint:

let eventest = function
    | x when (x % 2I = 0I) -> true
    | _ -> false

Now we can solve for the sum! We’ll use the pipeline operator to pass sequences between functions. Also note the anonymous function passed to Seq.takeWhile – its purpose is to stop computing new values in the fibs sequence when we reach 4,000,000

let main() =
    Seq.takeWhile (fun x -> x <= 4000000I) fibs
    |> Seq.filter eventest
    |> Seq.sum
    |> printfn "Answer: %A"

Get the full F# source

As one who loved mathematics (and still do – I considered becoming a mathematician) – Project Euler is a beautiful place to try and get practice on new programming languages as well as mathematical principles. Project Euler provides problems that require solutions, and which are designed for less than one minute solutions using the computer. The problems also highlight a mathematical principle in their solution.

I’ve only worked on a very few problems so far, but it appears that it is quite easy to write a brute force programming algorithm for some of these problems; personally, I am attempting to find the mathematical solution as well as solving the problem in Scala. There is a nice article about one person using Scala to solve Project Euler problems.

The biggest problem in using Project Euler for learning a programming language is that Project Euler isn’t set up for multiple language users: each user is able to specify (and track) solutions in only one language – but this is not a problem really.

If you want to solve more mathematical problems (not necessarily with a computer), the MathsChallenge web site is an excellent one, and is apparently the predecessor to the Project Euler site.

Read the details of the problem here

Summary

What is the smallest number that is evenly divisible by all of the numbers from 1 to 20?

Solution

I didn’t need to write a program for this question. I vaguely remembered from school that the LCM of a series of numbers is just the product of the maximum powers of its prime factors, or something like that terminology.

It goes something like this. 2^4 = 16, which is less than 20, so that’s included but 2^5 isn’t as 32 is greater than 20. Similarly 3^2 = 9, is in, but 3^3 = 27 is out. Intermediate numbers will always be able to be factored into products of lesser powers of the primes and can therefore be ignored.

So this gives the list: 2^4 * 3^2 * 5 * 7 * 11 * 13 * 17 * 19

So it wasn’t really much of a program to be written though groovysh did the calculation admirably. Performance wasn’t an issue!

Conclusion

Just goes to show it’s sometimes worth engaging brain before hitting the keyboard.

Reading ahead in the Project Euler questions it looks like factorization of large numbers is an ongoing theme so I’ll probably end up writing something that does this but I’ll do that when I need it.

Read the details of the problem here

Summary

Using a brute force attack, can you decrypt the cipher using XOR encryption?

Solution

I actually got lucky with this one. The clue was that it contained English text, so the most common character was likely to be SPACE (ASCII 32). I tried for a simple frequency analysis first on that basis to find candidate key characters and it gave the right answer. It ran in 0.62 seconds.

If this approach hadn’t worked my next approach would have been to restrict the key characters as per the question and compare each decoded sequence against a valid character set e..g a-z, A-Z, comma, parentheses, full-stops, etc. looking for least exceptions and rating the key against that.

For something like this, where the plaintext type and key length was known it didn’t really warrant coding up a sliding XOR attack.

def seqs = [ [], [], [] ]

new File("euler_p59_cipher1.txt").text.split(",")
        .eachWithIndex { val, idx –>
            seqs[idx % seqs.size()] << val.toInteger()
        }

def answer = 0
def ASCII_SPACE = 32

seqs.each { vals ->

    def freqs = new int[256]
    vals.each { freqs[it]++ }

    def ( pkey, max ) = [ 0, 0 ]
    freqs.eachWithIndex { freq, chr ->
        if (freq > max) ( pkey, max ) = [ chr ^ ASCII_SPACE, freq ]
    }

    answer += vals.sum { it ^ pkey }
}

I went on to decode the passage and the result was truly Biblical. Not sure that I would have used that particular text in such a website but, as this solution proves, you don’t actually need to read it to get the answer. As to the key itself, well, I’d have stayed clear of that too. It’s one of those passwords you just NEVER use!

Conclusion

Groovy was a very nice language to use for this. It made it very easy to read the file and split it into sequences for each character in the keyword. In fact, that could have been a one-liner. The construction of the frequency table and the extraction of a potential key character was also very straightforward.

As there was no heavy maths processing performance was fine, it was quick to write and the code intent is clear.

It also helped that I’ve had an interest in cryptography since young. I thoroughly recommend Simon Singh’s Code Book as a gentle introduction into the topic.

Read the details of the problem here

Summary

Find the largest palindrome made from the product of two 3-digit numbers.

Solution

An obvious brute force solution completes in 1.14 seconds. The only simple optimizations I made were to count down rather than up for the two numbers and to put a guard condition on the expensive functions.

String.metaClass.isPalindrome = { ->
    delegate == delegate.reverse()
}

def answer = 0

for (i in 999..100) {
    for (j in 999..100) {
       def p = i * j
       if ((p > answer)  && (p.toString().isPalindrome())) answer = p
    }
}

As they say, “‘Nuff Said!”

Conclusion

The ability to extend to the String metaclass with an “isPalindrome()” method leads to quite a nice syntax but isn’t much different to just defining a support method. (I could also have put the function into the Integer class directly and hidden the String conversion in that.)

The solution ran well within my 15 second limit but still felt slow for what it was doing. An equivalent Java version runs in 137 ms. That’s around 8x faster.

I discovered F# while searching for introductions to functional programming. Later that day I discovered Project Euler, a set of mathematical challenges for programmers. So with a new language and new problems, let’s start from the top.

The challenge

If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23.

Find the sum of all the multiples of 3 or 5 below 1000.

My first solution sticks to familiar if/else conditionals:

let rec AddIfElse ceiling current sum =
    if current >= ceiling then
        sum
    else
        if current % 3 = 0 || current % 5 = 0 then
            AddIfElse ceiling (current+1) (sum+current)
        else
            AddIfElse ceiling (current+1) sum

My second solution uses F# pattern matching and a nested function, just to play with the language:

let rec AddPatterns ceiling current sum =
    let adjustment = function
        | x when x % 3 = 0 || x % 5 = 0 -> x
        | _ -> 0

    match current with
        | x when x = ceiling -> sum
        | _ -> AddPatterns ceiling (current+1) (sum + adjustment current) 

In functional programming, functions are values and can be manipulated as such. Let’s set up a function that hides the recursion in our two solutions, so a client won’t have to initialize the recursive parameters. Our new function accepts:

• A number to solve for (1000 to answer the Euler question)
• A function to use in solving (either the IfElse or Patterns variant)

This function will return the answer computed by the function passed in.

let Solve n fn =
    fn n 1 0

Now we can solve the problem!

let main() =
    printfn "If/else solution:"
    printfn "10:     %d" (Solve 10 AddIfElse)
    printfn "1000:   %d" (Solve 1000 AddIfElse)
    printfn "Pattern matching solution:"
    printfn "10:     %d" (Solve 10 AddPatterns)
    printfn "1000:   %d" (Solve 1000 AddPatterns)

Get the full F# source

In this post I will show how did I solve the 9th problem of the Euler project. This was one of the first problems that gave me performance issues and therefore a brute force approach was not good enough. However, I just realised that after building a brute force algorithm

I started describing all the conditions stated in the description of the problem. Therefore, I got this Haskell function:

l = [ [a,b,c] | a <- [1..999], b <- [1..999], c <- [1..999], a+b+c== 1000 && a^2 + b^2 == c^2 && a < b && b < c]

Then, with a simple function called value:

value = product . head

By executing value l, I reached the following result: (371.90 secs, 32855979636 bytes)

As you can see, it is not an interesting result for such a problem. I was just making too many combinations of a, b and c, and most of the conditions were unnecessary. From the problem description, it is possible to deduct that c can be written by means of a and b. Using this simple substitution and removing the unnecessary conditions, I reached this solution:

h = [[a,b,1000-a-b] | a <- [1..999], b <- [1..999],a^2 + b^2 == (1000-a-b)^2]

After running value h, this was the result: (0.79 secs, 108452856 bytes), which is much better than the first one.

Read the details of the problem here

Summary

What is the largest prime factor of the number 600851475143?

Solution

Pretty straightforward question with a straightforward brute force answer.

The code simply uses a naïve Sieve of Eratosthenes to generate primes up to the  square root of the target number “n” and then factorises from that sieve.

long n = 600851475143L
def isPrime = new boolean[Math.sqrt(n)+1]
Arrays.fill(isPrime, true);
isPrime[1] = false

for (int i in 2..Math.sqrt(isPrime.size())) {
    if (isPrime[i]) {
        for (j = i + i; j < isPrime.size(); j += i) isPrime[j] = false
    }
}

def (answer, i) = [ 0, 2 ]
while (n > 1) {
    if ((isPrime[i]) && (n % i == 0)) {
        ( n, answer ) = [ n / i, i ]
    }
    i++
}

It’s all very quick to write but look at the explicit typing in the declaration of “n”. Without this the “n / i” calculation in the factorisation loop will assign a BigDecimal to n which will then fail on the next mod operation. It is also possible to work around this feature by casting the result but the typing approach is probably the lesser of two evils.

The script completes in 3.44 seconds, the sieve creation itself taking 3.36 seconds. This seems extremely slow. Porting this over into classic Java it returns in 32 ms with the sieve creation taking 31 ms. That’s 100 times faster.

A simpler solution, without the sieve and relying on the BigInteger#isProbablePrime method returns in 1.21 secs, whereas the Java version of this takes 0.87 secs.

Conclusion

Groovy didn’t actually add much to this solution apart from removing the boilerplate class code that Java required (and that IDEs generate automatically so it’s not much of a saving). The multiple assignment syntax was nice but nothing that I couldn’t have done without.

The fact that doing calculations like this means that the developer has to be aware of the types of the variables isn’t really a big deal but does suddenly make you aware that you’re not running in a real typeless environment like Ruby or Python. The runtime error message I received, “Cannot use mod() on this number type: BigDecimal” was a bit of a surprise and emphasises how much testing is necessary with dynamically typed languages where the number types can differ in the operations they support.

It appears from this that Groovy is imposing quite a severe overhead, adding some two orders of magnitude to numerical processing. If I need to do any real number crunching it’ll be best to create a proper Java helper class and use it from the Groovy script.

For the BigInteger#isProbablePrime solution (shown below), Groovy does provide for a much cleaner syntax than the Java version in which it’s obvious that the BigInteger class has been grafted on and, without operator overloading being available, is a bit of a stranger in a strange land.

long n = 600851475143G
def (answer, i) = [ 0, 2G ]
while (n > 1) {
    if (i.isProbablePrime(100) && (n % i == 0)) {
        ( n, answer ) = [ n / i, i ]
    }
    i++
}

See how easy it is to make “i” a BigInteger simply by appending a “G” to the value assignment. So it’s still necessary to be aware of the type, but this makes it easier than having to explicitly “new” a BigInteger.

The timings for this non-sieve solution show that, for large numbers of primes to be checked it’s almost always preferable to use a sieve in Java, whereas in Groovy there’s a higher tolerance given the overhead of building that sieve.

Today I ran into Project Euler care of Stack Overflow, and decided to try my hand. I’m looking for excuses to play with F#, and this works great.

First problem:

If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23.

Find the sum of all the multiples of 3 or 5 below 1000.

Two solutions here – both more general than Euler requests. Note the nested functions and use of recursion in both. One uses familiar if/else conditionals:

let AddNums n =
    let rec add ceiling current sum =
        if current >= ceiling then
            sum
        else
            if current % 3 = 0 || current % 5 = 0 then
                add ceiling (current+1) (sum+current)
            else
                add ceiling (current+1) sum

    add n 1 0

The next solution uses F# pattern matching and guards. It’s functionally equivalent to the first, but highlights some F# power:

[/sourcecode]

Source code is here at Google Code.

The 8th problem in the Project Euler website didn’t offer a lot of resistance.

I started by defining the 1000-digit number in Haskell, naming it n. So, I had something like:

import Char
import List

n :: Integer
n = 73167176531 … 52963450

(I didn’t see the point of writing the entire number here, since it is very big). Afterwards, it was a matter of defining this simple function:

f :: Integer -> Int
f = head . reverse . sort . g . map digitToInt . show

Where g is defined as:

g (x1:x2:x3:x4:x5:xs) = x1*x2*x3*x4*x5 : g (x2:x3:x4:x5:xs)
g _ = []

You can argue that it could be more efficient, however my ghci calculates the following execution time:

(0.03 secs, 1834872 bytes)

Which is good enough

I could see that the problem 4 of the Euler project could be solve with a brute force function.

Since one needed to calculate the product of two 3-digit numbers, I created two lists of all possible 3-digit numbers, and tried all combinations. Here is my implementation:

import List

palindrome = [ n*m | n <- [100..999], m <- [100..999], show (n*m) == reverse (show (n*m)) ]

lpal = (last . sort) palindrome

GHCi took about 2 seconds (and a lot of bytes!) in my computer to figure out the result.

The 5th problem of the Project Euler was the first one that gave me some work, mainly because I started (again) by trying a brute force algorithm. Of course, I had problems with it, starting by not getting the solution at all!! It just took too much time to calculate it and I did not let it finish. I tried different values as input, but it was not enough. Here is the code I used:

f [] = 0
f (x:xs) = if condition x then x else f xs

condition :: Int -> Bool
condition = foldr (&&) True . apply
where apply n = [ mod n x == 0 | x <- [1..20]]

As you can see, I needed to give a list as input for the function f and be lucky enough to have the correct value within that list. After a few tries, I decided to think a bit more in the problem and searching a bit in the Haskell Prelude and I came across with the lcm function, which allowed me to solve this problem very efficiently:

g = foldr lcm 1 [1..20]

The problem 6 of the Euler project site was again easy to solve. Using Haskell, I wrote the following one-line function:

g = (sum [1..100] ^ 2) - (sum (map (^2) [1..100]))

When I looked to the Project Euler website, I was very excited with the problems, so I decided to join and try to solve as much as I can. Since I enjoy Haskell very much, I decided to try to solve them all with it.

The first problem is an easy one, in my opinion. Here you can see the problem description.

Since Haskell has a powerful list type, I took advantage of that and here it is my one-line solution for this problem:

f = foldr (+) 0 [a | a <- [1..1000], mod a 3 == 0 || mod a 5 == 0]