华为机试练习

1. 计算字符个数

输入 ABCDEF A           输出 1

#include <iostream>
#include <cstring>
using namespace std;
int main(){
    string str,res;
    getline(cin,str); //只能使用getline函数来读入直到换行符
    char ch;
    cin>>ch;
    int size=str.length(),sum=0,flag=0;
    if(ch>='A'&&ch<='Z') flag=1;    //注意ascall码，A-Z 65-90; a-z 97-122;相差32
    if(ch>='a'&&ch<='z') flag=2;
    for(int i=0;i<size;i++)
    	if(flag==1){
    		if(str[i]==ch||(str[i]-ch)==32) sum++;
		}
        else if(flag==2){
        	if(str[i]==ch||(ch-str[i])==32) sum++;
		}
		else if(str[i]==ch) sum++;
    cout<<sum<<endl;
    return 0;
}

2. 明明的随机数(注意的是测试有多组数，需要加while)　//可以用set，或者是其他的排序，桶排序

#include <iostream>
#include <algorithm>
using namespace std;
int main(){
    int n;
    while(cin>>n){
        if(n<0||n>1000) return 0;
        int inputArray[n];
        for(int i=0;i<n;i++){
            cin>>inputArray[i];
            if(inputArray[i]<1||inputArray[i]>1000) return 0;
        }
        sort(inputArray,inputArray+n);
        for(int i=0;i<n-1;i++){
            if(inputArray[i]!=inputArray[i+1]) cout<<inputArray[i]<<endl;
        }
        cout<<inputArray[n-1]<<endl;
    }
    return 0;
}

　　

#include <iostream>
#include <set>
using namespace std; 
int main(){
    int n=0;
    while (cin>>n)                 
    {
        int a[1000],i=0;
        for (int i=0;i<n;i++) cin>>a[i];
        set<int> num(a,a+n);        //使用set容器直接初始化
        for (set<int>::iterator it =num.begin();it!=num.end();it++){
            cout<<*it<<endl;
        }
    }
    return 0;
}

　3. 【中级】单词倒排

//直接写了如下的代码但是没有通过，是从后往前的，没有用额外的存储空间

#include <iostream>
#include <cstring>
using namespace std;
bool isword(char ch){
    if((ch>='A'&&ch<='Z')||(ch>='a'&&ch<='z')) return true;
    return false;
}
int main(){
    string s;
    getline(cin,s);
    int size=s.length(),i,j,flag=0,end;
    for(i=size-1;i>=0;i--){
        if((i==(size-1))&&isword(s[i])) end=i;
        if((i!=(size-1))&&isword(s[i])&&(!isword(s[i+1]))) end=i;
        if((isword(s[i])&&(i==0))||(isword(s[i])&&(!isword(s[i-1])))){
            if((end-i)>20) return 0;
            if(flag) cout<<' ';
            flag=1;
            for(j=i;i<=end;j++)   
                cout<<s[j];
        }
    }
    return 0;
}

　　

//使用vector来存储单词，从前往后，提交成功

#include<iostream>
#include<string>
#include<vector>
using namespace std;
bool isword(char ch){
    if((ch>='A'&&ch<='Z')||(ch>='a'&&ch<='z')) return true;
    return false;
}
int main(){
    string str;
    while(getline(cin,str)){
        vector<string> array;
        string temp;
        for(int i=0;i<=str.length();i++){    
            if(isword(str[i])&&str[i]!='')
                temp+=str[i];
            else{
                if(temp!="") array.push_back(temp); //注意可能两个单词之间有多个分隔符
                temp.clear();
            }
        }
        for(int i=array.size()-1;i>=0;i--){
            cout<<array[i];
            if(i!=0) cout<<' ';
        }
        cout<<endl;
    }
    return 0;
}

　　多线程

此题可以直接利用cout<<"ABCD"过，尝试如下代码，但是未成功，condition_variable应该是c++ 11内容

#include<iostream>
#include<mutex>
#include<condition_variable>
#include<string>
#include<thread>
using namespace std;
string res("");
mutex mtx;          //互斥量加锁
bool done = false;
condition_variable A, B, C, D;
void fun_A(int times) {   //times～次数
    while (times--) {
        unique_lock<mutex> locker(mtx);
        A.wait(locker);
        res += 'A';
        B.notify_one();
    }
    done = true;
}
void fun_B() {
    while (!done) {
        unique_lock<mutex> locker(mtx);
        B.wait(locker);
        res += 'B';
        C.notify_one();
    }
}
void fun_C() {
    while (!done) {
        unique_lock<mutex> locker(mtx);
        C.wait(locker);
        res += 'C';
        D.notify_one();
    }
}
void fun_D() {
    while (!done) {
        unique_lock<mutex> locker(mtx);
        D.wait(locker);
        res += 'D';
        A.notify_one();
    }
}
int main() {
    int num;
    while (cin >> num) {
        res = "";
        thread t1(fun_A, num);
        thread t2(fun_B);
        thread t3(fun_C);
        thread t4(fun_D);
        A.notify_one();
        t1.join();
        t2.join();
        t3.join();
        t4.join();
        cout << res << endl;
        done = false;
    }
    return 0;
}

　放苹果

　

对于样例的画图分析很重要（7，3）

#include <iostream>
using namespace std;
int count(int apple, int panzi){
    if(apple<=1||panzi==1) return 1;   //退出的判断条件很重要
    if(apple<panzi) return count(apple,apple);   //如果苹果比盘子多
    else return count(apple,panzi-1)+count(apple-panzi,panzi); //问题的归纳，然后递归做
}
//思想是分为两种情况：如果有1个空盘和如果没有空盘 f(m,n)=f(m,n-1)+f(m-n,n);
int main(){
    int apple,panzi;
    while(cin>>apple>>panzi){
        if(apple>10||apple<0||panzi>10||panzi<1) return 0;
        cout<<count(apple,panzi)<<endl;
        }
    return 0;
}

　　也可以不使用递归，采用动规，其实思想是一样的。

#include<iostream>
#include<vector>
using namespace std;
 
int main() {
    int a, p;
    while (cin>>a>>p) {
        if (a < 1 || a>10 || p < 1 || p>10) {
            cout<<-1<<endl;
            continue;
        }
        vector<vector<int>> dp(a+1,vector<int>(p+1,0)); //二维数组dp
        for (int i = 1; i <= p; i++) dp[0][i] = 1;  //初始化dp
        for (int i = 1; i <= a; i++)
            for (int j=1; j<= p;j++)
                dp[i][j]=dp[i][j-1]+(i<j?0:dp[i-j][j]); //计算dp
        cout<<dp[a][p]<<endl;
    }
    return 0;
}

　　简单错误记录

• 开发一个简单错误记录功能小模块，能够记录出错的代码所在的文件名称和行号。
• 注意这题的输入输出格式，输出最近的8条记录，而不是最老的8条

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

struct record{
    string file;
    int line;
    int count{1};
    bool operator==(const record &a){
        if(file==a.file&&line==a.line) return true;
        else return false;
    }
};

string getfilename(string file){
    int pos;
    pos=file.rfind('\');
    file=file.substr(pos+1,file.length()-pos); //使用rfind和substr函数获取
    if(file.length()>16)
        file=file.substr(file.length()-16,16);  //pos是从0开始的
    return file;
}

int main(){
    string file;
    int line,time;
    vector<record> error_record;  //8
    while(cin>>file>>line){
        record tmp;
        tmp.file=getfilename(file);
        tmp.line=line;
        bool flag=false;
        vector<record>::iterator it=error_record.begin();
        for(;it!=error_record.end();it++)   //使用algorithm中的find函数
            if(*it==tmp){
                flag=true;
                break;
            }
        if(flag) (*it).count+=1;
        else error_record.push_back(tmp);
        time++;
    }
    int size=error_record.size(),start=0;
    if(size>8) start=size-8;
    for(int i=start;i<size;i++)
        cout<<error_record[i].file<<" "<<error_record[i].line<<" "<<error_record[i].count<<endl;
    return 0;
}

　　成绩排序

 

• 也可以使用桶排序，准备101个桶，vector<S> v[101];

#include <iostream>
#include <algorithm>  //使用stable_sort函数保证稳定性
#include <cstring>
#include <vector>
using namespace std;

struct stu{
    string name;
    int score;
};

bool cmp1 (const stu &i,const stu &j) {
    return (i.score<j.score);   //升序 
}

bool cmp2 (const stu &i,const stu &j) {
    return (i.score>j.score);    //降序 
}

int main(){
    int n,flag;
    while(cin>>n>>flag){
        vector<stu> s(n);
        for(int i=0;i<n;i++)
            cin>>s[i].name>>s[i].score;
        if(flag)
            stable_sort(s.begin(),s.end(),cmp1);
        else
            stable_sort(s.begin(),s.end(),cmp2);
        for(int i=0;i<n;i++)
            cout<<s[i].name<<" "<<s[i].score<<endl;
    }
    return 0;
}

　　C++标准库中的sort函数原理：STL中定义了一个SORT_MAX变量来进行判断，如果大于SORT_MAX就使用快排，否则使用插排。因此，如果使用快排的话就不能保证稳定性