commit f634066360d028bccfbbca3028fcbdc03698b3d4 · aylac.top/advent_of_code

+6 -6

2015/2/elixir/main.exs

···

       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

     

       17
       17
       +
           acc + Enum.sum(sides) * 2 + Enum.min(sides)

     

       19
       18
        
         end)

     

       20
       19
        
         |> IO.puts()

     

       21
       20
        
       

     

       22
       21
        
         input

     

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

     

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

     

       22
       22
       +
         |> Enum.reduce(0, fn measure, acc ->

     

       23
       23
       +
           [l, w, h] = measure

     

       25
       24
        
           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

     

       25
       25
       +
       

     

       26
       26
       +
           acc + Enum.reduce(measure, fn a, b -> a * b end) +

     

       27
       27
       +
             Enum.min(half_perimeter) * 2

     

       28
       28
        
         end)

     

       29
       29
        
         |> IO.puts()

     

       30
       30
        
       end

+10 -12

2015/2/gleam/src/main.gleam

···

       18
       18
        
       

     

       19
       19
        
         // part 1

     

       20
       20
        
         input

     

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

     

       21
       21
       +
         |> list.fold(0, fn(acc, 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) })

     

       26
       26
        
       

     

       27
       27
       -
           prev

     

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

     

       27
       27
       +
           acc

     

       28
       28
       +
           + { list.fold(sides, 0, int.add) |> int.multiply(2) }

     

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

     

       30
       30
        
         })

     

       31
       31
        
         |> int.to_string

     
···

       33
       33
        
       

     

       34
       34
        
         // part 2

     

       35
       35
        
         input

     

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

     

       36
       36
       +
         |> list.fold(0, fn(acc, 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
       -
             )

     

       38
       38
       +
             cur

     

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

     

       40
       40
       +
             |> list.combinations(2)

     

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

     

       42
       42
       +
             |> list.reduce(int.min)

     

       45
       43
        
             |> result.unwrap(0)

     

       46
       44
        
       

     

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

     

       45
       45
       +
           acc + smallest_perimeter + list.fold(cur, 1, int.multiply)

     

       48
       46
        
         })

     

       49
       47
        
         |> int.to_string

     

       50
       48
        
         |> io.println