Задачи для тренировки и лучшего понимания

///////////////////////////////////////////////////////////////////////////////
// Калькулятор делает то же, что и калькулятор в книжке Страуструпа, т.е.
// вычисляет последовательность арифметических выражений, в которых используются
// круглые скобки. Арифметические выражения должны быть записаны в одной строке, 
// и разделены точкой с запятой. Арифметическим выражением также считается 
// инициализация переменной. Имеются встроенные константы pi и e.
// Пример корректной строки ввода:
// r = 1.5; a = 2 * pi * r; b = a * a
///////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cctype>
#include <iostream>
#include <map>
#include <sstream>
#include <string>
///////////////////////////////////////////////////////////////////////////////
typedef std::string             T_str;
typedef double                  T_num;
typedef std::map<T_str, T_num>  T_names_values;
///////////////////////////////////////////////////////////////////////////////
class T_calculator
{
    //-------------------------------------------------------------------------    
    enum
    {
        LEFT_PARENTHESIS   = '(',
        RIGHT_PARENTHESIS  = ')',               
        
        PLUS_SIGN   = '+',
        MINUS_SIGN  = '-',        
 
        ASTERISK    = '*',
        SLASH       = '/',
 
        EQUALS_SIGN = '=',
        SEMICOLON   = ';',        
        FINISH_SYMB = '$'
    };
    //-------------------------------------------------------------------------
    T_names_values  names_values;
    //-------------------------------------------------------------------------
public:
    T_calculator();    
    //-------------------------------------------------------------------------
private:
    //-------------------------------------------------------------------------
    bool  calc_expr_list            (const T_str&  s_inp, T_str&  s_out);
    bool  print_expr                (const T_str&  s_inp, T_str&  s_out);    
 
    void  remove_spaces             (T_str&  s);
    bool  calc_expr                 (const T_str&  s_inp, T_str&  s_out, T_num& res);
    bool  calc_semicolon            (const T_str&  s_inp, T_str&  s_out);
 
    bool  calc_summand              (const T_str&  s_inp, T_str&  s_out, T_num& res);
    bool  calc_line_of_summand      (const T_str&  s_inp, T_str&  s_out, T_num& res);
    bool  calc_factor               (const T_str&  s_inp, T_str&  s_out, T_num& res);
 
    bool  calc_line_of_factor       (const T_str&  s_inp, T_str&  s_out, T_num& res);
    bool  calc_add_summand          (const T_str&  s_inp, T_str&  s_out, T_num& res);
    bool  calc_subtract_summand     (const T_str&  s_inp, T_str&  s_out, T_num& res);
 
    bool  calc_minus_factor         (const T_str&  s_inp, T_str&  s_out, T_num& res);
    bool  calc_expr_in_brackets     (const T_str&  s_inp, T_str&  s_out, T_num& res);
    bool  calc_name_and_name_init   (const T_str&  s_inp, T_str&  s_out, T_num& res);
 
    bool  calc_num                  (const T_str&  s_inp, T_str&  s_out, T_num& res);
    bool  calc_mult_to_factor       (const T_str&  s_inp, T_str&  s_out, T_num& res);
    bool  calc_div_into_factor      (const T_str&  s_inp, T_str&  s_out, T_num& res);
 
    bool  calc_plus                 (const T_str&  s_inp, T_str&  s_out);
    bool  calc_minus                (const T_str&  s_inp, T_str&  s_out);
    bool  calc_left_parenthesis     (const T_str&  s_inp, T_str&  s_out);
 
    bool  calc_right_parenthesis    (const T_str&  s_inp, T_str&  s_out);
    void  calc_name                 (const T_str&  s_inp, T_str&  s_out, T_str& name);
    bool  calc_name_init            (const T_str&  s_inp, T_str&  s_out, T_num& res);
 
    bool  calc_asterisk             (const T_str&  s_inp, T_str&  s_out);
    bool  calc_slash                (const T_str&  s_inp, T_str&  s_out);
    bool  calc_equals_sign          (const T_str&  s_inp, T_str&  s_out);
    bool  calc_symb                 (const char c, const T_str&  s_inp, T_str&  s_out);
};
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_name_init(const T_str&  s_inp, T_str&  s_out, T_num& res)
{    
    calc_equals_sign  (s_inp, s_out);
    return  calc_expr (s_out, s_out, res);
}
///////////////////////////////////////////////////////////////////////////////
void  T_calculator::calc_name(const T_str&  s_inp, T_str&  s_out, T_str&  name)
{ 
    T_str::const_iterator  str_it = std::find_if(s_inp.begin(), s_inp.end(), 
                                                 std::not1(std::ptr_fun(isalpha)));
    name.assign(s_inp.begin(), str_it);
    s_out.assign(str_it, s_inp.end());
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_name_and_name_init(const T_str&  s_inp, T_str&  s_out, T_num& res)
{    
    T_str  name;    
    calc_name(s_inp, s_out, name);    
    bool  bool_res;
    if(s_out[0] == EQUALS_SIGN)
    {
        bool_res = calc_name_init(s_out, s_out, res);
        if(bool_res)
        {                
            names_values[name] = res;
        }            
        return  bool_res; 
    }
    else//После имени нет инициализатора.
    {            
        bool_res = (names_values.count(name) != 0);
        //Если имя уже было инициализировано:
        if(bool_res)
        {
            res = names_values[name];                
        }
        else
        {                
            std::cout << "The variable \"" 
                      << name
                      << "\" is not initialized."
                      << std::endl;                
        }
        return  bool_res; 
    }                
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_equals_sign(const T_str&  s_inp, T_str&  s_out)
{
    return  calc_symb(EQUALS_SIGN, s_inp, s_out);
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_semicolon(const T_str&  s_inp, T_str&  s_out)
{
    return  calc_symb(SEMICOLON, s_inp, s_out);
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::print_expr(const T_str&  s_inp, T_str&  s_out)
{
    T_num  num_res;
    bool   bool_res = calc_expr(s_inp, s_out, num_res);
    if(bool_res)
    {
        std::cout << num_res
                  << std::endl;
    }
    return  bool_res;
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_expr_list(const T_str&  s_inp, T_str&  s_out)
{
    if(!print_expr(s_inp, s_out))
    {
        return false;
    }
    switch(s_out[0])
    {
    case FINISH_SYMB:
        return  true;
    case SEMICOLON:
        calc_semicolon(s_out, s_out);
        if(s_out[0] == FINISH_SYMB)
        {
            return true;
        }
        else
        {
            return  calc_expr_list(s_out, s_out);
        }        
    default:
        return false;
    }
}
///////////////////////////////////////////////////////////////////////////////
T_calculator::T_calculator()
{
    names_values["pi"]  = 3.1415926535897932385;                       
    names_values["e"]   = 2.7182818284590452354;
                      
    std::cout << "-> ";
    T_str  s_inp;
    std::getline(std::cin, s_inp);
    if(s_inp.empty()) exit(0);
    remove_spaces(s_inp);
    T_str  s_out;    
    if(!calc_expr_list(s_inp += FINISH_SYMB, s_out))
    {
        std::cout << "Not correct expr.";
    }
    std::cout << std::endl
              << std::endl
              << std::endl;
}
///////////////////////////////////////////////////////////////////////////////
void  T_calculator::remove_spaces(T_str&  s)
{    
    for(;;)
    {
        T_str::size_type  pos = s.find_first_of(" \t");   
        if(pos == T_str::npos)
        {
            break;
        }
        s = s.erase(pos, 1);
    }    
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_expr(const T_str&  s_inp, T_str&  s_out, T_num& res)
{    
    return     calc_summand         (s_inp, s_out, res)
            && calc_line_of_summand (s_out, s_out, res);   
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_summand(const T_str&  s_inp, T_str&  s_out, T_num& res)
{    
    return     calc_factor         (s_inp, s_out, res)
            && calc_line_of_factor (s_out, s_out, res);   
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_line_of_summand(const T_str&  s_inp, T_str&  s_out, T_num& res)
{   
    switch(s_inp[0])
    {
    case PLUS_SIGN:
        return     calc_add_summand      (s_inp, s_out, res)
                && calc_line_of_summand  (s_out, s_out, res);
    case MINUS_SIGN:
        return     calc_subtract_summand (s_inp, s_out, res)
                && calc_line_of_summand  (s_out, s_out, res);
    default:
        return  true;
    }
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_factor(const T_str&  s_inp, T_str&  s_out, T_num& res)
{    
    switch(s_inp[0])
    {
    case MINUS_SIGN:
        return  calc_minus_factor           (s_inp, s_out, res);
    case LEFT_PARENTHESIS:
        return  calc_expr_in_brackets       (s_inp, s_out, res);    
    default:
        if(isalpha(s_inp[0]))
        {
            return  calc_name_and_name_init (s_inp, s_out, res);
        }
        else
        {
            return  calc_num                (s_inp, s_out, res);
        }        
    }
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_minus_factor(const T_str&  s_inp, T_str&  s_out, T_num& res)
{    
    bool   bool_res =    calc_minus  (s_inp, s_out)
                      && calc_factor (s_out, s_out, res);
    res *= -1;
    return  bool_res;
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_line_of_factor(const T_str&  s_inp, T_str&  s_out, T_num& res)
{
    switch(s_inp[0])
    {
    case ASTERISK:
        return     calc_mult_to_factor  (s_inp, s_out, res)
                && calc_line_of_factor  (s_out, s_out, res);
    case SLASH:
        return     calc_div_into_factor (s_inp, s_out, res)
                && calc_line_of_factor  (s_out, s_out, res);
    default:
        return  true;
    }
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_add_summand(const T_str&  s_inp, T_str&  s_out, T_num& res)
{    
    T_num  res_summand;
    bool   bool_res =     calc_plus    (s_inp, s_out)
                       && calc_summand (s_out, s_out, res_summand);
    res += res_summand;
    return  bool_res;
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_subtract_summand(const T_str&  s_inp, T_str&  s_out, T_num& res)
{    
    T_num  res_summand;
    bool   bool_res =     calc_minus   (s_inp, s_out)
                       && calc_summand (s_out, s_out, res_summand);
    res -= res_summand;
    return  bool_res;
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_mult_to_factor(const T_str&  s_inp, T_str&  s_out, T_num& res)
{    
    T_num  res_factor;
    bool   bool_res =     calc_asterisk (s_inp, s_out)
                       && calc_factor   (s_out, s_out, res_factor);
    res *= res_factor;
    return  bool_res;
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_div_into_factor(const T_str&  s_inp, T_str&  s_out, T_num& res)
{    
    T_num  res_factor;
    bool   bool_res =     calc_slash  (s_inp, s_out)
                       && calc_factor (s_out, s_out, res_factor);
    res /= res_factor;
    return  bool_res;
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_plus(const T_str&  s_inp, T_str&  s_out)
{
    return  calc_symb(PLUS_SIGN, s_inp, s_out);
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_asterisk(const T_str&  s_inp, T_str&  s_out)
{
    return  calc_symb(ASTERISK, s_inp, s_out);
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_slash(const T_str&  s_inp, T_str&  s_out)
{
    return  calc_symb(SLASH, s_inp, s_out);
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_minus(const T_str&  s_inp, T_str&  s_out)
{
    return  calc_symb(MINUS_SIGN, s_inp, s_out);
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_expr_in_brackets(const T_str&  s_inp, T_str&  s_out, T_num& res)
{
    return     calc_left_parenthesis  (s_inp, s_out)
            && calc_expr              (s_out, s_out, res)
            && calc_right_parenthesis (s_out, s_out);
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_num(const T_str&  s_inp, T_str&  s_out, T_num& res)
{
    std::istringstream  sin(s_inp);    
    bool  bool_res = ((sin >> res) != 0);
    sin >> s_out;
    return  bool_res;
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_left_parenthesis(const T_str&  s_inp, T_str&  s_out)
{
    return  calc_symb(LEFT_PARENTHESIS, s_inp, s_out);
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_right_parenthesis(const T_str&  s_inp, T_str&  s_out)
{
    return  calc_symb(RIGHT_PARENTHESIS, s_inp, s_out);
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_symb(const char c, const T_str&  s_inp, T_str&  s_out)
{    
    bool  res = (s_inp[0] == c);
    if(res)
    {        
        s_out = s_inp.substr(1);
    }
    return res;    
}
///////////////////////////////////////////////////////////////////////////////
int main()
{    
    for(;;)
    { 
        T_calculator  calculator;        
    }
    return 0;
}

#include <iostream>
using namespace std;
int needed(int arr[], int size)
{
    int max=0;
    int sum0=0;
    for(int i=0;i<size;i++)
    {
        if(max<arr[i]) max=arr[i];
        sum0+=arr[i];
    }
    return (max/2)*(max+1)-sum0;
}
int main()
{
    int a[7]={0,3,5,1,6,2};
    cout<<needed(a,6)<<"\n";
    system("pause");
    return 0;
}

#include <iostream>
#include <string>
#include <conio.h>
const int size=10;
class stek
{
    private:
        char array[size];
    public:
        stek();
        void additem(char c);
        void substractitem(void);
        std::string stekins(void);
        char upperitem(void);
};
stek::stek()
{
    for(int i=0;i<size;i++)
        array[i]='\0';
}
void stek::additem(char c)
{
    for(int i=size-1;i>=0;i--)
        array[i]=array[i-1];
    array[0]=c;
}
void stek::substractitem(void)
{
    for(int i=0;i<size-1;i++)
        array[i]=array[i+1];
    array[size-1]='\0';
}
std::string stek::stekins(void)
{
    std::string s0;
    for(int i=0;i<size;i++)
        if(array[i]!='\0')
           s0=s0+array[i]+" ";
    return s0;
}
char stek::upperitem(void)
{
    return array[0];
}
std::string itorpn(std::string s)
{
    std::string s0;
    stek st;
    for(int i=0;i<s.length();i++)
    {
        if(isdigit(s[i]))
            s0=s0+s[i]+" ";
        if(s[i]=='+' || s[i]=='-' || s[i]=='*' || s[i]=='/')
        {
            if((s[i]=='-' || s[i]=='+') && (st.upperitem()=='/' || st.upperitem()=='*'))
            {
                s0=s0+st.upperitem()+" ";
                st.substractitem();
            }
            st.additem(s[i]);
        }
        if(s[i]=='(')
            st.additem('(');
        if(s[i]==')')
            {
                while(st.upperitem()!='(')
                {
                    s0=s0+st.upperitem()+" ";
                    st.substractitem();
                }
                st.substractitem();
            }
    }
    s0=s0+st.stekins();
    return s0;
}
int main()
{
    std::string ss;
    std::cin>>ss;
    std::cout<<itorpn(ss)<<"\n";
    getch();
    return 0;    
}

#include <iostream>
#include <string>
#include <conio.h>
const int size=10;
class stek
{
    private:
        char array[size];
    public:
        stek();
        void additem(char c);
        void substractitem(void);
        std::string stekins(void);
        char upperitem(void);
};
stek::stek()
{
    for(int i=0;i<size;i++)
        array[i]='\0';
}
void stek::additem(char c)
{
    for(int i=size-1;i>=0;i--)
        array[i]=array[i-1];
    array[0]=c;
}
void stek::substractitem(void)
{
    for(int i=0;i<size-1;i++)
        array[i]=array[i+1];
    array[size-1]='\0';
}
std::string stek::stekins(void)
{
    std::string s0;
    for(int i=0;i<size;i++)
        if(array[i]!='\0')
           s0=s0+array[i]+" ";
    return s0;
}
char stek::upperitem(void)
{
    return array[0];
}
std::string itorpn(std::string s)
{
    std::string s0;
    stek st;
    for(int i=0;i<s.length();i++)
    {
        if(isdigit(s[i]) && isdigit(s[i+1]))
            s0=s0+s[i];
        else if(isdigit(s[i]))
                 s0=s0+s[i]+" ";
        if(s[i]=='+' || s[i]=='-' || s[i]=='*' || s[i]=='/')
        {
            if((s[i]=='-' || s[i]=='+') && (st.upperitem()=='/' || st.upperitem()=='*'))
            {
                s0=s0+st.upperitem()+" ";
                st.substractitem();
            }
            st.additem(s[i]);
        }
        if(s[i]=='(')
            st.additem('(');
        if(s[i]==')')
            {
                while(st.upperitem()!='(')
                {
                    s0=s0+st.upperitem()+" ";
                    st.substractitem();
                }
                st.substractitem();
            }
    }
    s0=s0+st.stekins();
    return s0;
}
int main()
{
    std::string ss;
    std::cin>>ss;
    std::cout<<itorpn(ss)<<"\n";
    getch();
    return 0;
}

#include <iostream>
#include <string>
#include <conio.h>
int main()
{
    int sizee=0;
    std::string s=" a bc def ghik ";
    for(int j=0;j<s.length();j++)
        if(s[j]==' ')
            sizee++;
    char *c[sizee-1];
    int k=0;
    int isfree=0;
    for(int i=0;i<s.length();i++)
    {
        if(s[i]==' ')
        {
            k=i+1;
            while(s[k]!=' ')
            {    
                c[isfree][k+1-i]=s[k];
                k++;
            }
            isfree++;
        }
    }
    for(int l;l<sizee-1;l++)
        std::cout<<c[l]<<"\n";
    getch();
    return 0;
}

#include <iostream>
#include <string>
#include <sstream>
#include <list>
#include <algorithm>
#include <iterator>
    
int main(){
    std::string str;
    
    while ( true ){
        std::cout << "\nString: ";
        std::getline(std::cin, str);
        if ( str.empty() )
            break;
        std::istringstream ist(str);
        std::list<std::string> list;
        std::copy(std::istream_iterator<std::string>(ist), std::istream_iterator<std::string>(), std::back_inserter(list));
        std::cout << "List of tokens:" << std::endl;
        std::copy(list.begin(), list.end(), std::ostream_iterator<std::string>(std::cout, "\n"));
    }
    
    return 0;
}