1 Тема від v002002

  • v002002
  • Новий користувач
  • Поза форумом
  • Дата реєстрації: 17.01.2024
  • Повідомлень: 52
    • Репутація: 3

Тема: Не працює кодування

1) Є файл з російськими іменниками і в ньому є таблиці виду

<table>
<tbody>

<tr><! -- перший -->
<th><a>падеж</a>
</th>
<th><a>ед.ч.</a>
</th>
<th><a>мн.ч.</a>
</th>
</tr>

<tr><! -- другий -->
<td><a>Им.</a>
</td>
<td>абзац
</td>
<td>абзацы
</td>
</tr>

<tr><! -- третій -->
<td><a>Р.</a>
</td>
<td>абзаца
</td>
<td>абзацев
</td>
</tr>

<tr><! -- четвертий -->
<td><a>Д.</a>
</td>
<td>абзацу
</td>
<td>абзацам
</td>
</tr>

<tr><! -- пятий -->
<td><a>В.</a>
</td>
<td>абзац
</td>
<td>абзацы
</td>
</tr>

<tr><! -- шостий -->
<td><a>Тв.</a>
</td>
<td>абзацем
</td>
<td>абзацами
</td>
</tr>

<tr><! -- сьомий -->
<td><a>Пр.</a>
</td>
<td>абзаце
</td>
<td>абзацах
</td>
</tr>
</tbody></table>
перший <tr></tr> пропуск (опис)
другий <tr></tr> Називний (Именительный), переклад як NOMINATIVE: перший <td></td> пропуск, другий однина, третій множ.
3  <tr></tr>  Родовий(Родительный) GENITIVE : перший <td></td> пропуск, другий однина, третій множ.
4 <tr></tr> Давальний(Дательный) DATIVE: перший <td></td> пропуск, другий однина, третій множ.
5 <tr></tr> Знахідний(Винительный) ACCUSATIVE: перший <td></td> пропуск, другий однина, третій множ.
6 <tr></tr> Орудний(Творительный) INSTRUMENTAL: перший <td></td> пропуск, другий однина, третій множ.
7 <tr></tr> Не знайшов аналога(Предложный) PREPOSITIONAL: перший <td></td> пропуск, другий однина, третій множ.
8 пропуск (інші різні відмінки і є не у всіх таблицях)

Причому між <td></td> можуть міститися кілька варіантів, розділених через <br>, але це зберігається як одна стрічка.
2) Код

#define NOMINATIVE 0
#define GENITIVE 1
#define DATIVE 2
#define ACCUSATIVE 3
#define INSTRUMENTAL 4
#define PREPOSITIONAL 5

#define SINGULAR 0
#define PLURAL 1

struct st_noun_char
{
    int inum;
    int icase;
    string str;
};
struct st_noun
{
    st_noun_char sing[6];
    st_noun_char plur[6];
};

3) Код для витягання у стрічки між <table></table>, <tr></tr>, <td></td>

struct ss
{
    size_t pos;
    string sstr;
};

ss sub(string str, string beg, string end, size_t pos)
{
    ss ret;
    size_t pos1=str.find(beg, pos);
    if(pos1!=std::string::npos)
    {
        size_t pos2=str.find(end, pos1);
        if(pos2!=std::string::npos)
        {
            ret.sstr=str.substr(pos1+beg.size(), pos2-pos1-end.size()+1);
        }
        ret.pos=pos2;
        return ret;
    }
    ret.pos = pos1;
    return ret;
}

Прикладом виконання має бути

string table="<table><tr>1</tr></table>";
ss tr=sub(table, "<table>", "</table>);
cout << tr.sstr << endl;
<tr>1</tr>

4) Код для розбиття на слова через <br>

std::vector<std::string> split(const std::string& str, const std::string& delim) {
  std::vector<std::string> words;
  size_t start = 0;
  size_t end = str.find(delim);
  while (end != std::string::npos) {
    words.push_back(str.substr(start, end - start));
    start = end + delim.length();
    end = str.find(delim, start);
  }
  words.push_back(str.substr(start));
  return words;
}

5) Усе разом з кодом для "завантаження іменників", "перевірки іменників" та "друку іменників":

#include <iostream>
#include <string>
#include <fstream>
#include <vector>
#include <sstream>
#include <windows.h>
#define NOMINATIVE 0
#define GENITIVE 1
#define DATIVE 2
#define ACCUSATIVE 3
#define INSTRUMENTAL 4
#define PREPOSITIONAL 5

#define SINGULAR 0
#define PLURAL 1
using namespace std;
std::vector<std::string> split(const std::string& str, const std::string& delim) {
  std::vector<std::string> words;
  size_t start = 0;
  size_t end = str.find(delim);
  while (end != std::string::npos) {
    words.push_back(str.substr(start, end - start));
    start = end + delim.length();
    end = str.find(delim, start);
  }
  words.push_back(str.substr(start));
  return words;
}
struct ss
{
    size_t pos;
    string sstr;
};
struct st_noun_char
{
    int inum;
    int icase;
    string str;
};
struct st_noun
{
    st_noun_char sing[6];
    st_noun_char plur[6];
};
ss sub(string str, string beg, string end, size_t pos)
{
    ss ret;
    size_t pos1=str.find(beg, pos);
    if(pos1!=std::string::npos)
    {
        size_t pos2=str.find(end, pos1);
        if(pos2!=std::string::npos)
        {
            ret.sstr=str.substr(pos1+beg.size(), pos2-pos1-end.size()+1);
            
        }
        ret.pos=pos2;
        return ret;
    }
    ret.pos = pos1;
    return ret;
}
st_noun load_noun(string str)// це видобуте з <table></table>
{
    string trfrom="<tr>";
    string trto="</tr>";
    string tdfrom="<td>";
    string tdto="</td>";
    
    ss op1, op2, op3;
    op2.pos=0;op3.pos=0;
    st_noun noun;
    
    op2=sub(str, trfrom, trto, op2.pos);//propusk
    //BEGIN
    op2=sub(str, trfrom, trto, op2.pos);
    op3.pos=0;
    
    op3=sub(op2.sstr, tdfrom, tdto, op3.pos);//propusk
    
    op3=sub(op2.sstr, tdfrom, tdto, op3.pos);//NOMINATIVE
    noun.sing[NOMINATIVE].inum=SINGULAR;
    noun.sing[NOMINATIVE].icase=NOMINATIVE;
    noun.sing[NOMINATIVE].str=op3.sstr;
    
    op3=sub(op2.sstr, tdfrom, tdto, op3.pos);//NOMINATIVE
    noun.plur[NOMINATIVE].inum=PLURAL;
    noun.plur[NOMINATIVE].icase=NOMINATIVE;
    noun.plur[NOMINATIVE].str=op3.sstr;
    //END
    //BEGIN
    op2=sub(str, trfrom, trto, op2.pos);
    op3.pos=0;
    
    op3=sub(op2.sstr, tdfrom, tdto, op3.pos);//propusk
    
    op3=sub(op2.sstr, tdfrom, tdto, op3.pos);//GENITIVE
    noun.sing[GENITIVE].inum=SINGULAR;
    noun.sing[GENITIVE].icase=GENITIVE;
    noun.sing[GENITIVE].str=op3.sstr;
    
    op3=sub(op2.sstr, tdfrom, tdto, op3.pos);//GENITIVE
    noun.plur[GENITIVE].inum=PLURAL;
    noun.plur[GENITIVE].icase=GENITIVE;
    noun.plur[GENITIVE].str=op3.sstr;
    //END
    //BEGIN
    op2=sub(str, trfrom, trto, op2.pos);
    op3.pos=0;
    
    op3=sub(op2.sstr, tdfrom, tdto, op3.pos);//propusk
    
    op3=sub(op2.sstr, tdfrom, tdto, op3.pos);//DATIVE
    noun.sing[DATIVE].inum=SINGULAR;
    noun.sing[DATIVE].icase=DATIVE;
    noun.sing[DATIVE].str=op3.sstr;
    
    op3=sub(op2.sstr, tdfrom, tdto, op3.pos);//DATIVE
    noun.plur[DATIVE].inum=PLURAL;
    noun.plur[DATIVE].icase=DATIVE;
    noun.plur[DATIVE].str=op3.sstr;
    //END
    //BEGIN
    op2=sub(str, trfrom, trto, op2.pos);
    op3.pos=0;
    
    op3=sub(op2.sstr, tdfrom, tdto, op3.pos);//propusk
    
    op3=sub(op2.sstr, tdfrom, tdto, op3.pos);//ACCUSATIVE
    noun.sing[ACCUSATIVE].inum=SINGULAR;
    noun.sing[ACCUSATIVE].icase=ACCUSATIVE;
    noun.sing[ACCUSATIVE].str=op3.sstr;
    
    op3=sub(op2.sstr, tdfrom, tdto, op3.pos);//ACCUSATIVE
    noun.plur[ACCUSATIVE].inum=PLURAL;
    noun.plur[ACCUSATIVE].icase=ACCUSATIVE;
    noun.plur[ACCUSATIVE].str=op3.sstr;
    //END
    //BEGIN
    op2=sub(str, trfrom, trto, op2.pos);
    op3.pos=0;
    
    op3=sub(op2.sstr, tdfrom, tdto, op3.pos);//propusk
    
    op3=sub(op2.sstr, tdfrom, tdto, op3.pos);//INSTRUMENTAL
    noun.sing[INSTRUMENTAL].inum=SINGULAR;
    noun.sing[INSTRUMENTAL].icase=INSTRUMENTAL;
    noun.sing[INSTRUMENTAL].str=op3.sstr;
    
    op3=sub(op2.sstr, tdfrom, tdto, op3.pos);//INSTRUMENTAL
    noun.plur[INSTRUMENTAL].inum=PLURAL;
    noun.plur[INSTRUMENTAL].icase=INSTRUMENTAL;
    noun.plur[INSTRUMENTAL].str=op3.sstr;
    //END
    //BEGIN
    op2=sub(str, trfrom, trto, op2.pos);
    op3.pos=0;
    
    op3=sub(op2.sstr, tdfrom, tdto, op3.pos);//propusk
    
    op3=sub(op2.sstr, tdfrom, tdto, op3.pos);//PREPOSITIONAL
    noun.sing[PREPOSITIONAL].inum=SINGULAR;
    noun.sing[PREPOSITIONAL].icase=PREPOSITIONAL;
    noun.sing[PREPOSITIONAL].str=op3.sstr;
    
    op3=sub(op2.sstr, tdfrom, tdto, op3.pos);//PREPOSITIONAL
    noun.plur[PREPOSITIONAL].inum=PLURAL;
    noun.plur[PREPOSITIONAL].icase=PREPOSITIONAL;
    noun.plur[PREPOSITIONAL].str=op3.sstr;
    //END
    return noun;
}
void print_noun(st_noun noun)
{
    SetConsoleCP(1251);
    SetConsoleOutputCP(1251);
    cout << "\tSINGULAR\tPLURAL\n";
    cout << "N:\t" << noun.sing[NOMINATIVE].str << "\t" << noun.plur[NOMINATIVE].str << "\n";
    cout << "G:\t" << noun.sing[GENITIVE].str << "\t" << noun.plur[GENITIVE].str << "\n";
    cout << "D:\t" << noun.sing[DATIVE].str << "\t" << noun.plur[DATIVE].str << "\n";
    cout << "A:\t" << noun.sing[ACCUSATIVE].str << "\t" << noun.plur[ACCUSATIVE].str << "\n";
    cout << "A:\t" << noun.sing[INSTRUMENTAL].str << "\t" << noun.plur[INSTRUMENTAL].str << "\n";
    cout << "P:\t" << noun.sing[PREPOSITIONAL].str << "\t" << noun.plur[PREPOSITIONAL].str << "\n";
    
}
bool check_noun(st_noun noun, string str)
{
    vector <string> singNom=split(noun.sing[NOMINATIVE].str, "<br>"), plurNom=split(noun.plur[NOMINATIVE].str, "<br>"),
            singGen=split(noun.sing[GENITIVE].str, "<br>"), plurGen=split(noun.plur[GENITIVE].str, "<br>"),
            singDat=split(noun.sing[DATIVE].str, "<br>"), plurDat=split(noun.plur[DATIVE].str, "<br>"),
            singAcc=split(noun.sing[ACCUSATIVE].str, "<br>"), plurAcc=split(noun.plur[ACCUSATIVE].str, "<br>"),
            singInst=split(noun.sing[INSTRUMENTAL].str, "<br>"), plurInst=split(noun.plur[INSTRUMENTAL].str, "<br>"),
            singPrep=split(noun.sing[PREPOSITIONAL].str, "<br>"), plurPrep=split(noun.plur[PREPOSITIONAL].str, "<br>");
    bool b=0;
    for (int i=0; i<singNom.size(); i++) if(singNom[i]==str) b=1; for (int i=0; i<plurNom.size(); i++) if(plurNom[i]==str) b=1; 
    for (int i=0; i<singGen.size(); i++) if(singGen[i]==str) b=1; for (int i=0; i<plurGen.size(); i++) if(plurGen[i]==str) b=1; 
    for (int i=0; i<singDat.size(); i++) if(singDat[i]==str) b=1; for (int i=0; i<plurDat.size(); i++) if(plurDat[i]==str) b=1; 
    for (int i=0; i<singAcc.size(); i++) if(singAcc[i]==str) b=1; for (int i=0; i<plurAcc.size(); i++) if(plurAcc[i]==str) b=1; 
    for (int i=0; i<singInst.size(); i++) if(singInst[i]==str) b=1; for (int i=0; i<plurInst.size(); i++) if(plurInst[i]==str) b=1; 
    for (int i=0; i<singPrep.size(); i++) if(singPrep[i]==str) b=1; for (int i=0; i<plurPrep.size(); i++) if(plurPrep[i]==str) b=1; 
    
    return b;
}

6) Код завантаження файлу в стрічку

string LoadFile(string FilePath) {
  ifstream infile(FilePath.c_str());
  if (!infile.is_open()) {
    cerr << "File\"" << FilePath << "\" not found." << endl;
    return "";
  }
  string content;
  string line;
  while (getline(infile, line)) {
    content += line + "\n";
  }
  infile.close();

  return content;
}

7) Розбиття стрічки на слова через пробіл (для файлу з текстом)

std::vector<std::string> delim(const std::string str) {
    std::vector<std::string> result;
    std::istringstream iss(str);
    std::string word;
    while (iss >> word) {
        result.push_back(word);
    }
    return result;
}

8) Разом з main()

#include <iostream>
#include <string>
#include <fstream>
#include <vector>
#include <sstream>
#include <windows.h>
#define NOMINATIVE 0
#define GENITIVE 1
#define DATIVE 2
#define ACCUSATIVE 3
#define INSTRUMENTAL 4
#define PREPOSITIONAL 5

#define SINGULAR 0
#define PLURAL 1
using namespace std;
std::vector<std::string> split(const std::string& str, const std::string& delim) {
  std::vector<std::string> words;
  size_t start = 0;
  size_t end = str.find(delim);
  while (end != std::string::npos) {
    words.push_back(str.substr(start, end - start));
    start = end + delim.length();
    end = str.find(delim, start);
  }
  words.push_back(str.substr(start));
  return words;
}
struct ss
{
    size_t pos;
    string sstr;
};
struct st_noun_char
{
    int inum;
    int icase;
    string str;
};
struct st_noun
{
    st_noun_char sing[6];
    st_noun_char plur[6];
};
ss sub(string str, string beg, string end, size_t pos)
{
    ss ret;
    size_t pos1=str.find(beg, pos);
    if(pos1!=std::string::npos)
    {
        size_t pos2=str.find(end, pos1);
        if(pos2!=std::string::npos)
        {
            ret.sstr=str.substr(pos1+beg.size(), pos2-pos1-end.size()+1);
            
        }
        ret.pos=pos2;
        return ret;
    }
    ret.pos = pos1;
    return ret;
}
string LoadFile(string FilePath) {
  ifstream infile(FilePath.c_str());
  if (!infile.is_open()) {
    cerr << "File\"" << FilePath << "\" not found." << endl;
    return "";
  }
  string content;
  string line;
  while (getline(infile, line)) {
    content += line + "\n";
  }
  infile.close();

  return content;
}

st_noun load_noun(string str)
{
    string trfrom="<tr>";
    string trto="</tr>";
    string tdfrom="<td>";
    string tdto="</td>";
    
    ss op1, op2, op3;
    op2.pos=0;op3.pos=0;
    st_noun noun;
    
    op2=sub(str, trfrom, trto, op2.pos);//propusk
    //BEGIN
    op2=sub(str, trfrom, trto, op2.pos);
    op3.pos=0;
    
    op3=sub(op2.sstr, tdfrom, tdto, op3.pos);//propusk
    
    op3=sub(op2.sstr, tdfrom, tdto, op3.pos);//NOMINATIVE
    noun.sing[NOMINATIVE].inum=SINGULAR;
    noun.sing[NOMINATIVE].icase=NOMINATIVE;
    noun.sing[NOMINATIVE].str=op3.sstr;
    
    op3=sub(op2.sstr, tdfrom, tdto, op3.pos);//NOMINATIVE
    noun.plur[NOMINATIVE].inum=PLURAL;
    noun.plur[NOMINATIVE].icase=NOMINATIVE;
    noun.plur[NOMINATIVE].str=op3.sstr;
    //END
    //BEGIN
    op2=sub(str, trfrom, trto, op2.pos);
    op3.pos=0;
    
    op3=sub(op2.sstr, tdfrom, tdto, op3.pos);//propusk
    
    op3=sub(op2.sstr, tdfrom, tdto, op3.pos);//GENITIVE
    noun.sing[GENITIVE].inum=SINGULAR;
    noun.sing[GENITIVE].icase=GENITIVE;
    noun.sing[GENITIVE].str=op3.sstr;
    
    op3=sub(op2.sstr, tdfrom, tdto, op3.pos);//GENITIVE
    noun.plur[GENITIVE].inum=PLURAL;
    noun.plur[GENITIVE].icase=GENITIVE;
    noun.plur[GENITIVE].str=op3.sstr;
    //END
    //BEGIN
    op2=sub(str, trfrom, trto, op2.pos);
    op3.pos=0;
    
    op3=sub(op2.sstr, tdfrom, tdto, op3.pos);//propusk
    
    op3=sub(op2.sstr, tdfrom, tdto, op3.pos);//DATIVE
    noun.sing[DATIVE].inum=SINGULAR;
    noun.sing[DATIVE].icase=DATIVE;
    noun.sing[DATIVE].str=op3.sstr;
    
    op3=sub(op2.sstr, tdfrom, tdto, op3.pos);//DATIVE
    noun.plur[DATIVE].inum=PLURAL;
    noun.plur[DATIVE].icase=DATIVE;
    noun.plur[DATIVE].str=op3.sstr;
    //END
    //BEGIN
    op2=sub(str, trfrom, trto, op2.pos);
    op3.pos=0;
    
    op3=sub(op2.sstr, tdfrom, tdto, op3.pos);//propusk
    
    op3=sub(op2.sstr, tdfrom, tdto, op3.pos);//ACCUSATIVE
    noun.sing[ACCUSATIVE].inum=SINGULAR;
    noun.sing[ACCUSATIVE].icase=ACCUSATIVE;
    noun.sing[ACCUSATIVE].str=op3.sstr;
    
    op3=sub(op2.sstr, tdfrom, tdto, op3.pos);//ACCUSATIVE
    noun.plur[ACCUSATIVE].inum=PLURAL;
    noun.plur[ACCUSATIVE].icase=ACCUSATIVE;
    noun.plur[ACCUSATIVE].str=op3.sstr;
    //END
    //BEGIN
    op2=sub(str, trfrom, trto, op2.pos);
    op3.pos=0;
    
    op3=sub(op2.sstr, tdfrom, tdto, op3.pos);//propusk
    
    op3=sub(op2.sstr, tdfrom, tdto, op3.pos);//INSTRUMENTAL
    noun.sing[INSTRUMENTAL].inum=SINGULAR;
    noun.sing[INSTRUMENTAL].icase=INSTRUMENTAL;
    noun.sing[INSTRUMENTAL].str=op3.sstr;
    
    op3=sub(op2.sstr, tdfrom, tdto, op3.pos);//INSTRUMENTAL
    noun.plur[INSTRUMENTAL].inum=PLURAL;
    noun.plur[INSTRUMENTAL].icase=INSTRUMENTAL;
    noun.plur[INSTRUMENTAL].str=op3.sstr;
    //END
    //BEGIN
    op2=sub(str, trfrom, trto, op2.pos);
    op3.pos=0;
    
    op3=sub(op2.sstr, tdfrom, tdto, op3.pos);//propusk
    
    op3=sub(op2.sstr, tdfrom, tdto, op3.pos);//PREPOSITIONAL
    noun.sing[PREPOSITIONAL].inum=SINGULAR;
    noun.sing[PREPOSITIONAL].icase=PREPOSITIONAL;
    noun.sing[PREPOSITIONAL].str=op3.sstr;
    
    op3=sub(op2.sstr, tdfrom, tdto, op3.pos);//PREPOSITIONAL
    noun.plur[PREPOSITIONAL].inum=PLURAL;
    noun.plur[PREPOSITIONAL].icase=PREPOSITIONAL;
    noun.plur[PREPOSITIONAL].str=op3.sstr;
    //END
    return noun;
}
void print_noun(st_noun noun)
{
    SetConsoleCP(1251);
    SetConsoleOutputCP(1251);
    cout << "\tSINGULAR\tPLURAL\n";
    cout << "N:\t" << noun.sing[NOMINATIVE].str << "\t" << noun.plur[NOMINATIVE].str << "\n";
    cout << "G:\t" << noun.sing[GENITIVE].str << "\t" << noun.plur[GENITIVE].str << "\n";
    cout << "D:\t" << noun.sing[DATIVE].str << "\t" << noun.plur[DATIVE].str << "\n";
    cout << "A:\t" << noun.sing[ACCUSATIVE].str << "\t" << noun.plur[ACCUSATIVE].str << "\n";
    cout << "A:\t" << noun.sing[INSTRUMENTAL].str << "\t" << noun.plur[INSTRUMENTAL].str << "\n";
    cout << "P:\t" << noun.sing[PREPOSITIONAL].str << "\t" << noun.plur[PREPOSITIONAL].str << "\n";
    
}
bool check_noun(st_noun noun, string str)
{
    vector <string> singNom=split(noun.sing[NOMINATIVE].str, "<br>"), plurNom=split(noun.plur[NOMINATIVE].str, "<br>"),
            singGen=split(noun.sing[GENITIVE].str, "<br>"), plurGen=split(noun.plur[GENITIVE].str, "<br>"),
            singDat=split(noun.sing[DATIVE].str, "<br>"), plurDat=split(noun.plur[DATIVE].str, "<br>"),
            singAcc=split(noun.sing[ACCUSATIVE].str, "<br>"), plurAcc=split(noun.plur[ACCUSATIVE].str, "<br>"),
            singInst=split(noun.sing[INSTRUMENTAL].str, "<br>"), plurInst=split(noun.plur[INSTRUMENTAL].str, "<br>"),
            singPrep=split(noun.sing[PREPOSITIONAL].str, "<br>"), plurPrep=split(noun.plur[PREPOSITIONAL].str, "<br>");
    bool b=0;
    for (int i=0; i<singNom.size(); i++) if(singNom[i]==str) b=1; for (int i=0; i<plurNom.size(); i++) if(plurNom[i]==str) b=1; 
    for (int i=0; i<singGen.size(); i++) if(singGen[i]==str) b=1; for (int i=0; i<plurGen.size(); i++) if(plurGen[i]==str) b=1; 
    for (int i=0; i<singDat.size(); i++) if(singDat[i]==str) b=1; for (int i=0; i<plurDat.size(); i++) if(plurDat[i]==str) b=1; 
    for (int i=0; i<singAcc.size(); i++) if(singAcc[i]==str) b=1; for (int i=0; i<plurAcc.size(); i++) if(plurAcc[i]==str) b=1; 
    for (int i=0; i<singInst.size(); i++) if(singInst[i]==str) b=1; for (int i=0; i<plurInst.size(); i++) if(plurInst[i]==str) b=1; 
    for (int i=0; i<singPrep.size(); i++) if(singPrep[i]==str) b=1; for (int i=0; i<plurPrep.size(); i++) if(plurPrep[i]==str) b=1; 
    
    return b;
}
std::vector<std::string> delim(const std::string str) {
    std::vector<std::string> result;
    std::istringstream iss(str);
    std::string word;
    while (iss >> word) {
        result.push_back(word);
    }
    return result;
}
int main()
{
    SetConsoleCP(1251);
    SetConsoleOutputCP(1251);
    string tablefrom="<table>";
    string tableto="</table>";
    
    string input_file_n;
    cout << "Input File1: ";
    cin>>input_file_n;
    string input_file_n2;
    cout << "Input File2: ";
    cin>>input_file_n2;
    string str2=LoadFile(input_file_n2);
    string str=LoadFile(input_file_n);
    ss op1;
    op1.pos=0;
    st_noun noun;
    std::vector<std::string> words=delim(str2);
    for (int i=0; i<words.size(); i++)
    {
        op1.pos=0;
        while(op1.pos!=std::string::npos)
         {
             op1=sub(str, tablefrom, tableto, op1.pos);
            noun=load_noun(op1.sstr);
            if(check_noun(noun, words[i])) cout << noun.sing[NOMINATIVE].str << " ";
         }
    }
     
    
    return 0;
}

Результат роботи має бути таким.
Вхід: nouns.txt, text.txt ANSI
Вихід: іменники у називному відмінку по порядку, що використовувалися у тексті text.txt
Але я не отримую нічого.
Те саме і при вводі з клавіатури.
Але функція print_noun() працює і виводить іменники як за планом.
Тобто треба зберегти у nouns.txt таблицю з початку повідомлення (з "абзацем"), написати текст типу "в абзацах" і зберегти у text.txt.
І у мене трохи інший код (зовсім трохи), я редагував його прямо тут але сенс той

2 Відповідь від v002002

  • v002002
  • Новий користувач
  • Поза форумом
  • Дата реєстрації: 17.01.2024
  • Повідомлень: 52
    • Репутація: 3

Re: Не працює кодування

Рішення виявилось простим. Воно записує не "абзац", а "абзац\n". Якщо стерти у nouns.txt всі нові рядки (\n), функція check_noun()  працює