Proc 17

def RootsCount(A, B, C):
    D = B**2 - 4*A*C
    if D > 0:
        return 2
    elif D == 0:
        return 1
    else:
        return 0

В этой функции мы сначала вычисляем дискриминант D согласно формуле D = B**2 - 4*A*C. Затем мы проверяем значение D и возвращаем соответствующее количество корней: 2, если D > 0, 1, если D == 0, и 0, если D < 0.

Чтобы найти количество корней для каждого из трех квадратных уравнений с данными коэффициентами, мы можем вызвать функцию RootsCount три раза, передавая различные значения коэффициентов A, B и C. Например:

equation1_roots = RootsCount(1, -2, 1)
equation2_roots = RootsCount(2, 5, -3)
equation3_roots = RootsCount(3, 4, 2)

print("Количество корней уравнения 1:", equation1_roots)
print("Количество корней уравнения 2:", equation2_roots)
print("Количество корней уравнения 3:", equation3_roots)

Proc18

def CircleS(R):
    pi = 3.14
    S = pi * R**2
    return S

Чтобы найти площади трех кругов с заданными радиусами, можно вызвать функцию CircleS три раза, передавая разные значения радиусов:

radius1 = 2.5
radius2 = 4.7
radius3 = 3.0

area1 = CircleS(radius1)
area2 = CircleS(radius2)
area3 = CircleS(radius3)

print("Площадь первого круга:", area1)
print("Площадь второго круга:", area2)
print("Площадь третьего круга:", area3)

Proc19

def RingS(R1, R2):
    outer_area = 3.14 * R1**2
    inner_area = 3.14 * R2**2
    ring_area = outer_area - inner_area
    return ring_area

```python
outer_radius1 = 10
inner_radius1 = 5
area1 = RingS(outer_radius1, inner_radius1)

outer_radius2 = 15
inner_radius2 = 8
area2 = RingS(outer_radius2, inner_radius2)

outer_radius3 = 20
inner_radius3 = 12
area3 = RingS(outer_radius3, inner_radius3)
`

Proc20

def TriangleP(a, h):
    b = ((a / 2) ** 2 + h ** 2) ** 0.5
    perimeter = a + 2 * b
    return perimeter

В данной функции мы сначала находим значение боковой стороны \( b \) с помощью теоремы Пифагора. Затем, используя найденное значение \( b \), мы вычисляем периметр треугольника по формуле: \( \text{периметр} = a + 2b \).

Теперь, чтобы найти периметры трех треугольников, для которых даны основания и высоты, мы можем вызвать функцию TriangleP три раза, передавая ей соответствующие значения основания \( a \) и высоты \( h \). Например:

perimeter1 = TriangleP(5, 3)
perimeter2 = TriangleP(8, 4)
perimeter3 = TriangleP(10, 6)

В результате, переменные perimeter1, perimeter2 и perimeter3 будут содержать периметры трех треугольников соответственно.

Proc21

def SumRange(A, B):
    if A > B:
        return 0
    else:
        sum = 0
        for i in range(A, B+1):
            sum += i
        return sum

Эта функция проверяет, если \( A > B \), то возвращает 0, так как сумма чисел от \( A \) до \( B \) не имеет смысла, если \( A \) больше \( B \). В противном случае, функция использует цикл для нахождения суммы всех целых чисел от \( A \) до \( B \) включительно и возвращает эту сумму.

Чтобы найти суммы чисел от \( A \) до \( B \) и от \( B \) до \( C \), можно вызвать функцию SumRange дважды:

sum1 = SumRange(A, B)
sum2 = SumRange(B, C)

Proc22

def Calc(A, B, Op):
    if Op == 1:
        result = A - B
    elif Op == 2:
        result = A * B
    elif Op == 3:
        result = A / B
    else:
        result = A + B
    return result

result1 = Calc(A, B, N1)
result2 = Calc(A, B, N2)
result3 = Calc(A, B, N3)

В этом решении мы определяем функцию Calc с параметрами A, B и Op. Внутри функции мы используем условные операторы if-elif-else для выполнения соответствующей арифметической операции в зависимости от значения Op. Результат операции сохраняется в переменной result, которая затем возвращается из функции.

Затем мы вызываем функцию Calc три раза, передавая ей значения A, B и соответствующие значения N1, N2 и N3. Результаты операций сохраняются в переменных result1, result2 и result3.

Proc23

def Quarter(x, y):
    if x > 0 and y > 0:
        return 1
    elif x < 0 and y > 0:
        return 2
    elif x < 0 and y < 0:
        return 3
    elif x > 0 and y < 0:
        return 4
    else:
        return "Точка лежит на одной из осей"

В данной функции используется условная конструкция if-elif-else для определения номера координатной четверти, в которой находится точка. Если обе координаты положительны, то точка находится в первой четверти. Если x отрицательно, а y положительно, то точка находится во второй четверти. Если обе координаты отрицательны, то точка находится в третьей четверти. Если x положительно, а y отрицательно, то точка находится в четвертой четверти. Если точка лежит на одной из осей, то возвращается соответствующее сообщение.

Пример использования функции для трех точек с ненулевыми координатами:

point1 = (2, 3)
point2 = (-4, 5)
point3 = (-1, -2)

print(Quarter(*point1)) # Вывод: 1
print(Quarter(*point2)) # Вывод: 2
print(Quarter(*point3)) # Вывод: 3
В данном примере функция Quarter вызывается для каждой из трех точек, передавая ей координаты точки в виде аргументов. Результатом вызова функции будет номер соответствующей координатной четверти для каждой точки.
`

Proc24

function Even(K: integer): boolean;
begin
  Even := (K mod 2 = 0);
end;

var
  numbers: array[1..10] of integer; // Предполагаем, что у вас есть массив из 10 целых чисел.

procedure CountEvenNumbers;
var
  i, count: integer;
begin
  count := 0;
  for i := 1 to 10 do
  begin
    if Even(numbers[i]) then
      count := count + 1;
  end;
  // Теперь переменная "count" содержит количество четных чисел в наборе.
end;

Proc25

function IsSquare(K: integer): boolean;
var
  root: integer;
begin
  if K > 0 then
  begin
    root := round(sqrt(K));
    IsSquare := (root * root = K);
  end
  else
    IsSquare := false;
end;

var
  positiveNumbers: array[1..10] of integer; // Предполагаем, что у вас есть массив из 10 целых положительных чисел.

procedure CountSquares;
var
  i, count: integer;
begin
  count := 0;
  for i := 1 to 10 do
  begin
    if IsSquare(positiveNumbers[i]) then
      count := count + 1;
  end;
  // Теперь переменная "count" содержит количество квадратов в наборе.
end;

Proc 24:

def Even(K):
    return K % 2 == 0

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

def CountEvenNumbers():
    count = 0
    for num in numbers:
        if Even(num):
            count += 1
    # Теперь переменная "count" содержит количество четных чисел в наборе.
    return count

print(CountEvenNumbers())  # Вывод: 5

Proc25

import math

def IsSquare(K):
    if K > 0:
        root = int(math.sqrt(K))
        return root * root == K
    else:
        return False

positiveNumbers = [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

def CountSquares():
    count = 0
    for num in positiveNumbers:
        if IsSquare(num):
            count += 1
    # Теперь переменная "count" содержит количество квадратов в наборе.
    return count

print(CountSquares())  # Вывод: 10

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}")