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

等待另一个根号二

于 2024-01-27 16:43:01 发布

阅读量623

点赞数 10

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

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

版权

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

9 篇文章 0 订阅

订阅专栏

1 交换最小值和最大值

编写程序，先将输入的一系列整数中的最小值与第一个数交换，然后将最大值与最后一个数交换，最后输出交换后的序列。
注意：最大值、最小值唯一。

要求：

输入格式：
输入在第一行中给出一个正整数N(<=10)，第二行给出N个整数，数字间以空格分隔。
输出格式：
在一行中顺序输出交换后的序列，每个整数后跟一个空格。
输入样例：

5
8 2 5 1 4

输出样例：

1 2 5 4 8

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

代码：

#include <stdio.h>
#include <stdlib.h>
int main()
{
    int N;
    scanf("%d",&N);
    int i,a[10],temp;
    for(i=0;i<N;i++)
    {
        scanf("%d",&a[i]);
    }
    int min=a[0],max=a[0];
    for(i=0;i<N;i++)
    {
        if(a[i]>max)
        {
            max=a[i];
        }
        if(a[i]<min)
        {
            min=a[i];
        }
    }
    for(i=0;i<N;i++)
    {
        if(a[i]==max)
        {
            temp=a[N-1];
            a[N-1]=max;
            a[i]=temp;
        }
    }
    for(i=0;i<N;i++)
    {
        if(min==a[i])
        {
            temp=a[0];
            a[0]=min;
            a[i]=temp;
        }
    }
    for(i=0;i<N;i++)
    {
        printf("%d ",a[i]);
    }
    return 0;
}

2 字符串字母大小写转换

编写程序，对一个以“#”结束的字符串，将其小写字母全部转换成大写字母，把大写字母全部转换成小写字母，其他字符不变输出。

要求：

输入格式：
输入一个以“#”结束的字符串（不超过30个字符）。
输出格式：
在一行中输出大小写转换后的结果字符串。
输入样例：

Hello World！123#

输出样例：

hELLO wORLD！123

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

代码：

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int main()
{
    int i,j;
    char a[10010];
    gets(a);
    int k = strlen(a);
    a[k-1] = '\0';
    for(i=0; a[i]!='\0'; i++)
    {
        if(((a[i]>='a'&&a[i]<='z') || (a[i]>='A'&&a[i]<='Z')) ==0)
            continue;
        else if(a[i]>='a'&&a[i]<='z')
            a[i]-=32;
        else
            a[i]+=32;
    }
    puts(a);
    return 0;
}

3 输出数组元素

编写程序，对顺序读入的n个整数，顺次计算后项减前项之差，并按每行三个元素的格式输出结果。

要求：

输入格式：
输入的第一行给出正整数n(1<n<=10)。随后一行给出n个整数，其间以空格分隔。
输出格式：
顺次计算后项减前项之差，并按每行三个元素的格式输出结果。数字间空一格，行末不得有多余空格。
输入样例：

10
5 1 7 14 6 36 4 28 50 100

输出样例：

-4 6 7
-8 30 -32
24 22 50

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

代码：

#include<stdio.h>
#include<string.h>
int main()
{
    int N;
    scanf("%d",&N);
    int a[1000],x;
    for(int i=0;i<N;i++)
    {
        scanf("%d",&a[i]);
    }
    for(int i=1;i<N;i++)
    {
        x=a[i]-a[i-1];
        if(i==N-1||i%3==0)
            printf("%d",x);
        else
            printf("%d ",x);
        if(i%3==0&&i!=N-1)
            printf("\n");
    }
    return 0;
}

4 查找整数

从输入的N个整数中查找给定的X。如果找到，输出X的位置（从0开始数）；如果没有找到，输出“Not Found”。

要求：

输入格式：
输入在第一行中给出两个正整数N(<=20)和X，第二行给出N个整数。数字均不超过长整型，其间以空格分隔。
输出格式：
在一行中输出X的位置，或者“Not Found”。
输入样例1：

5 7
3 5 7 1 9

输出样例1：

2

输入样例2：

5 7
3 5 8 1 9

输出样例2：

Not Found

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

代码：

#include<stdio.h>
#include<stdlib.h>
int main()
{
    int N,X;
    scanf("%d %d",&N,&X);
    int a[20],i;
    for(i=0;i<N;i++)
    {
        scanf("%d",&a[i]);
        if(a[i]==X)
            break;
    }
    if(i==N)
            printf("Not Found");
    else
            printf("%d\n",i);
    return 0;
}

5 个位数统计

在这里插入图片描述

要求：

输入格式：
每个输入包含1个测试用例，即一个不超过1000位的正整数N。
输出格式：
对N中每一种不同的各位数字，以D:M的格式在一行中输出该位数字D及其在N中出现的次数M。要求按D的升序输出。
输入样例：

100311

输出样例：

0:2
1:3
3:1

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

代码：

#include<stdio.h>
#include<string.h>
#include<math.h>
int main()
{
    char a[1000];
    scanf("%s",&a);
    int i,b[10]={0,0,0,0,0,0,0,0,0,0};
    for(i=0;i<strlen(a);i++)
    {
        if(a[i]=='0') b[0]++;
        if(a[i]=='1') b[1]++;
        if(a[i]=='2') b[2]++;
        if(a[i]=='3') b[3]++;
        if(a[i]=='4') b[4]++;
        if(a[i]=='5') b[5]++;
        if(a[i]=='6') b[6]++;
        if(a[i]=='7') b[7]++;
        if(a[i]=='8') b[8]++;
        if(a[i]=='9') b[9]++;
    }
    for(i=0;i<10;i++)
        if(b[i]!=0)
            printf("%d:%d\n",i,b[i]);
    return 0;
}

6 检查密码

帮助某网站的用户注册模块写一个密码合法性检查的小功能。该网站要求用户设置的密码必须由不少于6个字符组成，并且只能有英文字母、数字和小数点==.==，还必须既有字母也有数字。

要求：

输入格式：
输入第一行给出一个正整数N(<=100)，随后N行，每行给出一个用户设置的密码，为不超过80个字符的非空字符串，以回车结束。
注意：不存在只有小数点的输入。
输出格式：
对每个用户的密码，在一行中输出系统反馈信息分以下5种：
如果密码合法，输出Your password is wan mei.；
如果密码太短，不论合法与否，都输出Your password is tai duan le.；
如果密码长度合法，但存在不合法字符，则输出Your password is tai luan le.；
如果密码长度合法，但只有字母没有数字，则输出Your password needs shu zi.；
如果密码长度合法，但只有数字没有字母，则输出Your password needs zi mu.。
输入样例：

5
123s
zheshi.wodepw
1234.5678
WanMei23333
pass*word.6

输出样例：

Your password is tai duan le.
Your password needs shu zi.
Your password needs zi mu.
Your password is wan mei.
Your password is tai luan le.

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

代码：

#include<stdio.h>
#include<string.h>
int main()
{
    int b[110];
    char a[110][81];
    int N;
    scanf("%d",&N);
    getchar();
    for(int i=0;i<N;i++)
    {
        b[i]=0;
        gets(a[i]);
        if(strlen(a[i])<6)///长度小于六时，不论合法与否
        {
            b[i]=0;
            continue;
        }
        else///判断是否合法
        {
            b[i]=CASE(a[i]);
            continue;
        }
    }
    for(int i=0;i<N;i++)
    {
        if(b[i]==0)
            printf("Your password is tai duan le.\n");///长度小于六时
        if(b[i]==1)
            printf("Your password is wan mei.\n");///密码合法
        if(b[i]==2)
            printf("Your password is tai luan le.\n");///有不合法字符存在
        if(b[i]==3)
            printf("Your password needs shu zi.\n");///缺少数字
        if(b[i]==4)
            printf("Your password needs zi mu.\n");///缺少字母
    }
    return 0;
}
int CASE(char a[81])
{
    int zimu=0,shuzi=0,other=0;
    int l=strlen(a);
    for(int i=0;i<l;i++)
    {
        if((a[i]>='A'&&a[i]<='Z')||(a[i]>='a'&&a[i]<='z'))///字母不论大小写
            zimu++;
        else if(a[i]>='0'&&a[i]<='9')///数字
            shuzi++;
        else if(a[i]=='.')///合法符号
            continue;
        else other++;///不合法符号
    }
    if(other!=0)///存在不合法符号
        return 2;
    else if(zimu!=0&&shuzi==0)///无字母
        return 3;
    else if(shuzi!=0&&zimu==0)无数字
        return 4;
    else return 1;///密码合法
}

7 数组循环左移

实现一个对数组进行循环左移的简单函数：一个数组a中存有n(>0)个整数，在不允许使用另外数组的前提下，将每个整数循环向左移m(>=0)个位置（最前面的m个数循环移至最后面的m个位置）。如果还需要考虑程序移动数据的次数尽量少，要如何设计移动的方法？

要求：

输入格式：
输入第一行给出正整数n(<=100)和整数m(>=0)；第二行给出n个整数，其间以空格分隔。
输出格式：
在一行中输出循环左移m位以后的整数序列，之间用空格分隔，序列结尾不能有多余空格。
输入样例：

8 3
1 2 3 4 5 6 7 8

输出样例：

4 5 6 7 8 1 2 3

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

代码：

#include<stdio.h>
#include<stdlib.h>
int main()
{
    int n,m,x;
    scanf("%d %d",&n,&m);
    int a[n];
    if(m>n)
        m=m%n;
    if(m<=n)
    {
        for(int i=n-m;i<n;i++)///从左移后的第一个开始
            scanf("%d ",&a[i]);
        for(int i=0;i<n-m;i++)///接着从最初开始
            scanf("%d ",&a[i]);
        for(int i=0;i<n;i++)///输出所有
        {
		    printf("%d",a[i]);
		    if(i!=n-1)
        	    printf(" ");
        }
    }
    return 0;
}

8 冒泡法排序

将N个整数按从小到大排序的冒泡排序法：从头到尾比较相邻两个元素，如果前面的元素大于其紧随的后面元素，则交换它们。通过一遍扫描，则最后一个元素必定是最大的元素。然后用同样的方法对前N−1个元素进行第二遍扫描。依此类推，最后只需处理两个元素，就完成了对N个数的排序。
要求对任意给定的K(<N)，输出扫描完第K遍后的中间结果数列。

要求：

输入格式：
输入在第一行中给出N和K(1≤K<N≤100)，在第二行中给出N个待排序的整数，数字间以空格分隔。
输出格式：
在一行中输出冒泡排序法扫描完第K遍后的中间结果数列，数字间以空格分隔，但末尾不得有多余空格。
输入样例：

6 2
2 3 5 1 6 4

输出样例：

2 1 3 4 5 6

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

代码：

#include<stdio.h>
#include<math.h>
#include<string.h>
int main()
{
    int a[100],TEMP;
    int N,K;
    scanf("%d %d",&N,&K);
    for(int i=0;i<N;i++)
    {
        scanf("%d",&a[i]);
    }
    for(int i=0;i<K;i++)
    {
        for(int j=0;j<(N-i-1);j++)
        if((a[j]>a[j+1]))
        {
            TEMP=a[j];
            a[j]=a[j+1];
            a[j+1]=TEMP;
        }
    }
    for(int i=0;i<N-1;i++)
    {
        printf("%d ",a[i]);
    }
    printf("%d",a[N-1]);
    return 0;
}

9 删除重复字符

编写程序，将给定字符串去掉重复的字符后，按照字符ASCII码顺序从小到大排序后输出。

要求：

输入格式：
输入是一个以回车结束的非空字符串（少于80个字符）。
输出格式：
输出去重排序后的结果字符串。
输入样例：

ad2f3adjfeainzzzv

输出样例：

23adefijnvz

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

代码：

#include <stdio.h>
#include <string.h>
int main()
{
    char a[100],TEMP;
    gets(a);
    int l=strlen(a),x;
    for(int i=0;i<l;i++)///进行排序
    {
        x=i;
        for(int j=i+1;j<l;j++)
        {
            if(a[j]<a[x])
            {
                x=j;
            }
        }
        if(x!=i)///交换位置
        {
            TEMP=a[i];
            a[i]=a[x];
            a[x]=TEMP;
        }
    }
    printf("%c",a[0]);
    for(int i=1;i<l;i++)///不重复输出，即删除重复字符
    {
        if(a[i]!=a[i-1])
        {
            printf("%c",a[i]);
        }
    }
    return 0;
}

10 矩阵A乘以B

给定两个矩阵A和B，计算它们的乘积矩阵AB。只有规模匹配的矩阵才可以相乘。即若A有Ra行、Ca列，B有Rb行、Cb列，则只有Ca与Rb相等时，两个矩阵才能相乘。

要求：

输入格式：
输入先后给出两个矩阵A和B。对于每个矩阵，首先在一行中给出其行数R和列数C，随后R行，每行给出C个整数，以1个空格分隔，且行首尾没有多余的空格。输入保证两个矩阵的R和C都是正数，并且所有整数的绝对值不超过100。
输出格式：
若输入的两个矩阵的规模是匹配的，则按照输入的格式输出乘积矩阵AB，否则输出Error: Ca != Rb，其中Ca是A的列数，Rb是B的行数。
输入样例1：

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

输出样例1：

2 4
20 22 24 16
53 58 63 28

输入样例2：

3 2
38 26
43 -5
0 17
3 2
-11 57
99 68
81 72

输出样例2：

Error: 2 != 3

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

代码：

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int main()
{
    int Ra,Ca;
    scanf("%d %d",&Ra,&Ca);///输入矩阵A
    int A[Ra][Ca];
    for(int i=0;i<Ra;i++)
    {
        for(int j=0;j<Ca;j++)
        {
            scanf("%d",&A[i][j]);
        }
    }
    int Rb,Cb;
    scanf("%d %d",&Rb,&Cb);///输入矩阵B
    int B[Rb][Cb];
    for(int i=0;i<Rb;i++)
    {
        for(int j=0;j<Cb;j++)
        {
            scanf("%d",&B[i][j]);
        }
    }
    if(Ca!=Rb)///矩阵模式非匹配时输出
    {
        printf("Error: %d != %d",Ca,Rb);
    }
    else///矩阵匹配相乘
    {
        int S[Ra][Cb];
        memset(S,0,sizeof(S));
        for(int i=0;i<Ra;i++)
        {
            for(int j=0;j<Cb;j++)
            {
                for(int k=0;k<Ca;k++)
                {
                    S[i][j]=S[i][j]+A[i][k]*B[k][j];///合成矩阵
                }
            }
        }
        printf("%d %d\n",Ra,Cb);
        for(int i=0;i<Ra;i++)
        {
            printf("%d",S[i][0]);
            for(int j=1;j<Cb;j++)
            {
                printf(" %d",S[i][j]);
            }
            if(i!=Ra-1)
            {
                printf("\n");
            }
        }
    }
    return 0;
}

11 福到了

“福”字倒着贴，寓意“福到”。不论到底算不算民俗，本题且请你编写程序，把各种汉字倒过来输出。这里要处理的每个汉字是由一个N × N的网格组成的，网格中的元素或者为字符==@==或者为空格。而倒过来的汉字所用的字符由裁判指定。

要求：

输入格式：
输入在第一行中给出倒过来的汉字所用的字符、以及网格的规模 N（不超过100的正整数），其间以1个空格分隔；随后N行，每行给出N个字符，或者为==@==或者为空格。
输出格式：
输出倒置的网格，如样例所示。但是，如果这个字正过来倒过去是一样的，就先输出bu yong dao le，然后再用输入指定的字符将其输出。
输入样例1：

输出样例1：

输入样例2：

输出样例2：

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

代码：

#include<stdio.h>
#include<string.h>
int main()
{
    char c;int n;
    scanf("%c %d",&c,&n);
    getchar();
    char a[100][100];
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
            scanf("%c",&a[i][j]);
        }
        getchar();
    }
    int flag=0;
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
            if(a[i][j]!=a[n-i-1][n-j-1])
            {
                flag=1;
            }
        }
    }
    if(!flag)
    {
        printf("bu yong dao le\n");
    }
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
            if(a[n-i-1][n-j-1]!=' ')
            {
                printf("%c",c);
            }
            else
            {
                printf(" ");
            }
        }
        printf("\n");
    }
    return 0;
}

12 谷歌的招聘

从任一给定的长度为 L 的数字中，找出最早出现的 K 位连续数字所组成的素数。

要求：

输入格式：
输入在第一行给出2个正整数，分别是L（不超过1000的正整数，为数字长度）和K（小于10的正整数）。接下来一行给出一个长度为L的正整数N。
输出格式：
在一行中输出N中最早出现的K位连续数字所组成的素数。如果这样的素数不存在，则输出404。注意，原始数字中的前导零也计算在位数之内。例如在200236中找4位素数，0023算是解；但第一位2不能被当成0002输出，因为在原始数字中不存在这个2的前导零。
输入样例1：

20 5
23654987725541023819

输出样例1：

49877

输入样例2：

10 3
2468001680

输出样例2：

404

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

代码：

#include <stdio.h>
#include <stdlib.h>
#include<string.h>
#include<math.h>
int main()
{
    int L,K,N;
    scanf("%d %d",&L,&K);
    if(K==0)
    {
        printf("404");
        return 0;
    }
    int flag=0;
    char *a,*dest;///目标字符数组
    dest=(char *)malloc((K+1)*sizeof(char));///不知道具体位置，进行动态内存分配.
    a=(char *)malloc((L+1)*sizeof(char));
    scanf("%s",a);
    for(int i=0;i<=L-K;i++)
    {
        strncpy(dest,a+i,K);///(目标,源数组,长度)将指定长度的字符串复制到字符数组中.
        dest[K]='\0';
        N=atoi(dest);///将字符串变为数字.
        if(1==Prime(N))///判断素数
        {
            printf("%s",dest);///输出素数
            flag=1;
            break;
        }
    }
    if(flag==0)
    {
        printf("404");///没有该素数时,输出
    }
    return 0;
}
int Prime(int N)///求素数
{
    if(N==1)
    {
        return 0;
    }
    for(int i=2;i<=sqrt(N);i++)
    {
        if(N%i==0)
        {
            return 0;
        }
    }
    return 1;
}

13 彩虹瓶

假设彩虹瓶里要按顺序装 N 种颜色的小球（不妨将顺序就编号为 1 到 N）。现在工厂里有每种颜色的小球各一箱，工人需要一箱一箱地将小球从工厂里搬到装填场地。如果搬来的这箱小球正好是可以装填的颜色，就直接拆箱装填；如果不是，就把箱子先码放在一个临时货架上，码放的方法就是一箱一箱堆上去。当一种颜色装填完以后，先看看货架顶端的一箱是不是下一个要装填的颜色，如果是就取下来装填，否则去工厂里再搬一箱过来。
如果工厂里发货的顺序比较好，工人就可以顺利地完成装填。例如要按顺序装填 7 种颜色，工厂按照 7、6、1、3、2、5、4 这个顺序发货，则工人先拿到 7、6 两种不能装填的颜色，将其按照 7 在下、6 在上的顺序堆在货架上；拿到 1 时可以直接装填；拿到 3 时又得临时码放在 6 号颜色箱上；拿到 2 时可以直接装填；随后从货架顶取下 3 进行装填；然后拿到 5，临时码放到 6 上面；最后取了 4 号颜色直接装填；剩下的工作就是顺序从货架上取下 5、6、7 依次装填。
但如果工厂按照 3、1、5、4、2、6、7 这个顺序发货，工人就必须要愤怒地折腾货架了，因为装填完 2 号颜色以后，不把货架上的多个箱子搬下来就拿不到 3 号箱，就不可能顺利完成任务。
另外，货架的容量有限，如果要堆积的货物超过容量，工人也没办法顺利完成任务。例如工厂按照 7、6、5、4、3、2、1 这个顺序发货，如果货架够高，能码放 6 只箱子，那还是可以顺利完工的；但如果货架只能码放 5 只箱子，工人就又要愤怒了……
请你判断一下，工厂的发货顺序能否让工人顺利完成任务。

要求：

输入格式：
输入首先在第一行给出 3 个正整数，分别是彩虹瓶的颜色数量 N(1<N≤10³)、临时货架的容量 M(<N)、以及需要判断的发货顺序的数量K。
随后K行，每行给出N个数字，是1到N的一个排列，对应工厂的发货顺序。
一行中的数字都以空格分隔。
输出格式：
对每个发货顺序，如果工人可以愉快完工，就在一行中输出YES；否则输出NO。
输入样例：

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

输出样例：

YES
NO
NO

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

代码：

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int main()
{
    
    int m,n,k;
    scanf("%d %d %d",&n,&m,&k);
    int a[1000],b[1000]={0},x,y,j;
    for(int i=0;i<k;i++)
    {
        for(int j=0;j<n;j++)
            scanf("%d",&a[j]);
        j=0;
        x=0;
        y=1;
        while(y<n)
        {
            if(b[j]!=y)
            {
                if(a[x]!=y)
                    b[++j]=a[x++];
                else
                {
                    x++;
                    y++;
                }
            }
            else if(j!=0)
            {
                y++;
                j--;
            }
            if(j>m)
            {
                printf("NO\n");
                break;
            }
            if(x>n)
            {
                printf("NO\n");
                break;
            }
        }
        if(y==n)
            printf("YES\n");
    }
    return 0;
}

14 列车调度

火车站的列车调度铁轨的结构如下图所示。
在这里插入图片描述
两端分别是一条入口（Entrance）轨道和一条出口（Exit）轨道，它们之间有N条平行的轨道。每趟列车从入口可以选择任意一条轨道进入，最后从出口离开。在图中有9趟列车，在入口处按照{8，4，2，5，3，9，1，6，7}的顺序排队等待进入。如果要求它们必须按序号递减的顺序从出口离开，则至少需要多少条平行铁轨用于调度？

要求：

输入格式：
输入第一行给出一个整数N(2≤N≤10⁵)，下一行给出从1到N的整数序号的一个重排列。数字间以空格分隔。
输出格式：
在一行中输出可以将输入的列车按序号递减的顺序调离所需要的最少的铁轨条数。
输入样例：

9
8 4 2 5 3 9 1 6 7

输出样例：

4

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

代码：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main()//二分法
{
	int n;
	scanf("%d",&n);
	int a[100000];
	int i,m,L=0;
	for(i=0;i<n;i++)
    {
		scanf("%d",&m);
		if(L==0||a[L-1]<m)
        {
			a[L++]=m;
		}
		else
		{
			int high=L-1,low=0,mid;
			while(low<=high)
			{
				mid=(low+high)/2;
				if(a[mid]>m)
				{
					high=mid-1;
				}else
				{
					low=mid+1;
				}
			}
			a[low]=m;
		}
	}
	printf("%d",L);
	return 0;
}

15 包装机

一种自动包装机的结构如图 1 所示。首先机器中有 N 条轨道，放置了一些物品。轨道下面有一个筐。当某条轨道的按钮被按下时，活塞向左推动，将轨道尽头的一件物品推落筐中。当 0 号按钮被按下时，机械手将抓取筐顶部的一件物品，放到流水线上。图 2 显示了顺序按下按钮 3、2、3、0、1、2、0 后包装机的状态。
图1 自动包装机的结构

图2 顺序按下按钮3、2、3、0、1、2、0后包装机的状态
在这里插入图片描述
一种特殊情况是，因为筐的容量是有限的，当筐已经满了，但仍然有某条轨道的按钮被按下时，系统应强制启动 0 号键，先从筐里抓出一件物品，再将对应轨道的物品推落。此外，如果轨道已经空了，再按对应的按钮不会发生任何事；同样的，如果筐是空的，按 0 号按钮也不会发生任何事。
现给定一系列按钮操作，请你依次列出流水线上的物品。

要求：

输入格式：
输入第一行给出3个正整数N(≤100)、M(≤1000)和Smax(≤100)，分别为轨道的条数（于是轨道从1到N编号）、每条轨道初始放置的物品数量、以及筐的最大容量。随后 N 行，每行给出 M 个英文大写字母，表示每条轨道的初始物品摆放。
最后一行给出一系列数字，顺序对应被按下的按钮编号，直到 −1 标志输入结束，这个数字不要处理。数字间以空格分隔。题目保证至少会取出一件物品放在流水线上。
输出格式：
在一行中顺序输出流水线上的物品，不得有任何空格。
输入样例：

3 4 4
GPLT
PATA
OMSA
3 2 3 0 1 2 0 2 2 0 -1

输出样例：

MATA

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

代码：

#include<stdio.h>
#include<string.h>
int main()
{
	int i,init=0,num;//篮子起始值，轨道编号
	int l,side,max;//轨道数，轨道大小，篮子大小
	scanf("%d %d %d",&l,&side,&max);
	int b[l];
	static int chushi[1000];//数组初始化
	char a[l][side+1];
	char d[max];//放不符合东西的篮子
	getchar();
	for(i=0;i<l;i++)
	{
		gets(a[i]);
		b[i]=strlen(a[i]); //使初始值相同
	}
    while(1)
	{
		scanf("%d",&num);
		if(num==-1)break;
		else if(num==0)//从篮子里取一个
		{
			if(init!=0)
			{
				printf("%c",d[init-1]);
				init--;
			}
		}
		else if(num>=1)
		{
			num=num-1;
			if(b[num]!=0)//轨道有东西
			{
			   if(init>=max)//超出篮子大小
				{
					printf("%c",d[init-1]);//先拿一个
					init--;
					d[init]=a[num][chushi[num]];//再放一个
					init++;
				}
			else if(init<max)//小于篮子大小，直接放
				{
					d[init]=a[num][chushi[num]];
					init++;
				}
			chushi[num]++;//下一个货物
            b[num]--;//轨道上物品数减一
			}
		}
	}
	return 0;
}

等待另一个根号二

关注

10
点赞
踩
10

收藏

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

例如要按顺序装填 7 种颜色，工厂按照 7、6、1、3、2、5、4 这个顺序发货，则工人先拿到 7、6 两种不能装填的颜色，将其按照 7 在下、6 在上的顺序堆在货架上；一种特殊情况是，因为筐的容量是有限的，当筐已经满了，但仍然有某条轨道的按钮被按下时，系统应强制启动 0 号键，先从筐里抓出一件物品，再将对应轨道的物品推落。在图中有9趟列车，在入口处按照{8，4，2，5，3，9，1，6，7}的顺序排队等待进入。这里要处理的每个汉字是由一个N × N的网格组成的，网格中的元素或者为字符==@==或者为空格。
复制链接

扫一扫