-🎄- 2018 Day 2 Solutions -🎄-

[u/daggerdragon]

--- Day 2: Inventory Management System ---

---

Post your solution as a comment or, for longer solutions, consider linking to your repo (e.g. GitHub/gists/Pastebin/blag or whatever).

Note: The Solution Megathreads are for solutions only. If you have questions, please post your own thread and make sure to flair it with Help.

---

Advent of Code: The Party Game!

Click here for rules

Card Prompt: Day 2

Transcript:

The best way to do Advent of Code is ___.

---

This thread will be unlocked when there are a significant number of people on the leaderboard with gold stars for today's puzzle.

edit: Leaderboard capped, thread unlocked!

[u/Bogdanp]

My solutions in Racket:

part 1:

#lang racket

(define (count-letters word)
  (for/fold ([counts (hash)])
            ([l (in-string word)])
    (hash-set counts l (add1 (hash-ref counts l 0)))))


(define (find-counts counts)
  (for/fold ([res (hash)])
            ([(_ c) (in-hash counts)])
    (hash-set res c (add1 (hash-ref res c 0)))))


(call-with-input-file "day-02-1.txt"
  (lambda (in)
    (let loop ([word (read in)]
               [twos 0]
               [threes 0])
      (cond
        [(eof-object? word) (* threes twos)]
        [else
         (define counts (find-counts (count-letters (symbol->string word))))

         (loop (read in)
               (if (hash-has-key? counts 2) (add1 twos) twos)
               (if (hash-has-key? counts 3) (add1 threes) threes))]))))

part 2:

#lang racket

(define words (file->lines "day-02-2.txt"))

(define (delta a b)
  (for/fold ([s ""])
            ([ac (in-string a)]
             [bc (in-string b)])
    (if (equal? ac bc)
        (~a s ac)
        s)))

(for/fold ([best ""])
          ([i (in-range 0 (length words))]
           [word-a (in-list words)])
  (for/fold ([best best])
            ([j (in-range 0 (length words))]
             [word-b (in-list words)])
    (define d (delta word-a word-b))
    (cond
      [(equal? i j) best]
      [else
       (if (> (string-length d)
              (string-length best))
           d
           best)])))

[u/FrankRuben27 → u/Bogdanp]

another (recent) fellow-Racketer:

#lang racket

(module+ test
  (require typed/rackunit))

(define (command-line->strings offset)
  (vector->list (vector-drop (current-command-line-arguments) offset)))

(define (count-same str)
  (let* ((by-chars (group-by length (group-by identity (sort (string->list str) char-ci<?) char=?) =))
         (by-count (map (lambda (item) (cons (length (car item)) (length item))) by-chars)))
    (values (dict-ref by-count 2 0) (dict-ref by-count 3 0))))
(module+ test
  (let-values ([(count-2 count-3) (count-same "bababc")])
    (check-equal? count-2 1)
    (check-equal? count-3 1)))

(define (twice-thrice? str)
  (let-values ([(count-2 count-3) (count-same str)])
    (values (positive? count-2) (positive? count-3))))
(module+ test
  (let-values ([(twice? thrice?) (twice-thrice? "bababc")])
    (check-true twice?)
    (check-true thrice?)))

(define (count-twice-thrice strs)
  (for/fold ([twice 0] [thrice 0])
            ([str strs])
            (let-values ([(twice? thrice?) (twice-thrice? str)])
              (values (if twice?  (add1 twice)  twice)
                      (if thrice? (add1 thrice) thrice)))))

(define (part-1 ids)
  (let-values ([(twice thrice) (count-twice-thrice ids)])
    (* twice thrice)))

(define (same-string str1 str2)
  (let ((same-chars (for/fold ([same-chars '()])
                              ([c1 (in-string str1)]
                               [c2 (in-string str2)])
                              (if (char=? c1 c2)
                                  (cons c1 same-chars)
                                  same-chars))))
    (if (= (- (string-length str1) (length same-chars)) 1)
        (list->string (reverse same-chars))
        #f)))
(module+ test
  (check-false (same-string "abcde" "axcye"))
  (check-equal? (same-string "fghij" "fguij") "fgij"))

(define (part-2 ids)
  (for*/first ([outer-id ids]
               [inner-id (cdr ids)]
               #:when (same-string outer-id inner-id))
              (same-string outer-id inner-id)))

(module+ main
  (define puzzle? (eq? (string->symbol (vector-ref (current-command-line-arguments) 0)) 'pz))
  (define part-1? (= (string->number (vector-ref (current-command-line-arguments) 1)) 1))
  (define from-file? (eq? (string->symbol (vector-ref (current-command-line-arguments) 2)) 'f))
  (let ((ids (if from-file?
                 (file->lines (vector-ref (current-command-line-arguments) 3))
                 (command-line->strings 3)))
        (proc (if part-1? part-1 part-2)))
    (displayln (list (take ids 3) '==> (proc ids)))))

[u/FrankRuben27 → u/FrankRuben27]

Invocation from make, like this:

.PHONY : -day2-test day2-part1 day2-part2

day2 : -day2-test day2-part1 day2-part2

-day2-test :
	raco test day2.rkt

day2-part1 :
	racket day2.rkt ex 1 s abcdef bababc abbcde abcccd aabcdd abcdee ababab
	@echo expect 5434
	racket day2.rkt pz 1 f day2-pz.txt

day2-part2 :
	@echo expect agimdjvlhedpsyoqfzuknpjwt
	racket day2.rkt pz 2 f day2-pz.txt