module Bag where

import Data.Map as Map

type Bag a = Map a Int

fromList :: Ord a => [a] -> Bag a
fromList []     = Map.empty
fromList (x:xs) = Map.insertWith (+) x 1 (Bag.fromList xs)

mostCommon :: Int -> Bag a -> Bag a
{- How to implement this function ... -}

module Bag where
import Data.Map as Map
import List

-- A bag is a specialised type of map
type Bag a = Map a Int

-- Creates a bag from a list
fromList :: Ord a => [a] -> Bag a
fromList []     = Map.empty
fromList (x:xs) = Map.insertWith (+) x 1 (Bag.fromList xs)

-- Compares the latter value of two tuples
compareAmounts :: Ord b => (a,b) -> (a,b) -> Ordering
compareAmounts (_,x) (_,y) = compare x y

-- Creates an ordered list from a bag
toAscList :: Ord a => Bag a -> [(a, Int)]
toAscList = (sortBy compareAmounts) . Map.toList

-- Returns the most common elements in the bag
mostCommon :: Ord a => Int -> Bag a -> Bag a
mostCommon n = Map.fromList . (Map.foldWithKey maximumValues [])
	where maximumValues k v maxs = take n (insertValues k v maxs)
	      insertValues  k v      = insertBy (flip compareAmounts) (k,v)

-- Written by Jessehk on
-- Monday December 11, 2006

module Cards
    where

import System.Random

data Card = Card Face Suit
          | Joker
          deriving (Show, Eq)

data Suit = Hearts
          | Diamonds
          | Clubs 
          | Spades
          deriving (Show, Eq)

suits :: [Suit]
suits = [Hearts, Diamonds, Clubs, Spades]

data Face = Jack
          | Queen
          | King
          | Ace
          | Number Int
          deriving (Show, Eq)

faces :: [Face]
faces = [Number 2 , Number 3, Number 4, Number 5,
         Number 6 , Number 7, Number 8, Number 9,
         Number 10, Jack    , Queen   , King    ,
         Ace]

-- Return a list of all cards of a given Suit.
allOfSuit :: Suit -> [Card]
allOfSuit = cardsFromList . (zip faces) . repeat

deck :: [Card]
deck = (concat . map allOfSuit) suits

-- Return a List of cards from a List of tuples.
cardsFromList :: [(Face, Suit)] -> [Card]
cardsFromList []                  = []
cardsFromList ((face, suit) : xs) = Card face suit : cardsFromList xs

shuffle :: [Card] -> IO [Card]
shuffle []    = return []
shuffle cards = do
    card <- randCard cards
    rest <- shuffle $ filter (/= card) cards
    return (card : rest)

randCard :: [Card] -> IO Card
randCard cards = do
    numb <- randomRIO (0 :: Int, length cards - 1)
    return $ cards !! numb

module Main
    where

import Cards

main = do
    shuffled <- shuffle deck
    (putStrLn . show . length) shuffled

def fib(n):
    a = 1
    b = 1
    print a
    print b
    for i in range(n):
        c = a + b
        a = b
        b = c
        print b

fib(10)

def fib(n):
    s = [1, 1]
    for i in xrange(n):
        s.append(sum(s))
        yield s.pop(0)

for x in fib(10): print x

fib = 1 : 1 : zipWith (+) fib (tail fib)

main = mapM (putStrLn . show) (take 10 fib)