杭电ACM基础题(1720、1785、1799、1859、1862)

1720、A+B Coming[十六进制数A+B]

Input
Input may contain multiple test cases. Each case contains A and B in one line.
A, B are hexadecimal number.
Input terminates by EOF.
Output
Output A+B in decimal number in one line.
Sample Input

1 9
A B
a b

Sample Output

10
21
21

Code
十六进制数A+B,将A B转化为十进制数,输出十进制A+B的结果

//十六进制数A+B,结果用十进制数表示
#include<iostream>
#include<cstring>
#include<cmath>
using namespace std;

//将16进制数转化为10进制数
int convert_ten(char c[]){
    int len=strlen(c);
    int num[1000],j=0;
    for(int i=0;i<len;i++){
        switch(c[i]){
            case 'A':
                num[j++]=10;break;
            case 'a':
                num[j++]=10;break;
            case 'B':
                num[j++]=11;break;
            case 'b':
                num[j++]=11;break;
            case 'C':
                num[j++]=12;break;
            case 'c':
                num[j++]=12;break;
            case 'D':
                num[j++]=13;break;
            case 'd':
                num[j++]=13;break;
            case 'E':
                num[j++]=14;break;
            case 'e':
                num[j++]=14;break;
            case 'F':
                num[j++]=15;break;
            case 'f':
                num[j++]=15;break;
            default:
                num[j++]=c[i]-'0';break;
        }
    }
    int result=0;
    for(int i=len-1,k=0;i>=0;i--,k++){
        result=result+num[i]*pow(16,k);
    }
    return result;
} 


char a[1000],b[1000];
int main() {
    while(cin>>a>>b){
        //将十六进制数a和b转化为十进制数 
        int m=convert_ten(a);
        int n=convert_ten(b);
        cout<<m+n<<endl;
    }
}

1785、给定(x,y)坐标,比较其与x轴正向夹角

用原点到该队员所在的点所构成的向量来表示一个队员。如果该向量和X正轴夹角比较小的话,就说他的能力比较高,排名就应该靠前。
Input
输入数据包含多组测试实例,每个实例的第一行是一个整数n(n<=100),表示集训队员的人数,紧接着的一行是2*n个数,表示n个队员的坐标值(x1,y1,x2,y2…xn,yn),n为负数的时候表示输入数据的结束。
特别说明,所有的y坐标均为正数,并且所有的坐标值都是有一位小数的浮点数。
Output
对于每个测试实例,请在一行内输出排名后的坐标,坐标之间用一个空格隔开。特别地,你可以假设根据“伪氏排名规则”结果唯一。
Sample Input

3
5.0 4.0 3.1 0.1 2.0 2.0
-1

Sample Output

3.1 0.1 5.0 4.0 2.0 2.0

Code:
定义结构体数组来存储每位队员的(x,y)以及与x轴正向的夹角的余弦值,利用sort()函数对结构体数组进行排序,按排序结果输出即可

//比较(x,y)与x轴正向夹角,利用结构体存储x,y,以及角度 
#include<iostream>
#include<cmath>
#include<algorithm>
#include<iomanip>
using namespace std;
//利用结构体
struct Point{
    double x;
    double y;
    double value;
} stu[100];

bool comp(Point x,Point y){
    return x.value>y.value;
} 

int main(){
    int n;//(0,100]队员个数 
    while(cin>>n){
        if(n<0) return 0;
        for(int i=0;i<n;i++){
            cin>>stu[i].x>>stu[i].y;
            //与x轴正方向的夹角余弦值,余弦值越大,与x轴正方向的坐标越小 
            stu[i].value=stu[i].x/sqrt(stu[i].x*stu[i].x+stu[i].y*stu[i].y);
        }
        //利用sort数组对结构体数组进行排序
        sort(stu,stu+n,comp);
        cout<<setiosflags(ios::fixed);
        for(int i=0;i<n;i++){
            if(i==0){
                cout<<setprecision(1)<<stu[i].x<<" "<<setprecision(1)<<stu[i].y;
            }
            else{
                cout<<" "<<setprecision(1)<<stu[i].x<<" "<<setprecision(1)<<stu[i].y;
            }
        }
        cout<<endl;
    }
    
} 

1799、多重for循环,计算程序一共执行了多少次

我们知道,在编程中,我们时常需要考虑到时间复杂度,特别是对于循环的部分。例如,
如果代码中出现
for(i=1;i<=n;i++) OP ;
那么做了n次OP运算,如果代码中出现
fori=1;i<=n; i++)
for(j=i+1;j<=n; j++) OP;
那么做了n*(n-1)/2 次OP 操作。
现在给你已知有m层for循环操作,且每次for中变量的起始值是上一个变量的起始值+1(第一个变量的起始值是1),终止值都是一个输入的n,问最后OP有总共多少计算量。
Input
有T组case,T<=10000。每个case有两个整数m和n,0<m<=2000,0<n<=2000.
Output
对于每个case,输出一个值,表示总的计算量,也许这个数字很大,那么你只需要输出除1007留下的余数即可。
Sample Input

2
1 3
2 3

Sample Output

3
3

Code:
思路:C(n,m)相当于共有n个球,要从中取出m个球,共有多少种组合方式,可等价于—共有n个数,从中取出m个数,有多少种组合方式,–即m重循环,循环截止条件为n的程序执行多少次

/*多重for循环,计算程序一共执行了多少次
思路:C(n,m)相当于共有n个球,要从中取出m个球,共有多少种组合方式
可等价于---共有n个数,从中取出m个数,有多少种组合方式 */ 
#include<iostream>
using namespace std;

int a[2001][2001]={0};
//计算C(n,m)=C(n-1,m)+C(n-1,m-1);
//a[n][m]代表C(n,m) 
void fun_C(void){
    a[0][0]=1;
    for(int i=1;i<=2000;i++){
        a[i][0]=1;
        for(int j=1;j<=i;j++){
            a[i][j]=(a[i-1][j]+a[i-1][j-1])%1007;
        }
    }
}

int main(){
    int t;//t组测试用例[1,10000]
    cin>>t;
    fun_C();
    while(t--){
        int m,n;//m重循环,终止条件为n  (0,2000]
        cin>>m>>n;//C(n,m)组合公式 
        cout<<a[n][m]<<endl;
    } 
    return 0;
} 

1859、最小长方形[长方形框左下坐标,右上坐标]

给定一系列2维平面点的坐标(x, y),其中x和y均为整数,要求用一个最小的长方形框将所有点框在内。长方形框的边分别平行于x和y坐标轴,点落在边上也算是被框在内。
Input
测试输入包含若干测试用例,每个测试用例由一系列坐标组成,每对坐标占一行,其中|x|和|y|小于 231;一对0 坐标标志着一个测试用例的结束。注意(0, 0)不作为任何一个测试用例里面的点。一个没有点的测试用例标志着整个输入的结束。
Output
对每个测试用例,在1行内输出2对整数,其间用一个空格隔开。第1对整数是长方形框左下角的坐标,第2对整数是长方形框右上角的坐标。
Sample Input

12 56
23 56
13 10
0 0
12 34
0 0
0 0

Sample Output

12 10 23 56
12 34 12 34

Code
给定一系列2维平面点的坐标(x, y),用一个最小的长方形框将所有点框在内,输出该最小长方形的左下角的坐标,长方形框右上角的坐标。
思路:输出这一系列点的横坐标的最小值,纵坐标的最小值,横坐标的最大值,纵坐标的最大值

//给定一系列2维平面点的坐标(x, y),用一个最小的长方形框将所有点框在内。
//输出是长方形框左下角的坐标,长方形框右上角的坐标。
#include<iostream>
#include<algorithm>
using namespace std;

int x_arry[1000],y_arry[1000];
int main(){
    while(cin>>x_arry[0]>>y_arry[0]){
        if(x_arry[0]==0&&y_arry[0]==0){
            return 0;
        }
        int i=1;
        while(cin>>x_arry[i]>>y_arry[i]){
            if(x_arry[i]==0&&y_arry[i]==0) break;
            i++;
        }
        
        //对x_arry[] y_arry[]进行排序
        sort(x_arry,x_arry+i);
        sort(y_arry,y_arry+i);
        //输出最小的横坐标 最小的纵坐标 最大的横坐标 最大的纵坐标 
        cout<<x_arry[0]<<" "<<y_arry[0]<<" "<<x_arry[i-1]<<" "<<y_arry[i-1]<<endl; 
    }
}

1862、EXCEL排序排序

Excel可以对一组纪录按任意指定列排序。现请你编写程序实现类似功能。
Input
测试输入包含若干测试用例。每个测试用例的第1行包含两个整数 N (<=100000) 和 C,其中 N 是纪录的条数,C 是指定排序的列号。以下有 N
行,每行包含一条学生纪录。每条学生纪录由学号(6位数字,同组测试中没有重复的学号)、姓名(不超过8位且不包含空格的字符串)、成绩(闭区间[0, 100]内的整数)组成,每个项目间用1个空格隔开。当读到 N=0 时,全部输入结束,相应的结果不要输出。
Output
对每个测试用例,首先输出1行“Case i:”,其中 i 是测试用例的编号(从1开始)。随后在 N 行中输出按要求排序后的结果,即:当 C=1 时,按学号递增排序;当 C=2时,按姓名的非递减字典序排序;当 C=3
时,按成绩的非递减排序。当若干学生具有相同姓名或者相同成绩时,则按他们的学号递增排序。
Sample Input

3 1
000007 James 85
000010 Amy 90
000001 Zoe 60
4 2
000007 James 85
000010 Amy 90
000001 Zoe 60
000002 James 98
4 3
000007 James 85
000010 Amy 90
000001 Zoe 60
000002 James 90
0 0

Sample Output

Case 1:
000001 Zoe 60
000007 James 85
000010 Amy 90
Case 2:
000010 Amy 90
000002 James 98
000007 James 85
000001 Zoe 60
Case 3:
000001 Zoe 60
000007 James 85
000002 James 90
000010 Amy 90

Code
对结构体数组按指定的方式进行排序

//按指定方式排序
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;

struct Student{
    char id[7];//学号
    char name[8];
    int score;//分数 
} stu[100000];

bool comp_id(Student x,Student y){
    if(strcmp(x.id,y.id)<0) return true;
    else return false;
}

bool comp_name(Student x,Student y){
    if(strcmp(x.name,y.name)==0){
        return strcmp(y.id,x.id)>0;
    }else{
        if(strcmp(x.name,y.name)<0) return true;
        else return false;
    }
}

bool comp_score(Student x,Student y){
     if(x.score==y.score){
         return strcmp(y.id,x.id)>0;
    }
    else{
        return x.score<y.score;
    } 
} 

int main(){
    int i=0;//测试用例的编号
    int n,c;
    while(cin>>n>>c){
        if(n==0) return 0;
        i++;
        for(int j=0;j<n;j++){
            cin>>stu[j].id>>stu[j].name>>stu[j].score;
        }
        //按何种顺序进行排序 
        switch(c){
            case 1://按学号递增排序
                sort(stu,stu+n,comp_id);
                break;
            case 2://按姓名非递减排序--按学号递增排序 
                sort(stu,stu+n,comp_name);
                break;
            case 3://按成绩的非递减排序--按学号递增排序 
                sort(stu,stu+n,comp_score);
                break; 
        }
        cout<<"Case "<<i<<":"<<endl;
        for(int k=0;k<n;k++){
            cout<<stu[k].id<<" "<<stu[k].name<<" "<<stu[k].score<<endl;
        } 
    }
}
  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值