可信20210122招聘题

第一题 招聘候选人

#include <iostream>
#include <vector>
#include <set>
#include <algorithm> // sort 函数在此头文件
using namespace std;

/*
结构体的排序：
1. 定义结构体
struct St {
	
}
2. 定义排序函数
bool cmp(St left, St right) {
	if (left.a != right.a) return left.a  > right.a; 左边大 
	if (left.b != left.b) return left.b < right.b 右边大 
}
3. 定义vector<St> vec; 
4. 排序 sort(vec.begin(), vec.end(), cmp);
*/
struct Worker {
	int score;
	int index;
	set<int> prefer;
	bool select_state;
};
bool cmp(Worker w1, Worker w2) {
	if (w1.score != w2.score) return w1.score > w2.score; 
	return w1.index < w2.index;
}
vector<int> DepartmentRecruit(const vector<int> &nums, const vector<int> &scores,
	const vector<vector<int>> &preference) {
	vector<Worker> workers;
	for (size_t i = 0; i < scores.size(); i++) {
		Worker worker;
		worker.score = scores[i];
		worker.index = i;
		for (size_t j = 0; j < preference[i].size(); j++) {
			worker.prefer.insert(preference[i][j]);	
		}
		worker.select_state = false;
		workers.push_back(worker);
		std::cout << i << endl;
	}
	vector<int> depart_nums = nums;
	
	sort(workers.begin(), workers.end(), cmp);
	for (size_t i = 0; i < workers.size(); i++) {
		if (!workers[i].select_state) {
			for (size_t j = 0; j < depart_nums.size(); j++) {
				if (workers[i].prefer.find(j) != workers[i].prefer.end() && depart_nums[j] != 0) {
					depart_nums[j] = depart_nums[j] - 1;
					workers[i].select_state = true;
					break; // 选完后不要再选了
				}
			}
		}		
	}
	int uncompelete_part_num = 0;
	for (size_t i = 0; i < depart_nums.size(); i++) {
		if (depart_nums[i] != 0) {
			uncompelete_part_num++;
		}
	}
	int unselected_man_num = 0;
	for (size_t i = 0; i < workers.size(); i++) {
		if (!workers[i].select_state) {
			unselected_man_num++;
		}
	}
	return {uncompelete_part_num, unselected_man_num};
}
int main() {
	std::cout << "hello" << std::endl;
	vector<int> nums = {3, 2, 0};
	vector<int> scores = {67, 89, 67, 42};
	vector<vector<int> > preference = {{2, 1}, {1}, {1, 2}, {1}};
	vector<int> res = DepartmentRecruit(nums, scores, preference);
	cout << res[0] << endl;
	cout << res[1] << endl;
	return 0;
}

0903的挑选 套装题

一样的套路

#include <iostream>
#include <vector>
#include <set>
#include <map>
#include <algorithm> // sort 函数在此头文件
using namespace std;

/*
结构体的排序：
1. 定义结构体
struct St {
	
}
2. 定义排序函数
bool cmp(St left, St right) {
	if (left.a != right.a) return left.a  > right.a; 左边大 
	if (left.b != left.b) return left.b < right.b 右边大 
}
3. 定义vector<St> vec; 
4. 排序 sort(vec.begin(), vec.end(), cmp);
*/
struct Suit {
	int cost;
	int profit;
	int id;
	int index;
};
bool cmp(Suit s1, Suit s2) {
	if (s1.cost != s2.cost) return s1.cost < s2.cost;
	if (s1.profit != s2.cost) return s1.profit > s2.profit;
	return s1.id < s2.id;
}

vector<int> select(const vector<vector<int>> &sale,const vector<vector<int>> &limit, int cnt) {
	vector<Suit> suits;
	for (int i = 0; i < sale.size(); i++) {
		Suit suit;
		suit.id = sale[i][0];
		suit.cost = sale[i][1];
		suit.profit = sale[i][2];
		suit.index = i;
		suits.push_back(suit);
	}
	sort(suits.begin(), suits.end(), cmp);
	map<int, int> limits;
	for (int i = 0; i < limit.size(); i++) {
		limits[limit[i][0]] = limit[i][1];
	}
	vector<int> res;
	int num = 0;
	for (int i = 0; i < suits.size(); i++) {
		if (limits[suits[i].id] != 0) {
			limits[suits[i].id]--;
			res.push_back(suits[i].index);
			num++;
		}
		if (num == cnt) {
			sort(res.begin(), res.end());
			return res;
		}
	}
	return {}; 
}

int main() {
	vector<vector<int>> sale = {{2, 60, 10}, {2, 50, 20}, {4, 70, 30}, {3, 50, 40}, {1, 70, 20}, {1, 60, 20}, {3, 50, 20}, {3, 60, 10}, {2, 50, 30}};
	vector<vector<int>> limit = {{3,3}, {1, 2}, {2, 2}, {4, 5}};
	int cnt = 5;
	vector<int>  res = select(sale, limit, cnt);
	for (int i = 0; i < res.size(); i++) {
		std::cout << res[i] << std::endl;
	}
	return 0;
}

解题模式

struct
cmp
sort

0521上机编程 租房信息查询系统同样的套路

#include <iostream>
#include <vector>
#include <queue>
#include <map>
#include <algorithm>
#include <climits>
#include "math.h"
using namespace std;

struct Room {
    int id;
    int area;
    int price;
    int rooms;
    vector<int> address;
};
vector<vector<int>> orderBy_;
vector<int> origin_address_;
bool cmp(Room r1, Room r2) {
  if (!orderBy_.empty()) {
    for (int i = 0; i < orderBy_.size(); i++) {
      if (orderBy_[i][0] == 1) {
        if (r1.area != r2.area) {
          if (orderBy_[i][1] == 1) {
            return r1.area < r2.area;
          }
          return r1.area > r2.area;
        }
      } else if (orderBy_[i][0] == 2) {
        if (r1.price != r2.price) {
          if (orderBy_[i][1] == 1) {
            return r1.price < r2.price;
          }
          return r1.price > r2.price;
        }
      } else {
        int man_distance_r1 = abs(r1.address[0] - origin_address_[0]) + abs(r1.address[1] - origin_address_[1]);
        int man_distance_r2 = abs(r2.address[0] - origin_address_[0]) + abs(r2.address[1] - origin_address_[1]);
        if (man_distance_r1 != man_distance_r2) {
          return orderBy_[i][1] == 1 ? (man_distance_r1 <  man_distance_r2) : (man_distance_r1 > man_distance_r2);
        }
      }
    }
  }
  return r1.id < r2.id;
}
class RentingSystem {
public:
    bool addRoom(int id, int area, int price, int rooms, vector<int> address) {
      if (id_room_map.find(id) == id_room_map.end()) {
        Room room;
        room.id = id;
        room.area = area;
        room.price = price;
        room.address = address;
        room.rooms = rooms;
        id_room_map[id] = room;
        return true;
      } else {
        id_room_map[id].id = id;
        id_room_map[id].area = area;
        id_room_map[id].price = price;
        id_room_map[id].address = address;
        id_room_map[id].rooms = rooms;
        return false;
      }
    }
    bool deleteRoom(int id) {
      if (id_room_map.find(id) == id_room_map.end()) {
        return false;
      }
      id_room_map.erase(id_room_map.find(id));
      return true;
    }
    vector<Room> queryRoom(int area, int price, int rooms, vector<int> address, vector<vector<int>> orderBy) {
      vector<Room> query_rooms;
      for (auto it = id_room_map.begin(); it != id_room_map.end(); it++) {
        if (it->second.area >= area && it->second.price <= price && it->second.rooms == rooms) {
          query_rooms.push_back(it->second);
        }
      }
      orderBy_ = orderBy;
      origin_address_ = address;
      sort(query_rooms.begin(),query_rooms.end(), cmp);
      return query_rooms;
    }

private:
  map<int, Room> id_room_map;
};

int main() {
  RentingSystem obj = RentingSystem();
  obj.deleteRoom(10);
  obj.addRoom(3,24,200,2,{0,1});
  obj.addRoom(3,24,500,2,{0,1});
  obj.addRoom(3,27,500,4,{1,1});
  obj.addRoom(1,27,500,4,{20, 23});
  obj.addRoom(6,35,227,4,{2, 4});
  obj.addRoom(9,20,3540,4,{4, 321});
  obj.queryRoom(25, 900, 4, {10, 1}, {{1, 1}, {2, -1}, {3, 1}});
  obj.queryRoom(25, 900, 4, {10, 1}, {});

  return 0;
}

0723上机编程 “数据设备系统设计”

1 通篇阅读文章（不包括第二个例子），理解题意，注意不要没读完就写代码

2 手动运行第二个例子，在纸上推导，确定自己的理解有没有错误

3 设计数据结构 Struct node， vector，map，sort

4 写代码

5 debug

时间安排：

1+2--》20分钟

3+4-》40分钟

5-》30分钟

注意机器的编号是从1开始的

#include <iostream>
#include <vector>
#include <queue>
#include <map>
#include <algorithm>
#include <climits>
#include "math.h"
#include <set>
using namespace std;
struct Node{
    int device_id_;
    map<int, int> data_id_predevice_id_;
    int distribution_;
};

class DataMachineSystem {
public:
    DataMachineSystem(int num) {
      for (int i = 0; i < num; i++) {
        Node node;
        node.device_id_ = i + 1;
        node.distribution_ = 0;
        nodes_.push_back(node);
      }
    }
    int transferData(int machineA, int machineB, int dataId) {
      if (nodes_[machineB - 1].data_id_predevice_id_.find(dataId) != nodes_[machineB - 1].data_id_predevice_id_.end()) {
        return 0;
      }
      if (nodes_[machineA - 1].data_id_predevice_id_.find(dataId) == nodes_[machineA - 1].data_id_predevice_id_.end()) {
        nodes_[machineA - 1].data_id_predevice_id_[dataId] = machineA;
      }

      nodes_[machineB - 1].data_id_predevice_id_[dataId] = machineA;

      int pre_device = machineA;
      while (nodes_[pre_device - 1].data_id_predevice_id_[dataId] != pre_device) {
        nodes_[pre_device - 1].distribution_ += 10;
        pre_device = nodes_[pre_device - 1].data_id_predevice_id_[dataId];
      }
      nodes_[pre_device - 1].distribution_ += 10;

      return 1;
    }

    void transferDataToAll(int machine, int dataId) {
      for (int i = 0; i < nodes_.size(); i++) {
        if (nodes_[i].device_id_ != machine) {
          transferData(machine, nodes_[i].device_id_, dataId);
        }
      }
    }

    int queryCountribution(int machine) {
      return nodes_[machine - 1].distribution_;
    }
private:
    vector<Node> nodes_;
};

int main() {
  DataMachineSystem obj = DataMachineSystem(4);
  obj.transferData(1, 2, 15);
  obj.transferData(2, 3, 15);
  obj.transferData(3, 4, 15);
  int a = obj.queryCountribution(1);
  obj.transferData(2, 4, 37);
  obj.transferDataToAll(2, 37);
  int b = obj.queryCountribution(2);
  obj.transferData(3, 4, 37);
  int a_1 = obj.queryCountribution(1);
  int a_3 = obj.queryCountribution(3);
  int a_4 = obj.queryCountribution(4);
  return 0;
}

1029上机编程 备忘录设计系统

仍然是增删改查系统设计题，可以设计为一张表，考试时记得用map<int, Node> ma;形式，注意id是什么，Node的struct设计，然后sort的应用

#include <iostream>
#include <vector>
#include <queue>
#include <map>
#include <algorithm>
#include <climits>
#include "math.h"
#include <set>
using namespace std;

struct Event {
    string content_;
    int date_;
    int finish_flag_;
};
bool cmp(Event l, Event r) {
  if (l.date_ != r.date_) {
    return l.date_ < r.date_;
  }
  return l.content_ > r.content_;
}
class EventSystem{
public:
    int addEvent(int startDate, string content, int num, int period) {
      int cout = 0;
      for (int i = 0; i < num; i++) {
        string cmp_id = to_string(startDate + i * period) + content;
        if (events_.find(cmp_id) == events_.end()) {
          Event event;
          event.content_ = content;
          event.date_ = startDate + i * period;
          event.finish_flag_ = false;
          string event_id = to_string(event.date_) + event.content_;
          events_[event_id] = event;
          cout++;
        }
      }
      return cout;
    }
    bool finishEvent(int date, string content) {
      string cmp_id = to_string(date) + content;
      if (events_.find(cmp_id) == events_.end()) {
        return false;
      } else {
        if (events_[cmp_id].finish_flag_) {
          return false;
        }
      }

      events_[cmp_id].finish_flag_ = true;
      return true;
    }
    bool removeEvent(int date, string content) {
      string cmp_id = to_string(date) + content;
      if (events_.find(cmp_id) == events_.end()) {
        return false;
      }
      events_.erase(cmp_id);
    }
    vector<string> queueTodo(int startDate, int endDate) {
      vector<Event> query_events;
      for (auto it = events_.begin(); it != events_.end(); it++) {
        if (it->second.date_ >= startDate && it->second.date_ <= endDate && !(it->second.finish_flag_)) {
          query_events.push_back(it->second);
        }
      }
      sort(query_events.begin(), query_events.end(), cmp);
      vector<string> res;
      for (int i = 0; i < query_events.size(); i++) {
        res.push_back(query_events[i].content_);
      }
      return res;
    }
private:
    map<string, Event> events_;
};

int main() {
  EventSystem system = EventSystem();
  system.addEvent(2, "save files", 1, 1);
  system.addEvent(2, "eat a burger", 1, 2);
  system.removeEvent(2, "drink water");
  system.finishEvent(1, "drink water");
  system.addEvent(0, "eat a burger", 5, 2);
  system.addEvent(2, "save files", 1, 1);
  vector<string> a= system.queueTodo(0, 4);
  vector<string> b = system.queueTodo(10, 11);
  system.finishEvent(2, "eat a burger");
  system.addEvent(2, "eat a burger", 1, 1);
  return 0;
}

扣分项

圈复杂度

   代码圈复杂度（10， 15]扣3分

   可以右键 code check， 复杂度分析

空格：

  CTL + ALT + L格式化