Hydra Implementation in Haskell

basics-1.hs

let firstArray = 0:1:[2, 3]
-- [0, 1, 2, 3]
let infiniteOnes = 1:infiniteOnes
-- [1, 1, 1, 1, 1, ........................]
-- never stops, hit ctrl-C to get your interpreter back

basics-2.hs

sumOfElements []     = 0
sumOfElements (x:xs) = x + sumOfElements xs

basics-3.hs

[1] ++ [3]     -- [1, 3]
null []        -- True
null [1]       -- False
replicate 2 3  -- [3, 3]

chop.hs

chop []       = []
chop (1:xs)   = xs
chop (n:xs)   = (replicate (n - 1) (n - 1)) ++ xs
----------------------------------------------------
chop [1]
-- []
chop [4]
-- [3, 3, 3]
chop [3, 3, 3]
-- [2, 2, 3, 3]
chop [9,9,9,9,9,9,9,9,9]
-- [8,8,8,8,8,8,8,8,9,9,9,9,9,9,9,9]

count-chops.hs

countOfChops heads = length (repeatedlyChopTillDead heads)
--------------------------------------------------
countOfChops [1] -- 1
countOfChops [3] -- 5
countOfChops [9,9,9,9,9,9,9,9,9] -- 986409 (this takes a while)

herculeswilldie.hs

willHerculesDie n heads = any (> n) (map length (repeatedlyChopTillDead heads))
----------------------------------------------------------------------------
willHerculesDie 37 [9,9,9,9,9,9,9,9,9] -- False
willHerculesDie 36 [9,9,9,9,9,9,9,9,9] -- True

hydra.hs

-- To load this, save this as hydra.hs
-- then run ghci, and type :l hydra (colon ell hydra)

module Hydra where

firstArray = 0:1:[2, 3]
infiniteOnes = 1:infiniteOnes

chop []       = []
chop (1:xs)   = xs
chop (n:xs)   = (replicate (n - 1) (n - 1)) ++ xs

-- repeatedlyChop heads = heads:repeatedlyChop (chop heads)
-- takeWhileAlive (x:xs) = if null x then [] else x:(takeWhileAlive xs)
-- repeatedlyChopTillDead heads = takeWhileAlive (repeatedlyChop heads)

repeatedlyChopTillDead heads = takeWhile (not.null) (iterate chop heads)

countOfChops heads = length (repeatedlyChopTillDead heads)
willHerculesDie n heads = any (> n) (map length (repeatedlyChopTillDead heads))

iteratethroughheads.hs

repeatedlyChopTillDead heads = takeWhileAlive (repeatedlyChopTillDead heads)
----------------------------------------------------------------------------
repeatedlyChopTillDead [4]
-- [[4],[3,3,3],[2,2,3,3],[1,2,3,3],[2,3,3],[1,3,3],[3,3],[2,2,3],[1,2,3],[2,3],[1,3],[3],[2,2],[1,2],[2],[1]]

repeatedly-chop1.hs

repeatedlyChop heads = heads:repeatedlyChop (chop heads)
----------------------------------------------------------
repeatedlyChop [3]
-- [[3],[2,2],[1,2],[2],[1], [], [], [] ...]
-- this is an infinite list

repeatedly-chop2.hs

repeatedlyChop heads = iterate chop heads

repeatedly-simple.hs

repeatedlyChopTillDead heads = takeWhile (not.null) (iterate chop heads)

takewhilealive.hs

takeWhileAlive (x:xs) = if null x then [] else x:(takeWhileAlive xs)