小茗的笔记

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

题目描述

编写一个函数比较两个字符串，参数是两个字符指针（要求显式定义，例如char *S, char *T)，比较字符串S和T的大小。如果S大于T，则返回1，如果S小于T则返回-1，如果S与T相等则返回0。
比较规则：
1.把两个字符串的相同位置上的字符进行比较，字符的大小比较以ASCII值为准
2.在比较中，如果字符串S的字符大于字符串T的字符的数量超过小于的数量，则认为S大于T，如果等于则S等于T，如果小于则S小于T
例如S为aaccdd，T为eebbbb，每个位置比较得到S前两个字母都小于T，但后4个字母都大于T，最终认为S大于T
3.如果两个字符串长度不同，则更长的字符串为大
在主函数中输入两个字符串，并调用该函数进行判断，在判断函数中必须使用函数参数的指针进行字符比较

输入

输入t表示有t个测试实例
接着每两行输入两个字符串
依次输入t个实例

输出

每行输出一个实例的比较结果

样例输入

3
aaccdd
eebbbb
AAbb++
aaEE*-
zznnkk
aaaaaaa

样例输出

1
0
-1

提示

解决方案

#include <iostream>
#include <cstring>

int strcmp(char *str1, char *str2) {
    size_t str1_length = strlen(str1), str2_length = strlen(str2);
    if (str1_length > str2_length) {
        return 1;
    } else if (str1_length < str2_length) {
        return -1;
    }
    unsigned int value1 = 0, value2 = 0;
    while (*str1 != '\0') {
        if (*str1 == *str2) {
            continue;
        }
        if (*(str1++) > *(str2++)) {
            value1 += 1;
        } else {
            value2 += 1;
        }
    }
    if (value1 > value2) {
        return 1;
    } else if (value1 < value2) {
        return -1;
    } else {
        return 0;
    }
}

int main() {
    size_t T;
    std::cin >> T;
    while (T--) {
        char str1[1024], str2[1024];
        std::cin >> str1 >> str2;
        std::cout << strcmp(str1, str2) << std::endl;
    }
    return 0;
}

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

题目描述

已知每个月份的英文单词如下，要求创建一个指针数组，数组中的每个指针指向一个月份的英文字符串，要求根据输入的月份数字输出相应的英文单词
1月 January
2月 February
3月 March
4月 April
5月 May
6月 June
7月 July
8月 August
9月 September
10月 October
11月 November
12月 December

输入

第一行输入t表示t个测试实例
接着每行输入一个月份的数字
依次输入t行

输出

每行输出相应的月份的字符串，若没有这个月份的单词，输出error

样例输入

3
5
11
15

样例输出

May
November
error

提示

解决方案

#include <iostream>

int main() {
    const char *calendar[] = {"January", "February", "March",
                              "April", "May", "June",
                              "July", "August", "September",
                              "October", "November", "December"};
    size_t T;
    std::cin >> T;
    while (T--) {
        unsigned int month;
        std::cin >> month;
        if (1 <= month && month <= 12) {
            std::cout << calendar[month - 1] << std::endl;
        } else {
            std::cout << "error" << std::endl;
        }
    }
    return 0;
}

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

题目描述

设定以下汇率常量
美元汇率为6.2619，表示1美元兑换6.2619元人民币
欧元汇率为6.6744，表示1欧元兑换6.6744元人民币
日元汇率为0.0516，表示1元日元兑换0.0516元人民币
港币汇率为0.8065，表示1元港币币兑换0.8065元人民币
定义一个常量指针，根据需求指针指向不同的汇率，然后计算出各种货币兑换为人民币的数量
要求：不能直接使用汇率常量进行计算，必须使用常量指针，只能使用一个指针

输入

输入一个t表示有t个测试实例
每行先输入一个字母，表示货币类型，然后再输入一个数字（正浮点数），表示货币数量
D表示美元，E表示欧元，Y表示日圆，H表示港币
依次输入t行

输出

每行输出兑换后的人民币数量，保留4位小数
在C++中，输出指定精度的参考代码如下：

#include <iostream>
#include <iomanip> //必须包含这个头文件

using namespace std;

void main( )
{
  double a =3.141596;
  cout<<fixed<<setprecision(3)<<a<<endl;  //输出小数点后3位
}

样例输入

4
Y 10000
D 88.3
H 200
E 73.1

样例输出

516.0000
552.9258
161.3000
487.8986

提示

解决方案

#include <iostream>
#include <iomanip>

const double USD_CNY = 6.2619, EUR_CNY = 6.6744, JPY_CNY = 0.0516, HKD_CNY = 0.8065;

int main() {
    size_t T;
    std::cin >> T;
    const double *exchange_rate = nullptr;
    while (T--) {
        char type;
        double money;
        std::cin >> type >> money;
        switch (type) {
            case 'D':
                exchange_rate = &USD_CNY;
                break;
            case 'E':
                exchange_rate = &EUR_CNY;
                break;
            case 'Y':
                exchange_rate = &JPY_CNY;
                break;
            case 'H':
                exchange_rate = &HKD_CNY;
                break;
            default:
                exit(-1);
        }
        std::cout << std::fixed << std::setprecision(4) << (money * *exchange_rate) << std::endl;
    }
    return 0;
}

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

题目描述

有一种方式是使用密钥进行加密的方法，就是对明文的每个字符使用密钥上对应的密码进行加密，最终得到密文
例如明文是abcde，密钥是234，那么加密方法就是a对应密钥的2，也就是a偏移2位转化为c；明文b对应密钥的3，就是b偏移3位转化为e，同理c偏移4位转化为g。这时候密钥已经使用完，那么又重头开始使用。因此明文的d对应密钥的2，转化为f，明文的e对应密钥的3转化为h。所以明文abcde，密钥234，经过加密后得到密文是cegfh。
如果字母偏移的位数超过26个字母范围，则循环偏移，例如字母z偏移2位，就是转化为b，同理字母x偏移5位就是转化为c
要求：使用三个指针p、q、s分别指向明文、密钥和密文，然后使用指针p和q来访问每个位置的字符，进行加密得到密文存储在指针s指向的位置。
除了变量定义和输入数据，其他过程都不能使用数组下标法，必须使用三个指针来访问明文、密钥和密文。
提示：当指针q已经移动到密钥的末尾，但明文仍然没有结束，那么q就跳回密钥头

输入

第一行输入t表示有t个测试实例
第二行输入一个字符串，表示第一个实例的明文
第三行输入一个数字串，表示第一个实例的密钥
依次输入t个实例

输出

每行输出加密后的密文

样例输入

2
abcde
234
XenOS
56

样例输出

cegfh
CksUX

提示

解决方案

#include <iostream>
#include <cstring>

typedef char *string;

char addCharRegular(char ch, int index) {
    index = index - '0';
    if ('a' <= ch && ch <= 'z') {
        return ((ch - 'a') + index) % 26 + 'a';
    } else {
        return ((ch - 'A') + index) % 26 + 'A';
    }
}

int main() {
    size_t T;
    std::cin >> T;
    while (T--) {
        const auto plaintext = new char[1024], cipher = new char[1024], ciphertext = new char[1024] {};
        std::cin >> plaintext >> cipher;
        size_t plaintext_length = strlen(plaintext), cipher_length = strlen(cipher);
        auto plaintext_ptr = plaintext, cipher_ptr = cipher, ciphertext_ptr = ciphertext;
        const auto plaintext_end = plaintext + plaintext_length, cipher_end = cipher + cipher_length;
        while (plaintext_ptr != plaintext_end) {
            *(ciphertext_ptr++) = addCharRegular(*(plaintext_ptr++), *(cipher_ptr++));
            if (cipher_ptr == cipher_end) {
                cipher_ptr = cipher;
            }
        }
        *ciphertext_ptr = '\0';
        std::cout << ciphertext << std::endl;
    }
    return 0;
}

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

题目描述

一开始未知数组长度，根据要求创建不同类型的指针，并且使用指针创建相应长度的数组，然后再完成不同的要求
若要求创建整数数组，计算数组内所有数据的平均值
若要求创建字符数组，找出数组内的最大字母
若要求创建浮点数数组，找出数组的最小值
要求程序整个过程不能使用数组下标，从数组创建、输入到搜索、比较、计算，到输出都必须使用指针
提示：使用new关键字

输入

第一行输入t表示有t个测试实例
第二行先输入一个大写字母表示数组类型，I表示整数类型，C表示字符类型，F表示浮点数类型；然后输入n表示数组长度。
第三行输入n个数据
依次输入t个实例

输出

每个根据不同的数组类型输出相应的结果

样例输入

3
C 5
A D E B C
I 6
22 55 77 33 88 55
F 4
3.1 1.9 6.5 4.8

样例输出

E
55
1.9

提示

解决方案

不明白这种要求存在的意义。它对于让学生更好地理解指针这个问题上没有任何意义，反而降低代码质量。对于这个问题，我建议你去阅读《征服C指针》之类的图书，或许对你帮助会很大。

顺便一提，*(p+5)是p[5]的语法糖，也就是说，p[5]是前者的简化形式，方便输入等。因此，在这个时候甚至5[p]和p[5]也是一样的，不过别写成这样。具体内容详见上述图书。

#include <iostream>

int getAverageValue(const int *array, size_t size) {
    int sum = 0;
    size_t times = size;
    while (times--) {
        sum += *(array++);
    }
    return (sum / static_cast<int>(size));
}

char getMaximumChar(const char *array, size_t size) {
    char maxChar = *array;
    while (size--) {
        if (maxChar < *array) {
            maxChar = *array;
        }
        array += 1;
    }
    return maxChar;
}

double getMinimumFloat(const double *array, size_t size) {
    double minDouble = *array;
    while (size--) {
        if (minDouble > *array) {
            minDouble = *array;
        }
        array += 1;
    }
    return minDouble;
}

template<typename T>
T *handleArray(size_t size) {
    T *array = new T[size];
    for (size_t i = 0; i < size; ++i) {
        std::cin >> *(array + i);
    }
    return array;
}

int main() {
    size_t T;
    std::cin >> T;
    while (T--) {
        char type;
        size_t size;
        std::cin >> type >> size;
        switch (type) {
            case 'I': {
                const int *array = handleArray<int>(size);
                std::cout << getAverageValue(array, size) << std::endl;
                break;
            }
            case 'C': {
                const char *array = handleArray<char>(size);
                std::cout << getMaximumChar(array, size) << std::endl;
                break;
            }
            case 'F': {
                const double *array = handleArray<double>(size);
                std::cout << getMinimumFloat(array, size) << std::endl;
                break;
            }
            default:
                exit(-1);
        }
    }
    return 0;
}

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

题目描述

已知一组学生成绩，然后根据输入的序号查询成绩
要求：

1. 使用一个整数数组存储学生成绩，假设元素数是n。
2. 使用一个指针指向数组中间元素,即n/2的位置。
3. 使用++和–运算符，求出数组中间元素的前一个成绩和后一个成绩
4. 输入一个序号，然后计算这个序号的元素和中间元素的距离，然后使用指针去访问
   例如有11个学生，指针指向中间的学生也就是第6个学生，若输入序号3，即查询第3个学生的成绩，第3和第6之间距离为3，那么指针应该怎么运算呢？？？
   如果有两个中间学生，则将后面那个看为中间学生。
5. 整个程序除了输入时可以使用数组下标，其他部分尽量使用使用指针进行访问。

输入

第一行输入t表示有t个测试实例
第二行先输入n，表示有n个学生，然后再输入n个成绩（正整数）
第三行输入1个序号，表示要查询成绩的学生的序号。
依次输入t个实例
按自然意义，序号是从1开始计算
提示：在数组中是从……..

输出

对于每个测试实例：
第一行输出数组中间元素的前一个成绩和后一个成绩
第二行根据序号输出1个成绩

样例输入

2
7 66 99 88 44 77 33 11
2
11 60 80 50 20 90 35 70 40 10 95 30
9

样例输出

88 77
99
90 70
10

提示

解决方案

不想评论了…

#include <iostream>
#include <algorithm>

inline const unsigned int *getArrayMiddlePointer(const unsigned int *array, const size_t size) {
    return array + (size / 2);
}

int main() {
    size_t T;
    std::cin >> T;
    while (T--) {
        size_t ARRAY_SIZE;
        std::cin >> ARRAY_SIZE;
        auto *array = new unsigned int[ARRAY_SIZE];
        for (size_t i = 0; i < ARRAY_SIZE; ++i) {
            std::cin >> array[i];
        }
        auto ptr = getArrayMiddlePointer(array, ARRAY_SIZE);
        std::cout << *(--ptr) << ' ';
        ptr = getArrayMiddlePointer(array, ARRAY_SIZE);
        std::cout << *(++ptr) << std::endl;
        size_t number;
        std::cin >> number;
        const auto delta = (ARRAY_SIZE / 2) + 1 - number;
        ptr = getArrayMiddlePointer(array, ARRAY_SIZE);
        std::cout << *(ptr - delta) << std::endl;
    }
    return 0;
}

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

题目描述

输入一个字符串，判断这个字符串是否一个完全整数值的字符串，例如输入”1234″，那么表示整数1234，输入”12a3″就表示只是一个字符串，不是一个整数
要求编写函数isNumber，参数是一个字符指针，返回值是整数类型
如果字符串表示一个整数，则计算出这个整数并且返回
如果字符串不是表示一个整数，则返回-1
主函数必须调用isNumber来判断字符串，不能使用任何C++自带或第三方的类似函数

输入

输入t表示有t个测试实例
每行输入一个字符串
依次输入t行

输出

每行输出判断结果

样例输入

3
1234
567a
0890

样例输出

1234
-1
890

提示

解决方案

有一说一，这题搞得我很火大。本来几句话就秒掉的题目，没想到后台数据竟然一份换行符是LR，一份是CRLF…搞得加了一堆删白符的代码，看着就不爽…早知道不这么写了。而且要是想让学生写的代码更好，至少也应该先讲过相关内容吧？不然一起怪OJ有问题很好玩么？

总而言之，说归说，最后还是一句话：我菜。

#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>

bool isDigit(const char ch) {
    return ('0' <= ch) && (ch <= '9');
}

bool isNumber(const char *string, size_t size) {
    return std::find_if(string, (string + size), [](char ch) { return !isDigit(ch); }) == (string + size);
}

int main() {
    size_t T;
    std::cin >> T;
    if (std::cin.get() == '\r') {
        std::cin.get();
    }
    char string[1024]{};
    while (T--) {
        std::cin.getline(string, 1024);
//        std::cout << string << std::endl;
        size_t string_length = strlen(string);
        if (string[string_length - 1] == '\r' || string[string_length - 1] == '\n') {
            string[string_length - 1] = '\0';
            string_length -= 1;
        }
        size_t leading_zero_amount = std::find_if_not(string, string + string_length, [](char ch) { return ch == '0'; }) - string;
        std::cout << (isNumber(string, string_length) ? std::string(string + leading_zero_amount, string + string_length) : "-1") << std::endl;
    }
    return 0;
}

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

题目描述

输入三个整数，然后按照从大到小的顺序输出数值。
要求：用三个指针分别指向这三个整数，排序过程必须通过这三个指针来操作，不能直接访问这三个整数
输出时，必须使用这三个指针，不能使用存储三个整数的变量

输入

第一行输入t表示有t个测试实例
第二行起，每行输入三个整数
输入t行

输出

每行按照从大到小的顺序输出每个实例
在每行中，每个数据输出后都带有一个空格，即使该行最后一个数据输出后也要再输出一个空格

样例输入

3
2 4 6
88 99 77
111 333 222

样例输出

6 4 2 
99 88 77 
333 222 111 

提示

解决方案

#include <iostream>
#include <algorithm>

const size_t ARRAY_SIZE = 3;

int main() {
    unsigned int T;
    std::cin >> T;
    while (T--) {
        int integer_array[ARRAY_SIZE]{}, *integer_ptr_array[ARRAY_SIZE]{};
        for (size_t i = 0; i < ARRAY_SIZE; ++i) {
            std::cin >> integer_array[i];
            integer_ptr_array[i] = integer_array + i;
        }
        for (size_t i1 = 0; i1 < (ARRAY_SIZE - 1); ++i1) {
            for (size_t i2 = 0; i2 < (ARRAY_SIZE - i1 - 1); ++i2) {
                if (*integer_ptr_array[i2] < *integer_ptr_array[i2 + 1]) {
                    // swap pointers
                    auto tmp_ptr = integer_ptr_array[i2];
                    integer_ptr_array[i2] = integer_ptr_array[i2 + 1];
                    integer_ptr_array[i2 + 1] = tmp_ptr;
                }
            }
        }
        for (auto item : integer_ptr_array) {
            std::cout << *item << ' ';
        }
        std::cout << std::endl;
    }
    return 0;
}