задачи на основные темы, требующие как минимум присутствие логики

//////////////////////////////////////////////////////////////////////////////////////
//!!индивидуальное домашнее задание №4. Строки.
//(В задачах этого раздела строки состоят из слов (последовательность букв) 
//и знаков препинания (последовательность любых небуквенных символов).)
 
//Найти в строке тройку слов таких, что из букв двух слов можно получить третье 
//(при составлении этого слова следует использовать все буквы двух других). 
//Если таких троек несколько, вывести ту, которая имеет максимальное суммарное 
//количество букв.
//////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cctype>
#include <iostream>
#include <map>
#include <sstream>
#include <string>
#include <vector>
//////////////////////////////////////////////////////////////////////////////////////
typedef std::string                T_str;
typedef std::vector<T_str>         T_words;
typedef std::map<size_t, T_words>  T_3_words_map;
//////////////////////////////////////////////////////////////////////////////////////
T_words  get_words(const T_str&  s)
{
    T_str  s_new;
    std::transform(s.begin(), s.end(), std::back_inserter(s_new), tolower);
    
    std::replace_if(s_new.begin(), s_new.end(), std::not1(std::ptr_fun(isalpha)), ' ');
 
    std::istringstream  ssin(s_new);
    
    T_words  words;
    std::copy
        (
            std::istream_iterator<T_str>(ssin), 
            std::istream_iterator<T_str>(),           
            std::back_inserter(words)
        );
 
    return  words;
}
//////////////////////////////////////////////////////////////////////////////////////
size_t  get_3_words_total_size(const T_words&  words)
{
    return  words[0].size() + words[1].size() + words[2].size();   
}
//////////////////////////////////////////////////////////////////////////////////////
bool  word_is_made_of_2_words_letters(const T_words&  _3_words)
{
    T_str  A_str(_3_words[0]);
    T_str  B_str(_3_words[1] + _3_words[2]);
    
    std::sort(A_str.begin(), A_str.end());
    std::sort(B_str.begin(), B_str.end());
    return  A_str == B_str;
}
//////////////////////////////////////////////////////////////////////////////////////
void  print_3_words(const T_words&  words)
{
    T_3_words_map  _3_words_map;    
    for(T_str::size_type  i = 0; i < words.size(); ++i)
    {        
        for(T_str::size_type  j = 0; j < words.size(); ++j)
        {
            if(j == i) continue;     
            for(T_str::size_type  k = 0; k < words.size(); ++k)
            {
                if(   k == i
                   || k == j) continue;
 
                T_words  _3_words;
                _3_words.push_back(words[i]);
                _3_words.push_back(words[j]);
                _3_words.push_back(words[k]);                
                
                if(word_is_made_of_2_words_letters(_3_words))
                {                    
                    _3_words_map[get_3_words_total_size(_3_words)] = _3_words;
                }              
            }        
        }    
    }
    if(_3_words_map.empty())
    {
        std::cout << "В заданной строке нет слова, состоящего из букв двух других."
                  << std::endl;
    }
    else
    {
        std::cout << "В заданной строке слово \""
                  << _3_words_map.rbegin()->second[0]
                  << "\" состоит из букв слов \""
                  << _3_words_map.rbegin()->second[1]
                  << "\" и \""
                  << _3_words_map.rbegin()->second[2]
                  << "\"."
                  << std::endl;
    }
}
//////////////////////////////////////////////////////////////////////////////////////
int main()
{
    std::locale::global(std::locale(""));
    std::cout << "Введите строку из латинских букв, разделенную на слова не латинскими буквами:"   
              << std::endl;
 
    T_str  s;
    getline(std::cin, s);    
    print_3_words(get_words(s));
}

#include <iostream>;
#include <fstream>;
using namespace std;
 
int search (int n)
{int m;
if (n%2==0) m=n/2;
else m=n/2+1;
return m;
}
 
void selection (int *mas,int n)
{
int m;
for (int i=0;i<n-1;i++)
{int min=mas[i];m=i;
    for (int j=i+1;j<n;j++)
    {int r=mas[j];
    if (r<min) {min=r;m=j;}
    }
mas[m]=mas[i];
mas[i]=min;
}
}
 
bool razn (int *mas,int n)
{int r,sch=0;
bool q=true;
for (int i=0;i<n;i++)
    {r=mas[i];
for (int j=i+1;j<n;j++)
    if (r==mas[j]) {q=false; sch+=1;}
};
return q;
}
 
int schet (int *mas,int n)
{int r,sch=0;
bool q=true;
for (int i=0;i<n;i++)
    {r=mas[i];
for (int j=i+1;j<n;j++)
    if (r==mas[j]) {q=false; sch+=1;}
};
return sch;
}
 
void main() {
double z;
int n,b,s,min,ch,Ay=100,By=-100,spy=0,soy=0;
ifstream fin;
fin.open("Dano.txt");
fin>>n;
cout<<n<<endl;
int flag=0;
int *masy;
masy=new int [n];
int *masx;
masx=new int [n];
int *mas;
mas=new int [(n*(n-1)/2)];
int k=0,h=0;
for (int j=0;j<n*2;j++){
    if (flag==1){
        fin>>ch;
        masy[k]=ch;
        k++;
        flag=0;
        }
    else
    {
    fin>>ch;
    masx[h]=ch;
    flag=1;
    h++;
    }
}
 
selection (masy,n);
selection (masx,n);
 
if (razn (masy,n))
{
s=search (n);
    if (n%2==0)
    {
        if ((masy[s-1]-masy[s])%2==0) z=(masy[s]-masy[s+1])/2;
        else z=(masy[s-1]-masy[s])/2+0.5;
    }
    else z=masy[s-1];
cout<<"y="<<z;
}
else
{
if (razn (masx,n))
{
s=search (n);
    if (n%2==0)
    {
        if ((masx[s-1]-masx[s])%2==0) z=(masx[s]-masx[s+1])/2;
        else z=(masx[s-1]-masx[s])/2+0.5;
    }
    else z=masx[s-1];
cout<<"x="<<z;
}
else 
{
cout<<"прямой нет";
 
}
}
fin.close();
cin>>b;
}