Problem 18 and 67 are a good example. My brute force code on 18 takes longer than my elegant code on 67 which is essentially the same problem only larger.

My approach is just the opposite, and that’s the appeal of Euler–you and I are after different things. I’ve done 41, and about half were prototyped in a spreadsheet and then moved on to VBA. The spreadsheet graphic allows me to visualize the arrays (key examples would be the triangles of Problems 18 and 67) and gives me insight to the code. I started this to expand my coding. I never coded the opening of a file in VBA before I started Euler.

301 columns? That’s cheating…

…mrt

My solution, which only took about 3 minutes to write, is to “build” the answer over multiple columns, one column for each digit of the answer.

Imagine that row 1 holds 2 ** 1, row 2 is 2 ** 2, etc. I calculated 2 ** n in the normal way in column a – at row 48 (2 ** 49), the answer is 562,949,953,421,312, which has 15 digits and is the biggest number you can get before losing precision.

So, in column C, I calculate the last digit of the answer. This is done by seeding a ’2′ in column C1 and calculating the 999 rows below as ‘=mod(cell above me*2, 10). This will work fine for all 1,000 rows, but it is only the last digit – I need a way to calculate the other digits.

So, I copied the following formula ‘=MOD((2*cell above me)+IF(cell above me and one to the left*2>=10,1,0),10)’ to the range d4…ku1000. I used this range because a) you have to skip the top three rows where there is only one digit (2, 4, and the answer to =power(2, 1000) is 1.07E+301, so I went out 305 positions just to be safe (D … KU is 305 columns).

This formula basically looks to see if we need to carry the one.

Using the approach, it built my answer in 301 columns of row 1000. The only hard part is that you have to read the number left to right (backwards), but it is easy to calculate =sum(d1000 .. ku 1000) for the answer.

Has anyone else tried to solve all of these using basic Excel?

I look forward to your “large” functions. My attempt at multiplication has two virtues: (1) it’s accurate and (2) it’s slow. It’ll never meet any standards for Euler time.

I can see nothing but good stuff on your webpages. Thank you for making a Euler page.

…best, Michael (well known for wasting people’s time )

Thanks for getting me hooked on yet other way to spend (waste, some might call it) my time. {grin}

I wrote a set of functions LargeAdd, LargeMult (requires LargeAdd), LargePower, and LargeFactorial (the last two require LargeMult) that work with numbers with more than 15 significant digits. But, before I share my take on Problem 16, I’d like to start with my solutions to other problems. Of course, what I share is not as much the solution as a road map to the solution.

The list of what I have solved (in the sense that the Project Euler website accepts my answer) and written up the solution is at
Project Euler Problems
http://www.tushar-mehta.com/misc_tutorials/project_euler/

…Michael (Blessings of the season to all)

I wouldn’t really call it brute force. There was a real brute force one in the discussion which just tries every feasible combination of the coins, and counts the ones that add up to 200. I converted that from Java to VBA and started it about five minutes ago, and it’s still running.

I might try it in Fortran and see if it completes within the time limit.

I thought the Haskell and Mathematica examples that do this in 2 or 3 lines were just annoying

Might have a go at trying to work out how they do it over Christmas.

Sub P31()

Dim P1 As Long, P2 As Long, P5 As Long, P10 As Long, P20 As Long, P50 As Long, P100 As Long, P200 As Long
Dim n1 As Long, n2 As Long, n5 As Long, n10 As Long, n20 As Long, n50 As Long, n100 As Long, n200 As Long
Dim n As Long
For P1 = 0 To 200 Step 1
n1 = P1
For P2 = 0 To 200 – n1 Step 2
n2 = n1 + P2
For P5 = 0 To 200 – n2 Step 5
n5 = n2 + P5
For P10 = 0 To 200 – n5 Step 10
n10 = n5 + P10
For P20 = 0 To 200 – n10 Step 20
n20 = n10 + P20
For P50 = 0 To 200 – n20 Step 50
n50 = n20 + P50
For P100 = 0 To 200 – n50 Step 100
n100 = n50 + P100
For P200 = 0 To 200 – n100 Step 200
If n100 + P200 = 200 Then
n = n + 1
End If
Next P200
Next P100
Next P50
Next P20
Next P10
Next P5
Next P2
Next P1
Debug.Print n

End Sub

For some reason I found number 31 difficult and haven’t solved it yet (and no time at the moment).

I noticed the anti-VBA bias as well. I also noticed some compiled solutions that took hours that were solvable in less than a second. The algorithm is much more important than the programming language with these things.

Anyone wanting a VBA prime number generator might like to have a look here:
http://newtonexcelbach.wordpress.com/2008/11/18/finding-prime-numbers-with-excel-and-using-array-

It is faster than your AddAsStrings because instead of working character by character, it breaks the numbers into chunks of 7 chars which can be multiplied normally, then the chunks are combined.

But the real key to speed is to start by calculating 2^40 normally, then incrementing it as shown below, to reduce the number of arithmetic operations.

k = 2 ^ 40
S = CStr(k)
s1 = BigMultiply(S, S) ’80
s1 = BigMultiply(s1, S) ’120
s1 = BigMultiply(s1, 32) ’125
s1 = BigMultiply(s1, s1) ’250
s1 = BigMultiply(s1, s1) ’500
s1 = BigMultiply(s1, s1) ’1000

I have quite a number of the problems solved, and am stuck on others, and I am happy to share, especially helper functions like prime number tests that are needed quite often.