27.06 Поиск двойных/тройных звездных систем

Для начала визуально оценим данные в условии кластеры. Для этого откроем предложенные файлы в , перейдем в раздел «Вставка Диаграммы Точечная».

Диаграмма для файла А имеет вид:

Диаграмма для файла Б имеет вид:

Для разделения звезд на кластеры будем использоваться функцию dbscan. Дальше основная идея решения будет заключаться в том, что мы будем проходить по каждой точке в найденных кластерах и с помощью того же метода dbscan для каждого кластера найти списки звезд, расстояние между которыми менее 0.01. Далее в каждом кластере нужно оставить только те списки, в которых количество звезд равно трем – то есть только тройные звездные системы. В конце остается дело за малым: для каждой звездной системы в каждом кластере найти максимальное расстояние между звездами а затем расчитать среднее расстояние между всеми найденными парами.

Код программы

from math import *

def dbscan(a, r):
    cl = [] # Инициализируем список для хранения кластеров
    while a: # Пока есть элементы в входном массиве ’a’
        # Создаем новый кластер и добавляем в него первый элемент из ’a’
        cl.append([a.pop(0)])
        for i in cl[-1]: # Проходим по элементам последнего кластера
            # Проверяем каждый элемент ’j’ в оставшихся элементах ’a’
            for j in a[:]:
                # Если расстояние между ’i’ и ’j’ меньше радиуса ’r’
                if dist(i, j) <= r:
                    cl[-1].append(j) # Добавляем ’j’ в текущий кластер
                    a.remove(j) # Удаляем ’j’ из списка ’a’, чтобы не проверять его снова
    return cl

f = open("2.txt")
s = f.readline()
a = [list(map(float, i.replace(",", ".").split())) for i in f]
cl = dbscan(a, 0.45)
cl_total = []
for i in cl:
    if len(i) > 10: cl_total.append(i)

t = 0.02 # Для файла А
t = 0.01 # Для файла Б
ans = []
for i in cl_total: # Проходим по каждому элементу в списке cl_total
    found_star = dbscan(i, t) # Применяем алгоритм DBSCAN
    tr_stars = [] # Список для тройных звездных систем
    mn_starsys = [] # Список для хранения звездной системы с максимальным расстоянием
    # Проходим по каждому кластеру, найденному алгоритмом DBSCAN
    for j in found_star:
        if len(j) == 3: # Проверяем, состоит ли кластер из трех звезд
            # Проверяем является ли остроугольным треугольником
            d1 = dist(j[0], j[1])
            d2 = dist(j[0], j[2])
            d3 = dist(j[1], j[2])
            if (d1 <= t) and (d2 <= t) and (d3 <= t):
                tr_stars.append(j)
    mn_per = 100000000000 # Переменная для хранения максимального длины стороны
    for j in tr_stars: # Проходим по всем найденным тройным системам
                                                                                                  
                                                                                                  
        # Вычисляем периметр
        d1 = dist(j[0], j[1])
        d2 = dist(j[0], j[2])
        d3 = dist(j[1], j[2])
        if d1 + d2 + d3 < mn_per:
            mn_per = d1 + d2 + d3 # Обновляем максимальное расстояние
            mn_starsys = j # Сохраняем текущую звездную систему как систему с максимальным расстоянием
    ans.append(mn_starsys)

# Рассчитываем среднее значение
res_X = 0
res_Y = 0
for i in ans:
    res_X += (i[0][0] + i[1][0] + i[2][0])
    res_Y += (i[0][1] + i[1][1] + i[2][1])

print(int(abs(res_X / 9) * 10000))  # Для файла А
print(int(abs(res_Y / 9) * 10000))  # Для файла А

print(int(abs(res_X / 12) * 10000))  # Для файла Б
print(int(abs(res_Y / 12) * 10000))  # Для файла Б

Для начала визуально оценим данные в условии кластеры. Для этого откроем предложенные файлы в , перейдем в раздел «Вставка Диаграммы Точечная».

Диаграмма для файла А имеет вид:

Диаграмма для файла Б имеет вид:

Для разделения звезд на кластеры будем использоваться функцию dbscan. Дальше основная идея решения будет заключаться в том, что мы будем проходить по каждой точке в найденных кластерах и с помощью того же метода dbscan для каждого кластера найти списки звезд, расстояние между которыми менее 0.05 для файла А и менее 0.03 для файла Б. Далее в каждом кластере нужно оставить только те списки, в которых количество звезд равно двум – то есть только двойные звездные системы. В конце остается дело за малым: для каждой звездной системы в каждом кластере найти максимальное расстояние между звездами, а затем рассчитать среднее расстояние между всеми найденными парами.

Код программы

from math import *

def dbscan(a, r):
    cl = [] # Инициализируем список для хранения кластеров
    while a: # Пока есть элементы в входном массиве ’a’
        # Создаем новый кластер и добавляем в него первый элемент из ’a’
        cl.append([a.pop(0)])
        for i in cl[-1]: # Проходим по элементам последнего кластера
            # Проверяем каждый элемент ’j’ в оставшихся элементах ’a’
            for j in a[:]:
                # Если расстояние между ’i’ и ’j’ меньше радиуса ’r’
                x = [i[0], i[1]]
                y = [j[0], j[1]]
                if dist(x, y) < r:
                    cl[-1].append(j) # Добавляем ’j’ в текущий кластер
                    a.remove(j) # Удаляем ’j’ из списка ’a’, чтобы не проверять его снова
    return cl

f = open("2.txt")
s = f.readline()
a = [list(map(float, i.replace(",", ".").split())) for i in f]
cl = dbscan(a, 0.5)
cl_total = []
for i in cl:
    if len(i) > 10: cl_total.append(i)

t = 0.05 # для файла А
t = 0.03 # для файла Б
ans = []
for i in cl_total: # Проходим по каждому элементу в списке cl_total
    found_star = dbscan(i, t) # Применяем алгоритм DBSCAN
    bin_stars = [] # Список для бинарных звездных систем
    mx_starsys = [] # Список для хранения звездной системы с максимальным расстоянием
    # Проходим по каждому кластеру, найденному алгоритмом DBSCAN
    for j in found_star:
        if len(j) == 2: # Проверяем, состоит ли кластер из двух звезд
            # Проверяем состоит ли кластер из белого и голубого карликов
            if ((5.3 <= j[0][2] <= 10 and 2.5 <= j[1][2] <= 5) or (
                    5.3 <= j[1][2] <= 10 and 2.5 <= j[0][2] <= 5)):
                bin_stars.append(j)
    mx_dist = 0 # Переменная для хранения максимального расстояния
    for j in bin_stars: # Проходим по всем найденным бинарным системам
                                                                                                  
                                                                                                  
        x = [j[0][0], j[0][1]]
        y = [j[1][0], j[1][1]]
        # Вычисляем расстояние между звездами в бинарной системе
        if dist(x, y) > mx_dist:
            mx_dist = dist(x, y) # Обновляем максимальное расстояние
            mx_starsys = j # Сохраняем текущую звездную систему как систему с максимальным расстоянием
    ans.append(mx_starsys)

# Рассчитываем среднее значение
res_X = 0
res_Y = 0
for i in ans:
    res_X += (i[0][0] + i[1][0])
    res_Y += (i[0][1] + i[1][1])

print(int(abs(res_X / 4) * 1000))  # Для файла А
print(int(abs(res_Y / 4) * 1000))  # Для файла А

print(int(abs(res_X / 8) * 1000))  # Для файла Б
print(int(abs(res_Y / 8) * 1000))  # Для файла Б

Для начала визуально оценим данные в условии кластеры. Для этого откроем предложенные файлы в , перейдем в раздел «Вставка Диаграммы Точечная».

Диаграмма для файла А имеет вид:

Диаграмма для файла Б имеет вид:

Для разделения звезд на кластеры будем использоваться функцию dbscan. Дальше основная идея решения будет заключаться в том, что мы будем проходить по каждой точке в найденных кластерах и с помощью того же метода dbscan для каждого кластера найдем списки звезд, расстояние между которыми менее 0.02 (или 0.01 для файла Б). Далее в каждом кластере нужно оставить только те списки, в которых количество звезд равно двум – то есть только двойные звездные системы и эти пары состоят из белого и голубого карликов. В конце остается дело за малым: для каждой звездной системы в каждом кластере найти минимальные расстояние между звездами, а затем рассчитать среднее расстояние между всеми найденными парами.

Код программы

from math import *

def dbscan(a, r):
    cl = [] # Инициализируем список для хранения кластеров
    while a: # Пока есть элементы в входном массиве ’a’
        # Создаем новый кластер и добавляем в него первый элемент из ’a’
        cl.append([a.pop(0)])
        for i in cl[-1]: # Проходим по элементам последнего кластера
            # Проверяем  каждый элемент ’j’ в оставшихся элементах ’a’
            for j in a[:]:
                # Если расстояние между ’i’ и ’j’ меньше радиуса ’r’
                x = [i[0], i[1]]
                y = [j[0], j[1]]
                if dist(x, y) < r:
                    cl[-1].append(j) # Добавляем ’j’ в текущий кластер
                    a.remove(j) # Удаляем ’j’ из списка ’a’, чтобы не проверять его снова
    return cl

f = open("2.txt")
s = f.readline()
a = [list(map(float, i.replace(",", ".").split())) for i in f]
cl = dbscan(a, 0.6) # для файла А
cl = dbscan(a, 0.4) # для файла Б
cl_total = []
for i in cl:
    if len(i) > 10: cl_total.append(i)

t = 0.02 # для файла А
t = 0.01 # для файла Б
ans = []
for i in cl_total: # Проходим по каждому элементу в списке cl_total
    found_star = dbscan(i, t) # Применяем алгоритм DBSCAN
    bin_stars = [] # Список для бинарных звездных систем
    mn_starsys = [] # Список для хранения звездной системы с минимальным расстоянием
    # Проходим по каждому кластеру, найденному алгоритмом DBSCAN
    for j in found_star:
        if len(j) == 2: # Проверяем, состоит ли кластер из двух звезд
            # Проверяем состоит ли кластер из белого и голубого карликов
            if ((0.5 <= j[0][2] <= 1.3 and 0.08 <= j[1][2] <= 0.2) or (
                    0.5 <= j[1][2] <= 1.3 and 0.08 <= j[0][2] <= 0.2)):
                bin_stars.append(j)
    mn_dist = 1000000000000 # Переменная для хранения минимального расстояния
                                                                                                  
                                                                                                  
    for j in bin_stars: # Проходим по всем найденным бинарным системам
        x = [j[0][0], j[0][1]]
        y = [j[1][0], j[1][1]]
        # Вычисляем расстояние между звездами в бинарной системе
        if dist(x, y) < mn_dist:
            mn_dist = dist(x, y) # Обновляем минимальное расстояние
            mn_starsys = j # Сохраняем текущую звездную систему как систему с минимальным расстоянием
    ans.append(mn_starsys)

# Рассчитываем среднее значение
res_X = 0
res_Y = 0
for i in ans:
    res_X += (i[0][0] + i[1][0])
    res_Y += (i[0][1] + i[1][1])

print(int(abs(res_X / 8) * 1000))  # Для файла А
print(int(abs(res_Y / 8) * 1000))  # Для файла А

print(int(abs(res_X / 14) * 1000))  # Для файла Б
print(int(abs(res_Y / 14) * 1000))  # Для файла Б

Для начала визуально оценим данные в условии кластеры. Для этого откроем предложенные файлы в , перейдем в раздел «Вставка Диаграммы Точечная».

Диаграмма для файла А имеет вид:

Диаграмма для файла Б имеет вид:

Для разделения звезд на кластеры будем использоваться функцию dbscan. Дальше основная идея решения будет заключаться в том, что мы будем проходить по каждой точке в найденных кластерах и с помощью того же метода dbscan для каждого кластера найти списки звезд, расстояние между которыми менее 0.01. Далее в каждом кластере нужно оставить только те списки, в которых количество звезд равно трем – то есть только тройные звездные системы. В конце остается дело за малым: для каждой звездной системы в каждом кластере найти максимальное расстояние между звездами а затем расчитать среднее расстояние между всеми найденными парами.

Код программы

from math import *

def dbscan(a, r):
    cl = [] # Инициализируем список для хранения кластеров
    while a: # Пока есть элементы в входном массиве ’a’
        # Создаем новый кластер и добавляем в него первый элемент из ’a’
        cl.append([a.pop(0)])
        for i in cl[-1]: # Проходим по элементам последнего кластера
            # Проверяем  каждый элемент ’j’ в оставшихся элементах ’a’
            for j in a[:]:
                # Если расстояние между ’i’ и ’j’ меньше радиуса ’r’
                if dist(i, j) < r:
                    cl[-1].append(j) # Добавляем ’j’ в текущий кластер
                    a.remove(j) # Удаляем ’j’ из списка ’a’, чтобы не проверять его снова
    return cl

f = open("24.txt")
s = f.readline()
a = [list(map(float, i.replace(",", ".").split())) for i in f]
cl = dbscan(a, 0.65)
cl_total = []
for i in cl:
    if len(i) > 10: cl_total.append(i)

t = 0.01
ans = []
for i in cl_total: # Проходим по каждому элементу в списке cl_total
    found_star = dbscan(i, t) # Применяем алгоритм DBSCAN
    tr_stars = [] # Список для тройных звездных систем
    mx_starsys = [] # Список для хранения звездной системы с максимальным расстоянием
    # Проходим по каждому кластеру, найденному алгоритмом DBSCAN
    for j in found_star:
        if len(j) == 3: # Проверяем, состоит ли кластер из трех звезд
            d1 = dist(j[0], j[1])
            d2 = dist(j[0], j[2])
            d3 = dist(j[1], j[2])
            if (d1*d1 < d2*d2 + d3*d3) and (d2*d2 < d1*d1 + d3*d3) and (d3*d3 < d2*d2 + d1*d1) and d1 < t and d2 < t and d3 < t:
                tr_stars.append(j)
    mx_per = 0 # Переменная для хранения максимального длины стороны
    for j in tr_stars: # Проходим по всем найденным тройным системам
        # Вычисляем периметр
        d1 = dist(j[0], j[1])
                                                                                                  
                                                                                                  
        d2 = dist(j[0], j[2])
        d3 = dist(j[1], j[2])
        if d1 + d2 + d3 > mx_per:
            mx_per = d1 + d2 + d3 # Обновляем максимальное расстояние
            mx_starsys = j # Сохраняем текущую звездную систему как систему с максимальным расстоянием
    ans.append(mx_starsys)
# Рассчитываем среднее значение
res_X = 0
res_Y = 0
for i in ans:
    res_X += (i[0][0] + i[1][0] + i[2][0])
    res_Y += (i[0][1] + i[1][1] + i[2][1])

print(int(res_X / 6 * 10000))  # Для файла А
print(int(res_Y / 6 * 10000))  # Для файла А

print(int(res_X / 9 * 10000))  # Для файла Б
print(int(res_Y / 9 * 10000))  # Для файла Б

Для начала визуально оценим данные в условии кластеры. Для этого откроем предложенные файлы в , перейдем в раздел «Вставка Диаграммы Точечная».

Диаграмма для файла А имеет вид:

Диаграмма для файла Б имеет вид:

Для разделения звезд на кластеры будем использоваться функцию dbscan. Дальше основная идея решения будет заключаться в том, что мы будем проходить по каждой точке в найденных кластерах и с помощью того же метода dbscan для каждого кластера найти списки звезд, расстояние между которыми менее 0.02 (и 0.01 дляя файла Б). Далее в каждом кластере нужно оставить только те списки, в которых количество звезд равно двум – то есть только двойные звездные системы. В конце остается дело за малым: для каждой звездной системы в каждом кластере найти максимальную разницу между массами звезд а затем расчитать среднее расстояние между всеми найденными парами.

Код программы

from math import *

def dbscan(a, r):
    cl = [] # Инициализируем список для хранения кластеров
    while a: # Пока есть элементы в входном массиве ’a’
        # Создаем новый кластер и добавляем в него первый элемент из ’a’
        cl.append([a.pop(0)])
        for i in cl[-1]: # Проходим по элементам последнего кластера
            # Проверяем  каждый элемент ’j’ в оставшихся элементах ’a’
            for j in a[:]:
                # Если расстояние между ’i’ и ’j’ меньше радиуса ’r’
                x = [i[0], i[1]]
                y = [j[0], j[1]]
                if dist(x, y) < r:
                    cl[-1].append(j) # Добавляем ’j’ в текущий кластер
                    a.remove(j) # Удаляем ’j’ из списка ’a’, чтобы не проверять его снова
    return cl

f = open("2.txt")
s = f.readline()
a = [list(map(float, i.replace(",", ".").split())) for i in f]
cl = dbscan(a, 0.5)
cl_total = []
for i in cl:
    if len(i) > 10: cl_total.append(i)

t = 0.02 # для А
t = 0.01 # для Б
ans = []
for i in cl_total: # Проходим по каждому элементу в списке cl_total
    found_star = dbscan(i, t) # Применяем алгоритм DBSCAN
    bin_stars = [] # Список для бинарных звездных систем
    mx_starsys = [] # Список для хранения звездной системы с максимальной разницей масс
    # Проходим по каждому кластеру, найденному алгоритмом DBSCAN
    for j in found_star:
        if len(j) == 2: # Проверяем, состоит ли кластер из двух звезд
            # Проверяем являются ли обе эти звезды нейтронными
            if -2.7 <= j[0][2] < 0 and -2.7 <= j[1][2] < 0:
                bin_stars.append(j)
    mx_mass = 0 # Переменная для хранения максимальной разницы масс
    for j in bin_stars: # Проходим по всем найденным бинарным системам
        # Вычисляем разницу между массами
                                                                                                  
                                                                                                  
        if abs(j[0][2]-j[1][2]) > mx_mass:
            mx_mass = abs(j[0][2]-j[1][2]) # Обновляем максимальную разницу
            mx_starsys = j # Сохраняем текущую звездную систему как систему с максимальной разницей
    ans.append(mx_starsys)

# Рассчитываем среднее значение
res_X = 0
res_Y = 0
for i in ans:
    res_X += (i[0][0] + i[1][0])
    res_Y += (i[0][1] + i[1][1])

print(int(abs(res_X / 6) * 1000))  # Для файла А
print(int(abs(res_Y / 6) * 1000))  # Для файла А

print(int(abs(res_X / 8) * 1000))  # Для файла Б
print(int(abs(res_Y / 8) * 1000))  # Для файла Б

Для начала визуально оценим данные в условии кластеры. Для этого откроем предложенные файлы в , перейдем в раздел «Вставка Диаграммы Точечная».

Диаграмма для файла А имеет вид:

Диаграмма для файла Б имеет вид:

Для разделения звезд на кластеры будем использоваться функцию dbscan. Дальше основная идея решения будет заключаться в том, что мы будем проходить по каждой точке в найденных кластерах и с помощью того же метода dbscan для каждого кластера найти списки звезд, расстояние между которыми менее 0.01. Далее в каждом кластере нужно оставить только те списки, в которых количество звезд равно двум – то есть только двойные звездные системы. В конце остается дело за малым: для каждой звездной системы в каждом кластере найти максимальное расстояние между звездами а затем расчитать среднее расстояние между всеми найденными парами.

Код программы

from math import *

def dbscan(a, r):
    cl = [] # Инициализируем список для хранения кластеров
    while a: # Пока есть элементы в входном массиве ’a’
        # Создаем новый кластер и добавляем в него первый элемент из ’a’
        cl.append([a.pop(0)])
        for i in cl[-1]: # Проходим по элементам последнего кластера
            # Проверяем  каждый элемент ’j’ в оставшихся элементах ’a’
            for j in a[:]:
                # Если расстояние между ’i’ и ’j’ меньше радиуса ’r’
                x = [i[0], i[1]]
                y = [j[0], j[1]]
                if dist(x, y) < r:
                    cl[-1].append(j) # Добавляем ’j’ в текущий кластер
                    a.remove(j) # Удаляем ’j’ из списка ’a’, чтобы не проверять его снова
    return cl

f = open("2.txt")
s = f.readline()
a = [list(map(float, i.replace(",", ".").split())) for i in f]
cl = dbscan(a, 0.5)
cl_total = []
for i in cl:
    if len(i) > 10: cl_total.append(i)

t = 0.01
ans = []
for i in cl_total: # Проходим по каждому элементу в списке cl_total
    found_star = dbscan(i, t) # Применяем алгоритм DBSCAN
    bin_stars = [] # Список для бинарных звездных систем
    mn_starsys = [] # Список для хранения звездной системы с минимальной разницей масс
    # Проходим по каждому кластеру, найденному алгоритмом DBSCAN
    for j in found_star:
        if len(j) == 2: # Проверяем, состоит ли кластер из двух звезд
            # Проверяем являются ли обе эти звезды черными дырами
            if j[0][2] < -2.7 and j[1][2] < -2.7:
                bin_stars.append(j)
    mn_mass = 1000000000 # Переменная для хранения максимальной разницы масс
    for j in bin_stars: # Проходим по всем найденным бинарным системам
        # Вычисляем разницу между массами
        if abs(j[0][2]-j[1][2]) < mn_mass:
                                                                                                  
                                                                                                  
            mn_mass = abs(j[0][2]-j[1][2]) # Обновляем минимальную разницу
            mn_starsys = j # Сохраняем текущую звездную систему как систему с минимальной разницей
    ans.append(mn_starsys)

# Рассчитываем среднее значение
res_X = 0
res_Y = 0
for i in ans:
    res_X += (i[0][0] + i[1][0])
    res_Y += (i[0][1] + i[1][1])

print(int(abs(res_X / 8) * 100))  # Для файла А
print(int(abs(res_Y / 8) * 100))  # Для файла А

print(int(abs(res_X / 14) * 100))  # Для файла Б
print(int(abs(res_Y / 14) * 100))  # Для файла Б

Для начала визуально оценим данные в условии кластеры. Для этого откроем предложенные файлы в , перейдем в раздел «Вставка Диаграммы Точечная».

Диаграмма для файла А имеет вид:

Диаграмма для файла Б имеет вид:

Для разделения звезд на кластеры будем использовать функцию dbscan.

Дальше основная идея решения будет заключаться в том, что мы будем проходить по каждой точке в 4 для файла А и 3 для файла Б найденных кластерах и с помощью того же метода dbscan для каждого кластера найти списки звезд, расстояние между которыми менее 0.3 для файла А и 0.03 для файла Б.

В каждом кластере нужно оставить только те списки, в которых количество звезд равно трем – то есть только тройные звездные системы. Также нужно проверить по массе звезд, чтобы в тройке были красный и желтый карлики.

В конце остается дело за малым: для каждой звездной системы в каждом кластере найти систему с минимальным периметром, а затем рассчитать среднее расстояние между всеми найденными тройками.

Программа:

from math import *
def dbscan(a, r):
    cl = [] # Инициализируем список для хранения кластеров
    while a: # Пока есть элементы в входном массиве ’a’
        # Создаем новый кластер и добавляем в него первый элемент из ’a’
        cl.append([a.pop(0)])
        for i in cl[-1]: # Проходим по элементам последнего кластера
            # Проверяем каждый элемент ’j’ в оставшихся элементах ’a’
            for j in a[:]:
                # Если расстояние между ’i’ и ’j’ меньше радиуса ’r’
                x = [i[0], i[1]]
                y = [j[0], j[1]]
                if dist(x, y) <= r:
                    cl[-1].append(j) # Добавляем ’j’ в текущий кластер
                    a.remove(j) # Удаляем ’j’ из списка ’a’, чтобы не проверять его снова
    return cl

f = open("2.txt")
s = f.readline()
a = [list(map(float, i.replace(",", ".").split())) for i in f]
cl = dbscan(a, 0.8)
cl_total = []
for i in cl:
    if len(i) > 10: cl_total.append(i)

# t = 0.3 # Для файла А
t = 0.03 # Для файла Б
ans = []
for i in cl_total: # Проходим по каждому элементу в списке cl_total
    found_star = dbscan(i, t) # Применяем алгоритм DBSCAN
    tr_stars = [] # Список для тройных звездных систем
    mn_starsys = [] # Список для хранения звездной системы с минимальным периметром
    # Проходим по каждому кластеру, найденному алгоритмом DBSCAN
    for j in found_star:
        if len(j) == 3: # Проверяем, состоит ли кластер из трех звезд
            # Проверяем есть ли в системе красный и желтый карлики
            if ((0.08 <= j[0][2] <= 0.6 or 0.08 <= j[1][2] <= 0.6 or 0.08 <= j[2][2] <= 0.6)
            and (0.8 <= j[0][2] <= 1.2 or 0.8 <= j[1][2] <= 1.2 or 0.8 <= j[2][2] <= 1.2)):
                tr_stars.append(j)
    mn_per = 1000000000000 # Переменная для хранения минимального периметра
    for j in tr_stars: # Проходим по всем найденным тройным системам
        x = [j[0][0], j[0][1]]
                                                                                                  
                                                                                                  
        y = [j[1][0], j[1][1]]
        z = [j[2][0], j[2][1]]
        # Вычисляем периметр
        d1 = dist(x, y)
        d2 = dist(x, z)
        d3 = dist(z, y)
        if (d1 + d2 + d3) < mn_per and d1 < t and d2 < t and d3 < t:
            mn_per = d1 + d2 + d3 # Обновляем минимальный периметр
            mn_starsys = j # Сохраняем текущую звездную систему
    ans.append(mn_starsys)

res_X = 0
res_Y = 0
for i in ans:
    res_X += (i[0][0] + i[1][0] + i[2][0])
    res_Y += (i[0][1] + i[1][1] + i[2][1])

print(int(abs(res_X / (4 * 3)) * 100))  # Для файла А
print(int(abs(res_Y / (4 * 3)) * 100))  # Для файла А

print(int(abs(res_X / (3 * 3)) * 100))  # Для файла Б
print(int(abs(res_Y / (3 * 3)) * 100))  # Для файла Б

Для разделения звезд на кластеры будем использовать функцию dbscan.

Дальше основная идея решения будет заключаться в том, что мы будем проходить по каждой точке в пяти для файла А и четырех для файла Б найденных кластерах и с помощью того же метода dbscan для каждого кластера найти списки звезд, расстояние между которыми менее 0.3 для файла А и 0.03 для файла Б.

В каждом кластере нужно оставить только те списки, в которых количество звезд равно двум – то есть только двойные звездные системы. Также нужно проверить по массе звезд, чтобы в паре были красный и желтый карлики.

В конце остается дело за малым: для каждой звездной системы в каждом кластере найти пару с максимальным расстоянием между звездами, а затем рассчитать среднее расстояние между всеми найденными парами.

Диаграмма для файла А имеет вид:

Диаграмма для файла Б имеет вид:

Программа:

from math import *
def dbscan(a, r):
    cl = [] # Инициализируем список для хранения кластеров
    while a: # Пока есть элементы в входном массиве ’a’
        # Создаем новый кластер и добавляем в него первый элемент из ’a’
        cl.append([a.pop(0)])
        for i in cl[-1]: # Проходим по элементам последнего кластера
            # Проверяем  каждый элемент ’j’ в оставшихся элементах ’a’
            for j in a[:]:
                # Если расстояние между ’i’ и ’j’ меньше радиуса ’r’
                x = [i[0], i[1]]
                y = [j[0], j[1]]
                if dist(x, y) <= r:
                    cl[-1].append(j) # Добавляем ’j’ в текущий кластер
                    a.remove(j) # Удаляем ’j’ из списка ’a’, чтобы не проверять его снова
    return cl

f = open("2.txt")
s = f.readline()
a = [list(map(float, i.replace(",", ".").split())) for i in f]
cl = dbscan(a, 0.9)
cl_total = []
for i in cl:
    if len(i) > 10: cl_total.append(i)

t = 0.2 # Для файла А
t = 0.02 # Для файла Б
ans = []
for i in cl_total: # Проходим по каждому элементу в списке cl_total
    found_star = dbscan(i, t) # Применяем алгоритм DBSCAN
    bin_stars = [] # Список для двойных звездных систем
    mx_starsys = [] # Список для хранения звездной системы с максимальным расстоянием
    # Проходим по каждому кластеру, найденному алгоритмом DBSCAN
    for j in found_star:
        if len(j) == 2: # Проверяем, состоит ли кластер из двух звезд
            # Проверяем есть ли в системе красный и желтый карлики
            if ((0.08 <= j[0][2] <= 0.6 and 0.8 <= j[1][2] <= 1.2)
            or (0.08 <= j[1][2] <= 0.6 and 0.8 <= j[0][2] <= 1.2)):
                bin_stars.append(j)
    mx_dist = 0 # Переменная для хранения максимального расстояния
    for j in bin_stars: # Проходим по всем найденным двойным системам
        x = [j[0][0], j[0][1]]
                                                                                                  
                                                                                                  
        y = [j[1][0], j[1][1]]
        # Вычисляем периметр
        if dist(x, y) > mx_dist:
            mx_dist = dist(x, y)  # Обновляем максимальное расстояние
            mx_starsys = j # Сохраняем текущую звездную систему
    ans.append(mx_starsys)

res_X = 0
res_Y = 0
for i in ans:
    res_X += (i[0][0] + i[1][0])
    res_Y += (i[0][1] + i[1][1])

print(int(abs(res_X / (5 * 2)) * 1000))  # Для файла А
print(int(abs(res_Y / (5 * 2)) * 1000))  # Для файла А

print(int(abs(res_X / (4 * 2)) * 1000))  # Для файла Б
print(int(abs(res_Y / (4 * 2)) * 1000))  # Для файла Б

Для начала визуально оценим данные в условии кластеры. Для этого откроем предложенные файлы в , перейдем в раздел «Вставка Диаграммы Точечная».

Диаграмма для файла А имеет вид:

Диаграмма для файла Б имеет вид:

Для разделения звезд на кластеры будем использовать функцию dbscan.

Дальше основная идея решения будет заключаться в том, что мы будем проходить по каждой точке в пяти для файла А и четырех для файла Б найденных кластерах и с помощью того же метода dbscan для каждого кластера найти списки звезд, расстояние между которыми менее 0.2 для файла А и 0.02 для файла Б.

В каждом кластере нужно оставить только те списки, в которых количество звезд равно двум – то есть только двойные звездные системы. Также нужно проверить по массе звезд, чтобы в паре была звезда и черная дыра.

В конце остается дело за малым: для каждой звездной системы в каждом кластере найти пару с максимальной разницей масс между телами, а затем рассчитать среднее расстояние между всеми найденными парами.

Программа:

from math import *

def dbscan(a, r):
    cl = []  # Инициализируем список для хранения кластеров
    while a:  # Пока есть элементы в входном массиве ’a’
        # Создаем новый кластер и добавляем в него первый элемент из ’a’
        cl.append([a.pop(0)])
        for i in cl[-1]:  # Проходим по элементам последнего кластера
            # Проверяем  каждый элемент ’j’ в оставшихся элементах ’a’
            for j in a[:]:
                # Если расстояние между ’i’ и ’j’ меньше радиуса ’r’
                x = [i[0], i[1]]
                y = [j[0], j[1]]
                if dist(x, y) < r:
                    cl[-1].append(j)  # Добавляем ’j’ в текущий кластер
                    a.remove(j)  # Удаляем ’j’ из списка ’a’, чтобы не проверять его снова
    return cl


f = open("2.txt")
s = f.readline()
a = [list(map(float, i.replace(",", ".").split())) for i in f]
cl = dbscan(a, 0.68)  # для файла А
cl = dbscan(a, 0.55)  # для файла Б
cl_total = []
for i in cl:
    if len(i) > 10: cl_total.append(i)

t = 0.2  # для файла А
t = 0.02  # для файла Б
ans = []
for i in cl_total:  # Проходим по каждому элементу в списке cl_total
    found_star = dbscan(i, t)  # Применяем алгоритм DBSCAN
    bin_stars = []  # Список для бинарных систем
    mx_starsys = []  # Список для хранения системы небесных тел с максимальной разницей масс
    # Проходим по каждому кластеру, найденному алгоритмом DBSCAN
    for j in found_star:
        if len(j) == 2:  # Проверяем, состоит ли кластер из двух тел
            # Проверяем, что в паре есть черная дыра и обычная звезда
            if (j[0][2] < -2.7 and j[1][2] > 0) or (j[1][2] < -2.7 and j[0][2] > 0):
                bin_stars.append(j)
    mx_mass = 0  # Переменная для хранения максимальной разницы масс
                                                                                                  
                                                                                                  
    for j in bin_stars:  # Проходим по всем найденным бинарным системам
    # Вычисляем разницу между массами
        if abs(abs(j[0][2]) - abs(j[1][2])) > mx_mass:
            mx_mass = abs(abs(j[0][2]) - abs(j[1][2]))  # Обновляем максимальную разницу
            mx_starsys = j  # Сохраняем текущую звездную систему как систему с максимальной разницей
    ans.append(mx_starsys)

# Рассчитываем среднее значение
res_X = 0
res_Y = 0
for i in ans:
    res_X += (i[0][0] + i[1][0])
    res_Y += (i[0][1] + i[1][1])

print(int(res_X / (5 * 2) * 100))  # Для файла А
print(int(res_Y / (5 * 2) * 100))  # Для файла А

print(int(res_X / (4 * 2) * 100))  # Для файла Б
print(int(res_Y / (4 * 2) * 100))  # Для файла Б

Для начала визуально оценим данные в условии кластеры. Для этого откроем предложенные файлы в , перейдем в раздел «Вставка Диаграммы Точечная».

Диаграмма для файла А имеет вид:

Диаграмма для файла Б имеет вид:

Для разделения звезд на кластеры будем использовать функцию dbscan.

Дальше основная идея решения будет заключаться в том, что мы будем проходить по каждой точке в 3 для файла А и 6 для файла Б найденных кластерах и с помощью того же метода dbscan для каждого кластера найти списки звезд, расстояние между которыми менее 0.11 для файла А и 0.05 для файла Б.

В каждом кластере нужно оставить только те списки, в которых количество звезд равно трем – то есть только тройные звездные системы. Так же нужно проверить по массе звезд, чтобы в тройке была нейтронная звезда и черная дыра.

В конце остается дело за малым: для каждой звездной системы в каждом кластере найти систему с минимальной суммарной массой, а затем расcчитать среднее расстояние между всеми найденными тройками.

Программа:

from math import *


def dbscan(a, r):
    cl = []  # Инициализируем список для хранения кластеров
    while a:  # Пока есть элементы в входном массиве ’a’
    # Создаем новый кластер и добавляем в него первый элемент из ’a’
        cl.append([a.pop(0)])
        for i in cl[-1]:  # Проходим по элементам последнего кластера
            # Проверяем  каждый элемент ’j’ в оставшихся элементах ’a’
            for j in a[:]:
                # Если расстояние между ’i’ и ’j’ меньше радиуса ’r’
                x = [i[0], i[1]]
                y = [j[0], j[1]]
                if dist(x, y) <= r:
                    cl[-1].append(j)  # Добавляем ’j’ в текущий кластер
                    a.remove(j)  # Удаляем ’j’ из списка ’a’, чтобы не проверять его снова
    return cl


f = open("4_A__5wzaw.txt")
s = f.readline()
a = [list(map(float, i.replace(",", ".").split())) for i in f]
cl = dbscan(a, 0.7)  # Для файла А
cl = dbscan(a, 0.6)  # Для файла Б
cl_total = []
for i in cl:
    if len(i) > 10: cl_total.append(i)

t = 0.11  # Для файла А
t = 0.05  # Для файла Б
ans = []
for i in cl_total:  # Проходим по каждому элементу в списке cl_total
    found_star = dbscan(i, t)  # Применяем алгоритм DBSCAN
    tr_stars = []  # Список для тройных звездных систем
    mn_starsys = []  # Список для хранения звездной системы с минимальной суммарной массой
    # Проходим по каждому кластеру, найденному алгоритмом DBSCAN
    for j in found_star:
        if len(j) == 3:  # Проверяем, состоит ли кластер из трех звезд
            # Проверяем есть ли в нейтронная звезда и черная дыра
            if ((0 > j[0][2] >= -2.7 or 0 > j[1][2] >= -2.7 or 0 > j[2][2] >= -2.7)
                    and (j[0][2] < -2.7 or j[1][2] < -2.7 or j[2][2] < -2.7)):
                                                                                                  
                                                                                                  
                tr_stars.append(j)
    mn_mass = 1000000000000  # Переменная для хранения минимальной суммарной массы
    for j in tr_stars:  # Проходим по всем найденным тройным системам
        x = [j[0][0], j[0][1]]
        y = [j[1][0], j[1][1]]
        z = [j[2][0], j[2][1]]
        # Вычисляем периметр
        d1 = dist(x, y)
        d2 = dist(x, z)
        d3 = dist(z, y)
        if (j[0][2] + j[1][2] + j[2][2]) < mn_mass and d1 < t and d2 < t and d3 < t:
            mn_mass = (j[0][2] + j[1][2] + j[2][2])  # Обновляем минимальную суммарную массу
            mn_starsys = j  # Сохраняем текущую звездную систему
    ans.append(mn_starsys)
res_X = 0
res_Y = 0
for i in ans:
    res_X += (i[0][0] + i[1][0] + i[2][0])
    res_Y += (i[0][1] + i[1][1] + i[2][1])

print(int(res_X / (3 * 3) * 500))  # Для файла А
print(int(res_Y / (3 * 3) * 500))  # Для файла А

print(int(res_X / (6 * 3) * 500))  # Для файла Б
print(int(res_Y / (6 * 3) * 500))  # Для файла Б

Для начала визуально оценим данные в условии кластеры. Для этого откроем предложенные файлы в , перейдем в раздел «Вставка Диаграммы Точечная».

Диаграмма для файла А имеет вид:

Диаграмма для файла Б имеет вид:

Для разделения звезд на кластеры будем использоваться функцию dbscan. Дальше основная идея решения будет заключаться в том, что мы будем проходить по каждой точке в найденных кластерах и с помощью того же метода dbscan для каждого кластера найти списки звезд, расстояние между которыми менее 0.02 в А файле (менее 0.03 в Б файле). Далее в каждом кластере нужно оставить только те списки, в которых количество звезд равно двум – то есть только двойные звездные системы. В конце остается дело за малым: для каждой звездной системы в каждом кластере найти максимальную разницу масс между звездами, а затем расчитать среднее арифметическое их координат между всеми найденными звёздами.

Код программы

from math import *

def dbscan(a, r):
    cl = [] # Инициализируем список для хранения кластеров
    while a: # Пока есть элементы в входном массиве ’a’
        # Создаем новый кластер и добавляем в него первый элемент из ’a’
        cl.append([a.pop(0)])
        for i in cl[-1]: # Проходим по элементам последнего кластера
            # Проверяем  каждый элемент ’j’ в оставшихся элементах ’a’
            for j in a[:]:
                # Если расстояние между ’i’ и ’j’ меньше радиуса ’r’
                x = [i[0], i[1]]
                y = [j[0], j[1]]
                if dist(x, y) < r:
                    cl[-1].append(j) # Добавляем ’j’ в текущий кластер
                    a.remove(j) # Удаляем ’j’ из списка ’a’, чтобы не проверять его снова
    return cl

f = open("1_B.txt")
s = f.readline()
a = [list(map(float, i.replace(",", ".").split())) for i in f]
cl = dbscan(a, 0.6)
cl_total = []
for i in cl:
    if len(i) > 10: cl_total.append(i)
t = 0.03 # Для файла Б
t = 0.02 # Для файла А
ans = []
for i in cl_total: # Проходим по каждому элементу в списке cl_total
    found_star = dbscan(i, t) # Применяем алгоритм DBSCAN
    duo_stars = [] # Список для бинарных звездных систем
    mx_starsys = [] # Список для хранения звездной системы с максимальной разницей масс
    # Проходим по каждому кластеру, найденному алгоритмом DBSCAN
    for j in found_star:
        if len(j) == 2: # Проверяем, состоит ли кластер из двух звезд
            # Проверяем являются ли обе эти звезды нейтронными звёздами
            if -2.7 < j[0][2] < 0 and -2.7 < j[1][2] < 0:
                duo_stars.append(j)
    mx_mass = 0 # Переменная для хранения максимальной разницы масс
    for j in duo_stars: # Проходим по всем найденным бинарным системам
        # Вычисляем разницу между массами
        if abs(j[0][2]-j[1][2]) > mx_mass:
                                                                                                  
                                                                                                  
            mx_mass = abs(j[0][2]-j[1][2]) # Обновляем максимальную разницу
            mx_starsys = j # Сохраняем текущую звездную систему как систему с максимальной разницей
    ans.append(mx_starsys)

# Рассчитываем среднее значение
res_X = 0
res_Y = 0
for i in ans:
    res_X += (i[0][0] + i[1][0])
    res_Y += (i[0][1] + i[1][1])

print(int(abs(res_X / 4) * 100))  # Для файла А
print(int(abs(res_Y / 4) * 100))  # Для файла А

print(int(abs(res_X / 6) * 100))  # Для файла Б
print(int(abs(res_Y / 6) * 100))  # Для файла Б

Для начала визуально оценим данные в условии кластеры. Для этого откроем предложенные файлы в , перейдем в раздел «Вставка Диаграммы Точечная».

Диаграмма для файла А имеет вид:

Диаграмма для файла Б имеет вид:

Для разделения звезд на кластеры будем использоваться функцию dbscan. Дальше основная идея решения будет заключаться в том, что мы будем проходить по каждой точке в найденных кластерах и с помощью того же метода dbscan для каждого кластера найти списки звезд, расстояние между которыми менее 0.03 в А файле (менее 0.009 в Б файле). Далее в каждом кластере нужно оставить только те списки, в которых количество звезд равно двум – то есть только двойные звездные системы. В конце остается дело за малым: для каждой звездной системы в каждом кластере найти максимальное расстояние между звездами, а затем расчитать среднее арифметическое их координат между всеми найденными парами звёзд.

Код программы для А файла

from math import *
def dbscan(a, r):
    cl = [] # Инициализируем список для хранения кластеров
    while a: # Пока есть элементы в входном массиве ’a’
    # Создаем новый кластер и добавляем в него первый элемент из ’a’
        cl.append([a.pop(0)])
        for i in cl[-1]: # Проходим по элементам последнего кластера
        # Проверяем  каждый элемент ’j’ в оставшихся элементах ’a’
            for j in a[:]:
            # Если расстояние между ’i’ и ’j’ меньше радиуса ’r’
                if dist(i, j) < r:
                    cl[-1].append(j) # Добавляем ’j’ в текущий кластер
                    a.remove(j) # Удаляем ’j’ из списка ’a’, чтобы не проверять его снова
    return cl

f = open("2_A.txt")
s = f.readline()
a = [list(map(float, i.replace(",", ".").split())) for i in f]
cl = dbscan(a, 0.4)
cl_total = []
c = 0
for i in cl:
    if len(i) > 10:
        cl_total.append(i)
res = []
t = 0.03  # Устанавливаем радиус для алгоритма DBSCAN
for i in cl_total: # Проходим по каждому элементу в списке cl_total
    found_star = dbscan(i, t) # Применяем алгоритм DBSCAN
    bin_stars = []  # Список для бинарных звездных систем
    max_star_sys = []
    # Проходим по каждому кластеру, найденному алгоритмом DBSCAN
    for j in found_star:
        if len(j) == 2: # Проверяем, состоит ли кластер из двух звезд
            bin_stars.append(j)  # Добавляем бинарную систему в список
    mx_dist = 0  # Переменная для хранения максимального расстояния
    # Список для хранения звездной системы с максимальным расстоянием
    for j in bin_stars: # Проходим по всем найденным бинарным системам
    # Вычисляем расстояние между звездами в бинарной системе
        if dist(j[0], j[1]) > mx_dist:
            mx_dist = dist(j[0], j[1])  # Обновляем максимальное расстояние
            max_star_sys = j
    # Сохраняем текущую звездную систему как систему с максимальным расстоянием
                                                                                                  
                                                                                                  
    res.append(max_star_sys)

res_X = 0
res_Y = 0
for i in res:
    res_X += (i[0][0] + i[1][0])
    res_Y += (i[0][1] + i[1][1])

print(int(abs(res_X / 10) * 1000))
print(int(abs(res_Y / 10) * 1000))

Код программы для Б файла

from math import *

def dbscan(a, r):
    cl = [] # Инициализируем список для хранения кластеров
    while a: # Пока есть элементы в входном массиве ’a’
        # Создаем новый кластер и добавляем в него первый элемент из ’a’
        cl.append([a.pop(0)])
        for i in cl[-1]: # Проходим по элементам последнего кластера
            # Проверяем  каждый элемент ’j’ в оставшихся элементах ’a’
            for j in a[:]:
                # Если расстояние между ’i’ и ’j’ меньше радиуса ’r’
                x = [i[0], i[1]]
                y = [j[0], j[1]]
                if dist(x, y) < r:
                    cl[-1].append(j) # Добавляем ’j’ в текущий кластер
                    a.remove(j) # Удаляем ’j’ из списка ’a’, чтобы не проверять его снова
    return cl

f = open("2_B.txt")
s = f.readline()
a = [list(map(float, i.replace(",", ".").split())) for i in f]
cl = dbscan(a, 0.65)
cl_total = []

for i in cl:
    if len(i) > 20:
        cl_total.append(i)
ans = []
t = 0.009
for cluster in cl_total:
    clust = dbscan(cluster,t)
    duo_stars = []
    max_star_sys = []
    for star_sys in clust:
        if len(star_sys) == 2:
            duo_stars.append(star_sys)
    max_dist = 0
    for i in duo_stars:
        if dist(i[0],i[1]) > max_dist:
            max_dist = dist(i[0],i[1])
            max_star_sys = i
    ans.append(max_star_sys)
                                                                                                  
                                                                                                  
sum_X = 0
sum_Y = 0
for i in ans:
    sum_X += i[0][0] + i[1][0]
    sum_Y += i[0][1] + i[1][1]
print(int(abs(sum_X/8)*1000))
print(int(abs(sum_Y/8)*1000))

Для начала визуально оценим данные в условии кластеры. Для этого откроем предложенные файлы в , перейдем в раздел «Вставка Диаграммы Точечная».

Диаграмма для файла А имеет вид:

Диаграмма для файла Б имеет вид:

Для разделения звезд на кластеры будем использоваться функцию dbscan. Дальше основная идея решения будет заключаться в том, что мы будем проходить по каждой точке в найденных кластерах и с помощью того же метода dbscan для каждого кластера найти списки звезд, расстояние между которыми менее 0.02 в А файле (менее 0.01 в Б файле). Далее в каждом кластере нужно оставить только те списки, в которых количество звезд равно трем – то есть только тройные звездные системы. В конце остается дело за малым: для каждой звездной системы в каждом кластере найти максимальное расстояние между звездами, а затем расчитать среднее арифметическое их координат между всеми найденными тройками звёзд.

Код программы для А файла

from math import *
def dbscan(a, r):
    cl = [] # Инициализируем список для хранения кластеров
    while a: # Пока есть элементы в входном массиве ’a’
        cl.append([a.pop(0)])
        for i in cl[-1]: # Проходим по элементам последнего кластера
            for j in a[:]:
                x = [i[0], i[1]]
                y = [j[0], j[1]]
                if dist(x, y) <= r:
                    cl[-1].append(j) # Добавляем ’j’ в текущий кластер
                    a.remove(j) # Удаляем ’j’ из списка ’a’, чтобы не проверять его снова
    return cl

f = open("1_A.txt")
s = f.readline()
a = [list(map(float, i.replace(",", ".").split())) for i in f]
cl = dbscan(a, 0.5)  # Для файла А
cl_total = []
for i in cl:
    if len(i) > 10: cl_total.append(i)

t = 0.05  # Для файла А
ans = []
for i in cl_total:  # Проходим по каждому элементу в списке cl_total
    found_star = dbscan(i, t)  # Применяем алгоритм DBSCAN
    tr_stars = []  # Список для тройных звездных систем
    mn_starsys = []  # Список для хранения звездной системы с минимальной суммарной массой
    # Проходим по каждому кластеру, найденному алгоритмом DBSCAN
    for j in found_star:
        if len(j) == 3:  # Проверяем, состоит ли кластер из трех звезд
            tr_stars.append(j)
    mx_d = 0  # Переменная для хранения максимального суммарного расстояния
    for j in tr_stars:  # Проходим по всем найденным тройным системам
        x = [j[0][0], j[0][1]]
        y = [j[1][0], j[1][1]]
        z = [j[2][0], j[2][1]]
        d1 = dist(x, y)
        d2 = dist(x, z)
        d3 = dist(z, y)
        if d1 < t and d2 < t and d3 < t and (d1 + d2 + d3) > mx_d:
            mx_d = d1 + d2 + d3
                                                                                                  
                                                                                                  
            mn_starsys = j  # Сохраняем текущую звездную систему
    ans.append(mn_starsys)
res_X = 0
res_Y = 0
for i in ans:
    res_X += (i[0][0] + i[1][0] + i[2][0])
    res_Y += (i[0][1] + i[1][1] + i[2][1])

print(int(abs(res_X / (4 * 3)) * 1000))  # Для файла А
print(int(abs(res_Y / (4 * 3)) * 1000))  # Для файла А

Код программы для Б файла

from math import *
def dbscan(a, r):
    cl = [] # Инициализируем список для хранения кластеров
    while a: # Пока есть элементы в входном массиве ’a’
        cl.append([a.pop(0)])
        for i in cl[-1]: # Проходим по элементам последнего кластера
            for j in a[:]:
                x = [i[0], i[1]]
                y = [j[0], j[1]]
                if dist(x, y) <= r:
                    cl[-1].append(j) # Добавляем ’j’ в текущий кластер
                    a.remove(j) # Удаляем ’j’ из списка ’a’, чтобы не проверять его снова
    return cl

f = open("1_B.txt")
s = f.readline()
a = [list(map(float, i.replace(",", ".").split())) for i in f]
cl = dbscan(a, 0.6)
cl_total = []
for i in cl:
    if len(i) > 10: cl_total.append(i)

t = 0.01
ans = []
for i in cl_total: # Проходим по каждому элементу в списке cl_total
    found_star = dbscan(i, t) # Применяем алгоритм DBSCAN
    tr_stars = [] # Список для тройных звездных систем
    mn_starsys = [] # Список для хранения звездной системы с минимальной суммарной массой
    # Проходим по каждому кластеру, найденному алгоритмом DBSCAN
    for j in found_star:
        if len(j) == 3: # Проверяем, состоит ли кластер из трех звезд
            tr_stars.append(j)
    mx_d = 0  # Переменная для хранения максимального суммарного расстояния
    for j in tr_stars: # Проходим по всем найденным тройным системам
        x = [j[0][0], j[0][1]]
        y = [j[1][0], j[1][1]]
        z = [j[2][0], j[2][1]]
        d1 = dist(x, y)
        d2 = dist(x, z)
        d3 = dist(z, y)
        if d1 < t and d2 < t and d3 < t and (d1 + d2 + d3) > mx_d:
            mx_d = d1 + d2 + d3
                                                                                                  
                                                                                                  
            mn_starsys = j # Сохраняем текущую звездную систему
    ans.append(mn_starsys)
res_X = 0
res_Y = 0
for i in ans:
    res_X += (i[0][0] + i[1][0] + i[2][0])
    res_Y += (i[0][1] + i[1][1] + i[2][1])

print(int(abs(res_X / (3 * 3)) * 1000))  # Для файла Б
print(int(abs(res_Y / (3 * 3)) * 1000))  # Для файла Б

Для начала визуально оценим данные в условии кластеры. Для этого откроем предложенные файлы в , перейдем в раздел «Вставка Диаграммы Точечная».

Диаграмма для файла А имеет вид:

Диаграмма для файла Б имеет вид:

Для разделения звезд на кластеры будем использовать функцию dbscan.

Дальше основная идея решения будет заключаться в том, что мы будем проходить по каждой точке в 3 для файла А и 4 для файла Б найденных кластерах и с помощью того же метода dbscan для каждого кластера найти списки звезд, расстояние между которыми менее 0.08 для файла А и 0.05 для файла Б.

В каждом кластере нужно оставить только те списки, в которых количество звезд равно трем – то есть только тройные звездные системы. Также нужно проверить по массе звезд, чтобы в тройке были красный и желтый карлики.

В конце остается дело за малым: для каждой звездной системы в каждом кластере найти систему с максимальной площадью, а затем рассчитать среднее расстояние между всеми найденными тройками.

Программа для файла А:

from math import *
def dbscan(a, r):
    cl = [] # Инициализируем список для хранения кластеров
    while a: # Пока есть элементы в входном массиве ’a’
        cl.append([a.pop(0)])
        for i in cl[-1]: # Проходим по элементам последнего кластера
            for j in a[:]:
                x = [i[0], i[1]]
                y = [j[0], j[1]]
                if dist(x, y) <= r:
                    cl[-1].append(j) # Добавляем ’j’ в текущий кластер
                    a.remove(j) # Удаляем ’j’ из списка ’a’, чтобы не проверять его снова
    return cl

f = open("2_A.txt")
s = f.readline()
a = [list(map(float, i.replace(",", ".").split())) for i in f]
cl = dbscan(a, 0.7) # Для файла А
cl_total = []
for i in cl:
    if len(i) > 10: cl_total.append(i)

t = 0.08 # Для файла А
ans = []
for i in cl_total: # Проходим по каждому элементу в списке cl_total
    found_star = dbscan(i, t) # Применяем алгоритм DBSCAN
    tr_stars = [] # Список для тройных звездных систем
    mn_starsys = [] # Список для хранения звездной системы с минимальной суммарной массой
    # Проходим по каждому кластеру, найденному алгоритмом DBSCAN
    for j in found_star:
        if len(j) == 3: # Проверяем, состоит ли кластер из трех звезд
            if ((0.08 <= j[0][2] <= 0.6 or 0.08 <= j[1][2] <= 0.6 or 0.08 <= j[2][2] <= 0.6)
            and (0.8 <= j[0][2] <= 1.2 or 0.8 <= j[1][2] <= 1.2 or 0.8 <= j[2][2] <= 1.2)):
                tr_stars.append(j)
    mx_square = -100000
    for j in tr_stars: # Проходим по всем найденным тройным системам
        x = [j[0][0], j[0][1]]
        y = [j[1][0], j[1][1]]
        z = [j[2][0], j[2][1]]
        d1 = dist(x, y)
        d2 = dist(x, z)
        d3 = dist(z, y)
                                                                                                  
                                                                                                  
        half_per = (d1 + d2 + d3) / 2
        if (half_per * (half_per - d1) * (half_per - d2) * (half_per - d3)) ** 0.5 > mx_square and d1 < t and d2 < t and d3 < t:
            mx_square = (half_per * (half_per - d1) * (half_per - d2) * (half_per - d3)) ** 0.5 # Обновляем максимальную площадь
            mn_starsys = j # Сохраняем текущую звездную систему
    ans.append(mn_starsys)
res_X = 0
res_Y = 0
for i in ans:
    res_X += (i[0][0] + i[1][0] + i[2][0])
    res_Y += (i[0][1] + i[1][1] + i[2][1])

print(int(res_X / (3 * 3) * 1000))  # Для файла А
print(int(res_Y / (3 * 3) * 1000))  # Для файла А

Программа для файла Б:

from math import *
def dbscan(a, r):
    cl = [] # Инициализируем список для хранения кластеров
    while a: # Пока есть элементы в входном массиве ’a’
        cl.append([a.pop(0)])
        for i in cl[-1]: # Проходим по элементам последнего кластера
            for j in a[:]:
                x = [i[0], i[1]]
                y = [j[0], j[1]]
                if dist(x, y) <= r:
                    cl[-1].append(j) # Добавляем ’j’ в текущий кластер
                    a.remove(j) # Удаляем ’j’ из списка ’a’, чтобы не проверять его снова
    return cl

f = open("2_B.txt")
s = f.readline()
a = [list(map(float, i.replace(",", ".").split())) for i in f]
cl = dbscan(a, 0.5) # Для файла Б
cl_total = []
for i in cl:
    if len(i) > 10: cl_total.append(i)

t = 0.05 # Для файла Б
ans = []
for i in cl_total: # Проходим по каждому элементу в списке cl_total
    found_star = dbscan(i, t) # Применяем алгоритм DBSCAN
    tr_stars = [] # Список для тройных звездных систем
    mn_starsys = [] # Список для хранения звездной системы с минимальной суммарной массой
    # Проходим по каждому кластеру, найденному алгоритмом DBSCAN
    for j in found_star:
        if len(j) == 3: # Проверяем, состоит ли кластер из трех звезд
            if ((0.08 <= j[0][2] <= 0.6 or 0.08 <= j[1][2] <= 0.6 or 0.08 <= j[2][2] <= 0.6)
            and (0.8 <= j[0][2] <= 1.2 or 0.8 <= j[1][2] <= 1.2 or 0.8 <= j[2][2] <= 1.2)):
                tr_stars.append(j)
    mx_square = -100000
    for j in tr_stars: # Проходим по всем найденным тройным системам
        x = [j[0][0], j[0][1]]
        y = [j[1][0], j[1][1]]
        z = [j[2][0], j[2][1]]
        d1 = dist(x, y)
        d2 = dist(x, z)
        d3 = dist(z, y)
                                                                                                  
                                                                                                  
        half_per = (d1 + d2 + d3) / 2
        if (half_per * (half_per - d1) * (half_per - d2) * (half_per - d3)) ** 0.5 > mx_square and d1 < t and d2 < t and d3 < t:
            mx_square = (half_per * (half_per - d1) * (half_per - d2) * (half_per - d3)) ** 0.5 # Обновляем максимальную площадь
            mn_starsys = j # Сохраняем текущую звездную систему
    ans.append(mn_starsys)
res_X = 0
res_Y = 0
for i in ans:
    res_X += (i[0][0] + i[1][0] + i[2][0])
    res_Y += (i[0][1] + i[1][1] + i[2][1])

print(int(res_X / (4 * 3) * 1000))  # Для файла Б
print(int(res_Y / (4 * 3) * 1000))  # Для файла Б

Оценим данные визуально, открыв файлы в и построив точечные диаграммы через раздел «Вставка Диаграммы Точечная».

Диаграмма для файла A:

Диаграмма для файла B:

Для кластеризации используем алгоритм DBSCAN с радиусом . Затем в каждом кластере применим DBSCAN с радиусом для поиска двойных систем. Оставим только пары из двух нейтронных звёзд () и выберем ту, где сумма масс по модулю минимальна. Вычислим средние и для всех найденных пар.

Код для файла A:

from math import *

def dbscan(a, r):
    cl = [] # Инициализируем список для хранения кластеров
    while a: # Пока есть элементы в входном массиве ’a’
        # Создаем новый кластер и добавляем в него первый элемент из ’a’
        cl.append([a.pop(0)])
        for i in cl[-1]: # Проходим по элементам последнего кластера
            # Проверяем  каждый элемент ’j’ в оставшихся элементах ’a’
            for j in a[:]:
                # Если расстояние между ’i’ и ’j’ меньше радиуса ’r’
                x = [i[0], i[1]]
                y = [j[0], j[1]]
                if dist(x, y) < r:
                    cl[-1].append(j) # Добавляем ’j’ в текущий кластер
                    a.remove(j) # Удаляем ’j’ из списка ’a’, чтобы не проверять его снова
    return cl

f = open("1_A.txt")
a = [list(map(float, i.replace(",", ".").split())) for i in f]
cl = dbscan(a, 0.5)
cl_total = []
for i in cl:
    if len(i) > 10: cl_total.append(i)
t = 0.15
ans = []
for i in cl_total:
    found_star = dbscan(i, t)
    duo_stars = []
    mx_starsys = []
    for j in found_star:
        if len(j) == 2:
            if -2.5 < j[0][2] < 0 and -2.5 < j[1][2] < 0:
                duo_stars.append(j)
    mx_mass = 0
    for j in duo_stars:
        if abs(j[0][2] + j[1][2]) > mx_mass:
            mx_mass = abs(j[0][2] + j[1][2])
            mx_starsys = j
    ans.append(mx_starsys)
# Рассчитываем среднее значение
res_X = 0
                                                                                                  
                                                                                                  
res_Y = 0
for i in ans:
    res_X += (i[0][0] + i[1][0])
    res_Y += (i[0][1] + i[1][1])

print(int(abs(res_X / 4) * 200))
print(int(abs(res_Y / 4) * 200))

Код для файла B:

from math import *

def dbscan(a, r):
    cl = [] # Инициализируем список для хранения кластеров
    while a: # Пока есть элементы в входном массиве ’a’
        # Создаем новый кластер и добавляем в него первый элемент из ’a’
        cl.append([a.pop(0)])
        for i in cl[-1]: # Проходим по элементам последнего кластера
            # Проверяем  каждый элемент ’j’ в оставшихся элементах ’a’
            for j in a[:]:
                # Если расстояние между ’i’ и ’j’ меньше радиуса ’r’
                x = [i[0], i[1]]
                y = [j[0], j[1]]
                if dist(x, y) < r:
                    cl[-1].append(j) # Добавляем ’j’ в текущий кластер
                    a.remove(j) # Удаляем ’j’ из списка ’a’, чтобы не проверять его снова
    return cl

f = open("1_B.txt")
s = f.readline()
a = [list(map(float, i.replace(",", ".").split())) for i in f]
cl = dbscan(a, 0.7)
cl_total = []
for i in cl:
    if len(i) > 10: cl_total.append(i)
t = 0.025
ans = []
for i in cl_total:
    found_star = dbscan(i, t)
    duo_stars = []
    mx_starsys = []
    for j in found_star:
        if len(j) == 2:
            if -2.5 < j[0][2] < 0 and -2.5 < j[1][2] < 0:
                duo_stars.append(j)
    mx_mass = 0
    for j in duo_stars:
        if abs(j[0][2] + j[1][2]) > mx_mass:
            mx_mass = abs(j[0][2] + j[1][2])
            mx_starsys = j
    ans.append(mx_starsys)
# Рассчитываем среднее значение
                                                                                                  
                                                                                                  
res_X = 0
res_Y = 0
for i in ans:
    res_X += (i[0][0] + i[1][0])
    res_Y += (i[0][1] + i[1][1])

print(int(abs(res_X / 6) * 200))
print(int(abs(res_Y / 6) * 200))

Визуализируем данные в , используя «Вставка Диаграммы Точечная», чтобы понять структуру кластеров.

Диаграмма для файла A:

Диаграмма для файла B:

Применяем DBSCAN с радиусом для выделения кластеров, затем с радиусом для поиска двойных систем. Фильтруем пары из нейтронных звёзд (), выбираем ту, где расстояние максимально, и вычисляем и .

Код для файла A:

from math import *

def dbscan(a, r):
    cl = [] # Инициализируем список для хранения кластеров
    while a: # Пока есть элементы в входном массиве ’a’
        # Создаем новый кластер и добавляем в него первый элемент из ’a’
        cl.append([a.pop(0)])
        for i in cl[-1]: # Проходим по элементам последнего кластера
            # Проверяем  каждый элемент ’j’ в оставшихся элементах ’a’
            for j in a[:]:
                # Если расстояние между ’i’ и ’j’ меньше радиуса ’r’
                x = [i[0], i[1]]
                y = [j[0], j[1]]
                if dist(x, y) < r:
                    cl[-1].append(j) # Добавляем ’j’ в текущий кластер
                    a.remove(j) # Удаляем ’j’ из списка ’a’, чтобы не проверять его снова
    return cl

f = open("2_A.txt")
a = [list(map(float, i.replace(",", ".").split())) for i in f]
cl = dbscan(a, 0.8)
cl_total = []
for i in cl:
    if len(i) > 10: cl_total.append(i)
t = 0.1
ans = []
for i in cl_total:
    found_star = dbscan(i, t)
    duo_stars = []
    mx_starsys = []
    for j in found_star:
        if len(j) == 2:
            x = [j[0][0],j[0][1]]
            y = [j[1][0],j[1][1]]
            if -2.7 < j[0][2] < 0 and -2.7 < j[1][2] < 0:
                duo_stars.append([x,y])
    mx_dist = 0
    for j in duo_stars:
        if dist(j[0],j[1]) > mx_dist:
            mx_mass = dist(j[0],j[1])
            mx_starsys = j
    ans.append(mx_starsys)
                                                                                                  
                                                                                                  
# Рассчитываем среднее значение
res_X = 0
res_Y = 0
for i in ans:
    res_X += (i[0][0] + i[1][0])
    res_Y += (i[0][1] + i[1][1])

print(int(abs(res_X / 6) * 150))
print(int(abs(res_Y / 6) * 150))

Код для файла B:

from math import *

def dbscan(a, r):
    cl = [] # Инициализируем список для хранения кластеров
    while a: # Пока есть элементы в входном массиве ’a’
        # Создаем новый кластер и добавляем в него первый элемент из ’a’
        cl.append([a.pop(0)])
        for i in cl[-1]: # Проходим по элементам последнего кластера
            # Проверяем  каждый элемент ’j’ в оставшихся элементах ’a’
            for j in a[:]:
                # Если расстояние между ’i’ и ’j’ меньше радиуса ’r’
                x = [i[0], i[1]]
                y = [j[0], j[1]]
                if dist(x, y) < r:
                    cl[-1].append(j) # Добавляем ’j’ в текущий кластер
                    a.remove(j) # Удаляем ’j’ из списка ’a’, чтобы не проверять его снова
    return cl

f = open("2_B.txt")
a = [list(map(float, i.replace(",", ".").split())) for i in f]
cl = dbscan(a, 0.4)
cl_total = []
for i in cl:
    if len(i) > 10: cl_total.append(i)
t = 0.08
ans = []
for i in cl_total:
    found_star = dbscan(i, t)
    duo_stars = []
    mx_starsys = []
    for j in found_star:
        if len(j) == 2:
            x = [j[0][0],j[0][1]]
            y = [j[1][0],j[1][1]]
            if -2.7 < j[0][2] < 0 and -2.7 < j[1][2] < 0:
                duo_stars.append([x,y])
    mx_dist = 0
    for j in duo_stars:
        if dist(j[0],j[1]) > mx_dist:
            mx_dist = dist(j[0],j[1])
            mx_starsys = j
    ans.append(mx_starsys)
                                                                                                  
                                                                                                  
# Рассчитываем среднее значение
res_X = 0
res_Y = 0
for i in ans:
    res_X += (i[0][0] + i[1][0])
    res_Y += (i[0][1] + i[1][1])

print(int(abs(res_X / 8) * 150))
print(int(abs(res_Y / 8) * 150))