华为笔试题

1.老师想知道从某某同学当中，分数最高的是多少，现在请你编程模拟老师的询问。当然，老师有时候需要更新某位同学的成绩.
输入描述:
输入包括多组测试数据。
每组输入第一行是两个正整数N和M（0 < N <= 30000,0 < M < 5000）,分别代表学生的数目和操作的数目。
学生ID编号从1编到N。
第二行包含N个整数，代表这N个学生的初始成绩，其中第i个数代表ID为i的学生的成绩
接下来又M行，每一行有一个字符C（只取‘Q’或‘U’），和两个正整数A,B,当C为’Q’的时候, 表示这是一条询问操作，他询问ID从A到B（包括A,B）的学生当中，成绩最高的是多少
当C为‘U’的时候，表示这是一条更新操作，要求把ID为A的学生的成绩更改为B。

输出描述:
对于每一次询问操作，在一行里面输出最高成绩.

输入例子1:
5 7
1 2 3 4 5
Q 1 5
U 3 6
Q 3 4
Q 4 5
U 4 5
U 2 9
Q 1 5

输出例子1:
5
6
5
9

#include <stdio.h>#include <algorithm>using namespace std;const int MAXN=100000;int data[MAXN+5];int querymax ( int l , int r ) {    int ans=data[l];    for(int i=l+1;i<=r;i++) ans=max(ans,data[i]);    return ans;}void update(int idx,int value){    data[idx]=value;}int main(){    int n,m;    while(~scanf("%d%d",&n,&m)){        for(int i=1;i<=n;i++){            scanf("%d",&data[i]);        }        char order;        int a,b;        for(;m--;){            scanf(" %c%d%d",&order,&a,&b);            if(order=='U'){                update(a,b);            }else if(order=='Q'){                if(a>b)swap(a,b);                printf("%d\n",querymax(a,b));            }        }    }    return 0;}

2.
开发一个简单错误记录功能小模块，能够记录出错的代码所在的文件名称和行号。
处理:
1.记录最多8条错误记录，对相同的错误记录(即文件名称和行号完全匹配)只记录一条，错误计数增加；(文件所在的目录不同，文件名和行号相同也要合并)
2.超过16个字符的文件名称，只记录文件的最后有效16个字符；(如果文件名不同，而只是文件名的后16个字符和行号相同，也不要合并)
3.输入的文件可能带路径，记录文件名称不能带路径
输入描述:
一行或多行字符串。每行包括带路径文件名称，行号，以空格隔开。

文件路径为windows格式如：E:\V1R2\product\fpgadrive.c 1325

输出描述:
将所有的记录统计并将结果输出，格式：文件名代码行数数目，一个空格隔开，如: fpgadrive.c 1325 1

结果根据数目从多到少排序，数目相同的情况下，按照输入第一次出现顺序排序。如果超过8条记录，则只输出前8条记录.如果文件名的长度超过16个字符，则只输出后16个字符

输入例子1:
E:\V1R2\product\fpgadrive.c 1325

输出例子1:
fpgadrive.c 1325 1

#include <iostream>#include <vector>#include <string>#include <algorithm>using namespace std;bool compare(pair<string, int> a, pair<string, int> b){    return a.second > b.second;}int main(void){    string input, file;    vector<pair<string, int>> errors;    while (getline(cin, input)){        if (input.size() == 0)            break;        unsigned int f = input.rfind('\\');        file = input.substr(f + 1);        errors.push_back(make_pair(file, 1));        for (int i = 0; i<(errors.size() - 1); i++){            if (errors[i].first == file){                errors[i].second++;                errors.pop_back(); break;            }        }    }    stable_sort(errors.begin(), errors.end(), compare);    int idx = 0;    while (idx<8 && idx<errors.size()){        string check = errors[idx].first;        int t = check.find(' ');        if (t>16)            errors[idx].first.erase(0, t - 16);        cout << errors[idx].first << ' ' << errors[idx].second << endl;        idx++;    }}

3
扑克牌游戏大家应该都比较熟悉了，一副牌由54张组成，含3~A，2各4张，小王1张，大王1张。牌面从小到大用如下字符和字符串表示（其中，小写joker表示小王，大写JOKER表示大王）:)
3 4 5 6 7 8 9 10 J Q K A 2 joker JOKER
输入两手牌，两手牌之间用“-”连接，每手牌的每张牌以空格分隔，“-”两边没有空格，如：4 4 4 4-joker JOKER
请比较两手牌大小，输出较大的牌，如果不存在比较关系则输出ERROR

基本规则：
（1）输入每手牌可能是个子，对子，顺子（连续5张），三个，炸弹（四个）和对王中的一种，不存在其他情况，由输入保证两手牌都是合法的，顺子已经从小到大排列；
（2）除了炸弹和对王可以和所有牌比较之外，其他类型的牌只能跟相同类型的存在比较关系（如，对子跟对子比较，三个跟三个比较），不考虑拆牌情况（如：将对子拆分成个子）
（3）大小规则跟大家平时了解的常见规则相同，个子，对子，三个比较牌面大小；顺子比较最小牌大小；炸弹大于前面所有的牌，炸弹之间比较牌面大小；对王是最大的牌；
（4）输入的两手牌不会出现相等的情况。

答案提示：
（1）除了炸弹和对王之外，其他必须同类型比较。
（2）输入已经保证合法性，不用检查输入是否是合法的牌。
（3）输入的顺子已经经过从小到大排序，因此不用再排序了.
输入描述:
输入两手牌，两手牌之间用“-”连接，每手牌的每张牌以空格分隔，“-”两边没有空格，如4 4 4 4-joker JOKER。

输出描述:
输出两手牌中较大的那手，不含连接符，扑克牌顺序不变，仍以空格隔开；如果不存在比较关系则输出ERROR。

输入例子1:
4 4 4 4-joker JOKER

输出例子1:
joker JOKER

//“输入每手牌可能是个子，对子，顺子（连续5张），三个，炸弹（四个）和对王中的一种，//不存在其他情况，由输入保证两手牌都是合法的，顺子已经从小到大排列“//这句规则让牌面类型的确定和大小的比较直接可以转换为牌个数的比较了，这是解决测试问题的捷径！//所以一定要善于利用题目已知条件！！！#include <iostream>#include <string>#include <algorithm>using namespace std;int main(){    string line;    while(getline(cin,line)){        if(line.find("joker JOKER")!=-1)            cout<<"joker JOKER"<<endl;        else{            int dash=line.find('-');            string car1=line.substr(0,dash);            string car2=line.substr(dash+1);            int c1=count(car1.begin(),car1.end(),' ');            int c2=count(car2.begin(),car2.end(),' ');            string first1=car1.substr(0,car1.find(' '));            string first2=car2.substr(0,car2.find(' '));            string str="345678910JQKA2jokerJOKER";            if(c1==c2){                if(str.find(first1)>str.find(first2))                    cout<<car1<<endl;                else                    cout<<car2<<endl;            }else                if(c1==3)                    cout<<car1<<endl;                else if(c2==3)                    cout<<car2<<endl;                else                    cout<<"ERROR"<<endl;        }    }}

4
有这样一道智力题：“某商店规定：三个空汽水瓶可以换一瓶汽水。小张手上有十个空汽水瓶，她最多可以换多少瓶汽水喝？”答案是5瓶，方法如下：先用9个空瓶子换3瓶汽水，喝掉3瓶满的，喝完以后4个空瓶子，用3个再换一瓶，喝掉这瓶满的，这时候剩2个空瓶子。然后你让老板先借给你一瓶汽水，喝掉这瓶满的，喝完以后用3个空瓶子换一瓶满的还给老板。如果小张手上有n个空汽水瓶，最多可以换多少瓶汽水喝？

输入描述:
输入文件最多包含10组测试数据，每个数据占一行，仅包含一个正整数n（1<=n<=100），表示小张手上的空汽水瓶数。n=0表示输入结束，你的程序不应当处理这一行。

输出描述:
对于每组测试数据，输出一行，表示最多可以喝的汽水瓶数。如果一瓶也喝不到，输出0。

输入例子1:
3
10
81
0

输出例子1:
1
5
40

链接：https://www.nowcoder.com/questionTerminal/fe298c55694f4ed39e256170ff2c205f来源：牛客网/*递归问题3个瓶子换1瓶水+1个空瓶子，两个瓶子换1瓶水+0个空瓶子，1个瓶子换0瓶水。f(1) = 0f(2) = 1f(3) = 1f(4) = f(2)+1    //4个瓶子，其中3个可以换1瓶水+1个空瓶，所以是f(2)+1f(5) = f(3)+1    //3个瓶子换1瓶水+1个空瓶，所以是f(3)+1...f(n) = f(n-2)+1 */#include <iostream>using namespace std;int f(int n){    if(n==1) return 0;    if(n==2) return 1;    return f(n-2)+1;}int main(){    int n;    while(cin >> n){        if(n==0)            break;        cout<<f(n)<<endl;    }    return 0;}

5

明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了N个1到1000之间的随机整数（N≤1000），对于其中重复的数字，只保留一个，把其余相同的数去掉，不同的数对应着不同的学生的学号。然后再把这些数从小到大排序，按照排好的顺序去找同学做调查。请你协助明明完成“去重”与“排序”的工作。

Input Param
n 输入随机数的个数
inputArray n个随机整数组成的数组

Return Value
OutputArray 输出处理后的随机整数

注：测试用例保证输入参数的正确性，答题者无需验证。测试用例不止一组。

输入描述:
输入多行，先输入随机整数的个数，再输入相应个数的整数

输出描述:
返回多行，处理后的结果

输入例子1:
11
10
20
40
32
67
40
20
89
300
400
15

输出例子1:
10
15
20
32
40
67
89
300
400

#include <iostream>using namespace std;int main() {    int N, n;    while (cin >> N) {        int a[1001] = { 0 };        while (N--) {            cin >> n;            a[n] = 1;        }        for (int i = 0; i < 1001; i++)            if (a[i])                cout << i << endl;    }    return 0;}

6
写出一个程序，接受一个十六进制的数值字符串，输出该数值的十进制字符串。（多组同时输入 ）

输入描述:
输入一个十六进制的数值字符串。

输出描述:
输出该数值的十进制字符串。

输入例子1:
0xA

输出例子1:
10

#include <iostream>using namespace std;int main(){    int a;    while(cin>>hex>>a){    cout<<a<<endl;    }}

只是将字符串转换成十进制的数，程序就能通过，看来题目的目的只是将十六进制转换成十进制#include<stdio.h>#include<string.h>#include<math.h>int main(){    char str[100];    int i=0,count,sum;    while(gets(str))//用于多次输入    {        count=strlen(str);//计算字符串的长度        sum=0;        for(i=count-1;i>=0;i--)//从十六进制个位开始，每位都转换成十进制        {        if(str[i]>='0'&&str[i]<='9')//数字字符的转换        {            sum+=(str[i]-48)*pow(16,count-i-1);        }        else if(str[i]>='A'&&str[i]<='F')//字母字符的转换        {            sum+=(str[i]-55)*pow(16,count-i-1);        }        }        printf("%d\n",sum);    }    return 0; }

7

有一个数组a[N]顺序存放0~N-1，要求每隔两个数删掉一个数，到末尾时循环至开头继续进行，求最后一个被删掉的数的原始下标位置。以8个数(N=7)为例:｛0，1，2，3，4，5，6，7｝，0->1->2(删除)->3->4->5(删除)->6->7->0(删除),如此循环直到最后一个数被删除。

输入描述:
每组数据为一行一个整数n(小于等于1000)，为数组成员数,如果大于1000，则对a[999]进行计算。

输出描述:
一行输出最后一个被删掉的数的原始下标位置。

输入例子1:
8

输出例子1:
6

用队列模拟，队首取数，用一个计数器计数，隔2个删一个，其他的重新放到队尾 #include<iostream>#include<queue>using namespace std;int main(){    int n;    while(cin>>n)    {        queue<int> q;        for(int i=0;i<n;i++)        {            q.push(i);        }        int count=0;        while(q.size()!=1)        {            if(count!=2)            {                int b=q.front();                q.pop();                q.push(b);                count++;            }            else            {                q.pop();                count=0;            }        }        int c=q.front();        cout<<c<<endl;    }    return 0;}

8
输入一个字符串，求出该字符串包含的字符集合

输入描述:
每组数据输入一个字符串，字符串最大长度为100，且只包含字母，不可能为空串，区分大小写。

输出描述:
每组数据一行，按字符串原有的字符顺序，输出字符集合，即重复出现并靠后的字母不输出。

输入例子1:
abcqweracb

输出例子1:
abcqwer

#include <iostream>#include <vector>#include <string>#include <algorithm>using namespace std;int main(){    string s;    vector<char> cvec;    while (cin >> s)    {        for (int i = 0; i < s.size(); ++i)        {            auto beg = find(cvec.begin(), cvec.end(), s[i]);            if (beg == cvec.end())            {                cvec.push_back(s[i]);                cout << s[i];            }        }              cout << endl;        s.clear();        cvec.clear();    }    return 0;}

9
数独是一个我们都非常熟悉的经典游戏，运用计算机我们可以很快地解开数独难题，现在有一些简单的数独题目，请编写一个程序求解。

输入描述:
输入9行，每行为空格隔开的9个数字，为0的地方就是需要填充的。

输出描述:
输出九行，每行九个空格隔开的数字，为解出的答案。

import java.util.*;public class Main{       public static void main(String[] args){        Scanner sc=new Scanner(System.in);        while(sc.hasNext()){            int[][] data=new int[9][9];            ArrayList<HashSet<Integer>> row=new ArrayList<HashSet<Integer>>();            ArrayList<HashSet<Integer>> col=new ArrayList<HashSet<Integer>>();            ArrayList<HashSet<Integer>> squ=new ArrayList<HashSet<Integer>>();            for(int i=0;i<9;i++){                row.add(new HashSet<Integer>());                col.add(new HashSet<Integer>());                squ.add(new HashSet<Integer>());            }            for(int i=0;i<9;i++){                for(int j=0;j<9;j++){                    data[i][j]=sc.nextInt();                    if(data[i][j]!=0){                        row.get(i).add(data[i][j]);                        col.get(j).add(data[i][j]);                        squ.get(i/3*3+j/3).add(data[i][j]);                    }                }            }            dfs(data,row,col,squ,0);            for(int i=0;i<9;i++){                for(int j=0;j<9;j++){                    if(j!=8)                        System.out.print(data[i][j]+" ");                    else                        System.out.println(data[i][j]);                }            }        }        sc.close();    }    public static boolean dfs(int[][] data,ArrayList<HashSet<Integer>> row,ArrayList<HashSet<Integer>> col,ArrayList<HashSet<Integer>> squ,int index){        if(index==81)            return true;               int m=index/9;        int n=index%9;        int k=m/3*3+n/3;        if(data[m][n]!=0){            return dfs(data,row,col,squ,index+1);        }        else{            for(int i=1;i<=9;i++){                if(!row.get(m).contains(i) && !col.get(n).contains(i) && !squ.get(k).contains(i)){                    data[m][n]=i;                    row.get(m).add(i);                    col.get(n).add(i);                    squ.get(k).add(i);                    if(dfs(data,row,col,squ,index+1))                        return true;                    data[m][n]=0;                    row.get(m).remove(i);                    col.get(n).remove(i);                    squ.get(k).remove(i);                }            }            return false;        }    }}