answer.cpp

#include "answer.hpp"

#include <sstream>

bool between(int x1, int x2, int x)
{
	return ((x1 - x) * (x2 - x)) <= 0;
}

bool inside(int x1, int y1, int x2, int y2, int x, int y)
{
	return between(x1, x2, x) && between(y1, y2, y);
}

std::string solve(const std::string& s)
{
	std::istringstream iss(s);

	int  p1, p2, p3, p4, p5, p6;
	char h1, h2, c1, h3, h4;

	iss >> p1 >> h1 >> p2 >> h2 >> p3 >> c1 >> p4 >> h3 >> p5 >> h4 >> p6;


	if((h1 != '-') || (h2 != '-') || (h3 != '-') || (h4 != '-') || (c1 != ',') || ( ! iss.eof()))
	{
		return "-";
	}

	int x11 = p1 / 10, y11 = p1 % 10;
	int x12 = p2 / 10, y12 = p2 % 10;
	int x13 = p3 / 10, y13 = p3 % 10;
	int x21 = p4 / 10, y21 = p4 % 10;
	int x22 = p5 / 10, y22 = p5 % 10;
	int x23 = p6 / 10, y23 = p6 % 10;

	int count = 0;
	for(int y = 0; y < 10; ++y)
	{
		for(int x = 0; x < 10; ++x)
		{
			if( (inside(x11, y11, x12, y12, x, y) || inside(x11, y11, x13, y13, x, y)) && (inside(x21, y21, x22, y22, x, y) || inside(x21, y21, x23, y23, x, y))  )
			{
				++count;
			}
		}
	}

	std::ostringstream oss;

	oss << count;

	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

type Pos = (Int, Int)

between x1 x2 x = (x1 - x) * (x2 - x) <= 0

inside x1 y1 x2 y2 x y = (between x1 x2 x) && (between y1 y2 y)

l_intersect :: (Pos, Pos, Pos) -> (Pos, Pos, Pos) -> String
l_intersect ((x11, y11), (x12, y12), (x13, y13)) ((x21, y21), (x22, y22), (x23, y23)) =
    show $ length [1| x <- [0..9], y<-[0..9], ((inside x11 y11 x12 y12 x y) || (inside x11 y11 x13 y13 x y)) && ((inside x21 y21 x22 y22 x y) || (inside x21 y21 x23 y23 x y))]

solve :: String -> String
solve [x11,y11,'-',x12,y12,'-',x13,y13,',',x21,y21,'-',x22,y22,'-',x23,y23] =
    l_intersect ((read [x11], read [y11]), (read [x12], read [y12]), (read [x13], read [y13]))
                ((read [x21], read [y21]), (read [x22], read [y22]), (read [x23], read [y23]))

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

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 ()