【C语言】学习笔记第11章指针编程题

古城微笑少年丶 2024-03-22 10:46 12阅读 0赞

### 【C语言】学习笔记 ###

#### 文章目录 ####

*   *  【C语言】学习笔记
     *   *  第11章 指针
         *   *  编程题

#### 第11章 指针 ####

![在这里插入图片描述][0178fd20b6c04d3c92e9164a209e9079.png_pic_center]

指针是 C 语言最重要——也是最常被误解——的特性之一。

##### 编程题 #####

【1】修改第 2 章的编程题 7，使其包含下列函数：

void pay_amount(int dollars, int *twenties, int *tens, int *fives, int *ones);

函数需要确定：为支付参数 dollars 表示的付款金额，所需 20 美元、10 美元、5 美元和 1 美元钞票 的最小数目。twenties 参数所指向的变量存储所需 20 美元钞票的数目，tens、fives 和 ones 参数 类似。

#include <stdio.h>
    
    void pay_amount(int dollars, int* twenties, int* tens, int* fives, int* ones);
    
    int main(void) {
        
    
        int amount;
    
        printf("Enter a dollar amount: ");
        scanf("%d", &amount);
    
        int twenty_note, ten_note, five_note, one_note;
    
        pay_amount(amount, &twenty_note, &ten_note, &five_note, &one_note);
    
        printf("$20 bills: %d\n", twenty_note);
        printf("$10 bills: %d\n", ten_note);
        printf("$5 bills: %d\n", five_note);
        printf("$1 bills: %d\n", one_note);
    
        return 0;
    }
    
    void pay_amount(int dollars, int* twenties, int* tens, int* fives, int* ones) {
        
    
        *twenties = dollars / 20;
        *tens = (dollars - *twenties * 20) / 10;
        *fives = (dollars - *twenties * 20 - *tens * 10) / 5;
        *ones = (dollars - *twenties * 20 - *tens * 10) % 5;
    }

![在这里插入图片描述][63d8ee0c6703432e86ded3c06bd8f1ad.png_pic_center]

【2】修改第 5 章的编程题 8，使其包含下列函数：

void find_closest_flight(int desired_time, int *departure_time, int *arrival_time);

函数需查出起飞时间与 desired\_time（用从午夜开始的分钟数表示）最接近的航班。该航班的起飞 时间和抵达时间（也都用从午夜开始的分钟数表示）将分别存储在 departure\_time 和 arrival\_time 所指向的变量中。

#include<stdio.h>
    
    void find_closest_flight(int desired_time, int* departure_time, int* arrival_time);
    
    int main(void) {
        
    
        int departure, arrive;
        int hour, minute;
        int input_minutes;
    
        printf("Enter a 24-hour time: ");
        scanf("%d:%d", &hour, &minute);
    
        input_minutes = hour * 60 + minute;
    
        find_closest_flight(input_minutes, &departure, &arrive);
        printf("%d", departure);
    
        return 0;
    }
    
    void find_closest_flight(int desired_time, int* departure_time, int* arrival_time) {
        
    
        if (desired_time < (615) / 2) {
        
            *departure_time = 21 * 60 + 45;
            *arrival_time = 24 * 60 - 2;
        }
        else if (desired_time < (8 * 60 + 9 * 60 + 43) / 2) {
        
            *departure_time = 8 * 60;
            *arrival_time = 10 * 60 + 16;
        }
        else if (desired_time < (9 * 60 + 43 + 11 * 60 + 19) / 2) {
        
            *departure_time = 9 * 60 + 43;
            *arrival_time = 11 * 60 + 52;
        }
        else if (desired_time < (11 * 60 + 19 + 12 * 60 + 47) / 2) {
        
            *departure_time = 11 * 60 + 19;
            *arrival_time = 13 * 60 + 31;
        }
        else if (desired_time < (12 * 60 + 47 + 14 * 60) / 2) {
        
            *departure_time = 12 * 60 + 47;
            *arrival_time = 15 * 60;
        }
        else if (desired_time < (14 * 60 + 15 * 60 + 45) / 2) {
        
            *departure_time = 14 * 60;
            *arrival_time = 16 * 60 + 8;
        }
        else if (desired_time < (15 * 60 + 45 + 19 * 60) / 2) {
        
            *departure_time = 15 * 60 + 45;
            *arrival_time = 17 * 60 + 55;
        }
        else if (desired_time < (15 * 60 + 21 * 60 + 45) / 2) {
        
            *departure_time = 19 * 60;
            *arrival_time = 21 * 60 + 20;
        }
        else {
        
            *departure_time = 21 * 60 + 45;
            *arrival_time = 24 * 60 - 2;
        }
    
    }

![在这里插入图片描述][779963d479334c2ba3ca86e9a20604ae.png_pic_center]

【3】修改第 6 章的编程题 3，使其包含下列函数：

void reduce(int numerator, int denominator, int *reduced_numerator, int *reduced_denominator);

numerator 和 denominator 分别是分数的分子和分母。reduced\_numerator 和 reduced\_denominator 是指向变量的指针，相应变量中分别存储把分数化为最简形式后的分子和分母。

#include<stdio.h>
    
    void reduce(int numerator, int denominator, int* reduced_numerator, int* reduced_denominator);
    
    int main(void) {
        
    
    
        int top, bottom;
    
        printf("Enter a fraction: ");
        scanf("%d/%d", &top, &bottom);
    
        reduce(top, bottom, &top, &bottom);
    
        printf("In lowest terms: %d/%d", top, bottom);
        return 0;
    }
    
    void reduce(int numerator, int denominator, int* reduced_numerator, int* reduced_denominator) {
        
    
        int remainder;
    
        while (denominator != 0) {
        
            remainder = numerator % denominator;
            numerator = denominator;
            denominator = remainder;
        }
    
        *reduced_numerator /= numerator;
        *reduced_denominator /= numerator;
    }

![在这里插入图片描述][715f6bf2a99046d594c2964621a3e156.png_pic_center]

【4】修改 10.5 节的 poker.c 程序，把所有的外部变量移到 main 函数中，并修改各个函数，使它们通过参 数进行通信。analyze\_hand函数需要修改变量 straight、flush、four、three和 pairs，所以它需要以指向这些变量的指针作为参数。

/* Classifies a poker hand */
    
    #include <stdbool.h> 
    #include <stdio.h> 
    #include <stdlib.h> 
    
    #define NUM_RANKS 13 
    #define NUM_SUITS 4 
    #define NUM_CARDS 5 
    
    void read_cards(int num_in_rank[], int num_in_suit[]);
    void analyze_hand(int num_in_rank[], int num_in_suit[], bool* straight, bool* flush, bool* four, bool* three, int* pairs);
    void print_result(bool straight, bool flush, bool four, bool three, int pairs);
    
    
    /************************************************************
     * main: Calls read_cards, analyze_hand, and print_result *
     * repeatedly. *
     ************************************************************/
    int main(void)
    {
        
    
        int num_in_rank[NUM_RANKS];
        int num_in_suit[NUM_SUITS];
        bool straight, flush, four, three;
        int pairs; /* can be 0, 1, or 2 */
    
        read_cards(num_in_rank, num_in_suit);
        analyze_hand(num_in_rank, num_in_suit, &straight, &flush, &four, &three, &pairs);
    
        print_result(straight, flush, four, three, pairs);
    
        return 0;
    }
    
    /************************************************************
     * read_cards: Reads the cards into the external *
     * variables num_in_rank and num_in_suit; *
     * checks for bad cards and duplicate cards. *
     ************************************************************/
    void read_cards(int num_in_rank[], int num_in_suit[])
    {
        
        bool card_exists[NUM_RANKS][NUM_SUITS];
        char ch, rank_ch, suit_ch;
        int rank, suit;
        bool bad_card;
        int cards_read = 0;
    
        for (rank = 0; rank < NUM_RANKS; rank++) {
        
            num_in_rank[rank] = 0;
            for (suit = 0; suit < NUM_SUITS; suit++)
                card_exists[rank][suit] = false;
        }
        for (suit = 0; suit < NUM_SUITS; suit++)
            num_in_suit[suit] = 0;
    
        while (cards_read < NUM_CARDS) {
        
            bad_card = false;
            printf("Enter a card: ");
            rank_ch = getchar();
            switch (rank_ch) {
        
            case '0': exit(EXIT_SUCCESS);
            case '2': rank = 0; break;
            case '3': rank = 1; break;
            case '4': rank = 2; break;
            case '5': rank = 3; break;
            case '6': rank = 4; break;
            case '7': rank = 5; break;
            case '8': rank = 6; break;
            case '9': rank = 7; break;
            case 't': case 'T': rank = 8; break;
            case 'j': case 'J': rank = 9; break;
            case 'q': case 'Q': rank = 10; break;
            case 'k': case 'K': rank = 11; break;
            case 'a': case 'A': rank = 12; break;
            default: bad_card = true;
            }
            suit_ch = getchar();
            switch (suit_ch) {
        
            case 'c': case 'C': suit = 0; break;
            case 'd': case 'D': suit = 1; break;
            case 'h': case 'H': suit = 2; break;
            case 's': case 'S': suit = 3; break;
            default: bad_card = true;
            }
            while ((ch = getchar()) != '\n')
                if (ch != ' ') bad_card = true;
            if (bad_card)
                printf("Bad card; ignored.\n");
            else if (card_exists[rank][suit])printf("Duplicate card; ignored.\n");
            else {
        
                num_in_rank[rank]++;
                num_in_suit[suit]++;
                card_exists[rank][suit] = true;
                cards_read++;
            }
        }
    }
    
    /************************************************************
     * analyze_hand: Determines whether the hand contains a *
     * straight, a flush, four-of-a-kind, *
     * and/or three-of-a-kind; determines the *
     * number of pairs; stores the results into *
     * the external variables straight, flush, *
     * four, three, and pairs. *
     ************************************************************/
    void analyze_hand(int num_in_rank[], int num_in_suit[], bool* straight, bool* flush, bool* four, bool* three, int* pairs)
    {
        
        int num_consec = 0;
        int rank, suit;
    
        *straight = false;
        *flush = false;
        *four = false;
        *three = false;
        *pairs = 0;
        /* check for flush */
        for (suit = 0; suit < NUM_SUITS; suit++)
            if (num_in_suit[suit] == NUM_CARDS)
                *flush = true;
        /* check for straight */
        rank = 0;
        while (num_in_rank[rank] == 0) rank++;
        for (; rank < NUM_RANKS && num_in_rank[rank] > 0; rank++)
            num_consec++;
        if (num_consec == NUM_CARDS) {
        
            *straight = true;
            return;
        }
        /* check for 4-of-a-kind, 3-of-a-kind, and pairs */
        for (rank = 0; rank < NUM_RANKS; rank++) {
        
            if (num_in_rank[rank] == 4) *four = true;
            if (num_in_rank[rank] == 3) *three = true;
            if (num_in_rank[rank] == 2) *pairs++;
        }
    }
    
    /************************************************************
     * print_result: prints the classification of the hand, *
     * based on the values of the external *
     * variables straight, flush, four, three, *
     * and pairs. *
     ************************************************************/
    void print_result(bool straight, bool flush, bool four, bool three, int pairs)
    {
        
        if (straight && flush) printf("Straight flush");
        else if (four) printf("Four of a kind");
        else if (three && pairs == 1) printf("Full house");
        else if (flush) printf("Flush");
        else if (straight) printf("Straight");
        else if (three) printf("Three of a kind");
        else if (pairs == 2) printf("Two pairs");
        else if (pairs == 1) printf("Pair");
        else printf("High card");
        printf("\n\n");
    }

![在这里插入图片描述][b9bd5b896f714a54b1bbe637d0f18127.png_pic_center]

[0178fd20b6c04d3c92e9164a209e9079.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/4b1c414824d7452485a4e305873db947.png
[63d8ee0c6703432e86ded3c06bd8f1ad.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/981f5bce633d445b937d2af2f5069029.png
[779963d479334c2ba3ca86e9a20604ae.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/c0608a5747cc42bda92b162089e81797.png
[715f6bf2a99046d594c2964621a3e156.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/c4f01842e5214befb34b2207d3383446.png
[b9bd5b896f714a54b1bbe637d0f18127.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/251cec3cd24d4da1bd4ca478704a16aa.png