mpo

6.5 KiB

Raw Permalink Blame History

FPKATA #01: In the library…

(Soundtrack: Arch Enemy — War Eternal)

(Inspired from this exercice: http://www.codewars.com/kata/54dc6f5a224c26032800005c/train/haskell)

REPL compatible copy/paste (TL;DR)

type Stock = Stock { name : String, count : Int }
library1 =  [ Stock { name = "ABART", count = 20 } , Stock { name = "CDXEF", count = 50 } , Stock { name = "BKWRK", count = 25 } , Stock { name = "BTSQZ", count = 89 } , Stock { name = "DRTYM", count = 60 } ]
categories1 = [ 'A', 'B', 'C', 'W' ]

toUplet : List Repl.Stock -> List ( String, Int )
toUplet = List.map (\x -> case x of Stock v -> (v.name,v.count))

onlyInitials : List (String, Int) -> List (Char, Int)
onlyInitials = List.map (\x -> case x of (s, i) -> ((Maybe.withDefault '\0' << List.head << String.toList) s,i) )

howMany : Char -> List Char Int -> Int
howMany c = (List.foldl (\t acc -> acc + Tuple.second t) 0) << List.filter (\t -> (Tuple.first t) == c)

stockList : List Stock -> List Char -> List ( Char, Int )
stockList sl = List.map (\c -> (c, sl |> toUplet >> onlyInitials >> howMany c))

Prologue

You are stuck in a library with a very talkative and experimental science-minded IA. It keeps repeating the following:

— Pleeease, can you help me?

— …

— Pleaaase, can you help?

— …

— Hellooooo?

— …

Since you would really like to have peace, you dare ask:

— What's the matter?

— My code is incomplete, I've lost my code, please help!

— What code? What are you talking about?

— I really need to sort the library index and count how many books have the same first-letter reference, but only in from a list…

— Wait!

— … of characters that my master will provide.

— This makes no sense, can't you write it down?

A few seconds pass in total silence. Then, there's a sound coming from your right, something like an inkjet printer work at a fast pace. It's actually a printer. It throws the printed sheet of paper at you in a furious “TWEEEEEEEEEEEP”. You pick up the paper and read:

INPUT................:
  LIBRARY COUNT......: [("ABOOK", 12), ("BPDEXU", 45), ("BJLDRSA", 15), ("CLDAVB", 98), ("DAJLDI", 32)]
  INDICES............: ['A','B','C','W']
OUTPUT...............:
  INDEX COUNT........: [('A',12),('B',60),('C',98),('W',0)]
TIME TO GOOD ANSWER..: 203 years

You frown:

— It took you so long to find this?

— Can you help me? I've lost my code, my dedicated code for this task.

— Well, you managed to get this one right, didn't you?

— Nooooo! Master is going to unplug me if I use bruteforce again! Master was very unhappy with my performance! I want to live! Please help me!

— Ok, all right, calmn down, there, there… What are you programmed with?

— Elm.

Of course it's Elm…

Outline

module Main exposing (..)

import Html exposing (text)


type Stock
    = Stock String Int


library1 : List Stock
libr  ary1 =
    [ Stock "ABART" 20
    , Stock "CDXEF" 50
    , Stock "BKWRK" 25
    , Stock "BTSQZ" 89
    , Stock "DRTYM" 60
    ]


categories1 : List Char
categories1 =
    [ 'A'
    , 'B'
    , 'C'
    , 'W'
    ]


stockList : List Stock -> List Char -> List ( Char, Int )
stockList st cs =
    <THIS IS BLANK, FILL ME>


main =
    text (toString (stockList library1 categories1))

Walkthrough

All is needed is to fill the gaps from library1, categories1 to stockList. So, what is needed for successfully building a stockList? Let's look at the types: We have a List Stock but we don't have any function to work on it. We could make some functions for this, but we'll just be lazy and turn a List Stock into a much lower level List (String, Int):

toUplet : List Stock -> List ( String, Int )
toUplet = List.map (\x -> case x of Stock v -> (v.name,v.count))

We'll need to count stock by initials, so we write a function for that:

onlyInitials : List (String, Int) -> List (Char, Int)
onlyInitials = List.map (\x -> case x of (s, i) -> ((Maybe.withDefault '\0' << List.head << String.toList) s,i) )

So, for every tuple, we operate of the left part. There is some strange machinery for turning a String -> Char involving a Maybe value, because List.head may fail. Of course in our case, no book should ever have an empty title, but Elm doesn't know that. We mitigate this by setting a default null char if the title is empty.

Good! We can already chain the two preceding functions since the output type of toUplet matches the input type of onlyInitials. Ain't that a coincidence?

> library1 |> toUplet >> onlyInitials
[('A',20),('C',50),('B',25),('B',89),('D',60)] : List ( Char, Int )

Oh, but oh. There are two Bs in there! Those should go together and their counts added together, and for that, nothing is better than a fold. Let's write a function that answers the question: “How many X is there?” where X is a Char.

howMany : Char -> List Char Int -> Int
howMany c = List.filter (\t -> (Tuple.first t) == c)
          >> (List.foldl (\t acc -> acc + Tuple.second t) 0)

howMany is made of two functions: the first is one that only keeps tuples of interest (they match our Char c) and then we blindly sum the count of the resulting list. We always start the count from 0, so that if we don't find anything, it's still correct.

Let's try to find how may books that have a title starting with B in the library:

> library1 |> toUplet >> onlyInitials >> howMany 'B'
114 : Int

Nice! Well, we're almost done actually. We just need to do that for every letter we were requested in categories1. Let's use a map for that:

stockList sl = List.map (\c -> (c, sl |> toUplet >> onlyInitials >> howMany c) )

And voilà! Let's run this:

> stockList library1 categories1
[('A',20),('B',114),('C',50),('W',0)] : List ( Char, Int )

Mission accomplished.

Epilogue

You wave you solution in the air shouting:

— Here kitty kitty kitty!

A hopeful voice says:

— You found my code?

Well, not exactly, you think. But heck,

— Sure, here it is!

There's again a silence then a loud…

— Yiiiiiiiiiiiiiiiipeeeeeeeeeeeee!

… dissipates all doubts about the state of mind of your newfound friend (for life).

— It woooooooorks, I'm so relieved, master won't punish me!

The voice continues:

— But… But he cannot find out I've ever lost my code, no. Never.

— I promise I won't say…

You don't have time to finish your sentence. A brief “ZAP” later, you are only a smoking pile of ashes. A friendly and useful pile of ashes.

6.5 KiB Raw Permalink Blame History