华为4.15软件类笔试

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

using namespace std;

struct Info {
    string name;
    int cnt;
};
vector<Info> vec;

map<string, int> mp;

bool check(string s) {
    if (s.size() == 0)
        return false;
    int len = s.size();
    if (s[0] < 'A' || s[0] > 'Z')
        return false;
    for (int i = 1; i < len; ++i)
        if (s[i] < 'a' || s[i] > 'z')
            return false;
    ++mp[s];
    return true;
}

bool split(string s) {
    int len = s.size();
    if (len == 0)
        return false;
    string cur;
    int p = 0;
    while (p < len) {
        if (s[p] == ',') {
            bool ok = check(cur);
            if (!ok)
                return false;
            cur = "";
        } else {
            cur += s[p];
        }
        ++p;
    }
    if (cur.size() > 0) {
        bool ok = check(cur);
        if (!ok)
            return false;
    }
    return true;
}

bool cmp(const Info &a, const Info &b) {
    if (a.cnt != b.cnt)
        return a.cnt < b.cnt;
    if (a.name.size() == b.name.size())
        return a.name > b.name;
    if (a.name.find(b.name) != string::npos) {
        return true;
    }
    if (b.name.find(a.name) != string::npos)
        return false;
    return a.name > b.name;
}

int main() 
{
    string input;
    cin >> input;
    bool valid = split(input);
    if (!valid) {
        cout << "error.0001" << endl;
    } else {
        for (auto o : mp) {
            vec.push_back({o.first, o.second});
        }
        sort(vec.begin(), vec.end(), cmp);
        cout << vec[vec.size() - 1].name << endl;
    }
    return 0;
}

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

using namespace std;

struct Info {
    string addr;
    string mask;
    string val;
};

vector<Info> vec;

string pattern, content;

bool check16(string s) {
    int len = s.size();
    if (len < 3)
        return false;
    int idx = 0;
    if (s[idx] != '0')
        return false;
    ++idx;
    if (s[idx] != 'x' && s[idx] != 'X')
        return false;
    ++idx;
    string num = s.substr(idx);
    for (int i = 0; i < num.size(); ++i) {
        char ch = num[i];
        if (ch >= '0' && ch <= '9')
            continue;
        if (ch >= 'A' && ch <= 'F')
            continue;
        if (ch >= 'a' && ch <= 'f')
            continue;
        return false;
    }
    return true;
}

void check(string s) {
    int len = s.size();
    string head = s.substr(0, pattern.size());
    if (head != pattern) 
        return;
    int idx = pattern.size();
    if (idx < len && s[idx] != '[')
        return;
    ++idx;
    if (s.substr(idx, 5) != "addr=")
        return;
    idx += 5;
    int comma = s.find(",", idx);
    if (comma == string::npos || !check16(s.substr(idx, comma - idx))) 
        return; 
    string addr = s.substr(idx, comma - idx);
    // cout << addr << endl;
    idx = comma + 1;
    if (s.substr(idx, 5) != "mask=")
        return;
    idx += 5;
    // cout << idx << endl;
    comma = s.find(",", idx);
    // cout << comma << endl;
    if (comma == string::npos || !check16(s.substr(idx, comma - idx)))
        return;
    string mask = s.substr(idx, comma - idx);
    // cout << mask << endl;
    idx = comma + 1;
    if (s.substr(idx, 4) != "val=")
        return;
    idx += 4;
    if (!check16(s.substr(idx)))
        return;
    string val = s.substr(idx);
    // cout << val << endl;
    vec.push_back({addr, mask, val});
}

void solve(string s) {
    int len = s.size();
    int idx = 0;
    while (idx < len) {
        int r = s.find("],", idx);
        if (r == string::npos)
            break;
        check(s.substr(idx, r - idx));
        idx = r + 2;
    }
    while (idx < len) {
        int r = s.find("]", idx);
        // cout << r << endl;
        if (r == string::npos)
            break;
        check(s.substr(idx, r - idx));
        idx = r + 1;
    }
}

int main()
{
    cin >> pattern >> content;
    solve(content);
    if (vec.size() == 0)
        cout << "FAIL" << endl;
    else {
        for (int i = 0; i < vec.size(); ++i)
            cout << vec[i].addr << " " << vec[i].mask << " " << vec[i].val << "\r\n";
    }
    return 0;
}

#include <stdio.h>
#include <map>
#include <iostream>
#include <string.h>
#include <string>
#include <vector>

using namespace std;

vector<int> callnum, fsize;
vector<vector<int>> G;

int ans;

map<string, int> mp;
vector<bool> vis;

bool dfs(int cur, int sum) {
    vis[cur] = true;
    ans = max(ans, sum);
    for (int i = 0; i < G[cur].size(); ++i) {
        int nxt = G[cur][i];
        if (vis[nxt])
            return false;
        bool ret = dfs(nxt, sum + fsize[nxt]);
        if (!ret)
            return false;
    }
    vis[cur] = false;
    return true;
}

int main()
{
    int n;
    cin >> n;
    for (int i = 0; i < n; ++i) {
        int num;
        cin >> num;
        callnum.push_back(num);
    }
    int id = 0;
    for (int i = 0; i < n; ++i) {
        string name;
        cin >> name;
        if (mp.count(name) == 0) {
            mp[name] = ++id;
        }
        int sz;
        cin >> sz;
        fsize.resize(id + 5);
        fsize[mp[name]] = sz;
        // cout << sz << endl;
        for (int j = 0; j < callnum[i]; ++j) {
            // cout << j << endl;
            string s;
            cin >> s;
            if (mp.count(s) == 0)
                mp[s] = ++id;
            G.resize(id + 5);
            G[mp[name]].push_back(mp[s]);
        }
    }
    // cout << id << endl;
    if (id != n) {
        cout << "NA" << endl;
        return 0;
    }
    vis.resize(id + 5);
    for (auto o : mp) {
        int enter = o.second;
        for (int i = 1; i <= id; ++i)
            vis[i] = false;
        bool ret = dfs(enter, fsize[enter]);
        if (!ret) {
            cout << "R" << endl;
            return 0;
        }
    }
    cout << ans << endl;
    return 0;
}