Mirror of forum.nim-lang.org

10717 :: Advent of Nim 2023

• miran (orginal) [2023-12-01T13:07:49+01:00] view original

  Advent of Code 2023

  Today, Friday December 1st, at 5 a.m. UTC started the ninth incarnation of Advent of Code, popular programming contest started back in 2015. The author describes Advent of Code (AoC) as "a series of small programming puzzles for a variety of skill sets and skill levels in any programming language you like".

  The rules of AoC are quite simple. Starting from December 1st until Christmas, every day at 5 a.m. UTC a new task is released. The tasks consist of two parts, where second part is revealed after you solve the first part, and it is a continuation and/or variation of the first part. You don't submit your code, just the result of your calculation.

  The participation in AoC is free (although, if you like it, consider donating), all you need to do is log in with your Github, Google, Twitter, or Reddit account.

  If you have never participated in AoC before or you want to prepare yourself for the start of the competition by solving some tasks, take a look at the previous events. To bring you up to speed, we recommend solving any of first 10 tasks of any year, as those are usually easier and can be solved relatively fast.

  Nim leaderboards

  Advent of Code offers private leadearboards, and Nim has not only one but two of them.

  The original Nim private leaderboard has previously filled up to the maximum of 200 users. We have opened a new private leaderboard, which you can join by using 681448-60235f8f code on this link.

  If you have joined one of these leaderboards in previous years, there's no need to do it again — you're already in.

  Sharing solutions and asking for help

  In this thread you can post links to your AoC repositories, share your solutions, ask for help, discuss the tasks, etc.

  People usually share their solutions on r/adventofcode subreddit and we encourage you to share your Nim solutions there too and showcase the beauty of Nim.

  If you're sharing your solutions via Twitter or other platforms, use #AdventOfNim hashtag and/or mention @nim_lang.

  You can also use Nim IRC/Gitter/Discord channel (https://discord.gg/7RsJ5uEN, #aoc channel) if you have some Nim-related problem, but have in mind that your snippets might contain spoilers for other who haven't solved the task yet — not everybody will be able to solve the tasks at 5 a.m. UTC. Consider waiting at least couple of hours before asking for help (in that time, try it some more to see if you can solve it by yourself :)).

  Have fun!

---

• miran (orginal) [2023-12-01T13:08:33+01:00] view original

  Previous Advent of Nim threads:

  • AoC 2018
  • AoC 2019
  • Aoc 2020
  • AoC 2021
  • AoC 2022

---

• daylinmorgan (orginal) [2023-12-01T13:51:25+01:00] view original

  Nim solutions for 2023

---

• DeletedUser (orginal) [2023-12-01T14:33:08+01:00] view original

  Nim should be used in a lot of competitive programming competitions.

---

• janAkali (orginal) [2023-12-01T16:02:39+01:00] view original

  That's my first live Advent of Code. Let's see how long I will last.

  I'll be posting my solutions here: codeberg.org

---

• pietroppeter (orginal) [2023-12-02T09:28:59+01:00] view original

  Not using my usual repo this year, using this since I plan to do it in Nim but also in other languages: https://github.com/pietroppeter/adventofcode2023/

---

• freeflow (orginal) [2023-12-02T14:43:12+01:00] view original

  my attempts here. I'm not a professional programmer and think in VBA. https://github.com/FullValueRider/AoC2023

  Thus far, as a totally unfair comparison (because I have no idea about setting things up to be comparable) Day 01 nim 38 ms, twinBasic 19.5 ms Day 02 nim 47 ms, twinBasic 7.8 MS

---

• Kind-Distribution376 (orginal) [2023-12-02T15:40:10+01:00] view original

  I can say it has been rising in the context of Project Euler, and I couldn't be happier about it.

---

• lscrd (orginal) [2023-12-02T18:03:42+01:00] view original

  My solutions, all written in Nim, can be found here:

  https://github.com/lscrd/AdventOfCode2023

  Solutions for years 2016 to 2022 can also be found on https://github.com/lscrd.

---

• PMunch (orginal) [2023-12-02T18:46:26+01:00] view original

  Was that a private repo by chance? Link doesn't seem to work. And for speed comparisons, did you turn on -d:release?

---

• SolitudeSF (orginal) [2023-12-06T12:23:32+01:00] view original

  its not reasonable to expect the debug version to have representative performance.

---

• freeflow (orginal) [2023-12-06T14:16:56+01:00] view original

  I don't. I'm comparing it against something that also doesn't have representative performance. The comparison is for fun only.

---

• Calonger (orginal) [2023-12-06T20:15:58+01:00] view original

  Saying : turn on release build , not debug build .

---

• freeflow (orginal) [2023-12-06T21:10:49+01:00] view original

  In response to comments, running with 'nim compile -d:release -d:danger --verbosity:0 --hints:off --run' gives a time of 24 seconds (vs 480).

---

• PMunch (orginal) [2023-12-06T23:04:59+01:00] view original

  I decided to give your code a go on my machine, it took about 144 seconds. The reason it's slow though is because it creates a quite wild number of string and sequence allocations, along with not having any caching of already computed cards. When running your code as I was streaming my solution it used up about 10Gb of RAM before my stream crashed (you can find part two of my stream here). Actually a bit surprised that it manages to do all that in 24 seconds. Compare it for example to my solution where I converted the inputs into more reasonable data types during the parsing step and the simple caching of cards. On my machine it runs in about 2ms with a release build, and about 14ms with a debug build. I talk a bit about why you might be able to use these patterns in other languages like twinBasic, but it basically boils down to Nims default data structures being optimized for other things. When you use them in a way that abuses their design you can get very detrimental performance. Some languages optimize instead for okay speed for any way of using a data structure, with the penalty that it can't be made to go as fast as languages which require a bit more care.

---

• freeflow (orginal) [2023-12-07T20:23:31+01:00] view original

  Wow. Thanks for taking the time to look at my code. The video was very interesting and provided lots of points for me to follow up. I must admit to having a red face (embarrassment) in response to some of your comments, but that's the danger of asking for feedback.

  Thanks again.

---

• denise_amiga (orginal) [2023-12-20T18:08:44+01:00] view original

  Hello everyone:

  I have a problem and I think there is some bug in the compiler or can you help me debug my code, because I am not able to understand why ONLY those entries do not work, the rest without problems but thoses 4 entries goes into a loop, doesn't even show the first entry on the map.

  some help, thank you

  p2.nim

  import std/strutils
  import std/sequtils
  # import std/setutils
  # import std/algorithm
  # import std/sets
  import std/tables
  # import std/deques
  # import std/strscans
  # import std/os
  import ../../denise
  
  let input = readFile("input.txt")
  let test1 = """.|...\....
  |.-.\.....
  .....|-...
  ........|.
  ..........
  .........\
  ..../.\\..
  .-.-/..|..
  .|....-|.\
  ..//.|...."""
  
  type
    Beam = tuple
      pos: Vec2[int]
      dir: char
      stop: bool
  
  const
    dirs = {'^': (0, -1), '>': (1, 0), 'v': (0, 1), '<': (-1, 0)}.toTable
  
  var
    beams: seq[Beam]
    map: seq[seq[char]]
    visited: Table[Vec2[int], string]
  
  proc isInside(v: Vec2[int]): bool =
    if v.x < 0 or v.y < 0 or v.x > map[0].high or v.y > map.high:
      return false
    true
  
  proc update(b: var Beam, u: var seq[Beam]) =
    if b.stop: return
    if not isInside(b.pos):
      b.stop = true
      return
    if not visited.hasKey(b.pos):
      visited[b.pos] = ""
    visited[b.pos].add b.dir
    case map[b.pos.y][b.pos.x]:
      of '.':
        map[b.pos.y][b.pos.x] = b.dir
      of '\\':
        case b.dir:
          of '>': b.dir = 'v'
          of '<': b.dir = '^'
          of '^': b.dir = '<'
          of 'v': b.dir = '>'
          else: discard
      of '/':
        case b.dir:
          of '>': b.dir = '^'
          of '<': b.dir = 'v'
          of '^': b.dir = '>'
          of 'v': b.dir = '<'
          else: discard
      of '|':
        case b.dir:
          of '<', '>':
            u.add (b.pos, '^', false)
            u.add (b.pos, 'v', false)
            b.stop = true
            return
          else: discard
      of '-':
        case b.dir:
          of '^', 'v':
            u.add (b.pos, '<', false)
            u.add (b.pos, '>', false)
            b.stop = true
            return
          else: discard
      of '^':
        if b.dir == '^':  ## loop
          b.stop = true
          return
        map[b.pos.y][b.pos.x] = chr(visited[b.pos].len + 48)
      of '>':
        if b.dir == '>':  ## loop
          b.stop = true
          return
        map[b.pos.y][b.pos.x] = chr(visited[b.pos].len + 48)
      of 'v':
        if b.dir == 'v':  ## loop
          b.stop = true
          return
        map[b.pos.y][b.pos.x] = chr(visited[b.pos].len + 48)
      of '<':
        if b.dir == '<':  ## loop
          b.stop = true
          return
        map[b.pos.y][b.pos.x] = chr(visited[b.pos].len + 48)
      of '2' .. '9': discard
      else:
        echo "Error: ", b
        assert false
    b.pos += dirs[b.dir]
  
  proc printMap() =
    echo ""
    for l in map:
      echo l.join
  
  proc process(bs: var seq[Beam]): bool =
    var
      a: seq[Beam]
    
    for b in bs.mitems:
      b.update(a)
    if a.len > 0:
      beams.add a
    bs.anyIt(it.stop == false)
  
  proc shootBeam(b: Beam, m: seq[seq[char]]): int =
    var
      isRunning = true
      frame = 0
    
    visited.clear
    beams.setLen(0)
    beams.add b
    map = m
    while isRunning:
      isRunning = process(beams)
      frame.inc
    # printMap()
    # echo frame
    visited.len
  
  proc p2(input: string): int =
    var
      shoots: seq[int]
    let
      mapcp = input.strip.split('\n').mapIt(it.toSeq)
    
    for x in 0 .. mapcp[0].high:
      if x == 5 or x == 54 or x == 58 or x == 70: continue  ## (5,0) (54,0) (58,0) (70,0)
      shoots.add ((x, 0), 'v', false).shootBeam(mapcp)
    for x in 0 .. mapcp[0].high:
      shoots.add ((x, mapcp.high), '^', false).shootBeam(mapcp)
    for y in 0 .. mapcp.high:
      shoots.add ((0, y), '>', false).shootBeam(mapcp)
      shoots.add ((mapcp[0].high, y), '<', false).shootBeam(mapcp)
    shoots.max
  
  bench:
    p2(input)
  
  block:
    assert p2(test1) == 51
    discard
  Run

  denise.nim

  import std/times
  
  type
    Vec2*[T] = tuple
      x: T
      y: T
  
  proc `+`*[T](a, b: Vec2[T]): Vec2[T] =
    result.x = a.x + b.x
    result.y = a.y + b.y
  
  proc `-`*[T](a, b: Vec2[T]): Vec2[T] =
    result.x = a.x - b.x
    result.y = a.y - b.y
  
  proc `*`*[T](a: Vec2[T], n: int): Vec2[T] =
    result.x = a.x * n
    result.y = a.y * n
  
  proc `\`*[T](a: Vec2[T], n: int): Vec2[T] =
    result.x = a.x div n
    result.y = a.y div n
  
  proc `+=`*[T](a: var Vec2[T], b: Vec2[T]) =
    a.x += b.x
    a.y += b.y
  
  proc `-=`*[T](a: var Vec2[T], b: Vec2[T]) =
    a.x -= b.x
    a.y -= b.y
  
  proc `*=`*[T](a: var Vec2[T], n: int) =
    a.x *= n
    a.y *= n
  
  proc `\=`*[T](a: var Vec2[T], n: int) =
    a.x = a.x div n
    a.y = a.y div n
  
  type
    Vec3*[T] = tuple
      x: T
      y: T
      z: T
  
  proc `+`*[T](a, b: Vec3[T]): Vec3[T] =
    result.x = a.x + b.x
    result.y = a.y + b.y
    result.z = a.z + b.z
  
  proc `-`*[T](a, b: Vec3[T]): Vec3[T] =
    result.x = a.x - b.x
    result.y = a.y - b.y
    result.z = a.z - b.z
  
  proc `*`*[T](a: Vec3[T], n: int): Vec3[T] =
    result.x = a.x * n
    result.y = a.y * n
    result.z = a.z * n
  
  proc `\`*[T](a: Vec3[T], n: int): Vec3[T] =
    result.x = a.x div n
    result.y = a.y div n
    result.z = a.z div n
  
  proc `+=`*[T](a: var Vec3[T], b: Vec3[T]) =
    a.x += b.x
    a.y += b.y
    a.z += b.z
  
  proc `-=`*[T](a: var Vec3[T], b: Vec3[T]) =
    a.x -= b.x
    a.y -= b.y
    a.z -= b.z
  
  proc `*=`*[T](a: var Vec3[T], n: int) =
    a.x *= n
    a.y *= n
    a.z *= n
  
  proc `\=`*[T](a: var Vec3[T], n: int) =
    a.x = a.x div n
    a.y = a.y div n
    a.z = a.z div n
  
  template bench*(body: untyped) =
    block:
      let t1 = cpuTime()
      let z = body
      echo z, "\nTime: ", (cpuTime() - t1) * 1000, " ms."
  Run

  input.txt

  \.....................\.......................|..../......-.........../.|.....\.............|..........|..\...
  .../...................\..................../...|.......|........||...................../...........\.........
  ././....|......./................\............|..\...........-....../............../|........-................
  ....\..\...........-/..|......|......\............|............../.................-........./...-...|.......\
  ..................................|.\.......|...../.........................-...../......\..|...............\.
  .....\.............................................|../.\............../--.......................\............
  |.......-.|........\.................\..............|........./....\.........|...................\-.-...|.....
  ....\........./....-.........................--.....\..../......................|.\......................\...-
  \..-..../.....|..........\......................-|......|...................../...../........./...........-...
  ........................\.\|......../........../......................\.............|./../....................
  .....\...................|.............................|......-........|.........-./.../.|....................
  ..-................./.........................................\..\........-..-........-.......\../............
  -................-............................\................./..--................-............../.|.......
  ..-.....|.............|................./.......-.-........................-............-...........\.........
  ..........|..........................-...|..\...............................................\-....\...........
  /................../..........|....\..-......................../....\...\..........-....../.........../.....\.
  ................\....-................-|.\...-...........-.....-........\..........................\..........
  ...................................\../..|.../../...........................\.........../.\-......|.........-.
  /....|....|..........................\............./.....|/................./....-......................-.....
  ....-.............../.....|...........|../......\../.............../........................|............./...
  ......./..............|./../.................-.\.........../.....................|.........../........\.......
  ...................-...............\/.......|........|....................../.......................-/......\.
  ................\...../....-/......-.........-.....\/.\...............\....../...-....|......|.........\......
  ....-.........-.........................-......................../.......|...............................\....
  ......../..................|...../......\..\..-|-..../..............|......../............|.-.......-.........
  ......./............-..........-............................../.........................|\..-..-\.\......-..\.
  .\-.....|......................-..\................/.-................|.\..............\..................|...
  -..........................-............../.|.-......\......-..-...../......./................................
  ....|.................................................\....|..........\...................-......|........./..
  ................../...........-..............\......................................|.-........|..............
  ...-............|..............-...........-.\.......................|..|..../......................../.|....-
  .......-..-......./...../.........-.......\.....-.../............-./......../.../............-.....|...|......
  ...............|.........../..........|/..........|..........-.-...../...../..|..........\.....-./.|./....|...
  .........|......................\.|.....|......................-.-........|.............................-...|.
  .-...|..\...-...............\..............\......./........-............/.-..\........../...../....-....\....
  ...........\.-.......|.......|....-.............|-.|........../..../...\....\............|.|..|\..............
  .....................|.\....|......|../...\......|........................\......|.......-./..../.............
  ......................\--................................\.................|................-.................
  -...............\...-.....................................-.\...../....\...........................|..........
  .....|.......\.......................-/...\..-.........-..../\|..................\........-...................
  ..|........./....|..-./..\..\................-|..........\../......\...............\............\............|
  ......-................../.............|.............\................................-..\...../........-.....
  ....................../......../..\.-.........................|....\..|...\...../../.....|............../.....
  ...\................................/..............................\........|.........\.-............\........
  /.................../................-...........-.|.............\.................................|.....-....
  .|...-..|/./../.........-./.............................................../..........-.........-.|./..........
  ..../..................|......................|../..........\........-......../.........\...|.................
  ........./..................|..-..........|\............\......-..-..\...|....|.....................|....-....
  .....|/....|........\.........-................../..........|............|...........-.....|......./......//..
  ..........\.|../...|........................\.........\.|......||....-...............\\.....|.|..............|
  ............-................|.....-....||......../.../.......................|..\...........\................
  ...............-..../......-..../.......|-.....-.....\..................................../..|................
  /......-...............\/...././..................\..................\..........-......................|......
  ...................\.....\.................\...|.................-............/........-..............\./.....
  .-.\....\........\........-../.-............../...../..-..|...................../.-.....\.....-........../..\.
  |...|...............................|............../.............../....................|...../...............
  ....../....../...|..............-.-........-..|.../....................\|.....\......................|....../.
  ...\\.......|...|-............|..........-...........................................\/...../..-.-............
  .........|.............|..|......\............\...............|......\......\.............\...\-.......\.....\
  ...........\..-.|.......|\..\..................-........\/...............................-....................
  ...\.................\..............................................\...............\.......-.../.............
  ..\.............\....---....................//.......................................|./.............../\.....
  .\...........|..................................\........-......|.........\.................-........-........
  ..............-...............-.../....-........|.....-../......................./..../........../../--..\....
  .........-......\......-.........../...\./.|.................\...................--..-........|..\......\....|
  ....../.........................................|...../........../..............\\...-/.......-......\..\.....
  .........../...\.|..................../.\.................|......\.\..|.........../...../.....\.\...........|.
  ..../\..-...../.............................../..../............................-...-......\...........\......
  ..-..\.............................\...........|..........|.........|..........................-......./......
  -..|.................-\.....\...............\/.....|...........................././...\......\.......\...-....
  ......\..............|..|..............-............../....................-....\\........\....|..............
  |.............\....\./.....-|-....\.....\..............\/........-.|..|...........-..\......-..../.......|....
  ............................-.......................|........................../................|.............
  /................|../............\/.....\/....-.....\......\...../|..\..........|............../..............
  .|....../...../....................../..|.....................-................./...../-.........-............
  ......................\|........../......./..\........\.........-......../.........../.|/.......\.../.........
  ...............\......-|............\..\....../.........\.....|...|\............/............\.\..|.......\...
  ......|...........\....../....\./......./-....\../.......\...-...............\./...\.....-.......-..../.......
  ...|..|.............................\.....-.|........./......../......................-......./............\..
  .....|........\.........|...-.-.........\..../....../..-.......-...............\..../.....-..../..............
  ........./.\/........................-..........\.....................|.......-..............\./.\............
  ..../................/................................|.....||..............\........-...............|........
  ....\./.........../\-.....-...\............//.\..............\...../................|.....\..-................
  ..../|........./............|.....................|......................-..|...............................\.
  ..................\............................\.......\.........-.............|...../.-.............-......|.
  ..............|.-...........................\.\./.......\........../...\................/....-................
  .......|................/-............\............/...........-..../...........\......../...\.......\........
  ..............|..../......................-...........-..\.................................................-..
  ..............................-..-................-.......-.................-..........\.../...............|..
  ......-.........-........................./.....................\....|........................................
  .....\........./.....-.................../................|...................|........................|......
  ........../.../........................./.|................-...........\...........-....|.....................
  .....-.......\././/.......|..............|......../..\...........\.............................-......|../-.-.
  ........|-....-....................\.....|\...\/.....\........\......./..........|.\-..|......................
  ../...-...-...|...../............\.......................-..........\...\.....-...\...............|....../...|
  ............|..\....|..................\/...................../../....|...................|.............../...
  .............-................./............|.......|............\....................................\.-.....
  -...../|..............-......\..../..................|..\....-............................................\...
  ........|.........-........\................/....\..................../.|...................................|.
  .....|................./.........-|\...-...................|....-................-......../...............|..-
  .|.........|...........|...-.............................\............................|................\......
  ....|.....-......|......./.-.|...........\..-........|.........................-....-..-.....|................
  ........................................\.....................-.../........................../../..........|..
  -................/....\.......//....-........................../.\.........-......./..|\..........\...........
  -............................./......................................../-...........................\|........
  ........................................../-.....//......\......\...........\........|./....../.......--......
  ../..............-....../......../................../......./....-...........|../.......\.\.......-......./..\
  ..............-............../......|.........-...............|................................-..........\...
  .....................\..........|..\......|...............................................-...................
  ...../..|.../.........|.../.......-...................................\.....................................|.
  Run

  > nim --version

  Nim Compiler Version 2.0.2 [Linux: amd64]
  Compiled at 2023-12-15
  Copyright (c) 2006-2023 by Andreas Rumpf
  
  git hash: c4c44d10df8a14204a75c34e499def200589cb7c
  active boot switches: -d:release
  
  > PD. 7741 es valid
  
  7741
  Time: 226.47787 ms.
  

---

• denise_amiga (orginal) [2023-12-21T00:29:35+01:00] view original

  fixed

  the fault was in the management of the crosses, it only controlled a maximum of 9

  ...
  of '2' .. '9': discard
  ...
  Run

---

• Col (orginal) [2023-12-25T00:11:13+01:00] view original

  Very late to the AoC party. My attempts if anyone is interested: https://github.com/ColF/AdventOfNim2023/tree/master

  I didn't know about AoC so hopefully next year I can get into it properly.

---