【牛客华为机试C++实现】

最新推荐文章于 2023-04-09 20:32:57 发布
最新推荐文章于 2023-04-09 20:32:57 发布
阅读量301 收藏 3
点赞数
分类专栏： C++ 文章标签： c++ 华为 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45126405/article/details/129145818
版权
  1. HJ1字符串最后一个单词的长度
#include <iostream>
using namespace std;

int main() {
    
    string s1;
    getline(cin,s1);
    int ans=0;
    int i=s1.length()-1;
    while(i>=0 && s1[i]!=' ')
    {
        i--;
        ans++;
    }
    cout<<ans;
    return 0;   
}

2.HJ2计算某字符出现的次数

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

int main() {
    
    string s;
    char ch;
    getline(cin,s);//string字符串只能这样子输入
    cin>>ch;
    
    int num=0;
    //int j=s.length()-1;
    ch=tolower(ch);
    for(int i=0;i<s.length();i++)
    {
        if(tolower(s[i])==ch)
        {
            num++;
        }

    }
    cout<<num<<endl;
    return 0;  
}

3.HJ3明明的随机数

#include <iostream>
using namespace std;

int main() {
    int arr[1001] = { 0 };
	int n;
	cin >> n;
	while (n--)
	{
		int num;
		cin >> num;
		arr[num] = 1;
	}
	for (int i = 0; i < 1001; i++)
	{
		if (arr[i] == 1)
		{
			cout << i << endl;
		}
	}
}

4.HJ4字符串分割

#include <iostream>
using namespace std;

int main() {
    string s;
	getline(cin, s);
	int a = s.length();
	int b = a % 8;
	if (b != 0)
	{
		b = 8 - b;
		string new_s;
		for (int i = b; i > 0; i--)
		{
			new_s.append("0");

		}
		s.append(new_s);
	}
	a = s.length();
	for (int i = 0; i < a; i += 8)
	{
		string ss;
		ss = s.substr(i, 8);
		cout << ss << endl;
	}
    return 0;
}

5.HJ5进制转换

#include <iostream>
#include<math.h>
using namespace std;

int main() {
    //进制转换，将16进制转换为10进制
	string s;
	getline(cin, s);
	s = s.erase(0,2);
	int i = s.length() - 1;
	int ans = 0;
	for (i; i >= 0; i--)
	{
		if (s[i] >= '0'&&s[i] <= '9')
		{
			ans += (s[i] - '0')*pow(16, s.length() - i-1);//
		}
		else
		{
			ans += (s[i] - 'A'+10)*pow(16, s.length() - i-1);
		}
	}
    cout<<ans<<endl;
    return 0;
}

7.HJ7取近似值

#include <iostream>
#include<math.h>
using namespace std;

int main()
{
	double a, b;
	cin >> a;
	a=modf(a,&b);
	if (a >= 0.5)
	{
		cout << int(b + 1) << endl;

	}
	else
	{
		cout << int(b) << endl;
	}
	system("pause");
	return 0;
}

8.HJ8合并表记录

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

//合并表记录
int main()
{
	int num;
	cin >> num;
	map<int, int>arr;
	bool flag = false;
	while (num>0)
	{
		
		
		int a, b;
		cin >> a >> b;
		flag = false;
		for (map<int, int>::iterator it = arr.begin(); it != arr.end(); it++)
		{
			if (it->first == a)
			{
				arr[a] = arr[a] + b;
				flag = true;
				break;

			}
		}
		if (arr.size()==0||flag != true)
		{
			arr[a] = b;
		}
		
		num--;
				
	}
	
	for (map<int, int>::iterator it = arr.begin(); it != arr.end();it++)
	{
		cout << it->first << " " << it->second << endl;

	}
	
	system("pause");
	return 0;
}

10.HJ10字符个数统计

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

int main() {
    string s;
	getline(cin, s);
	char hash[128] = { -1 };
	int i = s.length() - 1;
	int num = 0;
	for (int j = 0; j <= i; j++)
	{
		
		if (hash[int(s[j])] != s[j])
		{
			hash[int(s[j])] = s[j];
			num++;
		}
	}
	cout << num << endl;
}

12.HJ12字符串反转

#include <iostream>
using namespace std;

int main() {
    string s;
	getline(cin, s);
	int a = s.length();
	if (a == 1)
	{
		cout << s << endl;
		return 0;
	}
	int j = 0;
	string s1=s;
	for (int i = a - 1; i >= 0; i--)
	{
		
		s1[j] = s[i];
		j++;
	}
	cout << s1 << endl;

}

14.HJ14字符串排序

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

int main() {
    int a;
	cin >> a;
	vector<string>v_s;
	while (a > 0)
	{
		string s;
        cin>>s;
		//getline(cin, s);
		v_s.push_back(s);
        a--;
	}
	sort(v_s.begin(), v_s.end());
	for (int i = 0; i < v_s.size(); i++)
	{
		cout << v_s[i] << endl;
	}
}

17.HJ17坐标移动

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

int main() {
   string s;
	getline(cin, s);//会有换行符
	vector<string>v_s;
	//int a = s.find(";");
	int x = 0;
	int y = 0;
	int length = s.length();
    int len = 0;
	for (int i = 0; i < length; i++)
	{
		
		if (s[i] != ';')
		{
			len++;
			continue;
			
		}
		string sub = s.substr(i - len, len);
		v_s.push_back(sub);
        len = 0;
	}

	for (int i = 0; i < v_s.size(); i++)
	{
		int num = 0;
		if (v_s[i].length() == 3 && v_s[i][1] >= '0' && v_s[i][1] <= '9' && v_s[i][2] >= '0' && v_s[i][2] <= '9')
		{
			num = (v_s[i][1] - '0') * 10 + (v_s[i][2] - '0');
		}
		else if (v_s[i].length() == 2 && v_s[i][1] >= '0' && v_s[i][1] <= '9')
		{
			num = v_s[i][1] - '0';
		}
		switch (v_s[i][0])
		{
		case 'A':
			x = x - num;
			break;
		case 'D':
			x = x + num;
			break;
		case 'S':
			y = y - num;
			break;
		case 'W':
			y = y + num;
			break;
        default:
            break;
		}					
	}
	
	cout << x << "," << y << endl;
}

18.HJ18识别有效的IP地址和掩码并进行分类统计

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

//将string255.255.255转为int并存入容器
vector<int> toint(string str)
{
	vector<int>test;
	int len = 0;
	for (int i = 0; i < str.size(); i++)
	{
		
		while (str[i] != '.'&&i < str.size())
		{
			len++;
			i++;
			//continue;
		}
		string s = str.substr(i - len, len);
		if (s != "")
		{
			int num = stoi(s);
			test.push_back(num);
			len = 0;
		}
		
	}
	return test;
}


//判断掩码是否合法
bool ismask(vector<int>mask_v)
{
	if (mask_v.size() != 4)
	{
		return false;
	}
	if ((mask_v[0] <= 255) && (mask_v[0] >= 0) && (mask_v[1] <= 255) && (mask_v[1] >= 0) && (mask_v[2] <= 255) && (mask_v[2] >= 0) && (mask_v[3] <= 255) && (mask_v[3] >= 0))
	{
		if (mask_v[0] == 255)
		{
			if (mask_v[1] == 255)
			{
				if (mask_v[2] == 255)
				{
					if (mask_v[3] == 254 || mask_v[3] == 252 || mask_v[3] == 248 || mask_v[3] == 240 || mask_v[3] == 224 || mask_v[3] == 192 || mask_v[3] == 128 || mask_v[3] == 0)
					{
						return true;
					}
					else
					{
						return false;
					}

				}
				else if (mask_v[2] == 254 || mask_v[2] == 252 || mask_v[2] == 248 || mask_v[2] == 240 || mask_v[2] == 224 || mask_v[2] == 192 || mask_v[2] == 128 || mask_v[2] == 0)
				{
					if (mask_v[3] == 0)
					{
						return true;
					}
					else
					{
						return false;
					}
				}
			}
			else if (mask_v[1] == 254 || mask_v[1] == 252 || mask_v[1] == 248 || mask_v[1] == 240 || mask_v[1] == 224 || mask_v[1] == 192 || mask_v[1] == 128 || mask_v[1] == 0)
			{
				if (mask_v[2] == 0 && mask_v[3] == 0)
				{
					return true;
				}
				else
				{
					return false;
				}
			}
		}
		else if (mask_v[0] == 254 || mask_v[0] == 252 || mask_v[0] == 248 || mask_v[0] == 240 || mask_v[0] == 224 || mask_v[0] == 192 || mask_v[0] == 128)
		{
			if (mask_v[1] == 0 && mask_v[2] == 0 && mask_v[3] == 0)
			{
				return true;
			}
			else
			{
				return false;
			}
		}
	}
	return false;
}




int main()
{
	
	//识别有效的IP地址和掩码
	vector<int>outcome(7,0);//最后打印的7个数字；
	string s;
	
	while (cin >> s)
	{
		vector<string>temp;
		int len = 0;
		for (int i = 0; i < s.length(); i++)
		{
			while (s[i] != '~'&&i<s.length())
			{
				len++;
				i++;
				//continue;
			}
			string s1 = s.substr(i - len, len);
			temp.push_back(s1);//从字符串中获取IP和子网掩码
			len = 0;
		}
		string ips = temp[0];//分割出来的ip
		string masks = temp[1];//分割出来的掩码
		vector<int>ip, mask;
		ip = toint(ips);
		mask = toint(masks);

		if ((ip[0] == 0) || (ip[0] == 127))
		{
			//不属于合法IP地址，计数时直接忽略
			continue;
		}

		//判断IP和掩码是否合法 ip和掩码分别为4位，如果不为8，则非法
		if (ip.size() + mask.size() == 8 )
		{
			if (ismask(mask))//掩码合法
			{
				if (ip[1] >= 0 && ip[1] <= 255 && ip[2] >= 0 && ip[2] <= 255 && ip[3] >= 0 && ip[3] <= 255)
				{
					if (ip[0] >= 1 && ip[0] <= 126)//A类
					{
						outcome[0]++;
						if (ip[0] == 10)
						{
							outcome[6]++;
						}
					}
					else if (ip[0] >= 128 && ip[0] <= 191)//B类
					{
						outcome[1]++;
						if (ip[0] == 172 && ip[1] >= 16 && ip[1] <= 31)
						{
							outcome[6]++;
						}
					}
					else if (ip[0] >= 192 && ip[0] <= 223)//C类
					{
						outcome[2]++;
						if (ip[0] == 192 && ip[1] == 168)
						{
							outcome[6]++;
						}
					}
					else if (ip[0] >= 224 && ip[0] <= 239)//D类
					{
						outcome[3]++;
					}
					else if (ip[0] >= 240 && ip[0] <= 255)//E类
					{
						outcome[4]++;
					}
					else
					{
						outcome[5]++;
					}
				}
			}
			else
			{
				outcome[5]++;
			}
			
		}
		else
		{
			outcome[5]++;
		}

		
	}
	
	for (int i = 0; i < outcome.size(); i++)
	{
		cout << outcome[i] << " ";
	}
	system("pause");
	return 0;
}

19.HJ19简单的错误记录

#include <iostream>
using namespace std;

struct recoder
{
	string s_filename;
	int s_hangshu;
	int s_num;
};
int main()
{
	string s;
	recoder rec[50];
	string filename;
	int hangshu;
	int num = 0;//记录总记录条数，不超过8
	while (getline(cin,s))
	{
		
		int flag = 0;
		
		int index = s.find_last_of("\\");
		int index2 = s.find_last_of(" ");
		int ci = stoi(s.substr(index2 + 1));
		s = s.substr(index + 1, index2 - index-1);
		if (s.length() > 16)
		{
			s = s.substr((s.length() - 16) , 16);
		}
		
		

		for (int i = 0; i < num; i++)
		{
			if (s == rec[i].s_filename&&ci == rec[i].s_hangshu)
			{
				rec[i].s_num++;
				flag = 1;
				break;
			}
		}
		if (flag != 1)
		{
			rec[num].s_filename = s;
			rec[num].s_hangshu = ci;
			rec[num].s_num = 1;
			num++;
		}


	}
	int i = 0;
	if (num > 8)
	{
		i = num - 8;
	}
	else
	{
		i = 0;
	}
	for (i; i < num; i++)
	{
		cout << rec[i].s_filename << " " << rec[i].s_hangshu << " " << rec[i].s_num << endl;
	}
	system("pause");
	return 0;
}

25.HI25数据分类处理

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

using namespace std;

bool match(int r, int i)
{
	string rr = to_string(r);
	string ii = to_string(i);
	int index = ii.find(rr);
	if (index != std::string::npos)
	{
		return true;
	}
	else
	{
		return false;
	}

}
int main()
{
	int Inum, Rnum;
	while (cin >> Inum)
	{
		vector<int>I, R;
		for (int i = 0; i < Inum; i++)
		{
			int in;
			cin >> in;
			I.push_back(in);
		}
		cin >> Rnum;
		for (int i = 0; i < Rnum; i++)
		{
			int rn;
			cin >> rn;
			R.push_back(rn);
		}
		sort(R.begin(), R.end());//排序
		R.erase(unique(R.begin(), R.end()), R.end());//去重
		vector<int>ivalue, index, cntsize, rvalue;
		for (int i = 0; i < R.size(); i++)
		{
			int cnt = 0;//记录R在I里面出现的数量
			for (int j = 0; j < I.size(); j++)
			{
				if (match(R[i],I[j]))
				{
					cnt++;
					index.push_back(j);//下标
					ivalue.push_back(I[j]);//具体的值
				}
			}
			if (cnt != 0)
			{
				cntsize.push_back(cnt);
				rvalue.push_back(R[i]);
				
			}

		}

		int sum = ivalue.size() + index.size() + cntsize.size() + rvalue.size();
		cout << sum << " ";
        int j = 0;
		for (int i = 0; i < rvalue.size(); i++)
		{
			cout << rvalue[i] << " " << cntsize[i] << " ";
			
			while (cntsize[i]--)
			{
				cout << index[j] << " " << ivalue[j] << " ";
				j++;
			}
		}
		
	}
	system("pause");
	return 0;
}

28.HJ28素数伴侣

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

using namespace std;

bool match(int r, int i)
{
	string rr = to_string(r);
	string ii = to_string(i);
	int index = ii.find(rr);
	if (index != std::string::npos)
	{
		return true;
	}
	else
	{
		return false;
	}

}
int main()
{
	int Inum, Rnum;
	while (cin >> Inum)
	{
		vector<int>I, R;
		for (int i = 0; i < Inum; i++)
		{
			int in;
			cin >> in;
			I.push_back(in);
		}
		cin >> Rnum;
		for (int i = 0; i < Rnum; i++)
		{
			int rn;
			cin >> rn;
			R.push_back(rn);
		}
		sort(R.begin(), R.end());//排序
		R.erase(unique(R.begin(), R.end()), R.end());//去重
		vector<int>ivalue, index, cntsize, rvalue;
		for (int i = 0; i < R.size(); i++)
		{
			int cnt = 0;//记录R在I里面出现的数量
			for (int j = 0; j < I.size(); j++)
			{
				if (match(R[i],I[j]))
				{
					cnt++;
					index.push_back(j);//下标
					ivalue.push_back(I[j]);//具体的值
				}
			}
			if (cnt != 0)
			{
				cntsize.push_back(cnt);
				rvalue.push_back(R[i]);
				
			}

		}

		int sum = ivalue.size() + index.size() + cntsize.size() + rvalue.size();
		cout << sum << " ";
        int j = 0;
		for (int i = 0; i < rvalue.size(); i++)
		{
			cout << rvalue[i] << " " << cntsize[i] << " ";
			
			while (cntsize[i]--)
			{
				cout << index[j] << " " << ivalue[j] << " ";
				j++;
			}
		}
		
	}
	system("pause");
	return 0;
}

44.HJ44Sudoku

#include <bits/stdc++.h>
using namespace std;
int arr[9][9];
bool flag = false;
bool check(int n)
{
	int h = n / 9;
	int l = n % 9;
	for (int i = 0; i <9; i++)
	{
		if (i != h && arr[i][l] == arr[h][l])//发现重复列元素
		{
			return false;
		}
	}


	for (int j = 0; j < 9; j++)
	{
		if (j != l && arr[h][j] == arr[h][l])//发现重复行元素
		{
			return false;
		}
	}


	for (int i = h / 3 * 3; i < h / 3 * 3 + 3; i++)
	{
		for (int j = l / 3 * 3; j < l / 3 * 3 + 3; j++)
		{
			if ((i != h || j != l) && arr[i][j] == arr[h][l])
			{
				return false;
			}
		}
	}
	return true;
}
void dfs(int n)//n是元素的数目，9宫格就是9*9=81，n是81
{
	if (n == 81)//n是81就直接输出
	{
		for (int i = 0; i < 9; i++)
		{
			for (int j = 0; j < 8; j++)
			{
				cout << arr[i][j] << " ";
			}
			cout << arr[i][8] << endl;
		}
		flag = true;
		return;
	}
	
	int h = n / 9;//当前元素所在的行
	int l = n % 9;//当前元素所在的列

	if (arr[h][l] == 0)
	{
		//填数字，回溯法/深度优先
		for (int i = 1; i <= 9; i++)
		{
			arr[h][l] = i;
			if (check(n))
			{
				dfs(n + 1);
				if (flag == true)
				{
					return;
				}
				arr[h][l] = 0;
			}
		}
		arr[h][l] = 0;
	}
	else
	{
		dfs(n + 1);
	}

	
}
int main()
{
	//数独输入
	
	for (int i = 0; i < 9; i++)
	{
		for (int j = 0; j < 9; j++)
		{
			cin >> arr[i][j];
		}

	}
	//深度优先搜索遍历
	dfs(0);

	system("pause");
	return 0;
}
highfivesuga
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
用C++解决华为OD机试考题，是真的高效，真的强，来吧，清单奉上，祝你上岸
梦想橡皮擦，专栏100例写作模式先行者，现象级专栏 《Python 爬虫 100 例》作者、《滚雪球学 Python 专栏》原创者
03-12 1万+
华为 OD 机试题清单（机试题库还在逐日更新） 直接在本页使用 Ctrl+F，输入题目名称就可以进行检索。
【华为OD机试模拟题】用 C++ 实现 - 能力组队 | 求最多可以派出多少支团队（2023.Q1）
梦想橡皮擦，专栏100例写作模式先行者，现象级专栏 《Python 爬虫 100 例》作者、《滚雪球学 Python 专栏》原创者
02-26 5196
参加华为od机试，一定要注意不要完全背诵代码，需要理解之后模仿写出，通过率才会高。能力组队 题目 用数组代表每个人的能力， 一个比赛活动要求，参赛团队的最低能力值为N 每个团队可以由一人或者两人组成， 且一个人只能参加一个团队， 计算出。一个比赛活动要求，参赛团队的最低能力值为。计算出最多可以派出多少只符合要求的队伍。每个团队可以由一人或者两人组成，第三行数值为团队要求的最低能力值。且一个人只能参加一个团队，第二行数组代表每个人的能力。用数组代表每个人的能力，第一行代表总人数，范围。最多可以派出的团队数量。
华为OD机试 - 第 N 个排列（C++） | 附带编码思路 【2023】
梦想橡皮擦，专栏100例写作模式先行者，现象级专栏 《Python 爬虫 100 例》作者、《滚雪球学 Python 专栏》原创者
02-21 3438
参加华为od机试，一定要注意不要完全背诵代码，需要理解之后模仿写出，通过率才会高。第 N 个排列 题目 给定参数n 从1到n会有n个整数 1，2，3，...n 这n个数字共有n!种排列 按大小顺序升序列出所有排列情况 并一一标记 当n = 3 时，所有排列如下 "123","132","213","231","312","321" 给定n和k返回第n个排列 输入 第一行为n 第二行为k n 的范围是 1 ~ 9 k 的范围是 1 ~ n!
【华为机试 C++ 万能头文件】HJ1 字符串最后一个单词的长度
izhxxx的博客
03-09 436
HJ1 字符串最后一个单词的长度 刷了很久的leetcode，都是核心代码模式，这里出来个ACM模式，不太适应 C++万能头文件参考 #include<bits/stdc++.h> #include<bits/stdc++.h> using namespace std; int main() { string str = ""; getline(cin, str); int ans = 0; for(int ii = str.size() - .
华为机考108题（c++）（101-108）
seek97的博客
04-04 779
HJ101 输入整型数组和排序标识，对其元素按照升序或降序进行排序 描述 输入整型数组和排序标识，对其元素按照升序或降序进行排序 数据范围： 1≤n≤1000，元素大小满足 0≤val≤100000 输入描述： 第一行输入数组元素个数 第二行输入待排序的数组，每个数用空格隔开 第三行输入一个整数0或1。0代表升序排序，1代表降序排序 输出描述： 输出排好序的数字 方法一：数组法 #include <iostream> #include <al...
牛客华为机试10道题答案c++.zip
01-05
牛客华为机试10道题答案c++.zip，适合华为机试的朋友，题目在注释部分，C++语言编写的，部分题有写了多种解法 1、快递运输 2、TLV解码 3、考勤信息 4、字符串分割 5、组成最大数 6、高矮个子排队 7、猴子爬山 8、...
牛客华为1机试10道题答案C++.zip
01-05
牛客华为1机试10道题，使用C++语言，适合准备华为机试的朋友。均在本地IDE运行通过。 1、求解连续数列 2、查找众数及中位数 3、寻找相同子串 4、字符串统计 5、磁盘容量排序 6、太阳能板最大面积 7、靠谱的车 8、...
凉小秋的牛客日记-华为机试
05-18
本资源摘要信息涵盖凉小秋的牛客日记中的华为机试相关知识点，主要涉及C++编程语言、字符串处理、算法设计等方面。 知识点1：字符串处理 在本华为机试中，考察字符串处理的能力，特别是计算字符串最后一个单词的...
2017最全华为机试题C/C++（含答案源码）
09-22
2017最全华为机试题C/C++（含答案源码)，包含111道上机考试题，欢迎下载，觉得资源好请好评。
华为 OD 机试真题部分题解+全部题解见《华为机试真题》专栏
04-10
机试题专栏 题目来自牛客平台机考同学的机试分享，题目描述信息可能记录不完整，题解无法保证通过率，只提供结题思路，注意！注意！！不要直接使用博主代码进行机考！ 欢迎加微信: Ayemmar 本文解法非最优解
华为OD机试模拟题 用 C++ 实现 - 通信误码（2023.Q1）
梦想橡皮擦，专栏100例写作模式先行者，现象级专栏 《Python 爬虫 100 例》作者、《滚雪球学 Python 专栏》原创者
02-27 3080
通信误码 信号传播过程中会出现一些误码，不同的数字表示不同的误码 ID，取值范围为 1~65535，用一个数组记录误码出现的情况，每个误码出现的次数代表误码频度，请找出记录中包含频度最高误码的最小子数组长度。参加华为od机试，一定要注意不要完全背诵代码，需要理解之后模仿写出，通过率才会高。通信误码。误码出现频率数组：误码 ID 范围为。，取值为 0 表示没有误码的情况。包含频率最高的误码最小子数组长度。可以包含频度最高的记录数组是。误码总数目：取值范围为。
【100%通过率】华为OD机试真题 C++ 实现【通信误码】【2022.11 Q4 新题】
MISAYAONE的博客
12-15 8013
信号传播过程中会出现一些误码，不同的数字表示不同的误码ID，取值范围为1~65535，用一个数组记录误码出现的情况，每个误码出现的次数代表误码频度，请找出记录中包含频度最高误码的最小子数组长度。
太阳能板最大面积
weixin_44219664的博客
03-28 2855
注意！答案仅作为参考（实际考试中下列代码通过用例100%，但不代表最优解） 给航天器一侧加装长方形和正方形的太阳能板(图中的斜线区域) 需要先安装两个支柱(图中的黑色竖条) 再在支柱的中间部分固定太阳能板 但航天器不同位置的支柱长度不同 太阳能板的安装面积受限于最短一侧的那支支柱的长度 现提供一组整型数组的支柱高度数据 假设每个支柱间的距离相等为一个单位长度 计算如何选择两根支柱可以使太阳能板的面积最大 输入描述 10,9,8,7,6,5,4,3,2,1 注释，支柱至少有两根，最多1
牛客网华为机试60-81c++版
永远相信,美好的事情即将发生
04-09 134
【代码】牛客网华为机试60-81c++版。
【华为OD机试2023】通信误码 C++ Java Python
Abmcar的博客
03-10 443
【华为OD机试2023】通信误码 C++ Java Python 信号传播过程中会出现一些误码，不同的数字表示不同的误码ID，取值范围为1~65535，用一个数组记录误码出现的况。每个误码出现的次数代表误码频度，请找出记录中包含频度最高误码的最小子数组长度。
华为机试练练手（c++代码）
小桥流水的专栏
12-15 882
输入一个整数，如12336544，或1750，然后从最后一位开始倒过来输出，最后如果是0，则不输出，输出的数字是不带重复数字的，所以上面的输出是456321和571。如果是负数，比如输入-175，输出-571。 #include #include using namespace std; int main() { string str; string str1; cin>>str;
华为od统一考试B卷【堆栈中的剩余数字】C++ 实现
MISAYAONE的博客
10-26 573
向一个空栈中依次存入正整数， 假设入栈元素 n(1
【华为上机真题】太阳能板的最大面积
Linux猿
01-01 1282
【华为上机真题】太阳能板的最大面积 CSDN博客专家🏆，华为云享专家🏆，Linux、C/C++、云计算、物联网、面试、刷题、算法尽管咨询我，关注我，有问题私聊！
【华为机试真题 JAVA】IPv4地址转换成整数-100
weixin_52894047的博客
10-16 1089
存在一种虚拟IPv4地址，由4小节组成，每节的范围为0~128，以#号间隔，格式如下： `(1~128)#(0~255)#(0~255)#(0~255)`. 请利用这个特性把虚拟IPv4地址转换为一个32位的整数，IPv4地址以字符串形式给出，要求每个IPv4地址只能对应到唯一的整数上。 如果是非法IPv4，返回invalid IP。
牛客华为机试题库 c++
最新发布
07-29
牛客网是一个面向程序员的在线...总之，牛客华为机试题库C是一个有益于C语言学习和华为面试备考的资源，通过做题和参考题解，可以提高候选人的编程能力和竞争力，也可以帮助企业和招聘人员更好地进行招聘和选拔工作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值