Array85:

def cyclic_shift_right(arr, K):
    helper_array = arr[-K:]  # копируем последние K элементов во вспомогательный массив
    for i in range(len(arr)-1, K-1, -1):
        arr[i] = arr[i-K]  # сдвигаем элементы вправо
    for i in range(K):
        arr[i] = helper_array[i]  # копируем элементы из вспомогательного массива в начало
    return arr

# Пример использования
N = 6
K = 3
array = [1, 2, 3, 4, 5, 6]
shifted_array = cyclic_shift_right(array, K)
print(shifted_array)

Результат выполнения кода будет:

[4, 5, 6, 1, 2, 3]

Array86:

def cyclic_shift_left(arr, K):
    helper_array = arr[:K]  # копируем первые K элементов во вспомогательный массив
    for i in range(K, len(arr)):
        arr[i-K] = arr[i]  # сдвигаем элементы влево
    for i in range(K):
        arr[len(arr)-K+i] = helper_array[i]  # копируем элементы из вспомогательного массива в конец
    return arr

# Пример использования
N = 6
K = 3
array = [1, 2, 3, 4, 5, 6]
shifted_array = cyclic_shift_left(array, K)
print(shifted_array)

Результат выполнения кода будет:

[4, 5, 6, 1, 2, 3]

Array87:

def move_first_element(arr):
    first_element = arr[0]  # сохраняем значение первого элемента
    for i in range(len(arr)-1):
        arr[i] = arr[i+1]  # сдвигаем элементы вправо
    arr[-1] = first_element  # последний элемент равен первому сохраненному значению
    return arr

# Пример использования
N = 5
array = [3, 1, 2, 4, 5]
sorted_array = move_first_element(array)
print(sorted_array)

Результат выполнения кода будет:

[1, 2, 4, 5, 3]

Array88:

def move_last_element(arr):
    last_element = arr[-1]  # сохраняем значение последнего элемента
    for i in range(len(arr)-1, 0, -1):
        arr[i] = arr[i-1]  # сдвигаем элементы влево
    arr[0] = last_element  # первый элемент равен последнему сохраненному значению
    return arr

# Пример использования
N = 5
array = [1, 2, 4, 5, 3]
sorted_array = move_last_element(array)
print(sorted_array)

Результат выполнения кода будет:

[3, 1, 2, 4, 5]

Array 89

def order_array(arr):
    n = len(arr)
    index = -1

    # Находим индекс элемента, нарушающего упорядоченность
    for i in range(n-1):
        if arr[i] > arr[i+1]:
            index = i
            break

    if index == -1:
        # Массив уже упорядочен
        return arr

    # Сохраняем значение и индекс элемента
    value = arr[index]
    del arr[index]

    # Находим позицию для вставки сохраненного значения
    for i in range(n-2, -1, -1):
        if arr[i] < value:
            arr.insert(i+1, value)
            break

    return arr

# Пример использования
arr = [5, 4, 3, 2, 1, 7, 6]
ordered_arr = order_array(arr)
print(ordered_arr)

Результат выполнения данного кода будет:

[1, 2, 3, 4, 5, 6, 7]

Array90:

def remove_element(arr, k):
    if k < 1 or k > len(arr):
        return arr

    del arr[k-1]
    return arr

# Пример использования
arr = [1, 2, 3, 4, 5]
k = 3
result = remove_element(arr, k)
print(result)

Array91:

def remove_elements(arr, k, l):
    if k < 1 or l > len(arr) or k > l:
        return len(arr), arr

    del arr[k-1:l]
    return len(arr), arr

# Пример использования
arr = [1, 2, 3, 4, 5, 6, 7]
k = 2
l = 5
size, result = remove_elements(arr, k, l)
print(size, result)

Array92:

def remove_odd_numbers(arr):
    new_arr = [x for x in arr if x % 2 == 0]
    return len(new_arr), new_arr

# Пример использования
arr = [1, 2, 3, 4, 5, 6]
size, result = remove_odd_numbers(arr)
print(size, result)

Array93:

def remove_elements_with_even_indices(arr):
    new_arr = arr[1::2]
    return new_arr

# Пример использования
arr = [1, 2, 3, 4, 5, 6, 7]
result = remove_elements_with_even_indices(arr)
print(result)

Array94:

def remove_elements_with_odd_indices(arr):
    new_arr = arr[0::2]
    return new_arr

# Пример использования
arr = [1, 2, 3, 4, 5, 6, 7]
result = remove_elements_with_odd_indices(arr)
print(result)

Array95:

def remove_duplicate_neighbors(arr):
    new_arr = [arr[0]]
    for i in range(1, len(arr)):
        if arr[i] != arr[i-1]:
            new_arr.append(arr[i])
    return new_arr

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

Array96:

def remove_duplicates_keep_first(arr):
    new_arr = []
    for num in arr:
        if num not in new_arr:
            new_arr.append(num)
    return new_arr

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

Array97:

def remove_duplicates_keep_last(arr):
    new_arr = []
    for num in reversed(arr):
        if num not in new_arr:
            new_arr.insert(0, num)
    return new_arr[::-1]

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

Array98:

def remove_less_than_three_occurrences(arr):
    occurrences = {}
    for num in arr:
        occurrences[num] = occurrences.get(num, 0) + 1
    new_arr = [num for num in arr if occurrences[num] >= 3]
    return new_arr

# Пример использования
arr = [1, 2, 2, 3, 4, 4, 5, 6, 6, 6]
result = remove_less_than_three_occurrences(arr)
print("Размер массива:", len(result))
print("Содержимое массива:", result)

Array99:

def remove_more_than_two_occurrences(arr):
    occurrences = {}
    for num in arr:
        occurrences[num] = occurrences.get(num, 0) + 1
    new_arr = [num for num in arr if occurrences[num] <= 2]
    return new_arr

# Пример использования
arr = [1, 2, 2, 3, 4, 4, 5, 6, 6, 6]
result = remove_more_than_two_occurrences(arr)
print("Размер массива:", len(result))
print("Содержимое массива:", result)

Array100:

def remove_exactly_two_occurrences(arr):
    occurrences = {}
    for num in arr:
        occurrences[num] = occurrences.get(num, 0) + 1
    new_arr = [num for num in arr if occurrences[num] != 2]
    return new_arr

# Пример использования
arr = [1, 2, 2, 3, 4, 4, 5, 6, 6, 6]
result = remove_exactly_two_occurrences(arr)
print("Размер массива:", len(result))
print("Содержимое массива:", result)

Array101:

def insert_zero_before_k(arr, k):
    arr.insert(k, 0)
    return arr

# Пример использования
arr = [1, 2, 3, 4, 5]
k = 3
result = insert_zero_before_k(arr, k)
print("Размер массива:", len(result))
print("Содержимое массива:", result)

Array102:

def insert_zero_after_k(arr, k):
    arr.insert(k, 0)
    return arr

# Пример использования
arr = [1, 2, 3, 4, 5]
k = 3
result = insert_zero_after_k(arr, k)
print("Размер массива:", len(result))
print("Содержимое массива:", result)

Array103:

def insert_zero_around_extremes(arr):
    min_index = arr.index(min(arr))
    max_index = arr.index(max(arr))
    arr.insert(min_index, 0)
    arr.insert(max_index + 1, 0)
    return arr

# Пример использования
arr = [1, 2, 3, 4, 5]
result = insert_zero_around_extremes(arr)
print("Размер массива:", len(result))
print("Содержимое массива:", result)

Array104:

def insert_zeros_before_k(arr, k, m):
    for _ in range(m):
        arr.insert(k - 1, 0)
    return arr

# Пример использования
arr = [1, 2, 3, 4, 5]
k = 3
m = 2
result = insert_zeros_before_k(arr, k, m)
print("Размер массива:", len(result))
print("Содержимое массива:", result)

Array105:

def insert_zeros_after_k(arr, k, m):
    for _ in range(m):
        arr.insert(k + 1, 0)
    return arr

# Пример использования
arr = [1, 2, 3, 4, 5]
k = 3
m = 2
result = insert_zeros_after_k(arr, k, m)
print("Размер массива:", len(result))
print("Содержимое массива:", result)

Array106:

def duplicate_even_elements(arr):
    for i in range(2, len(arr), 2):
        arr.insert(i, arr[i-1])
    return arr

# Пример использования
arr = [1, 2, 3, 4, 5]
result = duplicate_even_elements(arr)
print("Размер массива:", len(result))
print("Содержимое массива:", result)

Array107:

def remove_odd_elements(arr):
    for i in range(1, len(arr), 2):
        del arr[i]
    return arr

# Пример использования
arr = [1, 2, 3, 4, 5]
result = remove_odd_elements(arr)
print("Размер массива:", len(result))
print("Содержимое массива:", result)

Array108:

def insert_zero_before_positive_elements(arr):
    i = 0
    while i < len(arr):
        if arr[i] > 0:
            arr.insert(i, 0)
            i += 1
        i += 1
    return arr

# Пример использования
arr = [1, -2, 3, -4, 5]
result = insert_zero_before_positive_elements(arr)
print("Размер массива:", len(result))
print("Содержимое массива:", result)

Array109:

def insert_zero_after_negative_elements(arr):
    i = 0
    while i < len(arr):
        if arr[i] < 0:
            arr.insert(i+1, 0)
            i += 1
        i += 1
    return arr

# Пример использования
arr = [1, -2, 3, -4, 5]
result = insert_zero_after_negative_elements(arr)
print("Размер массива:", len(result))
print("Содержимое массива:", result)

Array110:

def duplicate_even_numbers(arr):
    for i in range(len(arr)):
        if arr[i] % 2 == 0:
            arr.insert(i, arr[i])
            i += 1
    return arr

# Пример использования
arr = [1, 2, 3, 4, 5]
result = duplicate_even_numbers(arr)
print("Размер массива:", len(result))
print("Содержимое массива:", result)

Array111:

def triple_odd_numbers(arr):
    for i in range(len(arr)):
        if arr[i] % 2 != 0:
            arr.insert(i, arr[i])
            arr.insert(i, arr[i])
            i += 2
    return arr

# Пример использования
arr = [1, 2, 3, 4, 5]
result = triple_odd_numbers(arr)
print("Размер массива:", len(result))
print("Содержимое массива:", result)

Array 112

def bubble_sort(arr):
    n = len(arr)
    for i in range(n-1):
        for j in range(n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
        print(arr)  # Выводим содержимое массива после каждого прохода
    return arr

# Пример использования
arr = [5, 3, 8, 2, 1]
sorted_arr = bubble_sort(arr)
print("Отсортированный массив:", sorted_arr)

Array 113

def selection_sort(arr):
    n = len(arr)
    for i in range(n-1):
        max_idx = i
        for j in range(i+1, n):
            if arr[j] > arr[max_idx]:
                max_idx = j
        arr[i], arr[max_idx] = arr[max_idx], arr[i]
        print(arr)
    return arr

# Пример использования
A = [5, 2, 8, 3, 1, 6]
sorted_A = selection_sort(A)

Array 114

def insertion_sort(arr):
    n = len(arr)
    for i in range(1, n):
        key = arr[i]
        j = i - 1
        while j >= 0 and arr[j] > key:
            arr[j + 1] = arr[j]
            j -= 1
        arr[j + 1] = key
        print(arr)
    return arr

# Пример использования
A = [5, 2, 8, 3, 1, 6]
sorted_A = insertion_sort(A)

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)