#include <iostream>

//--------------------------------------------------------------------------
// Data Definition
//-----------------
// A homework is either
//  - an empty list
// or a structure consisting of
//  - data as number
//  - rest as homework
//--------------------------------------------------------------------------
struct Homework
{
    double   data;
    Homework *rest;
};

//--------------------------------------------------------------------------
// Data example
//--------------------------------------------------------------------------
Homework *empty = 0;
Homework hw1 = { 84.3, empty };
Homework hw2 = { 95.4, &hw1 };
Homework hw3 = { -59.0, &hw2 };
Homework hw4 = { 23.3, &hw3 };

//--------------------------------------------------------------------------
// Code Pattern
//--------------------------------------------------------------------------
//... F(Homework * H)
//{
//    if (H == 0)
//    {
//        ...
//    }
//    else
//    {
//        ... H->data ...
//            ... F(H->rest) ...
//    }
//}

//--------------------------------------------------------------------------
// Data Definition
//-----------------
// A ScoreCard is a structure consisting of
//  - hw as Homework
//  - project as number
//  - midterm as number
//  - final as number
//--------------------------------------------------------------------------
struct ScoreCard
{
    Homework    *hw;
    double      project;
    double      midterm;
    double      final;
};

//--------------------------------------------------------------------------
// Data example
//--------------------------------------------------------------------------
ScoreCard s1 = { empty, 60.0, 70.0, 95.0 };
ScoreCard s2 = { &hw1, 84.7, 37.9, 58.4 };
ScoreCard s3 = { &hw2, 68.7, 78.2, 95.6 };

//--------------------------------------------------------------------------
// Code Pattern
//--------------------------------------------------------------------------
//... G(ScoreCard S)
//{
//    ... F(S.hw) ...
//    ... S.project ...
//    ... S.midterm ...
//    ... S.final ...
//}

//**************************************************************************
// Prototypes
//**************************************************************************
bool isValidScore(Homework *);
double finalScore(ScoreCard);
double sumScore(Homework *);
int nScore(Homework *);
double averageScore(Homework *);

//**************************************************************************
// main
//**************************************************************************
int main()
{
    std::cout << "isValidScore(empty) == " << std::boolalpha << isValidScore(empty) << "\n";
    std::cout << "isValidScore(&hw1) == " << std::boolalpha << isValidScore(&hw1) << "\n";
    std::cout << "isValidScore(&hw2) == " << std::boolalpha << isValidScore(&hw2) << "\n";
    std::cout << "isValidScore(&hw3) == " << std::boolalpha << isValidScore(&hw3) << "\n";
    std::cout << "isValidScore(&hw4) == " << std::boolalpha << isValidScore(&hw4) << "\n";

    std::cout << "sumScore(empty) == " << sumScore(empty) << "\n";
    std::cout << "sumScore(&hw1) == " << sumScore(&hw1) << "\n";
    std::cout << "sumScore(&hw2) == " << sumScore(&hw2) << "\n";

    std::cout << "nScore(empty) == " << nScore(empty) << "\n";
    std::cout << "nScore(&hw1) == " << nScore(&hw1) << "\n";
    std::cout << "nScore(&hw2) == " << nScore(&hw2) << "\n";

    std::cout << "averageScore(empty) == " << averageScore(empty) << "\n";
    std::cout << "averageScore(&hw1) == " << averageScore(&hw1) << "\n";
    std::cout << "averageScore(&hw2) == " << averageScore(&hw2) << "\n";

    std::cout << "finalScore(s1) == " << finalScore(s1) << "\n";
    std::cout << "finalScore(s2) == " << finalScore(s2) << "\n";
    std::cout << "finalScore(s3) == " << finalScore(s3) << "\n";

    return 0;
}

//--------------------------------------------------------------------------
// @description Check whether the homework scores are valid
// @param H a homework
// @return true if every score is between 0 and 100 inclusively
// @contract isValidScore : Homework -> boolean
// @example isValidScore(empty) == true
// @example isValidScore(&hw1) == true
// @example isValidScore(&hw2) == true
// @example isValidScore(&hw3) == false
// @example isValidScore(&hw4) == false
//--------------------------------------------------------------------------
bool isValidScore(Homework * H)
{
    if (H == 0)
    {
        return true;
    }
    else
    {
        return (0 <= H->data) && (H->data <= 100) && isValidScore(H->rest);
    }
}

//--------------------------------------------------------------------------
// @description determine the final score according to the following ratio
//              homework    20%
//              project     15%
//              midterm     30%
//              final       35%
// @param S a score card
// @return the weighted sum of all scores
// @contract finalScore : ScoreCard -> double
// @example finalScore(S1) == 63.25
// @example finalScore(S2) == 61.375
// @example finalScore(S3) == 85.195
//--------------------------------------------------------------------------
double finalScore(ScoreCard S)
{
    return averageScore(S.hw) * 0.20 +
           S.project * 0.15 +
           S.midterm * 0.30 +
           S.final * 0.35;
}

//--------------------------------------------------------------------------
// @description determine the average of homework scores
// @param H a homework
// @return the average of homework scores
// @contract averageScore : Homework -> double
// @example averageScore(empty) == 0
// @example averageScore(hw1) == 84.3
// @example averageScore(hw2) == 89.85
//--------------------------------------------------------------------------
double averageScore(Homework * H)
{
    if (H == 0)
    {
        return 0.0;
    }
    else
    {
        return sumScore(H) / nScore(H);
    }
}

//--------------------------------------------------------------------------
// @description determine the sum of homework scores
// @param H a homework
// @return the sum of homework scores
// @contract sumScore : Homework -> double
// @example sumScore(empty) == 0
// @example sumScore(hw1) == 84.3
// @example sumScore(hw2) == 179.7
//--------------------------------------------------------------------------
double sumScore(Homework * H)
{
    if (H == 0)
    {
        return 0.0;
    }
    else
    {
        return H->data + sumScore(H->rest);
    }
}

//--------------------------------------------------------------------------
// @description determine the number of homework scores
// @param H a homework
// @return the sum of homework scores
// @contract nScore : Homework -> int
// @example nScore(empty) == 0
// @example nScore(hw1) == 1
// @example nScore(hw2) == 2
//--------------------------------------------------------------------------
int nScore(Homework * H)
{
    if (H == 0)
    {
        return 0;
    }
    else
    {
        return 1 + nScore(H->rest);
    }
}