Skip Navigation

Posts
187
Comments
356
Joined
2 yr. ago

  • Aside from the general conciseness, the "universal function call syntax" is my favorite aspect of nim.

    If you want to take chaining procedures to the next level, try a concatenative language like Factor (I have a day 4 solution in this thread -- with no assignment to variables).

    I also suggest having a look at Roc if you want a functional programming adventure, which offers great chaining syntax, a very friendly community, and is in an exciting development phase.

  • I have a hard time getting into a distro describing itself with a completely non-communicative "word" like "dragonized" but with numbers instead of letters. I thought it was cool when they provided a bunch of different desktops for live images (like wayfire), but they cut down on those.

    Did you find Chakra to add anything to the Arch experience? I worry that it might be "like Arch, but maybe some non-Qt stuff won't work."

    If you give CachyOS a try please report back! To me that's the most interesting Arch-topper right now.

  • Factor on github (with comments and imports):

     
        
    : line>cards ( line -- winning-nums player-nums )
      ":|" split rest
      [
        [ CHAR: space = ] trim
        split-words harvest [ string>number ] map
      ] map first2
    ;
    
    : points ( winning-nums player-nums -- n )
      intersect length
      dup 0 > [ 1 - 2^ ] when
    ;
    
    : part1 ( -- )
      "vocab:aoc-2023/day04/input.txt" utf8 file-lines
      [ line>cards points ] map-sum .
    ;
    
    : follow-card ( i commons -- n )
      [ 1 ] 2dip
      2dup nth swapd
      over + (a..b]
      [ over follow-card ] map-sum
      nip +
    ;
    
    : part2 ( -- )
      "vocab:aoc-2023/day04/input.txt" utf8 file-lines
      [ line>cards intersect length ] map
      dup length  swap '[ _ follow-card ]
      map-sum .
    ;
    
      
  • Factor on github (with comments and imports):

     
        
    : symbol-indices ( line -- seq )
      [ ".0123456789" member? not ] find-all [ first ] map
    ;
    
    : num-spans ( line -- seq )
      >array [ over digit? [ nip ] [ 2drop f ] if ] map-index
      { f } split harvest
      [ [ first ] [ last ] bi 2array ] map
    ;
    
    : adjacent? ( num-span symbol-indices -- ? )
      swap [ first 1 - ] [ last 1 + ] bi [a,b]
      '[ _ interval-contains? ] any?
    ;
    
    : part-numbers ( line nearby-symbol-indices -- seq )
      [ dup num-spans ] dip
      '[ _ adjacent? ] filter
      swap '[ first2 1 + _ subseq string>number ] map
    ;
    
    : part1 ( -- )
      "vocab:aoc-2023/day03/input.txt" utf8 file-lines
      [ [ symbol-indices ] map ] keep
      [
        pick swap [ 1 - ?nth-of ] [ nth-of ] [ 1 + ?nth-of ] 2tri
        3append part-numbers sum
      ] map-index sum nip .
    ;
    
    : star-indices ( line -- seq )
      [ CHAR: * = ] find-all [ first ] map
    ;
    
    : gears ( line prev-line next-line -- seq-of-pairs )
      pick star-indices
      [ 1array '[ _ part-numbers ] [ 3dup ] dip tri@ 3append ]
      [ length 2 = ] map-filter [ 3drop ] dip
    ;
    
    : part2 ( -- )
      "vocab:aoc-2023/day03/input.txt" utf8 file-lines
      dup [
        pick swap [ 1 - ?nth-of ] [ 1 + ?nth-of ] 2bi
        gears [ product ] map-sum
      ] map-index sum nip .
    ;
    
      
  • Factor on github (with comments and imports):

     
        
    : known-color ( color-phrases regexp -- n )
      all-matching-subseqs [ 0 ] [
        [ split-words first string>number ] map-supremum
      ] if-empty
    ;
    
    : line>known-rgb ( str -- game-id known-rgb )
      ": " split1 [ split-words last string>number ] dip
      R/ \d+ red/ R/ \d+ green/ R/ \d+ blue/
      [ known-color ] tri-curry@ tri 3array
    ;
    
    : possible? ( known-rgb test-rgb -- ? )
      v<= [ ] all?
    ;
    
    : part1 ( -- )
      "vocab:aoc-2023/day02/input.txt" utf8 file-lines
      [ line>known-rgb 2array ]
      [ last { 12 13 14 } possible? ] map-filter
      [ first ] map-sum .
    ;
    
    : part2 ( -- )
      "vocab:aoc-2023/day02/input.txt" utf8 file-lines
      [ line>known-rgb nip product ] map-sum .
    ;
    
      
  • I feel ok about part 1, and just terrible about part 2.

    day01.factor on github (with comments and imports):

     
        
    : part1 ( -- )
      "vocab:aoc-2023/day01/input.txt" utf8 file-lines
      [
        [ [ digit? ] find nip ]
        [ [ digit? ] find-last nip ] bi
        2array string>number
      ] map-sum .
    ;
    
    MEMO: digit-words ( -- name-char-assoc )
      [ "123456789" [ dup char>name "-" split1 nip ,, ] each ] H{ } make
    ;
    
    : first-digit-char ( str -- num-char/f i/f )
      [ digit? ] find swap
    ;
    
    : last-digit-char ( str -- num-char/f i/f )
      [ digit? ] find-last swap
    ;
    
    : first-digit-word ( str -- num-char/f )
      [
        digit-words keys [
          2dup subseq-index
          dup [
            [ digit-words at ] dip
            ,,
          ] [ 2drop ] if
        ] each drop                           !
      ] H{ } make
      [ f ] [
        sort-keys first last
      ] if-assoc-empty
    ;
    
    : last-digit-word ( str -- num-char/f )
      reverse
      [
        digit-words keys [
          reverse
          2dup subseq-index
          dup [
            [ reverse digit-words at ] dip
            ,,
          ] [ 2drop ] if
        ] each drop                           !
      ] H{ } make
      [ f ] [
        sort-keys first last
      ] if-assoc-empty
    ;
    
    : first-digit ( str -- num-char )
      dup first-digit-char dup [
        pick 2dup swap head nip
        first-digit-word dup [
          [ 2drop ] dip
        ] [ 2drop ] if
        nip
      ] [
        2drop first-digit-word
      ] if
    ;
    
    : last-digit ( str -- num-char )
      dup last-digit-char dup [
        pick 2dup swap 1 + tail nip
        last-digit-word dup [
          [ 2drop ] dip
        ] [ 2drop ] if
        nip
      ] [
        2drop last-digit-word
      ] if
    ;
    
    : part2 ( -- )
      "vocab:aoc-2023/day01/input.txt" utf8 file-lines
      [ [ first-digit ] [ last-digit ] bi 2array string>number ] map-sum .
    ;
    
    
      
  • It seems actively developed. Is your issue in the tracker?

  • Find the wiki page for "hard mode."

  • Well I'm not experiencing the bug, so can't provide proper information. If you are, it would be helpful to report it.

  • I use it and like it, kinda, but it bothers me that it destroys output as it goes along, so you can't look away then scroll up to see everything you missed.

  • I would have liked to see a nice clear example at the top to help me decide if I really want to read about the language.


    EDIT: First sample:

     
        
    day := 1;
    import "advent-prelude.noul";
    
    puzzle_input := advent_input();
    
    submit! 1, puzzle_input split "\n\n" map ints map sum then max;
    submit! 2, puzzle_input split "\n\n" map ints map sum then sort then (_[-3:]) then sum;
    
      

    Looks not too different from what you might do in Factor:

     
        
    : totals ( -- seq )
      puzzle-input "\n\n" split-subseq [ split-lines [ string>number ] map-sum ] map
    ;
    
    : part1 ( -- ) totals supremum . ;
    
    : part2 ( -- ) totals sort 3 tail* sum . ;
    
      
  • Ah, but will a Lemmy UI have proper code block support by then?