struct Problem;

struct Solution;

class Skill {

public:

Skill() = default;

Solution Solve(Problem problem);

}

// Implement class to represent an engineer. Each engineer could have multiple skills.

// Implement class to represent a team. Each team could have multiple engineers.

// A team class needs to provide a Solve function: given a problem, whether it could be solved

// and what is the solution. A problem could be solved if there is an engineer in the team that

// could provide a solution to it.

// My solution:

class Engineer{

public:

Engineer() = default;

void setSkill(const Skill& skill);

Solution Solve(Problem problem) const;

private:

std::set<Skill> skills;

};

Solution Engineer::Slove(Problem problem) const

{

if(skills.empty())

return Solution::NOSOLUTION;

for(auto i : skills{

Solution solution = i.solve(problem);

if (solution != Solution::NOSOLUTION)

return solution;

}

return Solution::NOSOLUTION;

}

Solution Engineer::setSkill(const Skill& skill){

skills.insert(skill);

}

class Team{

public:

Team() = default;

void addMember(const Engineer&);

SolutionSolve(Problem problem) const;

private:

std::set<Engineer> engineers;

}

void Team::addMember(const Engineer& engeineer){

engineers.insert(engeineer);

}

Solution Team::Slove(Problem problem) const

{

if(engineers.empty())

return Solution::NOSOLUTION;

for(auto i : engineers{

Solution solution = i.solve(problem);

if (solution != Solution::NOSOLUTION)

return solution;

}

return Solution::NOSOLUTION;

}

public struct Problem { }
public struct Solution { }
public class Skill
{
    public Solution? Solve(Problem problem) 
    { throw new NotImplementedException();  }
}

// define a class to represent an engineer. Each engineer could have multiple skills.
public class Engineer
{
    public string Name { get; set; }
    public List<Skill> Skills { get; set; }
}

// define a class to represent a team. Each team could have multiple engineers.
public class Team
{
    public string Name { get; set; }
    public List<Engineer> Engineers { get; set; }
    public Solution? Solve(Problem problem)
    {
        foreach (var engineer in Engineers)
        foreach (var skill in engineer.Skills)
        {
            var solution = skill.Solve(problem);
            if (solution != null) return solution;
        }

        return null;
    }
}

#include gtest plz

class Skill {
    public:
        enum class SID { NONE,
                         EAT, SLEEP, BEAT_DOUDOU,
                         LADY_READ /*hard skill, contact you@are.lying.com if feel confident*/ };

        Skill(SID sid) : m_sid(sid) {};

    private:
        const SID m_sid = SID::NONE;
};

struct Solution {
public:
    Solution(bool solved) : m_solved(solved) { };
    Solution(const Solution& others) = default;
    Solution& operator=(const Solution& others) = default;

    bool Solved() const { return m_solved; }

private:
    bool m_solved { false };
};

class Problem {
public:
    Problem() = delete;
    Problem(std::initializer_listconst & skills): m_desiredSkills(skills) { }

    struct WorkTable {
        WorkTable(size_t size) : m_result(size, false) {}
        bool Done() const { return std::find(begin(m_result), end(m_result), false) == end(m_result); }
        void SetSolved(size_t index){ m_result[index] = true; }
        vector m_result;
    };

    WorkTable NewWorkTable() const { return WorkTable(m_mustHaveSkills.size()); }

    void Research(const Skill::SID sid, WorkTable& worktable) const {
        auto itor = m_mustHaveSkills.find(sid);
        if(itor != m_mustHaveSkills.end()) {
            worktable.SetSolved(abs(std::distance(m_mustHaveSkills.begin(), itor)));
        }
    }

    void Research(const std::unordered_set& skills, WorkTable& worktable) const {
        for(auto sid : skills) {
            Research(sid, worktable);
        }
    }

private:
    std::unordered_set m_mustHaveSkills;
};

class Engineer {
    public:
        Engineer() = delete; // no skill? not a engineer.
        Engineer(std::initializer_listconst & skills) : m_skills(skills) { };

        void Work(const Problem& problem, Problem::WorkTable& worktable) const {
            problem.Research(m_skills, worktable);
        }

    private:
        std::unordered_set m_skills;
};

class Team {
    public:
        Team() = delete;
        Team(std::initializer_listconst & engineers) : m_engineers(engineers) { };

        Solution Work(const Problem& problem) const {
            auto worktable = problem.NewWorkTable();
            for(auto& e : m_engineers) {
                e.Work(problem, worktable);
                if(worktable.Done()) {
                    return Solution(true);
                }
            }
            return Solution(false);
        }
private:
    std::vector m_engineers;
};

TEST(Q0007_SIMPLE, TEAM1)
{
    Team team_1 {
        { {Skill::SID::EAT} },
        { {Skill::SID::SLEEP } },
        { {Skill::SID::EAT, Skill::SID::SLEEP } },
        { {Skill::SID::BEAT_DOUDOU, Skill::SID::SLEEP } },
    };

    Problem p1 { Skill::SID::BEAT_DOUDOU };
    EXPECT_EQ(team_1.Work(p1).Solved(), true );

    Problem p2 { Skill::SID::LADY_READ };
    EXPECT_EQ(team_1.Work(p2).Solved(), false );
}