浙大PAT考试1013~1016(最伤的一次。。)

最新推荐文章于 2021-04-09 11:45:01 发布
最新推荐文章于 2021-04-09 11:45:01 发布
阅读量4.6k 收藏 2
点赞数 2
分类专栏： 浙大PAT考试甲级 文章标签： PAT
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/coraline_m/article/details/35857381
版权


我能说我1016WA了几天都不得最后还是拿别人代码交的么。。。

真心找不到那个神数据。。。


自己把整个程序的流程都画出来了，仔细推敲是木有问题的啊。。。


题目地址：点击打开链接


先从1013开始介绍。

题目大意：给你n个城市,m条路，k个询问，每次询问，是如果没有城市q1，，，qk其他城市链接在一起至少需要多少条路。简单的并查集问题。对节点qi不管，其他的点用并查集，我们所要求的就是有多少个分量，ans个分量则需要ans-1条路即可，详见代码：

AC代码：

#include<iostream>
#include<cstdio>
#include<cmath>
using namespace std;
const int maxn=1005;

struct node
{
    int x;
    int y;
}nod[maxn*maxn];

int fa[maxn];

void init()
{
    for(int i=1;i<=1000;i++)
        fa[i]=i;
}

int find1(int p)
{
    if(fa[p]!=p) fa[p]=find1(fa[p]);
    return fa[p];
}

void merge1(int p,int q)
{
    p=find1(p);
    q=find1(q);
    if(p!=q)
        fa[p]=q;
}

int main()
{
    int n,m,k;
    int i;
    while(cin>>n>>m>>k)
    {
        for(i=0;i<m;i++)
            scanf("%d%d",&nod[i].x,&nod[i].y);

        int cur;
        while(k--)
        {
            scanf("%d",&cur);
            int res=0;

            init();
            for(i=0;i<m;i++)
            {
                int p,q;
                p=nod[i].x,q=nod[i].y;
                if(p==cur||q==cur) continue;
                merge1(p,q);
            }
            for(i=1;i<=n;i++)
            {
                if(i==cur) continue;
                if(fa[i]==i) res++;
            }

            printf("%d\n",res-1);
        }
    }
    return 0;
}

/*
3 2 3
1 2
1 3
1 2 3
*/

1014：

题目大意：题目有点麻烦，意思是在取钱之类的背景下。。有n个窗口，每个窗口黄线里面最多容下的人数m，k个客户，q个查询。然后依次给出你k个客户的在柜台的处理时间，然后q个查询，每次查询编号为qi的客户处理完之后的时间。时间是08：00开始，17:00结束。

注意，这里有个bug，17：00结束是如果你在17：00之前还在柜台前面，就会被处理。

解题思路：最开始我们先把队伍一个一个排好，因为题目说的意思是每次都会排在最少人数的队列中，如果队列人数有一样的，选编号小的。那么我们最开始处理的时候就先把n*m容量之类的排好，一个一个按着队列排，然后出一个进一个，依次模拟，详见代码：

AC代码：

#include<iostream>
#include<cstdio>
#include<cmath>
#include<queue>
#include<cstring>
using namespace std;

int n,m,k,peo,ccnt;

struct node
{
    int t;
    int index;
} nod[1005];

queue <node> mq[25];
int res[1005];
int mp[25];

void debug()
{
    for(int i=1; i<=2; i++)
    {
        node x=mq[i].front();
        cout<<x.t<<" ";
        mq[i].pop();
        x=mq[i].front();
        cout<<x.t<<endl;
    }
}

void init()   //初始化，先预先站队
{
    int i,j;
    for(int i=1;i<=1000;i++)
        res[i]=10000;
    for(i=1; i<=20; i++)
    {
        while(!mq[i].empty())
            mq[i].pop();
    }

    int cnt=0;
    for(i=1; i<=k; i+=n)
    {
        for(j=0; j<n; j++)
        {
            if(cnt==n*m)
            {
                //debug();
                peo=cnt+1;
                return;
            }
            mq[j+1].push(nod[i+j]);
            cnt++;
        }
    }

    peo=cnt+1;   //peo代表下一个排队人的编号
    return;
}

void resolve()  //时间到了16:59，只有reserved的人才可以完成交易
{
    int i;
    for(i=1; i<=n; i++)
    {
        if(!mq[i].empty())
        {
            node x=mq[i].front();
            res[x.index]=ccnt+mp[i];
        }
    }
    return;
}

void solve()
{
    ccnt=1;

    for(int i=1; i<=n; i++)
    {
        if(!mq[i].empty())
        {
            node x=mq[i].front();
            mp[i]=x.t;
        }
    }

    while(1)
    {
        if(ccnt==540)
        {
            ccnt--;
            resolve();  //时间已到，只处理在队首的
            break;
        }

        for(int i=1; i<=n; i++)
        {
            if(!mq[i].empty())
            {
                mp[i]--;
                if(mp[i]==0) //如果某个队伍有人完成交易，立马填充人进来
                {
                    node x=mq[i].front();
                    mq[i].pop();
                    res[x.index]=ccnt;
                    if(peo<=k)
                        mq[i].push(nod[peo++]);
                    if(!mq[i].empty())
                    {
                        node x=mq[i].front();
                        mp[i]=x.t;
                    }
                }
            }
        }
        ccnt++;
    }
}

int main()
{
    int q,i;
    while(cin>>n>>m>>k>>q)
    {
        for(i=1; i<=k; i++)
        {
            cin>>nod[i].t;
            nod[i].index=i;
        }
        init();
        solve();

        //cout<<res[6]<<endl;
        int x;
        while(q--)
        {
            cin>>x;
            if(res[x]==10000)
                puts("Sorry");
            else printf("%02d:%02d\n",(res[x]+480)/60,(res[x]+480)%60);
        }
    }
    return 0;
}

/*
2 2 7 5
1 2 6 4 3 534 2
3 4 5 6 7
*/

1015：

题目大意：给你两个数n，b，我们记另一个数是m，将n转换为b进制然后再倒转再转换成10进制变成m，如果n和m都是素数，那么yes，否则no。

直接模拟就好。

AC代码：

#include<iostream>
#include<cstdio>
#include<cmath>
#include<queue>
#include<cstring>
using namespace std;
const int maxn=1005;

int a[maxn];
int base;

int isprime(int x)
{
    if(x==1||x==0) return 0;
    for(int i=2;i<=sqrt(x+0.5);i++)
    {
        if(x%i==0) return 0;
    }
    return 1;
}

int verse(int x)
{
    int p=x;

    int cnt=0;
    while(p)
    {
        a[cnt++]=p%base;
        p/=base;
    }
    int ans=0;
    for(int i=0;i<cnt;i++)
    {
        ans=ans*base+a[i];
    }
    return ans;
}

int main()
{
    int x;
    while(cin>>x&&x>=0)
    {
        cin>>base;
        int y=verse(x);
        //cout<<y<<endl;
        if(isprime(x)&&isprime(y)) puts("Yes");
        else puts("No");
    }
    return 0;
}

/*
73 10
23 2
23 10
-2
*/

1016：

因为这个1016，真的被伤了。。。。

题目大意：主题是算话费的，先给你24小时每小时内每分钟的资费，分别是00:00-01:00,01:00-02:00的每分钟话费，单位是美分，然后给你n个电话记录，每条记录会有用户名，月：天：时：分，然后是一个状态，online表示打电话，offline表示挂电话。所以我们要排序匹配。而题目中说了保证每个人的记录是一个月份内的。

并且如果某人的记录没一个能匹配的话就不打印他的账单。

估计是自己的代码写挫了。。。


（15分/25分）代码：

#include<iostream>
#include<cstdio>
#include<cmath>
#include<queue>
#include<cstring>
#include<algorithm>
#define ll long long
using namespace std;
const double eps=1e-10;

int rate[26];  //每小时里1分钟的价钱
int n;  //多少个记录

struct node
{
    char name[25];
    char time[25];
    int month;
    int day;
    int hour;
    int minu;
    int fla;
} bill[1005];

struct nod
{
    char ans1[25];
    char ans2[25];
    int curt;
    double mon;
} ans[1005];

int cmp(node p1,node p2)
{
    if(strcmp(p1.name,p2.name)<0)
        return 1;
    else if(strcmp(p1.name,p2.name)==0&&strcmp(p1.time,p2.time)<0)
        return 1;
    return 0;
}

double cal1(int day,int hour,int minu)  //计算money
{
    double ans=0;
    ans+=(double)day*rate[25]*60;
    for(int i=1; i<hour+1; i++)
        ans+=rate[i]*60;
    ans+=(double)rate[hour+1]*minu;
    return ans/100.0;
}

int cal2(int day,int hour,int minu)  //计算时间
{
    return day*24*60+hour*60+minu;
}

void solve()
{
    char ansname[25];
    int cnt;
    int month;

    cnt=0;
    int p=0;

    //cout<<bill[0].time<<" "<<bill[0].month<<endl;
    //for(int i=0; i<n; i++)
        //cout<<i<<" "<<bill[i].name<<" "<<bill[i].time<<" "<<bill[i].fla<<endl;
    while(p<n)  //最开始先找一个online的位置p
    {
        if(bill[p].fla==1)
        {
            strcpy(ansname,bill[p].name);
            month=bill[p].month;
            p++;
            break;
        }
        else p++;
    }

    //cout<<ansname<<" "<<month<<endl;
    //cout<<p<<endl;

    double total=0; //记录一个月的花费

    int flag=1;  //flag=1代表有online，
    //puts("fuck1");
    while(p<n)
    {
        //cout<<p<<"****"<<endl;
        if(strcmp(ansname,bill[p].name)!=0)
        {
            //cout<<"????"<<cnt<<endl;
            if(cnt>0)
            {
                printf("%s %02d\n",ansname,month);
                for(int i=0; i<cnt; i++)
                {
                    printf("%s %s %d $%.2f\n",ans[i].ans1,ans[i].ans2,ans[i].curt,ans[i].mon);
                }
                printf("Total amount: $%.2f\n",total);
                total=0;
                cnt=0;
            }

            flag=0;
            while(p<n)  //刚处理完一个人的，寻找下一个online的
            {
                if(bill[p].fla==1)
                {
                    strcpy(ansname,bill[p].name);
                    month=bill[p].month;
                    p++;
                    flag=1;
                    break;
                }
                else p++;
            }
        }
        else   //说明当前是一个月一个人的。
        {
            if(bill[p].fla==0&&flag)  //开始计算
            {
                ans[cnt].curt=cal2(bill[p].day,bill[p].hour,bill[p].minu)-
                              cal2(bill[p-1].day,bill[p-1].hour,bill[p-1].minu);
                ans[cnt].mon=cal1(bill[p].day,bill[p].hour,bill[p].minu)-
                             cal1(bill[p-1].day,bill[p-1].hour,bill[p-1].minu);
                total+=ans[cnt].mon;
                char tmp1[25],tmp2[25];
                for(int i=0; i<8; i++)
                {
                    tmp1[i]=bill[p-1].time[i+3];
                    tmp2[i]=bill[p].time[i+3];
                }
                tmp1[8]=tmp2[8]-'\0';
                strcpy(ans[cnt].ans1,tmp1);
                strcpy(ans[cnt++].ans2,tmp2);

                p++;
                flag=0;
                //cout<<p<<" hhe"<<endl;
            }
            else
            {
                flag=0;
                if(bill[p].fla==1)
                {
                    flag=1;
                }
                p++;
            }
        }
    }

    if(cnt>0)
    {
        //puts("fuck");
        printf("%s %02d\n",ansname,month);
        for(int i=0; i<cnt; i++)
        {
            printf("%s %s %d $%.2f\n",ans[i].ans1,ans[i].ans2,ans[i].curt,ans[i].mon);
        }
        printf("Total amount: $%.2f\n",total);
        total=0;
        cnt=0;
    }
}

int main()
{
    int i;
    while(cin>>rate[1])
    {
        rate[25]=0;
        rate[25]+=rate[1];
        for(i=2; i<=24; i++)
        {
            cin>>rate[i];
            rate[25]+=rate[i];  //rate[25]是24小时的总和
        }

        char tmp1[25];
        cin>>n;
        for(i=0; i<n; i++)
        {
            cin>>bill[i].name>>bill[i].time>>tmp1;
            if(strcmp(tmp1,"on-line")==0)   //如果是1，表示接通，不是的话就是挂断
                bill[i].fla=1;
            else bill[i].fla=0;
            strcpy(tmp1,bill[i].time);
            bill[i].month=(tmp1[0]-'0')*10+(tmp1[1]-'0');
            bill[i].day=(tmp1[3]-'0')*10+(tmp1[4]-'0');
            bill[i].hour=(tmp1[6]-'0')*10+(tmp1[7]-'0');
            bill[i].minu=(tmp1[9]-'0')*10+(tmp1[10]-'0');
        }
        sort(bill,bill+n,cmp);
        solve();
    }
    return 0;
}

/*
10 10 10 10 10 10 20 20 20 15 15 15 15 15 15 15 20 30 20 15 15 10 10 10
10
CYLL 01:01:06:01 on-line
CYLL 01:28:16:05 off-line
CYJJ 01:01:07:00 off-line
CYLL 01:01:08:03 off-line
CYJJ 01:01:05:59 on-line
aaa 01:01:01:03 on-line
aaa 01:02:00:01 on-line
CYLL 01:28:15:41 on-line
aaa 01:05:02:24 on-line
aaa 01:04:23:59 off-line

10 10 10 10 10 10 20 20 20 15 15 15 15 15 15 15 20 30 20 15 15 10 10 10
4
CYJJ 01:01:07:00 off-line
CYJJ 01:01:05:59 on-line
CYJJ 01:01:05:00 on-line
CYJJ 01:01:07:59 off-line

10 10 10 10 10 10 20 20 20 15 15 15 15 15 15 15 20 30 20 15 15 10 10 10
2
CYJJ 01:01:08:00 on-line
CYJJ 01:01:07:59 off-line

10 10 10 10 10 10 20 20 20 15 15 15 15 15 15 15 20 30 20 15 15 10 10 10
2
CYJJ 01:01:07:58 on-line
CYJJ 01:01:07:59 off-line

10 10 10 10 10 10 20 20 20 15 15 15 15 15 15 15 20 30 20 15 15 10 10 10
18
CYLL 01:01:06:01 on-line
CYLL 01:01:07:00 off-line
CYLL 01:01:08:03 on-line
CYLL 01:01:08:09 off-line
CYLL 01:01:08:09 on-line
CYLL 01:02:00:01 off-line
CYLL 01:28:15:41 on-line
CYLL 01:29:02:24 on-line
CYLL 01:30:23:59 off-line
CYLL 01:30:24:59 off-line
CYLL 01:30:25:00 off-line
CYLL 01:30:25:25 off-line
MQ 01:01:06:01 on-line
MQ 01:02:03:04 on-line
MQ 01:03:04:05 on-line
MQ 01:03:04:06 off-line
YF 01:02:03:04 on-line
YF 01:02:03:05 on-line

all dates will be within a single month.
*/

网上有大神的满分代码： 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct
{
    char name[22];//名字
    int month;//月份
    int day;//天
    int hour;//时
    int minute;//分
    char tag[10];//on-line or off-line
}record;

int n;
record *rd;
int rate[24];//费率
int count, start;//记录当前处理的这个用户的记录数目，和当前这个用户的第一条记录位置
double totalCharge;//该用户该月的费用合计

double charge(int sday, int shour, int sminute, int eday, int ehour, int eminute)//计算一条有效电话记录的时长和费用，并返回费用
{
    double cost = 0;
    long time = 0;

    while(sday < eday)//先让天相等
    {
        time += (60 - sminute);
        cost += (60 - sminute) * rate[shour];
        sminute = 0; shour ++;//分化成0，时加1
        time += 60 * (24 - shour);
        while(shour < 24)
        {
            cost += 60 * rate[shour];
            shour ++;
        }
        shour = 0; sday ++;//时化成0，天加1
    }//天此时相等，时分为00:00
    while(shour < ehour)//再让时相等
    {
        time += (60 - sminute);
        cost += (60 - sminute) * rate[shour];
        sminute = 0; shour ++;
    }
    time += (eminute - sminute);
    cost += rate[ehour] * (eminute - sminute);

    printf("%ld $%.2lf\n", time, cost / 100);

    return cost / 100;
}

void totalCount()//数出当前要处理的客户的总记录数目
{
    int i;
    for(i = start + 1; i < n; i ++)
    {
        if(strcmp(rd[i].name, rd[i - 1].name) != 0)
        {
            break;
        }
        else
        {
            count ++;
        }
    }
}

int comp_name(const void *a, const void *b)
{
    record c = *(record *)a;
    record d = *(record *)b;


    if(strcmp(c.name, d.name) <= 0) return -1;
    else return 1;
}

int comp_time(const void *a, const void *b)
{
    record c = *(record *)a;
    record d = *(record *)b;

    if(c.day < d.day) return -1;
    else if(c.day > d.day) return 1;
    else
    {
        if(c.hour < d.hour) return -1;
        else if(c.hour > d.hour) return 1;
        else
        {
            if(c.minute < d.minute) return -1;
            else return 1;
        }
    }
}

int main()
{
    int i;
    int flag;//1应该出现offline, 0应该出现online
    int onpos;//记录最近有效的on-line记录位置，为了算出charge
    int sign;//0表示该客户名字和月份还没有输出，1表示已输出
    

    while(scanf("%d", &rate[0]) != EOF)
    {
        for(i = 1; i < 24; i ++)
        {
            scanf("%d", &rate[i]);
        }
        scanf("%d", &n);
        rd = (record *)malloc(n * sizeof(record));
        for(i = 0; i < n; i ++)
        {
            scanf("\n%s %d:%d:%d:%d %s", rd[i].name, &rd[i].month, &rd[i].day, &rd[i].hour, &rd[i].minute, rd[i].tag);
        }
        qsort(rd, n, sizeof(record), comp_name);//先将记录按字母表顺序分类
        count = 1; start = 0; totalCount(); sign = 0;
        while(start < n)//整个记录表还没处理完
        {
            qsort(rd + start, count, sizeof(record), comp_time);
            flag = 0;
            totalCharge = 0;
            for(i = start; i < start + count; i ++)//处理该客户
            {
                if(flag == 0)//期待出现online,如果是offline跳过
                {
                    if(rd[i].tag[1] == 'f')//off-line
                    {
                        continue;
                    }
                    else//on-line
                    {
                        onpos = i;
                        flag = 1;
                    }
                }
                else//期待出现offline，如果是online则更新onpos
                {
                    if(rd[i].tag[1] == 'n')//on-line
                    {
                        onpos = i;
                    }
                    else//off-line
                    {
                        if(sign == 0)
                        {
                            printf("%s %02d\n", rd[start].name, rd[start].month);
                            sign = 1;
                        }
                        printf("%02d:%02d:%02d %02d:%02d:%02d ", rd[onpos].day, rd[onpos].hour, rd[onpos].minute, rd[i].day, rd[i].hour, rd[i].minute);
                        totalCharge += charge(rd[onpos].day, rd[onpos].hour, rd[onpos].minute, rd[i].day, rd[i].hour, rd[i].minute);
                        flag = 0;
                    }
                }
            }
            if(sign == 1)
            {
                printf("Total amount: $%.2lf\n", totalCharge);
            }
            start += count; count = 1; totalCount(); sign = 0;
        }
    }
    return 0;
}

真心被玩儿出内伤了。。。。


果7
关注
专栏目录
PAT甲级1013 Battle Over Cities (python)
小海同学的博客
01-29 561
思路 1013 Battle Over Cities (25 分) 题目就不抄了，思路翻译以一下就是： 给出若干个城市n，以及哪些城市之间有路，题目要求解决的是：选取其中k个城市，其中一个被占领时，与之相关的路全部报废，问重新连接这些k-1个城市，至少要修几条路。 从样例基本可以看出，这个图的问题，把图转为矩阵，解题思路就是回溯，有想法，但是代码只能部分通过： 想法思路： 其中3被占领与2基本一致 python代码编写 #甲级1013 n = 0 visit = [[False for i in ran
PAT简介和2019年秋季浙大PAT考试报名流程
小阿兜的博客
04-02 8544
PAT简介： 计算机程序设计能力考试（Programming Ability Test，简称 PAT ） 旨在通过统一组织的在线考试及自动评测方法客观地评判考生的算法设计与程序设计实现能力， 科学的评价计算机程序设计人才， 为企业选拔人才提供参考标准。 PAT目前有考点 67 处， 分布在 26 省/直辖市的 49 座城市中， 涉及合作院校 60 所。 联盟院校承诺为考试提供统一配置的机房以及网络...
http://pat.zju.edu.cn/contests/pat-practise/1013
我不要写标题
10-13 694
1013. Battle Over Cities (25) 时间限制 400 ms 内存限制 32000 kB 代码长度限制 16000 B 判题程序 Standard 作者 CHEN, Yue It is vitally important to have all the
pat1013. Battle Over Cities (25)
weixin_30583563的博客
08-08 189
1013. Battle Over Cities (25) 时间限制 400 ms 内存限制 65536 kB 代码长度限制 16000 B 判题程序 Standard 作者 CHEN, Yue It is vitally important to have all the cities connected by highways ...
PAT A1016
weixin_33896069的博客
02-09 156
本质上是一个很简单的问题，但是在写代码实现上发现自己还是一个弱鸡；主要的思路就是先进行记录的录入和排序，按照字典序、时间大小进行排序，使得同一个人的记录在一起，并且按照日期递增；后续难就难在怎么进行on-line和off-line状态的查询以及计费的计算；对于状态查询，示例代码有如下操作：1.先进行同一人记录的查询，找到最后一条的边界，并...
PAT1016
weixin_30667301的博客
08-31 125
#include<cstdio> #include<algorithm> #include<vector> #include<cstring> using namespace std; const int maxn=1510; int fare[1510]; struct R{ char name[25]; int M,D,...
PAT浙江大学计算机程序设计能力考试资料集(2022.03.16)A.pdf
03-16
PAT 浙江大学计算机程序设计能力考试资料集 本文档是关于 PAT 浙江大学计算机程序设计能力考试的资料集，涵盖了 PAT 乙级和 PAT 甲级考试的相关信息和资源。 PAT 乙级考试是中国计算机程序设计能力考试的一部分，...
浙江大学PAT乙级考试1-70题参考答案
06-19
计算机程序设计能力考试（Programming Ability Test，简称PAT） 旨在通过统一组织的在线考试及自动评测方法客观地评判考生的算法设计与程序设计实现能力， 科学的评价计算机程序设计人才， 为企业选拔人才提供参考...
浙江大学PAT
01-20
浙江大学PAT是浙江大学主办的一项编程能力测试，主要针对计算机科学和技术领域的学生和爱好者，旨在提升他们的算法设计和编程技能。这个平台提供了多个级别的题目，涵盖从基础到高级的各种问题，为学习者提供了一个...
PAT浙江大学计算机程序设计能力考试资料集(2022.01.04)B.pdf
01-04
PAT浙江大学计算机程序设计能力考试资料集 PAT浙江大学计算机程序设计能力考试资料集是中国浙江大学计算机科学与技术学院举办的计算机程序设计能力考试的考题集。该考试旨在考察考生的编程能力，涵盖了C++、Python...
PAT甲级1013
Erick Lv的笔记
01-30 309
PAT甲级1013 求图的连通分量 本题实际上是把检查点去掉后，求解图中连通分量的个数，结果用连通分量的个数减一。连通分量的求解使用并查集，把每一个连通分量的点，在自己所在的分量中找一个结点当做根，最后统计根的个数就行了。 #include using namespace std; const int MAXN = 1005; const int MAXM = 10000000; int
PAT【甲级】1013
qq_41375322的博客
04-09 268
题目链接：PAT【甲级】1013 题目简述：输入N,M,K三个正整数（N为城市数量，M为城市间道路数量，K为要查询的案例数），然后输入M组格式为c1 c2的数字，分别代表两个城市之间连有通路。下面则数输入K个数，表示删除这个节点后，还需要建立多少条路来使得各城市节点互通。 #include<bits/stdc++.h> using namespace std; vector<vector<int>> graph(1000, vector<int>(1000,
PAT 甲级 1013. Battle Over Cities
zjbh89757的专栏
06-29 312
1013. Battle Over Cities (25) 时间限制 400 ms 内存限制 65536 kB 代码长度限制 16000 B 判题程序 Standard 作者 CHEN, Yue It is vitally important to have all the
PAT 1016
说文科技，做有态度的研究。
01-11 504
1.思路分析 题目的大致意思如下： 1）给出每时中通电话的价钱（cent/minute） 2）给出一系列的账单，其中包括的信息有账户名称，【月份，日期，小时，分钟】对应在题中则是【mm:dd:hh:mm】。同时标记on-line/off-line。 3）只有在按照时间顺序下的on-line与off-line相匹配时才能计算账单。 4）但是若一个账户没有正确的匹配项，即没有任何花费，则不应
PAT乙级考试C语言答案集锦
浙江大学的PAT乙级考试是针对学生程序设计能力的一项考核，这个资源提供了解决所有乙级题目所用的C语言代码，对于准备此类考试或提高编程技能的人来说非常有帮助。下面将对部分题目代码进行解析和知识点说明。 1001...
评论 12
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值