• 1 Post
  • 25 Comments
Joined 16 days ago
cake
Cake day: December 6th, 2024

help-circle

  • Uiua

    Ok, so part one wasn’t too hard, and since uiua also takes negative values for accessing arrays, I didn’t even have to care about converting my modulus results (though I did later for part two).
    I’m a bit conflicted about the way I detected the quadrants the robots are in, or rather the way the creation of the mask-array happens. I basically made a 11x7 field of 0’s, then picked out each quadrant and added 1-4 respectively. Uiua’s group () function then takes care of putting all the robots in separate arrays for each quadrant. Simple.

    For part two, I didn’t even think long before I came here to see other’s approaches. The idea to look for the first occurrence where no robots’ positions overlapped was my starting point for what follows.

    Example input stuff

    Run with example input here

    $ p=0,4 v=3,-3
    $ p=6,3 v=-1,-3
    $ p=10,3 v=-1,2
    $ p=2,0 v=2,-1
    $ p=0,0 v=1,3
    $ p=3,0 v=-2,-2
    $ p=7,6 v=-1,-3
    $ p=3,0 v=-1,-2
    $ p=9,3 v=2,3
    $ p=7,3 v=-1,2
    $ p=2,4 v=2,-3
    $ p=9,5 v=-3,-3
    .
    PartOne ← (
      # &rs ∞ &fo "input-14.txt"
      ⊜(↯2_2⋕regex"-?\\d+")≠@\n.
      ≡(⍜⌵(◿11_7)+°⊟⍜⊡₁×₁₀₀)
      ↯⟜(▽×°⊟)7_11 0
      ⍜↙₃(⍜≡↙₅+₁⍜≡↘₆+₂)
      ⍜↘₄(⍜≡↙₅+₃⍜≡↘₆+₄)
      /×≡◇⧻⊕□-₁⊸(⊡:)⍉
    )
    
    PartTwo ← (
      # &rs ∞ &fo "input-14.txt"
      ⊜(↯2_2⋕regex"-?\\d+")≠@\n.
      0 # number of seconds to start at
      0_0
      ⍢(◡(≡(⍜⌵(◿11_7)+°⊟⍜⊡₁×):)◌
        ◿[11_7]≡+[11_7]
        ⊙+₁
      | ≠⊙(⧻◴)⧻.)
      ⊙◌◌
      -₁
    )
    
    &p "Day 14:"
    &pf "Part 1: "
    &p PartOne
    &pf "Part 2: "
    &p PartTwo
    

    Now on to the more layered approach of how I got my solution.

    In my case, there’s two occasions of non-overlapping positions before the christmas tree appears.
    I had some fun trying to get those frames and kept messing up with going back and forth between 7x11 vs 103x101 fields, often forgetting to adjust the modulus and other parts, so that was great.

    In the end, I uploaded my input to the online uiua pad to make visualizing possible frames easier since uiua is able to output media if the arrays match a defined format.

    Try it out yourself with your input
    1. Open the uiua pad with code here
    2. Replace the 0 in the first line with your solution for part two
    3. If necessary, change the name of the file containing your input
    4. Drag a file containing your input onto the pad to upload it and run the code
    5. An image should be displayed

    I used this code to find the occurrence of non-overlapping positions (running this locally):

    &rs ∞ &fo "input-14.txt"
    ⊜(↯2_2⋕regex"-?\\d+")≠@\n.
    0 # number of seconds to start at
    0_0
    ⍢(◡(≡(⍜⌵(◿101_103)+°⊟⍜⊡₁×):)◌
      ◿[101_103]≡+[101_103]
      ⊙+₁
    | ≠⊙(⧻◴)⧻.)
    ⊙◌◌
    -₁
    

    Whenever a new case was found, I put the result into the code in the online pad to check the generated image, and finally got this at the third try:


  • Welp, got frustrated again with part one because there kept being something wrong with my totally-not-ugly loop and so came here again. I did have to change IsInt (and thus also Cost to account for different handling) for part two though because I kept getting wrong results for my input.
    I’m guessing it’s because uiua didn’t see the difference between rounded and non-rounded number anymore.

    Here’s the updated, slightly messier version of the two functions that worked out for me in the end :D

    IsInt ← ≍°⊟⍉⍜(⊙(⍉≡↙₂))(/+×)⊙⍉⁅
    Cost  ← /+×3_1×⟜IsInt⊸AB
    

    Could have been done better but I’m lacking the patience for that now





  • Uiua

    I spent a while thinking about how to best do a flood fill in Uiua when I saw that (partition) works beautifully with multidimensional markers: “Groups are formed from markers that are adjacent along any axis.”, meaning I just had to convert all letters into numbers and I’d get all indices belonging to a field into an array.
    For part 2, I cheated a bit by coming here and reading that you only need to count the edges. To my surprise, the second part is actually a bit faster than part 1. Takes less than 0.2 seconds each though :D

    Run with example input here

    $ RRRRIICCFF
    $ RRRRIICCCF
    $ VVRRRCCFFF
    $ VVRCCCJFFF
    $ VVVVCJJCFE
    $ VVIVCCJJEE
    $ VVIIICJJEE
    $ MIIIIIJJEE
    $ MIIISIJEEE
    $ MMMISSJEEE
    .
    N     ← +[0_¯1 0_1 ¯1_0 1_0]
    Areas ← ⊜□:⇡△.+1⍜♭⊛
    Peri  ← -/+≡(/+∊N¤)⟜¤⟜(×4⧻)
    Sides ← (
      ⊙(-¤)↯:▽⊙0×°⊟.+2⌵⊸-+1⊃⊣⊢⊸⍜⍉≡⍆
      ⧻⊚⊸∊1_3⧈(/+/+)2_2.⍜⊡=₀+1:
      +⊙(×2/+/+⧈(∊[[1_0 0_1][0_1 1_0]])2_2◌)
    )
    Cost! ← /+≡◇(×^0⟜⧻)
    
    PartOne ← (
      # &rs ∞ &fo "input-12.txt"
      ⊜∘≠@\n.
      Cost!Peri Areas
    )
    
    PartTwo ← (
      # &rs ∞ &fo "input-12.txt"
      ⊜∘≠@\n.
      Cost!Sides Areas
    )
    
    &p "Day 12:"
    &pf "Part 1: "
    &p PartOne
    &pf "Part 2: "
    &p PartTwo
    

  • Uiua

    After finally deciding to put aside Day 9 Part 2 for now, this was really easy actually. The longest was figuring out how many extra dimensions I had to give some arrays and where to remove those again (and how). Then part 2 came along and all I had to do was remove a single character (not removing duplicates when landing on the same field by going different ways from the same starting point). Basically, everything in the parentheses of the Trails! macro was my solution for part 1, just that the ^0 was (deduplicate). Once that was removed, the solution for part 2 was there as well.

    Run with example input here

    Note: in order to use the code here for the actual input, you have to replace =₈ with =₅₀ because I was too lazy to make it work with variable array sizes this time.

    $ 89010123
    $ 78121874
    $ 87430965
    $ 96549874
    $ 45678903
    $ 32019012
    $ 01329801
    $ 10456732
    .
    Adj ← ¤[0_¯1 0_1 ¯1_0 1_0]
    
    Trails! ← (
      ⊚=0.
      ⊙¤
      ≡(□¤)
      1
      ⍥(⊙(≡(□^0/⊂≡(+¤)⊙¤°□)⊙Adj
          ≡(□▽¬≡/++⊃=₋₁=₈.°□))
        +1⟜⊸⍚(▽=⊙(:⟜⊡))
      )9
      ⊙◌◌
      ⧻/◇⊂
    )
    
    PartOne ← (
      # &rs ∞ &fo "input-10.txt"
      ⊜∵⋕≠@\n.
      Trails!◴
    )
    
    PartTwo ← (
      # &rs ∞ &fo "input-10.txt"
      ⊜∵⋕≠@\n.
      Trails!∘
    )
    
    &p "Day 10:"
    &pf "Part 1: "
    &p PartOne
    &pf "Part 2: "
    &p PartTwo
    

  • That’s also possible, though I’ve had cases where putting a ? before a function changed the output to what I expected instead of doing something else.
    This only happened in the online pad and seems to have been fixed by reloading the tab but I’ve taken to call any such behavior a bug now :D
    Especially in this case because "1019" should at least not throw a “invalid float literal” error.

    Though if you ever find another explanation I’d be happy to read it ^^

    (I’m going to ‘investigate’ some more because I had this error a few times but I don’t remember the circumstances and solution anymore)


  • Great explanation :D
    I understand what I called black magic before now. I did wonder what something other than a concatenation would do in that place but didn’t consider that it might be just that because it looked so complicated.

    I wasn’t able to get it running with ⋕$"__" either, though I’d assume it’s a bug caused by how the numbers get passed around or something. The day uiua has a stable release will be glorious


  • Uiua

    Adapting the part one solution for part two took me longer than part one did today, but I didn’t want to change much anymore.

    I even got scolded by the interpreter to split the evaluating line onto multiple ones because it got too long.
    Can’t say it’s pretty but it does it’s job ^^’

    Run with example input here

    PartOne ← (
      &rs ∞ &fo "input-8.txt"
      ⟜(▽¬∈".\n".◴)
      ⊜∘≠@\n.
      :¤⟜(:¤-1△)
      ≡(□⊚⌕)
      ◴/◇⊂⍚(≡(-:⟜-°⊟)⧅≠2)
      ⧻▽¬:⊙(/+⍉+)⟜⊓><,0
    )
    
    PartTwo ← (
      &rs ∞ &fo "input-8.txt"
      ⟜(▽¬∈".\n".◴⟜¤
        ▽:⟜≡(>1⧻⊚⌕)
      )
      ⊜∘≠@\n.
      :¤⟜(:¤-1△)
      ≡(□⊚⌕)
      ⊸⍚(
        ⧅≠2⊙¤
        ≡(:¤⟜-°⊟
          ⍢(⊙⊂⟜-⊙⊸⊢
          | ⋅(=0/++⊓><,0⊢))
          □⊙◌◌
        )
      )
      ◴/◇⊂/◇⊂
      ⧻▽¬:⊙(/+⍉+)⟜⊓><,0
    )
    
    &p "Day 8:"
    &pf "Part 1: "
    &p PartOne
    &pf "Part 2: "
    &p PartTwo
    








  • Thanks to your solution I learned more about how to use reduce :D

    My solution did work for the example input but not for the actual one. When I went here and saw this tiny code block and you saying

    This turned out to be reasonably easy

    I was quite taken aback. And it’s so much better performance-wise too :D (well, until part 2 comes along in my case. Whatever this black magic is you used there is too high for my fried brain atm)


  • Uiua

    Credits to @mykl@lemmy.world for the approach of using reduce and also how to split the input by multiple characters.
    I can happily say that I learned quite a bit today, even though the first part made me frustrated enough that I went searching for other approaches ^^

    Part two just needed a simple modification. Changing how the input is parsed and passed to the adapted function took longer than changing the function itself actually.

    Run with example input here

    PartOne ← (
      &rs ∞ &fo "input-7.txt"
      ⊜□≠@\n.
      ≡◇(⊜□≠@:.)
      ≡⍜⊡⋕0
      ≡⍜(°□⊡1)(⊜⋕≠@ .)
      ⟜(⊡0⍉)
    
      # own attempt, produces a too low number
      # ≡(:∩°□°⊟
      #   ⍣(⍤.◡⍣(1⍤.(≤/×)⍤.(≥/+),,)0
      #     ⊙¤⋯⇡ⁿ:2-1⊸⧻
      #     ⊞(⍥(⟜⍜(⊙(↙2))(⨬+×⊙°⊟⊡0)
      #         ↘1
      #       )⧻.
      #       ⍤.=0⧻.
      #     )
      #     ∈♭◌
      #   )0)
    
      # reduce approach found on the programming.dev AoC community by mykl@lemmy.world
      ≡(◇(∈/(◴♭[⊃(+|×)]))⊡0:°⊂)
      °□/+▽
    )
    
    PartTwo ← (
      &rs ∞ &fo "input-7.txt"
      ⊜(□⊜⋕¬∈": ".)≠@\n.
      ⟜≡◇⊢
      ≡◇(∈/(◴♭[≡⊃⊃(+|×|⋕$"__")]):°⊂)
      °□/+▽
    )
    
    &p "Day 7:"
    &pf "Part 1: "
    &p PartOne
    &pf "Part 2: "
    &p PartTwo
    

  • Uiua

    Part one was simple enough. Part two nearly made me give up.
    Part two has the most ugly and least performant code I’ve made in uiua so far but it gets the job done and that’s all I care about for now.

    Run with example input here

    RotateClock ← (
      ⊙⊙(⍉⇌)
      ⊙(⇌⍜(⊡0)(-⊙(⧻⊡0.)+1))
      ↻¯1
    )
    
    RotateCounter ← (
      ⊙⊙(⇌⍉)
      ⊙(⍜(⊡0)(-⊙(⧻.)+1)⇌)
      ↻1
    )
    
    NewPos ← (
      ⊙⍜(⊙⊡:)(-1+⊙(⊗@#)⟜↘⊙.)⟜°⊟
      ⍜(⊡1)⋅
    )
    
    MarkPath ← (
      RotateClock
      ⍢( # replace characters up til next '#'
        ⊙(⊙⍜(↘⊙⊡:)(⍜(↙)(▽:@^⧻)⊗@#.)⟜°⊟
          NewPos
        )
        RotateCounter
      | ⋅(≠0⊡0))
      ◌◌
    )
    
    PartOne ← (
      &rs ∞ &fo "input-6.txt"
      ⊜∘≠@\n.
      # maybe make compatible with
      # non-up facing inputs
      ♭⊚=@^.
      [0 1 2 3]
      MarkPath
      &fwa "test.txt" json.
      /+/+=@^
    )
    
    PartTwo ← (
      &rs ∞ &fo "input-6.txt"
      ⊜∘≠@\n.
      # maybe make compatible with
      # non-up facing inputs
      ♭⊚=@^.
      [0 1 2 3]
      ◡MarkPath
      ⊙::
      # rotate the field to match the intital state
      ⊙⊙(
        ⊙(⊚=@#)
        ⍢(⇌⍉|¬≍⊚=@#)
        ⊙◌
      )
      ⊙⊙(⊚=@^.)
      ⊙⊙⊙¤∩¤
      ⊞(⊙⊙(⍜⊡⋅@#)
        RotateClock
        ⊙NewPos
        ¤¯1_¯1_¯1
        ⍢(⊙◡(⊂⊢)
          ⊂
          ⊙(RotateCounter
            ⊙NewPos
          )
        | =1+⊙(∈↘1⇌)◡⋅(≠129⊡2)⊙(⊂⊢))
        # 129 = length of input array. Hardcoded because
        # the condition block doesn't seem to get the
        # input array passed to it so the length can't
        # be read dynamically
        ⊙(⊂⊢)
        ∈
        ⊙◌
      )
      /+♭
    )
    
    &p "Day 6:"
    &pf "Part 1: "
    &p PartOne
    &pf "Part 2: "
    &p PartTwo