# src/euler.lisp @ 32aa6dc56935

`Problem 11 (ugly)`
author Steve Losh Fri, 10 Feb 2017 21:30:11 +0000 829e38d1f825 55e8aef75bee
```(in-package :euler)

;;;; Utils --------------------------------------------------------------------
(defun digits (n)
"Return how many digits `n` has in base 10."
(values (truncate (1+ (log n 10)))))

(defun definitely-palindrome-p (n)
"Return whether `n` is a palindrome (in base 10), the slow-but-sure way."
(let ((s (format nil "~D" n)))
(string= s (reverse s))))

(defun palindromep (n)
"Return whether `n` is a palindrome (in base 10)."
(assert (>= n 0) (n) "~A must be a non-negative integer" n)
;; All even-length base-10 palindromes are divisible by 11, so we can shortcut
;; the awful string comparison. E.g.:
;;
;;   abccba =
;;   100001 * a +
;;   010010 * b +
;;   001100 * c
(cond
((zerop n) t)
((and (evenp (digits n))
(not (dividesp n 11))) nil)
(t (definitely-palindrome-p n))))

(defun sum (sequence)
(iterate (for n :in-whatever sequence)
(sum n)))

;;;; Problems -----------------------------------------------------------------
(defun problem-1 ()
;; 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.
(iterate (for i :from 1 :below 1000)
(when (or (dividesp i 3)
(dividesp i 5))
(sum i))))

(defun problem-2 ()
;; 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, ...
;;
;; By considering the terms in the Fibonacci sequence whose values do not
;; exceed four million, find the sum of the even-valued terms.
(iterate (with a = 0)
(with b = 1)
(while (<= b 4000000))
(when (evenp b)
(sum b))
(psetf a b
b (+ a b))))

(defun problem-3 ()
;; The prime factors of 13195 are 5, 7, 13 and 29.
;;
;; What is the largest prime factor of the number 600851475143 ?
(apply #'max (prime-factorization 600851475143)))

(defun problem-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.
(iterate (for-nested ((i :from 0 :to 999)
(j :from 0 :to 999)))
(for product = (* i j))
(when (palindromep product)
(maximize product))))

(defun problem-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?
(iterate
;; all numbers are divisible by 1 and we can skip checking everything <= 10
;; because:
;;
;; anything divisible by 12 is automatically divisible by 2
;; anything divisible by 12 is automatically divisible by 3
;; anything divisible by 12 is automatically divisible by 4
;; anything divisible by 15 is automatically divisible by 5
;; anything divisible by 12 is automatically divisible by 6
;; anything divisible by 14 is automatically divisible by 7
;; anything divisible by 16 is automatically divisible by 8
;; anything divisible by 18 is automatically divisible by 9
;; anything divisible by 20 is automatically divisible by 10
(with divisors = (range 11 21))
(for i :from 20 :by 20) ; it must be divisible by 20
(finding i :such-that (every (lambda (n) (dividesp i n))
divisors))))

(defun problem-6 ()
;; The sum of the squares of the first ten natural numbers is,
;;   1² + 2² + ... + 10² = 385
;;
;; The square of the sum of the first ten natural numbers is,
;;   (1 + 2 + ... + 10)² = 55² = 3025
;;
;; Hence the difference between the sum of the squares of the first ten
;; natural numbers and the square of the sum is 3025 − 385 = 2640.
;;
;; Find the difference between the sum of the squares of the first one hundred
;; natural numbers and the square of the sum.
(flet ((sum-of-squares (to)
(sum (range 1 (1+ to) :key #'square)))
(square-of-sum (to)
(square (sum (range 1 (1+ to))))))
(abs (- (sum-of-squares 100) ; apparently it wants the absolute value
(square-of-sum 100)))))

(defun problem-7 ()
;; By listing the first six prime numbers: 2, 3, 5, 7, 11, and 13, we can see
;; that the 6th prime is 13.
;;
;; What is the 10 001st prime number?
(nth-prime 10001))

(defun problem-8 ()
;; The four adjacent digits in the 1000-digit number that have the greatest
;; product are 9 × 9 × 8 × 9 = 5832.
;;
;; Find the thirteen adjacent digits in the 1000-digit number that have the
;; greatest product. What is the value of this product?
(let ((digits (map 'list #'digit-char-p
"7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450")))
(iterate (for window :in (n-grams 13 digits))
(maximize (apply #'* window)))))

(defun problem-9 ()
;; A Pythagorean triplet is a set of three natural numbers, a < b < c, for
;; which:
;;
;;   a² + b² = c²
;;
;; For example, 3² + 4² = 9 + 16 = 25 = 5².
;;
;; There exists exactly one Pythagorean triplet for which a + b + c = 1000.
;; Find the product abc.
(flet ((pythagorean-triplet-p (a b c)
(= (+ (square a) (square b))
(square c))))
;; They must add up to 1000, so C can be at most 998.
;; A can be at most 999 - C (to leave 1 for B).
(iterate (for c :from 998 :downto 1)
(iterate (for a :from (- 999 c) :downto 1)
(for b = (- 1000 c a))
(when (pythagorean-triplet-p a b c)
(return-from problem-9 (* a b c)))))))

(defun problem-10 ()
;; The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17.
;; Find the sum of all the primes below two million.
(sum (primes-below 2000000)))

(defun problem-11 ()
;; In the 20×20 grid below, four numbers along a diagonal line have been marked
;; in red.
;;
;; The product of these numbers is 26 × 63 × 78 × 14 = 1788696.
;;
;; What is the greatest product of four adjacent numbers in the same direction
;; (up, down, left, right, or diagonally) in the 20×20 grid?
(let ((grid
#2A((08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08)
(49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00)
(81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65)
(52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91)
(22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80)
(24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50)
(32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70)
(67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21)
(24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72)
(21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95)
(78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92)
(16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57)
(86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58)
(19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40)
(04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66)
(88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69)
(04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36)
(20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16)
(20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54)
(01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48))))
(max
;; horizontal
(iterate (for-nested ((row :from 0 :below 20)
(col :from 0 :below 16)))
(maximize (* (aref grid row (+ 0 col))
(aref grid row (+ 1 col))
(aref grid row (+ 2 col))
(aref grid row (+ 3 col)))))
;; vertical
(iterate (for-nested ((row :from 0 :below 16)
(col :from 0 :below 20)))
(maximize (* (aref grid (+ 0 row) col)
(aref grid (+ 1 row) col)
(aref grid (+ 2 row) col)
(aref grid (+ 3 row) col))))
;; backslash \
(iterate (for-nested ((row :from 0 :below 16)
(col :from 0 :below 16)))
(maximize (* (aref grid (+ 0 row) (+ 0 col))
(aref grid (+ 1 row) (+ 1 col))
(aref grid (+ 2 row) (+ 2 col))
(aref grid (+ 3 row) (+ 3 col)))))
;; slash /
(iterate (for-nested ((row :from 3 :below 20)
(col :from 0 :below 16)))
(maximize (* (aref grid (- row 0) (+ 0 col))
(aref grid (- row 1) (+ 1 col))
(aref grid (- row 2) (+ 2 col))
(aref grid (- row 3) (+ 3 col))))))))

;;;; Tests --------------------------------------------------------------------
(def-suite :euler)
(in-suite :euler)

(test p1 (is (= 233168 (problem-1))))
(test p2 (is (= 4613732 (problem-2))))
(test p3 (is (= 6857 (problem-3))))
(test p4 (is (= 906609 (problem-4))))
(test p5 (is (= 232792560 (problem-5))))
(test p6 (is (= 25164150 (problem-6))))
(test p7 (is (= 104743 (problem-7))))
(test p8 (is (= 23514624000 (problem-8))))
(test p9 (is (= 31875000 (problem-9))))
(test p10 (is (= 142913828922 (problem-10))))
(test p11 (is (= 70600674 (problem-11))))

; (run! :euler)```