Найти ID цепочки ДНК, имеющей наибольший показатель содержания GC

/* Template of the assignment 1 */
 
// Include libraries
#include <cstdio>
#include <fstream>
#include <string>
using namespace std;
 
// Main function
int main() {
    // Open file "rosaling_GC.txt" without any errors check
    ifstream sample;
    sample.open("rosalind_GC.txt");
    if (!sample.good()) { // Check has file been opened
        printf("%s\n", "Bad file. Does it exist?");
        return -1;
    }
    // Define a strands' amount to process 
    const unsigned int STRANDS_AMOUNT = 9;
    // 2 arrays keep a pair of values: id of a strand and the strand itself
    // e.g.
    // >strand1
    // ACTGA
    // GTTC
    // >strand2
    // CTGGC
    // will be kept as ids[0] == "strand1", ids[1] == "strand2"
    // strands[0] == "ACTGAGTTC", strands[1] == "CTGGC"
    string ids[STRANDS_AMOUNT];
    string strands[STRANDS_AMOUNT];
 
    // Some auxiliary variables
    int pos = -1;
    string currentLine;
    // Loop writes a pair of a strand's id and the strand to arrays
    while (!sample.eof()) {
        getline(sample, currentLine); // read one line from txt
 
        if (currentLine[0] == '>') { // check if it's id
            pos++;
 
            ids[pos] = currentLine.substr(1, currentLine.length()); // fill id
            strands[pos] = "";
        } else { // else proceed the strand filling
            int winReturnPos = currentLine.rfind('\r'); // A dirty hack aganst a windows file format
            strands[pos] += currentLine.substr(0,
                (winReturnPos < 0) ? currentLine.length() : winReturnPos);
        }
    };
 
    // some auxiliary variables
    int maxValuePosition = 0;
    double maxValue = 0.0;
 
    // ============ YOUR CODE HERE =======================
 
 
 
 
 
 
 
 
 
    // ====================================================
 
    printf("%s\n%.2f%%\n" , ids[maxValuePosition].c_str(), maxValue);
 
    sample.close();
    return 0;
};

int GC_count=0;
for(size_t pos=0;pos!=string::npos;pos=sequence.find("GC",pos),++GC_count)
    if(pos!=string::npos)
        pos+=2;

/////////////////////////////////////////////////////////////////////////////////////////
//Дано: Максимум 10 цепочек ДНК в формате FASTA (каждая длинной не более 1 тыс. знаков).
//Возвращаемое значение: ID цепочки, имеющей наибольший показатель содержания GC, за которым 
//следует сам показатель цепочки с точностью до 2-х десятичных знаков.
//
// 2 arrays keep a pair of values: id of a strand and the strand itself
    // e.g.
    // >strand1
    // ACTGA
    // GTTC
    // >strand2
    // CTGGC
    // will be kept as ids[0] == "strand1", ids[1] == "strand2"
    // strands[0] == "ACTGAGTTC", strands[1] == "CTGGC"
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cctype>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <string>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string                             T_str;
typedef T_str::size_type                        T_pos;
typedef std::map        < T_str,    T_str   >   T_DNA_chain_of_chain_name;
typedef std::pair       < T_str,    T_str   >   T_chain_name_and_chain;
typedef std::multimap   < double,   T_str   >   T_DNA_chain_name_of_GC_rate;
/////////////////////////////////////////////////////////////////////////////////////////
void    remove_from_string_symbol_and_spaces
    (
        T_str   &   s,
        char        bad_symb
    )
{
    s.erase
        (
            std::remove_if
                (
                    s.begin     (),
                    s.end       (),
 
                    [=]         ( char  c )
                    {
                        return      c == bad_symb
                                ||  isspace(c);
                    }
                ),
 
            s.end()
        );
}
/////////////////////////////////////////////////////////////////////////////////////////
namespace std
{
    std::istream    &   operator>>
        (
            std::istream            &   istr,
            T_chain_name_and_chain  &   chain_name_and_chain
        )
    {
        static  const   char    CHAIN_NAME_PREFIX   =   '>';
 
        getline                                 ( istr,     chain_name_and_chain.first                          );
        getline                                 ( istr,     chain_name_and_chain.second,    CHAIN_NAME_PREFIX   );
 
        remove_from_string_symbol_and_spaces    ( chain_name_and_chain.first,   CHAIN_NAME_PREFIX   );
        remove_from_string_symbol_and_spaces    ( chain_name_and_chain.second,  CHAIN_NAME_PREFIX   );
 
        return  istr;
    }
}
////////////////////////////////////////////////////////////////////////////////////////
class   T_DNA_calculator
{
    //-----------------------------------------------------------------------------------
    T_DNA_chain_of_chain_name       DNA_chain_of_chain_name_;
    T_DNA_chain_name_of_GC_rate     DNA_chain_name_of_GC_rate_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    void    load_data_from_file( T_str  const   &   filename )
    {
        std::ifstream   ifile( filename );
 
        if( !ifile )
        {
            std::cout   <<  "Файл \""
                        <<  filename
                        <<  "\" не найден."
                        <<  std::endl;
 
            system("pause");
            exit(0);
        }//if
 
        std::copy
            (
                std::istream_iterator< T_chain_name_and_chain >     ( ifile ),
                std::istream_iterator< T_chain_name_and_chain >     (),
 
                std::inserter
                    (
                        DNA_chain_of_chain_name_,
                        DNA_chain_of_chain_name_.begin()
                    )
            );
    }
    //-----------------------------------------------------------------------------------
    void    calc_GC_rate()
    {
        std::transform
            (
                DNA_chain_of_chain_name_.begin  (),
                DNA_chain_of_chain_name_.end    (),
 
                std::inserter
                    (
                        DNA_chain_name_of_GC_rate_,
                        DNA_chain_name_of_GC_rate_.begin()
                    ),
 
                [=]  ( T_DNA_chain_of_chain_name::value_type    const   &   chain_name_and_chain )
                {
                    return  std::make_pair
                                (
                                    get_GC_rate_for_DNA_chain( chain_name_and_chain.second ),
                                    chain_name_and_chain.first
                                );
                }
            );
    }
    //-----------------------------------------------------------------------------------
    void    print_max_GC_rate()
    {
        static  const   int     PRECISION   =   2;
        auto                    rev_it      =   DNA_chain_name_of_GC_rate_.rbegin();
 
        std::cout   <<  "Частота подстроки \"GC\" максимальна в цепочке \""
                    <<  rev_it->second
                    <<  "\" "
                    <<  std::endl
                    <<  "и составляет "
                    <<  std::fixed
                    <<  std::setprecision( PRECISION )
                    <<  rev_it->first
                    <<  " %."
                    <<  std::endl;
    }
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    double  get_GC_rate_for_DNA_chain( T_str   const   &   chain )
    {
        static  const   int     PERCENT_PER_UNIT    =   100;
        int                     GC_counter          =   0;
        T_pos                   find_begin_pos      =   0;
        T_str                   substr_for_find     =   "GC";
 
        while   (
                        (
                            find_begin_pos  =   chain.find
                                                    (
                                                        substr_for_find,
                                                        find_begin_pos
                                                    )
                        )
 
                    !=  T_str::npos
                )
        {
            ++GC_counter;
            ++find_begin_pos;
        }//while
 
        return  double( GC_counter ) / chain.size() * PERCENT_PER_UNIT;
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    std::locale::global(std::locale(""));
    const   T_str       DNA_FILENAME    =   "dna.txt";
    T_DNA_calculator    DNA_calculator;
 
    DNA_calculator.load_data_from_file  ( DNA_FILENAME );
    DNA_calculator.calc_GC_rate         ();
    DNA_calculator.print_max_GC_rate    ();
    system("pause");
}