day1.cr

@@ -1,5 +1,4 @@
-require "advent"
+INPUT = File.read("day1.txt").lines.map(&.chomp.to_i32) 
-INPUT = input(2020, 1).lines.map(&.chomp.to_i32) 
 
 def part1
   input = INPUT.clone.sort!

day2.cr

@@ -1,5 +1,4 @@
-require "advent"
+INPUT = File.read("day2.txt").lines.map(&.chomp) 
-INPUT = input(2020, 2).lines.map(&.chomp) 
 
 def parse(line)
     data = line.match(/([0-9]+)-([0-9]+) ([a-z]): ([a-z]+)/) 

day3.cr

@@ -1,5 +1,4 @@
-require "advent"
+INPUT = File.read("day3.txt").lines.map(&.chomp) 
-INPUT = input(2020, 3).lines.map(&.chomp) 
 
 def run(input, slopes)
   prod = 1_i64

day4.cr

@@ -1,6 +1,5 @@
 require "./passports.cr"
-require "advent"
+INPUT = File.read("day4.txt")
-INPUT = input(2020, 4)
 
 def part1
   input = INPUT.clone

day5.cr

@@ -1,5 +1,4 @@
-require "advent"
+INPUT = File.read("day5.txt").lines.map(&.chomp) 
-INPUT = input(2020, 5).lines.map(&.chomp) 
 
 def partition(choices, list)
   b = 0

day5g.cr

@@ -1,2 +0,0 @@
-i=File.read_lines("day5.txt").map &.tr("FBLR", "0101").to_i32(2);
-puts({i.max,(i.min..i.max).select{|n|!i.includes? n}})

day6.cr

@@ -1,21 +0,0 @@
-require "advent"
-INPUT = input(2020, 6).split("\n\n")
-
-def part1
-  input = INPUT.clone
-  answers = input.map do |i|
-    i.chars.uniq!.count &.ascii_letter?
-  end
-  puts answers.sum
-end
-
-def part2
-  input = INPUT.clone
-  sol = input.map do |i|
-    i.split("\n").reject(&.empty?).map(&.chars.to_set).reduce { |s1, s2| s1 & s2 }
-  end
-  puts(sol.map(&.size).sum)
-end
-
-part1
-part2

graph.cr

@@ -0,0 +1,48 @@
+class Graph(A)
+  def initialize
+    @edges = {} of A => Set({A, Int32})
+  end
+
+  def add_edge(f, t, c = 1)
+    @edges[f] ||= Set({A, Int32}).new
+    @edges[f] << {t, c}
+  end
+
+  def add_biedge(f, t, c = 1)
+    add_edge(f, t, c)
+    add_edge(t, f, c)
+  end
+
+  def find_path(f, t)
+    visited = Set(A).new
+    candidates = Set { f }
+    distances = {f => 0}
+    prev = {} of A => A
+
+    while !candidates.empty?
+      candidate = candidates.min_by { |c| distances[c] }
+      break if candidate == t
+      visited << candidate
+      candidates.delete candidate
+      dist = distances[candidate]
+
+      @edges.fetch(candidate, Set({A, Int32}).new).each do |e|
+        node, cost = e
+        new_dist = dist + cost
+        candidates << node unless visited.includes? node
+        next if (old_dist = distances[node]?) && old_dist < new_dist
+        distances[node] = new_dist 
+        prev[node] = candidate
+      end
+    end
+
+    backtrack = t
+    path = [t] of A
+    while backtrack != f
+      return nil unless prev_bt = prev[backtrack]?
+      path << prev_bt
+      backtrack = prev_bt
+    end
+    {path.reverse!, distances[t]}
+  end
+end

heap.cr

@@ -0,0 +1,83 @@
+class Array(T)
+  def bubble_up(i, &cmp)
+    return if i >= size
+    while i != 0
+      j = (i-1)//2
+      break if yield self[i], self[j]
+      self[i], self[j] = self[j], self[i]
+      i = j
+    end
+  end
+
+  def percalate_down(i, &cmp)
+    while i*2+1 < size
+      j1, j2 = i*2+1, i*2+2
+      v1 = self[j1]
+      v2 = self[j2]?
+      if v2 && (yield v1, v2) && (yield self[i], v2)
+        self[j2], self[i] = self[i], v2
+        i = j2
+      elsif yield self[i], v1
+        self[j1], self[i] = self[i], v1
+        i = j1
+      else
+        break
+      end
+    end
+  end
+
+  def heapify(&cmp : T,T -> Bool)
+    size.times do |i|
+      i = size - i - 1
+      bubble_up(i, &cmp)
+    end
+    self
+  end
+
+  def heapify
+    heapify do |i,j|
+      i < j
+    end
+  end
+
+  def heap_push(v, &cmp : T,T -> Bool)
+    self << v
+    bubble_up(size - 1, &cmp)
+  end
+
+  def heap_push(v)
+    heap_push(v) do |i,j|
+      i < j
+    end
+  end
+
+  def heap_pop(&cmp : T,T -> Bool)
+    self[0], self[size-1] = self[size-1], self[0]
+    v = pop
+    percalate_down(0, &cmp)
+    v
+  end
+
+  def heap_pop
+    heap_pop do |i, j|
+      i < j
+    end
+  end
+
+  def is_heap?(&cmp : T,T -> Bool)
+    (size-1).times do |i|
+      i = size - i - 1
+      vi = self[i]
+      vp = self[(i-1)//2]
+      return false unless (yield self[i], self[(i-1)//2]) || vi == vp
+    end
+    return true
+  end
+
+  def is_heap?
+    is_heap? do |i,j|
+      i < j
+    end
+  end
+
+end

knapsack.cr

@@ -0,0 +1,39 @@
+class Array(T)
+  def knapsack(budget, &cv : T -> {Int32,Int32})
+    cost_values = map &cv
+
+    memo = {} of {Int32, Int32} => Int32
+    bt = {} of {Int32, Int32} => Bool
+    compute = uninitialized Int32, Int32 -> Int32
+    compute = ->(size : Int32, budget : Int32) {
+      if m = memo[{size, budget}]?
+        return m 
+      end
+      return memo[{size, budget}] = 0 if size == 0
+
+      cost, value = cost_values[size-1]
+      no_val = compute.call(size-1, budget)
+      yes_val = (budget < cost) ? 0 : compute.call(size-1, budget - cost) + value  
+
+      if yes_val > no_val
+        bt[{size, budget}] = true
+        return yes_val
+      else
+        bt[{size, budget}] = false
+        return no_val
+      end
+    }
+
+    value = compute.call(size, budget)
+    i = size
+    items = [] of T
+    while i != 0
+      if bt[{i, budget}]
+        items << self[i-1]
+        budget -= cost_values[i-1][0]
+      end
+      i -= 1
+    end
+    {value, items}
+  end
+end

shard.yml

@@ -1,13 +0,0 @@
-name: advent-2020
-version: 0.1.0
-
-authors:
-  - your-name-here <your-email-here>
-
-dependencies:
-  advent:
-    git: https://dev.danilafe.com/Advent-of-Code/advent
-
-crystal: 0.35.1
-
-license: MIT

template.cr

@@ -1,5 +1,4 @@
-require "advent"
+INPUT = File.read("dayN.txt")#.lines.map(&.chomp) 
-INPUT = input(2020, n)#.lines.map(&.chomp) 
 
 def part1
   input = INPUT.clone