Удалить элементы массива соответствующие пересекающимся окружностям

void CheckArr(int** Arr, int NumCrl) {
 
    for (int i = 0; i < NumCrl-1; i++){
 
        for (int j = 1; j < NumCrl-1; j++) {
 
            int DeltaX = pow(Arr[i][0] - Arr[j][0],2);
            int DeltaY = pow(Arr[i][1] - Arr[j][1],2);
            double LenghtSntrCrl = sqrt(DeltaX + DeltaY);
 
            int SumRadius = Arr[i][2] + Arr[j][2];
 
            if (LenghtSntrCrl < SumRadius) {
                Arr[j][0] = Arr[j + 1][0];
                Arr[j][1] = Arr[j + 1][1];
                Arr[j][2] = Arr[j + 1][2];
            }
        }
    }
}
 
void NewArray(int** Arr, int NumCrl) {
    int** NewArray = new int*[HowManyUnic(Arr, NumCrl)];
    int* Index = new int[HowManyUnic(Arr, NumCrl)];
 
    for (int i = 0;i < HowManyUnic(Arr, NumCrl);i++) {
        NewArray[i] = new int[3];
    }
    
    int Num = 0;
    for (int i = 0; i < NumCrl; i++) {  // Цикл до NumCrl (включительно)
        bool different = true;
        if (i < NumCrl - 1) {
            different = (Arr[i][0] != Arr[i + 1][0]);
        }
        if (different) {
            NewArray[Num][0] = Arr[i][0];
            NewArray[Num][1] = Arr[i][1];
            NewArray[Num][2] = Arr[i][2];
            Num++;
        }
    }
}

#include <iostream>
#include <vector>
#include <cmath>
using namespace std;
 
struct Circle
{
    double x;
    double y;
    double r;
    bool meow = false;
};
 
void intersection(Circle& a, Circle& b)
{
    double t1 = fabs(a.r - b.r);
    double t2 = hypot(a.x-b.x, a.y-b.y);
    double t3 = a.r + b.r;
    if (t1 <= t2 && t2 <= t3)
    {
        a.meow = true;
        b.meow = true;
    }
}
 
int main()
{
    vector<Circle> arr
        {{252, 424, 219},
        {577, 462, 366},
        {418, 557, 375},
        {537, 360, 341},
        {459, 541, 295},
        {459, 514, 418},
        {363, 110, 108},
        {497, 492, 488},
        {515, 473, 465},
        {281, 348, 121}};
    
    for (size_t i = 0; i < arr.size() - 1; ++i)
        for (size_t j = i + 1; j < arr.size(); ++j)
            intersection(arr[i], arr[j]);
 
    for (const auto& c : arr)
        if (!c.meow)
            cout << "Circle (" << c.x << '\t' << c.y << '\t' << c.r << ")\n";
 
}

#include <iostream>
#include <vector>
#include <cmath>
using namespace std;
 
struct Circle
{
    double x;
    double y;
    double r;
    bool meow = false;
};
 
void intersection(Circle& a, Circle& b)
{
    double t1 = fabs(a.r - b.r);
    double t2 = hypot(a.x-b.x, a.y-b.y);
    double t3 = a.r + b.r;
    if (t1 <= t2 && t2 <= t3)
    {
        a.meow = true;
        b.meow = true;
    }
}
 
int main()
{
    vector<Circle> arr
        {{252, 424, 219},
        {577, 462, 366},
        {418, 557, 375},
        {537, 360, 341},
        {459, 541, 295},
        {459, 514, 418},
        {363, 110, 108},
        {497, 492, 488},
        {515, 473, 465},
        {281, 348, 121}};
    
    for (size_t i = 0; i < arr.size() - 1; ++i)
        for (size_t j = i + 1; j < arr.size(); ++j)
            intersection(arr[i], arr[j]);
 
    
    erase_if(arr, [](Circle& x) { return x.meow; });
    
    for (const auto& c : arr)
            cout << "Circle (" << c.x << '\t' << c.y << '\t' << c.r << ")\n";
 
 
}

  const int N = 10, M = 3;
  int arr[N][M] = {
                    252, 424, 219,
                    577, 462, 366,
                    418, 557, 375,
                    537, 360, 341,
                    459, 541, 295,
                    459, 514, 418,
                    363, 110, 108,
                    497, 492, 488,
                    515, 473, 465,
                    281, 348, 121
                  };
  int limit = 1 << N, max_count = 2, num = 0, state[N];
  double max_square = 0;
 
  // всего вариантов (2^N)-1
  for (int k = 1; k < limit; k++)
  {
    int count = 0, tmp = k;
    double square = 0;  // площадь
    // окружности, которые проверяем на непересечение друг с другом
    for (int m = 0; m < N; m++)
    {
      state[m] = tmp % 2, tmp /= 2;
      if (state[m])
      {
        count++;  // кол-во окружностей
        square += arr[m][2] * arr[m][2];  // без множителя Pi
      }
    }
 
    // определяем, являются ли окружности непересекающимися друг с другом
    for (int i = 0; i < N - 1; i++)
      for (int j = i + 1; j < N; j++)
        if (count > 1 && state[i] && state[j])
        {
          int x1 = arr[i][0], y1 = arr[i][1], r1 = arr[i][2];
          int x2 = arr[j][0], y2 = arr[j][1], r2 = arr[j][2];
          double dist = hypot(abs(x1 - x2), abs(y1 - y2));
 
          // если есть пересечение
          if (dist >= abs(r1 - r2) && dist <= r1 + r2)
            count = 0;  // сбрасываем счетчик
          if (!count)  // "оптимизация" (если есть желание, можно улучшить)
            break;
        }
 
    // запоминаем кол-во и номер комбинации окружностей
    if (count > max_count || count == max_count && square > max_square)
    {
      max_count = count;
      num = k;
      max_square = square;
    }
  }
 
  TColor color[N] = {clRed, clBlue, clGreen, clNavy, clMaroon, clOlive, clPurple, clBlack, clGray, clFuchsia};
  Canvas->Brush->Style = bsClear;
  // "выводим" (рисуем) окружности
  for (int i = 0; i < N; i++)
  {
    if (num % 2)
    {
      Canvas->Pen->Color = color[i];
      Canvas->Font->Color = color[i];
      int x = arr[i][0], y = arr[i][1], r = arr[i][2];
      Canvas->TextOutW(x, y, i + 1);
      Canvas->Ellipse(x - r, y - r, x + r, y + r);
      Canvas->MoveTo(x - r, y);
      Canvas->LineTo(x + r, y);
    }
    num /= 2;
  }

#include <windows.h>
#include <iostream>
#include <vector>
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
HWND hwnd_form;
 
struct Circle
{
    double x;
    double y;
    double r;
    bool meow = false;
};
 
// the simplest way to draw a circle:
void ReallySimpleCircle(HDC hdc, LONG radius, POINT ptCenter, COLORREF crColor)
{
    LONG    cx = 0, cy;
    double  xLimit = sqrt((double)(radius * radius) / 2);
 
    while (cx++ <= xLimit)
    {
        cy = (LONG)floor(sqrt(radius * radius - cx * cx));
        SetPixel(hdc, cx + ptCenter.x, cy + ptCenter.y, crColor);      // 45-90    degrees
        SetPixel(hdc, cx + ptCenter.x, -cy + ptCenter.y, crColor);     // 270-315  degrees
        SetPixel(hdc, -cx + ptCenter.x, cy + ptCenter.y, crColor);     // 90-135   degrees
        SetPixel(hdc, -cx + ptCenter.x, -cy + ptCenter.y, crColor);    // 225-270  degrees
        SetPixel(hdc, cy + ptCenter.x, cx + ptCenter.y, crColor);      // 0-45     degrees
        SetPixel(hdc, cy + ptCenter.x, -cx + ptCenter.y, crColor);     // 315-360  degrees
        SetPixel(hdc, -cy + ptCenter.x, cx + ptCenter.y, crColor);     // 135-180  degrees
        SetPixel(hdc, -cy + ptCenter.x, -cx + ptCenter.y, crColor);    // 180-225  degrees
    }
}
 
 
 
std::vector<Circle> arr;
 
 
 
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
    WNDCLASSEXA wc;
    MSG msg;
 
    //Registering the Window Class
    wc.cbSize = sizeof(WNDCLASSEX);
    wc.style = 0;
    wc.lpfnWndProc = WndProc;
    wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;
    wc.hInstance = hInstance;
    wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
    wc.lpszMenuName = NULL;
    wc.lpszClassName = "myWindowClass";
    wc.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
    RegisterClassExA(&wc);
 
    //Creating the Window 
    hwnd_form = CreateWindowExA(WS_EX_CLIENTEDGE, "myWindowClass",
        "Simple Window", WS_VISIBLE | WS_OVERLAPPEDWINDOW,
        0, 0, 940, 920, NULL, NULL, hInstance, NULL);
 
    //The Message Loop
    while (GetMessage(&msg, NULL, 0, 0) > 0)
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    return msg.wParam;
}
 
//WndProc procedure. Application acts on messages
LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    HDC hDC; HPEN hPen;
    Circle e;
    POINT ptCenter;
    
    switch (msg)
    {
    case WM_CREATE:
        e.x = 252; e.y = 424; e.r = 219;
        arr.push_back(e);
        e.x = 577; e.y = 462; e.r = 366;
        arr.push_back(e);
        e.x = 418; e.y = 557; e.r = 375;
        arr.push_back(e);
        e.x = 537; e.y = 360; e.r = 341;
        arr.push_back(e);
        e.x = 459; e.y = 541; e.r = 295;
        arr.push_back(e);
        e.x = 459; e.y = 514; e.r = 418;
        arr.push_back(e);
        e.x = 363; e.y = 110; e.r = 108;
        arr.push_back(e);
        e.x = 497; e.y =492; e.r = 488;
        arr.push_back(e);
        e.x = 515; e.y = 473; e.r = 465;
        arr.push_back(e);
        e.x = 281; e.y = 348; e.r = 121;
        arr.push_back(e);
        break;
    
    case WM_PAINT:
        hDC = GetDC(hwnd_form);
        for (size_t i = 0; i < arr.size(); ++i) 
        {
 
            ptCenter.x = arr[i].x;
            ptCenter.y = arr[i].y;
            
    ReallySimpleCircle(hDC, arr[i].r, ptCenter, 0);
                    
        }
        ReleaseDC(NULL, hDC);
    
        break;
    case WM_CLOSE:
        DestroyWindow(hwnd);
        break;
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProcA(hwnd, msg, wParam, lParam);
    }
    return 0;
}

case WM_PAINT:
 
        for (size_t i = 0; i < arr.size() - 1; ++i)
            for (size_t j = i + 1; j < arr.size(); ++j)
                intersection(arr[i], arr[j]);
        hDC = GetDC(hwnd_form);
        for (size_t i = 0; i < arr.size(); ++i) 
        {
            ptCenter.x = arr[i].x;
            ptCenter.y = arr[i].y;
            
    if(!arr[i].meow)ReallySimpleCircle(hDC, arr[i].r, ptCenter, 0);
        }
        ReleaseDC(NULL, hDC);
    break;

void intersection(Circle& a, Circle& b)
{
    double t1 = fabs(a.r - b.r);
    double t2 = hypot(a.x - b.x, a.y - b.y);
    double t3 = a.r + b.r;
    if (t1 <= t2 && t2 <= t3)
    {
        a.meow = true;// Если маркировать одну из них, то пару штук оставляет.
        //b.meow = true;
    }
}

#include <iostream>
#include <string>
#include <algorithm>
 
int main() {
    std::string t, s;
    
    std::cin >> t;
    std::remove_copy(t.begin(), t.end(), std::back_inserter(s), 'a');
    
    int mid = s.size() / 2;
    std::cout << ( (s.substr(0, mid) == s.substr(mid)) ?  t.substr(0, t.size() - mid) : ":(" ) << std::endl;
}