pat Class A string processing

A1153

#include<iostream>
#include<vector>
#include<algorithm>
#include<map>
using namespace std;

const int maxn=10010;

int n,m;

struct node
{
    
    
    string name;
    int grade;
}Node[maxn];



bool cmp(node a,node b)
{
    
    
    if(a.grade!=b.grade)
        return a.grade>b.grade;
    return a.name<b.name;
}

int main()
{
    
    
    cin >> n >> m;
    for(int i=0; i<n; i++)
    {
    
    
        cin >> Node[i].name >> Node[i].grade;
    }

    string a,b;
    for(int T=1; T<=m; T++)
    {
    
    
        cin >> a >> b;
        printf("Case %d: %s %s\n",T,a.c_str(),b.c_str());
        if(a=="1")
        {
    
    
            vector<node> path;         //这个path必须每次重新定义，不然如果再输入1的话，就把数字加入到之前的测试样例中
            for(int i=0; i<n; i++)
                if(Node[i].name[0]==b[0])
                {
    
    
                    path.push_back(Node[i]);
                }
            sort(path.begin(),path.end(),cmp);
            if(path.size()==0)
            {
    
    
                printf("NA\n");
            }
            else
            {
    
    
                for(int i=0; i<path.size(); i++)
                {
    
    
                    printf("%s %d\n",path[i].name.c_str(),path[i].grade);
                }
            }
        }
        else if(a=="2")
        {
    
    
            int cnt=0,all=0;
            for(int i=0; i<n; i++)
                if(b==Node[i].name.substr(1,3))
                {
    
    
                    all+=Node[i].grade;
                    cnt++;
                }
            if(cnt==0)
            {
    
    
                printf("NA\n");
            }
            else
            {
    
    
                printf("%d %d\n",cnt,all);
            }
        }
        else
        {
    
    
            map<string,int> mp;
            for(int i=0; i<n; i++)
                if(b==Node[i].name.substr(4,6))
                {
    
    
                    mp[Node[i].name.substr(1,3)]++;
                }
            vector<pair<int,string>> q;
            //题目要求按照人数的降序排列，如果人数相同则按照site的升序排列，所以将人数去负值，这样都是都是按照升序排列，最后输出时对人数再去负号即可
            for(map<string,int>::iterator it=mp.begin(); it!=mp.end(); it++)
            {
    
    
                q.push_back({
    
    it->second*(-1),it->first});
            }
            sort(q.begin(),q.end());   //sort排序是以第1个关键字先递增排序，如果第1关键字相同，则按照第2关键字的升序排列
            if(q.size()==0)
            {
    
    
                printf("NA\n");
            }
            else
            {
    
    
                for(int i=0; i<q.size(); i++)
                {
    
    
                    printf("%s %d\n",q[i].second.c_str(),-q[i].first);
                }
            }
        }
    }
}

A1141

#include<iostream>
#include<map>
#include<vector>
#include<algorithm>
using namespace std;

const int maxn=100010;

int n;

struct node
{
    
    
    string id;            //学校名字
    double grade;      //总成绩
    int cnt;         //总人数
    node(): grade(0),cnt(0) {
    
    }        //先对结构进行初始 总成绩为0 总人数为0
};

map<string,node> mp;

bool cmp(node a,node b)
{
    
    
    if(a.grade!=b.grade)
        return a.grade>b.grade;
    if(a.cnt!=b.cnt)
        return a.cnt<b.cnt;
    return a.id<b.id;
}

int main()
{
    
    
    cin >> n;
    string id;
    double chengji;
    string name;
    /*
        通过映射哈希表，将学校名作为第1关键字，然后计算其总成绩和总人数，不然的话直接使用sruct办不到
    */
    for(int i=0; i<n; i++)      //通过map连接一个结构
    {
    
    
        cin >> id >> chengji >> name;

        for(int j=0; j<name.size(); j++)   //将所有的学校小写化
            name[j]=tolower(name[j]);

        if(id[0]=='T')       //如果id为T，则成绩*1.5
        {
    
    
            chengji*=1.5;
        }
        else if(id[0]=='B')     //如果id为B，则成绩/1.5
        {
    
    
            chengji/=1.5;
        }

        mp[name].id=name;
        mp[name].grade+=chengji;     //由于成绩设计*1.5或者/1.5所以grade必须设置为double类型
        mp[name].cnt++;
    }

    vector<node> path;     //将结构输入到数组中进行排序
    for(map<string,node>::iterator it=mp.begin(); it!=mp.end(); it++)
    {
    
    
        it->second.grade=(int)(it->second.grade);   //注意这里对结构中的成绩进行一个取整，是为了在后面的排序中，对于12.99和12来说，按照题意应该是相同的，不进行取整则12.99>12 
        path.push_back(it->second);
    }
    sort(path.begin(),path.end(),cmp);

    int rank=1;
    cout << mp.size() << endl;

    for(int i=0; i<path.size(); i++)
    {
    
    
        if(i && path[i].grade!=path[i-1].grade)     //如果前一个人的成绩等于后一个人，则排名不变，否则为i+1
            rank=i+1;
        printf("%d %s %d %d\n",rank,path[i].id.c_str(),(int)path[i].grade,path[i].cnt);    //注意由于此时的path[i]的grade还是double类型，输出的话是%d 所以必须对数字进行取整
    }
}

A1124

#include<iostream>
#include<map>
#include<vector>
using namespace std;

const int maxn=1111;

int n,m,s;

int a[maxn];

string b[maxn];

map<string,bool> c;

vector<int> path;

//这他妈就是牛逼之处

int main()
{
    
    
    cin >> m >> n >> s;
    for(int i=1; i<=m; i++)
    {
    
    
        cin >> b[i];
        a[i]=i;
    }

    while(s<=m)
    {
    
    
        if(c[b[s]]==true)
        {
    
    
            s++;
        }
        else
        {
    
    
            path.push_back(s);
            c[b[s]]=true;
            s+=n;
        }
    }
    if(path.size()!=0)
    {
    
    
        for(int i=0; i<path.size(); i++)
            cout << b[path[i]] << endl;
    }
    else
        cout << "Keep going..." << endl;
}

A1108

#include<iostream>
using namespace std;

int n;

int main()
{
    
    
    cin >> n;
    string temp;       //设置string类型的字符串
    
    int cnt=0;
    double all=0.0;
    
    while(n--)
    {
    
    
        cin >> temp;
        bool success=true;        //注意对success进行初始化为true
        double num;
        
        //这是对stof所设置的try{}catch(...)语句，而其中stof是将字符串转化为double类型的数字
        try
        {
    
    
            size_t idx;     //size_t其实就是stof第2个参数的类型，具体见下面
            num=stof(temp,&idx);
            if(idx<temp.size())        //stof对于 4.23abc不会报出异常只会取出4.23但是本题中4.23不是合法的数字，所以通过stof所截取的字符串的长度进行判断
            {
    
    
                success=false;
            }
        }
        catch(...)      //抛出异常错误
        {
    
    
            success=false;
        }

        if(num<-1000 || num>1000)    
        {
    
    
            success=false;
        }

        int k=temp.find('.');
        if(k!=-1 && temp.size()-k>3)    //找到输入的字符串中第1个小数点的位置，如果找得到则不为-1，如果小数点在最后面则temp.size()-k表示为1，在倒数第2位表示2，在倒数第3位即小数点后面保留2位，表示3
            success=false;

        if(success)   //如果找到合适的数字
        {
    
    
            cnt++;
            all+=num;
        }
        else       //如果没有找到合适的数字输出不合法
        {
    
    
            printf("ERROR: %s is not a legal number\n",temp.c_str());
        }
    }

    if(cnt==0)
        printf("The average of 0 numbers is Undefined\n");
    else if(cnt==1)
        printf("The average of 1 number is %.2lf\n",all);
    else
    {
    
    
        printf("The average of %d numbers is %.2lf\n",cnt,all/cnt);
    }
}

stof

A1113

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

const int maxn=101111;

int n;

vector<int> child;

//这道题的思路就是给出n个数字，然后分成两个部分，要求两个数组的个数之差最小，两个数组的和是最大的

int main()
{
    
    
    cin >> n;
    int temp;
    for(int i=0; i<n; i++)
    {
    
    
        cin >> temp;
        child.push_back(temp);
    }
    sort(child.begin(),child.end());
    int kk=child.size()/2;
    int sum1=0,sum2=0;

    for(int i=0; i<kk; i++)
    {
    
    
        sum1+=child[i];
    }

    for(int i=kk; i<child.size(); i++)
    {
    
    
        sum2+=child[i];
    }

    cout << child.size()-kk-kk << " " << sum2-sum1;
    return 0;
}