鸡蛋队列(数组,函数)

时间限制: 1 Sec 内存限制: 128 MB

题目描述

将两根筷子平行的放在一起,就构成了一个队列。将带有编号的鸡蛋放到两根筷子之间叫做入队(push),将筷子之间的鸡蛋拿出来叫做出队(pop)。但这两种方式有特殊的定义,对于入队,只能将鸡蛋从队列的尾部向里放入;对于出队,只能将鸡蛋从队列的头部向外将鸡蛋拿出来。

输入

第一行输入一个数T,表示有T组数据 第二行输入一个数N,表示有N(N<=10)种操作 接下来N行,每行一种操作,push表示将编号为x的鸡蛋放入队列中,pop表示拿走队列头部的一个鸡蛋。 数据输入保证合法,队列中没有鸡蛋时不会有出队操作!

输出

输出N种操作完之后,队列中蛋蛋的编号,如果没蛋了,就输出”no eggs!”(不包括引号)每组输出占一行。

样例输入

2
3
push 1 
push 2
push 3
2
push 1
pop

样例输出

1 2 3
no eggs!

提示

数组模拟队列,用下标记录对头、队尾位置。

解决方案

#include <stdio.h>

struct Queue {
    int data[32];
    int head, tail;
};

void push(struct Queue *queue, int data);
void pop(struct Queue *queue);
void show(struct Queue *queue);

int main() {
    int ctrl;
    scanf("%d", &ctrl);

    while (ctrl--) {
        struct Queue queue = {};
        int time;
        scanf("%d", &time);
        while (time--) {
            char operation[8];
            scanf("%s", operation);
            if (operation[1] == 'u') {
                int data;
                scanf("%d", &data);
                push(&queue, data);
            } else {
                pop(&queue);
            }
        }
        show(&queue);
    }

    return 0;
}

void push(struct Queue *queue, int data) {
    queue->data[queue->tail] = data;
    queue->tail += 1;
}

void pop(struct Queue *queue) {
    queue->head += 1;
}

void show(struct Queue *queue) {
    if (queue->head == queue->tail) {
        printf("no eggs!\n");
    } else {
        printf("%d", queue->data[queue->head]);
        for (int i = queue->head + 1; i != queue->tail; ++i) {
            printf(" %d", queue->data[i]);
        }
        printf("\n");
    }
}

分类排序(函数)

时间限制: 1 Sec 内存限制: 128 MB

题目描述

从键盘输入10个整数(10个整数均不相同), 然后再从键盘中输入一个整数a,
如果该整数a为奇数, 且与这10个整数中的任一个数相同,则删掉与a相同的 这个数,并将剩下的9个数按升序排序输出;
若a为偶数, 且与这10个数都不同,则加入a,并将这11个数降序排 序输出;
否则,则将这10个数奇数在前,偶数在后, 降序排列输出。
例如,10个数分别为6,89,34,12, 0,-8,78,15,9,3.
若a为9,则输出为:-8,0,3, 6,12,15,34,78,89.
若a为2,则输出为:89,78, 34,15,12,9,6,3,2,0,-8.
若a为7或者12,则 输出为:89,15,9,3,78,34,12,6,0,-8.
要求:使用函数解决本题,至少编写以下几个函数,
1、升序排序函数void sort(int a[], int n);
2、查找函数int find(int a[],int n,int value)—-在大小为n的a数组中查找值为value的元素,找到就返回元素的下标,找不到,就返回-1;
3、输出函数display(int a[], int n)—逐个输出数组a的元素;
4、反转数组函数void reverse(int a[], int n)—-将数组逆序。

输入

测试数据的组数n
第一组测试数据的10个整数
第一组的整数a
第二组测试数据的10个整数
第二组的整数a
……
第n组测试数据的10个整数
第n组的整数a

输出

第一组数据排序输出
第二组数据排序输出
…….
第n组数据排序输出

样例输入

3
6 89 34 12 0 -8 78 15 9 3
9
6 89 34 12 0 -8 78 15 9 3
2
6 89 34 12 0 -8 78 15 9 3
7

样例输出

-8 0 3 6 12 15 34 78 89
89 78 34 15 12 9 6 3 2 0 -8
89 15 9 3 78 34 12 6 0 -8

提示

解决方案

#include <stdio.h>

#define FAILED_FIND_IN_ARRAY -1

struct Array {
    int data[16];
    int size;
};

void scanToArray(struct Array *array);
int findInArray(struct Array *array, int data);
void sortArray(struct Array *array);
void reverseArray(struct Array *array);
void sortArrayInOddAndEven(struct Array *array);
void printArray(struct Array *array);

int main() {
    int ctrl;
    scanf("%d", &ctrl);

    while (ctrl--) {
        struct Array array = {};
        scanToArray(&array);
        int number;
        scanf("%d", &number);
        if (number % 2 != 0 && findInArray(&array, number) != FAILED_FIND_IN_ARRAY) {
            array.size -= 1;
            for (int i = findInArray(&array, number); i < array.size; ++i) {
                array.data[i] = array.data[i + 1];
            }
            sortArray(&array);
        } else if (number % 2 == 0 && findInArray(&array, number) == FAILED_FIND_IN_ARRAY) {
            array.data[array.size] = number;
            array.size += 1;
            sortArray(&array);
            reverseArray(&array);
        } else {
            sortArrayInOddAndEven(&array);
        }
        printArray(&array);
    }

    return 0;
}

void scanToArray(struct Array *array) {
    array->size = 10;
    for (int i = 0; i < array->size; ++i) {
        scanf("%d", &array->data[i]);
    }
}

int findInArray(struct Array *array, int data) {
    for (int i = 0; i < array->size; ++i) {
        if (array->data[i] == data) {
            return i;
        }
    }
    return -1;
}

void sortArray(struct Array *array) {
    for (int i1 = 0; i1 < array->size - 1; ++i1) {
        for (int i2 = 0; i2 < array->size - 1 - i1; ++i2) {
            if (array->data[i2] > array->data[i2 + 1]) {
                int data = array->data[i2];
                array->data[i2] = array->data[i2 + 1];
                array->data[i2 + 1] = data;
            }
        }
    }
}

void reverseArray(struct Array *array) {
    for (int i = 0; i < array->size / 2; ++i) {
        int data = array->data[i];
        array->data[i] = array->data[array->size - 1 - i];
        array->data[array->size - 1 - i] = data;
    }
}

void sortArrayInOddAndEven(struct Array *array) {
    struct Array odd = {}, even = {};
    for (int i = 0; i < array->size; ++i) {
        if (array->data[i] % 2 == 0) {
            even.data[even.size] = array->data[i];
            even.size += 1;
        } else {
            odd.data[odd.size] = array->data[i];
            odd.size += 1;
        }
    }
    sortArray(&odd);
    reverseArray(&odd);
    sortArray(&even);
    reverseArray(&even);
    for (int i = 0; i < odd.size; ++i) {
        array->data[i] = odd.data[i];
    }
    for (int i = 0; i < even.size; ++i) {
        array->data[i + odd.size] = even.data[i];
    }
}

void printArray(struct Array *array) {
    printf("%d", array->data[0]);
    for (int i = 1; i < array->size; ++i) {
        printf(" %d", array->data[i]);
    }
    printf("\n");
}

计算字符串的长度

时间限制: 1 Sec 内存限制: 128 MB

题目描述

计算字符串S的长度,功能与strlen函数相同,但不能调用库函数strlen,否则不给分。输入的字符串不包含空格。

输入

输入测试组数t
对于每组测试,输入字符串S(长度<=30)

输出

对于每组测试,输出S的长度

样例输入

1
hehe

样例输出

4

提示

解决方案

#include <iostream>

int main() {
    int ctrl;
    std::cin >> ctrl;
    while (ctrl--) {
        char str[64] = {};
        std::cin >> str;
        int length = 0;
        while (str[++length] != '\0');
        std::cout << length << std::endl;
    }

    return 0;
}

单词统计

时间限制: 1 Sec 内存限制: 128 MB

题目描述

编写一个程序,根据单词的出现频率降序打印出所输入的的各个单词。每个单词前标有它的计数值。

输入

各个单词,输入0则表示单词结束

输出

降序打印单词出现的频率和单词。单词频度相同,按出现顺序输出。

样例输入

bad
good
bad
cute
how
good
good
0

样例输出

3 good
2 bad
1 cute
1 how

提示

解决方案

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

struct Pair {
    std::string string;
    int count;
    Pair(std::string &string, int count) : string(string), count(count) {}
};
bool operator==(Pair &pair, const std::string &string) {
    return pair.string == string;
}
bool operator<(const Pair &lhs, const Pair &rhs) {
    return lhs.count > rhs.count; // NG
}

int main() {
    std::vector<Pair> vector;
    std::string string;
    std::cin >> string;
    while (string != "0") {
        std::vector<Pair>::iterator it = std::find(vector.begin(), vector.end(), string);
        if (it != vector.end()) {
            it->count += 1;
        } else {
            vector.push_back(Pair(string, 1));
        }
        std::cin >> string;
    }
    std::sort(vector.begin(), vector.end());
    for (int i = 0; i < vector.size(); ++i) {
        std::cout << vector[i].count << ' ' << vector[i].string << std::endl;
    }

    return 0;
}

求矩阵的最大和最小值

时间限制: 1 Sec 内存限制: 128 MB

题目描述

定义一个函数用一级指针接收一个任意行任意列的矩阵并返回该矩阵元素的最大和最小值.

输入

矩阵的行数 矩阵的列数
矩阵各元素的值

输出

最大值
最小值

样例输入

3 3
1 2 3
4 5 6
7 8 9

样例输出

9
1

提示

解决方案

#include <iostream>

void findMinAndMaxValues(int *ptr, int row, int col);

int main() {
    int row, col;
    std::cin >> row >> col;
    int mat[row][col];
    for (int ir = 0; ir < row; ++ir) {
        for (int ic = 0; ic < col; ++ic) {
            std::cin >> mat[ir][ic];
        }
    }
    findMinAndMaxValues(&mat[0][0], row, col);

    return 0;
}

void findMinAndMaxValues(int *ptr, int row, int col) {
    int min = *ptr, max = *ptr;
    for (int ir = 0; ir < row; ++ir) {
        for (int ic = 0; ic < col; ++ic) {
            if (ptr[ir * col + ic] < min) {
                min = ptr[ir * col + ic];
            }
            if (ptr[ir * col + ic] > max) {
                max = ptr[ir * col + ic];
            }
        }
    }
    std::cout << max << std::endl << min << std::endl;
}