PTA初级题目练习

作者：~小明学编程 

文章专栏：蓝桥杯PTA练习

格言：目之所及皆为回忆，心之所想皆为过往

7-1 约会成功了吗？

题目

2021年9月9日，张三想约一直暗恋了很久的的女生小芳看电影，小芳告诉张三这天没空，可以答应在某年某月某日陪他一起看。输入一个约会的日期，请你编写程序判断最终张三是否能实现他约会的愿望，若能实现则输出yes，否则输出no。注意，约会不能穿越到2021年9月9日前。

输入格式:

在一行中输入年月日，用-分隔。

输出格式:

合法的日期输出yes,不合法的日期输出no

输入样例1:

2022-7-7

输出样例1:

yes

输入样例2:

2022-2-29

输出样例2:

no

输入样例3:

2021-2-28

输出样例3:

no

代码

#include
//判断输入的日期是否合法
int judgeLgal(int year,int month,int day)
{
    int arr[13] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
    if((year%4==0&&year%100!=0||year%400==0))
    {
//         if(month==2&&day>28)
//         {
//             return -1;
//         }
        arr[2]=29;
    }
    if(arr[month]
    {
        return -1;
    }
    if(year>2021)
    {
        return 0;
    }
    else
    {
        if(year==2021&&month>9)
        {
            return 0;
        }
        else
        {
            if(year==2021&&month==9&&day>=9)
            {
                return 0;
            }
            else
            {
                return -1;
            }
        }
    }
}
int main()
{
    int year = 0;
    int month = 0;
    int day = 0;
    scanf("%d-%d-%d",&year,&month,&day);
    if(judgeLgal(year,month,day)==0)
    {
        printf("yes");
    }
    else
    {
        printf("no");
    }
    return 0;
}

7-2 验证回文串

题目：

编写程序，验证一个字符串是否为回文串：是否从前读它和从后读它都是一样的。例如，mom，dad是回文串。该程序接收用户输入的字符串，判断是否为回文串，然后将判断的结果输出。

输入格式:

输入在一行中给出一个字符串。

输出格式:

如果输入的字符串为回文串，则输出yes；否则输出no。

输入样例:

在这里给出一组输入。例如：

mom

输出样例:

在这里给出相应的输出。例如：

yes

代码

#include
#include
int judge(char* str)
{
    int right = strlen(str)-1;
    int left = 0;
    while(left<=right)
    {
        if(*(str+left)==*(str+right))
        {
            left++;
            right--;
            continue;
        }
        else
        {
            return -1;
        }
 
    }
    return 0;
}
int main()
{
    char str[81] = {0};
    scanf("%s",str);
    if(judge(str)==0)
    {
        printf("yes\n");
    }
    else
    {
        printf("no\n");
    }
    return 0;
}

7-3 自守数

题目

数学的世界有很多很漂亮的数字或者数字集合，比如梅森数，哥德巴赫猜想，水仙花数，完全数，自守数。今天我们就一起来探究一下自守数。自守数是指一个数的平方的尾数等于该数自身的自然数。例如：25^2 = 625，76^2 = 5776，9376^2 = 87909376。请求出n以内的自守数的个数

输入格式:

第一行输入n,随后输入n个数m。

输出格式:

在一行中输出m以内自守数的个数，所有输出在一行内完成，末尾没有多余空格。

输入样例:

5
1
2
3
4
5

输出样例:

2 2 2 2 3

代码

#include
#include
//计算位数
int number(int m)
{
    int count = 0;
    while(m!=0)
    {
        count++;
        m = m/10;
    }
    return count;
}
//计算切断之后的数
int cutNumber(int x,int number)
{
    return x%(int)pow(10,number);
}
int main()
{
    int n = 0;
    int m=0;
    scanf("%d",&n);
    while(n--)
    {
        int count = 0;
        scanf("%d",&m);
        for(int i=1;i<=m;i++)
        {
            if(i==cutNumber(i*i,number(i)))
            {
                count++;
            }
        }
        if(n==0)
        {
            printf("%d",count+1);
        }
        else
        {
            printf("%d ",count+1);
        }
    }
    return 0;
}

7-4 验证“哥德巴赫猜想”

题目：

数学领域著名的“哥德巴赫猜想”的大致意思是：任何一个大于2的偶数总能表示为两个素数之和。比如：24=5+19，其中5和19都是素数。本实验的任务是设计一个程序，验证20亿以内的偶数都可以分解成两个素数之和。

输入格式：

输入在一行中给出一个(2, 2 000 000 000]范围内的偶数N。

输出格式：

在一行中按照格式“N = p + q”输出N的素数分解，其中p ≤ q均为素数。又因为这样的分解不唯一（例如24还可以分解为7+17），要求必须输出所有解中p最小的解。

输入样例：

24

输出样例：

24 = 5 + 19

代码

#include
#include
int judgePrime(int number)
{
    for(int i=2;i<=(int)sqrt(number);i++)
    {
        
        if(number%i==0)//不是素数
        {
            return -1;
        }
    }
    return 1;
}
int main()
{
    int N = 0;
    scanf("%d",&N);
    for(int i=2;i
    {
        if(judgePrime(i)==1&&judgePrime(N-i)==1)
        {
            printf("%d = %d + %d",N,i,N-i);
            break;
        }
    }
    return 0;
}

7-5 逐行排序

题目：

给你一个n阶方阵，请你把每行数据按数据从小到大排序并输出。

输入格式:

输入数据首先包含一个整数T，表示测试实例的个数，然后是T组测试数据。
每组测试数据的第一行输入1个整数n(1

输出格式:

对于每组测试，输出排好序后的结果。每行中各数据之间留一个空格。

输入样例:

2
3
4 9 2
3 5 7
8 1 6
2
3 5
1 2

输出样例:

2 4 9
3 5 7
1 6 8
3 5
1 2

代码

#include
void bubbleSort(int arr[21][21], int n)
{
    for (int k = 0; k < n; k++)
    {
        for (int i = 0; i < n - 1; i++)
        {
            for (int j = 0; j < n - i - 1; j++)
            {
                if (arr[k][j] > arr[k][j + 1])
                {
                    int ret = arr[k][j];
                    arr[k][j] = arr[k][j + 1];
                    arr[k][j + 1] = ret;
                }
            }
        }
    }
}
void print(int arr[21][21], int n)
{
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            if (j == n - 1)
            {
                printf("%d", arr[i][j]);
            }
            else
            {
                printf("%d ", arr[i][j]);
            }
        }
        printf("\n");
    }
}
int main()
{
    int T = 0;
    int n = 0;
    int arr[21][21] = { 0 };
    scanf("%d", &T);
    while (T--)
    {
        scanf("%d", &n);
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < n; j++)
            {
                scanf("%d", &arr[i][j]);
            }
        }
        bubbleSort(arr, n);
        print(arr, n);
 
    }
    return 0;
}

7-6 判断双对称方阵

题目

对于一个n阶方阵，请判断该方阵是否双对称，即既左右对称又上下对称。若是则输出“yes”，否则输出“no”。例如，样例中，以第2列为界则左右对称，以第2行为界则上下对称，因此输出“yes”。

输入格式:

首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每组数据的第一行输入方阵的阶n（2≤n≤50），接下来输入n行，每行n个整数，表示方阵中的元素。

输出格式:

对于每组测试数据，若该方阵双对称，则输出“yes”，否则输出“no”。注意，引号不必输出。

输入样例:

2
3
1 2 1
3 5 3
1 4 1
3
1 2 1
3 5 3
1 2 1

输出样例:

no
yes

代码

#include
int judge(int arr[51][51],int n)
{
    for(int i=0;i2;i++)
    {
        for(int j=0;j
        {
            if(arr[i][j]!=arr[n-1-i][j]||arr[j][i]!=arr[j][n-1-i])
                return -1;
        }
    }
    return 0;
    
}
int main()
{
    int T = 0;
    int n = 0;
    int arr[51][51] = { 0 };
    scanf("%d", &T);
    while (T--)
    {
        scanf("%d", &n);
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < n; j++)
            {
                scanf("%d", &arr[i][j]);
            }
        }
        if(judge(arr,n)==0)
        {
            printf("yes\n");
        }
        else
        {
            printf("no\n");
        }
    }
    return 0;
}

7-7 蛇形矩阵

题目

蛇形矩阵是由1开始的自然数依次排列成的一个上三角矩阵（参看 输出样例）。要求输入整数n，构造并输出蛇形矩阵。

输入格式:

首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每组测试输入一个正整数N（N不大于100)。

输出格式:

对于每组测试，输出一个共有N行的蛇形矩阵。每行的每两个数字之间留一个空格。

输入样例:

在这里给出一组输入。例如：

1
5

输出样例:

1 3 6 10 15
2 5 9 14
4 8 13
7 12
11

代码

#include
void initArr(int arr[101][101], int n)
{
    int init = 1;//第一个数
    int ret = 1;
    int add = 0;
    for (int i = 0; i < n; i++)
    {
        ret++;//每行一开始加的数
        init += i;//每行的第一个数
        add = ret;
 
        for (int j = 0; j < n - i; j++)
        {
            if (j == 0)
            {
                arr[i][j] = init;
            }
            else
            {
                arr[i][j] = arr[i][j-1] + add;
                add++;
            }
        }
    }
}
void print(int arr[101][101], int n)
{
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n - i; j++)
        {
            if (j != n - i - 1)
            {
                printf("%d ", arr[i][j]);
            }
            else
            {
                printf("%d", arr[i][j]);
 
            }
        }
        printf("\n");
    }
}
int main()
{
    int T = 0;
    int N = 0;
    int arr[101][101] = { 0 };
    scanf("%d", &T);
    while (T--)
    {
        scanf("%d", &N);
        initArr(arr, N);
        print(arr, N);
    }
    return 0;
}

7-8 扫雷游戏

题目

玩过扫雷游的朋友都知道，该游戏的目标是找出一个nm矩阵内的所有的地雷，在本题中，你需要为每一个单元格统计出它周围地雷的个数，每个单元格最多有8个相邻单元格，如下图，44 的格子里，用“*”表示雷，用“^” 表示没有雷。

*^^^

^^^^

^*^^

^^^^

计算后的输出结果为：

*100

2210

1*10

1110

输入格式:

输入包含若干个矩阵，对于每一个矩阵，第一行包含两个数M和N，分别表示该矩阵的行数和列数（0

输出格式:

对于每一个矩阵，首先在单独一行打印出矩阵序号：Field #X: 其中X是矩阵的编号，从1开始编号，接下来N行中，读入的“^”用该位置周围的地雷数目所代替，地雷处，仍用“*”表示。输出相邻的两个矩阵之间，空一行。

输入样例:

在这里给出一组输入。例如：

4 4 
*^^^
^^^^
^*^^
^^^^
8 8
*^^^*^^^
*^****^^
^*^^**^^
^^**^**^
^*^^**^^
*^^^*^^^
^^**^**^
^*^^**^^
0 0

输出样例:

在这里给出相应的输出。例如：

Field #1:
*100
2210
1*10
1110
 
Field #2:
*324*310
*4****20
2*56**41
23**6**1
2*34**31
*334*531
23**5**1
1*33**31

代码

#include
void initBoard(char arr[102][102], int N, int M)
{
    for (int i = 0; i < 102; i++)
	{
		for (int j = 0; j < 102; j++)
		{
			arr[i][j] = '^';
		}
	}
	for (int i = 1; i <= N; i++)
	{
		for (int j = 1; j <= M; j++)
		{
			scanf("%c", &arr[i][j]);
		}
		getchar();
	}
}
int get_mine_count(char mine[102][102], int x, int y)
{
	return (mine[x - 1][y] +
		mine[x + 1][y] +
		mine[x][y - 1] +
		mine[x][y + 1] +
		mine[x - 1][y - 1] +
		mine[x - 1][y + 1] +
		mine[x + 1][y - 1] +
		mine[x + 1][y + 1] - 8 * '^')/('*'-'^');
}
void findMine(char arr[102][102], int N, int M)
{
	for (int i = 1; i <= N; i++)
	{
		for (int j = 1; j <= M; j++)
		{
			if (arr[i][j] == '*')
			{
				printf("%c",arr[i][j]);
			}
			else
			{
				printf("%c",'0'+get_mine_count(arr, i, j));
			}
		}
		printf("\n");
	}
}
int main()
{
    int count = 1;
	int N = 0;
	int M = 0;
	char arr[102][102] = { 0 };
    while(scanf("%d %d\n", &N, &M)!=EOF)
    {
//         getchar();
        if (M == N && N == 0)
        {
            return 0;
        }
        initBoard(arr, N, M);
        printf("Field #%d:\n",count);
        findMine(arr, N, M);
        printf("\n");
        count++;
     }
	
	return 0;
}

7-9 优美的括号序列

题目

某日，小明特别无聊，就想找点东西玩，于是他发现括号()特别好玩，而且新学会了一项技能，

将一对小括号()，插入到一个括号序列中，其中插入的规则是，左括号'('的位置要小于右括号')'的位置，不要求插入的左右括号相邻，

例如以下，为了方便区分，我们拿ab代表原括号序列

将()插入到()中可形成()ab (a)b (ab) a()b a(b) ab()等等序列，其中a代表原括号序列的左括号,b代表原括号序列的右括号。

小明认为一个括号序列是一个优美的序列当且仅当这个括号序列可以被如下方法构造出来：

一开始有一个空串，然后执行0次或者若干次操作，每次操作将()插入到当前的括号序列中。

根据上面的定义：() , (()) , (()())都是优美的括号序列，(() , )( , ()))都不是优美的括号序列

输入格式：

多组输入

每行输入给定一个仅由'(',')'组成的括号序列,长度小于等于1000

题目保证没有空串

输出格式：

对于每个输入输出一行，若当前的括号序列是优美的，则输出"YES"（不含引号）

否则输出"NO"（不含引号）

输入样例：

()
(())
(()())
()()
(()
)(
()))

输出样例：

YES
YES
YES
YES
NO
NO
NO

代码

#include
#include
int judge(char arr[])
{
    int count=0;
    for(int i=0;i<strlen(arr);i++)
        {
            if(arr[i]=='(')
            {
                count++;
            }
            else
            {
                count--;
            }
            if(count<0)
            {
                return -1;
            }
        }
        if(count==0)
        {
            return 1;
        }
        else
        {
            return -1;
        }
    
}
int main()
{
    char arr[1001]={0};
    int count = 0;
    while(scanf("%s\n",arr)!=EOF)
    {
        if(judge(arr)==1)
        {
            printf("YES\n");
        }
        else
        {
            printf("NO\n");
        }
    }
    return 0;
}

7-10 单链表基本操作

题目

请编写程序实现单链表插入、删除结点等基本算法。给定一个单链表和一系列插入、删除结点的操作序列，输出实施上述操作后的链表。单链表数据域值为整数。

输入格式:

输入第1行为1个正整数n，表示当前单链表长度；第2行为n个空格间隔的整数，为该链表n个元素的数据域值。第3行为1个正整数m，表示对该链表施加的操作数量；接下来m行，每行表示一个操作，为2个或3个整数，格式为0 k d或1 k。0 k d表示在链表第k个结点后插入一个数据域值为d的结点，若k=0则表示表头插入。1 k表示删除链表中第k个结点，此时k不能为0。注：操作序列中若含有不合法的操作（如在长度为5的链表中删除第8个结点、删除第0个结点等），则忽略该操作。n和m不超过100000。

输出格式:

输出为一行整数，表示实施上述m个操作后的链表，每个整数后一个空格。输入数据保证结果链表不空。

输入样例:

5
1 2 3 4 5
5
0 2 8
0 9 6
0 0 7
1 0 
1 6

输出样例:

7 1 2 8 3 5 

代码

#include
#include
struct Node
 {
     int data;
     struct Node * next;
 };
 //输出链表
 void ShowList(struct Node* list)
 {
     //list = list->next;
     while (list) {
         printf("%d ", list->data);
         list = list->next;
     }
     //printf("%d\n", list->data);
     printf("\n");
 }
 void DeleteList(struct Node* list, int t)
 {
 
     struct Node* p = list;
     struct Node* q = NULL;
     if (t) {
         for (int i = 0; p && i < t - 1; ++i) {
             if (!p->next) {
             return ;//若超出链表范围，不处理
         }
             p = p->next;
         }
         
         q = p;
         p = p->next;
         q->next = p->next;//删除中间结点和尾结点
     }
     else {
         return;
     }
//      free(p);
 }
 void InsertList(struct Node* list, int t ,int data)
 {
     if (t < 0)
     {
         return;
     }
     struct Node* p = list;
     struct Node* insert = (struct Node*)malloc(sizeof(struct Node*));//开辟一块新的空间
     /*for (int i = 0; i < t ; i++) {
         p = p->next;
     }*/
     while (t-->0)
     {
         if (p->next==NULL)//链表越界则直接返回
             return;
         p = p->next;
     }
     //找到所插入位置处的上一块空间
     insert->data = data;//存入数据
     insert->next = p->next;//和后面的空间建立连接
     p->next = insert;//和前面的空间建立连接
 }
 
 int main()
 {
     int n = 0;
     struct Node* head;
     struct Node* cur;
     struct Node* tem;
     scanf("%d", &n);
//      int curn = n;//复制一个链表个数
     head = (struct Node*)malloc(sizeof(struct Node));
     head->next = NULL;
     cur = head;
     //创建链表
     while (n--)
     {
         tem = (struct Node*)malloc(sizeof(struct Node));
         scanf("%d", &(tem->data));
         cur->next = tem;
         cur = cur->next;
     }
     cur->next = NULL;
     //对链表施加的操作数
     int operand = 0;
     scanf("%d",&operand);
     //用于判断进行删除还是插入操作
     int flag=0;
     int k = 0;
     int d = 0;
     while(operand--)
     {
         scanf("%d",&flag);
         if(flag==0)//插入节点
         {
             scanf("%d %d", &k, &d);
             InsertList(head, k, d);
             //ShowList(head->next);
         }
         else//删除节点
         {
             scanf("%d", &k);
             DeleteList(head, k);
             //ShowList(head->next);
 
         }
     }
     ShowList(head->next);
     
 }