We use cookies to ensure you have the best browsing experience on our website. Please read our cookie policy for more information about how we use cookies.
  1. Prepare
  2. C++
  3. Strings
  4. Attribute Parser
  5. Discussions

Attribute Parser

Sort by

recency

|

454 Discussions

|

  • owaisarshad70
     + 0 comments

    Read the latest chapters of popular manga for free and officially on MANGA Plus by SHUEISHA. Read World Trigger on the app or web!

  • elmehdighoulami
     + 0 comments

    here is my solution for this problem:

    typedef struct  
{
    string tag;
    string value;
} TagAttr;

int main() 
{
    int N, Q;
    
    cin >> N >> Q;
    cin.ignore();
    
    string tag, line;
    vector<TagAttr> tagsAttr;
    int currentPos;

    for(int n = 0; n < N; n++)
    {
        currentPos = 1;
        
        getline(cin, line);
        if(line[currentPos] == '/')
        {
            if(tag.rfind('.') != string::npos)
            {
                tag = tag.substr(0, tag.rfind('.'));
            }
            else
            {
                tag.clear();
            }                
        }
        else
        {
            TagAttr element;
            int i = 0;
            
            while(line[currentPos+i] != ' ' && line[currentPos+i] != '>')
                i++;
            
            if(tag.empty())
                tag = line.substr(currentPos, i);
            else
                tag = tag + '.' + line.substr(currentPos, i);
                
            currentPos += i;
            
            while (line[currentPos] != '>') 
            {
                currentPos++;
                i=0;
                
                while(line[currentPos+i] != ' ')
                    i++;
                    
                element.tag = tag + "~" + line.substr(currentPos, i);
                
                currentPos += (i+3);
                i=0;
                
                while(line[currentPos+i] != ' ' && line[currentPos+i] != '>')
                    i++;
                
                element.value = line.substr(currentPos+1, i-2);
                
                currentPos += i;
                                    
                i=0;
                tagsAttr.push_back(element);
            }
        }
    } 
    
    string query;
    while (Q--) 
    {
        getline(cin, query);
        
        int i = 0;
        for(auto &elm : tagsAttr)
        {
            i++;
            if(query.compare(elm.tag) == 0)
            {
                cout << elm.value << endl;
                break;
            }
            if(i == tagsAttr.size())
                cout << "Not Found!" << endl;
        }
    }
    return 0;
}

  • nqtrung21112005
     + 0 comments

    int main() { int N, Q; cin >> N >> Q; 

    cin.ignore();   
vector<string> input; 
vector<string> query; 
unordered_map<string, string> solution; 

for (int i = 0; i < N; i++) {
    string str;
    getline(cin, str); 
    input.push_back(str); 
}

for (int i = 0; i < Q; i++) {
    string str; 
    getline(cin, str); 
    query.push_back(str); 
}

string cur = ""; 
for (int i = 0; i < N; i++) {
    vector<string> tokens; 
    string line = input[i]; 
    char *cstr = new char[line.length() + 1];
    strcpy(cstr, line.c_str());
    char *token = strtok(cstr, "<=\"> "); 
    while (token != nullptr) {
        tokens.push_back(string(token));
        token = strtok(nullptr, "<=\"> ");
    }
    delete [] cstr; 
    if (tokens[0][0] != '/') {
        cur += tokens[0] + "."; 
    }
    else {
        int size = tokens[0].size(); 
        while (size--) {
            cur.pop_back(); 
        }
    }

    string prev = cur; 
    prev[prev.size() - 1] = '~'; 
    for (int j = 2; j < tokens.size(); j += 2) {
        solution[prev + tokens[j - 1]] = tokens[j];  
    }
}

for (int i = 0; i < Q; i++) {
    if (solution.find(query[i]) == solution.end()) {
        cout << "Not Found!\n"; 
    } 
    else {
        cout << solution[query[i]] << "\n"; 
    }
}

return 0;

    }

  • marcinorszulak8
     + 0 comments

    Code:

    #include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
#include <string>
using namespace std;

void handleAttributes(vector<pair<string, string>>& attributes)
{
  std::string attributeName;
  std::string temp;
  std::string attributeValue;

  while (1)
  {
    cin >> attributeName;
    cin >> temp;
    cin >> temp;
    attributeValue = temp.substr(1, temp.find_last_of('"') -1);

    attributes.push_back(make_pair(attributeName, attributeValue));

    if (temp.back() == '>')
      break;
  }
}



int main() {
  /* Enter your code here. Read input from STDIN. Print output to STDOUT */


  int n, q;

  cin >> n;
  cin >> q;

  vector<string> tags;
  vector<vector<pair<string, string>>> attributes;

  string temp;
  string tag;
  string prevTag;


  for (int i = 0; i < n; i++)
  {

    // parsing one line into the data

    //Searching for tag name

    cin >> tag;

    tag = tag.substr(1);

    //Checking if starting or ending

    if (tag[0] == '/') // ending
    {
      if (std::string::npos != prevTag.find('.'))
        prevTag = prevTag.substr(0, prevTag.find_last_of('.'));
      else
        prevTag = "";
      continue;
    }
    else //starting tag
    {
      vector<pair<string, string>> attributesOfTag;
      if (tag.back() == '>')
      {
        tag.pop_back();
      }
      else
      {
        handleAttributes(attributesOfTag);
      }

      if (prevTag != "")
      {
        tag = prevTag + "." + tag;
      }
      tags.push_back(tag);
      prevTag = tag;


      attributes.push_back(attributesOfTag);
    }
  }


  string tagName;
  string attributeName;

  vector<string> results;

  for (int i = 0; i < q; i++)
  {
    cin >> tagName;
    attributeName = tagName.substr(tagName.find_last_of('~') + 1);
    tagName = tagName.substr(0, tagName.find_last_of('~'));

    int j = 0;
    bool foundTag = false;
    bool foundAttribute = false;
    for (const auto& tagIt : tags)
    {
      if (tagIt == tagName)
      {
        foundTag = true;
        for (const auto& attributeIt : attributes[j])
        {
          if (attributeIt.first == attributeName)
          {
            results.push_back(attributeIt.second);
            foundAttribute = true;
            break;
          }

        }
        if (foundAttribute == false)
          results.push_back("Not Found!");
        break;
      }
      j++;
    }
    if (!foundTag)
      results.push_back("Not Found!");
  }



  for (const auto& result : results)
  {
    cout << result << endl;
  }

  return 0;
}

  • ingit
     + 0 comments
    #include <bits/stdc++.h>
using namespace std;

unordered_map<string, string> m;
string current_path;

string cleanString(const string &s) {
    string temp;
    for (char c : s) {
        if (c != '\"' && c != '>') {
            temp.push_back(c);
        }
    }
    return temp;
}

void parseLine(const string &s) {
    istringstream stream(s);
    string temp, tag, attr, value;

    while (stream >> temp) {
        if (temp[0] == '<') {
            if (temp[1] == '/') {
                size_t pos = current_path.find_last_of('.');
                if (pos != string::npos) {
                    current_path = current_path.substr(0, pos);
                } else {
                    current_path.clear();
                }
            } else {
                tag = temp.substr(1);
                if (tag.back() == '>') tag.pop_back(); 
                if (!current_path.empty()) {
                    current_path += "." + tag;
                } else {
                    current_path = tag;
                }
            }
        } else if (temp[0] == '=') {
            continue;
        } else if (temp[0] == '\"') {
            value = cleanString(temp);
            m[current_path + "~" + attr] = value;
        } else {
            attr = temp;
        }
    }
}

int main() {
    int n, q;
    cin >> n >> q;
    cin.ignore();

    while (n-- > 0) {
        string s;
        getline(cin, s);
        parseLine(s);
    }

    while (q-- > 0) {
        string query;
        getline(cin, query);
        if (m.find(query) != m.end()) {
            cout << m[query] << '\n';
        } else {
            cout << "Not Found!" << '\n';
        }
    }
    return 0;
}