···

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

     

       
15
       
 
       
    [l, w, h] = v

     

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

     

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

     

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

     

       
19
       
 
       
  end)

     

       
20
       
 
       
  |> IO.puts()

     

       
21
       
 
       


     

       
22
       
 
       
  input

     

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

     

       
24
       
-
       
    [l, w, h] = v

     

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

     

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

     

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

     

       
0
       
 
       

     

       
28
       
 
       
  end)

     

       
29
       
 
       
  |> IO.puts()

     

       
30
       
 
       
end

     

···

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

     

       
15
       
 
       
    [l, w, h] = v

     

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

     

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

     

       
0
       
 
       

     

       
18
       
 
       
  end)

     

       
19
       
 
       
  |> IO.puts()

     

       
20
       
 
       


     

       
21
       
 
       
  input

     

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

     

       
23
       
+
       
    [l, w, h] = measure

     

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

     

       
25
       
+
       


     

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

     

       
27
       
+
       
      Enum.min(half_perimeter) * 2

     

       
28
       
 
       
  end)

     

       
29
       
 
       
  |> IO.puts()

     

       
30
       
 
       
end

     

···

       
18
       
 
       


     

       
19
       
 
       
  // part 1

     

       
20
       
 
       
  input

     

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

     

       
22
       
 
       
    let sides =

     

       
23
       
 
       
      cur

     

       
24
       
 
       
      |> list.combinations(2)

     

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

     

       
26
       
 
       


     

       
27
       
-
       
    prev

     

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

     

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

     

       
30
       
 
       
  })

     

       
31
       
 
       
  |> int.to_string

     
···

       
33
       
 
       


     

       
34
       
 
       
  // part 2

     

       
35
       
 
       
  input

     

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

     

       
37
       
 
       
    let smallest_perimeter =

     

       
38
       
-
       
      list.reduce(

     

       
39
       
-
       
        cur

     

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

     

       
41
       
-
       
          |> list.combinations(2)

     

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

     

       
43
       
-
       
        int.min,

     

       
44
       
-
       
      )

     

       
45
       
 
       
      |> result.unwrap(0)

     

       
46
       
 
       


     

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

     

       
48
       
 
       
  })

     

       
49
       
 
       
  |> int.to_string

     

       
50
       
 
       
  |> io.println

     

···

       
18
       
 
       


     

       
19
       
 
       
  // part 1

     

       
20
       
 
       
  input

     

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

     

       
22
       
 
       
    let sides =

     

       
23
       
 
       
      cur

     

       
24
       
 
       
      |> list.combinations(2)

     

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

     

       
26
       
 
       


     

       
27
       
+
       
    acc

     

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

     

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

     

       
30
       
 
       
  })

     

       
31
       
 
       
  |> int.to_string

     
···

       
33
       
 
       


     

       
34
       
 
       
  // part 2

     

       
35
       
 
       
  input

     

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

     

       
37
       
 
       
    let smallest_perimeter =

     

       
38
       
+
       
      cur

     

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

     

       
40
       
+
       
      |> list.combinations(2)

     

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

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
43
       
 
       
      |> result.unwrap(0)

     

       
44
       
 
       


     

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

     

       
46
       
 
       
  })

     

       
47
       
 
       
  |> int.to_string

     

       
48
       
 
       
  |> io.println