C语言程序设计现代方法_第二版，CH10第十章编程题（Programming_Projects）

最新推荐文章于 2022-08-18 11:45:45 发布
最新推荐文章于 2022-08-18 11:45:45 发布
阅读量1k 收藏 14
点赞数 2
分类专栏： C语言程序设计现代方法_第二版 文章标签： c语言 程序设计
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44009070/article/details/104349366
版权

CH10_1

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

#define STACK_SIZE 100

char contents[STACK_SIZE];
int top = 0;
void make_empty(void);
int stack_overflow(void);
int stack_underflow(void);
bool is_empty(void);
bool is_full(void);
void push(char i);
char pop(void);

int main(void)
{
    char ch;
    make_empty();

    printf("Enter parentheses and/or braces: ");

    do {       
        ch = getchar();
        if (ch == '(' || ch == '{') {
            push(ch);
        }
        else if (ch == ')' && pop() != '(') {    
            printf("Parentheses/braces are not nested properly\n");
            return 0; 
        }
        else if (ch == '}' && pop() != '{') {
            printf("Parentheses/braces are not nested properly\n");
            return 0;
        }
    } while (ch != '\n');

    if (is_empty()) {
        printf("Parentheses/braces are nested properly\n");
    }
    else {
        printf("Parentheses/braces are not nested properly\n");
    }

    return 0;
}

int stack_overflow(void)
{
    printf("Stack overflow\n");
    exit(EXIT_FAILURE);
}

int stack_underflow(void)
{
    printf("Stack underflow\n");
    exit(EXIT_FAILURE);
}

void make_empty(void)
{
    top = 0;
}

bool is_empty(void)
{
    return top == 0;
}

bool is_full(void)
{
    return top == STACK_SIZE;
}

void push(char i)
{
    if (is_full()) {
        stack_overflow();
    }      
    else {
        contents[top++] = i;
    }
}

char pop(void)
{
    if (is_empty()) {
        stack_underflow();
    }       
    else {
        return contents[--top];
    }     
}

CH10_2

#include <stdbool.h>   /* C99 only */
#include <stdio.h>
#include <stdlib.h>

#define NUM_RANKS 13
#define NUM_SUITS 4
#define NUM_CARDS 5

/* external variables */
bool straight, flush, four, three;
int pairs;   /* can be 0, 1, or 2 */

/* prototypes */
void read_cards(int num_in_rank[], int num_in_suit[]);
void analyze_hand(int num_in_rank[], int num_in_suit[]);
void print_result(void);

/**********************************************************
 * 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];

    for (;;) {
        read_cards(num_in_rank, num_in_suit);
        analyze_hand(num_in_rank, num_in_suit);
        print_result();
    }
}

/**********************************************************
 * 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[])
{
    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(void)
{
    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");
}

CH10_3

#include <stdbool.h>   /* C99 only */
#include <stdio.h>
#include <stdlib.h>

#define NUM_CARDS 5
#define RANK 0
#define SUIT 1

/* external variables */
int hand[NUM_CARDS][2];

bool straight, flush, four, three;
int pairs;   /* can be 0, 1, or 2 */

/* prototypes */
void read_cards(void);
void analyze_hand(void);
void print_result(void);

/**********************************************************
 * main: Calls read_cards, analyze_hand, and print_result *
 *       repeatedly.                                      *
 **********************************************************/
int main(void)
{
    for (;;) {
        read_cards();
        analyze_hand();
        print_result();
    }
}

/**********************************************************
 * read_cards: Reads the cards into the external variable *
 *             hand; checks for bad cards and duplicate   *
 *             cards.                                     *
 **********************************************************/
void read_cards(void)
{
    char ch, rank_ch, suit_ch;
    int i, rank, suit;
    bool bad_card, duplicate_card;
    int cards_read = 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");
            continue;
        }

        duplicate_card = false;
        for (i = 0; i < cards_read; i++)
            if (hand[i][RANK] == rank && hand[i][SUIT] == suit) {
                printf("Duplicate card; ignored.\n");
                duplicate_card = true;
                break;
            }

        if (!duplicate_card) {
            hand[cards_read][RANK] = rank;
            hand[cards_read][SUIT] = suit;
            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(void)
{
    int rank, suit, card, pass, run;

    straight = true;
    flush = true;
    four = false;
    three = false;
    pairs = 0;

    /* sort cards by rank */
    for (pass = 1; pass < NUM_CARDS; pass++)
        for (card = 0; card < NUM_CARDS - pass; card++) {
            rank = hand[card][RANK];
            suit = hand[card][SUIT];
            if (hand[card + 1][RANK] < rank) {
                hand[card][RANK] = hand[card + 1][RANK];
                hand[card][SUIT] = hand[card + 1][SUIT];
                hand[card + 1][RANK] = rank;
                hand[card + 1][SUIT] = suit;
            }
        }

    /* check for flush */
    suit = hand[0][SUIT];
    for (card = 1; card < NUM_CARDS; card++)
        if (hand[card][SUIT] != suit)
            flush = false;

    /* check for straight */
    for (card = 0; card < NUM_CARDS - 1; card++)
        if (hand[card][RANK] + 1 != hand[card + 1][RANK])
            straight = false;

    /* check for 4-of-a-kind, 3-of-a-kind, and pairs by
       looking for "runs" of cards with identical ranks */
    card = 0;
    while (card < NUM_CARDS) {
        rank = hand[card][RANK];
        run = 0;
        do {
            run++;
            card++;
        } while (card < NUM_CARDS && hand[card][RANK] == rank);
        switch (run) {
        case 2: pairs++;      break;
        case 3: three = true; break;
        case 4: four = true;  break;
        }
    }
}

/**********************************************************
 * 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(void)
{
    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");
}

CH10_4

#include <stdbool.h>   /* C99 only */
#include <stdio.h>
#include <stdlib.h>

#define NUM_RANKS 13
#define NUM_SUITS 4
#define NUM_CARDS 5

/* external variables */
bool straight, flush, four, three, royal_flush;
int pairs;   /* can be 0, 1, or 2 */

/* prototypes */
void read_cards(int hand[5][2]);
void analyze_hand(int hand[5][2]);
void print_result(void);
bool check_for_duplicate_card(int rank, int suit, int hand[5][2], int cards_read);

/**********************************************************
 * main: Calls read_cards, analyze_hand, and print_result *
 *       repeatedly.                                      *
 **********************************************************/
int main(void)
{
    int hand[5][2];

    for (;;) {
        read_cards(hand);
        analyze_hand(hand);
        print_result();
    }
}

/**********************************************************
 * 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 hand[5][2])
{
    char ch, rank_ch, suit_ch;
    int rank, suit;
    bool bad_card;
    int cards_read = 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 (check_for_duplicate_card(rank, suit, hand, cards_read))
            printf("Duplicate card; ignored.\n");
        else {
            hand[cards_read][0] = rank;
            hand[cards_read][1] = suit;
            cards_read++;
        }
    }
}

bool check_for_duplicate_card(int rank, int suit, int hand[5][2], int cards_read)
{
    int i;
    for (i = 0; i < cards_read; i++)
        if (hand[i][0] == rank && hand[i][1] == suit)
            return true;

    return false;
}

/**********************************************************
 * 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 hand[5][2])
{
    int num_consec = 0;
    int card, rank, suit;
    int i, j, smallest;

    straight = false;
    flush = false;
    four = false;
    three = false;
    pairs = 0;
    royal_flush = false;

    /* Sort the cards by rank via selection sort*/
    for (i = 0; i < NUM_CARDS; i++) {
        smallest = i;

        for (j = i + 1; j < NUM_CARDS; j++) {
            if (hand[j][0] < hand[smallest][0])
                smallest = j;
        }

        rank = hand[i][0];
        suit = hand[i][1];
        hand[i][0] = hand[smallest][0];
        hand[i][1] = hand[smallest][1];
        hand[smallest][0] = rank;
        hand[smallest][1] = suit;
    }

    /* check for flush */
    for (card = 1; card < NUM_CARDS; card++) {
        if (hand[card][1] != hand[0][1])
            break;

        if (card == NUM_CARDS - 1)
            flush = true;
    }

    /* check for straight */
    for (card = 1; card < NUM_CARDS; card++) {
        if (hand[card][0] - hand[card - 1][0] != 1)
            break;

        if (card == NUM_CARDS - 1)
            straight = true;
    }

    /* Check for pairs, three of a kind, and four of a kind in the hand
     * by checking for matches to card i*/
    int matches;
    for (i = 0; i < NUM_CARDS; i++) {
        matches = 0;
        for (j = i + 1; j < NUM_CARDS; j++) {
            if (hand[j][0] == hand[i][0])
                matches++;
        }

        switch (matches) {
        case 1: pairs++;
            break;
        case 2: three = true;
            break;
        case 3: four = true;
            break;
        }
    }

    /* Checks for a royal flush
     * first card must be rank 8 (number 10) for royal flush to be a possibility */
    if (hand[0][0] == 8 && straight && flush)
        royal_flush = true;

}

/**********************************************************
 * 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(void)
{
    if (royal_flush)       printf("Royal flush");
    else 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");
}

CH10_5

#include <stdbool.h>   /* C99 only */
#include <stdio.h>
#include <stdlib.h>

#define NUM_RANKS 13
#define NUM_SUITS 4
#define NUM_CARDS 5

/* external variables */
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 */

/* prototypes */
void read_cards(void);
void analyze_hand(void);
void print_result(void);

/**********************************************************
 * main: Calls read_cards, analyze_hand, and print_result *
 *       repeatedly.                                      *
 **********************************************************/
int main(void)
{
    for (;;) {
        read_cards();
        analyze_hand();
        print_result();
    }
}

/**********************************************************
 * 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(void)
{
    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(void)
{
    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 ace-low straight */
    if (num_consec == NUM_CARDS - 1 &&
        num_in_rank[0] > 0 && num_in_rank[NUM_RANKS - 1] > 0) {
        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(void)
{
    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");
}

CH10_6

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

#define STACK_SIZE 100

int contents[STACK_SIZE];
int top = 0;
void make_empty(void);
int stack_overflow(void);
int stack_underflow(void);
bool is_empty(void);
bool is_full(void);
void push(int i);
int pop(void);

int main(void)
{
    char ch;
    int m, n;
    make_empty();

    while (1) {

        printf("Enter an RPN expression: ");

        while ((ch = getchar()) != '=') {

            switch (ch) {
            case '0': push(0); break;
            case '1': push(1); break;
            case '2': push(2); break;
            case '3': push(3); break;
            case '4': push(4); break;
            case '5': push(5); break;
            case '6': push(6); break;
            case '7': push(7); break;
            case '8': push(8); break;
            case '9': push(9); break;
            //引入变量m，n；可以调节出栈元素运算顺序；若直接 push(pop() + pop());
            //对于减法和除法会产生运算错误
            case '+': m = pop(); n = pop(); push(n + m); break;
            case '-': m = pop(); n = pop(); push(n - m); break;
            case '*': m = pop(); n = pop(); push(n * m); break;
            case '/': m = pop(); n = pop(); push(n / m); break;

            case ' ':; break;
            default: printf("END\n"); return 0; break;
            }

        }

        printf("%d\n\n", pop());
        getchar();  //扫走输入一次的回车
    }

    return 0;
}

int stack_overflow(void)
{
    printf("Stack overflow\n");
    exit(EXIT_FAILURE);
}

int stack_underflow(void)
{
    printf("Stack underflow\n");
    exit(EXIT_FAILURE);
}

void make_empty(void)
{
    top = 0;
}

bool is_empty(void)
{
    return top == 0;
}

bool is_full(void)
{
    return top == STACK_SIZE;
}

void push(int i)
{
    if (is_full()) {
        stack_overflow();
    }
    else {
        contents[top++] = i;
    }
}

int pop(void)
{
    if (is_empty()) {
        stack_underflow();
    }
    else {
        return contents[--top];
    }
}

CH10_7

#include <stdio.h>

#define MAX_DIGITS 10

char digits[3][4 * MAX_DIGITS];
const int segments[10][7] = {
                  {1, 1, 1, 1, 1, 1, 0}, /* 0 */
                  {0, 1, 1, 0, 0, 0, 0}, /* 1 */
                  {1, 1, 0, 1, 1, 0, 1}, /* 2 */
                  {1, 1, 1, 1, 0, 0, 1}, /* 3 */
                  {0, 1, 1, 0, 0, 1, 1}, /* 4 */
                  {1, 0, 1, 1, 0, 1, 1}, /* 5 */
                  {1, 0, 1, 1, 1, 1, 1}, /* 6 */
                  {1, 1, 1, 0, 0, 0, 0}, /* 7 */
                  {1, 1, 1, 1, 1, 1, 1}, /* 8 */
                  {1, 1, 1, 1, 0, 1, 1},  /* 9 */
};


void clear_digits_array(void);
void process_digit(int digit, int position);
void print_digits_array(void);

int main(void)
{
    char ch;
    int n = 0;

    clear_digits_array();

    printf("Enter a number: ");

    while ((ch = getchar()) != '\n' && n<10) {
        if (ch >= '0' && ch <= '9') {
            process_digit(ch-'0', n);
            n++;
        }      
    }

    print_digits_array();

    return 0;
}

void clear_digits_array(void)
{
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4 * MAX_DIGITS; j++) {
            digits[i][j] = ' ';
        }
    }
}

void process_digit(int digit, int position)
{

    for (int i = 0; i < 7; i++) {
        if (segments[digit][i] == 1) {
            switch (i) {
            case 0: digits[0][1 + 4 * position] = (i % 3 == 0 ? '_' : '|'); break;
            case 1: digits[1][2 + 4 * position] = (i % 3 == 0 ? '_' : '|'); break;
            case 2: digits[2][2 + 4 * position] = (i % 3 == 0 ? '_' : '|'); break;
            case 3: digits[2][1 + 4 * position] = (i % 3 == 0 ? '_' : '|'); break;
            case 4: digits[2][0 + 4 * position] = (i % 3 == 0 ? '_' : '|'); break;
            case 5: digits[1][0 + 4 * position] = (i % 3 == 0 ? '_' : '|'); break;
            case 6: digits[1][1 + 4 * position] = (i % 3 == 0 ? '_' : '|'); break;
            }  
        }
    }

}

void print_digits_array(void)
{
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4 * MAX_DIGITS; j++) {
            printf("%c", digits[i][j]);
        }
        printf("\n");
    }
}
lodumani_
关注
  • 2
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言程序设计（2020）编程题答案——第10章 字符串
weixin_46472915的博客
11-29 631
10.19 请编写函数mygets和myputs，其功能分别与gets和puts相同，函数中用getchar和putchar读入和输出字符。 #include <stdio.h> void mygets(char *a)//指针 { while((*a++=getchar())!='\n'); *a='\0'; } void myputs(char *a) { while(*a)putchar(*a++); putchar('\n');//puts会自动输出一个换行符 } main(
C语言程序设计现代方法第二版 第十章答案（下）
qq_29445129的博客
04-01 1182
5： /********************************************************* * From C PROGRAMMING: A MODERN APPROACH, Second Edition * * By K. N. King * * Copyright (c) 200...
C语言程序设计-现代方法 第二版 第10.5 小节代码 给一手牌分类
hughq的博客
12-14 250
第10.5 小节代码 给一手牌分类 //This is a comment //Author:King //Time:2020/12/7 //Reference:C Programming:A Modern Approach,Second Edition /*************************************************************** 10.5 小节代码 给一手牌分类 ********************************************
c语言程序设计第十次测试,《C语言程序设计》第10章在线测试..doc
weixin_42336958的博客
05-18 240
《C语言程序设计》第10章在线测试.《C语言程序设计》第10章在线测试剩余时间：58:38窗体顶端?答题须知：1、本卷满分20分。?????????? 2、答完题后，请一定要单击下面的“交卷”按钮交卷，否则无法记录本试卷的成绩。?????????? 3、在交卷之前，不要刷新本网页，否则你的答题结果将会被清空。第一题、单项选择题(每题1分，5道题共5分)?1、对于char p[]＝"ABC\0ABC...
数据结构04
unhere
04-21 914
0401 实现整型数顺序表的赋值、打印、取值和查找操作 输入要求： 见代码注释 输出要求： 见代码注释 数据示例1： 输入： 5 1 3 5 7 9 0 1 1 1 5 1 0 1 6 2 5 2 2 输出： 1 3 5 7 9 1 9 Error Error 3 Error #include<stdio.h> #include<stdlib.h> // 函数结果状态码 typedef int Status; #define OK 1 #define ERROR 0 #d
C语言常用算法程序集.zip_C++_C语言常用算法_C语言常用算法程序集_常用算法程序_算法 书
最新发布
09-19
《C语言常用算法程序集》是一本面向C语言学习者的实践性教材，旨在帮助读者深入理解和掌握编程中的常见算法。该资源以C++为补充，提供了C语言实现的经典算法示例，适合对C语言有一定基础并希望提升算法能力的读者。...
JSP程序设计第2版代码.zip
06-01
**JSP程序设计第二版** 是一门深入理解JavaServer Pages（JSP）技术的重要课程，本书的代码资源包含了从基础到高级的各种示例，旨在帮助读者逐步掌握JSP的编程技巧。通过解压"JSP程序设计第2版代码.zip"，我们可以...
例说8051单片_ch10-C语言版-刘义和
12-10
《例说8051单片机_C语言版》由刘义和编著，是一部深入浅出地讲解8051单片机及其C语言编程技术的书籍。第十章聚焦于步进电机的控制，这一章节是理解如何利用8051单片机对步进电机进行精确控制的关键部分。下面将详细...
C 程序设计教学课件：Ch10 Search & Sort.pdf
05-07
在C程序设计中，搜索和排序是至关重要的概念，它们被广泛应用于各种数据处理和算法实现。本教学课件Ch10重点介绍了两种搜索方法——线性搜索和二分搜索，以及一个常见的排序算法——冒泡排序。 首先，线性搜索是最...
C语言实现栈(基于数组)
热门推荐
Jum
11-26 2万+
栈是一种操作受限的数据结构，只允许从一段操作，而且先进后出(FILO  first in last out)这里将栈的操作封装在C语言的头文件里 实现栈的代码如下   #include&lt;stdbool.h&gt; #define maxsize 10 typedef int datatype; //Sequence Stack 实现顺序栈，使用数组来实现 struct stack ...
嵌入式linux学习笔记-- 获取linux的网卡的信息
jeason的博客
06-27 525
最近整理了一下 关于linux 使用C/C++ 获得 网卡信息的方法 #include <sys/ioctl.h> #include <net/if.h> #include <unistd.h> #include <netinet/in.h> #include <string.h> #include <stdio.h> #include <stdbool.h> typedef struct tag_network{
顺序栈示例（c）
刘念卿的博客
10-01 116
#include <stdio.h> #include <stdbool.h> #include <stdlib.h> // 栈 尽在表尾端（栈顶）进行插入和删除 // 后进先出 // 顺序栈 #define MAXSIZE 10 //数组最大容量 //顺序栈就是功能不完整的数组，栈顶相当于数组的最后一个 typedef struct STACK { int stacksize; //栈最大可用容量 int count;
浙江大学MOOC数据结构-陈越、何钦铭 编程练习题（第七讲）
qq_39309050的博客
08-06 1137
浙江大学MOOC数据结构-陈越、何钦铭 编程练习题（第七讲） 编程说明 编程环境：平台运行 编程语言：C 第一题代码 #include <stdio.h> #include <stdlib.h> #define MaxVertexNum 100 /* 最大顶点数设为100 */ #define INFINITY 65535 /* ∞设为双字节无符号整数的最大值65535*/ typedef int Vertex; /* 用顶点下标表示顶点,为整型 */ typede
C语言程序设计现代方法第二版，第七章课后编程习题全部答案
编程初学者学习笔记
06-10 2万+
自己练习时手写，难免会有些疏忽遗漏等各种各样问题，错误之处还请指出 但这些代码确实已通过编译，实现了书上的输出结果，还希望能给抱有期待之人作为个小参考 7.1 这个直接粘上原答案吧！ 7.2 #include &lt;stdio.h&gt; int main (void) { int i, n; printf ("This program prints a tabl...
C语言程序设计现代方法（第二版）十二章编程题答案
Vasion_snow的博客
08-17 5852
作为一名C语言初学者，以下答案为随手练习笔记，均已通过编译器实现书上功能，如有错误之处欢迎指出。 1、 （a) # include &lt;cstdio&gt; # include &lt;iostream&gt; # define N 30 void reverse(char [], int); int main(void) { int sign = N; c...
数据结构 栈和队列部分代码c
@@老胡的博客
08-18 203
栈在括号匹配中的应用其实不仅仅是局限在括号匹配，对于常遇到的检验对称性的数据，都可以使用类似的思路去实现，比如检验回文序列等，在不同的应用中会有不同的表达，但是总体都是一个思路。，这个表示top指向下一个可以存储数据的位置，如果初始条件是这种，那么对于push和pop的实现过程（先改变top还是先存取数据）和原本的实现刚好相反。使用不带头结点的单链表来实现链式栈，对应的push就是头插法建立单链表，pop操作就是逐个删除头结点，和单链表的实现没有区别。，总之无论是什么方案，至少都需要花费一定的空间的代价。.
栈的c代码实现
linxizi0622的博客
06-23 447
c比较接近操作系统底层，也比较好理解，所以就用c语言实现了 首先定义一个头文件，关于栈的定义，比如压栈，弹栈，清空栈邓基本操作 #include #include   #define maxsize 10 struct stack { int data[maxsize]; int top; }; typedef struct stack Stack; void
C primer plus 14章课后题--巨人航空公司问题
嵌入式与Linux那些事的博客
12-21 836
#include <stdio.h> #include <stdlib.h> #include <stdbool.h> #define ture 1 #define false 0 #define SEATCOUNT 12 #define FLIGHTCOUNT 12 #define FNAME_LEN 50 #define LNAME_LEN 50 /*...
"Ch10 Search: C程序设计教学
The topic of search in C programming is crucial for understanding how to efficiently locate information within a program. In this chapter of the C programming design curriculum, students are ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值