Quick Search

# Page History: Project Euler Comes to Azeroth

Compare Page Revisions

 « Older Revision - Back to Page History - Newer Revision »

# Intro

I joked with my friend Dustin about creating solutions to the Project Euler problems using LUA (and running them in WoW). Here's where I'll post those solutions as I finish them.

I'll try to generalize my solutions where I see fit. For example, I added a parameter to Problem 1 to set the upper limit of 1000, but I did not parameterize the 3 and 5, etc.

# Problem 1

```function ProjectEuler:OnEnable()
ProjectEuler:Problem001(1000)
end
function ProjectEuler:Problem001(upperLimit)
self:Print("Sum of all numbers less than "
.. upperLimit .. " that are divisible by 3 or 5")

local f = function(factor)
local n = math.ceil(upperLimit / factor)
return n * (n-1) * factor / 2
end

local result = f(3) + f(5) - f(15)

self:Print(result)
end```

# Problem 2

```function ProjectEuler:Problem002(upperLimit)
self:Print("Sum of all even numbers less than " .. upperLimit .. " in Fibonacci Sequence")

local result, x1, x2 = 0, 1, 2

local f = function(t1, t2)
return t2, t1+t2
end

while x2 < upperLimit
do
result = result + x2
x1,x2 = f(f(f(x1,x2)))
end

self:Print(result)
end```

# Problem 3

```function ProjectEuler:Problem003(composite)
self:Print("Largest prime factor of "..composite)

local n = 2

while n < (composite / n)
do
if composite % n == 0 then
composite = composite / n
self:Print("prime factor="..n);
n = 1 -- reset N to ensure primes (i.e., 2x2x3x5x5 = 300)
end
n=n+1
end

self:Print("The largest is: "..composite)
end```

# Problem 4

I don't feel like this is a necessarily elegant solution... Maybe the challenge is in the palindrome logic... /shrug

```function ProjectEuler:Problem004()

local reverse = function(a)
local result = 0
while a > 0
do
result = result * 10 + mod(a,10)
a = floor(a/10)
end

return result
end

for n=999,900,-1
do
for m=n,900,-1
do
local x = n*m
if x == reverse(x) then
self:Print("Palindrome: "..x)
return
end
end
end
end```

# Problem 5

f() is called recursively to prime factorize each of the numbers to 20. My brute force method of generating the LCM first divides out any common prime factors (between the 1..20 series and the accumulated LCM) and then multiplies by the iteration number (1-20).
```function ProjectEuler:Problem005()

local result = 1
local f = function(x)
for i = 2, x
do
if x % i == 0 then
return i, x / i
end
end

return 1, x
end

for n = 20, 3, -1
do
local z = n
while z > 1
do
pf, z = f(z)
if pf == 1 then break end
if result % pf == 0 then result = result / pf end
end
result = result * n
end

self:Print(result)

end```

ScrewTurn Wiki version 2.0.13. Some of the icons created by FamFamFam.