answer.cpp

#include "answer.hpp"

#include <bitset>
#include <string>
#include <iostream>
#include <sstream>
#include <algorithm>

typedef std::bitset<100> Bitset;

struct El
{
    int p1, p2, p3;

    Bitset asBitset() const
    {
        int x1 = p1 / 10, y1 = p1 % 10;
        int x2 = p2 / 10, y2 = p2 % 10;
        int x3 = p3 / 10, y3 = p3 % 10;

        Bitset b2, b3;

        fill(b2, std::min(x1, x2), std::min(y1, y2), std::max(x1, x2), std::max(y1, y2));
        fill(b3, std::min(x1, x3), std::min(y1, y3), std::max(x1, x3), std::max(y1, y3));

        return b2 | b3;
    }

    static void fill(Bitset& b, int x1, int y1, int x2, int y2)
    {
        for(int y = y1; y <= y2; ++y)
        {
            for(int x = x1; x <= x2; ++x)
            {
                b.set(x * 10 + y);
            }
        }
    }
};

std::istream& operator >> (std::istream& in, El& el)
{
    int  p1, p2, p3;
    char d1, d2;
    in >> p1 >> d1 >> p2 >> d2 >> p3;
    if((d1 == '-') && (d2 == '-'))
    {
        el.p1 = p1; el.p2 = p2; el.p3 = p3;
    }
    return in;
}

std::string solve(const std::string& s)
{
    std::istringstream iss(s);
    El e1, e2;
    char d;

    iss >> e1 >> d >> e2;

    std::ostringstream oss;
    if((d == ',') && iss.eof())
    {
        oss << ((e1.asBitset() & e2.asBitset()).count());
    }
    else
    {
        oss << 0;
    }

    return oss.str();
}

answer.hpp

#ifndef DOUKAKU_ANSWER_HPP
#define DOUKAKU_ANSWER_HPP

#include <string>

std::string solve(const std::string& s);

#endif//DOUKAKU_ANSWER_HPP

Answer.hs

module Answer(solve) where

import Data.List

type Pos = (Int, Int)

l_intersect :: (Pos, Pos, Pos) -> (Pos, Pos, Pos) -> String
l_intersect ((a11, a12), (a21, a22), (a31, a32)) ((b11, b12), (b21, b22), (b31, b32)) =
    show $ length $ intersect (union rect1 rect2) (union rect3 rect4)
    where
        rect1 = [(x,y)|x<-(n a11 a21), y<-(n a12 a22)]
        rect2 = [(x,y)|x<-(n a11 a31), y<-(n a12 a32)]
        rect3 = [(x,y)|x<-(n b11 b21), y<-(n b12 b22)]
        rect4 = [(x,y)|x<-(n b11 b31), y<-(n b12 b32)]
        n a b = if a < b then [a..b] else [b..a]

solve :: String -> String
solve [a11,a12,'-',a21,a22,'-',a31,a32,',',b11,b12,'-',b21,b22,'-',b31,b32] =
    l_intersect ((read [a11], read [a12]), (read [a21], read [a22]), (read [a31], read [a32]))
                ((read [b11], read [b12]), (read [b21], read [b22]), (read [b31], read [b32]))

patterns.tsv

test.cpp

#include "answer.hpp"

#include <string>
#include <iostream>
#include <fstream>

struct Pattern
{
    Pattern(const std::string& s) : name(), input(), expected()
    {
        std::size_t d1 = s.find('\t');
        std::size_t d2 = s.find('\t', d1 + 1);
        if((d1 != std::string::npos) && (d2 != std::string::npos))
        {
            name     = s.substr(0, d1);
            input    = s.substr(d1 + 1, d2 - d1 - 1);
            expected = s.substr(d2 + 1);
        }
    }

    std::string name;
    std::string input;
    std::string expected;
};

int main(int, char* [])
{
    std::ifstream patterns("patterns.tsv");
    int           count_cases    = 0;
    int           count_failures = 0;
    std::string   s;
    while(std::getline(patterns, s).good())
    {
        ++count_cases;
        Pattern     pattern(s);
        std::string actual = solve(pattern.input);
        if(actual != pattern.expected)
        {
            ++count_failures;
            std::cout << "Failure in " << pattern.name << "\n"
                      << "expected: \"" << pattern.expected << "\"\n"
                      << "  actual: \"" << actual << "\"\n";
        }
    }
    std::cout << "\nCases: " << count_cases << "  Failures: " << count_failures << "\n";

    return 0;
}

/*
% g++ answer.cpp test.cpp -o cpp_test; ./cpp_test
Failure in #2
expected: "13245"
  actual: "12345"

Cases: 3  Failures: 1
*/

test.hs

module Main where
import Test.HUnit
import Answer

-- referring to source of words 
-- http://www.haskell.org/ghc/docs/latest/html/libraries/base-4.6.0.0/src/Data-List.html#words
split :: (a -> Bool) -> [a] -> [[a]]
split f s =
    case dropWhile f s of
         [] -> []
         s' -> w : split f s''
               where (w, s'') = break f s'

doAssert :: [String] -> Assertion
doAssert (name:input:expected:_) =
    assertEqual name expected (solve input)
doAssert _ = error "Specify a list which contains more than 3 items."

main :: IO ()
main =
    readFile "patterns.tsv"
    >>= runTestTT . test . map (doAssert . split (== '\t')) . lines
    >>  return ()

-- % runhaskell test.hs
-- ### Failure in: 1
-- #2
-- expected: "13245"
--  but got: "12345"
-- Cases: 3  Tried: 3  Errors: 0  Failures: 1