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;
};