package dev.mikeburgess.euler.problems

import dev.mikeburgess.euler.extensions.*
import dev.mikeburgess.euler.math.lcm
import dev.mikeburgess.euler.sequences.fibonacciSequence
import dev.mikeburgess.euler.sequences.primeSequence
import org.assertj.core.api.Assertions.assertThat
import kotlin.test.Test

class Problems00x {

    /**
     * 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.
     */
    @Test
    fun `Problem 1`() {
        val result = (1 until 1000L)
            .filter { it % 3 == 0L || it % 5 == 0L }
            .sum()

        assertThat(result).isEqualTo(233168L)
    }

    /**
     * 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.
     */
    @Test
    fun `Problem 2`() {
        val result = fibonacciSequence()
            .takeWhile { it < 4_000_000 }
            .filter { it.isEven() }
            .sum()

        assertThat(result).isEqualTo(4613732L)
    }

    /**
     * Problem 3
     *
     * The prime factors of 13195 are 5, 7, 13 and 29.
     *
     * What is the largest prime factor of the number 600851475143?
     */
    @Test
    fun `Problem 3`() {
        var number = 600_851_475_143
        var factor = 2L
        while (factor < number) {
            when {
                number % factor == 0L -> number /= factor
                else -> factor++
            }
        }

        assertThat(factor).isEqualTo(6857L)
    }

    /**
     * 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.
     */
    @Test
    fun `Problem 4`() {
        val result = (100..999L)
            .associateWith { it..999L }
            .flatMap { entry -> entry.value.map { entry.key * it } }
            .filter { it.isPalindrome() }
            .maxOf { it }

        assertThat(result).isEqualTo(906609L)
    }

    /**
     * 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?
     */
    @Test
    fun `Problem 5`() {
        val result = (1..20L)
            .reduce { x, y -> lcm(x, y) }

        assertThat(result).isEqualTo(232792560L)
    }

    /**
     * Problem 6
     *
     * The sum of the squares of the first ten natural numbers is,
     *
     * 1^2 + 2^2 + ... + 10^2 = 385
     *
     * The square of the sum of the first ten natural numbers is,
     *
     * (1 + 2 + ... + 10)^2 = 552 = 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.
     */
    @Test
    fun `Problem 6`() {
        val sumOfSquares = (1..100L).sumOf { it.squared() }
        val squareOfSums = (1..100L).sum().squared()
        val result = squareOfSums - sumOfSquares

        assertThat(result).isEqualTo(25164150L)
    }

    /**
     * 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?
     */
    @Test
    fun `Problem 7`() {
        val result = primeSequence()
            .take(10001)
            .last()

        assertThat(result).isEqualTo(104743L)
    }

    /**
     * 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?
     */
    @Test
    fun `Problem 8`() {
        val number = "73167176531330624919225119674426574742355349194934" +
                "96983520312774506326239578318016984801869478851843" +
                "85861560789112949495459501737958331952853208805511" +
                "12540698747158523863050715693290963295227443043557" +
                "66896648950445244523161731856403098711121722383113" +
                "62229893423380308135336276614282806444486645238749" +
                "30358907296290491560440772390713810515859307960866" +
                "70172427121883998797908792274921901699720888093776" +
                "65727333001053367881220235421809751254540594752243" +
                "52584907711670556013604839586446706324415722155397" +
                "53697817977846174064955149290862569321978468622482" +
                "83972241375657056057490261407972968652414535100474" +
                "82166370484403199890008895243450658541227588666881" +
                "16427171479924442928230863465674813919123162824586" +
                "17866458359124566529476545682848912883142607690042" +
                "24219022671055626321111109370544217506941658960408" +
                "07198403850962455444362981230987879927244284909188" +
                "84580156166097919133875499200524063689912560717606" +
                "05886116467109405077541002256983155200055935729725" +
                "71636269561882670428252483600823257530420752963450"

        val result = (13..number.length)
            .map { number.subSequence(it - 13, it) }
            .maxOf {
                it.chars()
                    .mapToLong { c -> c - '0'.code.toLong() }
                    .reduce(1) { x, y -> x * y }
            }

        assertThat(result).isEqualTo(23514624000L)
    }

    /**
     * Problem 9
     *
     * A Pythagorean triplet is a set of three natural numbers, a < b < c, for which,
     *
     * a^2 + b^2 = c^2
     *
     * For example, 3^2 + 4^2 = 9 + 16 = 25 = 5^2.
     *
     * There exists exactly one Pythagorean triplet for which a + b + c = 1000.
     * Find the product abc.
     */
    @Test
    fun `Problem 9`() {
        val result = (1..332L)
            .flatMap { a -> LongRange(a + 1, (1000 - a) / 2).map { b -> a to b to 1000 - a - b } }
            .first { it.isPythagorean() }
            .product()

        assertThat(result).isEqualTo(31875000L)
    }
}
