commit ba53422e81970dc012c139db08874e5c0404aa4e · aylac.top/advent_of_code

+30

2015/2/elixir/main.exs

···

       1
       1
       +
       defmodule Main do

     

       2
       2
       +
         {_, input} =

     

       3
       3
       +
           File.read("../input.txt")

     

       4
       4
       +
       

     

       5
       5
       +
         input =

     

       6
       6
       +
           input

     

       7
       7
       +
           |> String.trim()

     

       8
       8
       +
           |> String.split("\n")

     

       9
       9
       +
           |> Enum.map(fn v ->

     

       10
       10
       +
             v |> String.split("x") |> Enum.map(fn v -> String.to_integer(v) end)

     

       11
       11
       +
           end)

     

       12
       12
       +
       

     

       13
       13
       +
         input

     

       14
       14
       +
         |> Enum.reduce(0, fn v, acc ->

     

       15
       15
       +
           [l, w, h] = v

     

       16
       16
       +
           sides = [l * w, w * h, h * l]

     

       17
       17
       +
           smallest = sides |> Enum.reduce(fn a, b -> min(a, b) end)

     

       18
       18
       +
           (sides |> Enum.sum()) * 2 + smallest + acc

     

       19
       19
       +
         end)

     

       20
       20
       +
         |> IO.puts()

     

       21
       21
       +
       

     

       22
       22
       +
         input

     

       23
       23
       +
         |> Enum.reduce(0, fn v, acc ->

     

       24
       24
       +
           [l, w, h] = v

     

       25
       25
       +
           half_perimeter = [l + w, w + h, h + l]

     

       26
       26
       +
           smallest_half_perimeter = half_perimeter |> Enum.reduce(fn a, b -> min(a, b) end)

     

       27
       27
       +
           l * w * h + smallest_half_perimeter * 2 + acc

     

       28
       28
       +
         end)

     

       29
       29
       +
         |> IO.puts()

     

       30
       30
       +
       end

+40 -42

2015/2/gleam/src/main.gleam

···

       1
       1
       -
       import gleam/int.{add, min, multiply, to_string}

     

       2
       2
       -
       import gleam/io.{println}

     

       3
       3
       -
       import gleam/list.{combinations, fold, map, reduce}

     

       4
       4
       -
       import gleam/result.{unwrap}

     

       5
       5
       -
       import gleam/string.{split, trim}

     

       6
       6
       -
       import simplifile.{read}

     

       1
       1
       +
       import gleam/int

     

       2
       2
       +
       import gleam/io

     

       3
       3
       +
       import gleam/list

     

       4
       4
       +
       import gleam/result

     

       5
       5
       +
       import gleam/string

     

       6
       6
       +
       import simplifile as file

     

       7
       7
        
       

     

       8
       8
        
       pub fn main() {

     

       9
       9
        
         let input =

     

       10
       10
       -
           read(from: "../input.txt")

     

       11
       11
       -
           |> unwrap("")

     

       12
       12
       -
           |> trim()

     

       13
       13
       -
           |> split("\n")

     

       14
       14
       -
           |> map(fn(str) {

     

       15
       15
       -
             split(str, "x")

     

       16
       16
       -
             |> map(fn(str) { int.base_parse(str, 10) |> unwrap(0) })

     

       10
       10
       +
           file.read(from: "../input.txt")

     

       11
       11
       +
           |> result.unwrap("")

     

       12
       12
       +
           |> string.trim

     

       13
       13
       +
           |> string.split("\n")

     

       14
       14
       +
           |> list.map(fn(str) {

     

       15
       15
       +
             string.split(str, "x")

     

       16
       16
       +
             |> list.map(fn(str) { int.base_parse(str, 10) |> result.unwrap(0) })

     

       17
       17
        
           })

     

       18
       18
        
       

     

       19
       19
        
         // part 1

     

       20
       20
       -
         println(

     

       21
       21
       -
           input

     

       22
       22
       -
           |> fold(0, fn(prev, cur) {

     

       23
       23
       -
             let sides =

     

       24
       24
       -
               cur

     

       25
       25
       -
               |> combinations(2)

     

       26
       26
       -
               |> map(fn(v) { fold(v, 1, multiply) })

     

       20
       20
       +
         input

     

       21
       21
       +
         |> list.fold(0, fn(prev, cur) {

     

       22
       22
       +
           let sides =

     

       23
       23
       +
             cur

     

       24
       24
       +
             |> list.combinations(2)

     

       25
       25
       +
             |> list.map(fn(v) { list.fold(v, 1, int.multiply) })

     

       27
       26
        
       

     

       28
       28
       -
             prev

     

       29
       29
       -
             + fold(sides, 0, fn(prev, cur) { prev + 2 * cur })

     

       30
       30
       -
             + { reduce(sides, min) |> unwrap(0) }

     

       31
       31
       -
           })

     

       32
       32
       -
           |> to_string,

     

       33
       33
       -
         )

     

       27
       27
       +
           prev

     

       28
       28
       +
           + list.fold(sides, 0, fn(prev, cur) { prev + 2 * cur })

     

       29
       29
       +
           + { list.reduce(sides, int.min) |> result.unwrap(0) }

     

       30
       30
       +
         })

     

       31
       31
       +
         |> int.to_string

     

       32
       32
       +
         |> io.println

     

       34
       33
        
       

     

       35
       34
        
         // part 2

     

       36
       36
       -
         println(

     

       37
       37
       -
           input

     

       38
       38
       -
           |> fold(0, fn(prev, cur) {

     

       39
       39
       -
             let smallest_perimeter =

     

       40
       40
       -
               reduce(

     

       41
       41
       -
                 cur

     

       42
       42
       -
                   |> map(fn(v) { multiply(v, 2) })

     

       43
       43
       -
                   |> combinations(2)

     

       44
       44
       -
                   |> map(fn(v) { fold(v, 0, add) }),

     

       45
       45
       -
                 min,

     

       46
       46
       -
               )

     

       47
       47
       -
               |> unwrap(0)

     

       35
       35
       +
         input

     

       36
       36
       +
         |> list.fold(0, fn(prev, cur) {

     

       37
       37
       +
           let smallest_perimeter =

     

       38
       38
       +
             list.reduce(

     

       39
       39
       +
               cur

     

       40
       40
       +
                 |> list.map(fn(v) { v |> int.multiply(2) })

     

       41
       41
       +
                 |> list.combinations(2)

     

       42
       42
       +
                 |> list.map(fn(v) { list.fold(v, 0, int.add) }),

     

       43
       43
       +
               int.min,

     

       44
       44
       +
             )

     

       45
       45
       +
             |> result.unwrap(0)

     

       48
       46
        
       

     

       49
       49
       -
             prev + smallest_perimeter + fold(cur, 1, multiply)

     

       50
       50
       -
           })

     

       51
       51
       -
           |> to_string,

     

       52
       52
       -
         )

     

       47
       47
       +
           prev + smallest_perimeter + list.fold(cur, 1, int.multiply)

     

       48
       48
       +
         })

     

       49
       49
       +
         |> int.to_string

     

       50
       50
       +
         |> io.println

     

       53
       51
        
       }