joachifm

module Alternate where

import Control.Arrow (Arrow, (***))
import Test.QuickCheck

-- | Transform a list into a list of pairs.
-- Lazy consumer.
pairs :: [a] -> [(a, a)]
pairs (x:y:z) = (x, y) : pairs (y:z)
pairs _ = []

joachifm

import Control.Monad
import Data.List (find, unfoldr)

main = interact (unlines . map (uncurry fmt) . zip [1..] . map solve . parse)
    where fmt n (Just (x, y)) = "Case #" ++ show n ++ ": " ++ unwords [show x, show y]
          fmt _ Nothing = ""

solve (c, xs) = go $ zip [1..] xs
    where go ((i, n):ys) =
            case find (\(_, n') -> n' + n == c) ys of

joachifm

library(XML)
  
url <- "http://eu.battle.net/sc2/en/profile/2007578/1/joachifm"
  
scrape.matchhistory <- function(profile.url) {
  url <- paste(profile.url, "/matches", sep="")
  doc <- htmlTreeParse(url, useInternalNodes=T)
  thead <- xpathSApply(doc, "//*/table[@class='data-table']/thead/tr/th", xmlValue)
  tbody <- xpathSApply(doc, "//*/table[@class='data-table']/tbody/tr/td", compose(trim, xmlValue))
  m <- matrix(tbody, ncol=length(thead), byrow=T)

joachifm

module Volume (runTest) where

import Control.Monad (forM_)
import qualified Test.QuickCheck as QC

-- | Volume values.
--
-- Values of this type are always in the range 0-100.
--
-- Arithmetic on volumes has the property that:

joachifm

{-|
General 'length' for any 'Foldable' structure.

> foldLength [undefined, undefined] = 2
-}

module FoldLength (foldLength1, foldLength2) where

import Data.Functor
import qualified Data.Foldable as F

joachifm

module Timed (timed) where

import Control.Concurrent

-- | Fork a process that should return some value within some time limit.
--
-- > timed 10 (threadDelay 100 >> return "takes too long") = Nothing
-- > timed 100 (threadDelay 10 >> return "in time") = Just "in time"
timed :: Int -- microseconds
      -> IO a

joachifm

{-|
A naive implementation of hash chains; can be used for
one-time password systems.
See <https://en.wikipedia.org/wiki/S/KEY>.
-}

module HashChain (
    HashChain(_size, _hash)
  , next
  , init_chain

joachifm

{-
A direct implementation of a prime sieve ...
-}

module ArrSieve
  ( Sieve(unSieve)
  , isPrime
  , unsafeIsPrime
  , sieve
  ) where

joachifm

import Control.Monad (guard)
import Control.Applicative ((<|>), (*>), pure)
import Data.Maybe (mapMaybe)
import Data.Monoid ((<>))

fizzBuzz :: [Integer] -> [String]
fizzBuzz = mapMaybe (\x -> g 3 "Fizz" x <> g 5 "Buzz" x <|> pure (show x))
  where g d s x = guard ((x `rem` d) == 0) *> pure s

joachifm

{-# LANGUAGE OverloadedStrings #-}

module Commitment ( Message, Commitment, Opening, commit, reveal ) where

import Crypto.Cipher.AES (initAES, encryptCTR, decryptCTR)
import qualified Data.ByteString.Lazy as LB
import qualified Data.ByteString as SB

--