Array48.

def find_max_same_elements(arr):
    count_dict = {}
    max_count = 0

    for num in arr:
        if num in count_dict:
            count_dict[num] += 1
        else:
            count_dict[num] = 1

        if count_dict[num] > max_count:
            max_count = count_dict[num]

    return max_count

# Пример использования
array = [1, 5, 9, 2, 7, 5, 9, 5]
max_count = find_max_same_elements(array)
print(max_count)  # Выведет: 3

Array49.

def check_permutation(arr):
    n = len(arr)
    check_array = [0] * n

    for num in arr:
        if num < 1 or num > n:
            return arr.index(num) + 1
        check_array[num-1] = 1

    if 0 in check_array:
        return check_array.index(0) + 1
    else:
        return 0

# Пример использования
array1 = [1, 5, 3, 2, 4]
array2 = [1, 5, 3, 2, 2]
result1 = check_permutation(array1)
result2 = check_permutation(array2)
print(result1)  # Выведет: 0
print(result2)  # Выведет: 5

Array50.

def count_inversions(arr):
    if len(arr) <= 1:
        return 0

    mid = len(arr) // 2
    left = arr[:mid]
    right = arr[mid:]

    inversions = count_inversions(left) + count_inversions(right)

    i = j = k = 0
    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            arr[k] = left[i]
            i += 1
        else:
            arr[k] = right[j]
            j += 1
            inversions += len(left) - i
        k += 1

    while i < len(left):
        arr[k] = left[i]
        i += 1
        k += 1

    while j < len(right):
        arr[k] = right[j]
        j += 1
        k += 1

    return inversions

# Пример использования
array = [2, 4, 1, 3, 5]
inversions = count_inversions(array)
print(inversions)  # Выведет: 3

В данном примере массив [2, 4, 1, 3, 5] содержит 3 инверсии: (2, 1), (4, 1) и (4, 3).

Array51.

def swap_arrays(a, b):
    temp = a.copy()
    a = b.copy()
    b = temp.copy()
    return a, b

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

A, B = swap_arrays(A, B)

print("Преобразованный массив A:", A)
print("Преобразованный массив B:", B)

Array52.

def transform_array(A):
    B = []
    for element in A:
        if element < 5:
            B.append(element / 2)
        else:
            B.append(2 * element)
    return B

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

print("Массив B:", B)

Array53.

def max_array(A, B):
    C = []
    for i in range(len(A)):
        C.append(max(A[i], B[i]))
    return C

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

print("Массив C:", C)

Array54.

def even_numbers(A):
    B = []
    for num in A:
        if num % 2 == 0:
            B.append(num)
    return B

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

print("Размер массива B:", len(B))
print("Содержимое массива B:", B)

Array55.

def odd_index_numbers(A):
    B = A[1::2]
    return B

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

print("Размер массива B:", len(B))
print("Содержимое массива B:", B)

Array56.

def multiple_of_three(A):
    B = A[2::3]
    return B

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

print("Размер массива B:", len(B))
print("Содержимое массива B:", B)

Array 57

def rearrange_array(A):
    even_elements = A[1::2]  # Четные элементы с нечетными индексами
    odd_elements = A[0::2]  # Нечетные элементы с четными индексами
    B = even_elements + odd_elements  # Объединяем элементы в новом порядке
    return B

# Пример использования
A = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
B = rearrange_array(A)
print(B)  # Вывод: [2, 1, 4, 3, 6, 5, 8, 7, 10, 9]

Array58:

def calculate_sum_array(A):
    B = [0] * len(A)  # Создаем новый массив B с нулевыми значениями
    B[0] = A[0]  # Первый элемент B равен первому элементу A
    for i in range(1, len(A)):
        B[i] = B[i-1] + A[i]  # Суммируем элементы A от 1 до i и присваиваем значение элементу B[i]
    return B

# Пример использования
A = [1, 2, 3, 4, 5]
B = calculate_sum_array(A)
print(B)  # Вывод: [1, 3, 6, 10, 15]

Array59:

def calculate_average_array(A):
    B = [0] * len(A)  # Создаем новый массив B с нулевыми значениями
    B[0] = A[0]  # Первый элемент B равен первому элементу A
    for i in range(1, len(A)):
        B[i] = sum(A[:i+1]) / (i+1)  # Вычисляем среднее арифметическое элементов A от 1 до i и присваиваем значение элементу B[i]
    return B

# Пример использования
A = [1, 2, 3, 4, 5]
B = calculate_average_array(A)
print(B)  # Вывод: [1.0, 1.5, 2.0, 2.5, 3.0]

Array 60:

def calculate_reverse_sum_array(A):
    B = [0] * len(A)  # Создаем новый массив B с нулевыми значениями
    B[-1] = A[-1]  # Последний элемент B равен последнему элементу A
    for i in range(len(A)-2, -1, -1):
        B[i] = B[i+1] + A[i]  # Суммируем элементы A от i до N и присваиваем значение элементу B[i]
    return B

# Пример использования
A = [1, 2, 3, 4, 5]
B = calculate_reverse_sum_array(A)
print(B)  # Вывод: [15, 14, 12, 9, 5]

Array61:

def calculate_average_array(A):
    B = [0] * len(A)  # Создаем новый массив B с нулевыми значениями
    for k in range(len(A)):
        B[k] = sum(A[k:]) / (len(A) - k)  # Вычисляем среднее арифметическое элементов A с номерами от k до N и присваиваем значение элементу B[k]
    return B

# Пример использования
A = [1, 2, 3, 4, 5]
B = calculate_average_array(A)
print(B)  # Вывод: [3.0, 3.3333333333333335, 3.6666666666666665, 4.0, 5.0]

Array62:

def separate_positive_negative(A):
    B = []  # Создаем новый массив B для положительных элементов
    C = []  # Создаем новый массив C для отрицательных элементов
    for num in A:
        if num > 0:
            B.append(num)  # Добавляем положительный элемент в массив B
        elif num < 0:
            C.append(num)  # Добавляем отрицательный элемент в массив C
    return B, C

# Пример использования
A = [1, -2, 3, -4, 5]
B, C = separate_positive_negative(A)
print(len(B), B)  # Вывод: 3 [1, 3, 5]
print(len(C), C)  # Вывод: 2 [-2, -4]

Array63:

def merge_arrays(A, B):
    C = sorted(A + B)  # Объединяем массивы A и B и сортируем полученный массив C по возрастанию
    return C

# Пример использования
A = [1, 3, 5, 7, 9]
B = [2, 4, 6, 8, 10]
C = merge_arrays(A, B)
print(C)  # Вывод: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Array64:

def merge_arrays(A, B, C):
    D = sorted(A + B + C, reverse=True)  # Объединяем массивы A, B и C и сортируем полученный массив D по убыванию
    return D

# Пример использования
A = [9, 7, 5, 3, 1]
B = [10, 8, 6, 4, 2]
C = [15, 13, 11]
D = merge_arrays(A, B, C)
print(D)  # Вывод: [15, 13, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

В первом примере мы объединяем массивы A и B с помощью оператора "+", а затем сортируем полученный массив C по возрастанию с помощью функции sorted().

Во втором примере мы объединяем массивы A, B и C с помощью оператора "+", а затем сортируем полученный массив D по убыванию с помощью функции sorted() и параметра reverse=True.

Array 65

def increase_array_elements(arr, k):
    value = arr[k-1]  # Сохраняем значение элемента A[K]
    for i in range(len(arr)):
        arr[i] += value  # Увеличиваем каждый элемент на значение value
    return arr

# Пример использования
A = [1, 2, 3, 4, 5]
K = 3
result = increase_array_elements(A, K)
print(result)  # Вывод: [4, 5, 6, 7, 8]

Array66:

def increase_even_numbers(arr):
    first_even = None
    for i in range(len(arr)):
        if arr[i] % 2 == 0:  # Проверяем, является ли текущий элемент четным
            if first_even is None:  # Если первое четное число еще не найдено
                first_even = arr[i]  # Присваиваем значение текущего элемента переменной first_even
            else:
                arr[i] += first_even  # Увеличиваем текущий элемент на значение first_even
    return arr

# Пример использования
arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
result = increase_even_numbers(arr)
print(result)  # Вывод: [1, 4, 3, 8, 5, 12, 7, 16, 9, 20]

Array67:

def increase_odd_numbers(arr):
    last_odd = None
    for i in range(len(arr)):
        if arr[i] % 2 != 0:  # Проверяем, является ли текущий элемент нечетным
            last_odd = arr[i]  # Присваиваем значение текущего элемента переменной last_odd
    for i in range(len(arr)):
        if arr[i] % 2 != 0:  # Проверяем, является ли текущий элемент нечетным
            arr[i] += last_odd  # Увеличиваем текущий элемент на значение last_odd
    return arr

# Пример использования
arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
result = increase_odd_numbers(arr)
print(result)  # Вывод: [2, 2, 6, 4, 10, 6, 14, 8, 18, 10]

Array68:

def swap_min_max(arr):
    min_index = 0
    max_index = 0
    for i in range(len(arr)):
        if arr[i] < arr[min_index]:  # Проверяем, является ли текущий элемент минимальным
            min_index = i  # Присваиваем текущий индекс переменной min_index
        if arr[i] > arr[max_index]:  # Проверяем, является ли текущий элемент максимальным
            max_index = i  # Присваиваем текущий индекс переменной max_index
    arr[min_index], arr[max_index] = arr[max_index], arr[min_index]  # Меняем местами минимальный и максимальный элементы
    return arr

# Пример использования
arr = [5, 2, 8, 1, 9, 3]
result = swap_min_max(arr)
print(result)  # Вывод: [5, 9, 8, 1, 2, 3]

Array69:

def swap_elements(arr):
    for i in range(0, len(arr), 2):
        arr[i], arr[i+1] = arr[i+1], arr[i]
    return arr

# Пример использования
A = [1, 2, 3, 4, 5, 6]
result = swap_elements(A)
print(result)  # Вывод: [2, 1, 4, 3, 6, 5]

Array70:

def swap_halves(arr):
    mid = len(arr) // 2
    arr[:mid], arr[mid:] = arr[mid:], arr[:mid]
    return arr

# Пример использования
A = [1, 2, 3, 4, 5, 6]
result = swap_halves(A)
print(result)  # Вывод: [4, 5, 6, 1, 2, 3]

Array71:

def reverse_array(arr):
    return arr[::-1]

# Пример использования
A = [1, 2, 3, 4, 5, 6]
result = reverse_array(A)
print(result)  # Вывод: [6, 5, 4, 3, 2, 1]

Array72:

def reverse_elements_between(arr, K, L):
    arr[K:L+1] = arr[K:L+1][::-1]
    return arr

# Пример использования
A = [1, 2, 3, 4, 5, 6]
K = 2
L = 4
result = reverse_elements_between(A, K, L)
print(result)  # Вывод: [1, 2, 5, 4, 3, 6]

Array73:

def reverse_elements_excluding(arr, K, L):
    arr[K+1:L] = arr[K+1:L][::-1]
    return arr

# Пример использования
A = [1, 2, 3, 4, 5, 6]
K = 2
L = 4
result = reverse_elements_excluding(A, K, L)
print(result)  # Вывод: [1, 2, 4, 3, 5, 6]

Array 74

def zero_between_min_max(arr):
    min_index = arr.index(min(arr))
    max_index = arr.index(max(arr))
    start = min(min_index, max_index) + 1
    end = max(min_index, max_index)
    for i in range(start, end):
        arr[i] = 0
    return arr

# Пример использования
A = [1, 2, 3, 4, 5, 6]
result = zero_between_min_max(A)
print(result)  # Вывод: [1, 2, 0, 0, 0, 6]

Array75.

def reverse_between_min_max(arr):
    min_index = arr.index(min(arr))
    max_index = arr.index(max(arr))
    start = min(min_index, max_index)
    end = max(min_index, max_index)
    arr[start:end+1] = arr[start:end+1][::-1]
    return arr

# Пример использования
A = [1, 2, 3, 4, 5, 6]
result = reverse_between_min_max(A)
print(result)  # Вывод: [1, 6, 5, 4, 3, 2]

Array76.

def zero_local_maxima(arr):
    for i in range(1, len(arr)-1):
        if arr[i] > arr[i-1] and arr[i] > arr[i+1]:
            arr[i] = 0
    return arr

# Пример использования
A = [1, 2, 3, 2, 5, 4, 6]
result = zero_local_maxima(A)
print(result)  # Вывод: [1, 2, 3, 0, 5, 4, 6]

Array77.

def square_local_minima(arr):
    for i in range(1, len(arr)-1):
        if arr[i] < arr[i-1] and arr[i] < arr[i+1]:
            arr[i] = arr[i] ** 2
    return arr

# Пример использования
A = [1, 2, 3, 2, 5, 4, 6]
result = square_local_minima(A)
print(result)  # Вывод: [1, 2, 9, 2, 5, 4, 6]

Array78.

def replace_with_average(arr):
    for i in range(1, len(arr)-1):
        average = (arr[i-1] + arr[i] + arr[i+1]) / 3
        arr[i] = average
    return arr

# Пример использования
A = [1, 2, 3, 4, 5]
result = replace_with_average(A)
print(result)  # Вывод: [1, 2.0, 3.0, 4.0, 5]

Array 79

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

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

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

[0, 1, 2, 3, 4]

Array80:

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

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

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

[2, 3, 4, 5, 0]

Array81:

def shift_array_right_k(arr, K):
    new_array = [0] * len(arr)  # создаем новый массив с нулевыми значениями
    for i in range(K, len(arr)):
        new_array[i] = arr[i-K]  # копируем последние N-K элементов
    for i in range(K):
        new_array[i] = 0  # первые K элементов равны 0
    return new_array

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

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

[0, 0, 0, 1, 2, 3]

Array82:

def shift_array_left_k(arr, K):
    N = len(arr)
    new_array = [0] * N  # создаем новый массив с нулевыми значениями
    for i in range(N-K):
        new_array[i] = arr[i+K]  # сдвигаем элементы влево
    return new_array

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

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

[3, 4, 5, 0, 0]

Array83:

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

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

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

[5, 1, 2, 3, 4]

Array84:

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

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

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

[2, 3, 4, 5, 1]

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)