C语言程序设计现代方法_第二版，CH12第十二章练习题（Exercises）

CH12_1

//(a):14 (b):34 (c):4 (d):true (e):false

CH12_2

//不合法原因：指针变量只支持三种运算，因此指针变量low和high不可相加运算；
//考虑到指针变量可以和整数进行运算，因此可修改为如下所示：
middle = low + (high - low)/2;	//合法

CH12_3

a = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};

CH12_4

#define STACK_SIZE 10

int contents[STACK_SIZE];
int* top_ptr = &contents[0];	//全局变量

void make_empty(void)
{
    top_ptr = &contents[0];
}

bool is_empty(void)
{
    return top_ptr == &contents[0];
}

bool is_full(void)
{
    return top_ptr == &contents[STACK_SIZE];
}

CH12_5

//(a)不合法，其余都为真

CH12_6

int sum_array(const int a[], int n)
{
    int sum = 0;
    const int *p;
    for (p = a; p < a + n; p++)
        sum += *p;
    return sum;
}

CH12_7

bool search(const int a[], int n, int key)
{
    for (int* p = a; p < a + n; p++) {
        if (key == *p) {
            return true;
        }
    }
    return false;
}

CH12_8

void store_zeros(int a[], int n)
{
    for (int* p = a; p < a + n; p++) {
        *p = 0;
    }
}

CH12_9

double inner_product(const double* a, const double* b, int n)
{
    double sum = 0;
    for (const double* a_ptr = a, *b_ptr = b; a_ptr < a + n && b_ptr < b + n; sum += *a_ptr++ * *b_ptr++) {
        ;
    }

    return sum;
}

CH12_10

int *find_middle(int a[], int n) {
    return a + (n / 2);
}

CH12_11

int *find_largest(int a[], int n)
{
    int *p, *largest;
    for (p = a, largest = a; p < a + n; p++) {
        if (*p > *largest)
            largest = p;
    }
    return largest;
}

CH12_12

void find_two_largest(const int* a, int n, int* largest, int* second_largest)
{
    const int* p;

    for (p = largest = second_largest = a; p < a + n; p++) {
        if (*p > * largest) {
            second_largest = largest;
            largest = p;
        }
        else if (*p > * second_largest) {
            second_largest = p;
        }
    }
}

CH12_13

#include <stdio.h>

#define N 5

int main(void)
{
    double ident[N][N] = { 0 };

    for (double* p = ident[0]; p < ident[N]; p += (N+1)) {
        *p = 1;	//注意ident范围，虽不存在ident[N]，但合法
    }
    
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            printf("%.0f ", ident[i][j]);
        }
        printf("\n");
    }

    return 0;
}

CH12_14

#include <stdio.h>
#include <stdbool.h>

bool search(const int a[], int n, int key);

int main(void)
{
    int temperatures[7][24] = {1,2,3};  //测试

    printf("%d", search(temperatures[0], 168, 4));

    return 0;
}

bool search(const int a[], int n, int key)
{
    for (int* p = a; p < a + n; p++) {
        if (key == *p) {
            return true;
        }
    }
    return false;
}

CH12_15

#include <stdio.h>

int main(void)
{
    int temperatures[7][24] = { 
    {1,2,3,4,5,6,7},
    {8,9,10,11,12,13,14},
    {15,16,17,18,19,20,21},
    };  //测试

    int i = 2;  //假设输出第二行数据

    for (int* p = temperatures[i]; p < temperatures[i] + 24; p++) {
        printf("%d ", *p);
    }

    return 0;
}

CH12_16

#include <stdio.h>

int* find_largest(int a[], int n);

int main(void)
{
    int temperatures[7][24] = { [2][15] = 31,[3][14] = 34,[6][7] = 30 };
    int* day_largest;
    int day;

    for (day = 0; day < 7; day++) {
        day_largest = find_largest(temperatures[day], 24);

        printf("Day %d largest: %d\n", day + 1, *day_largest);
    }

    return 0;
}

int* find_largest(int a[], int n)
{
    int* p, * largest;

    for (p = a, largest = a; p < a + n; p++) {
        if (*p > * largest)
            largest = p;
    }
    return largest;
}

CH12_17

int sum_two_dimensional_array(const int* a, int n)
{
    int sum = 0; 

    for (const int* p = a; p < a + n; p++) {
        sum += *p;
    }      
    return sum;
}

CH12_18

int evaluate_position(char* board, int n)
{
    int white_score = 0, black_score = 0;
    char* p;

    for (p = board; p < board + n; p++) {

        switch (*p) {
        case 'Q':   white_score += 9; 
            break;
        case 'R':   white_score += 5; 
            break;
        case 'B':
        case 'N':   white_score += 3; 
            break;
        case 'P':   white_score += 1; 
            break;
        case 'q':   black_score += 9; 
            break;
        case 'r':   black_score += 5; 
            break;
        case 'b':
        case 'n':   black_score += 3; 
            break;
        case 'p':   black_score += 1; 
            break;
        }
    }
    return black_score - white_score;


    return 0;
}