Proc42

import math

def Cos1(x, epsilon):
    summation = 1
    term = 1
    factorial = 1
    sign = -1
    power = 2
    
    while abs(term) > epsilon:
        factorial *= power * (power - 1)
        term *= x * x / factorial
        summation += sign * term
        sign *= -1
        power += 2
    
    return summation

Proc43

def LnI(x, epsilon):
    summation = x
    term = x
    power = 2
    sign = -1
    
    while abs(term) > epsilon:
        term *= x * sign / power
        summation += term
        power += 1
        sign *= -1
    
    return summation

```
# Пример использования функций для нахождения приближенных значений

x = 0.5
epsilons = [0.1, 0.01, 0.001, 0.0001, 0.00001, 0.000001]

for epsilon in epsilons:
cos_approx = Cos1(x, epsilon)
ln_approx = LnI(x, epsilon)
cos_exact = math.cos(x)
ln_exact = math.log(1 + x)

print(f"При epsilon = {epsilon}:")
print(f"Приближенное значение cos({x}) = {cos_approx}")
print(f"Точное значение cos({x}) = {cos_exact}")
print(f"Приближенное значение ln(1 + {x}) = {ln_approx}")
print(f"Точное значение ln(1 + {x}) = {ln_exact}")
print()
`

Proc 44

import math

def Arctg1(x, epsilon):
    result = 0
    term = x
    n = 1
    
    while abs(term) >= epsilon:
        result += term
        term = (-1) ** n * (x ** (2 * n + 1)) / (2 * n + 1)
        n += 1
    
    return result

Proc45

def Power4(x, a, epsilon):
    result = 1
    term = 1
    n = 1
    
    while abs(term) >= epsilon:
        result += term
        term = a * (a - 1) * ... * (a - n + 1) * (x ** n) / math.factorial(n)
        n += 1
    
    return result

Proc46
Функция NOD2, реализующая алгоритм Евклида для нахождения наибольшего общего делителя (НОД) двух целых положительных чисел A и B, может быть описана следующим образом:

def NOD2(A, B):
    while B != 0:
        A, B = B, A % B
    return A

Для нахождения наибольшего общего делителя пар (A, B), (A, C), (A, D), где даны числа A, B, C, D, можно использовать функцию NOD2 следующим образом:

A = 24
B = 36
C = 48
D = 60

NOD_AB = NOD2(A, B)
NOD_AC = NOD2(A, C)
NOD_AD = NOD2(A, D)

print("НОД(A, B) =", NOD_AB)
print("НОД(A, C) =", NOD_AC)
print("НОД(A, D) =", NOD_AD)

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

НОД(A, B) = 12
НОД(A, C) = 24
НОД(A, D) = 12

Таким образом, наибольшие общие делители пар (A, B), (A, C), (A, D) равны 12, 24 и 12 соответственно.

Proc47

Вот описание процедуры Fracl на языке программирования:

def Fracl(a, b, p, q):
    nod = NOD2(a, b)
    p = a // nod
    q = b // nod
    if q < 0:
        p = -p
        q = -q

В этой процедуре сначала вычисляется наибольший общий делитель nod с помощью функции NOD2. Затем числитель p присваивается результату деления a на nod, а знаменатель q присваивается результату деления b на nod. Если знаменатель q отрицателен, то меняем знак числителя p и знаменателя q, чтобы знак результирующей дроби был приписан числителю.

С помощью процедуры Fracl можно найти несократимые дроби, равные a / b + c / d, a / b + e / f и a / b + g / h, где a, b, c, d, e, f, g, h - заданные числа.

Proc48. Для решения этой задачи с использованием функции NOD2 из задания Proc46, опишем функцию NOK2(A, B), которая будет находить наименьшее общее кратное чисел A и B.

def NOD2(A, B):
    while B != 0:
        A, B = B, A % B
    return A

def NOK2(A, B):
    GCD = NOD2(A, B)
    return A * (B // GCD)

Для нахождения наименьших общих кратных пар (A, B), (A, C), (A, D), где даны числа A, B, C, D, можно вызвать функцию NOK2 для каждой пары чисел:

NOK_AB = NOK2(A, B)
NOK_AC = NOK2(A, C)
NOK_AD = NOK2(A, D)

Теперь переменные NOK_AB, NOK_AC и NOK_AD содержат наименьшие общие кратные пар (A, B), (A, C), (A, D) соответственно.

Proc49. Для решения этой задачи с использованием функции NOD2 из задания Proc46, опишем функцию NOD3(A, B, C), которая будет находить наибольший общий делитель трех чисел A, B, C.

def NOD3(A, B, C):
    GCD_AB = NOD2(A, B)
    GCD = NOD2(GCD_AB, C)
    return GCD

Для нахождения наибольших общих делителей троек (A, B, C), (A, C, D) и (B, C, D), где даны числа A, B, C, D, можно вызвать функцию NOD3 для каждой тройки чисел:

NOD_ABC = NOD3(A, B, C)
NOD_ACD = NOD3(A, C, D)
NOD_BCD = NOD3(B, C, D)

Теперь переменные NOD_ABC, NOD_ACD и NOD_BCD содержат наибольшие общие делители троек (A, B, C), (A, C, D) и (B, C, D) соответственно.

Proc50. Для решения этой задачи опишем процедуру TimeToHMS(T, H, M, S), которая будет определять по времени T (в секундах) количество часов H, минут M и секунд S.

def TimeToHMS(T):
    H = T // 3600
    T %= 3600
    M = T // 60
    S = T % 60
    return H, M, S

Для каждого отрезка времени T1, T2, ..., T5 можно вызвать процедуру TimeToHMS и передать соответствующее значение времени T:

H1, M1, S1 = TimeToHMS(T1)
H2, M2, S2 = TimeToHMS(T2)
...
H5, M5, S5 = TimeToHMS(T5)

Proc51. Для решения этой задачи с использованием функции IncTime(H, M, S, T), опишем процедуру IncTime, которая будет увеличивать время на заданное количество секунд.

def IncTime(H, M, S, T):
    S += T
    M += S // 60
    S %= 60
    H += M // 60
    M %= 60
    H %= 24
    return H, M, S

Теперь можно вызвать процедуру IncTime, передав значения часов H, минут M, секунд S и количество секунд T:

H, M, S = IncTime(H, M, S, T)

Теперь переменные H, M и S содержат новые значения часов, минут и секунд соответственно.

Proc52. Для решения этой задачи с использованием функции IsLeapYear(Y), опишем функцию IsLeapYear, которая будет проверять, является ли заданный год високосным.

def IsLeapYear(Y):
    if Y % 4 == 0 and (Y % 100 != 0 or Y % 400 == 0):
        return True
    else:
        return False

Теперь можно вызвать функцию IsLeapYear для каждого из пяти заданных значений года Y:

leap_year1 = IsLeapYear(Y1)
leap_year2 = IsLeapYear(Y2)
...
leap_year5 = IsLeapYear(Y5)

Теперь переменные leap_year1, leap_year2, ..., leap_year5 содержат значения True, если соответствующий год является високосным, и False в противном случае.

Proc53:

def IsLeapYear(Y):
    if Y % 4 == 0 and (Y % 100 != 0 or Y % 400 == 0):
        return True
    else:
        return False

def MonthDays(M, Y):
    if M < 1 or M > 12 or Y <= 0:
        # Обработка ошибки или возврат значения по умолчанию
        return -1
    else:
        if M in [1, 3, 5, 7, 8, 10, 12]:
            return 31
        elif M in [4, 6, 9, 11]:
            return 30
        elif M == 2:
            if IsLeapYear(Y):
                return 29
            else:
                return 28
        else:
            # Обработка ошибки или возврат значения по умолчанию
            return -1

Proc54:

def PrevDate(D, M, Y):
    if D < 1 or D > 31 or M < 1 or M > 12 or Y <= 0:
        # Обработка ошибки или завершение процедуры
        return
    else:
        D -= 1
        if D < 1:
            M -= 1
            if M < 1:
                M = 12
                Y -= 1
            D = MonthDays(M, Y)
    return D, M, Y

Proc55:

def NextDate(D, M, Y):
    if D < 1 or D > 31 or M < 1 or M > 12 or Y <= 0:
        # Обработка ошибки или завершение процедуры
        return
    else:
        D += 1
        if D > MonthDays(M, Y):
            D = 1
            M += 1
            if M > 12:
                M = 1
                Y += 1
    return D, M, Y

Примечание: В этих примерах предполагается, что функция IsLeapYear корректно реализована.

Proc56:

import math

def Leng(xA, yA, xB, yB):
    return math.sqrt((xA - xB)**2 + (yA - yB)**2)

Proc57:

def Perim(xA, yA, xB, yB, xC, yC):
    AB = Leng(xA, yA, xB, yB)
    BC = Leng(xB, yB, xC, yC)
    CA = Leng(xC, yC, xA, yA)
    return AB + BC + CA

Proc58:

def Area(xA, yA, xB, yB, xC, yC):
    AB = Leng(xA, yA, xB, yB)
    BC = Leng(xB, yB, xC, yC)
    CA = Leng(xC, yC, xA, yA)
    p = Perim(xA, yA, xB, yB, xC, yC) / 2
    return math.sqrt(p * (p - AB) * (p - BC) * (p - CA))

Примечание: В этих примерах предполагается, что значения координат точек A, B, C, D корректно передаются в функции Leng, Perim и Area.

Proc59:

def Dist(xP, yP, xA, yA, xB, yB):
    S_PAB = Area(xP, yP, xA, yA, xB, yB)
    AB = Leng(xA, yA, xB, yB)
    D = 2 * S_PAB / AB
    return D

# Пример использования функции Dist
Dist_AB = Dist(xP, yP, xA, yA, xB, yB)
Dist_AC = Dist(xP, yP, xA, yA, xC, yC)
Dist_BC = Dist(xP, yP, xB, yB, xC, yC)

Proc60:

def Heights(xA, yA, xB, yB, xC, yC):
    hA = Dist(xA, yA, xB, yB, xC, yC)
    hB = Dist(xB, yB, xA, yA, xC, yC)
    hC = Dist(xC, yC, xA, yA, xB, yB)
    return hA, hB, hC

# Пример использования процедуры Heights
hA_ABC, hB_ABC, hC_ABC = Heights(xA, yA, xB, yB, xC, yC)
hA_ABD, hB_ABD, hD_ABD = Heights(xA, yA, xB, yB, xD, yD)
hA_ACD, hC_ACD, hD_ACD = Heights(xA, yA, xC, yC, xD, yD)

Array1.

N = int(input("Введите целое число N: "))

array = [0] * N
num = 1

for i in range(N):
    array[i] = num
    num += 2

print("Сформированный массив:", array)

Array2.

N = int(input("Введите целое число N: "))

array = [0] * N
num = 1

for i in range(N):
    array[i] = num
    num *= 2

print("Сформированный массив:", array)

Array3.

N = int(input("Введите целое число N: "))
A = int(input("Введите первый член прогрессии A: "))
D = int(input("Введите разность прогрессии D: "))

array = [0] * N
current = A

for i in range(N):
    array[i] = current
    current += D

print("Сформированный массив:", array)

Array4.

N = int(input("Введите целое число N (>1): "))
A = int(input("Введите первый член геометрической прогрессии A: "))
D = int(input("Введите знаменатель геометрической прогрессии D: "))

progression = [A]  # Создаем пустой массив с первым элементом A

for i in range(1, N):
    progression.append(progression[i-1] * D)  # Добавляем следующий элемент в массив, умножая предыдущий на D

print("Массив размера N, содержащий N первых членов геометрической прогрессии:")
print(progression)

Array5.

N = int(input("Введите целое число N (>2): "))

fibonacci = [1, 1]  # Создаем массив с первыми двумя элементами

for i in range(2, N):
    fibonacci.append(fibonacci[i-2] + fibonacci[i-1])  # Добавляем следующий элемент в массив, равный сумме двух предыдущих

print("Целочисленный массив размера N, содержащий N первых элементов последовательности чисел Фибоначчи:")
print(fibonacci)

Array6.

N = int(input("Введите целое число N (>2): "))
A = int(input("Введите первый элемент A: "))
B = int(input("Введите второй элемент B: "))

sequence = [A, B]  # Создаем массив с первыми двумя элементами

for i in range(2, N):
    sequence.append(sum(sequence))  # Добавляем следующий элемент в массив, равный сумме всех предыдущих

print("Целочисленный массив размера N, первый элемент которого равен A, второй равен B, а каждый последующий элемент равен сумме всех предыдущих:")
print(sequence)

Array 7.

def reverse_array(arr):
    for i in range(len(arr)-1, -1, -1):
        print(arr[i])

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

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

5
4
3
2
1

Array 8.

def print_odd_numbers(arr):
    count = 0
    for i in range(len(arr)):
        if arr[i] % 2 != 0:
            print(arr[i])
            count += 1
    print("Количество нечетных чисел:", count)

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

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

1
3
5
Количество нечетных чисел: 3

Array 9.

def print_even_numbers(arr):
    count = 0
    for i in range(len(arr)-1, -1, -1):
        if arr[i] % 2 == 0:
            print(arr[i])
            count += 1
    print("Количество четных чисел:", count)

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

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

4
2
Количество четных чисел: 2

Array10.

def print_even_odd(arr):
    even_nums = [num for i, num in enumerate(arr) if i % 2 == 0 and num % 2 == 0]
    odd_nums = [num for i, num in enumerate(arr[::-1]) if i % 2 == 0 and num % 2 != 0]
    
    result = even_nums + odd_nums[::-1]
    
    for num in result:
        print(num, end=' ')

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

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

2 4 6 8 10 9 7 5 3 1

Array11.

def print_elements(arr, k):
    result = [arr[i-1] for i in range(k, len(arr)+1, k)]
    
    print(*result)

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

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

3 6 9

Array12.

def print_even_elements(arr):
    result = [arr[i] for i in range(1, len(arr), 2)]
    
    print(*result)

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

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

2 4 6 8 10

Array10. Вот другое решение задачи:

def print_even_odd(arr):
    even_nums = []
    odd_nums = []
    
    for num in arr:
        if num % 2 == 0:
            even_nums.append(num)
        else:
            odd_nums.append(num)
    
    even_nums.sort()
    odd_nums.sort(reverse=True)
    
    result = even_nums + odd_nums
    
    for num in result:
        print(num, end=' ')

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

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

2 4 6 8 10 9 7 5 3 1

Array11. Вот другое решение задачи:

def print_elements(arr, k):
    result = []
    
    for i in range(k-1, len(arr), k):
        result.append(arr[i])
    
    print(*result)

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

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

3 6 9

Array12. Вот другое решение задачи:

def print_even_elements(arr):
    result = []
    
    for i in range(1, len(arr), 2):
        result.append(arr[i])
    
    print(*result)

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

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

2 4 6 8 10

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

Array13.

N = len(A)
for i in range(N-1, 0, -2):
    print(A[i])

Array14.

N = len(A)
for i in range(1, N, 2):
    print(A[i])
for i in range(0, N, 2):
    print(A[i])

Array15.

def print_array_elements(array):
    n = len(array)
    # Вывод элементов с нечетными индексами в порядке возрастания
    for i in range(0, n, 2):
        print(array[i], end=' ')
    # Вывод элементов с четными индексами в порядке убывания
    for i in range(n-1, 0, -2):
        print(array[i], end=' ')

# Пример использования функции
A = [1, 2, 3, 4, 5, 6]
print_array_elements(A)

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

1 3 5 6 4 2

Array16.

def print_array_elements(array):
    n = len(array)
    # Вывод элементов массива в нужном порядке
    for i in range(n):
        if i % 2 == 0:
            print(array[i // 2], end=' ')
        else:
            print(array[n - (i // 2) - 1], end=' ')

# Пример использования функции
A = [1, 2, 3, 4, 5, 6]
print_array_elements(A)

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

1 6 2 5 3 4

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)