Proc26

def IsPower5(K):
    while K > 1:
        if K % 5 != 0:
            return False
        K = K / 5
    return True

Для нахождения количества степеней числа 5 в наборе из 10 целых положительных чисел, мы можем использовать эту функцию. Просто пройдемся по каждому числу в наборе и проверим, является ли оно степенью числа 5. Если да, увеличим счетчик на 1.

numbers = [10, 25, 30, 125, 150, 625, 750, 3125, 3750, 15625]
count = 0

for number in numbers:
    if IsPower5(number):
        count += 1

print("Количество степеней числа 5 в наборе:", count)

В этом примере мы создали список numbers, содержащий 10 целых положительных чисел. Затем мы проходимся по каждому числу в списке и используем функцию IsPower5 для проверки, является ли оно степенью числа 5. Если да, увеличиваем счетчик count на 1. В конце выводим количество степеней числа 5 в наборе.

Proc27.

def IsPowerN(K, N):
    power = 0
    while K % N == 0:
        K = K / N
        power += 1
    return K == 1

N = 2
numbers = [16, 8, 5, 32, 9, 64, 7, 128, 256, 1024]
count = 0

for num in numbers:
    if IsPowerN(num, N):
        count += 1

print("Количество степеней числа", N, "в данном наборе:", count)

В данном примере, функция IsPowerN проверяет, является ли каждое число в наборе степенью числа N=2. Затем, мы считаем количество чисел, для которых условие выполняется, и выводим результат. В данном случае, результат будет равен 6, так как числа 16, 8, 32, 64, 128 и 256 являются степенями числа 2.

Proc28.

def IsPrime(N):
    if N <= 1:
        return False
    for i in range(2, N):
        if N % i == 0:
            return False
    return True

numbers = [16, 8, 5, 32, 9, 64, 7, 128, 256, 1024]
count = 0

for num in numbers:
    if IsPrime(num):
        count += 1

print("Количество простых чисел в данном наборе:", count)

В данном примере, функция IsPrime проверяет, является ли каждое число в наборе простым. Затем, мы считаем количество чисел, для которых условие выполняется, и выводим результат. В данном случае, результат будет равен 1, так как только число 7 является простым числом.

Proc29

def DigitCount(K):
    count = 0
    while K > 0:
        count += 1
        K //= 10
    return count

# Пример использования функции
number1 = 12345
number2 = 987654321
number3 = 100
number4 = 9999
number5 = 1

count1 = DigitCount(number1)
count2 = DigitCount(number2)
count3 = DigitCount(number3)
count4 = DigitCount(number4)
count5 = DigitCount(number5)

print("Количество цифр в числе", number1, ":", count1)
print("Количество цифр в числе", number2, ":", count2)
print("Количество цифр в числе", number3, ":", count3)
print("Количество цифр в числе", number4, ":", count4)
print("Количество цифр в числе", number5, ":", count5)

Вывод:

Количество цифр в числе 12345 : 5
Количество цифр в числе 987654321 : 9
Количество цифр в числе 100 : 3
Количество цифр в числе 9999 : 4
Количество цифр в числе 1 : 1

Таким образом, функция DigitCount(K) находит количество цифр в заданном целом положительном числе K, а затем используется для нахождения количества цифр в каждом из пяти данных чисел.

Proc29

def DigitCount(K):
    count = 0
    while K > 0:
        count += 1
        K //= 10
    return count

Proc30

def DigitN(K, N):
    count = 0
    while K > 0 and count < N:
        count += 1
        digit = K % 10
        K //= 10
    if count < N:
        return -1
    return digit

Proc31

def IsPalindrom(K):
    count = DigitCount(K)
    i = 1
    isPalindrom = True
    while i <= count // 2:
        digit1 = DigitN(K, i)
        digit2 = DigitN(K, count - i + 1)
        if digit1 != digit2:
            isPalindrom = False
            break
        i += 1
    return isPalindrom

# Пример использования функций

# Пример использования функции DigitCount
count = DigitCount(12345)
print(count) # Вывод: 5

# Пример использования функции DigitN
digit = DigitN(12345, 3)
print(digit) # Вывод: 3

# Пример использования функции IsPalindrom
isPalindrom = IsPalindrom(12321)
print(isPalindrom) # Вывод: True`

Proc32.

Пример использования функции DegToRad(D)

def DegToRad(D):
    return D * 3.14 / 180

angle_degrees = 45
angle_radians = DegToRad(angle_degrees)
print(angle_radians)  # Выводит: 0.7853981633974483

Proc33.

Пример использования функции RadToDeg(R):

def RadToDeg(R):
    return R * 180 / 3.14

angle_radians = 1.57
angle_degrees = RadToDeg(angle_radians)
print(angle_degrees)  # Выводит: 89.80891719745223

Proc34.

Пример использования функции Fact(N):

def Fact(N):
    result = 1
    for i in range(1, N+1):
        result *= i
    return result

number = 5
factorial = Fact(number)
print(factorial)  # Выводит: 120
В данном примере вычисляется факториал числа 5, который равен 120.

Proc35

def Fact2(N):
    result = 1
    if N % 2 == 0:  # если N четное
        for i in range(2, N+1, 2):
            result *= i
    else:  # если N нечетное
        for i in range(1, N+1, 2):
            result *= i
    return result

python

numbers = [3, 4, 5, 6, 7]
for num in numbers:
    double_factorial = Fact2(num)
    print(f"Двойной факториал числа {num} равен {double_factorial}")

Proc36

def Fib(N):
    if N <= 0:
        return None
    elif N == 1 or N == 2:
        return 1
    else:
        return Fib(N-2) + Fib(N-1)

В этой реализации, мы проверяем базовые случаи: если N меньше или равно 0, возвращаем None, а если N равно 1 или 2, возвращаем 1. В противном случае, мы рекурсивно вызываем функцию Fib для \(N-2\) и \(N-1\) и складываем их значения.

Теперь, чтобы найти пять чисел Фибоначчи с данными номерами \(N_1, N_2, \ldots, N_5\), мы можем вызвать функцию Fib для каждого из этих номеров и сохранить результаты в переменные:

N1 = 10
N2 = 15
N3 = 20
N4 = 25
N5 = 30

fib1 = Fib(N1)
fib2 = Fib(N2)
fib3 = Fib(N3)
fib4 = Fib(N4)
fib5 = Fib(N5)

print(fib1, fib2, fib3, fib4, fib5)

В этом примере, мы вызываем функцию Fib для каждого из номеров \(N_1, N_2, \ldots, N_5\) и сохраняем результаты в переменные fib1, fib2, fib3, fib4, fib5. Затем мы выводим эти результаты на экран.

Обратите внимание, что вычисление чисел Фибоначчи с большими номерами может занять значительное время, так как рекурсивный подход имеет экспоненциальную сложность. Для более эффективного вычисления чисел Фибоначчи с большими номерами, можно использовать итеративный подход или сохранять промежуточные значения в массиве для повторного использования.

Proc37

import math

def Powerl(A, B):
    if A <= 0:
        return 0
    else:
        return math.exp(B * math.log(A))

# Пример использования функции
A = 2
B = 3
C = -1
P = 4

result_A = Powerl(A, P)  # Вычисляем A^P
result_B = Powerl(B, P)  # Вычисляем B^P
result_C = Powerl(C, P)  # Вычисляем C^P

print(result_A)  # Выводим результат A^P
print(result_B)  # Выводим результат B^P
print(result_C)  # Выводим результат C^P

Proc38

def Power2(A, N):
    if N == 0:
        return 1
    elif N > 0:
        result = 1
        for _ in range(N):
            result *= A
        return result
    else:
        result = 1
        for _ in range(abs(N)):
            result *= A
        return 1 / result

# Пример использования функции
A = 2
K = 3
L = -2
M = 4

result_K = Power2(A, K)  # Вычисляем A^K
result_L = Power2(A, L)  # Вычисляем A^L
result_M = Power2(A, M)  # Вычисляем A^M

print(result_K)  # Выводим результат A^K
print(result_L)  # Выводим результат A^L
print(result_M)  # Выводим результат A^M

Proc39

def Power3(A, B):
    if B % 1 == 0:
        return Power(A, round(B))
    else:
        return Powerl(A, B)

Proc40

import math

def Exp1(x, ε):
    result = 1.0
    term = 1.0
    n = 1
    while term > ε:
        result += term
        n += 1
        term = math.pow(x, n) / math.factorial(n)
    return result

x = 2.0
ε_values = [0.1, 0.01, 0.001, 0.0001, 0.00001, 0.000001]

for ε in ε_values:
    approx_exp = Exp1(x, ε)
    print(f"Приближенное значение exp({x}) при ε = {ε}: {approx_exp}")

Proc41

import math

def Sin1(x, ε):
    sum = 0
    term = 0
    n = 0
    
    while abs(term) > ε:
        n += 1
        term = (-1)**n * x**(2*n+1) / math.factorial(2*n+1)
        sum += term
    
    return sum

Теперь мы можем использовать функцию Sin1(x, ε) для нахождения приближенного значения синуса для данного x при шести разных значениях ε. Например:

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

for epsilon in epsilons:
    sin_approx = Sin1(x, epsilon)
    sin_actual = math.sin(x)
    print(f"Приближенное значение синуса для x={x} с ε={epsilon}: {sin_approx}")
    print(f"Фактическое значение синуса для x={x}: {sin_actual}")
    print(f"Разница: {abs(sin_approx - sin_actual)}\n")

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.