kejadlen

require "date"
require "strscan"

module QFX
  Transaction = Struct.new(:type, :date, :amount, :fitid, :name, keyword_init: true)

  class Parser
    def initialize(raw)
      @ss = StringScanner.new(raw)
    end

kejadlen

#!/usr/bin/env ruby

require "io/console"

require "capybara"
require "capybara/dsl"
require "selenium-webdriver"
require "pry"

print "Username: "

kejadlen

class Program
  def initialize(id, instructions, input, output)
    @id, @instructions, @input, @output = id, instructions, input, output
    @registers = Hash.new {|h,k|
      if k =~ /[a-z]/
        h[k] = 0
      else
        h[k] = k.to_i
      end
    }

kejadlen

~/Dropbox/src/github.com/kejadlen/advent_of_code/2017/rust master* ⇡
❯ time cargo run --release < ../input/day_05.txt
    Finished release [optimized] target(s) in 0.0 secs
     Running `target/release/advent_of_code_2017`
25347697
cargo run --release < ../input/day_05.txt  0.55s user 0.04s system 90% cpu 0.649 total

~/Dropbox/src/github.com/kejadlen/advent_of_code/2017/rust master* ⇡
❯ time cargo run < ../input/day_05.txt
    Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs

kejadlen

require "csv"

filename, column_name, replacement, output = *ARGV[0..3]
csv = begin
        CSV.read(filename, headers: true)
      rescue
        puts "input file missing"
        exit 1
      end

kejadlen

#lang typed/racket

(define num-update
  (lambda (#:main [main : Number 0] #:reserve [reserve : Number 1])
    (list main reserve)))

(print (num-update))
(print (num-update #:main 2))
(print (num-update #:reserve 2))

kejadlen

fn deserialize_images<'de, D>(de: D) -> Result<Vec<Image>, D::Error>
    where D: serde::Deserializer<'de>
{
    let value: serde_json::Value = serde::Deserialize::deserialize(de)?;
    let object = value
        .as_object()
        .ok_or(serde::de::Error::custom("expected an object of images"))?;
    let images = object
        .iter()
        .flat_map(|(k, v)| match (k.as_ref(), v) {

kejadlen

import Data.List

pairs xs = zip xs (tail xs)
repeatingPairs xs = filter (\(x,y) -> x == y) $ pairs xs

hasRepeatingPairs :: String -> Bool
hasRepeatingPairs xs = any (\pair -> length (elemIndices pair rps) >= 2) rps
  where rps = repeatingPairs xs

kejadlen

class Turing
  def initialize(file, tape=nil)
    @tape = Hash.new('_')
    @head = 0

    # initialize tape
    tape.split(//).each_with_index {|c,i| @tape[i] = c } if tape

    # read program instructions
    @program = Hash[

kejadlen

extern crate rand;

use std::collections::HashMap;
use std::io::{self, Read};

struct Markov {
    rng: rand::ThreadRng,
    seed: String,
    freqs: HashMap<String, Vec<String>>,
}