Array 115

def modified_bubble_sort(A):
    N = len(A)
    I = list(range(1, N+1))  # Создаем вспомогательный массив I с номерами от 1 до N

    for i in range(N-1):
        for j in range(N-1-i):
            if A[j] > A[j+1]:
                A[j], A[j+1] = A[j+1], A[j]  # Меняем местами элементы массива A
                I[j], I[j+1] = I[j+1], I[j]  # Меняем местами элементы массива I

    return I

# Пример использования
A = [5, 2, 8, 1, 4]
sorted_indices = modified_bubble_sort(A)
print(sorted_indices)

Array116.

def form_series_arrays(A):
    B = []  # Массив для хранения длин серий
    C = []  # Массив для хранения значений элементов серий

    count = 1  # Счетчик для подсчета длины серии
    for i in range(1, len(A)):
        if A[i] == A[i-1]:
            count += 1
        else:
            B.append(count)
            C.append(A[i-1])
            count = 1

    # Добавляем последнюю серию в массивы B и C
    B.append(count)
    C.append(A[-1])

    return B, C

# Пример использования
A = [1, 1, 2, 2, 2, 3, 4, 4, 4, 4]
B, C = form_series_arrays(A)
print(B)
print(C)

Array117.

def insert_zeros_before_series(A):
    B = []  # Массив для хранения элементов с нулевыми значениями исходного массива

    for i in range(len(A)):
        if i > 0 and A[i] != A[i-1]:
            B.append(0)
        B.append(A[i])

    return B

# Пример использования
A = [1, 1, 2, 2, 2, 3, 4, 4, 4, 4]
B = insert_zeros_before_series(A)
print(B)

Array118.

def insert_zeros_after_series(A):
    B = []  # Массив для хранения элементов с нулевыми значениями исходного массива

    for i in range(len(A)):
        B.append(A[i])
        if i < len(A)-1 and A[i] != A[i+1]:
            B.append(0)

    return B

# Пример использования
A = [1, 1, 2, 2, 2, 3, 4, 4, 4, 4]
B = insert_zeros_after_series(A)
print(B)

Array119.

def increase_series(A):
    B = []  # Массив для хранения преобразованных элементов

    for i in range(len(A)):
        B.append(A[i])
        if i < len(A)-1 and A[i] == A[i+1]:
            B.append(A[i])

    return B

# Пример использования
A = [1, 1, 2, 2, 2, 3, 4, 4, 4, 4]
B = increase_series(A)
print(B)

Array120.

def decrease_series(A):
    B = []  # Массив для хранения преобразованных элементов

    for i in range(len(A)):
        if i > 0 and A[i] == A[i-1]:
            continue
        B.append(A[i])

    return B

# Пример использования
A = [1, 1, 0, 2, 2, 2, 0, 4, 4, 4, 4, 0]
B = decrease_series(A)
print(B)

Array121.

def double_series_length(A, K):
    B = []  # Массив для хранения преобразованных элементов

    count = 0  # Счетчик для подсчета серий
    for i in range(len(A)):
        B.append(A[i])
        if i < len(A)-1 and A[i] == A[i+1]:
            count += 1
            if count == K:
                B.extend([A[i]] * count)
        else:
            count = 0

    return B

# Пример использования
A = [1, 1, 2, 2, 2, 3, 4, 4, 4, 4]
K = 2
B = double_series_length(A, K)
print(B)

Array122.

def remove_series(A, K):
    B = []  # Массив для хранения преобразованных элементов

    count = 0  # Счетчик для подсчета серий
    for i in range(len(A)):
        if i < len(A)-1 and A[i] == A[i+1]:
            count += 1
            if count == K:
                count = 0
                continue
        B.append(A[i])

    return B

# Пример использования
A = [1, 1, 2, 2, 2, 3, 4, 4, 4, 4]
K = 2
B = remove_series(A, K)
print(B)

Array123.

def swap_series(A, K):
    B = []  # Массив для хранения преобразованных элементов

    count = 0  # Счетчик для подсчета серий
    series_K = []  # Серия с номером K
    for i in range(len(A)):
        if i < len(A)-1 and A[i] == A[i+1]:
            count += 1
            if count == 1:
                series_K.extend([A[i]])
            if count == K:
                B.extend(series_K)
                count = 0
                series_K = []
        B.append(A[i])

    return B

# Пример использования
A = [1, 1, 2, 2, 2, 3, 4, 4, 4, 4]
K = 2
B = swap_series(A, K)
print(B)

Array124.

def swap_last_series(A, K):
    B = []  # Массив для хранения преобразованных элементов

    count = 0  # Счетчик для подсчета серий
    series_K = []  # Серия с номером K
    last_series = []  # Последняя серия
    for i in range(len(A)):
        if i < len(A)-1 and A[i] == A[i+1]:
            count += 1
            if count == 1:
                series_K.extend([A[i]])
            if count == K:
                B.extend(last_series)
                count = 0
                last_series = []
        last_series.append(A[i])

    B.extend(series_K)
    return B

# Пример использования
A = [1, 1, 2, 2, 2, 3, 4, 4, 4, 4]
K = 2
B = swap_last_series(A, K)
print(B)

Array125.

def replace_short_series(A, L):
    B = []  # Массив для хранения преобразованных элементов

    count = 0  # Счетчик для подсчета серий
    series = []  # Текущая серия
    for i in range(len(A)):
        if i < len(A)-1 and A[i] == A[i+1]:
            count += 1
            series.append(A[i])
        else:
            series.append(A[i])
            if count < L:
                B.extend([0] * len(series))
            else:
                B.extend(series)
            count = 0
            series = []

    return B

# Пример использования
A = [1, 1, 2, 2, 2, 3, 4, 4, 4, 4]
L = 3
B = replace_short_series(A, L)
print(B)

Array126.

def replace_equal_series(A, L):
    B = []  # Массив для хранения преобразованных элементов

    count = 0  # Счетчик для подсчета серий
    series = []  # Текущая серия
    for i in range(len(A)):
        if i < len(A)-1 and A[i] == A[i+1]:
            count += 1
            series.append(A[i])
        else:
            series.append(A[i])
            if count == L:
                B.append(0)
            else:
                B.extend(series)
            count = 0
            series = []

    return B

# Пример использования
A = [1, 1, 2, 2, 2, 3, 4, 4, 4, 4]
L = 3
B = replace_equal_series(A, L)
print(B)

Array127.

def replace_long_series(A, L):
    B = []  # Массив для хранения преобразованных элементов

    count = 0  # Счетчик для подсчета серий
    series = []  # Текущая серия
    for i in range(len(A)):
        if i < len(A)-1 and A[i] == A[i+1]:
            count += 1
            series.append(A[i])
        else:
            series.append(A[i])
            if count > L:
                B.append(0)
            else:
                B.extend(series)
            count = 0
            series = []

    return B

# Пример использования
A = [1, 2, 2, 2, 3, 4, 4, 4, 4, 5]
L = 2
B = replace_long_series(A, L)
print(B)

Array128.

def increase_longest_series(A):
    B = []  # Массив для хранения преобразованных элементов

    count = 0  # Счетчик для подсчета серий
    series = []  # Текущая серия
    max_length = 0  # Максимальная длина серии
    max_series = []  # Серия с наибольшей длиной
    for i in range(len(A)):
        if i < len(A)-1 and A[i] == A[i+1]:
            count += 1
            series.append(A[i])
        else:
            series.append(A[i])
            if count > max_length:
                max_length = count
                max_series = series
            count = 0
            series = []

    max_series.append(max_series[0] + 1)
    B.extend(max_series)
    B.extend(A[len(max_series):])

    return B

# Пример использования
A = [1, 1, 2, 2, 2, 3, 4, 4, 4, 4]
B = increase_longest_series(A)
print(B)

Array129.

def increase_last_long_series(A):
    B = []  # Массив для хранения преобразованных элементов

    count = 0  # Счетчик для подсчета серий
    series = []  # Текущая серия
    max_length = 0  # Максимальная длина серии
    max_series = []  # Серия с наибольшей длиной
    for i in range(len(A)):
        if i < len(A)-1 and A[i] == A[i+1]:
            count += 1
            series.append(A[i])
        else:
            series.append(A[i])
            if count >= max_length:
                max_length = count
                max_series = series
            count = 0
            series = []

    max_series.append(max_series[-1] + 1)
    B.extend(A[:len(A)-len(max_series)])
    B.extend(max_series)

    return B

# Пример использования
A = [1, 1, 2, 2, 2, 3, 4, 4, 4, 4]
B = increase_last_long_series(A)
print(B)

Array 130

def increase_longest_series(A):
    max_length = 0  # Максимальная длина серии
    max_series = []  # Серия с наибольшей длиной

    # Находим серию с наибольшей длиной
    count = 0  # Счетчик для подсчета серий
    series = []  # Текущая серия
    for i in range(len(A)):
        if i < len(A)-1 and A[i] == A[i+1]:
            count += 1
            series.append(A[i])
        else:
            series.append(A[i])
            if count >= max_length:
                max_length = count
                max_series = series
            count = 0
            series = []

    # Увеличиваем все элементы серий наибольшей длины на 1
    for i in range(len(A)):
        if A[i:i+len(max_series)] == max_series:
            A[i:i+len(max_series)] = [x+1 for x in A[i:i+len(max_series)]]

    return A

# Пример использования
A = [1, 1, 2, 2, 2, 3, 4, 4, 4, 4]
B = increase_longest_series(A)
print(B)

Array131.

import math

def find_closest_point(A, B):
    closest_point = None
    min_distance = float('inf')  # Инициализируем минимальное расстояние как бесконечность

    for point in A:
        distance = math.sqrt((point[0] - B[0])**2 + (point[1] - B[1])**2)
        if distance < min_distance:
            min_distance = distance
            closest_point = point

    return closest_point

# Пример использования
A = [(1, 2), (3, 4), (5, 6)]
B = (2, 3)
closest = find_closest_point(A, B)
print(closest)

После выполнения кода вы получите точку из множества \( A \), которая наиболее близка к точке \( B \).

Array132.

import math

def find_farthest_point(A):
    farthest_point = (0, 0)  # Инициализируем точку с нулевыми координатами
    max_distance = 0  # Инициализируем максимальное расстояние как 0

    for point in A:
        if point[0] < 0 and point[1] > 0:  # Проверяем, что точка лежит во второй четверти
            distance = math.sqrt(point[0]**2 + point[1]**2)
            if distance > max_distance:
                max_distance = distance
                farthest_point = point

    return farthest_point

# Пример использования
A = [(1, 2), (-3, 4), (-5, -6)]
farthest = find_farthest_point(A)
print(farthest)

Array 135

import math

def find_min_distance(A, B):
    min_distance = float('inf')  # Инициализируем минимальное расстояние как бесконечность
    min_distance_points = ()

    for point_a in A:
        for point_b in B:
            distance = math.sqrt((point_a[0] - point_b[0])**2 + (point_a[1] - point_b[1])**2)
            if distance < min_distance:
                min_distance = distance
                min_distance_points = (point_a, point_b)

    return min_distance_points, min_distance

# Пример использования
A = [(1, 2), (3, 4), (5, 6)]
B = [(7, 8), (9, 10), (11, 12)]
min_distance_points, min_distance = find_min_distance(A, B)
print(min_distance_points)
print(min_distance)

Array133.

import math

def find_closest_point(A):
    min_distance = float('inf')  # Инициализируем минимальное расстояние бесконечностью
    closest_point = (0, 0)  # Инициализируем точку с нулевыми координатами

    for point in A:
        x, y = point
        if x >= 0 and y >= 0 or x <= 0 and y <= 0:  # Проверяем, что точка находится в первой или третьей четверти
            distance = math.sqrt(x**2 + y**2)  # Вычисляем расстояние от точки до начала координат
            if distance < min_distance:
                min_distance = distance
                closest_point = point

    return closest_point

# Пример использования
A = [(1, 2), (-3, 4), (-5, -6), (7, -8)]
closest_point = find_closest_point(A)
print(closest_point)

Array134.

import math

def find_max_distance(A):
    max_distance = 0  # Инициализируем максимальное расстояние нулем
    point1 = ()
    point2 = ()

    for i in range(len(A)):
        for j in range(i+1, len(A)):
            distance = math.sqrt((A[i][0] - A[j][0])**2 + (A[i][1] - A[j][1])**2)
            if distance > max_distance:
                max_distance = distance
                point1 = A[i]
                point2 = A[j]

    return point1, point2, max_distance

# Пример использования
A = [(1, 2), (3, 4), (5, 6), (7, 8)]
point1, point2, max_distance = find_max_distance(A)
print(point1)
print(point2)
print(max_distance)

Array136:

import math

def find_min_distance_sum(points):
    min_sum = float('inf')
    best_point = None

    for p in points:
        distance_sum = 0
        for q in points:
            if p != q:
                distance = math.sqrt((p[0] - q[0])**2 + (p[1] - q[1])**2)
                distance_sum += distance
        
        if distance_sum < min_sum:
            min_sum = distance_sum
            best_point = p
    
    return best_point, min_sum

# Пример использования
points = [(1, 2), (3, 4), (5, 6), (7, 8)]
best_point, min_sum = find_min_distance_sum(points)
print("Лучшая точка:", best_point)
print("Минимальная сумма расстояний:", min_sum)

Array137:

import itertools

def find_max_perimeter(points):
    max_perimeter = 0
    best_triangle = []

    for p, q, r in itertools.combinations(points, 3):
        perimeter = distance(p, q) + distance(q, r) + distance(r, p)
        
        if perimeter > max_perimeter:
            max_perimeter = perimeter
            best_triangle = [p, q, r]
    
    return best_triangle, max_perimeter

def distance(p, q):
    return math.sqrt((p[0] - q[0])**2 + (p[1] - q[1])**2)

# Пример использования
points = [(1, 2), (3, 4), (5, 6), (7, 8)]
best_triangle, max_perimeter = find_max_perimeter(points)
print("Лучший треугольник:", best_triangle)
print("Наибольший периметр:", max_perimeter)

Array138:

import itertools
import math

def find_min_triangle_perimeter(points):
    min_perimeter = float('inf')
    best_triangle = []

    for p, q, r in itertools.combinations(points, 3):
        perimeter = distance(p, q) + distance(q, r) + distance(r, p)
        
        if perimeter < min_perimeter:
            min_perimeter = perimeter
            best_triangle = [p, q, r]
    
    return best_triangle, min_perimeter

def distance(p, q):
    return math.sqrt((p[0] - q[0])**2 + (p[1] - q[1])**2)

# Пример использования
points = [(1, 2), (3, 4), (5, 6), (7, 8)]
best_triangle, min_perimeter = find_min_triangle_perimeter(points)
print("Наименьший периметр треугольника:", min_perimeter)
print("Точки треугольника:", best_triangle)

Array139:

def compare_points(p1, p2):
    if p1[0] < p2[0]:
        return -1
    elif p1[0] > p2[0]:
        return 1
    else:
        if p1[1] < p2[1]:
            return -1
        elif p1[1] > p2[1]:
            return 1
        else:
            return 0

# Пример использования
points = [(3, 4), (1, 2), (7, 8), (5, 6)]
sorted_points = sorted(points, key=lambda p: (p[0], p[1]))
print("Отсортированные точки:", sorted_points)

Array 140

def merge_sort(points):
    if len(points) <= 1:
        return points
    
    mid = len(points) // 2
    left = points[:mid]
    right = points[mid:]
    
    left = merge_sort(left)
    right = merge_sort(right)
    
    return merge(left, right)

def merge(left, right):
    merged = []
    i = j = 0
    
    while i < len(left) and j < len(right):
        if left[i][0] + left[i][1] < right[j][0] + right[j][1] or (left[i][0] + left[i][1] == right[j][0] + right[j][1] and left[i][0] < right[j][0]):
            merged.append(left[i])
            i += 1
        else:
            merged.append(right[j])
            j += 1
    
    while i < len(left):
        merged.append(left[i])
        i += 1
    
    while j < len(right):
        merged.append(right[j])
        j += 1
    
    return merged

# Пример использования
points = [(1, 2), (3, 4), (2, 3), (4, 1)]
sorted_points = merge_sort(points)
print(sorted_points)

Всем привет

Если вам непонятно которые из этих решения.

Напишите в группу

Я другое решение вам отправлю