c++ | lwketh | day01

using namespace std;

template<class T>
void
_print(T arg) {
    cout << arg << " ";
}

template<class... Args>
void
log(Args... args) {
    int arr[] = { (_print(args), 0)... };
    cout << endl;
}

// 作业正式开始
//
// 例子 1
// 求数组的和
/*
在 C++ 中，函数必须标注返回值类型，变量、参数必须标注类型
sum 函数是一个返回 float 类型的函数
它的参数名是 array，类型是 vector<float> &
其中 vector<float> 表示类型是 “存储 float 元素的数组”
& 符号表示参数 array 是一个 “引用”

“引用” 是一个 C++ 中的新概念，它实际上是一个 C 语言中指针的语法糖
我们暂时不用关心这个，在后续的作业中会学到它
现在记住所有 vector 类型都使用 & 来修饰变量即可
 */
float
sum(vector<float> &array) {
    // 先设置一个变量 s 用来存数组的和
    float s = 0;
    // .size() 函数的返回值是 size_t
    // 所以这里的变量 i 也是 size_t（你可以当作 int）
    size_t i = 0;
    // array.size() 求得 vector 的大小
    while (i < array.size()) {
        float n = array[i];
        s = s + n;
        i = i + 1;
    }
    log("s", s);
    return s;
}

/*
按照《〖快编程〗的免费编程入门课》的标准
我们这里提供一个简易的测试方案（功能更强的测试方案在后续的作业中会给出）

ensure 函数第一个参数
如果为 true 则会输出 “测试成功”
如果为 false 则会输出 message
这样我们就可以知道是否测试成功，以及具体哪个测试失败了

对每一个函数，都应编写一个 test 函数，这样可以提高开发效率
*/
void
ensure(bool condition, const string &message) {
    if (condition) {
        log("测试成功");
    } else {
        log(message);
    }
}

void
testSum(void) {
    vector<float> v1 = {1, 2, 3, 4};
    float s1 = sum(v1);
    ensure(s1 == 10, "sum test error 1");
    //
    vector<float> v2 = {1, 2, 3, 4, 5, 6};
    float s2 = sum(v2);
    ensure(s2 == 21, "sum test error 2");
}

// 作业 1
// 参数是一个只包含数字的 array
// 求 array 的乘积
// 函数定义如下

// 提示：
//     通过遍历数组，然后累乘的方式计算数组的乘积，参考例子 1
//
// 分步提示：
//     1. 先设置一个变量 s 用来存数组的乘积，初始值为 1
//     2. 遍历数组，用变量 n 保存元素的值
//     3. 累乘每次的变量 n 到变量 s
//     4. 循环结束后，变量 s 里面存的是数组中所有元素的乘积
//     5. 返回变量 s（很重要，一定要 return s）

float
product(vector<float> &array) {
     // 先设置一个变量 s 用来存数组的和
    float s = 1;
    // .size() 函数的返回值是 size_t
    // 所以这里的变量 i 也是 size_t（你可以当作 int）
    size_t i = 0;
    // array.size() 求得 vector 的大小
    while (i < array.size())  {
        float n = array[i];
        s = s * n;
        i = i + 1;
    }
    log("product s", s);
    return s;
}

void 
test_product(void){
    vector<float> v1 = {1, 2, 3, 4};
    float s1 = product(v1);
    ensure(s1 == 24, "product test error 1");
    //
    vector<float> v2 = {1, 2, 3, 4, 5, 6};
    float s2 = product(v2);
    ensure(s2 == 720, "product test error 2");
}
// 作业 2
// 返回一个数字的绝对值
// 函数定义如下
//
// 参考入门课求绝对值的代码来实现
// 1. 如果 n < 0，就把 n 的值赋值成 -n
// 2. 返回 n 的值（很重要，一定要 return n）
float
abs1(float n) {
    // 先设置一个变量 s 用来存数组的和
    float s = n;
    // log("start s", s);
    if (n < 0) {
        s = -n;
    }
    // log("end s", s);
    return s;
}
void 
test_abs(void) {
    float v1 = -1;
    float s1 = abs1(v1);
    ensure(s1 == 1, "abs test error 1");
    //
    float v2 = 1;
    float s2 = abs1(v2);
    ensure(s2 == 1, "abs test error 2");
}

// 作业 3
// 参数是一个只包含数字的数组
// 求 数组 中所有数字的平均数
//
// 函数定义如下
// 求数组的平均数就是先求出数组中元素的总和，然后除以数组的长度（即元素的个数）
// 1. 使用例子 1 中的 sum 函数来计算数组中所有元素的总和
// 2. 使用 size 函数计算出数组中元素的个数
// 3. 使用数组中元素的总和除以数组中元素的个数，得到平均数
// 4. 返回平均数
float
average(vector<float> &array) {
    float s = sum(array);
    float length = array.size();
    float result = s / length;
    return result;
}
void 
test_average(void)
{
    vector<float> v1 = {3, 3, 3, 3};
    float s1 = average(v1);
    ensure(s1 == 3, "average test error 1");
    //
    vector<float> v2 = {3, 4, 5, 4};
    float s2 = average(v2);
    ensure(s2 == 4, "average test error 2");
    log("averagew 测试成功 大侄子");
}

// 作业 4
// 参数是一个只包含数字的 数组
// 求 数组 中最小的数字
//
// 先选数组中的第一个元素作为 s 的初始值
// 然后遍历数组，将每一个元素都与初始值比较
// 如果元素的值比初始值小，就把那个元素设置为 s 的值
// 最后返回 s 的值
// 1. 将数组中第一个元素的值赋值给 s 作为初始值
// 2. 遍历数组，用变量 n 保存元素的值
// 3. 比较 n 与 s 的值，如果 n < s，就把 n 的值赋值给 s
// 4. 循环结束后，变量 s 里面存的是数组中最小的数字
// 5. 返回变量 s（很重要，一定要 return s）
float
min(vector<float> &array) {
    // 先设置一个变量 s 用来存数组的和
    // float s = 0;
    float min_number = array[0];
    // .size() 函数的返回值是 size_t
    // 所以这里的变量 i 也是 size_t（你可以当作 int）
    size_t i = 0;
    // array.size() 求得 vector 的大小
    while (i < array.size())  {
        float n = array[i];
        if (min_number > n) {
            min_number = n;
        }
        i = i + 1;
    }
    return min_number;
}
void 
test_min(void) {
    vector<float> v1 = {3, 3, 3, 3};
    float s1 = min(v1);
    ensure(s1 == 3, "min test error 1");
    //
    vector<float> v2 = {3, 4, 5, 4};
    float s2 = min(v2);
    ensure(s2 == 3, "min test error 2");
     log("min 测试成功 大侄子");
}

// 作业 5
// 参数是一个数字 n
// 返回以下序列的结果
// 1 - 2 + 3 - 4 + 5 ... n

// 首先可以把序列看成是一个数组，这样就可以循环 n 次。
// 观察序列可以发现一个规律：奇数的时候是加，偶数的时候是减
//
// 1. 先设置一个变量 s 用来存序列的和，初始值为 0
// 2. 循环 n 次，从 1 开始，到 n + 1 结束，即包括 n 但是不包括 n + 1
// 3. 判断每次循环的值。如果是奇数，累加这个数到 s 上，如果是偶数，累减这个数到 s 上
// 4. 循环结束后，变量 s 里面存的是序列的和
// 5. 返回变量 s（很重要，一定要 return s）
bool 
isOdd(int number) {
    int n = number;
    bool r = n % 2 > 0;
    // log("number ", number, "r", r);
    return r;
}

int
sum1(int n) {
    // 先设置一个变量 s 用来存数组的和
    float s = 0;
    // .size() 函数的返回值是 size_t
    // 所以这里的变量 i 也是 size_t（你可以当作 int）
    size_t i = 0;
    // array.size() 求得 vector 的大小
    while (i < n)  {
        float n = i + 1;
        if (isOdd(n)) {
            s += n;
        } else {
            s -= n;
        }
        // log("i", i, "s", s);
        i = i + 1;
    }
    // log("sum1", s);
    return s;
}
void
test_sum1(void) {
    float v1 = 5;
    float s1 = sum1(v1);
    ensure(s1 == 3, "sum1 test error 1");
    log("davizi sum1 nb");
}

// 作业 6
// 参数是一个数字 n
// 返回以下序列的结果
// 1 + 2 - 3 + 4 - ... n
// 还是把序列看成是一个数组，不过从第二个元素（也就是 2 开始遍历）这样就可以循环 n - 1 次
//
// 1. 先设置一个变量 s 用来存序列的和，初始值为 1，这样就可以从 2 开始计算循环了
// 2. 循环 n - 1 次，从 2 开始，到 n 结束（包括 n）
// 3. 判断每次循环的值。
//    如果是第一个数字（这里是从 2 开始的），观察式子的规律，从 2 开始之后，当一个数字是奇数时，就是减去这个数（比如说 3 5 7 9...）。
//    当一个数字是偶数时，就是加上这个数（比如 2 4 6 8...）。
// 4. 循环结束后，变量 s 里面存的是序列的和
// 5. 返回变量 s（很重要，一定要 return s）
int
sum2(int n) {
    // 先设置一个变量 s 用来存数组的和
    float s = 0;
    // .size() 函数的返回值是 size_t
    // 所以这里的变量 i 也是 size_t（你可以当作 int）
    size_t i = 0;
    // array.size() 求得 vector 的大小
    while (i < n)  {
        float n = i + 1;
        if (isOdd(n) && n != 1) {
            s -= n;
        } else {
            s += n;
        }
        // log("i", i, "s", s);
        i = i + 1;
    }
    // log("sum1", s);
    return s;
}
void
test_sum2(void) {
    float v1 = 5;
    float s1 = sum2(v1);
    ensure(s1 == -1, "sum2 test error 1");
    log("davizi sum2 nb");
}

// 作业 7
//
// 实现 fac 函数
// 接受一个参数 n
// 返回 n 的阶乘, 1 * 2 * 3 * ... * n
// 计算从 1 到 n 的阶乘，重复了 n 次，所以可以用循环来处理
//
// 1. 先设置一个变量 s 用来存阶乘，初始值为 1
// 2. 用循环把 1 到 n 的数字相乘保存到 s 中
// 3. 循环结束后，变量 s 里面存的是从 1 到 n 的阶乘, 返回变量 s（很重要，一定要 return s）
int 
fac(int n) {
    if (n == 0) {
        return  1;
    } else {
        return n * fac(n - 1);
    }
}
void
test_fac(void) {
    float v1 = 4;
    float s1 = fac(v1);
    ensure(s1 == 24, "fac test error 1");
    log("davizi fac nb");
}

// 数组的长度
int
len(vector<float> &array) {
    int l =  array.size();
    return l;
}

void
test_len(void) {
    vector<float> v1 = {3, 3, 3, 3};
    float s1 = len(v1);
    ensure(s1 == 4, "len test error 1");
    log("len davizi nb");
}

//
void
test() {
    testSum();
    test_product();
    test_abs();
    test_average();
    test_min();
    test_sum1();
    test_sum2();
    test_fac();
}

// main 函数的参数是规定，复制粘贴即可
int
main(int argc, const char *argv[]) {
    log("xxxx");
    test();

    return 0;
}