···

       
1
       
 
       
import gleam/dict.{type Dict}

     

       
2
       
-
       
import gleam/dynamic

     

       
3
       
 
       
import gleam/dynamic/decode

     

       
4
       
 
       
import gleam/int.{to_string}

     

       
5
       
 
       
import gleam/io.{println}

     

       
6
       
 
       
import gleam/json

     

       
7
       
 
       
import gleam/list

     

       
8
       
 
       
import gleam/result.{unwrap}

     

       
9
       
-
       
import gleam/string.{trim}

     

       
10
       
 
       
import simplifile.{read}

     

       
11
       
 
       


     

       
12
       
 
       
type Nested {

     
···

       
25
       
 
       
  ])

     

       
26
       
 
       
}

     

       
27
       
 
       


     

       
28
       
-
       
fn get_total_number_dict(data: Dict(String, Nested)) {

     

       
29
       
-
       
  data

     

       
30
       
-
       
  |> dict.fold(0, fn(acc, _, data) {

     

       
31
       
-
       
    let add = case data {

     

       
32
       
-
       
      NestedList(items) -> get_total_number_list(items)

     

       
33
       
-
       
      NestedDict(items) -> get_total_number_dict(items)

     

       
34
       
-
       
      IntValue(v) -> v

     

       
35
       
-
       
      _ -> 0

     

       
36
       
-
       
    }

     

       
37
       
-
       
    acc + add

     

       
38
       
-
       
  })

     

       
39
       
-
       
}

     

       
40
       
-
       


     

       
41
       
-
       
fn get_total_number_list(data: List(Nested)) {

     

       
42
       
-
       
  data

     

       
43
       
-
       
  |> list.fold(0, fn(acc, data) {

     

       
44
       
-
       
    let add = case data {

     

       
45
       
-
       
      NestedList(items) -> get_total_number_list(items)

     

       
46
       
-
       
      NestedDict(items) -> get_total_number_dict(items)

     

       
47
       
-
       
      IntValue(v) -> v

     

       
48
       
-
       
      _ -> 0

     

       
49
       
-
       
    }

     

       
50
       
-
       
    acc + add

     

       
51
       
-
       
  })

     

       
52
       
 
       
}

     

       
53
       
 
       


     

       
54
       
-
       
fn get_total_number_dict_no_red(data: Dict(String, Nested)) {

     

       
55
       
-
       
  let has_red =

     

       
56
       
-
       
    data

     

       
57
       
-
       
    |> dict.fold(False, fn(state, _, data) {

     

       
58
       
-
       
      case data {

     

       
59
       
-
       
        StringValue("red") -> True

     

       
60
       
-
       
        _ -> state

     

       
61
       
-
       
      }

     

       
62
       
-
       
    })

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
63
       
 
       
  case has_red {

     

       
64
       
 
       
    True -> 0

     

       
65
       
 
       
    False ->

     

       
66
       
 
       
      data

     

       
67
       
-
       
      |> dict.fold(0, fn(acc, _, data) {

     

       
68
       
-
       
        let add = case data {

     

       
69
       
-
       
          NestedList(items) -> get_total_number_list_no_red(items)

     

       
70
       
-
       
          NestedDict(items) -> get_total_number_dict_no_red(items)

     

       
71
       
-
       
          IntValue(v) -> v

     

       
72
       
-
       
          _ -> 0

     

       
73
       
-
       
        }

     

       
74
       
-
       
        acc + add

     

       
75
       
-
       
      })

     

       
76
       
 
       
  }

     

       
77
       
 
       
}

     

       
78
       
 
       


     

       
79
       
-
       
fn get_total_number_list_no_red(data: List(Nested)) {

     

       
80
       
 
       
  data

     

       
81
       
-
       
  |> list.fold(0, fn(acc, data) {

     

       
82
       
-
       
    let add = case data {

     

       
83
       
-
       
      NestedList(items) -> get_total_number_list_no_red(items)

     

       
84
       
-
       
      NestedDict(items) -> get_total_number_dict_no_red(items)

     

       
85
       
-
       
      IntValue(v) -> v

     

       
86
       
-
       
      _ -> 0

     

       
87
       
-
       
    }

     

       
88
       
-
       
    acc + add

     

       
89
       
-
       
  })

     

       
90
       
 
       
}

     

       
91
       
 
       


     

       
92
       
 
       
pub fn main() {

     
···

       
96
       
 
       
    |> json.parse(int_anywhere_decoder())

     

       
97
       
 
       


     

       
98
       
 
       
  println(

     

       
99
       
-
       
    get_total_number_list([input])

     

       
100
       
 
       
    |> to_string,

     

       
101
       
 
       
  )

     

       
102
       
 
       
  println(

     

       
103
       
-
       
    get_total_number_list_no_red([input])

     

       
104
       
 
       
    |> to_string,

     

       
105
       
 
       
  )

     

       
106
       
 
       
}

     

···

       
1
       
 
       
import gleam/dict.{type Dict}

     

       
0
       
 
       

     

       
2
       
 
       
import gleam/dynamic/decode

     

       
3
       
 
       
import gleam/int.{to_string}

     

       
4
       
 
       
import gleam/io.{println}

     

       
5
       
 
       
import gleam/json

     

       
6
       
 
       
import gleam/list

     

       
7
       
 
       
import gleam/result.{unwrap}

     

       
0
       
 
       

     

       
8
       
 
       
import simplifile.{read}

     

       
9
       
 
       


     

       
10
       
 
       
type Nested {

     
···

       
23
       
 
       
  ])

     

       
24
       
 
       
}

     

       
25
       
 
       


     

       
26
       
+
       
fn handle_calc(data: Nested, no_red) {

     

       
27
       
+
       
  case data {

     

       
28
       
+
       
    NestedList(items) -> get_total_number_list(items, no_red)

     

       
29
       
+
       
    NestedDict(items) -> get_total_number_dict(items, no_red)

     

       
30
       
+
       
    IntValue(v) -> v

     

       
31
       
+
       
    _ -> 0

     

       
32
       
+
       
  }

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
33
       
 
       
}

     

       
34
       
 
       


     

       
35
       
+
       
fn get_total_number_dict(data: Dict(String, Nested), no_red) {

     

       
36
       
+
       
  let has_red = case no_red {

     

       
37
       
+
       
    True ->

     

       
38
       
+
       
      data

     

       
39
       
+
       
      |> dict.fold(False, fn(state, _, data) {

     

       
40
       
+
       
        case data {

     

       
41
       
+
       
          StringValue("red") -> True

     

       
42
       
+
       
          _ -> state

     

       
43
       
+
       
        }

     

       
44
       
+
       
      })

     

       
45
       
+
       
    False -> False

     

       
46
       
+
       
  }

     

       
47
       
 
       
  case has_red {

     

       
48
       
 
       
    True -> 0

     

       
49
       
 
       
    False ->

     

       
50
       
 
       
      data

     

       
51
       
+
       
      |> dict.fold(0, fn(acc, _, data) { acc + handle_calc(data, no_red) })

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
52
       
 
       
  }

     

       
53
       
 
       
}

     

       
54
       
 
       


     

       
55
       
+
       
fn get_total_number_list(data: List(Nested), no_red no_red) {

     

       
56
       
 
       
  data

     

       
57
       
+
       
  |> list.fold(0, fn(acc, data) { acc + handle_calc(data, no_red) })

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
58
       
 
       
}

     

       
59
       
 
       


     

       
60
       
 
       
pub fn main() {

     
···

       
64
       
 
       
    |> json.parse(int_anywhere_decoder())

     

       
65
       
 
       


     

       
66
       
 
       
  println(

     

       
67
       
+
       
    get_total_number_list([input], no_red: False)

     

       
68
       
 
       
    |> to_string,

     

       
69
       
 
       
  )

     

       
70
       
 
       
  println(

     

       
71
       
+
       
    get_total_number_list([input], no_red: True)

     

       
72
       
 
       
    |> to_string,

     

       
73
       
 
       
  )

     

       
74
       
 
       
}