Daily Challenge #174 - Soccer League Table

module SoccerLeague ( Game, Name, Team, League , empty, push, points , goalsFor, goalsAgainst, goalDifference , wins, draws, losses , State, runState ) where import Data.Map.Strict (Map) import qualified Data.Map.Strict as M import Data.Bifunctor (bimap) import Data.Tuple (swap) import Data.Maybe (fromMaybe) import Data.Bool (bool) import Text.ParserCombinators.Parsec ( GenParser, ParseError, parse, many1 , digit, letter, string, space, (<|>)) type Name = String data Team = Team { t_name :: Name , t_goalsFor :: Int , t_goalsAgainst :: Int , t_wins :: Int , t_draws :: Int , t_losses :: Int } deriving Show type League = Map Name Team type Game = ((Name, Int), (Name, Int)) updateTeam :: Name -> (Int, Int) -> State League () updateTeam name (for, against) = do map <- get let t = fromMaybe (Team name 0 0 0 0 0) $ map M.!? name let t' = Team { t_name = name , t_goalsFor = t_goalsFor t + for , t_goalsAgainst = t_goalsAgainst t + against , t_wins = t_wins t + bool 0 1 (for > against) , t_draws = t_draws t + bool 0 1 (for == against) , t_losses = t_losses t + bool 0 1 (for < against) } put $ M.insert name t' map empty :: League empty = M.empty push :: String -> State League () push str = case parseGame str of Left e -> error $ "bad push input: " ++ str Right ((n1, s1), (n2, s2)) -> do updateTeam n1 (s1, s2) updateTeam n2 (s2, s1) -- Lifts a simple function on a team in the league to work on the state liftToState :: (Team -> a) -> String -> State League (Maybe a) liftToState f name = get >>= return . fmap f . (flip (M.!?) name) points :: String -> State League (Maybe Int) points = liftToState $ sum . flip fmap [(*3) . t_wins, t_draws] . flip ($) goalsFor :: String -> State League (Maybe Int) goalsFor = liftToState t_goalsFor goalsAgainst :: String -> State League (Maybe Int) goalsAgainst = liftToState t_goalsAgainst goalDifference :: String -> State League (Maybe Int) goalDifference = liftToState (\team -> t_goalsFor team - t_goalsAgainst team) wins :: String -> State League (Maybe Int) wins = liftToState t_wins draws :: String -> State League (Maybe Int) draws = liftToState t_draws losses :: String -> State League (Maybe Int) losses = liftToState t_losses -- GAME STRING PARSER trimSpaces :: String -> String trimSpaces = f . f where f = dropWhile (==' ') . reverse number :: GenParser Char st Int number = many1 digit >>= return . read name :: GenParser Char st Name name = many1 (letter <|> space) >>= return . trimSpaces game :: GenParser Char st Game game = do fstName <- name fstScore <- number string " - " sndScore <- number sndName <- name return ((fstName, fstScore), (sndName, sndScore)) parseGame :: String -> Either ParseError Game parseGame = parse game "(unknown)" -- STATE MONAD IMPLEMENTATION newtype State s a = State { runState :: s -> (s, a) } instance Functor (State s) where fmap f (State x) = State $ bimap id f . x instance Applicative (State s) where pure x = State $ \s -> (s, x) (State sf) <*> (State sx) = State $ \s -> let (s', f) = sf s (s'', x) = sx s in (s'', f x) instance Monad (State s) where return = pure sx >>= f = State $ \s -> let (s', x) = runState sx s in runState (f x) s' get :: State s s get = State $ \x -> (x, x) put :: s -> State s () put s = State $ const (s, ()) 

import SoccerLeague import Data.Maybe (fromMaybe) example :: State League [Int] example = do push "Man Utd 3 - 0 Liverpool" l1 <- sequence [goalsFor "Man Utd", points "Man Utd", points "Liverpool", goalDifference "Liverpool"] push "Liverpool 1 - 1 Man Utd" l2 <- sequence [goalsFor "Man Utd", points "Man Utd", points "Liverpool", goalsAgainst "Man Utd", points "Tottenham"] return $ map (fromMaybe 0) $ l1 ++ l2 main :: IO () main = do sequence_ $ map print $ snd $ runState example empty 

 const calcPoints = Symbol('calcPoints'); class LeagueTable { constructor() { this.matches = []; this.teamMapping = null; } [calcPoints](a, b) { return a > b ? 3 : a === b ? 1 : 0; } push(matchString) { let rawScore = matchString.match(/\d+\s*\-\s*\d+/g)[0]; let teamGoals = rawScore.split('-').map(x => parseInt(x.trim())); let names = matchString.split(rawScore).map(x => x.trim()); if (!this.teamMapping) { this.teamMapping = names.map((x, i) => ({ key: i, value: x })); } let teamOne = { teamId: this.teamMapping.find(x => x.value === names[0]).key, goals: teamGoals[0], gd: teamGoals[0] - teamGoals[1], points: this[calcPoints](teamGoals[0], teamGoals[1]) }; let teamTwo = { teamId: this.teamMapping.find(x => x.value === names[1]).key, goals: teamGoals[1], gd: teamGoals[1] - teamGoals[0], points: this[calcPoints](teamGoals[1], teamGoals[0]) }; this.matches.push(teamOne); this.matches.push(teamTwo); } getPoints(teamName) { let teamId = this.teamMapping.find(x => x.value === teamName).key; return this.matches .filter(x => x.teamId === teamId) .reduce((acc, v) => acc + v.points, 0); } getGoalsFor(teamName) { let teamId = this.teamMapping.find(x => x.value === teamName).key; return this.matches .filter(x => x.teamId === teamId) .reduce((acc, v) => acc + v.goals, 0); } getGoalsAgainst(teamName) { let teamId = this.teamMapping.find(x => x.value !== teamName).key; return this.matches .filter(x => x.teamId === teamId) .reduce((acc, v) => acc + v.goals, 0); } getGoalDifference(teamName) { let teamId = this.teamMapping.find(x => x.value !== teamName).key; return this.matches .filter(x => x.teamId === teamId) .reduce((acc, v) => acc + -v.gd, 0); } getWins(teamName) { let teamId = this.teamMapping.find(x => x.value === teamName).key; return this.matches .filter(x => x.teamId === teamId) .reduce((acc, v) => (v.points > 1 ? acc + 1 : acc), 0); } getDraws(teamName) { let teamId = this.teamMapping.find(x => x.value === teamName).key; return this.matches .filter(x => x.teamId === teamId) .reduce((acc, v) => (v.points === 1 ? acc + 1 : acc), 0); } getLosses(teamName) { let teamId = this.teamMapping.find(x => x.value === teamName).key; return this.matches .filter(x => x.teamId === teamId) .reduce((acc, v) => (v.points === 0 ? acc + 1 : acc), 0); } } let lt = new LeagueTable(); lt.push('Man Utd 3 - 0 Liverpool'); console.log(`Goals : ${lt.getGoalsFor('Man Utd')}`); console.log(`Points : ${lt.getPoints('Man Utd')}`); console.log(`Points : ${lt.getPoints('Liverpool')}`); console.log(`Goal Difference : ${lt.getGoalDifference('Liverpool')}`); lt.push('Liverpool 1 - 1 Man Utd'); console.log(`Goals : ${lt.getGoalsFor('Man Utd')}`); console.log(`Points : ${lt.getPoints('Man Utd')}`); console.log(`Points : ${lt.getPoints('Liverpool')}`); console.log(`Goals Against : ${lt.getGoalsAgainst('Man Utd')}`); 

class LeagueTable def initialize @results = Hash.new(Hash.new(0)) end def push str str.match /^(.+) (\d+) - (\d+) (.+)$/ h_name, a_name = $1, $4 h_goal, a_goal = $2.to_i, $3.to_i result = h_goal <=> a_goal @results[h_name] = Hash.new(0) unless @results.has_key? h_name @results[a_name] = Hash.new(0) unless @results.has_key? a_name @results[h_name].tap do |stats| stats[:goals] += h_goal stats[:conceded] += a_goal stats[:wins] += (result + 1) / 2 stats[:losses] += (-result + 1) / 2 stats[:draws] += -(result.abs) + 1 end @results[a_name].tap do |stats| stats[:goals] += a_goal stats[:conceded] += h_goal stats[:wins] += (-result + 1) / 2 stats[:losses] += (result + 1) / 2 stats[:draws] += -(result.abs) + 1 end end def goals_for team @results[team][:goals] end def goals_against team @results[team][:conceded] end def goal_difference team @results[team][:goals] - @results[team][:conceded] end def get_wins team @results[team][:wins] end def get_draws team @results[team][:draws] end def get_losses team @results[team][:losses] end def get_points team 3*@results[team][:wins] + @results[team][:draws] end end 

function LeagueTable() { this.matches = [] }; LeagueTable.prototype.push = function (matchStr){ const teams = matchStr.split(' - '); const homeTeam = teams[0].slice(0,-2); const awayTeam = teams[1].slice(2); const homeGoals = parseInt(teams[0].slice(-2)); const awayGoals = parseInt(teams[1].slice(0, 2)); let homeScore = 0; let awayScore = 0; if(homeGoals == awayGoals) { homeScore = 1; awayScore = 1; } else if(homeGoals > awayGoals){ homeScore = 3; } else { awayScore = 0; } const match = { homeTeam, awayTeam, homeGoals, awayGoals, homeScore, awayScore, }; this.matches.push(match); return JSON.stringify(match); }; LeagueTable.prototype.get_points = function (teamName){ points = 0; this.matches.forEach(match => { if(match.homeTeam === teamName){ points += match.homeScore; } else if(match.awayTeam === teamName){ points += match.awayScore; } }) return points; }; LeagueTable.prototype.get_goals_for = function (teamName){ goals = 0; this.matches.forEach(match => { if(match.homeTeam === teamName){ goals += match.homeGoals; } else if(match.awayTeam === teamName){ goals += match.awayGoals; } }); return goals; }; LeagueTable.prototype.get_goals_against = function (teamName){ goals = 0; this.matches.forEach(match => { if(match.homeTeam === teamName){ goals += match.awayGoals; } else if(match.awayTeam === teamName){ goals += match.homeGoals; } }); return goals; }; LeagueTable.prototype.get_goals_difference = function (teamName){ diff = 0; this.matches.forEach(match => { if(match.homeTeam === teamName){ diff += (match.homeGoals - match.awayGoals); } else if(match.awayTeam === teamName){ diff += (match.awayGoals - match.homeGoals);; } }); return diff; }; LeagueTable.prototype.get_wins = function (teamName){ wins = 0; this.matches.forEach(match => { if(match.homeTeam === teamName && match.homeScore === 3){ wins++ } else if(match.awayTeam === teamName && match.awayScore === 3){ wins++ } }); return wins; }; LeagueTable.prototype.get_draws = function (teamName){ draws = 0; this.matches.forEach(match => { if(match.homeTeam === teamName && match.homeScore === 1){ draws++ } else if(match.awayTeam === teamName && match.awayScore === 1){ draws++ } }); return draws; }; LeagueTable.prototype.get_losses = function (teamName){ losses = 0; this.matches.forEach(match => { if(match.homeTeam === teamName && match.homeScore === 0){ losses++ } else if(match.awayTeam === teamName && match.awayScore === 0){ losses++ } }); return losses; };