A.三数论大小（指针）

题目描述

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

cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
#include <iostream>
using namespace std;

int main()
{
    int a, b, c, t;
    int* p1, * p2, * p3;
    int tmp;

    cin >> t;
    for (int i = 1; i <= t; i++)
    {
        cin >> a >> b >> c;
        p1 = &a;
        p2 = &b;
        p3 = &c;

        if (*p1 < *p2)
        {
            tmp = *p1;
            *p1 = *p2;
            *p2 = tmp;
        }
        
        if (*p1 < *p3)
        {
            tmp = *p1;
            *p1 = *p3;
            *p3 = tmp;
        }
        
        if (*p2 < *p3)
        {
            tmp = *p2;
            *p2 = *p3;
            *p3 = tmp;
        }

        cout << *p1<< " "<<  *p2 <<" " << *p3 << endl;

    }
    
    return 0;
}

B.货币兑换（指针与常量）

题目描述

设定以下汇率常量

美元汇率为6.2619，表示1美元兑换6.2619元人民币

欧元汇率为6.6744，表示1欧元兑换6.6744元人民币

日元汇率为0.0516，表示1元日元兑换0.0516元人民币

港币汇率为0.9200，表示1元港币币兑换0.92元人民币

定义一个常量指针，根据需求指针指向不同的汇率，然后计算出各种货币兑换为人民币的数量

要求：不能直接使用汇率常量进行计算，必须使用常量指针，只能使用一个指针

cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include <iostream>
#include<iomanip>
using namespace std;

int main()
{
    const double* p;
    int t;
    char ch;
    double d = 6.2619, e = 6.6744, y = 0.0516, h = 0.8065;
    double a;
    cin >> t;
    for (int i = 1; i <= t; i++)
    {
        cin >> ch;
        cin >> a;
        p = &a;
        if (ch == 'D') 
        {
            p = &d;
        }
        if (ch == 'E')
        {
            p = &e;
        }
        if (ch == 'Y')
        {
            p = &y;
        }
        if (ch == 'H')
        {
            p = &h;
        }
        cout << fixed << setprecision(4) << a * (*p) << endl;
    }
    return 0;

}

C.动态数组（指针与数组）

题目描述

一开始未知数组长度，根据要求创建不同类型的指针，并且使用指针创建相应长度的数组，然后再完成不同的要求

若要求创建整数数组，计算数组内所有数据的平均值

若要求创建字符数组，找出数组内的最大字母

若要求创建浮点数数组，找出数组的最小值

要求程序整个过程不能使用数组下标，从数组创建、输入到搜索、比较、计算，到输出都必须使用指针

提示：使用new关键字

cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
#include <iostream>
#include<iomanip>
using namespace std;

int main()
{
    int t, n;
    char ch;

    cin >> t;
    for (int i = 0; i < t; i++)
    {
        cin >> ch;
        cin >> n;
        if (ch == 'I')
        {
            int* i = new int[n];
            int sum = 0;
            for (int j = 0; j < n; j++)
            {
                cin >> *(i + j);
                sum += *(i + j);
            }
            cout << sum / n << endl;
        }
        if (ch == 'C')
        {
            char* c = new char[n];
            char max;
            for (int j = 0; j < n; j++)
            {
                cin >> *(c + j);
                if (j == 0)
                {
                    max = *(c);
                }
                else
                {
                    if (*(c + j) > max)
                    {
                        max = *(c + j);
                    }
                }
            }
            cout << max << endl;
        }
        if (ch == 'F')
        {
            double* f = new double[n];
            double min;
            for (int j = 0; j < n; j++)
            {
                cin >> *(f + j);
                if (j == 0)
                {
                    min = *(f);
                }
                else
                {
                    if (*(f + j) < min)
                    {
                        min = *(f + j);
                    }
                }
            }
            cout << min << endl;
        }
    }
    return 0;

}

D.三串合一（指针与字符数组）

题目描述

输入三个字符串，通过指针读取各个字符串的子串（子串是指字符串中连续的一小部分），把它们合并成一个新字符串

要求：

  1. 三个字符串的创建和输入可以使用数组，也可以不用
  2. 输入后，根据三个字符串的子串的长度，计算出新字符串的长度
  3. 使用动态数组的方法创建新的字符串，并且使用指针读取三个字符串的不同部分，并且复制到新字符串中，要求整个过程都不能使用数组下标
  4. 使用指针输出新的字符串
cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include <iostream>
#include <cstring>
using namespace std;

void myget(char* p, char* p1, char* p2, char* p3, char* p4, char* p5, char* p6)
{
    while (p1 != p4)  *p++ = *p1++;
    while (p2 != p5)  *p++ = *p2++;
    while (p3 != p6)  *p++ = *p3++;
    *p = '\0';
}


int main()
{
    int t;
    cin >> t;
    while (t--)
    {
        char a[15], b[15], c[15];
        cin >> a >> b >> c;
        int a1, a2, b1, b2, c1, c2;
        cin >> a1 >> a2 >> b1 >> b2 >> c1 >> c2;
        int len = a2 + b2 + c2 - (a1 + b1 + c1) + 3;
        char* arr = new char[len + 1];
        char* p = arr;
        char* p1 = a + a1 - 1;
        char* p2 = b + b1 - 1;
        char* p3 = c + c1 - 1;
        char* p4 = a + a2;
        char* p5 = b + b2;
        char* p6 = c + c2;
        myget(p, p1, p2, p3, p4, p5, p6);
        cout << arr << endl;
        delete[]arr;
    }

    return 0;
}

E.矩阵左转（指针与数组）

题目描述

输入一个2*3的矩阵，将这个矩阵向左旋转90度后输出

比如现在有2*3矩阵 ：

1 2 3

4 5 6

向左旋转90度后的矩阵变为：

3 6

2 5

1 4

要求：除了矩阵创建和数据输入可以使用数组和数组下标的方法，其他过程对矩阵的任何访问都必须使用指针

提示：m行n列的二维矩阵，第i行第j列的元素与首元素的距离为i*n+j，序号从0开始计算

cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#include <iostream>
#include <cstring>
using namespace std;

void change(int* arr1, int* arr2, int m, int n)
{
    for (int i = 0; i < m; i++) 
    {
        for (int j = 0; j < n; j++)
        {
            *(arr2 + (m - j) * m + i) = *(arr1 + i * n + j);
        }
    }
}

int main()
{
    int t;
    cin >> t;
    int arr1[2][3], arr2[3][2];
    while (t--)
    {
        for (int i = 0; i < 2; i++) 
        {
            for (int j = 0; j < 3; j++)
            {
                cin >> arr1[i][j];
            }
        }

        change(arr1[0], arr2[0], 2, 3);

        for (int i = 0; i < 3; i++)
        {
            for (int j = 0; j < 2; j++)
            {
                cout << arr2[i][j] << " ";
            }
            cout << endl;
        }
    }
    return 0;
}