华为机试——数字处理专题

HJ5进制转换（多组同时输入 ）

整数的范围：

int 占4个字节范围为：-2^31 ~ 2^31-1
longlong占8个字节 -2^63 ~ 2^63-1

HJ10字符个数统计

关于空字符’\n’ ; 空格字符’ ’ ; 0字符’0’

#include <iostream>
#include <unordered_map>
//#include <string.h>

using namespace std;

int main(){
    // 统计个数想到hash
    unordered_map <char, int> hash; // hash[a] =0 字符a出现0次
    //const int N=10010;
    //char c[N];
    //gets(c);
    //for(int i =0; i<c.size(); i++){
    //  hash[c[0]]=1; // hash[char]=1;
    //}
    char c; // 字符一个个输入 
    while(cin>>c) hash[c]=1; // 出现过的key字符其value都为1
    // 开始总计出现次数
    int sum=0;
    for(int i =0; i<hash.size(); i++){
        // ascii 0 ' '
        if(hash[' '+i]==1) // 怎么遍历字母h[char], 通过这种方式
            sum++;
    }
    cout << sum << endl;
    return 0;
    
}

HJ25数字分类处理

主要思路：

1. 先看看测试的输入输出，如何把数据输入进来，有空格那就用cin一个个输入并用vector保存吧
2. 保存好vector R、I后，按照题意先对R进行排序去重
3. 拿R[i]与I进行match
   需要对照着测试输出，30, 3,6,0,123,3,453,7,3,9,453456,13,453,14,123
   用 R_word cnt index value依次保存这些数，再输出

// 对于这道题要用到字符串匹配
// 题目描述这么多，最后干的事是
// 将规则数组排序(从小到大)，并去重
// 遍历输入数组，检查输入数组的每个元素是是否包含规则数组中的数字i,
// 如果包含则将输入数组元素位置和元素输出到最终结果中

#include <iostream>
#include <vector>
#include <algorithm>
#include <string.h>

using namespace std;

// 子集R[i]在I中
// 还有另外一种写法  strstr(d, c)
bool match(int r, int i){
    string strr=to_string(r);
    string stri=to_string(i);
    int pos=stri.find(strr);
    
    if(pos!=-1)
        return true;
    return false;
    
}
int main(){
    int Inum, Rnum;
    //15 123 456 786 453 46 7 5 3 665 453456 745 456 786 453 123 ：15是Inum,每个数用空格隔开
    //5 6 3 6 3 0
    while(cin >> Inum){
        vector<int> I, R;
        // 把I R序列存起来
        for(int i=0; i<Inum; i++){
            int temp;
            cin>>temp; // 第一次存123， 下次循环存456
            I.push_back(temp);
        }
        
        cin>>Rnum;
        for(int i=0; i<Rnum; i++){
            int temp;
            cin >> temp;
            R.push_back(temp);
        }
        
        // 1.R排序 去重
        sort(R.begin(), R.end());
        R.erase(unique(R.begin(), R.end()), R.end()); // 去重
        
        
        // 2.R[i]去匹配I
        vector<int> value, cnt, index, R_word;
        
        for(int i=0; i<R.size();i++){
            //30, 3,6,0,123,3,453,7,3,9,453456,13,453,14,123,6,7,1,456,2,786,4,46,8,665,9,453456,11,456,12,786
            int cnt1=0; // 记录R[i]在I中出现的次数
            for(int j=0; j<I.size(); j++){
                // if(找子集)
                if(match(R[i], I[j])){
                    cnt1++;
                    index.push_back(j); // 找到的数在I中的索引
                    value.push_back(I[j]); // 找到的数
                }
            }
            
            if(cnt1!=0){ // R[i]在I中有
                cnt.push_back(cnt1); // 保存R[i]在I[i]中的个数记录:R[i]的个数6
                // 同时push R[i]
                R_word.push_back(R[i]); // 相应的保存：R[i]=3
            }
        }
        
        // 接下来定义输出
        
        //30, 3,6,0,123
        int sum=R_word.size()+cnt.size()+index.size()+value.size(); // 30=3+6+0+123's size()
        cout << sum <<" "; // 举例子用逗号，实际输出空格
        // 输出R[i] CNT INDEX I[INDEX]
        int j=0;
        for(int i=0; i<cnt.size(); i++){
            cout<< R_word[i]<<' '<< cnt[i] << ' ';
            // INDEX I[INDEX]
            while((cnt[i]--)>0){
                //cout << index[j] << ' ' << value[j] << ' ';
                cout << index[j] << ' ' << value[j];
                if(i==cnt.size()-1 && cnt[i]==0)
                    cout << endl; // 结束一个测试用例的输出
                else
                    cout << ' '; // 当前测试用例没有输完，继续空格输入
                j++;
            }
        }

        
    }
    return 0;
}

HJ33整数与IP地址之间的转换

主要思路：

1. 移位计算
2. 注意用long保存十进制数，防止数组越界

#include <iostream>
#include <string>
using namespace std;

int main(){
    unsigned int a, b, c, d; // 10.0.3.193 
    // 小心数组越界，因为如果是int,只有31位，最高位为符号位并不能被使用，所以左移24很可能就溢出
    // 如果a=129就越界，因为2^31 高8位为：2^7=128, 最大放128的数
    // long a, b,c,d; // 也可
    char dot;
    // 用cin输入时,系统也会根据变量的类型从输入流中提取相应长度的字节
    while(cin>> a >> dot >> b >> dot >> c>> dot >> d){
        // 10.0.3.193 -> 167773121
        cout << (a<<24)+(b<<16)+(c<<8)+(d) << endl; // 小心数组越界，因为如果是int,只有31位，最高位为符号位并不能被使用，所以左移24很可能就溢出
        
        // 输入10进制
        long shi;
        cin>>shi;
        // 167969729->10.0.3.193
        cout<<((shi&0xff000000)>>24)<<'.'<<((shi&0x00ff0000)>>16)<<'.'<<((shi&0x0000ff00)>>8)<<'.'<<(shi&0x000000ff) << endl;
    }
    return 0;
}

HJ39判断两个ip是否属于同一子网

主要思路:

1. 处理输入，用cin+ dot;
2. 掩码与IP1、IP2输入后，先判断输入是否非法
3. 再通过&运算，判断是否相等

#include <iostream>

using namespace std;

int main(){
    // 先定义 然后处理输入 用cin char dot
    int mask1=0, mask2=0, mask3 =0, mask4=0; // 255.255.255.0
    int ip1a=0, ip1b=0, ip1c=0, ip1d=0;
    
    int ip2a=0, ip2b=0, ip2c=0, ip2d = 0;
    char ch;
    
    while(cin>>mask1>>ch>>mask2>>ch>>mask3>>ch>>mask4){
        cin>>ip1a>>ch>>ip1b>>ch>>ip1c>>ch>>ip1d;
        cin>>ip2a>>ch>>ip2b>>ch>>ip2c>>ch>>ip2d;
        
        // 输入处理完毕，现在看输入是否非法
        if((mask1>255 || mask1<0) || (mask2>255 || mask2<0)||(mask3>255 || mask3<0)||(mask4>255 || mask4<0)
          ||(ip1a>255 || ip1a<0)||(ip1b>255 || ip1b<0)||(ip1c>255 || ip1c<0)||(ip1d>255 || ip1d<0)
          ||(ip2a>255 || ip2a<0)||(ip2b>255 || ip2b<0)||(ip2c>255 || ip2c<0)||(ip2d>255 || ip2d<0)){
            cout << 1 << endl;
        }
        // 输入不非法，开始判断and后是否相等
        else if(((mask1&&ip1a)==(mask1&&ip2a))
               && ((mask2&&ip1b)==(mask1&&ip2b))
               && ((mask3&&ip1c)==(mask1&&ip2c))
               && ((mask4&&ip1d)==(mask1&&ip2d))){
            cout << 0 << endl;
        }
        else{
           // 输入不非法，但是也不相等
            cout << 2 << endl;
        }
    }
    
    return 0;
}