PTA-暑期学校-Day8（C语言）

最新推荐文章于 2024-08-13 10:31:01 发布

等待另一个根号二

最新推荐文章于 2024-08-13 10:31:01 发布

阅读量1.8k

点赞数 30

分类专栏： PTA 暑期学校文章标签： c语言

本文链接：https://blog.csdn.net/qq_52167875/article/details/135982522

版权

PTA 暑期学校专栏收录该内容

9 篇文章 0 订阅

订阅专栏

文章介绍了PTA暑期学校的C语言编程课程，包括乘法口诀数列的生成与验证、出栈序列的合法性判断、表达式求值算法以及社交网络中六度空间理论的应用。每个部分都有详细的代码示例和输入输出要求。

摘要由CSDN通过智能技术生成

1 乘法口诀数列

从任意给定的两个 1 位数字 a1 和 a2 开始，用乘法口诀生成一个数列 {an}，规则为从 a1 开始顺次进行，每次将当前数字与后面一个数字相乘，将结果贴在数列末尾。如果结果不是 1 位数，则其每一位都应成为数列的一项。

要求：

输入格式：
输入在一行中给出 3 个整数，依次为 a1、a2 和 n，满足 0≤a1，a2≤9，0<n≤10³。
输出格式：
在一行中输出数列的前 n 项。数字间以 1 个空格分隔，行首尾不得有多余空格。
输入样例：

2 3 10

输出样例：

2 3 6 1 8 6 8 4 8 4

样例解释：
数列前 2 项为 2 和 3。从 2 开始，因为 2×3=6，所以第 3 项是 6。因为 3×6=18，所以第 4、5 项分别是 1、8。依次类推…… 最后因为第 6 项有 6×8=48，对应第 10、11 项应该是 4、8。而因为只要求输出前 10 项，所以在输出 4 后结束。

代码长度限制 16KB
时间限制 400ms
内存限制 64MB
栈限制 8192KB

代码：

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
int main()
{
    int a[10000];
    for(int i=0;i<2;i++)
    {
        scanf("%d",&a[i]);
    }
    int n;
    scanf("%d",&n);
    int x,y=2;
    for(int i=0;i<n;i++)
    {
        x=a[i]*a[i+1];
        if(x/10==0)
            a[y++]=x;
        else
        {
            a[y++]=x/10;
            a[y++]=x%10;
        }
        printf("%d",a[i]);
        if(i!=n-1)
            printf(" ");
    }
    return 0;
}

2 出栈序列的合法性

给定一个最大容量为 M 的堆栈，将 N 个数字按 1, 2, 3, …, N 的顺序入栈，允许按任何顺序出栈，则哪些数字序列是不可能得到的？例如给定 M=5、N=7，则我们有可能得到{ 1, 2, 3, 4, 5, 6, 7 }，但不可能得到{ 3, 2, 1, 7, 5, 6, 4 }。

要求：

输入格式：
输入第一行给出 3 个不超过 1000 的正整数：M（堆栈最大容量）、N（入栈元素个数）、K（待检查的出栈序列个数）。最后 K 行，每行给出 N 个数字的出栈序列。所有同行数字以空格间隔。
输出格式：
对每一行出栈序列，如果其的确是有可能得到的合法序列，就在一行中输出YES，否则输出NO。
输入样例：

5 7 5
1 2 3 4 5 6 7
3 2 1 7 5 6 4
7 6 5 4 3 2 1
5 6 4 3 7 2 1
1 7 6 5 4 3 2

输出样例：

YES
NO
NO
YES
NO

代码长度限制 16KB
时间限制 400ms
内存限制 64MB

代码：

#include<stdio.h>
int m,n,k;
int stack[1007];       //栈 
int top=0;             //栈顶下标 
int index1=1,index2=1;     //index1来表示1-n的数字 ，index2来表示数组b的下标 
int b[1007];           //存放出栈序列 
int main()
{
    scanf("%d%d%d",&m,&n,&k);
    while(k--)
    {
    	int flag=1; 
    	index1=1;index2=1;
    	top=0; 
    	int i;
    	for(i=1;i<=n;i++)
    	  scanf("%d",&b[i]);
    	while(1)
    	{
    		//判断给出的出栈序列如果和1到n增长顺序相同，那就是入栈一个元素，然后立即出栈。 
    		if(index1==b[index2])
    		{
    			index1++;
    			index2++;
			}
			//判断如果栈中有元素，然后栈顶元素也与此时的出栈序列元素相同，那么就继续出栈来判断 
			else if(top!=0&&stack[top-1]==b[index2])
			{
				top--;
				index2++; 
			}
			else
			{
				if(index1>n)break;  //已经判断结束，就跳出循环 
				stack[top]=index1;  //元素入栈 
				top++;
				index1++;
				if(top>=m) //
				{
					flag=0;
					break;
				}
			}
		}
		if(flag==0||top!=0)printf("NO\n");
		else printf("YES\n");
	}
	return 0;
}

3 表达式求值

给定一个中缀表达式，请编写程序计算该表达式的值。表达式包含+、-、*、\、^ 、(、)，所有运算均为二元运算，操作数均为正整数，但可能不止一位，不超过10位。运算结果为整数，值域为[−2³¹ ,2³¹ )。除法运算结果若为小数则进行截尾取整。若除法运算中除数为0，则输出INVALID。幂运算须自行实现，不允许调用pow等系统函数。
测试数据保证幂运算中指数为非负，底数不为0。

要求：

输入格式：
输入为多行，每行为一个长度不超过1000的字符串，表示中缀表达式。
输出格式：
对每个表达式输出一行：为一个整数（表达式的值）或为一个字符串INVALID。
输入样例：

5+(102)-6
8(999+1)
1+5/(1-1)
7*2^3

输出样例：

19
8000
INVALID
56

代码长度限制 16KB
时间限制 50ms
内存限制 64MB
栈限制 8192KB

代码：

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
int shuzi(char c)///判断输入的子串中的数字
{
    if('0'<=c&&c<='9')
        return 1;
    return 0;
}
int hanshu(int a,int b,char d)///分加减乘除四种情况输出返回值
{
    if(d=='+')
        return a+b;
    if(d=='-')
        return a-b;
    if(d=='*')
        return a*b;
    if(d=='/')
    {
        if(b!=0)
            return a/b;
        else
            return 'INVALID';
    }
    return 0;
}
int youxian(char m,char n)///判断运算符的优先级，便于计算
{
    int x=0,y=0;///设置初始优先级
    if(m=='+'||m=='-')
        x=1;
    if(m=='*'||m=='/')
        x=2;
    if(m=='(')
        x=3;
    if(n=='+'||n=='-')
        y=1;
    if(n=='*'||n=='/')
        y=2;
    if(n=='(')
        y=3;
    if(x>y)
        return 1;
    return 0;
}
int main()
{
    char s[310];///输入的字符串
    int num[310]={0};///设置的数字栈，并进行初始化
    char op[310]={0};///设置的运算符栈，并进行初始化
    gets(s);
    int a=0,b=0;
    int i=0,l=strlen(s);
    while(i<l)
    {
        if(shuzi(s[i]))///判断数字，入栈
        {
            while(shuzi(s[i]))
            {
                num[a]=num[a]*10+s[i++]-'0';
            }
            a++;
            continue;
        }
        else///不是数字时，是括号
        {
            if(s[i]=='(')
            {
                op[b++]=s[i];
            }
            else if(s[i]==')')
            {
                while(op[b-1]!='(')
                {
                    num[a-2]=hanshu(num[a-2],num[a-1],op[b-1]);
                    num[a-1]=0;///栈顶元素清零
                    a--;///数字栈减少一层
                    b--;///符号栈减少一层
                }
                b--;
            }
            else///是运算符时
            {
                if(b==0)
                {
                    op[b++]=s[i];
                }
                else if(youxian(s[i],op[b-1]))
                {
                    op[b++]=s[i];
                }
                else
                {
                    while(!youxian(s[i],op[b-1]))
                    {
                        if(op[b-1]=='(')
                        {
                            break;
                        }
                        num[a-2]=hanshu(num[a-2],num[a-1],op[b-1]);
                        num[a-1]=0;
                        a--;
                        b--;
                        if(b==0)
                            break;
                    }
                    op[b++]=s[i];
                }
            }
        }
        i++;
    }
    while(a!=1&&b>0)///一直循环直到两个栈中无元素
    {
        num[a-2]=hanshu(num[a-2],num[a-1],op[b-1]);
        a--;
        b--;
    }
    printf("%d",num[0]);
}

4 银行业务队列简单模拟

设某银行有A、B两个业务窗口，且处理业务的速度不一样，其中A窗口处理速度是B窗口的2倍 —— 即当A窗口每处理完2个顾客时，B窗口处理完1个顾客。给定到达银行的顾客序列，请按业务完成的顺序输出顾客序列。假定不考虑顾客先后到达的时间间隔，并且当不同窗口同时处理完2个顾客时，A窗口顾客优先输出。

要求：

输入格式：
输入为一行正整数，其中第1个数字N(≤1000)为顾客总数，后面跟着N位顾客的编号。编号为奇数的顾客需要到A窗口办理业务，为偶数的顾客则去B窗口。数字间以空格分隔。
输出格式：
按业务处理完成的顺序输出顾客的编号。数字间以空格分隔，但最后一个编号后不能有多余的空格。
输入样例：

8 2 1 3 9 4 11 13 15

输出样例：

1 3 2 9 11 4 13 15

代码长度限制 16KB
时间限制 400ms
内存限制 64MB

代码：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
int main()
{
    int N;
    scanf("%d",&N);
    int A[1000],B[1000],a=0,b=0;
    for(int i=0;i<N;i++)
    {
        int c;
        scanf("%d",&c);///输入顾客
        if(c%2!=0)///奇数在A数组中
            A[++a]=c;
        if(c%2==0)///偶数在B数组中
            B[++b]=c;
    }
    int kong=0,x=1,y=1;///设置空格，两个数组的下标
    while(x<=a||y<=b)///没到该数组中的最后一人前，一直循环
    {
        if(x<=a)///A组完成两人，B组才完成一人，输出两次A，再输出一次B
        {
            if(kong++)
                printf(" ");
            printf("%d",A[x++]);
        }
        if(x<=a)
        {
            if(kong++)
                printf(" ");
            printf("%d",A[x++]);
        }
        if(y<=b)
        {
            if(kong++)
                printf(" ");
            printf("%d",B[y++]);
        }
    }
    return 0;
}

5 六度空间

“六度空间”理论又称作“六度分隔（Six Degrees of Separation）”理论。这个理论可以通俗地阐述为：“你和任何一个陌生人之间所间隔的人不会超过六个，也就是说，最多通过五个人你就能够认识任何一个陌生人。”
假如给你一个社交网络图，请你对每个节点计算符合“六度空间”理论的结点占结点总数的百分比。

要求：

输入格式：
输入第1行给出两个正整数，分别表示社交网络图的结点数N（1<N≤10³，表示人数）、边数M（≤33×N，表示社交关系数）。随后的M行对应M条边，每行给出一对正整数，分别是该条边直接连通的两个结点的编号（节点从1到N编号）。
输出格式：
对每个结点输出与该结点距离不超过6的结点数占结点总数的百分比，精确到小数点后2位。每个结节点输出一行，格式为“结点编号:（空格）百分比%”。
输入样例：

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

输出样例：

1: 70.00%
2: 80.00%
3: 90.00%
4: 100.00%
5: 100.00%
6: 100.00%
7: 100.00%
8: 90.00%
9: 80.00%
10: 70.00%

代码长度限制 16KB
时间限制 2500ms
内存限制 64MB

代码：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct Queue///设置队列
{
    int D[10000];
    int left,right;
}Q;
void InQueue(int x)///队列的插入
{
    Q.D[Q.right]=x;///右侧插入
    Q.right++;
}
int OutQueue()///队列的删除
{
    int x=Q.D[Q.left];///左侧删除
    Q.left++;
    return x;
}
int BFS(int **G, int v,int V)///遍历
{
    int Visited[10000];///设置遍历访问数组
    int c=1,level=0,last=v,tail;
    for(int i=0;i<V;i++)
    {
        Visited[i]=0;///遍历节点
    }
    Q.left=Q.right=0;///队列为空时
    Visited[v]=1;
    InQueue(v);///插入
    while(Q.left<Q.right)
    {
        int k=OutQueue();
        for(int i=0;i<V;i++)
        {
            if(G[k][i]&&Visited[i]==0)
            {
                Visited[i]=1;
                InQueue(i);
                c++;
                tail=i;
            }
        }
        if(k==last)
        {
            level++;
            last=tail;
        }
        if(level==6)
            break;
    }
    return c;
}
int main()///主函数输出
{
    double V,E;
    scanf("%lf %lf",&V,&E);
    int **G =(int **)malloc((V+1)*sizeof(int*));
    int e1,e2;
    for(int i=0;i<V;i++)
    {
        G[i]=(int *)malloc((V+1)*sizeof(int));
        memset(G[i],0,sizeof(int)*(V+1));///将数组初始化
    }
    for(int i=0;i<E;i++)
    {
        scanf("%d %d",&e1,&e2);
        G[e1-1][e2-1]=1;
        G[e2-1][e1-1]=1;
    }
    for(int i=0;i<V;i++)
    {
        double c=BFS(G,i,V);
        printf("%d: %.2lf%%\n",i+1,100.0*c/V);
    }
    return 0;
}

等待另一个根号二

关注

30
点赞
踩
33

收藏

觉得还不错? 一键收藏
1
评论
PTA-暑期学校-Day8（C语言）

设某银行有A、B两个业务窗口，且处理业务的速度不一样，其中A窗口处理速度是B窗口的2倍 —— 即当A窗口每处理完2个顾客时，B窗口处理完1个顾客。假定不考虑顾客先后到达的时间间隔，并且当不同窗口同时处理完2个顾客时，A窗口顾客优先输出。例如给定 M=5、N=7，则我们有可能得到{ 1, 2, 3, 4, 5, 6, 7 }，但不可能得到{ 3, 2, 1, 7, 5, 6, 4 }。表达式包含+、-、*、\、^ 、(、)，所有运算均为二元运算，操作数均为正整数，但可能不止一位，不超过10位。
复制链接

扫一扫