Merge branch 'master' of github.com:adelq/project-euler

23.jl

@@ -0,0 +1,36 @@
+# Upper bound for sums
+limit = 28123
+
+function isabundant(n)
+    factor_sum = 0
+    for i = 1:(n - 1)
+        if n % i == 0
+            factor_sum += i
+        end
+    end
+    return factor_sum > n
+end
+
+# Array of all possible abundant numbers
+all_abundants = filter(isabundant, [1:limit])
+
+# Create array of whether an integer can be expressed as a sum of 2 abundants
+sumOfAbundant = falses(limit)
+for i = all_abundants
+    for j = all_abundants
+        if i + j <= limit
+            sumOfAbundant[i + j] = true
+        else
+            break
+        end
+    end
+end
+
+# Sum up integers that cannot be expressed as sum of abundants
+sum = 0
+for (index, value) in enumerate(sumOfAbundant)
+    if !value
+        sum += index
+    end
+end
+println(sum)

27.jl

@@ -0,0 +1,40 @@
+function quadratic_prime(a, b)
+    return n -> n^2 + a*n + b
+end
+
+function isprime(n)
+    if n < 0
+        n *= -1
+    end
+    for i = 2:int(sqrt(n) + 1)
+        if n % i == 0
+            return false
+        end
+    end
+    return true
+end
+
+function number_of_primes(f)
+    prime = true
+    n = 0
+    while prime
+        n += 1
+        prime = isprime(f(n))
+    end
+    return n
+end
+
+max_primes = 0
+max_a = 0
+max_b = 0
+for i = -999:999
+    for j = -999:999
+        current_primes = number_of_primes(quadratic_prime(i, j))
+        if current_primes > max_primes
+            max_primes = current_primes
+            max_a = i
+            max_b = j
+        end
+    end
+end
+println(max_a * max_b)

4.py

@@ -4,9 +4,9 @@ def palindrome(number):
 
 palindromelist = []
 for i in range(1000):
-	for j in range(1000):
+	for j in range(i, 1000):
 		product = i*j
 		if palindrome(product):
 			palindromelist.append(product)
 
-print(max(palindromelist))
+print(max(palindromelist))

46.jl

@@ -0,0 +1,40 @@
+function isprime(n)
+    for i = 2:int(sqrt(n) + 1)
+        if n % i == 0
+            return false
+        end
+    end
+    return true
+end
+
+function isodd(n)
+    return n % 2 == 1
+end
+
+function goldbach(prime, square)
+    return prime + 2 * square
+end
+
+function istwicesquare(n)
+    square = sqrt(n/2)
+    return square == int(square)
+end
+
+primelist = filter(isprime, [1:10000])
+result = 1
+found = false
+
+while !found
+    result += 2
+    j = 1
+    found = true
+    while j <= length(primelist) && result >= primelist[j]
+        if istwicesquare(result - primelist[j])
+            found = false
+            break
+        end
+        j += 1
+    end
+end
+
+println(result)

problem01.go

@@ -0,0 +1,13 @@
+package main
+
+import "fmt"
+
+func main() {
+	sum := 0
+	for i := 0; i < 1000; i++ {
+		if i%3 == 0 || i%5 == 0 {
+			sum += i
+		}
+	}
+	fmt.Println(sum)
+}

problem02.go

@@ -0,0 +1,13 @@
+package main
+
+import "fmt"
+
+func main() {
+	sum := 0
+	for i, j := 1, 1; j < 4e6; i, j = i+j, i {
+		if j%2 == 0 {
+			sum += j
+		}
+	}
+	fmt.Println(sum)
+}

problem03.go

@@ -0,0 +1,23 @@
+package main
+
+import "fmt"
+
+func main() {
+	fmt.Println(maxPrimeFactor(13195))
+	fmt.Println(maxPrimeFactor(600851475143))
+}
+
+func maxPrimeFactor(n int) int {
+	var maxFactor int
+	d := 2
+	for n > 1 {
+		for n%d == 0 {
+			if d > maxFactor {
+				maxFactor = d
+			}
+			n /= d
+		}
+		d++
+	}
+	return maxFactor
+}

problem04.go

@@ -0,0 +1,29 @@
+package main
+
+import (
+	"fmt"
+	"strconv"
+)
+
+func main() {
+	var maxPalindrome int
+	for i := 0; i < 1000; i++ {
+		for j := i; j < 1000; j++ {
+			product := i * j
+			if palindrome(product) && product > maxPalindrome {
+				maxPalindrome = product
+			}
+		}
+	}
+	fmt.Println(maxPalindrome)
+}
+
+func palindrome(n int) bool {
+	number := strconv.Itoa(n)
+	for i, j := 0, len(number)-1; i < j; i, j = i+1, j-1 {
+		if number[i] != number[j] {
+			return false
+		}
+	}
+	return true
+}

problem05.go

@@ -0,0 +1,7 @@
+package main
+
+import "fmt"
+
+func main() {
+	fmt.Println(2520 * 11 * 13 * 17 * 19 * 2)
+}

problem06.go

@@ -0,0 +1,24 @@
+package main
+
+import "fmt"
+
+func main() {
+	n := 100
+	fmt.Println(sqsum(n) - sumsq(n))
+}
+
+func sqsum(n int) int {
+	s := 0
+	for i := 0; i <= n; i++ {
+		s += i
+	}
+	return s * s
+}
+
+func sumsq(n int) int {
+	s := 0
+	for i := 0; i <= n; i++ {
+		s += i * i
+	}
+	return s
+}

problem07.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"fmt"
+	"math"
+)
+
+func main() {
+	n := 0
+	i := 0
+	for n < 10001 {
+		i++
+		if prime(i) {
+			n++
+		}
+	}
+	fmt.Println(i)
+}
+
+func prime(n int) bool {
+	if n <= 1 {
+		return false
+	}
+	for i := 2; i < int(math.Sqrt(float64(n))+1); i++ {
+		if n%i == 0 {
+			return false
+		}
+	}
+	return true
+}

problem10.go

@@ -0,0 +1,28 @@
+package main
+
+import (
+	"fmt"
+	"math"
+)
+
+func main() {
+	sum := 0
+	for i := 0; i < 2e6; i++ {
+		if prime(i) {
+			sum += i
+		}
+	}
+	fmt.Println(sum)
+}
+
+func prime(n int) bool {
+	if n <= 1 {
+		return false
+	}
+	for i := 2; i < int(math.Sqrt(float64(n))+1); i++ {
+		if n%i == 0 {
+			return false
+		}
+	}
+	return true
+}

problem14.go

@@ -0,0 +1,40 @@
+package main
+
+import "fmt"
+
+var chainLengths = make(map[int]int)
+
+func main() {
+	var maxChainLength int
+	var maxStarting int
+	for i := 1; i < 1e6; i++ {
+		l := ChainLength(i)
+		if l > maxChainLength {
+			maxChainLength = l
+			maxStarting = i
+		}
+	}
+	fmt.Println(maxStarting)
+}
+
+func Collatz(n int) int {
+	if n%2 == 0 {
+		return n / 2
+	} else {
+		return 3*n + 1
+	}
+}
+
+func ChainLength(n int) int {
+	l := 0
+	for n != 1 {
+		i, ok := chainLengths[n]
+		if ok {
+			return l + i
+		}
+		n = Collatz(n)
+		l++
+	}
+	chainLengths[n] = l
+	return l + 1
+}