Array 17

def print_array_elements(array):
    start = 0
    end = len(array) - 1

    while start <= end:
        print(array[start], end=' ')
        if start != end:
            print(array[end], end=' ')
        start += 1
        end -= 1

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

Вывод:

1 10 2 9 3 8 4 7 5 6

Array18:

def find_element(A):
    for i in range(len(A)):
        if A[i] < A[9]:
            return A[i]
    return 0

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

Array19:

def find_index(A):
    for i in range(len(A)-1, 0, -1):
        if A[0] < A[i] < A[9]:
            return i
    return 0

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

Array20:

def sum_elements(A, K, L):
    total = 0
    for i in range(K-1, L):
        total += A[i]
    return total

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

Array21:

def find_average(arr, K, L):
    sub_array = arr[K-1:L]
    average = sum(sub_array) / len(sub_array)
    return average

# Пример использования функции
array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
K = 2
L = 6
result = find_average(array, K, L)
print("Среднее арифметическое элементов массива с номерами от", K, "до", L, "включительно:", result)

Array22:

def find_sum(arr, K, L):
    sub_array = arr[:K-1] + arr[L:]
    total_sum = sum(sub_array)
    return total_sum

# Пример использования функции
array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
K = 2
L = 6
result = find_sum(array, K, L)
print("Сумма всех элементов массива, кроме элементов с номерами от", K, "до", L, "включительно:", result)

Array23:

def find_average_except_range(arr, K, L):
    sub_array = arr[:K-1] + arr[L:]
    average = sum(sub_array) / len(sub_array)
    return average

# Пример использования функции
array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
K = 2
L = 6
result = find_average_except_range(array, K, L)
print("Среднее арифметическое всех элементов массива, кроме элементов с номерами от", K, "до", L, "включительно:", result)

Array24:

def check_arithmetic_progression(arr):
    diff = arr[1] - arr[0]
    for i in range(2, len(arr)):
        if arr[i] - arr[i-1] != diff:
            return 0
    return diff

# Пример использования функции
array = [1, 3, 5, 7, 9]
result = check_arithmetic_progression(array)
if result != 0:
    print("Элементы массива образуют арифметическую прогрессию с разностью:", result)
else:
    print("Элементы массива не образуют арифметическую прогрессию")

Array25:

def check_geometric_progression(arr):
    ratio = arr[1] / arr[0]
    for i in range(2, len(arr)):
        if arr[i] / arr[i-1] != ratio:
            return 0
    return ratio

# Пример использования функции
array = [2, 6, 18, 54, 162]
result = check_geometric_progression(array)
if result != 0:
    print("Элементы массива образуют геометрическую прогрессию со знаменателем:", result)
else:
    print("Элементы массива не образуют геометрическую прогрессию")

Array26:

def check_alternating_numbers(arr):
    for i in range(len(arr)):
        if i % 2 == 0 and arr[i] % 2 == 0:
            return i
        elif i % 2 == 1 and arr[i] % 2 == 1:
            return i
    return 0

# Пример использования функции
array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
result = check_alternating_numbers(array)
if result != 0:
    print("Числа в массиве не чередуются, первый нарушающий элемент находится на позиции:", result)
else:
    print("Числа в массиве чередуются")

Array27:

def check_alternating(arr):
    for i in range(len(arr)-1):
        if arr[i] * arr[i+1] > 0:
            return i+1
    return 0

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

array = [1, -2, 3, 4, 5, -6]
result = check_alternating(array)
print(result)  # Вывод: 4

Array28:

def find_min_even(arr):
    min_val = float('inf')
    for i in range(1, len(arr), 2):
        if arr[i] < min_val:
            min_val = arr[i]
    return min_val

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

Array29:

def find_max_odd(arr):
    max_val = float('-inf')
    for i in range(0, len(arr), 2):
        if arr[i] > max_val:
            max_val = arr[i]
    return max_val

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

Array30:

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

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

Array31:

def find_greater_than_left(arr):
    indices = [i for i in range(1, len(arr)) if arr[i] > arr[i-1]]
    return indices[::-1], len(indices)

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

Array32:

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

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

Array33:

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

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

Array34:

def find_max_local_minimum(arr):
    max_val = float('-inf')
    for i in range(1, len(arr)-1):
        if arr[i] < arr[i-1] and arr[i] < arr[i+1]:
            if arr[i] > max_val:
                max_val = arr[i]
    return max_val

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

Array32:

arr = [5, 2, 9, 1, 7, 4]
for i in range(len(arr)):
    if i == 0 and arr[i] < arr[i+1]:
        print(i)
        break
    elif i == len(arr)-1 and arr[i] < arr[i-1]:
        print(i)
        break
    elif arr[i] < arr[i-1] and arr[i] < arr[i+1]:
        print(i)
        break
else:
    print(-1)

Array33:

arr = [5, 2, 9, 1, 7, 4]
for i in range(len(arr)):
    if i == 0 and arr[i] > arr[i+1]:
        print(i)
        break
    elif i == len(arr)-1 and arr[i] > arr[i-1]:
        print(i)
        break
    elif arr[i] > arr[i-1] and arr[i] > arr[i+1]:
        print(i)
        break
else:
    print(-1)

Array34:

arr = [5, 2, 9, 1, 7, 4]
max_val = float('-inf')
for i in range(len(arr)):
    if i == 0 or i == len(arr)-1:
        continue
    if arr[i] < arr[i-1] and arr[i] < arr[i+1]:
        if arr[i] > max_val:
            max_val = arr[i]
print(max_val)

Надеюсь, это решение поможет вам решить задачи.

Array35:

def find_min_local_max(arr):
    min_local_max = float('inf')
    for i in range(1, len(arr)-1):
        if arr[i] > arr[i-1] and arr[i] > arr[i+1]:
            min_local_max = min(min_local_max, arr[i])
    return min_local_max

# Пример использования:
arr = [5, 2, 9, 1, 7, 4]
min_local_max = find_min_local_max(arr)
print(min_local_max)

Array36:

def find_max_not_min_max(arr):
    max_not_min_max = float('-inf')
    for i in range(len(arr)):
        if i == 0 or i == len(arr)-1:
            continue
        if arr[i] != max(arr[i-1], arr[i], arr[i+1]):
            max_not_min_max = max(max_not_min_max, arr[i])
    return max_not_min_max

# Пример использования:
arr = [5, 2, 9, 1, 7, 4]
max_not_min_max = find_max_not_min_max(arr)
print(max_not_min_max)

Array37:

def count_increasing_sections(arr):
    count = 0
    increasing = False
    for i in range(1, len(arr)):
        if arr[i] > arr[i-1]:
            if not increasing:
                count += 1
                increasing = True
        else:
            increasing = False
    return count

# Пример использования:
arr = [5, 2, 9, 1, 7, 4]
count = count_increasing_sections(arr)
print(count)

Array38:

def count_decreasing_sections(arr):
    count = 0
    for i in range(1, len(arr)):
        if arr[i] < arr[i-1]:
            count += 1
    return count

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

Array39:

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

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

Array40:

def find_closest_element(arr, R):
    min_diff = float('inf')
    closest_element = None
    for i in range(len(arr)):
        diff = abs(arr[i] - R)
        if diff < min_diff:
            min_diff = diff
            closest_element = arr[i]
    return closest_element

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

Array41:

def find_max_sum_pair(arr):
    max_sum = float('-inf')
    max_sum_pair = None
    for i in range(len(arr)-1):
        current_sum = arr[i] + arr[i+1]
        if current_sum > max_sum:
            max_sum = current_sum
            max_sum_pair = (arr[i], arr[i+1])
    return max_sum_pair

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

Array38:

def count_decreasing_sections(arr):
    count = 0
    for i in range(1, len(arr)):
        if arr[i] < arr[i-1]:
            count += 1
    return count

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

Array39:

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

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

Array40:

def find_closest_element(arr, R):
    min_diff = float('inf')
    closest_element = None
    for i in range(len(arr)):
        diff = abs(arr[i] - R)
        if diff < min_diff:
            min_diff = diff
            closest_element = arr[i]
    return closest_element

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

Array41:

def find_max_sum_pair(arr):
    max_sum = float('-inf')
    max_sum_pair = None
    for i in range(len(arr)-1):
        current_sum = arr[i] + arr[i+1]
        if current_sum > max_sum:
            max_sum = current_sum
            max_sum_pair = (arr[i], arr[i+1])
    return max_sum_pair

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

Array42:

arr = [1, 3, 5, 7, 9]
R = 6
closest_sum = float('inf')
closest_pair = None
for i in range(len(arr)-1):
    for j in range(i+1, len(arr)):
        current_sum = arr[i] + arr[j]
        if abs(current_sum - R) < abs(closest_sum - R):
            closest_sum = current_sum
            closest_pair = (arr[i], arr[j])
print(closest_pair)

Array43:

arr = [1, 2, 2, 3, 4, 4, 4, 5]
unique_elements = []
for element in arr:
    if element not in unique_elements:
        unique_elements.append(element)
print(len(unique_elements))

Array44:

arr = [1, 3, 5, 2, 7, 4, 5]
duplicate_indices = []
for i in range(len(arr)):
    for j in range(i+1, len(arr)):
        if arr[i] == arr[j] and i not in duplicate_indices:
            duplicate_indices.extend([i, j])
duplicate_indices.sort()
print(duplicate_indices)

Array45. Для решения данной задачи можно использовать следующий алгоритм:

1. Инициализировать переменные minDiff и index1, index2 со значениями, которые гарантированно не встречаются в массиве.
2. Проходить по массиву и для каждого элемента выполнять следующие шаги:
- Если разность между текущим элементом и предыдущим элементом меньше minDiff, то обновить minDiff и сохранить индексы текущего и предыдущего элементов в index1 и index2 соответственно.
3. Вывести значения index1 и index2 в порядке возрастания.

Пример кода на Python:

def find_closest_elements(arr):
    minDiff = float('inf')
    index1, index2 = -1, -1

    for i in range(1, len(arr)):
        diff = abs(arr[i] - arr[i-1])
        if diff < minDiff:
            minDiff = diff
            index1 = i-1
            index2 = i

    return index1, index2

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

Array46. Для решения данной задачи можно использовать следующий алгоритм:

1. Инициализировать переменные minDiff и index1, index2 со значениями, которые гарантированно не встречаются в массиве.
2. Проходить по массиву и для каждого элемента выполнять следующие шаги:
- Если разность между текущим элементом и числом R меньше minDiff, то обновить minDiff и сохранить индекс текущего элемента в index1.
- Если разность между текущим элементом и числом R равна minDiff, то обновить index2 на текущий индекс.
3. Вывести значения index1 и index2 в порядке возрастания.

Пример кода на Python:

def find_closest_sum_elements(arr, R):
    minDiff = float('inf')
    index1, index2 = -1, -1

    for i in range(len(arr)):
        diff = abs(arr[i] - R)
        if diff < minDiff:
            minDiff = diff
            index1 = i
            index2 = -1
        elif diff == minDiff:
            index2 = i

    return index1, index2

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

Array47. Для решения данной задачи можно использовать множество (set) для хранения уникальных элементов массива. Затем можно вернуть размер этого множества.

Пример кода на Python:

def count_unique_elements(arr):
    unique_elements = set(arr)
    return len(unique_elements)

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

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.