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 programmed with?

— Elm.

Of course it's Elm…

Outline

module Main exposing (..)

import Html exposing (text)


type Stock
    = Stock String Int


library1 : List Stock
library1 =
    [ 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

Ok, so you'll have to fill the blank. After a few minutes, you identify two main components: one is about taking the first letter of every Stock name. The second is finding the amount of each Char in a List (Char, Int).

Let's start with the second point and assume we have a value of List (Char, Int) already available. We know at least to functions to recurse on lists: maps and folds. Clearly, we'll have to choose a fold, since some aggregating is needed when several identical Char are in the list. Let's pick foldl, it does not really matter right now. So, the type of List.foldl is:

foldl : (a -> b -> b) -> b -> List a -> b

In fact, you notice you'll need two folds! One inner fold for counting of many book for initial X, and one outer fold for going through all the initials required by the master.

Inner foldl: how many books with Initial X

You think about using type aliases to make your code easier to read, the IA won't mind. To specialize your inner foldl, which is morally a foldlForX, you identify a as an element of a library stock (even though the title has been shortened already to its initial), and b as the final index count.

type alias Initial = Char
type alias Count = Int
type alias TitleCount = (Initial, Int) 
type alias FinalCount = (Initial, Int)

You rewrite your specialized foldl type signature to account for the type aliases:

foldForX : (TitleCount -> FinalCount -> FinalCount)
      -> FinalCount
      -> List TitleCount
      -> FinalCount

After a call to this, you'll get how many books have a title that starts with the initial X.

You are missing the function with type (TitleCount -> FinalCount -> FinalCount), and you reflect a little bit on its name and on its usage. Hmmm, it takes a TitleCount and a FinalCount and returns a (new) FinalCount? You choose to call it:

updateFinalCount : (TitleCount -> FinalCount -> FinalCount)

Actually it takes another (hidden) parameter, you change its name to reflect that:

updateFinalCountForX : (TitleCount -> FinalCount -> FinalCount)
updateFinalCountForX t f =

NB: addBio : String -> User -> User addBio bio user = { user | bio = bio }

4.5 KiB Raw Blame History

FPKATA #01: In the library…

Introduction

Outline

Walkthrough

Inner foldl: how many books with Initial X

4.5 KiB

Raw Blame History