字符串长度
如果不给你数组长度，读入一个数组怎么半
int target;
std::cin.ignore();
string line;
std::getline(std::cin,line);
std::istringstream iss(line);
int temp1;
while(iss>>temp1)
{
f.emplace_back(temp1);
}题目1：输入，一个钱总数target，一行面值的钱
输出，凑成钱总数的最小个数
#include<iostream>
#include<string>
#include<vector>
//#include<sstream>
using namespace std;
int main()
{
int amount;
cin >> amount;
std::cin.ignore();
string line;
std::getline(std::cin, line);
//std::istringstream iss(line);
int temp = 0;
vector<int> f;
for (int i = 0; i < line.size(); i++) {
if (line[i] != ' ') temp = temp * 10 + (line[i] - '0');
else {
f.emplace_back(temp);
temp = 0;
}
}
if (temp != 0) f.emplace_back(temp);
return 0;
}二维背包方法
vector<vector<int>> dp(f.size()+1,vector<int>(amount+1,amount+1));
for (int i = 0; i <=f.size(); i++) {
dp[i][0] = 0;
}
//价值是1，重量是面值，背包容量是总数
for (int i = 1; i <=f.size();i++ )//遍历物品
{
for (int j = 1; j <= amount;j++)//遍历容量装//一般问题是最大能装多少东西，价值
{
dp[i][j] = min(dp[i][j], dp[i - 1][j]);
if (j-f[i-1]>=0) {
dp[i][j] = min(dp[i][j], dp[i][j-f[i-1]] + 1);
}
}
}
int result = dp[f.size()][amount]== amount + 1 ? -1 : dp[f.size()][amount];
cout << result;一维背包方法
int minCoins(int target, const std::vector<int>& coins) {
// 初始化 dp 数组，长度为 target + 1，初始值为 INT_MAX（表示无法凑成）
std::vector<int> dp(target + 1, INT_MAX);
dp[0] = 0; // 凑成 0 元需要 0 个硬币
// 遍历从 1 到 target 的所有金额
for (int amount = 1; amount <= target; ++amount) {
// 对于每个金额，尝试每种硬币面值
for (int coin : coins) {
if (amount >= coin && dp[amount - coin] != INT_MAX) {
dp[amount] = std::min(dp[amount], dp[amount - coin] + 1);
}
}
}
// 如果 dp[target] 仍然是 INT_MAX，说明无法凑成目标金额
return dp[target] == INT_MAX ? -1 : dp[target];
}
c++用久了，用一下c
fgets(s1,sizeof s1,stdin)，'\0' 是 C 语言中的空字符（null character），也称作字符串终止符。它的 ASCII 值是 0，用来表示字符串的结束。（可把它代码写的简单坏了）
#include<stdio.h>
#include<string.h>
int count = 0;
char* vec(char* s1, char* s2) {
char* p1, * p2;
while (*s1 != '\0') {
p1 = s1;
p2 = s2;
while (*p1 != '\0' && *p2 != '\0' && *p1 == *p2) {
printf("%c %c ", *p1, *p2);
p1++;
p2++;
}
if (*p2 == '\0') {
printf("%c %d ",*p2,count);
count++;
}
s1++;
}
return s1;
}
int main() {
char s1[100]; // 假设字符串的最大长度为100
char s2[100];
printf("请输入第一个字符串：");
fgets(s1, sizeof(s1), stdin); // 读取第一个字符串
// 去除 s1 中的换行符
size_t len_s1 = strlen(s1);
if (len_s1 > 0 && s1[len_s1 - 1] == '\n') {
s1[len_s1 - 1] = '\0';
}
printf("请输入第二个字符串：");
fgets(s2, sizeof(s2), stdin); // 读取第二个字符串
// 去除 s2 中的换行符
size_t len_s2 = strlen(s2);
if (len_s2 > 0 && s2[len_s2 - 1] == '\n') {
s2[len_s2 - 1] = '\0';
}
char* result = vec(s1, s2); // 调用 vec 函数
printf("result: %d\n", count); //
return 0;
}
笔试题目1
题目：虚拟指令执行
3题 请设计一种虚拟机解释器，能解析并执行以下虚拟指令。
虚拟机约定：32位整形寄存器：a0，a1...a31，共32个寄存器;整个虚拟机只有寄存器和立即数参与计算。
规则集 (dst一定为寄存器，src为寄存器或十进制正整数，运算结果存在负数场景)：
1. MOV dst src
含义： dst =src
2. ADD dst src0 src1
含义：dst = src0 + src1
3. SUB dst src0 src1
含义：dst = src0 - src1
4. MUL dst src0 src1
含义： dst =srcO*src1
5.DIV dst src0 src1
含义： dst=src0/ src1 (结果向下取整)
6.PRINT dst
含义：打印dst寄存器值
约束：不用考虑计算溢出(用例保证)，指令数最多100条，至少一条PRINT指令，寄存器保证先赋值再引用。不用考虑小数跟除0。
思路：难点，
- 1 循环输入怎么处理 while(std::getline(std::cin.line)),
- 2 读进来后怎么处理读进来的字符串 istringstream iss(line) iss>>command (会按照空格将字符串分成几部分)
- 3 数据怎么存储 定义一个哈希表unordered_map<string,int> registers,因为题目中说了就32个寄存器。
#include<iostream>
#include<unordered_map>
#include<string>
#include<sstream>
using namespace std;
class duixiang
{
public:
void hanshu(std::string line) {
std::istringstream iss(line);
string command;
iss >> command;
if (command == "MOV") {
string dst, src;
iss >> dst >> src;
jicunqi[dst] = getvalue(src);
}
else if (command == "ADD") {
string dst, src0, src1;
iss >> dst >> src0 >> src1;
jicunqi[dst] = getvalue(src0) + getvalue(src1);
}
else if (command == "SUB") {
string dst, src0, src1;
iss >> dst >> src0 >> src1;
jicunqi[dst] = getvalue(src0) - getvalue(src1);
}
else if (command == "MUL") {
string dst,src0, src1;
iss >> dst >> src0 >> src1;
jicunqi[dst] = getvalue(src0) * getvalue(src1);
}
else if (command == "DIV") {
string dst, src0, src1;
iss >> dst >> src0 >> src1;
jicunqi[dst] = getvalue(src0) / getvalue(src1);
}
else if (command == "PRINT") {
string dst;
iss >> dst;
cout << jicunqi[dst] << endl;
}
}
private:
unordered_map<string, int> jicunqi;
int getvalue(string s) {
if (s[0] >= 'a' && s[0] <= 'z') { return jicunqi[s]; }
return stoi(s);
}
};
int main()
{
duixiang duixiang1;
string line;
while (std::getline(std::cin, line)) {
duixiang1.hanshu(line);
}
return 0;
}测试样例
MOV a1 100
MOV a2 200
ADD a3 a1 100
SUB a4 a3 a2
PRINT a4
0
MOV a1 100
MOV a2 200
PRINT a1
100
ADD a3 a1 100
SUB a4 a3 a2
PRINT a4
0
题目 2
无线基站邻区关系缓存表维护
天线通信移动性需要在基站上配置邻区 （本端基站的小区Localcel与周边邻基站的小区NerghorCell 关系，为了能够加速无线算法的十算效率，设计一个邻区关系缓存表，用于快速的通过本小区LocalCell查询邻小区Neigiborcel. 但是缓存表有一定的规格限制，因此到达规格井且需典插入新的5效周时，需要倒区数得，为释刚除区效对象的第略为：1) 便用次数是少的，2) 如果1） 返回有多个对象，则选样最久米使用的。
请设i计并实现一个满足以上要求的数据结构和算法实现。注：假设每个Localcel至多只有一个NeighborCel.
解答要求
时间限制：CIC++ 1000ms,其他语言：2000ms 内有限制粉： CIC++ 256MB,其他语言：512MB输入
1、首行以字符"capaily“标识设置一个型数容量；
2、以wille“标识开始进行若干组LocalCol, NeighborCell 3区数据的输入，每组数据为一行；如果”wite:"已经存在的LocalCel数据，更新其对应的NeighborCel， 并刷新使用时间和次数加、以'read“标识进行一次读取LocalCel的使用操作，刷新使用时间和次数1；
A、最后以'quey“标识查询输山保作，输入正型效Localcel, 查询NeighborCell;
注：
1) 写入和该现都表示对Locaicel的使用操作；
2) capaciy、LocalCelTNeighborCel是下型故，范国在(1, 10000);
3)输入的总行数不越过30000行，
输出
每个查询愉入正整数Loalce对应NeigilborCol, 表示在邻区关系彼行
表中的记录
1、找到，返NeighborCell;
2、没有找到，返回-1；
思路：思想就是，用一个哈希表储存localcell和它的一些参数（一些参数定义了一个结构体）
然后由于要排序，所有定义了一个优先级队列(最大堆维护，它的排序函数与一般的排序反着来)
难点：优先级队列修改里面的值的话，不会参与到排列中，所以只能删除，重新插入。
指针指向同一个地址，可以修改指针中地址
#include <iostream>
#include <unordered_map>
#include <queue>
#include <vector>
#include <string>
using namespace std;
struct CacheEntry {
int localCell;
int neighborCell;
int usageCount;
int lastUsedTime;
bool valid; // 标记缓存项是否有效
CacheEntry(int lc, int nc, int time)
: localCell(lc), neighborCell(nc), usageCount(0), lastUsedTime(time), valid(true) {}
};
struct Compare {
bool operator()(const CacheEntry* a, const CacheEntry* b) const {
if (a->usageCount == b->usageCount)
return a->lastUsedTime > b->lastUsedTime; // 使用次数相同，比较最后使用时间
return a->usageCount > b->usageCount; // 使用次数少的优先
}
};
class Cache {
public:
void write(int localCell, int neighborCell) {
currentTime++;
if (cacheMap.find(localCell) != cacheMap.end()) {
CacheEntry* entry = cacheMap[localCell];
entry->valid = false; // 标记旧的条目无效
}
if (cacheMap.size() == capacity && cacheMap.find(localCell) == cacheMap.end()) {
evict(); // 淘汰缓存项
}
CacheEntry* newEntry = new CacheEntry(localCell, neighborCell, currentTime);
cacheMap[localCell] = newEntry;
cacheQueue.push(newEntry);
// 打印当前计数时间
cout << "当前计数时间: " << currentTime << endl;
printQueueTop();
}
void read(int localCell) {
if (cacheMap.find(localCell) == cacheMap.end()) {
return;
}
CacheEntry* entry = cacheMap[localCell];
entry->usageCount++;
entry->lastUsedTime = ++currentTime;
entry->valid = false; // 标记旧条目为无效
CacheEntry* newEntry = new CacheEntry(localCell, entry->neighborCell, currentTime);
newEntry->usageCount = entry->usageCount;
cacheMap[localCell] = newEntry;
cacheQueue.push(newEntry); // 插入更新后的条目
printQueueTop();
}
int query(int localCell) {
if (cacheMap.find(localCell) != cacheMap.end()) {
return cacheMap[localCell]->neighborCell;
}
else {
return -1;
}
}
void printCacheMap() const {
for (const auto& pair : cacheMap) {
cout << "LocalCell: " << pair.first
<< ", NeighborCell: " << pair.second->neighborCell
<< ", UsageCount: " << pair.second->usageCount
<< ", LastUsedTime: " << pair.second->lastUsedTime
<< endl;
}
}
void printQueueTop() {
cleanUpInvalidEntries(); // 清理无效条目
if (!cacheQueue.empty()) {
CacheEntry* top = cacheQueue.top();
cout << "Queue Top -> LocalCell: " << top->localCell
<< ", NeighborCell: " << top->neighborCell
<< ", UsageCount: " << top->usageCount
<< ", LastUsedTime: " << top->lastUsedTime
<< endl;
}
else {
cout << "Queue is empty" << endl;
}
}
void fuzhicap(int cap) {
capacity = cap;
currentTime = 0;
}
private:
int capacity;
int currentTime; // 用于模拟时间的自增计数器
unordered_map<int, CacheEntry*> cacheMap;
priority_queue<CacheEntry*, vector<CacheEntry*>, Compare> cacheQueue;
void evict() {
cleanUpInvalidEntries(); // 清理无效条目
if (!cacheQueue.empty()) {
CacheEntry* entry = cacheQueue.top();
cacheQueue.pop();
while (!entry->valid) {
delete entry;
if (cacheQueue.empty()) return;
entry = cacheQueue.top();
cacheQueue.pop();
}
if (cacheMap.find(entry->localCell) != cacheMap.end() && cacheMap[entry->localCell] == entry) {
cacheMap.erase(entry->localCell);
delete entry;
}
}
}
void cleanUpInvalidEntries() {
// 清理优先级队列中无效的条目
while (!cacheQueue.empty() && !cacheQueue.top()->valid) {
delete cacheQueue.top();
cacheQueue.pop();
}
}
};
int main() {
Cache cache;
string command;
while (cin >> command) {
if (command == "write") {
int size;
cin >> size;
while (size--) {
int localCell, neighborCell;
cin >> localCell >> neighborCell;
cache.write(localCell, neighborCell);
cache.printQueueTop();
}
cache.printCacheMap();
}
else if (command == "read") {
cache.printQueueTop();
cache.printCacheMap();
int localCell;
cin >> localCell;
cache.read(localCell);
cache.printQueueTop();
cache.printCacheMap();
}
else if (command == "query") {
cache.printCacheMap();
int localCell;
cin >> localCell;
cout << cache.query(localCell) << endl;
}
else if (command == "capacity") {
// Handle capacity input
int cap;
cin >> cap;
cache.fuzhicap(cap);
}
}
return 0;
}输入：
capacity
3
write
3
1 2
4 3
2 3
read
2
write
1
3 1
query
1输出 -1
输入
capacity
4
write
5
3 5
1 2
4 3
2 3
5 4
read
4
read
1
read
2
read
5
write
1
6 1
query
1
输出2
字符串
一线工程师每到重要节日需要对网络进行健康检查，在网络中对各个网元采集数据，判断当前网络是否健康。 因每个网元的判断条件以及采集的数据不同，现在需要你对网络采集到的数据，以及工程师提供的判断条件进行解析。判断条件为布尔表达式，保证合法，字段名不会与关键字冲突。 若采集数据符合条件，则认为网络健康，否则网络处于不健康状态。制 输入：32 error = '1' AND (name = 'NE40' OR name = 'NE20) error =2'AND (name ='NE40' OR ame ='NE20) error =3' AND (name ='NE40°OR name ='NE20) name NE40 error 3 复制输出：1 1 0.
sb题目
error = '1' AND (name = 'NE40' OR name = 'NE20')
error = '2' AND (name = 'NE40' OR name = 'NE20')
error = '3' AND (name = 'NE40' OR name = 'NE20')
name NE40
error 3
原文地址：https://blog.csdn.net/zhangguojia7/article/details/139221694
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！