华为笔试题总结

IP地址交集判断

题目描述：输入四个IP端，前两个为第一个IP段的起始和终止地址，后两个是第二个IP段的起始和终止地址，判断这两个IP段是否存在交集

输入描述：输入4个IP

输出描述：如果存在交集，输出 Overlap IP ； 如果不存在交集，输出 No Overlap IP

#include<iostream>
#include<vector>
#include<string>
#include<stack>
using namespace std;
int main()
{
	string s1, s2, s3, s4;
	cin >> s1 >> s2 >> s3 >> s4;
	vector<int> ret1;
	vector<int> ret2;
	vector<int> ret3;
	vector<int> ret4;
	int a1 = 0;
	for (int i = 0;i < s1.size();i++)
	{		
		if (s1[i]!='.')
		{
			int tmp = s1[i] - '0';
			a1 = a1 *10+ tmp;
			
		}
		if(i==s1.size()-1||s1[i]=='.')
		{
			ret1.push_back(a1);
			a1 = 0;
		}
	}
	int a2 = 0;
	for (int i = 0;i < s2.size();i++)
	{
		if (s2[i] != '.')
		{
			int tmp = s2[i] - '0';
			a2 = a2 * 10 + tmp;

		}
		if (i == s2.size() - 1 || s2[i] == '.')
		{
			ret2.push_back(a2);
			a2 = 0;
		}
	}
	int a3 = 0;
	for (int i = 0;i < s3.size();i++)
	{
		if (s3[i] != '.')
		{
			int tmp = s3[i] - '0';
			a3 = a3 * 10 + tmp;

		}
		if (i == s3.size() - 1 || s3[i] == '.')
		{
			ret3.push_back(a3);
			a3 = 0;
		}
	}
	int a4 = 0;
	for (int i = 0;i < s4.size();i++)
	{
		if (s4[i] != '.')
		{
			int tmp = s4[i] - '0';
			a4 = a4 * 10 + tmp;

		}
		if (i == s4.size() - 1 || s4[i] == '.')
		{
			ret4.push_back(a4);
			a4 = 0;
		}
	}
	int count = 0;
	for (int i = 0;i < ret1.size();i++)
	{
		int a = ret1[i];
		int b = ret2[i];
		int c = ret3[i];
		int d = ret4[i];
		if (d<=b)
		{
			if (c >= a)
			{
				count++;
			}
		}
		else
		{
			if (c <= b)
			{
				count++;
			}
		}

	}
	if (count == 4)
		cout << "overlap IP" << endl;
	else
		cout << "NO OVERLAP" << endl;
	return 0;
}

进制转换

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

输入例子1:
0xA

输出例子1:
10

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<vector>
#include<string>
#include<stack>
#include<set>
#include<math.h>
#include<algorithm>
using namespace std;
int main()
{
	//freopen("Text.txt", "r", stdin);
	string str;
	while (cin >> str)
	{
		int len = str.size();
		int result=0;
		for (int i = len - 1;i > 1;i--)
		{
			if (str[i] >= '0'&&str[i] <= '9')
			{
				result += (str[i] - '0')*pow(16,len-i-1);
			}
			else if(str[i]>='A'&&str[i]<='F')
			{
				result += (str[i] - 55)*pow(16, len-i-1);
			}
		}
		cout << result << endl;
	}
	return 0;
}

明明的随机数

明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了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

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<vector>
#include<string>
#include<stack>
#include<set>
using namespace std;
int main()
{
	//freopen("Text.txt", "r", stdin);
	int n;
	while (cin >> n)
	{
		set<int> ret;
		while (n)
		{
			int a;
			cin >> a;
			ret.insert(a);
			n--;
		}
		for (set<int>::iterator it = ret.begin();it != ret.end();it++)
		{
			printf("%d\n", *it);
		}
	}
	return 0;
}

汽水瓶

有这样一道智力题：“某商店规定：三个空汽水瓶可以换一瓶汽水。小张手上有十个空汽水瓶，她最多可以换多少瓶汽水喝？”答案是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

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<vector>
#include<string>
#include<stack>
using namespace std;
int main()
{
	//freopen("Text.txt", "r", stdin);
	int n;
	while (cin>>n&&n)
	{
		int ret = 0;
		int tmp = n;
		while (tmp/3>0)
		{	
			int a = tmp / 3;
			int b = tmp % 3;
				ret += a;
				tmp =a+b==2?3:(a+b);

		}
		cout << ret << endl;
	}

	return 0;
}

删数

有一个数组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

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<vector>
#include<string>
#include<stack>
#include<set>
#include<math.h>
#include<algorithm>
using namespace std;
int main()
{
	//freopen("Text.txt", "r", stdin);
	int num;
	while(cin >> num)
	{
		vector<int> s;
		for (int i = 0;i < num;i++)
		{
			s.push_back(i);
		}
		int l = 3;
		int k = 0;
		int i = 0;
		while (1)
		{
			if (i == s.size())
			{
				i = 0;
			}
			if (s[i] != -1)
			{
				l--;
			}
			if (l == 0)
			{
				s[i] = -1;
				l = 3;
				k++;
				if (k == s.size())
				{
					cout << i << endl;
					break;
				}

			}
			i++;
		}
	}
	return 0;
}

数字处理

题目描述：给出一个不多于5位的整数，进行反序处理，要求

（1）求出它是几位数

（2）分别输出每一个数字（空格隔开）

（3）按逆序输出各位数字（仅数字间以空格间隔，负号与数字之间不需要间隔）

输入描述：位数不大于5的整数

输出描述：1.整数位数 2.空格间隔输出结果 3.逆序整数

#include<iostream>
#include<vector>
#include<string>
#include<stack>
using namespace std;
int main()
{
	string num;
	cin >> num;
	stack<char> ret;
	char opt = num[0];
	if (opt == '-') {
		cout << num.size() - 1 << endl;
	}
	else
	{
		cout << num.size() << endl;
	}
	for (int i = 0;i < num.size();i++)
	{
		if (num[i] == '-')
		{
			cout << num[i];
		}
		else
		{
			cout << num[i] << " ";
		}	
	}
	cout << endl;
	for (int i = 0;i < num.size();i++)
	{
		if(num[i]>='0'&&num[i]<='9')
			ret.push(num[i]);
	}
	if (num[0] == '-')
	{
		cout << num[0];
	}
	while (!ret.empty())
	{
		char a = ret.top();
		cout << a << " ";
		ret.pop();
	}
	cout << endl;
	return 0;
}

字符集合

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

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

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

输入例子1:
abcqweracb

输出例子1:
abcqwer

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<vector>
#include<string>
#include<stack>
#include<set>
#include<math.h>
#include<algorithm>
using namespace std;
int main()
{
	//freopen("Text.txt", "r", stdin);
	string str;
	while (cin >> str)
	{
		set<char> ret;
		vector<char> res;
		string result = "";
		for (int i = 0;i < str.size();i++)
		{
			if (ret.find(str[i]) != ret.end())
			{
				continue;
			}
			ret.insert(str[i]);
			res.push_back(str[i]);
		}
		for(int i=0;i<res.size();i++)
		{
			result += res[i];
		}
		cout << result << endl;
	}
	return 0;
}

字节流解析

根据数值占用BIT数，按顺序从输入字节流中解析出对应数值，解析顺序按输入数组astElement索引升序；
void Decode(unsigned int uiInputLen, unsigned char aInputByte[], unsigned int uiElementNum, ELEMENT_STRU astElement[]);
unsigned int uiInputLen：字节数组（流）长度
unsigned char aInputByte：字节数组（流）
unsigned int uiElementNum：解析数值个数
ELEMENT_STRU astElement[]：数值的结构数组指针，含义如下
Struct
{
unsigned int uiElementLength; //表示uiElementValue占用BIT数，范围1~32
unsigned int uiElementValue; //从字节流中按顺序解析的数值，用于输出
}ELEMENT_STRU;

输入描述:
字节数组长度uiIutputLen为3；
字节数组aInputByte[3]为{0x62, 0x80, 0x00}，对应二进制为“0110 0010, 1000 0000, 0000 0000”；
解析数值个数uiElementNum为2；
数值[0]的值占4个bit，即astElement[0].uiElementLength = 4；
数值[1]的值占5个bit，即astElement[1].uiElementLength = 5；
输出描述:
数值[0]的值为6，二进制为“0110”，即astElement[0].uiElementValue = 6；
数值[1]的值为5，二进制为“0010 1”，即astElement[1].uiElementValue = 5；

示例1
输入
3
0x62 0x80 0x00
2
4
5
输出
6
5

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <algorithm>
#include<vector>
#include<string>
#include<sstream>
#include<set>
using namespace std;

void HextoTwo(int num,string &ret)
{
	int remainder;
	char buf[16][5] = { "0000","0001","0010","0011",\
		"0100","0101","0110","0111",\
		"1000","1001","1010","1011",\
		"1100","1101","1110","1111" };
	if (0 == num)
		return;
	remainder = num % 16;
	HextoTwo(num >> 4,ret);
	ret += buf[remainder];
}

int main()
{

	//freopen("Text.txt", "r", stdin);
	int num;
	cin >> num;
	string ret = "";
	while (num)
	{
		int a;
		cin >> hex >> a;//以十六进制方式输入
		HextoTwo(a,ret);
		num--;
	}
	int a;
	cin >> a;
	vector<string> bit;
	int j = 0;
	while (a)
	{
		int k;
		cin >> k;	
		string tmp = "";
		int l = j + k;
		for (j;j < l;j++)
		{
			tmp += ret[j];
		}
		bit.push_back(tmp);		
		a--;
	}
	for (int i = 0;i < bit.size();i++)
	{
		string s = bit[i];
		int n = 0;
		for (int j = s.length()-1;j >= 0;j--)//二进制字符串转为十进制数
		{
			int number = s[j] - '0';
			n += number*pow(2, s.length()-j-1);
		}
		cout << n << endl;
	}

	return 0;
}

最长数字字符串

给定一个字符串，输出字符串中最长的数字串，并把这个数字串的长度输出。

请一个在字符串中找出连续最长的数字串，并把这个串的长度返回；如果存在长度相同的连续数字串，返回最后一个连续数字串；

注意：数字串只需要是数字组成的就可以，并不要求顺序，比如数字串“1234”的长度就小于数字串“1359055”，如果没有数字，则返回空字符串（“”）而不是NULL！

输入描述:
一个字符串
输出描述:
输出最长的数字串,输出最长数字串个数；
中间以逗号(,)隔开；

示例1
输入
abcd12345ed125ss123058789
输出
123058789,9

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<algorithm>
#include<vector>
#include<stack>
#include<string>
using namespace std;
bool cmp(string &a,string &b)
{
    return a.length()>b.length();
}
int main()
{
	//freopen("Text.txt","r",stdin);
	string str;
	while(cin>>str)
    {
        string ret = "";
        vector<string> vec;
        for (int i = 0;i < str.length();i++)
        {
            if (str[i] >= '0' && str[i] <= '9')
            {
                ret += str[i];
                if(i==str.length()-1)
                    vec.push_back(ret);
            }
            else
            {
                if (ret.length() != 0)
                {
                    vec.push_back(ret);
                    ret.clear();
                }

            }
        }
        string result = "";
        sort(vec.begin(),vec.end(),cmp);
        int l=vec[0].length();
        for(int i=0;i<vec.size();i++)
        {
            if(vec[i].length()==l)
                result+=vec[i];
        }
        cout << result << "," << l << endl;
    }
	return 0;
}

跳跃比赛

题目描述
给出一组正整数，你从第一个数向最后一个数方向跳跃，每次至少跳跃1格，每个数的值表示你从这个位置可以跳跃的最大长度。计算如何以最少的跳跃次数跳到最后一个数。

输入描述:
第一行表示有多少个数n
第二行开始依次是1到n个数，一个数一行
输出描述:
输出一行，表示最少跳跃的次数。
示例1
输入
7
2
3
2
1
2
1
5
输出
3

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<sstream>
#include<vector>
#include<stack>
#include<string>
using namespace std;

int main()
{
	//freopen("Text.txt", "r", stdin);
	int n;
	cin >> n;
	vector<int> ret;
	while (n)
	{
		int l;
		cin >> l;
		ret.push_back(l);
		n--;
	}
	if (ret.size() < 2)
		cout << 0 << endl;
	else
	{
		int cur_max = ret[0];//当前跳跃的最大距离
		int pre_max = ret[0];//之前跳跃的最大距离
		int jump = 1;
		for (int i = 1;i < ret.size();i++)
		{
			if (i > cur_max)
			{
				jump++;
				cur_max = pre_max;
			}
			if (pre_max < i + ret[i])
				pre_max = i + ret[i];//更新最大达到的距离
		}
		cout << jump << endl;
	}
	return 0;
}

字符串处理

输入描述：

1、忽略小数点，例如“A1.2”，认为包含整数1和2；

2、如果整数的左侧出现“-”，则奇数个数认为是负整数，偶数个数认为是正整数。例如AB-1CD--2EF---3“”,认为包含整数-1、2和-3。

输出描述：

输出即为字符串中所有整数数字之和。

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<sstream>
#include<vector>
#include<stack>
#include<string>
#include<algorithm>
#include<map>
using namespace std;

int main()
{
	//freopen("Text.txt", "r", stdin);
	string str;
	cin >> str;
	int num = 0;
	int flag = 0;
	vector<int> ret;
	str += "a";//以a结束，减少一条结束判断语句
	for (int i = 0;i < str.length();i++)
	{
		if (str[i] >= '0'&&str[i] <= '9')
		{
			num += str[i] - '0';
		}
		else if (str[i] == '-')
		{
			flag = 1;
			continue;
		}
		else
		{
			if (num != 0)
			{
				if (flag)
				{
					num % 2 == 0 ? num = num:num = -num;
				}
				ret.push_back(num);
			}
			flag = 0;
			num = 0;
		}
	}
	int sum = 0;
	for (int i = 0;i < ret.size();i++)
		sum += ret[i];
	cout << sum << endl;
	return 0;
}