···

       
14
       
 
       
  StringValue(String)

     

       
15
       
 
       
}

     

       
16
       
 
       


     

       
17
       
-
       
fn int_anywhere_decoder() -> decode.Decoder(Nested) {

     

       
18
       
 
       
  use <- decode.recursive

     

       
19
       
 
       
  decode.one_of(decode.int |> decode.map(IntValue), or: [

     

       
20
       
-
       
    decode.list(int_anywhere_decoder()) |> decode.map(NestedList),

     

       
21
       
-
       
    decode.dict(decode.string, int_anywhere_decoder()) |> decode.map(NestedDict),

     

       
22
       
 
       
    decode.string |> decode.map(StringValue),

     

       
23
       
 
       
  ])

     

       
24
       
 
       
}

     
···

       
29
       
 
       
      items

     

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

     

       
31
       
 
       
    NestedDict(items) -> {

     

       
32
       
-
       
      let has_red = case no_red {

     

       
33
       
-
       
        True ->

     

       
0
       
 
       

     

       
34
       
 
       
          items

     

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

     

       
36
       
-
       
            case data {

     

       
37
       
-
       
              StringValue("red") -> True

     

       
38
       
-
       
              _ -> state

     

       
39
       
-
       
            }

     

       
40
       
-
       
          })

     

       
41
       
-
       
        False -> False

     

       
42
       
-
       
      }

     

       
43
       
 
       
      case has_red {

     

       
44
       
 
       
        True -> 0

     

       
45
       
 
       
        False ->

     
···

       
58
       
 
       
  let assert Ok(input) =

     

       
59
       
 
       
    read(from: "../input.json")

     

       
60
       
 
       
    |> unwrap("")

     

       
61
       
-
       
    |> json.parse(int_anywhere_decoder())

     

       
62
       
 
       


     

       
63
       
 
       
  println(

     

       
64
       
 
       
    get_total_number(input, no_red: False)

     

···

       
14
       
 
       
  StringValue(String)

     

       
15
       
 
       
}

     

       
16
       
 
       


     

       
17
       
+
       
fn nested_decoder() -> decode.Decoder(Nested) {

     

       
18
       
 
       
  use <- decode.recursive

     

       
19
       
 
       
  decode.one_of(decode.int |> decode.map(IntValue), or: [

     

       
20
       
+
       
    decode.list(nested_decoder()) |> decode.map(NestedList),

     

       
21
       
+
       
    decode.dict(decode.string, nested_decoder()) |> decode.map(NestedDict),

     

       
22
       
 
       
    decode.string |> decode.map(StringValue),

     

       
23
       
 
       
  ])

     

       
24
       
 
       
}

     
···

       
29
       
 
       
      items

     

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

     

       
31
       
 
       
    NestedDict(items) -> {

     

       
32
       
+
       
      let has_red =

     

       
33
       
+
       
        no_red

     

       
34
       
+
       
        && {

     

       
35
       
 
       
          items

     

       
36
       
+
       
          |> dict.values

     

       
37
       
+
       
          |> list.any(fn(data) { data == StringValue("red") })

     

       
38
       
+
       
        }

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
39
       
 
       
      case has_red {

     

       
40
       
 
       
        True -> 0

     

       
41
       
 
       
        False ->

     
···

       
54
       
 
       
  let assert Ok(input) =

     

       
55
       
 
       
    read(from: "../input.json")

     

       
56
       
 
       
    |> unwrap("")

     

       
57
       
+
       
    |> json.parse(nested_decoder())

     

       
58
       
 
       


     

       
59
       
 
       
  println(

     

       
60
       
 
       
    get_total_number(input, no_red: False)